ProAutoSL DynamicTP-Institutional Risk Manager - MetaTrader 5용 expert

//+------------------------------------------------------------------+

//| ProAutoSL_DynamicTP.mq5                                         |

//| Copyright 2026, Khaled - Quant Developer                        |

//| https://www.mql5.com/en/users/bjmkhaled                         |

//+------------------------------------------------------------------+

#property copyright "Khaled - Quant Developer"

#property link      "https://www.mql5.com/en/users/bjmkhaled"

#property version   "2.10"

#property description "Automatic SL/TP manager for open positions."

#property description "Supports symbol, magic number and comment filtering."

#property description "Uses broker stop-level protection and retry logic."

#include <Trade\Trade.mqh>

//--- Trade object used for position modifications

CTrade trade;

//--- Filter settings

input string InpFilterSettings      = "--- Filter Settings ---"; // Filter settings

input long   InpMagicNumber         = -1;                        // Magic number (-1 = all positions)

input string InpFilterComment       = "";                        // Comment filter (empty = ignore)

input bool   InpModifyManualTrades  = true;                       // Manage manual trades (magic = 0)

//--- Stop Loss settings

input string InpStopLossSettings    = "--- Stop Loss Settings ---"; // Stop Loss settings

input double InpStopLossPips        = 30.0;                         // Stop Loss distance in pips

//--- Take Profit settings

input string InpTakeProfitSettings  = "--- Take Profit Settings ---"; // Take Profit settings

input bool   InpUseDynamicTP        = true;                            // Calculate TP from SL and multiplier

input double InpRiskRewardMultiplier= 2.0;                             // Risk-to-reward multiplier

input double InpFixedTakeProfitPips = 60.0;                            // Fixed Take Profit distance in pips

//--- Execution settings

input string InpExecutionSettings   = "--- Execution Settings ---"; // Execution settings

input int    InpMaxRetries          = 5;                              // Maximum modification attempts

input int    InpRetryDelayMs        = 1000;                           // Delay between retry attempts in milliseconds

//+------------------------------------------------------------------+

//| Expert initialization function                                   |

//+------------------------------------------------------------------+

int OnInit()

  {

//--- Validate user inputs before starting the timer

   if(InpStopLossPips < 0.0)

     {

      Print("Initialization failed: Stop Loss pips cannot be negative.");

      return(INIT_PARAMETERS_INCORRECT);

     }

   if(InpFixedTakeProfitPips < 0.0)

     {

      Print("Initialization failed: fixed Take Profit pips cannot be negative.");

      return(INIT_PARAMETERS_INCORRECT);

     }

   if(InpUseDynamicTP && InpRiskRewardMultiplier < 0.0)

     {

      Print("Initialization failed: risk-to-reward multiplier cannot be negative.");

      return(INIT_PARAMETERS_INCORRECT);

     }

   if(InpMaxRetries < 1 || InpRetryDelayMs < 0)

     {

      Print("Initialization failed: invalid retry settings.");

      return(INIT_PARAMETERS_INCORRECT);

     }

//--- Use a one-second timer to scan positions independently of tick flow

   if(!EventSetTimer(1))

     {

      PrintFormat("Initialization failed: EventSetTimer error %d.",GetLastError());

      return(INIT_FAILED);

     }

//--- Use synchronous trade operations for deterministic result handling

   trade.SetAsyncMode(false);

   return(INIT_SUCCEEDED);

  }

//+------------------------------------------------------------------+

//| Expert deinitialization function                                 |

//+------------------------------------------------------------------+

void OnDeinit(const int reason)

  {

//--- Release the timer when the expert is removed or reinitialized

   EventKillTimer();

  }

//+------------------------------------------------------------------+

//| Expert tick function                                             |

//+------------------------------------------------------------------+

void OnTick()

  {

//--- Position management is timer-driven by design

  }

//+------------------------------------------------------------------+

//| Expert timer function                                            |

//+------------------------------------------------------------------+

void OnTimer()

  {

//--- Process only positions belonging to the chart symbol

   ManageSymbolPositions(_Symbol);

  }

//+------------------------------------------------------------------+

//| Manage all eligible positions for a symbol                       |

//+------------------------------------------------------------------+

void ManageSymbolPositions(const string symbol)

  {

//--- Obtain current market data before calculating protection levels

   MqlTick tick;

   if(!SymbolInfoTick(symbol,tick))

     {

      PrintFormat("Unable to obtain tick data for %s. Error %d.",symbol,GetLastError());

      return;

     }

   const double point=SymbolInfoDouble(symbol,SYMBOL_POINT);

   const int    digits=(int)SymbolInfoInteger(symbol,SYMBOL_DIGITS);

   if(point<=0.0 || digits<0)

      return;

//--- Convert pips to points and include the broker's spread in dynamic TP

   const double pip_factor=((digits==3 || digits==5) ? 10.0 : 1.0);

   const double spread_points=(tick.ask-tick.bid)/point;

   const double stop_loss_points=InpStopLossPips*pip_factor;

   const double take_profit_points=(InpUseDynamicTP

                                    ? (stop_loss_points*InpRiskRewardMultiplier)+spread_points

                                    : InpFixedTakeProfitPips*pip_factor);

//--- Determine the broker's minimum distance for SL and TP

   const long stop_level_points=SymbolInfoInteger(symbol,SYMBOL_TRADE_STOPS_LEVEL);

   const long freeze_level_points=SymbolInfoInteger(symbol,SYMBOL_TRADE_FREEZE_LEVEL);

   const double minimum_distance=MathMax((double)stop_level_points,

                                         (double)freeze_level_points)*point;

//--- Iterate backwards because the position collection can change

   for(int index=PositionsTotal()-1; index>=0; index--)

     {

      const ulong ticket=PositionGetTicket(index);

      if(ticket==0)

         continue;

      //--- PositionGetTicket selects the position for subsequent queries

      if(PositionGetString(POSITION_SYMBOL)!=symbol)

         continue;

      if(!IsPositionEligible())

         continue;

      ApplyProtection(ticket,

                      symbol,

                      tick,

                      digits,

                      point,

                      minimum_distance,

                      stop_loss_points,

                      take_profit_points);

     }

  }

//+------------------------------------------------------------------+

//| Check symbol, magic number and comment filters                   |

//+------------------------------------------------------------------+

bool IsPositionEligible()

  {

//--- Apply the magic-number filter when it is not set to all trades

   const long position_magic=PositionGetInteger(POSITION_MAGIC);

   if(InpMagicNumber!=-1 && position_magic!=InpMagicNumber)

      return(false);

//--- Optionally exclude manually opened positions

   if(!InpModifyManualTrades && position_magic==0)

      return(false);

//--- Apply a case-sensitive partial comment filter when requested

   if(InpFilterComment!="")

     {

      const string position_comment=PositionGetString(POSITION_COMMENT);

      if(StringFind(position_comment,InpFilterComment)<0)

         return(false);

     }

   return(true);

  }

//+------------------------------------------------------------------+

//| Calculate and apply missing SL and TP levels                     |

//+------------------------------------------------------------------+

void ApplyProtection(const ulong ticket,

                     const string symbol,

                     const MqlTick &tick,

                     const int digits,

                     const double point,

                     const double minimum_distance,

                     const double stop_loss_points,

                     const double take_profit_points)

  {

   const long position_type=PositionGetInteger(POSITION_TYPE);

   const double open_price=PositionGetDouble(POSITION_PRICE_OPEN);

   const double current_sl=PositionGetDouble(POSITION_SL);

   const double current_tp=PositionGetDouble(POSITION_TP);

//--- Preserve existing protection and modify only missing levels

   double new_sl=current_sl;

   double new_tp=current_tp;

   bool needs_modification=false;

   if(position_type==POSITION_TYPE_BUY)

     {

      //--- Calculate a valid Buy Stop Loss below the current Bid

      if(current_sl<=0.0 && stop_loss_points>0.0)

        {

         new_sl=open_price-(stop_loss_points*point);

         if(minimum_distance>0.0 && tick.bid-new_sl<minimum_distance)

            new_sl=tick.bid-minimum_distance;

         needs_modification=true;

        }

      //--- Calculate a valid Buy Take Profit above the current Bid

      if(current_tp<=0.0 && take_profit_points>0.0)

        {

         new_tp=open_price+(take_profit_points*point);

         if(minimum_distance>0.0 && new_tp-tick.bid<minimum_distance)

            new_tp=tick.bid+minimum_distance;

         needs_modification=true;

        }

     }

   else

      if(position_type==POSITION_TYPE_SELL)

        {

         //--- Calculate a valid Sell Stop Loss above the current Ask

         if(current_sl<=0.0 && stop_loss_points>0.0)

           {

            new_sl=open_price+(stop_loss_points*point);

            if(minimum_distance>0.0 && new_sl-tick.ask<minimum_distance)

               new_sl=tick.ask+minimum_distance;

            needs_modification=true;

           }

         //--- Calculate a valid Sell Take Profit below the current Ask

         if(current_tp<=0.0 && take_profit_points>0.0)

           {

            new_tp=open_price-(take_profit_points*point);

            if(minimum_distance>0.0 && tick.ask-new_tp<minimum_distance)

               new_tp=tick.ask-minimum_distance;

            needs_modification=true;

           }

        }

   if(!needs_modification)

      return;

//--- Normalize prices according to the symbol precision

   if(new_sl>0.0)

      new_sl=NormalizeDouble(new_sl,digits);

   if(new_tp>0.0)

      new_tp=NormalizeDouble(new_tp,digits);

//--- Submit the modification with controlled retry handling

   ModifyPositionWithRetry(ticket,new_sl,new_tp);

  }

//+------------------------------------------------------------------+

//| Modify a position and retry transient trade-server errors        |

//+------------------------------------------------------------------+

bool ModifyPositionWithRetry(const ulong ticket,

                             const double stop_loss,

                             const double take_profit)

  {

   for(int attempt=1; attempt<=InpMaxRetries; attempt++)

     {

      ResetLastError();

      if(trade.PositionModify(ticket,stop_loss,take_profit))

        {

         PrintFormat("Position #%I64u modified successfully. SL=%G TP=%G.",

                     ticket,stop_loss,take_profit);

         return(true);

        }

      const uint retcode=trade.ResultRetcode();

      PrintFormat("Position #%I64u modification attempt %d/%d failed. Retcode=%u (%s).",

                  ticket,attempt,InpMaxRetries,retcode,trade.ResultRetcodeDescription());

      //--- Retry only errors that can be transient during execution

      if(!IsRetriableTradeRetcode(retcode))

         return(false);

      if(attempt<InpMaxRetries && InpRetryDelayMs>0)

         Sleep(InpRetryDelayMs);

     }

   PrintFormat("Position #%I64u could not be modified after %d attempts.",

               ticket,InpMaxRetries);

   return(false);

  }

//+------------------------------------------------------------------+

//| Identify transient trade-server return codes                     |

//+------------------------------------------------------------------+

bool IsRetriableTradeRetcode(const uint retcode)

  {

//--- Requote, price change, off quotes, timeout and connection errors

   return(retcode==TRADE_RETCODE_REQUOTE       ||

          retcode==TRADE_RETCODE_PRICE_CHANGED ||

          retcode==TRADE_RETCODE_PRICE_OFF     ||

          retcode==TRADE_RETCODE_TIMEOUT       ||

          retcode==TRADE_RETCODE_CONNECTION);

  }

//+------------------------------------------------------------------+

//--- Filter Settings

input string   s0 = "--- Filter Settings ---";

input long     MagicNumber = -1;          // Magic Number (-1 = All trades )

input string   FilterComment = "";        // Comment Filter (Leave empty to ignore)

input bool     ModifyManualTrades = true; // Modify manual trades (Magic = 0)?

//--- Stop Loss Settings

input string   s1 = "--- Stop Loss Settings ---";

input double   StopLossPips = 30.0;       // Stop Loss (in Pips)

//--- Take Profit Settings

input string   s2 = "--- Take Profit Settings ---";

input bool     UseDynamicTP = true;       // Enable: TP = (SL * X) + Spread

input double   MultiplierX = 2.0;         // Profit Multiplier (X)

input double   FixedTakeProfitPips = 60.0;// Fixed Take Profit (in Pips)