1000%/year BOLLINGER BANDS EUR-USD H8

using System;
using System.Linq;
using cAlgo.API;
using cAlgo.API.Indicators;
using cAlgo.API.Internals;
using cAlgo.Indicators;

namespace cAlgo.Robots
{
    [Robot(TimeZone = TimeZones.UTC, AccessRights = AccessRights.None)]
    public class DragonBollingerBandsPro : Robot
    {
        [Parameter("Source")]
        public DataSeries Source { get; set; }
        [Parameter("BandPeriods", DefaultValue = 19)]
        public int BandPeriod { get; set; }
        [Parameter("Std", DefaultValue = 1.6)]
        public double std { get; set; }
        [Parameter("MAType")]
        public MovingAverageType MAType { get; set; }
        [Parameter("Initial Volume Percent", DefaultValue = 1, MinValue = 0)]
        public double InitialVolumePercent { get; set; }
        [Parameter("Stop Loss", DefaultValue = 80)]
        public int StopLoss { get; set; }
        [Parameter("Take Profit", DefaultValue = 60)]
        public int TakeProfit { get; set; }
        [Parameter("MaxFail", DefaultValue = 1)]
        public int MaxFail { get; set; }
        [Parameter(DefaultValue = 1)]
        public int MaxPosition { get; set; }
        [Parameter("Trailing Stop", DefaultValue = false)]
        public bool TrailingStop { get; set; }

        private Position lastPosition;

        private int countFalse = 0;

        private BollingerBands boll;
        private double lastVolume;

        private string _label;

        protected override void OnStart()
        {
            // Put your initialization logic here
            boll = Indicators.BollingerBands(Source, BandPeriod, std, MAType);
            _label = string.Format("DragonBollingerPro{0}", Guid.NewGuid());
        }

        protected override void OnBar()
        {

            if (Positions.FindAll(_label).Length >= MaxPosition)
            {
                return;
            }



            if (Bars.Last(2).Close > boll.Top.Last(2))
            {
                if (Bars.Last(1).Close > boll.Top.Last(1))
                {
                    CreateOrder(TradeType.Buy);

                }
                else
                {
                    CreateOrder(TradeType.Sell);

                }
            }
            else if (Bars.Last(2).Close < boll.Bottom.Last(2))
            {
                if (Bars.Last(1).Close < boll.Bottom.Last(1))
                {
                    CreateOrder(TradeType.Sell);
                }
                else
                {

                    CreateOrder(TradeType.Buy);
                }
            }


        }

        private void CreateOrder(TradeType type)
        {
            var volumne = Math.Floor(Account.Balance * 10 * InitialVolumePercent / 1000) * 1000;


            if (lastPosition != null)
            {
                Print("countFalse: {0}", countFalse);
                if (lastPosition.NetProfit < 0 && countFalse < MaxFail)
                {
                    volumne = lastVolume * 2;
                    countFalse = countFalse + 1;
                }
                else
                {
                    countFalse = 0;
                }
            }

            var result = ExecuteMarketOrder(type, Symbol.Name, volumne, _label, StopLoss, TakeProfit, "new Order", TrailingStop);
            if (result.IsSuccessful)
            {
                lastPosition = result.Position;
                lastVolume = volumne;
                Print("volume:" + volumne);
            }
        }

        protected override void OnTick()
        {
            // Put your core logic here
        }

        protected override void OnStop()
        {
            // Put your deinitialization logic here
        }
    }
}