Português PT
Ver no GitHub

Estratégia Nova Aleatória

Visão geral

A Estratégia Nova Aleatória emula o especialista MetaTrader original "New Random" oferecendo três modos distintos de seleção de entrada. Ela abre apenas uma única posição por vez e aguarda até que a posição atual seja fechada antes de gerar a próxima direção de ordem. As entradas a mercado são acionadas em atualizações do melhor preço (dados Level 1) usando os melhores preços bid/ask como âncoras de execução. A estratégia calcula automaticamente os offsets de stop-loss e take-profit em pips, adaptando-se a cotações forex de 3 e 5 dígitos da mesma forma que a versão MQL.

Modos de entrada

  1. Gerador – a próxima direção é escolhida por um gerador pseudoaleatório semeado no início da estratégia. Cada oportunidade é um lançamento de moeda independente entre comprar e vender.
  2. Compra-Venda-Compra – as posições alternam estritamente entre compra e venda. A primeira ordem é uma compra, seguida de uma venda, e assim por diante.
  3. Venda-Compra-Venda – as posições alternam estritamente começando de uma venda, seguida de uma compra, e repetindo.

Parâmetros

  • Random Mode (Mode) – seleciona um dos três mecanismos de entrada descritos acima. Padrão: gerador aleatório.
  • Minimal Lot Count (MinimalLotCount) – multiplica o volume mínimo negociável do instrumento. Um valor de 1 significa que a estratégia negocia exatamente Security.VolumeMin, enquanto valores maiores escalam o tamanho da ordem por múltiplos inteiros.
  • Stop Loss (pips) (StopLossPips) – distância em pips abaixo/acima do preço de execução onde a estratégia sairá da posição. Definir como 0 para desabilitar o stop-loss.
  • Take Profit (pips) (TakeProfitPips) – distância em pips onde a estratégia realizará lucros. Definir como 0 para desabilitar o take-profit.

Lógica de negociação

  1. Assina dados Level 1 para o ativo configurado e armazena constantemente os últimos preços bid, ask e último trade.
  2. Quando não há posição aberta nem ordem pendente, a estratégia avalia o modo selecionado para determinar a próxima direção.
  3. As ordens são colocadas a mercado usando o snapshot mais recente do melhor bid/ask. Os alvos de stop-loss e take-profit são calculados imediatamente a partir do preço de entrada usando os parâmetros de distância em pips.
  4. Apenas uma posição pode existir por vez. Entradas subsequentes são suprimidas até que a posição ativa seja completamente fechada.

Gestão de posição

  • Posições compradas saem antecipadamente quando o preço atual cai ao stop-loss ou abaixo, ou sobe ao take-profit ou acima.
  • Posições vendidas saem quando o preço atual sobe ao stop-loss ou acima, ou cai ao take-profit ou abaixo.
  • As comparações de preço sempre usam as informações Level 1 mais recentes: o último preço de trade se disponível, caso contrário o melhor bid/ask para o lado respectivo.
  • Após fechar um trade, a estratégia reinicia o estado interno, alterna opcionalmente a próxima direção (para modos de sequência) e aguarda a próxima atualização de cotação antes de reingressar.

Notas

  • A estratégia nunca piramidaliza posições e mantém o comportamento determinístico para os modos baseados em sequência.
  • O modo aleatório é semeado com o contagem de ticks atual, portanto cada execução produz um fluxo de ordens único.
  • Todos os comentários internos e logs estão em inglês para se alinharem com as diretrizes do repositório.
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>
/// Randomized entry strategy that mimics the MetaTrader "New Random" expert.
/// </summary>
public class NewRandomStrategy : Strategy
{
	/// <summary>
	/// Available direction selection modes.
	/// </summary>
	public enum RandomModes
	{
		/// <summary>Use a pseudo random generator for every entry decision.</summary>
		Generator,
		/// <summary>Alternate buy-sell-buy.</summary>
		BuySellBuy,
		/// <summary>Alternate sell-buy-sell.</summary>
		SellBuySell
	}

	private readonly StrategyParam<RandomModes> _mode;
	private readonly StrategyParam<int> _stopLossPoints;
	private readonly StrategyParam<int> _takeProfitPoints;
	private readonly StrategyParam<DataType> _candleType;

	private Sides? _sequenceLastSide;
	private Sides? _positionSide;
	private decimal _entryPrice;
	private int _candleCount;

	/// <summary>Direction selection mode.</summary>
	public RandomModes Mode
	{
		get => _mode.Value;
		set => _mode.Value = value;
	}

	/// <summary>Stop loss in price steps.</summary>
	public int StopLossPoints
	{
		get => _stopLossPoints.Value;
		set => _stopLossPoints.Value = value;
	}

	/// <summary>Take profit in price steps.</summary>
	public int TakeProfitPoints
	{
		get => _takeProfitPoints.Value;
		set => _takeProfitPoints.Value = value;
	}

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

	public NewRandomStrategy()
	{
		_mode = Param(nameof(Mode), RandomModes.Generator)
			.SetDisplay("Random Mode", "Direction selection mode", "General");

		_stopLossPoints = Param(nameof(StopLossPoints), 5)
			.SetGreaterThanZero()
			.SetDisplay("Stop Loss (pts)", "Stop loss in price steps", "Risk");

		_takeProfitPoints = Param(nameof(TakeProfitPoints), 5)
			.SetGreaterThanZero()
			.SetDisplay("Take Profit (pts)", "Take profit in price steps", "Risk");

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

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

	/// <inheritdoc />
	protected override void OnReseted()
	{
		base.OnReseted();
		_sequenceLastSide = null;
		_positionSide = null;
		_entryPrice = 0m;
		_candleCount = 0;
	}

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

		_sequenceLastSide = Mode switch
		{
			RandomModes.BuySellBuy => Sides.Sell,
			RandomModes.SellBuySell => Sides.Buy,
			_ => null
		};

		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;

		_candleCount++;
		if (_candleCount < 3)
			return;

		var step = Security?.PriceStep ?? 1m;
		var stopDistance = StopLossPoints * step;
		var takeDistance = TakeProfitPoints * step;
		var price = candle.ClosePrice;

		// Check SL/TP for current position
		if (Position != 0 && _entryPrice > 0)
		{
			var hit = false;

			if (_positionSide == Sides.Buy)
			{
				if (stopDistance > 0 && candle.LowPrice <= _entryPrice - stopDistance)
					hit = true;
				if (takeDistance > 0 && candle.HighPrice >= _entryPrice + takeDistance)
					hit = true;
			}
			else if (_positionSide == Sides.Sell)
			{
				if (stopDistance > 0 && candle.HighPrice >= _entryPrice + stopDistance)
					hit = true;
				if (takeDistance > 0 && candle.LowPrice <= _entryPrice - takeDistance)
					hit = true;
			}

			if (hit)
			{
				if (Position > 0)
					SellMarket();
				else if (Position < 0)
					BuyMarket();

				_positionSide = null;
				_entryPrice = 0m;
			}
		}

		// If flat, open new random position
		if (Position == 0 && _positionSide == null)
		{
			var side = DetermineNextSide();

			if (side == Sides.Buy)
				BuyMarket();
			else
				SellMarket();

			_positionSide = side;
			_entryPrice = price;

			_sequenceLastSide = side;
		}
	}

	private Sides DetermineNextSide()
	{
		// All modes use deterministic alternating logic
		return _sequenceLastSide == Sides.Buy ? Sides.Sell : Sides.Buy;
	}
}