Backtesting with Pending Orders - Amazing in Backtest, Devastating in Reality - is it my code?

Hi there, 

I've developed a few strategies recently that rely on Pending Orders and they blow me away in Backtest but the Reality is very different.  Any idea why this and is there a way to fix it?  Is there something wrong with my code or is this just a “thing” in cTrader?  Many thanks in Advance.
 

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using cAlgo.API;
using cAlgo.API.Collections;
using cAlgo.API.Indicators;
using cAlgo.API.Internals;

namespace cAlgo.Robots
{
    [Robot(AccessRights = AccessRights.None)]
    public class OutsideBollingerBounces5mAllDay1m : Robot
    {
        private BollingerBands BB;

        [Parameter(DefaultValue = 6, Group = "Extra")]
        public int StartTime { get; set; }

        [Parameter(DefaultValue = "BollingerBounceBuy", Group = "General")]
        public string LabelBuy { get; set; }
        
        [Parameter(DefaultValue = "BollingerBounceSell", Group = "General")]
        public string LabelSell { get; set; }

        [Parameter("TakeProfit", DefaultValue = 3, MinValue = 3, MaxValue = 8, Step = 0.1, Group = "Risk Management")]
        public double TakeProfit { get; set; }

        [Parameter("StopLoss", DefaultValue = 8, MinValue = 3, MaxValue = 8, Step = 0.1, Group = "Risk Management")]
        public double StopLoss { get; set; }

        [Parameter("Gap", DefaultValue = 5, MinValue = 1.5, MaxValue = 10, Step = 0.5, Group = "Logic")]
        public double Gap { get; set; }

        [Parameter("Volume Percent", DefaultValue = 1, MinValue = 0, Group = "Extra")]
        public double VolumePercent { get; set; }

        [Parameter("Minimum Account Balance", DefaultValue = 300, Group = "Extra")]
        public int MinBalance { get; set; }
        
        [Parameter("Include Trailing Stop", DefaultValue = false, Group = "Risk Management")]
        public bool IncludeTrailingStop { get; set; }

        [Parameter("Trailing Stop Trigger (pips)", DefaultValue = 1.5, MinValue = 0.1, MaxValue = 6, Step = 0.1, Group = "Risk Management")]
        public double TrailingStopTrigger { get; set; }

        [Parameter("Trailing Stop Step (pips)", DefaultValue = 1.5, MinValue = 0.1, MaxValue = 6, Step = 0.1, Group = "Risk Management")]
        public double TrailingStopStep { get; set; }
        
        [Parameter("Drop Rate", DefaultValue = 8, MinValue = 5, MaxValue = 15, Step = 1, Group = "Extra")]
        public double DropRate { get; set; }
        
        [Parameter("Drop Rate 2", DefaultValue = 12, MinValue = 2, MaxValue = 20, Step = 1, Group = "Extra")]
        public double DropRate2 { get; set; }
        
        [Parameter("Drop Gap", DefaultValue = 3, MinValue = 2, MaxValue = 5, Step = 1, Group = "Extra")]
        public double DropGap { get; set; }

        [Parameter("BandPeriods", DefaultValue = 20)]
        public int BandPeriod { get; set; }
        
        [Parameter("Std", DefaultValue = 2)]
        public int Std { get; set; }
        
        [Parameter("MAType")]
        public MovingAverageType MAType { get; set; }
        
        [Parameter("Band Range Max", DefaultValue = 35)]
        public int BandRangeMax { get; set; }
        
        [Parameter("Band Range Min", DefaultValue = 25)]
        public int BandRangeMin { get; set; }
        
        public bool OverTop;
        public bool UnderBottom;

        public double spread;
        public double volumne;

        protected override void OnStart()
        {
            var TimeFrame5 = MarketData.GetBars(TimeFrame.Minute5);
            BB = Indicators.BollingerBands(TimeFrame5.ClosePrices,BandPeriod,Std,MAType);
            //Positions.Closed += PositionsOnClosed;
        }

        protected override void OnBar()
        {            
            //Spread and Time Avoid
            spread = Symbol.Spread;
            
            //Volume Calculation
            Asset baseAssetForNewOrder = Assets.GetAsset("GBP");
            Asset quoteAssetForNewOrder = Assets.GetAsset("USD");
            double BalanceUSD = baseAssetForNewOrder.Convert(quoteAssetForNewOrder, Account.Balance);
            if (Math.Floor(BalanceUSD * 200 * VolumePercent / Bars.ClosePrices.Last(0)) > 1000)
            {
                volumne = 1000;
            }
            else
            {
                volumne = Math.Floor(BalanceUSD * 200 * VolumePercent / Bars.ClosePrices.Last(0));
            }            
            if (Account.Balance < MinBalance / 1.3)
            {
                Stop();
            }
            
            ///////////////////////////////// INITIAL PLACEMENTS /////////////////////////////////
            //EMA14 Initial Placement
            var Buy = PendingOrders.Count(x => x.TradeType == TradeType.Buy && x.SymbolName == Symbol.Name && x.Label == LabelBuy);
            var Sell = PendingOrders.Count(x => x.TradeType == TradeType.Sell && x.SymbolName == Symbol.Name && x.Label == LabelSell);

            if (Bars.HighPrices.Last(0) > BB.Top.Last(0) + Gap && Positions.Count == 0 && Buy == 0)
            {
                PlaceLimitOrder(TradeType.Buy, SymbolName, volumne / 10, BB.Top.Last(0) + spread, LabelBuy, StopLoss, TakeProfit);
            }
            else if (Bars.LowPrices.Last(0) < BB.Bottom.Last(0) - Gap && Positions.Count == 0 && Sell == 0)
            {
                PlaceLimitOrder(TradeType.Sell, SymbolName, volumne / 10, BB.Bottom.Last(0), LabelSell, StopLoss, TakeProfit);
            }
            
            ///////////////////////////////// RESET ORDERS /////////////////////////////////
            //Reset the EMA14 Pending Orders.
            Buy = PendingOrders.Count(x => x.TradeType == TradeType.Buy && x.SymbolName == Symbol.Name && x.Label == LabelBuy);
            Sell = PendingOrders.Count(x => x.TradeType == TradeType.Sell && x.SymbolName == Symbol.Name && x.Label == LabelSell);
            
            if (Buy > 0 && Positions.Count == 0)
            {
                foreach (var pending in PendingOrders)
                {
                    if (pending.Label == LabelBuy)
                    {
                        PlaceLimitOrder(TradeType.Buy, SymbolName, volumne / 10, BB.Top.Last(0) + spread, LabelBuy, StopLoss, TakeProfit);
                        CancelPendingOrder(pending);
                    }
                }
            }
            else if (Sell > 0 && Positions.Count == 0)
            {
                foreach (var pending in PendingOrders)
                {
                    if (pending.Label == LabelSell)
                    {
                        PlaceLimitOrder(TradeType.Sell, SymbolName, volumne / 10, BB.Bottom.Last(0), LabelSell, StopLoss, TakeProfit);
                        CancelPendingOrder(pending);
                    }
                }
            }
            
        }

        protected override void OnTick()
        {
            if (IncludeTrailingStop)
            {
                SetTrailingStop();
            }
            
            if (Positions.Count > 0)
            {
                foreach(var pending in PendingOrders)
                {
                    CancelPendingOrder(pending);
                }
            }
            
            if (Positions.Count > 0 && (Bars.ClosePrices.Last(0) < BB.Top.Last(0) || Bars.OpenPrices.Last(0) < BB.Top.Last(0)))
            {
                foreach(var position in Positions.FindAll(LabelBuy))
                {
                    ClosePosition(position);
                }
            }
            else if (Positions.Count > 0 && (Bars.ClosePrices.Last(0) > BB.Bottom.Last(0) || Bars.OpenPrices.Last(0) > BB.Bottom.Last(0)))
            {
                foreach(var position in Positions.FindAll(LabelSell))
                {
                    ClosePosition(position);
                }
            }
        }    
            
        
        private void SetTrailingStop()
        {
            var sellPositions = Positions.FindAll(LabelSell, SymbolName, TradeType.Sell);
            foreach (var position in sellPositions)
            {
                double distance = position.EntryPrice - Symbol.Ask;
                if (distance < TrailingStopTrigger * Symbol.PipSize)
                    continue;

                double newStopLossPrice = Symbol.Ask + TrailingStopStep * Symbol.PipSize;
                if (position.StopLoss == null || newStopLossPrice < position.StopLoss)
                {
                    ModifyPosition(position, newStopLossPrice, (position.TakeProfit.HasValue ? position.TakeProfit.GetValueOrDefault() : (double?)null));
                    Print("Position TSL Modified");
                }
            }

            var buyPositions = Positions.FindAll(LabelBuy, SymbolName, TradeType.Buy);
            foreach (var position in buyPositions)
            {
                double distance = Symbol.Bid - position.EntryPrice;
                if (distance < TrailingStopTrigger * Symbol.PipSize)
                    continue;

                double newStopLossPrice = Symbol.Bid - TrailingStopStep * Symbol.PipSize;
                if (position.StopLoss == null || newStopLossPrice > position.StopLoss)
                {
                    ModifyPosition(position, newStopLossPrice, (position.TakeProfit.HasValue ? position.TakeProfit.GetValueOrDefault() : (double?)null));
                    Print("Position TSL Modified");
                }
            
            }
            
            
        }
        

        protected override void OnStop()
        {
            
        }
    }
}