Grid Bot Simulator

//@version=5

//------------------------------------------------------------------------------------------------<>
//      This source code is subject to the terms of the Mozilla Public License 2.0 
// © goodgains

//      https://mozilla.org/MPL/2.0/ 
//      Updated 01/17/2022: Pinescript v5: 
//          Price Selectors--Converted color transparences to prevent deprecation warning
strategy('Grid Bot Simulator', shorttitle='GridBot', overlay=true)

// @keywords: grid-bot-simulator, price-grid, grid-lines, buy-signal, sell-signal, upper-limit, lower-limit, grid-interval, ema-trend-line, trend-ema, backtest-window, trade-zone-highlight, direction-filter, extreme-cross, grid-entry, grid-exit, signal-tracker, grid-boundary, interval-lines, long-short-entries

//-----<Inputs>-----------------------------------------------------------------------------------<> 
UpperLimit = input.price(49000.0, 'Upper Limit', confirm=false)
LowerLimit = input.price(43000.0, 'Lower Limit', confirm=false)
No_Grids = input(60, 'Number of Grids(10)') + 1
Dir = input.string('neutral', 'Market Direction', options=['up', 'neutral', 'down'])
SS = input.string('small', 'Signal Size', options=['small', 'large'])
ShowGrids = input(true, 'Show Grids')
HighLight = input(true, 'Highlight Trade Zones')
ShowCurrent = input(false, 'Show Only Current Grids')
Extremes = input(true, 'High/Low for signals')
//Dates
bt_start = input.time(timestamp("01 mar 2022  00:00 +0000"), title="Start Date", group="backtesting period")
bt_end = input.time(timestamp("31 dec 9999  00:00 +0000"), title="End Date", group="backtesting period")
backtestPeriod = input("day", "backtest period", tooltip="month = 30 days year = 365 days", group="backtesting period")
//if backtestPeriod == "day"
//    bt_start := timestamp(year(timenow), month(timenow), dayofmonth(timenow), 00, 00) - 86400000
//if backtestPeriod == "week"
 //   bt_start := timestamp(year(timenow), month(timenow), dayofmonth(timenow), 00, 00) - (86400000 * 7)
//if backtestPeriod == "month"
//    bt_start := timestamp(year(timenow), month(timenow), dayofmonth(timenow), 00, 00) - (86400000 * 30)
//if backtestPeriod == "year"
//    bt_start := timestamp(year(timenow), month(timenow), dayofmonth(timenow), 00, 00) - (86400000 * 365)
bt_window = time >= bt_start and time <= bt_end
//-----<Variables>--------------------------------------------------------------------------------<>
LastSignal = 0
LastSignal_Index = 0
LastSignal_Time = time
SignalLine = 0.0
CurrentGrid = 0.0
Buy = false
Sell = false
Direction = Dir == 'up' ? 1 : Dir == 'down' ? -1 : 0
//-----<Signal variables>-----------------------------------------------------------------------------------<>
length1 = input.int(5, minval=1)
ema1 = ta.ema(close, length1)
ema2 = ta.ema(ema1, length1)
ema3 = ta.ema(ema2, length1)
t1 = 3 * (ema1 - ema2) + ema3
plot(t1,"T1", color=#FFFFFF)

length = input.int(5, minval=1)
ema4 = ta.ema(t1, length)
ema5 = ta.ema(ema4, length)
ema6 = ta.ema(ema5, length)
t2 = 3 * (ema4 - ema5) + ema6
plot(t2, "T2", color=#2962FF)
//-----<RE-ENTRY>-----------------------------------------------------------------------------------<>
//call_reentry = crossover(t1,t2)





//-----<Colors>-----------------------------------------------------------------------------------<>
RedGrid = color.new(color.red, 50)
GreenGrid = color.new(color.green, 40)
Crimson = #DC143C
LimeGreen = #32CD32
//-----<Calculate Grids>--------------------------------------------------------------------------<>
GridRange = UpperLimit - LowerLimit
GridInterval = GridRange / (No_Grids - 1)
//-----<Grid Array>-------------------------------------------------------------------------------<>
a_grid = array.new_float(No_Grids)
for x = 0 to No_Grids - 1 by 1
    array.set(a_grid, x, LowerLimit + GridInterval * x)
//-----<Get Array Function>-----------------------------------------------------------------------<>
Get_Array_Values(ArrayName, index) =>
    value = array.get(ArrayName, index)
    value
//-----<Calculate Signals>------------------------------------------------------------------------<>
Get_BuyLine_Index() =>
    Index = 0
    BuyValue = 0.0
    for x = 0 to No_Grids - 1 by 1
        BuyValue := LowerLimit + GridInterval * x - 50
        if Extremes
            Index := high[1] > BuyValue and low <= BuyValue ? x : Index
            Index
        else
            Index := close[1] > BuyValue and close <= BuyValue ? x : Index
            Index
Get_SellLine_Index() =>
    Index = 0
    SellValue = 0.0
    for x = 0 to No_Grids - 1 by 1
        SellValue := LowerLimit + GridInterval * x + 50
        if Extremes
            Index := low[1] < SellValue and high >= SellValue ? x : Index
            Index
        else
            Index := close[1] < SellValue and close >= SellValue ? x : Index
            Index
BuyLine_Index = Get_BuyLine_Index()
SellLine_Index = Get_SellLine_Index()
//-----<Signals>----------------------------------------------------------------------------------<>
Buy := BuyLine_Index > 0 ? true : Buy
Sell := SellLine_Index > 0 ? true : Sell
//No repeat trades at current level                                                                                     
if Extremes
    Buy := low >= SignalLine[1] - GridInterval ? false : Buy
    Sell := high <= SignalLine[1] + GridInterval ? false : Sell
    Sell
else
    Buy := close >= SignalLine[1] - GridInterval ? false : Buy
    Sell := close <= SignalLine[1] + GridInterval ? false : Sell
    Sell
//No trades outside of grid limits
Buy := close >= UpperLimit ? false : Buy
Buy := close < LowerLimit ? false : Buy
Sell := close <= LowerLimit ? false : Sell
Sell := close > UpperLimit ? false : Sell
//Direction Filter (skip one signal if against market direction)
Buy := Direction == -1 and low >= SignalLine[1] - GridInterval * 2 ? false : Buy
Sell := Direction == 1 and high <= SignalLine[1] + GridInterval * 2 ? false : Sell
//-----<Trackers>---------------------------------------------------------------------------------<>
LastSignal := Buy ? 1 : Sell ? -1 : LastSignal[1]
LastSignal_Index := Buy ? BuyLine_Index : Sell ? SellLine_Index : LastSignal_Index[1]
LastSignal_Time := Buy or Sell ? time : LastSignal_Time[1]
SignalLine := LowerLimit + GridInterval * LastSignal_Index
//-----<Plot Grids>-------------------------------------------------------------------------------<>
for i = 1 to No_Grids - 1 by 1
    Array_Value = Get_Array_Values(a_grid, i)
    ClosestGrid = Array_Value - close
    color linecolor = ClosestGrid > 0 ? RedGrid : ClosestGrid < 0 ? GreenGrid : na
    linecolor := i == LastSignal_Index ? na : linecolor
    if ShowGrids
        if ShowCurrent
            LineAbove = line.new(x1=LastSignal_Time, y1=SignalLine + GridInterval, x2=time + 1000000, y2=SignalLine + GridInterval, color=color.red, width=1, extend=extend.left, xloc=xloc.bar_time)
            LineBelow = line.new(x1=LastSignal_Time, y1=SignalLine - GridInterval, x2=time + 1000000, y2=SignalLine - GridInterval, color=color.green, width=1, extend=extend.left, xloc=xloc.bar_time)
            LineBelow
        else
            color colCurrent = LastSignal == 1 ? color.new(color.green, 95) : color.new(color.red, 95)
            GridLines = line.new(x1=time, y1=Array_Value, x2=time[1], y2=Array_Value, color=linecolor, width=1, extend=extend.right, xloc=xloc.bar_time)
            //draw line before latest signal
            CurrentLine = line.new(x1=LastSignal_Time, y1=SignalLine, x2=LastSignal_Time - 100000, y2=SignalLine, color=colCurrent, width=1, extend=extend.right, xloc=xloc.bar_time)
            CurrentLine
UL = ShowGrids and not ShowCurrent
plot(UL ? UpperLimit : na, color=close >= UpperLimit ? color.green : color.red, linewidth=3)
plot(UL ? LowerLimit : na, color=close <= LowerLimit ? color.red : color.green, linewidth=3)
//Lines One Above & One Below
LineAbove = SignalLine == UpperLimit ? SignalLine : SignalLine + GridInterval
LineBelow = SignalLine == LowerLimit ? SignalLine : SignalLine - GridInterval
a = plot(LineAbove, color=color.new(color.red, 100), style=plot.style_circles)
b = plot(LineBelow, color=color.new(color.green, 100), style=plot.style_circles)
boxColor = LastSignal == -1 ? color.new(color.green, 90) : color.new(color.red, 90)
boxColor := HighLight ? boxColor : na
fill(a, b, color=color.new(boxColor, 90))
//-----<Plot Signals>-----------------------------------------------------------------------------<>
plotchar(Buy and SS == 'small', 'Buy', color=color.new(LimeGreen, 0), size=size.tiny, location=location.belowbar, char='▲')
plotchar(Sell and SS == 'small', 'Sell', color=color.new(Crimson, 0), size=size.tiny, location=location.abovebar, char='▼')
plotchar(Buy and SS == 'large', 'Buy', color=color.new(LimeGreen, 0), size=size.small, location=location.belowbar, char='▲')
plotchar(Sell and SS == 'large', 'Sell', color=color.new(Crimson, 0), size=size.small, location=location.abovebar, char='▼')
//-----<Entry Conditions>-----------------------------------------------------------------------------------<>
//Buy Conditions 







//-----<Strategy Long Entry>---------<>
if (Buy)
    strategy.entry("GbsLE", strategy.long, comment="GbsLETK")
//alertcondition(condition=Buy, title='buy', message='buy')
//   ----<Strategy Short Entry>---------<>
if (Sell)
    strategy.entry("GbsSE", strategy.short, comment="GbsSETK")
//alertcondition(condition=Sell, title='sell', message='sell')