Português PT
Ver no GitHub

Estratégia Nevalyashka Flip

Um port direto para StockSharp do especialista MetaTrader "Nevalyashka". A estratégia sempre alterna entre trades comprados e vendidos: começa com uma ordem de venda a mercado, aguarda o fechamento da posição por stop loss ou take profit, e então abre imediatamente uma ordem a mercado na direção oposta. Ordens protetoras são recriadas para cada entrada usando os mesmos offsets baseados em pips do código original.

Lógica da estratégia

  1. Inicialização
    • Detecta o passo de preço do instrumento e os decimais para derivar um tamanho de pip idêntico à versão MQL (pares de 3/5 dígitos são multiplicados por 10).
    • Multiplica o MinVolume da bolsa pelo parâmetro LotMultiplier para obter o tamanho da ordem e arredonda para o step de volume, se necessário.
  2. Tratamento de cotações
    • Assina atualizações do livro de ordens para capturar os últimos preços bid/ask, espelhando a chamada RefreshRates() do especialista.
  3. Fluxo de ordens
    • Coloca uma ordem de venda a mercado inicial assim que as melhores cotações bid/ask estão disponíveis.
    • Após o fechamento de uma posição, inverte o lado (compra após venda, venda após compra) e emite uma nova ordem a mercado com o mesmo volume.
    • Para cada entrada executada, a estratégia coloca ordens separadas de stop-loss e take-profit usando os parâmetros de distância em pips.

Gestão de risco

  • Stop Loss: Opcional. Quando StopLossPips é maior que zero, a estratégia envia uma ordem stop protetora (SellStop para posições compradas, BuyStop para posições vendidas) em entrada ± StopLossPips * pip.
  • Take Profit: Opcional. Quando TakeProfitPips é maior que zero, a estratégia envia uma ordem limite protetora (SellLimit para posições compradas, BuyLimit para posições vendidas) em entrada ± TakeProfitPips * pip.
  • Ambas as ordens protetoras são canceladas sempre que a posição está zerada para evitar ordens pendentes antes do próximo flip.

Parâmetros

Nome Descrição Padrão
LotMultiplier Multiplicador aplicado ao volume mínimo do instrumento. O resultado é arredondado para o step de volume da bolsa. 1
StopLossPips Distância de stop-loss em pips. Definir como 0 para desabilitar o stop. 50
TakeProfitPips Distância de take-profit em pips. Definir como 0 para desabilitar o alvo. 50

Notas operacionais

  • A abordagem alterna continuamente a exposição e, portanto, se adapta a mercados de reversão à média onde um movimento completado provavelmente irá reverter.
  • Funciona com qualquer símbolo que forneça cotações do topo do livro; os cálculos de pips se adaptam automaticamente com base na precisão do preço.
  • O tratamento de slippage é delegado à bolsa — as ordens são enviadas a mercado sem verificações adicionais, assim como no especialista original.
  • A estratégia não inclui filtros de horário de negociação, filtros de notícias ou trailing stops. Tal lógica pode ser adicionada estendendo TryOpenNextPosition ou RegisterProtectionOrders.
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>
/// Alternating long-short strategy that mirrors the original Nevalyashka MQL logic.
/// Opens an initial sell position and flips direction each time the position is closed.
/// </summary>
public class NevalyashkaFlipStrategy : Strategy
{
	private readonly StrategyParam<int> _stopLossPoints;
	private readonly StrategyParam<int> _takeProfitPoints;
	private readonly StrategyParam<DataType> _candleType;

	private decimal _entryPrice;
	private Sides? _currentSide;
	private Sides? _lastCompletedSide;

	/// <summary>
	/// Stop loss distance in price steps.
	/// </summary>
	public int StopLossPoints
	{
		get => _stopLossPoints.Value;
		set => _stopLossPoints.Value = value;
	}

	/// <summary>
	/// Take profit distance in price steps.
	/// </summary>
	public int TakeProfitPoints
	{
		get => _takeProfitPoints.Value;
		set => _takeProfitPoints.Value = value;
	}

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

	/// <summary>
	/// Initializes a new instance of the <see cref="NevalyashkaFlipStrategy"/> class.
	/// </summary>
	public NevalyashkaFlipStrategy()
	{
		_stopLossPoints = Param(nameof(StopLossPoints), 5)
			.SetGreaterThanZero()
			.SetDisplay("Stop Loss (pts)", "Stop loss distance in price steps", "Risk");

		_takeProfitPoints = Param(nameof(TakeProfitPoints), 5)
			.SetGreaterThanZero()
			.SetDisplay("Take Profit (pts)", "Take profit distance in price steps", "Risk");

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

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

	/// <inheritdoc />
	protected override void OnReseted()
	{
		base.OnReseted();
		_entryPrice = 0m;
		_currentSide = null;
		_lastCompletedSide = null;
	}

	/// <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;

		var step = Security?.PriceStep ?? 1m;
		var stopDistance = StopLossPoints * step;
		var takeDistance = TakeProfitPoints * step;
		var price = candle.ClosePrice;

		// Check SL/TP for current position
		if (Position != 0 && _entryPrice > 0)
		{
			var hit = false;

			if (_currentSide == Sides.Buy)
			{
				if (stopDistance > 0 && candle.LowPrice <= _entryPrice - stopDistance)
					hit = true;
				if (takeDistance > 0 && candle.HighPrice >= _entryPrice + takeDistance)
					hit = true;
			}
			else if (_currentSide == Sides.Sell)
			{
				if (stopDistance > 0 && candle.HighPrice >= _entryPrice + stopDistance)
					hit = true;
				if (takeDistance > 0 && candle.LowPrice <= _entryPrice - takeDistance)
					hit = true;
			}

			if (hit)
			{
				// Close position
				if (Position > 0)
					SellMarket();
				else if (Position < 0)
					BuyMarket();

				_lastCompletedSide = _currentSide;
				_currentSide = null;
				_entryPrice = 0m;
			}
		}

		// If flat, open next position
		if (Position == 0 && _currentSide == null)
		{
			// Alternate direction: start with sell, then flip
			var sideToOpen = _lastCompletedSide switch
			{
				Sides.Buy => Sides.Sell,
				Sides.Sell => Sides.Buy,
				_ => Sides.Sell,
			};

			if (sideToOpen == Sides.Buy)
				BuyMarket();
			else
				SellMarket();

			_currentSide = sideToOpen;
			_entryPrice = price;
		}
	}
}