Fast Tape V6 For ThinkOrSwim

[atcsam]

SPY 2min EOD

Fast Tape V6 - The old ticker tape printed trades on a strip of paper. Traders watched it like pilots listening to engine noise, trying to tell whether the market was accelerating or stalling. Fast forward. We’re not reading paper anymore — we’re reading volatility normalized microstructure. No guessing. Just measurement. Fast Tape acts as a flight data recorder for intraday volatility. It tracks:

• tape speed

• price velocity

• volume acceleration

• pressure slope

• spread behavior

… and normalizes all of it against the volatility regime so you can separate signal from noise. It was built for fast charts — the modern ticker tape — but it ended up working on every timeframe. Normalize price against volatility, and a 1 minute bar reads the same as a daily candle. What started as a speed tool became a structural framework.

Chart Link https://tos.mx/!CIKkvQsh

The Fast Tape label strip is designed to read from left to right, moving from macro → micro → narrative → traps → volatility state. Each block answers a different question about what the market is doing right now. Below is the intended reading order and how to interpret each section.

1. Environment (Macro Weather): Question: What kind of market are we in? This is the first thing you read. It tells you the intraday environment the tape is operating inside.

• BLOWOFF → chaotic expansion​

​

• PROBLEM → abnormal behavior​

​

• COLLAPSE → no participation​

​

• EXPANSION → healthy volatility​

​

• COMPRESSION → coiled conditions​

​

• CHOP → two way noise This block sets the context for everything that follows.​

1. Tape State (Participation Level): Question: Who is active? How many players are in the room? This block measures participation intensity, not direction.

• CLIMAX → extreme volume​

​

• ACTIVE → above normal volume​

​

• NORMAL → typical participation This tells you whether the market is being driven by real players or just drifting.​

1. Speed Block (Tempo Cluster): Question: How fast is the market moving? This is the heartbeat of the tape. It measures velocity across three dimensions:

• Tape speed → accelerating, decelerating, or stable​

​

• Price speed → rising, falling, or stable​

​

• Volume speed → surging, fading, or normal Additional signals:​

​

• SPIKE → sudden acceleration​

​

• BULL DIV / BEAR DIV → divergence between tape and price This block tells you whether the market is pressing, stalling, or coiling.​

1. Narrative Block (Trend + Pressure + Spread): Question: What is the story of this bar? This block explains the current bar’s internal narrative.

• Trend strength (Strong Bull → Strong Bear)​

​

• Pressure slope (Rising, Fading, Stable)​

​

• Spread behavior (Up, Down, Neutral)​

​

• Curvature (Peak, Exhaust)​

​

• Tape Collapse (velocity failure)​

​

• Momentum Warnings (bull or bear fading) This is where you understand intent — who is trying to take control.​

1. Trap Block: Question: Is someone getting trapped? This block identifies:

• micro traps​

​

• standard traps​

​

• climax traps​

​

• divergence traps​

​

• trap setups​

​

• trap failures (polarity flips) Traps reveal where traders are wrong, which is often where the best trades come from.​

1. Spike State Block: Question: Is volatility behaving normally? This block classifies volatility behavior:

• CHOP → noisy, directionless​

​

• PROBLEM → abnormal volatility​

​

• COLLAPSE → no participation​

​

• SPIKE → volatility burst​

​

• X SPIKE → extreme burst​

​

• WARN → early warning This tells you whether the market is stable, unstable, or about to move.​

1. Reversals: Question: Did the bar produce a reversal?

• REV↑ → bullish reversal​

​

• REV↓ → bearish reversal These are bar level turning points confirmed by pressure.​

1. Regime Slope Histogram (Plot Off by Default): Question: What is the macro trend slope? This is the only part of the system that looks beyond the current bar. It measures the slope of the macro regime using RMS normalization.

• Strong positive → bullish regime​

​

• Strong negative → bearish regime​

​

• Neutral → no macro trend This gives you the bigger picture behind the microstructure.​

Summary:
(How to Read the Strip in Real Time)

- Environment → What kind of day is this?​

​

- Tape State → Who’s active?​

​

- Speed Block → How fast is the tape moving?​

​

- Narrative Block → What’s the story of this bar?​

​

- Trap Block → Who’s getting trapped?​

​

- Spike State → Is volatility normal or unstable?​

​

- Reversals → Did the bar flip direction?​

​

- Regime Slope → What’s the macro backdrop?​

​

Read it in that order and the entire market becomes a coherent narrative instead of noise.​

Fast Tape V6 turns intraday movement into a readable, structured narrative. Instead of reacting to noise, it breaks the market into clear components: environment, participation, speed, trend, pressure, traps, volatility state, and macro regime slope. Each block answers a different question about what the market is doing right now, and together they form a complete picture of microstructure in motion.



Note On Traps:

How Fast Tape Trap Detection Differs From (and Complements) the Climax Detector w/ Traps

Fast Tape and the Climax Detector both identify traps, but they operate on different layers of market behavior, which is why they work so well together.

Fast Tape detects behavioral traps. It reads the tape itself — speed, divergence, pressure slope, spread behavior, micro‑momentum, and participation intensity. Fast Tape traps fire when the behavior of the move breaks, even if the structure hasn’t broken yet. These are flow‑based traps.

The Climax Detector detects structural traps. It reads macro‑micro structure — climaxes, exhaustion, imbalance, pressure flips, wick symmetry, pattern clusters, and structural failure conditions. Climax traps fire when the structure of the move breaks, even if the tape is still behaving normally. These are structure‑based traps.

Together: Fast Tape shows how the trap is forming (behavior). Climax Detector shows where the trap is forming (structure). When both agree, you get a high‑authority trap with both structural failure and behavioral failure aligned.

Study Link:
Fast_Tape_V6

#####################
# V6 FAST TAPE
#####################
# atcsam 04/23/26
# Playing it forward
# Real Credit: thinkScript community

declare lower;

# ============================
# INPUTS
# ============================
input slopeLookback = 8;
input accelLookback = 5;
input divLookback   = 20;
input rVolThreshold = 1.2;
input spikeLength   = 20;

# ============================
# VOLATILITY MODEL
# ============================
def tr    = TrueRange(high, close, low);
def atr5  = Average(tr, 5);
def atr20 = Average(tr, 20);
def atr50 = Average(tr, 50);

def volRatio = atr5 / atr50;
def w = Min(1, Max(0, volRatio));

# ============================
# VOLUME MODEL
# ============================
def avgVol = Average(volume, 20);
def rVol   = if avgVol != 0 then volume / avgVol else 0;
def isSignificant = rVol > rVolThreshold;

def avgVol3 = (Average(volume, 20) + Average(volume[1], 20) + Average(volume[2], 20));
def sumVol3 = (volume + volume[1] + volume[2]);
def isClimaxVol = avgVol3 != 0 and sumVol3 > (avgVol3 * 1.5);

# ============================
# ADAPTIVE NORMALIZED PRESSURE (ANP)
# ============================
def ret5  = close - close[5];
def ret10 = close - close[10];
def ret20 = close - close[20];
def ret40 = close - close[40];

def swingFast  = if Average(tr, 5)  != 0 then ret5  / Average(tr, 5)  else 0;
def swingMed   = if Average(tr, 10) != 0 then ret10 / Average(tr, 10) else 0;
def regimeFast = if Average(tr, 20) != 0 then ret20 / Average(tr, 20) else 0;
def regimeMed  = if Average(tr, 40) != 0 then ret40 / Average(tr, 40) else 0;

def swingANP  = w * swingFast  + (1 - w) * swingMed;
def regimeANP = w * regimeFast + (1 - w) * regimeMed;

# ============================
# MOMENTUM / SPREAD
# ============================
def pressureSpread = swingANP - regimeANP;

def swingSlope  = swingANP  - swingANP[slopeLookback];
def slopeRising = swingSlope > 0;
def slopeFading = swingSlope < 0;

def swingSlopePrev = swingSlope[1];
def slopeChange = swingSlope - swingSlopePrev;

def curvatureDown = slopeChange < 0 and swingANP > 1;
def curvatureUp   = slopeChange > 0 and swingANP < -1;

# Exhaustion v2
def exhaustUp   = swingANP > 1 and swingANP[1] > 1 and swingANP < swingANP[1];
def exhaustDown = swingANP < -1 and swingANP[1] < -1 and swingANP > swingANP[1];

# Acceleration
def swingAccel = swingANP - swingANP[accelLookback];
def accelUp    = swingAccel > 0;
def accelDown  = swingAccel < 0;

# Spread bias
def spreadBullBias = swingANP > 1 and regimeANP > 0.5;
def spreadBearBias = swingANP < -1 and regimeANP < -0.5;

def spreadStrongUp =
    pressureSpread > 1.5 or
    (pressureSpread > 0.5 and spreadBullBias);

def spreadStrongDown =
    pressureSpread < -1.5 or
    (pressureSpread < -0.5 and spreadBearBias);

# Pressure flips (raw)
def pressureFlipUp   = pressureSpread > 0 and pressureSpread[1] <= 0;
def pressureFlipDown = pressureSpread < 0 and pressureSpread[1] >= 0;

# ============================
# TAPE DIRECTION MEMORY (NEW)
# ============================
# Raw tape direction from spread
def TapeDirRaw =
    if pressureSpread > 0 then 1
    else if pressureSpread < 0 then -1
    else 0;

rec tapeDirMem =
    if TapeDirRaw != 0 then TapeDirRaw
    else if IsNaN(tapeDirMem[1]) then 0
    else tapeDirMem[1];

# Memory‑aware flips (optional use later if desired)
def pressureFlipUpMem   = tapeDirMem == 1 and tapeDirMem[1] <= 0;
def pressureFlipDownMem = tapeDirMem == -1 and tapeDirMem[1] >= 0;


# ============================
# MICRO STRUCTURE (HL/LH)
# ============================
def microHL = low > low[1] and low[1] < low[2];
def microLH = high < high[1] and high[1] > high[2];

# ============================
# TAPE SPEED
# ============================
def priceSpeed = if tr != 0 then AbsValue(close - close[1]) / tr else 0;
def priceSpeedUp = priceSpeed > priceSpeed[1];
def priceSpeedDown = priceSpeed < priceSpeed[1];

def volSpeed = if avgVol != 0 then volume / avgVol else 0;
def volSpeedUp = volSpeed > volSpeed[1];
def volSpeedDown = volSpeed < volSpeed[1];

def tapeSpeed = (priceSpeed + volSpeed) / 2;
def tapeSpeedUp = tapeSpeed > tapeSpeed[1];
def tapeSpeedDown = tapeSpeed < tapeSpeed[1];

def tapeSpike = tapeSpeed > Highest(tapeSpeed[1], 10) * 1.5;

def tapeSpeedSeverity =
    (if tapeSpike then 3 else 0) +
    (if tapeSpeedUp then 1 else 0) +
    (if volSpeedUp then 1 else 0);

def tapeSpeedBearDiv =
    priceSpeedUp and volSpeedDown and swingANP > 1;

def tapeSpeedBullDiv =
    priceSpeedDown and volSpeedUp and swingANP < -1;

# ============================
# TAPE COLLAPSE DETECTOR (NEW)
# ============================
def tapeCollapse =
    slopeFading and
    tapeSpeedDown and
    volSpeedDown and
    AbsValue(pressureSpread) < AbsValue(pressureSpread[1]);

# ============================
# STRUCTURE / DIVERGENCE
# ============================
def priceHigh = high == Highest(high, divLookback);
def priceLow  = low == Lowest(low, divLookback);

def structuralHigh = priceHigh and swingANP > 1;
def structuralLow  = priceLow  and swingANP < -1;

def bearDiv =
    structuralHigh and
    swingANP < Highest(swingANP[1], divLookback) and
    exhaustUp and
    accelDown;

def bullDiv =
    structuralLow and
    swingANP > Lowest(swingANP[1], divLookback) and
    exhaustDown and
    accelUp;

# ============================
# TRAP WINDOW
# ============================
def trapWindow = BarNumber() - BarNumber()[1] < 3;

# ============================
# TRAP v2
# ============================
def microBearTrap =
    trapWindow and
    microHL and
    exhaustUp and
    accelUp and
    pressureFlipUp and
    tapeSpeedUp and
    isSignificant;

def microBullTrap =
    trapWindow and
    microLH and
    exhaustDown and
    accelDown and
    pressureFlipDown and
    tapeSpeedDown and
    isSignificant;

def priorSwingHigh = Highest(high[1], divLookback);
def priorSwingLow  = Lowest(low[1], divLookback);

def bullTrap =
    trapWindow and
    high > priorSwingHigh and
    swingANP < swingANP[1] and
    spreadStrongDown and
    slopeFading and
    isSignificant;

def bearTrap =
    trapWindow and
    low < priorSwingLow and
    swingANP > swingANP[1] and
    spreadStrongUp and
    slopeRising and
    isSignificant;

def bullClimaxTrap =
    trapWindow and
    structuralLow and
    exhaustDown and
    accelUp and
    spreadStrongUp and
    isClimaxVol;

def bearClimaxTrap =
    trapWindow and
    structuralHigh and
    exhaustUp and
    accelDown and
    spreadStrongDown and
    isClimaxVol;

def bullDivTrap = trapWindow and bullDiv;
def bearDivTrap = trapWindow and bearDiv;

def trapConfirm =
    (microBearTrap and close > close[1]) or
    (microBullTrap and close < close[1]) or
    (bearTrap and close > priorSwingLow) or
    (bullTrap and close < priorSwingHigh) or
    bullClimaxTrap or
    bearClimaxTrap or
    bullDivTrap or
    bearDivTrap;

def sev =
    (if bullClimaxTrap or bearClimaxTrap then 3 else
     if bullTrap or bearTrap then 2 else
     if bullDivTrap or bearDivTrap then 2 else
     if microBullTrap or microBearTrap then 1 else 0);
def trapSeverity = sev;

def trapCode =
    if bullClimaxTrap or bearClimaxTrap then 3 else
    if bullTrap or bearTrap then 2 else
    if bullDivTrap or bearDivTrap then 4 else
    if microBullTrap or microBearTrap then 1 else 0;

# =============
# TRAP SETUP
# =============

# Bear Trap Setup (pre‑trap condition)
def bearTrapSetup =
    trapWindow and
    (
        microHL or
        (low < priorSwingLow and swingANP > swingANP[1])
    ) and
    pressureFlipUp and
    accelUp and
    tapeSpeedUp and
    !trapConfirm;

# Bull Trap Setup (pre‑trap condition)
def bullTrapSetup =
    trapWindow and
    (
        microLH or
        (high > priorSwingHigh and swingANP < swingANP[1])
    ) and
    pressureFlipDown and
    accelDown and
    tapeSpeedDown and
    !trapConfirm;

# ============================
# TRAP FAILURE (POLARITY FLIP)
# ============================

# Bear‑trap setup fails → becomes bull trap collapse
def bearTrapFailToBull =
    bearTrapSetup and
    !trapConfirm and
    slopeFading and
    spreadStrongDown and
    tapeSpeedDown and
    close < close[1];

# Bull‑trap setup fails → becomes bear trap collapse
def bullTrapFailToBear =
    bullTrapSetup and
    !trapConfirm and
    slopeRising and
    spreadStrongUp and
    tapeSpeedUp and
    close > close[1];

# ============================
# SPIKE STATE ENGINE
# ============================
def barRange = high - low;
def avgRange = ExpAverage(barRange, spikeLength);

def priceSpikeStrength =
    if avgRange != 0 then (barRange / avgRange) - 1
    else 0;

def capHigh = 3.0;
def capLow  = -2.0;

def cappedSpike =
    if priceSpikeStrength > capHigh then capHigh
    else if priceSpikeStrength < capLow then capLow
    else priceSpikeStrength;

def spikeWarn     = cappedSpike > 1.25;
def spikeNormal   = cappedSpike > 1.50;
def spikeExtreme  = cappedSpike > 2.00;

def problemLevel  = -0.75;
def deadLevel     = -1.25;

def rawProblem = cappedSpike < problemLevel and cappedSpike >= deadLevel;
def isDead     = cappedSpike < deadLevel;

def chopBand = 0.35;
def isChop = AbsValue(cappedSpike) < chopBand;

def isUp   = close > open;
def isDown = close < open;

def flipUp   = isUp and close[1] < open[1];
def flipDown = isDown and close[1] > open[1];

def upperWickPct = if barRange != 0 then (high - close) / barRange else 0;
def lowerWickPct = if barRange != 0 then (close - low) / barRange else 0;

def bullRejection = upperWickPct > 0.40;
def bearRejection = lowerWickPct > 0.40;

def recentSpike = Highest(cappedSpike, 3) > 0.50;

def bullReversal = recentSpike and flipUp and bullRejection;
def bearReversal = recentSpike and flipDown and bearRejection;

def isProblem =
    rawProblem and
    !isDead and
    !isChop and
    !bullReversal and
    !bearReversal;

# ============================
# STATE ENGINE (ENVIRONMENT)
# ============================
def stateChop       = isChop;
def stateProblem    = isProblem;
def stateDead       = isDead;

def stateBlowoff =
    spikeExtreme or
    tapeSpike or
    isClimaxVol;

def stateCompression =
    volRatio < 0.8 or
    atr5 < atr20;

def stateExpansion =
    volRatio > 1.2 or
    atr5 > atr20;

# --- Priority resolver ---
def stateCode =
    if stateBlowoff then 6 else
    if stateProblem then 5 else
    if stateDead then 4 else
    if stateExpansion then 3 else
    if stateCompression then 2 else
    if stateChop then 1 else 0;

# ============================
# LABEL STRIP
# ============================

# --------------------------------
# 1. STATE BLOCK (environment)
# --------------------------------
AddLabel(stateCode == 6, "ENV: BLOWOFF", Color.MAGENTA);
AddLabel(stateCode == 5, "ENV: PROBLEM", Color.ORANGE);
AddLabel(stateCode == 4, "ENV: DEAD", Color.DARK_RED);
AddLabel(stateCode == 3, "ENV: EXPANSION", Color.CYAN);
AddLabel(stateCode == 2, "ENV: COMPRESSION", Color.YELLOW);
AddLabel(stateCode == 1, "ENV: CHOP", Color.LIGHT_GRAY);

# --------------------------------
# 2. TAPE STATE (participation)
# --------------------------------
AddLabel(isClimaxVol, "TAPE STAE: CLIMAX", Color.WHITE);
AddLabel(!isClimaxVol,
    if rVol > 2 then "TAPE STATE: ACTIVE" else "TAPE STATE: NORMAL",
    if rVol > 2 then Color.MAGENTA else Color.LIGHT_GRAY
);

# --------------------------------
# 3. SPEED BLOCK (tempo)
# --------------------------------

AddLabel(yes, "SPEED |", Color.WHITE);
AddLabel(yes,
    "TAPE: " +
    (if tapeSpeedUp then "ACCELERATING"
     else if tapeSpeedDown then "DECELERATING"
     else "STABLE"),
    if tapeSpeedUp then Color.GREEN
    else if tapeSpeedDown then Color.RED
    else Color.LIGHT_GRAY
);

AddLabel(yes,
    "PRICE: " +
    (if priceSpeedUp then "RISING"
     else if priceSpeedDown then "FALLING"
     else "STABLE"),
    if priceSpeedUp then Color.GREEN
    else if priceSpeedDown then Color.RED
    else Color.LIGHT_GRAY
);

AddLabel(yes,
    "VOL: " +
    (if volSpeedUp then "SURGING"
     else if volSpeedDown then "FADING"
     else "NORMAL"),
    if volSpeedUp then Color.MAGENTA
    else if volSpeedDown then Color.ORANGE
    else Color.LIGHT_GRAY
);

AddLabel(tapeSpike, "SPIKE", Color.YELLOW);
AddLabel(tapeSpeedBearDiv, "BEAR DIV", Color.CYAN);
AddLabel(tapeSpeedBullDiv, "BULL DIV", Color.MAGENTA);

AddLabel(yes, "|", Color.WHITE);

# --------------------------------
# 4. NARRATIVE BLOCK (trend + pressure)
# --------------------------------
AddLabel(yes,
    "TREND: " +
    (if swingANP >= 2 then "STRONG BULL"
     else if swingANP >= 1 then "BULL"
     else if swingANP > -1 then "NEUTRAL"
     else if swingANP > -2 then "BEAR"
     else "STRONG BEAR"),
    if swingANP >= 1 then Color.GREEN
    else if swingANP > -1 then Color.YELLOW
    else Color.RED
);

AddLabel(yes,
    (if slopeRising then "PRESSURE: RISING"
     else if slopeFading then "PRESSURE: FADING"
     else "PRESSURE: STABLE")
    + " | SPREAD: "
    + (if spreadStrongUp then "UP"
       else if spreadStrongDown then "DOWN"
       else "NEUTRAL")
    + (if curvatureDown then " | PEAK"
       else if curvatureUp then " | EXHAUST"
       else ""),
    if slopeRising then Color.GREEN
    else if slopeFading then Color.ORANGE
    else Color.LIGHT_GRAY
);



# Tape collapse label (NEW)
AddLabel(tapeCollapse,
    "TAPE COLLAPSE",
    Color.ORANGE
);

AddLabel(accelDown and swingANP > 1 and !microBearTrap and !bearClimaxTrap,
    "WARNING: BULL MOMENTUM FADING",
    Color.YELLOW
);

AddLabel(accelUp and swingANP < -1 and !microBullTrap and !bullClimaxTrap,
    "WARNING: BEAR MOMENTUM FADING",
    Color.CYAN
);

# --------------------------------
# 5. TRAP BLOCK
# --------------------------------

# --- Confirmed Traps ---
AddLabel(microBearTrap,   "TRAP: MICRO BEAR (S" + trapSeverity + ")", Color.CYAN);
AddLabel(microBullTrap,   "TRAP: MICRO BULL (S" + trapSeverity + ")", Color.MAGENTA);

AddLabel(bearTrap,        "TRAP: BEAR TRAP (S" + trapSeverity + ")", Color.CYAN);
AddLabel(bullTrap,        "TRAP: BULL TRAP (S" + trapSeverity + ")", Color.MAGENTA);

AddLabel(bearClimaxTrap,  "TRAP: BEAR CLIMAX (S" + trapSeverity + ")", Color.MAGENTA);
AddLabel(bullClimaxTrap,  "TRAP: BULL CLIMAX (S" + trapSeverity + ")", Color.CYAN);

AddLabel(bearDivTrap,     "TRAP: BEAR DIV (S" + trapSeverity + ")", Color.MAGENTA);
AddLabel(bullDivTrap,     "TRAP: BULL DIV (S" + trapSeverity + ")", Color.CYAN);

# --- Trap Setups ---
AddLabel(bearTrapSetup,
    "SETUP: BEAR TRAP",
    Color.CYAN
);

AddLabel(bullTrapSetup,
    "SETUP: BULL TRAP",
    Color.MAGENTA
);

# --- Trap Failures / Polarity Flips ---
AddLabel(bearTrapFailToBull,
    "TRAP FAIL: BEAR → BULL TRAP",
    Color.RED
);

AddLabel(bullTrapFailToBear,
    "TRAP FAIL: BULL → BEAR TRAP",
    Color.GREEN
);

# --------------------------------
# 6. SPIKE STATE BLOCK
# --------------------------------
AddLabel(isChop,    "CHOP",    Color.YELLOW);
AddLabel(isProblem, "PROBLEM", Color.ORANGE);
AddLabel(isDead,    "DEAD",    Color.DARK_RED);

AddLabel(spikeExtreme, "X-SPIKE", Color.WHITE);
AddLabel(spikeNormal and !spikeExtreme, "SPIKE", Color.CYAN);
AddLabel(spikeWarn and !spikeNormal, "WARN", Color.YELLOW);

# -----------------
# 7. REVERSALS
# -----------------
AddLabel(bullReversal, "REV↑", Color.GREEN);
AddLabel(bearReversal, "REV↓", Color.RED);

# ---------------------------------------------------------
# REGIME SLOPE HISTOGRAM
# ---------------------------------------------------------
input showPlot = no;

# RAW SLOPE
def RegimeSlopeRaw = regimeANP - regimeANP[1];

# RMS NORMALIZATION (stable, ratio‑preserving)
def sq = Sqr(RegimeSlopeRaw);
def meanSq = Average(sq, 20);
def rms = Sqrt(meanSq);

def RegimeSlope = if rms != 0 then RegimeSlopeRaw / rms else 0;

# ----------------
# HISTOGRAM
# ----------------

plot RegimeSlopeHist = if showPlot then RegimeSlopeRaw else Double.NaN;
RegimeSlopeHist.SetPaintingStrategy(PaintingStrategy.HISTOGRAM);
RegimeSlopeHist.SetLineWeight(3);

RegimeSlopeHist.AssignValueColor(
    if RegimeSlope >= 2 then Color.GREEN
    else if RegimeSlope >= 1 then Color.CYAN
    else if RegimeSlope <= -2 then Color.RED
    else if RegimeSlope <= -1 then Color.ORANGE
    else Color.GRAY
);

# --------------------------------
# TRAP ALERTS
# --------------------------------
input enableTrapAlerts = yes;

# Consolidated Bull Trap Alert
Alert(
    enableTrapAlerts and (
        microBullTrap or
        bullTrap or
        bullClimaxTrap or
        bullDivTrap or
        bullTrapSetup or
        bullTrapFailToBear
    ),
    "BULL TRAP",
    Alert.BAR,
    Sound.Ding
);

# Consolidated Bear Trap Alert
Alert(
    enableTrapAlerts and (
        microBearTrap or
        bearTrap or
        bearClimaxTrap or
        bearDivTrap or
        bearTrapSetup or
        bearTrapFailToBull
    ),
    "BEAR TRAP",
    Alert.BAR,
    Sound.Ding
);
##############
# HIDDEN PLOT
##############
plot _hidden = 0;
_hidden.SetHiding(yes);