forex-scalping.com

Code: Select all

//+------------------------------------------------------------------+
//|                                        HouseMoney_Engine_MT5.mq5 |
//+------------------------------------------------------------------+
#property strict
#include <Trade\Trade.mqh>

// --- Risk Management Engine ---
input double InpReferenceBalance = 100000.0; // Reference Baseline (0 = use current balance)
input double InpBaseRiskPct      = 0.5;      // Base Risk (%)
input double InpScaledRiskPct    = 1.5;      // Scaled Risk (%)
input double InpProfitBuffer     = 5.0;      // Activation Threshold (%)
input double InpHardStopEq       = 10.0;     // Max Drawdown Killswitch (%)

// --- Execution Parameters ---
input int    InpSLPoints         = 150;      // Stop Loss (Points)
input int    InpTPPoints         = 350;      // Take Profit (Points)
input ulong  InpMagicNumber      = 77777;    // Magic Number

double initBalance;
datetime lastBarTime;
CTrade trade;

//+------------------------------------------------------------------+
int OnInit() {
    initBalance = (InpReferenceBalance > 0) ? InpReferenceBalance : AccountInfoDouble(ACCOUNT_BALANCE);
    trade.SetExpertMagicNumber(InpMagicNumber);
    lastBarTime = iTime(_Symbol, PERIOD_CURRENT, 0);
    return(INIT_SUCCEEDED);
}

//+------------------------------------------------------------------+
void OnTick() {
    datetime currentTime = iTime(_Symbol, PERIOD_CURRENT, 0);
    if(currentTime == lastBarTime) return;
    lastBarTime = currentTime;

    double currentEq = AccountInfoDouble(ACCOUNT_EQUITY);
    double killswitchEq = initBalance * (1.0 - (InpHardStopEq / 100.0));
    double targetEq = initBalance * (1.0 + (InpProfitBuffer / 100.0));

    // Hard Stop Killswitch
    if(currentEq <= killswitchEq) {
        CloseAllPositions();
        Print("HARD STOP: Drawdown limit breached. Trading halted.");
        ExpertRemove();
        return;
    }

    // Only allow one open position
    if(PositionsTotal() > 0) return;

    // Buffer arrays for price data
    double high[], low[], close[];
    ArraySetAsSeries(high, true); ArraySetAsSeries(low, true); ArraySetAsSeries(close, true);
    
    if(CopyHigh(_Symbol, PERIOD_CURRENT, 0, 8, high) <= 0) return;
    if(CopyLow(_Symbol, PERIOD_CURRENT, 0, 8, low) <= 0) return;
    if(CopyClose(_Symbol, PERIOD_CURRENT, 0, 3, close) <= 0) return;

    // Structure detection: 5-bar lookback pivot (indexes 2 through 6)
    double lastPivotHigh = 0;
    double lastPivotLow  = 999999;
    
    for(int i = 2; i <= 6; i++) {
        if(high[i] > lastPivotHigh) lastPivotHigh = high[i];
        if(low[i]  < lastPivotLow)  lastPivotLow  = low[i];
    }

    // Sweep conditions (Bar 1 swept the pivot and closed back inside)
    bool sweepShort = high[1] > lastPivotHigh && close[1] < lastPivotHigh;
    bool sweepLong  = low[1] < lastPivotLow && close[1] > lastPivotLow;

    if(!sweepShort && !sweepLong) return;

    // Dynamic Size Calculation
    double activeRisk = (currentEq >= targetEq) ? InpScaledRiskPct : InpBaseRiskPct;
    double riskCapital = currentEq * (activeRisk / 100.0);
    
    double tickValue = SymbolInfoDouble(_Symbol, SYMBOL_TRADE_TICK_VALUE);
    double tickSize  = SymbolInfoDouble(_Symbol, SYMBOL_TRADE_TICK_SIZE);
    
    if(tickValue == 0 || tickSize == 0) return;

    // Normalization for points/ticks
    double pointMultiplier = _Point / tickSize;
    double adjustedSL = InpSLPoints * pointMultiplier;

    double rawLots = riskCapital / (adjustedSL * tickValue);
    double step    = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_STEP);
    double minLot  = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MIN);
    double maxLot  = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MAX);
    
    double lotSize = MathFloor(rawLots / step) * step;
    if(lotSize < minLot) lotSize = minLot;
    if(lotSize > maxLot) lotSize = maxLot;

    // Execution
    double ask = SymbolInfoDouble(_Symbol, SYMBOL_ASK);
    double bid = SymbolInfoDouble(_Symbol, SYMBOL_BID);

    if(sweepLong) {
        double sl = NormalizeDouble(ask - (InpSLPoints * _Point), _Digits);
        double tp = NormalizeDouble(ask + (InpTPPoints * _Point), _Digits);
        trade.Buy(lotSize, _Symbol, ask, sl, tp, "HouseMoney L");
    }
    else if(sweepShort) {
        double sl = NormalizeDouble(bid + (InpSLPoints * _Point), _Digits);
        double tp = NormalizeDouble(bid - (InpTPPoints * _Point), _Digits);
        trade.Sell(lotSize, _Symbol, bid, sl, tp, "HouseMoney S");
    }
}

//+------------------------------------------------------------------+
void CloseAllPositions() {
    for(int i = PositionsTotal() - 1; i >= 0; i--) {
        ulong ticket = PositionGetTicket(i);
        if(PositionGetString(POSITION_SYMBOL) == _Symbol && PositionGetInteger(POSITION_MAGIC) == InpMagicNumber) {
            trade.PositionClose(ticket);
        }
    }
}

Code: Select all

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

namespace cAlgo.Robots
{
    [Robot(TimeZone = TimeZones.UTC, AccessRights = AccessRights.None)]
    public class HouseMoneyEngine : Robot
    {
        // =========================================================================
        // PARAMETERS: RISK MANAGEMENT
        // =========================================================================
        [Parameter("Reference Balance (0 = Use Current)", Group = "Risk Management", DefaultValue = 100000.0)]
        public double ReferenceBalance { get; set; }

        [Parameter("Base Risk (%)", Group = "Risk Management", DefaultValue = 0.5, MinValue = 0.1, Step = 0.1)]
        public double BaseRiskPct { get; set; }

        [Parameter("Scaled Risk (%)", Group = "Risk Management", DefaultValue = 1.5, MinValue = 0.1, Step = 0.1)]
        public double ScaledRiskPct { get; set; }

        [Parameter("Activation Threshold (%)", Group = "Risk Management", DefaultValue = 5.0, MinValue = 0.1, Step = 0.5)]
        public double ProfitBuffer { get; set; }

        [Parameter("Max Drawdown Killswitch (%)", Group = "Risk Management", DefaultValue = 10.0, MinValue = 1.0, Step = 1.0)]
        public double HardStopEq { get; set; }

        // =========================================================================
        // PARAMETERS: EXECUTION (Converted to Pips for cTrader standard)
        // =========================================================================
        [Parameter("Stop Loss (Pips)", Group = "Execution", DefaultValue = 15.0)]
        public double StopLossPips { get; set; }

        [Parameter("Take Profit (Pips)", Group = "Execution", DefaultValue = 35.0)]
        public double TakeProfitPips { get; set; }

        private double _initBalance;
        private const string TradeLabel = "HouseMoney";

        protected override void OnStart()
        {
            // Initialize baseline. Hard-coding the ReferenceBalance ensures a VPS 
            // or terminal restart doesn't reset your baseline capital metric.
            _initBalance = ReferenceBalance > 0 ? ReferenceBalance : Account.Balance;
        }

        protected override void OnTick()
        {
            // 1. Tick-by-Tick Killswitch Monitoring
            // We monitor absolute capital preservation live, not just at bar close.
            double killswitchEq = _initBalance * (1.0 - (HardStopEq / 100.0));
            if (Account.Equity <= killswitchEq)
            {
                foreach (var position in Positions.Where(p => p.Label == TradeLabel && p.SymbolName == SymbolName))
                {
                    ClosePosition(position);
                }
                
                Print("HARD STOP: Drawdown limit breached. Trading halted.");
                Stop(); // Kills the cBot instance
                return;
            }

            // 2. Real-time Telemetry HUD
            UpdateHUD();
        }

        protected override void OnBar()
        {
            // Restrict to one active position to prevent risk compounding
            if (Positions.Count(p => p.Label == TradeLabel && p.SymbolName == SymbolName) > 0) return;

            // =========================================================================
            // MICROSTRUCTURE PROXY: LIQUIDITY SWEEP
            // =========================================================================
            // We scan indices 2 to 6, because index 1 is the bar that just closed.
            double lastPivotHigh = double.MinValue;
            double lastPivotLow  = double.MaxValue;

            for (int i = 2; i <= 6; i++)
            {
                if (Bars.HighPrices.Last(i) > lastPivotHigh) lastPivotHigh = Bars.HighPrices.Last(i);
                if (Bars.LowPrices.Last(i) < lastPivotLow)   lastPivotLow  = Bars.LowPrices.Last(i);
            }

            // Sweep conditions: The trigger bar pierced the fractal wick but closed back inside.
            bool sweepShort = Bars.HighPrices.Last(1) > lastPivotHigh && Bars.ClosePrices.Last(1) < lastPivotHigh;
            bool sweepLong  = Bars.LowPrices.Last(1)  < lastPivotLow  && Bars.ClosePrices.Last(1) > lastPivotLow;

            if (!sweepShort && !sweepLong) return;

            // =========================================================================
            // DYNAMIC RISK & POSITION SIZING
            // =========================================================================
            double targetEq = _initBalance * (1.0 + (ProfitBuffer / 100.0));
            
            // Immediate Reset Logic:
            double activeRisk = (Account.Equity >= targetEq) ? ScaledRiskPct : BaseRiskPct;
            double riskCapital = Account.Equity * (activeRisk / 100.0);
            
            // Calculate fiat cost per unit for accurate sizing across forex, indices, or commodities
            double riskPerUnit = StopLossPips * Symbol.PipValue;
            if (riskPerUnit <= 0) return; 

            double rawVolume = riskCapital / riskPerUnit;
            double volume = Symbol.NormalizeVolumeInUnits(rawVolume, RoundingMode.Down);

            if (volume < Symbol.VolumeInUnitsMin) return;
            if (volume > Symbol.VolumeInUnitsMax) volume = Symbol.VolumeInUnitsMax;

            // =========================================================================
            // EXECUTION
            // =========================================================================
            if (sweepLong)
            {
                ExecuteMarketOrder(TradeType.Buy, SymbolName, volume, TradeLabel, StopLossPips, TakeProfitPips);
            }
            else if (sweepShort)
            {
                ExecuteMarketOrder(TradeType.Sell, SymbolName, volume, TradeLabel, StopLossPips, TakeProfitPips);
            }
        }

        private void UpdateHUD()
        {
            double targetEq = _initBalance * (1.0 + (ProfitBuffer / 100.0));
            bool isScaled = Account.Equity >= targetEq;
            double activeRisk = isScaled ? ScaledRiskPct : BaseRiskPct;
            
            string hudText = $"=== HOUSE MONEY ENGINE ===\n" +
                             $"Live Equity: {Account.Equity:C2}\n" +
                             $"Target Eq:   {targetEq:C2}\n" +
                             $"Status:      {(isScaled ? "SCALED RISK" : "BASE RISK")}\n" +
                             $"Active Risk: {activeRisk}%";

            Chart.DrawStaticText("RiskHUD", hudText, VerticalAlignment.Bottom, HorizontalAlignment.Right, 
                isScaled ? Color.LimeGreen : Color.DarkGray);
        }
    }
}