Deutsch DE
Auf GitHub ansehen

Raymond Cloudy Day-Strategie

Überblick

Raymond Cloudy Day ist eine Ausbruchsverfolgungsstrategie, die die Handelslogik des ursprünglichen Expertenberaters „Raymond Cloudy Day für EA“ MQL5 rekonstruiert. Der Algorithmus leitet eine Reihe von Referenzniveaus von einer Kerze mit einem höheren Zeitrahmen ab und verwendet sie, um die Wiederaufnahme der Dynamik im Ausführungszeitrahmen zu erkennen. Der StockSharp-Port behält die ursprünglichen Handelsregeln bei und stellt jede Komponente als konfigurierbare Strategieparameter bereit.

Marktdaten

  • Signalkerzen – der Zeitrahmen, in dem Trades ausgeführt werden. Die Strategie abonniert diese Reihe für Einstiegssignale und Positionsmanagement.
  • Pivot-Kerzen – der höhere Zeitrahmen, der zur Berechnung der Raymond-Levels verwendet wird. Standardmäßig ist dies eine tägliche Kerze, die die MQL5-Eingabe RayMondTimeframe reproduziert.

Beide Abonnements werden automatisch über GetWorkingSecurities registriert, sodass die Strategie die erforderlichen Datenströme anfordert, sobald sie gestartet wird.

Raymond-Level-Berechnung

Für jede fertige Pivot-Kerze speichert die Strategie die vier Kernebenen, die durch die ursprüngliche EA definiert sind:

[ \beginTradeSS &= \frac{Hoch + Tief + Eröffnung + Schluss}{4} \ PivotRange &= Hoch - Niedrig \ ETB &= TradeSS + 0,382 \times PivotRange \ ETS &= TradeSS - 0,382 \times PivotRange \ TPB1 &= TradeSS + 0,618 \times PivotRange \ TPS1 &= TradeSS - 0,618 \times PivotRange \ TPB2 &= TradeSS + PivotRange \ TPS2 &= TradeSS – PivotRange \end]

Die StockSharp-Implementierung verwaltet den aktuellsten Snapshot dieser Werte und protokolliert jede Aktualisierung, sodass der Benutzer überwachen kann, wie sich die Werte im Laufe der Zeit entwickeln.

Eingabelogik

Sobald die Raymond-Level verfügbar sind, wertet die Strategie jede fertige Signalkerze aus:

  1. Long-Setup – Wenn das Tief der Kerze unter TPS1 fällt und der Schlusskurs über das Niveau zurückkehrt, geht die Strategie eine Long-Position ein. Dies spiegelt die EA-Bedingung Low[1] < TPS1 && Close[1] > TPS1 wider und erfasst die bullische Ablehnung des Niveaus.
  2. Short-Setup – Wenn die Kerze vollständig über TPS1 bleibt, aber darunter schließt, eröffnet die Strategie eine Short-Position (entspricht der ursprünglichen, wenn auch asymmetrischen Regel).

Vor der Platzierung einer neuen Order storniert der Algorithmus alle ausstehenden Orders und schließt gegebenenfalls die Gegenposition, sodass nur noch ein Richtungsgeschäft aktiv bleibt.

Risikomanagement

Raymond Cloudy Day verwendet symmetrische Schutzversätze, gemessen in Ticks:

  • Stop-Loss – positioniert ProtectiveOffsetTicks unter dem Long-Einstieg (oder über dem Short-Einstieg).
  • Take-Profit – positioniert ProtectiveOffsetTicks über dem Long-Einstieg (oder unter dem Short-Einstieg).

Die Offsets werden mit dem PriceStep des Instruments multipliziert, um Ticks in absolute Preisabstände umzuwandeln. Jede abgeschlossene Signalkerze löst eine Prüfung aus, die die Position schließt, wenn eines der Schutzniveaus erreicht wird. Wenn die Strategie flach ist, wird der interne Schutzstatus zurückgesetzt, um veraltete Ebenen zu vermeiden.

Parameter

Name Beschreibung Standard Notizen
TradeVolume Bestellvolumen, das für jeden Eintrag verwendet wird. 1 Beim Start mit der Eigenschaft Volume synchronisiert.
ProtectiveOffsetTicks Abstand in Ticks für Stop-Loss und Take-Profit. 500 Mit PriceStep multipliziert, um absolute Preise zu erhalten.
SignalCandleType Kerzentyp, der Handelssignale erzeugt. 1 hour Zeitrahmen Kann auf einen beliebigen DataType gesetzt werden, der Kerzen darstellt.
PivotCandleType Längerer Zeitrahmen für Raymond-Level-Berechnungen. 1 day Zeitrahmen Entspricht der RayMondTimeframe-Eingabe von MQL EA.

Alle Parameter unterstützen Optimierungsbereiche und beschreibende Metadaten für StockSharp Designer.

Zusätzliche Hinweise

  • Die Strategie erfordert, dass PriceStep durch die verbundene Sicherheit definiert wird. Fehlt es, werden Handelseinträge übersprungen und eine Warnung protokolliert.
  • Die Diagrammvisualisierung fügt die Ausführungskerzen zusammen mit den ausgeführten Trades hinzu. Bei Bedarf können zusätzliche benutzerdefinierte Zeichnungen hinzugefügt werden.
  • Die Implementierung vermeidet die direkte Abfrage von Indikatorwerten und verarbeitet nur fertige Kerzen unter Einhaltung der Projektrichtlinien in AGENTS.md.

Ursprüngliche EA-Besonderheiten erhalten

  • Formeln und Multiplikatoren auf Raymond-Ebene (0.382, 0.618, 1.0).
  • Eingabelogik basierend auf dem ersten Verkaufs-Take-Profit (TPS1).
  • Symmetrische 500-Punkte-Stop-Loss- und Take-Profit-Offsets, konvertiert in Ticks in der StockSharp-Umgebung.

Mit diesen Komponenten verhält sich die StockSharp-Strategie identisch mit der Quelle EA und bietet gleichzeitig umfangreiche Konfiguration und Protokollierung, die für weitere Forschung und Automatisierung geeignet sind.

using System;
using System.Linq;
using System.Collections.Generic;

using Ecng.Common;
using Ecng.Collections;
using Ecng.Serialization;

using StockSharp.Algo.Indicators;
using StockSharp.Algo.Strategies;
using StockSharp.BusinessEntities;
using StockSharp.Messages;

namespace StockSharp.Samples.Strategies;

/// <summary>
/// Raymond Cloudy Day strategy.
/// Computes Raymond levels from a higher timeframe and trades pullbacks around the first sell take-profit level.
/// </summary>
public class RaymondCloudyDayStrategy : Strategy
{
	private readonly StrategyParam<decimal> _tradeVolume;
	private readonly StrategyParam<int> _protectiveOffsetTicks;
	private readonly StrategyParam<DataType> _signalCandleType;
	private readonly StrategyParam<DataType> _pivotCandleType;

	private decimal? _tradeSessionLevel;
	private decimal? _extendedBuyLevel;
	private decimal? _extendedSellLevel;
	private decimal? _takeProfitBuyLevel;
	private decimal? _takeProfitSellLevel;
	private decimal? _takeProfitBuyLevel2;
	private decimal? _takeProfitSellLevel2;

	private decimal? _entryPrice;
	private decimal? _takePrice;
	private decimal? _stopPrice;

	/// <summary>
	/// Trade volume used for new positions.
	/// </summary>
	public decimal TradeVolume
	{
		get => _tradeVolume.Value;
		set => _tradeVolume.Value = value;
	}

	/// <summary>
	/// Distance in ticks used to build stop-loss and take-profit levels around the entry price.
	/// </summary>
	public int ProtectiveOffsetTicks
	{
		get => _protectiveOffsetTicks.Value;
		set => _protectiveOffsetTicks.Value = value;
	}

	/// <summary>
	/// Candle type that triggers trade signals.
	/// </summary>
	public DataType SignalCandleType
	{
		get => _signalCandleType.Value;
		set => _signalCandleType.Value = value;
	}

	/// <summary>
	/// Higher timeframe candle type used to compute Raymond levels.
	/// </summary>
	public DataType PivotCandleType
	{
		get => _pivotCandleType.Value;
		set => _pivotCandleType.Value = value;
	}

	/// <summary>
	/// Initializes strategy parameters.
	/// </summary>
	public RaymondCloudyDayStrategy()
	{
		_tradeVolume = Param(nameof(TradeVolume), 1m)
			.SetGreaterThanZero()
			.SetDisplay("Trade Volume", "Order volume used for entries", "Trading")
			
			.SetOptimize(0.1m, 5m, 0.1m);

		_protectiveOffsetTicks = Param(nameof(ProtectiveOffsetTicks), 500)
			.SetGreaterThanZero()
			.SetDisplay("Protective Offset (ticks)", "Distance in ticks for stop-loss and take-profit", "Risk Management")
			
			.SetOptimize(50, 1000, 50);

		_signalCandleType = Param(nameof(SignalCandleType), TimeSpan.FromMinutes(5).TimeFrame())
			.SetDisplay("Signal Candle Type", "Candle type used for trade signals", "Data");

		_pivotCandleType = Param(nameof(PivotCandleType), TimeSpan.FromMinutes(5).TimeFrame())
			.SetDisplay("Pivot Candle Type", "Higher timeframe used to compute Raymond levels", "Data");
	}

	/// <inheritdoc />
	public override IEnumerable<(Security sec, DataType dt)> GetWorkingSecurities()
	{
		yield return (Security, SignalCandleType);
	}

	/// <inheritdoc />
	protected override void OnReseted()
	{
		base.OnReseted();

		_tradeSessionLevel = null;
		_extendedBuyLevel = null;
		_extendedSellLevel = null;
		_takeProfitBuyLevel = null;
		_takeProfitSellLevel = null;
		_takeProfitBuyLevel2 = null;
		_takeProfitSellLevel2 = null;

		ResetProtection();
	}

	/// <inheritdoc />
	protected override void OnStarted2(DateTime time)
	{
		base.OnStarted2(time);

		Volume = TradeVolume;

		var signalSubscription = SubscribeCandles(SignalCandleType);
		signalSubscription
			.Bind(ProcessBothCandle)
			.Start();

		var priceArea = CreateChartArea();
		if (priceArea != null)
		{
			DrawCandles(priceArea, signalSubscription);
			DrawOwnTrades(priceArea);
		}
	}

	private void ProcessBothCandle(ICandleMessage candle)
	{
		if (candle.State != CandleStates.Finished)
			return;
		ProcessPivotCandle(candle);
		ProcessSignalCandle(candle);
	}

	private void ProcessPivotCandle(ICandleMessage candle)
	{
		// Skip unfinished candles to keep the level calculation consistent.
		if (candle.State != CandleStates.Finished)
			return;

		var high = candle.HighPrice;
		var low = candle.LowPrice;
		var open = candle.OpenPrice;
		var close = candle.ClosePrice;

		var tradeSession = (high + low + open + close) / 4m;
		var pivotRange = high - low;

		_tradeSessionLevel = tradeSession;
		_extendedBuyLevel = tradeSession + 0.382m * pivotRange;
		_extendedSellLevel = tradeSession - 0.382m * pivotRange;
		_takeProfitBuyLevel = tradeSession + 0.618m * pivotRange;
		_takeProfitSellLevel = tradeSession - 0.618m * pivotRange;
		_takeProfitBuyLevel2 = tradeSession + pivotRange;
		_takeProfitSellLevel2 = tradeSession - pivotRange;

		LogInfo($"Updated Raymond levels from {candle.OpenTime:u}. TradeSS={tradeSession}, ETB={_extendedBuyLevel}, ETS={_extendedSellLevel}, TPB1={_takeProfitBuyLevel}, TPS1={_takeProfitSellLevel}.");
	}

	private void ProcessSignalCandle(ICandleMessage candle)
	{
		// Manage exits first so protective logic reacts even when trading is disabled.
		if (candle.State != CandleStates.Finished)
			return;

		ManageOpenPosition(candle);

		//if (!IsFormedAndOnlineAndAllowTrading())
		//	return;

		if (_takeProfitSellLevel is not decimal triggerLevel)
			return;

		var low = candle.LowPrice;
		var close = candle.ClosePrice;

		// Replicate the original EA condition around the TPS1 level.
		if (Position <= 0 && low < triggerLevel && close > triggerLevel)
		{
			EnterLong(close);
		}
		else if (Position >= 0 && low > triggerLevel && close < triggerLevel)
		{
			EnterShort(close);
		}
	}

	private void EnterLong(decimal closePrice)
	{
		var priceStep = Security?.PriceStep ?? 1m;
		if (priceStep <= 0m)
			priceStep = 1m;

		CancelActiveOrders();

		var volume = TradeVolume + Math.Max(0m, -Position);
		BuyMarket(volume);

		var offset = priceStep * ProtectiveOffsetTicks;
		_entryPrice = closePrice;
		_takePrice = closePrice + offset;
		_stopPrice = closePrice - offset;

		LogInfo($"Opened long position at {closePrice}. TP={_takePrice}, SL={_stopPrice}.");
	}

	private void EnterShort(decimal closePrice)
	{
		var priceStep = Security?.PriceStep ?? 1m;
		if (priceStep <= 0m)
			priceStep = 1m;

		CancelActiveOrders();

		var volume = TradeVolume + Math.Max(0m, Position);
		SellMarket(volume);

		var offset = priceStep * ProtectiveOffsetTicks;
		_entryPrice = closePrice;
		_takePrice = closePrice - offset;
		_stopPrice = closePrice + offset;

		LogInfo($"Opened short position at {closePrice}. TP={_takePrice}, SL={_stopPrice}.");
	}

	private void ManageOpenPosition(ICandleMessage candle)
	{
		if (Position == 0)
		{
			ResetProtection();
			return;
		}

		if (_entryPrice is not decimal entry || _takePrice is not decimal take || _stopPrice is not decimal stop)
			return;

		if (Position > 0)
		{
			// Close the long position if price breaches the protective levels.
			if (candle.LowPrice <= stop)
			{
				SellMarket(Position);
				ResetProtection();
				LogInfo($"Long stop-loss triggered at {stop}.");
				return;
			}

			if (candle.HighPrice >= take)
			{
				SellMarket(Position);
				ResetProtection();
				LogInfo($"Long take-profit triggered at {take}.");
				return;
			}
		}
		else
		{
			var volume = Math.Abs(Position);

			// Close the short position when stop or take-profit is hit.
			if (candle.HighPrice >= stop)
			{
				BuyMarket(volume);
				ResetProtection();
				LogInfo($"Short stop-loss triggered at {stop}.");
				return;
			}

			if (candle.LowPrice <= take)
			{
				BuyMarket(volume);
				ResetProtection();
				LogInfo($"Short take-profit triggered at {take}.");
			}
		}
	}

	private void ResetProtection()
	{
		_entryPrice = null;
		_takePrice = null;
		_stopPrice = null;
	}
}