50% Win Rate Sounds Easy… Until You Actually Trade It

[dreambig]

A 50% win rate sounds pretty easy.

If you win half of your trades and lose the other half, you should be fine, right?

On paper, absolutely.

In real trading, it feels completely different.

Imagine you have a strategy with a 50% win rate and a 1:2 risk/reward.

Sounds great.

But then you lose three trades in a row.

Suddenly you start thinking:

“Is the strategy broken?”

“Maybe I should change something.”

“Maybe this setup doesn’t work anymore.”

So you change the entry.

You skip a trade.

You take a trade that wasn’t part of the system.

And then, of course, the next valid setup wins.

This is one of the hardest things about trading for me.

Understanding that a good strategy can still produce a losing streak.

You can do everything correctly and still lose the trade.

That doesn’t automatically mean the strategy stopped working.

If your system has a 50% win rate, losing streaks are part of the game. The important part is whether you continue executing the same system long enough for the probabilities to play out.

I think this is where trading becomes less about predicting the market and more about controlling yourself.

You don’t need to win the next trade.

You just need to take the next trade correctly.

DreamBig

[PTScalper]

A 50% win rate sounds pretty easy.

If you win half of your trades and lose the other half, you should be fine, right?

On paper, absolutely.

In real trading, it feels completely different.

Imagine you have a strategy with a 50% win rate and a 1:2 risk/reward.

Sounds great.

But then you lose three trades in a row.

Suddenly you start thinking:

“Is the strategy broken?”

“Maybe I should change something.”

“Maybe this setup doesn’t work anymore.”

So you change the entry.

You skip a trade.

You take a trade that wasn’t part of the system.

And then, of course, the next valid setup wins.

This is one of the hardest things about trading for me.

Understanding that a good strategy can still produce a losing streak.

You can do everything correctly and still lose the trade.

That doesn’t automatically mean the strategy stopped working.

If your system has a 50% win rate, losing streaks are part of the game. The important part is whether you continue executing the same system long enough for the probabilities to play out.

I think this is where trading becomes less about predicting the market and more about controlling yourself.

You don’t need to win the next trade.

You just need to take the next trade correctly.

DreamBig

Hi DreamBIg,

You hit the exact psychological barrier that wipes out more accounts than bad strategy ever could.
A true 50% win rate with a 1:2 R:R is a massive statistical edge. But human psychology wasn't built to process independent probabilistic events under financial pressure.

Here is the cold math behind that "easy" 50%:

In a sample of 100 trades with a 50% win rate, you have a near 100% mathematical probability of hitting a streak of 4–5 consecutive losses.
A streak of 6 or even 7 losses in a row is completely normal variance.
When those 4–6 losses happen over a couple of days, the brain treats it as an immediate crisis rather than a standard statistical clump. The instinct is to intervene—tweak the entry filter, drop the stop loss, or hesitate on the next trigger.

The brutal irony is that the moment you skip the next valid setup out of fear, you just broke the probability model. The edge only belongs to the full distribution of trades, not the ones you selectively feel confident about. If you miss the winners because of the recent losers, you keep the drawdown and discard the recovery.

Mark Douglas summed it up best: "There is a random distribution between wins and losses for any given set of variables that define an edge."
Accepting that you can execute flawlessly and still take a loss is the real dividing line between an analyst and an actual trader. Great reminder for the forum.

[PTScalper]

Here is a Pine Script (v5) implementation. Because Pine Script needs to read actual executed trades to calculate real-world metrics (accounting for slippage, partial closes, or premature exits), this is built as a strategy().

It uses TradingView's built-in strategy.grossprofit and strategy.grossloss to calculate your realized Average Win and Average Loss, giving you the true Reward-to-Risk (TP:SL) ratio rather than the theoretical one.

[PTScalper]

Pine Script:

Code: Select all

//@version=5
strategy("Realized Win Rate & R:R Tracker", overlay=true, margin_long=100, margin_short=100)

// =====================================================================
// 1. YOUR ENTRY/EXIT LOGIC GOES HERE
// (Dummy moving average crossover included just so the script compiles and generates trades)
// =====================================================================
fastMA = ta.sma(close, 10)
slowMA = ta.sma(close, 20)

if ta.crossover(fastMA, slowMA)
    strategy.entry("Long", strategy.long)
    strategy.exit("Exit Long", "Long", profit=200, loss=100)

if ta.crossunder(fastMA, slowMA)
    strategy.entry("Short", strategy.short)
    strategy.exit("Exit Short", "Short", profit=200, loss=100)

// =====================================================================
// 2. METRICS CALCULATION
// =====================================================================
totalTrades = strategy.closedtrades
wins        = strategy.wintrades
losses      = strategy.losstrades

// Win Rate %
winRate = totalTrades > 0 ? (wins / totalTrades) * 100 : 0.0

// Average Win & Loss
avgWin  = wins > 0   ? (strategy.grossprofit / wins)   : 0.0
avgLoss = losses > 0 ? (strategy.grossloss / losses)   : 0.0

// Realized TP:SL (Reward:Risk) Ratio
// If avgWin is $200 and avgLoss is $100, Ratio is 2.0 (1:2 Risk-to-Reward)
rrRatio = avgLoss > 0 ? (avgWin / avgLoss) : 0.0

// =====================================================================
// 3. HUD / DASHBOARD TABLE
// =====================================================================
var table statsTable = table.new(position.bottom_right, 2, 4, border_width=1, border_color=color.new(color.gray, 50), frame_width=1, frame_color=color.new(color.gray, 50))

if barstate.islast
    // Header colors
    bgDark = color.new(color.black, 20)
    bgCell = color.new(#1e222d, 10)
    
    // Row 0: Total Trades
    table.cell(statsTable, 0, 0, "Total Trades", bgcolor=bgDark, text_color=color.white, text_halign=text.align_left)
    table.cell(statsTable, 1, 0, str.tostring(totalTrades), bgcolor=bgCell, text_color=color.white, text_halign=text.align_right)

    // Row 1: Win Rate
    wrColor = winRate >= 50 ? color.new(color.teal, 30) : color.new(color.maroon, 30)
    table.cell(statsTable, 0, 1, "Win Rate", bgcolor=bgDark, text_color=color.white, text_halign=text.align_left)
    table.cell(statsTable, 1, 1, str.tostring(winRate, "#.##") + "%", bgcolor=wrColor, text_color=color.white, text_halign=text.align_right)

    // Row 2: Avg Win / Avg Loss
    table.cell(statsTable, 0, 2, "Avg Win / Loss", bgcolor=bgDark, text_color=color.white, text_halign=text.align_left)
    table.cell(statsTable, 1, 2, "$" + str.tostring(avgWin, "#.##") + " / $" + str.tostring(avgLoss, "#.##"), bgcolor=bgCell, text_color=color.gray, text_halign=text.align_right)

    // Row 3: R:R Ratio
    rrColor = rrRatio >= 2.0 ? color.new(color.teal, 30) : (rrRatio >= 1.0 ? color.new(color.yellow, 70) : color.new(color.maroon, 30))
    table.cell(statsTable, 0, 3, "Realized R:R", bgcolor=bgDark, text_color=color.white, text_halign=text.align_left)
    table.cell(statsTable, 1, 3, "1 : " + str.tostring(rrRatio, "#.##"), bgcolor=rrColor, text_color=color.white, text_halign=text.align_right)

[PTScalper]

How to adapt this to your raw price action setups:

If you are trading manually and just want to backtest the structural logic (like 15m/Daily setups), replace the dummy MA crossover logic with your structural triggers (e.g., specific candlestick patterns, sweeps, or liquidity grab definitions).

The HUD will paint dynamically on the bottom right of your chart. It calculates rrRatio exactly as Average Win / Average Loss. If you close a trade early manually (or via trailing stop), the script captures the actual hit to the gross profit/loss, meaning your R:R will reflect reality rather than just your hardcoded strategy.exit parameters.

[PTScalper]

To make this production-ready for serious algorithmic backtesting, we need to treat it like a proper software component.

A professional implementation needs Date/Time filters, Trade Expectancy, Profit Factor, and realistic commission/slippage simulation. As a C# developer, you'll also appreciate keeping the code DRY by using a custom function to render the UI table rows.

Here is the "Pro" version, structured cleanly so you can drop your raw price action logic right into the engine:

Code: Select all

//@version=5
strategy("Pro Backtest Engine & Metrics", overlay=true, initial_capital=10000, default_qty_type=strategy.percent_of_equity, default_qty_value=2, commission_type=strategy.commission.percent, commission_value=0.01, slippage=1)

// =========================================================================
// 1. SETTINGS & FILTERS
// =========================================================================
// Professional backtesting requires strict time boundary control
i_startTime = input.time(timestamp("2024-01-01T00:00:00"), "Start Date", group="Backtest Window")
i_endTime   = input.time(timestamp("2025-12-31T00:00:00"), "End Date", group="Backtest Window")
inWindow    = time >= i_startTime and time <= i_endTime

// Dashboard Configuration
i_tablePos  = input.string(position.bottom_right, "Table Position", options=[position.top_right, position.bottom_right, position.bottom_left], group="Dashboard UI")
i_textSize  = input.string(size.small, "Text Size", options=[size.tiny, size.small, size.normal], group="Dashboard UI")

// =========================================================================
// 2. ENTRY & EXIT LOGIC 
// =========================================================================
// -> Replace this placeholder with your 15m/Daily price action or liquidity sweeps
longCondition  = ta.crossover(ta.sma(close, 14), ta.sma(close, 28)) and inWindow
shortCondition = ta.crossunder(ta.sma(close, 14), ta.sma(close, 28)) and inWindow

if longCondition
    strategy.entry("Long", strategy.long)
    strategy.exit("Exit Long", "Long", profit=200, loss=100) 

if shortCondition
    strategy.entry("Short", strategy.short)
    strategy.exit("Exit Short", "Short", profit=200, loss=100)

// =========================================================================
// 3. PERFORMANCE CALCULATION ENGINE
// =========================================================================
totalTrades = strategy.closedtrades
wins        = strategy.wintrades
losses      = strategy.losstrades

// Base Metrics
winRate = totalTrades > 0 ? (wins / totalTrades) * 100 : 0.0
avgWin  = wins > 0   ? (strategy.grossprofit / wins) : 0.0
avgLoss = losses > 0 ? (strategy.grossloss / losses) : 0.0

// Advanced Metrics
rrRatio      = avgLoss > 0 ? (avgWin / avgLoss) : 0.0
profitFactor = strategy.grossloss > 0 ? (strategy.grossprofit / strategy.grossloss) : na
expectancy   = (winRate / 100 * avgWin) - ((1 - winRate / 100) * avgLoss)
netProfit    = strategy.netprofit

// =========================================================================
// 4. DASHBOARD RENDERER
// =========================================================================
var table hud = table.new(i_tablePos, 2, 7, border_width=1, border_color=color.new(#434651, 50), frame_width=1, frame_color=color.new(#434651, 50))

// DRY function to populate rows
fillRow(tbl, row, title, valStr, valColor) =>
    table.cell(tbl, 0, row, title, bgcolor=color.new(#131722, 10), text_color=color.white, text_size=i_textSize, text_halign=text.align_left)
    table.cell(tbl, 1, row, valStr, bgcolor=color.new(#1e222d, 10), text_color=valColor, text_size=i_textSize, text_halign=text.align_right)

if barstate.islast
    // Dynamic color coding based on threshold viability
    wrColor  = winRate >= 50 ? color.teal : color.red
    rrColor  = rrRatio >= 1.5 ? color.teal : (rrRatio >= 1.0 ? color.orange : color.red)
    pfColor  = profitFactor >= 1.5 ? color.teal : (profitFactor > 1.0 ? color.orange : color.red)
    expColor = expectancy > 0 ? color.teal : color.red
    npColor  = netProfit > 0 ? color.teal : color.red

    // Build the table
    fillRow(hud, 0, "Total Trades", str.tostring(totalTrades), color.white)
    fillRow(hud, 1, "Win Rate", str.tostring(winRate, "#.##") + "%", wrColor)
    fillRow(hud, 2, "Realized R:R", "1 : " + str.tostring(rrRatio, "#.##"), rrColor)
    fillRow(hud, 3, "Profit Factor", str.tostring(profitFactor, "#.##"), pfColor)
    fillRow(hud, 4, "Expectancy / Trade", "$" + str.tostring(expectancy, "#.##"), expColor)
    fillRow(hud, 5, "Avg Win / Loss", "$" + str.tostring(avgWin, "#.##") + " / $" + str.tostring(avgLoss, "#.##"), color.silver)
    fillRow(hud, 6, "Net Profit", "$" + str.tostring(netProfit, "#.##"), npColor)

[PTScalper]

What makes this version "Pro":

Trade Expectancy & Profit Factor: Win Rate and R:R alone can be misleading. A 40% win rate is fine if Expectancy is high. This version calculates Expectancy per Trade (the statistical average amount you make or lose every time you pull the trigger) and Profit Factor (Gross Profit / Gross Loss, where > 1.5 is a standard benchmark for algorithmic viability).

Real-World Cost Simulation: The strategy() declaration now includes commission_value and slippage. Your realized metrics will now factor in the spread and broker costs, giving you the true bottom line, not the theoretical paper-trading bottom line.

Backtest Time Windowing: Added i_startTime and i_endTime. A professional backtest needs to be isolated to specific market regimes (e.g., separating a bull market from a ranging market) to see if the edge holds up in different conditions.

DRY Table Rendering: Instead of hardcoding every table cell over 20 lines, the fillRow() method abstracts the UI generation, keeping your global space clean and easily extensible if you want to add tracking for Max Drawdown or consecutive losses later.

[PTScalper]

Here are the standalone on-chart indicator implementations for both MT4 (MQL4) and MT5 (MQL5).

Both versions analyze your actual closed trade history (factoring in spreads, commissions, and swaps) to calculate real-world Win Rate, Realized R:R (Avg Win : Avg Loss), Profit Factor, and Trade Expectancy, rendering a lightweight HUD panel directly on the chart.

MetaTrader 4 (MQL4)

Save this as RealizedMetricsHUD.mq4 in your MQL4/Indicators folder.

Code: Select all

//+------------------------------------------------------------------+
//|                                           RealizedMetricsHUD.mq4 |
//|                                  Copyright 2026, Quant Metrics   |
//+------------------------------------------------------------------+
#property copyright "Quant Metrics"
#property link      ""
#property version   "1.00"
#property strict
#property indicator_chart_window
#property indicator_plots 0

#define PREFIX_HUD "HUD_METRIC_"

//--- Inputs
input string   InpHeaderFilters   = "=== History & Filters ==="; // ---
input bool     InpFilterSymbol    = true;                       // Filter Current Symbol Only
input long     InpMagicNumber     = 0;                          // Magic Number (0 = All)
input datetime InpStartDate       = D'2024.01.01 00:00';        // History Start Date
input datetime InpEndDate         = D'2030.01.01 00:00';        // History End Date

input string   InpHeaderUI        = "=== HUD Settings ===";     // ---
input ENUM_BASE_CORNER InpCorner  = CORNER_RIGHT_UPPER;         // Chart Corner
input int      InpXOffset         = 240;                        // X Offset (px)
input int      InpYOffset         = 30;                         // Y Offset (px)
input int      InpRowHeight       = 18;                         // Row Height (px)
input color    InpTextColor       = clrWhite;                   // Label Text Color

//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int OnInit()
{
   UpdateDashboard();
   return(INIT_SUCCEEDED);
}

//+------------------------------------------------------------------+
//| Custom indicator deinitialization function                       |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
   ObjectsDeleteAll(0, PREFIX_HUD);
   ChartRedraw(0);
}

//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int OnCalculate(const int rates_total,
                const int prev_calculated,
                const datetime &time[],
                const double &open[],
                const double &high[],
                const double &low[],
                const double &close[],
                const long &tick_volume[],
                const long &volume[],
                const int &spread[])
{
   // Recalculate and update HUD on new ticks or recalculations
   UpdateDashboard();
   return(rates_total);
}

//+------------------------------------------------------------------+
//| Calculate performance metrics and redraw HUD                     |
//+------------------------------------------------------------------+
void UpdateDashboard()
{
   int    totalTrades  = 0;
   int    wins         = 0;
   int    losses       = 0;
   double grossProfit  = 0.0;
   double grossLoss    = 0.0;
   double netProfit    = 0.0;

   int totalHistory = OrdersHistoryTotal();
   for(int i = 0; i < totalHistory; i++)
   {
      if(!OrderSelect(i, SELECT_BY_POS, MODE_HISTORY)) continue;
      
      // Filter out non-trading operations (deposits, credits)
      if(OrderType() != OP_BUY && OrderType() != OP_SELL) continue;
      
      if(InpFilterSymbol && OrderSymbol() != _Symbol) continue;
      if(InpMagicNumber > 0 && OrderMagicNumber() != InpMagicNumber) continue;
      if(OrderCloseTime() < InpStartDate || OrderCloseTime() > InpEndDate) continue;

      // Realized profit includes swap and commission
      double pnl = OrderProfit() + OrderCommission() + OrderSwap();
      netProfit += pnl;
      totalTrades++;

      if(pnl > 0.0)
      {
         wins++;
         grossProfit += pnl;
      }
      else if(pnl < 0.0)
      {
         losses++;
         grossLoss += MathAbs(pnl);
      }
   }

   // Metric Derivations
   double winRate      = totalTrades > 0 ? ((double)wins / totalTrades) * 100.0 : 0.0;
   double avgWin       = wins > 0 ? (grossProfit / wins) : 0.0;
   double avgLoss      = losses > 0 ? (grossLoss / losses) : 0.0;
   double rrRatio      = avgLoss > 0.0 ? (avgWin / avgLoss) : 0.0;
   double profitFactor = grossLoss > 0.0 ? (grossProfit / grossLoss) : (grossProfit > 0.0 ? 99.0 : 0.0);
   double expectancy   = (winRate / 100.0 * avgWin) - ((1.0 - winRate / 100.0) * avgLoss);

   // Dynamic Color Coding
   color wrColor  = (winRate >= 50.0) ? clrMediumSeaGreen : clrCrimson;
   color rrColor  = (rrRatio >= 1.5) ? clrMediumSeaGreen : (rrRatio >= 1.0 ? clrGoldenrod : clrCrimson);
   color pfColor  = (profitFactor >= 1.5) ? clrMediumSeaGreen : (profitFactor >= 1.0 ? clrGoldenrod : clrCrimson);
   color expColor = (expectancy > 0.0) ? clrMediumSeaGreen : clrCrimson;
   color npColor  = (netProfit >= 0.0) ? clrMediumSeaGreen : clrCrimson;

   // Render Panel
   RenderPanelBackground(230, 7 * InpRowHeight + 16);
   
   RenderRow(0, "Total Trades:", IntegerToString(totalTrades), clrWhite);
   RenderRow(1, "Win Rate:", DoubleToString(winRate, 2) + "%", wrColor);
   RenderRow(2, "Realized R:R:", "1 : " + DoubleToString(rrRatio, 2), rrColor);
   RenderRow(3, "Profit Factor:", DoubleToString(profitFactor, 2), pfColor);
   RenderRow(4, "Expectancy / Trade:", DoubleToString(expectancy, 2), expColor);
   RenderRow(5, "Avg Win / Loss:", DoubleToString(avgWin, 2) + " / " + DoubleToString(avgLoss, 2), clrSilver);
   RenderRow(6, "Net Profit:", DoubleToString(netProfit, 2), npColor);

   ChartRedraw(0);
}

//+------------------------------------------------------------------+
//| GUI Helper: Render Background Panel                              |
//+------------------------------------------------------------------+
void RenderPanelBackground(int width, int height)
{
   string name = PREFIX_HUD + "BG";
   if(ObjectFind(0, name) < 0)
   {
      ObjectCreate(0, name, OBJ_RECTANGLE_LABEL, 0, 0, 0);
      ObjectSetInteger(0, name, OBJPROP_CORNER, InpCorner);
      ObjectSetInteger(0, name, OBJPROP_XDISTANCE, InpXOffset + 10);
      ObjectSetInteger(0, name, OBJPROP_YDISTANCE, InpYOffset - 8);
      ObjectSetInteger(0, name, OBJPROP_XSIZE, width);
      ObjectSetInteger(0, name, OBJPROP_YSIZE, height);
      ObjectSetInteger(0, name, OBJPROP_BGCOLOR, C'20,24,35');
      ObjectSetInteger(0, name, OBJPROP_BORDER_COLOR, C'60,65,80');
      ObjectSetInteger(0, name, OBJPROP_BORDER_TYPE, BORDER_FLAT);
      ObjectSetInteger(0, name, OBJPROP_BACK, false);
      ObjectSetInteger(0, name, OBJPROP_SELECTABLE, false);
   }
}

//+------------------------------------------------------------------+
//| GUI Helper: Render Single Data Row                               |
//+------------------------------------------------------------------+
void RenderRow(int row, string title, string val, color valColor)
{
   string titleName = PREFIX_HUD + "T_" + IntegerToString(row);
   string valName   = PREFIX_HUD + "V_" + IntegerToString(row);
   int yPos = InpYOffset + (row * InpRowHeight);

   // Title Label
   if(ObjectFind(0, titleName) < 0)
   {
      ObjectCreate(0, titleName, OBJ_LABEL, 0, 0, 0);
      ObjectSetInteger(0, titleName, OBJPROP_CORNER, InpCorner);
      ObjectSetInteger(0, titleName, OBJPROP_XDISTANCE, InpXOffset);
      ObjectSetString(0, titleName, OBJPROP_FONT, "Segoe UI");
      ObjectSetInteger(0, titleName, OBJPROP_FONTSIZE, 9);
      ObjectSetInteger(0, titleName, OBJPROP_COLOR, InpTextColor);
      ObjectSetInteger(0, titleName, OBJPROP_SELECTABLE, false);
   }
   ObjectSetInteger(0, titleName, OBJPROP_YDISTANCE, yPos);
   ObjectSetString(0, titleName, OBJPROP_TEXT, title);

   // Value Label
   if(ObjectFind(0, valName) < 0)
   {
      ObjectCreate(0, valName, OBJ_LABEL, 0, 0, 0);
      ObjectSetInteger(0, valName, OBJPROP_CORNER, InpCorner);
      ObjectSetInteger(0, valName, OBJPROP_XDISTANCE, InpXOffset - 120);
      ObjectSetString(0, valName, OBJPROP_FONT, "Segoe UI Semibold");
      ObjectSetInteger(0, valName, OBJPROP_FONTSIZE, 9);
      ObjectSetInteger(0, valName, OBJPROP_SELECTABLE, false);
   }
   ObjectSetInteger(0, valName, OBJPROP_YDISTANCE, yPos);
   ObjectSetString(0, valName, OBJPROP_TEXT, val);
   ObjectSetInteger(0, valName, OBJPROP_COLOR, valColor);
}

[PTScalper]

MetaTrader 5 (MQL5)

MT5 uses deals and orders rather than MT4's flat ticket system. The metric engine reads DEAL_ENTRY_OUT and DEAL_ENTRY_OUT_BY events to capture true round-turn completed trades, fees, commissions, and swaps.

Save this as RealizedMetricsHUD.mq5 in your MQL5/Indicators folder.

Code: Select all

//+------------------------------------------------------------------+
//|                                           RealizedMetricsHUD.mq5 |
//|                                  Copyright 2026, Quant Metrics   |
//+------------------------------------------------------------------+
#property copyright "Quant Metrics"
#property link      ""
#property version   "1.00"
#property indicator_chart_window
#property indicator_plots 0

#define PREFIX_HUD "HUD_METRIC_"

//--- Inputs
input group "=== History & Filters ==="
input bool     InpFilterSymbol    = true;                       // Filter Current Symbol Only
input long     InpMagicNumber     = 0;                          // Magic Number (0 = All)
input datetime InpStartDate       = D'2024.01.01 00:00';        // History Start Date
input datetime InpEndDate         = D'2030.01.01 00:00';        // History End Date

input group "=== HUD Settings ==="
input ENUM_BASE_CORNER InpCorner  = CORNER_RIGHT_UPPER;         // Chart Corner
input int      InpXOffset         = 240;                        // X Offset (px)
input int      InpYOffset         = 30;                         // Y Offset (px)
input int      InpRowHeight       = 18;                         // Row Height (px)
input color    InpTextColor       = clrWhite;                   // Label Text Color

//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int OnInit()
{
   UpdateDashboard();
   return(INIT_SUCCEEDED);
}

//+------------------------------------------------------------------+
//| Custom indicator deinitialization function                       |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
   ObjectsDeleteAll(0, PREFIX_HUD);
   ChartRedraw(0);
}

//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int OnCalculate(const int rates_total,
                const int prev_calculated,
                const datetime &time[],
                const double &open[],
                const double &high[],
                const double &low[],
                const double &close[],
                const long &tick_volume[],
                const long &volume[],
                const int &spread[])
{
   UpdateDashboard();
   return(rates_total);
}

//+------------------------------------------------------------------+
//| Calculate performance metrics and redraw HUD                     |
//+------------------------------------------------------------------+
void UpdateDashboard()
{
   int    totalTrades  = 0;
   int    wins         = 0;
   int    losses       = 0;
   double grossProfit  = 0.0;
   double grossLoss    = 0.0;
   double netProfit    = 0.0;

   // Load deal history for the specified window
   if(HistorySelect(InpStartDate, InpEndDate))
   {
      int totalDeals = HistoryDealsTotal();
      for(int i = 0; i < totalDeals; i++)
      {
         ulong ticket = HistoryDealGetTicket(i);
         if(ticket == 0) continue;

         // Only evaluate exiting deals (completed trades)
         long entry = HistoryDealGetInteger(ticket, DEAL_ENTRY);
         if(entry != DEAL_ENTRY_OUT && entry != DEAL_ENTRY_OUT_BY) continue;

         long dealType = HistoryDealGetInteger(ticket, DEAL_TYPE);
         if(dealType != DEAL_TYPE_BUY && dealType != DEAL_TYPE_SELL) continue;

         string symbol = HistoryDealGetString(ticket, DEAL_SYMBOL);
         if(InpFilterSymbol && symbol != _Symbol) continue;

         long magic = HistoryDealGetInteger(ticket, DEAL_MAGIC);
         if(InpMagicNumber > 0 && magic != InpMagicNumber) continue;

         // Full cost realization: Profit + Swap + Commission + Broker Fee
         double pnl = HistoryDealGetDouble(ticket, DEAL_PROFIT)
                    + HistoryDealGetDouble(ticket, DEAL_SWAP)
                    + HistoryDealGetDouble(ticket, DEAL_COMMISSION)
                    + HistoryDealGetDouble(ticket, DEAL_FEE);

         netProfit += pnl;
         totalTrades++;

         if(pnl > 0.0)
         {
            wins++;
            grossProfit += pnl;
         }
         else if(pnl < 0.0)
         {
            losses++;
            grossLoss += MathAbs(pnl);
         }
      }
   }

   // Metric Derivations
   double winRate      = totalTrades > 0 ? ((double)wins / totalTrades) * 100.0 : 0.0;
   double avgWin       = wins > 0 ? (grossProfit / wins) : 0.0;
   double avgLoss      = losses > 0 ? (grossLoss / losses) : 0.0;
   double rrRatio      = avgLoss > 0.0 ? (avgWin / avgLoss) : 0.0;
   double profitFactor = grossLoss > 0.0 ? (grossProfit / grossLoss) : (grossProfit > 0.0 ? 99.0 : 0.0);
   double expectancy   = (winRate / 100.0 * avgWin) - ((1.0 - winRate / 100.0) * avgLoss);

   // Dynamic Color Coding
   color wrColor  = (winRate >= 50.0) ? clrMediumSeaGreen : clrCrimson;
   color rrColor  = (rrRatio >= 1.5) ? clrMediumSeaGreen : (rrRatio >= 1.0 ? clrGoldenrod : clrCrimson);
   color pfColor  = (profitFactor >= 1.5) ? clrMediumSeaGreen : (profitFactor >= 1.0 ? clrGoldenrod : clrCrimson);
   color expColor = (expectancy > 0.0) ? clrMediumSeaGreen : clrCrimson;
   color npColor  = (netProfit >= 0.0) ? clrMediumSeaGreen : clrCrimson;

   // Render Panel
   RenderPanelBackground(230, 7 * InpRowHeight + 16);

   RenderRow(0, "Total Trades:", IntegerToString(totalTrades), clrWhite);
   RenderRow(1, "Win Rate:", DoubleToString(winRate, 2) + "%", wrColor);
   RenderRow(2, "Realized R:R:", "1 : " + DoubleToString(rrRatio, 2), rrColor);
   RenderRow(3, "Profit Factor:", DoubleToString(profitFactor, 2), pfColor);
   RenderRow(4, "Expectancy / Trade:", DoubleToString(expectancy, 2), expColor);
   RenderRow(5, "Avg Win / Loss:", DoubleToString(avgWin, 2) + " / " + DoubleToString(avgLoss, 2), clrSilver);
   RenderRow(6, "Net Profit:", DoubleToString(netProfit, 2), npColor);

   ChartRedraw(0);
}

//+------------------------------------------------------------------+
//| GUI Helper: Render Background Panel                              |
//+------------------------------------------------------------------+
void RenderPanelBackground(int width, int height)
{
   string name = PREFIX_HUD + "BG";
   if(ObjectFind(0, name) < 0)
   {
      ObjectCreate(0, name, OBJ_RECTANGLE_LABEL, 0, 0, 0);
      ObjectSetInteger(0, name, OBJPROP_CORNER, InpCorner);
      ObjectSetInteger(0, name, OBJPROP_XDISTANCE, InpXOffset + 10);
      ObjectSetInteger(0, name, OBJPROP_YDISTANCE, InpYOffset - 8);
      ObjectSetInteger(0, name, OBJPROP_XSIZE, width);
      ObjectSetInteger(0, name, OBJPROP_YSIZE, height);
      ObjectSetInteger(0, name, OBJPROP_BGCOLOR, C'20,24,35');
      ObjectSetInteger(0, name, OBJPROP_BORDER_COLOR, C'60,65,80');
      ObjectSetInteger(0, name, OBJPROP_BORDER_TYPE, BORDER_FLAT);
      ObjectSetInteger(0, name, OBJPROP_BACK, false);
      ObjectSetInteger(0, name, OBJPROP_SELECTABLE, false);
   }
}

//+------------------------------------------------------------------+
//| GUI Helper: Render Single Data Row                               |
//+------------------------------------------------------------------+
void RenderRow(int row, string title, string val, color valColor)
{
   string titleName = PREFIX_HUD + "T_" + IntegerToString(row);
   string valName   = PREFIX_HUD + "V_" + IntegerToString(row);
   int yPos = InpYOffset + (row * InpRowHeight);

   // Title Label
   if(ObjectFind(0, titleName) < 0)
   {
      ObjectCreate(0, titleName, OBJ_LABEL, 0, 0, 0);
      ObjectSetInteger(0, titleName, OBJPROP_CORNER, InpCorner);
      ObjectSetInteger(0, titleName, OBJPROP_XDISTANCE, InpXOffset);
      ObjectSetString(0, titleName, OBJPROP_FONT, "Segoe UI");
      ObjectSetInteger(0, titleName, OBJPROP_FONTSIZE, 9);
      ObjectSetInteger(0, titleName, OBJPROP_COLOR, InpTextColor);
      ObjectSetInteger(0, titleName, OBJPROP_SELECTABLE, false);
   }
   ObjectSetInteger(0, titleName, OBJPROP_YDISTANCE, yPos);
   ObjectSetString(0, titleName, OBJPROP_TEXT, title);

   // Value Label
   if(ObjectFind(0, valName) < 0)
   {
      ObjectCreate(0, valName, OBJ_LABEL, 0, 0, 0);
      ObjectSetInteger(0, valName, OBJPROP_CORNER, InpCorner);
      ObjectSetInteger(0, valName, OBJPROP_XDISTANCE, InpXOffset - 120);
      ObjectSetString(0, valName, OBJPROP_FONT, "Segoe UI Semibold");
      ObjectSetInteger(0, valName, OBJPROP_FONTSIZE, 9);
      ObjectSetInteger(0, valName, OBJPROP_SELECTABLE, false);
   }
   ObjectSetInteger(0, valName, OBJPROP_YDISTANCE, yPos);
   ObjectSetString(0, valName, OBJPROP_TEXT, val);
   ObjectSetInteger(0, valName, OBJPROP_COLOR, valColor);
}

[PTScalper]

Key Differences & Setup Notes:

MT4 vs. MT5 History API: MT4 evaluates flat order positions in the history pool (OrdersHistoryTotal()), while MT5 queries the deal log (HistorySelect()) and explicitly filters for closing transitions (DEAL_ENTRY_OUT), preventing duplicate counting of entries.

Cost Accounting: Both scripts sum Commission + Swap + Fees into the PnL of each trade. A break-even stop loss that costs $3.50 in round-turn commissions is treated as a realized small loss rather than an artificial scratch win.

Positioning: Both default to the top-right corner (CORNER_RIGHT_UPPER). You can freely adjust InpXOffset, InpYOffset, or change the anchor corner in the indicator properties without modifying the code.