forex-scalping.com

Code: Select all

/// <summary>
/// Custom execution wrapper that dynamically widens the SL based on volatility and logs the shadow penalty.
/// </summary>
public TradeResult ExecuteSlippageAdjustedOrder(TradeType tradeType, double volumeInUnits, string label, double baseSlPips, double tpPips)
{
    // 1. Calculate the current market slippage expectation in pips
    double slippagePips = GetVolatilitySlippageInPips();
    
    // 2. Calculate the final Stop Loss distance
    double finalSlPips = baseSlPips;
    
    if (UseDynamicSl)
    {
        // Multiply the expected slippage by your safety factor
        double slBuffer = slippagePips * SlVolatilityMultiplier;
        
        // Widen the stop loss distance
        finalSlPips += slBuffer;
        
        Print($"[Risk Manager] Base SL: {baseSlPips} pips | ATR Buffer: +{slBuffer:F1} pips | Final SL: {finalSlPips:F1} pips");
    }

    // 3. Execute the order using the widened SL
    TradeResult result = ExecuteMarketOrder(tradeType, SymbolName, volumeInUnits, label, finalSlPips, tpPips);

    if (result.IsSuccessful && IsBacktesting)
    {
        // 4. Log the monetary entry penalty for the shadow ledger
        double monetaryPenalty = slippagePips * Symbol.PipValue * volumeInUnits;
        _entrySlippageCost += monetaryPenalty;

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

    return result;
}

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 AtrTrailingStop : Robot
    {
        [Parameter("Trailing Label", Group = "Position Filters", DefaultValue = "MyAlgo")]
        public string TargetLabel { get; set; }

        [Parameter("ATR Timeframe", Group = "ATR Settings")]
        public TimeFrame AtrTimeFrame { get; set; }

        [Parameter("ATR Periods", Group = "ATR Settings", DefaultValue = 14)]
        public int AtrPeriods { get; set; }

        [Parameter("ATR Multiplier", Group = "ATR Settings", DefaultValue = 2.0, MinValue = 0.1)]
        public double AtrMultiplier { get; set; }

        [Parameter("Min Update Step (Pips)", Group = "Server Safety", DefaultValue = 1.0)]
        public double MinUpdatePips { get; set; }

        private AverageTrueRange _atr;
        private double _minUpdateDistance;

        protected override void OnStart()
        {
            // Initialize ATR on the explicitly selected timeframe, regardless of the chart the bot is attached to
            _atr = Indicators.AverageTrueRange(MarketData.GetBars(AtrTimeFrame), AtrPeriods, MovingAverageType.Simple);
            
            // Convert the pip setting to raw price value for fast mathematical comparison in OnTick
            _minUpdateDistance = MinUpdatePips * Symbol.PipSize;
        }

        protected override void OnTick()
        {
            // Loop only through open positions that match this specific bot's label and symbol
            var openPositions = Positions.FindAll(TargetLabel, SymbolName);

            foreach (var position in openPositions)
            {
                ManageAtrTrailingStop(position);
            }
        }

        private void ManageAtrTrailingStop(Position position)
        {
            // 1. Calculate the dynamic trail distance based on the latest closed ATR bar
            double currentAtr = _atr.Result.Last(1);
            double trailDistance = currentAtr * AtrMultiplier;

            if (position.TradeType == TradeType.Buy)
            {
                // 2. Calculate the proposed new SL (Current Bid minus the ATR buffer)
                double proposedSl = Symbol.Bid - trailDistance;
                proposedSl = Math.Round(proposedSl, Symbol.Digits);

                // 3. The Ratchet Logic: Only move the SL UP. 
                // If there is no SL, or the new SL is higher than the current SL by at least our safety threshold:
                if (!position.StopLoss.HasValue || (proposedSl - position.StopLoss.Value >= _minUpdateDistance))
                {
                    // Execute asynchronously to prevent thread-blocking if managing multiple positions
                    ModifyPositionAsync(position, proposedSl, position.TakeProfit);
                }
            }
            else if (position.TradeType == TradeType.Sell)
            {
                // 2. Calculate the proposed new SL (Current Ask plus the ATR buffer)
                double proposedSl = Symbol.Ask + trailDistance;
                proposedSl = Math.Round(proposedSl, Symbol.Digits);

                // 3. The Ratchet Logic: Only move the SL DOWN.
                if (!position.StopLoss.HasValue || (position.StopLoss.Value - proposedSl >= _minUpdateDistance))
                {
                    ModifyPositionAsync(position, proposedSl, position.TakeProfit);
                }
            }
        }
    }
}

Code: Select all

/// <summary>
/// Calculates the required volume to risk a specific percentage of the account balance.
/// </summary>
/// <param name="riskPercentage">The percentage of the account to risk (e.g., 1.0 for 1%)</param>
/// <param name="stopLossPips">The dynamic ATR Stop Loss distance in pips</param>
/// <returns>Normalized volume in units, safe for broker execution.</returns>
private double CalculateVolumeByRisk(double riskPercentage, double stopLossPips)
{
    if (stopLossPips <= 0)
    {
        Print("Warning: Stop loss must be greater than zero. Returning minimum volume.");
        return Symbol.VolumeInUnitsMin;
    }

    // 1. Calculate the absolute fiat amount you are willing to lose
    // Note: Use Account.Equity instead of Account.Balance if you want floating drawdowns factored in
    double maxRiskFiat = Account.Balance * (riskPercentage / 100.0);

    // 2. Calculate the fiat cost of a 1-pip move for a single unit of volume
    double costPerPipPerUnit = Symbol.PipValue;

    // 3. Calculate the exact mathematical volume required
    double exactVolume = maxRiskFiat / (stopLossPips * costPerPipPerUnit);

    // 4. Broker Normalization (The Strict Enforcer)
    // We strictly round DOWN. If math dictates 14,800 units, but the broker step is 1,000, 
    // it rounds to 14,000. Rounding up to 15,000 would exceed the 1% risk limit.
    double safeVolume = Symbol.NormalizeVolumeInUnits(exactVolume, RoundingMode.Down);

    // 5. Ensure the calculated volume does not fall below the broker's absolute minimum
    return Math.Max(safeVolume, Symbol.VolumeInUnitsMin);
}

Code: Select all

[Parameter("Risk % Per Trade", Group = "Risk Management", DefaultValue = 1.0, MinValue = 0.1)]
public double RiskPercentage { get; set; }

private void ExecuteAtrRiskAdjustedTrade(TradeType tradeType, string label)
{
    // 1. Fetch current ATR value and convert to pips
    double currentAtr = _atr.Result.Last(1);
    double atrStopLossPips = currentAtr / Symbol.PipSize;

    // Optional: Add the slippage buffer from our previous discussion
    double slBuffer = GetVolatilitySlippageInPips() * SlVolatilityMultiplier;
    double finalSlPips = atrStopLossPips + slBuffer;

    // 2. Calculate the exact volume required to risk 1% based on the final widened SL
    double volumeInUnits = CalculateVolumeByRisk(RiskPercentage, finalSlPips);

    // 3. Optional: Set Take Profit based on Risk-to-Reward ratio (e.g., 2.0R)
    double targetPips = finalSlPips * 2.0;

    Print($"[Execution] Final SL: {finalSlPips:F1} pips | Required Vol: {volumeInUnits} units");

    // 4. Execute the order
    ExecuteMarketOrder(tradeType, SymbolName, volumeInUnits, label, finalSlPips, targetPips);
}