#region Using declarations

using System;

using System.Collections.Generic;

using System.ComponentModel;

using System.ComponentModel.DataAnnotations;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

using System.Windows;

using System.Windows.Input;

using System.Windows.Media;

using System.Xml.Serialization;

using NinjaTrader.Cbi;

using NinjaTrader.Gui;

using NinjaTrader.Gui.Chart;

using NinjaTrader.Gui.SuperDom;

using NinjaTrader.Gui.Tools;

using NinjaTrader.Data;

using NinjaTrader.NinjaScript;

using NinjaTrader.Core.FloatingPoint;

using NinjaTrader.NinjaScript.Indicators;

using NinjaTrader.NinjaScript.DrawingTools;

#endregion

//This namespace holds Strategies in this folder and is required. Do not change it. 

namespace NinjaTrader.NinjaScript.Strategies

{

    public class RSIScalpTrailingStop : Strategy

    {

        // Define strategy parameters as public properties

        public int Trail_Trigger { get; set; }

        public int Trail_Size { get; set; }

        public int Trail_Frequency { get; set; }

        public int TicksBetweenTrades { get; set; }

        public int Trail_StopLossTicks { get; set; } // New parameter for Trailing Stop for Stop Loss

        public int Trail_ProfitTicks { get; set; } // New parameter for Trailing Stop for Profits

​

        private RSI rsi;

        private double trailingStopPrice;

        private int ticksSinceLastTrade;

        private double trailingProfitStopPrice; // Variable to track trailing profit stop price

        private double ExpectedProfit;

​

        // Define additional strategy parameters

        public int TP { get; set; }

        public int SL { get; set; }

        public int LotSize { get; set; }

        public int RSI55UP { get; set; }

        public int RSI50Down { get; set; }

​

        protected override void OnStateChange()

        {

            if (State == State.SetDefaults)

            {

                // Set default strategy parameters

                Description = @"Enter the description for your new custom Strategy here.";

                Name = "RSIScalpTrailingStop";

                Calculate = Calculate.OnEachTick;

                EntriesPerDirection = 1;

                EntryHandling = EntryHandling.AllEntries;

                IsExitOnSessionCloseStrategy = true;

                ExitOnSessionCloseSeconds = 30;

                IsFillLimitOnTouch = false;

                MaximumBarsLookBack = MaximumBarsLookBack.TwoHundredFiftySix;

                OrderFillResolution = OrderFillResolution.Standard;

                Slippage = 0;

                StartBehavior = StartBehavior.WaitUntilFlat;

                TimeInForce = TimeInForce.Gtc;

                TraceOrders = false;

                RealtimeErrorHandling = RealtimeErrorHandling.StopCancelClose;

                StopTargetHandling = StopTargetHandling.PerEntryExecution;

                BarsRequiredToTrade = 20;

​

                // Initialize parameters with default values

                Trail_Trigger = 5;

                Trail_Size = 4;

                Trail_Frequency = 3;

                TicksBetweenTrades = 10;

                TP = 12;

                SL = 20;

                LotSize = 1;

                RSI55UP = 55;

                RSI50Down = 50;

                Trail_StopLossTicks = 10;

                Trail_ProfitTicks = 10;

            }

            else if (State == State.DataLoaded)

            {

                // Initialize RSI indicator and set initial profit target

                rsi = RSI(Close, 14, 3);

                SetProfitTarget("", CalculationMode.Ticks, TP);

                SetStopLoss("", CalculationMode.Ticks, SL, false);

                // Initialize ExpectedProfit

                ExpectedProfit = TP * TickSize;

            }

        }

​

        protected override void OnBarUpdate()

        {

            // Count ticks since last trade

            ticksSinceLastTrade++;

​

            // Entry logic for long position

            if (CrossAbove(rsi.Default, RSI55UP, 1) && ticksSinceLastTrade >= TicksBetweenTrades)

            {

                EnterLong();

                SetStopLoss("", CalculationMode.Price, Low[0] - (Trail_Size * TickSize), false);

                trailingStopPrice = High[0] - (Trail_Trigger * TickSize);

                trailingProfitStopPrice = Close[0] + (Trail_ProfitTicks * TickSize);

                ticksSinceLastTrade = 0;

                BackBrush = Brushes.MediumSeaGreen;

            }

​

 // Entry logic for short position

if (CrossBelow(rsi.Default, RSI50Down, 1) && ticksSinceLastTrade >= TicksBetweenTrades)

{

    EnterShort(); // Enter short position

    SetStopLoss("", CalculationMode.Price, Low[0] + (Trail_Size * TickSize), false); // Set initial stop loss

    trailingStopPrice = High[0] - (Trail_Trigger * TickSize);

    trailingProfitStopPrice = Close[0] + (Trail_ProfitTicks * TickSize); // Set initial profit target

    ticksSinceLastTrade = 0; // Reset counter

    BackBrush = Brushes.Goldenrod;

}

​

​

            // Update trailing stop for profits

            if (Position.MarketPosition == MarketPosition.Long && Close[0] > trailingProfitStopPrice)

            {

                trailingProfitStopPrice = Close[0] + (Trail_ProfitTicks * TickSize);

                SetProfitTarget("", CalculationMode.Price, trailingProfitStopPrice);

            }

            else if (Position.MarketPosition == MarketPosition.Short && Close[0] < trailingProfitStopPrice)

            {

                trailingProfitStopPrice = Close[0] - (Trail_ProfitTicks * TickSize);

                SetProfitTarget("", CalculationMode.Price, trailingProfitStopPrice);

            }

​

            // Update trailing stop for stop loss based on frequency

            if (ticksSinceLastTrade % Trail_Frequency == 0)

            {

                if (Position.MarketPosition == MarketPosition.Long)

                {

                    SetStopLoss("", CalculationMode.Price, trailingStopPrice, false);

                }

                else if (Position.MarketPosition == MarketPosition.Short)

                {

                    SetStopLoss("", CalculationMode.Price, trailingStopPrice, false);

                }

            }

​

            // Dynamically adjust profit target when 90% of expected profit is reached

            if (Position.MarketPosition == MarketPosition.Long && Close[0] >= (ExpectedProfit * 0.9))

            {

                double newProfitTarget = trailingProfitStopPrice + (Trail_ProfitTicks * TickSize);

                SetProfitTarget("", CalculationMode.Price, newProfitTarget);

                // Update expected profit

                ExpectedProfit = newProfitTarget - trailingProfitStopPrice;

            }

            else if (Position.MarketPosition == MarketPosition.Short && Close[0] <= (ExpectedProfit * 0.9))

            {

                double newProfitTarget = trailingProfitStopPrice - (Trail_ProfitTicks * TickSize);

                SetProfitTarget("", CalculationMode.Price, newProfitTarget);

                // Update expected profit

                ExpectedProfit = trailingProfitStopPrice - newProfitTarget;

            }

        }

    }

}

​

​

​