| //+------------------------------------------------------------------+
|
| //| PaperTrading.mqh |
|
| //| Copyright 2023, MetaQuotes Software Corp. |
|
| //| https://www.mql5.com |
|
| //+------------------------------------------------------------------+
|
| #property copyright "Copyright 2023, MetaQuotes Software Corp."
|
| #property link "https://www.mql5.com"
|
| #property version "1.00"
|
| #property strict
|
|
|
| #include <Arrays\ArrayObj.mqh>
|
| #include <Trade\PositionInfo.mqh>
|
| #include "TradeExecutor.mqh"
|
|
|
| //+------------------------------------------------------------------+
|
| //| Paper Trade Position Class |
|
| //+------------------------------------------------------------------+
|
| class CPosition : public CObject
|
| {
|
| public:
|
| ulong ticket; // Position ticket
|
| string symbol; // Symbol
|
| ENUM_POSITION_TYPE type; // Position type
|
| double volume; // Position volume
|
| double openPrice; // Open price
|
| double stopLoss; // Stop loss level
|
| double takeProfit; // Take profit level
|
| datetime openTime; // Open time
|
|
|
| // Constructor
|
| CPosition(ulong t, string s, ENUM_POSITION_TYPE pt, double v, double op,
|
| double sl, double tp, datetime ot) :
|
| ticket(t), symbol(s), type(pt), volume(v), openPrice(op),
|
| stopLoss(sl), takeProfit(tp), openTime(ot) {}
|
|
|
| // Check if position is closed
|
| bool IsClosed() const { return volume <= 0; }
|
|
|
| // Calculate current profit
|
| double CalculateProfit(double currentBid, double currentAsk) const
|
| {
|
| if(IsClosed()) return 0.0;
|
|
|
| double profit = 0.0;
|
| double point = SymbolInfoDouble(symbol, SYMBOL_POINT);
|
|
|
| if(type == POSITION_TYPE_BUY)
|
| {
|
| profit = (currentBid - openPrice) * volume * SymbolInfoDouble(symbol, SYMBOL_TRADE_TICK_VALUE) / point;
|
| }
|
| else if(type == POSITION_TYPE_SELL)
|
| {
|
| profit = (openPrice - currentAsk) * volume * SymbolInfoDouble(symbol, SYMBOL_TRADE_TICK_VALUE) / point;
|
| }
|
|
|
| return profit;
|
| }
|
| };
|
|
|
| //+------------------------------------------------------------------+
|
| //| Paper Trading Class |
|
| //+------------------------------------------------------------------+
|
| class CPaperTrading
|
| {
|
| private:
|
| CArrayObj m_positions; // Array of open positions
|
| double m_balance; // Paper trading balance
|
| double m_equity; // Current equity
|
| double m_margin; // Used margin
|
| double m_freeMargin; // Free margin
|
|
|
| // Simulation parameters
|
| bool m_simulateSlippage; // Simulate slippage
|
| bool m_simulatePartialFills; // Simulate partial fills
|
| double m_maxSlippagePips; // Maximum slippage in pips
|
| double m_fillProbability; // Probability of fill (0-1)
|
|
|
| // Statistics
|
| int m_totalTrades; // Total number of trades
|
| int m_winningTrades; // Number of winning trades
|
| int m_losingTrades; // Number of losing trades
|
| double m_totalProfit; // Total profit
|
| double m_totalLoss; // Total loss
|
|
|
| // Objects
|
| CSymbolInfo *m_symbol; // Pointer to symbol info
|
|
|
| // Private methods
|
| double ApplySlippage(double price, ENUM_ORDER_TYPE type);
|
| double ApplyPartialFill(double requestedVolume);
|
| void UpdateMetrics();
|
|
|
| public:
|
| CPaperTrading();
|
| ~CPaperTrading();
|
|
|
| // Initialization
|
| bool Initialize(CSymbolInfo *symbol, double initialBalance = 10000.0,
|
| bool simulateSlippage = true, bool simulatePartialFills = true,
|
| double maxSlippagePips = 1.0, double fillProbability = 0.95);
|
|
|
| // Trading operations
|
| bool OpenPosition(ENUM_ORDER_TYPE type, double lots, double price,
|
| double sl = 0, double tp = 0);
|
| bool ClosePosition(ulong ticket, double lots = 0);
|
| bool ModifyPosition(ulong ticket, double sl, double tp);
|
|
|
| // Position management
|
| bool SelectPosition(ulong ticket, CPosition *&position);
|
| int TotalPositions() const { return m_positions.Total(); }
|
|
|
| // Account information
|
| double GetBalance() const { return m_balance; }
|
| double GetEquity() const { return m_equity; }
|
| double GetMargin() const { return m_margin; }
|
| double GetFreeMargin() const { return m_freeMargin; }
|
|
|
| // Statistics
|
| int GetTotalTrades() const { return m_totalTrades; }
|
| int GetWinningTrades() const { return m_winningTrades; }
|
| int GetLosingTrades() const { return m_losingTrades; }
|
| double GetTotalProfit() const { return m_totalProfit; }
|
| double GetTotalLoss() const { return m_totalLoss; }
|
| double GetWinRate() const
|
| {
|
| return (m_totalTrades > 0) ? (double)m_winningTrades / m_totalTrades * 100.0 : 0.0;
|
| }
|
|
|
| // Visualization
|
| void UpdateVisualization();
|
|
|
| // Update method called on each tick
|
| void Update();
|
|
|
| // Check if live trading is allowed based on paper trading results
|
| bool IsLiveTradingAllowed();
|
| };
|
|
|
| //+------------------------------------------------------------------+
|
| //| Constructor |
|
| //+------------------------------------------------------------------+
|
| CPaperTrading::CPaperTrading() : m_balance(10000.0),
|
| m_equity(10000.0),
|
| m_margin(0.0),
|
| m_freeMargin(10000.0),
|
| m_simulateSlippage(true),
|
| m_simulatePartialFills(true),
|
| m_maxSlippagePips(1.0),
|
| m_fillProbability(0.95),
|
| m_totalTrades(0),
|
| m_winningTrades(0),
|
| m_losingTrades(0),
|
| m_totalProfit(0.0),
|
| m_totalLoss(0.0),
|
| m_symbol(NULL)
|
| {
|
| m_positions.Clear();
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Destructor |
|
| //+------------------------------------------------------------------+
|
| CPaperTrading::~CPaperTrading()
|
| {
|
| m_positions.Clear();
|
| m_symbol = NULL;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Initialize paper trading |
|
| //+------------------------------------------------------------------+
|
| bool CPaperTrading::Initialize(CSymbolInfo *symbol, double initialBalance,
|
| bool simulateSlippage, bool simulatePartialFills,
|
| double maxSlippagePips, double fillProbability)
|
| {
|
| if(symbol == NULL || initialBalance <= 0)
|
| {
|
| Print("Error: Invalid parameters in PaperTrading initialization");
|
| return false;
|
| }
|
|
|
| m_symbol = symbol;
|
| m_balance = initialBalance;
|
| m_equity = initialBalance;
|
| m_freeMargin = initialBalance;
|
|
|
| // Set simulation parameters
|
| m_simulateSlippage = simulateSlippage;
|
| m_simulatePartialFills = simulatePartialFills;
|
| m_maxSlippagePips = maxSlippagePips;
|
| m_fillProbability = MathMax(0.0, MathMin(1.0, fillProbability));
|
|
|
| // Initialize statistics
|
| m_totalTrades = 0;
|
| m_winningTrades = 0;
|
| m_losingTrades = 0;
|
| m_totalProfit = 0.0;
|
| m_totalLoss = 0.0;
|
|
|
| return true;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Open a new position |
|
| //+------------------------------------------------------------------+
|
| bool CPaperTrading::OpenPosition(ENUM_ORDER_TYPE type, double lots, double price,
|
| double sl, double tp)
|
| {
|
| if(m_symbol == NULL || lots <= 0 || price <= 0)
|
| {
|
| Print("Error: Invalid parameters in OpenPosition");
|
| return false;
|
| }
|
|
|
| // Apply slippage if enabled
|
| double executionPrice = ApplySlippage(price, type);
|
|
|
| // Apply partial fill if enabled
|
| double filledLots = m_simulatePartialFills ?
|
| ApplyPartialFill(lots) : lots;
|
|
|
| if(filledLots <= 0)
|
| {
|
| Print("Order not filled (partial fill simulation)");
|
| return false;
|
| }
|
|
|
| // Generate a unique ticket
|
| static ulong lastTicket = 1000;
|
| ulong ticket = ++lastTicket;
|
|
|
| // Create and add the position
|
| CPosition *position = new CPosition(ticket, m_symbol.Name(),
|
| (type == ORDER_TYPE_BUY) ? POSITION_TYPE_BUY : POSITION_TYPE_SELL,
|
| filledLots, executionPrice, sl, tp, TimeCurrent());
|
|
|
| if(position == NULL)
|
| {
|
| Print("Error: Failed to create position object");
|
| return false;
|
| }
|
|
|
| m_positions.Add(position);
|
|
|
| // Update metrics
|
| UpdateMetrics();
|
|
|
| // Update statistics
|
| m_totalTrades++;
|
|
|
| return true;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Close a position |
|
| //+------------------------------------------------------------------+
|
| bool CPaperTrading::ClosePosition(ulong ticket, double lots = 0)
|
| {
|
| CPosition *position = NULL;
|
|
|
| // Find the position
|
| for(int i = 0; i < m_positions.Total(); i++)
|
| {
|
| CPosition *pos = m_positions.At(i);
|
| if(pos != NULL && pos.ticket == ticket && !pos.IsClosed())
|
| {
|
| position = pos;
|
| break;
|
| }
|
| }
|
|
|
| if(position == NULL)
|
| {
|
| Print("Error: Position not found or already closed");
|
| return false;
|
| }
|
|
|
| // Calculate close price with slippage
|
| double closePrice = ApplySlippage(
|
| (position.type == POSITION_TYPE_BUY) ? m_symbol.Bid() : m_symbol.Ask(),
|
| (position.type == POSITION_TYPE_BUY) ? ORDER_TYPE_SELL : ORDER_TYPE_BUY
|
| );
|
|
|
| // Calculate profit/loss
|
| double profit = 0.0;
|
| double point = m_symbol.Point();
|
| double tickValue = m_symbol.TickValue();
|
|
|
| if(position.type == POSITION_TYPE_BUY)
|
| {
|
| profit = (closePrice - position.openPrice) * position.volume * tickValue / point;
|
| }
|
| else // POSITION_TYPE_SELL
|
| {
|
| profit = (position.openPrice - closePrice) * position.volume * tickValue / point;
|
| }
|
|
|
| // Update balance and statistics
|
| m_balance += profit;
|
|
|
| if(profit >= 0)
|
| {
|
| m_winningTrades++;
|
| m_totalProfit += profit;
|
| }
|
| else
|
| {
|
| m_losingTrades++;
|
| m_totalLoss -= profit; // Loss is stored as positive value
|
| }
|
|
|
| // Close the position or reduce its volume
|
| if(lots <= 0 || lots >= position.volume)
|
| {
|
| // Close the entire position
|
| position.volume = 0;
|
| }
|
| else
|
| {
|
| // Partial close
|
| position.volume -= lots;
|
| }
|
|
|
| // Update metrics
|
| UpdateMetrics();
|
|
|
| return true;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Modify position's stop loss and take profit |
|
| //+------------------------------------------------------------------+
|
| bool CPaperTrading::ModifyPosition(ulong ticket, double sl, double tp)
|
| {
|
| CPosition *position = NULL;
|
|
|
| // Find the position
|
| for(int i = 0; i < m_positions.Total(); i++)
|
| {
|
| CPosition *pos = m_positions.At(i);
|
| if(pos != NULL && pos.ticket == ticket && !pos.IsClosed())
|
| {
|
| position = pos;
|
| break;
|
| }
|
| }
|
|
|
| if(position == NULL)
|
| {
|
| Print("Error: Position not found or already closed");
|
| return false;
|
| }
|
|
|
| // Update stop loss and take profit
|
| position.stopLoss = sl;
|
| position.takeProfit = tp;
|
|
|
| return true;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Select position by ticket |
|
| //+------------------------------------------------------------------+
|
| bool CPaperTrading::SelectPosition(ulong ticket, CPosition *&position)
|
| {
|
| for(int i = 0; i < m_positions.Total(); i++)
|
| {
|
| CPosition *pos = m_positions.At(i);
|
| if(pos != NULL && pos.ticket == ticket && !pos.IsClosed())
|
| {
|
| position = pos;
|
| return true;
|
| }
|
| }
|
|
|
| position = NULL;
|
| return false;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Apply slippage to price |
|
| //+------------------------------------------------------------------+
|
| double CPaperTrading::ApplySlippage(double price, ENUM_ORDER_TYPE type)
|
| {
|
| if(!m_simulateSlippage || m_maxSlippagePips <= 0)
|
| return price;
|
|
|
| // Generate random slippage (can be positive or negative)
|
| double slippagePips = ((double)MathRand() / 32767.0 - 0.5) * 2.0 * m_maxSlippagePips;
|
| double point = m_symbol.Point();
|
|
|
| // For buy orders, slippage is added to the price (worse execution)
|
| // For sell orders, slippage is subtracted from the price (worse execution)
|
| if(type == ORDER_TYPE_BUY)
|
| return price + slippagePips * point;
|
| else
|
| return price - slippagePips * point;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Apply partial fill to order |
|
| //+------------------------------------------------------------------
|
| double CPaperTrading::ApplyPartialFill(double requestedVolume)
|
| {
|
| if(!m_simulatePartialFills || m_fillProbability >= 1.0)
|
| return requestedVolume;
|
|
|
| // Check if order is filled based on probability
|
| if(((double)MathRand() / 32767.0) > m_fillProbability)
|
| return 0.0; // Order not filled
|
|
|
| // For simplicity, we either fill the entire order or nothing
|
| // In a more advanced simulation, you could implement partial fills
|
| return requestedVolume;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Update account metrics |
|
| //+------------------------------------------------------------------+
|
| void CPaperTrading::UpdateMetrics()
|
| {
|
| if(m_symbol == NULL)
|
| return;
|
|
|
| // Update current prices
|
| m_symbol.RefreshRates();
|
|
|
| // Calculate equity and margin
|
| double floatingProfit = 0.0;
|
| m_margin = 0.0;
|
|
|
| // Calculate floating P/L and used margin for all open positions
|
| for(int i = 0; i < m_positions.Total(); i++)
|
| {
|
| CPosition *pos = m_positions.At(i);
|
| if(pos != NULL && !pos.IsClosed())
|
| {
|
| // Calculate floating profit/loss
|
| if(pos.type == POSITION_TYPE_BUY)
|
| {
|
| floatingProfit += (m_symbol.Bid() - pos.openPrice) * pos.volume *
|
| m_symbol.TickValue() / m_symbol.Point();
|
| }
|
| else // POSITION_TYPE_SELL
|
| {
|
| floatingProfit += (pos.openPrice - m_symbol.Ask()) * pos.volume *
|
| m_symbol.TickValue() / m_symbol.Point();
|
| }
|
|
|
| // Calculate margin (simplified)
|
| m_margin += pos.volume * pos.openPrice / 100.0; // 1:100 leverage
|
| }
|
| }
|
|
|
| // Update equity and free margin
|
| m_equity = m_balance + floatingProfit;
|
| m_freeMargin = m_equity - m_margin;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Update method called on each tick |
|
| //+------------------------------------------------------------------+
|
| void CPaperTrading::Update()
|
| {
|
| // Update metrics and visualization
|
| UpdateMetrics();
|
| UpdateVisualization();
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Check if live trading is allowed based on paper trading results |
|
| //+------------------------------------------------------------------+
|
| bool CPaperTrading::IsLiveTradingAllowed()
|
| {
|
| // Check if we have enough trades
|
| if(m_totalTrades < 5) // Minimum number of trades required
|
| return false;
|
|
|
| // Check win rate (e.g., at least 60% win rate)
|
| double winRate = GetWinRate();
|
| if(winRate < 60.0)
|
| return false;
|
|
|
| // Check profit factor (e.g., at least 1.5)
|
| double profitFactor = (m_totalLoss != 0) ? m_totalProfit / m_totalLoss : m_totalProfit;
|
| if(profitFactor < 1.5)
|
| return false;
|
|
|
| // All conditions met, allow live trading
|
| return true;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Update visualization |
|
| //+------------------------------------------------------------------+
|
| void CPaperTrading::UpdateVisualization()
|
| {
|
| // Update metrics first
|
| UpdateMetrics();
|
|
|
| // Create or update panel
|
| string panelName = "PaperTrading_Panel";
|
|
|
| // Create panel background
|
| if(ObjectFind(0, panelName) < 0)
|
| {
|
| ObjectCreate(0, panelName, OBJ_RECTANGLE_LABEL, 0, 0, 0);
|
| ObjectSetInteger(0, panelName, OBJPROP_XDISTANCE, 10);
|
| ObjectSetInteger(0, panelName, OBJPROP_YDISTANCE, 150);
|
| ObjectSetInteger(0, panelName, OBJPROP_XSIZE, 200);
|
| ObjectSetInteger(0, panelName, OBJPROP_YSIZE, 120);
|
| ObjectSetInteger(0, panelName, OBJPROP_BGCOLOR, clrWhiteSmoke);
|
| ObjectSetInteger(0, panelName, OBJPROP_BORDER_TYPE, BORDER_FLAT);
|
| ObjectSetInteger(0, panelName, OBJPROP_CORNER, CORNER_RIGHT_UPPER);
|
| ObjectSetInteger(0, panelName, OBJPROP_COLOR, clrDimGray);
|
| ObjectSetInteger(0, panelName, OBJPROP_BACK, false);
|
| }
|
|
|
| // Create or update title
|
| string titleName = panelName + "_Title";
|
| if(ObjectFind(0, titleName) < 0)
|
| {
|
| ObjectCreate(0, titleName, OBJ_LABEL, 0, 0, 0);
|
| ObjectSetInteger(0, titleName, OBJPROP_COLOR, clrBlack);
|
| ObjectSetInteger(0, titleName, OBJPROP_CORNER, CORNER_RIGHT_UPPER);
|
| ObjectSetInteger(0, titleName, OBJPROP_XDISTANCE, 20);
|
| ObjectSetInteger(0, titleName, OBJPROP_YDISTANCE, 160);
|
| ObjectSetInteger(0, titleName, OBJPROP_FONTSIZE, 10);
|
| }
|
| ObjectSetString(0, titleName, OBJPROP_TEXT, "PAPER TRADING");
|
|
|
| // Create or update balance label
|
| string balanceName = panelName + "_Balance";
|
| if(ObjectFind(0, balanceName) < 0)
|
| {
|
| ObjectCreate(0, balanceName, OBJ_LABEL, 0, 0, 0);
|
| ObjectSetInteger(0, balanceName, OBJPROP_COLOR, clrBlack);
|
| ObjectSetInteger(0, balanceName, OBJPROP_CORNER, CORNER_RIGHT_UPPER);
|
| ObjectSetInteger(0, balanceName, OBJPROP_XDISTANCE, 20);
|
| ObjectSetInteger(0, balanceName, OBJPROP_YDISTANCE, 180);
|
| ObjectSetInteger(0, balanceName, OBJPROP_FONTSIZE, 9);
|
| }
|
| ObjectSetString(0, balanceName, OBJPROP_TEXT, "Balance: " + DoubleToString(m_balance, 2));
|
|
|
| // Create or update equity label
|
| string equityName = panelName + "_Equity";
|
| if(ObjectFind(0, equityName) < 0)
|
| {
|
| ObjectCreate(0, equityName, OBJ_LABEL, 0, 0, 0);
|
| ObjectSetInteger(0, equityName, OBJPROP_COLOR, clrBlack);
|
| ObjectSetInteger(0, equityName, OBJPROP_CORNER, CORNER_RIGHT_UPPER);
|
| ObjectSetInteger(0, equityName, OBJPROP_XDISTANCE, 20);
|
| ObjectSetInteger(0, equityName, OBJPROP_YDISTANCE, 200);
|
| ObjectSetInteger(0, equityName, OBJPROP_FONTSIZE, 9);
|
| }
|
| ObjectSetString(0, equityName, OBJPROP_TEXT, "Equity: " + DoubleToString(m_equity, 2));
|
|
|
| // Create or update margin label
|
| string marginName = panelName + "_Margin";
|
| if(ObjectFind(0, marginName) < 0)
|
| {
|
| ObjectCreate(0, marginName, OBJ_LABEL, 0, 0, 0);
|
| ObjectSetInteger(0, marginName, OBJPROP_COLOR, clrBlack);
|
| ObjectSetInteger(0, marginName, OBJPROP_CORNER, CORNER_RIGHT_UPPER);
|
| ObjectSetInteger(0, marginName, OBJPROP_XDISTANCE, 20);
|
| ObjectSetInteger(0, marginName, OBJPROP_YDISTANCE, 220);
|
| ObjectSetInteger(0, marginName, OBJPROP_FONTSIZE, 9);
|
| }
|
| ObjectSetString(0, marginName, OBJPROP_TEXT, "Margin: " + DoubleToString(m_margin, 2));
|
|
|
| // Create or update free margin label
|
| string freeMarginName = panelName + "_FreeMargin";
|
| if(ObjectFind(0, freeMarginName) < 0)
|
| {
|
| ObjectCreate(0, freeMarginName, OBJ_LABEL, 0, 0, 0);
|
| ObjectSetInteger(0, freeMarginName, OBJPROP_COLOR, clrBlack);
|
| ObjectSetInteger(0, freeMarginName, OBJPROP_CORNER, CORNER_RIGHT_UPPER);
|
| ObjectSetInteger(0, freeMarginName, OBJPROP_XDISTANCE, 20);
|
| ObjectSetInteger(0, freeMarginName, OBJPROP_YDISTANCE, 240);
|
| ObjectSetInteger(0, freeMarginName, OBJPROP_FONTSIZE, 9);
|
| }
|
| ObjectSetString(0, freeMarginName, OBJPROP_TEXT, "Free Margin: " + DoubleToString(m_freeMargin, 2));
|
|
|
| // Update the chart
|
| ChartRedraw();
|
| }
|
| //+------------------------------------------------------------------+
|
