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 VolatilitySlippageSimulator : Robot
    {
        [Parameter("ATR Periods", Group = "Slippage Settings", DefaultValue = 14)]
        public int AtrPeriods { get; set; }

        [Parameter("Slippage (% of ATR)", Group = "Slippage Settings", DefaultValue = 5.0, MinValue = 0.1, MaxValue = 100)]
        public double AtrSlippagePercent { get; set; }

        [Parameter("Minimum Slippage (Pips)", Group = "Slippage Settings", DefaultValue = 0.2)]
        public double MinSlippagePips { get; set; }

        private AverageTrueRange _atr;
        private double _totalSlippageCost; // Running tally of lost fiat equity

        protected override void OnStart()
        {
            // Initialize ATR on the 1-Minute timeframe to capture micro-volatility
            _atr = Indicators.AverageTrueRange(MarketData.GetBars(TimeFrame.Minute), AtrPeriods, MovingAverageType.Simple);
            _totalSlippageCost = 0;
        }

        /// <summary>
        /// Calculates the current market slippage penalty in pips based on recent volatility.
        /// </summary>
        private double GetVolatilitySlippageInPips()
        {
            // Get the latest completed ATR value
            double currentAtr = _atr.Result.Last(1); 
            
            // Convert raw ATR price value to standard Pips (handles JPY vs standard pairs automatically)
            double atrInPips = currentAtr / Symbol.PipSize;
            
            // Calculate penalty as a percentage of the ATR
            double calculatedSlippage = atrInPips * (AtrSlippagePercent / 100.0);
            
            // Ensure slippage never drops below the baseline broker minimum
            return Math.Max(calculatedSlippage, MinSlippagePips); 
        }

        /// <summary>
        /// Custom execution wrapper that executes the trade and logs the shadow penalty.
        /// </summary>
        public TradeResult ExecuteSlippageAdjustedOrder(TradeType tradeType, double volumeInUnits, string label, double slPips, double tpPips)
        {
            // 1. Calculate slippage at the exact moment before execution
            double slippagePips = GetVolatilitySlippageInPips();
            
            // 2. Execute the order (fills at cTrader's ideal backtest tick)
            TradeResult result = ExecuteMarketOrder(tradeType, SymbolName, volumeInUnits, label, slPips, tpPips);

            if (result.IsSuccessful && IsBacktesting)
            {
                // 3. Convert pip penalty to account currency fiat value
                // Symbol.PipValue is the fiat value of 1 pip for 1 unit of volume
                double monetaryPenalty = slippagePips * Symbol.PipValue * volumeInUnits;
                
                // 4. Add to the shadow ledger
                _totalSlippageCost += monetaryPenalty;

                Print($"[Slippage Applied] Position {result.Position.Id} | Penalty: {slippagePips:F1} pips | Fiat Cost: {monetaryPenalty:C2}");
            }

            return result;
        }

        // Example Trigger
        protected override void OnTick()
        {
            // Basic example: Execute once to demonstrate mechanics
            if (Positions.Count == 0 && Bars.ClosePrices.Last(1) > Bars.OpenPrices.Last(1))
            {
                ExecuteSlippageAdjustedOrder(TradeType.Buy, 100000, "VolatilityTest", 10, 20);
            }
        }

        protected override void OnStop()
        {
            if (IsBacktesting)
            {
                Print("=================================================");
                Print("            BACKTEST SLIPPAGE REPORT             ");
                Print("=================================================");
                Print($"Ideal Gross Equity:          {Account.Equity:C2}");
                Print($"Total Slippage Penalty:      -{_totalSlippageCost:C2}");
                Print("-------------------------------------------------");
                Print($"TRUE ADJUSTED EQUITY:        {(Account.Equity - _totalSlippageCost):C2}");
                Print("=================================================");
            }
        }
    }
}

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 VolatilitySlippageSimulator : Robot
    {
        [Parameter("ATR Periods", Group = "Slippage Settings", DefaultValue = 14)]
        public int AtrPeriods { get; set; }

        [Parameter("Slippage (% of ATR)", Group = "Slippage Settings", DefaultValue = 5.0, MinValue = 0.1, MaxValue = 100)]
        public double AtrSlippagePercent { get; set; }

        [Parameter("Minimum Slippage (Pips)", Group = "Slippage Settings", DefaultValue = 0.2)]
        public double MinSlippagePips { get; set; }

        private AverageTrueRange _atr;
        
        // Split ledgers for granular post-test analytics
        private double _entrySlippageCost; 
        private double _exitSlippageCost;

        protected override void OnStart()
        {
            _atr = Indicators.AverageTrueRange(MarketData.GetBars(TimeFrame.Minute), AtrPeriods, MovingAverageType.Simple);
            _entrySlippageCost = 0;
            _exitSlippageCost = 0;

            // Subscribe to the global position closed event
            Positions.Closed += OnPositionClosed;
        }

        private double GetVolatilitySlippageInPips()
        {
            double currentAtr = _atr.Result.Last(1); 
            double atrInPips = currentAtr / Symbol.PipSize;
            double calculatedSlippage = atrInPips * (AtrSlippagePercent / 100.0);
            
            return Math.Max(calculatedSlippage, MinSlippagePips); 
        }

        public TradeResult ExecuteSlippageAdjustedOrder(TradeType tradeType, double volumeInUnits, string label, double slPips, double tpPips)
        {
            double slippagePips = GetVolatilitySlippageInPips();
            TradeResult result = ExecuteMarketOrder(tradeType, SymbolName, volumeInUnits, label, slPips, tpPips);

            if (result.IsSuccessful && IsBacktesting)
            {
                double monetaryPenalty = slippagePips * Symbol.PipValue * volumeInUnits;
                _entrySlippageCost += monetaryPenalty;

                Print($"[ENTRY Penalty] Pos {result.Position.Id} | Slippage: {slippagePips:F1} pips | Cost: {monetaryPenalty:C2}");
            }

            return result;
        }

        /// <summary>
        /// Event handler that processes all closed positions and penalizes Stop Loss / Stop Out executions.
        /// </summary>
        private void OnPositionClosed(PositionClosedEventArgs args)
        {
            if (!IsBacktesting) return;

            // Take Profits are typically Limit Orders and do not suffer negative slippage.
            // We only penalize Market closures, Stop Losses, and Margin Calls (Stop Outs).
            if (args.Reason == PositionCloseReason.StopLoss || 
                args.Reason == PositionCloseReason.StopOut || 
                args.Reason == PositionCloseReason.Closed) // Covers standard market exits via code
            {
                double slippagePips = GetVolatilitySlippageInPips();
                
                // Fetch the specific symbol of the closed position to ensure correct pip valuation
                Symbol posSymbol = Symbols.GetSymbol(args.Position.SymbolName);
                double monetaryPenalty = slippagePips * posSymbol.PipValue * args.Position.VolumeInUnits;

                _exitSlippageCost += monetaryPenalty;

                Print($"[EXIT Penalty - {args.Reason}] Pos {args.Position.Id} | Slippage: {slippagePips:F1} pips | Cost: {monetaryPenalty:C2}");
            }
        }

        protected override void OnStop()
        {
            if (IsBacktesting)
            {
                double totalPenalty = _entrySlippageCost + _exitSlippageCost;
                
                Print("=================================================");
                Print("      BACKTEST SLIPPAGE & LIQUIDITY REPORT       ");
                Print("=================================================");
                Print($"Ideal Gross Equity:          {Account.Equity:C2}");
                Print($"Entry Execution Drag:       -{_entrySlippageCost:C2}");
                Print($"Exit (SL/Mkt) Drag:         -{_exitSlippageCost:C2}");
                Print("-------------------------------------------------");
                Print($"TRUE ADJUSTED EQUITY:        {(Account.Equity - totalPenalty):C2}");
                Print("=================================================");
            }
        }
    }
}

Code: Select all

[Parameter("Use Dynamic SL Buffer", Group = "Risk Management", DefaultValue = true)]
public bool UseDynamicSl { get; set; }

[Parameter("SL Volatility Multiplier", Group = "Risk Management", DefaultValue = 1.5, MinValue = 0.0)]
public double SlVolatilityMultiplier { get; set; }