Português PT
Ver no GitHub

Estratégia de direção Nevalyashka

Visão geral

A estratégia Nevalyashka é uma porta C# do MetaTrader 4 consultor especialista original Nevalyashka.mq4. O EA inverte repetidamente sua direção de negociação: ele abre uma única ordem de mercado, espera até que a posição seja fechada por um stop-loss, take-profit ou ação manual e entra instantaneamente novamente na direção oposta com o mesmo volume. A implementação StockSharp reproduz esse comportamento enquanto expõe todas as configurações críticas como parâmetros de estratégia.

Lógica de negociação

  1. Inicialização

    • Quando a estratégia é iniciada, ela calcula o tamanho do pip a partir do PriceStep do instrumento. Para símbolos Forex de 3 e 5 dígitos, o passo é multiplicado por 10 para corresponder à definição de ponto MetaTrader.
    • StartProtection é configurado com distâncias de stop-loss e take-profit convertidas de pips em pontos de preço. Ordens de proteção são anexadas a cada posição subsequente.
    • Uma ordem de mercado inicial é enviada na direção definida por InitialDirection (padrão: short). O volume solicitado é arredondado para o lote válido mais próximo usando os valores VolumeStep, MinVolume e MaxVolume do título.

  2. Rastreamento de posição

    • OnPositionChanged captura todas as alterações na exposição líquida. Quando uma nova posição é aberta, a estratégia armazena o volume preenchido e lembra o lado comercial.
    • Assim que a posição retornar totalmente à estabilidade, a estratégia emite imediatamente uma nova ordem de mercado na direção oposta, reutilizando o tamanho do lote armazenado anteriormente.

  3. Tratamento de falhas

    • Se a corretora rejeitar o registro de uma ordem, o sinalizador de direção pendente será apagado, permitindo que o operador da plataforma tente novamente manualmente ou ajuste os parâmetros sem estado interno obsoleto.

O fluxo de trabalho resultante reflete a ideia “rechonchuda” do script original: o bot está sempre no mercado, alternando entre posições longas e curtas com saídas fixas.

Parâmetros

Nome Descrição Padrão Notas
StopLossPips Distância do batente de proteção em pips. 50 Convertido em preços por meio do cálculo do tamanho do pip; defina como 0 para desativar a parada.
TakeProfitPips Distância do take-profit protetor em pips. 50 Convertido da mesma forma que o stop loss; definido como 0 para desativar o take-profit.
Volume Tamanho do lote usado para a primeira negociação. 1 Após o primeiro preenchimento, a estratégia reutiliza o volume efetivamente executado para todas as entradas futuras.
InitialDirection Lado da ordem de mercado inicial. Sell Escolha entre Buy e Sell para corresponder ao viés inicial desejado.

Notas de implementação

  • Não são necessárias assinaturas de velas ou indicadores; a estratégia reage apenas a eventos de posição e confirmações de pedidos.
  • IsFormedAndOnlineAndAllowTrading() é consultado antes de cada entrada para garantir que o conector esteja pronto para negociação.
  • O arredondamento de volume usa MidpointRounding.AwayFromZero para que os lotes fracionários sempre cheguem a um nível negociável em vez de zero.
  • A lógica de conversão de pip depende de metadados de instrumentos em vez de suposições codificadas, o que faz com que a porta funcione em símbolos FX, CFD ou futuros com diferentes formatos de preços.

Diferenças versus a versão MQL

  • A variante StockSharp expõe a direção inicial como um parâmetro em vez de forçar o short inicial do script MT4.
  • As ordens stop-loss e take-profit são gerenciadas por meio de StartProtection, que produz ordens de proteção nativas compatíveis com qualquer conector StockSharp.
  • As rejeições de pedidos limpam o estado pendente interno para evitar o envio repetido de solicitações inválidas.

Esses ajustes mantêm o espírito do consultor original enquanto se integram perfeitamente ao StockSharp API de alto nível.

using System;

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

namespace StockSharp.Samples.Strategies;

/// <summary>
/// Nevalyashka Direction: RSI reversal with ATR stops.
/// </summary>
public class NevalyashkaDirectionStrategy : Strategy
{
	private readonly StrategyParam<DataType> _candleType;
	private readonly StrategyParam<int> _rsiLength;
	private readonly StrategyParam<int> _atrLength;

	private decimal _prevRsi;
	private decimal _entryPrice;

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

		_rsiLength = Param(nameof(RsiLength), 14)
			.SetDisplay("RSI Length", "RSI period.", "Indicators");

		_atrLength = Param(nameof(AtrLength), 14)
			.SetDisplay("ATR Length", "ATR period.", "Indicators");
	}

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

	public int RsiLength
	{
		get => _rsiLength.Value;
		set => _rsiLength.Value = value;
	}

	public int AtrLength
	{
		get => _atrLength.Value;
		set => _atrLength.Value = value;
	}

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

		_prevRsi = 0;
		_entryPrice = 0;
	}

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

		_prevRsi = 0;
		_entryPrice = 0;

		var rsi = new RelativeStrengthIndex { Length = RsiLength };
		var atr = new AverageTrueRange { Length = AtrLength };

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

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

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

		if (_prevRsi == 0 || atrVal <= 0)
		{
			_prevRsi = rsiVal;
			return;
		}

		var close = candle.ClosePrice;

		if (Position > 0)
		{
			if (close >= _entryPrice + atrVal * 2m || close <= _entryPrice - atrVal * 1.5m || rsiVal > 70)
			{
				SellMarket();
				_entryPrice = 0;
			}
		}
		else if (Position < 0)
		{
			if (close <= _entryPrice - atrVal * 2m || close >= _entryPrice + atrVal * 1.5m || rsiVal < 30)
			{
				BuyMarket();
				_entryPrice = 0;
			}
		}

		if (Position == 0)
		{
			if (rsiVal < 35 && _prevRsi >= 35)
			{
				_entryPrice = close;
				BuyMarket();
			}
			else if (rsiVal > 65 && _prevRsi <= 65)
			{
				_entryPrice = close;
				SellMarket();
			}
		}

		_prevRsi = rsiVal;
	}
}