SDX-ZoneBreakout1_v1

Download script
Author: Copyright Shimodax
SDX-ZoneBreakout1_v1

Overview

This script is designed to identify specific price "breakout" opportunities on a trading chart by monitoring price action during predefined time windows. It works by creating visual boundaries (zones) based on the highest and lowest prices reached during early market sessions. When the price moves outside of these established boundaries, the script identifies a potential entry point for a trade.

Core Logic & Functionality

1. Time-Based Zone Creation The logic operates by dividing the trading day into specific time blocks. It focuses on two primary periods:

  • Period 1: The early morning session.
  • Period 2: The subsequent mid-morning session.
  • Rest of Day: Used as a reference to track the progression of the market.

The script automatically scans the historical data for each day and identifies the highest high and lowest low reached during these specific windows.

2. Dynamic Range Drawing Once these periods are identified, the script projects "Zones" onto your chart:

  • It draws upper and lower boundaries for both Period 1 and Period 2.
  • These lines act as support and resistance levels that remain constant throughout the remainder of the trading day once the respective time periods have concluded.
  • Users can customize a "buffer" (measured in pips) to add extra space beyond the high/low points, ensuring the signal isn't triggered by tiny fluctuations.

3. Breakout Detection The primary goal of this tool is to detect when the market "breaks out" of these zones. The logic looks for two specific types of price movements:

  • Buy Signals: Triggered when the price moves above an upper boundary. It specifically looks for instances where a candle opens below the line but closes or reaches above it.
  • Sell Signals: Triggered when the price moves below a lower boundary. It looks for candles that open above the line but drop below it.

4. Visual and Audio Alerts To make the tool actionable for a trader, the script provides two methods of notification:

  • Visual Markers: It places arrows directly on the chart at the exact moment a breakout occurs, marking the entry point.
  • Pop-up Alerts: If enabled in the settings, the script will trigger a standard trading platform alert (a pop-up window) the moment a signal is detected, ensuring the trader doesn't miss a move while away from the screen.

Summary for the User

Think of this tool as an automated "boundary watcher." It remembers how high or low the market went during the early morning hours and draws lines at those levels. If the market later manages to push through those lines, the script flags it with an arrow and an alert, suggesting that the price is breaking out of its previous trading range.

Miscellaneous
Implements a curve of type %1It issuies visual alerts to the screen
9 Views
0 Downloads
0 Favorites
SDX-ZoneBreakout1_v1 

//+------------------------------------------------------------------+
//|  TZ-Breaktout.mq4                                                |
//|  Shimodax                                                        |
//|                                                                  |
//+------------------------------------------------------------------+

#property copyright "Copyright Shimodax"
#property link      "http://www.strategybuilderfx.com/forums/showthread.php?t=15439"


/* Introduction:

   Draw ranges for "Simple Combined Breakout System for EUR/USD and GBP/USD" thread
   (see http://www.strategybuilderfx.com/forums/showthread.php?t=15439)

   TimeZoneOfData: TimeZone for which MT4 shows your local time, 
                  e.g. 1 or 2 for Europe (GMT+1 or GMT+2 (daylight 
                  savings time).  Use zero for no adjustment.
                  
                  The MetaQuotes demo server uses GMT +2.   
   Enjoy  :-)
   
   Markus

*/


#property indicator_chart_window
#property indicator_buffers 5
#property indicator_color1 DarkKhaki
#property indicator_color2 DarkKhaki
#property indicator_color3 Khaki
#property indicator_color4 Khaki
#property indicator_color5 Gold


extern bool DoEntryAlerts= false;
extern int TimeZoneOfData= 1;  // time zone of metatrader charts
extern int PipsForEntry= 5;

int DestTimeZone= 0;   // dest time zone for time computation (leave as zero (GMT))




double Zone1Upper[];
double Zone2Upper[];
double Zone1Lower[];
double Zone2Lower[];
double EntrySignalsBuffer[];
       



//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int init()
{
   SetIndexStyle(0,DRAW_LINE);
   SetIndexBuffer(0,Zone1Upper);
   SetIndexEmptyValue(0, 0.0);
	SetIndexLabel(0, "Upper Zone 1");

   SetIndexStyle(1,DRAW_LINE);
   SetIndexBuffer(1,Zone1Lower);
   SetIndexEmptyValue(1, 0.0);
   SetIndexLabel(1, "Lower Zone 1");

   SetIndexStyle(2,DRAW_LINE);
   SetIndexBuffer(2,Zone2Upper);
   SetIndexEmptyValue(2, 0.0);
   SetIndexLabel(2, "Upper Zone 2");

   SetIndexStyle(3,DRAW_LINE);
   SetIndexBuffer(3,Zone2Lower);
   SetIndexEmptyValue(3, 0.0);
   SetIndexLabel(3, "Lower Zone 2");


   SetIndexStyle(4,DRAW_ARROW);
   SetIndexArrow(4, 162);
   SetIndexBuffer(4, EntrySignalsBuffer);
   SetIndexEmptyValue(4, 0.0);
   SetIndexLabel(4, "Zone Breakout Signal");

   return(0);
}

int deinit()
{

   return(0);
}
  
//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int start()
{
   int counted_bars= IndicatorCounted(),
         lastbar, result;

   if (Bars<=100) 
      return(0);
      
   if (counted_bars>0)
      counted_bars--;
      
   lastbar= Bars - counted_bars;
   
   
   //
   // compute ranges
   //
   BreakoutRanges(0, lastbar, TimeZoneOfData, DestTimeZone);
   
   
   //
   // check alerts   
   //
   static datetime lastalerttime;
   static double lastalertprice;

   if (DoEntryAlerts && lastalerttime!=Time[0] && EntrySignalsBuffer[0]!=0 && EntrySignalsBuffer[0]!=lastalertprice) {
      Alert("ZoneBreakout signals entry!");
      lastalerttime= Time[0];
      lastalertprice= EntrySignalsBuffer[0];
   } 
   else {
      lastalerttime= 0;
      lastalertprice= 0.0;
   }


   return(0);
}

 
//+------------------------------------------------------------------+
//| Compute Breakout ranges for daily time periods                   |
//+------------------------------------------------------------------+
int BreakoutRanges(int offset, int lastbar, int tzlocal, int tzdest)
{     
   int i, j, k,
       tzdiff= tzlocal - tzdest,
       tzdiffsec= tzdiff*3600, 
       tidxstart[2]= { 0, 0}, 
       tidxend[2]= { 0, 0 };
   double thigh[2]= { 0.0, 0.0 }, 
           tlow[2]= { 99999.9, 99999.9 };
   string tfrom[3]= { "04:00", "08:00" ,  /*rest of day: */ "12:00"},
          tto[3]=   { "08:00", "12:00",   /*rest of day: */ "24:00" },
          tday;
   bool inperiod= -1;
   datetime timet;
   

   //
   // search back for the beginning of the day
   //
   tday= TimeToStr(Time[lastbar]-tzdiffsec, TIME_DATE);   
   for (  ; lastbar<Bars; lastbar++) {
      if (TimeToStr(Time[lastbar] - tzdiffsec, TIME_DATE)!=tday) {
         lastbar--;
         break;      
      }
   }   



   //
   // find the high/low for the two periods and carry them forward through the day
   //
   tday= "XXX";
   for (i= lastbar; i>=offset; i--) {
   
      timet= Time[i] - tzdiffsec;   // time of this bar
      
      string timestr= TimeToStr(timet, TIME_MINUTES),    // current time HH:MM
             thisday= TimeToStr(timet, TIME_DATE);       // current date
          
      EntrySignalsBuffer[i]= 0;   
          
      //
      // for all three periods (first period, second period, rest of day)
      //
      for (j= 0; j<3; j++) {
      
         if (tfrom[j]<=timestr && timestr<tto[j]) {   // Bar[i] in this period
      
            if (inperiod!=j) { // entered new period, so last one is completed
                                 
               if (j>0) {      // now draw high/low back over the recently completed period
               
                  for (k= tidxstart[j-1]; k>=tidxend[j-1]; k--) {
                     if (j-1==0) {
                        Zone1Upper[k]= thigh[j-1];
                        Zone1Lower[k]= tlow[j-1];
                     }

                     if (j-1==1) {
                        Zone2Upper[k]= thigh[j-1];
                        Zone2Lower[k]= tlow[j-1];
                     }
                  }
               }
               
               inperiod= j;   // remember current period
            }
            
            if (inperiod==2)   // inperiod==2 (end of day) is just to check completion of zone 2
               break;


            // for the current period find idxstart, idxend and compute high/low
            if (tidxstart[j]==0) {
               tidxstart[j]= i;
               tday= thisday;
            }
         
            tidxend[j]= i;
      
            thigh[j]= MathMax(thigh[j], High[i]);
            tlow[j]= MathMin(tlow[j], Low[i]);
         }
      }
      
      
      // 
      // carry forward the periods for which we have definite high/lows
      //
      if (inperiod>=1 && tday==thisday) { // first time period completed
         Zone1Upper[i]= thigh[0] + PipsForEntry*Point;
         Zone1Lower[i]= tlow[0] - PipsForEntry*Point;
         
         if (inperiod>=2) {   // second period completed
            Zone2Upper[i]= thigh[1] + PipsForEntry*Point;
            Zone2Lower[i]= tlow[1] - PipsForEntry*Point;
         }
         
         CheckSignal(i, Zone1Upper[i], OP_BUY, EntrySignalsBuffer);
         CheckSignal(i, Zone1Lower[i], OP_SELL, EntrySignalsBuffer);
         CheckSignal(i, Zone2Upper[i], OP_BUY, EntrySignalsBuffer);
         CheckSignal(i, Zone2Lower[i], OP_SELL, EntrySignalsBuffer);
      }
      else {   // none yet to carry forward (zero to clear old values, e.g. from switching timeframe)
         Zone1Upper[i]= 0;
         Zone1Lower[i]= 0;
         Zone2Upper[i]= 0;
         Zone2Lower[i]= 0;
      }
     

      //
      // at the beginning of a new day reset everything
      //
      if (tday!="XXX" && tday!=thisday || TimeToStr(timet, TIME_MINUTES)>=tto[2]) {
         // Print("#", i, "new day ", thisday, "/", tday);
      
         tday= "XXX";
         
         inperiod= -1;
         
         for (j= 0; j<2; j++) {
            tidxstart[j]= 0;
            tidxend[j]= 0;
         
            thigh[j]= 0;
            tlow[j]= 99999;
         }
      }
   }

   return (0);       
}




//+------------------------------------------------------------------+
//| Check price break                                                |
//+------------------------------------------------------------------+
bool CheckSignal(int shift, double price, int type, double &signalbuffer[]) 
{
   bool signal= false;

   if (type==OP_BUY && ((Open[shift]<price && High[shift]>price) || (Close[shift+1]<price && Open[shift]>price)) ) {
      signalbuffer[shift]= price;
      signal= true;
  }

   if (type==OP_SELL && (Open[shift]>price && Low[shift]<price) || (Close[shift+1]>price && Open[shift]<price)) {
      signalbuffer[shift]= price;
      signal= true;
  }
  
  return (signal);
}

Similar scripts

SDX-ZoneBreakout2

This indicator identifies momentum shifts by mapping high and low price extremes from specific morning trading windows and projecting them as dynamic breakout boundaries for the remainder of the session.

SDX- 8h

Identifies bullish and bearish signals by detecting price penetration beyond high and low extremes established during specific time-bound volatility windows.

SDX-ZoneBreakout

Identifies actionable liquidity levels by mapping historical high and low boundaries from specific multi-session time blocks to trigger breakout alerts.

Batfink Signal (Line 1 and 2)

This indicator identifies intraday liquidity thresholds by projecting price boundaries from specific time windows and signaling entry alerts when market action breaches these dynamically calculated levels.

Batfink Signal (Target 4)

This indicator identifies specific price breakout signals by monitoring volatility zones established during predefined temporal windows and alerting on expansion beyond a set pip distance.

Batfink Signal (Target 3)

This indicator identifies institutional supply and demand zones by calculating price extremes across specific time windows and plotting breakout signals when market price breaches defined pip-based buffers.

Batfink Signal (Target 2)

This indicator identifies specific price volatility zones based on pre-defined intraday time blocks and triggers visual alerts when the market breaks outside of these dynamically calculated bounds.

Batfink Signal (Target 1)

Identifies expansionary price action by detecting breaches of volatility zones calculated from specific time-bound trading sessions.

Batfink Signal (Stoploss B)

Identifies dynamic support and resistance levels by calculating price extremes across specific hourly windows and generating alerts on subsequent pips-based breaches.

Batfink Signal (Stoploss A)

This indicator identifies specific price breakouts by dynamically projecting high and low volatility zones derived from predefined historical time segments across different timezones.

SDX__8h

This indicator dynamically identifies and projects high/low boundaries from specific intra-day time windows to detect price breakouts with integrated pip-offset filters.

Comments