Support/Resistance that ends once touched

Department

New member
Hello,
I was wondering if someone knew how to code a price level that starts and ends on a condition? I have certain bars I'd like to trigger a price level. This level would then stop at the point were price touched it again.
My current code is below with the level indicated but I don't know how to make the line appear and only extend to the next time that price is touched.
Code:
input history = 10;
input multiplier = 1.5;

def highLow = high - low;
def body = bodyHeight();
def greenCandle = open < close;
def redCandle = close < open;
def volatility = atr(history);
def significantBar = volatility * multiplier;
def imBody = (body > highLow* 0.5) and (highLow >= significantBar);

assignPriceColor(if imBody and greenCandle then Color.dark_green else Color.Current);
assignPriceColor(if imBody and redCandle then Color.dark_red else Color.Current);

#These would be the price levels drawn on the chart.
#They start at the previous candle's high/low and end once price returns to that price.
#Green Candles
plot supportLevel = if imBody and greenCandle then high[1] else double.NaN;
supportLevel.setPaintingStrategy(PaintingStrategy.VALUES_ABOVE);

#Red Candles
plot resistenceLevel = if imBody and redCandle then low[1] else double.NaN;
resistenceLevel.setPaintingStrategy(PaintingStrategy.VALUES_ABOVE);

This would ideally result in a graph as shown below:
cRJfU42.png
 
Solution
Updated the code for this indicator to make better use of the plots.
I made it way to complicated the first time around, I blame lack of sleep.

Also added a basic strategy to buy and sell on bar open after signal bar,
and added more plots. (My kingdom for an array.....😩..lol).

@Stock Tradin, I would appreciate some more feed back from you as I'm not a chart/data analyst by any means.
I'm a coder, that's what I know, so that's what I do....
and it doesn't look like we will be hearing from @Department any time soon.
Also working on a script to buy 1 and sell 1 after every opposite bar and set multiple stops (sell 1 or buy 1) at the corresponding price levels.
Code:
#Support and Reisitance Lines That End When Price Returns to...
Good afternoon, I'm trying to get a script that creates a green line at close when the buying volume is above average and a red line at close when the selling volume is above average. Also once the that line is broken through with above average volume from the other side, it should disappear. For example...if a green line is created because there was above average buying and then later on, an above average red goes through that green bar, then the green bar should disappear.
I went through the forum and found this code create by @Department but I'm not sure how to edit it to have the color lines be created based on the close and how to have it disappear once its broken through.

Can you help.

input history = 10;
input multiplier = 1.5;

def highLow = high - low;
def body = BodyHeight();
def greenCandle = open < close;
def redCandle = close < open;
def volatility = ATR(history);
def significantBar = volatility * multiplier;
def imBody = (body > highLow * 0.5) and (highLow >= significantBar);

AssignPriceColor(if imBody and greenCandle then Color.DARK_GREEN else Color.CURRENT);
AssignPriceColor(if imBody and redCandle then Color.DARK_RED else Color.CURRENT);

#These would be the price levels drawn on the chart.
#They start at the previous candle's high/low and end once price returns to that price.
#Green Candles
plot supportLevel = if imBody and greenCandle then high[1] else Double.NaN;
supportLevel.SetPaintingStrategy(PaintingStrategy.VALUES_ABOVE);

#######################################################################################
#Code edit by Svanoy
#Continuation of Support Level Line.
def SLine = If !IsNaN(supportLevel) then supportLevel else SLine[1];
#Check for touch.
def STouched = fold s = 0 to 1 with ssum = 0 do if low<=Sline then ssum + 1 else ssum;
#Define end of Support Line.
def SLineEnd = If Sline!=high[1] and STouched then Double.NaN else If SLine==high[1] and !IsNaN(SupportLevel) then SLine else SlineEnd[1];
#Plot Support Line.
plot SLineP = SLineEnd;
SLineP.SetPaintingStrategy(PaintingStrategy.HORIZONTAL );
SLineP.SetDefaultColor(Color.GREEN);
SLineP.SetLineWeight(1);
#----------------------------------------------------------------------------------
#Continuation of Support Level Line 1.
def SLine2 = If SLine!=SLine[1] then SLine[1] else SLine2[1];
#Check for touch.
def STouched2 = fold s2 = 0 to 1 with ssum2 = 0 do if low<=Sline2 then ssum2 + 1 else ssum2;
#Define end of Support Line.
def SLineEnd2 = If STouched2 then Double.NaN else If SLine!=SLine[1] and !IsNaN(SLineP[1]) then SLineP[1] else SlineEnd2[1];
#Plot Support Line.
plot SLineP2 = SLineEnd2;
SLineP2.SetPaintingStrategy(PaintingStrategy.HORIZONTAL );
SLineP2.SetDefaultColor(Color.GREEN);
SLineP2.SetLineWeight(1);
#----------------------------------------------------------------------------------
#Continuation of Support Level Line 2.
#Copy and Paste this section to add more Support lines.
def SLine3 = If SLine2!=SLine2[1] then SLine2[1] else SLine3[1];
#Check for touch.
def STouched3 = fold s3 = 0 to 1 with ssum3 = 0 do if low<=Sline3 then ssum3 + 1 else ssum3;
#Define end of Support Line.
def SLineEnd3 = If STouched3 then Double.NaN else If SLine2!=SLine2[1] and !IsNaN(SLineP2[1]) then SLineP2[1] else SlineEnd3[1];
#Plot Support Line.
plot SLineP3 = SLineEnd3;
SLineP3.SetPaintingStrategy(PaintingStrategy.HORIZONTAL );
SLineP3.SetDefaultColor(Color.GREEN);
SLineP3.SetLineWeight(1);
#######################################################################################


#Red Candles
plot resistenceLevel = if imBody and redCandle then low[1] else Double.NaN;
resistenceLevel.SetPaintingStrategy(PaintingStrategy.VALUES_ABOVE);

#######################################################################################
#Code edit by Svanoy
#Continuation of Resistence Level Line.
def RLine = If !IsNaN(resistenceLevel) then resistenceLevel else RLine[1];
#Check for touch.
def RTouched = fold r = 0 to 1 with rsum = 0 do if high>=Rline then rsum + 1 else rsum;
#Define end of Resistence Line.
def RLineEnd = If Rline!=low[1] and RTouched then Double.NaN else If RLine==low[1] and !IsNaN(ResistenceLevel) then RLine else RlineEnd[1];
#Plot Resistence Line.
plot RLineP = RLineEnd;
RLineP.SetPaintingStrategy(PaintingStrategy.HORIZONTAL );
RLineP.SetDefaultColor(Color.RED);
RLineP.SetLineWeight(1);
#----------------------------------------------------------------------------------
#Continuation of Resistence Level Line 1.
def RLine2 = If RLine!=RLine[1] then RLine[1] else RLine2[1];
#Check for touch.
def RTouched2 = fold r2 = 0 to 1 with rsum2 = 0 do if high>=Rline2 then rsum2 + 1 else rsum2;
#Define end of Resistence Line.
def RLineEnd2 = If RTouched2 then Double.NaN else If RLine!=RLine[1] and !IsNaN(RLineP[1]) then RLineP[1] else RlineEnd2[1];
#Plot Resistence Line.
plot RLineP2 = RLineEnd2;
RLineP2.SetPaintingStrategy(PaintingStrategy.HORIZONTAL );
RLineP2.SetDefaultColor(Color.RED);
RLineP2.SetLineWeight(1);
#----------------------------------------------------------------------------------
#Continuation of Resistence Level Line 2.
#Copy and Paste this section to add more Resistence lines.
def RLine3 = If RLine2!=RLine2[1] then RLine2[1] else RLine3[1];
#Check for touch.
def RTouched3 = fold r3 = 0 to 1 with rsum3 = 0 do if high>=Rline3 then rsum3 + 1 else rsum3;
#Define end of Resistence Line.
def RLineEnd3 = If RTouched3 then Double.NaN else If RLine2!=RLine2[1] and !IsNaN(RLineP2[1]) then RLineP2[1] else RlineEnd3[1];
#Plot Resistence Line.
plot RLineP3 = RLineEnd3;
RLineP3.SetPaintingStrategy(PaintingStrategy.HORIZONTAL );
RLineP3.SetDefaultColor(Color.RED);
RLineP3.SetLineWeight(1);
#######################################################################################
 
Good afternoon, I'm trying to get a script that creates a green line at close when the buying volume is above average and a red line at close when the selling volume is above average. Also once the that line is broken through with above average volume from the other side, it should disappear. For example...if a green line is created because there was above average buying and then later on, an above average red goes through that green bar, then the green bar should disappear.
I went through the forum and found this code create by @Department but I'm not sure how to edit it to have the color lines be created based on the close and how to have it disappear once its broken through.

Can you help.

input history = 10;
input multiplier = 1.5;

def highLow = high - low;
def body = BodyHeight();
def greenCandle = open < close;
def redCandle = close < open;
def volatility = ATR(history);
def significantBar = volatility * multiplier;
def imBody = (body > highLow * 0.5) and (highLow >= significantBar);

AssignPriceColor(if imBody and greenCandle then Color.DARK_GREEN else Color.CURRENT);
AssignPriceColor(if imBody and redCandle then Color.DARK_RED else Color.CURRENT);

#These would be the price levels drawn on the chart.
#They start at the previous candle's high/low and end once price returns to that price.
#Green Candles
plot supportLevel = if imBody and greenCandle then high[1] else Double.NaN;
supportLevel.SetPaintingStrategy(PaintingStrategy.VALUES_ABOVE);

#######################################################################################
#Code edit by Svanoy
#Continuation of Support Level Line.
def SLine = If !IsNaN(supportLevel) then supportLevel else SLine[1];
#Check for touch.
def STouched = fold s = 0 to 1 with ssum = 0 do if low<=Sline then ssum + 1 else ssum;
#Define end of Support Line.
def SLineEnd = If Sline!=high[1] and STouched then Double.NaN else If SLine==high[1] and !IsNaN(SupportLevel) then SLine else SlineEnd[1];
#Plot Support Line.
plot SLineP = SLineEnd;
SLineP.SetPaintingStrategy(PaintingStrategy.HORIZONTAL );
SLineP.SetDefaultColor(Color.GREEN);
SLineP.SetLineWeight(1);
#----------------------------------------------------------------------------------
#Continuation of Support Level Line 1.
def SLine2 = If SLine!=SLine[1] then SLine[1] else SLine2[1];
#Check for touch.
def STouched2 = fold s2 = 0 to 1 with ssum2 = 0 do if low<=Sline2 then ssum2 + 1 else ssum2;
#Define end of Support Line.
def SLineEnd2 = If STouched2 then Double.NaN else If SLine!=SLine[1] and !IsNaN(SLineP[1]) then SLineP[1] else SlineEnd2[1];
#Plot Support Line.
plot SLineP2 = SLineEnd2;
SLineP2.SetPaintingStrategy(PaintingStrategy.HORIZONTAL );
SLineP2.SetDefaultColor(Color.GREEN);
SLineP2.SetLineWeight(1);
#----------------------------------------------------------------------------------
#Continuation of Support Level Line 2.
#Copy and Paste this section to add more Support lines.
def SLine3 = If SLine2!=SLine2[1] then SLine2[1] else SLine3[1];
#Check for touch.
def STouched3 = fold s3 = 0 to 1 with ssum3 = 0 do if low<=Sline3 then ssum3 + 1 else ssum3;
#Define end of Support Line.
def SLineEnd3 = If STouched3 then Double.NaN else If SLine2!=SLine2[1] and !IsNaN(SLineP2[1]) then SLineP2[1] else SlineEnd3[1];
#Plot Support Line.
plot SLineP3 = SLineEnd3;
SLineP3.SetPaintingStrategy(PaintingStrategy.HORIZONTAL );
SLineP3.SetDefaultColor(Color.GREEN);
SLineP3.SetLineWeight(1);
#######################################################################################


#Red Candles
plot resistenceLevel = if imBody and redCandle then low[1] else Double.NaN;
resistenceLevel.SetPaintingStrategy(PaintingStrategy.VALUES_ABOVE);

#######################################################################################
#Code edit by Svanoy
#Continuation of Resistence Level Line.
def RLine = If !IsNaN(resistenceLevel) then resistenceLevel else RLine[1];
#Check for touch.
def RTouched = fold r = 0 to 1 with rsum = 0 do if high>=Rline then rsum + 1 else rsum;
#Define end of Resistence Line.
def RLineEnd = If Rline!=low[1] and RTouched then Double.NaN else If RLine==low[1] and !IsNaN(ResistenceLevel) then RLine else RlineEnd[1];
#Plot Resistence Line.
plot RLineP = RLineEnd;
RLineP.SetPaintingStrategy(PaintingStrategy.HORIZONTAL );
RLineP.SetDefaultColor(Color.RED);
RLineP.SetLineWeight(1);
#----------------------------------------------------------------------------------
#Continuation of Resistence Level Line 1.
def RLine2 = If RLine!=RLine[1] then RLine[1] else RLine2[1];
#Check for touch.
def RTouched2 = fold r2 = 0 to 1 with rsum2 = 0 do if high>=Rline2 then rsum2 + 1 else rsum2;
#Define end of Resistence Line.
def RLineEnd2 = If RTouched2 then Double.NaN else If RLine!=RLine[1] and !IsNaN(RLineP[1]) then RLineP[1] else RlineEnd2[1];
#Plot Resistence Line.
plot RLineP2 = RLineEnd2;
RLineP2.SetPaintingStrategy(PaintingStrategy.HORIZONTAL );
RLineP2.SetDefaultColor(Color.RED);
RLineP2.SetLineWeight(1);
#----------------------------------------------------------------------------------
#Continuation of Resistence Level Line 2.
#Copy and Paste this section to add more Resistence lines.
def RLine3 = If RLine2!=RLine2[1] then RLine2[1] else RLine3[1];
#Check for touch.
def RTouched3 = fold r3 = 0 to 1 with rsum3 = 0 do if high>=Rline3 then rsum3 + 1 else rsum3;
#Define end of Resistence Line.
def RLineEnd3 = If RTouched3 then Double.NaN else If RLine2!=RLine2[1] and !IsNaN(RLineP2[1]) then RLineP2[1] else RlineEnd3[1];
#Plot Resistence Line.
plot RLineP3 = RLineEnd3;
RLineP3.SetPaintingStrategy(PaintingStrategy.HORIZONTAL );
RLineP3.SetDefaultColor(Color.RED);
RLineP3.SetLineWeight(1);
#######################################################################################
I also found this script written by @ruby which creates gray lines based on the volume being above 1.5. But there are few issues I can't figure out how to correct.
1) How to stop it from showing lines from the past days.
2) how to have the lines disappear once an Above average bar goes through it
3) How to have the lines be based on the close of the bar
4) how to change the color of the lines to be a green line for a bar that has above average buying and red for a bar that has above average selling


# bigvol_sr_horzlines_00

declare upper;

def na = Double.NaN;
def bn = BarNumber();

def v = volume;
input volavg_len = 20;
def vavg = Average(v, volavg_len);

input volavg_factor = 1.5;
def volf = floor(vavg * volavg_factor);
def vxup = if v crosses above volf then 1 else 0;


#----------------------
# if lmax Is increased > 15, then more formulas will have to be added, L# and plot commands.
def lmax = 15;

input qty_of_lines = 15;
def lqty = if qty_of_lines < 1 then 1
else if qty_of_lines > lmax then lmax
else qty_of_lines;

#----------------------
# incr line counter on each vol trigger
# counts 1 to qty_of_lines, then resets to 1
def linecnt = if bn == 1 then 0
else if vxup and linecnt[1] == qty_of_lines then 1
else if vxup then linecnt[1] + 1
else linecnt[1];


input show_wedge_on_vol_trigger = no;
plot w = if show_wedge_on_vol_trigger and vxup then 1 else 0;
w.SetPaintingStrategy(PaintingStrategy.BOOLEAN_WEDGE_up);
w.SetDefaultColor(Color.WHITE);
#w.SetLineWeight(2);

#--------------------------------------

addlabel(1, "volavg_len " + volavg_len, color.yellow);
addlabel(1, "volavg_factor " + volavg_factor, color.yellow);


input show_line_count = no;
plot y1 = if vxup and show_line_count then linecnt else na;
y1.SetPaintingStrategy(PaintingStrategy.VALUES_below);
y1.SetDefaultColor(Color.white);
#y1.setlineweight(1);
y1.hidebubble();


input test1_labels = no;
addlabel( test1_labels, "vol cross up " + vxup, color.yellow);
addlabel( test1_labels, "qty_of_lines " + qty_of_lines, color.yellow);
addlabel( test1_labels, "linecnt " + linecnt, color.yellow);


input test2_linecnt_bubbles = no;
addchartbubble(test2_linecnt_bubbles, low*0.997,
bn + " bn\n" +
vxup + " x\n" +
linecnt + " cnt"
, ( if vxup then color.yellow else color.gray), no);


#----------------------

def linelevel = close;
#def init = na;
def init = 0;

def L1 = if bn == 1 then init else if (vxup and linecnt == 1) then linelevel else L1[1];
def L2 = if bn == 1 then init else if (vxup and linecnt == 2) then linelevel else L2[1];
def L3 = if bn == 1 then init else if (vxup and linecnt == 3) then linelevel else L3[1];
def L4 = if bn == 1 then init else if (vxup and linecnt == 4) then linelevel else L4[1];
def L5 = if bn == 1 then init else if (vxup and linecnt == 5) then linelevel else L5[1];
def L6 = if bn == 1 then init else if (vxup and linecnt == 6) then linelevel else L6[1];
def L7 = if bn == 1 then init else if (vxup and linecnt == 7) then linelevel else L7[1];
def L8 = if bn == 1 then init else if (vxup and linecnt == 8) then linelevel else L8[1];
def L9 = if bn == 1 then init else if (vxup and linecnt == 9) then linelevel else L9[1];
def L10 = if bn == 1 then init else if (vxup and linecnt == 10) then linelevel else L10[1];

def L11 = if bn == 1 then init else if (vxup and linecnt == 11) then linelevel else L11[1];
def L12 = if bn == 1 then init else if (vxup and linecnt == 12) then linelevel else L12[1];
def L13 = if bn == 1 then init else if (vxup and linecnt == 13) then linelevel else L13[1];
def L14 = if bn == 1 then init else if (vxup and linecnt == 14) then linelevel else L14[1];
def L15 = if bn == 1 then init else if (vxup and linecnt == 15) then linelevel else L15[1];


#----------------------
plot z1 = L1;
z1.SetDefaultColor(Color.GRAY);
z1.SetPaintingStrategy(PaintingStrategy.HORIZONTAL);
plot z2 = L2;
z2.SetDefaultColor(Color.GRAY);
z2.SetPaintingStrategy(PaintingStrategy.HORIZONTAL);
plot z3 = L3;
z3.SetDefaultColor(Color.GRAY);
z3.SetPaintingStrategy(PaintingStrategy.HORIZONTAL);
plot z4 = L4;
z4.SetDefaultColor(Color.GRAY);
z4.SetPaintingStrategy(PaintingStrategy.HORIZONTAL);
plot z5 = L5;
z5.SetDefaultColor(Color.GRAY);
z5.SetPaintingStrategy(PaintingStrategy.HORIZONTAL);
plot z6 = L6;
z6.SetDefaultColor(Color.GRAY);
z6.SetPaintingStrategy(PaintingStrategy.HORIZONTAL);
plot z7 = L7;
z7.SetDefaultColor(Color.GRAY);
z7.SetPaintingStrategy(PaintingStrategy.HORIZONTAL);
plot z8 = L8;
z8.SetDefaultColor(Color.GRAY);
z8.SetPaintingStrategy(PaintingStrategy.HORIZONTAL);
plot z9 = L9;
z9.SetDefaultColor(Color.GRAY);
z9.SetPaintingStrategy(PaintingStrategy.HORIZONTAL);
plot z10 = L10;
z10.SetDefaultColor(Color.GRAY);
z10.SetPaintingStrategy(PaintingStrategy.HORIZONTAL);

plot z11 = L11;
z11.SetDefaultColor(Color.GRAY);
z11.SetPaintingStrategy(PaintingStrategy.HORIZONTAL);
plot z12 = L12;
z12.SetDefaultColor(Color.GRAY);
z12.SetPaintingStrategy(PaintingStrategy.HORIZONTAL);
plot z13 = L13;
z13.SetDefaultColor(Color.GRAY);
z13.SetPaintingStrategy(PaintingStrategy.HORIZONTAL);
plot z14 = L14;
z14.SetDefaultColor(Color.GRAY);
z14.SetPaintingStrategy(PaintingStrategy.HORIZONTAL);
plot z15 = L15;
z15.SetDefaultColor(Color.GRAY);
z15.SetPaintingStrategy(PaintingStrategy.HORIZONTAL);

#----------------------

input test3_line_values = no;
addchartbubble(test3_line_values, low*0.997,
l1 + " 1\n" +
l2 + " 2\n" +
l3 + " 3\n" +
l4 + " 4\n" +
l5 + " 5\n" +
l6 + " 6\n" +
l7 + " 7\n" +
l8 + " 8\n" +
l9 + " 9\n" +
l10 + " 10"
, ( if vxup then color.yellow else color.gray), no);
#
#
 
Fixed another plotting bug and removed strategy for now to reduce load time.

Ruby:
#Support and Reisitance Lines That End When Price Returns to Line.
#Original idea by Department
#Coded by Svanoy
#https://usethinkscript.com/threads/support-resistance-that-ends-once-touched.9491/#post-89067

######################################################################################
#Definition of Signal.################################################################
######################################################################################

input history = 10;
input multiplier = 1.5;
input bsmulti =1.2;
def highLow = high-low;
def buyopenlow = open-low;
def sellhighopen = high-open;
def greenCandle = open < close;
def redCandle = close < open;
def body = BodyHeight();
def volatility = ATR(history, AverageType.WILDERS);
def significantBar = volatility * multiplier;
def imBody = (body > highLow * 0.5) and (highLow >= significantBar);
def buybody = (body > buyopenLow * 0.5) and (buyopenLow >= volatility * bsmulti);
def sellbody = (body > sellhighopen * 0.5) and (sellhighopen >= volatility * bsmulti);
AssignPriceColor(if imBody and greenCandle then Color.LIME else Color.CURRENT);
AssignPriceColor(if imBody and redCandle then Color.DARK_RED else Color.CURRENT);

plot Bottom = buyBody and greenCandle;
Bottom.SetPaintingStrategy(PaintingStrategy.BOOLEAN_WEDGE_DOWN);
Bottom.SetLineWeight(5);
Bottom.AssignValueColor(Color.CYAN );

plot Top = sellBody and redCandle;
Top.SetPaintingStrategy(PaintingStrategy.BOOLEAN_WEDGE_UP);
Top.SetLineWeight(5);
Top.AssignValueColor(Color.LIGHT_ORANGE);

#######################################################################################
#Define Level Plot Triggers..##########################################################
#######################################################################################
def RedBar = imBody and redCandle ;#and low[1]>close;
def GreenBar = imBody and greenCandle ;#and high[1]<close;

######################################################################################
#Defintions of Support Levels.########################################################
######################################################################################
plot SupportLevel = if GreenBar then high[1] else Double.NaN;
SupportLevel.SetPaintingStrategy(PaintingStrategy.VALUES_ABOVE);

def SLine0;
def SLine1;
def SLine2;
def SLine3;
def SLine4;
def SLine5;
def SLine6;
def SLine7;
def SLine8;
def SLine9;
def SLine10;
def SLine11;
def SLine12;
def SLine13;
def SLine14;
def SLine15;
def SLine16;
def SLine17;
def SLine18;
def SLine19;
def SLine20;

def SLineCount;
If BarNumber() == 1 { SLineCount = 1;
}else if (IsNaN(SupportLevel) and !IsNaN(SLine1[1]) and low<=SLine1[1]) { SLineCount=0;
}else if (IsNaN(SupportLevel) and !IsNaN(SLine2[1]) and low<=SLine2[1]) { SLineCount=1;
}else if (IsNaN(SupportLevel) and !IsNaN(SLine3[1]) and low<=SLine3[1]) { SLineCount=2;
}else if (IsNaN(SupportLevel) and !IsNaN(SLine4[1]) and low<=SLine4[1]) { SLineCount=3;
}else if (IsNaN(SupportLevel) and !IsNaN(SLine5[1]) and low<=SLine5[1]) { SLineCount=4;
}else if (IsNaN(SupportLevel) and !IsNaN(SLine6[1]) and low<=SLine6[1]) { SLineCount=5;
}else if (IsNaN(SupportLevel) and !IsNaN(SLine7[1]) and low<=SLine7[1]) { SLineCount=6;
}else if (IsNaN(SupportLevel) and !IsNaN(SLine8[1]) and low<=SLine8[1]) { SLineCount=7;
}else if (IsNaN(SupportLevel) and !IsNaN(SLine9[1]) and low<=SLine9[1]) { SLineCount=8;
}else if (IsNaN(SupportLevel) and !IsNaN(SLine10[1]) and low<=SLine10[1]) { SLineCount=9;
}else if (IsNaN(SupportLevel) and !IsNaN(SLine11[1]) and low<=SLine11[1]) { SLineCount=10;
}else if (IsNaN(SupportLevel) and !IsNaN(SLine12[1]) and low<=SLine12[1]) { SLineCount=11;
}else if (IsNaN(SupportLevel) and !IsNaN(SLine13[1]) and low<=SLine13[1]) { SLineCount=12;
}else if (IsNaN(SupportLevel) and !IsNaN(SLine14[1]) and low<=SLine14[1]) { SLineCount=13;
}else if (IsNaN(SupportLevel) and !IsNaN(SLine15[1]) and low<=SLine15[1]) { SLineCount=14;
}else if (IsNaN(SupportLevel) and !IsNaN(SLine16[1]) and low<=SLine16[1]) { SLineCount=15;
}else if (IsNaN(SupportLevel) and !IsNaN(SLine17[1]) and low<=SLine17[1]) { SLineCount=16;
}else if (IsNaN(SupportLevel) and !IsNaN(SLine18[1]) and low<=SLine18[1]) { SLineCount=17;
}else if (IsNaN(SupportLevel) and !IsNaN(SLine19[1]) and low<=SLine19[1]) { SLineCount=18;
}else if (IsNaN(SupportLevel) and !IsNaN(SLine20[1]) and low<=SLine20[1]) { SLineCount=19;
}else if (IsNaN(SupportLevel) and !IsNaN(SLine0[1]) and low<=SLine0[1]) { SLineCount=20;

}else if (!IsNaN(SupportLevel) and !IsNaN(SLine0[1]) and low<=SLine0[1]) { SLineCount=0;
}else if (!IsNaN(SupportLevel) and !IsNaN(SLine1[1]) and low<=SLine1[1]) { SLineCount=1;
}else if (!IsNaN(SupportLevel) and !IsNaN(SLine2[1]) and low<=SLine2[1]) { SLineCount=2;
}else if (!IsNaN(SupportLevel) and !IsNaN(SLine3[1]) and low<=SLine3[1]) { SLineCount=3;
}else if (!IsNaN(SupportLevel) and !IsNaN(SLine4[1]) and low<=SLine4[1]) { SLineCount=4;
}else if (!IsNaN(SupportLevel) and !IsNaN(SLine5[1]) and low<=SLine5[1]) { SLineCount=5;
}else if (!IsNaN(SupportLevel) and !IsNaN(SLine6[1]) and low<=SLine6[1]) { SLineCount=6;
}else if (!IsNaN(SupportLevel) and !IsNaN(SLine7[1]) and low<=SLine7[1]) { SLineCount=7;
}else if (!IsNaN(SupportLevel) and !IsNaN(SLine8[1]) and low<=SLine8[1]) { SLineCount=8;
}else if (!IsNaN(SupportLevel) and !IsNaN(SLine9[1]) and low<=SLine9[1]) { SLineCount=9;
}else if (!IsNaN(SupportLevel) and !IsNaN(SLine10[1]) and low<=SLine10[1]) { SLineCount=10;
}else if (!IsNaN(SupportLevel) and !IsNaN(SLine11[1]) and low<=SLine11[1]) { SLineCount=11;
}else if (!IsNaN(SupportLevel) and !IsNaN(SLine12[1]) and low<=SLine12[1]) { SLineCount=12;
}else if (!IsNaN(SupportLevel) and !IsNaN(SLine13[1]) and low<=SLine13[1]) { SLineCount=13;
}else if (!IsNaN(SupportLevel) and !IsNaN(SLine14[1]) and low<=SLine14[1]) { SLineCount=14;
}else if (!IsNaN(SupportLevel) and !IsNaN(SLine15[1]) and low<=SLine15[1]) { SLineCount=15;
}else if (!IsNaN(SupportLevel) and !IsNaN(SLine16[1]) and low<=SLine16[1]) { SLineCount=16;
}else if (!IsNaN(SupportLevel) and !IsNaN(SLine17[1]) and low<=SLine17[1]) { SLineCount=17;
}else if (!IsNaN(SupportLevel) and !IsNaN(SLine18[1]) and low<=SLine18[1]) { SLineCount=18;
}else if (!IsNaN(SupportLevel) and !IsNaN(SLine19[1]) and low<=SLine19[1]) { SLineCount=19;
}else if (!IsNaN(SupportLevel) and !IsNaN(SLine20[1]) and low<=SLine20[1]) { SLineCount=20;
}else if (!IsNaN(SupportLevel)) and SLineCount[1]!=20 { SLineCount = SLineCount[1] + 1;
}else if (IsNaN(SupportLevel)) and SLineCount[1]==20 { SLineCount = 0;
} else {
    SLineCount = SLineCount[1];
}

#green candles
######################################################################################
#Plots of Support Levels.#############################################################
######################################################################################
SLine0 = if !IsNaN(SupportLevel) and SLineCount == 0 then SupportLevel else if !IsNaN(SLine0[1]) and low <= SLine0[1] then 0 else SLine0[1];
plot SLineP0 = if SLine0 > 0 then SLine0 else Double.NaN;
SLineP0.SetStyle(Curve.POINTS);
SLineP0.SetDefaultColor(Color.LIGHT_GREEN);
SLineP0.SetLineWeight(1);
SLineP0.HideBubble();
#----------------------------------------------------------------------------------
SLine1 = if !IsNaN(SupportLevel) and SLineCount == 1 then SupportLevel else if !IsNaN(SLine1[1]) and low <= SLine1[1] then 0 else SLine1[1];
plot SLineP1 = if SLine1 > 0 then SLine1 else Double.NaN;
SLineP1.SetStyle(Curve.POINTS);
SLineP1.SetDefaultColor(Color.LIGHT_GREEN);
SLineP1.SetLineWeight(1);
SLineP1.HideBubble();
#----------------------------------------------------------------------------------
SLine2 = if !IsNaN(SupportLevel) and SLineCount == 2 then SupportLevel else if !IsNaN(SLine2[1]) and low <= SLine2[1] then 0 else SLine2[1];
plot SLineP2 = if SLine2 > 0 then SLine2 else Double.NaN;
SLineP2.SetStyle(Curve.POINTS);
SLineP2.SetDefaultColor(Color.LIGHT_GREEN);
SLineP2.SetLineWeight(1);
SLineP2.HideBubble();
#----------------------------------------------------------------------------------
SLine3 = if !IsNaN(SupportLevel) and SLineCount == 3 then SupportLevel else if !IsNaN(SLine3[1]) and low <= SLine3[1] then 0 else SLine3[1];
plot SLineP3 = if SLine3 > 0 then SLine3 else Double.NaN;
SLineP3.SetStyle(Curve.POINTS);
SLineP3.SetDefaultColor(Color.LIGHT_GREEN);
SLineP3.SetLineWeight(1);
SLineP3.HideBubble();
#----------------------------------------------------------------------------------
SLine4 = if !IsNaN(SupportLevel) and SLineCount == 4 then SupportLevel else if !IsNaN(SLine4[1]) and low <= SLine4[1] then 0 else SLine4[1];
plot SLineP4 = if SLine4 > 0 then SLine4 else Double.NaN;
SLineP4.SetStyle(Curve.POINTS);
SLineP4.SetDefaultColor(Color.LIGHT_GREEN);
SLineP4.SetLineWeight(1);
SLineP4.HideBubble();
def SLine4Length = if SLine4 != SLine4[1] then 1 else if !IsNaN(SLine4[1]) and IsNaN(SLine4) then 0 else if !IsNaN(SLine4) then SLine4Length[1] + 1 else 0;
#----------------------------------------------------------------------------------
SLine5 = if !IsNaN(SupportLevel) and SLineCount == 5 then SupportLevel else if !IsNaN(SLine5[1]) and low <= SLine5[1] then 0 else SLine5[1];
plot SLineP5 = if SLine5 > 0 then SLine5 else Double.NaN;
SLineP5.SetStyle(Curve.POINTS);
SLineP5.SetDefaultColor(Color.LIGHT_GREEN);
SLineP5.SetLineWeight(1);
SLineP5.HideBubble();
#----------------------------------------------------------------------------------
SLine6 = if !IsNaN(SupportLevel) and SLineCount == 6 then SupportLevel else if !IsNaN(SLine6[1]) and low <= SLine6[1] then 0 else SLine6[1];
plot SLineP6 = if SLine6 > 0 then SLine6 else Double.NaN;
SLineP6.SetStyle(Curve.POINTS);
SLineP6.SetDefaultColor(Color.LIGHT_GREEN);
SLineP6.SetLineWeight(1);
SLineP6.HideBubble();
#----------------------------------------------------------------------------------
SLine7 = if !IsNaN(SupportLevel) and SLineCount == 7 then SupportLevel else if !IsNaN(SLine7[1]) and low <= SLine7[1] then 0 else SLine7[1];
plot SLineP7 = if SLine7 > 0 then SLine7 else Double.NaN;
SLineP7.SetStyle(Curve.POINTS);
SLineP7.SetDefaultColor(Color.LIGHT_GREEN);
SLineP7.SetLineWeight(1);
SLineP7.HideBubble();
#----------------------------------------------------------------------------------
SLine8 = if !IsNaN(SupportLevel) and SLineCount == 8 then SupportLevel else if !IsNaN(SLine8[1]) and low <= SLine8[1] then 0 else SLine8[1];
plot SLineP8 = if SLine8 > 0 then SLine8 else Double.NaN;
SLineP8.SetStyle(Curve.POINTS);
SLineP8.SetDefaultColor(Color.LIGHT_GREEN);
SLineP8.SetLineWeight(1);
SLineP8.SetLineWeight(1);
SLineP8.HideBubble();
#----------------------------------------------------------------------------------
SLine9 = if !IsNaN(SupportLevel) and SLineCount == 9 then SupportLevel else if !IsNaN(SLine9[1]) and low <= SLine9[1] then 0 else SLine9[1];
plot SLineP9 = if SLine9 > 0 then SLine9 else Double.NaN;
SLineP9.SetStyle(Curve.POINTS);
SLineP9.SetDefaultColor(Color.LIGHT_GREEN);
SLineP9.SetLineWeight(1);
SLineP9.HideBubble();
#----------------------------------------------------------------------------------
SLine10 = if !IsNaN(SupportLevel) and SLineCount == 10 then SupportLevel else if !IsNaN(SLine10[1]) and low <= SLine10[1] then 0 else SLine10[1];
plot SLineP10 = if SLine10 > 0 then SLine10 else Double.NaN;
SLineP10.SetStyle(Curve.POINTS);
SLineP10.SetDefaultColor(Color.LIGHT_GREEN);
SLineP10.SetLineWeight(1);
SLineP10.HideBubble();
#----------------------------------------------------------------------------------
SLine11 = if !IsNaN(SupportLevel) and SLineCount == 11 then SupportLevel else if !IsNaN(SLine11[1]) and low <= SLine11[1] then 0 else SLine11[1];
plot SLineP11 = if SLine11 > 0 then SLine11 else Double.NaN;
SLineP11.SetStyle(Curve.POINTS);
SLineP11.SetDefaultColor(Color.LIGHT_GREEN);
SLineP11.SetLineWeight(1);
SLineP11.HideBubble();
#----------------------------------------------------------------------------------
SLine12 = if !IsNaN(SupportLevel) and SLineCount == 12 then SupportLevel else if !IsNaN(SLine12[1]) and low <= SLine12[1] then 0 else SLine12[1];
plot SLineP12 = if SLine12 > 0 then SLine12 else Double.NaN;
SLineP12.SetStyle(Curve.POINTS);
SLineP12.SetDefaultColor(Color.LIGHT_GREEN);
SLineP12.SetLineWeight(1);
SLineP12.HideBubble();
#----------------------------------------------------------------------------------
SLine13 = if !IsNaN(SupportLevel) and SLineCount == 13 then SupportLevel else if !IsNaN(SLine13[1]) and low <= SLine13[1] then 0 else SLine13[1];
plot SLineP13 = if SLine13 > 0 then SLine13 else Double.NaN;
SLineP13.SetStyle(Curve.POINTS);
SLineP13.SetDefaultColor(Color.LIGHT_GREEN);
SLineP13.SetLineWeight(1);
SLineP13.HideBubble();
#----------------------------------------------------------------------------------
SLine14 = if !IsNaN(SupportLevel) and SLineCount == 14 then SupportLevel else if !IsNaN(SLine14[1]) and low <= SLine14[1] then 0 else SLine14[1];
plot SLineP14 = if SLine14 > 0 then SLine14 else Double.NaN;
SLineP14.SetStyle(Curve.POINTS);
SLineP14.SetDefaultColor(Color.LIGHT_GREEN);
SLineP14.SetLineWeight(1);
SLineP14.HideBubble();
#----------------------------------------------------------------------------------
SLine15 = if !IsNaN(SupportLevel) and SLineCount == 15 then SupportLevel else if !IsNaN(SLine15[1]) and low <= SLine15[1] then 0 else SLine15[1];
plot SLineP15 = if SLine15 > 0 then SLine15 else Double.NaN;
SLineP15.SetStyle(Curve.POINTS);
SLineP15.SetDefaultColor(Color.LIGHT_GREEN);
SLineP15.SetLineWeight(1);
SLineP15.HideBubble();
#----------------------------------------------------------------------------------
SLine16 = if !IsNaN(SupportLevel) and SLineCount == 16 then SupportLevel else if !IsNaN(SLine16[1]) and low <= SLine16[1] then 0 else SLine16[1];
plot SLineP16 = if SLine16 > 0 then SLine16 else Double.NaN;
SLineP16.SetStyle(Curve.POINTS);
SLineP16.SetDefaultColor(Color.LIGHT_GREEN);
SLineP16.SetLineWeight(1);
SLineP16.HideBubble();
#----------------------------------------------------------------------------------
SLine17 = if !IsNaN(SupportLevel) and SLineCount == 17 then SupportLevel else if !IsNaN(SLine17[1]) and low <= SLine17[1] then 0 else SLine17[1];
plot SLineP17 = if SLine17 > 0 then SLine17 else Double.NaN;
SLineP17.SetStyle(Curve.POINTS);
SLineP17.SetDefaultColor(Color.LIGHT_GREEN);
SLineP17.SetLineWeight(1);
SLineP17.HideBubble();
#----------------------------------------------------------------------------------
SLine18 = if !IsNaN(SupportLevel) and SLineCount == 18 then SupportLevel else if !IsNaN(SLine18[1]) and low < SLine18[1] then 0 else SLine18[1];
plot SLineP18 = if SLine18 > 0 then SLine18 else Double.NaN;
SLineP18.SetStyle(Curve.POINTS);
SLineP18.SetDefaultColor(Color.LIGHT_GREEN);
SLineP18.SetLineWeight(1);
SLineP18.HideBubble();
#----------------------------------------------------------------------------------
SLine19 = if !IsNaN(SupportLevel) and SLineCount == 19 then SupportLevel else if !IsNaN(SLine19[1]) and low <= SLine19[1] then 0 else SLine19[1];
plot SLineP19 = if SLine19 > 0 then SLine19 else Double.NaN;
SLineP19.SetStyle(Curve.POINTS);
SLineP19.SetDefaultColor(Color.LIGHT_GREEN);
SLineP19.SetLineWeight(1);
SLineP19.HideBubble();
#----------------------------------------------------------------------------------
SLine20 = if !IsNaN(SupportLevel) and SLineCount == 20 then SupportLevel else if !IsNaN(SLine20[1]) and low <= SLine20[1] then 0 else SLine20[1];
plot SLineP20 = if SLine20 > 0 then SLine20 else Double.NaN;
SLineP20.SetStyle(Curve.POINTS);
SLineP20.SetDefaultColor(Color.LIGHT_GREEN);
SLineP20.SetLineWeight(1);
SLineP20.HideBubble();
#----------------------------------------------------------------------------------
#####################################################################################


#red candles
######################################################################################
#Definitons of Resistance Levels.#####################################################
######################################################################################
plot ResistanceLevel = if RedBar then low[1] else Double.NaN;
ResistanceLevel.SetPaintingStrategy(PaintingStrategy.VALUES_ABOVE);

def RLine0;
def RLine1;
def RLine2;
def RLine3;
def RLine4;
def RLine5;
def RLine6;
def RLine7;
def RLine8;
def RLine9;
def RLine10;
def RLine11;
def RLine12;
def RLine13;
def RLine14;
def RLine15;
def RLine16;
def RLine17;
def RLine18;
def RLine19;
def RLine20;

def RLineCount;
If BarNumber() == 1 { RLineCount = 1;
}else if (IsNaN(ResistanceLevel) and !IsNaN(RLine1[1]) and high>=RLine1[1]) { RLineCount=0;
}else if (IsNaN(ResistanceLevel) and !IsNaN(RLine2[1]) and high>=RLine2[1]) { RLineCount=1;
}else if (IsNaN(ResistanceLevel) and !IsNaN(RLine3[1]) and high>=RLine3[1]) { RLineCount=2;
}else if (IsNaN(ResistanceLevel) and !IsNaN(RLine4[1]) and high>=RLine4[1]) { RLineCount=3;
}else if (IsNaN(ResistanceLevel) and !IsNaN(RLine5[1]) and high>=RLine5[1]) { RLineCount=4;
}else if (IsNaN(ResistanceLevel) and !IsNaN(RLine6[1]) and high>=RLine6[1]) { RLineCount=5;
}else if (IsNaN(ResistanceLevel) and !IsNaN(RLine7[1]) and high>=RLine7[1]) { RLineCount=6;
}else if (IsNaN(ResistanceLevel) and !IsNaN(RLine8[1]) and high>=RLine8[1]) { RLineCount=7;
}else if (IsNaN(ResistanceLevel) and !IsNaN(RLine9[1]) and high>=RLine9[1]) { RLineCount=8;
}else if (IsNaN(ResistanceLevel) and !IsNaN(RLine10[1]) and high>=RLine10[1]) { RLineCount=9;
}else if (IsNaN(ResistanceLevel) and !IsNaN(RLine11[1]) and high>=RLine11[1]) { RLineCount=10;
}else if (IsNaN(ResistanceLevel) and !IsNaN(RLine12[1]) and high>=RLine12[1]) { RLineCount=11;
}else if (IsNaN(ResistanceLevel) and !IsNaN(RLine13[1]) and high>=RLine13[1]) { RLineCount=12;
}else if (IsNaN(ResistanceLevel) and !IsNaN(RLine14[1]) and high>=RLine14[1]) { RLineCount=13;
}else if (IsNaN(ResistanceLevel) and !IsNaN(RLine15[1]) and high>=RLine15[1]) { RLineCount=14;
}else if (IsNaN(ResistanceLevel) and !IsNaN(RLine16[1]) and high>=RLine16[1]) { RLineCount=15;
}else if (IsNaN(ResistanceLevel) and !IsNaN(RLine17[1]) and high>=RLine17[1]) { RLineCount=16;
}else if (IsNaN(ResistanceLevel) and !IsNaN(RLine18[1]) and high>=RLine18[1]) { RLineCount=17;
}else if (IsNaN(ResistanceLevel) and !IsNaN(RLine19[1]) and high>=RLine19[1]) { RLineCount=18;
}else if (IsNaN(ResistanceLevel) and !IsNaN(RLine20[1]) and high>=RLine20[1]) { RLineCount=19;
}else if (IsNaN(ResistanceLevel) and !IsNaN(RLine0[1]) and high>=RLine0[1]) { RLineCount=20;

}else if (!IsNaN(ResistanceLevel) and !IsNaN(RLine0[1]) and high>=RLine0[1]) { RLineCount=0;
}else if (!IsNaN(ResistanceLevel) and !IsNaN(RLine1[1]) and high>=RLine1[1]) { RLineCount=1;
}else if (!IsNaN(ResistanceLevel) and !IsNaN(RLine2[1]) and high>=RLine2[1]) { RLineCount=2;
}else if (!IsNaN(ResistanceLevel) and !IsNaN(RLine3[1]) and high>=RLine3[1]) { RLineCount=3;
}else if (!IsNaN(ResistanceLevel) and !IsNaN(RLine4[1]) and high>=RLine4[1]) { RLineCount=4;
}else if (!IsNaN(ResistanceLevel) and !IsNaN(RLine5[1]) and high>=RLine5[1]) { RLineCount=5;
}else if (!IsNaN(ResistanceLevel) and !IsNaN(RLine6[1]) and high>=RLine6[1]) { RLineCount=6;
}else if (!IsNaN(ResistanceLevel) and !IsNaN(RLine7[1]) and high>=RLine7[1]) { RLineCount=7;
}else if (!IsNaN(ResistanceLevel) and !IsNaN(RLine8[1]) and high>=RLine8[1]) { RLineCount=8;
}else if (!IsNaN(ResistanceLevel) and !IsNaN(RLine9[1]) and high>=RLine9[1]) { RLineCount=9;
}else if (!IsNaN(ResistanceLevel) and !IsNaN(RLine10[1]) and high>=RLine10[1]) { RLineCount=10;
}else if (!IsNaN(ResistanceLevel) and !IsNaN(RLine11[1]) and high>=RLine11[1]) { RLineCount=11;
}else if (!IsNaN(ResistanceLevel) and !IsNaN(RLine12[1]) and high>=RLine12[1]) { RLineCount=12;
}else if (!IsNaN(ResistanceLevel) and !IsNaN(RLine13[1]) and high>=RLine13[1]) { RLineCount=13;
}else if (!IsNaN(ResistanceLevel) and !IsNaN(RLine14[1]) and high>=RLine14[1]) { RLineCount=14;
}else if (!IsNaN(ResistanceLevel) and !IsNaN(RLine15[1]) and high>=RLine15[1]) { RLineCount=15;
}else if (!IsNaN(ResistanceLevel) and !IsNaN(RLine16[1]) and high>=RLine16[1]) { RLineCount=16;
}else if (!IsNaN(ResistanceLevel) and !IsNaN(RLine17[1]) and high>=RLine17[1]) { RLineCount=17;
}else if (!IsNaN(ResistanceLevel) and !IsNaN(RLine18[1]) and high>=RLine18[1]) { RLineCount=18;
}else if (!IsNaN(ResistanceLevel) and !IsNaN(RLine19[1]) and high>=RLine19[1]) { RLineCount=19;
}else if (!IsNaN(ResistanceLevel) and !IsNaN(RLine20[1]) and high>=RLine20[1]) { RLineCount=20;
}else if (!IsNaN(ResistanceLevel)) and RLineCount[1]!=20 { RLineCount = RLineCount[1] + 1;
}else if (!IsNaN(ResistanceLevel)) and RLineCount[1]==20 { RLineCount = 0;
} else {
    RLineCount = RLineCount[1];
}

######################################################################################
#Plots of Resistance Levels.##########################################################
######################################################################################
RLine0 = if !IsNaN(ResistanceLevel) and RLineCount == 0 then ResistanceLevel else if !IsNaN(RLine0[1]) and high >= RLine0[1] then Double.NaN else RLine0[1];
plot RLineP0 = if RLine0 > 0 then RLine0 else Double.NaN;
RLineP0.SetStyle(Curve.POINTS);
RLineP0.SetDefaultColor(Color.LIGHT_RED);
RLineP0.SetLineWeight(1);
RLineP0.HideBubble();
def RLine0Length = if RLine0 != RLine0[1] then 1 else if !IsNaN(RLine0[1]) and IsNaN(RLine0) then 0 else if !IsNaN(RLine0) then RLine0Length[1] + 1 else 0;
#----------------------------------------------------------------------------------
RLine1 = if !IsNaN(ResistanceLevel) and RLineCount == 1 then ResistanceLevel else if !IsNaN(RLine1[1]) and high >= RLine1[1] then Double.NaN else RLine1[1];
plot RLineP1 = if RLine1 > 0 then RLine1 else Double.NaN;
RLineP1.SetStyle(Curve.POINTS);
RLineP1.SetDefaultColor(Color.LIGHT_RED);
RLineP1.SetLineWeight(1);
RLineP1.HideBubble();
def RLine1Length = if RLine1 != RLine1[1] then 1 else if !IsNaN(RLine1[1]) and IsNaN(RLine1) then 0 else if !IsNaN(RLine1) then RLine1Length[1] + 1 else 0;
#----------------------------------------------------------------------------------
RLine2 = if !IsNaN(ResistanceLevel) and RLineCount == 2 then ResistanceLevel else if !IsNaN(RLine2[1]) and high >= RLine2[1] then Double.NaN else RLine2[1];
plot RLineP2 = if RLine2 > 0 then RLine2 else Double.NaN;
RLineP2.SetStyle(Curve.POINTS);
RLineP2.SetDefaultColor(Color.LIGHT_RED);
RLineP2.SetLineWeight(1);
RLineP2.HideBubble();
def RLine2Length = if RLine2 != RLine2[1] then 1 else if !IsNaN(RLine2[1]) and IsNaN(RLine2) then 0 else if !IsNaN(RLine2) then RLine2Length[1] + 1 else 0;
#----------------------------------------------------------------------------------
RLine3 = if !IsNaN(ResistanceLevel) and RLineCount == 3 then ResistanceLevel else if !IsNaN(RLine3[1]) and high >= RLine3[1] then Double.NaN else RLine3[1];
plot RLineP3 = if RLine3 > 0 then RLine3 else Double.NaN;
RLineP3.SetStyle(Curve.POINTS);
RLineP3.SetDefaultColor(Color.LIGHT_RED);
RLineP3.SetLineWeight(1);
RLineP3.HideBubble();
def RLine3Length = if RLine3 != RLine3[1] then 1 else if !IsNaN(RLine3[1]) and IsNaN(RLine3) then 0 else if !IsNaN(RLine3) then RLine3Length[1] + 1 else 0;
#----------------------------------------------------------------------------------
RLine4 = if !IsNaN(ResistanceLevel) and RLineCount == 4 then ResistanceLevel else if !IsNaN(RLine4[1]) and high >= RLine4[1] then Double.NaN else RLine4[1];
plot RLineP4 = if RLine4 > 0 then RLine4 else Double.NaN;
RLineP4.SetStyle(Curve.POINTS);
RLineP4.SetDefaultColor(Color.LIGHT_RED);
RLineP4.SetLineWeight(1);
RLineP4.HideBubble();
def RLine4Length = if RLine4 != RLine4[1] then 1 else if !IsNaN(RLine4[1]) and IsNaN(RLine4) then 0 else if !IsNaN(RLine4) then RLine4Length[1] + 1 else 0;
#----------------------------------------------------------------------------------
RLine5 = if !IsNaN(ResistanceLevel) and RLineCount == 5 then ResistanceLevel else if !IsNaN(RLine5[1]) and high >= RLine5[1] then Double.NaN else RLine5[1];
plot RLineP5 = if RLine5 > 0 then RLine5 else Double.NaN;
RLineP5.SetStyle(Curve.POINTS);
RLineP5.SetDefaultColor(Color.LIGHT_RED);
RLineP5.SetLineWeight(1);
RLineP5.HideBubble();
def RLine5Length = if RLine5 != RLine5[1] then 1 else if !IsNaN(RLine5[1]) and IsNaN(RLine5) then 0 else if !IsNaN(RLine5) then RLine5Length[1] + 1 else 0;
#----------------------------------------------------------------------------------
RLine6 = if !IsNaN(ResistanceLevel) and RLineCount == 6 then ResistanceLevel else if !IsNaN(RLine6[1]) and high >= RLine6[1] then Double.NaN else RLine6[1];
plot RLineP6 = if RLine6 > 0 then RLine6 else Double.NaN;
RLineP6.SetStyle(Curve.POINTS);
RLineP6.SetDefaultColor(Color.LIGHT_RED);
RLineP6.SetLineWeight(1);
RLineP6.HideBubble();
#----------------------------------------------------------------------------------
RLine7 = if !IsNaN(ResistanceLevel) and RLineCount == 7 then ResistanceLevel else if !IsNaN(RLine7[1]) and high >= RLine7[1] then Double.NaN else RLine7[1];
plot RLineP7 = if RLine7 > 0 then RLine7 else Double.NaN;
RLineP7.SetStyle(Curve.POINTS);
RLineP7.SetDefaultColor(Color.LIGHT_RED);
RLineP7.SetLineWeight(1);
RLineP7.HideBubble();
#----------------------------------------------------------------------------------
RLine8 = if !IsNaN(ResistanceLevel) and RLineCount == 8 then ResistanceLevel else if !IsNaN(RLine8[1]) and high >= RLine8[1] then Double.NaN else RLine8[1];
plot RLineP8 = if RLine8 > 0 then RLine8 else Double.NaN;
RLineP8.SetStyle(Curve.POINTS);
RLineP8.SetDefaultColor(Color.LIGHT_RED);
RLineP8.SetLineWeight(1);
RLineP8.HideBubble();
#----------------------------------------------------------------------------------
RLine9 = if !IsNaN(ResistanceLevel) and RLineCount == 9 then ResistanceLevel else if !IsNaN(RLine9[1]) and high >= RLine9[1] then Double.NaN else RLine9[1];
plot RLineP9 = if RLine9 > 0 then RLine9 else Double.NaN;
RLineP9.SetStyle(Curve.POINTS);
RLineP9.SetDefaultColor(Color.LIGHT_RED);
RLineP9.SetLineWeight(1);
RLineP9.HideBubble();
#----------------------------------------------------------------------------------
RLine10 = if !IsNaN(ResistanceLevel) and RLineCount == 10 then ResistanceLevel else if !IsNaN(RLine10[1]) and high >= RLine10[1] then Double.NaN else RLine10[1];
plot RLineP10 = if RLine10 > 0 then RLine10 else Double.NaN;
RLineP10.SetStyle(Curve.POINTS);
RLineP10.SetDefaultColor(Color.LIGHT_RED);
RLineP10.SetLineWeight(1);
RLineP10.HideBubble();
#----------------------------------------------------------------------------------
RLine11 = if !IsNaN(ResistanceLevel) and RLineCount == 11 then ResistanceLevel else if !IsNaN(RLine11[1]) and high >= RLine11[1] then Double.NaN else RLine11[1];
plot RLineP11 = if RLine11 > 0 then RLine11 else Double.NaN;
RLineP11.SetStyle(Curve.POINTS);
RLineP11.SetDefaultColor(Color.LIGHT_RED);
RLineP11.SetLineWeight(1);
RLineP11.HideBubble();
#----------------------------------------------------------------------------------
RLine12 = if !IsNaN(ResistanceLevel) and RLineCount == 12 then ResistanceLevel else if !IsNaN(RLine12[1]) and high >= RLine12[1] then Double.NaN else RLine12[1];
plot RLineP12 = if RLine12 > 0 then RLine12 else Double.NaN;
RLineP12.SetStyle(Curve.POINTS);
RLineP12.SetDefaultColor(Color.LIGHT_RED);
RLineP12.SetLineWeight(1);
RLineP12.HideBubble();
#----------------------------------------------------------------------------------
RLine13 = if !IsNaN(ResistanceLevel) and RLineCount == 13 then ResistanceLevel else if !IsNaN(RLine13[1]) and high >= RLine13[1] then Double.NaN else RLine13[1];
plot RLineP13 = if RLine13 > 0 then RLine13 else Double.NaN;
RLineP13.SetStyle(Curve.POINTS);
RLineP13.SetDefaultColor(Color.LIGHT_RED);
RLineP13.SetLineWeight(1);
RLineP13.HideBubble();
#----------------------------------------------------------------------------------
RLine14 = if !IsNaN(ResistanceLevel) and RLineCount == 14 then ResistanceLevel else if !IsNaN(RLine14[1]) and high >= RLine14[1] then Double.NaN else RLine14[1];
plot RLineP14 = if RLine14 > 0 then RLine14 else Double.NaN;
RLineP14.SetStyle(Curve.POINTS);
RLineP14.SetDefaultColor(Color.LIGHT_RED);
RLineP14.SetLineWeight(1);
RLineP14.HideBubble();
#----------------------------------------------------------------------------------
RLine15 = if !IsNaN(ResistanceLevel) and RLineCount == 15 then ResistanceLevel else if !IsNaN(RLine15[1]) and high >= RLine15[1] then Double.NaN else RLine15[1];
plot RLineP15 = if RLine15 > 0 then RLine15 else Double.NaN;
RLineP15.SetStyle(Curve.POINTS);
RLineP15.SetDefaultColor(Color.LIGHT_RED);
RLineP15.SetLineWeight(1);
RLineP15.HideBubble();
#----------------------------------------------------------------------------------
RLine16 = if !IsNaN(ResistanceLevel) and RLineCount == 16 then ResistanceLevel else if !IsNaN(RLine16[1]) and high >= RLine16[1] then Double.NaN else RLine16[1];
plot RLineP16 = if RLine16 > 0 then RLine16 else Double.NaN;
RLineP16.SetStyle(Curve.POINTS);
RLineP16.SetDefaultColor(Color.LIGHT_RED);
RLineP16.SetLineWeight(1);
RLineP16.HideBubble();
#----------------------------------------------------------------------------------
RLine17 = if !IsNaN(ResistanceLevel) and RLineCount == 17 then ResistanceLevel else if !IsNaN(RLine17[1]) and high >= RLine17[1] then Double.NaN else RLine17[1];
plot RLineP17 = if RLine17 > 0 then RLine17 else Double.NaN;
RLineP17.SetStyle(Curve.POINTS);
RLineP17.SetDefaultColor(Color.LIGHT_RED);
RLineP17.SetLineWeight(1);
RLineP17.HideBubble();
#----------------------------------------------------------------------------------
RLine18 = if !IsNaN(ResistanceLevel) and RLineCount == 18 then ResistanceLevel else if !IsNaN(RLine18[1]) and high >= RLine18[1] then Double.NaN else RLine18[1];
plot RLineP18 = if RLine18 > 0 then RLine18 else Double.NaN;
RLineP18.SetStyle(Curve.POINTS);
RLineP18.SetDefaultColor(Color.LIGHT_RED);
RLineP18.SetLineWeight(1);
RLineP18.HideBubble();
#----------------------------------------------------------------------------------
RLine19 = if !IsNaN(ResistanceLevel) and RLineCount == 19 then ResistanceLevel else if !IsNaN(RLine19[1]) and high >= RLine19[1] then Double.NaN else RLine19[1];
plot RLineP19 = if RLine19 > 0 then RLine19 else Double.NaN;
RLineP19.SetStyle(Curve.POINTS);
RLineP19.SetDefaultColor(Color.LIGHT_RED);
RLineP19.SetLineWeight(1);
RLineP19.HideBubble();
#----------------------------------------------------------------------------------
RLine20 = if !IsNaN(ResistanceLevel) and RLineCount == 20 then ResistanceLevel else if !IsNaN(RLine20[1]) and high >= RLine20[1] then Double.NaN else RLine20[1];
plot RLineP20 = if RLine20 > 0 then RLine20 else Double.NaN;
RLineP20.SetStyle(Curve.POINTS);
RLineP20.SetDefaultColor(Color.LIGHT_RED);
RLineP20.SetLineWeight(1);
RLineP20.HideBubble();
#####################################################################################

I think it would be too complicated to modify this but just in case it's not:

Is it possible to use the close of the current candle instead of the previous candle's value (as high or low) to anchor the lines? If I change this offset from [1] to anything else then the plots don't work anymore:

Code:
plot SupportLevel = if GreenBar then high[1] else Double.NaN;

Another thing that I cannot figure out a way to do is make an extension line that goes all the way across the chart from the original line where it ends. For example, the original support line could use the points painting strategy and the extension could use either the horizontal or dashes painting strategy. I can't figure out a way to add extension lines because the value of each line rolls over to the next line every time. So using highestall from the last bar of the original line will plot the highest support line or highest resistance line, instead of that original line.
 
Last edited:

Join useThinkScript to post your question to a community of 21,000+ developers and traders.

Similar threads

Not the exact question you're looking for?

Start a new thread and receive assistance from our community.

87k+ Posts
149 Online
Create Post

Similar threads

Similar threads

The Market Trading Game Changer

Join 2,500+ subscribers inside the useThinkScript VIP Membership Club
  • Exclusive indicators
  • Proven strategies & setups
  • Private Discord community
  • ‘Buy The Dip’ signal alerts
  • Exclusive members-only content
  • Add-ons and resources
  • 1 full year of unlimited support

Frequently Asked Questions

What is useThinkScript?

useThinkScript is the #1 community of stock market investors using indicators and other tools to power their trading strategies. Traders of all skill levels use our forums to learn about scripting and indicators, help each other, and discover new ways to gain an edge in the markets.

How do I get started?

We get it. Our forum can be intimidating, if not overwhelming. With thousands of topics, tens of thousands of posts, our community has created an incredibly deep knowledge base for stock traders. No one can ever exhaust every resource provided on our site.

If you are new, or just looking for guidance, here are some helpful links to get you started.

What are the benefits of VIP Membership?
VIP members get exclusive access to these proven and tested premium indicators: Buy the Dip, Advanced Market Moves 2.0, Take Profit, and Volatility Trading Range. In addition, VIP members get access to over 50 VIP-only custom indicators, add-ons, and strategies, private VIP-only forums, private Discord channel to discuss trades and strategies in real-time, customer support, trade alerts, and much more. Learn all about VIP membership here.
How can I access the premium indicators?
To access the premium indicators, which are plug and play ready, sign up for VIP membership here.
Back
Top