Português PT
Ver no GitHub

Estratégia de Bug X

Visão geral

A Estratégia X Bug é um sistema cruzado de média móvel convertido do consultor especialista MQL4 com o mesmo nome. Ele compara duas médias móveis simples calculadas sobre o preço médio da vela. Quando a média rápida cruza acima ou abaixo da média lenta, a estratégia abre uma posição na direção do cruzamento. A implementação reproduz os recursos originais do Expert Advisor, incluindo reversão de sinal opcional, fechamento automático de posição em sinais opostos e ordens de proteção baseadas em pip.

Lógica de negociação

  1. Assine o tipo de vela configurado (velas de um minuto por padrão) e calcule duas médias móveis simples: uma linha rápida e uma linha lenta. As médias utilizam o preço mediano e respeitam as mudanças do indicador configuradas.
  2. Detecte um cruzamento de alta quando o valor rápido atual estiver acima do valor lento, enquanto o valor rápido duas barras anteriores estiver abaixo do valor lento. Detecte um cruzamento de baixa usando a condição oposta.
  3. Opcionalmente, inverta o sinal de cruzamento quando ReverseSignals estiver habilitado para negociar na direção oposta.
  4. Quando CloseOnSignal estiver habilitado, feche imediatamente qualquer posição oposta antes de inserir uma nova no novo sinal.
  5. Insira posições longas em sinais de alta e posições curtas em sinais de baixa. A estratégia evita empilhar posições na mesma direção; ele só negocia quando a posição atual é plana ou alinhada com o sinal.

Gestão de risco

  • StopLossPips – define um stop de proteção absoluto em pips. O stop é expresso em pips inteiros; o preço fracionário (cotações de 5 ou 3 dígitos) é tratado automaticamente pela conversão do valor do pip usando a etapa de preço do título.
  • TakeProfitPips – configura a distância alvo de lucro em pips.
  • TrailingStopPips – quando UseTrailingStop está habilitado, ativa um trailing stop que começa na distância do pip configurada assim que a posição se move para lucro. A etapa final corresponde à distância final, replicando a lógica MetaTrader original.
  • Todas as ordens de proteção são gerenciadas por meio de StartProtection com saídas de mercado para manter a paridade com o especialista MQL4.

Parâmetros

Parâmetro Descrição Padrão
OrderVolume Volume base de negociação usado para entradas no mercado. 0.1
StopLossPips Distância de stop-loss medida em pips; defina como 0 para desativar. 70
TakeProfitPips Distância de take-profit medida em pips; defina como 0 para desativar. 5000
UseTrailingStop Ativa ou desativa o gerenciamento de trailing stop. true
TrailingStopPips Distância final em pips. 90
FastPeriod Período da média móvel rápida. 1
FastShift Barras para mudar a média móvel rápida antes de avaliar os sinais. 0
SlowPeriod Período da média móvel lenta. 14
SlowShift Barras para mudar a média móvel lenta antes de avaliar os sinais. 10
CloseOnSignal Feche uma posição oposta imediatamente quando um novo sinal aparecer. true
ReverseSignals Inverta a direção do sinal para negociar contra o cruzamento. false
AppliedPrice Fonte de preços de velas fornecida às médias móveis. Median
CandleType Tipo de dados Candle para geração de sinal. 1 minute período de tempo

Notas

  • A conversão do pip multiplica o passo do preço por 10 para símbolos cotados com 5 ou 3 casas decimais, correspondendo ao comportamento original do Expert Advisor.
  • Nenhuma porta Python é fornecida; apenas a estratégia C# está incluída neste diretório.
  • Paradas finais, paradas e alvos são opcionais. Defina os valores pip correspondentes como zero para desativá-los.
namespace StockSharp.Samples.Strategies;

using System;
using System.Collections.Generic;

using Ecng.Common;

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

/// <summary>
/// Moving average crossover strategy converted from the MQL4 expert "X bug".
/// Uses fast and slow SMA crossover for signal generation.
/// </summary>
public class XBugStrategy : Strategy
{
	private readonly StrategyParam<int> _fastPeriod;
	private readonly StrategyParam<int> _slowPeriod;
	private readonly StrategyParam<bool> _reverseSignals;
	private readonly StrategyParam<DataType> _candleType;

	private SimpleMovingAverage _slowMa;
	private decimal? _prevFast;
	private decimal? _prevSlow;
	private int _cooldown;
	private int _candleCount;

	public XBugStrategy()
	{
		_fastPeriod = Param(nameof(FastPeriod), 5)
			.SetGreaterThanZero()
			.SetDisplay("Fast MA period", "Length of the fast moving average.", "Indicators");

		_slowPeriod = Param(nameof(SlowPeriod), 14)
			.SetGreaterThanZero()
			.SetDisplay("Slow MA period", "Length of the slow moving average.", "Indicators");

		_reverseSignals = Param(nameof(ReverseSignals), false)
			.SetDisplay("Reverse signals", "Invert buy and sell directions.", "Trading");

		_candleType = Param(nameof(CandleType), TimeSpan.FromMinutes(5).TimeFrame())
			.SetDisplay("Candle type", "Primary timeframe used for signals.", "General");
	}

	public int FastPeriod
	{
		get => _fastPeriod.Value;
		set => _fastPeriod.Value = value;
	}

	public int SlowPeriod
	{
		get => _slowPeriod.Value;
		set => _slowPeriod.Value = value;
	}

	public bool ReverseSignals
	{
		get => _reverseSignals.Value;
		set => _reverseSignals.Value = value;
	}

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

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

	protected override void OnReseted()
	{
		base.OnReseted();
		_slowMa = default;
		_prevFast = null;
		_prevSlow = null;
		_cooldown = 0;
		_candleCount = 0;
	}

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

		Volume = 0.001m;
		_prevFast = null;
		_prevSlow = null;
		_cooldown = 0;
		_candleCount = 0;

		_slowMa = new SimpleMovingAverage { Length = SlowPeriod };

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

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

		if (!_slowMa.IsFormed)
			return;

		_candleCount++;
		if (_cooldown > 0)
		{
			_cooldown--;
			return;
		}

		// Use close price as the "fast" value (period=1 effectively)
		var fastValue = candle.ClosePrice;

		if (_prevFast is null || _prevSlow is null)
		{
			_prevFast = fastValue;
			_prevSlow = slowValue;
			return;
		}

		var signal = 0;
		if (fastValue > slowValue && _prevFast.Value <= _prevSlow.Value)
			signal = 1;
		else if (fastValue < slowValue && _prevFast.Value >= _prevSlow.Value)
			signal = -1;

		_prevFast = fastValue;
		_prevSlow = slowValue;

		if (signal == 0)
			return;

		if (ReverseSignals)
			signal = -signal;

		if (signal > 0 && Position <= 0)
		{
			BuyMarket();
			_cooldown = 100;
		}
		else if (signal < 0 && Position >= 0)
		{
			SellMarket();
			_cooldown = 100;
		}
	}
}