forex-scalping.com

Code: Select all

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

namespace cAlgo.Robots
{
    [Robot(TimeZone = TimeZones.UTC, AccessRights = AccessRights.None)]
    public class InstitutionalStressTest : Robot
    {
        // =========================================================================
        // 1. INPUTS & PARAMETERS
        // =========================================================================
        [Parameter("Risk Per Trade (%)", Group = "Risk Management", DefaultValue = 1.0, MinValue = 0.1, Step = 0.1)]
        public double RiskPercent { get; set; }

        [Parameter("ATR Stop Loss Multiplier", Group = "Risk Management", DefaultValue = 1.5)]
        public double AtrSlMult { get; set; }

        [Parameter("ATR Take Profit Multiplier", Group = "Risk Management", DefaultValue = 3.0)]
        public double AtrTpMult { get; set; }

        [Parameter("Max Slippage (Pips)", Group = "Risk Management", DefaultValue = 0.5)]
        public double MaxSlippage { get; set; }

        [Parameter("Baseline Trend EMA", Group = "Strategy", DefaultValue = 200)]
        public int EmaPeriod { get; set; }

        [Parameter("Mean Reversion RSI", Group = "Strategy", DefaultValue = 4)]
        public int RsiPeriod { get; set; }

        [Parameter("Volatility ATR", Group = "Strategy", DefaultValue = 14)]
        public int AtrPeriod { get; set; }

        [Parameter("Start Hour (UTC)", Group = "Session Filter", DefaultValue = 9)]
        public int StartHour { get; set; }

        [Parameter("Start Min", Group = "Session Filter", DefaultValue = 30)]
        public int StartMin { get; set; }

        [Parameter("End Hour (UTC)", Group = "Session Filter", DefaultValue = 15)]
        public int EndHour { get; set; }

        [Parameter("End Min", Group = "Session Filter", DefaultValue = 45)]
        public int EndMin { get; set; }

        // =========================================================================
        // 2. INDICATOR REFERENCES
        // =========================================================================
        private ExponentialMovingAverage _ema;
        private RelativeStrengthIndex _rsi;
        private AverageTrueRange _atr;
        private const string Label = "Inst_StressTest";

        protected override void OnStart()
        {
            _ema = Indicators.ExponentialMovingAverage(Bars.ClosePrices, EmaPeriod);
            _rsi = Indicators.RelativeStrengthIndex(Bars.ClosePrices, RsiPeriod);
            _atr = Indicators.AverageTrueRange(Bars, AtrPeriod, MovingAverageType.Simple);
        }

        // =========================================================================
        // 3. CORE LOGIC & EXECUTION (Calculated on Bar Close)
        // =========================================================================
        protected override void OnBar()
        {
            // 3a. Session Filtering
            DateTime currentTime = Server.Time;
            int currentMinutes = currentTime.Hour * 60 + currentTime.Minute;
            int startMinutes = StartHour * 60 + StartMin;
            int endMinutes = EndHour * 60 + EndMin;
            
            bool inSession = (currentMinutes >= startMinutes && currentMinutes <= endMinutes);

            // 3b. End of Day Flattening
            if (!inSession)
            {
                var openPositions = Positions.FindAll(Label, SymbolName);
                foreach (var position in openPositions)
                {
                    ClosePosition(position);
                }
                return;
            }

            // Prevent pyramiding - only one trade at a time
            if (Positions.FindAll(Label, SymbolName).Length > 0)
                return;

            // 3c. Indicator Values (Index 1 is the last closed bar, Index 2 is the bar before that)
            double closePrice = Bars.ClosePrices.Last(1);
            double currentEma = _ema.Result.Last(1);
            double currentAtr = _atr.Result.Last(1);
            
            bool bullRegime = closePrice > currentEma;
            bool bearRegime = closePrice < currentEma;

            bool longTrigger = _rsi.Result.Last(2) > 30 && _rsi.Result.Last(1) <= 30; // Crossed under 30
            bool shortTrigger = _rsi.Result.Last(2) < 70 && _rsi.Result.Last(1) >= 70; // Crossed over 70

            // 3d. Dynamic Position Sizing & Execution
            if (longTrigger && bullRegime)
            {
                double slPips = (currentAtr * AtrSlMult) / Symbol.PipSize;
                double tpPips = (currentAtr * AtrTpMult) / Symbol.PipSize;
                double volume = CalculateVolume(slPips);

                if (volume >= Symbol.VolumeInUnitsMin)
                {
                    // ExecuteMarketRangeOrder limits acceptable slippage natively
                    ExecuteMarketRangeOrder(TradeType.Buy, SymbolName, volume, MaxSlippage, Symbol.Ask, Label, slPips, tpPips);
                }
            }
            else if (shortTrigger && bearRegime)
            {
                double slPips = (currentAtr * AtrSlMult) / Symbol.PipSize;
                double tpPips = (currentAtr * AtrTpMult) / Symbol.PipSize;
                double volume = CalculateVolume(slPips);

                if (volume >= Symbol.VolumeInUnitsMin)
                {
                    ExecuteMarketRangeOrder(TradeType.Sell, SymbolName, volume, MaxSlippage, Symbol.Bid, Label, slPips, tpPips);
                }
            }
        }

        // =========================================================================
        // 4. INSTITUTIONAL POSITION SIZING ALGORITHM
        // =========================================================================
        private double CalculateVolume(double stopLossPips)
        {
            if (stopLossPips <= 0) return 0;

            // Calculate exactly how much money we are willing to risk
            double riskMoney = Account.Equity * (RiskPercent / 100.0);
            
            // Calculate how much 1 unit of volume costs per pip
            double exactVolume = riskMoney / (stopLossPips * Symbol.PipValue);

            // Normalize the volume to the broker's required step sizes (e.g., 1000 for micro lots in FX)
            return Symbol.NormalizeVolumeInUnits(exactVolume, RoundingMode.Down);
        }
    }
}