Johny's BOT
Author: ChaoZhang, Date: 2022-05-18 09:38:27Tags: ADXRSIMACD
Hello
This is updated version of 60MIN bot, I decided to make this bot for people who still using 10BOT, This is much more profitable and reliable version
THIS IS SO IMPORTANT for users
As always, this bot is ONLY FOR BINANCE:BTCUSDTPERP
To make this result as true as possible, I decided to use as few indicators as possible which translates into more positions, which means that the bot is quick to react to any change in trend Unfortunately, as a result, the quality of opened positions has decreased quite strongly ( 79% profitable trades) It also consists of a fairly high target point and basically a low stop-loss.
TP: 1.5 SL: 7.2
The bot uses the most efficient and most important indicators such as:
ADX - Is one of the most powerful and accurate trend indicators. ADX measures how strong a trend is, and can give valuable information on whether there is a potential trading opportunity. CLOUD - This is one of the newset indicators I’m using. This indicator helps strategy , this indicator is designed to indicate the correct market trend. By applying the great length of this indicator, I am able to notice a change in the trend a little later, but more accurately. RANGE FILTER - this indicator is for the better view of trends, define trends, that is important for every bull/bear traps which helps a lot becouse of the very variable trends. FAST MA - like previous ones this is for better view of trends, and correctly define the trends, also Speed_MA are using for predict the future price action. MACD - Moving average convergence divergence ( MACD ) is a trend-following momentum indicator that shows the relationship between two moving averages of a security’s price. The MACD is calculated by subtracting the 26-period exponential moving average ( EMA ) from the 12-period EMA . VOLUME - is the most important indicator for the strategy, to avoid open trades on flat chart, new trades are open after a strong volume bars. RSI - value helps strategy to stop trade in right time. When RSI is overbought strategy don’t open new longs , also when RSI is oversold strategy don’t open new shorts
using these indicators, the bot opens about 75-80% of positions in addition, I created two independent of the main condition of the possibility of opening a position such as:
REVERSALS (based of rsi crossovers) - this option, can add more speed to make right decision, while trends are changin very fast. BOLLINGER BANDS - this function has also increased the possibilities of opening and closing new positions, it works in such a way that if the candle is closed outside the Bolinger bands, more positions are opened, I focused on this function in order to maintain a high percentage level as much as possible
To maintain the high quality of trades, both Bollinger Bands and Reversals are dependent on the most important indicators
I think that the results of this bot are the most correct, but let’s not forget that backtesting is testing in the past, it is not known how the bot will behave in the future, however, the use of indicators that are not very optimized, can bring the result very close in the future
Good luck and enjoy ;)
backtesting
/*backtest
start: 2022-05-01 00:00:00
end: 2022-05-16 23:59:00
period: 4h
basePeriod: 15m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/
//@version=4
strategy("Johny's BOT [60MIN]", overlay=true, pyramiding=1,initial_capital = 10000, default_qty_type= strategy.percent_of_equity, default_qty_value = 100, calc_on_order_fills=false, slippage=0,commission_type=strategy.commission.percent,commission_value=0.04)
//SOURCE =============================================================================================================================================================================================================================================================================================================
src = input(high)
// INPUTS ============================================================================================================================================================================================================================================================================================================
// ADX --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
ADX_options = input("MASANAKAMURA", title = "ADX option", options = ["CLASSIC", "MASANAKAMURA"], group = "ADX")
ADX_len = input(13, title = "ADX lenght", type = input.integer, minval = 1, group = "ADX")
th = input(15, title = "ADX treshold", type = input.float, minval = 0, step = 0.5, group = "ADX")
// Cloud --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
len = input(7, title="Cloud Length", group="Cloud")
//SAR----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
start = input(0.015, title="SAR Start", type=input.float, step=0.001 , group="SAR")
increment = input(0.018, title="SAR Increment", type=input.float, step=0.001 , group="SAR")
maximum = input(0.1, title="SAR Maximum", type=input.float, step=0.01 , group="SAR")
// Range Filter ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
per_ = input(10, title="Period", minval=1, group = "Range Filter")
mult = input(1.5, title="mult.", minval=0.1, step = 0.1, group = "Range Filter")
//MACD----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
fast_length = input(6, title="Fast Length", type=input.integer, group="MACD")
slow_length = input(8, title="Slow Length", type=input.integer, group="MACD")
signal_length = input(17, title="Signal Smoothing", type=input.integer, group="MACD")
// Volume ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
volume_f = input(0.8, title="Volume mult.", minval = 0, step = 0.1, group="Volume")
sma_length = input(37, title="Volume lenght", minval = 1, group="Volume")
// RSI -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
RSI_len = input(25, title="Rsi Lenght", minval = 1, group="RSI")
//BOLINGER BANDS ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
// inputs
bb1 = input(true, title="Show BB ", group="Bollinger Bands")
m1 = input(true, title="Show MA ", group="Bollinger Bands")
tf1 = input("", title = "Timeframe ", type = input.resolution, group="Bollinger Bands")
src1 = input(high, title = "Source ", type = input.source, group="Bollinger Bands")
per1 = input(10, title = "Period ", type = input.integer, minval = 2, group="Bollinger Bands")
dev1 = input(2.1, title = "Deviation ", type = input.float, minval = 1, group="Bollinger Bands")
//MA----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
length = input(66, title="MA Length", minval=1, group="Fast MA" )
matype = input(2, title="AvgType", minval=1, maxval=5, group="Fast MA")
//REVERSAL ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
ACT_REV = input(true, title = "REVERSAL", type = input.bool, group="REVERSAL")
leftBars = input(15)
rightBars = input(7)
rsi_ob = input(64, title="REV Rsi Overbought", group="REVERSAL")
rsi_os = input(34, title="REV RSI Oversold", group="REVERSAL")
//TP PLOTSHAPE -----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
tp_long0 = input(1.5, title="TP Long", type = input.float, minval = 0, step = 0.1, group="TP PLOTSHAPE")
tp_short0 = input(1.5, title="TP Short", type = input.float, minval = 0, step = 0.1, group="TP PLOTSHAPE")
// SL PLOTSHAPE ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Act_sl = input(true, title="Stop loss?", type = input.bool, group="SL PLOTSHAPE")
sl0 = input(7.2, title="% Stop loss", type = input.float, minval = 0, step = 0.1, group="SL PLOTSHAPE")
//INDICATORS =============================================================================================================================================================================================================================================================================================================
//ADX-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
calcADX(_len) =>
up = change(high)
down = -change(low)
plusDM = na(up) ? na : (up > down and up > 0 ? up : 0)
minusDM = na(down) ? na : (down > up and down > 0 ? down : 0)
truerange = rma(tr, _len)
_plus = fixnan(100 * rma(plusDM, _len) / truerange)
_minus = fixnan(100 * rma(minusDM, _len) / truerange)
sum = _plus + _minus
_adx = 100 * rma(abs(_plus - _minus) / (sum == 0 ? 1 : sum), _len)
[_plus,_minus,_adx]
calcADX_Masanakamura(_len) =>
SmoothedTrueRange = 0.0
SmoothedDirectionalMovementPlus = 0.0
SmoothedDirectionalMovementMinus = 0.0
TrueRange = max(max(high - low, abs(high - nz(close[1]))), abs(low - nz(close[1])))
DirectionalMovementPlus = high - nz(high[1]) > nz(low[1]) - low ? max(high - nz(high[1]), 0) : 0
DirectionalMovementMinus = nz(low[1]) - low > high - nz(high[1]) ? max(nz(low[1]) - low, 0) : 0
SmoothedTrueRange := nz(SmoothedTrueRange[1]) - (nz(SmoothedTrueRange[1]) /_len) + TrueRange
SmoothedDirectionalMovementPlus := nz(SmoothedDirectionalMovementPlus[1]) - (nz(SmoothedDirectionalMovementPlus[1]) / _len) + DirectionalMovementPlus
SmoothedDirectionalMovementMinus := nz(SmoothedDirectionalMovementMinus[1]) - (nz(SmoothedDirectionalMovementMinus[1]) / _len) + DirectionalMovementMinus
DIP = SmoothedDirectionalMovementPlus / SmoothedTrueRange * 100
DIM = SmoothedDirectionalMovementMinus / SmoothedTrueRange * 100
DX = abs(DIP-DIM) / (DIP+DIM)*100
adx = sma(DX, _len)
[DIP,DIM,adx]
[DIPlusC,DIMinusC,ADXC] = calcADX(ADX_len)
[DIPlusM,DIMinusM,ADXM] = calcADX_Masanakamura(ADX_len)
DIPlus = ADX_options == "CLASSIC" ? DIPlusC : DIPlusM
DIMinus = ADX_options == "CLASSIC" ? DIMinusC : DIMinusM
ADX = ADX_options == "CLASSIC" ? ADXC : ADXM
L_adx = DIPlus > DIMinus and ADX > th
S_adx = DIPlus < DIMinus and ADX > th
//Cloud --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
PI = 2 * asin(1)
hilbertTransform(src) =>
0.0962 * src + 0.5769 * nz(src[2]) - 0.5769 * nz(src[4]) - 0.0962 * nz(src[6])
computeComponent(src, mesaPeriodMult) =>
hilbertTransform(src) * mesaPeriodMult
computeAlpha(src, fastLimit, slowLimit) =>
mesaPeriod = 0.0
mesaPeriodMult = 0.075 * nz(mesaPeriod[1]) + 0.54
smooth = 0.0
smooth := (4 * src + 3 * nz(src[1]) + 2 * nz(src[2]) + nz(src[3])) / 10
detrender = 0.0
detrender := computeComponent(smooth, mesaPeriodMult)
I1 = nz(detrender[3])
Q1 = computeComponent(detrender, mesaPeriodMult)
jI = computeComponent(I1, mesaPeriodMult)
jQ = computeComponent(Q1, mesaPeriodMult)
I2 = 0.0
Q2 = 0.0
I2 := I1 - jQ
Q2 := Q1 + jI
I2 := 0.2 * I2 + 0.8 * nz(I2[1])
Q2 := 0.2 * Q2 + 0.8 * nz(Q2[1])
Re = I2 * nz(I2[1]) + Q2 * nz(Q2[1])
Im = I2 * nz(Q2[1]) - Q2 * nz(I2[1])
Re := 0.2 * Re + 0.8 * nz(Re[1])
Im := 0.2 * Im + 0.8 * nz(Im[1])
if Re != 0 and Im != 0
mesaPeriod := 2 * PI / atan(Im / Re)
if mesaPeriod > 1.5 * nz(mesaPeriod[1])
mesaPeriod := 1.5 * nz(mesaPeriod[1])
if mesaPeriod < 0.67 * nz(mesaPeriod[1])
mesaPeriod := 0.67 * nz(mesaPeriod[1])
if mesaPeriod < 6
mesaPeriod := 6
if mesaPeriod > 50
mesaPeriod := 50
mesaPeriod := 0.2 * mesaPeriod + 0.8 * nz(mesaPeriod[1])
phase = 0.0
if I1 != 0
phase := (180 / PI) * atan(Q1 / I1)
deltaPhase = nz(phase[1]) - phase
if deltaPhase < 1
deltaPhase := 1
alpha = fastLimit / deltaPhase
if alpha < slowLimit
alpha := slowLimit
[alpha,alpha/2.0]
er = abs(change(src,len)) / sum(abs(change(src)),len)
[a,b] = computeAlpha(src, er, er*0.1)
mama = 0.0
mama := a * src + (1 - a) * nz(mama[1])
fama = 0.0
fama := b * mama + (1 - b) * nz(fama[1])
alpha = pow((er * (b - a)) + a, 2)
kama = 0.0
kama := alpha * src + (1 - alpha) * nz(kama[1])
L_cloud = kama > kama[1]
S_cloud = kama < kama[1]
//SAR------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
psar = sar(start, increment, maximum)
dir = psar < close ? 1 : -1
L_sar = dir ==1
S_sar = dir ==-1
// Range Filter ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
var bool L_RF = na, var bool S_RF = na
Range_filter(_src, _per_, _mult)=>
var float _upward = 0.0
var float _downward = 0.0
wper = (_per_*2) - 1
avrng = ema(abs(_src - _src[1]), _per_)
_smoothrng = ema(avrng, wper)*_mult
_filt = _src
_filt := _src > nz(_filt[1]) ? ((_src-_smoothrng) < nz(_filt[1]) ? nz(_filt[1]) : (_src-_smoothrng)) : ((_src+_smoothrng) > nz(_filt[1]) ? nz(_filt[1]) : (_src+_smoothrng))
_upward := _filt > _filt[1] ? nz(_upward[1]) + 1 : _filt < _filt[1] ? 0 : nz(_upward[1])
_downward := _filt < _filt[1] ? nz(_downward[1]) + 1 : _filt > _filt[1] ? 0 : nz(_downward[1])
[_smoothrng,_filt,_upward,_downward]
[smoothrng, filt, upward, downward] = Range_filter(src, per_, mult)
hband = filt + smoothrng
lband = filt - smoothrng
L_RF := high > hband and upward > 0
S_RF := low < lband and downward > 0
//MACD-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
fast_ma = ema(src, fast_length)
slow_ma = ema(src, slow_length)
macd = fast_ma - slow_ma
signal_ = sma(macd, signal_length)
L_macd = macd > signal_
S_macd = macd < signal_
// RSI -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
WiMA(src, length) =>
var float MA_s=0.0
MA_s := (src + nz(MA_s[1] * (length-1)))/length
MA_s
RSI_Volume(fv, length) =>
up = iff(fv>fv[1],abs(fv-fv[1])*volume,0)
dn = iff(fv<fv[1],abs(fv-fv[1])*volume,0)
upt = WiMA(up,length)
dnt = WiMA(dn,length)
100*(upt/(upt+dnt))
RSI_V = RSI_Volume(src, RSI_len)
RSI_ = 52
L_rsi = (RSI_V > RSI_)
S_rsi = (RSI_V < RSI_)
// Volume -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Volume_condt = volume > sma(volume,sma_length)*volume_f
// BOLINGER BADNS -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
ma1 = security(syminfo.tickerid, tf1, sma(src1, per1))
hb1 = ma1 + security(syminfo.tickerid, tf1, stdev(src1, per1)) * dev1
lb1 = ma1 - security(syminfo.tickerid, tf1, stdev(src1, per1)) * dev1
L_BB = open > hb1
S_BB = open < lb1
//MA------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
simplema = sma(src,length)
exponentialma = ema(src,length)
hullma = wma(2*wma(src, length/2)-wma(src, length), round(sqrt(length)))
weightedma = wma(src, length)
volweightedma = vwma(src, length)
avgval = matype==1 ? simplema : matype==2 ? exponentialma : matype==3 ? hullma : matype==4 ? weightedma : matype==5 ? volweightedma : na
MA_speed = (avgval / avgval[1] -1 ) *100
L_s_ma = MA_speed > 0
S_s_ma = MA_speed < 0
//REVERSAL ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
swh = pivothigh(leftBars,rightBars)
swl = pivotlow(leftBars, rightBars)
pivots = not na(swh)? swh: not na(swl)? swl : na
swh_cond = not na(swh)
hprice = 0.0
hprice := swh_cond ? swh : hprice[1]
le = false
le := swh_cond ? true : (le[1] and high > hprice ? false : le[1]) and (rsi(close, 14)<rsi_ob)
swl_cond = not na(swl)
lprice = 0.0
lprice := swl_cond ? swl : lprice[1]
se = false
se := swl_cond ? true : (se[1] and low < lprice ? false : se[1]) and (rsi(close, 14)>rsi_os)
le_se = 0
le_se := ( crossover(high,hprice+syminfo.mintick) )? +1 : ( crossunder(low,lprice-syminfo.mintick) )? -1 : nz(le_se[1])
_le_se = le_se[1]==-1 and le_se==+1 and rsi(close, 14)<rsi_ob? 1 : le_se[1]==+1 and le_se==-1 and rsi(close, 14)>rsi_os? -1 :0
L_REV = _le_se==+1
S_REV = _le_se==-1
//CONDITIONS =======================================================================================================================================================================================================================================================================================================
L_rev_condt = L_REV and ACT_REV
S_rev_condt = S_REV and ACT_REV
//STRATEGY ==========================================================================================================================================================================================================================================================================================================
L_basic_condt = L_adx and L_cloud and L_sar and L_RF and L_macd and L_rsi and L_s_ma and Volume_condt
S_basic_condt = S_adx and S_cloud and S_sar and S_RF and S_macd and S_rsi and S_s_ma and Volume_condt
L_second_condt = L_basic_condt or L_BB and L_adx and L_sar and L_rsi
S_second_condt = S_basic_condt or S_BB and S_adx and S_sar and S_rsi
L_third_condt = L_second_condt or L_rev_condt and L_adx and L_sar and Volume_condt
S_third_condt = S_second_condt or S_rev_condt and S_adx and S_sar and Volume_condt
// PRICE POSITION ==========================================================================================================================================================================================================================================================================================================
var bool longCond = na, var bool shortCond = na
var int CondIni_long = 0, var int CondIni_short = 0
var bool _Final_longCondition = na, var bool _Final_shortCondition = na
var float last_open_longCondition = na, var float last_open_shortCondition = na
var int last_longCondition = na, var int last_shortCondition = na
var int last_Final_longCondition = na, var int last_Final_shortCondition = na
var int nLongs = na, var int nShorts = na
var float sum_long = 0.0, var float sum_short = 0.0
var float Position_Price = 0.0
var bool Final_long_BB = na, var bool Final_short_BB = na
var int last_long_BB = na, var int last_short_BB = na
longCond := L_third_condt
shortCond := S_third_condt
CondIni_long := longCond[1] ? 1 : shortCond[1] ? -1 : nz(CondIni_long[1] )
CondIni_short := longCond[1] ? 1 : shortCond[1] ? -1 : nz(CondIni_short[1] )
longCondition = (longCond[1] and nz(CondIni_long[1]) == -1 )
shortCondition = (shortCond[1] and nz(CondIni_short[1]) == 1 )
last_open_longCondition := longCondition or Final_long_BB[1] ? close[1] : nz(last_open_longCondition[1] )
last_open_shortCondition := shortCondition or Final_short_BB[1] ? close[1] : nz(last_open_shortCondition[1] )
last_longCondition := longCondition or Final_long_BB[1] ? time : nz(last_longCondition[1] )
last_shortCondition := shortCondition or Final_short_BB[1] ? time : nz(last_shortCondition[1] )
in_longCondition = last_longCondition > last_shortCondition
in_shortCondition = last_shortCondition > last_longCondition
last_Final_longCondition := longCondition ? time : nz(last_Final_longCondition[1] )
last_Final_shortCondition := shortCondition ? time : nz(last_Final_shortCondition[1] )
nLongs := nz(nLongs[1] )
nShorts := nz(nShorts[1] )
if longCondition or Final_long_BB
nLongs := nLongs + 1
nShorts := 0
sum_long := nz(last_open_longCondition) + nz(sum_long[1])
sum_short := 0.0
if shortCondition or Final_short_BB
nLongs := 0
nShorts := nShorts + 1
sum_short := nz(last_open_shortCondition)+ nz(sum_short[1])
sum_long := 0.0
Position_Price := nz(Position_Price[1])
Position_Price := longCondition or Final_long_BB ? sum_long/nLongs : shortCondition or Final_short_BB ? sum_short/nShorts : na
//TP---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
var bool long_tp = na, var bool short_tp = na
var int last_long_tp = na, var int last_short_tp = na
var bool Final_Long_tp = na, var bool Final_Short_tp = na
var bool Final_Long_sl0 = na, var bool Final_Short_sl0 = na
var bool Final_Long_sl = na, var bool Final_Short_sl = na
var int last_long_sl = na, var int last_short_sl = na
tp_long = ((nLongs > 1) ? tp_long0 / nLongs : tp_long0) / 100
tp_short = ((nShorts > 1) ? tp_short0 / nShorts : tp_short0) / 100
long_tp := high > (fixnan(Position_Price) * (1 + tp_long)) and in_longCondition
short_tp := low < (fixnan(Position_Price) * (1 - tp_short)) and in_shortCondition
last_long_tp := long_tp ? time : nz(last_long_tp[1])
last_short_tp := short_tp ? time : nz(last_short_tp[1])
Final_Long_tp := (long_tp and last_longCondition > nz(last_long_tp[1]) and last_longCondition > nz(last_long_sl[1]))
Final_Short_tp := (short_tp and last_shortCondition > nz(last_short_tp[1]) and last_shortCondition > nz(last_short_sl[1]))
//TP SIGNALS--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
tplLevel = (in_longCondition and
(last_longCondition > nz(last_long_tp[1])) and
(last_longCondition > nz(last_long_sl[1])) and not Final_Long_sl[1]) ?
(nLongs > 1) ?
(fixnan(Position_Price) * (1 + tp_long)) : (last_open_longCondition * (1 + tp_long)) : na
tpsLevel = (in_shortCondition and
(last_shortCondition > nz(last_short_tp[1])) and
(last_shortCondition > nz(last_short_sl[1])) and not Final_Short_sl[1]) ?
(nShorts > 1) ?
(fixnan(Position_Price) * (1 - tp_short)) : (last_open_shortCondition * (1 - tp_short)) : na
//SL ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Risk =7.2
Percent_Capital =99
sl = in_longCondition ? min(sl0,(((Risk) * 100) / (Percent_Capital * max(1, nLongs)))) :
in_shortCondition ? min(sl0,(((Risk) * 100) / (Percent_Capital * max(1, nShorts)))) : sl0
Normal_long_sl = ((Act_sl and in_longCondition and low <= ((1 - (sl / 100)) * (fixnan(Position_Price)))))
Normal_short_sl = ((Act_sl and in_shortCondition and high >= ((1 + (sl / 100)) * (fixnan(Position_Price)))))
last_long_sl := Normal_long_sl ? time : nz(last_long_sl[1])
last_short_sl := Normal_short_sl ? time : nz(last_short_sl[1])
Final_Long_sl := Normal_long_sl and last_longCondition > nz(last_long_sl[1]) and last_longCondition > nz(last_long_tp[1]) and not Final_Long_tp
Final_Short_sl := Normal_short_sl and last_shortCondition > nz(last_short_sl[1]) and last_shortCondition > nz(last_short_tp[1]) and not Final_Short_tp
//RE-ENTRY ON TP-HIT-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
if Final_Long_tp or Final_Long_sl
CondIni_long := -1
sum_long := 0.0
nLongs := na
if Final_Short_tp or Final_Short_sl
CondIni_short := 1
sum_short := 0.0
nShorts := na
// Colors ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
ADX_COLOR = L_adx ? color.lime : S_adx ? color.red : color.orange
SCALPS_COLOR = L_rev_condt ? color.lime : S_rev_condt ? color.maroon : na
BAR_COLOR = L_adx ? color.lime : S_adx ? color.red : L_rev_condt ? color.blue : S_rev_condt ? color.maroon : color.orange
barcolor (color = BAR_COLOR)
//Indicator plots ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
psarPlot = plot(psar, title="Psar Plot", style=plot.style_circles, color=ADX_COLOR, linewidth=1, transp=0 )
plot((bb1 and m1) ? ma1 : na, title = "MA1", color = ADX_COLOR, transp = 0, linewidth = 1)
hband1 = plot(bb1 ? hb1 : na, title = "HBand1", color = #006064, style = plot.style_line, linewidth = 2)
lband1 = plot(bb1 ? lb1 : na, title = "LBand1", color = color.maroon, style = plot.style_line, linewidth = 2)
fill(hband1, lband1, title = "BG1", color = ADX_COLOR, transp = 85)
mama_p = plot(mama, title="Cloud A", color=ADX_COLOR )
fama_p = plot(fama, title="Cloud B", color=ADX_COLOR )
fill (mama_p,fama_p, color=ADX_COLOR )
//Price plots ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
plot((nLongs > 1) or (nShorts > 1) ? Position_Price : na, title = "Price", color = in_longCondition ? color.aqua : color.orange, linewidth = 2, style = plot.style_cross)
plot(tplLevel, title="Long TP ", style = plot.style_cross, color=color.green, linewidth = 1 )
plot(tpsLevel, title="Short TP ", style = plot.style_cross, color=color.red, linewidth = 1 )
//PLOTSHAPES----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
plotshape(Final_Long_tp, title="TP Long Signal", style = shape.flag, location=location.abovebar, color=color.red, size=size.small , text="TP", textcolor=color.red, transp = 0 )
plotshape(Final_Short_tp, title="TP Short Signal", style = shape.flag, location=location.belowbar, color=color.green, size=size.small , text="TP", textcolor=color.green, transp = 0 )
plotshape(Final_Long_sl, title="SL Long", style=shape.xcross, location=location.belowbar, color=color.fuchsia, size=size.small , text ="SL", transp = 0 )
plotshape(Final_Short_sl, title="SL Short", style=shape.xcross, location=location.abovebar, color=color.fuchsia, size=size.small , text ="SL", transp = 0 )
plotshape(longCondition, title="Long", style=shape.triangleup, location=location.belowbar, color=color.blue, size=size.small , text="Long", textcolor=color.white, transp = 0 )
plotshape(shortCondition, title="Short", style=shape.triangledown, location=location.abovebar, color=color.red, size=size.small , text="Short", textcolor=color.white, transp = 0 )
//BACKTESTING inputs --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
long_ = input(true, title="Longs", group= "BACKTEST")
short_ = input(true, title="Shorts", group= "BACKTEST")
// Backtest tp & sl ================================================================================================================================================================================================================================================================================================================================
g(v, p) => round(v * (pow(10, p))) / pow(10, p)
tp_= input(0.015, title=" TP/100", step=0.001, group= "BACKTEST")
sl_= input(0.072, title=" SL/100", step=0.001, group= "BACKTEST")
// Backtest Long ==================================================================================================================================================================================================================================================================================================================================
if long_
strategy.entry("L" ,1, when = L_third_condt )
strategy.exit("S_tp/sl", "L", profit=close * tp_ / syminfo.mintick, loss=close * sl_ / syminfo.mintick)
// Backtest Short ==================================================================================================================================================================================================================================================================================================================================
if short_
strategy.entry("S" ,0, when = S_third_condt )
strategy.exit("S_tp/sl", "S", profit=close * tp_ / syminfo.mintick, loss=close * sl_ / syminfo.mintick)
Related
- VuManChu Cipher B + Divergences Strategy
- Trend-Following Variable Position Grid Strategy
- Dynamic Position Sizing Short-Term Forex Trading Strategy
- Gaussian Cross EMA Trend Retracement Strategy
- Enhanced Dual EMA Pullback Breakout Trading Strategy
- 15MIN BTCUSDTPERP BOT
- Volume-based Dynamic DCA Strategy
- Elliott Wave Theory 4-9 Impulse Wave Automatic Detection Trading Strategy
- Laguerre RSI with ADX Filtered Trading Signals Strategy
- RSI-MACD Multi-Signal Trading System with Dynamic Stop Management
More
- HODL LINE
- 2 Moving Average Color Direction Detection
- Scalping PullBack Tool R1
- Buy&Sell Strategy depends on AO+Stoch+RSI+ATR
- EMA TREND CLOUD
- RedK Volume-Accelerated Directional Energy Ratio
- Donchian Breakout no repaint
- RedK Momentum Bars
- SuperJump Turn Back Bollinger Band
- Fukuiz Trend
- SSL Hybrid
- Chandelier Exit
- RISOTTO
- EMA Cloud Intraday Strategy
- Pivot Point Supertrend
- Supertrend+4moving
- Momentum-based ZigZag
- VuManChu Cipher B + Divergences Strategy
- Concept Dual SuperTrend
- Super Scalper