Español ES
Ver en GitHub

V1N1 Lonny Breakout Strategy

Overview

The V1N1 Lonny Breakout strategy replicates the MetaTrader "V1N1 LONNY" expert advisor. It targets breakouts that emerge around the London and New York sessions by building an opening range and waiting for a decisive close outside that range. The strategy relies on an exponential moving average to capture the prevailing trend and on a stochastic oscillator to filter out overbought or oversold conditions before entering the market.

A configurable risk model allows position sizing by fixed volume or as a percentage of account equity. The implementation also includes optional spread filtering, trailing stops, and a bar-based timeout that closes the trade if momentum fades after a predefined number of candles.

Trading Logic

  1. Session alignment – Trading is only allowed between the configured start and end times. The timetable can be shifted according to daylight-saving schedules for either London or New York.
  2. Opening range – Immediately before the session begins, the strategy records the highs and lows of a fixed number of candles. This range provides the breakout levels used during the trading window.
  3. Trend confirmation – The exponential moving average (EMA) slope must agree with the trade direction. A bullish breakout requires the EMA to be rising, while a bearish breakout requires it to be falling.
  4. Momentum filter – The stochastic oscillator must stay inside a configurable zone around the midpoint to avoid entering when the market is already overbought or oversold.
  5. Breakout validation – The previous candle must close beyond the range high or low by at least the minimum breakout distance but not farther than the maximum distance.
  6. Risk controls – Each position defines a stop loss from the range boundary and a take-profit target based on a factor of that stop distance. A trailing stop can tighten the exit as the trade progresses, and positions can be forcibly closed after a certain number of candles.

Parameters

Name Description
StartTrade Session start time.
EndTrade Session end time.
SwitchDst Daylight-saving handling: Europe (no shift), USA (relative shift between London and New York), or disabled.
RiskModes Position sizing mode (percentage of equity or fixed volume).
PositionRisk Risk percentage or fixed volume, depending on the mode.
TradeRange Number of candles used to build the opening range.
MinRangePoints / MaxRangePoints Minimum and maximum size of the opening range, in price points.
MinBreakRange / MaxBreakRange Minimum and maximum acceptable breakout distance above or below the range, in price points.
StopLossPoints Stop-loss distance measured from the opposite side of the range, in price points.
TpFactor Take-profit multiplier applied to the stop-loss distance.
TrailStopPoints Optional trailing stop distance, in price points. Set to zero to disable trailing.
TrendPeriod Period for the EMA slope filter.
OverPeriod Period for the stochastic oscillator.
OverLevels Distance from 50 used to define the acceptable stochastic range.
BarsToClose Maximum number of candles to keep the position open. Zero disables the timeout.
MaxSpreadPoints Maximum allowed spread in price points.
SlippagePoints Reference slippage in price points (kept for compatibility with the original expert advisor).
CandleType Candle type and timeframe processed by the strategy.

Usage Notes

  • The strategy is designed for instruments quoted with a fixed price step. Point-based inputs are multiplied by the instrument's PriceStep to obtain price distances.
  • Order book data is used to estimate the current spread. If best bid/ask quotes are unavailable, spread filtering is skipped.
  • Trailing and timeout exits are evaluated on closed candles, matching the original MQL logic.
  • Position sizing requires portfolio valuation (Portfolio.CurrentValue) when RiskModes is set to percentage. If the value is unavailable the strategy falls back to the configured lot size.

Files

  • CS/V1n1LonnyBreakoutStrategy.cs – Strategy implementation in C# for StockSharp.
  • README.md – This description in English.
  • README_zh.md – 中文简介。
  • README_ru.md – Русское описание.
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 that mirrors the original "V1N1 LONNY" MQL expert advisor.
/// The strategy forms an opening range from early candles and
/// enters when a candle closes outside that range while trend and momentum filters agree.
/// </summary>
public class V1n1LonnyBreakoutStrategy : Strategy
{
	private readonly StrategyParam<int> _trendPeriod;
	private readonly StrategyParam<int> _rsiPeriod;
	private readonly StrategyParam<int> _rangeBars;
	private readonly StrategyParam<DataType> _candleType;

	private ExponentialMovingAverage _ema;
	private RelativeStrengthIndex _rsi;

	private decimal _prevEma;
	private decimal _prevPrevEma;
	private bool _hasPrevEma;
	private bool _hasPrevPrevEma;

	private readonly List<decimal> _highs = new();
	private readonly List<decimal> _lows = new();
	private bool _rangeReady;
	private decimal _rangeHigh;
	private decimal _rangeLow;
	private bool _breakoutUpSeen;
	private bool _breakoutDownSeen;

	/// <summary>
	/// EMA period for the trend filter.
	/// </summary>
	public int TrendPeriod
	{
		get => _trendPeriod.Value;
		set => _trendPeriod.Value = value;
	}

	/// <summary>
	/// RSI period for momentum filter.
	/// </summary>
	public int RsiPeriod
	{
		get => _rsiPeriod.Value;
		set => _rsiPeriod.Value = value;
	}

	/// <summary>
	/// Number of initial bars to build the opening range.
	/// </summary>
	public int RangeBars
	{
		get => _rangeBars.Value;
		set => _rangeBars.Value = value;
	}

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

	/// <summary>
	/// Initializes a new instance of the <see cref="V1n1LonnyBreakoutStrategy"/> class.
	/// </summary>
	public V1n1LonnyBreakoutStrategy()
	{
		_trendPeriod = Param(nameof(TrendPeriod), 20)
			.SetGreaterThanZero()
			.SetDisplay("Trend EMA", "EMA period for trend filter", "Indicators");

		_rsiPeriod = Param(nameof(RsiPeriod), 14)
			.SetGreaterThanZero()
			.SetDisplay("RSI Period", "RSI period for momentum filter", "Indicators");

		_rangeBars = Param(nameof(RangeBars), 5)
			.SetGreaterThanZero()
			.SetDisplay("Range Bars", "Bars used to build the opening range", "Breakout");

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

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

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

		_ema = null;
		_rsi = null;
		_prevEma = 0m;
		_prevPrevEma = 0m;
		_hasPrevEma = false;
		_hasPrevPrevEma = false;

		_highs.Clear();
		_lows.Clear();
		_rangeReady = false;
		_rangeHigh = 0m;
		_rangeLow = 0m;
		_breakoutUpSeen = false;
		_breakoutDownSeen = false;
	}

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

		_ema = new ExponentialMovingAverage { Length = TrendPeriod };
		_rsi = new RelativeStrengthIndex { Length = RsiPeriod };

		Indicators.Add(_ema);
		Indicators.Add(_rsi);

		var subscription = SubscribeCandles(CandleType);
		subscription
			.Bind(_ema, ProcessCandle)
			.Start();

		StartProtection(
			takeProfit: new Unit(2, UnitTypes.Percent),
			stopLoss: new Unit(1, UnitTypes.Percent));

		var area = CreateChartArea();
		if (area != null)
		{
			DrawCandles(area, subscription);
			DrawIndicator(area, _ema);
			DrawOwnTrades(area);
		}
	}

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

		var rsiResult = _rsi.Process(new DecimalIndicatorValue(_rsi, candle.ClosePrice, candle.OpenTime) { IsFinal = true });

		if (!_rsi.IsFormed || !_ema.IsFormed)
		{
			ShiftEma(emaValue);
			return;
		}

		var rsiValue = rsiResult.ToDecimal();

		// Build the opening range from the first N bars
		if (!_rangeReady)
		{
			_highs.Add(candle.HighPrice);
			_lows.Add(candle.LowPrice);

			if (_highs.Count >= RangeBars)
			{
				_rangeHigh = decimal.MinValue;
				_rangeLow = decimal.MaxValue;

				for (var i = 0; i < _highs.Count; i++)
				{
					if (_highs[i] > _rangeHigh) _rangeHigh = _highs[i];
					if (_lows[i] < _rangeLow) _rangeLow = _lows[i];
				}

				_rangeReady = true;
			}

			ShiftEma(emaValue);
			return;
		}

		if (Position != 0 || !_hasPrevEma || !_hasPrevPrevEma)
		{
			ShiftEma(emaValue);
			return;
		}

		// Trend rising: EMA going up
		var trendUp = _prevEma > _prevPrevEma;
		var trendDown = _prevEma < _prevPrevEma;

		// Long: close above range high + trend up + RSI not overbought
		if (!_breakoutUpSeen && trendUp && rsiValue < 70 && candle.ClosePrice > _rangeHigh)
		{
			BuyMarket();
			_breakoutUpSeen = true;
		}
		// Short: close below range low + trend down + RSI not oversold
		else if (!_breakoutDownSeen && trendDown && rsiValue > 30 && candle.ClosePrice < _rangeLow)
		{
			SellMarket();
			_breakoutDownSeen = true;
		}

		ShiftEma(emaValue);
	}

	private void ShiftEma(decimal emaValue)
	{
		if (_hasPrevEma)
		{
			_prevPrevEma = _prevEma;
			_hasPrevPrevEma = true;
		}

		_prevEma = emaValue;
		_hasPrevEma = true;
	}
}