forex-scalping.com

Code: Select all

//@version=5
strategy("Intraday Risk Manager [House Money System]", overlay=true, calc_on_every_tick=true, initial_capital=10000)

// =========================================================================
// 1. INPUTS & RISK PARAMETERS
// =========================================================================
grp_risk = "Core Risk Parameters"
baseRiskPct = input.float(1.0, title="Base Risk per Trade (%)", group=grp_risk)
hardStopPct = input.float(3.0, title="Hard Daily Loss Stop (%)", tooltip="Platform shuts down if daily loss hits this %", group=grp_risk)
softStopPct = input.float(1.0, title="Soft Throttle Drawdown (%)", tooltip="Drawdown % where size is cut in half", group=grp_risk)

grp_house = "House Money (Scaling up on profits)"
useHouseMoney   = input.bool(true, title="Enable House Money Scaling?", group=grp_house)
profitThreshold = input.float(2.0, title="Profit Threshold to Scale (%)", tooltip="Daily profit % required to start risking house money", group=grp_house)
riskProfitPct   = input.float(100.0, title="% of Daily Profit to Risk", tooltip="100% means you risk all intraday profits on the next setup. If you lose, you return to break-even for the day.", group=grp_house)

// =========================================================================
// 2. DAILY PNL TRACKING
// =========================================================================
var float startOfDayEquity = strategy.initial_capital
var float currentRiskPct   = baseRiskPct
var bool  canTradeToday    = true

// Detect new trading day
isNewDay = ta.change(time("D")) != 0

if isNewDay
    startOfDayEquity := strategy.equity
    canTradeToday    := true

// Calculate current daily performance
dailyPnL    = strategy.equity - startOfDayEquity
dailyPnLPct = (dailyPnL / startOfDayEquity) * 100

// =========================================================================
// 3. THE RISK ENGINE
// =========================================================================
// Rule A: Hard Stop
if dailyPnLPct <= -hardStopPct
    canTradeToday := false

// Rule B & C: Throttles and House Money
if canTradeToday
    if dailyPnLPct <= -softStopPct
        // Soft throttle: Cut size in half to catch the spiral
        currentRiskPct := baseRiskPct * 0.5
        
    else if useHouseMoney and dailyPnLPct >= profitThreshold
        // House money: Risk a percentage of the profits you've already made today
        // We use math.max to ensure you at least risk your base amount
        houseMoneyRisk = dailyPnLPct * (riskProfitPct / 100)
        currentRiskPct := math.max(baseRiskPct, houseMoneyRisk)
        
    else
        // Standard operating size
        currentRiskPct := baseRiskPct

// =========================================================================
// 4. EXECUTION (Replace with your actual setups)
// =========================================================================
// Dummy triggers for demonstration
fastMA = ta.sma(close, 9)
slowMA = ta.sma(close, 21)
longSetup  = ta.crossover(fastMA, slowMA)
shortSetup = ta.crossunder(fastMA, slowMA)

// Calculate position size based on current dynamic risk and a fixed 1% Stop Loss
// Formula: Size = (Equity * Risk%) / (Price * SL%)
fixedSlPct = 1.0 
posSize = (strategy.equity * (currentRiskPct / 100)) / (close * (fixedSlPct / 100))

if longSetup and canTradeToday and strategy.opentrades == 0
    strategy.entry("Long", strategy.long, qty=posSize)
    strategy.exit("Exit Long", "Long", loss=close * (fixedSlPct/100) / syminfo.mintick, profit=close * (fixedSlPct*2/100) / syminfo.mintick)

if shortSetup and canTradeToday and strategy.opentrades == 0
    strategy.entry("Short", strategy.short, qty=posSize)
    strategy.exit("Exit Short", "Short", loss=close * (fixedSlPct/100) / syminfo.mintick, profit=close * (fixedSlPct*2/100) / syminfo.mintick)

// =========================================================================
// 5. ON-CHART DASHBOARD
// =========================================================================
var table dash = table.new(position.top_right, 2, 4, border_width = 1, border_color=color.new(color.gray, 50))
if barstate.islast
    // Daily PnL
    table.cell(dash, 0, 0, "Daily PnL %", bgcolor=color.new(color.black, 20), text_color=color.white)
    table.cell(dash, 1, 0, str.tostring(dailyPnLPct, "#.##") + "%", bgcolor=dailyPnLPct > 0 ? color.new(color.green, 50) : color.new(color.red, 50), text_color=color.white)
    
    // Active Risk
    table.cell(dash, 0, 1, "Current Risk %", bgcolor=color.new(color.black, 20), text_color=color.white)
    table.cell(dash, 1, 1, str.tostring(currentRiskPct, "#.##") + "%", bgcolor=color.new(color.blue, 50), text_color=color.white)
    
    // System Status
    table.cell(dash, 0, 2, "Status", bgcolor=color.new(color.black, 20), text_color=color.white)
    table.cell(dash, 1, 2, canTradeToday ? "ACTIVE" : "HALTED", bgcolor=canTradeToday ? color.new(color.green, 50) : color.new(color.red, 50), text_color=color.white)
    
    // Current Mode
    table.cell(dash, 0, 3, "State", bgcolor=color.new(color.black, 20), text_color=color.white)
    modeText = not canTradeToday ? "Hard Stop Hit" : dailyPnLPct <= -softStopPct ? "Throttled Down" : (useHouseMoney and dailyPnLPct >= profitThreshold) ? "House Money" : "Standard Size"
    table.cell(dash, 1, 3, modeText, bgcolor=color.new(color.black, 0), text_color=color.white)

Code: Select all

// --- Input Variables ---
input double InpBaseRiskPct = 1.0;
input double InpHardStopPct = 3.0;
input double InpSoftStopPct = 1.0;
input bool   InpUseHouseMoney = true;
input double InpProfitThresholdPct = 2.0;
input double InpRiskProfitPct = 100.0;

// --- Calculate Intraday Risk ---
double GetDynamicRiskPct() {
    datetime startOfDay = iTime(Symbol(), PERIOD_D1, 0);
    double closedProfitToday = 0.0;
    
    // Sum closed trades for today
    for (int i = 0; i < OrdersHistoryTotal(); i++) {
        if (OrderSelect(i, SELECT_BY_POS, MODE_HISTORY)) {
            if (OrderCloseTime() >= startOfDay) {
                closedProfitToday += OrderProfit() + OrderSwap() + OrderCommission();
            }
        }
    }
    
    // Sum open floating profit
    double openProfit = 0.0;
    for (int i = 0; i < OrdersTotal(); i++) {
        if (OrderSelect(i, SELECT_BY_POS, MODE_TRADES)) {
            openProfit += OrderProfit() + OrderSwap() + OrderCommission();
        }
    }
    
    double dailyPnL = closedProfitToday + openProfit;
    
    // Reconstruct start-of-day equity (assumes no intraday deposits/withdrawals)
    double startOfDayEquity = AccountBalance() - closedProfitToday;
    if (startOfDayEquity <= 0) startOfDayEquity = AccountBalance(); 
    
    double dailyPnLPct = (dailyPnL / startOfDayEquity) * 100.0;
    
    // Rule A: Hard Stop
    if (dailyPnLPct <= -InpHardStopPct) return 0.0; 
    
    // Rule B: Soft Throttle
    if (dailyPnLPct <= -InpSoftStopPct) return InpBaseRiskPct * 0.5;
    
    // Rule C: House Money Scaling
    if (InpUseHouseMoney && dailyPnLPct >= InpProfitThresholdPct) {
        double houseMoneyRisk = dailyPnLPct * (InpRiskProfitPct / 100.0);
        return MathMax(InpBaseRiskPct, houseMoneyRisk);
    }
    
    return InpBaseRiskPct;
}

Code: Select all

// --- Input Variables ---
input double InpBaseRiskPct = 1.0;
input double InpHardStopPct = 3.0;
input double InpSoftStopPct = 1.0;
input bool   InpUseHouseMoney = true;
input double InpProfitThresholdPct = 2.0;
input double InpRiskProfitPct = 100.0;

// --- Calculate Intraday Risk ---
double GetDynamicRiskPct() {
    datetime startOfDay = iTime(_Symbol, PERIOD_D1, 0);
    HistorySelect(startOfDay, TimeCurrent());
    
    double closedProfitToday = 0.0;
    int deals = HistoryDealsTotal();
    
    // Sum closed deals for today
    for (int i = 0; i < deals; i++) {
        ulong ticket = HistoryDealGetTicket(i);
        if (ticket > 0) {
            long entryType = HistoryDealGetInteger(ticket, DEAL_ENTRY);
            
            // Only aggregate exits
            if (entryType == DEAL_ENTRY_OUT || entryType == DEAL_ENTRY_OUT_BY) {
                closedProfitToday += HistoryDealGetDouble(ticket, DEAL_PROFIT) + 
                                     HistoryDealGetDouble(ticket, DEAL_SWAP) + 
                                     HistoryDealGetDouble(ticket, DEAL_COMMISSION);
            }
        }
    }
    
    // Floating profit = Current Equity - Current Balance
    double openProfit = AccountInfoDouble(ACCOUNT_EQUITY) - AccountInfoDouble(ACCOUNT_BALANCE);
    double dailyPnL = closedProfitToday + openProfit;
    
    // Reconstruct start-of-day equity
    double startOfDayEquity = AccountInfoDouble(ACCOUNT_BALANCE) - closedProfitToday;
    if (startOfDayEquity <= 0) startOfDayEquity = AccountInfoDouble(ACCOUNT_BALANCE);
    
    double dailyPnLPct = (dailyPnL / startOfDayEquity) * 100.0;
    
    // Rule A: Hard Stop
    if (dailyPnLPct <= -InpHardStopPct) return 0.0; 
    
    // Rule B: Soft Throttle
    if (dailyPnLPct <= -InpSoftStopPct) return InpBaseRiskPct * 0.5;
    
    // Rule C: House Money Scaling
    if (InpUseHouseMoney && dailyPnLPct >= InpProfitThresholdPct) {
        double houseMoneyRisk = dailyPnLPct * (InpRiskProfitPct / 100.0);
        return MathMax(InpBaseRiskPct, houseMoneyRisk);
    }
    
    return InpBaseRiskPct;
}

Code: Select all

double currentRisk = GetDynamicRiskPct();

if (currentRisk <= 0.0) {
    Comment("System Halted: Daily Hard Stop Hit");
    return; // Block all new entries today
}

// Proceed with order execution using currentRisk for lot sizing

Code: Select all

using System;
using System.Linq;
using cAlgo.API;

namespace cAlgo.Robots
{
    [Robot(TimeZone = TimeZones.UTC, AccessRights = AccessRights.None)]
    public class IntradayRiskManager : Robot
    {
        // --- Input Parameters ---
        [Parameter("Base Risk per Trade (%)", Group = "Core Risk", DefaultValue = 1.0)]
        public double BaseRiskPct { get; set; }

        [Parameter("Hard Daily Loss Stop (%)", Group = "Core Risk", DefaultValue = 3.0)]
        public double HardStopPct { get; set; }

        [Parameter("Soft Throttle Drawdown (%)", Group = "Core Risk", DefaultValue = 1.0)]
        public double SoftStopPct { get; set; }

        [Parameter("Enable House Money Scaling?", Group = "House Money", DefaultValue = true)]
        public bool UseHouseMoney { get; set; }

        [Parameter("Profit Threshold to Scale (%)", Group = "House Money", DefaultValue = 2.0)]
        public double ProfitThresholdPct { get; set; }

        [Parameter("% of Daily Profit to Risk", Group = "House Money", DefaultValue = 100.0)]
        public double RiskProfitPct { get; set; }

        // --- Core Risk Engine ---
        private double GetDynamicRiskPct()
        {
            // 1. Define start of the trading day based on broker server time
            DateTime startOfDay = Server.Time.Date;

            // 2. Sum closed profit for today (NetProfit already includes commissions + swap)
            double closedProfitToday = History
                .Where(trade => trade.ClosingTime >= startOfDay)
                .Sum(trade => trade.NetProfit);

            // 3. Sum open floating profit
            double openProfit = Positions.Sum(pos => pos.NetProfit);
            
            double dailyPnL = closedProfitToday + openProfit;

            // 4. Reconstruct Start-of-Day Equity
            double startOfDayEquity = Account.Balance - closedProfitToday;
            if (startOfDayEquity <= 0) 
                startOfDayEquity = Account.Balance; // Fallback

            double dailyPnLPct = (dailyPnL / startOfDayEquity) * 100.0;

            // Rule A: Hard Stop
            if (dailyPnLPct <= -HardStopPct) 
                return 0.0;

            // Rule B: Soft Throttle
            if (dailyPnLPct <= -SoftStopPct) 
                return BaseRiskPct * 0.5;

            // Rule C: House Money Scaling
            if (UseHouseMoney && dailyPnLPct >= ProfitThresholdPct)
            {
                double houseMoneyRisk = dailyPnLPct * (RiskProfitPct / 100.0);
                return Math.Max(BaseRiskPct, houseMoneyRisk); // Ensures you never scale down below base risk during a green streak
            }

            // Default: Standard size
            return BaseRiskPct;
        }

        // --- Execution Loop Example ---
        protected override void OnTick()
        {
            double currentRiskPct = GetDynamicRiskPct();

            // Intercept and halt if hard stop is hit
            if (currentRiskPct <= 0.0)
            {
                Chart.DrawStaticText("RiskStatus", "SYSTEM HALTED: Hard Stop Hit", 
                    VerticalAlignment.Top, HorizontalAlignment.Right, Color.Red);
                
                // Block all further trade entry logic
                return; 
            }
            
            Chart.DrawStaticText("RiskStatus", $"Active Risk: {currentRiskPct:F2}%", 
                VerticalAlignment.Top, HorizontalAlignment.Right, Color.DodgerBlue);

            // -------------------------------------------------------------
            // Place your price action triggers and execution logic below.
            // When calculating volume/lot size, use currentRiskPct.
            // -------------------------------------------------------------
        }
    }
}