Português PT
Ver no GitHub

Estratégia Maximus vX Lite

Esta estratégia tenta negociar rompimentos de zonas de consolidação de curto prazo. Ela procura faixas de preço compactas no gráfico de 15 minutos e abre negociações quando o preço se afasta dessas faixas por uma distância especificada.

Lógica da estratégia

  1. Para cada candle de 15 minutos finalizado, são calculados a máxima mais alta e a mínima mais baixa dos últimos 40 candles.
  2. Se a distância entre esses extremos for inferior ao parâmetro Range, uma zona de consolidação é assumida.
  3. Após o período Delay Open passar sem novas negociações, um rompimento acima do limite superior mais Distance pontos aciona uma posição comprada, enquanto um rompimento abaixo do limite inferior menos Distance pontos aciona uma posição vendida.
  4. Um Stop Loss fixo e um trailing stop de Trail pontos são aplicados assim que uma posição é aberta.
  5. Os limites de consolidação são redefinidos após decorridas as horas de Period.

Parâmetros

  • DelayOpen – Horas de espera antes de abrir uma nova negociação.
  • Distance – Distância de rompimento a partir do limite de consolidação em pontos.
  • Period – Horas após as quais os níveis de consolidação são recalculados.
  • Range – Tamanho máximo da zona de consolidação em pontos.
  • StopLoss – Stop loss inicial em pontos.
  • Trail – Distância do trailing stop em pontos.

Notas

A estratégia usa apenas a API de alto nível: os candles são recebidos via SubscribeCandles, e os valores dos indicadores são vinculados usando Bind. As ordens são enviadas com os métodos BuyMarket e SellMarket. Os comentários no código-fonte estão escritos em inglês.

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>
/// Breakout strategy based on consolidation zones.
/// </summary>
public class MaximusVxLiteStrategy : Strategy
{
	private readonly StrategyParam<int> _lookback;
	private readonly StrategyParam<DataType> _candleType;

	private decimal _prevHigh;
	private decimal _prevLow;
	private bool _hasPrev;

	public int Lookback { get => _lookback.Value; set => _lookback.Value = value; }
	public DataType CandleType { get => _candleType.Value; set => _candleType.Value = value; }

	public MaximusVxLiteStrategy()
	{
		_lookback = Param(nameof(Lookback), 20)
			.SetDisplay("Lookback", "Highest/Lowest lookback period", "General");

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

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

	protected override void OnReseted()
	{
		base.OnReseted();
		_prevHigh = 0;
		_prevLow = 0;
		_hasPrev = false;
	}

	protected override void OnStarted2(DateTime time)
	{
		base.OnStarted2(time);

		var highest = new Highest { Length = Lookback };
		var lowest = new Lowest { Length = Lookback };

		SubscribeCandles(CandleType).Bind(highest, lowest, ProcessCandle).Start();
	}

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

		if (!_hasPrev)
		{
			_prevHigh = highest;
			_prevLow = lowest;
			_hasPrev = true;
			return;
		}

		var close = candle.ClosePrice;

		// Breakout above previous highest
		if (close > _prevHigh && Position <= 0)
		{
			if (Position < 0) BuyMarket();
			BuyMarket();
		}
		// Breakout below previous lowest
		else if (close < _prevLow && Position >= 0)
		{
			if (Position > 0) SellMarket();
			SellMarket();
		}

		_prevHigh = highest;
		_prevLow = lowest;
	}
}