forex-scalping.com

Code: Select all

//@version=5
indicator("Dynamic Position Sizer Dashboard", overlay=true)

// --- Inputs ---
grp1 = "Account & Risk Management"
accCapital  = input.float(10000, title="Account Capital ($)", group=grp1)
riskPct     = input.float(0.5, title="Risk Per Trade (%)", step=0.1, group=grp1)

grp2 = "Stop Loss Strategy"
slMode      = input.string("Manual Pips", options=["Manual Pips", "ATR Volatility"], title="Stop Loss Mode", group=grp2)
manualPips  = input.float(10.0, title="Manual Stop Loss (Pips/Points)", step=0.5, group=grp2)
atrLength   = input.int(14, title="ATR Length", group=grp2)
atrMult     = input.float(1.5, title="ATR Multiplier", step=0.1, group=grp2)

grp3 = "Asset Specifics"
isForex     = input.bool(true, title="Is this a Forex pair? (Converts to Lots)", group=grp3)

// --- Core Risk Math ---
// 1. Calculate Dollar Risk
riskDollars = accCapital * (riskPct / 100)

// 2. Determine Stop Loss Distance in actual price format
// A standard forex pip is typically 10 ticks for a 5-decimal broker.
pipSize = isForex ? (syminfo.mintick * 10) : syminfo.mintick

float slPriceDiff = na
if slMode == "Manual Pips"
    slPriceDiff := manualPips * pipSize
else
    slPriceDiff := ta.atr(atrLength) * atrMult

// 3. Calculate Position Size
// Total risk per 1 unit of the asset = SL price difference * the point value
riskPerUnit = slPriceDiff * syminfo.pointvalue

// Total units = Risk in Dollars / Risk per 1 unit
units = riskDollars / riskPerUnit

// Convert raw units to standard lots (100,000 units = 1 Standard Lot in Forex)
lots = isForex ? (units / 100000) : units

// --- Dashboard Rendering ---
var table riskTable = table.new(position.bottom_right, 2, 5, border_width=1, border_color=color.new(color.gray, 80))

if barstate.islast
    // Header
    table.cell(riskTable, 0, 0, "DYNAMIC RISK SIZER", text_color=color.white, bgcolor=color.new(color.blue, 30), text_size=size.small)
    table.cell(riskTable, 1, 0, syminfo.ticker, text_color=color.white, bgcolor=color.new(color.blue, 30), text_size=size.small)
    
    // Risk Output
    table.cell(riskTable, 0, 1, "Max Risk:", text_color=color.gray, bgcolor=color.black, text_halign=text.align_left)
    table.cell(riskTable, 1, 1, "$" + str.tostring(riskDollars, "#.##"), text_color=color.red, bgcolor=color.black, text_halign=text.align_right)
    
    // Stop Loss Distance Output
    slDisplay = slMode == "Manual Pips" ? str.tostring(manualPips) + " Pips" : str.tostring(slPriceDiff / pipSize, "#.##") + " Pips (ATR)"
    table.cell(riskTable, 0, 2, "SL Distance:", text_color=color.gray, bgcolor=color.black, text_halign=text.align_left)
    table.cell(riskTable, 1, 2, slDisplay, text_color=color.white, bgcolor=color.black, text_halign=text.align_right)
    
    // Raw Units Output
    table.cell(riskTable, 0, 3, "Raw Units:", text_color=color.gray, bgcolor=color.black, text_halign=text.align_left)
    table.cell(riskTable, 1, 3, str.tostring(units, "#.##"), text_color=color.silver, bgcolor=color.black, text_halign=text.align_right)
    
    // Final Lot Size Output
    table.cell(riskTable, 0, 4, isForex ? "Lot Size:" : "Share Size:", text_color=color.white, bgcolor=color.new(color.green, 80), text_halign=text.align_left)
    table.cell(riskTable, 1, 4, str.tostring(lots, "#.###"), text_color=color.white, bgcolor=color.new(color.green, 80), text_halign=text.align_right)

Code: Select all

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

namespace cAlgo
{
    public enum SlCalculationMode
    {
        ManualPips,
        ATR_Volatility
    }

    [Indicator(IsOverlay = true, TimeZone = TimeZones.UTC, AccessRights = AccessRights.None)]
    public class DynamicPositionSizer : Indicator
    {
        [Parameter("Risk Per Trade (%)", DefaultValue = 0.5, MinValue = 0.01, Step = 0.1)]
        public double RiskPct { get; set; }

        [Parameter("Stop Loss Mode", DefaultValue = SlCalculationMode.ManualPips)]
        public SlCalculationMode SlMode { get; set; }

        [Parameter("Manual SL (Pips)", DefaultValue = 10.0, MinValue = 0.1)]
        public double ManualPips { get; set; }

        [Parameter("ATR Period", DefaultValue = 14, MinValue = 1)]
        public int AtrPeriod { get; set; }

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

        private AverageTrueRange _atr;
        private TextBlock _uiRisk;
        private TextBlock _uiSl;
        private TextBlock _uiUnits;
        private TextBlock _uiLots;

        protected override void Initialize()
        {
            _atr = Indicators.AverageTrueRange(AtrPeriod, MovingAverageType.Simple);
            BuildUI();
        }

        public override void Calculate(int index)
        {
            if (IsLastBar)
            {
                UpdateCalculations();
            }
        }

        private void UpdateCalculations()
        {
            // 1. Live account balance pull
            double riskDollars = Account.Balance * (RiskPct / 100.0);
            double slPips = ManualPips;

            // 2. Volatility Conversion
            if (SlMode == SlCalculationMode.ATR_Volatility)
            {
                // Converts raw price movement into broker-accurate pips
                slPips = (_atr.Result.LastValue / Symbol.PipSize) * AtrMultiplier;
            }

            if (slPips <= 0 || Symbol.PipValue == 0) return;

            // 3. Mathematical execution
            // Total risk = Volume * PipValue * SL in Pips
            double rawUnits = riskDollars / (slPips * Symbol.PipValue);
            
            // cTrader natively rounds to safe lot sizes to prevent broker execution errors
            double safeUnits = Symbol.NormalizeVolumeInUnits(rawUnits, RoundingMode.Down);
            double lots = Symbol.VolumeInUnitsToQuantity(safeUnits);

            // 4. Update UI
            _uiRisk.Text = $"Risk: {Account.Currency} {Math.Round(riskDollars, 2)}";
            
            string modeLabel = SlMode == SlCalculationMode.ManualPips ? "Pips" : "Pips (ATR)";
            _uiSl.Text = $"SL: {Math.Round(slPips, 1)} {modeLabel}";
            
            _uiUnits.Text = $"Units: {safeUnits}";
            _uiLots.Text = $"Lots: {Math.Round(lots, 2)}";
        }

        private void BuildUI()
        {
            var mainPanel = new StackPanel
            {
                Orientation = Orientation.Vertical,
                BackgroundColor = Color.FromArgb(220, 15, 15, 15),
                HorizontalAlignment = HorizontalAlignment.Right,
                VerticalAlignment = VerticalAlignment.Bottom,
                Margin = new Thickness(20),
                Width = 160
            };

            mainPanel.AddChild(new TextBlock 
            { 
                Text = "DYNAMIC SIZER", 
                ForegroundColor = Color.White, 
                BackgroundColor = Color.DodgerBlue,
                FontWeight = FontWeight.ExtraBold, 
                Margin = new Thickness(0, 0, 0, 5),
                Padding = new Thickness(5),
                TextAlignment = TextAlignment.Center
            });

            _uiRisk = CreateTextRow(mainPanel, Color.Tomato);
            _uiSl = CreateTextRow(mainPanel, Color.LightGray);
            _uiUnits = CreateTextRow(mainPanel, Color.DarkGray);
            _uiLots = CreateTextRow(mainPanel, Color.LimeGreen, true);

            Chart.AddControl(mainPanel);
        }

        private TextBlock CreateTextRow(StackPanel parent, Color color, bool isBold = false)
        {
            var textBlock = new TextBlock
            {
                ForegroundColor = color,
                FontWeight = isBold ? FontWeight.ExtraBold : FontWeight.Normal,
                Margin = new Thickness(5, 2, 5, 2)
            };
            parent.AddChild(textBlock);
            return textBlock;
        }
    }
}