SCE Price Action Suite

This is an indicator designed to use past market data to mark key price action levels as well as provide a different kind of insight. There are 8 different features in the script that users can turn on and off. This description will go in depth on all 8 with chart examples.

#1 Absorption Zones



I defined Absorption Zones as follows.

//----------------------------------------------
//---------------Absorption---------------------
//----------------------------------------------
box absorptionBox = na

absorptionBar = ta.highest(bodySize, absorptionLkb)

bsab = ta.barssince(bool(ta.change(absorptionBar)))

if bsab == 0 and upBar and showAbsorption
    absorptionBox := box.new(left = bar_index - 1, top = close, right = bar_index + az_strcuture, bottom = open, border_color = color.rgb(0, 80, 75), border_width = boxLineSize, bgcolor = color.rgb(0, 80, 75))
    absorptionBox

else if bsab == 0 and downBar and showAbsorption
    absorptionBox := box.new(left = bar_index - 1, top = close, right = bar_index + az_strcuture, bottom = open, border_color = color.rgb(105, 15, 15), border_width = boxLineSize, bgcolor = color.rgb(105, 15, 15))
    absorptionBox

What this means is that absorption bars are defined as the bars with the largest bodies over a selected lookback period. Those large bodies represent areas where price may react. I was inspired by the concept of a Fair Value Gap for this concept. In that body price may enter to be a point of support or resistance, market participants get “absorbed” in the area so price can continue in whichever direction.

#2 Candle Wick Theory/Strategy



I defined Candle Wick Theory/Strategy as follows.

//----------------------------------------------
//---------------Candle Wick--------------------
//----------------------------------------------
highWick = upBar ? high - close : downBar ? high - open : na
lowWick = upBar ? open - low : downBar ? close - low : na

upWick = upBar ? close + highWick : downBar ? open + highWick : na
downWick = upBar ? open - lowWick : downBar ? close - lowWick : na

downDelivery = upBar[1] and downBar and high > upWick[1] and highWick > lowWick and totalSize[1] > totalSize and barstate.isconfirmed and session.ismarket
upDelivery = downBar[1] and upBar and low < downWick[1] and highWick < lowWick and totalSize[1] > totalSize and barstate.isconfirmed and session.ismarket

line lG = na
line lE = na
line lR = na

bodyMidpoint = math.abs(body) / 2
upWickMidpoint = math.abs(upWickSize) / 2
downWickkMidpoint = math.abs(downWickSize) / 2
if upDelivery and showCdTheory
    cpE = chart.point.new(time, bar_index - 1, downWickkMidpoint)
    cpE2 = chart.point.new(time, bar_index + bl, downWickkMidpoint)

    cpG = chart.point.new(time, bar_index + bl, downWickkMidpoint * (1 + tp))
    cpR = chart.point.new(time, bar_index + bl, downWickkMidpoint * (1 - sl))

    cpG1 = chart.point.new(time, bar_index - 1, downWickkMidpoint * (1 + tp))
    cpR1 = chart.point.new(time, bar_index - 1, downWickkMidpoint * (1 - sl))

    lG := line.new(cpG1, cpG, xloc.bar_index, extend.none, color.green, line.style_solid, 1)
    lE := line.new(cpE, cpE2, xloc.bar_index, extend.none, color.white, line.style_solid, 1)
    lR := line.new(cpR1, cpR, xloc.bar_index, extend.none, color.red, line.style_solid, 1)
    lR

else if downDelivery and showCdTheory
    cpE = chart.point.new(time, bar_index - 1, upWickMidpoint)
    cpE2 = chart.point.new(time, bar_index + bl, upWickMidpoint)

    cpG = chart.point.new(time, bar_index + bl, upWickMidpoint * (1 - tp))
    cpR = chart.point.new(time, bar_index + bl, upWickMidpoint * (1 + sl))

    cpG1 = chart.point.new(time, bar_index - 1, upWickMidpoint * (1 - tp))
    cpR1 = chart.point.new(time, bar_index - 1, upWickMidpoint * (1 + sl))

    lG := line.new(cpG1, cpG, xloc.bar_index, extend.none, color.green, line.style_solid, 1)
    lE := line.new(cpE, cpE2, xloc.bar_index, extend.none, color.white, line.style_solid, 1)
    lR := line.new(cpR1, cpR, xloc.bar_index, extend.none, color.red, line.style_solid, 1)
    lR

First I get the size of the wicks for the top and bottoms of the candles. This depends on if the bar is red or green. If the bar is green the wick is the high minus the close, if red the high minus the open, and so on. Next, the script defines the upper and lower bounds of the wicks for further comparison. If the candle is green, it's the open price minus the bottom wick. If the candle is red, it's the close price minus the bottom wick, and so on. Next we have the condition for when this strategy is present.

Down delivery:
Occurs when the previous candle is green, the current candle is red, and:
The high of the current candle is above the upper wick of the previous candle.
The size of the current candle's top wick is greater than its bottom wick.
The total size of the previous candle is greater than the total size of the current candle.
The current bar is confirmed (barstate.isconfirmed).
The session is during market hours (session.ismarket).

Up delivery:
Occurs when the previous candle is red, the current candle is green, and:
The low of the current candle is below the lower wick of the previous candle.
The size of the current candle's bottom wick is greater than its top wick.
The total size of the previous candle is greater than the total size of the current candle.
The current bar is confirmed.
The session is during market hours
Then risk is plotted from the percentage that users can input from an ideal entry spot.

#3 Candle Size Theory

I defined Candle Size Theory as follows.

//----------------------------------------------
//---------------Candle displacement------------
//----------------------------------------------
line lECD = na

notableDown = bodySize > bodySize[1] * candle_size_sensitivity and downBar and session.ismarket and barstate.isconfirmed
notableUp = bodySize > bodySize[1] * candle_size_sensitivity and upBar and session.ismarket and barstate.isconfirmed

if notableUp and showCdSizeTheory
    cpE = chart.point.new(time, bar_index - 1, close)
    cpE2 = chart.point.new(time, bar_index + bl_strcuture, close)

    lECD := line.new(cpE, cpE2, xloc.bar_index, extend.none, color.rgb(0, 80, 75), line.style_solid, 3)
    lECD

else if notableDown and showCdSizeTheory
    cpE = chart.point.new(time, bar_index - 1, close)
    cpE2 = chart.point.new(time, bar_index + bl_strcuture, close)

    lECD := line.new(cpE, cpE2, xloc.bar_index, extend.none, color.rgb(105, 15, 15), line.style_solid, 3)
    lECD

This plots candles that are “notable” or out of the ordinary. Candles that are larger than the last by a value users get to specify. These candles' highs or lows, if they are green or red, act as levels for support or resistance.

#4 Candle Structure Theory



I defined Candle Structure Theory as follows.

//----------------------------------------------
//---------------Structure----------------------
//----------------------------------------------
breakDownStructure = low[2] < low[1] and low[1] < low and high[1] > high and upBar[3] and downBar[2] and upBar[1] and downBar and session.ismarket and barstate.isconfirmed
breakUpStructure = low[2] > low[1] and low[1] > low and high[1] < high and downBar[3] and upBar[2] and downBar[1] and upBar and session.ismarket and barstate.isconfirmed

if breakUpStructure and showStructureTheory
    cpE = chart.point.new(time, bar_index - 1, close)
    cpE2 = chart.point.new(time, bar_index + bl_strcuture, close)

    lE := line.new(cpE, cpE2, xloc.bar_index, extend.none, color.teal, line.style_solid, 3)
    lE

else if breakDownStructure and showStructureTheory
    cpE = chart.point.new(time, bar_index - 1, open)
    cpE2 = chart.point.new(time, bar_index + bl_strcuture, open)

    lE := line.new(cpE, cpE2, xloc.bar_index, extend.none, color.red, line.style_solid, 3)
    lE

It is a series of candles to create a notable event. 2 lower lows in a row, a lower high, then green bar, red bar, green bar is a structure for a breakdown. 2 higher lows in a row, a higher high, red bar, green bar, red bar for a break up.

#5 Candle Swing Structure Theory



I defined Candle Swing Structure Theory as follows.

//----------------------------------------------
//---------------Swing Structure----------------
//----------------------------------------------
line htb = na
line ltb = na

if totalSize[1] * swing_struct_sense < totalSize and upBar[1] and downBar and high[1] > high and showSwingSturcture and session.ismarket and barstate.isconfirmed
    cpS = chart.point.new(time, bar_index - 1, high)
    cpE = chart.point.new(time, bar_index + bl_strcuture, high)
    htb := line.new(cpS, cpE, xloc.bar_index, color = color.red, style = line.style_dashed)
    htb

else if totalSize[1] * swing_struct_sense < totalSize and downBar[1] and upBar and low[1] > low and showSwingSturcture and session.ismarket and barstate.isconfirmed
    cpS = chart.point.new(time, bar_index - 1, low)
    cpE = chart.point.new(time, bar_index + bl_strcuture, low)
    ltb := line.new(cpS, cpE, xloc.bar_index, color = color.teal, style = line.style_dashed)
    ltb

A bearish swing structure is defined as the last candle’s total size, times a scalar that the user can input, is less than the current candles. Like a size imbalance. The last bar must be green and this one red. The last high should also be less than this high. For a bullish swing structure the same size imbalance must be present, but we need a red bar then a green bar, and the last low higher than the current low.

#6 Fractal Boxes



I define the Fractal Boxes as follows

//----------------------------------------------
//---------------Fractal Boxes------------------
//----------------------------------------------
box b = na
int indexx = na
if bar_index % (n * 2) == 0 and session.ismarket and showBoxes
    b := box.new(left = bar_index, top = topBox, right = bar_index + n, bottom = bottomBox, border_color = color.rgb(105, 15, 15), border_width = boxLineSize, bgcolor = na)
    indexx := bar_index + 1
    indexx

The idea of this strategy is that the market is fractal. It is considered impossible to be able to tell apart two different time frames from just the chart. So inside the chart there are many many breakouts and breakdowns happening as price bounces around. The boxes are there to give you the view from your timeframe if the market is in a range from a time frame that would be higher than it. Like if we are inside what a larger time frame candle’s range. If we break out or down from this, we might be able to trade it. Users can specify a lookback period and the box is that period’s, as an interval, high and low. I say as an interval because it is plotted every n * 2 bars. So we get a box, price moves, then a new box.

#7 Potential Move Width



I define the Potential Move Width as follows

//----------------------------------------------
//---------------Move width---------------------
//----------------------------------------------
velocity = V(n)

line lC = na
line l = na
line l2 = na
line l3 = na
line l4 = na
line l5 = na
line l6 = na
line l7 = na
line l8 = na
line lGFractal = na
line lRFractal = na
cp2 = chart.point.new(time, bar_index + n, close + velocity)
cp3 = chart.point.new(time, bar_index + n, close - velocity)
cp4 = chart.point.new(time, bar_index + n, close + velocity * 5)
cp5 = chart.point.new(time, bar_index + n, close - velocity * 5)
cp6 = chart.point.new(time, bar_index + n, close + velocity * 10)
cp7 = chart.point.new(time, bar_index + n, close - velocity * 10)
cp8 = chart.point.new(time, bar_index + n, close + velocity * 15)
cp9 = chart.point.new(time, bar_index + n, close - velocity * 15)
cpG = chart.point.new(time, bar_index + n, close + R)
cpR = chart.point.new(time, bar_index + n, close - R)

if ((bar_index + n) * 2 - bar_index) % n == 0 and session.ismarket and barstate.isconfirmed and showPredictionWidtn
    cp = chart.point.new(time, bar_index, close)
    cpG1 = chart.point.new(time, bar_index, close + R)
    cpR1 = chart.point.new(time, bar_index, close - R)
    l := line.new(cp, cp2, xloc.bar_index, extend.none, color.aqua, line.style_solid, 1)
    l2 := line.new(cp, cp3, xloc.bar_index, extend.none, color.aqua, line.style_solid, 1)
    l3 := line.new(cp, cp4, xloc.bar_index, extend.none, color.red, line.style_solid, 1)
    l4 := line.new(cp, cp5, xloc.bar_index, extend.none, color.red, line.style_solid, 1)
    l5 := line.new(cp, cp6, xloc.bar_index, extend.none, color.teal, line.style_solid, 1)
    l6 := line.new(cp, cp7, xloc.bar_index, extend.none, color.teal, line.style_solid, 1)
    l7 := line.new(cp, cp8, xloc.bar_index, extend.none, color.blue, line.style_solid, 1)
    l8 := line.new(cp, cp9, xloc.bar_index, extend.none, color.blue, line.style_solid, 1)
    l8

By using the past n bar’s velocity, or directional speed, every n * 2 bars. I can use it to scale the close value and get an estimate for how wide the next moves might be.

#8 Linear regression

//----------------------------------------------
//---------------Linear Regression--------------
//----------------------------------------------
lr = showLR ? ta.linreg(close, n, 0) : na
plot(lr, 'Linear Regression', color.blue)

I used TradingView’s built in linear regression to not reinvent the wheel. This is present to see past market strength of weakness from a different perspective.

User input

Users can control a lot about this script. For the strategy based plots you can enter what you want the risk to be in percentages. So the default 0.01 is 1%. You can also control how far forward the line goes.

Look back at where it is needed as well as line width for the Fractal Boxes are controllable. Also users can check on and off what they would like to see on the charts.

No indicator is 100% reliable, do not follow this one blindly. I encourage traders to make their own decisions and not trade solely based on technical indicators. I encourage constructive criticism in the comments below. Thank you.