forex-scalping.com

Code: Select all

//@version=5
strategy("ALMA Pro Scalper: Partial & Trail", overlay=true, initial_capital=10000, 
         default_qty_type=strategy.percent_of_equity, default_qty_value=2, 
         commission_type=strategy.commission.cash_per_order, commission_value=3, slippage=1,
         max_labels_count=500, max_lines_count=500)

// ==========================================
// INPUT GROUPS & PARAMETERS
// ==========================================
var string G_ALMA   = "ALMA Core Settings"
var string G_MACD   = "MACD Momentum Filter"
var string G_FILTER = "Pro Filters (Session & Trend)"
var string G_RISK   = "Risk, Partials & Trailing"
var string G_UI     = "Visuals & HUD"

// ALMA Settings
almaLength = input.int(9, title="Window Size", group=G_ALMA)
almaOffset = input.float(0.85, title="Offset", step=0.05, group=G_ALMA)
almaSigma  = input.int(6, title="Sigma", group=G_ALMA)

// MACD Settings
fastLength   = input.int(12, title="Fast Length", group=G_MACD)
slowLength   = input.int(26, title="Slow Length", group=G_MACD)
signalLength = input.int(9, title="Signal Length", group=G_MACD)

// Filters
useSession   = input.bool(true, title="Enable Session Filter?", group=G_FILTER)
sessionTimes = input.session("0800-1700", title="Trading Session (Exchange Time)", group=G_FILTER)
useHtfEma    = input.bool(true, title="Filter with 200 EMA?", group=G_FILTER)

// Risk & Management
atrLength    = input.int(14, title="ATR Length", group=G_RISK)
slMultiplier = input.float(1.5, title="Initial SL ATR Multiplier", step=0.1, group=G_RISK)
partialRR    = input.float(1.5, title="Partial Profit Target (in R)", step=0.1, group=G_RISK)
partialPct   = input.float(50.0, title="Partial Close %", group=G_RISK)
moveToBE     = input.bool(true, title="Move to Breakeven on Partial?", group=G_RISK)
trailBuffer  = input.int(10, title="Trail Buffer behind ALMA (Ticks/Points)", group=G_RISK)

// Visuals
showHUD      = input.bool(true, title="Show Dashboard Table?", group=G_UI)
colorCandles = input.bool(true, title="Color Candles by ALMA Trend?", group=G_UI)

// ==========================================
// INDICATOR CALCULATIONS
// ==========================================
almaLine = ta.alma(close, almaLength, almaOffset, almaSigma)
[macdLine, signalLine, histLine] = ta.macd(close, fastLength, slowLength, signalLength)
atr = ta.atr(atrLength)
ema200 = ta.ema(close, 200)
inSession = useSession ? not na(time(timeframe.period, sessionTimes)) : true

// ==========================================
// STATE VARIABLES FOR TRADE MANAGEMENT
// ==========================================
var float g_entry = na
var float g_sl    = na
var float g_tp    = na
var bool  g_partial_done = false

// Reset state when flat
if strategy.position_size == 0
    g_entry := na
    g_sl    := na
    g_tp    := na
    g_partial_done := false

// Detect Partial Close (if position volume decreases but remains active)
if strategy.position_size > 0 and strategy.position_size[1] > 0 and strategy.position_size < strategy.position_size[1]
    g_partial_done := true
    if moveToBE
        g_sl := math.max(g_sl, g_entry) // Shift SL to entry for Long

if strategy.position_size < 0 and strategy.position_size[1] < 0 and strategy.position_size > strategy.position_size[1]
    g_partial_done := true
    if moveToBE
        g_sl := math.min(g_sl, g_entry) // Shift SL to entry for Short

// ==========================================
// ENTRY LOGIC
// ==========================================
longCross  = ta.crossover(close, almaLine)
shortCross = ta.crossunder(close, almaLine)

longCond  = longCross  and (histLine > 0) and inSession and (useHtfEma ? close > ema200 : true)
shortCond = shortCross and (histLine < 0) and inSession and (useHtfEma ? close < ema200 : true)

if longCond and strategy.position_size == 0
    g_entry := close
    g_sl    := close - (atr * slMultiplier)
    risk    = close - g_sl
    g_tp    := close + (risk * partialRR)
    strategy.entry("Long", strategy.long)

if shortCond and strategy.position_size == 0
    g_entry := close
    g_sl    := close + (atr * slMultiplier)
    risk    = g_sl - close
    g_tp    := close - (risk * partialRR)
    strategy.entry("Short", strategy.short)

// ==========================================
// TRAILING SL LOGIC & EXIT EXECUTION
// ==========================================
if strategy.position_size > 0
    // Trail SL behind ALMA
    trail_level = almaLine - (trailBuffer * syminfo.mintick)
    g_sl := math.max(g_sl, trail_level) // Never move stop downwards
    
    // Execute Partials and Trails
    if not g_partial_done
        strategy.exit("TP1", "Long", qty_percent=partialPct, limit=g_tp, stop=g_sl)
    strategy.exit("Trail", "Long", stop=g_sl)

if strategy.position_size < 0
    // Trail SL behind ALMA
    trail_level = almaLine + (trailBuffer * syminfo.mintick)
    g_sl := math.min(g_sl, trail_level) // Never move stop upwards
    
    // Execute Partials and Trails
    if not g_partial_done
        strategy.exit("TP1", "Short", qty_percent=partialPct, limit=g_tp, stop=g_sl)
    strategy.exit("Trail", "Short", stop=g_sl)

// ==========================================
// VISUAL RENDERING
// ==========================================
almaColor = close > almaLine ? color.new(#00E676, 0) : color.new(#FF5252, 0)
plot(almaLine, color=almaColor, linewidth=2, title="ALMA")
plot(useHtfEma ? ema200 : na, color=color.new(color.white, 50), linewidth=1, title="200 EMA")

// Plot the dynamic Trailing Stop Loss line when in a trade
plot(strategy.position_size != 0 ? g_sl : na, color=color.new(color.fuchsia, 0), style=plot.style_stepline, linewidth=1, title="Active Stop Loss")

barcolor(colorCandles ? almaColor : na)
bgcolor(useSession and inSession ? color.new(color.blue, 95) : na, title="Trading Session")

// ==========================================
// DASHBOARD HUD
// ==========================================
if showHUD
    var table hud = table.new(position.top_right, 2, 5, border_width = 1)
    if barstate.islast
        table.cell(hud, 0, 0, "Metric", text_color=color.white, bgcolor=color.gray)
        table.cell(hud, 1, 0, "Value", text_color=color.white, bgcolor=color.gray)
        
        table.cell(hud, 0, 1, "ALMA Trend", text_color=color.white, bgcolor=color.black)
        table.cell(hud, 1, 1, close > almaLine ? "BULLISH" : "BEARISH", text_color=close > almaLine ? color.green : color.red, bgcolor=color.black)
        
        table.cell(hud, 0, 2, "Session Status", text_color=color.white, bgcolor=color.black)
        table.cell(hud, 1, 2, inSession ? "ACTIVE" : "CLOSED", text_color=inSession ? color.green : color.red, bgcolor=color.black)
        
        table.cell(hud, 0, 3, "Volatility (ATR)", text_color=color.white, bgcolor=color.black)
        table.cell(hud, 1, 3, str.tostring(atr, "#.#####"), text_color=color.yellow, bgcolor=color.black)
        
        table.cell(hud, 0, 4, "Trade State", text_color=color.white, bgcolor=color.black)
        
        tradeStateText = strategy.position_size == 0 ? "FLAT" : (g_partial_done ? "TRAILING (BE)" : "INITIAL RISK")
        tradeStateColor = strategy.position_size == 0 ? color.gray : (g_partial_done ? color.fuchsia : color.orange)
        table.cell(hud, 1, 4, tradeStateText, text_color=tradeStateColor, bgcolor=color.black)

Code: Select all

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

namespace cAlgo.Robots
{
    [Robot(TimeZone = TimeZones.UTC, AccessRights = AccessRights.None)]
    public class ALMA_Pro_Scalper : Robot
    {
        // ==========================================
        // PARAMETERS
        // ==========================================
        [Parameter("ALMA Window Size", Group = "ALMA", DefaultValue = 9)]
        public int AlmaLength { get; set; }

        [Parameter("ALMA Offset", Group = "ALMA", DefaultValue = 0.85, MinValue = 0, MaxValue = 1)]
        public double AlmaOffset { get; set; }

        [Parameter("ALMA Sigma", Group = "ALMA", DefaultValue = 6.0)]
        public double AlmaSigma { get; set; }

        [Parameter("MACD Fast", Group = "MACD", DefaultValue = 12)]
        public int MacdFast { get; set; }

        [Parameter("MACD Slow", Group = "MACD", DefaultValue = 26)]
        public int MacdSlow { get; set; }

        [Parameter("MACD Signal", Group = "MACD", DefaultValue = 9)]
        public int MacdSignal { get; set; }

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

        [Parameter("Initial SL (ATR Multiplier)", Group = "Risk Management", DefaultValue = 1.5)]
        public double SlAtrMultiplier { get; set; }

        [Parameter("Partial Target (in R)", Group = "Risk Management", DefaultValue = 1.5)]
        public double PartialRR { get; set; }

        [Parameter("Partial Close %", Group = "Risk Management", DefaultValue = 50.0)]
        public double PartialPct { get; set; }

        [Parameter("Move to Breakeven?", Group = "Risk Management", DefaultValue = true)]
        public bool MoveToBE { get; set; }

        [Parameter("Trail Buffer (Pips)", Group = "Risk Management", DefaultValue = 1.0)]
        public double TrailBufferPips { get; set; }

        [Parameter("Max Spread (Pips)", Group = "Filters", DefaultValue = 1.5)]
        public double MaxSpreadPips { get; set; }

        [Parameter("Trading Session (UTC)", Group = "Filters", DefaultValue = "08:00-17:00")]
        public string SessionHours { get; set; }

        [Parameter("Trade Volume (Units)", Group = "Execution", DefaultValue = 100000)]
        public double LotVolume { get; set; }

        // ==========================================
        // STATE & INDICATORS
        // ==========================================
        private MacdCross _macd;
        private AverageTrueRange _atr;
        private Dictionary<int, double> _partialTargets = new Dictionary<int, double>();
        
        private TimeSpan _sessionStart;
        private TimeSpan _sessionEnd;
        private const string BotLabel = "ALMA Pro";

        protected override void OnStart()
        {
            // Note: cTrader MacdCross takes (Long, Short, Signal)
            _macd = Indicators.MacdCross(Bars.ClosePrices, MacdSlow, MacdFast, MacdSignal);
            _atr = Indicators.AverageTrueRange(Bars, AtrPeriod, MovingAverageType.Simple);

            string[] hours = SessionHours.Split('-');
            _sessionStart = TimeSpan.Parse(hours[0]);
            _sessionEnd = TimeSpan.Parse(hours[1]);
        }

        protected override void OnPositionOpened(PositionOpenedEventArgs args)
        {
            var pos = args.Position;
            if (pos.SymbolName == SymbolName && pos.Label == BotLabel)
            {
                // Memorize the exact absolute price for the 1.5R partial target
                if (pos.StopLoss.HasValue)
                {
                    double risk = Math.Abs(pos.EntryPrice - pos.StopLoss.Value);
                    double target = pos.TradeType == TradeType.Buy 
                        ? pos.EntryPrice + (risk * PartialRR) 
                        : pos.EntryPrice - (risk * PartialRR);
                        
                    _partialTargets[pos.Id] = target;
                }
            }
        }

        protected override void OnPositionClosed(PositionClosedEventArgs args)
        {
            // Clean up memory if position is fully closed (e.g., SL hit before partial)
            _partialTargets.Remove(args.Position.Id);
        }

        protected override void OnTick()
        {
            double currentAlma = CalculateALMA(1, AlmaLength, AlmaOffset, AlmaSigma);
            if (currentAlma == 0) return;

            foreach (var pos in Positions.FindAll(BotLabel, SymbolName))
            {
                // 1. Manage ALMA Trailing Stop
                if (pos.TradeType == TradeType.Buy)
                {
                    double newSl = currentAlma - (TrailBufferPips * Symbol.PipSize);
                    if (newSl > (pos.StopLoss ?? 0) && newSl < Symbol.Bid)
                    {
                        ModifyPosition(pos, Math.Round(newSl, Symbol.Digits), pos.TakeProfit);
                    }
                }
                else if (pos.TradeType == TradeType.Sell)
                {
                    double newSl = currentAlma + (TrailBufferPips * Symbol.PipSize);
                    if ((newSl < (pos.StopLoss ?? double.MaxValue)) && newSl > Symbol.Ask)
                    {
                        ModifyPosition(pos, Math.Round(newSl, Symbol.Digits), pos.TakeProfit);
                    }
                }

                // 2. Manage Partial Closes
                if (_partialTargets.ContainsKey(pos.Id))
                {
                    double targetPrice = _partialTargets[pos.Id];
                    bool targetHit = pos.TradeType == TradeType.Buy ? Symbol.Bid >= targetPrice : Symbol.Ask <= targetPrice;

                    if (targetHit)
                    {
                        // Calculate standard volume to close based on broker step size
                        double targetVolume = pos.VolumeInUnits * (PartialPct / 100.0);
                        double closeVol = Symbol.NormalizeVolumeInUnits(targetVolume, RoundingMode.Down);

                        if (closeVol >= Symbol.VolumeInUnitsMin)
                        {
                            ClosePosition(pos, closeVol); // cTrader natively handles the partial close
                        }
                        
                        _partialTargets.Remove(pos.Id); // Mark as done

                        if (MoveToBE)
                        {
                            ModifyPosition(pos, pos.EntryPrice, pos.TakeProfit);
                        }
                    }
                }
            }
        }

        protected override void OnBarClosed()
        {
            // Ensure we only have one position open at a time
            if (Positions.FindAll(BotLabel, SymbolName).Length > 0) return;

            // Session Filter
            TimeSpan now = Server.Time.TimeOfDay;
            bool inSession = (_sessionStart <= _sessionEnd) 
                ? (now >= _sessionStart && now <= _sessionEnd) 
                : (now >= _sessionStart || now <= _sessionEnd);
            
            if (!inSession) return;

            // Max Spread Filter
            double spreadPips = Symbol.Spread / Symbol.PipSize;
            if (spreadPips > MaxSpreadPips)
            {
                Print($"Spread ({spreadPips} pips) exceeds max allowance. Skipping ALMA cross.");
                return;
            }

            double alma1 = CalculateALMA(1, AlmaLength, AlmaOffset, AlmaSigma);
            double alma2 = CalculateALMA(2, AlmaLength, AlmaOffset, AlmaSigma);
            if (alma1 == 0 || alma2 == 0) return;

            double close1 = Bars.ClosePrices.Last(1);
            double close2 = Bars.ClosePrices.Last(2);
            double hist1  = _macd.Histogram.Last(1);

            bool longCross  = (close1 > alma1 && close2 <= alma2);
            bool shortCross = (close1 < alma1 && close2 >= alma2);

            if (longCross && hist1 > 0)
            {
                double slPips = (_atr.Result.Last(1) * SlAtrMultiplier) / Symbol.PipSize;
                ExecuteMarketOrder(TradeType.Buy, SymbolName, LotVolume, BotLabel, slPips, null);
            }
            else if (shortCross && hist1 < 0)
            {
                double slPips = (_atr.Result.Last(1) * SlAtrMultiplier) / Symbol.PipSize;
                ExecuteMarketOrder(TradeType.Sell, SymbolName, LotVolume, BotLabel, slPips, null);
            }
        }

        // Custom Gaussian Distribution ALMA Calculation
        private double CalculateALMA(int shift, int length, double offset, double sigma)
        {
            double m = offset * (length - 1);
            double s = length / sigma;
            double wSum = 0.0;
            double res = 0.0;

            for (int i = 0; i < length; i++)
            {
                double w = Math.Exp(-(Math.Pow(i - m, 2)) / (2 * s * s));
                res += Bars.ClosePrices.Last(shift + (length - 1 - i)) * w;
                wSum += w;
            }
            
            return wSum > 0 ? res / wSum : 0.0;
        }
    }
}

Code: Select all

[Robot(TimeZone = TimeZones.UTC, AccessRights = AccessRights.FullAccess)]
public class ALMA_Pro_Scalper : Robot

Code: Select all

[Parameter("Enable Discord Alerts", Group = "Webhooks", DefaultValue = false)]
public bool EnableDiscord { get; set; }

[Parameter("Discord Webhook URL", Group = "Webhooks", DefaultValue = "")]
public string DiscordUrl { get; set; }

[Parameter("Enable Telegram Alerts", Group = "Webhooks", DefaultValue = false)]
public bool EnableTelegram { get; set; }

[Parameter("Telegram Bot Token", Group = "Webhooks", DefaultValue = "")]
public string TelegramToken { get; set; }

[Parameter("Telegram Chat ID", Group = "Webhooks", DefaultValue = "")]
public string TelegramChatId { get; set; }

Code: Select all

private void SendAlert(string message)
{
    // Discord Integration
    if (EnableDiscord && !string.IsNullOrEmpty(DiscordUrl))
    {
        try 
        {
            // Discord expects a "content" key
            string payload = $"{{\"content\": \"{message}\"}}";
            Http.Post(DiscordUrl, payload, "application/json");
        } 
        catch (Exception ex) { Print("Discord Webhook Error: " + ex.Message); }
    }

    // Telegram Integration
    if (EnableTelegram && !string.IsNullOrEmpty(TelegramToken) && !string.IsNullOrEmpty(TelegramChatId))
    {
        try 
        {
            string url = $"https://api.telegram.org/bot{TelegramToken}/sendMessage";
            // Telegram expects "chat_id" and "text" keys
            string payload = $"{{\"chat_id\": \"{TelegramChatId}\", \"text\": \"{message}\"}}";
            Http.Post(url, payload, "application/json");
        } 
        catch (Exception ex) { Print("Telegram Webhook Error: " + ex.Message); }
    }
}

Code: Select all

protected override void OnPositionOpened(PositionOpenedEventArgs args)
{
    var pos = args.Position;
    if (pos.SymbolName == SymbolName && pos.Label == BotLabel)
    {
        // ... (Keep your existing partial targets logic here) ...
        
        // Build and send the alert
        string direction = pos.TradeType == TradeType.Buy ? "LONG" : "SHORT";
        string msg = $"🚨 **ALMA Scalper Executed**\\n" +
                     $"Symbol: {pos.SymbolName}\\n" +
                     $"Direction: {direction}\\n" +
                     $"Entry: {pos.EntryPrice}\\n" +
                     $"Initial SL: {pos.StopLoss}";
                     
        SendAlert(msg);
    }
}