Português PT
Ver no GitHub

Estratégia de Rompimento com Stop Pendente

Visão Geral

Esta estratégia recria o consultor especialista original de "breakdown" do MetaTrader. Coloca ordens de stop ao redor do intervalo do dia anterior e atualiza continuamente as ordens a cada sessão. Um motor de trailing-stop replica a lógica de trailing escalonado do script fonte, mantendo os stops ajustados uma vez que a posição começa a mover na direção lucrativa.

Como Funciona

  • Preparação diária – Quando uma vela diária fecha, a estratégia armazena o máximo e o mínimo. No início da sessão seguinte cancela as ordens restantes e envia um buy stop acima do máximo anterior e um sell stop abaixo do mínimo anterior. O parâmetro Min Distance (ticks) desloca as ordens dos níveis brutos para evitar ruído.
  • Atualização de ordens – Sempre que as ordens pendentes são executadas ou um novo dia começa, as ordens restantes são canceladas e um novo par é enviado usando os mesmos níveis do dia anterior. O comportamento espelha o especialista MQL que mantém continuamente entradas de stop em ambos os lados do mercado.
  • Controles de risco – Posições executadas inicializam alvos de stop-loss e take-profit com base em distâncias em ticks. Uma regra de trailing escalonado sobe/baixa o stop apenas depois que o preço ganha pelo menos Trailing Stop (ticks) + Trailing Step (ticks) desde a entrada, exatamente como a implementação original de trailing-stop.
  • Saídas – As posições fecham imediatamente quando o preço toca o stop ou o alvo ativo. O trailing manual fecha posições ao mercado quando o nível de trailing é violado, coincidindo com a lógica do MetaTrader que modificava stops a cada tick.

Parâmetros

Parâmetro Descrição
Working Candles Período usado para monitorar a ação do preço e gerenciar stops (padrão: velas de 15 minutos).
Stop Loss (ticks) Distância do stop protetor inicial convertida em preço absoluto usando o tamanho do tick do instrumento. Definir como zero para desabilitar.
Take Profit (ticks) Distância inicial de take-profit. Definir como zero para desabilitar.
Trailing Stop (ticks) Distância principal do trailing-stop. Definir como zero para desabilitar o trailing.
Trailing Step (ticks) Lucro adicional necessário antes que o trailing stop seja movido.
Min Distance (ticks) Offset adicionado ao máximo/mínimo do dia anterior ao colocar as ordens pendentes.
Order Volume Quantidade enviada com ambas as ordens de stop.

Notas de Uso

  • Configurar a estratégia em instrumentos que publiquem velas diárias para que o intervalo da sessão anterior possa ser obtido.
  • A lógica assume um tamanho de tick constante. Para instrumentos com incrementos de tick variáveis, ajustar os padrões adequadamente.
  • A estratégia não implementa o dimensionamento baseado em porcentagem do script MQL original; o volume é definido explicitamente através do parâmetro Order Volume.
  • Nenhuma versão Python ainda é fornecida para esta estratégia.
using System;
using System.Collections.Generic;

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

namespace StockSharp.Samples.Strategies;

/// <summary>
/// Breakout strategy using Highest/Lowest channel.
/// Enters long when price breaks above the channel high, enters short when price breaks below the channel low.
/// </summary>
public class BreakdownPendingStopStrategy : Strategy
{
	private readonly StrategyParam<DataType> _candleType;
	private readonly StrategyParam<int> _period;

	private decimal? _prevHigh;
	private decimal? _prevLow;

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

	public int Period
	{
		get => _period.Value;
		set => _period.Value = value;
	}

	public BreakdownPendingStopStrategy()
	{
		_candleType = Param(nameof(CandleType), TimeSpan.FromHours(4).TimeFrame())
			.SetDisplay("Candle Type", "Timeframe", "General");

		_period = Param(nameof(Period), 20)
			.SetGreaterThanZero()
			.SetDisplay("Period", "Channel lookback period", "Indicators");
	}

	public override IEnumerable<(Security sec, DataType dt)> GetWorkingSecurities()
	{
		return [(Security, CandleType)];
	}

	/// <inheritdoc />
	protected override void OnReseted()
	{
		base.OnReseted();
		_prevHigh = null;
		_prevLow = null;
	}

	protected override void OnStarted2(DateTime time)
	{
		base.OnStarted2(time);

		_prevHigh = null;
		_prevLow = null;

		var highest = new Highest { Length = Period };
		var lowest = new Lowest { Length = Period };

		var subscription = SubscribeCandles(CandleType);
		subscription
			.Bind(highest, lowest, ProcessCandle)
			.Start();

		var area = CreateChartArea();
		if (area != null)
		{
			DrawCandles(area, subscription);
			DrawIndicator(area, highest);
			DrawIndicator(area, lowest);
			DrawOwnTrades(area);
		}
	}

	private void ProcessCandle(ICandleMessage candle, decimal high, decimal low)
	{
		if (candle.State != CandleStates.Finished)
			return;

		if (!IsFormedAndOnlineAndAllowTrading())
		{
			_prevHigh = high;
			_prevLow = low;
			return;
		}

		if (_prevHigh == null || _prevLow == null)
		{
			_prevHigh = high;
			_prevLow = low;
			return;
		}

		var close = candle.ClosePrice;

		if (close > _prevHigh.Value && Position <= 0)
		{
			if (Position < 0)
				BuyMarket();
			BuyMarket();
		}
		else if (close < _prevLow.Value && Position >= 0)
		{
			if (Position > 0)
				SellMarket();
			SellMarket();
		}

		_prevHigh = high;
		_prevLow = low;
	}
}