Español ES
Ver en GitHub

Estrategia S7 Up Bot

Sistema de ruptura que busca máximos o mínimos casi iguales seguidos de un movimiento brusco de precio. Cuando dos mínimos consecutivos son casi iguales y el precio sube Span Price, el bot entra largo. Entra corto cuando dos máximos se alinean y el precio cae Span Price. Las posiciones están protegidas con funciones opcionales de take-profit, stop-loss, trailing stop y salida anticipada.

Detalles

  • Criterios de entrada:
    • Compra: La diferencia entre el mínimo actual y el anterior es menor que HL Divergence y el precio está Span Price por encima del mínimo.
    • Venta: La diferencia entre el máximo actual y el anterior es menor que HL Divergence y el precio está Span Price por debajo del máximo.
  • Largo/Corto: Ambos.
  • Criterios de salida:
    • Take-profit o stop-loss.
    • Trailing stop o ajuste de trailing a cero.
    • Salida anticipada si el precio cruza el máximo/mínimo anterior (Exit At Extremum) o se acerca al nivel de reversión (Exit At Reversal).
  • Stops: Take-profit y stop-loss absolutos con trailing opcional.
  • Filtros: Ninguno.

Parámetros

  • Take Profit – objetivo de ganancia en unidades de precio.
  • Stop Loss – límite de pérdida en unidades de precio, 0 para stop automático basado en extremos.
  • HL Divergence – diferencia máxima permitida entre dos máximos o mínimos consecutivos.
  • Span Price – distancia desde el extremo al precio requerida para la entrada.
  • Max Trades – número máximo de operaciones simultáneas.
  • Use Trailing Stop – habilitar el mecanismo de trailing stop.
  • Trail Stop – distancia del trailing stop.
  • Zero Trailing – mover el stop hacia el precio una vez que la posición sea rentable.
  • Step Trailing – paso mínimo para ajustar el trailing a cero.
  • Exit At Extremum – cerrar si el precio cruza el máximo/mínimo anterior.
  • Exit At Reversal – cerrar si el precio se acerca al extremo opuesto.
  • Span To Revers – distancia desde el extremo para activar la salida por reversión.
  • Candle Type – marco temporal utilizado para el análisis.
  • Order Volume – cantidad por operación.
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;

/// <summary>
/// S7 Up Bot breakout strategy.
/// Opens long after double bottom and short after double top.
/// </summary>
public class S7UpBotStrategy : Strategy
{
	private readonly StrategyParam<decimal> _takeProfit;
	private readonly StrategyParam<decimal> _stopLoss;
	private readonly StrategyParam<decimal> _hlDivergence;
	private readonly StrategyParam<decimal> _spanPrice;
	private readonly StrategyParam<DataType> _candleType;

	private decimal _prevLow;
	private decimal _prevHigh;
	private decimal _entryPrice;
	private decimal _stopPrice;
	private decimal _takeProfitPrice;
	private bool _isLong;
	private bool _inPosition;

	public decimal TakeProfit { get => _takeProfit.Value; set => _takeProfit.Value = value; }
	public decimal StopLoss { get => _stopLoss.Value; set => _stopLoss.Value = value; }
	public decimal HlDivergence { get => _hlDivergence.Value; set => _hlDivergence.Value = value; }
	public decimal SpanPrice { get => _spanPrice.Value; set => _spanPrice.Value = value; }
	public DataType CandleType { get => _candleType.Value; set => _candleType.Value = value; }

	public S7UpBotStrategy()
	{
		_takeProfit = Param(nameof(TakeProfit), 500m)
			.SetDisplay("Take Profit", "Absolute take profit", "Risk");

		_stopLoss = Param(nameof(StopLoss), 300m)
			.SetDisplay("Stop Loss", "Absolute stop loss", "Risk");

		_hlDivergence = Param(nameof(HlDivergence), 100m)
			.SetGreaterThanZero()
			.SetDisplay("HL Divergence", "Max difference between highs or lows", "General");

		_spanPrice = Param(nameof(SpanPrice), 50m)
			.SetGreaterThanZero()
			.SetDisplay("Span Price", "Distance from extreme to price", "General");

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

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

	/// <inheritdoc />
	protected override void OnReseted()
	{
		base.OnReseted();
		_prevLow = 0m;
		_prevHigh = 0m;
		_entryPrice = 0m;
		_stopPrice = 0m;
		_takeProfitPrice = 0m;
		_isLong = false;
		_inPosition = false;
	}

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

		_prevLow = 0m;
		_prevHigh = 0m;
		_inPosition = false;

		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 price = candle.ClosePrice;

		if (_inPosition)
			ManagePosition(candle, price);

		if (!_inPosition && _prevLow != 0m && _prevHigh != 0m)
			CheckEntry(candle, price);

		_prevLow = candle.LowPrice;
		_prevHigh = candle.HighPrice;
	}

	private void CheckEntry(ICandleMessage candle, decimal price)
	{
		// Double bottom: consecutive similar lows + bounce
		if (Math.Abs(candle.LowPrice - _prevLow) < HlDivergence &&
			price - candle.LowPrice > SpanPrice)
		{
			if (Position <= 0)
				BuyMarket();
			_inPosition = true;
			_isLong = true;
			_entryPrice = price;
			_stopPrice = price - StopLoss;
			_takeProfitPrice = price + TakeProfit;
		}
		// Double top: consecutive similar highs + drop
		else if (Math.Abs(candle.HighPrice - _prevHigh) < HlDivergence &&
			candle.HighPrice - price > SpanPrice)
		{
			if (Position >= 0)
				SellMarket();
			_inPosition = true;
			_isLong = false;
			_entryPrice = price;
			_stopPrice = price + StopLoss;
			_takeProfitPrice = price - TakeProfit;
		}
	}

	private void ManagePosition(ICandleMessage candle, decimal price)
	{
		if (_isLong)
		{
			if (candle.HighPrice >= _takeProfitPrice || candle.LowPrice <= _stopPrice)
			{
				SellMarket();
				_inPosition = false;
			}
		}
		else
		{
			if (candle.LowPrice <= _takeProfitPrice || candle.HighPrice >= _stopPrice)
			{
				BuyMarket();
				_inPosition = false;
			}
		}
	}
}