forex-scalping.com

Code: Select all

using System;
using System.Collections.Generic;
using cAlgo.API;
using cAlgo.API.Internals;

namespace cAlgo.Robots
{
    [Robot(TimeZone = TimeZones.UTC, AccessRights = AccessRights.None)]
    public class ScaleOutManager : Robot
    {
        [Parameter("Scale Out at 1R?", Group = "Trade Management", DefaultValue = true)]
        public bool EnableScaleOut { get; set; }

        // Memory cache to prevent the bot from scaling out the same position multiple times
        private HashSet<int> _scaledOutPositions = new HashSet<int>();

        protected override void OnStart()
        {
            // Subscribe to the closed event to clear memory and prevent leaks
            Positions.Closed += OnPositionClosed;
        }

        protected override void OnTick()
        {
            if (!EnableScaleOut) return;

            foreach (var position in Positions)
            {
                // Skip if this position has already been scaled out, or lacks a Stop Loss to calculate 1R
                if (_scaledOutPositions.Contains(position.Id) || !position.StopLoss.HasValue)
                    continue;

                ManageScaleOut(position);
            }
        }

        private void ManageScaleOut(Position position)
        {
            // 1. Calculate the initial risk distance (1R) in raw price terms
            double riskInPrice = Math.Abs(position.EntryPrice - position.StopLoss.Value);

            bool is1RHit = false;

            // 2. Check if current price has reached the 1R target
            if (position.TradeType == TradeType.Buy)
            {
                double targetPrice1R = position.EntryPrice + riskInPrice;
                if (Symbol.Bid >= targetPrice1R) is1RHit = true;
            }
            else if (position.TradeType == TradeType.Sell)
            {
                double targetPrice1R = position.EntryPrice - riskInPrice;
                if (Symbol.Ask <= targetPrice1R) is1RHit = true;
            }

            // 3. Execute the partial close
            if (is1RHit)
            {
                // Calculate 50% of the current volume
                double targetVolumeToClose = position.VolumeInUnits / 2.0;

                // Normalize STRICTLY down to ensure broker step compliance
                double safeVolumeToClose = Symbol.NormalizeVolumeInUnits(targetVolumeToClose, RoundingMode.Down);

                if (safeVolumeToClose >= Symbol.VolumeInUnitsMin)
                {
                    // Critical: Add to memory BEFORE execution to prevent micro-tick double-firing
                    _scaledOutPositions.Add(position.Id);

                    // Execute asynchronously to prevent locking the main thread
                    ClosePositionAsync(position, safeVolumeToClose, OnScaleOutComplete);
                    
                    Print($"[Scale Out] 1R Hit for Position {position.Id}. Closing {safeVolumeToClose} units.");
                }
            }
        }

        /// <summary>
        /// Callback to handle execution failures.
        /// </summary>
        private void OnScaleOutComplete(TradeResult result)
        {
            if (!result.IsSuccessful && result.Position != null)
            {
                // If the broker rejected the partial close, remove it from memory so the bot tries again
                _scaledOutPositions.Remove(result.Position.Id);
                Print($"[Scale Out Error] Failed to scale out Position {result.Position.Id}: {result.Error}");
            }
        }

        /// <summary>
        /// Housekeeping: Remove the ID from memory once the remaining volume hits TP or SL.
        /// </summary>
        private void OnPositionClosed(PositionClosedEventArgs args)
        {
            _scaledOutPositions.Remove(args.Position.Id);
        }
    }
}

Code: Select all

using System;
using System.Collections.Generic;
using cAlgo.API;
using cAlgo.API.Internals;

namespace cAlgo.Robots
{
    [Robot(TimeZone = TimeZones.UTC, AccessRights = AccessRights.None)]
    public class RiskFreeScaleOutManager : Robot
    {
        [Parameter("Scale Out at 1R?", Group = "Trade Management", DefaultValue = true)]
        public bool EnableScaleOut { get; set; }

        [Parameter("Move to BE at 1R?", Group = "Trade Management", DefaultValue = true)]
        public bool MoveToBreakEven { get; set; }

        [Parameter("BE Spread Buffer (Pips)", Group = "Trade Management", DefaultValue = 0.5, MinValue = 0.0)]
        public double BreakEvenBufferPips { get; set; }

        private HashSet<int> _scaledOutPositions = new HashSet<int>();

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

        protected override void OnTick()
        {
            if (!EnableScaleOut && !MoveToBreakEven) return;

            foreach (var position in Positions)
            {
                if (_scaledOutPositions.Contains(position.Id) || !position.StopLoss.HasValue)
                    continue;

                ManageRiskFreeState(position);
            }
        }

        private void ManageRiskFreeState(Position position)
        {
            double riskInPrice = Math.Abs(position.EntryPrice - position.StopLoss.Value);
            bool is1RHit = false;

            if (position.TradeType == TradeType.Buy)
            {
                if (Symbol.Bid >= (position.EntryPrice + riskInPrice)) is1RHit = true;
            }
            else if (position.TradeType == TradeType.Sell)
            {
                if (Symbol.Ask <= (position.EntryPrice - riskInPrice)) is1RHit = true;
            }

            if (is1RHit)
            {
                // 1. Lock the position state immediately to prevent OnTick double-firing
                _scaledOutPositions.Add(position.Id);

                // 2. Fire the Partial Close Request
                if (EnableScaleOut)
                {
                    double safeVolumeToClose = Symbol.NormalizeVolumeInUnits(position.VolumeInUnits / 2.0, RoundingMode.Down);
                    if (safeVolumeToClose >= Symbol.VolumeInUnitsMin)
                    {
                        ClosePositionAsync(position, safeVolumeToClose, OnScaleOutComplete);
                    }
                }

                // 3. Fire the Stop Loss Modification Request concurrently
                if (MoveToBreakEven)
                {
                    ExecuteBreakEvenModification(position);
                }
            }
        }

        private void ExecuteBreakEvenModification(Position position)
        {
            double bufferInPrice = BreakEvenBufferPips * Symbol.PipSize;
            double breakEvenPrice;

            if (position.TradeType == TradeType.Buy)
            {
                breakEvenPrice = Math.Round(position.EntryPrice + bufferInPrice, Symbol.Digits);
                
                // Only move SL up. Do not accidentally widen it if the user manually moved it higher.
                if (position.StopLoss.Value < breakEvenPrice)
                {
                    ModifyPositionAsync(position, breakEvenPrice, position.TakeProfit, OnBreakEvenComplete);
                }
            }
            else // Sell
            {
                breakEvenPrice = Math.Round(position.EntryPrice - bufferInPrice, Symbol.Digits);
                
                // Only move SL down.
                if (position.StopLoss.Value > breakEvenPrice)
                {
                    ModifyPositionAsync(position, breakEvenPrice, position.TakeProfit, OnBreakEvenComplete);
                }
            }
        }

        private void OnScaleOutComplete(TradeResult result)
        {
            if (!result.IsSuccessful && result.Position != null)
            {
                _scaledOutPositions.Remove(result.Position.Id);
                Print($"[Error] Scale out failed for Pos {result.Position.Id}. Re-arming. Error: {result.Error}");
            }
        }

        private void OnBreakEvenComplete(TradeResult result)
        {
            if (result.IsSuccessful)
            {
                Print($"[Risk Free] Position {result.Position.Id} secured at Break-Even + Buffer.");
            }
            else
            {
                Print($"[Error] Break-Even modification failed: {result.Error}");
            }
        }

        private void OnPositionClosed(PositionClosedEventArgs args)
        {
            _scaledOutPositions.Remove(args.Position.Id);
        }
    }
}

Code: Select all

using System;
using System.Collections.Generic;
using cAlgo.API;

namespace cAlgo.Robots
{
    [Robot(TimeZone = TimeZones.UTC, AccessRights = AccessRights.None)]
    public class LineageScaleOutManager : Robot
    {
        // The memory cache now tracks the unique Label string, not the Position ID
        private HashSet<string> _scaledOutLogicalTrades = new HashSet<string>();

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

        /// <summary>
        /// Entry Logic: Generates a unique Logical Trade ID (LTID) for every new execution.
        /// </summary>
        private void ExecuteNewTrade()
        {
            // Append the current exact millisecond tick count to ensure absolute uniqueness
            string uniqueLtid = "MyAlgo_" + DateTime.Now.Ticks.ToString();

            ExecuteMarketOrder(TradeType.Buy, SymbolName, 100000, uniqueLtid, 10, 20);
        }

        protected override void OnTick()
        {
            foreach (var position in Positions)
            {
                // If this label is in our memory cache, it has already been scaled out.
                // It does not matter if the Position.Id changed; the label persists.
                if (_scaledOutLogicalTrades.Contains(position.Label) || !position.StopLoss.HasValue)
                    continue;

                ManageScaleOut(position);
            }
        }

        private void ManageScaleOut(Position position)
        {
            double riskInPrice = Math.Abs(position.EntryPrice - position.StopLoss.Value);
            bool is1RHit = Symbol.Bid >= (position.EntryPrice + riskInPrice); // Simplified for Buy

            if (is1RHit)
            {
                double targetVolumeToClose = Symbol.NormalizeVolumeInUnits(position.VolumeInUnits / 2.0, RoundingMode.Down);

                if (targetVolumeToClose >= Symbol.VolumeInUnitsMin)
                {
                    // 1. Lock the logical trade state immediately using the Label
                    _scaledOutLogicalTrades.Add(position.Label);

                    // 2. Execute the partial close
                    ClosePositionAsync(position, targetVolumeToClose, OnScaleOutComplete);
                    
                    Print($"[Scale Out] 1R Hit. Locked Logical Trade: {position.Label}");
                }
            }
        }

        private void OnScaleOutComplete(TradeResult result)
        {
            if (!result.IsSuccessful && result.Position != null)
            {
                // Unlock the label so the bot can try again on the next tick
                _scaledOutLogicalTrades.Remove(result.Position.Label);
            }
        }

        /// <summary>
        /// Housekeeping: Safely clears the memory cache ONLY when the entire logical trade is flat.
        /// </summary>
        private void OnPositionClosed(PositionClosedEventArgs args)
        {
            string closedLabel = args.Position.Label;

            // CRITICAL SAFETY CHECK:
            // If the broker created a new Position ID for the remainder, it fires this Closed event 
            // for the parent. If we blindly remove the label from memory right now, the new child 
            // position will immediately get scaled-out again on the next tick.
            
            // We must check if ANY positions with this label still exist in the market.
            if (Positions.FindAll(closedLabel).Length == 0)
            {
                // Only if the count is 0 (the entire trade is fully closed/flat), purge the memory.
                _scaledOutLogicalTrades.Remove(closedLabel);
                Print($"[Memory Purge] Logical Trade {closedLabel} fully closed. Cache cleared.");
            }
        }
    }
}

Code: Select all

using System.Linq;
using cAlgo.API;

namespace cAlgo.Robots
{
    [Robot(TimeZone = TimeZones.UTC, AccessRights = AccessRights.None)]
    public class PnlAggregator : Robot
    {
        /// <summary>
        /// Calculates the total Net PnL (Realized + Unrealized) for a Logical Trade ID.
        /// </summary>
        /// <param name="logicalTradeId">The unique label assigned at the original entry.</param>
        /// <returns>The net fiat profit or loss in the account currency.</returns>
        private double CalculateLogicalTradeNetPnL(string logicalTradeId)
        {
            double realizedNetPnL = 0;
            double unrealizedNetPnL = 0;

            // 1. Sum Realized PnL from all closed fragments (Partial closes / Scale-outs)
            var closedFragments = History.FindAll(logicalTradeId);
            foreach (var historicTrade in closedFragments)
            {
                // NetProfit natively includes all deducted Commissions and Swaps
                realizedNetPnL += historicTrade.NetProfit;
            }

            // 2. Sum Unrealized (Floating) PnL from the remaining open fragments
            var openFragments = Positions.FindAll(logicalTradeId);
            foreach (var openPosition in openFragments)
            {
                unrealizedNetPnL += openPosition.NetProfit;
            }

            double totalNetPnL = realizedNetPnL + unrealizedNetPnL;

            return totalNetPnL;
        }

        // Example trigger to monitor the PnL of an active sequence
        protected override void OnTick()
        {
            // Assuming "MyAlgo_638321045231" is the LTID of an active trade sequence
            string currentLtid = "MyAlgo_638321045231";
            
            // Only calculate if the trade is actually active
            if (Positions.FindAll(currentLtid).Length > 0)
            {
                double currentTotalPnL = CalculateLogicalTradeNetPnL(currentLtid);
                
                // Display the true aggregated PnL on the chart for monitoring
                Chart.DrawText("pnl_display", $"Trade {currentLtid} Net PnL: {currentTotalPnL:C2}", 
                    Chart.Height - 50, Chart.Width - 200, Color.LimeGreen);
            }
        }
    }
}