Русский RU
Открыть на GitHub

Стратегия Raymond Cloudy Day

Общее описание

Raymond Cloudy Day — стратегия пробойного возобновления, полностью повторяющая логику исходного эксперта "Raymond Cloudy Day for EA" на MQL5. Алгоритм получает набор опорных уровней с более старшего таймфрейма и использует их для поиска импульсных входов на рабочем таймфрейме. Перенос на StockSharp сохраняет оригинальные правила и одновременно делает каждый компонент настраиваемым через параметры стратегии.

Источники данных

  • Свечи сигналов — таймфрейм, на котором исполняются сделки. Подписка на этот поток используется для генерации входов и сопровождения позиции.
  • Свечи расчёта уровней — более старший таймфрейм, из которого вычисляются уровни Raymond. По умолчанию это дневная свеча, аналог параметра RayMondTimeframe в MQL5.

Обе подписки регистрируются автоматически в GetWorkingSecurities, поэтому необходимые серии данных запрашиваются сразу после запуска стратегии.

Вычисление уровней Raymond

Для каждой закрытой свечи старшего таймфрейма стратегия пересчитывает четыре ключевых уровня:

[ \beginTradeSS &= \frac{High + Low + Open + Close}{4} \ PivotRange &= High - Low \ 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]

Актуальные значения сохраняются в полях стратегии и выводятся в лог после каждого обновления, что позволяет отслеживать динамику уровней во времени.

Логика входа

После получения уровней стратегия анализирует каждую закрытую свечу рабочего таймфрейма:

  1. Покупка — если минимум свечи опускается ниже TPS1, а закрытие возвращается выше уровня, открывается длинная позиция. Это прямое соответствие условию EA Low[1] < TPS1 && Close[1] > TPS1, фиксирующему отскок вверх.
  2. Продажа — если свеча остаётся полностью выше TPS1, но закрывается ниже уровня, открывается короткая позиция (асимметричное правило, присутствующее в оригинале).

Перед выставлением нового ордера стратегия отменяет активные заявки и, при необходимости, закрывает позицию противоположного направления, чтобы в рынке находилась только одна сделка.

Управление риском

Raymond Cloudy Day использует симметричные защитные смещения, измеряемые в тиках:

  • Стоп-лосс — отстоит от цены входа на ProtectiveOffsetTicks ниже для лонга и выше для шорта.
  • Тейк-профит — располагается на таком же расстоянии, но в прибыльную сторону.

Смещение умножается на PriceStep инструмента для преобразования тиков в абсолютное изменение цены. Каждая завершённая свеча сигналов проверяет достижение защитных уровней и закрывает позицию при срабатывании стопа или тейка. При отсутствии позиции внутренние переменные защиты сбрасываются, исключая использование устаревших значений.

Параметры

Параметр Описание Значение по умолчанию Примечания
TradeVolume Объём ордера для каждого входа. 1 При запуске копируется в свойство Volume.
ProtectiveOffsetTicks Расстояние в тиках для стоп-лосса и тейк-профита. 500 Конвертируется в цену через PriceStep.
SignalCandleType Таймфрейм, формирующий торговые сигналы. Свеча 1 часа Можно выбрать любой тип свечей (DataType).
PivotCandleType Старший таймфрейм для расчёта уровней. Свеча 1 дня Соответствует параметру RayMondTimeframe в MQL EA.

Все параметры снабжены диапазонами оптимизации и описаниями для конструктора StockSharp.

Дополнительные замечания

  • Для корректной работы необходим заданный PriceStep. При его отсутствии стратегия пропускает вход и записывает предупреждение в лог.
  • На график выводятся свечи рабочего таймфрейма и совершённые сделки. При желании можно добавить собственную визуализацию уровней.
  • Реализация обрабатывает только закрытые свечи и не опрашивает индикаторы напрямую, что соответствует требованиям AGENTS.md.

Что сохранено из оригинального эксперта

  • Формулы уровней Raymond и коэффициенты (0.382, 0.618, 1.0).
  • Условия входа вокруг первого тейк-профита на продажу (TPS1).
  • Симметричные стоп-лосс и тейк-профит в 500 пунктов, перенесённые в тиковый формат StockSharp.

Таким образом, стратегия в StockSharp повторяет поведение исходного робота и одновременно предоставляет расширенные возможности конфигурации и журналирования для дальнейшего исследования.

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;
	}
}