shved_supply_and_demand
Download scriptThis script is designed to identify and visualize key "Supply and Demand" zones on a trading chart. It automatically detects areas where the price has historically encountered significant resistance or support, helping traders see where potential reversals or breakouts might occur.
Core Logic and Features
1. Dynamic Zone Detection The script scans historical price data to find "fractals"—specific high and low points in the market. It uses two different sensitivity levels (Fast and Slow) to identify these structural points. From these points, it calculates boundaries for supply (resistance) and demand (support) zones.
2. Zone Validation and Strength Not all identified zones are treated equally. The script evaluates each zone based on how the market has interacted with it over time:
- Untested: New areas that the price hasn't returned to yet.
- Verified/Proven: Zones that have been touched multiple times without breaking, indicating high stability.
- Weak: Areas with low historical significance.
- Turncoats: These are unique zones where the price has broken through once but has since "flipped" roles (e.g., old resistance becoming new support).
3. Automated Management To keep the chart clean and relevant, the script includes several automated maintenance features:
- Merging: If multiple overlapping zones are detected in the same price area, the script merges them into a single, more significant zone.
- Cleanup: It automatically deletes old or irrelevant data to ensure the chart remains readable.
- Persistence: It uses "Global Variables" to remember the status and history of these zones even when you switch timeframes or restart your platform.
4. Visual Indicators and Alerts The script provides a rich visual experience for the user:
- Color Coding: Different colors are assigned based on the strength and type of the zone (e.g., various shades of Green for Support and Red/Orange for Resistance).
- Labels: It places text labels on the chart identifying the "Strength" of the zone and how many times it has been "tested."
- Nearest Zone Tracking: It identifies and highlights the zones closest to the current live price.
- Real-time Alerts: You can enable pop-up notifications and sound alerts that trigger specifically when the current market price enters a identified Support or Resistance zone.
Summary for the User
Essentially, this tool acts as an automated "map" of the market. It looks back at history to find where the "walls" (Resistance) and "floors" (Support) are located, ranks them by how reliable they are, draws them on your chart clearly, and notifies you the moment the price touches one of these important levels.
//+------------------------------------------------------------------+
//| shved_supply_and_demand.mq4 |
//+------------------------------------------------------------------+
#property copyright "Shved"
#property link "http://ruforum_mt5_com/members/11434-shved"
#property description "edited by eevviill"
#property description "on-off zones,build 600+,nearest zones in buffers"
#property indicator_chart_window
#property indicator_buffers 8
#property indicator_color1 Red
#property indicator_color2 Red
#property indicator_color3 DodgerBlue
#property indicator_color4 DodgerBlue
extern int BackLimit=1000;
extern string pus1="/////////////////////////////////////////////////";
extern bool zone_show_weak=true;
extern bool zone_show_untested = true;
extern bool zone_show_turncoat = false;
extern double zone_fuzzfactor=0.75;
extern string pus2="/////////////////////////////////////////////////";
extern bool fractals_show=false;
extern double fractal_fast_factor = 3.0;
extern double fractal_slow_factor = 6.0;
extern bool SetGlobals=true;
extern string pus3="/////////////////////////////////////////////////";
extern bool zone_solid=true;
extern int zone_linewidth=1;
extern int zone_style=0;
extern bool zone_show_info=true;
extern int zone_label_shift=4;
extern bool zone_merge=true;
extern bool zone_extend=true;
extern string pus4="/////////////////////////////////////////////////";
extern bool zone_show_alerts = false;
extern bool zone_alert_popups = true;
extern bool zone_alert_sounds = true;
extern int zone_alert_waitseconds=300;
extern string pus5="/////////////////////////////////////////////////";
extern int Text_size=8;
extern string Text_font = "Courier New";
extern color Text_color = White;
extern string sup_name = "Sup";
extern string res_name = "Res";
extern string test_name= "Retests";
extern color color_support_weak = DarkSlateGray;
extern color color_support_untested = SeaGreen;
extern color color_support_verified = Green;
extern color color_support_proven = LimeGreen;
extern color color_support_turncoat = OliveDrab;
extern color color_resist_weak = Indigo;
extern color color_resist_untested = Orchid;
extern color color_resist_verified = Crimson;
extern color color_resist_proven = Red;
extern color color_resist_turncoat = DarkOrange;
double FastDnPts[],FastUpPts[];
double SlowDnPts[],SlowUpPts[];
double zone_hi[1000],zone_lo[1000];
int zone_start[1000],zone_hits[1000],zone_type[1000],zone_strength[1000],zone_count=0;
bool zone_turn[1000];
#define ZONE_SUPPORT 1
#define ZONE_RESIST 2
#define ZONE_WEAK 0
#define ZONE_TURNCOAT 1
#define ZONE_UNTESTED 2
#define ZONE_VERIFIED 3
#define ZONE_PROVEN 4
#define UP_POINT 1
#define DN_POINT -1
int time_offset=0;
double ner_lo_zone_P1[];
double ner_lo_zone_P2[];
double ner_hi_zone_P1[];
double ner_hi_zone_P2[];
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
int init()
{
IndicatorBuffers(4);
SetIndexBuffer(0,SlowDnPts);
SetIndexBuffer(1,SlowUpPts);
SetIndexBuffer(2,FastDnPts);
SetIndexBuffer(3,FastUpPts);
if(fractals_show==true)
{
SetIndexStyle(0,DRAW_ARROW,0,3);
SetIndexStyle(1,DRAW_ARROW,0,3);
SetIndexStyle(2,DRAW_ARROW,0,1);
SetIndexStyle(3,DRAW_ARROW,0,1);
SetIndexArrow(0,218);
SetIndexArrow(1,217);
SetIndexArrow(2,218);
SetIndexArrow(3,217);
}
else
{
SetIndexStyle(0,DRAW_NONE);
SetIndexStyle(1,DRAW_NONE);
SetIndexStyle(2,DRAW_NONE);
SetIndexStyle(3,DRAW_NONE);
}
SetIndexBuffer(4,ner_hi_zone_P1);
SetIndexBuffer(5,ner_hi_zone_P2);
SetIndexBuffer(6,ner_lo_zone_P1);
SetIndexBuffer(7,ner_lo_zone_P2);
SetIndexStyle(4,DRAW_NONE);
SetIndexStyle(5,DRAW_NONE);
SetIndexStyle(6,DRAW_NONE);
SetIndexStyle(7,DRAW_NONE);
SetIndexLabel(4,"ner up zone P1");
SetIndexLabel(5,"ner up zone P2");
SetIndexLabel(6,"ner dn zone P1");
SetIndexLabel(7,"ner dn zone P2");
IndicatorDigits(Digits);
return(0);
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
int deinit()
{
DeleteZones();
DeleteGlobalVars();
return(0);
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
int start()
{
if(NewBar()==true)
{
int old_zone_count=zone_count;
FastFractals();
SlowFractals();
DeleteZones();
FindZones();
DrawZones();
if(zone_count<old_zone_count)
DeleteOldGlobalVars(old_zone_count);
}
if(zone_show_info==true)
{
for(int i=0; i<zone_count; i++)
{
string lbl;
if(zone_strength[i]==ZONE_PROVEN)
lbl="Proven";
else if(zone_strength[i]==ZONE_VERIFIED)
lbl="Verified";
else if(zone_strength[i]==ZONE_UNTESTED)
lbl="Untested";
else if(zone_strength[i]==ZONE_TURNCOAT)
lbl="Turncoat";
else
lbl="Weak";
if(zone_type[i]==ZONE_SUPPORT)
lbl=lbl+" "+sup_name;
else
lbl=lbl+" "+res_name;
if(zone_hits[i]>0 && zone_strength[i]>ZONE_UNTESTED)
{
if(zone_hits[i]==1)
lbl=lbl+", "+test_name+"="+zone_hits[i];
else
lbl=lbl+", "+test_name+"="+zone_hits[i];
}
int adjust_hpos;
int wbpc=WindowBarsPerChart();
int k=Period()*60+(20+StringLen(lbl));
if(wbpc<80)
adjust_hpos=Time[0]+k*4;
else if(wbpc<125)
adjust_hpos=Time[0]+k*8;
else if(wbpc<250)
adjust_hpos=Time[0]+k*15;
else if(wbpc<480)
adjust_hpos=Time[0]+k*29;
else if(wbpc<950)
adjust_hpos=Time[0]+k*58;
else
adjust_hpos=Time[0]+k*115;
//
int shift=k*zone_label_shift;
double vpos=zone_hi[i]-(zone_hi[i]-zone_lo[i])/2;
if(zone_strength[i]==ZONE_WEAK && zone_show_weak==false)
continue;
if(zone_strength[i]==ZONE_UNTESTED && zone_show_untested==false)
continue;
if(zone_strength[i]==ZONE_TURNCOAT && zone_show_turncoat==false)
continue;
string s="SSSR#"+i+"LBL";
ObjectCreate(s,OBJ_TEXT,0,0,0);
ObjectSet(s,OBJPROP_TIME1,adjust_hpos+shift);
ObjectSet(s,OBJPROP_PRICE1,vpos);
ObjectSetText(s,StringRightPad(lbl,36," "),Text_size,Text_font,Text_color);
}
}
CheckAlerts();
return(0);
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
void CheckAlerts()
{
static int lastalert=0;
if(zone_show_alerts==false)
return;
if(Time[0]-lastalert>zone_alert_waitseconds)
if(CheckEntryAlerts()==true)
lastalert=Time[0];
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CheckEntryAlerts()
{
// check for entries
for(int i=0; i<zone_count; i++)
{
if(Close[0]>=zone_lo[i] && Close[0]<zone_hi[i])
{
if(zone_show_alerts==true)
{
if(zone_alert_popups==true)
{
if(zone_type[i]==ZONE_SUPPORT)
Alert(Symbol()+TimeFrameToString(Period())+": Support Zone Entered");
else
Alert(Symbol()+TimeFrameToString(Period())+": Resistance Zone Entered");
}
if(zone_alert_sounds==true)
PlaySound("alert_wav");
}
return(true);
}
}
return(false);
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
void DeleteGlobalVars()
{
if(SetGlobals==false)
return;
GlobalVariableDel("SSSR_Count_"+Symbol()+Period());
GlobalVariableDel("SSSR_Updated_"+Symbol()+Period());
int old_count=zone_count;
zone_count=0;
DeleteOldGlobalVars(old_count);
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
void DeleteOldGlobalVars(int old_count)
{
if(SetGlobals==false)
return;
for(int i=zone_count; i<old_count; i++)
{
GlobalVariableDel("SSSR_HI_"+Symbol()+Period()+i);
GlobalVariableDel("SSSR_LO_"+Symbol()+Period()+i);
GlobalVariableDel("SSSR_HITS_"+Symbol()+Period()+i);
GlobalVariableDel("SSSR_STRENGTH_"+Symbol()+Period()+i);
GlobalVariableDel("SSSR_AGE_"+Symbol()+Period()+i);
}
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
void FindZones()
{
int i,j,shift,bustcount=0,testcount=0;
double hival,loval;
bool turned=false,hasturned=false;
double temp_hi[1000],temp_lo[1000];
int temp_start[1000],temp_hits[1000],temp_strength[1000],temp_count=0;
bool temp_turn[1000],temp_merge[1000];
int merge1[1000],merge2[1000],merge_count=0;
// iterate through zones from oldest to youngest (ignore recent 5 bars),
// finding those that have survived through to the present___
for(shift=MathMin(Bars-1,BackLimit); shift>5; shift--)
{
double atr= iATR(NULL,0,7,shift);
double fu = atr/2 * zone_fuzzfactor;
bool isWeak;
bool touchOk= false;
bool isBust = false;
if(FastUpPts[shift]>0.001)
{
// a zigzag high point
isWeak=true;
if(SlowUpPts[shift]>0.001)
isWeak=false;
hival=High[shift];
if(zone_extend==true)
hival+=fu;
loval=MathMax(MathMin(Close[shift],High[shift]-fu),High[shift]-fu*2);
turned=false;
hasturned=false;
isBust=false;
bustcount = 0;
testcount = 0;
for(i=shift-1; i>=0; i--)
{
if((turned==false && FastUpPts[i]>=loval && FastUpPts[i]<=hival) ||
(turned==true && FastDnPts[i]<=hival && FastDnPts[i]>=loval))
{
// Potential touch, just make sure its been 10+candles since the prev one
touchOk=true;
for(j=i+1; j<i+11; j++)
{
if((turned==false && FastUpPts[j]>=loval && FastUpPts[j]<=hival) ||
(turned==true && FastDnPts[j]<=hival && FastDnPts[j]>=loval))
{
touchOk=false;
break;
}
}
if(touchOk==true)
{
// we have a touch_ If its been busted once, remove bustcount
// as we know this level is still valid & has just switched sides
bustcount=0;
testcount++;
}
}
if((turned==false && High[i]>hival) ||
(turned==true && Low[i]<loval))
{
// this level has been busted at least once
bustcount++;
if(bustcount>1 || isWeak==true)
{
// busted twice or more
isBust=true;
break;
}
if(turned == true)
turned = false;
else if(turned==false)
turned=true;
hasturned=true;
// forget previous hits
testcount=0;
}
}
if(isBust==false)
{
// level is still valid, add to our list
temp_hi[temp_count] = hival;
temp_lo[temp_count] = loval;
temp_turn[temp_count] = hasturned;
temp_hits[temp_count] = testcount;
temp_start[temp_count] = shift;
temp_merge[temp_count] = false;
if(testcount>3)
temp_strength[temp_count]=ZONE_PROVEN;
else if(testcount>0)
temp_strength[temp_count]=ZONE_VERIFIED;
else if(hasturned==true)
temp_strength[temp_count]=ZONE_TURNCOAT;
else if(isWeak==false)
temp_strength[temp_count]=ZONE_UNTESTED;
else
temp_strength[temp_count]=ZONE_WEAK;
temp_count++;
}
}
else if(FastDnPts[shift]>0.001)
{
// a zigzag low point
isWeak=true;
if(SlowDnPts[shift]>0.001)
isWeak=false;
loval=Low[shift];
if(zone_extend==true)
loval-=fu;
hival=MathMin(MathMax(Close[shift],Low[shift]+fu),Low[shift]+fu*2);
turned=false;
hasturned=false;
bustcount = 0;
testcount = 0;
isBust=false;
for(i=shift-1; i>=0; i--)
{
if((turned==true && FastUpPts[i]>=loval && FastUpPts[i]<=hival) ||
(turned==false && FastDnPts[i]<=hival && FastDnPts[i]>=loval))
{
// Potential touch, just make sure its been 10+candles since the prev one
touchOk=true;
for(j=i+1; j<i+11; j++)
{
if((turned==true && FastUpPts[j]>=loval && FastUpPts[j]<=hival) ||
(turned==false && FastDnPts[j]<=hival && FastDnPts[j]>=loval))
{
touchOk=false;
break;
}
}
if(touchOk==true)
{
// we have a touch_ If its been busted once, remove bustcount
// as we know this level is still valid & has just switched sides
bustcount=0;
testcount++;
}
}
if((turned==true && High[i]>hival) ||
(turned==false && Low[i]<loval))
{
// this level has been busted at least once
bustcount++;
if(bustcount>1 || isWeak==true)
{
// busted twice or more
isBust=true;
break;
}
if(turned == true)
turned = false;
else if(turned==false)
turned=true;
hasturned=true;
// forget previous hits
testcount=0;
}
}
if(isBust==false)
{
// level is still valid, add to our list
temp_hi[temp_count] = hival;
temp_lo[temp_count] = loval;
temp_turn[temp_count] = hasturned;
temp_hits[temp_count] = testcount;
temp_start[temp_count] = shift;
temp_merge[temp_count] = false;
if(testcount>3)
temp_strength[temp_count]=ZONE_PROVEN;
else if(testcount>0)
temp_strength[temp_count]=ZONE_VERIFIED;
else if(hasturned==true)
temp_strength[temp_count]=ZONE_TURNCOAT;
else if(isWeak==false)
temp_strength[temp_count]=ZONE_UNTESTED;
else
temp_strength[temp_count]=ZONE_WEAK;
temp_count++;
}
}
}
// look for overlapping zones___
if(zone_merge==true)
{
merge_count=1;
int iterations=0;
while(merge_count>0 && iterations<3)
{
merge_count=0;
iterations++;
for(i=0; i<temp_count; i++)
temp_merge[i]=false;
for(i=0; i<temp_count-1; i++)
{
if(temp_hits[i]==-1 || temp_merge[j]==true)
continue;
for(j=i+1; j<temp_count; j++)
{
if(temp_hits[j]==-1 || temp_merge[j]==true)
continue;
if((temp_hi[i]>=temp_lo[j] && temp_hi[i]<=temp_hi[j]) ||
(temp_lo[i] <= temp_hi[j] && temp_lo[i] >= temp_lo[j]) ||
(temp_hi[j] >= temp_lo[i] && temp_hi[j] <= temp_hi[i]) ||
(temp_lo[j] <= temp_hi[i] && temp_lo[j] >= temp_lo[i]))
{
merge1[merge_count] = i;
merge2[merge_count] = j;
temp_merge[i] = true;
temp_merge[j] = true;
merge_count++;
}
}
}
// ___ and merge them ___
for(i=0; i<merge_count; i++)
{
int target = merge1[i];
int source = merge2[i];
temp_hi[target] = MathMax(temp_hi[target], temp_hi[source]);
temp_lo[target] = MathMin(temp_lo[target], temp_lo[source]);
temp_hits[target] += temp_hits[source];
temp_start[target] = MathMax(temp_start[target], temp_start[source]);
temp_strength[target]=MathMax(temp_strength[target],temp_strength[source]);
if(temp_hits[target]>3)
temp_strength[target]=ZONE_PROVEN;
if(temp_hits[target]==0 && temp_turn[target]==false)
{
temp_hits[target]=1;
if(temp_strength[target]<ZONE_VERIFIED)
temp_strength[target]=ZONE_VERIFIED;
}
if(temp_turn[target] == false || temp_turn[source] == false)
temp_turn[target] = false;
if(temp_turn[target] == true)
temp_hits[target] = 0;
temp_hits[source]=-1;
}
}
}
// copy the remaining list into our official zones arrays
zone_count=0;
for(i=0; i<temp_count; i++)
{
if(temp_hits[i]>=0 && zone_count<1000)
{
zone_hi[zone_count] = temp_hi[i];
zone_lo[zone_count] = temp_lo[i];
zone_hits[zone_count] = temp_hits[i];
zone_turn[zone_count] = temp_turn[i];
zone_start[zone_count] = temp_start[i];
zone_strength[zone_count] = temp_strength[i];
if(zone_hi[zone_count]<Close[4])
zone_type[zone_count]=ZONE_SUPPORT;
else if(zone_lo[zone_count]>Close[4])
zone_type[zone_count]=ZONE_RESIST;
else
{
for(j=5; j<1000; j++)
{
if(Close[j]<zone_lo[zone_count])
{
zone_type[zone_count]=ZONE_RESIST;
break;
}
else if(Close[j]>zone_hi[zone_count])
{
zone_type[zone_count]=ZONE_SUPPORT;
break;
}
}
if(j==1000)
zone_type[zone_count]=ZONE_SUPPORT;
}
zone_count++;
}
}
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
void DrawZones()
{
double lower_nerest_zone_P1=0;
double lower_nerest_zone_P2=0;
double higher_nerest_zone_P1=EMPTY_VALUE;
double higher_nerest_zone_P2=EMPTY_VALUE;
if(SetGlobals==true)
{
GlobalVariableSet("SSSR_Count_"+Symbol()+Period(),zone_count);
GlobalVariableSet("SSSR_Updated_"+Symbol()+Period(),TimeCurrent());
}
for(int i=0; i<zone_count; i++)
{
if(zone_strength[i]==ZONE_WEAK && zone_show_weak==false)
continue;
if(zone_strength[i]==ZONE_UNTESTED && zone_show_untested==false)
continue;
if(zone_strength[i]==ZONE_TURNCOAT && zone_show_turncoat==false)
continue;
//name sup
if(zone_type[i]==ZONE_SUPPORT)
string s="SSSR#S"+i+" Strength=";
else
//name res
s="SSSR#R"+i+" Strength=";
if(zone_strength[i]==ZONE_PROVEN)
s=s+"Proven, Test Count="+zone_hits[i];
else if(zone_strength[i]==ZONE_VERIFIED)
s=s+"Verified, Test Count="+zone_hits[i];
else if(zone_strength[i]==ZONE_UNTESTED)
s=s+"Untested";
else if(zone_strength[i]==ZONE_TURNCOAT)
s=s+"Turncoat";
else
s=s+"Weak";
ObjectCreate(s,OBJ_RECTANGLE,0,0,0,0,0);
ObjectSet(s,OBJPROP_TIME1,Time[zone_start[i]]);
ObjectSet(s,OBJPROP_TIME2,Time[0]);
ObjectSet(s,OBJPROP_PRICE1,zone_hi[i]);
ObjectSet(s,OBJPROP_PRICE2,zone_lo[i]);
ObjectSet(s,OBJPROP_BACK,zone_solid);
ObjectSet(s,OBJPROP_WIDTH,zone_linewidth);
ObjectSet(s,OBJPROP_STYLE,zone_style);
if(zone_type[i]==ZONE_SUPPORT)
{
// support zone
if(zone_strength[i]==ZONE_TURNCOAT)
ObjectSet(s,OBJPROP_COLOR,color_support_turncoat);
else if(zone_strength[i]==ZONE_PROVEN)
ObjectSet(s,OBJPROP_COLOR,color_support_proven);
else if(zone_strength[i]==ZONE_VERIFIED)
ObjectSet(s,OBJPROP_COLOR,color_support_verified);
else if(zone_strength[i]==ZONE_UNTESTED)
ObjectSet(s,OBJPROP_COLOR,color_support_untested);
else
ObjectSet(s,OBJPROP_COLOR,color_support_weak);
}
else
{
// resistance zone
if(zone_strength[i]==ZONE_TURNCOAT)
ObjectSet(s,OBJPROP_COLOR,color_resist_turncoat);
else if(zone_strength[i]==ZONE_PROVEN)
ObjectSet(s,OBJPROP_COLOR,color_resist_proven);
else if(zone_strength[i]==ZONE_VERIFIED)
ObjectSet(s,OBJPROP_COLOR,color_resist_verified);
else if(zone_strength[i]==ZONE_UNTESTED)
ObjectSet(s,OBJPROP_COLOR,color_resist_untested);
else
ObjectSet(s,OBJPROP_COLOR,color_resist_weak);
}
if(SetGlobals==true)
{
GlobalVariableSet("SSSR_HI_"+Symbol()+Period()+i,zone_hi[i]);
GlobalVariableSet("SSSR_LO_"+Symbol()+Period()+i,zone_lo[i]);
GlobalVariableSet("SSSR_HITS_"+Symbol()+Period()+i,zone_hits[i]);
GlobalVariableSet("SSSR_STRENGTH_"+Symbol()+Period()+i,zone_strength[i]);
GlobalVariableSet("SSSR_AGE_"+Symbol()+Period()+i,zone_start[i]);
}
//nearest zones
if(zone_lo[i]>lower_nerest_zone_P2 && Bid>zone_lo[i]) {lower_nerest_zone_P1=zone_hi[i];lower_nerest_zone_P2=zone_lo[i];}
if(zone_hi[i]<higher_nerest_zone_P1 && Bid<zone_hi[i]) {higher_nerest_zone_P1=zone_hi[i];higher_nerest_zone_P2=zone_lo[i];}
}
ner_hi_zone_P1[0]=higher_nerest_zone_P1;
ner_hi_zone_P2[0]=higher_nerest_zone_P2;
ner_lo_zone_P1[0]=lower_nerest_zone_P1;
ner_lo_zone_P2[0]=lower_nerest_zone_P2;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool Fractal(int M,int P,int shift)
{
if(Period()>P)
P=Period();
P=P/Period()*2+MathCeil(P/Period()/2);
if(shift<P)
return(false);
if(shift>Bars-P)
return(false);
for(int i=1; i<=P; i++)
{
if(M==UP_POINT)
{
if(High[shift+i]>High[shift])
return(false);
if(High[shift-i]>=High[shift])
return(false);
}
if(M==DN_POINT)
{
if(Low[shift+i]<Low[shift])
return(false);
if(Low[shift-i]<=Low[shift])
return(false);
}
}
return(true);
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
void FastFractals()
{
int shift;
int limit=MathMin(Bars-1,BackLimit);
int P=Period()*fractal_fast_factor;
FastUpPts[0] = 0.0; FastUpPts[1] = 0.0;
FastDnPts[0] = 0.0; FastDnPts[1] = 0.0;
for(shift=limit; shift>1; shift--)
{
if(Fractal(UP_POINT,P,shift)==true)
FastUpPts[shift]=High[shift];
else
FastUpPts[shift]=0.0;
if(Fractal(DN_POINT,P,shift)==true)
FastDnPts[shift]=Low[shift];
else
FastDnPts[shift]=0.0;
}
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
void SlowFractals()
{
int shift;
int limit=MathMin(Bars-1,BackLimit);
int P=Period()*fractal_slow_factor;
SlowUpPts[0] = 0.0; SlowUpPts[1] = 0.0;
SlowDnPts[0] = 0.0; SlowDnPts[1] = 0.0;
for(shift=limit; shift>1; shift--)
{
if(Fractal(UP_POINT,P,shift)==true)
SlowUpPts[shift]=High[shift];
else
SlowUpPts[shift]=0.0;
if(Fractal(DN_POINT,P,shift)==true)
SlowDnPts[shift]=Low[shift];
else
SlowDnPts[shift]=0.0;
}
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool NewBar()
{
static datetime LastTime=0;
if(iTime(Symbol(),Period(),0)+time_offset!=LastTime)
{
LastTime=iTime(Symbol(),Period(),0)+time_offset;
return (true);
}
else
return (false);
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
void DeleteZones()
{
int len=5;
int i;
while(i<ObjectsTotal())
{
string objName=ObjectName(i);
if(StringSubstr(objName,0,len)!="SSSR#")
{
i++;
continue;
}
ObjectDelete(objName);
}
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
string TimeFrameToString(int tf) //code by TRO
{
string tfs;
switch(tf)
{
case PERIOD_M1:
tfs="M1";
break;
case PERIOD_M5:
tfs="M5";
break;
case PERIOD_M15:
tfs="M15";
break;
case PERIOD_M30:
tfs="M30";
break;
case PERIOD_H1:
tfs="H1";
break;
case PERIOD_H4:
tfs="H4";
break;
case PERIOD_D1:
tfs="D1";
break;
case PERIOD_W1:
tfs="W1";
break;
case PERIOD_MN1:
tfs="MN";
}
return(tfs);
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
string StringRepeat(string str,int n=1)
{
string outstr="";
for(int i=0; i<n; i++) outstr=outstr+str;
return(outstr);
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
string StringRightPad(string str,int n=1,string str2=" ")
{
return(str + StringRepeat(str2,n-StringLen(str)));
}
//+------------------------------------------------------------------+
Comments