forex-scalping.com

Code: Select all

[Parameter("Enable Latency Simulator", DefaultValue = true, Group = "Slippage Simulator")]
public bool EnableLatencySim { get; set; }

[Parameter("Min Delay (ms)", DefaultValue = 100, Group = "Slippage Simulator")]
public int MinDelayMs { get; set; }

[Parameter("Max Delay (ms)", DefaultValue = 1500, Group = "Slippage Simulator")]
public int MaxDelayMs { get; set; }

// Structure to hold delayed API commands
private class PendingExecution
{
    public DateTime ExecutionTime { get; set; }
    public Action Command { get; set; }
}

private List<PendingExecution> _executionQueue = new List<PendingExecution>();
private HashSet<int> _queuedScaleOutIds = new HashSet<int>();
private Random _rng = new Random();

Code: Select all

protected override void OnTick()
{
    // --- 1. PROCESS LATENCY QUEUE ---
    for (int i = _executionQueue.Count - 1; i >= 0; i--)
    {
        if (Server.Time >= _executionQueue[i].ExecutionTime)
        {
            _executionQueue[i].Command.Invoke();
            _executionQueue.RemoveAt(i);
        }
    }
    
    // ... rest of your OnTick logic ...

Code: Select all

if (isTargetHit)
{
    // Ensure we don't queue the same scale-out 500 times while waiting for the delay
    if (_queuedScaleOutIds.Contains(position.Id)) return;
    
    double scaleOutVolume = Symbol.NormalizeVolumeInUnits(position.VolumeInUnits / 2, RoundingMode.Down);
    
    if (scaleOutVolume >= Symbol.VolumeInUnitsMin)
    {
        _queuedScaleOutIds.Add(position.Id);

        // If simulator is off, delay is 0
        int delay = EnableLatencySim ? _rng.Next(MinDelayMs, MaxDelayMs) : 0;
        DateTime executionTime = Server.Time.AddMilliseconds(delay);

        Print($"[Target Hit] Queuing {scaleOutVolume} units. Broker Lag: {delay}ms.");

        // Inject the API command into the queue
        _executionQueue.Add(new PendingExecution
        {
            ExecutionTime = executionTime,
            Command = () => 
            {
                // Verify position wasn't closed by a hard stop during the delay
                var activePos = Positions.Find(BotLabel, SymbolName);
                if (activePos != null)
                {
                    TradeResult closeResult = ClosePosition(activePos, scaleOutVolume);
                    
                    if (closeResult.IsSuccessful)
                    {
                        Print($"[Scale-Out Filled] Simulated slippage captured.");
                        _scaleOutTargets.Remove(activePos.Id);
                        
                        // Execute Breakeven logic here...
                    }
                }
                _queuedScaleOutIds.Remove(position.Id);
            }
        });
    }
}

Code: Select all

[Parameter("Worst-Case Slippage (Pips)", DefaultValue = 2.0, Group = "Slippage Simulator")]
public double AdverseSlippagePips { get; set; }

private double _shadowNetProfit = 0;

Code: Select all

protected override void OnStart()
{
    Positions.Closed += OnPositionClosed;
}

private void OnPositionClosed(PositionClosedEventArgs args)
{
    if (args.Position.Label == BotLabel && args.Position.SymbolName == SymbolName)
    {
        // 1. Get the actual profit from the backtest fill
        double actualProfit = args.Position.GrossProfit;
        
        // 2. Calculate the financial penalty of the adverse slippage
        // Penalty = Volume * PipValue * BadPips
        double slippagePenalty = (args.Position.VolumeInUnits / Symbol.VolumeInUnitsMin) 
                                 * Symbol.PipValue 
                                 * AdverseSlippagePips;

        // 3. Update the shadow ledger
        double adjustedProfit = actualProfit - slippagePenalty;
        _shadowNetProfit += adjustedProfit;

        // 4. Render to chart
        string ledgerText = $"Actual Backtest Equity: {Account.Equity:C2}\n" +
                            $"Worst-Case Shadow Equity: {(Account.Balance + _shadowNetProfit):C2}";

        Chart.DrawStaticText("ShadowLedger", ledgerText, VerticalAlignment.Top, HorizontalAlignment.Left, Color.Red);
    }
}

Code: Select all

[Parameter("Dynamic Spread Multiplier", DefaultValue = 3.0, Group = "Liquidity Protection",
           ToolTip = "Halts execution if current spread is X times larger than the 1-hour average.")]
public double SpreadMultiplier { get; set; }

[Parameter("Absolute Max Spread (Pips)", DefaultValue = 5.0, Group = "Liquidity Protection",
           ToolTip = "The hard ceiling failsafe. Execution is blocked if spread crosses this, regardless of the baseline.")]
public double AbsoluteMaxSpread { get; set; }

[Parameter("Minimum Baseline Spread (Pips)", DefaultValue = 0.5, Group = "Liquidity Protection",
           ToolTip = "Protects against math errors if the broker provides a 0.0 pip spread. Prevents the dynamic limit from becoming too tight.")]
public double MinBaselineSpread { get; set; }

Code: Select all

private Queue<double> _spreadBaselineQueue = new Queue<double>();
private DateTime _lastSpreadSample;
private double _currentBaselineSpread;
private DateTime _lastSpreadLogTime;

Code: Select all

protected override void OnTick()
{
    double currentSpread = Symbol.Spread / Symbol.PipSize;

    // --- 1. TIME-SAMPLED BASELINE GENERATOR ---
    // Sample the spread exactly once per minute to build a stable 1-hour historical baseline
    if ((Server.Time - _lastSpreadSample).TotalMinutes >= 1)
    {
        _spreadBaselineQueue.Enqueue(currentSpread);
        
        if (_spreadBaselineQueue.Count > 60) // Maintain exactly 60 minutes of data
            _spreadBaselineQueue.Dequeue();

        // LINQ Average is fast enough here since the queue never exceeds 60 items
        _currentBaselineSpread = _spreadBaselineQueue.Average();
        _lastSpreadSample = Server.Time;
    }

    // --- 2. CALCULATE DYNAMIC EXECUTION LIMIT ---
    // Prevent mathematically impossible tight limits (e.g., 0.1 pip baseline * 3 = 0.3 pip limit)
    double safeBaseline = Math.Max(_currentBaselineSpread, MinBaselineSpread);
    double dynamicLimit = safeBaseline * SpreadMultiplier;
    
    // Final ceiling is the absolute max spread
    double effectiveSpreadLimit = Math.Min(dynamicLimit, AbsoluteMaxSpread);

    // ... [Process Latency Queue Here] ...

    var position = Positions.Find(BotLabel, SymbolName);
    if (position == null) return;

    // --- 3. SCALE-OUT TARGET EVALUATION ---
    if (_scaleOutTargets.TryGetValue(position.Id, out double targetPrice))
    {
        bool isTargetHit = position.TradeType == TradeType.Buy 
            ? Symbol.Bid >= targetPrice 
            : Symbol.Ask <= targetPrice;

        if (isTargetHit)
        {
            // --- THE SPREAD BLOCKER ---
            if (currentSpread > effectiveSpreadLimit)
            {
                // Throttle the logging so you don't spam the cTrader journal 500x a second during rollover
                if ((Server.Time - _lastSpreadLogTime).TotalSeconds > 1) 
                {
                    Print($"[Liquidity Fracture] Target hit, but spread ({currentSpread:F1}) exceeds limit ({effectiveSpreadLimit:F1}). Holding scale-out.");
                    _lastSpreadLogTime = Server.Time;
                }
                
                // Abort the scale-out for this tick. The target remains in the dictionary.
                // It will continually retry on subsequent ticks until the spread compresses.
                return; 
            }

            // --- PROCEED TO LATENCY QUEUE OR EXECUTION ---
            if (_queuedScaleOutIds.Contains(position.Id)) return;
            
            double scaleOutVolume = Symbol.NormalizeVolumeInUnits(position.VolumeInUnits / 2, RoundingMode.Down);
            
            if (scaleOutVolume >= Symbol.VolumeInUnitsMin)
            {
                // Add to Latency Queue or execute ClosePosition(position, scaleOutVolume) here
            }
        }
    }
}