Español ES
Ver en GitHub

Estrategia HelloSmart

Esta estrategia implementa un enfoque de trading en cuadrícula simple que abre posiciones en una sola dirección. Se coloca una nueva orden cada vez que el mercado se mueve un número configurado de ticks en contra de la última entrada. Cuando el volumen acumulado de la posición alcanza un umbral, el tamaño de la siguiente orden se multiplica. Todas las posiciones se cierran cuando la ganancia o pérdida total alcanza los límites predefinidos.

Parámetros

  • Trade Direction – elegir 1 para abrir solo posiciones largas o 2 para abrir solo posiciones cortas.
  • Step – número de ticks de precio que el mercado debe moverse antes de añadir otra posición.
  • Initial Lot – volumen base para la primera orden.
  • Threshold Volume – tamaño de posición acumulada que activa la multiplicación del lote.
  • Maximum Lot – límite superior para el volumen de cualquier orden individual.
  • Profit Target – monto de ganancia en divisa tras el cual se cierran todas las posiciones.
  • Loss Limit – monto de pérdida en divisa tras el cual se cierran todas las posiciones.
  • Lot Multiplier – factor aplicado a la siguiente orden cuando se supera el volumen umbral.
  • Candle Type – serie de velas usada para medir el movimiento de precios.
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>
/// Grid strategy that opens sequential orders in a single direction.
/// Closes all positions on reaching profit or loss limits.
/// </summary>
public class HelloSmartStrategy : Strategy
{
	public enum TradeModes
	{
		Buy,
		Sell
	}

	private readonly StrategyParam<TradeModes> _tradeMode;
	private readonly StrategyParam<decimal> _stepTicks;
	private readonly StrategyParam<decimal> _profitTarget;
	private readonly StrategyParam<decimal> _lossLimit;
	private readonly StrategyParam<DataType> _candleType;

	private decimal _lastPrice;

	public TradeModes Mode { get => _tradeMode.Value; set => _tradeMode.Value = value; }
	public decimal StepTicks { get => _stepTicks.Value; set => _stepTicks.Value = value; }
	public decimal ProfitTarget { get => _profitTarget.Value; set => _profitTarget.Value = value; }
	public decimal LossLimit { get => _lossLimit.Value; set => _lossLimit.Value = value; }
	public DataType CandleType { get => _candleType.Value; set => _candleType.Value = value; }

	public HelloSmartStrategy()
	{
		_tradeMode = Param(nameof(Mode), TradeModes.Sell)
			.SetDisplay("Trade Direction", "Buy or Sell direction", "General");
		_stepTicks = Param(nameof(StepTicks), 300m)
			.SetGreaterThanZero()
			.SetDisplay("Step", "Price movement to add position", "Risk");
		_profitTarget = Param(nameof(ProfitTarget), 60m)
			.SetDisplay("Profit Target", "Close all positions on this profit", "Risk");
		_lossLimit = Param(nameof(LossLimit), 5100m)
			.SetDisplay("Loss Limit", "Close all positions on this loss", "Risk");
		_candleType = Param(nameof(CandleType), TimeSpan.FromHours(4).TimeFrame())
			.SetDisplay("Candle Type", "Type of candles", "General");
	}

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

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

		_lastPrice = 0m;
	}

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

		_lastPrice = 0m;

		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;

		if (!IsFormedAndOnlineAndAllowTrading())
			return;

		var price = candle.ClosePrice;
		var stepPrice = StepTicks * 0.01m;

		// Check PnL limits first
		if (Position != 0 && (PnL > ProfitTarget || PnL < -LossLimit))
		{
			if (Position > 0)
				SellMarket();
			else
				BuyMarket();
			_lastPrice = price;
			return;
		}

		if (Mode == TradeModes.Buy)
		{
			var needOpen = Position <= 0 || (Position > 0 && (_lastPrice - price) >= stepPrice);
			if (needOpen)
			{
				BuyMarket();
				_lastPrice = price;
			}
		}
		else
		{
			var needOpen = Position >= 0 || (Position < 0 && (price - _lastPrice) >= stepPrice);
			if (needOpen)
			{
				SellMarket();
				_lastPrice = price;
			}
		}
	}
}