Author: Coded by Don Lawson (don_forex)
V-T&Bv6_v2

This script is a specialized technical analysis tool designed to identify specific price action patterns on a trading chart. It focuses on detecting "rejection" signals by analyzing the relationship between a candle's body and its wicks (the thin lines above and below the main candle body) in conjunction with market volatility.

Core Logic and Functionality

1. Candle Anatomy Analysis The tool examines individual price candles to determine their structure. It specifically looks for "Wick Ratios"—measuring how large a wick is relative to the actual body of the candle. If a wick is significantly longer than the body (based on a user-defined percentage), the script identifies this as a potential price rejection.

2. Price Directional States The logic categorizes every candle into one of four states based on two different timeframes: the current candle and the one immediately preceding it. By comparing whether the price is moving up (Bullish) or down (Bearish) across these two bars, the script builds a context for where the price might be heading next.

3. Rejection Detection (V-Top and V-Bottom) The indicator looks for specific "breakout" behaviors:

  • V-Top: This occurs when a candle exceeds the high of the previous candle but ends with a long upper wick. This suggests that while buyers pushed the price up, sellers were strong enough to push it back down.
  • V-Bottom: This occurs when a candle drops below the low of the previous candle but ends with a long lower wick. This suggests that while sellers pushed the price down, buyers stepped in to push it back up.

4. Volatility Filtering ("Juice") To ensure the signals are meaningful and not just "noise" from a slow market, the script uses a volatility filter (referred to in the code as "Juice"). It measures the standard deviation of price movements over a specific period. A signal is only confirmed if the current market activity exceeds a certain threshold, ensuring that the rejection happens during an active trading environment.

5. Signal Confirmation and Alerts Before placing a visual arrow on the chart (the final signal), the script performs a final check:

  • It calculates a "Penetration" level to ensure the wick actually reached into the previous candle's territory with enough strength.
  • It checks the current market state against these penetration levels to confirm the reversal.
  • If all conditions—wick ratio, price direction, volatility, and penetration—are met, the script places a Red arrow (for top reversals) or a Green arrow (for bottom reversals) on the chart.
  • Optional audio alerts can be triggered at these moments to notify the user in real-time.

Summary for the User

In plain terms, this tool scans the market to find "failed" breakouts. It looks for moments where the price tries to break out of a previous range but gets aggressively pushed back by the opposite side of the market. By combining this visual rejection with a volatility check, it aims to highlight high-probability turning points where the trend might be shifting.

Miscellaneous
Implements a curve of type %1It plays sound alerts
9 Views
0 Downloads
0 Favorites
V-T&Bv6_v2
//+------------------------------------------------------------------+
//|                                                        V-T&B.mq4 |
//|                                           Don Lawson (don_forex) |
//+------------------------------------------------------------------+
#property copyright "Coded by Don Lawson (don_forex)"
#property link      "d_n_d_enterprises@sbcglobal.net"
//----
#property indicator_chart_window
#property indicator_buffers 2
#property indicator_color1 Red
#property indicator_width1 2
#property indicator_color2 Green
#property indicator_width2 2
//----
extern double  WickRatio     =0.5;
extern double  WickPercent   =50;
extern int     JuicePeriod   =7;
extern int JuiceLevelForAlert=5;
extern bool Notify=false;
extern bool UseNew=true;
//----
double VTop[];
double VBottom[];
double DistanceFromCandle;
int    Level=5;
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int init()
  {
//---- indicators
   SetIndexStyle(0, DRAW_ARROW, EMPTY);
   SetIndexArrow(0, 234);
   SetIndexBuffer(0, VTop);
   SetIndexStyle(1, DRAW_ARROW, EMPTY);
   SetIndexArrow(1, 233);
   SetIndexBuffer(1, VBottom);
//----
   return(0);
  }
//+------------------------------------------------------------------+
//| Custom indicator deinitialization function                       |
//+------------------------------------------------------------------+
int deinit()
  {
//---- 
//----
   return(0);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void SetVTop(int index)
  {
   double Juice, JuiceLevel;
   // Check for Juice
   JuiceLevel=Level*Point;
   if (Period()==5)JuiceLevel=JuiceLevel/2;
   Juice=iStdDev  (NULL,0,JuicePeriod,MODE_EMA,0,PRICE_CLOSE,index)-JuiceLevel;
     if (Juice > JuiceLevelForAlert*Point) 
     {
      VTop[index]=High[index]+ DistanceFromCandle;
      if (Notify) PlaySound("V-Top.wav");
     }
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void SetVBottom(int index)
  {
   double Juice, JuiceLevel;
   // Check for Juice
   JuiceLevel=Level*Point;
   if (Period()==5)JuiceLevel=JuiceLevel/2;
   Juice=iStdDev  (NULL,0,JuicePeriod,MODE_EMA,0,PRICE_CLOSE,index)-JuiceLevel;
     if (Juice > JuiceLevelForAlert*Point) {
      VBottom[index]=Low[index]- DistanceFromCandle;
      if (Notify) PlaySound("V-Bottom.wav");
     }
  }
//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int start()
  {
   int limit, i,State;
   double WickPenetration;
   double BullWickPenHi,BullWickPenLow;
   double BearWickPenHi,BearWickPenLow;
   double BullWickHi,BullWickLow,BullBody;
   double BearWickHi,BearWickLow,BearBody;
   int counted_bars=IndicatorCounted();
//---- check for possible errors
   if(counted_bars<0) return(-1);
//---- last counted bar will be recounted
   if(counted_bars>0) counted_bars--;
//----
   limit=Bars-counted_bars;
//----
   WickPenetration=WickPercent/100.0;
   DistanceFromCandle=Point*8;
     for(i=1; i<=limit; i++) 
     {
      bool  CurrentBull    =false,
      CurrentBear    =false,
      Bull           =false,
      Bear           =false,
      HiWick         =false,
      LoWick         =false;
      if (Open[i-1]<Close[i-1])
         CurrentBull=true;
      else
         CurrentBear=true;
      if (Open[i]<Close[i])
         Bull=true;
      else
         Bear=true;
      BullWickHi=High[i] - Close[i];
      BullWickLow=Open[i] - Low[i];
      BullBody=Close[i] - Open[i];
      BearWickHi=High[i] - Open[i];
      BearWickLow=Close[i] - Low[i];
      BearBody=Open[i] - Close[i];
      // Check for VTOP
      if (High[i] > High[i+1])
        {
           if (Bull) 
           {
            if ((BullWickHi > BullBody * WickRatio))// && (BullWickHi > BullWickLow)
               HiWick=true;
           }
           if (Bear)
           {
            if ((BearWickHi > BearBody * WickRatio))// && (BearWickHi > BearWickLow)
               HiWick=true;
           }
        }
      // Check for VBottom
      if (Low[i] < Low[i+1])
        {
           if (Bull)
           {
            if ((BullWickLow > BullBody * WickRatio))// && (BullWickLow > BullWickHi)
               LoWick=true;
           }
           if (Bear)
           {
            if ((BearWickLow > BearBody * WickRatio))// && (BearWickLow > BearWickHi)
               LoWick=true;
           }
        }
      // Set up State Table
      if (CurrentBear && Bull) State=1;
      if (CurrentBear && Bear) State=2;
      if (CurrentBull && Bull) State=3;
      if (CurrentBull && Bear) State=4;
      // Set Arrow
        if (HiWick) 
        {
         BullWickPenHi=Close[i] + BullWickHi * WickPenetration;
         BearWickPenHi=Open[i] + BearWickHi * WickPenetration;
         switch(State)
           {
            case 1 : // CurrentBear && Bull 
               if (UseNew)
                 {
                  if(Open[i-1] < BullWickPenHi) SetVTop(i);
                 }
               else
                 {
                  SetVTop(i);
                 }
               break;
            case 2 : // CurrentBear && Bear 
               if (UseNew)
                 {
                  if (Open[i-1] < BearWickPenHi) SetVTop(i);
                 }
               else
                 {
                  SetVTop(i);
                 }
               break;
            case  3 : // CurrentBull && Bull
               if (UseNew)
                 {
                  if (Close[i-1] < BullWickPenHi) SetVTop(i);
                 }
               else
                 {
                  SetVTop(i);
                 }
               break;
            case 4 : // CurrentBull && Bear
               if (UseNew)
                 {
                  if (Close[i-1] < BearWickPenHi)  SetVTop(i);
                 }
               else
                 {
                  SetVTop(i);
                 }
               break;
           }
        }
        if (LoWick) 
        {
         BullWickPenLow=Open[i] - BullWickLow * WickPenetration;
         BearWickPenLow=Close[i] - BearWickLow * WickPenetration;
         switch(State)
           {
            case 1 : // CurrentBear && Bull
               if (UseNew)
                 {
                  if (Close[i-1] > BullWickPenLow) SetVBottom(i);
                 }
               else
                 {
                  SetVBottom(i);
                 }
               break;
            case 2 : // CurrentBear && Bear
               if (UseNew)
                 {
                  if (Close[i-1] > BearWickPenLow) SetVBottom(i);
                 }
               else
                 {
                  SetVBottom(i);
                 }
               break;
            case 3 : // CurrentBull && Bull
               if (UseNew)
                 {
                  if (Open[i-1] > BullWickPenLow) SetVBottom(i);
                 }
               else
                 {
                  SetVBottom(i);
                 }
               break;
            case 4 : //CurrentBull && Bear)
               if (UseNew)
                 {
                  if (Open[i-1] > BearWickPenLow) SetVBottom(i);
                 }
               else
                 {
                  SetVBottom(i);
                 }
               break;
           }
        }
     }
   return(0);
  }
//+------------------------------------------------------------------+

Comments