Strategy with Breakeven not working...

watchmoon

Can someone help me with this code? I can’t seem to get the breakeven to work. Thanks ;-)

using System;
using System.Collections.Generic;
using System.Data;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Text;
using System.Xml.Linq;
using cAlgo.API;
using cAlgo.API.Collections;
using cAlgo.API.Indicators;
using cAlgo.API.Internals;

namespace cAlgo.Robots
{
    [Robot(AccessRights = AccessRights.None)]
    public class AlgoBuilderBot : Robot
    {
        // Paramètres de la stratégie

        [Parameter("Quantity (Lots)", Group = "Protection", DefaultValue = 0.01, MinValue = 0.01, Step = 0.01)]
        public double Quantity { get; set; }

        [Parameter("Stop Loss (Pips)", Group = "Protection", DefaultValue = 20, MaxValue = 40, MinValue = 2, Step = 1)]
        public int StopLossInPips { get; set; }

        [Parameter("Take Profit (Pips)", Group = "Protection", DefaultValue = 30, MaxValue = 100, MinValue = 2, Step = 1)]
        public int TakeProfitInPips { get; set; }

        [Parameter("Close on reverse", Group = "Protection", DefaultValue = false)]
        public bool CloseOnReverse { get; set; }

        // Paramètres pour Bollinger Bands

        [Parameter("Periods", Group = "Bollinger Bands", DefaultValue = 40, MaxValue = 80, MinValue = 10, Step = 10)]
        public int BollingerPeriods { get; set; }

        [Parameter("Standard Dev", Group = "Bollinger Bands", DefaultValue = 2.75, MaxValue = 4, MinValue = 1, Step = 0.25)]
        public double BollingerDeviation { get; set; }

        [Parameter("Ma Type", DefaultValue = MovingAverageType.Exponential, Group = "Bollinger Bands")]
        public MovingAverageType BollingerMaType { get; set; }

        // Paramètres pour HMA

        [Parameter("HMA Period", Group = "HMA", DefaultValue = 390, MaxValue = 400, MinValue = 50, Step = 10)]
        public int HMALength { get; set; }

        // Paramètres pour BreakEven
        [Parameter("Include Break-Even", Group = "BreakEven", DefaultValue = false)]
        public bool IncludeBreakEven { get; set; }

        [Parameter("Break-Even Trigger (pips)", Group = "BreakEven", DefaultValue = 10, MinValue = 1)]
        public int BreakEvenPips { get; set; }

        [Parameter("Break-Even Extra (pips)", Group = "BreakEven", DefaultValue = 2, MinValue = 1)]
        public int BreakEvenExtraPips { get; set; }


        private BollingerBands _bollinger_buy1;
        private BollingerBands _bollinger_sell1;

        private Bars _bollingerBars_Buy1;
        private Bars _bollingerBars_Sell1;

        private HullMovingAverage _hma;

        private string StrategyName { get; set; }

        bool IsBullish { get; set; }
        bool IsBearish { get; set; }

        protected override void OnStart()
        {
            StrategyName = "Bollinger Bands + HMA";

            _bollingerBars_Buy1 = MarketData.GetBars(TimeFrame);
            _bollingerBars_Sell1 = MarketData.GetBars(TimeFrame);

            _bollinger_buy1 = Indicators.BollingerBands(_bollingerBars_Buy1.ClosePrices, BollingerPeriods, BollingerDeviation, BollingerMaType);
            _bollinger_sell1 = Indicators.BollingerBands(_bollingerBars_Sell1.ClosePrices, BollingerPeriods, BollingerDeviation, BollingerMaType);

            // Initialisation de l'indicateur HMA
            _hma = Indicators.HullMovingAverage(Bars.ClosePrices, HMALength);
        }

        protected override void OnTick()
        {
            if (IncludeBreakEven)
            {
                var allPositions = Positions.FindAll(StrategyName, SymbolName);
                BreakEvenAdjustment(allPositions);
            }
        }

        protected override void OnBarClosed()
        {
            TradeRulesBullish();
            TradeRulesBearish();
        }

        private void TradeRulesBullish()
        {
            bool OpenBuyTrade = false;

            if (IsBullishSignal() && IsHMAColorGreen())
            {
                OpenBuyTrade = true;
            }

            if (OpenBuyTrade)
            {
                if (!IsBullish)
                {
                    if (!IsTradeOpen(TradeType.Buy))
                    {
                        OpenTrade(TradeType.Buy);
                    }
                }

                IsBullish = true;

                if (CloseOnReverse)
                {
                    CloseTrade(TradeType.Sell);
                }
            }
            else
            {
                IsBullish = false;
            }
        }

        private void TradeRulesBearish()
        {
            bool OpenSellTrade = false;

            if (IsBearishSignal() && IsHMAColorRed())
            {
                OpenSellTrade = true;
            }

            if (OpenSellTrade)
            {
                if (!IsBearish)
                {
                    if (!IsTradeOpen(TradeType.Sell))
                    {
                        OpenTrade(TradeType.Sell);
                    }
                }

                IsBearish = true;

                if (CloseOnReverse)
                {
                    CloseTrade(TradeType.Buy);
                }
            }
            else
            {
                IsBearish = false;
            }
        }

        // Vérifie si le signal HMA est vert (bullish)
        private bool IsHMAColorGreen()
        {
            return _hma.Result.Last(0) > _hma.Result.Last(1); // Si la HMA actuelle est plus haute que la précédente, elle est verte.
        }

        // Vérifie si le signal HMA est rouge (bearish)
        private bool IsHMAColorRed()
        {
            return _hma.Result.Last(0) < _hma.Result.Last(1); // Si la HMA actuelle est plus basse que la précédente, elle est rouge.
        }

        private bool IsBullishSignal()
        {
            return Bars.ClosePrices.Last(0) > _bollinger_buy1.Bottom.Last(0) && Bars.HighPrices.Last(0) < _bollinger_sell1.Top.Last(0) && Bars.LowPrices.Last(1) < _bollinger_buy1.Bottom.Last(1) && Bars.HighPrices.Last(1) < _bollinger_sell1.Top.Last(1);
        }

        private bool IsBearishSignal()
        {
            return Bars.ClosePrices.Last(0) < _bollinger_sell1.Top.Last(0) && Bars.LowPrices.Last(0) > _bollinger_buy1.Bottom.Last(0) && Bars.HighPrices.Last(1) > _bollinger_sell1.Top.Last(1) && Bars.LowPrices.Last(1) > _bollinger_buy1.Bottom.Last(1);
        }

        private void OpenTrade(TradeType type)
        {
            var volume = Symbol.QuantityToVolumeInUnits(Quantity);
            volume = Symbol.NormalizeVolumeInUnits(volume, RoundingMode.Down);

            ExecuteMarketOrder(type, SymbolName, volume, StrategyName, StopLossInPips, TakeProfitInPips);
        }

        private bool IsTradeOpen(TradeType type)
        {
            var positions = Positions.FindAll(StrategyName, SymbolName, type);
            return positions.Count() > 0;
        }

        private void CloseTrade(TradeType type)
        {
            var positions = Positions.FindAll(StrategyName, SymbolName, type);
            foreach (var position in positions)
            {
                position.Close();
            }
        }
        /// Adjusts the break even plus (x) pips
        /// </summary>
        /// <param name="tradeType"></param>
        private void BreakEvenAdjustment(IList<Position> allPositions)
        {
            foreach (Position position in allPositions)
            {
                if (position.StopLoss != null)
                    return;

                var entryPrice = position.EntryPrice;
                var distance = position.TradeType == TradeType.Buy ? Symbol.Bid - entryPrice : entryPrice - Symbol.Ask;

                // move stop loss to break even plus and additional (x) pips
                if (distance >= BreakEvenPips * Symbol.PipSize)
                {
                    if (position.TradeType == TradeType.Buy)
                    {
                        if (position.StopLoss <= position.EntryPrice + (Symbol.PipSize * BreakEvenExtraPips) || position.StopLoss == null)
                        {
                            ModifyPosition(position, position.EntryPrice + (Symbol.PipSize * BreakEvenExtraPips), position.TakeProfit);
                            Print("Stop Loss to Break Even set for BUY position {0}", position.Id);
                        }
                    }
                    else
                    {
                        if (position.StopLoss >= position.EntryPrice - (Symbol.PipSize * BreakEvenExtraPips) || position.StopLoss == null)
                        {
                            ModifyPosition(position, entryPrice - (Symbol.PipSize * BreakEvenExtraPips), position.TakeProfit);
                            Print("Stop Loss to Break Even set for SELL position {0}", position.Id);
                        }
                    }
                }
            }
        }
    }
}

algoman

According to your code, in the breakeven method, you exit if there is a stop loss.

 if (position.StopLoss != null)
    return;

Maybe it should be

 if (position.StopLoss == null)
   return;

watchmoon

Thanks a lot Algoman! Each symbol has its importance... ;-)