Natuseko Protrader 4H 策略

概述

Natuseko Protrader 4H 策略是 MetaTrader 4 专家顾问 NatusekoProtrader4HStrategy 的 StockSharp 版本。原始 EA 在四小时级别上同时使用指数移动平均线（EMA）、经布林带过滤的 MACD、RSI 阈值以及抛物线 SAR 来寻找强劲的突破蜡烛。本移植版保留了相同的入场、等待回调以及分批止盈管理流程。

交易逻辑

订阅由 CandleType 定义的主时间框架（默认 4 小时），仅处理收盘蜡烛。
在收盘价上计算三条 EMA：快速、慢速与趋势 EMA。
计算 MACD 主线，并对其应用简单移动平均线与布林带。布林带的中轨作为多空判断的参考。
计算收盘价 RSI 以及抛物线 SAR，二者共同决定入场与离场。
当满足以下全部条件时生成多头信号：快速 EMA 高于慢速与趋势 EMA；RSI 位于 RsiEntryLevel 与 RsiTakeProfitLong 之间；MACD 主线高于其自身的 SMA 与布林中轨；蜡烛实体大于上下影线；抛物线 SAR 位于收盘价之下。
空头信号使用完全对称的条件：EMA 顺序反转、RSI 位于 RsiTakeProfitShort 与 RsiEntryLevel 之间、MACD 位于布林中轨之下、看跌实体并且 SAR 在收盘价上方。
如果信号蜡烛距离趋势 EMA 过远（超过 DistanceThresholdPoints 点），策略会记录等待标志并观察回调。价格回落触及快速 EMA 且 RSI、SAR 仍支持原方向时再入场；空头端的逻辑相同。
满足条件时策略会平掉相反持仓并按 TradeVolume 开仓。止损优先使用抛物线 SAR（若启用 UseSarStopLoss），否则使用趋势 EMA，并将 StopOffsetPoints 换算成价格增量叠加在止损价上。
持有多头期间，每根蜡烛都会重新计算止损并执行以下管理：
- 价格跌破止损立即平仓全部多头；
- 当盈利达到 MinimumProfitPoints 点以上且未分批时，如果 RSI 高于 RsiTakeProfitLong 或 SAR 翻到价格上方，就平仓一半；
- 当盈利满足条件且 RSI 回落到 RsiEntryLevel 以下时，平掉剩余多头。
空头管理与上述规则完全镜像，只是阈值方向相反。

仓位管理

每个方向最多只进行一次分批止盈，之后等待 RSI 回到中枢或止损触发再平掉剩余头寸。
止损价格会随着最新的 SAR 或趋势 EMA 每根蜡烛更新，以贴合 MQL 的做法。
当仓位归零时，等待标志、止损引用与分批标记都会重置。

参数

名称	类型	默认值	说明
`CandleType`	`DataType`	4 小时	主时间框架。
`TradeVolume`	`decimal`	`0.1`	每次开仓数量。
`FastEmaPeriod`	`int`	`13`	快速 EMA 长度。
`SlowEmaPeriod`	`int`	`21`	慢速 EMA 长度。
`TrendEmaPeriod`	`int`	`55`	趋势 EMA 长度，同时用于止损与距离判定。
`MacdFastPeriod`	`int`	`5`	MACD 快速 EMA 长度。
`MacdSlowPeriod`	`int`	`200`	MACD 慢速 EMA 长度。
`MacdSignalPeriod`	`int`	`1`	MACD 信号线长度。
`BollingerPeriod`	`int`	`20`	计算 MACD 布林带的样本数。
`BollingerWidth`	`decimal`	`1`	MACD 布林带的标准差倍数。
`MacdSmaPeriod`	`int`	`3`	MACD 主线的平滑 SMA 长度。
`RsiPeriod`	`int`	`21`	RSI 长度。
`RsiEntryLevel`	`decimal`	`50`	RSI 中枢阈值。
`RsiTakeProfitLong`	`decimal`	`65`	多头分批止盈 RSI 阈值。
`RsiTakeProfitShort`	`decimal`	`35`	空头分批止盈 RSI 阈值。
`DistanceThresholdPoints`	`decimal`	`100`	价格相对趋势 EMA 的最大距离（点）。
`SarStep`	`decimal`	`0.02`	抛物线 SAR 加速步长。
`SarMaximum`	`decimal`	`0.2`	抛物线 SAR 最大加速度。
`UseSarStopLoss`	`bool`	`false`	是否使用 SAR 作为止损。
`UseTrendStopLoss`	`bool`	`true`	是否使用趋势 EMA 作为止损。
`StopOffsetPoints`	`int`	`0`	止损附加点数。
`UseSarTakeProfit`	`bool`	`true`	是否在 SAR 反向时分批止盈。
`UseRsiTakeProfit`	`bool`	`true`	是否在 RSI 超过阈值时分批止盈。
`MinimumProfitPoints`	`decimal`	`5`	启用止盈规则所需的最小盈利（点）。

与原 EA 的差异

StockSharp 采用净头寸模型，因此在反向开仓前会先平掉现有持仓，以模拟 MT4 单票逻辑。
止盈止损通过市价单执行，而不是修改订单属性，因为 StockSharp 不维护 MT4 式的单独订单。效果与原 EA 分批+全部平仓的逻辑一致。
距离与盈利阈值会按交易品种的 PriceStep 换算。如果标的未提供价格步长，则默认使用 1，可根据需要调整相关参数。

使用建议

根据标的合约大小调整 TradeVolume，构造函数也会同步设置 Strategy.Volume 以便辅助方法使用正确的手数。
若经常因为价格离趋势 EMA 太远而错过交易，可降低 DistanceThresholdPoints 或设为 0 关闭该过滤。
建议开启图表：策略会绘制蜡烛、三条 EMA、RSI、抛物线 SAR 以及 MACD 布林带，方便对照 MQL 行为。
MACD 参数完全复制原策略（5/200/1），该组合非常平滑但滞后，实盘前可以考虑优化。

namespace StockSharp.Samples.Strategies;

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;

public class NatusekoProtrader4HStrategy : Strategy
{
	private readonly StrategyParam<DataType> _candleType;
	private readonly StrategyParam<decimal> _tradeVolume;
	private readonly StrategyParam<int> _fastEmaPeriod;
	private readonly StrategyParam<int> _slowEmaPeriod;
	private readonly StrategyParam<int> _trendEmaPeriod;
	private readonly StrategyParam<int> _macdFastPeriod;
	private readonly StrategyParam<int> _macdSlowPeriod;
	private readonly StrategyParam<int> _macdSignalPeriod;
	private readonly StrategyParam<int> _bollingerPeriod;
	private readonly StrategyParam<decimal> _bollingerWidth;
	private readonly StrategyParam<int> _macdSmaPeriod;
	private readonly StrategyParam<int> _rsiPeriod;
	private readonly StrategyParam<decimal> _rsiEntryLevel;
	private readonly StrategyParam<decimal> _rsiTakeProfitLong;
	private readonly StrategyParam<decimal> _rsiTakeProfitShort;
	private readonly StrategyParam<decimal> _distanceThresholdPoints;
	private readonly StrategyParam<decimal> _sarStep;
	private readonly StrategyParam<decimal> _sarMaximum;
	private readonly StrategyParam<bool> _useSarStopLoss;
	private readonly StrategyParam<bool> _useTrendStopLoss;
	private readonly StrategyParam<int> _stopOffsetPoints;
	private readonly StrategyParam<bool> _useSarTakeProfit;
	private readonly StrategyParam<bool> _useRsiTakeProfit;
	private readonly StrategyParam<decimal> _minimumProfitPoints;

	private ExponentialMovingAverage _fastEma;
	private ExponentialMovingAverage _slowEma;
	private ExponentialMovingAverage _trendEma;
	private MovingAverageConvergenceDivergence _macd;
	private BollingerBands _macdBands;
	private SimpleMovingAverage _macdSma;
	private RelativeStrengthIndex _rsi;
	private ParabolicSar _parabolicSar;

	private bool _waitingForLongEntry;
	private bool _waitingForShortEntry;
	private bool _longPartialExecuted;
	private bool _shortPartialExecuted;
	private decimal? _longStopPrice;
	private decimal? _shortStopPrice;
	private decimal? _longEntryPrice;
	private decimal? _shortEntryPrice;

	public NatusekoProtrader4HStrategy()
	{
		_candleType = Param(nameof(CandleType), TimeSpan.FromMinutes(5).TimeFrame())
			.SetDisplay("Candle type", "Primary timeframe processed by the strategy.", "General");

		_tradeVolume = Param(nameof(TradeVolume), 0.1m)
			.SetGreaterThanZero()
			.SetDisplay("Trade volume", "Default order size used for entries.", "Trading");

		_fastEmaPeriod = Param(nameof(FastEmaPeriod), 13)
			.SetGreaterThanZero()
			.SetDisplay("Fast EMA period", "Length of the fast EMA filter.", "Indicator");

		_slowEmaPeriod = Param(nameof(SlowEmaPeriod), 21)
			.SetGreaterThanZero()
			.SetDisplay("Slow EMA period", "Length of the slower EMA filter.", "Indicator");

		_trendEmaPeriod = Param(nameof(TrendEmaPeriod), 55)
			.SetGreaterThanZero()
			.SetDisplay("Trend EMA period", "Length of the trend EMA used for filters and stop loss.", "Indicator");

		_macdFastPeriod = Param(nameof(MacdFastPeriod), 5)
			.SetGreaterThanZero()
			.SetDisplay("MACD fast period", "Fast EMA length inside the MACD indicator.", "Indicator");

		_macdSlowPeriod = Param(nameof(MacdSlowPeriod), 26)
			.SetGreaterThanZero()
			.SetDisplay("MACD slow period", "Slow EMA length inside the MACD indicator.", "Indicator");

		_macdSignalPeriod = Param(nameof(MacdSignalPeriod), 1)
			.SetGreaterThanZero()
			.SetDisplay("MACD signal period", "Signal moving average length for MACD.", "Indicator");

		_bollingerPeriod = Param(nameof(BollingerPeriod), 20)
			.SetGreaterThanZero()
			.SetDisplay("Bollinger period", "Number of MACD samples used for the Bollinger Bands.", "Indicator");

		_bollingerWidth = Param(nameof(BollingerWidth), 1m)
			.SetGreaterThanZero()
			.SetDisplay("Bollinger width", "Standard deviation multiplier for the MACD Bollinger Bands.", "Indicator");

		_macdSmaPeriod = Param(nameof(MacdSmaPeriod), 3)
			.SetGreaterThanZero()
			.SetDisplay("MACD SMA period", "Length of the moving average applied to the MACD line.", "Indicator");

		_rsiPeriod = Param(nameof(RsiPeriod), 21)
			.SetGreaterThanZero()
			.SetDisplay("RSI period", "Length of the RSI filter.", "Indicator");

		_rsiEntryLevel = Param(nameof(RsiEntryLevel), 50m)
			.SetDisplay("RSI neutral level", "Central RSI threshold used for both entry and exit rules.", "Trading");

		_rsiTakeProfitLong = Param(nameof(RsiTakeProfitLong), 65m)
			.SetDisplay("RSI take profit long", "RSI value that triggers a partial exit for long positions.", "Trading");

		_rsiTakeProfitShort = Param(nameof(RsiTakeProfitShort), 35m)
			.SetDisplay("RSI take profit short", "RSI value that triggers a partial exit for short positions.", "Trading");

		_distanceThresholdPoints = Param(nameof(DistanceThresholdPoints), 100m)
			.SetNotNegative()
			.SetDisplay("Distance threshold", "Maximum distance in points between price and the trend EMA before delaying the entry.", "Trading");

		_sarStep = Param(nameof(SarStep), 0.02m)
			.SetGreaterThanZero()
			.SetDisplay("SAR step", "Acceleration step of the Parabolic SAR indicator.", "Indicator");

		_sarMaximum = Param(nameof(SarMaximum), 0.2m)
			.SetGreaterThanZero()
			.SetDisplay("SAR maximum", "Maximum acceleration of the Parabolic SAR indicator.", "Indicator");

		_useSarStopLoss = Param(nameof(UseSarStopLoss), false)
			.SetDisplay("Use SAR stop loss", "Whether the Parabolic SAR defines the protective stop price.", "Risk");

		_useTrendStopLoss = Param(nameof(UseTrendStopLoss), true)
			.SetDisplay("Use trend stop loss", "Whether the trend EMA defines the protective stop price.", "Risk");

		_stopOffsetPoints = Param(nameof(StopOffsetPoints), 0)
			.SetNotNegative()
			.SetDisplay("Stop offset", "Additional point offset added to the protective stop.", "Risk");

		_useSarTakeProfit = Param(nameof(UseSarTakeProfit), true)
			.SetDisplay("Use SAR take profit", "Enable partial exits when price crosses the Parabolic SAR.", "Risk");

		_useRsiTakeProfit = Param(nameof(UseRsiTakeProfit), true)
			.SetDisplay("Use RSI take profit", "Enable partial exits driven by RSI thresholds.", "Risk");

		_minimumProfitPoints = Param(nameof(MinimumProfitPoints), 5m)
			.SetNotNegative()
			.SetDisplay("Minimum profit", "Minimum profit in points required before take-profit rules activate.", "Risk");
	}

	public DataType CandleType
	{
		get => _candleType.Value;
		set => _candleType.Value = value;
	}

	public decimal TradeVolume
	{
		get => _tradeVolume.Value;
		set => _tradeVolume.Value = value;
	}

	public int FastEmaPeriod
	{
		get => _fastEmaPeriod.Value;
		set => _fastEmaPeriod.Value = value;
	}

	public int SlowEmaPeriod
	{
		get => _slowEmaPeriod.Value;
		set => _slowEmaPeriod.Value = value;
	}

	public int TrendEmaPeriod
	{
		get => _trendEmaPeriod.Value;
		set => _trendEmaPeriod.Value = value;
	}

	public int MacdFastPeriod
	{
		get => _macdFastPeriod.Value;
		set => _macdFastPeriod.Value = value;
	}

	public int MacdSlowPeriod
	{
		get => _macdSlowPeriod.Value;
		set => _macdSlowPeriod.Value = value;
	}

	public int MacdSignalPeriod
	{
		get => _macdSignalPeriod.Value;
		set => _macdSignalPeriod.Value = value;
	}

	public int BollingerPeriod
	{
		get => _bollingerPeriod.Value;
		set => _bollingerPeriod.Value = value;
	}

	public decimal BollingerWidth
	{
		get => _bollingerWidth.Value;
		set => _bollingerWidth.Value = value;
	}

	public int MacdSmaPeriod
	{
		get => _macdSmaPeriod.Value;
		set => _macdSmaPeriod.Value = value;
	}

	public int RsiPeriod
	{
		get => _rsiPeriod.Value;
		set => _rsiPeriod.Value = value;
	}

	public decimal RsiEntryLevel
	{
		get => _rsiEntryLevel.Value;
		set => _rsiEntryLevel.Value = value;
	}

	public decimal RsiTakeProfitLong
	{
		get => _rsiTakeProfitLong.Value;
		set => _rsiTakeProfitLong.Value = value;
	}

	public decimal RsiTakeProfitShort
	{
		get => _rsiTakeProfitShort.Value;
		set => _rsiTakeProfitShort.Value = value;
	}

	public decimal DistanceThresholdPoints
	{
		get => _distanceThresholdPoints.Value;
		set => _distanceThresholdPoints.Value = value;
	}

	public decimal SarStep
	{
		get => _sarStep.Value;
		set => _sarStep.Value = value;
	}

	public decimal SarMaximum
	{
		get => _sarMaximum.Value;
		set => _sarMaximum.Value = value;
	}

	public bool UseSarStopLoss
	{
		get => _useSarStopLoss.Value;
		set => _useSarStopLoss.Value = value;
	}

	public bool UseTrendStopLoss
	{
		get => _useTrendStopLoss.Value;
		set => _useTrendStopLoss.Value = value;
	}

	public int StopOffsetPoints
	{
		get => _stopOffsetPoints.Value;
		set => _stopOffsetPoints.Value = value;
	}

	public bool UseSarTakeProfit
	{
		get => _useSarTakeProfit.Value;
		set => _useSarTakeProfit.Value = value;
	}

	public bool UseRsiTakeProfit
	{
		get => _useRsiTakeProfit.Value;
		set => _useRsiTakeProfit.Value = value;
	}

	public decimal MinimumProfitPoints
	{
		get => _minimumProfitPoints.Value;
		set => _minimumProfitPoints.Value = value;
	}

	/// <inheritdoc />
	public override IEnumerable<(Security sec, DataType dt)> GetWorkingSecurities()
		=> [(Security, CandleType)];

	/// <inheritdoc />
	protected override void OnReseted()
	{
		base.OnReseted();

		_waitingForLongEntry = false;
		_waitingForShortEntry = false;
		_longPartialExecuted = false;
		_shortPartialExecuted = false;
		_longStopPrice = null;
		_shortStopPrice = null;
		_longEntryPrice = null;
		_shortEntryPrice = null;
	}

	/// <inheritdoc />
	protected override void OnStarted2(DateTime time)
	{
		base.OnStarted2(time);

		Volume = TradeVolume;

		_fastEma = new EMA { Length = FastEmaPeriod };
		_slowEma = new EMA { Length = SlowEmaPeriod };
		_trendEma = new EMA { Length = TrendEmaPeriod };

		_macd = new MovingAverageConvergenceDivergence
		{
			ShortMa = { Length = MacdFastPeriod },
			LongMa = { Length = MacdSlowPeriod }
		};

		_macdBands = new BollingerBands
		{
			Length = BollingerPeriod,
			Width = BollingerWidth
		};

		_macdSma = new SMA { Length = MacdSmaPeriod };
		_rsi = new RelativeStrengthIndex { Length = RsiPeriod };
		_parabolicSar = new ParabolicSar
		{
			Acceleration = SarStep,
			AccelerationMax = SarMaximum
		};

		_waitingForLongEntry = false;
		_waitingForShortEntry = false;
		_longPartialExecuted = false;
		_shortPartialExecuted = false;
		_longStopPrice = null;
		_shortStopPrice = null;
		_longEntryPrice = null;
		_shortEntryPrice = null;

		var subscription = SubscribeCandles(CandleType);
		subscription
			.BindEx(new IIndicator[] { _fastEma, _slowEma, _trendEma, _rsi, _macd, _parabolicSar }, ProcessCandle)
			.Start();

		var area = CreateChartArea();
		if (area != null)
		{
			DrawCandles(area, subscription);
			DrawIndicator(area, _fastEma);
			DrawIndicator(area, _slowEma);
			DrawIndicator(area, _trendEma);
			DrawIndicator(area, _rsi);
			DrawIndicator(area, _parabolicSar);
			DrawOwnTrades(area);
		}

		var macdArea = CreateChartArea();
		if (macdArea != null)
		{
			DrawIndicator(macdArea, _macd);
			DrawIndicator(macdArea, _macdBands);
		}
	}

	private void ProcessCandle(ICandleMessage candle, IIndicatorValue[] values)
	{
		if (candle.State != CandleStates.Finished)
			return;

		var fastEmaVal = values[0];
		var slowEmaVal = values[1];
		var trendEmaVal = values[2];
		var rsiVal = values[3];
		var macdVal = values[4];
		var sarVal = values[5];

		if (fastEmaVal.IsEmpty || slowEmaVal.IsEmpty || trendEmaVal.IsEmpty ||
			rsiVal.IsEmpty || macdVal.IsEmpty || sarVal.IsEmpty)
			return;

		var fastEmaValue = fastEmaVal.ToDecimal();
		var slowEmaValue = slowEmaVal.ToDecimal();
		var trendEmaValue = trendEmaVal.ToDecimal();
		var rsiValue = rsiVal.ToDecimal();
		var macdLine = macdVal.ToDecimal();
		var sarValue = sarVal.ToDecimal();

		var macdSmaRaw = _macdSma.Process(macdLine, candle.OpenTime, true);
		if (macdSmaRaw.IsEmpty)
			return;
		var macdSmaValue = macdSmaRaw.ToDecimal();
		var macdMiddle = macdSmaValue;

		if (!_fastEma.IsFormed || !_slowEma.IsFormed || !_trendEma.IsFormed || !_macd.IsFormed || !_macdSma.IsFormed ||
				!_rsi.IsFormed || !_parabolicSar.IsFormed)
		{
			return;
		}

		if (!IsFormedAndOnlineAndAllowTrading())
			return;

		var priceStep = Security?.PriceStep ?? 0m;
		if (priceStep <= 0m)
			priceStep = 1m;
		var stopOffset = StopOffsetPoints * priceStep;

		if (Position > 0)
		{
			var updatedStop = CalculateStopPrice(true, sarValue, trendEmaValue, stopOffset);
			if (updatedStop.HasValue)
				_longStopPrice = updatedStop;
		}
		else if (Position < 0)
		{
			var updatedStop = CalculateStopPrice(false, sarValue, trendEmaValue, stopOffset);
			if (updatedStop.HasValue)
				_shortStopPrice = updatedStop;
		}

		ManageOpenPositions(candle, rsiValue, sarValue, priceStep);

		if (Position > 0)
			_waitingForLongEntry = false;
		if (Position < 0)
			_waitingForShortEntry = false;

		TryEnterLong(candle, fastEmaValue, slowEmaValue, trendEmaValue, rsiValue, macdLine, macdSmaValue, macdMiddle, sarValue, priceStep);
		TryEnterShort(candle, fastEmaValue, slowEmaValue, trendEmaValue, rsiValue, macdLine, macdSmaValue, macdMiddle, sarValue, priceStep);
	}

	private void ManageOpenPositions(ICandleMessage candle, decimal rsiValue, decimal sarValue, decimal priceStep)
	{
		var profitThreshold = MinimumProfitPoints * priceStep;

		if (Position > 0)
		{
			var volume = Math.Abs(Position);
			if (volume > 0m)
			{
				if (_longStopPrice is decimal stop && candle.LowPrice <= stop)
				{
					SellMarket(volume);
					ResetLongState();
				}
				else
				{
					var entry = _longEntryPrice ?? candle.ClosePrice;
					_longEntryPrice ??= entry;

					var profit = candle.ClosePrice - entry;

					if ((profitThreshold <= 0m || profit >= profitThreshold) && !_longPartialExecuted)
					{
						if (UseRsiTakeProfit && rsiValue >= RsiTakeProfitLong)
						{
							CloseHalfLong(volume);
						}
						else if (UseSarTakeProfit && sarValue >= candle.ClosePrice)
						{
							CloseHalfLong(volume);
						}
					}

					if ((profitThreshold <= 0m || profit >= profitThreshold) && rsiValue <= RsiEntryLevel)
					{
						SellMarket(volume);
						ResetLongState();
					}
				}
			}
		}
		else
		{
			ResetLongState();
		}

		if (Position < 0)
		{
			var volume = Math.Abs(Position);
			if (volume > 0m)
			{
				if (_shortStopPrice is decimal stop && candle.HighPrice >= stop)
				{
					BuyMarket(volume);
					ResetShortState();
				}
				else
				{
					var entry = _shortEntryPrice ?? candle.ClosePrice;
					_shortEntryPrice ??= entry;

					var profit = entry - candle.ClosePrice;

					if ((profitThreshold <= 0m || profit >= profitThreshold) && !_shortPartialExecuted)
					{
						if (UseRsiTakeProfit && rsiValue <= RsiTakeProfitShort)
						{
							CloseHalfShort(volume);
						}
						else if (UseSarTakeProfit && sarValue <= candle.ClosePrice)
						{
							CloseHalfShort(volume);
						}
					}

					if ((profitThreshold <= 0m || profit >= profitThreshold) && rsiValue >= RsiEntryLevel)
					{
						BuyMarket(volume);
						ResetShortState();
					}
				}
			}
		}
		else
		{
			ResetShortState();
		}
	}

	private void CloseHalfLong(decimal volume)
	{
		var half = volume / 2m;
		if (half <= 0m)
			return;

		SellMarket(half);
		_longPartialExecuted = true;
	}

	private void CloseHalfShort(decimal volume)
	{
		var half = volume / 2m;
		if (half <= 0m)
			return;

		BuyMarket(half);
		_shortPartialExecuted = true;
	}

	private void TryEnterLong(ICandleMessage candle, decimal fastEma, decimal slowEma, decimal trendEma, decimal rsi, decimal macdLine,
		decimal macdSma, decimal macdMiddle, decimal sar, decimal priceStep)
	{
		if (Position > 0)
			return;

		var body = Math.Abs(candle.ClosePrice - candle.OpenPrice);
		var upperShadow = Math.Abs(candle.HighPrice - candle.ClosePrice);
		var lowerShadow = Math.Abs(candle.OpenPrice - candle.LowPrice);

		var baseCondition = fastEma > slowEma && fastEma > trendEma && rsi > RsiEntryLevel &&
			macdLine > 0m;

		if (baseCondition)
		{
			var distanceLimit = DistanceThresholdPoints * priceStep;
			var distance = candle.ClosePrice - trendEma;

			if (distanceLimit > 0m && distance >= distanceLimit)
			{
				_waitingForLongEntry = true;
			}
			else
			{
				OpenLong(candle, sar, trendEma, priceStep);
			}
		}
		else if (_waitingForLongEntry && candle.LowPrice <= fastEma && rsi < RsiTakeProfitLong && sar < candle.ClosePrice)
		{
			OpenLong(candle, sar, trendEma, priceStep);
			_waitingForLongEntry = false;
		}
	}

	private void TryEnterShort(ICandleMessage candle, decimal fastEma, decimal slowEma, decimal trendEma, decimal rsi, decimal macdLine,
		decimal macdSma, decimal macdMiddle, decimal sar, decimal priceStep)
	{
		if (Position < 0)
			return;

		var body = Math.Abs(candle.ClosePrice - candle.OpenPrice);
		var upperShadow = Math.Abs(candle.HighPrice - candle.ClosePrice);
		var lowerShadow = Math.Abs(candle.OpenPrice - candle.LowPrice);

		var baseCondition = fastEma < slowEma && fastEma < trendEma && rsi < RsiEntryLevel &&
			macdLine < 0m;

		if (baseCondition)
		{
			var distanceLimit = DistanceThresholdPoints * priceStep;
			var distance = trendEma - candle.ClosePrice;

			if (distanceLimit > 0m && distance >= distanceLimit)
			{
				_waitingForShortEntry = true;
			}
			else
			{
				OpenShort(candle, sar, trendEma, priceStep);
			}
		}
		else if (_waitingForShortEntry && candle.HighPrice >= fastEma && rsi > RsiTakeProfitShort && sar > candle.ClosePrice)
		{
			OpenShort(candle, sar, trendEma, priceStep);
			_waitingForShortEntry = false;
		}
	}

	private void OpenLong(ICandleMessage candle, decimal sar, decimal trendEma, decimal priceStep)
	{
		var volume = TradeVolume;
		if (volume <= 0m)
			return;

		if (Position < 0m)
			BuyMarket(Math.Abs(Position));

		BuyMarket(volume);

		_longEntryPrice = candle.ClosePrice;
		_longPartialExecuted = false;

		_longStopPrice = CalculateStopPrice(true, sar, trendEma, StopOffsetPoints * priceStep);
	}

	private void OpenShort(ICandleMessage candle, decimal sar, decimal trendEma, decimal priceStep)
	{
		var volume = TradeVolume;
		if (volume <= 0m)
			return;

		if (Position > 0m)
			SellMarket(Math.Abs(Position));

		SellMarket(volume);

		_shortEntryPrice = candle.ClosePrice;
		_shortPartialExecuted = false;

		_shortStopPrice = CalculateStopPrice(false, sar, trendEma, StopOffsetPoints * priceStep);
	}

	private decimal? CalculateStopPrice(bool isLong, decimal sar, decimal trendEma, decimal offset)
	{
		decimal? stop = null;

		if (UseSarStopLoss)
			stop = isLong ? sar - offset : sar + offset;

		if (UseTrendStopLoss)
			stop = isLong ? trendEma - offset : trendEma + offset;

		return stop;
	}

	private void ResetLongState()
	{
		_longPartialExecuted = false;
		_longStopPrice = null;
		_longEntryPrice = null;
	}

	private void ResetShortState()
	{
		_shortPartialExecuted = false;
		_shortStopPrice = null;
		_shortEntryPrice = null;
	}
}

import clr

clr.AddReference("StockSharp.Messages")
clr.AddReference("StockSharp.Algo")
clr.AddReference("StockSharp.Algo.Indicators")
clr.AddReference("StockSharp.Algo.Strategies")

from System import TimeSpan, Math
from StockSharp.Messages import DataType, CandleStates
from StockSharp.Algo.Indicators import (ExponentialMovingAverage, MovingAverageConvergenceDivergence,
    BollingerBands, SimpleMovingAverage, RelativeStrengthIndex, ParabolicSar)
from StockSharp.Algo.Strategies import Strategy
from datatype_extensions import *
from indicator_extensions import *

class natuseko_protrader_4h_strategy(Strategy):
    def __init__(self):
        super(natuseko_protrader_4h_strategy, self).__init__()
        self._candle_type = self.Param("CandleType", tf(5)).SetDisplay("Candle type", "Primary timeframe.", "General")
        self._trade_volume = self.Param("TradeVolume", 0.1).SetGreaterThanZero().SetDisplay("Trade volume", "Default order size.", "Trading")
        self._fast_ema_period = self.Param("FastEmaPeriod", 13).SetGreaterThanZero().SetDisplay("Fast EMA period", "Fast EMA length.", "Indicator")
        self._slow_ema_period = self.Param("SlowEmaPeriod", 21).SetGreaterThanZero().SetDisplay("Slow EMA period", "Slow EMA length.", "Indicator")
        self._trend_ema_period = self.Param("TrendEmaPeriod", 55).SetGreaterThanZero().SetDisplay("Trend EMA period", "Trend EMA length.", "Indicator")
        self._macd_fast_period = self.Param("MacdFastPeriod", 5).SetGreaterThanZero().SetDisplay("MACD fast period", "MACD fast EMA.", "Indicator")
        self._macd_slow_period = self.Param("MacdSlowPeriod", 26).SetGreaterThanZero().SetDisplay("MACD slow period", "MACD slow EMA.", "Indicator")
        self._rsi_period = self.Param("RsiPeriod", 21).SetGreaterThanZero().SetDisplay("RSI period", "RSI length.", "Indicator")
        self._rsi_entry_level = self.Param("RsiEntryLevel", 50.0).SetDisplay("RSI neutral level", "Central RSI threshold.", "Trading")
        self._rsi_tp_long = self.Param("RsiTakeProfitLong", 65.0).SetDisplay("RSI TP long", "RSI partial exit long.", "Trading")
        self._rsi_tp_short = self.Param("RsiTakeProfitShort", 35.0).SetDisplay("RSI TP short", "RSI partial exit short.", "Trading")
        self._distance_threshold = self.Param("DistanceThresholdPoints", 100.0).SetNotNegative().SetDisplay("Distance threshold", "Max distance from trend EMA.", "Trading")
        self._sar_step = self.Param("SarStep", 0.02).SetGreaterThanZero().SetDisplay("SAR step", "Parabolic SAR step.", "Indicator")
        self._sar_maximum = self.Param("SarMaximum", 0.2).SetGreaterThanZero().SetDisplay("SAR maximum", "Parabolic SAR max.", "Indicator")
        self._use_sar_sl = self.Param("UseSarStopLoss", False).SetDisplay("Use SAR stop loss", "SAR defines stop.", "Risk")
        self._use_trend_sl = self.Param("UseTrendStopLoss", True).SetDisplay("Use trend stop loss", "Trend EMA defines stop.", "Risk")
        self._stop_offset = self.Param("StopOffsetPoints", 0).SetNotNegative().SetDisplay("Stop offset", "Additional stop offset.", "Risk")
        self._use_sar_tp = self.Param("UseSarTakeProfit", True).SetDisplay("Use SAR take profit", "SAR partial exits.", "Risk")
        self._use_rsi_tp = self.Param("UseRsiTakeProfit", True).SetDisplay("Use RSI take profit", "RSI partial exits.", "Risk")
        self._min_profit = self.Param("MinimumProfitPoints", 5.0).SetNotNegative().SetDisplay("Minimum profit", "Min profit for TP.", "Risk")

    @property
    def CandleType(self): return self._candle_type.Value
    @CandleType.setter
    def CandleType(self, value): self._candle_type.Value = value
    @property
    def TradeVolume(self): return self._trade_volume.Value
    @TradeVolume.setter
    def TradeVolume(self, value): self._trade_volume.Value = value

    def OnReseted(self):
        super(natuseko_protrader_4h_strategy, self).OnReseted()
        self._waiting_long = False
        self._waiting_short = False
        self._long_partial = False
        self._short_partial = False
        self._long_stop = None
        self._short_stop = None
        self._long_entry = None
        self._short_entry = None

    def OnStarted2(self, time):
        super(natuseko_protrader_4h_strategy, self).OnStarted2(time)
        self.Volume = self.TradeVolume
        self._waiting_long = False
        self._waiting_short = False
        self._long_partial = False
        self._short_partial = False
        self._long_stop = None
        self._short_stop = None
        self._long_entry = None
        self._short_entry = None

        self._fast_ema = ExponentialMovingAverage()
        self._fast_ema.Length = self._fast_ema_period.Value
        self._slow_ema = ExponentialMovingAverage()
        self._slow_ema.Length = self._slow_ema_period.Value
        self._trend_ema = ExponentialMovingAverage()
        self._trend_ema.Length = self._trend_ema_period.Value
        self._rsi = RelativeStrengthIndex()
        self._rsi.Length = self._rsi_period.Value
        self._macd = MovingAverageConvergenceDivergence()
        self._macd.ShortMa.Length = self._macd_fast_period.Value
        self._macd.LongMa.Length = self._macd_slow_period.Value
        self._parabolic_sar = ParabolicSar()
        self._parabolic_sar.Acceleration = self._sar_step.Value
        self._parabolic_sar.AccelerationMax = self._sar_maximum.Value

        sub = self.SubscribeCandles(self.CandleType)
        sub.Bind(self._fast_ema, self._slow_ema, self._trend_ema, self._rsi, self.OnProcess).Start()

        area = self.CreateChartArea()
        if area is not None:
            self.DrawCandles(area, sub)
            self.DrawIndicator(area, self._fast_ema)
            self.DrawIndicator(area, self._slow_ema)
            self.DrawIndicator(area, self._trend_ema)
            self.DrawOwnTrades(area)

    def OnProcess(self, candle, fast_val, slow_val, trend_val, rsi_val):
        if candle.State != CandleStates.Finished:
            return

        close = candle.ClosePrice
        price_step = 1.0
        if self.Security is not None and self.Security.PriceStep is not None and self.Security.PriceStep > 0:
            price_step = self.Security.PriceStep
        stop_offset = self._stop_offset.Value * price_step

        # Entry logic
        base_long = fast_val > slow_val and fast_val > trend_val and rsi_val > self._rsi_entry_level.Value
        base_short = fast_val < slow_val and fast_val < trend_val and rsi_val < self._rsi_entry_level.Value

        if self.Position == 0:
            if base_long:
                dist_limit = self._distance_threshold.Value * price_step
                if dist_limit > 0 and (close - trend_val) >= dist_limit:
                    self._waiting_long = True
                else:
                    self.BuyMarket()
                    self._long_entry = close
                    self._long_partial = False
            elif base_short:
                dist_limit = self._distance_threshold.Value * price_step
                if dist_limit > 0 and (trend_val - close) >= dist_limit:
                    self._waiting_short = True
                else:
                    self.SellMarket()
                    self._short_entry = close
                    self._short_partial = False

        # Exit logic
        if self.Position > 0:
            profit_threshold = self._min_profit.Value * price_step
            entry = self._long_entry if self._long_entry is not None else close
            profit = close - entry
            if profit_threshold <= 0 or profit >= profit_threshold:
                if self._use_rsi_tp.Value and rsi_val >= self._rsi_tp_long.Value and not self._long_partial:
                    self.SellMarket()
                    self._long_partial = True
                elif rsi_val <= self._rsi_entry_level.Value:
                    self.SellMarket()
                    self._long_entry = None
        elif self.Position < 0:
            profit_threshold = self._min_profit.Value * price_step
            entry = self._short_entry if self._short_entry is not None else close
            profit = entry - close
            if profit_threshold <= 0 or profit >= profit_threshold:
                if self._use_rsi_tp.Value and rsi_val <= self._rsi_tp_short.Value and not self._short_partial:
                    self.BuyMarket()
                    self._short_partial = True
                elif rsi_val >= self._rsi_entry_level.Value:
                    self.BuyMarket()
                    self._short_entry = None

    def CreateClone(self):
        return natuseko_protrader_4h_strategy()