XAUUSD 7m account size 25000 USD 1:30 free

using System;
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 XAUSD5mctrader10000bot : Robot
    {
        [Parameter("Fast MA Period", DefaultValue = 10)]
        public int FastMAPeriod { get; set; }

        [Parameter("Slow MA Period", DefaultValue = 30)]
        public int SlowMAPeriod { get; set; }

        [Parameter("Risk Percentage", DefaultValue = 0.04, MinValue = 0.01, MaxValue = 0.04)]
        public double RiskPercentage { get; set; }

        [Parameter("ATR Period", DefaultValue = 14)]
        public int ATRPeriod { get; set; }

        [Parameter("Take Profit ATR Multiplier", DefaultValue = 1.0, MinValue = 0.5, MaxValue = 10)]
        public double TakeProfitATRMultiplier { get; set; }

        [Parameter("Stop Loss (pips)", DefaultValue = 75)]
        public int StopLossPips { get; set; }

        [Parameter("Max Lot Size", DefaultValue = 2.0, MinValue = 0.01)]
        public double MaxLotSize { get; set; }

        [Parameter("Max Equity Drawdown", DefaultValue = 0.04, MinValue = 0.01, MaxValue = 0.5)]
        public double MaxEquityDrawdown { get; set; }

        [Parameter("Allow Multiple Trades", DefaultValue = true)]
        public bool AllowMultipleTradesEnabled { get; set; }

        private MovingAverage fastMA;
        private MovingAverage slowMA;
        private double peakEquity = 0;
        private bool canTrade = true; // Flag to control multiple trades

        protected override void OnStart()
        {
            try
            {
                fastMA = Indicators.MovingAverage(Bars.ClosePrices, FastMAPeriod, MovingAverageType.Simple);
                slowMA = Indicators.MovingAverage(Bars.ClosePrices, SlowMAPeriod, MovingAverageType.Simple);

                peakEquity = Account.Equity;
            }
            catch (Exception ex)
            {
                Print("Error in OnStart: " + ex.Message);
                LogError("OnStart", ex);
            }
        }

        protected override void OnTick()
        {
            try
            {
                // Update peak equity
                peakEquity = Math.Max(peakEquity, Account.Equity);

                // Calculate drawdown as a percentage of peak equity
                double equityDrawdown = (peakEquity - Account.Equity) / peakEquity;

                // Check if drawdown exceeds the equity threshold
                if (equityDrawdown > MaxEquityDrawdown)
                {
                    // Take action to mitigate drawdown (e.g., pause trading)
                    PauseTrading();
                }
            }
            catch (Exception ex)
            {
                Print("Error in OnTick: " + ex.Message);
                LogError("OnTick", ex);
            }
        }

        protected override void OnBar()
        {
            try
            {
                // Check if there are any open positions or pending orders
                if (!AllowMultipleTradesEnabled && (!canTrade || Positions.Count > 0 || PendingOrders.Count > 0))
                {
                    Print("There are open positions or pending orders. Cannot open new trades.");
                    return;
                }

                double riskAmount = Account.Balance * RiskPercentage;
                double atr = CalculateATR(ATRPeriod);

                double takeProfitPips = atr * TakeProfitATRMultiplier;

                double volumeInUnits = Symbol.QuantityToVolumeInUnits(Math.Min(riskAmount / (StopLossPips * Symbol.PipSize * Symbol.LotSize), MaxLotSize));

                // Moving Average Crossover Strategy
                if (fastMA.Result.Last(1) > slowMA.Result.Last(1) && fastMA.Result.Last(2) <= slowMA.Result.Last(2))
                {
                    if (IsBullishMarket())
                    {
                        double takeProfitPrice = Symbol.Ask + (takeProfitPips * Symbol.PipSize);
                        ExecuteMarketOrder(TradeType.Buy, SymbolName, volumeInUnits, "Buy Order", null, StopLossPips, takeProfitPrice.ToString());
                        canTrade = AllowMultipleTradesEnabled; // Allow multiple trades if set to true
                    }
                }
                else if (fastMA.Result.Last(1) < slowMA.Result.Last(1) && fastMA.Result.Last(2) >= slowMA.Result.Last(2))
                {
                    if (IsBearishMarket())
                    {
                        double takeProfitPrice = Symbol.Bid - (takeProfitPips * Symbol.PipSize);
                        ExecuteMarketOrder(TradeType.Sell, SymbolName, volumeInUnits, "Sell Order", null, StopLossPips, takeProfitPrice.ToString());
                        canTrade = AllowMultipleTradesEnabled; // Allow multiple trades if set to true
                    }
                }
            }
            catch (Exception ex)
            {
                Print("Error in OnBar: " + ex.Message);
                LogError("OnBar", ex);
            }
        }

        private bool IsBullishMarket()
        {
            return Bars.OpenPrices.Last(1) < Bars.ClosePrices.Last(1);
        }

        private bool IsBearishMarket()
        {
            return Bars.OpenPrices.Last(1) > Bars.ClosePrices.Last(1);
        }

        private double CalculateATR(int period)
        {
            try
            {
                double trSum = 0;
                for (int i = 1; i <= period; i++)
                {
                    double tr = Math.Max(Bars.HighPrices[i] - Bars.LowPrices[i], Math.Max(Math.Abs(Bars.HighPrices[i] - Bars.ClosePrices[i - 1]), Math.Abs(Bars.LowPrices[i] - Bars.ClosePrices[i - 1])));
                    trSum += tr;
                }
                return trSum / period;
            }
            catch (Exception ex)
            {
                Print("Error in CalculateATR: " + ex.Message);
                LogError("CalculateATR", ex);
                return 0;
            }
        }

        private void PauseTrading()
        {
            // Implement logic to pause trading (e.g., set a flag to stop placing new trades)
            // You might also consider closing existing positions or reducing position sizes
            Print("Maximum Drawdown is exceeded. Pausing the trading...");
            canTrade = false; // Prevent further trades
        }

        private void LogError(string method, Exception ex)
        {
            // Implement logging to an external file or service for better monitoring
            Print($"{method} error: {ex.Message}");
        }
    }
}