Davo Strategy Indicator

//@version=4
//Davo Strategy - Indicator
study(title="Davo Strategy Indicator", shorttitle="Davo Indicator", overlay=true, precision=8)
// ################################################################################################################################################################
// General info and acknowledgements
// ################################################################################################################################################################
// Author: maqpie (a.k.a sanne)
// Date: 4th of December 2016
// 
// This script is based upon Davinci's dav-o meter and his original script, which searches for W's and M's in price, OBV, RSI and/or Willy.
// Although the original script is elegant, a W or M has to occur within 5 bars. 
// However, often what you will see is that a W or M forms over more than 5 bars.
// This script tries to remove that limit.
//  
// It took me several different approaches to find a good solution. For the most part because of the lack of any real debugging tool in Pine script.
// Let me know what you think, because I feel like I need tone down the number of options so it is easier to use.
// If you have any questions, or things you would like to see different please contact me at TRI.
// 
// Have fun playing and goofing around with it!
// 
// ################################################################################################################################################################
// How it works
// ################################################################################################################################################################
//
// Now, trading is more of an art form than a science and this indicator is no exception.
// When talking about M's and W's, it begs the question: what exactly counts as a W or M?
// My personal experience is that for a W to count as such, it has to adhere to the following rules:
//  
//      1. A 'W'  has 5 points, A, B, C, D and E                                E
//      2. Point A can be any point                                        C   /
//      3. Point B should be lower than A                             A   / \ /
//      4. Point C should be higher than B                             \ /   D
//      5. Point D should be lower than C, but higher than B            B
//      6. Point E should be higher than C
//
//      1. A 'M'  has 5 points, A, B, C, D and E                        B
//      2. Point A can be any point                                    / \   D
//      3. Point B should be higher than A                            A   \ / \
//      4. Point C should be lower than B                                  C   \
//      5. Point D should be higher than C, but lower than B                    E
//      6. Point E should be lower than C
//
// ######################################################################################################################################################################################################
// Script input parameters
// ######################################################################################################################################################################################################
// 
// You can use the following indicators to search for W's or M's:
//      - price (close)
//      - OBV
//      - RSI
//      - Willy
//      - MFI
//      - DMI (only DI+ and DI-; ADX isn't used)
// 
// For each of these indicators you set the following options:
//      - Use:                  whether you want to use it
//      - The maximum width:    over how many bars a W / M is allowed to form
//      - The maximum offset:   how many bars back a W / M is allowed to form
//      - Strict:               when not set, rule 5 (see 'How it works') changes: point D no longer has to be above B (for W), and no longer has to be below B (for M)
//      - Length:               lenght of the indicator, for example a 14 bar RSI
// 
// Other options:
//      - Period:               you can limit the period for backtesting. Useful to identify under what market conditions the script works best.
//
// ######################################################################################################################################################################################################
// Changelog
// ######################################################################################################################################################################################################
//
// v3.2
// - added title to plotshapes so that alerts are identifiable
// - set the default value for the allowed width of all indicators to 7
// - set the default value for "limit period" to true
// - set the default period for "limit period" to 1/1/2017 - 1/1/2018
// - moved indicator label to the bottom of the chart so it is easier to find
// - removed option "Show Dav-O" (this can now be done via the style tab)
// - removed option "Show Potential Dav-O". This was added to detect intra-bar signals. However, this can now be handled from within the Create Alert dialog. Use the option 'Once per bar (on condition)'.
//
// v3.3
// - migrated to Pine Version 3
// - added source
// - reinstated 'potential' dav-o based upon barstate.isrealtime as it is useful to have it on the chart
//
// v3.4
// - added MFI
// - fixed the offset; the offset wasn't working as intended
// - tidied up code
// - set the default period for "limit period" to 1/7/2017 - 1/1/2019
//
// v3.5
// - added DMI (only DI+ and DI-; ADX is not used)
//
// ######################################################################################################################################################################################################
// List of future improvements
// ######################################################################################################################################################################################################
//
// List of future improvements (in no particluar order):
//      - find a way to get rid of the "width" option, i.e. find W's and M's dynamically
//      - add option rsi overbought / oversold
//      - add option willy stupid
//      - add option to incorporate RLZ (this might become a separate indicator though)
//      - add option find divergences (this might become a separate indicator though)
//
//  Please share ideas with me to further improve this indicator. Thanks 
//
// ######################################################################################################################################################################################################


src = input(title="Source", type=input.source, defval=close)
//option_potential = input(defval = false, title = "Show unconfirmed")

includePrice = input(defval=true, title="Use price")
strictPrice = input(defval=true, title="Strict")
rangePrice = input(9, minval=5, title="Max. width of price W/M")  // e.g. allow an price W/M to form over 7 bars. 
offsetPrice = input(0, minval=0, title="Max. offset of price W/M")  // e.g. allow an price W/M to form 1 bar in history. Keep this number low. The goal is to synch the market structure over multiple indicators.

includeOBV = input(defval=true, title="Use OBV")
strictOBV = input(defval=true, title="Strict")
rangeOBV = input(9, minval=5, title="Max. width of OBV W/M")
offsetOBV = input(0, minval=0, title="Max. offset of OBV W/M")

includeWly = input(defval=true, title="Use Willy")
includeWillyStupid = input(defval=false, title="Use Willy stupid")
strictWly = input(defval=true, title="Strict")
rangeWly = input(9, minval=5, title="Max. width of Willy W/M")
offsetWly = input(0, minval=0, title="Max. offset of Willy W/M")
lengthWly = input(21, minval=1, title="Willy length")
lengthWlyEma = input(13, minval=1, title="Willy length ema")


includeMFI = input(defval=false, title="Use MFI")
strictMFI = input(defval=true, title="Strict")
rangeMFI = input(9, minval=5, title="Max. width of MFI W/M")
offsetMFI = input(0, minval=0, title="Max. offset of MFI W/M")
lengthMFI = input(14, minval=1, title="MFI length")

includeRSI = input(defval=false, title="Use RSI")
strictRSI = input(defval=true, title="Strict")
rangeRSI = input(9, minval=5, title="Max. width of RSI W/M")
offsetRSI = input(0, minval=0, title="Max. offset of RSI W/M")
lengthRSI = input(14, minval=1, title="RSI length")

includeDMI = input(defval=false, title="Use DMI (DI+ & DI-)")
strictDMI = input(defval=true, title="Strict")
rangeDMI = input(9, minval=5, title="Max. width of DMI W/M")
offsetDMI = input(0, minval=0, title="Max. offset of DMI W/M")
lengthDMI = input(14, minval=1, title="DMI length")

includeWithinRLZ = input(defval=false, title="Price within RLZ")
includeBelowRLZ = input(defval=false, title="Price above/below RLZ")
upperBoundRLZ = input(defval=61.8, minval=0.0, maxval=100.0, title="Upper bound of RLZ (fib)")
lowerBoundRLZ = input(defval=78.6, minval=0.0, maxval=100.0, title="Lower bound of RLZ (fib)")
lengthPeriodRLZ = input(defval=200, minval=5, title="Lookback period (bars)")
showRLZLong = input(defval=false, title="Draw RLZ long")
showRLZShort = input(defval=false, title="Draw RLZ short")

ATH = highest(high, lengthPeriodRLZ)
ATL = lowest(low, lengthPeriodRLZ)
range = ATH - ATL

is_rlz_long = barssince(highest(high, lengthPeriodRLZ)) >= 
   barssince(lowest(low, lengthPeriodRLZ))
is_rlz_short = barssince(highest(high, lengthPeriodRLZ)) < 
   barssince(lowest(low, lengthPeriodRLZ))

longUpperRLZ = showRLZLong ? (1 - upperBoundRLZ / 100) * range + ATL : na
longLowerRLZ = showRLZLong ? (1 - lowerBoundRLZ / 100) * range + ATL : na
longWithinRLZ = longUpperRLZ >= src and src >= longLowerRLZ
longBelowRLZ = longLowerRLZ > src
p1 = plot(longUpperRLZ, color=color.green, title="61.8 (long)")
p2 = plot(longLowerRLZ, color=color.green, title="78.6 (long)")
fill(p1, p2, color=#7DCEA0, transp=90, title="RLZ long")

shortUpperRLZ = showRLZShort ? ATH - (1 - upperBoundRLZ / 100) * range : na
shortLowerRLZ = showRLZShort ? ATH - (1 - lowerBoundRLZ / 100) * range : na
shortWithinRLZ = shortUpperRLZ <= src and src <= shortLowerRLZ
shortAboveRLZ = shortLowerRLZ < src
p3 = plot(shortUpperRLZ, color=color.red, title="78.6 (short)")
p4 = plot(shortLowerRLZ, color=color.red, title="61.8 (short)")
fill(p3, p4, color=#cd6155, transp=90, title="RLZ short")

includeSMA = input(defval=false, title="Price above/below SMA")
lengthSMA = input(20, minval=1, title="SMA length")

// limit by period option
limitPeriod = input(defval=true, title="Limit period (increases perfomance)")
lengthPeriod = input(240, minval=1, title="Length of period (hours)")

hours_in_milliseconds = 1000 * 60 * 60
withinPeriod = not limitPeriod or timenow - time < hours_in_milliseconds * lengthPeriod

// quickLook = input(defval = true, title = "Quick Look") // ignores historic data and will plot a signal on the chart
// show_order_details = input(defval = true, title = "Show entry / stoploss / target") // show entry, stoploss and target (toggling this doesn't work)
show_order_details = true
entrySource = input(title="Source for stoploss", type=input.source, defval=close)
stopLossSource = input(title="Source for entry", type=input.source, defval=close)
stopLossPercentage = input(defval=0.01, minval=0, maxval=100, step=0.01, title="Stop loss %")
riskRewardRatio = input(defval=2.0, minval=0.0, title="Risk to Reward 1-to-")

show = not barstate.isrealtime and 
   (includePrice or includeOBV or includeRSI or includeWly or includeMFI or 
   includeDMI)
//showPotential = barstate.isrealtime and (includePrice or includeOBV or includeRSI or includeWly or includeMFI or includeDMI) and option_potential

// create a series of obv, mfi, rsi, sma and willy values
change_1 = change(src)
OBVs = cum(change(src) > 0 ? volume : change_1 < 0 ? -volume : 0 * volume)
// caclulate mfi series
upper_s = sum(volume * (change(hlc3) <= 0 ? 0 : hlc3), lengthMFI)
lower_s = sum(volume * (change(hlc3) >= 0 ? 0 : hlc3), lengthMFI)
MFIs = rsi(upper_s, lower_s)
RSIs = rsi(lengthRSI, src)
SMAs = sma(src, lengthSMA)
// make willy series
upperWly = highest(lengthWly)
lowerWly = lowest(lengthWly)
WLYs = 100 * (src - upperWly) / (upperWly - lowerWly)
emaWly = ema(WLYs, lengthWlyEma)

series_a_above_series_b(seriesA, seriesB, aRange) =>
    result = true
    for i = 0 to aRange - 1 by 1
        if seriesB[i] > seriesA[i]
            result := false
            break
    result := result
    result

series_a_below_series_b(seriesA, seriesB, aRange) =>
    result = true
    for i = 0 to aRange - 1 by 1
        if seriesB[i] < seriesA[i]
            result := false
            break
    result := result
    result

dirmov(len) =>
    up = change(high)
    down = -change(low)
    truerange = rma(tr, len)
    plus = fixnan(100 * rma(up > down and up > 0 ? up : 0, len) / truerange)
    minus = fixnan(100 * rma(down > up and down > 0 ? down : 0, len) / truerange)
    [plus, minus]

data_W(aSeries, aRange, anOffset, strict) =>
    e = 0
    d = 0
    c = 0
    b = 0
    a = 0
    valueE = aSeries[0]
    valueD = aSeries[0]
    valueC = aSeries[0]
    valueB = aSeries[0]
    valueA = aSeries[0]
    found = false

    for offset = 0 to anOffset by 1
        if found
            break
        e := 0
        d := 0
        c := 0
        b := 0
        a := 0
        valueE := aSeries[0]
        valueC := aSeries[0]
        valueD := aSeries[0]
        valueB := aSeries[0]
        valueA := aSeries[0]

        for i = 1 to aRange - 1 by 1
            // find d
            if aSeries[i + offset] < aSeries[i + offset - 1] and valueC == aSeries[0]
                d := i + offset
                valueD := aSeries[i + offset]
                continue
            if d == 0
                break
            // find c
            if aSeries[i + offset] > aSeries[i + offset - 1] and valueB == aSeries[0]
                c := i + offset
                valueC := aSeries[i + offset]
                continue
            if c == 0
                break
            if aSeries[i + offset] < aSeries[i + offset - 1] and valueA == aSeries[0]
                b := i + offset
                valueB := aSeries[i + offset]
                continue
            if b == 0
                break
            if aSeries[i + offset] > aSeries[i + offset - 1]
                a := i + offset
                valueA := aSeries[i + offset]
                continue
            if a == 0
                break
        // W found if we have found point A, and point B has a lower value than point D                
        found := a > 0 and a != b and c != 0 and d != 0 and aSeries[e] > aSeries[c] and 
           aSeries[d] < aSeries[e] and aSeries[d] < aSeries[c] and 
           (aSeries[b] <= aSeries[d] or not strict) and aSeries[b] < aSeries[a]
        found
    entry = found ? aSeries[c] : na
    stopLoss = found ? aSeries[b] * ((100 - stopLossPercentage) / 100) : na
    target = found ? entry + (entry - stopLoss) * riskRewardRatio : na
    [found, entry, stopLoss, target, a, b, c, d, e]

data_M(aSeries, aRange, anOffset, strict) =>
    e = 0
    d = 0
    c = 0
    b = 0
    a = 0
    valueE = aSeries[0]
    valueD = aSeries[0]
    valueC = aSeries[0]
    valueB = aSeries[0]
    valueA = aSeries[0]
    found = false

    for offset = 0 to anOffset by 1
        if found
            break
        e := 0
        d := 0
        c := 0
        b := 0
        a := 0
        valueE := aSeries[0]
        valueC := aSeries[0]
        valueD := aSeries[0]
        valueB := aSeries[0]
        valueA := aSeries[0]

        for i = 1 to aRange - 1 by 1
            // find d
            if aSeries[i + offset] > aSeries[i + offset - 1] and valueC == aSeries[0]
                d := i + offset
                valueD := aSeries[i + offset]
                continue
            if d == 0
                break
            // find c
            if aSeries[i + offset] < aSeries[i + offset - 1] and valueB == aSeries[0]
                c := i + offset
                valueC := aSeries[i + offset]
                continue
            if c == 0
                break
            if aSeries[i + offset] > aSeries[i + offset - 1] and valueA == aSeries[0]
                b := i + offset
                valueB := aSeries[i + offset]
                continue
            if b == 0
                break
            if aSeries[i + offset] < aSeries[i + offset - 1]
                a := i + offset
                valueA := aSeries[i + offset]
                continue
            if a == 0
                break
        // M found if we have found point A, and point B has a greater value than point D                
        found := a > 0 and a != b and c != 0 and d != 0 and aSeries[e] < aSeries[c] and 
           aSeries[d] > aSeries[e] and aSeries[d] > aSeries[c] and 
           (aSeries[b] >= aSeries[d] or not strict) and aSeries[b] > aSeries[a]
        found
    entry = found ? aSeries[c] : na
    stopLoss = found ? aSeries[b] * ((100 + stopLossPercentage) / 100) : na
    target = found ? entry - (stopLoss - entry) * riskRewardRatio : na
    [found, entry, stopLoss, target, a, b, c, d, e]


find_W(aSeries, aRange, anOffset, strict) =>
    [found, entry, stopLoss, target, a, b, c, d, e] = data_W(aSeries, aRange, anOffset, strict)
    found

find_M(aSeries, aRange, anOffset, strict) =>
    [found, entry, stopLoss, target, a, b, c, d, e] = data_M(aSeries, aRange, anOffset, strict)
    found

// Direction Movement Index
[DIplus, DIminus] = dirmov(lengthDMI)

// calculate if price is below/above SMA
HighAboveSMA = includeSMA == false or series_a_above_series_b(high, SMAs, rangePrice)
LowBelowSMA = includeSMA == false or series_a_below_series_b(low, SMAs, rangePrice)

label_1 = 'davo'
label_entry = 'entry'

// PLOT DAV-O
[W_found, W_entry, W_stopLoss, W_target, W_pointA, W_pointB, W_pointC, W_pointD, W_pointE] = data_W(src, rangePrice, offsetPrice, strictPrice)
[M_found, M_entry, M_stopLoss, M_target, M_pointA, M_pointB, M_pointC, M_pointD, M_pointE] = data_M(src, rangePrice, offsetPrice, strictPrice)
priceW = includePrice == false or W_found
priceM = includePrice == false or M_found

OBVw = includeOBV == false or find_W(OBVs, rangeOBV, offsetOBV, strictOBV)
OBVm = includeOBV == false or find_M(OBVs, rangeOBV, offsetOBV, strictOBV)
MFIw = includeMFI == false or find_W(MFIs, rangeMFI, offsetMFI, strictMFI)
MFIm = includeMFI == false or find_M(MFIs, rangeMFI, offsetMFI, strictMFI)
RSIw = includeRSI == false or find_M(RSIs, rangeRSI, offsetRSI, strictRSI)  // we are searching for M's here to be a bull
RSIm = includeRSI == false or find_W(RSIs, rangeRSI, offsetRSI, strictRSI)  // we are searching for W's here to be a bear
Wlyw = includeWly == false or find_W(WLYs, rangeWly, offsetWly, strictWly)
Wlym = includeWly == false or find_M(WLYs, rangeWly, offsetWly, strictWly)
DMIw = includeDMI == false or find_W(DIplus, rangeDMI, offsetDMI, strictDMI) and 
   find_M(DIminus, rangeDMI, offsetDMI, strictDMI)
DMIm = includeDMI == false or find_M(DIplus, rangeDMI, offsetDMI, strictDMI) and 
   find_W(DIminus, rangeDMI, offsetDMI, strictDMI)
RLZw = includeWithinRLZ == false and includeBelowRLZ == false or 
   includeWithinRLZ == true and longWithinRLZ or 
   includeBelowRLZ == true and longBelowRLZ
RLZm = includeWithinRLZ == false and includeBelowRLZ == false or 
   includeWithinRLZ == true and shortWithinRLZ or 
   includeBelowRLZ == true and shortAboveRLZ

longCondition = LowBelowSMA and priceW and OBVw and MFIw and RSIw and Wlyw and DMIw and 
   withinPeriod and (includeWillyStupid == false or emaWly < -80) and RLZw
shortCondition = HighAboveSMA and priceM and OBVm and MFIm and RSIm and Wlym and DMIm and 
   withinPeriod and (includeWillyStupid == false or emaWly > -20) and RLZm

// calculate entry, stoploss and target
entrySourceLong = entrySource == low ? high : entrySource
entrySourceShort = entrySource == high ? low : entrySource
stopSourceLong = stopLossSource == high ? low : stopLossSource
stopSourceShort = stopLossSource == low ? high : stopLossSource

long_entry = show and longCondition and not longCondition[1] ? entrySourceLong[W_pointC] : na
lowest_1 = lowest(stopSourceLong, rangePrice)
long_stoploss = show and longCondition and not longCondition[1] ? 
   lowest_1 * ((100 - stopLossPercentage) / 100) : na
long_target = show and longCondition and not longCondition[1] ? 
   long_entry + (long_entry - long_stoploss) * riskRewardRatio : na
short_entry = show and shortCondition and not shortCondition[1] ? entrySourceShort[M_pointC] : 
   na
highest_1 = highest(stopSourceShort, rangePrice)
short_stoploss = show and shortCondition and not shortCondition[1] ? 
   highest_1 * ((100 + stopLossPercentage) / 100) : na
short_target = show and shortCondition and not shortCondition[1] ? 
   short_entry - (short_stoploss - short_entry) * riskRewardRatio : na

entry = long_entry ? long_entry : short_entry ? short_entry : na
stoploss = long_stoploss ? long_stoploss : short_stoploss ? short_stoploss : na
target = long_target ? long_target : short_target ? short_target : na

// define plot settings for entry, stoploss and target
transparency = show_order_details ? 0 : 100
clr_entry = show and (longCondition or shortCondition) ? color.white : na
clr_stoploss = show and (longCondition or shortCondition) ? color.red : na
clr_target = show and (longCondition or shortCondition) ? color.lime : na

// plot davo
plotshape(show and longCondition and not longCondition[1], title="Davo long", style=shape.triangleup, location=location.belowbar, color=color.lime, text=label_1)
plotshape(show and shortCondition and not shortCondition[1], title="Davo short", style=shape.triangledown, location=location.abovebar, color=color.red, text=label_1)
plotshape(show and longCondition[1], title="Davo long confirmed", style=shape.cross, location=location.bottom, color=color.lime, text="alert", transp=100)
plotshape(show and shortCondition[1], title="Davo short confirmed", style=shape.cross, location=location.top, color=color.red, text="alert", transp=100)
//plotshape(showPotential and longCondition, title="Davo long (potential)", style=shape.triangleup, location=location.belowbar, color=orange, text=label)
//plotshape(showPotential and shortCondition, title="Davo short (potential)", style=shape.triangledown, location=location.abovebar, color=orange, text=label)

// plot entry, stoploss target
//plotshape(entry[1], title="Entry", style=shape.circle, location=location.absolute, color=clr_entry[1], transp=transparency[1])
//plotshape(stoploss[1], title="Stop loss", color=clr_stoploss[1], style=shape.circle, location=location.absolute, transp=transparency[1])
//plotshape(target[1], title="Target", color=clr_target[1], style=shape.circle, location=location.absolute, transp=transparency[1])

// plot long entry, stoploss target
// plotshape(long_entry, title="Long entry", color=clr_entry, style=shape.circle, location=location.absolute, transp=transparency)
// plotshape(long_stoploss, title="Long stop loss", color=clr_stoploss, style=shape.circle, location=location.absolute, transp=transparency)
// plotshape(long_target, title="Long target", color=clr_target, style=shape.circle, location=location.absolute, transp=transparency)
// plot short entry, stoploss target
// plotshape(short_entry, title="Short entry", color=clr_entry, style=shape.circle, location=location.absolute, transp=transparency)
// plotshape(short_stoploss, title="Short stop loss", color=clr_stoploss, style=shape.circle, location=location.absolute, transp=transparency)
// plotshape(short_target, title="Short target", color=clr_target, style=shape.circle, location=location.absolute, transp=transparency)

// alerts
alertcondition(longCondition[1] and not longCondition[2], title='Davo long confirmed', message='Davo long')
alertcondition(shortCondition[1] and not longCondition[2], title='Davo short confirmed', message='Davo short')