Adwizard/Virtual/VirtualStrategy.mqh

<EFBFBD><EFBFBD>//+------------------------------------------------------------------+
//|                                              VirtualStrategy.mqh |
//|                                 Copyright 2019-2025, Yuriy Bykov |
//|                            https://www.mql5.com/ru/users/antekov |
//+------------------------------------------------------------------+
#property copyright "Copyright 2019-2025, Yuriy Bykov"
#property link      "https://www.mql5.com/ru/users/antekov"
#property version   "1.09"

#include <Generic/HashMap.mqh>
#include "../Base/Strategy.mqh"
#include "VirtualOrder.mqh"
#include "../Database/Storage.mqh"

//+------------------------------------------------------------------+
//| ;0AA B>@3>2>9 AB@0B5388 A 28@BC0;L=K<8 ?>78F8O<8                |
//+------------------------------------------------------------------+
class CVirtualStrategy : public CStrategy {
protected:
   CVirtualOrder     *m_orders[];      // 0AA82 28@BC0;L=KE ?>78F89 (>@45@>2)
   int               m_ordersTotal;    // 1I55 :>;8G5AB2> >B:@KBKE ?>78F89 8 >@45@>2
   double            m_fittedBalance;  // >@<8@>20==K9 10;0=A AB@0B5388
   double            m_fixedLot;       // $8:A8@>20==K9 @07<5@ AB@0B5388
   
   double            m_baseFittedBalance;  // 0G0;L=K9 =>@<8@>20==K9 10;0=A AB@0B5388

   virtual void      CountOrders();    // >4AG5B :>;8G5AB20 >B:@KBKE 28@BC0;L=KE ?>78F89 8 >@45@>2

public:
                     CVirtualStrategy();  // >=AB@C:B>@

   virtual void      OnOpen(CVirtualOrder *o);            // 1@01>BG8: A>1KB8O >B:@KB8O 28@BC0;L=>9 ?>78F88 (>@45@0)
   virtual void      OnClose(CVirtualOrder *o);           // 1@01>BG8: A>1KB8O 70:@KB8O 28@BC0;L=>9 ?>78F88 (>@45@0)

   virtual double    Profit() const;
   virtual double    ClosedProfit() const;
   virtual void      Close();

   virtual void      Save();   // !>E@0=5=85 A>AB>O=8O
   virtual bool      Load();   // 03@C7:0 A>AB>O=8O
   
   // #AB0=>2:0 =0G0;L=>3> =>@<8@>20==>3> 10;0=A0 AB@0B5388
   void              FittedBalance(double fittedBalance) {    
      m_fittedBalance = fittedBalance;
      m_baseFittedBalance = fittedBalance;
   }

   // >@<8@>20==K9 10;0=A AB@0B5388
   double            FittedBalance() const {    
      return m_fittedBalance;
   }

   // 0AHB018@>20=85 =>@<8@>20==>3> 10;0=A0
   void              Scale(double p_scale) { 
      m_fittedBalance /= p_scale;
   }
   
   // 0AHB01=K9 <=>68B5;L AB@0B5388
   double            Scale() const { 
      return m_baseFittedBalance / m_fittedBalance;
   }

   // 0<5=0 =0720=89 A8<2>;>2
   virtual bool      SymbolsReplace(CHashMap<string, string> &p_symbolsMap) {
      return true;
   }
};


//+------------------------------------------------------------------+
//| >=AB@C:B>@                                                      |
//+------------------------------------------------------------------+
CVirtualStrategy::CVirtualStrategy() :
   m_fixedLot(0.01),
   m_ordersTotal(0) {
      FittedBalance(10000);
   }


//+------------------------------------------------------------------+
//| >4AG5B :>;8G5AB20 >B:@KBKE 28@BC0;L=KE ?>78F89 8 >@45@>2        |
//+------------------------------------------------------------------+
void CVirtualStrategy::CountOrders() {
   m_ordersTotal = 0;
   FOREACH(m_orders) m_ordersTotal += m_orders[i].IsOpen();
}

//+------------------------------------------------------------------+
//| 1@01>BG8: A>1KB8O >B:@KB8O 28@BC0;L=>9 ?>78F88 (>@45@0)         |
//+------------------------------------------------------------------+
void CVirtualStrategy::OnOpen(CVirtualOrder *o) {
   CountOrders();
}

//+------------------------------------------------------------------+
//| 1@01>BG8: A>1KB8O 70:@KB8O 28@BC0;L=>9 ?>78F88 (>@45@0)         |
//+------------------------------------------------------------------+
void CVirtualStrategy::OnClose(CVirtualOrder *o) {
   CountOrders();
}

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
double CVirtualStrategy::Profit() const {
   double profit = 0;
   FOREACH(m_orders) profit += m_orders[i].Profit();
   return profit;
}

double CVirtualStrategy::ClosedProfit() const {
   double profit = 0;
   FOREACH(m_orders) profit += m_orders[i].ClosedProfit();
   return profit;
}

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CVirtualStrategy::Close(void) {
   FOREACH(m_orders) m_orders[i].Close();
}

//+------------------------------------------------------------------+
//| !>E@0=5=85 A>AB>O=8O                                             |
//+------------------------------------------------------------------+
void CVirtualStrategy::Save() {
// !>E@0=O5< 28@BC0;L=K5 ?>78F88 (>@45@0) AB@0B5388
   FOREACH(m_orders) CStorage::Set(i, m_orders[i]);
}

//+------------------------------------------------------------------+
//| 03@C7:0 A>AB>O=8O                                               |
//+------------------------------------------------------------------+
bool CVirtualStrategy::Load() {
   bool res = true;
   
// 03@C605< 28@BC0;L=K5 ?>78F88 (>@45@0) AB@0B5388
   res = CStorage::Get(this.Hash(), m_orders);

   return res;
}
//+------------------------------------------------------------------+