Deutsch DE
Auf GitHub ansehen

Nevalyashka Flip-Strategie

Ein direkter StockSharp-Port des MetaTrader-Experten "Nevalyashka". Die Strategie wechselt immer zwischen Long- und Short-Trades: Sie beginnt mit einer Marktverkaufsorder, wartet darauf, dass die Position durch Stop Loss oder Take Profit geschlossen wird, und eröffnet dann sofort eine Marktorder in entgegengesetzter Richtung. Schutzorders werden für jeden Einstieg mit denselben Pip-basierten Abständen wie im Originalcode neu erstellt.

Strategielogik

  1. Initialisierung
    • Erkennt den Preisschritt des Instruments und die Dezimalstellen, um eine Pip-Größe identisch mit der MQL-Version zu berechnen (3/5-Dezimal-Paare werden mit 10 multipliziert).
    • Multipliziert das börsennotierte MinVolume mit dem Parameter LotMultiplier, um die Ordergröße zu erhalten, und rundet diese bei Bedarf auf den Volumenschritt.
  2. Kursbearbeitung
    • Abonniert Auftragsbuch-Updates, um die neuesten besten Bid/Ask-Kurse zu erfassen und ahmt den RefreshRates()-Aufruf des Experten nach.
  3. Orderfluss
    • Platziert eine anfängliche Marktverkaufsorder, sobald die besten Bid/Ask-Kurse verfügbar sind.
    • Nachdem eine Position geschlossen wurde, dreht es die Seite um (Kauf nach Verkauf, Verkauf nach Kauf) und gibt eine neue Marktorder mit demselben Volumen aus.
    • Für jeden ausgeführten Einstieg platziert die Strategie separate Stop-Loss- und Take-Profit-Orders mithilfe der Pip-Distanzparameter.

Risikomanagement

  • Stop Loss: Optional. Wenn StopLossPips größer als null ist, reicht die Strategie eine schützende Stop-Order ein (SellStop für Long-Positionen, BuyStop für Short-Positionen) bei Einstieg ± StopLossPips * Pip.
  • Take Profit: Optional. Wenn TakeProfitPips größer als null ist, reicht die Strategie eine schützende Limit-Order ein (SellLimit für Long-Positionen, BuyLimit für Short-Positionen) bei Einstieg ± TakeProfitPips * Pip.
  • Beide Schutzorders werden storniert, wenn die Position flach ist, um hängende Orders vor dem nächsten Flip zu vermeiden.

Parameter

Name Beschreibung Standard
LotMultiplier Multiplikator, der auf das minimale Instrumentvolumen angewendet wird. Das Ergebnis wird auf den Börsenvolumsschritt gerundet. 1
StopLossPips Stop-Loss-Abstand in Pips. Auf 0 setzen, um den Stop zu deaktivieren. 50
TakeProfitPips Take-Profit-Abstand in Pips. Auf 0 setzen, um das Ziel zu deaktivieren. 50

Betriebshinweise

  • Der Ansatz wechselt kontinuierlich das Exposure und eignet sich daher für Mean-Reversion-Märkte, bei denen ein abgeschlossener Kurs wahrscheinlich umkehrt.
  • Funktioniert mit jedem Symbol, das Top-of-Book-Kurse bereitstellt; Pip-Berechnungen passen sich automatisch basierend auf der Kursgenauigkeit an.
  • Die Slippage-Behandlung wird an die Börse delegiert—Orders werden ohne zusätzliche Prüfungen am Markt gesendet, genau wie beim ursprünglichen Experten.
  • Die Strategie enthält keine Handelszeit-Filter, Nachrichten-Filter oder Trailing Stops. Solche Logik kann durch Erweiterung von TryOpenNextPosition oder RegisterProtectionOrders hinzugefügt werden.
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;
		}
	}
}