Português PT
Ver no GitHub

Estratégia de Temporização EMA BeerGod

Esta estratégia replica o consultor especializado BeerGodEA do MetaTrader dentro do StockSharp. Ela negocia configurações de reversão à média em um único símbolo monitorando uma média móvel exponencial (EMA) de 60 períodos e comparando a ação do preço atual com a barra anterior. Os sinais são avaliados apenas uma vez por barra em um deslocamento configurável de minutos após a abertura da vela, imitando o EA original que aguarda alguns minutos antes de agir.

Quando o preço se afasta temporariamente da EMA enquanto a média está tendendo na direção oposta, a estratégia abre uma posição a mercado esperando que o movimento reverta. As posições existentes na direção oposta são invertidas imediatamente ajustando o tamanho da ordem para que os vendidos sejam cobertos antes de estabelecer uma nova posição comprada (e vice-versa).

Como Funciona

  1. Subscrever velas de período (padrão 5 minutos) e construir uma EMA de 60 períodos sobre os preços de fechamento.
  2. Rastrear a vela atual em tempo real. No primeiro tick de cada nova barra, armazenar o valor EMA anterior e o fechamento da barra anterior para que a estratégia possa compará-los depois.
  3. Uma vez transcorrido o número configurado de minutos desde a abertura (padrão 3 minutos), avaliar as seguintes condições usando o preço atual e a inclinação da EMA:
    • Configuração de compra: preço atual < EMA atual, EMA está abaixo de seu valor anterior (caindo), e preço atual < fechamento da barra anterior.
    • Configuração de venda: preço atual > EMA atual, EMA está acima de seu valor anterior (subindo), e preço atual > fechamento da barra anterior.
  4. Se ocorrer uma configuração de compra enquanto não estiver comprado, enviar uma ordem de compra a mercado dimensionada para fechar qualquer vendido aberto e estabelecer o volume comprado desejado. A mesma lógica se aplica simetricamente para configurações de venda.
  5. Após um trade ser acionado, o sinal para aquela vela é considerado processado para evitar entradas duplicadas.

Parâmetros

  • Volume – tamanho de ordem em lotes (padrão 1). A estratégia adiciona automaticamente o valor absoluto da posição atual quando precisa inverter direções para que a nova ordem feche a exposição antiga e abra o novo trade em uma única transação.
  • EMA Length – período de lookback para a média móvel exponencial (padrão 60).
  • Trigger Minutes – número de minutos após a abertura da barra quando as condições de entrada são verificadas (padrão 3). Se a janela for perdida, a estratégia aguarda a próxima vela.
  • Candle Type – tipo de dados de vela usado para cálculos (padrão período de 5 minutos).

Notas de Trading

  • A lógica funciona em qualquer símbolo desde que dados de velas e preços de nível 1 estejam disponíveis. Ajuste a duração da vela se o instrumento negociar em sessões diferentes da configuração original do MetaTrader.
  • Apenas uma posição (comprada ou vendida) é mantida em qualquer momento. Inverter direções é feito dimensionando a nova ordem a mercado para cobrir a posição pendente e abrir o novo trade em um passo.
  • Nenhum nível explícito de stop-loss ou take-profit é definido no EA original. O gerenciamento de risco deve ser adicionado externamente se necessário.
  • A proteção de início está habilitada para que o StockSharp trate automaticamente as saídas de posição de emergência quando ocorrem intervenções manuais ou problemas de conexão.
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>
/// Mean-reversion strategy that triggers trades a few minutes after the bar opens using an EMA trend filter.
/// </summary>
public class BeerGodEmaTimingStrategy : Strategy
{
	private readonly StrategyParam<int> _emaLength;
	private readonly StrategyParam<int> _triggerMinutes;
	private readonly StrategyParam<DataType> _candleType;

	private EMA _ema = null!;
	private DateTimeOffset _currentCandleOpenTime = DateTimeOffset.MinValue;
	private decimal _currentEma;
	private decimal _previousEma;
	private decimal _currentClose;
	private decimal _previousClose;


	/// <summary>
	/// EMA length used as the directional filter.
	/// </summary>
	public int EmaLength
	{
		get => _emaLength.Value;
		set => _emaLength.Value = value;
	}

	/// <summary>
	/// Minutes from the candle open when the entry check is performed.
	/// </summary>
	public int TriggerMinutesFromOpen
	{
		get => _triggerMinutes.Value;
		set => _triggerMinutes.Value = value;
	}

	/// <summary>
	/// Candle type used for signal generation.
	/// </summary>
	public DataType CandleType
	{
		get => _candleType.Value;
		set => _candleType.Value = value;
	}

	/// <summary>
	/// Initializes a new instance of <see cref="BeerGodEmaTimingStrategy"/>.
	/// </summary>
	public BeerGodEmaTimingStrategy()
	{

		_emaLength = Param(nameof(EmaLength), 60)
			.SetGreaterThanZero()
			.SetDisplay("EMA Length", "EMA length for the trend filter", "Indicator")
			
			.SetOptimize(20, 120, 10);

		_triggerMinutes = Param(nameof(TriggerMinutesFromOpen), 3)
			.SetNotNegative()
			.SetDisplay("Trigger Minutes", "Minutes after open to check signals", "Timing")
			
			.SetOptimize(1, 10, 1);

		_candleType = Param(nameof(CandleType), TimeSpan.FromHours(4).TimeFrame())
			.SetDisplay("Candle Type", "Primary candle type", "General");
	}

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

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

		_currentCandleOpenTime = DateTimeOffset.MinValue;
		_currentEma = 0m;
		_previousEma = 0m;
		_currentClose = 0m;
		_previousClose = 0m;
	}

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

		_ema = new EMA
		{
			Length = EmaLength
		};

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

		// no fixed protection needed
	}

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

		_previousEma = _currentEma;
		_previousClose = _currentClose;

		_currentEma = emaValue;
		_currentClose = candle.ClosePrice;

		if (!_ema.IsFormed || _previousEma == 0m)
			return;

		var price = candle.ClosePrice;
		var maCurrent = _currentEma;
		var maPrevious = _previousEma;
		var prevClose = _previousClose;

		var newBuy = price < maCurrent && maCurrent < maPrevious && price < prevClose;
		var newSell = price > maCurrent && maCurrent > maPrevious && price > prevClose;

		if (!newBuy && !newSell)
			return;

		if (newBuy && Position <= 0)
		{
			BuyMarket();
		}
		else if (newSell && Position >= 0)
		{
			SellMarket();
		}
	}
}