MQLArticles/RM/RiskManagement.mqh

<EFBFBD><EFBFBD>//+------------------------------------------------------------------+

//|                                               RiskManagement.mqh |

//|                                  Copyright 2025, Niquel Mendoza. |

//|                     https://www.mql5.com/es/users/nique_372/news |

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

#property copyright "Copyright 2025, Niquel Mendoza."

#property link      "https://www.mql5.com/es/users/nique_372/news"

#property strict



#ifndef MQLARTICLES_RM_RISKMANAGEMENT_MQH

#define MQLARTICLES_RM_RISKMANAGEMENT_MQH



#include "RM_Hooks.mqh"



/*

ADVERTENCIA al momeneto de a<EFBFBD>adir items a esta clase, esta si son dinamicos las eliminara cuidado, como un modificador.

WARNING when adding items to this class, if they are dynamic, it will remove them carefully, as a modifier.

*/



//open_positions

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

//| Clase Base CRiskManagement                                       |

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

class CRiskManagemet : public CRiskManagemetBase

 {

protected:

  //---

  CGetLote*          get_lote;



  //---

  double             chosen_balance;



  //--- Extra Variables

  ENUM_GET_LOT       type_get_lot;



  //-- main variables

  long               StopLoss; //StopLoss

  double             lote; //Last recorded lot



  //--- variables to store the values of the maximum losses

  double             nmlpo; //last expected loss

  bool               is_init; //flag indicating if it is init



  //--- variables that store percentages and enumeration, which will be used for the subsequent calculation of losses

  CLossProfitManager* loss_profits_manager;



  //--- Modifiers

  CRiskManagemeHookManager* m_hooks;

  bool               isCachedModifier[LOSS_PROFIT_COUNT];



  //--- general function to assign values to loss variables

  virtual double     GetValorWithApplied(double percentage_, int type, ENUM_APPLIED_PERCENTAGES applied) const override;



  //--- Update profits function

  void               UpdateProfit(const double &profit, const double& acc_total_profit);

  virtual void       OnOpenTrade() { }

  virtual void       OnCloseTrade() { }



  //---

  virtual FuncionLossProfitSuperate SuperateModeToFunctionProfit(ENUM_TYPE_LOSS_PROFIT type) const;

  virtual FuncionLossProfitSuperate SuperateModeToFunctionLoss(ENUM_TYPE_LOSS_PROFIT type) const;



  //---

  virtual void*      GetPtrLossProfits() { return &this; }





public:

  //--- Constructor and Destructor

                     CRiskManagemet(const ulong& _magic, const ENUM_GET_LOT& type_get_lot_, const bool& is_global);

                    ~CRiskManagemet();



  //--- Set

  void               EndAddProfitLoss();

  virtual void       SetGeneralParameters(MqlParam &params[]) = 0;

  void               SetLote(CGetLote* lote_ptr);

  inline void        SetStopLoss(double dist_open_sl) { this.StopLoss = (long)ConvertPriceToPoints(_Symbol, dist_open_sl);  }

  inline void        SetStopLoss(long _sl_point_)     { this.StopLoss = _sl_point_;                                         }



  //--- Get losses and profits

  const CLossProfit* const GetLossOrProfit(const ENUM_TYPE_LOSS_PROFIT _type) const { return loss_profits_manager[_type]; }



  //--- Superated funcionts

  const CLossProfitManager* GetLossProfitManager() const { return loss_profits_manager; }



  //--- Add

  // Modificators

  bool               AddModificator(CExtraModifications* modificator); // Modificator pointer

  __forceinline bool AddModificator(CExtraModifications  &modificator) { return AddModificator(&modificator); }



  // Hook

  bool               AddRmHook(IRiskManagementHook* hook);

  __forceinline bool AddRmHook(IRiskManagementHook& hook) { return AddRmHook(&hook); }



  // Loss



  bool               AddLoss(double _percentage, ENUM_APPLIED_PERCENTAGES _applied, ENUM_RISK_CALCULATION_MODE _mode, ENUM_TYPE_LOSS_PROFIT type, bool strict,

                             bool is_dynamic = false, string percentages_to_activate = NULL, string risks_to_be_applied = NULL); // Loss



  // Profit

  bool               AddProfit(double _percentage, ENUM_APPLIED_PERCENTAGES _applied, ENUM_RISK_CALCULATION_MODE _mode, ENUM_TYPE_LOSS_PROFIT type, bool is_strict_,

                               bool is_dynamic = false, string percentages_to_activate = NULL, string risks_to_be_applied = NULL); // Profit



  //--- Functions inherited from CAccountGestor

  // Basic events

  void               OnNewDay(const datetime& curr_time) override;

  void               OnNewWeek(const datetime& curr_time) override;

  void               OnNewMonth(const datetime& curr_time) override;



  // Account status

  void               OnNewProfit(const ROnOpenClosePosition &profit, const datetime& curr_time) override;

  void               OnOpenClosePosition(const ROnOpenClosePosition &pos) override;

  void               OnWithdrawalDeposit(const double& value) override;

  void               OnInitNewPos(const ROnOpenClosePosition &position) override;



  //--- Get the lot using GMPLO and type_get_lot

  double             GetLote(ENUM_ORDER_TYPE type, double entry_price, ulong deviation, ulong stop_limit);



  //--- Obtain the SL by risk per operation

  long               GetSL(ENUM_ORDER_TYPE type, double entry_price, ulong deviation, ulong stop_limit);



  //--- Functions for working with the get lot size mod

  void                TypeGetLot(ENUM_GET_LOT new_get_mode) { this.type_get_lot = new_get_mode; }

  inline ENUM_GET_LOT TypeGetLot() const  { return this.type_get_lot; }



  //--- Magic number

  inline ulong       MagicNumber() const { return this.magic_number; }





  //--- Risk management type

  virtual inline ENUM_MODE_RISK_MANAGEMENT ModeRiskManagement() const = 0;

 };





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

//| Constructor                                                      |

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

CRiskManagemet::CRiskManagemet(const ulong& _magic, const ENUM_GET_LOT& type_get_lot_, const bool& is_global)

  :                CRiskManagemetBase(_magic, is_global)

 {



//---

  this.chosen_balance = AccountInfoDouble(ACCOUNT_BALANCE);

  for(int i = 0 ; i < LOSS_PROFIT_COUNT; i++)

   {

    isCachedModifier[i] = false;

   }



//---

  const bool ac_i = account_status.IsInitialized();



//--- Registramos la clase para recibir eventos

// Basicos

  CBasicEvents::Register(&this, BASICEVENT_REG_ALL_FLAG); // OnNewDay, Week, Month



// Para trabajar con las posiciones

  account_status.RegisterEvents(&this,

                                (ACCOUNT_STATUS_REG_FLAG_ON_OPEN_CLOSE_POSITION |

                                 ACCOUNT_STATUS_REG_FLAG_ON_WITHDRAWAL_DEPOSIT |

                                 ACCOUNT_STATUS_REG_FLAG_ON_NEW_PROFIT |

                                 (ac_i ? 0 : ACCOUNT_STATUS_REG_FLAG_ON_INIT_NEW_POS)

                                ));





//---

  this.type_get_lot = type_get_lot_;



//---

  loss_profits_manager = new CLossProfitManager(is_global); // Le pasamos is_global

  m_hooks = new CRiskManagemeHookManager();



//---

  AddLogger(loss_profits_manager, true); // Si pertenece..

  AddLogger(m_hooks, false);



//---

  if(ac_i) // Se crea luego de que se inicie

   {

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

     {

      ulong position_ticket = PositionGetTicket(i);

      if(!PositionSelectByTicket(position_ticket))

        continue;



      ulong position_magic = PositionGetInteger(POSITION_MAGIC);

      ENUM_POSITION_TYPE type = (ENUM_POSITION_TYPE)PositionGetInteger(POSITION_TYPE);



      if(position_magic == _magic || _magic == NOT_MAGIC_NUMBER)

       {

        Position new_pos;

        new_pos.type = (ENUM_POSITION_TYPE)PositionGetInteger(POSITION_TYPE);

        new_pos.ticket = position_ticket;

        new_pos.profit = GetTotalPositionProfitNoCurrent(new_pos.ticket);

        new_pos.magic = _magic;

        AddArrayNoVerification2(open_positions, new_pos, RISK_MANAGEMENT_RESERVE_POS)

       }

     }

   }

 }



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

//| Destructor                                                       |

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

CRiskManagemet::~CRiskManagemet()

 {

//---

  CleanItems("RiskManagement");



//---  Solo desregistrase si no es global (se elimina antes)

  if(!m_is_global)

   {

    //--- Registramos la clase para recibir eventos

    // Basicos

    CBasicEvents::Unregister(&this, BASICEVENT_REG_ALL_FLAG); // OnNewDay, Week, Month



    // Para trabajar con las posiciones

    account_status.UnregisterEvents(&this,

                                    (ACCOUNT_STATUS_REG_FLAG_ON_OPEN_CLOSE_POSITION |

                                     ACCOUNT_STATUS_REG_FLAG_ON_WITHDRAWAL_DEPOSIT |

                                     ACCOUNT_STATUS_REG_FLAG_ON_NEW_PROFIT |

                                     ACCOUNT_STATUS_REG_FLAG_ON_INIT_NEW_POS)

                                   );

   }

 }





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

//|                                                                  |

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

void CRiskManagemet::OnInitNewPos(const ROnOpenClosePosition &position)

 {

  if(position.position.magic == this.magic_number || this.magic_number  == NOT_MAGIC_NUMBER)

   {

    AddArrayNoVerification2(open_positions, position.position, RISK_MANAGEMENT_RESERVE_POS)

   }

 }



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

//| Function to check if the maximum profit per day was exceeded     |

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

__forceinline bool RiskMNormal_IsSuperatedProfit(const double& value, const double& saved_value, void* ptr)

 {

  return (account_status_curr_profit > value);

 }



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

//| Boolean function to check if a loss was overcome                 |

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

__forceinline bool RiskMNormal_IsSuperatedLoss(const double& value, const double& saved_value, void* ptr)

 {

  return (-account_status_curr_profit) > value;

 }



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

//| Funciones para obtener el tipo de fucnion a superar              |

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

FuncionLossProfitSuperate CRiskManagemet::SuperateModeToFunctionProfit(ENUM_TYPE_LOSS_PROFIT type) const

 {

  return RiskMNormal_IsSuperatedProfit;

 }



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

// Si es GMLPO empty

FuncionLossProfitSuperate CRiskManagemet::SuperateModeToFunctionLoss(ENUM_TYPE_LOSS_PROFIT type) const

 {

  return type == LP_GMLPO ? (FuncionLossProfitSuperate)LossProfitEmptyFuncionSup : (FuncionLossProfitSuperate)RiskMNormal_IsSuperatedLoss;

 }







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

//| SetLote function                                                 |

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

void CRiskManagemet::SetLote(CGetLote *lote_ptr)

 {

  if(!CheckPointer(lote_ptr))

   {

    LogError("El puntero a CGetlote* es invalido", FUNCION_ACTUAL);

    return;

   }



//---

  if(CheckPointer(get_lote) == POINTER_DYNAMIC) // is not equal to 0 (POINTER_INVALID)

   {

    //---

    delete get_lote;

    RemoveLogger(get_lote);



    //---

    AddLogger(lote_ptr, false);

    this.get_lote = lote_ptr;

   }

  else //Si es null

   {

    AddLogger(lote_ptr, false);

    this.get_lote = lote_ptr;

   }

 }



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

//| Function that will be executed once all the                      |

//| Maximum profit and loss have been added                          |

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

void               CRiskManagemet::EndAddProfitLoss()

 {

  if(is_init)

    return;

  LogInfo(StringFormat("The total size between maximum profit and loss is: %d", loss_profits_manager.SizeValids()), FUNCION_ACTUAL);

  loss_profits_manager.SetValues();

  this.is_init = true;

 }



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

//| Function to add a maximum loss                                   |

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

bool CRiskManagemet::AddLoss(double _percentage, ENUM_APPLIED_PERCENTAGES _applied, ENUM_RISK_CALCULATION_MODE _mode, ENUM_TYPE_LOSS_PROFIT type, bool strict,

                             bool is_dynamic = false, string percentages_to_activate = NULL, string risks_to_be_applied = NULL)

 {

//---

  if(_percentage <= 0.00)

   {

    LogWarning(StringFormat("Invalid percentage %.2f for lost profit %s, will not be added to the main array", _percentage, EnumToString(type)), FUNCION_ACTUAL);

    return false;

   }



//---

  if(_percentage > 100.00 && _mode == percentage)

   {

    LogWarning(StringFormat("Percentage %.2f for %s exceeds 100%%, limiting to 100%%", _percentage, EnumToString(type)), FUNCION_ACTUAL);

    _percentage = 100.00;

   }



//---

  const int index = int(type);

  if(index > 5 || index < 0)

   {

    LogError(StringFormat("Invalid maximum loss type: %s (index: %d)", EnumToString(type), index), FUNCION_ACTUAL);

    return false;

   }





//--- Creamos

  CLossProfit* new_loss = NULL;

  CRiskManagemetBase* basic_risk = ((CRiskManagemetBase*)&this);



// Por tipo

  if(_mode == money)

   {

    switch(index)

     {

      case LP_GMLPO:

       {

        CLossLossGmlpo<CLossProfitMoney<CLossProfit>>* temp = new CLossLossGmlpo<CLossProfitMoney<CLossProfit>>(false, basic_risk, m_is_global);

        temp.Init(_percentage, _applied, strict, SuperateModeToFunctionLoss(type));

        new_loss = temp;

        break;

       }

      case LP_MDL:

       {

        CLossLossMaxDaily<CLossProfitMoney<CLossProfit>>* temp = new CLossLossMaxDaily<CLossProfitMoney<CLossProfit>>(false, basic_risk, m_is_global);

        temp.Init(_percentage, _applied, strict, SuperateModeToFunctionLoss(type));

        new_loss = temp;

        break;

       }

      case LP_MWL:

       {

        CLossLossMaxWeekly<CLossProfitMoney<CLossProfit>>* temp = new CLossLossMaxWeekly<CLossProfitMoney<CLossProfit>>(false, basic_risk, m_is_global);

        temp.Init(_percentage, _applied, strict, SuperateModeToFunctionLoss(type));

        new_loss = temp;

        break;

       }

      case LP_MML:

       {

        CLossLossMaxMon<CLossProfitMoney<CLossProfit>>* temp = new CLossLossMaxMon<CLossProfitMoney<CLossProfit>>(false, basic_risk, m_is_global);

        temp.Init(_percentage, _applied, strict, SuperateModeToFunctionLoss(type));

        new_loss = temp;

        break;

       }

      case LP_ML:

       {

        CLossLossMax<CLossProfitMoney<CLossProfit>>* temp = new CLossLossMax<CLossProfitMoney<CLossProfit>>(false, basic_risk, m_is_global);

        temp.Init(_percentage, _applied, strict, SuperateModeToFunctionLoss(type));

        new_loss = temp;

        break;

       }

      case LP_ML_PICO:

       {

        CLossLossMaxDesdeArriba<CLossProfitMoney<CLossProfit>>* temp = new CLossLossMaxDesdeArriba<CLossProfitMoney<CLossProfit>>(false, basic_risk, m_is_global);

        temp.Init(_percentage, _applied, strict, SuperateModeToFunctionLoss(type));

        new_loss = temp;

        break;

       }

     }

   }

  else  // percentage

   {

    switch(index)

     {

      case LP_GMLPO:

       {

        CLossLossGmlpo<CLossProfitPercentage<CLossProfit>>* temp = new CLossLossGmlpo<CLossProfitPercentage<CLossProfit>>(false, basic_risk, m_is_global);

        temp.Init(_percentage, _applied, strict, SuperateModeToFunctionLoss(type));

        new_loss = temp;

        break;

       }

      case LP_MDL:

       {

        CLossLossMaxDaily<CLossProfitPercentage<CLossProfit>>* temp = new CLossLossMaxDaily<CLossProfitPercentage<CLossProfit>>(false, basic_risk, m_is_global);

        temp.Init(_percentage, _applied, strict, SuperateModeToFunctionLoss(type));

        new_loss = temp;

        break;

       }

      case LP_MWL:

       {

        CLossLossMaxWeekly<CLossProfitPercentage<CLossProfit>>* temp = new CLossLossMaxWeekly<CLossProfitPercentage<CLossProfit>>(false, basic_risk, m_is_global);

        temp.Init(_percentage, _applied, strict, SuperateModeToFunctionLoss(type));

        new_loss = temp;

        break;

       }

      case LP_MML:

       {

        CLossLossMaxMon<CLossProfitPercentage<CLossProfit>>* temp = new CLossLossMaxMon<CLossProfitPercentage<CLossProfit>>(false, basic_risk, m_is_global);

        temp.Init(_percentage, _applied, strict, SuperateModeToFunctionLoss(type));

        new_loss = temp;

        break;

       }

      case LP_ML:

       {

        CLossLossMax<CLossProfitPercentage<CLossProfit>>* temp = new CLossLossMax<CLossProfitPercentage<CLossProfit>>(false, basic_risk, m_is_global);

        temp.Init(_percentage, _applied, strict, SuperateModeToFunctionLoss(type));

        new_loss = temp;

        break;

       }

      case LP_ML_PICO:

       {

        CLossLossMaxDesdeArriba<CLossProfitPercentage<CLossProfit>>* temp = new CLossLossMaxDesdeArriba<CLossProfitPercentage<CLossProfit>>(false, basic_risk, m_is_global);

        temp.Init(_percentage, _applied, strict, SuperateModeToFunctionLoss(type));

        new_loss = temp;

        break;

       }

     }

   }





//---

  if(!loss_profits_manager.Add(new_loss))

   {

    delete new_loss;

    return false;

   }



//---

  new_loss.SetPtrSuperated(GetPtrLossProfits());



//---

  if(is_dynamic && percentages_to_activate != NULL && risks_to_be_applied != NULL)

   {

    if(!isCachedModifier[index])

     {

      new_loss.SetDynamic(percentages_to_activate, risks_to_be_applied, this.chosen_balance);

      LogInfo(StringFormat("Dynamic maximum loss %s successfully configured", EnumToString(type)), FUNCION_ACTUAL);

     }

    else

     {

      LogError(StringFormat("Maximum loss %s already has an active modifier", EnumToString(type)), FUNCION_ACTUAL);

     }

   }

  else

   {

    LogInfo(StringFormat("Maximum loss %s added: %.2f%s", EnumToString(type), _percentage, (_mode == money ? "money" : "%")), FUNCION_ACTUAL);

   }

  return true;

 }



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

//| Function to add a maximum gain                                   |

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

bool CRiskManagemet::AddProfit(double _percentage, ENUM_APPLIED_PERCENTAGES _applied, ENUM_RISK_CALCULATION_MODE _mode, ENUM_TYPE_LOSS_PROFIT type, bool is_strict_,

                               bool is_dynamic = false, string percentages_to_activate = NULL, string risks_to_be_applied = NULL)

 {

//---

  if(_percentage <= 0.00)

   {

    LogWarning(StringFormat("Invalid percentage %.2f for maximum gain %s, will not be added to the main array", _percentage, EnumToString(type)), FUNCION_ACTUAL);

    return false;

   }



//---

  if(_percentage > 100.00 && _mode == percentage)

   {

    LogWarning(StringFormat("Percentage %.2f for %s exceeds 100%%, limiting to 100%%", _percentage, EnumToString(type)), FUNCION_ACTUAL);

    _percentage = 100.00;

   }



//---

  const int index = int(type);

  if(index < 6 || index > 10)  // Profits: LP_MDP=6 a LP_MP_BAJO=10

   {

    LogError(StringFormat("Invalid maximum gain type: %s (index: %d)", EnumToString(type), index), FUNCION_ACTUAL);

    return false;

   }



//--- Creamos

  CLossProfit* new_profit = NULL;

  CRiskManagemetBase* basic_risk = ((CRiskManagemetBase*)&this);



// Ajustar <EFBFBD>ndice para el switch (restar 6 para que LP_MDP=0, LP_MWP=1, etc.)

  const int switch_index = index - 6;



// Por tipo

  if(_mode == money)

   {

    switch(switch_index)

     {

      case 0:  // LP_MDP

       {

        CLossProfitMaxDaily<CLossProfitMoney<CLossProfit>>* temp = new CLossProfitMaxDaily<CLossProfitMoney<CLossProfit>>(false, basic_risk, m_is_global);

        temp.Init(_percentage, _applied, is_strict_, SuperateModeToFunctionProfit(type));

        new_profit = temp;

        break;

       }

      case 1:  // LP_MWP

       {

        CLossProfitMaxWeekly<CLossProfitMoney<CLossProfit>>* temp = new CLossProfitMaxWeekly<CLossProfitMoney<CLossProfit>>(false, basic_risk, m_is_global);

        temp.Init(_percentage, _applied, is_strict_, SuperateModeToFunctionProfit(type));

        new_profit = temp;

        break;

       }

      case 2:  // LP_MMP

       {

        CLossProfitMaxMon<CLossProfitMoney<CLossProfit>>* temp = new CLossProfitMaxMon<CLossProfitMoney<CLossProfit>>(false, basic_risk, m_is_global);

        temp.Init(_percentage, _applied, is_strict_, SuperateModeToFunctionProfit(type));

        new_profit = temp;

        break;

       }

      case 3:  // LP_MP

       {

        CLossProfitMax<CLossProfitMoney<CLossProfit>>* temp = new CLossProfitMax<CLossProfitMoney<CLossProfit>>(false, basic_risk, m_is_global);

        temp.Init(_percentage, _applied, is_strict_, SuperateModeToFunctionProfit(type));

        new_profit = temp;

        break;

       }

      case 4:  // LP_MP_BAJO

       {

        CLossProfitMaxDesdeBaajo<CLossProfitMoney<CLossProfit>>* temp = new CLossProfitMaxDesdeBaajo<CLossProfitMoney<CLossProfit>>(false, basic_risk, m_is_global);

        temp.Init(_percentage, _applied, is_strict_, SuperateModeToFunctionProfit(type));

        new_profit = temp;

        break;

       }

     }

   }

  else  // percentage

   {

    switch(switch_index)

     {

      case 0:  // LP_MDP

       {

        CLossProfitMaxDaily<CLossProfitPercentage<CLossProfit>>* temp = new CLossProfitMaxDaily<CLossProfitPercentage<CLossProfit>>(false, basic_risk, m_is_global);

        temp.Init(_percentage, _applied, is_strict_, SuperateModeToFunctionProfit(type));

        new_profit = temp;

        break;

       }

      case 1:  // LP_MWP

       {

        CLossProfitMaxWeekly<CLossProfitPercentage<CLossProfit>>* temp = new CLossProfitMaxWeekly<CLossProfitPercentage<CLossProfit>>(false, basic_risk, m_is_global);

        temp.Init(_percentage, _applied, is_strict_, SuperateModeToFunctionProfit(type));

        new_profit = temp;

        break;

       }

      case 2:  // LP_MMP

       {

        CLossProfitMaxMon<CLossProfitPercentage<CLossProfit>>* temp = new CLossProfitMaxMon<CLossProfitPercentage<CLossProfit>>(false, basic_risk, m_is_global);

        temp.Init(_percentage, _applied, is_strict_, SuperateModeToFunctionProfit(type));

        new_profit = temp;

        break;

       }

      case 3:  // LP_MP

       {

        CLossProfitMax<CLossProfitPercentage<CLossProfit>>* temp = new CLossProfitMax<CLossProfitPercentage<CLossProfit>>(false, basic_risk, m_is_global);

        temp.Init(_percentage, _applied, is_strict_, SuperateModeToFunctionProfit(type));

        new_profit = temp;

        break;