forex-scalping.com

Code: Select all

//@version=5
strategy("Overtrading Controller [Daily Limits]", overlay=true, default_qty_type=strategy.percent_of_equity, default_qty_value=10)

// --- Inputs ---
maxDailyLoss   = input.float(500, title="Max Daily Loss ($)", group="Risk Management")
maxDailyTrades = input.int(3, title="Max Daily Trades", group="Risk Management")

// --- Daily Reset Logic ---
var int tradesToday = 0
isNewDay = ta.change(time("D"))

if isNewDay
    tradesToday := 0

// --- Built-in Risk Management ---
// Hard stops trading for the day if the loss limit is hit
strategy.risk.max_intraday_loss(maxDailyLoss, strategy.cash)

// --- Entry Logic & Permission ---
// Replace these with your actual strategy conditions
longCondition = ta.crossover(ta.sma(close, 10), ta.sma(close, 20))
shortCondition = ta.crossunder(ta.sma(close, 10), ta.sma(close, 20))

// Permission Check: Only trade if under the daily ticket limit
canTrade = tradesToday < maxDailyTrades

if (longCondition and canTrade)
    strategy.entry("Long", strategy.long)
    tradesToday += 1

if (shortCondition and canTrade)
    strategy.entry("Short", strategy.short)
    tradesToday += 1

// --- Visual Dashboard ---
if barstate.islast
    var label dashboard = label.new(x=bar_index, y=high, text="", color=color.new(color.black, 80), textcolor=color.white, style=label.style_label_left, yloc=yloc.price)
    statusText = "Trades Today: " + str.tostring(tradesToday) + " / " + str.tostring(maxDailyTrades)
    statusText += "\nPermission: " + (canTrade ? "GRANTED" : "REVOKED (Limit Reached)")
    label.set_text(dashboard, statusText)
    label.set_xy(dashboard, bar_index + 5, close)

Code: Select all

//+------------------------------------------------------------------+
//|                                     OvertradingController.mq4    |
//|                                  Daily Limit & Permission HUD    |
//+------------------------------------------------------------------+
#property copyright "Trading Discipline Tools"
#property link      ""
#property version   "1.00"
#property indicator_chart_window

//--- Inputs
input group "=== Daily Risk Parameters ==="
input double InpMaxDailyLoss   = 500.0;    // Max Daily Loss (Account Currency)
input int    InpMaxDailyTrades = 3;        // Max Trades Opened Today
input bool   InpIncludeFloating= true;     // Include Floating Drawdown in Loss Limit
input bool   InpSendAlerts     = true;     // Popup & Sound Alerts on Limit Breach

//--- State
datetime glbDayStart = 0;
bool     glbAlertSent = false;

//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int OnInit()
{
   EventSetTimer(1); // 1-second refresh for timer consistency
   DrawDashboard("Initializing...", clrGray);
   return(INIT_SUCCEEDED);
}

//+------------------------------------------------------------------+
//| Custom indicator deinitialization function                       |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
   EventKillTimer();
   ObjectDelete(0, "OTC_Panel_BG");
   ObjectDelete(0, "OTC_Panel_Title");
   ObjectDelete(0, "OTC_Panel_Trades");
   ObjectDelete(0, "OTC_Panel_PnL");
   ObjectDelete(0, "OTC_Panel_Status");
}

//+------------------------------------------------------------------+
//| Timer & Tick handling                                            |
//+------------------------------------------------------------------+
void OnTimer()
{
   RunCheck();
}

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[])
{
   RunCheck();
   return(rates_total);
}

//+------------------------------------------------------------------+
//| Main calculation and permission evaluation                       |
//+------------------------------------------------------------------+
void RunCheck()
{
   datetime currentDayStart = iTime(_Symbol, PERIOD_D1, 0);
   if(currentDayStart != glbDayStart)
   {
      glbDayStart = currentDayStart;
      glbAlertSent = false; // Reset daily alert flag
   }

   int    tradesOpenedToday = 0;
   double closedDailyPnL    = 0.0;
   double floatingPnL       = 0.0;

   // 1. Scan closed trades from history
   int histTotal = OrdersHistoryTotal();
   for(int i = 0; i < histTotal; i++)
   {
      if(OrderSelect(i, SELECT_BY_POS, MODE_HISTORY))
      {
         if(OrderType() == OP_BUY || OrderType() == OP_SELL)
         {
            if(OrderOpenTime() >= glbDayStart)
               tradesOpenedToday++;

            if(OrderCloseTime() >= glbDayStart)
               closedDailyPnL += (OrderProfit() + OrderSwap() + OrderCommission());
         }
      }
   }

   // 2. Scan currently open positions
   int openTotal = OrdersTotal();
   for(int j = 0; j < openTotal; j++)
   {
      if(OrderSelect(j, SELECT_BY_POS, MODE_TRADES))
      {
         if(OrderType() == OP_BUY || OrderType() == OP_SELL)
         {
            if(OrderOpenTime() >= glbDayStart)
               tradesOpenedToday++;

            floatingPnL += (OrderProfit() + OrderSwap() + OrderCommission());
         }
      }
   }

   double totalEffectivePnL = closedDailyPnL + (InpIncludeFloating ? floatingPnL : 0.0);

   // 3. Permission Evaluation
   bool tradeLimitHit = (tradesOpenedToday >= InpMaxDailyTrades);
   bool lossLimitHit  = (totalEffectivePnL <= -InpMaxDailyLoss);
   bool permitted     = (!tradeLimitHit && !lossLimitHit);

   string statusStr = "";
   color  statusColor = clrLime;

   if(!permitted)
   {
      statusColor = clrCrimson;
      if(tradeLimitHit && lossLimitHit)
         statusStr = "REVOKED (Limit & Loss Reached)";
      else if(tradeLimitHit)
         statusStr = "REVOKED (Max Trades Hit)";
      else
         statusStr = "REVOKED (Max Loss Hit)";

      if(InpSendAlerts && !glbAlertSent)
      {
         Alert(StringFormat("[Overtrading Controller] %s breached! Trading PERMISSION REVOKED.", _Symbol));
         glbAlertSent = true;
      }
   }
   else
   {
      statusStr = "GRANTED";
   }

   // 4. Update HUD
   UpdateDashboard(tradesOpenedToday, totalEffectivePnL, statusStr, statusColor);
}

//+------------------------------------------------------------------+
//| On-screen HUD visual objects                                     |
//+------------------------------------------------------------------+
void DrawDashboard(string initText, color initCol)
{
   CreateLabel("OTC_Panel_Title",  20, 30, "=== PERMISSION CONTROLLER ===", clrSilver, 9, true);
   CreateLabel("OTC_Panel_Trades", 20, 50, "Trades Today: --", clrWhite, 9, false);
   CreateLabel("OTC_Panel_PnL",    20, 70, "Daily P&L: --", clrWhite, 9, false);
   CreateLabel("OTC_Panel_Status", 20, 95, "PERMISSION: " + initText, initCol, 10, true);
}

void UpdateDashboard(int count, double pnl, string status, color col)
{
   ObjectSetString(0, "OTC_Panel_Trades", OBJPROP_TEXT, StringFormat("Tickets Opened Today: %d / %d", count, InpMaxDailyTrades));
   ObjectSetString(0, "OTC_Panel_PnL", OBJPROP_TEXT, StringFormat("Session Net P&L: %.2f (Limit: -%.2f)", pnl, InpMaxDailyLoss));
   ObjectSetString(0, "OTC_Panel_Status", OBJPROP_TEXT, "PERMISSION: " + status);
   ObjectSetInteger(0, "OTC_Panel_Status", OBJPROP_COLOR, col);
}

void CreateLabel(string name, int x, int y, string text, color clr, int fontSize, bool bold)
{
   if(ObjectFind(0, name) < 0)
      ObjectCreate(0, name, OBJ_LABEL, 0, 0, 0);

   ObjectSetInteger(0, name, OBJPROP_CORNER, CORNER_LEFT_UPPER);
   ObjectSetInteger(0, name, OBJPROP_XDISTANCE, x);
   ObjectSetInteger(0, name, OBJPROP_YDISTANCE, y);
   ObjectSetString(0, name, OBJPROP_TEXT, text);
   ObjectSetInteger(0, name, OBJPROP_COLOR, clr);
   ObjectSetInteger(0, name, OBJPROP_FONTSIZE, fontSize);
   ObjectSetString(0, name, OBJPROP_FONT, bold ? "Arial Bold" : "Arial");
   ObjectSetInteger(0, name, OBJPROP_SELECTABLE, false);
}

Code: Select all

//+------------------------------------------------------------------+
//|                                     OvertradingController.mq5    |
//|                                  Daily Limit & Permission HUD    |
//+------------------------------------------------------------------+
#property copyright "Trading Discipline Tools"
#property link      ""
#property version   "1.00"
#property indicator_chart_window
#property indicator_plots 0

//--- Inputs
input group "=== Daily Risk Settings ==="
input double InpMaxDailyLoss   = 500.0;    // Max Daily Loss (Account Currency)
input int    InpMaxDailyTrades = 3;        // Max Trades Opened Today
input bool   InpIncludeFloating= true;     // Include Floating Drawdown in Loss Limit
input bool   InpSendAlerts     = true;     // Popup & Sound Alert on Limit Breach

//--- Global Variables
datetime glbDayStart  = 0;
bool     glbAlertSent = false;

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

//+------------------------------------------------------------------+
//| Custom indicator deinitialization function                       |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
   EventKillTimer();
   ObjectDelete(0, "OTC5_Title");
   ObjectDelete(0, "OTC5_Trades");
   ObjectDelete(0, "OTC5_PnL");
   ObjectDelete(0, "OTC5_Status");
}

//+------------------------------------------------------------------+
//| Event Handlers                                                   |
//+------------------------------------------------------------------+
void OnTimer()
{
   EvaluateLimits();
}

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[])
{
   EvaluateLimits();
   return(rates_total);
}

//+------------------------------------------------------------------+
//| Core Limit Calculation                                           |
//+------------------------------------------------------------------+
void EvaluateLimits()
{
   datetime now = TimeCurrent();
   MqlDateTime dt;
   TimeToStruct(now, dt);
   dt.hour = 0; dt.min = 0; dt.sec = 0;
   datetime currentDayStart = StructToTime(dt);

   if(currentDayStart != glbDayStart)
   {
      glbDayStart = currentDayStart;
      glbAlertSent = false;
   }

   int    entriesCount   = 0;
   double closedDailyPnL = 0.0;
   double floatingPnL    = 0.0;

   // 1. History Deals since 00:00 broker time
   if(HistorySelect(glbDayStart, now))
   {
      int totalDeals = HistoryDealsTotal();
      for(int i = 0; i < totalDeals; i++)
      {
         ulong dealTicket = HistoryDealGetTicket(i);
         if(dealTicket > 0)
         {
            long entryType = HistoryDealGetInteger(dealTicket, DEAL_ENTRY);
            
            // Count tickets opened today
            if(entryType == DEAL_ENTRY_IN)
               entriesCount++;

            // Sum closed profits/losses
            closedDailyPnL += HistoryDealGetDouble(dealTicket, DEAL_PROFIT)
                            + HistoryDealGetDouble(dealTicket, DEAL_SWAP)
                            + HistoryDealGetDouble(dealTicket, DEAL_COMMISSION)
                            + HistoryDealGetDouble(dealTicket, DEAL_FEE);
         }
      }
   }

   // 2. Open Positions
   int openPositions = PositionsTotal();
   for(int j = 0; j < openPositions; j++)
   {
      ulong posTicket = PositionGetTicket(j);
      if(posTicket > 0)
      {
         floatingPnL += PositionGetDouble(POSITION_PROFIT)
                      + PositionGetDouble(POSITION_SWAP);
      }
   }

   double totalEffectivePnL = closedDailyPnL + (InpIncludeFloating ? floatingPnL : 0.0);

   // 3. Permission State
   bool tradeLimitHit = (entriesCount >= InpMaxDailyTrades);
   bool lossLimitHit  = (totalEffectivePnL <= -InpMaxDailyLoss);
   bool permitted     = (!tradeLimitHit && !lossLimitHit);

   string statusStr = "";
   color  statusColor = clrLime;

   if(!permitted)
   {
      statusColor = clrCrimson;
      if(tradeLimitHit && lossLimitHit)
         statusStr = "REVOKED (Trades & Loss Limits Hit)";
      else if(tradeLimitHit)
         statusStr = "REVOKED (Max Trades Hit)";
      else
         statusStr = "REVOKED (Max Daily Loss Hit)";

      if(InpSendAlerts && !glbAlertSent)
      {
         Alert(StringFormat("[MT5 Overtrading Controller] %s breached! PERMISSION REVOKED.", _Symbol));
         glbAlertSent = true;
      }
   }
   else
   {
      statusStr = "GRANTED";
   }

   // 4. Update Display
   ObjectSetString(0, "OTC5_Trades", OBJPROP_TEXT, StringFormat("Tickets Opened Today: %d / %d", entriesCount, InpMaxDailyTrades));
   ObjectSetString(0, "OTC5_PnL", OBJPROP_TEXT, StringFormat("Session Net P&L: %.2f (Limit: -%.2f)", totalEffectivePnL, InpMaxDailyLoss));
   ObjectSetString(0, "OTC5_Status", OBJPROP_TEXT, "PERMISSION: " + statusStr);
   ObjectSetInteger(0, "OTC5_Status", OBJPROP_COLOR, statusColor);
   ChartRedraw(0);
}

//+------------------------------------------------------------------+
//| Initialize UI Labels                                             |
//+------------------------------------------------------------------+
void InitHUD()
{
   CreateHUDLabel("OTC5_Title",  20, 30, "=== PERMISSION CONTROLLER ===", clrSilver, 9, true);
   CreateHUDLabel("OTC5_Trades", 20, 50, "Tickets Opened Today: --", clrWhite, 9, false);
   CreateHUDLabel("OTC5_PnL",    20, 70, "Session Net P&L: --", clrWhite, 9, false);
   CreateHUDLabel("OTC5_Status", 20, 95, "PERMISSION: Initializing...", clrGray, 10, true);
}

void CreateHUDLabel(string name, int x, int y, string text, color clr, int fontSize, bool bold)
{
   if(ObjectFind(0, name) < 0)
      ObjectCreate(0, name, OBJ_LABEL, 0, 0, 0);

   ObjectSetInteger(0, name, OBJPROP_CORNER, CORNER_LEFT_UPPER);
   ObjectSetInteger(0, name, OBJPROP_XDISTANCE, x);
   ObjectSetInteger(0, name, OBJPROP_YDISTANCE, y);
   ObjectSetString(0, name, OBJPROP_TEXT, text);
   ObjectSetInteger(0, name, OBJPROP_COLOR, clr);
   ObjectSetInteger(0, name, OBJPROP_FONTSIZE, fontSize);
   ObjectSetString(0, name, OBJPROP_FONT, bold ? "Arial Bold" : "Arial");
   ObjectSetInteger(0, name, OBJPROP_SELECTABLE, false);
}

Code: Select all

using System;
using System.Linq;
using cAlgo.API;
using cAlgo.API.Internals;
using cAlgo.API.Indicators;
using cAlgo.Indicators;

namespace cAlgo
{
    [Indicator(IsOverlay = true, TimeZone = TimeZones.UTC, AccessRights = AccessRights.None)]
    public class OvertradingController : Indicator
    {
        // --- Parameters ---
        [Parameter("Max Daily Loss ($)", Group = "Risk Limits", DefaultValue = 500.0)]
        public double MaxDailyLoss { get; set; }

        [Parameter("Max Daily Trades", Group = "Risk Limits", DefaultValue = 3)]
        public int MaxDailyTrades { get; set; }

        [Parameter("Include Floating P&L", Group = "Risk Limits", DefaultValue = true)]
        public bool IncludeFloating { get; set; }

        // --- UI Elements ---
        private StackPanel _panel;
        private TextBlock _titleText;
        private TextBlock _tradesText;
        private TextBlock _pnlText;
        private TextBlock _statusText;

        // --- State ---
        private DateTime _currentDay;
        private bool _alertSent;

        protected override void Initialize()
        {
            _currentDay = Server.Time.Date;

            // 1. Build the UI using cTrader's native controls
            _titleText = new TextBlock 
            { 
                Text = "=== PERMISSION CONTROLLER ===", 
                ForegroundColor = Color.Silver, 
                FontWeight = FontWeight.Bold, 
                Margin = new Thickness(0, 0, 0, 5) 
            };
            
            _tradesText = new TextBlock { Text = "Tickets Opened Today: --", ForegroundColor = Color.White };
            _pnlText = new TextBlock { Text = "Session Net P&L: --", ForegroundColor = Color.White };
            
            _statusText = new TextBlock 
            { 
                Text = "PERMISSION: Initializing...", 
                ForegroundColor = Color.Gray, 
                FontWeight = FontWeight.Bold, 
                Margin = new Thickness(0, 5, 0, 0) 
            };

            _panel = new StackPanel
            {
                HorizontalAlignment = HorizontalAlignment.Left,
                VerticalAlignment = VerticalAlignment.Top,
                BackgroundColor = Color.FromArgb(180, 0, 0, 0), // Semi-transparent black
                Margin = new Thickness(20),
                Padding = new Thickness(10)
            };

            _panel.AddChild(_titleText);
            _panel.AddChild(_tradesText);
            _panel.AddChild(_pnlText);
            _panel.AddChild(_statusText);

            Chart.AddControl(_panel);

            // 2. Start timer for 1-second ticks to update floating P&L accurately
            Timer.Start(TimeSpan.FromSeconds(1));
        }

        protected override void OnTimer()
        {
            EvaluateLimits();
        }

        public override void Calculate(int index)
        {
            // Calculation is handled by the Timer to ensure UI updates 
            // even when the market is slow/not ticking.
        }

        private void EvaluateLimits()
        {
            // Reset state at broker midnight
            if (Server.Time.Date != _currentDay)
            {
                _currentDay = Server.Time.Date;
                _alertSent = false;
            }

            // 1. LINQ queries to calculate today's metrics
            var closedTradesToday = History.Where(t => t.EntryTime >= _currentDay).ToList();
            var openPositionsToday = Positions.Where(p => p.EntryTime >= _currentDay).ToList();

            int ticketsOpenedToday = closedTradesToday.Count + openPositionsToday.Count;
            
            double closedPnL = closedTradesToday.Sum(t => t.NetProfit);
            double floatingPnL = IncludeFloating ? Positions.Sum(p => p.NetProfit) : 0;
            double totalEffectivePnL = closedPnL + floatingPnL;

            // 2. Evaluate Permission
            bool tradeLimitHit = ticketsOpenedToday >= MaxDailyTrades;
            bool lossLimitHit = totalEffectivePnL <= -MaxDailyLoss;
            bool permitted = !tradeLimitHit && !lossLimitHit;

            string statusStr;
            Color statusColor = Color.LimeGreen;

            if (!permitted)
            {
                statusColor = Color.Crimson;
                if (tradeLimitHit && lossLimitHit)
                    statusStr = "REVOKED (Trades & Loss Limits Hit)";
                else if (tradeLimitHit)
                    statusStr = "REVOKED (Max Trades Hit)";
                else
                    statusStr = "REVOKED (Max Daily Loss Hit)";

                if (!_alertSent)
                {
                    // Log the breach and trigger an audio alert
                    Print($"[Overtrading Controller] LIMIT BREACHED. {statusStr}");
                    Notifications.PlaySound(SoundType.Doorbell); 
                    _alertSent = true;
                }
            }
            else
            {
                statusStr = "GRANTED";
            }

            // 3. Update the UI
            _tradesText.Text = $"Tickets Opened Today: {ticketsOpenedToday} / {MaxDailyTrades}";
            _pnlText.Text = $"Session Net P&L: {Math.Round(totalEffectivePnL, 2)} (Limit: -{MaxDailyLoss})";
            _statusText.Text = $"PERMISSION: {statusStr}";
            _statusText.ForegroundColor = statusColor;
        }
    }
}