Português PT
Ver no GitHub

Estratégia Eugene de Rompimento Interno

A estratégia Eugene de Rompimento Interno é uma portagem direta do consultor especialista original do MetaTrader por barabashkakvn. Ela se concentra na ação do preço pura: uma sequência de velas internas seguida de um rompimento de intervalo. Os níveis de confirmação derivados do corpo da vela anterior garantem que o rompimento desenvolva momentum antes que a estratégia tome uma posição.

Visão geral

A estratégia observa por uma nova máxima ou mínima em relação à vela anterior. As configurações compradas exigem que a vela anterior tenha uma mínima abaixo da máxima da vela antes dela, destacando a compressão antes do rompimento. As configurações vendidas se recusam a operar se a vela anterior for uma barra interna, espelhando as proteções na lógica MQL fonte. As ordens são sempre executadas a mercado com um volume fixo.

Lógica de mercado

  • Enfatiza os rompimentos da máxima/mínima mais recente para captar movimentos direcionais cedo.
  • Usa o corpo da vela anterior para calcular dois níveis de retração de um terço (zigLevelBuy e zigLevelSell). O preço deve tocar esses níveis, ou a sessão deve estar além da hora de ativação configurada, antes que uma entrada seja permitida.
  • Previne novas posições quando um rompimento coincide com uma vela interna contra a direção da operação.
  • Fecha posições abertas sempre que o sinal de rompimento oposto confirmar, garantindo que a estratégia esteja sempre plana ou alinhada com o último sinal.

Regras de entrada

Comprado

  1. A máxima da vela atual é maior do que a máxima da vela anterior.
  2. A confirmação é recebida quando a mínima atual perfura a retração de um terço do corpo da vela anterior, ou a hora atual está além do parâmetro de hora de ativação.
  3. A mínima atual deve permanecer acima da mínima anterior enquanto a mínima anterior fica abaixo da máxima de duas velas atrás.
  4. Nenhuma posição existente está aberta.

Vendido

  1. A mínima da vela atual é menor do que a mínima da vela anterior.
  2. A confirmação é recebida quando a máxima atual testa a retração superior de um terço do corpo da vela anterior, ou a hora atual está além do parâmetro de hora de ativação.
  3. A vela anterior não deve ser uma barra interna.
  4. A máxima atual deve estar abaixo da máxima anterior.
  5. Nenhuma posição existente está aberta.

Regras de saída

  • Fechar posições compradas quando um rompimento vendido validado se forma (condições 1–3 da lógica de entrada vendida).
  • Fechar posições vendidas quando um rompimento comprado validado se forma (condições 1–3 da lógica de entrada comprada).

Parâmetros

Nome Descrição Padrão
CandleType Período das velas processadas pela estratégia. Velas de 1 hora
Volume Tamanho da ordem enviada com cada ordem de mercado. 0.1
ActivationHour Hora do dia após a qual as confirmações são aceitas automaticamente, replicando o filtro TimeCurrent() do código MQL. 8

Notas

  • As verificações de confirmação rotuladas "white bird" e "black bird" no script original sempre se avaliam como falsas devido às condições fonte; elas são preservadas para paridade, mas não afetam as decisões de trading.
  • Nenhum indicador adicional ou trailing stop é usado—a abordagem é puramente baseada em preço e vira posições a cada rompimento oposto.
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>
/// Breakout strategy derived from the Eugene expert advisor.
/// </summary>
public class EugeneInsideBreakoutStrategy : Strategy
{
	private readonly StrategyParam<DataType> _candleType;
	private readonly StrategyParam<int> _activationHour;

	private decimal _prevOpen1;
	private decimal _prevClose1;
	private decimal _prevHigh1;
	private decimal _prevLow1;

	private decimal _prevOpen2;
	private decimal _prevClose2;
	private decimal _prevHigh2;
	private decimal _prevLow2;

	private bool _hasPrev1;
	private bool _hasPrev2;

	/// <summary>
	/// Candle type to process.
	/// </summary>
	public DataType CandleType
	{
		get => _candleType.Value;
		set => _candleType.Value = value;
	}


	/// <summary>
	/// Hour of day after which confirmations are automatically valid.
	/// </summary>
	public int ActivationHour
	{
		get => _activationHour.Value;
		set => _activationHour.Value = value;
	}

	/// <summary>
	/// Initializes <see cref="EugeneInsideBreakoutStrategy"/>.
	/// </summary>
	public EugeneInsideBreakoutStrategy()
	{
		_candleType = Param(nameof(CandleType), TimeSpan.FromHours(1).TimeFrame())
			.SetDisplay("Candle Type", "Type of candles to process", "General");


		_activationHour = Param(nameof(ActivationHour), 8)
			.SetRange(0, 23)
			.SetDisplay("Activation Hour", "Hour when confirmations become unconditional", "Filters");

		ResetHistory();
	}

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

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

		ResetHistory();
	}

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

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

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

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

		if (!_hasPrev2)
		{
			UpdateHistory(candle);
			return;
		}

		var open1 = _prevOpen1;
		var close1 = _prevClose1;
		var open2 = _prevOpen2;
		var close2 = _prevClose2;
		var high0 = candle.HighPrice;
		var high1 = _prevHigh1;
		var high2 = _prevHigh2;
		var low0 = candle.LowPrice;
		var low1 = _prevLow1;
		var low2 = _prevLow2;

		// Replicate the original expert advisor checks for inside bars.
		var blackInsider = high1 <= high2 && low1 >= low2 && close1 <= open1;
		var whiteInsider = high1 <= high2 && low1 >= low2 && close1 > open1;
		var whiteBird = whiteInsider && close2 > open2;
		var blackBird = blackInsider && close2 < open2;

		// ZigZag style confirmation levels based on the previous candle body.
		var zigLevelBuy = close1 < open1
			? open1 - (close1 - open1) / 3m
			: open1 - (open1 - low1) / 3m;

		var zigLevelSell = close1 > open1
			? open1 + (close1 - open1) / 3m
			: open1 + (high1 - open1) / 3m;

		var confirmBuy = (low0 <= zigLevelBuy || candle.CloseTime.Hour >= ActivationHour) && !blackBird && !whiteInsider;
		var confirmSell = (high0 >= zigLevelSell || candle.CloseTime.Hour >= ActivationHour) && !whiteBird && !blackInsider;

		var buySignal = high0 > high1;
		var sellSignal = low0 < low1;

		if (Position == 0)
		{
			if (buySignal && confirmBuy && low0 > low1 && low1 < high2)
			{
				BuyMarket();
			}
			else if (sellSignal && confirmSell && high0 < high1)
			{
				SellMarket();
			}
		}
		else if (Position > 0)
		{
			if (sellSignal && confirmSell && high0 < high1)
				SellMarket();
		}
		else if (Position < 0)
		{
			if (buySignal && confirmBuy && low0 > low1 && low1 < high2)
				BuyMarket();
		}

		UpdateHistory(candle);
	}

	private void UpdateHistory(ICandleMessage candle)
	{
		// Keep the two most recent completed candles for decision making.
		_prevOpen2 = _prevOpen1;
		_prevClose2 = _prevClose1;
		_prevHigh2 = _prevHigh1;
		_prevLow2 = _prevLow1;
		_hasPrev2 = _hasPrev1;

		_prevOpen1 = candle.OpenPrice;
		_prevClose1 = candle.ClosePrice;
		_prevHigh1 = candle.HighPrice;
		_prevLow1 = candle.LowPrice;
		_hasPrev1 = true;
	}

	private void ResetHistory()
	{
		_prevOpen1 = default;
		_prevClose1 = default;
		_prevHigh1 = default;
		_prevLow1 = default;
		_prevOpen2 = default;
		_prevClose2 = default;
		_prevHigh2 = default;
		_prevLow2 = default;
		_hasPrev1 = false;
		_hasPrev2 = false;
	}
}