English EN
View on GitHub

Martingale Breakout Strategy

Overview

The Martingale Breakout Strategy is a StockSharp port of the MetaTrader expert advisor MartinGaleBreakout.mq5. The system waits for abnormally large breakout candles and places a single market order in the breakout direction. While the original EA tracks a "magic number" to manage its positions, the StockSharp implementation relies on the strategy context, so the behaviour is effectively the same when the strategy is executed in isolation.

The algorithm focuses on two core ideas:

  1. Breakout detection – the strategy examines the size of each finished candle and compares it to the average range of the previous ten candles. When the current range is three times larger than the average and the candle closes strongly in the direction of the breakout, a trading signal is produced.
  2. Martingale-style recovery – the strategy keeps track of floating profit and loss. Whenever the unrealized PnL reaches the configured loss threshold it immediately closes all open positions and increases the next profit target so the following trade attempts to recover the loss. Once the increased target is met, the thresholds are reset to the original values.

The port keeps all money-management parameters from the MQL5 code, including the balance percentage reserved for margin, the percentage-based profit and loss goals, and the multiplier that expands the take-profit distance during the recovery phase.

Trading logic

  1. Subscribe to the configured candle series and wait for finished candles.
  2. Compute the candle range (High - Low) and maintain a fixed-size buffer with the previous ten ranges to determine the reference average used for breakout detection.
  3. Calculate the floating PnL by tracking average entry prices for the long and short sides. If the unrealized PnL exceeds the profit target or breaches the stop-loss threshold, immediately close all positions and reset the recovery state as in the original expert advisor.
  4. Skip order placement while the strategy already holds a position or when trading is not allowed by the connection state.
  5. When a bullish breakout candle appears, size the order so that the expected profit matches the current target. The take-profit distance in price steps is multiplied during recovery, exactly like the TP_Points_Multiplier parameter from the EA.
  6. Validate the calculated volume against the instrument limits (minimum, maximum and step) and make sure the required margin does not exceed the configured balance allocation or the available free funds. If the constraints are respected, submit a market buy order.
  7. Repeat the same process for bearish breakouts, submitting a market sell order instead.

The combination of these rules recreates the behaviour of the original MetaTrader system, including the transition into and out of the recovery mode after a stop-loss event.

Parameters

Parameter Description Default
TakeProfitPoints Distance between the entry price and the take-profit price expressed in price steps. 50
BalancePercentAvailable Maximum percentage of the account balance that can be reserved for margin on a single trade. 50
TakeProfitPercentOfBalance Target profit expressed as a percentage of the current balance. 0.1
StopLossPercentOfBalance Stop-loss size expressed as a percentage of the current balance. 10
RecoveryStartFraction Fraction of the stop-loss used before switching into the recovery mode. 0.1
RecoveryPointsMultiplier Multiplier applied to the take-profit distance while recovering. 1
CandleType Candle data source used by the strategy (time frame, tick candles, etc.). 15-minute time frame

Additional notes

  • The volume calculation replicates the MetaTrader helper CalcLotWithTP. It derives the lot size required to reach the current profit target for a given price move and then normalizes the result to the instrument's volume step.
  • Margin checks are performed with the same spirit as CheckVolumeValue and the balance-percentage filter used in the MQL version. Orders are rejected when the required margin exceeds the allowed share of the balance or the free funds reported by the portfolio.
  • The strategy cancels all active orders before flattening positions so the behaviour matches the CloseAllOrders helper from the original expert advisor.
  • The internal range buffer stores only ten values and is equivalent to iterating over iHigh/iLow in the source EA. No historical data beyond the last ten candles is required.
using System;

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

namespace StockSharp.Samples.Strategies;

/// <summary>
/// Breakout strategy that detects abnormally large candles and enters in the breakout direction.
/// Uses a simple martingale recovery: after a losing trade, the next entry is taken more aggressively.
/// </summary>
public class MartingaleBreakoutStrategy : Strategy
{
	private readonly StrategyParam<int> _lookback;
	private readonly StrategyParam<decimal> _breakoutMultiplier;
	private readonly StrategyParam<decimal> _takeProfitPct;
	private readonly StrategyParam<decimal> _stopLossPct;
	private readonly StrategyParam<DataType> _candleType;

	private readonly decimal[] _rangeBuffer = new decimal[10];
	private int _rangeBufferCount;
	private int _rangeBufferIndex;
	private decimal _rangeBufferSum;

	private decimal _entryPrice;
	private Sides? _entrySide;
	private bool _lastWasLoss;

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

	public decimal BreakoutMultiplier
	{
		get => _breakoutMultiplier.Value;
		set => _breakoutMultiplier.Value = value;
	}

	public decimal TakeProfitPct
	{
		get => _takeProfitPct.Value;
		set => _takeProfitPct.Value = value;
	}

	public decimal StopLossPct
	{
		get => _stopLossPct.Value;
		set => _stopLossPct.Value = value;
	}

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

	public MartingaleBreakoutStrategy()
	{
		_lookback = Param(nameof(Lookback), 10)
			.SetDisplay("Lookback", "Number of candles for average range", "General");

		_breakoutMultiplier = Param(nameof(BreakoutMultiplier), 3m)
			.SetDisplay("Breakout Mult", "Multiplier above avg range for breakout", "General");

		_takeProfitPct = Param(nameof(TakeProfitPct), 1m)
			.SetDisplay("Take Profit %", "Take profit as percentage of entry price", "Trading");

		_stopLossPct = Param(nameof(StopLossPct), 0.5m)
			.SetDisplay("Stop Loss %", "Stop loss as percentage of entry price", "Trading");

		_candleType = Param(nameof(CandleType), TimeSpan.FromMinutes(60).TimeFrame())
			.SetDisplay("Candle Type", "Candle type", "General");
	}

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

		_rangeBufferCount = 0;
		_rangeBufferIndex = 0;
		_rangeBufferSum = 0m;
		_entryPrice = 0m;
		_entrySide = null;
		_lastWasLoss = 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 closePrice = candle.ClosePrice;

		// Check exit conditions first
		if (Position != 0 && _entryPrice > 0)
		{
			var tp = _lastWasLoss ? TakeProfitPct * 1.5m : TakeProfitPct;
			var sl = StopLossPct;

			if (_entrySide == Sides.Buy)
			{
				var pnlPct = (closePrice - _entryPrice) / _entryPrice * 100m;
				if (pnlPct >= tp || pnlPct <= -sl)
				{
					_lastWasLoss = pnlPct < 0;
					SellMarket();
					_entryPrice = 0;
					_entrySide = null;
					UpdateRangeStatistics(candle);
					return;
				}
			}
			else if (_entrySide == Sides.Sell)
			{
				var pnlPct = (_entryPrice - closePrice) / _entryPrice * 100m;
				if (pnlPct >= tp || pnlPct <= -sl)
				{
					_lastWasLoss = pnlPct < 0;
					BuyMarket();
					_entryPrice = 0;
					_entrySide = null;
					UpdateRangeStatistics(candle);
					return;
				}
			}
		}

		// Entry logic - only when flat
		if (Position == 0)
		{
			var range = candle.HighPrice - candle.LowPrice;

			if (_rangeBufferCount >= _rangeBuffer.Length)
			{
				var avgRange = _rangeBufferSum / _rangeBuffer.Length;

				if (range > avgRange * BreakoutMultiplier)
				{
					var body = candle.ClosePrice - candle.OpenPrice;

					if (body > 0 && body > range * 0.4m)
					{
						// Bullish breakout
						BuyMarket();
						_entryPrice = closePrice;
						_entrySide = Sides.Buy;
					}
					else if (body < 0 && Math.Abs(body) > range * 0.4m)
					{
						// Bearish breakout
						SellMarket();
						_entryPrice = closePrice;
						_entrySide = Sides.Sell;
					}
				}
			}
		}

		UpdateRangeStatistics(candle);
	}

	private void UpdateRangeStatistics(ICandleMessage candle)
	{
		var range = candle.HighPrice - candle.LowPrice;

		if (_rangeBufferCount < _rangeBuffer.Length)
		{
			_rangeBuffer[_rangeBufferIndex] = range;
			_rangeBufferSum += range;
			_rangeBufferCount++;
			_rangeBufferIndex = (_rangeBufferIndex + 1) % _rangeBuffer.Length;
			return;
		}

		_rangeBufferSum -= _rangeBuffer[_rangeBufferIndex];
		_rangeBuffer[_rangeBufferIndex] = range;
		_rangeBufferSum += range;
		_rangeBufferIndex = (_rangeBufferIndex + 1) % _rangeBuffer.Length;
	}

	/// <inheritdoc />
	protected override void OnReseted()
	{
		Array.Clear(_rangeBuffer);
		_rangeBufferCount = 0;
		_rangeBufferIndex = 0;
		_rangeBufferSum = 0m;
		_entryPrice = 0m;
		_entrySide = null;
		_lastWasLoss = false;

		base.OnReseted();
	}
}