Español ES
Ver en GitHub

Estrategia de Fraktrak XonaX Advanced

Descripción general

Esta estrategia es una conversión en C# del asesor experto de MetaTrader 5 Fraktrak xonax.mq5. El robot original rastrea fractales de Williams y abre operaciones cuando el precio rompe el nivel fractal más reciente. La versión de StockSharp mantiene la misma idea aprovechando características de la API de alto nivel como suscripciones a velas, helpers integrados de gestión monetaria y protección automática de operaciones.

Lógica de trading

  1. Detección de fractales – el algoritmo mantiene una ventana de cinco velas. Cuando la vela del medio crea un máximo más alto (o mínimo más bajo) que sus vecinas, el precio se guarda como el último fractal superior (o inferior).
  2. Señales de ruptura – cuando una vela completada toca o supera el nivel fractal actual, la estrategia se prepara para operar:
    • Ruptura de fractal superior → abrir posición larga (o posición corta cuando el Modo Reversión está habilitado).
    • Ruptura de fractal inferior → abrir posición corta (o posición larga cuando el Modo Reversión está habilitado).
  3. Gestión de posiciones – la estrategia convertida reproduce el comportamiento de MetaTrader:
    • Cierre opcional de la posición opuesta antes de abrir una nueva.
    • Stop-loss y take-profit iniciales se establecen según las distancias configuradas en pips.
    • Un trailing stop de dos etapas mueve el nivel protector después de que el precio avanza por el Paso de Trailing especificado.
  4. Gestión monetaria – elegir entre lote fijo o porcentaje de riesgo basado en patrimonio. Cuando el modo de riesgo está activo, el algoritmo estima el volumen usando el patrimonio del portafolio, el tamaño del paso de precio y la distancia de stop configurada.

Parámetros

Parámetro Descripción
StopLossPips Distancia de stop-loss expresada en pips. Establecer en cero para deshabilitar el nivel de stop-loss.
TakeProfitPips Distancia de take-profit en pips. Cero deshabilita el objetivo.
TrailingStopPips Distancia base del trailing stop. Requiere que TrailingStepPips sea mayor que cero.
TrailingStepPips Distancia adicional que el precio debe recorrer antes de que el trailing stop avance.
ReverseMode Invertir las reglas de ruptura (vender fractales superiores, comprar fractales inferiores).
CloseOpposite Cuando es verdadero, cualquier posición opuesta se cierra antes de abrir una nueva operación.
ManagementMode Seleccionar entre gestión monetaria FixedLot o RiskPercent.
ManagementValue Valor usado por el modo de gestión monetaria activo (tamaño de lote o porcentaje).
CandleType Serie de velas usada tanto para la detección de fractales como para las decisiones de trading.

Notas de uso

  • El tamaño del pip se deriva automáticamente del paso de precio del instrumento. Los activos con tres o cinco dígitos decimales se tratan como instrumentos de pip fraccional (0.1 pip). Ajustar los parámetros pip en consecuencia.
  • La lógica del trailing stop coincide con el experto original: requiere que tanto la distancia de trailing como el paso adicional sean positivos. De lo contrario, el trailing se omite.
  • La gestión monetaria en modo de riesgo asume que el costo del paso de precio está disponible. Si no lo está, la estrategia recurre a un cálculo simplificado basado en la distancia de precio bruta.
  • Habilitar Cerrar Opuesto para emular el comportamiento del asesor experto donde una nueva ruptura cierra la operación en ejecución antes de entrar en la dirección opuesta.

Archivos

  • CS/FraktrakXonaxAdvancedStrategy.cs – implementación de la estrategia.
  • README.md – documento actual.
  • README_ru.md – descripción en ruso.
  • README_zh.md – descripción en chino.
using System;
using System.Collections.Generic;

using Ecng.Common;

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

namespace StockSharp.Samples.Strategies;

public class FraktrakXonaxAdvancedStrategy : Strategy
{
	private readonly StrategyParam<int> _fastPeriod;
	private readonly StrategyParam<int> _slowPeriod;
	private readonly StrategyParam<int> _stopLossPoints;
	private readonly StrategyParam<int> _takeProfitPoints;

	private ExponentialMovingAverage _fast;
	private ExponentialMovingAverage _slow;

	private decimal _prevFast;
	private decimal _prevSlow;
	private decimal _entryPrice;
	private int _cooldown;

	public int FastPeriod { get => _fastPeriod.Value; set => _fastPeriod.Value = value; }
	public int SlowPeriod { get => _slowPeriod.Value; set => _slowPeriod.Value = value; }
	public int StopLossPoints { get => _stopLossPoints.Value; set => _stopLossPoints.Value = value; }
	public int TakeProfitPoints { get => _takeProfitPoints.Value; set => _takeProfitPoints.Value = value; }

	public FraktrakXonaxAdvancedStrategy()
	{
		_fastPeriod = Param(nameof(FastPeriod), 14).SetGreaterThanZero().SetDisplay("Fast Period", "Fast EMA period", "Indicator");
		_slowPeriod = Param(nameof(SlowPeriod), 50).SetGreaterThanZero().SetDisplay("Slow Period", "Slow EMA period", "Indicator");
		_stopLossPoints = Param(nameof(StopLossPoints), 200).SetNotNegative().SetDisplay("Stop Loss", "Stop-loss in price steps", "Risk");
		_takeProfitPoints = Param(nameof(TakeProfitPoints), 400).SetNotNegative().SetDisplay("Take Profit", "Take-profit in price steps", "Risk");
	}

	public override IEnumerable<(Security sec, DataType dt)> GetWorkingSecurities()
	{
		yield return (Security, TimeSpan.FromMinutes(5).TimeFrame());
	}

	protected override void OnReseted()
	{
		base.OnReseted();
		_fast = null; _slow = null;
		_prevFast = 0; _prevSlow = 0; _entryPrice = 0; _cooldown = 0;
	}

	protected override void OnStarted2(DateTime time)
	{
		base.OnStarted2(time);
		_fast = new ExponentialMovingAverage { Length = FastPeriod };
		_slow = new ExponentialMovingAverage { Length = SlowPeriod };
		var subscription = SubscribeCandles(TimeSpan.FromMinutes(5).TimeFrame());
		subscription.Bind(_fast, _slow, ProcessCandle);
		subscription.Start();
	}

	private void ProcessCandle(ICandleMessage candle, decimal fastValue, decimal slowValue)
	{
		if (candle.State != CandleStates.Finished) return;
		if (!_fast.IsFormed || !_slow.IsFormed) { _prevFast = fastValue; _prevSlow = slowValue; return; }
		if (_cooldown > 0) { _cooldown--; _prevFast = fastValue; _prevSlow = slowValue; return; }

		var close = candle.ClosePrice;
		var step = Security?.PriceStep ?? 1m;

		if (Position > 0 && _entryPrice > 0)
		{
			if (StopLossPoints > 0 && close <= _entryPrice - StopLossPoints * step) { SellMarket(); _entryPrice = 0; _cooldown = 100; _prevFast = fastValue; _prevSlow = slowValue; return; }
			if (TakeProfitPoints > 0 && close >= _entryPrice + TakeProfitPoints * step) { SellMarket(); _entryPrice = 0; _cooldown = 100; _prevFast = fastValue; _prevSlow = slowValue; return; }
		}
		else if (Position < 0 && _entryPrice > 0)
		{
			if (StopLossPoints > 0 && close >= _entryPrice + StopLossPoints * step) { BuyMarket(); _entryPrice = 0; _cooldown = 100; _prevFast = fastValue; _prevSlow = slowValue; return; }
			if (TakeProfitPoints > 0 && close <= _entryPrice - TakeProfitPoints * step) { BuyMarket(); _entryPrice = 0; _cooldown = 100; _prevFast = fastValue; _prevSlow = slowValue; return; }
		}

		if (_prevFast <= _prevSlow && fastValue > slowValue && Position <= 0)
		{ if (Position < 0) BuyMarket(); BuyMarket(); _entryPrice = close; _cooldown = 100; }
		else if (_prevFast >= _prevSlow && fastValue < slowValue && Position >= 0)
		{ if (Position > 0) SellMarket(); SellMarket(); _entryPrice = close; _cooldown = 100; }

		_prevFast = fastValue; _prevSlow = slowValue;
	}
}