Swing_ZZ_with_alert

Author: onix
Swing_ZZ_with_alert

This script is designed to function as a specialized "Swing ZigZag" indicator. Its primary goal is to identify and map out significant trend shifts—specifically the major peaks and valleys (highs and lows)—in price movement across a trading chart.

Instead of just showing every minor fluctuation, the logic uses a specific set of rules to filter out "market noise" and highlight meaningful structural turns. Here is a breakdown of how the logic operates:

Core Movement Detection

The script scans historical price data bar by bar to determine the direction of the current price swing. It distinguishes between three types of price action:

  • Expansion: When a new high or low is established, expanding the current range.
  • Continuation: When the price moves in the same direction as the previous trend but stays within the existing extremes.
  • Reversal: When the price begins to move in the opposite direction of the current trend.

Trend Transition Logic

To decide when a "Swing" has actually occurred (and should be marked on your chart), the script employs a counting system based on the minBars parameter. It tracks how many consecutive bars are moving in a specific direction compared to the opposing direction.

A new point is only plotted when:

  1. The trend has shown consistent strength for more than the minimum number of bars defined by the user.
  2. The price breaks out of its previous boundaries in a way that confirms a shift in momentum.

Dynamic Updating (The "Swing" Adjustment)

A key feature of this logic is its ability to update the most recent point. If the price continues to move higher than the last recorded "High" (in an uptrend) or lower than the last recorded "Low" (in a downtrend), the script will dynamically shift the marker to the new extreme. This ensures that the ZigZag line always represents the absolute peak or valley of the current swing rather than getting "stuck" on an older point.

Visual and Notification Features

The script provides three distinct visual outputs:

  • Trend Lines: It connects the peaks and valleys to form a clear, continuous path of the market's structure.
  • Arrows/Markers: It places specific markers at the exact moment a high or low is confirmed.
  • Alert System: The logic includes an optional notification system. When the script identifies a confirmed "Swing Up" (a new high) or "Swing Down" (a new low), it can trigger a pop-up alert on your screen or send an automated email, depending on your settings.

Summary for the User

In short, this tool acts as a structural map for the market. It ignores minor price wobbles and only draws a line when a significant move has taken place. It helps traders visualize the "skeleton" of the market's price action, making it easier to see where trends are forming, where they are exhausting, and where the next potential turning point might be.

Miscellaneous
Implements a curve of type %1It sends emails
15 Views
0 Downloads
0 Favorites
Swing_ZZ_with_alert 
//+------------------------------------------------------------------+
//|                                                     Swing_ZZ.mq4 |
//+------------------------------------------------------------------+

//---- Alert by FerruFx

#property copyright "onix"
#property link      "http://onix-trade.net/forum/index.php?s=&showtopic=118&view=findpost&p=131476"

#property indicator_chart_window
#property indicator_buffers 3
#property indicator_color1 Aqua
#property indicator_color2 Blue
#property indicator_color3 Red

//---- indicator parameters
extern int    minBars = 2; 
extern bool   SignalAlert    = false;
extern bool   SendAlertEmail = false;

//---- indicator buffers
double zzL[];
double zzH[];
double zz[];

//---- Alert
int up =0;
int down =0;
string Timeframe="";
double time_frame;


//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int init()
  {
 //  IndicatorBuffers(3);
//---- drawing settings
   SetIndexStyle(2,DRAW_ARROW);
   SetIndexStyle(1,DRAW_ARROW);
   SetIndexStyle(0,DRAW_SECTION);
   SetIndexArrow(2,159);
   SetIndexArrow(1,159);
//---- indicator buffers mapping
   SetIndexBuffer(0,zz);
   SetIndexBuffer(1,zzH);
   SetIndexBuffer(2,zzL);
   SetIndexEmptyValue(0,0.0);
   SetIndexEmptyValue(1,0.0);
   SetIndexEmptyValue(2,0.0);
     
//---- indicator short name
   IndicatorShortName("Swing_ZZ("+minBars+")");

//---- initialization done

   return(0);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int start()
  {
 int cbi;
 double lLast=0,hLast=0; 
 int fs=0; 
 int ai,bi,ai0,aip0,bi0,bip0; 
 datetime tai,tbi,taip,tbip,ti; 
 
 // Ïåðåìåííûå äëÿ Ñâèíãîâ Ãàííà
 double lLast_m=0, hLast_m=0;
 int countBarExt; // ñ÷åò÷èê âíåøíèõ áàðîâ
 int countBarl,countBarh;
 int i,n;

   ArrayInitialize(zz,0.0);
   ArrayInitialize(zzL,0.0);
   ArrayInitialize(zzH,0.0);



// lLast, hLast - ìèíèìóì è ìàêñèìóì àêòèâíîãî áàðà
// lLast_m, hLast_m - ìèíèìóì è ìàêñèìóì "ïðîìåæóòî÷íûõ" áàðîâ

//   cbi=Bars-IndicatorCounted()-1;
   cbi=Bars-1; 
//---------------------------------
   for (i=cbi; i>=0; i--) 
     {
//-------------------------------------------------
      // Óñòàíàâëèâàåì íà÷àëüíûå çíà÷åíèÿ ìèíèìóìà è ìàêñèìóìà áàðà
      if (lLast==0) {lLast=Low[i]; hLast=High[i]; ai=i; bi=i;}
      if (ti!=Time[i])
        {
         ti=Time[i];
         if (lLast_m==0 && hLast_m==0)
           {
            if (lLast>Low[i] && hLast<High[i]) // Âíåøíèé áàð
              {
               lLast=Low[i];hLast=High[i];lLast_m=Low[i];hLast_m=High[i];countBarExt++;
               if (fs==1) {countBarl=countBarExt; ai=i; tai=Time[i];}
               else if (fs==2) {countBarh=countBarExt; bi=i; tbi=Time[i];}
               else {countBarl++;countBarh++;}
              }
            else if (lLast<=Low[i] && hLast<High[i]) // Òåíäåíöèÿ íà òåêóùåì áàðå âîñõîäÿùàÿ
              {
               lLast_m=0;hLast_m=High[i];countBarl=0;countBarExt=0;
               if (fs!=1) countBarh++;
               else {lLast=Low[i]; hLast=High[i]; lLast_m=0; hLast_m=0; ai=i; tai=Time[i];}
              }
            else if (lLast>Low[i] && hLast>=High[i]) // Òåíäåíöèÿ íà òåêóùåì áàðå íèñõîäÿùàÿ
              {
               lLast_m=Low[i];hLast_m=0;countBarh=0;countBarExt=0;
               if (fs!=2) countBarl++;
               else {lLast=Low[i]; hLast=High[i]; lLast_m=0; hLast_m=0; bi=i; tbi=Time[i];}
              }
           }
         else  if (lLast_m>0 && hLast_m>0) // Âíåøíèé áàð (ïðåäûäóùèé)
           {
            if (lLast_m>Low[i] && hLast_m<High[i]) // Âíåøíèé áàð
              {
               lLast=Low[i];hLast=High[i];lLast_m=Low[i];hLast_m=High[i];countBarExt++;
               if (fs==1) {countBarl=countBarExt; ai=i; tai=Time[i];}
               else if (fs==2) {countBarh=countBarExt; bi=i; tbi=Time[i];}
               else {countBarl++;countBarh++;}
              }
            else if (lLast_m<=Low[i] && hLast_m<High[i]) // Òåíäåíöèÿ íà òåêóùåì áàðå âîñõîäÿùàÿ
              {
               lLast_m=0;hLast_m=High[i];countBarl=0;countBarExt=0;
               if (fs!=1) countBarh++;
               else {lLast=Low[i]; hLast=High[i]; lLast_m=0; hLast_m=0; ai=i; tai=Time[i];}
              }
            else if (lLast_m>Low[i] && hLast_m>=High[i]) // Òåíäåíöèÿ íà òåêóùåì áàðå íèñõîäÿùàÿ
              {
               lLast_m=Low[i];hLast_m=0;countBarh=0;countBarExt=0;
               if (fs!=2) countBarl++;
               else {lLast=Low[i]; hLast=High[i]; lLast_m=0; hLast_m=0; bi=i; tbi=Time[i];}
              }
           }
         else  if (lLast_m>0)
           {
            if (lLast_m>Low[i] && hLast<High[i]) // Âíåøíèé áàð
              {
               lLast=Low[i];hLast=High[i];lLast_m=Low[i];hLast_m=High[i];countBarExt++;
               if (fs==1) {countBarl=countBarExt; ai=i; tai=Time[i];}
               else if (fs==2) {countBarh=countBarExt; bi=i; tbi=Time[i];}
               else {countBarl++;countBarh++;}
              }
            else if (lLast_m<=Low[i] && hLast<High[i]) // Òåíäåíöèÿ íà òåêóùåì áàðå âîñõîäÿùàÿ
              {
               lLast_m=0;hLast_m=High[i];countBarl=0;countBarExt=0;
               if (fs!=1) countBarh++;
               else {lLast=Low[i]; hLast=High[i]; lLast_m=0; hLast_m=0; ai=i; tai=Time[i];}
              }
            else if (lLast_m>Low[i] && hLast>=High[i]) // Òåíäåíöèÿ íà òåêóùåì áàðå íèñõîäÿùàÿ
              {
               lLast_m=Low[i];hLast_m=0;countBarh=0;countBarExt=0;
               if (fs!=2) countBarl++;
               else {lLast=Low[i]; hLast=High[i]; lLast_m=0; hLast_m=0; bi=i; tbi=Time[i];}
              }
           }
         else  if (hLast_m>0)
           {
            if (lLast>Low[i] && hLast_m<High[i]) // Âíåøíèé áàð
              {
               lLast=Low[i];hLast=High[i];lLast_m=Low[i];hLast_m=High[i];countBarExt++;
               if (fs==1) {countBarl=countBarExt; ai=i; tai=Time[i];}
               else if (fs==2) {countBarh=countBarExt; bi=i; tbi=Time[i];}
               else {countBarl++;countBarh++;}
              }
            else if (lLast<=Low[i] && hLast_m<High[i]) // Òåíäåíöèÿ íà òåêóùåì áàðå âîñõîäÿùàÿ
              {
               lLast_m=0;hLast_m=High[i];countBarl=0;countBarExt=0;
               if (fs!=1) countBarh++;
               else {lLast=Low[i]; hLast=High[i]; lLast_m=0; hLast_m=0; ai=i; tai=Time[i];}
              }
            else if (lLast>Low[i] && hLast_m>=High[i]) // Òåíäåíöèÿ íà òåêóùåì áàðå íèñõîäÿùàÿ
              {
               lLast_m=Low[i];hLast_m=0;countBarh=0;countBarExt=0;
               if (fs!=2) countBarl++;
               else {lLast=Low[i]; hLast=High[i]; lLast_m=0; hLast_m=0; bi=i; tbi=Time[i];}
              }
           }

         // Îïðåäåëÿåì íàïðàâëåíèå òðåíäà. 
         if (fs==0)
           {
            if (lLast<lLast_m && hLast>hLast_m) // âíóòðåííèé áàð
              {
               lLast=Low[i]; hLast=High[i]; ai=i; bi=i; countBarl=0;countBarh=0;countBarExt=0;
              }
              
            if (countBarh>countBarl && countBarh>countBarExt && countBarh>minBars)
              {
               lLast=Low[i]; hLast=High[i]; lLast_m=0; hLast_m=0;
               fs=1;countBarh=0;countBarl=0;countBarExt=0;
               zz[bi]=Low[bi];
               zzL[bi]=Low[bi];
               zzH[bi]=0;
               ai=i;
               tai=Time[i];
              }
            else if (countBarl>countBarh && countBarl>countBarExt && countBarl>minBars)
              {
               lLast=Low[i]; hLast=High[i]; lLast_m=0; hLast_m=0;
               fs=2;countBarl=0;countBarh=0;countBarExt=0;
               zz[ai]=High[ai];
               zzH[ai]=High[ai];
               zzL[ai]=0;
               bi=i;
               tbi=Time[i];
              }
           }
         else
           {
            if (lLast_m==0 && hLast_m==0)
              {
               countBarl=0;countBarh=0;countBarExt=0;
              }

            // Òåíäåíöèÿ âîñõîäÿùàÿ
            if (fs==1)
              {
                  if (countBarl>countBarh && countBarl>countBarExt && countBarl>minBars) // Îïðåäåëÿåì òî÷êó ñìåíû òåíäåíöèè.
                    {
                     // çàïîìèíàåì çíà÷åíèå íàïðàâëåíèÿ òðåíäà fs íà ïðåäûäóùåì áàðå
                     ai0=iBarShift(Symbol(),0,tai); 
                     bi0=iBarShift(Symbol(),0,tbi);
                     fs=2;
                     countBarl=0;

                     zz[ai]=High[ai];
                     zzH[ai]=High[ai];
                     zzL[ai]=0;
                     bi=i;
                     tbi=Time[i];

                     lLast=Low[i]; hLast=High[i]; lLast_m=0; hLast_m=0;

                     for (n=0;countBarExt<minBars;n++) 
                       {
                        if (lLast<Low[i+n+1] && hLast>High[i+n+1]) {countBarExt++; countBarh++; lLast=Low[i+n+1]; hLast=High[i+n+1]; hLast_m=High[i];}
                        else break;
                       }

                     lLast=Low[i]; hLast=High[i];

                    }
              }

            // Òåíäåíöèÿ íèñõîäÿùàÿ
            if (fs==2)
              {
                  if (countBarh>countBarl && countBarh>countBarExt && countBarh>minBars) // Îïðåäåëÿåì òî÷êó ñìåíû òåíäåíöèè.
                    {
                     // çàïîìèíàåì çíà÷åíèå íàïðàâëåíèÿ òðåíäà fs íà ïðåäûäóùåì áàðå
                     ai0=iBarShift(Symbol(),0,tai); 
                     bi0=iBarShift(Symbol(),0,tbi);
                     fs=1;
                     countBarh=0;

                     zz[bi]=Low[bi];
                     zzL[bi]=Low[bi];
                     zzH[bi]=0;
                     ai=i;
                     tai=Time[i];

                     lLast=Low[i]; hLast=High[i]; lLast_m=0; hLast_m=0;

                     for (n=0;countBarExt<minBars;n++) 
                       {
                        if (lLast<Low[i+n+1] && hLast>High[i+n+1]) {countBarExt++; countBarl++; lLast=Low[i+n+1]; hLast=High[i+n+1]; lLast_m=Low[i];}
                        else break;
                       }

                     lLast=Low[i]; hLast=High[i];

                    }
              }
           } 
        } 
       if (i==0)
         {
          if (hLast<High[i] && fs==1) // Òåíäåíöèÿ íà òåêóùåì áàðå âîñõîäÿùàÿ
            {
             ai=i; tai=Time[i]; zz[ai]=High[ai]; zzH[ai]=High[ai]; zzL[ai]=0;
            }
          else if (lLast>Low[i] && fs==2) // Òåíäåíöèÿ íà òåêóùåì áàðå íèñõîäÿùàÿ
            {
             bi=i; tbi=Time[i]; zz[bi]=Low[bi]; zzL[bi]=Low[bi]; zzH[bi]=0;
            }
//===================================================================================================
      // Íóëåâîé áàð. Ðàñ÷åò ïåðâîãî ëó÷à ZigZag-a

          ai0=iBarShift(Symbol(),0,tai); 
          bi0=iBarShift(Symbol(),0,tbi);

          if (bi0>1) if (fs==1) {for (n=bi0-1; n>=0; n--) {zzH[n]=0.0; zz[n]=0.0;} zz[ai0]=High[ai0]; zzH[ai0]=High[ai0]; zzL[ai0]=0.0;}         
          if (ai0>1) if (fs==2) {for (n=ai0-1; n>=0; n--) {zzL[n]=0.0; zz[n]=0.0;} zz[bi0]=Low[bi0]; zzL[bi0]=Low[bi0]; zzH[bi0]=0.0;}

          if (ti<Time[1]) i=2;

         }
//====================================================================================================
      //---- Alert
      time_frame=Period();
      if(time_frame==1) { Timeframe = "M1"; }
      if(time_frame==5) { Timeframe = "M5"; }
      if(time_frame==15) { Timeframe = "M15"; }
      if(time_frame==30) { Timeframe = "M30"; }
      if(time_frame==60) { Timeframe = "H1"; }
      if(time_frame==240) { Timeframe = "H4"; }
      if(time_frame==1440) { Timeframe = "D1"; }
      if(time_frame==10080) { Timeframe = "W1"; }
      if(time_frame==43200) { Timeframe = "MN"; }
      
      if(zzL[i] != 0 && down ==0)
      {
       if (SignalAlert) Alert("Swing ZZ Down - ",Symbol()," ",Timeframe," at ",TimeToStr(TimeCurrent(),TIME_SECONDS));
       if(SendAlertEmail) SendMail("Swing ZZ","Swing ZZ Down - "+Symbol()+" "+Timeframe+" at "+TimeToStr(TimeCurrent(),TIME_SECONDS)+" (server time)");
       up = 0;
       down = 1;
      }
      if(zzH[i] != 0 && up ==0)
      {
       if (SignalAlert) Alert("Swing ZZ Up - ",Symbol()," ",Timeframe," at ",TimeToStr(TimeCurrent(),TIME_SECONDS));
       if(SendAlertEmail) SendMail("Swing ZZ","Swing ZZ Up - "+Symbol()+" "+Timeframe+" at "+TimeToStr(TimeCurrent(),TIME_SECONDS)+" (server time)");
       up = 1;
       down = 0;
      }
      
      
      
      
      
      
     }
//--------------------------------------------
   
return(0);
}
//+------------------------------------------------------------------+

Similar scripts

guppy34_alert

EA_MA_Email

Stoch_Crossing

Stoch Crossing_v2

This indicator identifies precise bullish and bearish entry points by detecting the instantaneous intersection of the Stochastic %K and %D lines across multi-period dynamics.

MACD_ColorHist_Alert_001

BrainTrend1Sig_v3

BrainTrend1Sig_v5

MACD_4ColorHist_2L_SEAlert

FISHER~1 (2)

This indicator calculates a smoothed price location relative to the extreme range and applies a logarithmic transformation to identify momentum shifts across zero-line thresholds.

doji_arrows_v2

P&F_v2_alerts

Comments