Deutsch DE
Auf GitHub ansehen

RPoint 250 Umkehrstrategie

Die RPoint 250 Reversal Strategy ist eine StockSharp-Portierung des MetaTrader 4-Expertenberaters e_RPoint_250. Der ursprüngliche Roboter basiert auf einem benutzerdefinierten Indikator namens RPoint, der das jüngste Swing-Hoch und Swing-Tief hervorhebt. Denn dieser Indikator ist nicht verfügbar auf StockSharp, die Konvertierung reproduziert das gleiche Verhalten mit den integrierten Indikatoren Highest und Lowest. Immer wenn ein neues Extrem das zuvor erkannte ersetzt, kehrt die Strategie die Position sofort um und stellt dieselbe wieder her Stop-Loss-, Take-Profit- und Trailing-Logik, definiert in der MQL-Version.

Handelsablauf

  1. Abonnieren Sie die durch CandleType angegebene Kerzenserie (Standard: 5-Minuten-Kerzen).
  2. Verfolgen Sie das gleitende Maximum und Minimum über die letzten ReversePoint Balken. Diese Werte stellen die emulierten RPoint-Ebenen dar.
  3. Wenn der Preis ein neues Höchsthoch erreicht, schließen Sie alle Long-Positionen und eröffnen Sie eine Short-Position mit einem Volumen von OrderVolume.
  4. Wenn der Preis ein neues Tief erreicht, schließen Sie alle Short-Positionen und eröffnen Sie eine Long-Position mit einem Volumen von OrderVolume.
  5. Erteilen Sie Schutzanordnungen mit StartProtection. Die Stop-Loss- und Take-Profit-Abstände werden in Preispunkten ausgedrückt die Parameter StopLossPoints und TakeProfitPoints.
  6. Optional können Sie die Gewinne um TrailingStopPoints verzögern. Die nachlaufende Engine misst, wie weit sich der Preis zugunsten des bewegt hat Position und schließt sie, wenn der Preis um die konfigurierte Anzahl von Punkten zurückgeht.
  7. Merken Sie sich die Kerzenzeit des letzten erfolgreichen Einstiegs, um zu vermeiden, dass innerhalb desselben Balkens mehrere Trades eröffnet werden, die mit dem übereinstimmen TimeN-Schutz vor dem MQL-Skript.

Die Strategie behält immer höchstens eine offene Position bei. Es schließt bestehende Geschäfte, bevor es in die entgegengesetzte Richtung einsteigt skaliert nie ein.

Parameter

Parameter Typ Standard Beschreibung
OrderVolume decimal 0.1 Mit jeder Marktorder gesendetes Volumen. Spiegelt die Eingabe Lots in der Version MetaTrader wider.
TakeProfitPoints decimal 15 Abstand zur Take-Profit-Order, gemessen in Preispunkten. Auf 0 setzen, um Gewinnziele zu deaktivieren.
StopLossPoints decimal 999 Abstand zum Schutzstopp, ausgedrückt in Preispunkten. Auf 0 einstellen, um ohne festen Stop zu handeln.
TrailingStopPoints decimal 0 Optionaler Nachlaufabstand in Preispunkten. Bei Null ist die nachgestellte Logik deaktiviert.
ReversePoint int 250 Anzahl der Kerzen, die bei der Suche nach dem letzten Swing-Hoch und Swing-Tief berücksichtigt werden. Größere Werte glätten das Rauschen.
CandleType DataType TimeSpan.FromMinutes(5).TimeFrame() Von der Strategie analysierte Kerzenaggregation. Ändern Sie es so, dass es dem in MetaTrader verwendeten Diagrammzeitrahmen entspricht.

Hinweise zur Implementierung

  • Highest und Lowest sind über das übergeordnete Bind API an das Kerzenabonnement gebunden, daher gibt es keine manuellen Indikatorwarteschlangen erforderlich.
  • StartProtection reproduziert die ursprünglichen Stop-Loss- und Take-Profit-Abstände in absoluten Preiseinheiten. StockSharp kümmert sich um die Auftragserteilung, sobald eine neue Position erscheint.
  • Trailing Stops werden durch die Überwachung jeder abgeschlossenen Kerze implementiert. Wenn der Preis um die konfigurierte Punktezahl abweicht Um den besten nach Eintritt erzielten Preis zu erreichen, wird die Position mit einer Marktorder geschlossen.
  • Die Klasse speichert die zuletzt ausgeführten Umkehrstufen (_executedHighLevel und _executedLowLevel), um Duplikate zu vermeiden Einträge. Dies entspricht den Variablen Reverse_High / Reverse_Low im Code MQL.
  • Das Feld _lastSignalTime spiegelt die Variable TimeN wider und blockiert mehrere Bestellungen innerhalb derselben Kerze, wodurch verhindert wird versehentliche Doppeleinreichungen auf illiquiden Märkten.

Nutzungsrichtlinien

  1. Hängen Sie die Strategie an ein Portfolio an, das das ausgewählte Instrument und den Kerzentyp unterstützt.
  2. Passen Sie OrderVolume an die Vertragsgröße und die Risikomanagementregeln Ihres Brokers an.
  3. Passen Sie ReversePoint an die Volatilität des gehandelten Vermögenswerts an. Höhere Werte führen zu weniger, aber aussagekräftigeren Umkehrungen.
  4. Stellen Sie sicher, dass StopLossPoints, TakeProfitPoints und TrailingStopPoints mit dem PriceStep des Wertpapiers kompatibel sind.
  5. Führen Sie einen Backtest in StockSharp Designer oder Backtester durch, um das Verhalten zu bestätigen, bevor Sie mit Live-Kapital handeln.
  6. Überwachen Sie die Protokollausgabe: Informationsmeldungen heben Positionsänderungen hervor und können bei der Validierung der Konvertierung helfen.

Da der RPoint-Indikator durch integrierte Komponenten angenähert wird, bestehen geringfügige Unterschiede zur MetaTrader-Ausführung möglich bei historischen Daten mit Lücken oder unterschiedlichen Rundungsregeln. Validieren Sie die Ergebnisse immer mit Ihren eigenen Marktdaten-Feeds bevor man sich auf die Strategie in der Produktion verlässt.

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>
/// Reverse-point breakout strategy converted from the MetaTrader 4 expert e_RPoint_250.
/// </summary>
public class RPoint250Strategy : Strategy
{
	private readonly StrategyParam<decimal> _orderVolume;
	private readonly StrategyParam<decimal> _takeProfitPoints;
	private readonly StrategyParam<decimal> _stopLossPoints;
	private readonly StrategyParam<decimal> _trailingStopPoints;
	private readonly StrategyParam<int> _reversePoint;
	private readonly StrategyParam<DataType> _candleType;

	private Highest _highest;
	private Lowest _lowest;

	private decimal _lastHighLevel;
	private decimal _lastLowLevel;
	private decimal _executedHighLevel;
	private decimal _executedLowLevel;
	private DateTimeOffset? _lastSignalTime;
	private decimal _priceStep;
	private decimal _trailingDistance;
	private decimal? _bestLongPrice;
	private decimal? _bestShortPrice;

	public RPoint250Strategy()
	{
		_orderVolume = Param(nameof(OrderVolume), 1m)
			.SetDisplay("Order Volume", "Base volume for market entries.", "Trading")
			;

		_takeProfitPoints = Param(nameof(TakeProfitPoints), 500m)
			.SetDisplay("Take Profit Points", "Take profit distance expressed in price points.", "Risk")
			;

		_stopLossPoints = Param(nameof(StopLossPoints), 999m)
			.SetDisplay("Stop Loss Points", "Stop loss distance expressed in price points.", "Risk")
			;

		_trailingStopPoints = Param(nameof(TrailingStopPoints), 0m)
			.SetDisplay("Trailing Stop Points", "Optional trailing distance in price points.", "Risk")
			;

		_reversePoint = Param(nameof(ReversePoint), 250)
			.SetDisplay("Reverse Point Length", "Number of candles scanned for the latest reversal levels.", "Signals")
			.SetGreaterThanZero()
			;

		_candleType = Param(nameof(CandleType), TimeSpan.FromHours(1).TimeFrame())
			.SetDisplay("Candle Type", "Candle aggregation used for calculations.", "General");
	}

	/// <summary>
	/// Market order volume used for both entries and reversals.
	/// </summary>
	public decimal OrderVolume
	{
		get => _orderVolume.Value;
		set => _orderVolume.Value = value;
	}

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

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

	/// <summary>
	/// Trailing-stop distance in price points.
	/// </summary>
	public decimal TrailingStopPoints
	{
		get => _trailingStopPoints.Value;
		set => _trailingStopPoints.Value = value;
	}

	/// <summary>
	/// Number of candles used to approximate the rPoint indicator.
	/// </summary>
	public int ReversePoint
	{
		get => _reversePoint.Value;
		set => _reversePoint.Value = value;
	}

	/// <summary>
	/// Candle type processed by the strategy.
	/// </summary>
	public DataType CandleType
	{
		get => _candleType.Value;
		set => _candleType.Value = value;
	}

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

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

		_highest = null;
		_lowest = null;
		_lastHighLevel = 0m;
		_lastLowLevel = 0m;
		_executedHighLevel = 0m;
		_executedLowLevel = 0m;
		_lastSignalTime = null;
		_priceStep = 0m;
		_trailingDistance = 0m;
		_bestLongPrice = null;
		_bestShortPrice = null;
	}

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

		_highest = new Highest { Length = Math.Max(1, ReversePoint) };
		_lowest = new Lowest { Length = Math.Max(1, ReversePoint) };

		_priceStep = Security?.PriceStep ?? 0m;
		if (_priceStep <= 0m)
			_priceStep = 1m;

		var takeDistance = TakeProfitPoints > 0m ? _priceStep * TakeProfitPoints : 0m;
		var stopDistance = StopLossPoints > 0m ? _priceStep * StopLossPoints : 0m;
		_trailingDistance = TrailingStopPoints > 0m ? _priceStep * TrailingStopPoints : 0m;

		// Apply the same static protection as in the original MQL script.
		var tp = takeDistance > 0m ? new Unit(takeDistance, UnitTypes.Absolute) : (Unit)null;
		var sl = stopDistance > 0m ? new Unit(stopDistance, UnitTypes.Absolute) : (Unit)null;
		if (tp != null || sl != null)
			StartProtection(tp, sl);

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

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

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

		if (!_highest.IsFormed || !_lowest.IsFormed)
			return;

		// Capture the latest swing levels as soon as they appear.
		if (highestValue == candle.HighPrice && highestValue != _lastHighLevel)
			_lastHighLevel = highestValue;

		if (lowestValue == candle.LowPrice && lowestValue != _lastLowLevel)
			_lastLowLevel = lowestValue;

		if (Position > 0)
		{
			_bestLongPrice = _bestLongPrice is null || candle.HighPrice > _bestLongPrice
				? candle.HighPrice
				: _bestLongPrice;

			if (!IsFormedAndOnlineAndAllowTrading())
				return;

			// Close the long position when price retraces by the trailing distance.
			if (_trailingDistance > 0m && _bestLongPrice is decimal bestLong && bestLong - candle.LowPrice >= _trailingDistance)
			{
				SellMarket(Position);
				_bestLongPrice = null;
				return;
			}

			// Reverse the position when a new high reversal point appears.
			if (_lastHighLevel != 0m && _lastHighLevel != _executedHighLevel)
			{
				SellMarket(Position);
				_bestLongPrice = null;
				return;
			}
		}
		else if (Position < 0)
		{
			_bestShortPrice = _bestShortPrice is null || candle.LowPrice < _bestShortPrice
				? candle.LowPrice
				: _bestShortPrice;

			if (!IsFormedAndOnlineAndAllowTrading())
				return;

			// Close the short position when price rallies by the trailing distance.
			if (_trailingDistance > 0m && _bestShortPrice is decimal bestShort && candle.HighPrice - bestShort >= _trailingDistance)
			{
				BuyMarket(-Position);
				_bestShortPrice = null;
				return;
			}

			// Reverse the position when a new low reversal point appears.
			if (_lastLowLevel != 0m && _lastLowLevel != _executedLowLevel)
			{
				BuyMarket(-Position);
				_bestShortPrice = null;
				return;
			}
		}
		else
		{
			_bestLongPrice = null;
			_bestShortPrice = null;

			if (!IsFormedAndOnlineAndAllowTrading())
				return;

			if (OrderVolume <= 0m)
				return;

			if (_lastSignalTime == candle.OpenTime)
				return;

			// Enter short when the reversal high changes.
			if (_lastHighLevel != 0m && _lastHighLevel != _executedHighLevel)
			{
				SellMarket(OrderVolume);
				_executedHighLevel = _lastHighLevel;
				_lastSignalTime = candle.OpenTime;
				_bestShortPrice = candle.ClosePrice;
				return;
			}

			// Enter long when the reversal low changes.
			if (_lastLowLevel != 0m && _lastLowLevel != _executedLowLevel)
			{
				BuyMarket(OrderVolume);
				_executedLowLevel = _lastLowLevel;
				_lastSignalTime = candle.OpenTime;
				_bestLongPrice = candle.ClosePrice;
			}
		}
	}
}