Mr. Love AIOSuite: MTF Moving Averages, Gaps, FVGs & Order Block

maxjede · study · 974 行 · 点赞 7 · TradingView 原页

本页源码来自 TradingView 公开发布的开源脚本,版权归原作者所有, 请遵循其原始许可(Pine 脚本常见 CC BY-NC-SA / MPL-2.0 / MIT)。 本项目仅用于研究检索与许可范围内的移植。

Pine Script

//@version=6
indicator("Mr. Love AIOSuite", shorttitle = "Mr. Love AIOSuite", overlay = true, max_boxes_count = 500, max_labels_count = 60, max_polylines_count = 5)
 
// ════════════════════════════════════════════════════════════════════════════════
//  Mr. Love AIOSuite – eigene Implementierung
//  20 MTF Moving Averages (Step / Live / Smoothed-Interpolated) · Bollinger Bands
//  VWAP · Auto-anchored VWAP · Daily Gaps · Fair Value Gaps · Order Blocks
// ════════════════════════════════════════════════════════════════════════════════
 
const string G_ZONE = "ZONES (GLOBAL)"
const string G_GAP  = "DAILY GAPS"
const string G_FVG  = "FAIR VALUE GAPS"
const string G_OB   = "ORDER BLOCKS"
const string G_BB   = "BOLLINGER BANDS"
const string G_MA   = "MOVING AVERAGES (GLOBAL)"
const string G_LBL  = "MA LABELS"
const string G_VW   = "VWAP"
const string G_XV   = "10XVWAP (AUTO-ANCHORED)"
const string G_SYS  = "SYSTEM"
 
// ════════════════════════════════════════════════════════════════════════════════
//  INPUTS
// ════════════════════════════════════════════════════════════════════════════════
 
// ───── Zones (global)
bool  zFadeOn     = input.bool(true, "Adaptive Zone Fade", inline = "zf", group = G_ZONE)
float zFadeDist   = input.float(10.0, "Full Fade Distance (Daily ATR)", minval = 0.5, step = 0.5, inline = "zf", group = G_ZONE, tooltip = "Zonen werden mit wachsendem Abstand zum Kurs transparenter. Ab diesem Abstand (in Daily-ATR) sind sie komplett ausgeblendet.")
int   zFilledFade = input.int(40, "Filled Zone Fade (%)", minval = 0, maxval = 100, group = G_ZONE, tooltip = "Zusätzliche Transparenz für gefüllte Zonen (Anteil der verbleibenden Deckkraft).")
bool  zLblGap     = input.bool(false, "Gaps", inline = "zl", group = G_ZONE)
bool  zLblFvg     = input.bool(false, "FVGs", inline = "zl", group = G_ZONE)
bool  zLblOb      = input.bool(false, "OBs", inline = "zl", group = G_ZONE, tooltip = "Text-Label in den Zonen anzeigen.")
int   zTransp     = input.int(90, "Transparency", minval = 0, maxval = 100, group = G_ZONE, tooltip = "Basis-Transparenz aller Zonen.")
 
// ───── Daily Gaps
bool   gapOn      = input.bool(true, "Enabled", group = G_GAP, tooltip = "Gap = Abstand zwischen Schlusskurs der Vorperiode und Eröffnung der neuen Periode.")
string gapTf      = input.timeframe("D", "Zeitrahmen", group = G_GAP)
int    gapLen     = input.int(14, "Average Range Length", minval = 1, group = G_GAP, tooltip = "Länge der durchschnittlichen Range (High-Low) auf dem Gap-Zeitrahmen.")
float  gapMinDev  = input.float(1.0, "Minimale Abweichung (%)", minval = 0.0, step = 0.5, group = G_GAP, tooltip = "Mindestgröße eines Gaps in % der durchschnittlichen Range.")
string gapFill    = input.string("Wick", "Fill Detection", options = ["Wick", "Close"], group = G_GAP, tooltip = "Wick: Docht reicht zum Füllen. Close: Schlusskurs muss die Zone durchqueren.")
bool   gapPartial = input.bool(true, "Track Partial Fills", group = G_GAP, tooltip = "Zone schrumpft auf den noch ungefüllten Teil.")
int    gapMax     = input.int(80, "Max Zones", minval = 1, maxval = 250, group = G_GAP)
bool   gapExpOn   = input.bool(true, "Expire Zones (bars)", inline = "gexp", group = G_GAP)
int    gapExp     = input.int(4000, "", minval = 1, inline = "gexp", group = G_GAP, tooltip = "Offene Zonen älter als X Bars werden entfernt.")
bool   gapKeepOn  = input.bool(true, "Keep Filled Zones", inline = "gkeep", group = G_GAP)
int    gapKeep    = input.int(250, "", minval = 0, inline = "gkeep", group = G_GAP, tooltip = "Anzahl gefüllter Zonen, die (verblasst) sichtbar bleiben.")
color  gapUpCol   = input.color(#4CAF50, "Gap Up Color", inline = "gcol", group = G_GAP)
color  gapDnCol   = input.color(#F23645, "Gap Down Color", inline = "gcol", group = G_GAP)
 
// ───── Fair Value Gaps
bool   fvgOn      = input.bool(true, "Enabled", group = G_FVG, tooltip = "3-Kerzen-Ineffizienz: Low(Kerze 3) > High(Kerze 1) bzw. High(Kerze 3) < Low(Kerze 1).")
string fvgTf      = input.timeframe("", "Zeitrahmen", group = G_FVG)
bool   fvgAuto    = input.bool(false, "Auto Threshold", inline = "fthr", group = G_FVG)
float  fvgManual  = input.float(0.5, "Manual (%)", minval = 0.0, step = 0.1, inline = "fthr", group = G_FVG, tooltip = "Mindestgröße des FVG in % vom Preis. Auto: durchschnittliche Bar-Range in % über 'Auto Length'.")
int    fvgAutoLen = input.int(100, "Auto Length", minval = 1, group = G_FVG)
string fvgFill    = input.string("Wick", "Fill Detection", options = ["Wick", "Close"], group = G_FVG)
bool   fvgPartial = input.bool(true, "Track Partial Fills", group = G_FVG)
int    fvgMax     = input.int(80, "Max Zones", minval = 1, maxval = 250, group = G_FVG)
bool   fvgExpOn   = input.bool(true, "Expire Zones (bars)", inline = "fexp", group = G_FVG)
int    fvgExp     = input.int(4000, "", minval = 1, inline = "fexp", group = G_FVG)
bool   fvgKeepOn  = input.bool(true, "Keep Filled Zones", inline = "fkeep", group = G_FVG)
int    fvgKeep    = input.int(250, "", minval = 0, inline = "fkeep", group = G_FVG)
color  fvgBullCol = input.color(#2962FF, "Bullish FVG Color", inline = "fcol", group = G_FVG)
color  fvgBearCol = input.color(#7B1FA2, "Bearish FVG Color", inline = "fcol", group = G_FVG)
 
// ───── Order Blocks
bool   obIntOn     = input.bool(true, "Internal Order Blocks", group = G_OB, tooltip = "OBs aus der internen (kurzfristigen) Marktstruktur.")
bool   obSwOn      = input.bool(true, "Swing Order Blocks", group = G_OB, tooltip = "OBs aus der Swing-Marktstruktur.")
int    obIntLen    = input.int(5, "Internal Pivot Length", minval = 2, maxval = 50, group = G_OB)
int    obSwLen     = input.int(11, "Swing Pivot Length", minval = 3, maxval = 100, group = G_OB)
int    obIntMax    = input.int(7, "Max Internal OBs", minval = 1, maxval = 50, group = G_OB)
color  obIBull     = input.color(#089981, "Internal Bull", inline = "oic", group = G_OB)
color  obIBear     = input.color(#F23645, "Internal Bear", inline = "oic", group = G_OB)
int    obSwMax     = input.int(7, "Max Swing OBs", minval = 1, maxval = 50, group = G_OB)
color  obSBull     = input.color(#1B5E20, "Swing Bull", inline = "osc", group = G_OB)
color  obSBear     = input.color(#801922, "Swing Bear", inline = "osc", group = G_OB)
string obInval     = input.string("Close", "Invalidation Method", options = ["Close", "Wick"], group = G_OB, tooltip = "Close: OB ungültig, wenn der Schlusskurs die Gegenseite durchbricht. Wick: bereits der Docht.")
string obBreak     = input.string("Close", "Break Confirmation", options = ["Close", "Wick"], group = G_OB, tooltip = "Wie ein Strukturbruch (Pivot-Bruch) bestätigt wird.")
string obAnchor    = input.string("Extreme", "Anchor Mode", options = ["Extreme", "Last Opposite"], group = G_OB, tooltip = "Extreme: Kerze mit dem tiefsten Low (bull) bzw. höchsten High (bear) zwischen Pivot und Bruch. Last Opposite: letzte Gegenkerze vor dem Bruch.")
string obBounds    = input.string("Hybrid", "OB Bounds", options = ["Hybrid", "Wick", "Body"], group = G_OB, tooltip = "Hybrid: Body + Docht auf der Extrem-Seite. Wick: komplette Kerze. Body: nur Kerzenkörper.")
bool   obAllowBrk  = input.bool(true, "Allow Break Candle Anchor", group = G_OB, tooltip = "Die Bruch-Kerze selbst darf als OB-Kerze dienen.")
string obVolMode   = input.string("ATR", "Volatility Filter", options = ["ATR", "Range", "None"], group = G_OB, tooltip = "Hoch-volatile Kerzen (Range >= Multiplier x Referenz) werden nur mit ihrem Körper als OB verwendet.")
int    obVolLen    = input.int(250, "Volatility Length", minval = 1, group = G_OB)
float  obVolMult   = input.float(2.0, "High-Vol Multiplier", minval = 0.5, step = 0.25, group = G_OB)
bool   obPrefOpp   = input.bool(true, "Prefer Opposite Candle", group = G_OB, tooltip = "Bei 'Extreme' werden Gegenkerzen (bearish für Bull-OB) bevorzugt. Fallback: alle Kerzen.")
int    obMaxSearch = input.int(600, "Max Search Window (bars)", minval = 10, maxval = 4000, group = G_OB)
 
// ───── Bollinger Bands
bool   bbOn      = input.bool(false, "Enabled", group = G_BB)
string bbTf      = input.timeframe("D", "Zeitrahmen", group = G_BB)
string bbSrc     = input.string("close", "Quelle", options = ["close", "open", "high", "low", "hl2", "hlc3", "ohlc4", "hlcc4"], group = G_BB)
int    bbLen     = input.int(20, "Länge", minval = 1, group = G_BB)
float  bbMult    = input.float(2.0, "StdDev Multiplier", minval = 0.1, step = 0.1, group = G_BB)
color  bbBandCol = input.color(#787B86, "Band Color", inline = "bbc", group = G_BB)
color  bbBaseCol = input.color(#787B8600, "Basis Color", inline = "bbc", group = G_BB)
int    bbFillT   = input.int(100, "Fill Transparency", minval = 0, maxval = 100, group = G_BB)
 
// ───── Moving Averages (global)
string maMode = input.string("Smoothed (No Repaint)", "MTF Display Mode", options = ["Smoothed (Interpolated)", "Smoothed (No Repaint)", "Step", "Live"], group = G_MA, tooltip = "Gilt für MAs auf höherem Zeitrahmen als der Chart.\n\nSmoothed (Interpolated): Jeder HTF-Wert wird am Beginn seiner HTF-Kerze gesetzt, dazwischen gerade Linien. Laufende HTF-Kerze = aktueller Wert (flach). Historisch um eine HTF-Kerze vorlaufend (Repaint).\n\nSmoothed (No Repaint): Linie läuft innerhalb der HTF-Kerze vom letzten bestätigten zum aktuellen Wert, ohne Blick in die Zukunft.\n\nStep: nur bestätigte HTF-Werte (Treppe, kein Repaint).\n\nLive: aktueller (sich entwickelnder) HTF-Wert auf jeder Kerze.")
bool   maOn   = input.bool(true, "Enabled", group = G_MA)
int    maLw   = input.int(1, "Linienbreite", minval = 1, maxval = 4, group = G_MA)
 
// ───── MA Labels
bool   lblType = input.bool(true, "Display MA Type", group = G_LBL)
bool   lblLen  = input.bool(true, "Display MA Length", group = G_LBL)
bool   lblTf   = input.bool(true, "Display MA Timeframe", group = G_LBL)
bool   lblNum  = input.bool(false, "Display MA Number", group = G_LBL)
int    lblOff  = input.int(3, "Label offset", minval = 0, maxval = 100, group = G_LBL)
string lblSize = input.string("small", "Label size", options = ["tiny", "small", "normal", "large"], group = G_LBL)
 
// ───── MA #1
bool   m1On   = input.bool(false, "Enabled", group = "MOVING AVERAGE #1")
string m1Type = input.string("EMA", "Typ", options = ["SMA", "EMA", "WMA", "VWMA", "RMA", "HMA", "DEMA", "TEMA", "LSMA"], group = "MOVING AVERAGE #1")
int    m1Len  = input.int(13, "Länge", minval = 1, group = "MOVING AVERAGE #1")
string m1Tf   = input.timeframe("D", "Zeitrahmen", group = "MOVING AVERAGE #1")
string m1Src  = input.string("close", "Quelle", options = ["close", "open", "high", "low", "hl2", "hlc3", "ohlc4", "hlcc4"], group = "MOVING AVERAGE #1")
color  m1Col  = input.color(#FFEB3B, "Color", group = "MOVING AVERAGE #1")
// ───── MA #2
bool   m2On   = input.bool(true, "Enabled", group = "MOVING AVERAGE #2")
string m2Type = input.string("SMA", "Typ", options = ["SMA", "EMA", "WMA", "VWMA", "RMA", "HMA", "DEMA", "TEMA", "LSMA"], group = "MOVING AVERAGE #2")
int    m2Len  = input.int(20, "Länge", minval = 1, group = "MOVING AVERAGE #2")
string m2Tf   = input.timeframe("D", "Zeitrahmen", group = "MOVING AVERAGE #2")
string m2Src  = input.string("close", "Quelle", options = ["close", "open", "high", "low", "hl2", "hlc3", "ohlc4", "hlcc4"], group = "MOVING AVERAGE #2")
color  m2Col  = input.color(#FF9800, "Color", group = "MOVING AVERAGE #2")
// ───── MA #3
bool   m3On   = input.bool(true, "Enabled", group = "MOVING AVERAGE #3")
string m3Type = input.string("SMA", "Typ", options = ["SMA", "EMA", "WMA", "VWMA", "RMA", "HMA", "DEMA", "TEMA", "LSMA"], group = "MOVING AVERAGE #3")
int    m3Len  = input.int(50, "Länge", minval = 1, group = "MOVING AVERAGE #3")
string m3Tf   = input.timeframe("D", "Zeitrahmen", group = "MOVING AVERAGE #3")
string m3Src  = input.string("close", "Quelle", options = ["close", "open", "high", "low", "hl2", "hlc3", "ohlc4", "hlcc4"], group = "MOVING AVERAGE #3")
color  m3Col  = input.color(#4CAF50, "Color", group = "MOVING AVERAGE #3")
// ───── MA #4
bool   m4On   = input.bool(true, "Enabled", group = "MOVING AVERAGE #4")
string m4Type = input.string("SMA", "Typ", options = ["SMA", "EMA", "WMA", "VWMA", "RMA", "HMA", "DEMA", "TEMA", "LSMA"], group = "MOVING AVERAGE #4")
int    m4Len  = input.int(200, "Länge", minval = 1, group = "MOVING AVERAGE #4")
string m4Tf   = input.timeframe("D", "Zeitrahmen", group = "MOVING AVERAGE #4")
string m4Src  = input.string("close", "Quelle", options = ["close", "open", "high", "low", "hl2", "hlc3", "ohlc4", "hlcc4"], group = "MOVING AVERAGE #4")
color  m4Col  = input.color(#D1D4DC, "Color", group = "MOVING AVERAGE #4")
// ───── MA #5
bool   m5On   = input.bool(false, "Enabled", group = "MOVING AVERAGE #5")
string m5Type = input.string("EMA", "Typ", options = ["SMA", "EMA", "WMA", "VWMA", "RMA", "HMA", "DEMA", "TEMA", "LSMA"], group = "MOVING AVERAGE #5")
int    m5Len  = input.int(200, "Länge", minval = 1, group = "MOVING AVERAGE #5")
string m5Tf   = input.timeframe("D", "Zeitrahmen", group = "MOVING AVERAGE #5")
string m5Src  = input.string("close", "Quelle", options = ["close", "open", "high", "low", "hl2", "hlc3", "ohlc4", "hlcc4"], group = "MOVING AVERAGE #5")
color  m5Col  = input.color(#D1D4DC, "Color", group = "MOVING AVERAGE #5")
// ───── MA #6
bool   m6On   = input.bool(false, "Enabled", group = "MOVING AVERAGE #6")
string m6Type = input.string("EMA", "Typ", options = ["SMA", "EMA", "WMA", "VWMA", "RMA", "HMA", "DEMA", "TEMA", "LSMA"], group = "MOVING AVERAGE #6")
int    m6Len  = input.int(13, "Länge", minval = 1, group = "MOVING AVERAGE #6")
string m6Tf   = input.timeframe("W", "Zeitrahmen", group = "MOVING AVERAGE #6")
string m6Src  = input.string("close", "Quelle", options = ["close", "open", "high", "low", "hl2", "hlc3", "ohlc4", "hlcc4"], group = "MOVING AVERAGE #6")
color  m6Col  = input.color(#FFEB3B, "Color", group = "MOVING AVERAGE #6")
// ───── MA #7
bool   m7On   = input.bool(true, "Enabled", group = "MOVING AVERAGE #7")
string m7Type = input.string("SMA", "Typ", options = ["SMA", "EMA", "WMA", "VWMA", "RMA", "HMA", "DEMA", "TEMA", "LSMA"], group = "MOVING AVERAGE #7")
int    m7Len  = input.int(20, "Länge", minval = 1, group = "MOVING AVERAGE #7")
string m7Tf   = input.timeframe("W", "Zeitrahmen", group = "MOVING AVERAGE #7")
string m7Src  = input.string("close", "Quelle", options = ["close", "open", "high", "low", "hl2", "hlc3", "ohlc4", "hlcc4"], group = "MOVING AVERAGE #7")
color  m7Col  = input.color(#FF9800, "Color", group = "MOVING AVERAGE #7")
// ───── MA #8
bool   m8On   = input.bool(true, "Enabled", group = "MOVING AVERAGE #8")
string m8Type = input.string("SMA", "Typ", options = ["SMA", "EMA", "WMA", "VWMA", "RMA", "HMA", "DEMA", "TEMA", "LSMA"], group = "MOVING AVERAGE #8")
int    m8Len  = input.int(50, "Länge", minval = 1, group = "MOVING AVERAGE #8")
string m8Tf   = input.timeframe("W", "Zeitrahmen", group = "MOVING AVERAGE #8")
string m8Src  = input.string("close", "Quelle", options = ["close", "open", "high", "low", "hl2", "hlc3", "ohlc4", "hlcc4"], group = "MOVING AVERAGE #8")
color  m8Col  = input.color(#4CAF50, "Color", group = "MOVING AVERAGE #8")
// ───── MA #9
bool   m9On   = input.bool(true, "Enabled", group = "MOVING AVERAGE #9")
string m9Type = input.string("SMA", "Typ", options = ["SMA", "EMA", "WMA", "VWMA", "RMA", "HMA", "DEMA", "TEMA", "LSMA"], group = "MOVING AVERAGE #9")
int    m9Len  = input.int(200, "Länge", minval = 1, group = "MOVING AVERAGE #9")
string m9Tf   = input.timeframe("W", "Zeitrahmen", group = "MOVING AVERAGE #9")
string m9Src  = input.string("close", "Quelle", options = ["close", "open", "high", "low", "hl2", "hlc3", "ohlc4", "hlcc4"], group = "MOVING AVERAGE #9")
color  m9Col  = input.color(#64B5F6, "Color", group = "MOVING AVERAGE #9")
// ───── MA #10
bool   m10On   = input.bool(false, "Enabled", group = "MOVING AVERAGE #10")
string m10Type = input.string("EMA", "Typ", options = ["SMA", "EMA", "WMA", "VWMA", "RMA", "HMA", "DEMA", "TEMA", "LSMA"], group = "MOVING AVERAGE #10")
int    m10Len  = input.int(200, "Länge", minval = 1, group = "MOVING AVERAGE #10")
string m10Tf   = input.timeframe("W", "Zeitrahmen", group = "MOVING AVERAGE #10")
string m10Src  = input.string("close", "Quelle", options = ["close", "open", "high", "low", "hl2", "hlc3", "ohlc4", "hlcc4"], group = "MOVING AVERAGE #10")
color  m10Col  = input.color(#64B5F6, "Color", group = "MOVING AVERAGE #10")
// ───── MA #11
bool   m11On   = input.bool(false, "Enabled", group = "MOVING AVERAGE #11")
string m11Type = input.string("EMA", "Typ", options = ["SMA", "EMA", "WMA", "VWMA", "RMA", "HMA", "DEMA", "TEMA", "LSMA"], group = "MOVING AVERAGE #11")
int    m11Len  = input.int(13, "Länge", minval = 1, group = "MOVING AVERAGE #11")
string m11Tf   = input.timeframe("M", "Zeitrahmen", group = "MOVING AVERAGE #11")
string m11Src  = input.string("close", "Quelle", options = ["close", "open", "high", "low", "hl2", "hlc3", "ohlc4", "hlcc4"], group = "MOVING AVERAGE #11")
color  m11Col  = input.color(#FFEB3B, "Color", group = "MOVING AVERAGE #11")
// ───── MA #12
bool   m12On   = input.bool(false, "Enabled", group = "MOVING AVERAGE #12")
string m12Type = input.string("EMA", "Typ", options = ["SMA", "EMA", "WMA", "VWMA", "RMA", "HMA", "DEMA", "TEMA", "LSMA"], group = "MOVING AVERAGE #12")
int    m12Len  = input.int(20, "Länge", minval = 1, group = "MOVING AVERAGE #12")
string m12Tf   = input.timeframe("M", "Zeitrahmen", group = "MOVING AVERAGE #12")
string m12Src  = input.string("close", "Quelle", options = ["close", "open", "high", "low", "hl2", "hlc3", "ohlc4", "hlcc4"], group = "MOVING AVERAGE #12")
color  m12Col  = input.color(#FF9800, "Color", group = "MOVING AVERAGE #12")
// ───── MA #13
bool   m13On   = input.bool(false, "Enabled", group = "MOVING AVERAGE #13")
string m13Type = input.string("EMA", "Typ", options = ["SMA", "EMA", "WMA", "VWMA", "RMA", "HMA", "DEMA", "TEMA", "LSMA"], group = "MOVING AVERAGE #13")
int    m13Len  = input.int(50, "Länge", minval = 1, group = "MOVING AVERAGE #13")
string m13Tf   = input.timeframe("M", "Zeitrahmen", group = "MOVING AVERAGE #13")
string m13Src  = input.string("close", "Quelle", options = ["close", "open", "high", "low", "hl2", "hlc3", "ohlc4", "hlcc4"], group = "MOVING AVERAGE #13")
color  m13Col  = input.color(#4CAF50, "Color", group = "MOVING AVERAGE #13")
// ───── MA #14
bool   m14On   = input.bool(false, "Enabled", group = "MOVING AVERAGE #14")
string m14Type = input.string("SMA", "Typ", options = ["SMA", "EMA", "WMA", "VWMA", "RMA", "HMA", "DEMA", "TEMA", "LSMA"], group = "MOVING AVERAGE #14")
int    m14Len  = input.int(200, "Länge", minval = 1, group = "MOVING AVERAGE #14")
string m14Tf   = input.timeframe("M", "Zeitrahmen", group = "MOVING AVERAGE #14")
string m14Src  = input.string("close", "Quelle", options = ["close", "open", "high", "low", "hl2", "hlc3", "ohlc4", "hlcc4"], group = "MOVING AVERAGE #14")
color  m14Col  = input.color(#D1D4DC, "Color", group = "MOVING AVERAGE #14")
// ───── MA #15
bool   m15On   = input.bool(false, "Enabled", group = "MOVING AVERAGE #15")
string m15Type = input.string("EMA", "Typ", options = ["SMA", "EMA", "WMA", "VWMA", "RMA", "HMA", "DEMA", "TEMA", "LSMA"], group = "MOVING AVERAGE #15")
int    m15Len  = input.int(200, "Länge", minval = 1, group = "MOVING AVERAGE #15")
string m15Tf   = input.timeframe("M", "Zeitrahmen", group = "MOVING AVERAGE #15")
string m15Src  = input.string("close", "Quelle", options = ["close", "open", "high", "low", "hl2", "hlc3", "ohlc4", "hlcc4"], group = "MOVING AVERAGE #15")
color  m15Col  = input.color(#D1D4DC, "Color", group = "MOVING AVERAGE #15")
// ───── MA #16
bool   m16On   = input.bool(false, "Enabled", group = "MOVING AVERAGE #16")
string m16Type = input.string("SMA", "Typ", options = ["SMA", "EMA", "WMA", "VWMA", "RMA", "HMA", "DEMA", "TEMA", "LSMA"], group = "MOVING AVERAGE #16")
int    m16Len  = input.int(1, "Länge", minval = 1, group = "MOVING AVERAGE #16")
string m16Tf   = input.timeframe("", "Zeitrahmen", group = "MOVING AVERAGE #16")
string m16Src  = input.string("close", "Quelle", options = ["close", "open", "high", "low", "hl2", "hlc3", "ohlc4", "hlcc4"], group = "MOVING AVERAGE #16")
color  m16Col  = input.color(#FFFFFF, "Color", group = "MOVING AVERAGE #16")
// ───── MA #17
bool   m17On   = input.bool(false, "Enabled", group = "MOVING AVERAGE #17")
string m17Type = input.string("SMA", "Typ", options = ["SMA", "EMA", "WMA", "VWMA", "RMA", "HMA", "DEMA", "TEMA", "LSMA"], group = "MOVING AVERAGE #17")
int    m17Len  = input.int(2, "Länge", minval = 1, group = "MOVING AVERAGE #17")
string m17Tf   = input.timeframe("", "Zeitrahmen", group = "MOVING AVERAGE #17")
string m17Src  = input.string("close", "Quelle", options = ["close", "open", "high", "low", "hl2", "hlc3", "ohlc4", "hlcc4"], group = "MOVING AVERAGE #17")
color  m17Col  = input.color(#FFFFFF, "Color", group = "MOVING AVERAGE #17")
// ───── MA #18
bool   m18On   = input.bool(false, "Enabled", group = "MOVING AVERAGE #18")
string m18Type = input.string("SMA", "Typ", options = ["SMA", "EMA", "WMA", "VWMA", "RMA", "HMA", "DEMA", "TEMA", "LSMA"], group = "MOVING AVERAGE #18")
int    m18Len  = input.int(3, "Länge", minval = 1, group = "MOVING AVERAGE #18")
string m18Tf   = input.timeframe("", "Zeitrahmen", group = "MOVING AVERAGE #18")
string m18Src  = input.string("close", "Quelle", options = ["close", "open", "high", "low", "hl2", "hlc3", "ohlc4", "hlcc4"], group = "MOVING AVERAGE #18")
color  m18Col  = input.color(#FFFFFF, "Color", group = "MOVING AVERAGE #18")
// ───── MA #19
bool   m19On   = input.bool(false, "Enabled", group = "MOVING AVERAGE #19")
string m19Type = input.string("SMA", "Typ", options = ["SMA", "EMA", "WMA", "VWMA", "RMA", "HMA", "DEMA", "TEMA", "LSMA"], group = "MOVING AVERAGE #19")
int    m19Len  = input.int(4, "Länge", minval = 1, group = "MOVING AVERAGE #19")
string m19Tf   = input.timeframe("", "Zeitrahmen", group = "MOVING AVERAGE #19")
string m19Src  = input.string("close", "Quelle", options = ["close", "open", "high", "low", "hl2", "hlc3", "ohlc4", "hlcc4"], group = "MOVING AVERAGE #19")
color  m19Col  = input.color(#FFFFFF, "Color", group = "MOVING AVERAGE #19")
// ───── MA #20
bool   m20On   = input.bool(false, "Enabled", group = "MOVING AVERAGE #20")
string m20Type = input.string("SMA", "Typ", options = ["SMA", "EMA", "WMA", "VWMA", "RMA", "HMA", "DEMA", "TEMA", "LSMA"], group = "MOVING AVERAGE #20")
int    m20Len  = input.int(5, "Länge", minval = 1, group = "MOVING AVERAGE #20")
string m20Tf   = input.timeframe("", "Zeitrahmen", group = "MOVING AVERAGE #20")
string m20Src  = input.string("close", "Quelle", options = ["close", "open", "high", "low", "hl2", "hlc3", "ohlc4", "hlcc4"], group = "MOVING AVERAGE #20")
color  m20Col  = input.color(#FFFFFF, "Color", group = "MOVING AVERAGE #20")
 
// ───── VWAP
bool   vwOn     = input.bool(false, "Enabled", group = G_VW)
color  vwCol    = input.color(#FFEB3B, "Color", group = G_VW)
int    vwLw     = input.int(1, "Linienbreite", minval = 1, maxval = 4, group = G_VW)
string vwAnchor = input.string("Session", "Anchor", options = ["Session", "Week", "Month", "Quarter", "Year"], group = G_VW, tooltip = "Reset-Periode des VWAP. Ohne Volumen (z. B. Kassa-Indizes) wird gleichgewichtet.")
 
// ───── 10xVWAP (auto-anchored)
bool   xvOn     = input.bool(false, "Enabled", group = G_XV, tooltip = "VWAP, automatisch am letzten bestätigten Swing-Hoch/-Tief verankert (oder an einer festen Periode).")
color  xvCol    = input.color(#FFC107, "Color", group = G_XV)
int    xvLw     = input.int(2, "Linienbreite", minval = 1, maxval = 4, group = G_XV)
string xvAnchor = input.string("Auto Swing", "Anchor", options = ["Auto Swing", "Session", "Week", "Month", "Quarter", "Year"], group = G_XV)
int    xvLen    = input.int(20, "Swing Length", minval = 2, maxval = 400, group = G_XV)
 
// ───── System
bool alertsOn = input.bool(true, "Enable Alert Conditions", group = G_SYS, tooltip = "Alarm über 'Any alert() function call' oder die einzelnen Alert-Conditions anlegen.")
bool confOnly = input.bool(true, "Close Events: Confirmed Only (optional)", group = G_SYS, tooltip = "Close-basierte Events (MA-Cross, Close-Fill, Close-Break) feuern erst bei Kerzenschluss.")
bool showWarn = input.bool(false, "Show TF Warning Panel", group = G_SYS, tooltip = "Listet Module, deren Zeitrahmen kleiner als der Chart-Zeitrahmen ist (diese werden ausgeblendet).")
 
// ════════════════════════════════════════════════════════════════════════════════
//  TYPES & GLOBAL STATE
// ════════════════════════════════════════════════════════════════════════════════
type Zone
    box   bx
    float top
    float bot
    bool  bull
    int   born
    color col
 
type Piv
    float level   = na
    int   bar     = na
    bool  crossed = true
 
int chartSecG = timeframe.in_seconds(timeframe.period)
 
var array<Zone> gapAct = array.new<Zone>()
var array<box>  gapFil = array.new<box>()
var array<Zone> fvgAct = array.new<Zone>()
var array<box>  fvgFil = array.new<box>()
var array<Zone> iobAct = array.new<Zone>()
var array<Zone> sobAct = array.new<Zone>()
 
// ════════════════════════════════════════════════════════════════════════════════
//  HELPERS – Moving Averages
// ════════════════════════════════════════════════════════════════════════════════
srcOf(simple string name, float o, float h, float l, float c) =>
    switch name
        "open"  => o
        "high"  => h
        "low"   => l
        "hl2"   => (h + l) / 2.0
        "hlc3"  => (h + l + c) / 3.0
        "ohlc4" => (o + h + l + c) / 4.0
        "hlcc4" => (h + l + 2.0 * c) / 4.0
        => c
 
// Gewicht des jüngsten Inputs im (linearen) MA-Filter.
// Damit lässt sich der sich entwickelnde HTF-Wert ohne Lookahead rekonstruieren.
maW0(simple string t, simple int n) =>
    float a = 2.0 / (n + 1)
    switch t
        "SMA"  => 1.0 / n
        "EMA"  => a
        "WMA"  => a
        "RMA"  => 1.0 / n
        "DEMA" => 2.0 * a - a * a
        "TEMA" => 3.0 * a - 3.0 * a * a + a * a * a
        "HMA"  =>
            int half = math.max(1, int(n / 2))
            int sq   = math.max(1, math.round(math.sqrt(n)))
            (2.0 / (sq + 1)) * (2.0 * (2.0 / (half + 1)) - a)
        "LSMA" => 2.0 * (2 * n - 1) / (n * (n + 1))
        => 1.0 / n
 
hmaCalc(float s, simple int n) =>
    int half = math.max(1, int(n / 2))
    int sq   = math.max(1, math.round(math.sqrt(n)))
    ta.wma(2.0 * ta.wma(s, half) - ta.wma(s, n), sq)
 
maCalc(simple string t, float s, simple int n) =>
    switch t
        "SMA"  => ta.sma(s, n)
        "EMA"  => ta.ema(s, n)
        "WMA"  => ta.wma(s, n)
        "VWMA" => ta.vwma(s, n)
        "RMA"  => ta.rma(s, n)
        "HMA"  => hmaCalc(s, n)
        "DEMA" =>
            float e1 = ta.ema(s, n)
            2.0 * e1 - ta.ema(e1, n)
        "TEMA" =>
            float e1 = ta.ema(s, n)
            float e2 = ta.ema(e1, n)
            3.0 * e1 - 3.0 * e2 + ta.ema(e2, n)
        "LSMA" => ta.linreg(s, n, 0)
        => ta.sma(s, n)
 
// Läuft im HTF-Kontext: liefert nur Werte, die ausschließlich von abgeschlossenen HTF-Kerzen abhängen.
htfPack(simple string t, simple int n, simple string srcName) =>
    float s   = srcOf(srcName, open, high, low, close)
    float m   = maCalc(t, s, n)
    float vol = nz(volume)
    bool  isV = t == "VWMA" and n > 1
    int   k   = math.max(1, n - 1)
    float pv  = isV ? math.sum(s * vol, k) : 0.0
    float vv  = isV ? math.sum(vol, k) : 0.0
    [m[1], m - maW0(t, n) * s, pv[1], vv[1], m]
 
calcMA(bool en, simple string t, simple int n, simple string tf, simple string srcName) =>
    string tfE      = tf == "" ? timeframe.period : tf
    int    chartSec = timeframe.in_seconds(timeframe.period)
    int    tfSec    = timeframe.in_seconds(tfE)
    bool   sameTf   = tfSec <= chartSec
    [vPrev, base, pvS, vS, vNow] = request.security(syminfo.tickerid, tfE, htfPack(t, n, srcName), lookahead = barmerge.lookahead_on)
    bool   chg      = timeframe.change(tfE)
    // sich entwickelnde HTF-Kerze aus Chart-Kerzen
    var float dO = na
    var float dH = na
    var float dL = na
    var float dV = 0.0
    if sameTf or chg or na(dO)
        dO := open
        dH := high
        dL := low
        dV := nz(volume)
    else
        dH := math.max(dH, high)
        dL := math.min(dL, low)
        dV += nz(volume)
    float sDev = srcOf(srcName, dO, dH, dL, close)
    float live = t == "VWMA" ? (pvS + sDev * dV) / (vS + dV) : base + maW0(t, n) * sDev
    // Fortschritt innerhalb der HTF-Kerze (0..1)
    int   tO   = time(tfE)
    int   tC   = time_close(tfE)
    float p    = sameTf or na(tO) or na(tC) or tC <= tO ? 1.0 : math.max(0.0, math.min(1.0, float(time_close - tO) / float(tC - tO)))
    // out = Plot-Wert, alt = durchgehender aktueller Wert (für Alerts)
    float out  = na
    float alt  = na
    if en and tfSec >= chartSec
        alt := live
        out := switch maMode
            // Ankerpunkt am Beginn jeder HTF-Kerze + letzte Kerze; plot.style_line verbindet die Punkte gerade
            "Smoothed (Interpolated)" => sameTf ? live : chg or barstate.islast ? vNow : na
            "Smoothed (No Repaint)"   => na(vPrev) ? live : vPrev + (live - vPrev) * p
            "Step"                    => p >= 1.0 ? live : vPrev
            => live
    [out, alt]
 
tfText(string tfIn) =>
    string tf  = tfIn == "" ? timeframe.period : tfIn
    int    len = str.length(tf)
    string u   = str.substring(tf, len - 1)
    string out = tf
    if u == "D" or u == "W" or u == "M" or u == "S"
        string num = len > 1 ? str.substring(tf, 0, len - 1) : "1"
        out := u == "S" ? num + "s" : num == "1" ? u : num + u
    else
        float mins = str.tonumber(tf)
        if not na(mins)
            out := mins % 60 == 0 ? str.tostring(mins / 60, "#") + "H" : str.tostring(mins, "#") + "m"
    out
 
maText(int idx, string t, int n, string tf) =>
    array<string> parts = array.new<string>()
    if lblNum
        parts.push("#" + str.tostring(idx))
    if lblLen
        parts.push(str.tostring(n))
    if lblTf
        parts.push(tfText(tf))
    if lblType
        parts.push(t)
    parts.join(" ")
 
maLabel(int idx, float v, color c, string t, int n, string tf) =>
    var label lb = na
    if barstate.islast
        label.delete(lb)
        string txt = maText(idx, t, n, tf)
        lb := na(v) or txt == "" ? na : label.new(bar_index + lblOff, v, txt, xloc = xloc.bar_index, color = color.new(color.black, 100), textcolor = c, style = label.style_label_left, size = lblSize)
    lb
 
tfLow(simple string tf) =>
    timeframe.in_seconds(tf == "" ? timeframe.period : tf) < timeframe.in_seconds(timeframe.period)
 
anchorTfOf(simple string a) =>
    switch a
        "Week"    => "W"
        "Month"   => "M"
        "Quarter" => "3M"
        "Year"    => "12M"
        => "D"
 
// ════════════════════════════════════════════════════════════════════════════════
//  HELPERS – Zonen
// ════════════════════════════════════════════════════════════════════════════════
zoneColor(color c, float fade) =>
    color.new(c, zTransp + (100 - zTransp) * math.max(0.0, math.min(1.0, fade)))
 
makeZone(bool bull, int leftTime, float top, float bot, color c, string txt) =>
    box b = box.new(left = leftTime, top = top, right = time, bottom = bot, xloc = xloc.bar_time, extend = extend.right, border_color = color.new(c, 100), border_width = 1, bgcolor = zoneColor(c, 0.0), text = txt, text_color = color.new(c, 25), text_size = size.tiny, text_halign = text.align_right, text_valign = text.align_center)
    Zone.new(b, top, bot, bull, bar_index, c)
 
pushZone(array<Zone> arr, Zone z, int maxN) =>
    arr.push(z)
    if arr.size() > maxN
        Zone old = arr.shift()
        box.delete(old.bx)
 
// Prüft Fills / Partial Fills / Expiry. Gibt die Anzahl neu gefüllter Zonen zurück.
processFills(array<Zone> act, array<box> fil, bool wick, bool partial, bool expOn, int expN, bool keepOn, int keepN) =>
    int filled = 0
    if act.size() > 0
        for i = act.size() - 1 to 0
            Zone z = act.get(i)
            if expOn and bar_index - z.born > expN
                box.delete(z.bx)
                act.remove(i)
            else
                float lo   = wick ? low : close
                float hi   = wick ? high : close
                bool  done = false
                if z.bull
                    if lo <= z.bot
                        done := true
                    else if partial and lo < z.top
                        z.top := lo
                        z.bx.set_top(lo)
                else
                    if hi >= z.top
                        done := true
                    else if partial and hi > z.bot
                        z.bot := hi
                        z.bx.set_bottom(hi)
                if done
                    filled += 1
                    act.remove(i)
                    if keepOn and keepN > 0
                        z.bx.set_right(time)
                        z.bx.set_extend(extend.none)
                        z.bx.set_bgcolor(zoneColor(z.col, zFilledFade / 100.0))
                        fil.push(z.bx)
                        if fil.size() > keepN
                            box.delete(fil.shift())
                    else
                        box.delete(z.bx)
    filled
 
fadeZones(array<Zone> act, float atrD) =>
    if act.size() > 0
        for z in act
            float dist = close > z.top ? close - z.top : close < z.bot ? z.bot - close : 0.0
            float f    = zFadeOn and not na(atrD) and atrD > 0 ? dist / (zFadeDist * atrD) : 0.0
            z.bx.set_bgcolor(zoneColor(z.col, f))
 
// Hält die Gesamtzahl der Boxen unter dem Pine-Limit (500).
enforceBudget() =>
    int total = gapAct.size() + gapFil.size() + fvgAct.size() + fvgFil.size() + iobAct.size() + sobAct.size()
    while total > 490
        if gapFil.size() + fvgFil.size() > 0
            if gapFil.size() >= fvgFil.size()
                box.delete(gapFil.shift())
            else
                box.delete(fvgFil.shift())
        else if gapAct.size() > 0 and gapAct.size() >= fvgAct.size()
            Zone zg = gapAct.shift()
            box.delete(zg.bx)
        else if fvgAct.size() > 0
            Zone zf = fvgAct.shift()
            box.delete(zf.bx)
        else
            break
        total -= 1
 
// ════════════════════════════════════════════════════════════════════════════════
//  MOVING AVERAGES
// ════════════════════════════════════════════════════════════════════════════════
[ma1, ma1A] = calcMA(maOn and m1On,  m1Type,  m1Len,  m1Tf,  m1Src)
[ma2, ma2A] = calcMA(maOn and m2On,  m2Type,  m2Len,  m2Tf,  m2Src)
[ma3, ma3A] = calcMA(maOn and m3On,  m3Type,  m3Len,  m3Tf,  m3Src)
[ma4, ma4A] = calcMA(maOn and m4On,  m4Type,  m4Len,  m4Tf,  m4Src)
[ma5, ma5A] = calcMA(maOn and m5On,  m5Type,  m5Len,  m5Tf,  m5Src)
[ma6, ma6A] = calcMA(maOn and m6On,  m6Type,  m6Len,  m6Tf,  m6Src)
[ma7, ma7A] = calcMA(maOn and m7On,  m7Type,  m7Len,  m7Tf,  m7Src)
[ma8, ma8A] = calcMA(maOn and m8On,  m8Type,  m8Len,  m8Tf,  m8Src)
[ma9, ma9A] = calcMA(maOn and m9On,  m9Type,  m9Len,  m9Tf,  m9Src)
[ma10, ma10A] = calcMA(maOn and m10On, m10Type, m10Len, m10Tf, m10Src)
[ma11, ma11A] = calcMA(maOn and m11On, m11Type, m11Len, m11Tf, m11Src)
[ma12, ma12A] = calcMA(maOn and m12On, m12Type, m12Len, m12Tf, m12Src)
[ma13, ma13A] = calcMA(maOn and m13On, m13Type, m13Len, m13Tf, m13Src)
[ma14, ma14A] = calcMA(maOn and m14On, m14Type, m14Len, m14Tf, m14Src)
[ma15, ma15A] = calcMA(maOn and m15On, m15Type, m15Len, m15Tf, m15Src)
[ma16, ma16A] = calcMA(maOn and m16On, m16Type, m16Len, m16Tf, m16Src)
[ma17, ma17A] = calcMA(maOn and m17On, m17Type, m17Len, m17Tf, m17Src)
[ma18, ma18A] = calcMA(maOn and m18On, m18Type, m18Len, m18Tf, m18Src)
[ma19, ma19A] = calcMA(maOn and m19On, m19Type, m19Len, m19Tf, m19Src)
[ma20, ma20A] = calcMA(maOn and m20On, m20Type, m20Len, m20Tf, m20Src)
 
plot(ma1,  "MA #1",  m1Col,  maLw, display = maOn and m1On  ? display.all : display.none)
plot(ma2,  "MA #2",  m2Col,  maLw, display = maOn and m2On  ? display.all : display.none)
plot(ma3,  "MA #3",  m3Col,  maLw, display = maOn and m3On  ? display.all : display.none)
plot(ma4,  "MA #4",  m4Col,  maLw, display = maOn and m4On  ? display.all : display.none)
plot(ma5,  "MA #5",  m5Col,  maLw, display = maOn and m5On  ? display.all : display.none)
plot(ma6,  "MA #6",  m6Col,  maLw, display = maOn and m6On  ? display.all : display.none)
plot(ma7,  "MA #7",  m7Col,  maLw, display = maOn and m7On  ? display.all : display.none)
plot(ma8,  "MA #8",  m8Col,  maLw, display = maOn and m8On  ? display.all : display.none)
plot(ma9,  "MA #9",  m9Col,  maLw, display = maOn and m9On  ? display.all : display.none)
plot(ma10, "MA #10", m10Col, maLw, display = maOn and m10On ? display.all : display.none)
plot(ma11, "MA #11", m11Col, maLw, display = maOn and m11On ? display.all : display.none)
plot(ma12, "MA #12", m12Col, maLw, display = maOn and m12On ? display.all : display.none)
plot(ma13, "MA #13", m13Col, maLw, display = maOn and m13On ? display.all : display.none)
plot(ma14, "MA #14", m14Col, maLw, display = maOn and m14On ? display.all : display.none)
plot(ma15, "MA #15", m15Col, maLw, display = maOn and m15On ? display.all : display.none)
plot(ma16, "MA #16", m16Col, maLw, display = maOn and m16On ? display.all : display.none)
plot(ma17, "MA #17", m17Col, maLw, display = maOn and m17On ? display.all : display.none)
plot(ma18, "MA #18", m18Col, maLw, display = maOn and m18On ? display.all : display.none)
plot(ma19, "MA #19", m19Col, maLw, display = maOn and m19On ? display.all : display.none)
plot(ma20, "MA #20", m20Col, maLw, display = maOn and m20On ? display.all : display.none)
 
maLabel(1,  ma1,  m1Col,  m1Type,  m1Len,  m1Tf)
maLabel(2,  ma2,  m2Col,  m2Type,  m2Len,  m2Tf)
maLabel(3,  ma3,  m3Col,  m3Type,  m3Len,  m3Tf)
maLabel(4,  ma4,  m4Col,  m4Type,  m4Len,  m4Tf)
maLabel(5,  ma5,  m5Col,  m5Type,  m5Len,  m5Tf)
maLabel(6,  ma6,  m6Col,  m6Type,  m6Len,  m6Tf)
maLabel(7,  ma7,  m7Col,  m7Type,  m7Len,  m7Tf)
maLabel(8,  ma8,  m8Col,  m8Type,  m8Len,  m8Tf)
maLabel(9,  ma9,  m9Col,  m9Type,  m9Len,  m9Tf)
maLabel(10, ma10, m10Col, m10Type, m10Len, m10Tf)
maLabel(11, ma11, m11Col, m11Type, m11Len, m11Tf)
maLabel(12, ma12, m12Col, m12Type, m12Len, m12Tf)
maLabel(13, ma13, m13Col, m13Type, m13Len, m13Tf)
maLabel(14, ma14, m14Col, m14Type, m14Len, m14Tf)
maLabel(15, ma15, m15Col, m15Type, m15Len, m15Tf)
maLabel(16, ma16, m16Col, m16Type, m16Len, m16Tf)
maLabel(17, ma17, m17Col, m17Type, m17Len, m17Tf)
maLabel(18, ma18, m18Col, m18Type, m18Len, m18Tf)
maLabel(19, ma19, m19Col, m19Type, m19Len, m19Tf)
maLabel(20, ma20, m20Col, m20Type, m20Len, m20Tf)
 
var array<string> maTypeArr = array.from(m1Type, m2Type, m3Type, m4Type, m5Type, m6Type, m7Type, m8Type, m9Type, m10Type, m11Type, m12Type, m13Type, m14Type, m15Type, m16Type, m17Type, m18Type, m19Type, m20Type)
var array<int>    maLenArr  = array.from(m1Len, m2Len, m3Len, m4Len, m5Len, m6Len, m7Len, m8Len, m9Len, m10Len, m11Len, m12Len, m13Len, m14Len, m15Len, m16Len, m17Len, m18Len, m19Len, m20Len)
var array<string> maTfArr   = array.from(m1Tf, m2Tf, m3Tf, m4Tf, m5Tf, m6Tf, m7Tf, m8Tf, m9Tf, m10Tf, m11Tf, m12Tf, m13Tf, m14Tf, m15Tf, m16Tf, m17Tf, m18Tf, m19Tf, m20Tf)
var array<bool>   maLowArr  = array.from(maOn and m1On and tfLow(m1Tf), maOn and m2On and tfLow(m2Tf), maOn and m3On and tfLow(m3Tf), maOn and m4On and tfLow(m4Tf), maOn and m5On and tfLow(m5Tf), maOn and m6On and tfLow(m6Tf), maOn and m7On and tfLow(m7Tf), maOn and m8On and tfLow(m8Tf), maOn and m9On and tfLow(m9Tf), maOn and m10On and tfLow(m10Tf), maOn and m11On and tfLow(m11Tf), maOn and m12On and tfLow(m12Tf), maOn and m13On and tfLow(m13Tf), maOn and m14On and tfLow(m14Tf), maOn and m15On and tfLow(m15Tf), maOn and m16On and tfLow(m16Tf), maOn and m17On and tfLow(m17Tf), maOn and m18On and tfLow(m18Tf), maOn and m19On and tfLow(m19Tf), maOn and m20On and tfLow(m20Tf))
 
// ════════════════════════════════════════════════════════════════════════════════
//  BOLLINGER BANDS
// ════════════════════════════════════════════════════════════════════════════════
bbCalc(simple string srcName, simple int n, simple float mult) =>
    float s = srcOf(srcName, open, high, low, close)
    float b = ta.sma(s, n)
    float d = mult * ta.stdev(s, n)
    [b, b + d, b - d]
 
string bbTfE = bbTf == "" ? timeframe.period : bbTf
[bbB, bbU, bbL] = request.security(syminfo.tickerid, bbTfE, bbCalc(bbSrc, bbLen, bbMult))
bool bbShow = bbOn and not tfLow(bbTfE)
pBbU = plot(bbShow ? bbU : na, "Bollinger Upper", bbBandCol, 1, display = bbOn ? display.all : display.none)
pBbL = plot(bbShow ? bbL : na, "Bollinger Lower", bbBandCol, 1, display = bbOn ? display.all : display.none)
plot(bbShow ? bbB : na, "Bollinger Basis", bbBaseCol, 1, display = bbOn ? display.all : display.none)
fill(pBbU, pBbL, color.new(bbBandCol, bbFillT), "Bollinger Fill", display = bbOn ? display.all : display.none)
 
// ════════════════════════════════════════════════════════════════════════════════
//  VWAP
// ════════════════════════════════════════════════════════════════════════════════
float barVol = nz(volume) > 0 ? volume : 1.0
 
string vwTf    = anchorTfOf(vwAnchor)
bool   vwReset = timeframe.change(vwTf)
var float vwPV = 0.0
var float vwV  = 0.0
if vwReset
    vwPV := 0.0
    vwV  := 0.0
vwPV += hlc3 * barVol
vwV  += barVol
float vwapVal = vwPV / vwV
bool  vwBreak = vwReset and timeframe.in_seconds(vwTf) > chartSecG
plot(vwOn ? vwapVal : na, "VWAP", vwBreak ? color.new(vwCol, 100) : vwCol, vwLw, display = vwOn ? display.all : display.none)
 
// ════════════════════════════════════════════════════════════════════════════════
//  10xVWAP (auto-anchored)
// ════════════════════════════════════════════════════════════════════════════════
var float xvCumPV = 0.0
var float xvCumV  = 0.0
xvCumPV += hlc3 * barVol
xvCumV  += barVol
max_bars_back(xvCumPV, 500)
max_bars_back(xvCumV, 500)
 
float  xvPH  = ta.pivothigh(high, xvLen, xvLen)
float  xvPL  = ta.pivotlow(low, xvLen, xvLen)
string xvTf  = anchorTfOf(xvAnchor)
bool   xvChg = timeframe.change(xvTf)
 
var float xvAPV = 0.0
var float xvAV  = 0.0
var array<chart.point> xvBack = array.new<chart.point>()
bool xvNew = false
if xvAnchor == "Auto Swing"
    if not na(xvPH) or not na(xvPL)
        xvAPV := nz(xvCumPV[xvLen + 1])
        xvAV  := nz(xvCumV[xvLen + 1])
        xvNew := true
        xvBack.clear()
        for i = xvLen to 0
            float pv = xvCumPV[i] - xvAPV
            float vv = xvCumV[i] - xvAV
            if vv > 0
                xvBack.push(chart.point.from_index(bar_index - i, pv / vv))
else if xvChg
    xvAPV := nz(xvCumPV[1])
    xvAV  := nz(xvCumV[1])
    xvNew := timeframe.in_seconds(xvTf) > chartSecG
    xvBack.clear()
 
float xvVal = xvCumV - xvAV > 0 ? (xvCumPV - xvAPV) / (xvCumV - xvAV) : na
plot(xvOn ? xvVal : na, "10xVWAP", xvNew ? color.new(xvCol, 100) : xvCol, xvLw, display = xvOn ? display.all : display.none)
 
// Rückwirkendes Segment vom Swing-Anker bis zur Bestätigung
var polyline xvPoly = na
if barstate.islast
    polyline.delete(xvPoly)
    xvPoly := xvOn and xvBack.size() > 1 ? polyline.new(xvBack, curved = false, closed = false, xloc = xloc.bar_index, line_color = xvCol, line_width = xvLw) : na
 
// ════════════════════════════════════════════════════════════════════════════════
//  DAILY GAPS
// ════════════════════════════════════════════════════════════════════════════════
string gapTfE = gapTf == "" ? timeframe.period : gapTf
int    gapSec = timeframe.in_seconds(gapTfE)
[gO, gPC, gAR] = request.security(syminfo.tickerid, gapTfE, [open, close[1], ta.sma(high - low, gapLen)[1]], lookahead = barmerge.lookahead_on)
bool   gapChg    = timeframe.change(gapTfE)
bool   gapNewBar = gapSec == chartSecG or gapChg
 
bool newGapUp = false
bool newGapDn = false
if gapOn and gapSec >= chartSecG and gapNewBar and not na(gPC) and not na(gAR) and not na(time[1])
    float gThr = gapMinDev / 100.0 * gAR
    float gSz  = gO - gPC
    if gSz > 0 and gSz >= gThr
        pushZone(gapAct, makeZone(true, time[1], gO, gPC, gapUpCol, zLblGap ? "Gap ↑" : ""), gapMax)
        newGapUp := true
    else if gSz < 0 and -gSz >= gThr
        pushZone(gapAct, makeZone(false, time[1], gPC, gO, gapDnCol, zLblGap ? "Gap ↓" : ""), gapMax)
        newGapDn := true
int gapFilledN = gapOn ? processFills(gapAct, gapFil, gapFill == "Wick", gapPartial, gapExpOn, gapExp, gapKeepOn, gapKeep) : 0
 
// ════════════════════════════════════════════════════════════════════════════════
//  FAIR VALUE GAPS
// ════════════════════════════════════════════════════════════════════════════════
string fvgTfE = fvgTf == "" ? timeframe.period : fvgTf
int    fvgSec = timeframe.in_seconds(fvgTfE)
// Nur abgeschlossene Kerzen: [1] = Kerze 3, [2] = Kerze 2, [3] = Kerze 1
[fH1, fL1, fC2, fH3, fL3, fT3, fAR] = request.security(syminfo.tickerid, fvgTfE, [high[1], low[1], close[2], high[3], low[3], time[3], ta.sma((high - low) / low, fvgAutoLen)[1]], lookahead = barmerge.lookahead_on)
bool   fvgChg    = timeframe.change(fvgTfE)
bool   fvgNewBar = fvgSec == chartSecG or fvgChg
float  fvgThr    = fvgAuto ? fAR : fvgManual / 100.0
 
bool newFvgBull = false
bool newFvgBear = false
if fvgOn and fvgSec >= chartSecG and fvgNewBar and not na(fH3) and not na(fL3) and not na(fT3) and not na(fvgThr)
    if fL1 > fH3 and fC2 > fH3 and (fL1 - fH3) / fH3 > fvgThr
        pushZone(fvgAct, makeZone(true, fT3, fL1, fH3, fvgBullCol, zLblFvg ? "FVG ↑" : ""), fvgMax)
        newFvgBull := true
    else if fH1 < fL3 and fC2 < fL3 and (fL3 - fH1) / fH1 > fvgThr
        pushZone(fvgAct, makeZone(false, fT3, fL3, fH1, fvgBearCol, zLblFvg ? "FVG ↓" : ""), fvgMax)
        newFvgBear := true
int fvgFilledN = fvgOn ? processFills(fvgAct, fvgFil, fvgFill == "Wick", fvgPartial, fvgExpOn, fvgExp, fvgKeepOn, fvgKeep) : 0
 
// ════════════════════════════════════════════════════════════════════════════════
//  ORDER BLOCKS
// ════════════════════════════════════════════════════════════════════════════════
var array<float> obH  = array.new<float>()
var array<float> obL  = array.new<float>()
var array<float> obO  = array.new<float>()
var array<float> obC  = array.new<float>()
var array<int>   obT  = array.new<int>()
var array<bool>  obHV = array.new<bool>()
 
float obAtr    = ta.atr(obVolLen)
float obCumRng = ta.cum(high - low) / (bar_index + 1)
float obVolRef = obVolMode == "ATR" ? obAtr : obVolMode == "Range" ? obCumRng : na
bool  obIsHV   = not na(obVolRef) and high - low >= obVolMult * obVolRef
 
obH.push(high)
obL.push(low)
obO.push(open)
obC.push(close)
obT.push(time)
obHV.push(obIsHV)
if obH.size() > obMaxSearch + 5
    obH.shift()
    obL.shift()
    obO.shift()
    obC.shift()
    obT.shift()
    obHV.shift()
 
// Leg-Erkennung: 0 = bearish Leg (Pivot-Hoch entstanden), 1 = bullish Leg (Pivot-Tief entstanden)
obLeg(simple int size) =>
    var int lg = 0
    bool nh = high[size] > ta.highest(size)
    bool nl = low[size] < ta.lowest(size)
    if nh
        lg := 0
    else if nl
        lg := 1
    lg
 
isOpp(bool bull, int idx) =>
    bull ? obC.get(idx) < obO.get(idx) : obC.get(idx) > obO.get(idx)
 
buildOB(bool bull, int pivBar, bool swing) =>
    Zone z = na
    int  n = obH.size()
    if n > 1 and not na(pivBar)
        int lo = obAllowBrk ? 0 : 1
        int hi = math.min(bar_index - pivBar, math.min(obMaxSearch, n - 1))
        if hi >= lo
            int best = -1
            if obAnchor == "Last Opposite"
                for off = lo to hi
                    int idx = n - 1 - off
                    if isOpp(bull, idx)
                        best := idx
                        break
            if best < 0
                float bestV = na
                for pass = 0 to 1
                    if best < 0 and (pass == 1 or obPrefOpp)
                        for off = lo to hi
                            int idx = n - 1 - off
                            if pass == 1 or isOpp(bull, idx)
                                float v = bull ? obL.get(idx) : obH.get(idx)
                                if na(bestV) or (bull ? v <= bestV : v >= bestV)
                                    bestV := v
                                    best  := idx
            if best >= 0
                float h    = obH.get(best)
                float l    = obL.get(best)
                float bTop = math.max(obO.get(best), obC.get(best))
                float bBot = math.min(obO.get(best), obC.get(best))
                string mode = obHV.get(best) ? "Body" : obBounds
                float top  = mode == "Wick" ? h : mode == "Body" ? bTop : bull ? bTop : h
                float bot  = mode == "Wick" ? l : mode == "Body" ? bBot : bull ? l : bBot
                if top - bot <= 0
                    top := h
                    bot := l
                color  col = swing ? (bull ? obSBull : obSBear) : (bull ? obIBull : obIBear)
                string txt = zLblOb ? (swing ? "sOB" : "iOB") : ""
                z := makeZone(bull, obT.get(best), top, bot, col, txt)
    z
 
invalidateOBs(array<Zone> act) =>
    int cnt = 0
    if act.size() > 0
        for i = act.size() - 1 to 0
            Zone  z  = act.get(i)
            float lo = obInval == "Close" ? close : low
            float hi = obInval == "Close" ? close : high
            if (z.bull and lo < z.bot) or (not z.bull and hi > z.top)
                box.delete(z.bx)
                act.remove(i)
                cnt += 1
    cnt
 
int iLeg    = obLeg(obIntLen)
int sLeg    = obLeg(obSwLen)
int iLegChg = nz(ta.change(iLeg))
int sLegChg = nz(ta.change(sLeg))
 
var Piv iHi = Piv.new()
var Piv iLo = Piv.new()
var Piv sHi = Piv.new()
var Piv sLo = Piv.new()
 
if iLegChg == -1
    iHi.level   := high[obIntLen]
    iHi.bar     := bar_index - obIntLen
    iHi.crossed := false
if iLegChg == 1
    iLo.level   := low[obIntLen]
    iLo.bar     := bar_index - obIntLen
    iLo.crossed := false
if sLegChg == -1
    sHi.level   := high[obSwLen]
    sHi.bar     := bar_index - obSwLen
    sHi.crossed := false
if sLegChg == 1
    sLo.level   := low[obSwLen]
    sLo.bar     := bar_index - obSwLen
    sLo.crossed := false
 
int obInvalN = invalidateOBs(iobAct) + invalidateOBs(sobAct)
 
float obBullMeas = obBreak == "Close" ? close : high
float obBearMeas = obBreak == "Close" ? close : low
bool  obNewBull  = false
bool  obNewBear  = false
 
// Internal Structure
if not iHi.crossed and not na(iHi.level) and obBullMeas > iHi.level and (na(sHi.level) or iHi.level != sHi.level)
    iHi.crossed := true
    if obIntOn
        Zone z = buildOB(true, iHi.bar, false)
        if not na(z)
            pushZone(iobAct, z, obIntMax)
            obNewBull := true
if not iLo.crossed and not na(iLo.level) and obBearMeas < iLo.level and (na(sLo.level) or iLo.level != sLo.level)
    iLo.crossed := true
    if obIntOn
        Zone z = buildOB(false, iLo.bar, false)
        if not na(z)
            pushZone(iobAct, z, obIntMax)
            obNewBear := true
// Swing Structure
if not sHi.crossed and not na(sHi.level) and obBullMeas > sHi.level
    sHi.crossed := true
    if obSwOn
        Zone z = buildOB(true, sHi.bar, true)
        if not na(z)
            pushZone(sobAct, z, obSwMax)
            obNewBull := true
if not sLo.crossed and not na(sLo.level) and obBearMeas < sLo.level
    sLo.crossed := true
    if obSwOn
        Zone z = buildOB(false, sLo.bar, true)
        if not na(z)
            pushZone(sobAct, z, obSwMax)
            obNewBear := true
 
// ════════════════════════════════════════════════════════════════════════════════
//  ZONE-FADE & BOX-BUDGET
// ════════════════════════════════════════════════════════════════════════════════
float dAtr = request.security(syminfo.tickerid, "D", ta.atr(14))
 
enforceBudget()
if barstate.islast
    fadeZones(gapAct, dAtr)
    fadeZones(fvgAct, dAtr)
    fadeZones(iobAct, dAtr)
    fadeZones(sobAct, dAtr)
 
// ════════════════════════════════════════════════════════════════════════════════
//  ALERTS
// ════════════════════════════════════════════════════════════════════════════════
string closeFreq = confOnly ? alert.freq_once_per_bar_close : alert.freq_once_per_bar
bool   closeGate = not confOnly or barstate.isconfirmed
 
array<float> maNow = array.from(ma1A, ma2A, ma3A, ma4A, ma5A, ma6A, ma7A, ma8A, ma9A, ma10A, ma11A, ma12A, ma13A, ma14A, ma15A, ma16A, ma17A, ma18A, ma19A, ma20A)
array<float> maPrv = array.from(ma1A[1], ma2A[1], ma3A[1], ma4A[1], ma5A[1], ma6A[1], ma7A[1], ma8A[1], ma9A[1], ma10A[1], ma11A[1], ma12A[1], ma13A[1], ma14A[1], ma15A[1], ma16A[1], ma17A[1], ma18A[1], ma19A[1], ma20A[1])
 
bool   anyUp    = false
bool   anyDn    = false
string crossMsg = ""
for i = 0 to 19
    float v  = maNow.get(i)
    float vp = maPrv.get(i)
    if not na(v) and not na(vp)
        bool up = close > v and close[1] <= vp
        bool dn = close < v and close[1] >= vp
        if up or dn
            anyUp := anyUp or up
            anyDn := anyDn or dn
            if barstate.isrealtime
                crossMsg += (crossMsg == "" ? "" : " | ") + (up ? "↑ über " : "↓ unter ") + maText(i + 1, maTypeArr.get(i), maLenArr.get(i), maTfArr.get(i)) + " (" + str.tostring(v, format.mintick) + ")"
anyUp := anyUp and closeGate
anyDn := anyDn and closeGate
 
bool gapNew = newGapUp or newGapDn
bool fvgNew = newFvgBull or newFvgBear
bool obNew  = obNewBull or obNewBear
 
if alertsOn and barstate.isrealtime
    if crossMsg != "" and closeGate
        alert(syminfo.ticker + ": Close " + crossMsg, closeFreq)
    if gapNew
        alert(syminfo.ticker + ": Neues Gap " + (newGapUp ? "↑" : "↓"), alert.freq_once_per_bar)
    if gapFilledN > 0
        alert(syminfo.ticker + ": Gap gefüllt", gapFill == "Close" ? closeFreq : alert.freq_once_per_bar)
    if fvgNew
        alert(syminfo.ticker + ": Neues FVG " + (newFvgBull ? "↑" : "↓"), alert.freq_once_per_bar)
    if fvgFilledN > 0
        alert(syminfo.ticker + ": FVG gefüllt", fvgFill == "Close" ? closeFreq : alert.freq_once_per_bar)
    if obNew
        alert(syminfo.ticker + ": Neuer Order Block " + (obNewBull ? "↑" : "↓"), obBreak == "Close" ? closeFreq : alert.freq_once_per_bar)
    if obInvalN > 0
        alert(syminfo.ticker + ": Order Block invalidiert", obInval == "Close" ? closeFreq : alert.freq_once_per_bar)
 
alertcondition(alertsOn and anyUp, "MA Cross Up", "{{ticker}}: Close kreuzt über einen MA ({{close}})")
alertcondition(alertsOn and anyDn, "MA Cross Down", "{{ticker}}: Close kreuzt unter einen MA ({{close}})")
alertcondition(alertsOn and gapNew, "New Gap", "{{ticker}}: Neues Gap")
alertcondition(alertsOn and gapFilledN > 0, "Gap Filled", "{{ticker}}: Gap gefüllt")
alertcondition(alertsOn and fvgNew, "New FVG", "{{ticker}}: Neues Fair Value Gap")
alertcondition(alertsOn and fvgFilledN > 0, "FVG Filled", "{{ticker}}: FVG gefüllt")
alertcondition(alertsOn and obNew, "New Order Block", "{{ticker}}: Neuer Order Block")
alertcondition(alertsOn and obInvalN > 0, "Order Block Invalidated", "{{ticker}}: Order Block invalidiert")
 
// ════════════════════════════════════════════════════════════════════════════════
//  TF WARNING PANEL
// ════════════════════════════════════════════════════════════════════════════════
var table warnTbl = table.new(position.bottom_right, 1, 26, bgcolor = color.new(#131722, 5), frame_color = color.new(#787B86, 40), frame_width = 1)
if barstate.islast
    table.clear(warnTbl, 0, 0, 0, 25)
    if showWarn
        int row = 0
        table.cell(warnTbl, 0, row, "TF-Check · Chart " + tfText(""), text_color = #FF9800, text_size = size.small, text_halign = text.align_left)
        row += 1
        for i = 0 to 19
            if maLowArr.get(i)
                table.cell(warnTbl, 0, row, "MA #" + str.tostring(i + 1) + " (" + tfText(maTfArr.get(i)) + ") < Chart-TF: ausgeblendet", text_color = #B2B5BE, text_size = size.small, text_halign = text.align_left)
                row += 1
        if gapOn and gapSec < chartSecG
            table.cell(warnTbl, 0, row, "Daily Gaps (" + tfText(gapTfE) + ") < Chart-TF: deaktiviert", text_color = #B2B5BE, text_size = size.small, text_halign = text.align_left)
            row += 1
        if fvgOn and fvgSec < chartSecG
            table.cell(warnTbl, 0, row, "FVGs (" + tfText(fvgTfE) + ") < Chart-TF: deaktiviert", text_color = #B2B5BE, text_size = size.small, text_halign = text.align_left)
            row += 1
        if bbOn and tfLow(bbTfE)
            table.cell(warnTbl, 0, row, "Bollinger (" + tfText(bbTfE) + ") < Chart-TF: ausgeblendet", text_color = #B2B5BE, text_size = size.small, text_halign = text.align_left)
            row += 1
        if row == 1
            table.cell(warnTbl, 0, row, "Alle Zeitrahmen OK", text_color = #4CAF50, text_size = size.small, text_halign = text.align_left)

← 返回列表