Estratégia de padrão um-dois-três

using System;







using StockSharp.Algo.Indicators;



using StockSharp.Algo.Strategies;



using StockSharp.BusinessEntities;



using StockSharp.Messages;







namespace StockSharp.Samples.Strategies;







public class OneTwoThreePatternStrategy : Strategy



{



	private readonly StrategyParam<int> _channelPeriod;



	private readonly StrategyParam<DataType> _candleType;







	private decimal _prevClose; private decimal _prevMid; private bool _hasPrev;



	private int _cooldown;







	public int ChannelPeriod { get => _channelPeriod.Value; set => _channelPeriod.Value = value; }



	public DataType CandleType { get => _candleType.Value; set => _candleType.Value = value; }







	public OneTwoThreePatternStrategy()



	{



		_channelPeriod = Param(nameof(ChannelPeriod), 20).SetDisplay("Channel Period", "Pattern lookback", "Indicators");



		_candleType = Param(nameof(CandleType), TimeSpan.FromMinutes(30).TimeFrame()).SetDisplay("Candle Type", "Candle timeframe", "General");



	}







	/// <inheritdoc />



	protected override void OnReseted()



	{



		base.OnReseted();



		_prevClose = default;



		_prevMid = default;



		_hasPrev = default;



		_cooldown = default;



	}







	/// <inheritdoc />



	/// <inheritdoc />

	protected override void OnStarted2(DateTime time)



	{



		base.OnStarted2(time);



		_hasPrev = false;



		var highest = new Highest { Length = ChannelPeriod };



		var lowest = new Lowest { Length = ChannelPeriod };



		var subscription = SubscribeCandles(CandleType);



		subscription.Bind(highest, lowest, ProcessCandle).Start();



	}







	private void ProcessCandle(ICandleMessage candle, decimal highest, decimal lowest)



	{



		if (candle.State != CandleStates.Finished) return;



		if (!IsFormedAndOnlineAndAllowTrading()) return;



		var close = candle.ClosePrice;



		var mid = (highest + lowest) / 2;



		if (!_hasPrev) { _prevClose = close; _prevMid = mid; _hasPrev = true; return; }



		if (_cooldown > 0)



		{



			_cooldown--;



			_prevClose = close; _prevMid = mid;



			return;



		}







		if (_prevClose <= _prevMid && close > mid && Position <= 0)



		{



			var volume = Volume + Math.Abs(Position);



			BuyMarket(volume);



			_cooldown = 6;



		}



		else if (_prevClose >= _prevMid && close < mid && Position >= 0)



		{



			var volume = Volume + Math.Abs(Position);



			SellMarket(volume);



			_cooldown = 6;



		}



		_prevClose = close; _prevMid = mid;



	}



}

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 Highest, Lowest
from StockSharp.Algo.Strategies import Strategy

class one_two_three_pattern_strategy(Strategy):
    def __init__(self):
        super(one_two_three_pattern_strategy, self).__init__()
        self._channel_period = self.Param("ChannelPeriod", 20).SetDisplay("Channel Period", "Pattern lookback", "Indicators")
        self._candle_type = self.Param("CandleType", DataType.TimeFrame(TimeSpan.FromMinutes(30))).SetDisplay("Candle Type", "Candle timeframe", "General")
        self._prev_close = 0.0; self._prev_mid = 0.0; self._has_prev = False; self._cooldown = 0

    @property
    def channel_period(self): return self._channel_period.Value
    @property
    def candle_type(self): return self._candle_type.Value

    def OnReseted(self):
        super(one_two_three_pattern_strategy, self).OnReseted()
        self._prev_close = 0.0; self._prev_mid = 0.0; self._has_prev = False; self._cooldown = 0

    def OnStarted2(self, time):
        super(one_two_three_pattern_strategy, self).OnStarted2(time)
        self._has_prev = False; self._cooldown = 0
        highest = Highest(); highest.Length = self.channel_period
        lowest = Lowest(); lowest.Length = self.channel_period
        subscription = self.SubscribeCandles(self.candle_type)
        subscription.Bind(highest, lowest, self.process_candle).Start()

    def process_candle(self, candle, highest, lowest):
        if candle.State != CandleStates.Finished: return
        if not self.IsFormedAndOnlineAndAllowTrading(): return
        close = float(candle.ClosePrice)
        mid = (float(highest) + float(lowest)) / 2.0
        if not self._has_prev:
            self._prev_close = close; self._prev_mid = mid; self._has_prev = True; return
        if self._cooldown > 0:
            self._cooldown -= 1; self._prev_close = close; self._prev_mid = mid; return
        if self._prev_close <= self._prev_mid and close > mid and self.Position <= 0:
            volume = self.Volume + abs(self.Position)
            self.BuyMarket(volume); self._cooldown = 6
        elif self._prev_close >= self._prev_mid and close < mid and self.Position >= 0:
            volume = self.Volume + abs(self.Position)
            self.SellMarket(volume); self._cooldown = 6
        self._prev_close = close; self._prev_mid = mid

    def CreateClone(self): return one_two_three_pattern_strategy()