V-T&Bv6_v1





/*-----------------------------+
|			       |
| Shared by www.Aptrafx.com    |
|			       |
+------------------------------*/

//+------------------------------------------------------------------+
//|                                                        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);
}





Sample





Analysis



Market Information Used:

Series array that contains the highest prices of each bar
Series array that contains the lowest prices of each bar
Series array that contains close prices for each bar
Series array that contains open prices of each bar


Indicator Curves created:

Implements a curve of type DRAW_ARROW


Indicators Used:



Custom Indicators Used:

Order Management characteristics:

Other Features:

It plays sound alerts