killzonessessionpivots.mq5

#property version   "1.04"
#property description "ICT killzones in New York time with session pivots, previous day, week"
#property description "and month levels, and opening-price lines at key times."
#property indicator_chart_window
#property indicator_buffers 0
#property indicator_plots   0

enum ENUM_EXTENSION                 // how long pivots run
  {
   EXTEND_UNTIL_TAKEN,              // until taken
   EXTEND_PAST_TAKEN                // past the take
  };
enum ENUM_SERVER_DST                // broker daylight-saving calendar
  {
   SERVER_DST_US,                   // US
   SERVER_DST_EU,                   // EU
   SERVER_DST_NONE                  // none
  };

input group "Sessions (New York time)"
input string InpS1Name     = "ASIA";         // session 1 name
input string InpS1Time     = "2000-0000";    // session 1 time
input color  InpS1Color    = C'94,129,172';  // session 1 color
input string InpS2Name     = "LONDON";       // session 2 name
input string InpS2Time     = "0200-0500";    // session 2 time
input color  InpS2Color    = C'196,98,62';   // session 2 color
input string InpS3Name     = "NY AM";        // session 3 name
input string InpS3Time     = "0930-1100";    // session 3 time
input color  InpS3Color    = C'52,140,96';   // session 3 color
input string InpS4Name     = "NY LUNCH";     // session 4 name
input string InpS4Time     = "";             // session 4 time
input color  InpS4Color    = C'201,152,40';  // session 4 color
input string InpS5Name     = "NY PM";        // session 5 name
input string InpS5Time     = "1330-1600";    // session 5 time
input color  InpS5Color    = C'134,92,176';  // session 5 color
input int    InpKeep       = 3;              // sessions kept on the chart
input int    InpBoxOpacity = 40;             // box opacity, percent

input group "Session pivots"
input bool           InpPivots    = true;               // draw session high and low
input bool           InpMid       = false;              // draw session midpoint
input bool           InpPivotTags = true;               // label the pivots
input ENUM_EXTENSION InpExtension = EXTEND_UNTIL_TAKEN; // extend pivots
input bool           InpAlerts    = true;               // alert when a high or low is taken

input group "Previous day, week, month"
input bool  InpDayLevels   = true;           // previous day levels
input color InpDayColor    = C'70,110,160';  // day color
input bool  InpWeekLevels  = true;           // previous week levels
input color InpWeekColor   = C'58,146,134';  // week color
input bool  InpMonthLevels = true;           // previous month levels
input color InpMonthColor  = C'176,72,84';   // month color

input group "Key times (New York time)"
input bool   InpOpens   = true;              // opening-price line at each time
input bool   InpMarks   = true;              // vertical marker at each time
input string InpK1Time  = "0930";            // time 1
input string InpK1Name  = "NY Open";         // time 1 label
input color  InpK1Color = C'70,110,160';     // time 1 color
input string InpK2Time  = "1200";            // time 2
input string InpK2Name  = "Midday";          // time 2 label
input color  InpK2Color = C'201,152,40';     // time 2 color
input string InpK3Time  = "1600";            // time 3
input string InpK3Name  = "Close";           // time 3 label
input color  InpK3Color = C'176,72,84';      // time 3 color

input group "Broker clock"
input int             InpServerGmt = 2;             // broker server GMT offset in winter
input ENUM_SERVER_DST InpServerDst = SERVER_DST_US; // broker daylight-saving calendar
input ENUM_TIMEFRAMES InpMaxPeriod = PERIOD_M30;    // draw only up to this timeframe

#define TAG        "KSP_"   // prefix of every chart object
#define SESSIONS   5        // session slots
#define SLOTS      3        // key-time slots
#define FRAMES     3        // day, week, month
#define KIND_HIGH  0        // frame line: previous high
#define KIND_LOW   1        // frame line: previous low
#define KIND_MID   2        // frame line: previous midline
#define FONT_SIZE  8        // label font size
#define HISTORY    5000     // bars processed on load

struct TimeSpan
  {
   int               from;        // first minute inside the window
   int               to;          // first minute after the window
   bool              valid;       // parsed correctly
  };

struct SessionMark
  {
   int               slot;        // session slot, 0..4
   long              id;          // unique id, names the objects
   datetime          opened;      // first bar of the session
   datetime          lastIn;      // last bar inside the session
   double            top;         // session high so far
   double            bottom;      // session low so far
   datetime          topAt;       // bar of the high
   datetime          bottomAt;    // bar of the low
   datetime          topUntil;    // right end of the high line
   datetime          bottomUntil; // right end of the low line
   datetime          midUntil;    // right end of the midline
   bool              topOpen;     // high not taken yet
   bool              bottomOpen;  // low not taken yet
   bool              midOpen;     // midline not touched yet
  };

struct FrameLine
  {
   int               frame;       // 0 day, 1 week, 2 month
   int               kind;        // KIND_HIGH, KIND_LOW or KIND_MID
   long              id;          // unique id
   double            price;       // level
   datetime          from;        // left end
   datetime          until;       // right end
   datetime          period;      // start of the period it describes
  };

struct FrameTotals
  {
   long              key;         // period key of the current period
   double            open;        // current period open
   double            high;        // current period high
   double            low;         // current period low
   double            prevHigh;    // previous period high
   double            prevLow;     // previous period low
   datetime          began;       // current period first bar
   datetime          prevBegan;   // previous period first bar
   bool              highTaken;   // previous high traded through
   bool              lowTaken;    // previous low traded through
   int               periods;     // periods counted for hit rates
   int               highHits;    // periods whose previous high was taken
   int               lowHits;     // periods whose previous low was taken
  };

struct TimeLine
  {
   int               slot;        // key-time slot, 0..2
   long              id;          // unique id
   double            price;       // opening price (unused by markers)
   datetime          from;        // bar of the time
   datetime          until;       // right end
  };

class CLayerState
  {
public:
   SessionMark       marks[];
   FrameLine         frames[];
   TimeLine          opens[];
   TimeLine          stamps[];
   FrameTotals       totals[FRAMES];
   int               runs[SESSIONS];
   int               topHits[SESSIONS];
   int               bottomHits[SESSIONS];
   datetime          firstRun[SESSIONS];
   long              nextId;

   void              Clear(void);

   void              CopyFrom(const CLayerState &src);
  };

struct SessionSetup
  {
   bool              on;          // slot enabled
   string            name;        // label text
   color             tint;        // drawing color
   TimeSpan          span;        // window
  };

struct SlotSetup
  {
   bool              on;          // slot enabled
   string            name;        // label text
   color             tint;        // drawing color
   TimeSpan          span;        // one-minute window
  };

SessionSetup g_sessions[SESSIONS];   // the five sessions
SlotSetup    g_times[SLOTS];         // the key times
CLayerState  g_done;                 // state after the last closed bar
CLayerState  g_view;                 // state including the bar in progress
int          g_doneBar = -1;         // index of the last closed bar applied
datetime     g_doneTime = 0;         // time of that bar
string       g_drawn[];              // objects drawn on the last render
string       g_alerted[];            // alerts already sent, by key

void CLayerState::Clear(void)
  {
   ArrayResize(marks,0);
   ArrayResize(frames,0);
   ArrayResize(opens,0);
   ArrayResize(stamps,0);
   ZeroMemory(totals);
   ArrayInitialize(runs,0);
   ArrayInitialize(topHits,0);
   ArrayInitialize(bottomHits,0);
   ArrayInitialize(firstRun,0);
   nextId=1;
  }

void CLayerState::CopyFrom(const CLayerState &src)
  {
   ArrayCopy(marks,src.marks);
   ArrayResize(marks,ArraySize(src.marks));
   ArrayCopy(frames,src.frames);
   ArrayResize(frames,ArraySize(src.frames));
   ArrayCopy(opens,src.opens);
   ArrayResize(opens,ArraySize(src.opens));
   ArrayCopy(stamps,src.stamps);
   ArrayResize(stamps,ArraySize(src.stamps));
   for(int f=0; f<FRAMES; f++)
      totals[f]=src.totals[f];
   for(int s=0; s<SESSIONS; s++)
     {
      runs[s]=src.runs[s];
      topHits[s]=src.topHits[s];
      bottomHits[s]=src.bottomHits[s];
      firstRun[s]=src.firstRun[s];
     }
   nextId=src.nextId;
  }

TimeSpan ParseSpan(string text,const bool single)
  {
   TimeSpan span;
   span.valid=false;
   StringReplace(text," ","");
   StringReplace(text,":","");
   string part[];
   int    count=StringSplit(text,'-',part);
   if(count!=(single ? 1 : 2))
      return(span);
   int edge[2];
   for(int k=0; k<count; k++)
     {
      string p=part[k];
      if(StringLen(p)==3)
         p="0"+p;
      if(StringLen(p)!=4)
         return(span);
      int hh=(int)StringToInteger(StringSubstr(p,0,2));
      int mm=(int)StringToInteger(StringSubstr(p,2,2));
      if(hh<0 || hh>23 || mm<0 || mm>59)
         return(span);
      edge[k]=hh*60+mm;
     }
   span.from=edge[0];
   span.to=single ? edge[0]+1 : (edge[1]==0 ? 1440 : edge[1]);
   span.valid=true;
   return(span);
  }

bool Inside(const TimeSpan &span,const int minute)
  {
   if(!span.valid)
      return(false);
   if(span.from<span.to)
      return(minute>=span.from && minute<span.to);
   return(minute>=span.from || minute<span.to);
  }

int SundayOf(const int year,const int month,const int n)
  {
   MqlDateTime d;
   ZeroMemory(d);
   d.year=year;
   d.mon=month;
   d.day=1;
   datetime first=StructToTime(d);
   TimeToStruct(first,d);
   int firstSunday=1+(7-d.day_of_week)%7;
   if(n>0)
      return(firstSunday+7*(n-1));
   MqlDateTime e;
   ZeroMemory(e);
   e.year=(month==12) ? year+1 : year;
   e.mon=(month==12) ? 1 : month+1;
   e.day=1;
   int days=(int)((StructToTime(e)-first)/86400);
   int last=firstSunday;
   while(last+7<=days)
      last+=7;
   return(last);
  }

datetime At(const int year,const int month,const int day,const int hour)
  {
   MqlDateTime d;
   ZeroMemory(d);
   d.year=year;
   d.mon=month;
   d.day=day;
   d.hour=hour;
   return(StructToTime(d));
  }

bool UsSummer(const datetime utc)
  {
   MqlDateTime d;
   TimeToStruct(utc,d);
   datetime begin=At(d.year,3,SundayOf(d.year,3,2),7);
   datetime end=At(d.year,11,SundayOf(d.year,11,1),6);
   return(utc>=begin && utc<end);
  }

bool EuSummer(const datetime utc)
  {
   MqlDateTime d;
   TimeToStruct(utc,d);
   datetime begin=At(d.year,3,SundayOf(d.year,3,0),1);
   datetime end=At(d.year,10,SundayOf(d.year,10,0),1);
   return(utc>=begin && utc<end);
  }

datetime ToClock(const datetime server)
  {
   datetime guess=server-InpServerGmt*3600;
   bool     summer=(InpServerDst==SERVER_DST_US) ? UsSummer(guess) :
                   (InpServerDst==SERVER_DST_EU) ? EuSummer(guess) : false;
   datetime utc=guess-(summer ? 3600 : 0);
   return(utc+(UsSummer(utc) ? -4 : -5)*3600);
  }

int ClockMinute(const datetime server)
  {
   return((int)((ToClock(server)%86400)/60));
  }

long PeriodKey(const int frame,const datetime t)
  {
   long day=(long)(t/86400);
   if(frame==0)
      return(day);
   if(frame==1)
      return((day+3)/7);
   MqlDateTime d;
   TimeToStruct(t,d);
   return((long)d.year*12+d.mon);
  }

void Notify(const bool live,const string key,const string text)
  {
   if(!live)
      return;
   for(int k=ArraySize(g_alerted)-1; k>=0; k--)
      if(g_alerted[k]==key)
         return;
   int n=ArraySize(g_alerted);
   ArrayResize(g_alerted,n+1);
   g_alerted[n]=key;
   Alert(_Symbol," ",text);
  }

void TrimMarks(CLayerState &st,const int slot)
  {
   int seen=0;
   for(int k=ArraySize(st.marks)-1; k>=0; k--)
     {
      if(st.marks[k].slot!=slot)
         continue;
      if(++seen>MathMax(1,InpKeep))
         ArrayRemove(st.marks,k,1);
     }
  }

void TrimFrames(CLayerState &st,const int frame,const int kind)
  {
   int seen=0,keep=MathMax(1,InpKeep);
   for(int k=ArraySize(st.frames)-1; k>=0; k--)
     {
      if(st.frames[k].frame!=frame || st.frames[k].kind!=kind)
         continue;
      if(++seen>keep)
         ArrayRemove(st.frames,k,1);
     }
  }

void TrimLines(TimeLine &list[],const int slot,const int keep)
  {
   int seen=0;
   for(int k=ArraySize(list)-1; k>=0; k--)
     {
      if(list[k].slot!=slot)
         continue;
      if(++seen>keep)
         ArrayRemove(list,k,1);
     }
  }

void StepSessions(CLayerState &st,const datetime t,const double hi,const double lo,
                  const int minute,const int prevMinute,const bool live)
  {
   for(int s=0; s<SESSIONS; s++)
     {
      if(!g_sessions[s].on)
         continue;
      bool now=Inside(g_sessions[s].span,minute);
      bool before=Inside(g_sessions[s].span,prevMinute);

      if(now && !before)
        {
         SessionMark m;
         ZeroMemory(m);
         m.slot=s;
         m.id=st.nextId++;
         m.opened=t;
         m.lastIn=t;
         m.top=hi;
         m.bottom=lo;
         m.topAt=t;
         m.bottomAt=t;
         m.topUntil=t;
         m.bottomUntil=t;
         m.midUntil=t;
         m.topOpen=true;
         m.bottomOpen=true;
         m.midOpen=true;
         int n=ArraySize(st.marks);
         ArrayResize(st.marks,n+1);
         st.marks[n]=m;
         st.runs[s]++;
         if(st.firstRun[s]==0)
            st.firstRun[s]=t;
         TrimMarks(st,s);
        }

      int rank=0;
      for(int k=ArraySize(st.marks)-1; k>=0; k--)
        {
         if(st.marks[k].slot!=s)
            continue;
         if(rank==0 && now)
           {
            st.marks[k].lastIn=t;
            if(hi>st.marks[k].top)
              {
               st.marks[k].top=hi;
               st.marks[k].topAt=t;
              }
            if(lo<st.marks[k].bottom)
              {
               st.marks[k].bottom=lo;
               st.marks[k].bottomAt=t;
              }
           }
         if(rank==0)
           {
            if(InpExtension==EXTEND_PAST_TAKEN || st.marks[k].topOpen)
               st.marks[k].topUntil=t;
            if(InpExtension==EXTEND_PAST_TAKEN || st.marks[k].bottomOpen)
               st.marks[k].bottomUntil=t;
            if(st.marks[k].topOpen && hi>st.marks[k].top)
              {
               st.marks[k].topOpen=false;
               st.topHits[s]++;
               if(InpAlerts && InpPivots)
                  Notify(

Показано первые 50% кода (символов: 21992)