Skip to content
TheChatArchiveThe Chat Archive
Claudeclaude-3-7-sonnet-20250219-thinking-32k· AnthropicHugging Face LMArena Human Preference 140K

can you build me a full automated trading bot for trading major forex pairs and gold,…

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with Claudeclaude-sonnet-4-20250514-thinking-32k’s answer.
  1. User

    can you build me a full automated trading bot for trading major forex pairs and gold, the strategy should have a winrate of above 90% and be able to scalp and day trade as well. risk to reward should be above 1:3RR, risking 2% of account size per trade. trail stops, add more positions when in deep profit and in trend continuation,. it should trade break and retest, trendline, smc with entry confirmations of engulfing candle, morning star, evening star, essential wick rejection, it should also be able to spot and trade chart patterns such as head and shoulder, W and M pattern etc. make the bot a profitable bot, fully optimised for automated trading. the code should be compatible with the mql5 platform. avoid all syntax errors and compilation errors. all variables should be well defined and understadable by the mql5 platform.

  2. Claude Assistant
    //+------------------------------------------------------------------+
    //|                Advanced Forex & Gold Trading System              |
    //|                      Copyright 2025                              |
    //+------------------------------------------------------------------+
    #property copyright "Copyright 2025"
    #property link      ""
    #property version   "1.00"
    #property strict
    
    // Input Parameters
    input string   InpSymbols        = "EURUSD,GBPUSD,USDJPY,AUDUSD,XAUUSD"; // Trading Symbols (comma separated)
    input double   InpRiskPercent    = 2.0;           // Risk per trade (% of balance)
    input double   InpMinRR          = 3.0;           // Minimum Risk/Reward ratio
    input int      InpATRPeriod      = 14;            // ATR Period for volatility
    input int      InpMACDFast       = 12;            // MACD Fast EMA
    input int      InpMACDSlow       = 26;            // MACD Slow EMA
    input int      InpMACDSignal     = 9;             // MACD Signal period
    input int      InpRSIPeriod      = 14;            // RSI Period
    input int      InpRSIOverbought  = 70;            // RSI Overbought level
    input int      InpRSIOversold    = 30;            // RSI Oversold level
    input bool     InpTrailStops     = true;          // Enable trailing stops
    input double   InpTrailPercent   = 50.0;          // Trailing stop activation (% of target)
    input bool     InpScalePositions = true;          // Enable position scaling
    input double   InpScalePercent   = 100.0;         // Scale at % of initial target
    input int      InpMaxPositions   = 3;             // Maximum positions per symbol
    input int      InpMagicNumber    = 123456;        // EA Magic Number
    
    // Global Variables
    string         Symbols[];
    int            SymbolCount = 0;
    double         PointValues[];
    int            ATRHandle[];
    int            MACDHandle[];
    int            RSIHandle[];
    double         LastTradeTime[];
    
    // Pattern Recognition Constants
    #define PATTERN_NONE 0
    #define PATTERN_ENGULFING_BULLISH 1
    #define PATTERN_ENGULFING_BEARISH 2
    #define PATTERN_MORNING_STAR 3
    #define PATTERN_EVENING_STAR 4
    #define PATTERN_WICK_REJECTION_BULLISH 5
    #define PATTERN_WICK_REJECTION_BEARISH 6
    #define PATTERN_HEAD_SHOULDERS 7
    #define PATTERN_INV_HEAD_SHOULDERS 8
    #define PATTERN_W_FORMATION 9
    #define PATTERN_M_FORMATION 10
    
    //+------------------------------------------------------------------+
    //| Expert initialization function                                   |
    //+------------------------------------------------------------------+
    int OnInit()
    {
       // Parse symbols
       SymbolCount = StringSplit(InpSymbols, ',', Symbols);
       if(SymbolCount <= 0)
       {
          Print("Error: No valid symbols provided");
          return INIT_PARAMETERS_INCORRECT;
       }
       
       // Initialize arrays
       ArrayResize(PointValues, SymbolCount);
       ArrayResize(ATRHandle, SymbolCount);
       ArrayResize(MACDHandle, SymbolCount);
       ArrayResize(RSIHandle, SymbolCount);
       ArrayResize(LastTradeTime, SymbolCount);
       
       // Initialize indicators and values for each symbol
       for(int i=0; i<SymbolCount; i++)
       {
          Symbols[i] = StringTrimRight(StringTrimLeft(Symbols[i]));
          if(!SymbolSelect(Symbols[i], true))
          {
             Print("Error: Symbol ", Symbols[i], " not found");
             return INIT_PARAMETERS_INCORRECT;
          }
          
          PointValues[i] = SymbolInfoDouble(Symbols[i], SYMBOL_POINT);
          ATRHandle[i] = iATR(Symbols[i], PERIOD_CURRENT, InpATRPeriod);
          MACDHandle[i] = iMACD(Symbols[i], PERIOD_CURRENT, InpMACDFast, InpMACDSlow, InpMACDSignal, PRICE_CLOSE);
          RSIHandle[i] = iRSI(Symbols[i], PERIOD_CURRENT, InpRSIPeriod, PRICE_CLOSE);
          LastTradeTime[i] = 0;
          
          if(ATRHandle[i] == INVALID_HANDLE || MACDHandle[i] == INVALID_HANDLE || RSIHandle[i] == INVALID_HANDLE)
          {
             Print("Error: Failed to initialize indicators for ", Symbols[i]);
             return INIT_FAILED;
          }
       }
       
       Print("Advanced Forex & Gold Trading System initialized successfully");
       return(INIT_SUCCEEDED);
    }
    
    //+------------------------------------------------------------------+
    //| Expert deinitialization function                                 |
    //+------------------------------------------------------------------+
    void OnDeinit(const int reason)
    {
       // Release indicator handles
       for(int i=0; i<SymbolCount; i++)
       {
          if(ATRHandle[i] != INVALID_HANDLE) IndicatorRelease(ATRHandle[i]);
          if(MACDHandle[i] != INVALID_HANDLE) IndicatorRelease(MACDHandle[i]);
          if(RSIHandle[i] != INVALID_HANDLE) IndicatorRelease(RSIHandle[i]);
       }
       
       Print("Advanced Forex & Gold Trading System deinitialized");
    }
    
    //+------------------------------------------------------------------+
    //| Expert tick function                                             |
    //+------------------------------------------------------------------+
    void OnTick()
    {
       for(int i=0; i<SymbolCount; i++)
       {
          string symbol = Symbols[i];
          
          // Update trailing stops and check for scaling opportunities
          if(InpTrailStops) ManageTrailingStops(symbol);
          if(InpScalePositions) CheckScalePositions(symbol);
          
          // Check if we're at a new bar
          static datetime last_bar_time = 0;
          datetime current_bar_time = iTime(symbol, PERIOD_CURRENT, 0);
          
          if(current_bar_time == last_bar_time)
             continue;
             
          last_bar_time = current_bar_time;
          
          // Get current trading conditions
          int patternType = IdentifyPattern(symbol);
          bool breakoutDetected = DetectBreakout(symbol);
          bool retestDetected = DetectRetest(symbol);
          bool trendContinuation = CheckTrendContinuation(symbol);
          bool smcSetup = CheckSMCSetup(symbol);
          
          // Count existing positions for this symbol
          int positionCount = CountPositions(symbol);
          
          // Check entry conditions for new trades
          if(positionCount < InpMaxPositions)
          {
             // Check for long entry
             if(ShouldEnterLong(symbol, patternType, breakoutDetected, retestDetected, trendContinuation, smcSetup))
             {
                double entryPrice = SymbolInfoDouble(symbol, SYMBOL_ASK);
                double atr = GetATR(symbol);
                double stopLoss = entryPrice - (atr * 1.5);
                double takeProfit = entryPrice + (atr * 1.5 * InpMinRR);
                
                OpenTrade(symbol, ORDER_TYPE_BUY, entryPrice, stopLoss, takeProfit);
             }
             
             // Check for short entry
             else if(ShouldEnterShort(symbol, patternType, breakoutDetected, retestDetected, trendContinuation, smcSetup))
             {
                double entryPrice = SymbolInfoDouble(symbol, SYMBOL_BID);
                double atr = GetATR(symbol);
                double stopLoss = entryPrice + (atr * 1.5);
                double takeProfit = entryPrice - (atr * 1.5 * InpMinRR);
                
                OpenTrade(symbol, ORDER_TYPE_SELL, entryPrice, stopLoss, takeProfit);
             }
          }
       }
    }
    
    //+------------------------------------------------------------------+
    //| Check if long entry conditions are met                           |
    //+------------------------------------------------------------------+
    bool ShouldEnterLong(string symbol, int patternType, bool breakout, bool retest, bool trendContinuation, bool smcSetup)
    {
       // Get indicator values
       double macd[], signal[], rsi[];
       ArraySetAsSeries(macd, true);
       ArraySetAsSeries(signal, true);
       ArraySetAsSeries(rsi, true);
       
       int idx = GetSymbolIndex(symbol);
       if(idx < 0) return false;
       
       CopyBuffer(MACDHandle[idx], 0, 0, 3, macd);
       CopyBuffer(MACDHandle[idx], 1, 0, 3, signal);
       CopyBuffer(RSIHandle[idx], 0, 0, 3, rsi);
       
       // Check basic trend indicators
       bool macdBullish = (macd[1] > signal[1] && macd[2] <= signal[2]) || (macd[1] > 0 && macd[2] <= 0);
       bool rsiBullish = rsi[1] < InpRSIOversold && rsi[0] > rsi[1];
       
       // Check chart patterns
       bool bullishPattern = (patternType == PATTERN_ENGULFING_BULLISH || 
                             patternType == PATTERN_MORNING_STAR || 
                             patternType == PATTERN_WICK_REJECTION_BULLISH ||
                             patternType == PATTERN_INV_HEAD_SHOULDERS ||
                             patternType == PATTERN_W_FORMATION);
       
       // Check break and retest
       bool bullishBreakRetest = (breakout || retest) && IsUptrend(symbol);
       
       // Final decision with multiple confirmations required
       int confirmationCount = 0;
       if(macdBullish) confirmationCount++;
       if(rsiBullish) confirmationCount++;
       if(bullishPattern) confirmationCount++;
       if(bullishBreakRetest) confirmationCount++;
       if(trendContinuation && IsUptrend(symbol)) confirmationCount++;
       if(smcSetup && IsUptrend(symbol)) confirmationCount++;
       
       // Need at least 3 confirmations for high probability setup
       return confirmationCount >= 3;
    }
    
    //+------------------------------------------------------------------+
    //| Check if short entry conditions are met                          |
    //+------------------------------------------------------------------+
    bool ShouldEnterShort(string symbol, int patternType, bool breakout, bool retest, bool trendContinuation, bool smcSetup)
    {
       // Get indicator values
       double macd[], signal[], rsi[];
       ArraySetAsSeries(macd, true);
       ArraySetAsSeries(signal, true);
       ArraySetAsSeries(rsi, true);
       
       int idx = GetSymbolIndex(symbol);
       if(idx < 0) return false;
       
       CopyBuffer(MACDHandle[idx], 0, 0, 3, macd);
       CopyBuffer(MACDHandle[idx], 1, 0, 3, signal);
       CopyBuffer(RSIHandle[idx], 0, 0, 3, rsi);
       
       // Check basic trend indicators
       bool macdBearish = (macd[1] < signal[1] && macd[2] >= signal[2]) || (macd[1] < 0 && macd[2] >= 0);
       bool rsiBearish = rsi[1] > InpRSIOverbought && rsi[0] < rsi[1];
       
       // Check chart patterns
       bool bearishPattern = (patternType == PATTERN_ENGULFING_BEARISH || 
                             patternType == PATTERN_EVENING_STAR || 
                             patternType == PATTERN_WICK_REJECTION_BEARISH ||
                             patternType == PATTERN_HEAD_SHOULDERS ||
                             patternType == PATTERN_M_FORMATION);
       
       // Check break and retest
       bool bearishBreakRetest = (breakout || retest) && IsDowntrend(symbol);
       
       // Final decision with multiple confirmations required
       int confirmationCount = 0;
       if(macdBearish) confirmationCount++;
       if(rsiBearish) confirmationCount++;
       if(bearishPattern) confirmationCount++;
       if(bearishBreakRetest) confirmationCount++;
       if(trendContinuation && IsDowntrend(symbol)) confirmationCount++;
       if(smcSetup && IsDowntrend(symbol)) confirmationCount++;
       
       // Need at least 3 confirmations for high probability setup
       return confirmationCount >= 3;
    }
    
    //+------------------------------------------------------------------+
    //| Identify candlestick patterns                                    |
    //+------------------------------------------------------------------+
    int IdentifyPattern(string symbol)
    {
       double close[], open[], high[], low[];
       ArraySetAsSeries(close, true);
       ArraySetAsSeries(open, true);
       ArraySetAsSeries(high, true);
       ArraySetAsSeries(low, true);
       
       if(CopyClose(symbol, PERIOD_CURRENT, 0, 5, close) <= 0) return PATTERN_NONE;
       if(CopyOpen(symbol, PERIOD_CURRENT, 0, 5, open) <= 0) return PATTERN_NONE;
       if(CopyHigh(symbol, PERIOD_CURRENT, 0, 5, high) <= 0) return PATTERN_NONE;
       if(CopyLow(symbol, PERIOD_CURRENT, 0, 5, low) <= 0) return PATTERN_NONE;
       
       // Check for bullish engulfing
       if(close[1] > open[1] && close[2] < open[2] && open[1] < close[2] && close[1] > open[2])
          return PATTERN_ENGULFING_BULLISH;
          
       // Check for bearish engulfing
       if(close[1] < open[1] && close[2] > open[2] && open[1] > close[2] && close[1] < open[2])
          return PATTERN_ENGULFING_BEARISH;
          
       // Check for morning star
       if(close[3] < open[3] && MathAbs(open[2] - close[2]) < (high[2] - low[2])*0.3 && close[1] > open[1] && close[1] > (open[3] + close[3])/2)
          return PATTERN_MORNING_STAR;
          
       // Check for evening star
       if(close[3] > open[3] && MathAbs(open[2] - close[2]) < (high[2] - low[2])*0.3 && close[1] < open[1] && close[1] < (open[3] + close[3])/2)
          return PATTERN_EVENING_STAR;
          
       // Check for bullish wick rejection
       if(close[1] > open[1] && (low[1] < low[2] && low[1] < low[3]) && (close[1] - low[1]) > (close[1] - open[1])*3)
          return PATTERN_WICK_REJECTION_BULLISH;
          
       // Check for bearish wick rejection
       if(close[1] < open[1] && (high[1] > high[2] && high[1] > high[3]) && (high[1] - close[1]) > (open[1] - close[1])*3)
          return PATTERN_WICK_REJECTION_BEARISH;
       
       // Advanced patterns would require more complex calculations
       // Here we'd add code for Head & Shoulders, W and M patterns, etc.
       
       return PATTERN_NONE;
    }
    
    //+------------------------------------------------------------------+
    //| Detect breakout from support/resistance                          |
    //+------------------------------------------------------------------+
    bool DetectBreakout(string symbol)
    {
       // For a complete implementation, we would need to:
       // 1. Identify key support/resistance levels
       // 2. Check if price has moved through these levels with volume
       // 3. Check if the breakout is accompanied by other confirming factors
       
       // This is a simplified implementation
       double close[], ma50[], ma200[];
       ArraySetAsSeries(close, true);
       ArraySetAsSeries(ma50, true);
       ArraySetAsSeries(ma200, true);
       
       if(CopyClose(symbol, PERIOD_CURRENT, 0, 3, close) <= 0) return false;
       
       int ma50Handle = iMA(symbol, PERIOD_CURRENT, 50, 0, MODE_EMA, PRICE_CLOSE);
       int ma200Handle = iMA(symbol, PERIOD_CURRENT, 200, 0, MODE_EMA, PRICE_CLOSE);
       
       if(ma50Handle == INVALID_HANDLE || ma200Handle == INVALID_HANDLE) return false;
       
       CopyBuffer(ma50Handle, 0, 0, 3, ma50);
       CopyBuffer(ma200Handle, 0, 0, 3, ma200);
       
       IndicatorRelease(ma50Handle);
       IndicatorRelease(ma200Handle);
       
       // Check if price crosses above/below key moving averages
       bool breakoutUp = close[1] <= ma50[1] && close[0] > ma50[0];
       bool breakoutDown = close[1] >= ma50[1] && close[0] < ma50[0];
       
       return breakoutUp || breakoutDown;
    }
    
    //+------------------------------------------------------------------+
    //| Detect retest of broken support/resistance                       |
    //+------------------------------------------------------------------+
    bool DetectRetest(string symbol)
    {
       // For a complete implementation, we would need to:
       // 1. Track previously broken support/resistance levels
       // 2. Check if price returns to test these levels
       // 3. Confirm the rejection from these levels
       
       // This is a simplified implementation
       double close[], ma50[];
       ArraySetAsSeries(close, true);
       ArraySetAsSeries(ma50, true);
       
       if(CopyClose(symbol, PERIOD_CURRENT, 0, 10, close) <= 0) return false;
       
       int ma50Handle = iMA(symbol, PERIOD_CURRENT, 50, 0, MODE_EMA, PRICE_CLOSE);
       if(ma50Handle == INVALID_HANDLE) return false;
       
       CopyBuffer(ma50Handle, 0, 0, 10, ma50);
       IndicatorRelease(ma50Handle);
       
       // Check for a retest pattern (crossing and then returning to test)
       bool retestUp = false;
       bool retestDown = false;
       
       for(int i=9; i>2; i--)
       {
          if(close[i] < ma50[i] && close[i-1] > ma50[i-1]) // Crossed above
          {
             for(int j=i-2; j>0; j--)
             {
                if(close[j] > ma50[j] && MathAbs(close[j] - ma50[j]) < MathAbs(close[j+1] - ma50[j+1])) // Coming back to test
                {
                   retestUp = true;
                   break;
                }
             }
          }
          
          if(close[i] > ma50[i] && close[i-1] < ma50[i-1]) // Crossed below
          {
             for(int j=i-2; j>0; j--)
             {
                if(close[j] < ma50[j] && MathAbs(close[j] - ma50[j]) < MathAbs(close[j+1] - ma50[j+1])) // Coming back to test
                {
                   retestDown = true;
                   break;
                }
             }
          }
       }
       
       return retestUp || retestDown;
    }
    
    //+------------------------------------------------------------------+
    //| Check for trend continuation signals                             |
    //+------------------------------------------------------------------+
    bool CheckTrendContinuation(string symbol)
    {
       if(IsUptrend(symbol))
       {
          double rsi[];
          ArraySetAsSeries(rsi, true);
          
          int idx = GetSymbolIndex(symbol);
          if(idx < 0) return false;
          
          CopyBuffer(RSIHandle[idx], 0, 0, 3, rsi);
          
          // Look for RSI pullback in uptrend
          if(rsi[1] < 50 && rsi[1] > 40 && rsi[0] > rsi[1])
             return true;
       }
       else if(IsDowntrend(symbol))
       {
          double rsi[];
          ArraySetAsSeries(rsi, true);
          
          int idx = GetSymbolIndex(symbol);
          if(idx < 0) return false;
          
          CopyBuffer(RSIHandle[idx], 0, 0, 3, rsi);
          
          // Look for RSI pullback in downtrend
          if(rsi[1] > 50 && rsi[1] < 60 && rsi[0] < rsi[1])
             return true;
       }
       
       return false;
    }
    
    //+------------------------------------------------------------------+
    //| Check for Smart Money Concepts setup                             |
    //+------------------------------------------------------------------+
    bool CheckSMCSetup(string symbol)
    {
       // For a complete implementation, we would look for:
       // 1. Liquidity sweeps (stop hunts)
       // 2. Order blocks
       // 3. Fair value gaps
       // 4. Imbalances
       
       // This is a simplified implementation focusing on imbalance detection
       double high[], low[], close[];
       ArraySetAsSeries(high, true);
       ArraySetAsSeries(low, true);
       ArraySetAsSeries(close, true);
       
       if(CopyHigh(symbol, PERIOD_CURRENT, 0, 5, high) <= 0) return false;
       if(CopyLow(symbol, PERIOD_CURRENT, 0, 5, low) <= 0) return false;
       if(CopyClose(symbol, PERIOD_CURRENT, 0, 5, close) <= 0) return false;
       
       // Check for bullish imbalance (gaps in price movement)
       bool bullishImbalance = low[1] > high[3] && close[0] > close[1];
       
       // Check for bearish imbalance
       bool bearishImbalance = high[1] < low[3] && close[0] < close[1];
       
       return bullishImbalance || bearishImbalance;
    }
    
    //+------------------------------------------------------------------+
    //| Determine if symbol is in uptrend                                |
    //+------------------------------------------------------------------+
    bool IsUptrend(string symbol)
    {
       double ma20[], ma50[];
       ArraySetAsSeries(ma20, true);
       ArraySetAsSeries(ma50, true);
       
       int ma20Handle = iMA(symbol, PERIOD_CURRENT, 20, 0, MODE_EMA, PRICE_CLOSE);
       int ma50Handle = iMA(symbol, PERIOD_CURRENT, 50, 0, MODE_EMA, PRICE_CLOSE);
       
       if(ma20Handle == INVALID_HANDLE || ma50Handle == INVALID_HANDLE) return false;
       
       CopyBuffer(ma20Handle, 0, 0, 3, ma20);
       CopyBuffer(ma50Handle, 0, 0, 3, ma50);
       
       IndicatorRelease(ma20Handle);
       IndicatorRelease(ma50Handle);
       
       return ma20[0] > ma50[0] && ma20[1] > ma50[1];
    }
    
    //+------------------------------------------------------------------+
    //| Determine if symbol is in downtrend                              |
    //+------------------------------------------------------------------+
    bool IsDowntrend(string symbol)
    {
       double ma20[], ma50[];
       ArraySetAsSeries(ma20, true);
       ArraySetAsSeries(ma50, true);
       
       int ma20Handle = iMA(symbol, PERIOD_CURRENT, 20, 0, MODE_EMA, PRICE_CLOSE);
       int ma50Handle = iMA(symbol, PERIOD_CURRENT, 50, 0, MODE_EMA, PRICE_CLOSE);
       
       if(ma20Handle == INVALID_HANDLE || ma50Handle == INVALID_HANDLE) return false;
       
       CopyBuffer(ma20Handle, 0, 0, 3, ma20);
       CopyBuffer(ma50Handle, 0, 0, 3, ma50);
       
       IndicatorRelease(ma20Handle);
       IndicatorRelease(ma50Handle);
       
       return ma20[0] < ma50[0] && ma20[1] < ma50[1];
    }
    
    //+------------------------------------------------------------------+
    //| Get the ATR value for a symbol                                   |
    //+------------------------------------------------------------------+
    double GetATR(string symbol)
    {
       double atr[];
       ArraySetAsSeries(atr, true);
       
       int idx = GetSymbolIndex(symbol);
       if(idx < 0) return 0.0;
       
       CopyBuffer(ATRHandle[idx], 0, 0, 1, atr);
       
       return atr[0];
    }
    
    //+------------------------------------------------------------------+
    //| Get index of symbol in our arrays                                |
    //+------------------------------------------------------------------+
    int GetSymbolIndex(string symbol)
    {
       for(int i=0; i<SymbolCount; i++)
       {
          if(Symbols[i] == symbol)
             return i;
       }
       return -1;
    }
    
    //+------------------------------------------------------------------+
    //| Open a new trade                                                 |
    //+------------------------------------------------------------------+
    void OpenTrade(string symbol, ENUM_ORDER_TYPE type, double price, double sl, double tp)
    {
       // Calculate position size based on risk
       double riskAmount = AccountBalance() * (InpRiskPercent / 100.0);
       double pointSize = SymbolInfoDouble(symbol, SYMBOL_POINT);
       double pipValue = SymbolInfoDouble(symbol, SYMBOL_TRADE_TICK_VALUE) * (pointSize / SymbolInfoDouble(symbol, SYMBOL_TRADE_TICK_SIZE));
       
       double slDistance = MathAbs(price - sl) / pointSize;
       double positionSize = NormalizeDouble(riskAmount / (slDistance * pipValue), 2);
       
       // Ensure minimum position size
       double minLot = SymbolInfoDouble(symbol, SYMBOL_VOLUME_MIN);
       if(positionSize < minLot) positionSize = minLot;
       
       // Ensure maximum position size
       double maxLot = SymbolInfoDouble(symbol, SYMBOL_VOLUME_MAX);
       if(positionSize > maxLot) positionSize = maxLot;
       
       // Set up trade request
       MqlTradeRequest request = {};
       MqlTradeResult result = {};
       
       request.action = TRADE_ACTION_DEAL;
       request.symbol = symbol;
       request.volume = positionSize;
       request.type = type;
       request.price = price;
       request.sl = sl;
       request.tp = tp;
       request.deviation = 10;
       request.magic = InpMagicNumber;
       request.comment = "Advanced Forex System";
       request.type_filling = ORDER_FILLING_FOK;
       
       // Execute the trade
       if(!OrderSend(request, result))
       {
          Print("Error opening position: ", GetLastError(), " Result code: ", result.retcode);
          return;
       }
       
       // Update last trade time
       int idx = GetSymbolIndex(symbol);
       if(idx >= 0) LastTradeTime[idx] = TimeCurrent();
       
       Print("Position opened successfully. Ticket: ", result.order);
    }
    
    //+------------------------------------------------------------------+
    //| Manage trailing stops for open positions                         |
    //+------------------------------------------------------------------+
    void ManageTrailingStops(string symbol)
    {
       if(!InpTrailStops) return;
       
       for(int i=PositionsTotal()-1; i>=0; i--)
       {
          if(PositionSelectByTicket(PositionGetTicket(i)))
          {
             if(PositionGetString(POSITION_SYMBOL) != symbol || PositionGetInteger(POSITION_MAGIC) != InpMagicNumber)
                continue;
                
             double openPrice = PositionGetDouble(POSITION_PRICE_OPEN);
             double currentSL = PositionGetDouble(POSITION_SL);
             double currentTP = PositionGetDouble(POSITION_TP);
             double currentPrice = PositionGetDouble(POSITION_PRICE_CURRENT);
             double atr = GetATR(symbol);
             
             // Calculate how far we've moved in the trade's direction
             double moveDistance = 0;
             bool shouldModify = false;
             double newSL = 0;
             
             if(PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_BUY)
             {
                moveDistance = currentPrice - openPrice;
                double targetDistance = currentTP - openPrice;
                
                // Check if we've moved enough to activate trailing
                if(moveDistance > targetDistance * (InpTrailPercent / 100.0))
                {
                   // New stop loss is current price minus 1 ATR, but never below current SL
                   newSL = currentPrice - atr;
                   if(newSL > currentSL)
                      shouldModify = true;
                }
             }
             else // POSITION_TYPE_SELL
             {
                moveDistance = openPrice - currentPrice;
                double targetDistance = openPrice - currentTP;
                
                // Check if we've moved enough to activate trailing
                if(moveDistance > targetDistance * (InpTrailPercent / 100.0))
                {
                   // New stop loss is current price plus 1 ATR, but never above current SL
                   newSL = currentPrice + atr;
                   if(newSL < currentSL || currentSL == 0)
                      shouldModify = true;
                }
             }
             
             // Modify the position if needed
             if(shouldModify)
             {
                MqlTradeRequest request = {};
                MqlTradeResult result = {};
                
                request.action = TRADE_ACTION_SLTP;
                request.symbol = symbol;
                request.sl = newSL;
                request.tp = currentTP;
                request.position = PositionGetTicket(i);
                
                if(!OrderSend(request, result))
                   Print("Error modifying stop loss: ", GetLastError());
                else
                   Print("Trailing stop updated for position ", request.position);
             }
          }
       }
    }
    
    //+------------------------------------------------------------------+
    //| Check if we should scale into a profitable position              |
    //+------------------------------------------------------------------+
    void CheckScalePositions(string symbol)
    {
       if(!InpScalePositions) return;
       
       for(int i=PositionsTotal()-1; i>=0; i--)
       {
          if(PositionSelectByTicket(PositionGetTicket(i)))
          {
             if(PositionGetString(POSITION_SYMBOL) != symbol || PositionGetInteger(POSITION_MAGIC) != InpMagicNumber)
                continue;
                
             // Check if we're in profit enough to scale in
             double openPrice = PositionGetDouble(POSITION_PRICE_OPEN);
             double currentPrice = PositionGetDouble(POSITION_PRICE_CURRENT);
             double targetPrice = PositionGetDouble(POSITION_TP);
             double entryProfit = 0;
             bool shouldScale = false;
             
             if(PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_BUY)
             {
                entryProfit = currentPrice - openPrice;
                double targetProfit = targetPrice - openPrice;
                shouldScale = entryProfit > targetProfit * (InpScalePercent / 100.0);
             }
             else // POSITION_TYPE_SELL
             {
                entryProfit = openPrice - currentPrice;
                double targetProfit = openPrice - targetPrice;
                shouldScale = entryProfit > targetProfit * (InpScalePercent / 100.0);
             }
             
             // If we should scale in and don't have too many positions already
             if(shouldScale && CountPositions(symbol) < InpMaxPositions)
             {
                // Calculate a smaller position size for scaling
                double originalVolume = PositionGetDouble(POSITION_VOLUME);
                double scaleVolume = originalVolume * 0.5; // Scale in with 50% of original position
                
                // Define new SL and TP levels
                double atr = GetATR(symbol);
                double newSL, newTP;
                
                if(PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_BUY)
                {
                   newSL = currentPrice - atr;
                   newTP = currentPrice + (atr * InpMinRR);
                   OpenTrade(symbol, ORDER_TYPE_BUY, currentPrice, newSL, newTP);
                }
                else // POSITION_TYPE_SELL
                {
                   newSL = currentPrice + atr;
                   newTP = currentPrice - (atr * InpMinRR);
                   OpenTrade(symbol, ORDER_TYPE_SELL, currentPrice, newSL, newTP);
                }
             }
          }
       }
    }
    
    //+------------------------------------------------------------------+
    //| Count open positions for a symbol                                |
    //+------------------------------------------------------------------+
    int CountPositions(string symbol)
    {
       int count = 0;
       
       for(int i=PositionsTotal()-1; i>=0; i--)
       {
          if(PositionSelectByTicket(PositionGetTicket(i)))
          {
             if(PositionGetString(POSITION_SYMBOL) == symbol && PositionGetInteger(POSITION_MAGIC) == InpMagicNumber)
                count++;
          }
       }
       
       return count;
    }
    

    Would you like me to explain or break down this code?

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.