hi there,
thanks for your hard work
i always appreciate you
Please i have a code but need some alteration some changes the way robot works and these changes are
1.Add Enable robot to trade once per bar if a trade is close due to take profit robot will open next trade on next bar.
2.Robot will operate Moving average time period as chart or selected in the robot properties.
So basically robot is all fine but need to modify these two parameters into the code so we can select once per bar and time frame of robot from robot property.
Hi there
one thing i have not added before is that if using Moving Average trend or any other trend indicator Robot does no follow the trend which is a problem.
For example if using MA 10 H1 and price is above MA robot opens long trade but when price comes below MA it is not opening any short trade which it should.
So if you modify the given code please also modify it that robot opens short and long both if price is above and below MA.If price is above MA and there is a opened long trade which is waiting for TP but price droped Below MA then Robot should open a short trade and keep the long trade open and donot close on reversal signal and if price keep dropping below the MA robot keep Taking the Short trade TP and opening Short Trade on new BAR But not opening new long trade as price is below MA and viseversa.thanks
thanks
the code is
//+------------------------------------------------------------------+
//| Blessing Moving Average.mq4 |
//| Copyright 2021, Muhammad Nadeem |
//| Muhammad.Adeeb |
//+------------------------------------------------------------------+
#property copyright "Copyright 2021, Muhammad Nadeem"
#property link "Muhammad.Adeeb"
#property version "1.00"
#include <stdlib.mqh>
#include <stderror.mqh>
#include <WinUser32.mqh>
#define A 1 //All (Basket + Hedge)
#define B 2 //Basket
#define H 3 //Hedge
#define T 4 //Ticket
#define P 5 //Pending
//+-----------------------------------------------------------------+
//| External Parameters Set |
//+-----------------------------------------------------------------+
extern string Version_3_9_6 = "EA Settings:";
extern string TradeComment = "Blessing 3.9.6.09";
// Enter a manual number to identify this EA
extern int MagicNum = 1789600;
// Enter a unique number to identify this EA
extern int EANumber = 1;
// Setting this to true will close all open orders immediately
extern bool EmergencyCloseAll = false;
extern string LabelAcc = "Account Trading Settings:";
// Setting this to true will stop the EA trading after any open trades have been closed
extern bool ShutDown = false;
// percent of account balance lost before trading stops
extern double StopTradePercent = 10;
// set to true for nano "penny a pip" account (contract size is $10,000)
extern bool NanoAccount = false;
// Percentage of account you want to trade on this pair
extern double PortionPC = 100;
// If Basket open: 0=no Portion change;1=allow portion to increase; -1=allow increase and decrease
extern int PortionChange = 1;
// Percent of portion for max drawdown level.
extern double MaxDDPercent = 50;
// Maximum allowed spread while placing trades
extern double MaxSpread = 5;
// Will shutdown over holiday period
extern bool UseHolidayShutdown = true;
// List of holidays, each seperated by a comma, [day]/[mth]-[day]/[mth], dates inclusive
extern string Holidays = "18/12-01/01";
// will sound alarms
extern bool PlaySounds = false;
// Alarm sound to be played
extern string AlertSound = "Alert.wav";
extern string LabelIES = "Indicator / Entry Settings:";
// Stop/Limits for entry if true, Buys/Sells if false
extern bool B3Traditional = false;
// Market condition 0=uptrend 1=downtrend 2=range 3=off
extern int ForceMarketCond = 2;
// true = ANY entry can be used to open orders, false = ALL entries used to open orders
extern bool UseAnyEntry = false;
// 0 = Off, 1 = will base entry on MA channel, 2 = will trade in reverse
extern int MAEntry = 1;
// 0 = Off, 1 = will base entry on CCI indicator, 2 = will trade in reverse
extern int CCIEntry = 0;
// 0 = Off, 1 = will base entry on BB, 2 = will trade in reverse
extern int BollingerEntry = 0;
// 0 = Off, 1 = will base entry on Stoch, 2 = will trade in reverse
extern int StochEntry = 0;
// 0 = Off, 1 = will base entry on MACD, 2 = will trade in reverse
extern int MACDEntry = 0;
extern string LabelLS = "Lot Size Settings:";
// Money Management
extern bool UseMM = true;
// Adjusts MM base lot for large accounts
extern double LAF = 0.5;
// Starting lots if Money Management is off
extern double Lot = 0.01;
// Multiplier on each level
extern double Multiplier = 1.4;
extern string LabelGS = "Grid Settings:";
// Auto calculation of TakeProfit and Grid size;
extern bool AutoCal = false;
extern string LabelATRTFr = "0:Chart, 1:M1, 2:M5, 3:M15, 4:M30, 5:H1, 6:H4, 7:D1, 8:W1, 9:MN1";
// TimeFrame for ATR calculation
extern int ATRTF = 0;
// Number of periods for the ATR calculation
extern int ATRPeriods = 21;
// Widens/Squishes Grid on increments/decrements of .1
extern double GAF = 1.0;
// Time Grid in seconds, to avoid opening of lots of levels in fast market
extern int EntryDelay = 2400;
// In pips, used in conjunction with logic to offset first trade entry
extern double EntryOffset = 5;
// True = use RSI/MA calculation for next grid order
extern bool UseSmartGrid = true;
extern string LabelTS = "Trading Settings:";
// Maximum number of trades to place (stops placing orders when reaches MaxTrades)
extern int MaxTrades = 15;
// Close All level, when reaches this level, doesn't wait for TP to be hit
extern int BreakEvenTrade = 12;
// Pips added to Break Even Point before BE closure
extern double BEPlusPips = 2;
// True = will close the oldest open trade after CloseTradesLevel is reached
extern bool UseCloseOldest = false;
// will start closing oldest open trade at this level
extern int CloseTradesLevel = 5;
// Will close the oldest trade whether it has potential profit or not
extern bool ForceCloseOldest = true;
// Maximum number of oldest trades to close
extern int MaxCloseTrades = 4;
// After Oldest Trades have closed, Forces Take Profit to BE +/- xx Pips
extern double CloseTPPips = 10;
// Force Take Profit to BE +/- xx Pips
extern double ForceTPPips = 0;
// Ensure Take Profit is at least BE +/- xx Pips
extern double MinTPPips = 0;
extern string LabelHS = "Hedge Settings:";
// Enter the Symbol of the same/correlated pair EXACTLY as used by your broker.
extern string HedgeSymbol = "";
// Number of days for checking Hedge Correlation
extern int CorrPeriod = 30;
// Turns DD hedge on/off
extern bool UseHedge = false;
// DD = start hedge at set DD;Level = Start at set level
extern string DDorLevel = "DD";
// DD Percent or Level at which Hedge starts
extern double HedgeStart = 20;
// Hedge Lots = Open Lots * hLotMult
extern double hLotMult = 0.8;
// DD Hedge maximum pip loss - also hedge trailing stop
extern double hMaxLossPips = 30;
// true = fixed SL at hMaxLossPips
extern bool hFixedSL = false;
// Hedge Take Profit
extern double hTakeProfit = 30;
// Increase to HedgeStart to stop early re-entry of the hedge
extern double hReEntryPC = 5;
// True = Trailing Stop will stop at BE;False = Hedge will continue into profit
extern bool StopTrailAtBE = true;
// False = Trailing Stop is Fixed;True = Trailing Stop will reduce after BE is reached
extern bool ReduceTrailStop = true;
extern string LabelES = "Exit Settings:";
// Turns on TP move and Profit Trailing Stop Feature
extern bool MaximizeProfit = false;
// Locks in Profit at this percent of Total Profit Potential
extern double ProfitSet = 70;
// Moves TP this amount in pips
extern double MoveTP = 30;
// Number of times you want TP to move before stopping movement
extern int TotalMoves = 2;
// Use Stop Loss and/or Trailing Stop Loss
extern bool UseStopLoss = false;
// Pips for fixed StopLoss from BE, 0=off
extern double SLPips = 30;
// Pips for trailing stop loss from BE + TSLPips: +ve = fixed trail; -ve = reducing trail; 0=off
extern double TSLPips = 10;
// Minimum trailing stop pips if using reducing TS
extern double TSLPipsMin = 3;
// Transmits a SL in case of internet loss
extern bool UsePowerOutSL = false;
// Power Out Stop Loss in pips
extern double POSLPips = 600;
// Close trades in FIFO order
extern bool UseFIFO = false;
extern string LabelEE = "Early Exit Settings:";
// Reduces ProfitTarget by a percentage over time and number of levels open
extern bool UseEarlyExit = false;
// Number of Hours to wait before EE over time starts
extern double EEStartHours = 3;
// true = StartHours from FIRST trade: false = StartHours from LAST trade
extern bool EEFirstTrade = true;
// Percentage reduction per hour (0 = OFF)
extern double EEHoursPC = 0.5;
// Number of Open Trades before EE over levels starts
extern int EEStartLevel = 5;
// Percentage reduction at each level (0 = OFF)
extern double EELevelPC = 10;
// true = Will allow the basket to close at a loss : false = Minimum profit is Break Even
extern bool EEAllowLoss = false;
extern string LabelAdv = "Advanced Settings Change sparingly";
extern string LabelGrid = "Grid Size Settings:";
// Specifies number of open trades in each block (separated by a comma)
extern string SetCountArray = "4,4";
// Specifies number of pips away to issue limit order (separated by a comma)
extern string GridSetArray = "25,50,100";
// Take profit for each block (separated by a comma)
extern string TP_SetArray = "50,100,200";
extern string LabelMA = "MA Entry Settings:";
// Period of MA (H4 = 100, H1 = 400)
extern int MAPeriod = 100;
// Distance from MA to be treated as Ranging Market
extern double MADistance = 10;
extern string LabelCCI = "CCI Entry Settings:";
// Period for CCI calculation
extern int CCIPeriod = 14;
extern string LabelBBS = "Bollinger Bands Entry Settings:";
// Period for Bollinger
extern int BollPeriod = 10;
// Up/Down spread
extern double BollDistance = 10;
// Standard deviation multiplier for channel
extern double BollDeviation = 2.0;
extern string LabelSto = "Stochastic Entry Settings:";
// Determines Overbought and Oversold Zones
extern int BuySellStochZone = 20;
// Stochastic KPeriod
extern int KPeriod = 10;
// Stochastic DPeriod
extern int DPeriod = 2;
// Stochastic Slowing
extern int Slowing = 2;
extern string LabelMACD = "MACD Entry Settings:";
extern string LabelMACDTF = "0:Chart, 1:M1, 2:M5, 3:M15, 4:M30, 5:H1, 6:H4, 7:D1, 8:W1, 9:MN1";
// Time frame for MACD calculation
extern int MACD_TF = 0;
// MACD EMA Fast Period
extern int FastPeriod = 12;
// MACD EMA Slow Period
extern int SlowPeriod = 26;
// MACD EMA Signal Period
extern int SignalPeriod = 9;
// 0=close, 1=open, 2=high, 3=low, 4=HL/2, 5=HLC/3 6=HLCC/4
extern int MACDPrice = 0;
extern string LabelSG = "Smart Grid Settings:";
extern string LabelSGTF = "0:Chart, 1:M1, 2:M5, 3:M15, 4:M30, 5:H1, 6:H4, 7:D1, 8:W1, 9:MN1";
// Timeframe for RSI calculation - should be less than chart TF.
extern int RSI_TF = 3;
// Period for RSI calculation
extern int RSI_Period = 14;
// 0=close, 1=open, 2=high, 3=low, 4=HL/2, 5=HLC/3 6=HLCC/4
extern int RSI_Price = 0;
// Period for MA of RSI calculation
extern int RSI_MA_Period = 10;
// 0=Simple MA, 1=Exponential MA, 2=Smoothed MA, 3=Linear Weighted MA
extern int RSI_MA_Method = 0;
extern string LabelOS = "Other Settings:";
// true = Recoup any Hedge/CloseOldest losses: false = Use original profit target.
extern bool RecoupClosedLoss = true;
// Largest Assumed Basket size. Lower number = higher start lots
extern int Level = 7;
// Adjusts opening and closing orders by "slipping" this amount
extern int slip = 99;
// true = will save equity statistics
extern bool SaveStats = false;
// seconds between stats entries - off by default
extern int StatsPeriod = 3600;
// true for backtest - false for forward/live to ACCUMULATE equity traces
extern bool StatsInitialise = true;
extern string LabelUE = "Email Settings:";
extern bool UseEmail = false;
extern string LabelEDD = "At what DD% would you like Email warnings (Max: 49, Disable: 0)?";
extern double EmailDD1 = 20;
extern double EmailDD2 = 30;
extern double EmailDD3 = 40;
extern string LabelEH = "Number of hours before DD timer resets";
// Minimum number of hours between emails
extern double EmailHours = 24;
extern string LabelDisplay = "Used to Adjust Overlay";
// Turns the display on and off
extern bool displayOverlay = true;
// Turns off copyright and icon
extern bool displayLogo = true;
// Turns off the CCI display
extern bool displayCCI = true;
// Show BE, TP and TS lines
extern bool displayLines = true;
// Moves display left and right
extern int displayXcord = 100;
// Moves display up and down
extern int displayYcord = 22;
// Moves CCI display left and right
extern int displayCCIxCord = 10;
//Display font
extern string displayFont = "Arial Bold";
// Changes size of display characters
extern int displayFontSize = 9;
// Changes space between lines
extern int displaySpacing = 14;
// Ratio to increase label width spacing
extern double displayRatio = 1;
// default color of display characters
extern color displayColor = DeepSkyBlue;
// default color of profit display characters
extern color displayColorProfit = Green;
// default color of loss display characters
extern color displayColorLoss = Red;
// default color of ForeGround Text display characters
extern color displayColorFGnd = White;
extern bool Debug = false;
extern string LabelOpt = "These values can only be used while optimizing";
// Set to true if you want to be able to optimize the grid settings.
extern bool UseGridOpt = false;
// These values will replace the normal SetCountArray,
// GridSetArray and TP_SetArray during optimization.
// The default values are the same as the normal array defaults
// REMEMBER:
// There must be one more value for GridArray and TPArray
// than there is for SetArray
extern int SetArray1 = 4;
extern int SetArray2 = 4;
extern int SetArray3 = 0;
extern int SetArray4 = 0;
extern int GridArray1 = 25;
extern int GridArray2 = 50;
extern int GridArray3 = 100;
extern int GridArray4 = 0;
extern int GridArray5 = 0;
extern int TPArray1 = 50;
extern int TPArray2 = 100;
extern int TPArray3 = 200;
extern int TPArray4 = 0;
extern int TPArray5 = 0;
//+-----------------------------------------------------------------+
//| Internal Parameters Set |
//+-----------------------------------------------------------------+
int ca;
int Magic,hMagic;
int CbT,CpT,ChT;
double Pip,hPip;
int POSLCount;
double SLbL;
int Moves;
double MaxDD;
double SLb;
int AccountType;
double StopTradeBalance;
double InitialAB;
bool Testing,Visual;
bool AllowTrading;
bool EmergencyWarning;
double MaxDDPer;
int Error,y;
int Set1Level,Set2Level,Set3Level,Set4Level;
int EmailCount;
string sTF;
datetime EmailSent;
int GridArray[,2];
double Lots[],MinLotSize,LotStep,LotDecimal;
int LotMult,MinMult;
bool PendLot;
string CS,UAE;
int HolShutDown;
datetime HolArray[,4];
datetime HolFirst,HolLast,NextStats,OTbF;
double RSI[];
int Digit[,2],TF[10]={0,1,5,15,30,60,240,1440,10080,43200};
double Email[3];
double EETime,PbC,PhC,hDDStart,PbMax,PbMin,PhMax,PhMin,LastClosedPL,ClosedPips,SLh,hLvlStart,StatLowEquity,StatHighEquity;
int hActive,EECount,TbF,CbC,CaL,FileHandle;
bool TradesOpen,FileClosed,HedgeTypeDD,hThisChart,hPosCorr,dLabels,FirstRun;
string FileName,ID,StatFile;
double TPb,StopLevel,TargetPips,LbF,bTS,PortionBalance;
//+-----------------------------------------------------------------+
//| expert initialization function |
//+-----------------------------------------------------------------+
int init()
{ CS="Waiting for next tick ."; // To display comments while testing, simply use CS = .... and
Comment(CS); // it will be displayed by the line at the end of the start() block.
CS="";
Testing=IsTesting();
Visual=IsVisualMode();
FirstRun=true;
AllowTrading=true;
if(EANumber<1)EANumber=1;
if(Testing)EANumber=0;
Magic=MagicNum;
//Magic=GenerateMagicNumber();
hMagic=JenkinsHash(Magic);
FileName="B3_"+Magic+".dat";
if(Debug)
{ Print("Magic Number: "+DTS(Magic,0));
Print("Hedge Number: "+DTS(hMagic,0));
Print("FileName: "+FileName);
}
Pip=Point;
if(Digits%2==1)Pip*=10;
if(NanoAccount)AccountType=10;
else AccountType=1;
MoveTP=ND(MoveTP*Pip,Digits);
EntryOffset=ND(EntryOffset*Pip,Digits);
MADistance=ND(MADistance*Pip,Digits);
BollDistance=ND(BollDistance*Pip,Digits);
POSLPips=ND(POSLPips*Pip,Digits);
hMaxLossPips=ND(hMaxLossPips*Pip,Digits);
hTakeProfit=ND(hTakeProfit*Pip,Digits);
CloseTPPips=ND(CloseTPPips*Pip,Digits);
ForceTPPips=ND(ForceTPPips*Pip,Digits);
MinTPPips=ND(MinTPPips*Pip,Digits);
BEPlusPips=ND(BEPlusPips*Pip,Digits);
SLPips=ND(SLPips*Pip,Digits);
TSLPips=ND(TSLPips*Pip,Digits);
TSLPipsMin=ND(TSLPipsMin*Pip,Digits);
slip*=Pip/Point;
if(UseHedge)
{ if(HedgeSymbol=="")HedgeSymbol=Symbol();
if(HedgeSymbol==Symbol())hThisChart=true;
else hThisChart=false;
hPip=MarketInfo(HedgeSymbol,MODE_POINT);
int hDigits=MarketInfo(HedgeSymbol,MODE_DIGITS);
if(hDigits%2==1)hPip*=10;
if(CheckCorr()>0.9||hThisChart)hPosCorr=true;
else if(CheckCorr()<-0.9)hPosCorr=false;
else
{ AllowTrading=false;
UseHedge=false;
Print("The Hedge Symbol you have entered ("+HedgeSymbol+") is not closely correlated to "+Symbol());
}
if(StringSubstr(DDorLevel,0,1)=="D"||StringSubstr(DDorLevel,0,1)=="d")HedgeTypeDD=true;
else if(StringSubstr(DDorLevel,0,1)=="L"||StringSubstr(DDorLevel,0,1)=="l")HedgeTypeDD=false;
else UseHedge=false;
if(HedgeTypeDD)
{ HedgeStart/=100;
hDDStart=HedgeStart;
}
}
StopTradePercent/=100;
ProfitSet/=100;
EEHoursPC/=100;
EELevelPC/=100;
hReEntryPC/=100;
PortionPC/=100;
InitialAB=AccountBalance();
StopTradeBalance=InitialAB*(1-StopTradePercent);
if(Testing)ID="B3Test.";
else ID=DTS(Magic,0)+".";
HideTestIndicators(true);
MinLotSize=MarketInfo(Symbol(),MODE_MINLOT);
if(MinLotSize>Lot)
{ Print("Lot is less than your brokers minimum lot size");
AllowTrading=false;
}
LotStep=MarketInfo(Symbol(),MODE_LOTSTEP);
double MinLot=MathMin(MinLotSize,LotStep);
LotMult=ND(MathMax(Lot,MinLotSize)/MinLot,0);
MinMult=LotMult;
Lot=MinLot;
if(MinLot<0.01)LotDecimal=3;
else if(MinLot<0.1)LotDecimal=2;
else if(MinLot<1)LotDecimal=1;
else LotDecimal=0;
FileHandle=FileOpen(FileName,FILE_BIN|FILE_READ);
if(FileHandle!=-1)
{ TbF=FileReadInteger(FileHandle,LONG_VALUE);
FileClose(FileHandle);
Error=GetLastError();
if(OrderSelect(TbF,SELECT_BY_TICKET))
{ OTbF=OrderOpenTime();
LbF=OrderLots();
LotMult=MathMax(1,LbF/MinLot);
PbC=FindClosedPL(B);
PhC=FindClosedPL(H);
TradesOpen=true;
if(Debug)Print(FileName+" File Read: "+TbF+" Lots: "+DTS(LbF,LotDecimal));
}
else
{ FileDelete(FileName);
TbF=0;
OTbF=0;
LbF=0;
Error=GetLastError();
if(Error==ERR_NO_ERROR)
{ if(Debug)Print(FileName+" File Deleted");
}
else Print("Error deleting file: "+FileName+" "+Error+" "+ErrorDescription(Error));
}
}
GlobalVariableSet(ID+"LotMult",LotMult);
if(Debug)Print("MinLotSize: "+DTS(MinLotSize,2)+" LotStep: "+DTS(LotStep,2)+" MinLot: "+DTS(MinLot,2)+" StartLot: "+DTS(Lot,2)+
" LotMult: "+DTS(LotMult,0)+" Lot Decimal: "+DTS(LotDecimal,0));
EmergencyWarning=EmergencyCloseAll;
if(IsOptimization())Debug=false;
if(UseAnyEntry)UAE="||";
else UAE="&&";
if(ForceMarketCond<0||ForceMarketCond>3)ForceMarketCond=3;
if(MAEntry<0||MAEntry>2)MAEntry=0;
if(CCIEntry<0||CCIEntry>2)CCIEntry=0;
if(BollingerEntry<0||BollingerEntry>2)BollingerEntry=0;
if(StochEntry<0||StochEntry>2)StochEntry=0;
if(MACDEntry<0||MACDEntry>2)MACDEntry=0;
if(MaxCloseTrades==0)MaxCloseTrades=MaxTrades;
ArrayResize(Digit,6);
for(y=0;y<ArrayRange(Digit,0);y++)
{ if(y>0)Digit[y,0]=MathPow(10,y);
Digit[y,1]=y;
if(Debug)Print("Digit: "+y+" ["+Digit[y,0]+","+Digit[y,1]+"]");
}
LabelCreate();
dLabels=false;
//+-----------------------------------------------------------------+
//| Set Lot Array |
//+-----------------------------------------------------------------+
ArrayResize(Lots,MaxTrades);
for(y=0;y<MaxTrades;y++)
{ if(y==0||Multiplier<1)Lots[y]=Lot;
else Lots[y]=ND(MathMax(Lots[y-1]*Multiplier,Lots[y-1]+LotStep),LotDecimal);
if(Debug)Print("Lot Size for level "+DTS(y+1,0)+" : "+DTS(Lots[y]*MathMax(LotMult,1),LotDecimal));
}
if(Multiplier<1)Multiplier=1;
//+-----------------------------------------------------------------+
//| Set Grid and TP array |
//+-----------------------------------------------------------------+
if(!AutoCal)
{ int GridSet,GridTemp,GridTP,GridIndex,GridLevel,GridError;
ArrayResize(GridArray,MaxTrades);
if(IsOptimization()&&UseGridOpt)
{ if(SetArray1>0)
{ SetCountArray=DTS(SetArray1,0);
GridSetArray=DTS(GridArray1,0);
TP_SetArray=DTS(TPArray1,0);
}
if(SetArray2>0||(SetArray1>0&&GridArray2>0))
{ if(SetArray2>0)SetCountArray=SetCountArray+","+DTS(SetArray2,0);
GridSetArray=GridSetArray+","+DTS(GridArray2,0);
TP_SetArray=TP_SetArray+","+DTS(TPArray2,0);
}
if(SetArray3>0||(SetArray2>0&&GridArray3>0))
{ if(SetArray3>0)SetCountArray=SetCountArray+","+DTS(SetArray3,0);
GridSetArray=GridSetArray+","+DTS(GridArray3,0);
TP_SetArray=TP_SetArray+","+DTS(TPArray3,0);
}
if(SetArray4>0||(SetArray3>0&&GridArray4>0))
{ if(SetArray4>0)SetCountArray=SetCountArray+","+DTS(SetArray4,0);
GridSetArray=GridSetArray+","+DTS(GridArray4,0);
TP_SetArray=TP_SetArray+","+DTS(TPArray4,0);
}
if(SetArray4>0&&GridArray5>0)
{ GridSetArray=GridSetArray+","+DTS(GridArray5,0);
TP_SetArray=TP_SetArray+","+DTS(TPArray5,0);
}
}
while(GridIndex<MaxTrades)
{ if(StringFind(SetCountArray,",")==-1&&GridIndex==0)
{ GridError=1;
break;
}
else GridSet=StrToInteger(StringSubstr(SetCountArray,0,StringFind(SetCountArray,",")));
if(GridSet>0)
{ SetCountArray=StringSubstr(SetCountArray,StringFind(SetCountArray,",")+1);
GridTemp=StrToInteger(StringSubstr(GridSetArray,0,StringFind(GridSetArray,",")));
GridSetArray=StringSubstr(GridSetArray,StringFind(GridSetArray,",")+1);
GridTP=StrToInteger(StringSubstr(TP_SetArray,0,StringFind(TP_SetArray,",")));
TP_SetArray=StringSubstr(TP_SetArray,StringFind(TP_SetArray,",")+1);
}
else GridSet=MaxTrades;
if(GridTemp==0||GridTP==0)
{ GridError=2;
break;
}
for(GridLevel=GridIndex;GridLevel<=MathMin(GridIndex+GridSet-1,MaxTrades-1);GridLevel++)
{ GridArray[GridLevel,0]=GridTemp;
GridArray[GridLevel,1]=GridTP;
if(Debug)Print("GridArray "+(GridLevel+1)+" : ["+GridArray[GridLevel,0]+","+GridArray[GridLevel,1]+"]");
}
GridIndex=GridLevel;
}
if(GridError>0||GridArray[0,0]==0||GridArray[0,1]==0)
{ if(GridError==1)Print("Grid Array Error. Each value should be separated by a comma.");
else Print("Grid Array Error. Check that there is one more 'Grid' and 'TP' number than there are 'Set' numbers, separated by commas.");
AllowTrading=false;
}
}
else
{ while(GridIndex<4)
{ GridSet=StrToInteger(StringSubstr(SetCountArray,0,StringFind(SetCountArray,",")));
SetCountArray=StringSubstr(SetCountArray,StringFind(SetCountArray,DTS(GridSet,0))+2);
if(GridIndex==0&&GridSet<1)
{ GridError=1;
break;
}
if(GridSet>0)GridLevel+=GridSet;
else if(GridLevel<MaxTrades)GridLevel=MaxTrades;
else GridLevel=MaxTrades+1;
if(GridIndex==0)Set1Level=GridLevel;
else if(GridIndex==1&&GridLevel<=MaxTrades)Set2Level=GridLevel;
else if(GridIndex==2&&GridLevel<=MaxTrades)Set3Level=GridLevel;
else if(GridIndex==3&&GridLevel<=MaxTrades)Set4Level=GridLevel;
GridIndex++;
}
if(GridError==1||Set1Level==0)
{ Print("Error setting up the Grid Levels. Check that the SetCountArray has valid numbers, separated by a comma.");
AllowTrading=false;
}
}
//+-----------------------------------------------------------------+
//| Set holidays array |
//+-----------------------------------------------------------------+
if(UseHolidayShutdown)
{ int HolTemp,NumHols,NumBS,HolCounter;
string HolTempStr;
if(StringFind(Holidays,",",0)==-1)NumHols=1;
else
{ NumHols=1;
while(HolTemp!=-1)
{ HolTemp=StringFind(Holidays,",",HolTemp+1);
if(HolTemp!=-1)NumHols+=1;
}
}
HolTemp=0;
while(HolTemp!=-1)
{ HolTemp=StringFind(Holidays,"/",HolTemp+1);
if(HolTemp!=-1)NumBS+=1;
}
if(NumBS!=NumHols*2)
{ Print("Holidays Error, number of back-slashes ("+NumBS+") should be equal to 2* number of Holidays ("+NumHols+
", and separators should be a comma.");
AllowTrading=false;
}
else
{ HolTemp=0;
ArrayResize(HolArray,NumHols);
while(HolTemp!=-1)
{ if(HolTemp==0)HolTempStr=StringTrimLeft(StringTrimRight(StringSubstr(Holidays,0,StringFind(Holidays,",",HolTemp))));
else HolTempStr=StringTrimLeft(StringTrimRight(StringSubstr(Holidays,HolTemp+1,
StringFind(Holidays,",",HolTemp+1)-StringFind(Holidays,",",HolTemp)-1)));
HolTemp=StringFind(Holidays,",",HolTemp+1);
HolArray[HolCounter,0]=StrToInteger(StringSubstr(StringSubstr(HolTempStr,0,StringFind(HolTempStr,"-",0)),
StringFind(StringSubstr(HolTempStr,0,StringFind(HolTempStr,"-",0)),"/")+1));
HolArray[HolCounter,1]=StrToInteger(StringSubstr(StringSubstr(HolTempStr,0,StringFind(HolTempStr,"-",0)),0,
StringFind(StringSubstr(HolTempStr,0,StringFind(HolTempStr,"-",0)),"/")));
HolArray[HolCounter,2]=StrToInteger(StringSubstr(StringSubstr(HolTempStr,StringFind(HolTempStr,"-",0)+1),
StringFind(StringSubstr(HolTempStr,StringFind(HolTempStr,"-",0)+1),"/")+1));
HolArray[HolCounter,3]=StrToInteger(StringSubstr(StringSubstr(HolTempStr,StringFind(HolTempStr,"-",0)+1),0,
StringFind(StringSubstr(HolTempStr,StringFind(HolTempStr,"-",0)+1),"/")));
HolCounter+=1;
}
}
for(HolTemp=0;HolTemp<HolCounter;HolTemp++)
{ int Start1,Start2,Temp0,Temp1,Temp2,Temp3;
for(int Item1=HolTemp+1;Item1<HolCounter;Item1++)
{ Start1=HolArray[HolTemp,0]*100+HolArray[HolTemp,1];
Start2=HolArray[Item1,0]*100+HolArray[Item1,1];
if(Start1>Start2)
{ Temp0=HolArray[Item1,0];
Temp1=HolArray[Item1,1];
Temp2=HolArray[Item1,2];
Temp3=HolArray[Item1,3];
HolArray[Item1,0]=HolArray[HolTemp,0];
HolArray[Item1,1]=HolArray[HolTemp,1];
HolArray[Item1,2]=HolArray[HolTemp,2];
HolArray[Item1,3]=HolArray[HolTemp,3];
HolArray[HolTemp,0]=Temp0;
HolArray[HolTemp,1]=Temp1;
HolArray[HolTemp,2]=Temp2;
HolArray[HolTemp,3]=Temp3;
}
}
}
if(Debug)
{ for(HolTemp=0;HolTemp<HolCounter;HolTemp++)
Print("Holidays - From: ",HolArray[HolTemp,1],"/",HolArray[HolTemp,0]," - ",HolArray[HolTemp,3],"/",HolArray[HolTemp,2]);
}
}
//+-----------------------------------------------------------------+
//| Set email parameters |
//+-----------------------------------------------------------------+
if(UseEmail)
{ if(Period()==43200)sTF="MN1";
else if(Period()==10800)sTF="W1";
else if(Period()==1440)sTF="D1";
else if(Period()==240)sTF="H4";
else if(Period()==60)sTF="H1";
else if(Period()==30)sTF="M30";
else if(Period()==15)sTF="M15";
else if(Period()==5)sTF="M5";
else if(Period()==1)sTF="M1";
Email[0]=MathMax(MathMin(EmailDD1,MaxDDPercent-1),0)/100;
Email[1]=MathMax(MathMin(EmailDD2,MaxDDPercent-1),0)/100;
Email[2]=MathMax(MathMin(EmailDD3,MaxDDPercent-1),0)/100;
ArraySort(Email,WHOLE_ARRAY,0,MODE_ASCEND);
for(int z=0;z<=2;z++)
{ for(y=0;y<=2;y++)
{ if(Email[y]==0)
{ Email[y]=Email[y+1];
Email[y+1]=0;
}
}
if(Debug)Print("Email ["+(z+1)+"] : "+Email[z]);
}
}
//+-----------------------------------------------------------------+
//| Set SmartGrid parameters |
//+-----------------------------------------------------------------+
if(UseSmartGrid)
{ ArrayResize(RSI,RSI_Period+RSI_MA_Period);
ArraySetAsSeries(RSI,true);
}
//+---------------------------------------------------------------+
//| Initialize Statistics |
//+---------------------------------------------------------------+
if(SaveStats)
{ StatFile="B3"+Symbol()+"_"+Period()+"_"+EANumber+".csv";
NextStats=TimeCurrent();
Stats(StatsInitialise,false,AccountBalance()*PortionPC,0);
}
return(0);
}
//+-----------------------------------------------------------------+
//| expert deinitialization function |
//+-----------------------------------------------------------------+
int deinit()
{ switch(UninitializeReason())
{ case REASON_REMOVE:
case REASON_CHARTCLOSE:
case REASON_CHARTCHANGE:
if(CpT>0)while(CpT>0)CpT-=ExitTrades(P,displayColorLoss,"Blessing Removed");
GlobalVariablesDeleteAll(ID);
case REASON_RECOMPILE:
case REASON_PARAMETERS:
case REASON_ACCOUNT:
if(!Testing)LabelDelete();
Comment("");
}
return(0);
}
//+-----------------------------------------------------------------+
//| expert start function |
//+-----------------------------------------------------------------+
int start()
{ int CbB =0; // Count buy
int CbS =0; // Count sell
int CpBL =0; // Count buy limit
int CpSL =0; // Count sell limit
int CpBS =0; // Count buy stop
int CpSS =0; // Count sell stop
double LbB =0; // Count buy lots
double LbS =0; // Count sell lots
double LbT =0; // total lots out
double OPpBL =0; // Buy limit open price
double OPpSL =0; // Sell limit open price
double SLbB =0; // stop losses are set to zero if POSL off
double SLbS =0; // stop losses are set to zero if POSL off
double BCb,BCh,BCa; // Broker costs (swap + commission)
double ProfitPot =0; // The Potential Profit of a basket of Trades
double PipValue,PipVal2,ASK,BID;
double OrderLot;
double OPbL,OPhO; // last open price
int OTbL; // last open time
double g2,tp2,Entry,RSI_MA,LhB,LhS,LhT,OPbO,OTbO,OThO,TbO,ThO;
int Ticket,ChB,ChS,IndEntry;
double Pb,Ph,PaC,PbPips,PbTarget,DrawDownPC,BEb,BEh,BEa;
bool BuyMe,SellMe,Success,SetPOSL;
string IndicatorUsed;
//+-----------------------------------------------------------------+
//| Count Open Orders, Lots and Totals |
//+-----------------------------------------------------------------+
PipVal2=MarketInfo(Symbol(),MODE_TICKVALUE)/MarketInfo(Symbol(),MODE_TICKSIZE);
PipValue=PipVal2*Pip;
StopLevel=MarketInfo(Symbol(),MODE_STOPLEVEL)*Point;
ASK=ND(MarketInfo(Symbol(),MODE_ASK),MarketInfo(Symbol(),MODE_DIGITS));
BID=ND(MarketInfo(Symbol(),MODE_BID),MarketInfo(Symbol(),MODE_DIGITS));
if(ASK==0||BID==0)return(0);
for(y=0;y<OrdersTotal();y++)
{ if(!OrderSelect(y,SELECT_BY_POS,MODE_TRADES))continue;
int Type=OrderType();
if(OrderMagicNumber()==hMagic)
{ Ph+=OrderProfit();
BCh+=OrderSwap()+OrderCommission();
BEh+=OrderLots()*OrderOpenPrice();
if(OrderOpenTime()<OThO||OThO==0)
{ OThO=OrderOpenTime();
ThO=OrderTicket();
OPhO=OrderOpenPrice();
}
if(Type==OP_BUY)
{ ChB++;
LhB+=OrderLots();
}
else if(Type==OP_SELL)
{ ChS++;
LhS+=OrderLots();
}
continue;
}
if(OrderMagicNumber()!=Magic||OrderSymbol()!=Symbol())continue;
if(OrderTakeProfit()>0)ModifyOrder(OrderOpenPrice(),OrderStopLoss());
if(Type<=OP_SELL)
{ Pb+=OrderProfit();
BCb+=OrderSwap()+OrderCommission();
BEb+=OrderLots()*OrderOpenPrice();
if(OrderOpenTime()>=OTbL)
{ OTbL=OrderOpenTime();
OPbL=OrderOpenPrice();
}
if(OrderOpenTime()<OTbF||TbF==0)
{ OTbF=OrderOpenTime();
TbF=OrderTicket();
LbF=OrderLots();
}
if(OrderOpenTime()<OTbO||OTbO==0)
{ OTbO=OrderOpenTime();
TbO=OrderTicket();
OPbO=OrderOpenPrice();
}
if(UsePowerOutSL&&((POSLPips>0&&OrderStopLoss()==0)||(POSLPips==0&&OrderStopLoss()>0)))SetPOSL=true;
if(Type==OP_BUY)
{ CbB++;
LbB+=OrderLots();
continue;
}
else
{ CbS++;
LbS+=OrderLots();
continue;
}
}
else
{ if(Type==OP_BUYLIMIT)
{ CpBL++;
OPpBL=OrderOpenPrice();
continue;
}
else if(Type==OP_SELLLIMIT)
{ CpSL++;
OPpSL=OrderOpenPrice();
continue;
}
else if(Type==OP_BUYSTOP)CpBS++;
else CpSS++;
}
}
CbT=CbB+CbS;
LbT=LbB+LbS;
Pb=ND(Pb+BCb,2);
ChT=ChB+ChS;
LhT=LhB+LhS;
Ph=ND(Ph+BCh,2);
CpT=CpBL+CpSL+CpBS+CpSS;
BCa=BCb+BCh;
//+-----------------------------------------------------------------+
//| Calculate Min/Max Profit and Break Even Points |
//+-----------------------------------------------------------------+
if(LbT>0)
{ BEb=ND(BEb/LbT,Digits);
if(BCa<0)BEb-=ND(BCa/PipVal2/(LbB-LbS),Digits);
if(Pb>PbMax||PbMax==0)PbMax=Pb;
if(Pb<PbMin||PbMin==0)PbMin=Pb;
if(!TradesOpen)
{ FileHandle=FileOpen(FileName,FILE_BIN|FILE_WRITE);
if(FileHandle>-1)
{ FileWriteInteger(FileHandle,TbF);
FileClose(FileHandle);
TradesOpen=true;
if(Debug)Print(FileName+" File Written: "+TbF);
}
}
}
else if(TradesOpen)
{ TPb=0;
PbMax=0;
PbMin=0;
OTbF=0;
TbF=0;
LbF=0;
PbC=0;
PhC=0;
PaC=0;
ClosedPips=0;
CbC=0;
CaL=0;
bTS=0;
if(HedgeTypeDD)hDDStart=HedgeStart;
else hLvlStart=HedgeStart;
EmailCount=0;
EmailSent=0;
FileHandle=FileOpen(FileName,FILE_BIN|FILE_READ);
if(FileHandle>-1)
{ FileClose(FileHandle);
Error=GetLastError();
FileDelete(FileName);
Error=GetLastError();
if(Error==ERR_NO_ERROR)
{ if(Debug)Print(FileName+" File Deleted");
TradesOpen=false;
}
else Print("Error deleting file: "+FileName+" "+Error+" "+ErrorDescription(Error));
}
else TradesOpen=false;
}
if(LhT>0)
{ BEh=ND(BEh/LhT,Digits);
if(Ph>PhMax||PhMax==0)PhMax=Ph;
if(Ph<PhMin||PhMin==0)PhMin=Ph;
}
else
{ PhMax=0;
PhMin=0;
SLh=0;
}
//+-----------------------------------------------------------------+
//| Check if trading is allowed |
//+-----------------------------------------------------------------+
if(CbT==0&&ChT==0&&ShutDown)
{ if(CpT>0)
{ ExitTrades(P,displayColorLoss,"Blessing is shutting down");
return(0);
}
if(AllowTrading)
{ Print("Blessing has ShutDown. Set ShutDown = 'false' to continue trading");
if(PlaySounds)PlaySound(AlertSound);
AllowTrading=false;
}
if(UseEmail&&EmailCount<4&&!Testing)
{ SendMail("Blessing EA","Blessing has shut down on "+Symbol()+" "+sTF+
". Trading has been suspended. To resume trading, set ShutDown to false.");
Error=GetLastError();
if(Error>0)Print("Error sending Email: "+Error+" "+ErrorDescription(Error));
else EmailCount=4;
}
}
if(!AllowTrading)
{ static bool LDelete;
if(!LDelete)
{ LDelete=true;
LabelDelete();
if(ObjectFind("B3LStop")==-1)CreateLabel("B3LStop","Trading has been stopped on this pair.",10,0,0,3,displayColorLoss);
if(Testing)string Tab="Tester Journal";
else Tab="Terminal Experts";
if(ObjectFind("B3LExpt")==-1)CreateLabel("B3LExpt","Check the "+Tab+" tab for the reason why.",10,0,0,6,displayColorLoss);
if(ObjectFind("B3LResm")==-1)CreateLabel("B3LResm","Reset Blessing to resume trading.",10,0,0,9,displayColorLoss);
}
return(0);
}
else
{ LDelete=false;
ObjDel("B3LStop");
ObjDel("B3LExpt");
ObjDel("B3LResm");
}
//+-----------------------------------------------------------------+
//| Calculate Drawdown and Equity Protection |
//+-----------------------------------------------------------------+
double NewPortionBalance=ND(AccountBalance()*PortionPC,2);
if(CbT==0||PortionChange<0||(PortionChange>0&&NewPortionBalance>PortionBalance))PortionBalance=NewPortionBalance;
if(Pb+Ph<0)DrawDownPC=-(Pb+Ph)/PortionBalance;
if(!FirstRun&&DrawDownPC>=MaxDDPercent/100)
{ ExitTrades(A,displayColorLoss,"Equity Stop Loss Reached");
if(PlaySounds)PlaySound(AlertSound);
return(0);
}
if(-(Pb+Ph)>MaxDD)MaxDD=-(Pb+Ph);
MaxDDPer=MathMax(MaxDDPer,DrawDownPC*100);
if(SaveStats)Stats(false,TimeCurrent()<NextStats,PortionBalance,Pb+Ph);
//+-----------------------------------------------------------------+
//| Calculate Stop Trade Percent |
//+-----------------------------------------------------------------+
double StepAB=InitialAB*(1+StopTradePercent);
double StepSTB=AccountBalance()*(1-StopTradePercent);
double NextISTB=StepAB*(1-StopTradePercent);
if(StepSTB>NextISTB)
{ InitialAB=StepAB;
StopTradeBalance=StepSTB;
}
double InitialAccountMultiPortion=StopTradeBalance*PortionPC;
if(PortionBalance<InitialAccountMultiPortion)
{ if(CbT==0)
{ AllowTrading=false;
if(PlaySounds)PlaySound(AlertSound);
Print("Portion Balance dropped below stop trade percent");
MessageBox("Reset Blessing, account balance dropped below stop trade percent on "+Symbol()+Period(),"Blessing 3: Warning",48);
return(0);
}
else if(!ShutDown&&!RecoupClosedLoss)
{ ShutDown=true;
if(PlaySounds)PlaySound(AlertSound);
Print("Portion Balance dropped below stop trade percent");
return(0);
}
}
//+-----------------------------------------------------------------+
//| Calculation of Trend Direction |
//+-----------------------------------------------------------------+
int Trend;
string ATrend;
double ima_0=iMA(Symbol(),0,MAPeriod,0,MODE_EMA,PRICE_CLOSE,0);
if(ForceMarketCond==3)
{ if(BID>ima_0+MADistance)Trend=0;
else if(ASK<ima_0-MADistance)Trend=1;
else Trend=2;
}
else
{ Trend=ForceMarketCond;
if(Trend!=0&&BID>ima_0+MADistance)ATrend="U";
if(Trend!=1&&ASK<ima_0-MADistance)ATrend="D";
if(Trend!=2&&(BID<ima_0+MADistance&&ASK>ima_0-MADistance))ATrend="R";
}
//+-----------------------------------------------------------------+
//| Hedge/Basket/ClosedTrades Profit Management |
//+-----------------------------------------------------------------+
double Pa=Pb;
PaC=PbC+PhC;
if(hActive==1&&ChT==0)
{ PhC=FindClosedPL(H);
hActive=0;
return(0);
}
else if(hActive==0&&ChT>0)hActive=1;
if(LbT>0)
{ if(PbC>0||(PbC<0&&RecoupClosedLoss))
{ Pa+=PbC;
BEb-=ND(PbC/PipVal2/(LbB-LbS),Digits);
}
if(PhC>0||(PhC<0&&RecoupClosedLoss))
{ Pa+=PhC;
BEb-=ND(PhC/PipVal2/(LbB-LbS),Digits);
}
if(Ph>0||(Ph<0&&RecoupClosedLoss))Pa+=Ph;
}
//+-----------------------------------------------------------------+
//| Close oldest open trade after CloseTradesLevel reached |
//+-----------------------------------------------------------------+
if(UseCloseOldest&&CbT>=CloseTradesLevel&&CbC<MaxCloseTrades)
{ if(!FirstRun&&TPb>0&&(ForceCloseOldest||(CbB>0&&OPbO>TPb)||(CbS>0&&OPbO<TPb)))
{ y=ExitTrades(T,DarkViolet,"Close Oldest Trade",TbO);
if(y==1)
{ OrderSelect(TbO,SELECT_BY_TICKET);
PbC+=OrderProfit()+OrderSwap()+OrderCommission();
ca=0;
CbC++;
return(0);
}
}
}
//+-----------------------------------------------------------------+
//| ATR for Auto Grid Calculation and Grid Set Block |
//+-----------------------------------------------------------------+
if(AutoCal)
{ double GridTP;
double GridATR=iATR(NULL,TF[ATRTF],ATRPeriods,0)/Pip;
if((CbT+CbC>Set4Level)&&Set4Level>0)
{ g2=GridATR*12; //GS*2*2*2*1.5
tp2=GridATR*18; //GS*2*2*2*1.5*1.5
}
else if((CbT+CbC>Set3Level)&&Set3Level>0)
{ g2=GridATR*8; //GS*2*2*2
tp2=GridATR*12; //GS*2*2*2*1.5
}
else if((CbT+CbC>Set2Level)&&Set2Level>0)
{ g2=GridATR*4; //GS*2*2
tp2=GridATR*8; //GS*2*2*2
}
else if((CbT+CbC>Set1Level)&&Set1Level>0)
{ g2=GridATR*2; //GS*2
tp2=GridATR*4; //GS*2*2
}
else
{ g2=GridATR;
tp2=GridATR*2;
}
GridTP=GridATR*2;
}
else
{ y=MathMax(MathMin(CbT+CbC,MaxTrades)-1,0);
g2=GridArray[y,0];
tp2=GridArray[y,1];
GridTP=GridArray[0,1];
}
g2=ND(MathMax(g2*GAF*Pip,Pip),Digits);
tp2=ND(tp2*GAF*Pip,Digits);
GridTP=ND(GridTP*GAF*Pip,Digits);
//+-----------------------------------------------------------------+
//| Money Management and Lot size coding |
//+-----------------------------------------------------------------+
if(UseMM)
{ if(CbT>0)
{ if(GlobalVariableCheck(ID+"LotMult"))LotMult=GlobalVariableGet(ID+"LotMult");
if(LbF!=LotSize(Lots[0]*LotMult))
{ LotMult=LbF/Lots[0];
GlobalVariableSet(ID+"LotMult",LotMult);
Print("LotMult reset to "+DTS(LotMult,0));
}
}
if(CbT==0)
{ double Contracts,Factor,Lotsize;
Contracts=PortionBalance/10000;
if(Multiplier<=1)Factor=Level;
else Factor=(MathPow(Multiplier,Level)-Multiplier)/(Multiplier-1);
Lotsize=LAF*AccountType*Contracts/(1+Factor);
LotMult=MathMax(MathFloor(Lotsize/Lot),MinMult);
GlobalVariableSet(ID+"LotMult",LotMult);
}
}
else if(CbT==0)LotMult=MinMult;
//+-----------------------------------------------------------------+
//| Calculate Take Profit |
//+-----------------------------------------------------------------+
static double BCaL,BEbL;
double nLots=LbB-LbS;
if(CbT>0&&(TPb==0||CbT+ChT!=CaL||BEbL!=BEb||BCa!=BCaL||FirstRun))
{ string sCalcTP="Set New TP: BE: "+DTS(BEb,Digits);
double NewTP,BasePips;
CaL=CbT+ChT;
BCaL=BCa;
BEbL=BEb;
BasePips=ND(Lot*LotMult*GridTP*(CbT+CbC)/nLots,Digits);
if(CbB>0)
{ if(ForceTPPips>0)
{ NewTP=BEb+ForceTPPips;
sCalcTP=sCalcTP+" +Force TP ("+DTS(ForceTPPips,Digits)+") ";
}
else if(CbC>0&&CloseTPPips>0)
{ NewTP=BEb+CloseTPPips;
sCalcTP=sCalcTP+" +Close TP ("+DTS(CloseTPPips,Digits)+") ";
}
else if(BEb+BasePips>OPbL+tp2)
{ NewTP=BEb+BasePips;
sCalcTP=sCalcTP+" +Base TP: ("+DTS(BasePips,Digits)+") ";
}
else
{ NewTP=OPbL+tp2;
sCalcTP=sCalcTP+" +Grid TP: ("+DTS(tp2,Digits)+") ";
}
if(MinTPPips>0)
{ NewTP=MathMax(NewTP,BEb+MinTPPips);
sCalcTP=sCalcTP+" >Minimum TP: ";
}
NewTP+=MoveTP*Moves;
if(BreakEvenTrade>0&&CbT+CbC>=BreakEvenTrade)
{ NewTP=BEb+BEPlusPips;
sCalcTP=sCalcTP+" >BreakEven: ("+DTS(BEPlusPips,Digits)+") ";
}
sCalcTP=(sCalcTP+"Buy: TakeProfit: ");
}
else if(CbS>0)
{ if(ForceTPPips>0)
{ NewTP=BEb-ForceTPPips;
sCalcTP=sCalcTP+" -Force TP ("+DTS(ForceTPPips,Digits)+") ";
}
else if(CbC>0&&CloseTPPips>0)
{ NewTP=BEb-CloseTPPips;
sCalcTP=sCalcTP+" -Close TP ("+DTS(CloseTPPips,Digits)+") ";
}
else if(BEb+BasePips<OPbL-tp2)
{ NewTP=BEb+BasePips;
sCalcTP=sCalcTP+" -Base TP: ("+DTS(BasePips,Digits)+") ";
}
else
{ NewTP=OPbL-tp2;
sCalcTP=sCalcTP+" -Grid TP: ("+DTS(tp2,Digits)+") ";
}
if(MinTPPips>0)
{ NewTP=MathMin(NewTP,BEb-MinTPPips);
sCalcTP=sCalcTP+" >Minimum TP: ";
}
NewTP-=MoveTP*Moves;
if(BreakEvenTrade>0&&CbT+CbC>=BreakEvenTrade)
{ NewTP=BEb-BEPlusPips;
sCalcTP=sCalcTP+" >BreakEven: ("+DTS(BEPlusPips,Digits)+") ";
}
sCalcTP=(sCalcTP+"Sell: TakeProfit: ");
}
if(TPb!=NewTP)
{ TPb=NewTP;
if(nLots>0)TargetPips=ND(TPb-BEb,Digits);
else TargetPips=ND(BEb-TPb,Digits);
Print(sCalcTP+DTS(NewTP,Digits));
return(0);
}
}
PbTarget=TargetPips/Pip;
ProfitPot=ND(TargetPips*PipVal2*MathAbs(nLots),2);
if(CbB>0)PbPips=ND((BID-BEb)/Pip,1);
if(CbS>0)PbPips=ND((BEb-ASK)/Pip,1);
//+-----------------------------------------------------------------+
//| Adjust BEb/TakeProfit if Hedge is active |
//+-----------------------------------------------------------------+
double hAsk=MarketInfo(HedgeSymbol,MODE_ASK);
double hBid=MarketInfo(HedgeSymbol,MODE_BID);
double hSpread=hAsk-hBid;
if(hThisChart)nLots+=LhB-LhS;
if(hActive==1)
{ double TPa,PhPips;
if(nLots==0)
{ BEa=0;
TPa=0;
}
else if(hThisChart)
{ if(nLots>0)
{ if(CbB>0)BEa=ND((BEb*LbT-(BEh-hSpread)*LhT)/(LbT-LhT),Digits);
else BEa=ND(((BEb-(ASK-BID))*LbT-BEh*LhT)/(LbT-LhT),Digits);
TPa=ND(BEa+TargetPips,Digits);
}
else
{ if(CbS>0)BEa=ND((BEb*LbT-(BEh+hSpread)*LhT)/(LbT-LhT),Digits);
else BEa=ND(((BEb+ASK-BID)*LbT-BEh*LhT)/(LbT-LhT),Digits);
TPa=ND(BEa-TargetPips,Digits);
}
}
else
{
}
if(ChB>0)PhPips=ND((hBid-BEh)/hPip,1);
if(ChS>0)PhPips=ND((BEh-hAsk)/hPip,1);
}
else
{ BEa=BEb;
TPa=TPb;
}
//+-----------------------------------------------------------------+
//| Calculate Early Exit Percentage |
//+-----------------------------------------------------------------+
if(UseEarlyExit&&CbT>0)
{ double EEpc,EEopt,EEStartTime,TPaF;
if(EEFirstTrade)EEopt=OTbF;
else EEopt=OTbL;
if(DayOfWeek()<TimeDayOfWeek(EEopt))EEStartTime=2*24*3600;
EEStartTime+=EEopt+EEStartHours*3600;
if(EEHoursPC>0&&TimeCurrent()>=EEStartTime)EEpc=EEHoursPC*(TimeCurrent()-EEStartTime)/3600;
if(EELevelPC>0&&(CbT+CbC)>=EEStartLevel)EEpc+=EELevelPC*(CbT+CbC-EEStartLevel+1);
EEpc=1-EEpc;
if(!EEAllowLoss&&EEpc<0)EEpc=0;
PbTarget*=EEpc;
TPaF=ND((TPa-BEa)*EEpc+BEa,Digits);
if(displayOverlay&&displayLines&&(hActive!=1||(hActive==1&&hThisChart))&&(!Testing||(Testing&&Visual))&&EEpc<1
&&(CbT+CbC+ChT>EECount||EETime!=Time[0])&&((EEHoursPC>0&&EEopt+EEStartHours*3600<Time[0])||(EELevelPC>0&&CbT+CbC>=EEStartLevel)))
{ EETime=Time[0];
EECount=CbT+CbC+ChT;
if(ObjectFind("B3LEELn")<0)
{ ObjectCreate("B3LEELn",OBJ_TREND,0,0,0);
ObjectSet("B3LEELn",OBJPROP_COLOR,Yellow);
ObjectSet("B3LEELn",OBJPROP_WIDTH,1);
ObjectSet("B3LEELn",OBJPROP_STYLE,0);
ObjectSet("B3LEELn",OBJPROP_RAY,false);
}
if(EEHoursPC>0)ObjectMove("B3LEELn",0,MathFloor(EEopt/3600+EEStartHours)*3600,TPa);
else ObjectMove("B3LEELn",0,MathFloor(EEopt/3600)*3600,TPaF);
ObjectMove("B3LEELn",1,Time[1],TPaF);
if(ObjectFind("B3VEELn")<0)
{ ObjectCreate("B3VEELn",OBJ_TEXT,0,0,0);
ObjectSet("B3VEELn",OBJPROP_COLOR,Yellow);
ObjectSet("B3VEELn",OBJPROP_WIDTH,1);
ObjectSet("B3VEELn",OBJPROP_STYLE,0);
}
ObjSetTxt("B3VEELn"," "+DTS(TPaF,Digits),-1,Yellow);
ObjectSet("B3VEELn",OBJPROP_PRICE1,TPaF+2*Pip);
ObjectSet("B3VEELn",OBJPROP_TIME1,Time[1]);
}
else if((!displayLines||EEpc==1||(!EEAllowLoss&&EEpc==0)||(EEHoursPC>0&&EEopt+EEStartHours*3600>=Time[0])))
{ ObjDel("B3LEELn");
ObjDel("B3VEELn");
}
}
else
{ TPaF=TPa;
EETime=0;
EECount=0;
ObjDel("B3LEELn");
ObjDel("B3VEELn");
}
//+-----------------------------------------------------------------+
//| Maximize Profit with Moving TP and setting Trailing Profit Stop |
//+-----------------------------------------------------------------+
if(MaximizeProfit)
{ if(CbT==0)
{ SLbL=0;
Moves=0;
SLb=0;
}
if(!FirstRun&&CbT>0)
{ if(Pb+Ph<0&&SLb>0)SLb=0;
if(SLb>0&&((nLots>0&&BID<SLb)||(nLots<0&&ASK>SLb)))
{ ExitTrades(A,displayColorProfit,"Profit Trailing Stop Reached ("+DTS(ProfitSet*100,2)+"%)");
return(0);
}
if(PbTarget>0)
{ double TPbMP=ND(BEa+(TPa-BEa)*ProfitSet,Digits);
if((nLots>0&&BID>TPbMP)||(nLots<0&&ASK<TPbMP))SLb=TPbMP;
}
if(SLb>0&&SLb!=SLbL&&MoveTP>0&&TotalMoves>Moves)
{ TPb=0;
Moves++;
if(Debug)Print("MoveTP");
SLbL=SLb;
if(PlaySounds)PlaySound(AlertSound);
return(0);
}
}
}
if(!FirstRun&&TPaF>0)
{ if((nLots>0&&BID>=TPaF)||(nLots<0&&ASK<=TPaF))
{ ExitTrades(A,displayColorProfit,"Profit Target Reached @ "+DTS(TPaF,Digits));
return(0);
}
}
if(!FirstRun&&UseStopLoss)
{ double bSL;
if(SLPips>0)
{ if(nLots>0)
{ bSL=BEa-SLPips;
if(BID<=bSL)
{ ExitTrades(A,displayColorProfit,"Stop Loss Reached");
return(0);
}
}
else if(nLots<0)
{ bSL=BEa+SLPips;
if(ASK>=bSL)
{ ExitTrades(A,displayColorProfit,"Stop Loss Reached");
return(0);
}
}
}
if(TSLPips!=0)
{ if(nLots>0)
{ if(TSLPips>0&&BID>BEa+TSLPips)bTS=MathMax(bTS,BID-TSLPips);
if(TSLPips<0&&BID>BEa-TSLPips)bTS=MathMax(bTS,BID-MathMax(TSLPipsMin,-TSLPips*(1-(BID-BEa+TSLPips)/(-TSLPips*2))));
if(bTS>0&&BID<=bTS)
{ ExitTrades(A,displayColorProfit,"Trailing Stop Reached");
return(0);
}
}
else if(nLots<0)
{ if(TSLPips>0&&ASK<BEa-TSLPips)
{ if(bTS>0)bTS=MathMin(bTS,ASK+TSLPips);
else bTS=ASK+TSLPips;
}
if(TSLPips<0&&ASK<BEa+TSLPips)bTS=MathMin(bTS,ASK+MathMax(TSLPipsMin,-TSLPips*(1-(BEa-ASK+TSLPips)/(-TSLPips*2))));
if(bTS>0&&ASK>=bTS)
{ ExitTrades(A,displayColorProfit,"Trailing Stop Reached");
return(0);
}
}
}
}
//+-----------------------------------------------------------------+
//| Check for and Delete hanging pending orders |
//+-----------------------------------------------------------------+
if(CbT==0&&!PendLot)
{ PendLot=true;
for(y=OrdersTotal()-1;y>=0;y--)
{ if(!OrderSelect(y,SELECT_BY_POS,MODE_TRADES))continue;
if(OrderMagicNumber()!=Magic||OrderType()<=OP_SELL)continue;
if(ND(OrderLots(),LotDecimal)>ND(Lots[0]*LotMult,LotDecimal))
{ PendLot=false;
while(IsTradeContextBusy())Sleep(100);
if(IsStopped())return(-1);
Success=OrderDelete(OrderTicket());
if(Success)
{ PendLot=true;
if(Debug)Print("Delete pending > Lot");
}
}
}
return(0);
}
else if((CbT>0||(CbT==0&&CpT>0&&!B3Traditional))&&PendLot)
{ PendLot=false;
for(y=OrdersTotal()-1;y>=0;y--)
{ if(!OrderSelect(y,SELECT_BY_POS,MODE_TRADES))continue;
if(OrderMagicNumber()!=Magic||OrderType()<=OP_SELL)continue;
if(ND(OrderLots(),LotDecimal)==ND(Lots[0]*LotMult,LotDecimal))
{ PendLot=true;
while(IsTradeContextBusy())Sleep(100);
if(IsStopped())return(-1);
Success=OrderDelete(OrderTicket());
if(Success)
{ PendLot=false;
if(Debug)Print("Delete pending = Lot");
}
}
}
return(0);
}
//+-----------------------------------------------------------------+
//| Check ca, Breakeven Trades and Emergency Close All |
//+-----------------------------------------------------------------+
switch(ca)
{ case B: if(CbT==0&&CpT==0)ca=0;break;
case H: if(ChT==0)ca=0;break;
case A: if(CbT==0&&CpT==0&&ChT==0)ca=0;break;
case P: if(CpT==0)ca=0;break;
case T: break;
default: break;
}
if(ca>0)
{ ExitTrades(ca,displayColorLoss,"Close All ("+DTS(ca,0)+")");
return(0);
}
if(CbT==0&&ChT>0)
{ ExitTrades(H,displayColorLoss,"Basket Closed");
return(0);
}
if(EmergencyCloseAll)
{ ExitTrades(A,displayColorLoss,"Emergency Close All Trades");
EmergencyCloseAll=false;
return(0);
}
//+-----------------------------------------------------------------+
//| Check Holiday Shutdown |
//+-----------------------------------------------------------------+
if(UseHolidayShutdown)
{ if(HolShutDown>0&&TimeCurrent()>=HolLast&&HolLast>0)
{ Print("Blessing has resumed after the holidays. From: "+TimeToStr(HolFirst,TIME_DATE)+" To: "+TimeToStr(HolLast,TIME_DATE));
HolShutDown=0;
LabelDelete();
LabelCreate();
if(PlaySounds)PlaySound(AlertSound);
}
if(HolShutDown==3)
{ if(ObjectFind("B3LStop")==-1)
CreateLabel("B3LStop","Trading has been stopped on this pair for the holidays.",10,0,0,3,displayColorLoss);
if(ObjectFind("B3LResm")==-1)
CreateLabel("B3LResm","Blessing will resume trading after "+TimeToStr(HolLast,TIME_DATE)+".",10,0,0,9,displayColorLoss);
return(0);
}
else if((HolShutDown==0&&TimeCurrent()>=HolLast)||HolFirst==0)
{ for(y=0;y<ArraySize(HolArray);y++)
{ HolFirst=StrToTime(Year()+"."+HolArray[y,0]+"."+HolArray[y,1]);
HolLast=StrToTime(Year()+"."+HolArray[y,2]+"."+HolArray[y,3]+" 23:59:59");
if(TimeCurrent()<HolFirst)
{ if(HolFirst>HolLast)HolLast=StrToTime(DTS(Year()+1,0)+"."+HolArray[y,2]+"."+HolArray[y,3]+" 23:59:59");
break;
}
if(TimeCurrent()<HolLast)
{ if(HolFirst>HolLast)HolFirst=StrToTime(DTS(Year()-1,0)+"."+HolArray[y,0]+"."+HolArray[y,1]);
break;
}
if(TimeCurrent()>HolFirst&&HolFirst>HolLast)
{ HolLast=StrToTime(DTS(Year()+1,0)+"."+HolArray[y,2]+"."+HolArray[y,3]+" 23:59:59");
if(TimeCurrent()<HolLast)break;
}
}
if(TimeCurrent()>=HolFirst&&TimeCurrent()<=HolLast)
{ Comment("");
HolShutDown=1;
}
}
else if(HolShutDown==0&&TimeCurrent()>=HolFirst&&TimeCurrent()<HolLast)HolShutDown=1;
if(HolShutDown==1&&CbT==0)
{ Print("Blessing has shut down for the holidays. From: "+TimeToStr(HolFirst,TIME_DATE)+
" To: "+TimeToStr(HolLast,TIME_DATE));
if(CpT>0)
{ y=ExitTrades(P,displayColorLoss,"Holiday Shutdown");
if(y==CpT)ca=0;
}
HolShutDown=2;
ObjDel("B3LClos");
}
else if(HolShutDown==1)
{ if(ObjectFind("B3LClos")==-1)CreateLabel("B3LClos","",5,0,0,23,displayColorLoss);
ObjSetTxt("B3LClos","Blessing will shutdown for the holidays when this basket closes",5);
}
if(HolShutDown==2)
{ LabelDelete();
if(PlaySounds)PlaySound(AlertSound);
HolShutDown=3;
}
if(HolShutDown==3)
{ if(ObjectFind("B3LStop")==-1)
CreateLabel("B3LStop","Trading has been stopped on this pair for the holidays.",10,0,0,3,displayColorLoss);
if(ObjectFind("B3LResm")==-1)
CreateLabel("B3LResm","Blessing will resume trading after "+TimeToStr(HolLast,TIME_DATE)+".",10,0,0,9,displayColorLoss);
Comment("");
return(0);
}
}
//+-----------------------------------------------------------------+
//| Power Out Stop Loss Protection |
//+-----------------------------------------------------------------+
if(SetPOSL)
{ if(UsePowerOutSL&&POSLPips>0)
{ double POSL=MathMin(PortionBalance*(MaxDDPercent+1)/100/PipVal2/LbT,POSLPips);
SLbB=ND(BEb-POSL,Digits);
SLbS=ND(BEb+POSL,Digits);
}
else
{ SLbB=0;
SLbS=0;
}
for(y=0;y<OrdersTotal();y++)
{ if(!OrderSelect(y,SELECT_BY_POS,MODE_TRADES))continue;
if(OrderMagicNumber()!=Magic||OrderSymbol()!=Symbol()||OrderType()>OP_SELL)continue;
if(OrderType()==OP_BUY&&OrderStopLoss()!=SLbB)
{ Success=ModifyOrder(OrderOpenPrice(),SLbB,Purple);
if(Debug&&Success)Print("Order: "+OrderTicket()+" Sync POSL Buy");
}
else if(OrderType()==OP_SELL&&OrderStopLoss()!=SLbS)
{ Success=ModifyOrder(OrderOpenPrice(),SLbS,Purple);
if(Debug&&Success)Print("Order: "+OrderTicket()+" Sync POSL Sell");
}
}
}
//+-----------------------------------------------------------------+ << This must be the first Entry check.
//| Moving Average Indicator for Order Entry | << Add your own Indicator Entry checks
//+-----------------------------------------------------------------+ << after the Moving Average Entry.
if(MAEntry>0&&CbT==0&&CpT<2)
{ if(BID>ima_0+MADistance&&(!B3Traditional||(B3Traditional&&Trend!=2)))
{ if(MAEntry==1)
{ if(ForceMarketCond!=1&&(UseAnyEntry||IndEntry==0||(!UseAnyEntry&&IndEntry>0&&BuyMe)))BuyMe=true;
else BuyMe=false;
if(!UseAnyEntry&&IndEntry>0&&SellMe&&(!B3Traditional||(B3Traditional&&Trend!=2)))SellMe=false;
}
else if(MAEntry==2)
{ if(ForceMarketCond!=0&&(UseAnyEntry||IndEntry==0||(!UseAnyEntry&&IndEntry>0&&SellMe)))SellMe=true;
else SellMe=false;
if(!UseAnyEntry&&IndEntry>0&&BuyMe&&(!B3Traditional||(B3Traditional&&Trend!=2)))BuyMe=false;
}
}
else if(ASK<ima_0-MADistance&&(!B3Traditional||(B3Traditional&&Trend!=2)))
{ if(MAEntry==1)
{ if(ForceMarketCond!=0&&(UseAnyEntry||IndEntry==0||(!UseAnyEntry&&IndEntry>0&&SellMe)))SellMe=true;
else SellMe=false;
if(!UseAnyEntry&&IndEntry>0&&BuyMe&&(!B3Traditional||(B3Traditional&&Trend!=2)))BuyMe=false;
}
else if(MAEntry==2)
{ if(ForceMarketCond!=1&&(UseAnyEntry||IndEntry==0||(!UseAnyEntry&&IndEntry>0&&BuyMe)))BuyMe=true;
else BuyMe=false;
if(!UseAnyEntry&&IndEntry>0&&SellMe&&(!B3Traditional||(B3Traditional&&Trend!=2)))SellMe=false;
}
}
else if(B3Traditional&&Trend==2)
{ if(ForceMarketCond!=1&&(UseAnyEntry||IndEntry==0||(!UseAnyEntry&&IndEntry>0&&BuyMe)))BuyMe=true;
if(ForceMarketCond!=0&&(UseAnyEntry||IndEntry==0||(!UseAnyEntry&&IndEntry>0&&SellMe)))SellMe=true;
}
else
{ BuyMe=false;
SellMe=false;
}
if(IndEntry>0)IndicatorUsed=IndicatorUsed+UAE;
IndEntry++;
IndicatorUsed=IndicatorUsed+" MA ";
}
//+----------------------------------------------------------------+
//| CCI of 5M,15M,30M,1H for Market Condition and Order Entry |
//+----------------------------------------------------------------+
if(CCIEntry>0)
{ double cci_01=iCCI(Symbol(),PERIOD_M5,CCIPeriod,PRICE_CLOSE,0);
double cci_02=iCCI(Symbol(),PERIOD_M15,CCIPeriod,PRICE_CLOSE,0);
double cci_03=iCCI(Symbol(),PERIOD_M30,CCIPeriod,PRICE_CLOSE,0);
double cci_04=iCCI(Symbol(),PERIOD_H1,CCIPeriod,PRICE_CLOSE,0);
double cci_11=iCCI(Symbol(),PERIOD_M5,CCIPeriod,PRICE_CLOSE,1);
double cci_12=iCCI(Symbol(),PERIOD_M15,CCIPeriod,PRICE_CLOSE,1);
double cci_13=iCCI(Symbol(),PERIOD_M30,CCIPeriod,PRICE_CLOSE,1);
double cci_14=iCCI(Symbol(),PERIOD_H1,CCIPeriod,PRICE_CLOSE,1);
}
if(CCIEntry>0&&CbT==0&&CpT<2)
{ if(cci_11>0&&cci_12>0&&cci_13>0&&cci_14>0&&cci_01>0&&cci_02>0&&cci_03>0&&cci_04>0)
{ if(ForceMarketCond==3)Trend=0;
if(CCIEntry==1)
{ if(ForceMarketCond!=1&&(UseAnyEntry||IndEntry==0||(!UseAnyEntry&&IndEntry>0&&BuyMe)))BuyMe=true;
else BuyMe=false;
if(!UseAnyEntry&&IndEntry>0&&SellMe&&(!B3Traditional||(B3Traditional&&Trend!=2)))SellMe=false;
}
else if(CCIEntry==2)
{ if(ForceMarketCond!=0&&(UseAnyEntry||IndEntry==0||(!UseAnyEntry&&IndEntry>0&&SellMe)))SellMe=true;
else SellMe=false;
if(!UseAnyEntry&&IndEntry>0&&BuyMe&&(!B3Traditional||(B3Traditional&&Trend!=2)))BuyMe=false;
}
}
else if(cci_11<0&&cci_12<0&&cci_13<0&&cci_14<0&&cci_01<0&&cci_02<0&&cci_03<0&&cci_04<0)
{ if(ForceMarketCond==3)Trend=1;
if(CCIEntry==1)
{ if(ForceMarketCond!=0&&(UseAnyEntry||IndEntry==0||(!UseAnyEntry&&IndEntry>0&&SellMe)))SellMe=true;
else SellMe=false;
if(!UseAnyEntry&&IndEntry>0&&BuyMe&&(!B3Traditional||(B3Traditional&&Trend!=2)))BuyMe=false;
}
else if(CCIEntry==2)
{ if(ForceMarketCond!=1&&(UseAnyEntry||IndEntry==0||(!UseAnyEntry&&IndEntry>0&&BuyMe)))BuyMe=true;
else BuyMe=false;
if(!UseAnyEntry&&IndEntry>0&&SellMe&&(!B3Traditional||(B3Traditional&&Trend!=2)))SellMe=false;
}
}
else if(!UseAnyEntry&&IndEntry>0)
{ BuyMe=false;
SellMe=false;
}
if(IndEntry>0)IndicatorUsed=IndicatorUsed+UAE;
IndEntry++;
IndicatorUsed=IndicatorUsed+" CCI ";
}
//+----------------------------------------------------------------+
//| Bollinger Band Indicator for Order Entry |
//+----------------------------------------------------------------+
if(BollingerEntry>0&&CbT==0&&CpT<2)
{ double ma=iMA(Symbol(),0,BollPeriod,0,MODE_SMA,PRICE_OPEN,0);
double stddev=iStdDev(Symbol(),0,BollPeriod,0,MODE_SMA,PRICE_OPEN,0);
double bup=ma+(BollDeviation*stddev);
double bdn=ma-(BollDeviation*stddev);
double bux=bup+BollDistance;
double bdx=bdn-BollDistance;
if(ASK<bdx)
{ if(BollingerEntry==1)
{ if(ForceMarketCond!=1&&(UseAnyEntry||IndEntry==0||(!UseAnyEntry&&IndEntry>0&&BuyMe)))BuyMe=true;
else BuyMe=false;
if(!UseAnyEntry&&IndEntry>0&&SellMe&&(!B3Traditional||(B3Traditional&&Trend!=2)))SellMe=false;
}
else if(BollingerEntry==2)
{ if(ForceMarketCond!=0&&(UseAnyEntry||IndEntry==0||(!UseAnyEntry&&IndEntry>0&&SellMe)))SellMe=true;
else SellMe=false;
if(!UseAnyEntry&&IndEntry>0&&BuyMe&&(!B3Traditional||(B3Traditional&&Trend!=2)))BuyMe=false;
}
}
else if(BID>bux)
{ if(BollingerEntry==1)
{ if(ForceMarketCond!=0&&(UseAnyEntry||IndEntry==0||(!UseAnyEntry&&IndEntry>0&&SellMe)))SellMe=true;
else SellMe=false;
if(!UseAnyEntry&&IndEntry>0&&BuyMe&&(!B3Traditional||(B3Traditional&&Trend!=2)))BuyMe=false;
}
else if(BollingerEntry==2)
{ if(ForceMarketCond!=1&&(UseAnyEntry||IndEntry==0||(!UseAnyEntry&&IndEntry>0&&BuyMe)))BuyMe=true;
else BuyMe=false;
if(!UseAnyEntry&&IndEntry>0&&SellMe&&(!B3Traditional||(B3Traditional&&Trend!=2)))SellMe=false;
}
}
else if(!UseAnyEntry&&IndEntry>0)
{ BuyMe=false;
SellMe=false;
}
if(IndEntry>0)IndicatorUsed=IndicatorUsed+UAE;
IndEntry++;
IndicatorUsed=IndicatorUsed+" BBands ";
}
//+----------------------------------------------------------------+
//| Stochastic Indicator for Order Entry |
//+----------------------------------------------------------------+
if(StochEntry>0&&CbT==0&&CpT<2)
{ int zoneBUY=BuySellStochZone;
int zoneSELL=100-BuySellStochZone;
double stoc_0=iStochastic(NULL,0,KPeriod,DPeriod,Slowing,MODE_LWMA,1,0,1);
double stoc_1=iStochastic(NULL,0,KPeriod,DPeriod,Slowing,MODE_LWMA,1,1,1);
if(stoc_0<zoneBUY&&stoc_1<zoneBUY)
{ if(StochEntry==1)
{ if(ForceMarketCond!=1&&(UseAnyEntry||IndEntry==0||(!UseAnyEntry&&IndEntry>0&&BuyMe)))BuyMe=true;
else BuyMe=false;
if(!UseAnyEntry&&IndEntry>0&&SellMe&&(!B3Traditional||(B3Traditional&&Trend!=2)))SellMe=false;
}
else if(StochEntry==2)
{ if(ForceMarketCond!=0&&(UseAnyEntry||IndEntry==0||(!UseAnyEntry&&IndEntry>0&&SellMe)))SellMe=true;
else SellMe=false;
if(!UseAnyEntry&&IndEntry>0&&BuyMe&&(!B3Traditional||(B3Traditional&&Trend!=2)))BuyMe=false;
}
}
else if(stoc_0>zoneSELL&&stoc_1>zoneSELL)
{ if(StochEntry==1)
{ if(ForceMarketCond!=0&&(UseAnyEntry||IndEntry==0||(!UseAnyEntry&&IndEntry>0&&SellMe)))SellMe=true;
else SellMe=false;
if(!UseAnyEntry&&IndEntry>0&&BuyMe&&(!B3Traditional||(B3Traditional&&Trend!=2)))BuyMe=false;
}
else if(StochEntry==2)
{ if(ForceMarketCond!=1&&(UseAnyEntry||IndEntry==0||(!UseAnyEntry&&IndEntry>0&&BuyMe)))BuyMe=true;
else BuyMe=false;
if(!UseAnyEntry&&IndEntry>0&&SellMe&&(!B3Traditional||(B3Traditional&&Trend!=2)))SellMe=false;
}
}
else if(!UseAnyEntry&&IndEntry>0)
{ BuyMe=false;
SellMe=false;
}
if(IndEntry>0)IndicatorUsed=IndicatorUsed+UAE;
IndEntry++;
IndicatorUsed=IndicatorUsed+" Stoch ";
}
//+----------------------------------------------------------------+
//| MACD Indicator for Order Entry |
//+----------------------------------------------------------------+
if(MACDEntry>0&&CbT==0&&CpT<2)
{ double MACDm=iMACD(NULL,TF[MACD_TF],FastPeriod,SlowPeriod,SignalPeriod,MACDPrice,0,0);
double MACDs=iMACD(NULL,TF[MACD_TF],FastPeriod,SlowPeriod,SignalPeriod,MACDPrice,1,0);
if(MACDm>MACDs)
{ if(MACDEntry==1)
{ if(ForceMarketCond!=1&&(UseAnyEntry||IndEntry==0||(!UseAnyEntry&&IndEntry>0&&BuyMe)))BuyMe=true;
else BuyMe=false;
if(!UseAnyEntry&&IndEntry>0&&SellMe&&(!B3Traditional||(B3Traditional&&Trend!=2)))SellMe=false;
}
else if(MACDEntry==2)
{ if(ForceMarketCond!=0&&(UseAnyEntry||IndEntry==0||(!UseAnyEntry&&IndEntry>0&&SellMe)))SellMe=true;
else SellMe=false;
if(!UseAnyEntry&&IndEntry>0&&BuyMe&&(!B3Traditional||(B3Traditional&&Trend!=2)))BuyMe=false;
}
}
else if(MACDm<MACDs)
{ if(MACDEntry==1)
{ if(ForceMarketCond!=0&&(UseAnyEntry||IndEntry==0||(!UseAnyEntry&&IndEntry>0&&SellMe)))SellMe=true;
else SellMe=false;
if(!UseAnyEntry&&IndEntry>0&&BuyMe&&(!B3Traditional||(B3Traditional&&Trend!=2)))BuyMe=false;
}
else if(MACDEntry==2)
{ if(ForceMarketCond!=1&&(UseAnyEntry||IndEntry==0||(!UseAnyEntry&&IndEntry>0&&BuyMe)))BuyMe=true;
else BuyMe=false;
if(!UseAnyEntry&&IndEntry>0&&SellMe&&(!B3Traditional||(B3Traditional&&Trend!=2)))SellMe=false;
}
}
else if(!UseAnyEntry&&IndEntry>0)
{ BuyMe=false;
SellMe=false;
}
if(IndEntry>0)IndicatorUsed=IndicatorUsed+UAE;
IndEntry++;
IndicatorUsed=IndicatorUsed+" MACD ";
}
//+-----------------------------------------------------------------+ << This must be the last Entry check before
//| UseAnyEntry Check && Force Market Condition Buy/Sell Entry | << the Trade Selection Logic. Add checks for
//+-----------------------------------------------------------------+ << additional indicators before this block.
if((!UseAnyEntry&&IndEntry>1&&BuyMe&&SellMe)||FirstRun)
{ BuyMe=false;
SellMe=false;
}
if(ForceMarketCond<2&&IndEntry==0&&CbT==0&&!FirstRun)
{ if(ForceMarketCond==0)BuyMe=true;
if(ForceMarketCond==1)SellMe=true;
IndicatorUsed=" FMC ";
}
//+-----------------------------------------------------------------+
//| Trade Selection Logic |
//+-----------------------------------------------------------------+
OrderLot=LotSize(Lots[StrToInteger(DTS(MathMin(CbT+CbC,MaxTrades-1),0))]*LotMult);
if(CbT==0&&CpT<2&&!FirstRun)
{ if(B3Traditional)
{ if(BuyMe)
{ if(CpBS==0&&CpSL==0&&((Trend!=2||MAEntry==0)||(Trend==2&&MAEntry==1)))
{ Entry=g2-MathMod(ASK,g2)+EntryOffset;
if(Entry>StopLevel)
{ Ticket=SendOrder(Symbol(),OP_BUYSTOP,OrderLot,Entry,0,Magic,CLR_NONE);
if(Ticket>0)
{ if(Debug)Print("Indicator Entry - ("+IndicatorUsed+") BuyStop MC = "+Trend);
CpBS++;
}
}
}
if(CpBL==0&&CpSS==0&&((Trend!=2||MAEntry==0)||(Trend==2&&MAEntry==2)))
{ Entry=MathMod(ASK,g2)+EntryOffset;
if(Entry>StopLevel)
{ Ticket=SendOrder(Symbol(),OP_BUYLIMIT,OrderLot,-Entry,0,Magic,CLR_NONE);
if(Ticket>0)
{ if(Debug)Print("Indicator Entry - ("+IndicatorUsed+") BuyLimit MC = "+Trend);
CpBL++;
}
}
}
}
if(SellMe)
{ if(CpSL==0&&CpBS==0&&((Trend!=2||MAEntry==0)||(Trend==2&&MAEntry==2)))
{ Entry=g2-MathMod(BID,g2)+EntryOffset;
if(Entry>StopLevel)
{ Ticket=SendOrder(Symbol(),OP_SELLLIMIT,OrderLot,Entry,0,Magic,CLR_NONE);
if(Ticket>0&&Debug)Print("Indicator Entry - ("+IndicatorUsed+") SellLimit MC = "+Trend);
}
}
if(CpSS==0&&CpBL==0&&((Trend!=2||MAEntry==0)||(Trend==2&&MAEntry==1)))
{ Entry=MathMod(BID,g2)+EntryOffset;
if(Entry>StopLevel)
{ Ticket=SendOrder(Symbol(),OP_SELLSTOP,OrderLot,-Entry,0,Magic,CLR_NONE);
if(Ticket>0&&Debug)Print("Indicator Entry - ("+IndicatorUsed+") SellStop MC = "+Trend);
}
}
}
}
else
{ if(BuyMe)
{ Ticket=SendOrder(Symbol(),OP_BUY,OrderLot,0,slip,Magic,Blue);
if(Ticket>0&&Debug)Print("Indicator Entry - ("+IndicatorUsed+") Buy");
}
else if(SellMe)
{ Ticket=SendOrder(Symbol(),OP_SELL,OrderLot,0,slip,Magic,displayColorLoss);
if(Ticket>0&&Debug)Print("Indicator Entry - ("+IndicatorUsed+") Sell");
}
}
if(Ticket>0)return(0);
}
else if(TimeCurrent()-EntryDelay>OTbL&&CbT+CbC<MaxTrades&&!FirstRun)
{ if(UseSmartGrid)
{ if(RSI[1]!=iRSI(NULL,TF[RSI_TF],RSI_Period,RSI_Price,1))
for(y=0;y<RSI_Period+RSI_MA_Period;y++)RSI[y]=iRSI(NULL,TF[RSI_TF],RSI_Period,RSI_Price,y);
else RSI[0]=iRSI(NULL,TF[RSI_TF],RSI_Period,RSI_Price,0);
RSI_MA=iMAOnArray(RSI,0,RSI_MA_Period,0,RSI_MA_Method,0);
}
if(CbB>0)
{ if(OPbL>ASK)Entry=OPbL-(MathRound((OPbL-ASK)/g2)+1)*g2;
else Entry=OPbL-g2;
double OPbN;
if(UseSmartGrid)
{ if(ASK<OPbL-g2)
{ if(RSI[0]>RSI_MA)
{ Ticket=SendOrder(Symbol(),OP_BUY,OrderLot,0,slip,Magic,Blue);
if(Ticket>0&&Debug)Print("SmartGrid Buy RSI: "+RSI[0]+" > MA: "+RSI_MA);
}
OPbN=0;
}
else OPbN=OPbL-g2;
}
else if(CpBL==0)
{ if(ASK-Entry<=StopLevel)Entry=OPbL-(MathFloor((OPbL-ASK+StopLevel)/g2)+1)*g2;
Ticket=SendOrder(Symbol(),OP_BUYLIMIT,OrderLot,Entry-ASK,0,Magic,SkyBlue);
if(Ticket>0&&Debug)Print("BuyLimit grid");
}
else if(CpBL==1&&Entry-OPpBL>g2/2&&ASK-Entry>StopLevel)
{ for(y=OrdersTotal();y>=0;y--)
{ if(!OrderSelect(y,SELECT_BY_POS,MODE_TRADES))continue;
if(OrderMagicNumber()!=Magic||OrderSymbol()!=Symbol()||OrderType()!=OP_BUYLIMIT)continue;
Success=ModifyOrder(Entry,0,SkyBlue);
if(Success&&Debug)Print("Mod BuyLimit Entry");
}
}
}
else if(CbS>0)
{ if(BID>OPbL)Entry=OPbL+(MathRound((-OPbL+BID)/g2)+1)*g2;
else Entry=OPbL+g2;
if(UseSmartGrid)
{ if(BID>OPbL+g2)
{ if(RSI[0]<RSI_MA)
{ Ticket=SendOrder(Symbol(),OP_SELL,OrderLot,0,slip,Magic,displayColorLoss);
if(Ticket>0&&Debug)Print("SmartGrid Sell RSI: "+RSI[0]+" < MA: "+RSI_MA);
}
OPbN=0;
}
else OPbN=OPbL+g2;
}
else if(CpSL==0)
{ if(Entry-BID<=StopLevel)Entry=OPbL+(MathFloor((-OPbL+BID+StopLevel)/g2)+1)*g2;
Ticket=SendOrder(Symbol(),OP_SELLLIMIT,OrderLot,Entry-BID,0,Magic,Coral);
if(Ticket>0&&Debug)Print("SellLimit grid");
}
else if(CpSL==1&&OPpSL-Entry>g2/2&&Entry-BID>StopLevel)
{ for(y=OrdersTotal()-1;y>=0;y--)
{ if(!OrderSelect(y,SELECT_BY_POS,MODE_TRADES))continue;
if(OrderMagicNumber()!=Magic||OrderSymbol()!=Symbol()||OrderType()!=OP_SELLLIMIT)continue;
Success=ModifyOrder(Entry,0,Coral);
if(Success&&Debug)Print("Mod SellLimit Entry");
}
}
}
if(Ticket>0)return(0);
}
//+-----------------------------------------------------------------+
//| Hedge Trades Set-Up and Monitoring |
//+-----------------------------------------------------------------+
if((UseHedge&&CbT>0)||ChT>0)
{ int hLevel=CbT+CbC;
if(HedgeTypeDD)
{ if(hDDStart==0&&ChT>0)hDDStart=MathMax(HedgeStart,DrawDownPC+hReEntryPC);
if(hDDStart>HedgeStart&&hDDStart>DrawDownPC+hReEntryPC)hDDStart=DrawDownPC+hReEntryPC;
if(hActive==2)
{ hActive=0;
hDDStart=MathMax(HedgeStart,DrawDownPC+hReEntryPC);
}
}
if(hActive==0)
{ if(!hThisChart&&((hPosCorr&&CheckCorr()<0.9)||(!hPosCorr&&CheckCorr()>-0.9)))
{ if(ObjectFind("B3LhCor")==-1)
CreateLabel("B3LhCor","The correlation with the hedge pair has dropped below 90%.",0,0,190,10,displayColorLoss);
}
else ObjDel("B3LhCor");
if(hLvlStart>hLevel+1||(!HedgeTypeDD&&hLvlStart==0))hLvlStart=MathMax(HedgeStart,hLevel+1);
if((HedgeTypeDD&&DrawDownPC>hDDStart)||(!HedgeTypeDD&&hLevel>=hLvlStart))
{ OrderLot=LotSize(LbT*hLotMult);
if((CbB>0&&!hPosCorr)||(CbS>0&&hPosCorr))
{ Ticket=SendOrder(HedgeSymbol,OP_BUY,OrderLot,0,slip,hMagic,MidnightBlue);
if(Ticket>0)
{ if(hMaxLossPips>0)SLh=hAsk-hMaxLossPips;
if(Debug)Print("Hedge Buy : Stoploss @ "+DTS(SLh,Digits));
}
}
if((CbB>0&&hPosCorr)||(CbS>0&&!hPosCorr))
{ Ticket=SendOrder(HedgeSymbol,OP_SELL,OrderLot,0,slip,hMagic,Maroon);
if(Ticket>0)
{ if(hMaxLossPips>0)SLh=hBid+hMaxLossPips;
if(Debug)Print("Hedge Sell : Stoploss @ "+DTS(SLh,Digits));
}
}
if(Ticket>0)
{ hActive=1;
if(HedgeTypeDD)hDDStart+=hReEntryPC;
hLvlStart=hLevel+1;
return(0);
}
}
}
else if(hActive==1)
{ if(HedgeTypeDD&&hDDStart>HedgeStart&&hDDStart<DrawDownPC+hReEntryPC)hDDStart=DrawDownPC+hReEntryPC;
if(hLvlStart==0)
{ if(HedgeTypeDD)hLvlStart=hLevel+1;
else hLvlStart=MathMax(HedgeStart,hLevel+1);
}
if(hLevel>=hLvlStart)
{ OrderLot=LotSize(Lots[CbT+CbC-1]*LotMult*hLotMult);
if(OrderLot>0&&((CbB>0&&!hPosCorr)||(CbS>0&&hPosCorr)))
{ Ticket=SendOrder(HedgeSymbol,OP_BUY,OrderLot,0,slip,hMagic,MidnightBlue);
if(Ticket>0&&Debug)Print("Hedge Buy");
}
if(OrderLot>0&&((CbB>0&&hPosCorr)||(CbS>0&&!hPosCorr)))
{ Ticket=SendOrder(HedgeSymbol,OP_SELL,OrderLot,0,slip,hMagic,Maroon);
if(Ticket>0&&Debug)Print("Hedge Sell");
}
if(Ticket>0)
{ hLvlStart=hLevel+1;
return(0);
}
}
y=0;
if(!FirstRun&&hMaxLossPips>0)
{ if(ChB>0)
{ if(hFixedSL)
{ if(SLh==0)SLh=hBid-hMaxLossPips;
}
else
{ if(SLh==0||(SLh<BEh&&SLh<hBid-hMaxLossPips))SLh=hBid-hMaxLossPips;
else if(StopTrailAtBE&&hBid-hMaxLossPips>=BEh)SLh=BEh;
else if(SLh>=BEh&&!StopTrailAtBE)
{ if(!ReduceTrailStop)SLh=MathMax(SLh,hBid-hMaxLossPips);
else SLh=MathMax(SLh,hBid-MathMax(StopLevel,hMaxLossPips*(1-(hBid-hMaxLossPips-BEh)/(hMaxLossPips*2))));
}
}
if(hBid<=SLh)y=ExitTrades(H,DarkViolet,"Hedge Stop Loss");
}
else if(ChS>0)
{ if(hFixedSL)
{ if(SLh==0)SLh=hAsk+hMaxLossPips;
}
else
{ if(SLh==0||(SLh>BEh&&SLh>hAsk+hMaxLossPips))SLh=hAsk+hMaxLossPips;
else if(StopTrailAtBE&&hAsk+hMaxLossPips<=BEh)SLh=BEh;
else if(SLh<=BEh&&!StopTrailAtBE)
{ if(!ReduceTrailStop)SLh=MathMin(SLh,hAsk+hMaxLossPips);
else SLh=MathMin(SLh,hAsk+MathMax(StopLevel,hMaxLossPips*(1-(BEh-hAsk-hMaxLossPips)/(hMaxLossPips*2))));
}
}
if(hAsk>=SLh)y=ExitTrades(H,DarkViolet,"Hedge Stop Loss");
}
}
if(y==0&&hTakeProfit>0)
{ if(ChB>0&&hBid>OPhO+hTakeProfit)y=ExitTrades(T,DarkViolet,"Hedge Take Profit reached",ThO);
if(ChS>0&&hAsk<OPhO-hTakeProfit)y=ExitTrades(T,DarkViolet,"Hedge Take Profit reached",ThO);
}
if(y>0)
{ PhC=FindClosedPL(H);
if(y==ChT)
{ if(HedgeTypeDD)hActive=2;
else hActive=0;
}
return(0);
}
}
}
//+-----------------------------------------------------------------+
//| Check DD% and send Email |
//+-----------------------------------------------------------------+
if((UseEmail||PlaySounds)&&!Testing)
{ if(EmailCount<2&&Email[EmailCount]>0&&DrawDownPC>Email[EmailCount])
{ GetLastError();
if(UseEmail)
{ SendMail("Blessing EA","Blessing has exceeded a drawdown of "+Email[EmailCount]*100+"% on "+Symbol()+" "+sTF);
Error=GetLastError();
if(Error>0)Print("Email DD: "+DTS(DrawDownPC*100,2)+" Error: "+Error+" "+ErrorDescription(Error));
else if(Debug)Print("DrawDown Email sent on "+Symbol()+" "+sTF+ " DD: "+DTS(DrawDownPC*100,2));
EmailSent=TimeCurrent();
EmailCount++;
}
if(PlaySounds)PlaySound(AlertSound);
}
else if(EmailCount>0&&EmailCount<3&&DrawDownPC<Email[EmailCount]&&TimeCurrent()>EmailSent+EmailHours*3600)EmailCount--;
}
//+-----------------------------------------------------------------+
//| Display Overlay Code |
//+-----------------------------------------------------------------+
if((Testing&&Visual)||!Testing)
{ if(displayOverlay)
{ color Colour;
int dDigits;
ObjSetTxt("B3VTime",TimeToStr(TimeCurrent(),TIME_SECONDS));
DrawLabel("B3VSTAm",InitialAccountMultiPortion,167,2,displayColorLoss);
if(UseHolidayShutdown)
{ ObjSetTxt("B3VHolF",TimeToStr(HolFirst,TIME_DATE));
ObjSetTxt("B3VHolT",TimeToStr(HolLast,TIME_DATE));
}
DrawLabel("B3VPBal",PortionBalance,167);
if(DrawDownPC>0.4)Colour=displayColorLoss;
else if(DrawDownPC>0.3)Colour=Orange;
else if(DrawDownPC>0.2)Colour=Yellow;
else if(DrawDownPC>0.1)Colour=displayColorProfit;
else Colour=displayColor;
DrawLabel("B3VDrDn",DrawDownPC*100,315,2,Colour);
if(UseHedge&&HedgeTypeDD)ObjSetTxt("B3VhDDm",DTS(hDDStart*100,2));
else if(UseHedge&&!HedgeTypeDD)
{ DrawLabel("B3VhLvl",CbT+CbC,318,0);
ObjSetTxt("B3VhLvT",DTS(hLvlStart,0));
}
ObjSetTxt("B3VSLot",DTS(Lot*LotMult,2));
if(ProfitPot>=0)DrawLabel("B3VPPot",ProfitPot,190);
else
{ ObjSetTxt("B3VPPot",DTS(ProfitPot,2),0,displayColorLoss);
dDigits=Digit[ArrayBsearch(Digit,-ProfitPot,WHOLE_ARRAY,0,MODE_ASCEND),1];
ObjSet("B3VPPot",186-dDigits*7);
}
if(UseEarlyExit&&EEpc<1)
{ if(ObjectFind("B3SEEPr")==-1)CreateLabel("B3SEEPr","/",0,0,220,12);
if(ObjectFind("B3VEEPr")==-1)CreateLabel("B3VEEPr","",0,0,229,12);
ObjSetTxt("B3VEEPr",DTS(PbTarget*PipValue*MathAbs(LbB-LbS),2));
}
else
{ ObjDel("B3SEEPr");
ObjDel("B3VEEPr");
}
if(SLb>0)DrawLabel("B3VPrSL",SLb,190,Digits);
else if(bSL>0)DrawLabel("B3VPrSL",bSL,190,Digits);
else if(bTS>0)DrawLabel("B3VPrSL",bTS,190,Digits);
else DrawLabel("B3VPrSL",0,190,2);
if(Pb>=0)
{ DrawLabel("B3VPnPL",Pb,190,2,displayColorProfit);
ObjSetTxt("B3VPPip",DTS(PbPips,1),0,displayColorProfit);
ObjSet("B3VPPip",229);
}
else
{ ObjSetTxt("B3VPnPL",DTS(Pb,2),0,displayColorLoss);
dDigits=Digit[ArrayBsearch(Digit,-Pb,WHOLE_ARRAY,0,MODE_ASCEND),1];
ObjSet("B3VPnPL",186-dDigits*7);
ObjSetTxt("B3VPPip",DTS(PbPips,1),0,displayColorLoss);
ObjSet("B3VPPip",225);
}
if(PbMax>=0)DrawLabel("B3VPLMx",PbMax,190,2,displayColorProfit);
else
{ ObjSetTxt("B3VPLMx",DTS(PbMax,2),0,displayColorLoss);
dDigits=Digit[ArrayBsearch(Digit,-PbMax,WHOLE_ARRAY,0,MODE_ASCEND),1];
ObjSet("B3VPLMx",186-dDigits*7);
}
if(PbMin<0)ObjSet("B3VPLMn",225);
else ObjSet("B3VPLMn",229);
ObjSetTxt("B3VPLMn",DTS(PbMin,2),0,displayColorLoss);
if(CbT+CbC<BreakEvenTrade&&CbT+CbC<MaxTrades)Colour=displayColor;
else if(CbT+CbC<MaxTrades)Colour=Orange;
else Colour=displayColorLoss;
if(CbB>0)
{ ObjSetTxt("B3LType","Buy:");
DrawLabel("B3VOpen",CbB,207,0,Colour);
}
else if(CbS>0)
{ ObjSetTxt("B3LType","Sell:");
DrawLabel("B3VOpen",CbS,207,0,Colour);
}
else
{ ObjSetTxt("B3LType","");
ObjSetTxt("B3VOpen",DTS(0,0),0,Colour);
ObjSet("B3VOpen",207);
}
ObjSetTxt("B3VLots",DTS(LbT,2));
ObjSetTxt("B3VMove",DTS(Moves,0));
DrawLabel("B3VMxDD",MaxDD,107);
DrawLabel("B3VDDPC",MaxDDPer,229);
if(Trend==0)
{ ObjSetTxt("B3LTrnd","Trend is UP",10,displayColorProfit);
if(ObjectFind("B3ATrnd")==-1)CreateLabel("B3ATrnd","",0,0,160,20,displayColorProfit,"Wingdings");
ObjectSetText("B3ATrnd","é",displayFontSize+9,"Wingdings",displayColorProfit);
ObjSet("B3ATrnd",160);
ObjectSet("B3ATrnd",OBJPROP_YDISTANCE,displayYcord+displaySpacing*20);
if(StringLen(ATrend)>0)
{ if(ObjectFind("B3AATrn")==-1)CreateLabel("B3AATrn","",0,0,200,20,displayColorProfit,"Wingdings");
if(ATrend=="D")
{ ObjectSetText("B3AATrn","ê",displayFontSize+9,"Wingdings",displayColorLoss);
ObjectSet("B3AATrn",OBJPROP_YDISTANCE,displayYcord+displaySpacing*20+5);
}
else if(ATrend=="R")
{ ObjSetTxt("B3AATrn","R",10,Orange);
ObjectSet("B3AATrn",OBJPROP_YDISTANCE,displayYcord+displaySpacing*20);
}
}
else ObjDel("B3AATrn");
}
else if(Trend==1)
{ ObjSetTxt("B3LTrnd","Trend is DOWN",10,displayColorLoss);
if(ObjectFind("B3ATrnd")==-1)CreateLabel("B3ATrnd","",0,0,210,20,displayColorLoss,"WingDings");
ObjectSetText("B3ATrnd","ê",displayFontSize+9,"Wingdings",displayColorLoss);
ObjSet("B3ATrnd",210);
ObjectSet("B3ATrnd",OBJPROP_YDISTANCE,displayYcord+displaySpacing*20+5);
if(StringLen(ATrend)>0)
{ if(ObjectFind("B3AATrn")==-1)CreateLabel("B3AATrn","",0,0,250,20,displayColorProfit,"Wingdings");
if(ATrend=="U")
{ ObjectSetText("B3AATrn","é",displayFontSize+9,"Wingdings",displayColorProfit);
ObjectSet("B3AATrn",OBJPROP_YDISTANCE,displayYcord+displaySpacing*20);
}
else if(ATrend=="R")
{ ObjSetTxt("B3AATrn","R",10,Orange);
ObjectSet("B3AATrn",OBJPROP_YDISTANCE,displayYcord+displaySpacing*20);
}
}
else ObjDel("B3AATrn");
}
else if(Trend==2)
{ ObjSetTxt("B3LTrnd","Trend is Ranging",10,Orange);
ObjDel("B3ATrnd");
if(StringLen(ATrend)>0)
{ if(ObjectFind("B3AATrn")==-1)CreateLabel("B3AATrn","",0,0,220,20,displayColorProfit,"Wingdings");
if(ATrend=="U")
{ ObjectSetText("B3AATrn","é",displayFontSize+9,"Wingdings",displayColorProfit);
ObjectSet("B3AATrn",OBJPROP_YDISTANCE,displayYcord+displaySpacing*20);
}
else if(ATrend=="D")
{ ObjectSetText("B3AATrn","ê",displayFontSize+8,"Wingdings",displayColorLoss);
ObjectSet("B3AATrn",OBJPROP_YDISTANCE,displayYcord+displaySpacing*20+5);
}
}
else ObjDel("B3AATrn");
}
if(PaC!=0)
{ if(ObjectFind("B3LClPL")==-1)CreateLabel("B3LClPL","Closed P/L",0,0,312,11);
if(ObjectFind("B3VClPL")==-1)CreateLabel("B3VClPL","",0,0,327,12);
if(PaC>=0)DrawLabel("B3VClPL",PaC,327,2,displayColorProfit);
else
{ ObjSetTxt("B3VClPL",DTS(PaC,2),0,displayColorLoss);
dDigits=Digit[ArrayBsearch(Digit,-PaC,WHOLE_ARRAY,0,MODE_ASCEND),1];
ObjSet("B3VClPL",323-dDigits*7);
}
}
else
{ ObjDel("B3LClPL");
ObjDel("B3VClPL");
}
if(hActive==1)
{ if(ObjectFind("B3LHdge")==-1)CreateLabel("B3LHdge","Hedge",0,0,323,13);
if(ObjectFind("B3VhPro")==-1)CreateLabel("B3VhPro","",0,0,312,14);
if(Ph>=0)DrawLabel("B3VhPro",Ph,312,2,displayColorProfit);
else
{ ObjSetTxt("B3VhPro",DTS(Ph,2),0,displayColorLoss);
dDigits=Digit[ArrayBsearch(Digit,-Ph,WHOLE_ARRAY,0,MODE_ASCEND),1];
ObjSet("B3VhPro",308-dDigits*7);
}
if(ObjectFind("B3VhPMx")==-1)CreateLabel("B3VhPMx","",0,0,312,15);
if(PhMax>=0)DrawLabel("B3VhPMx",PhMax,312,2,displayColorProfit);
else
{ ObjSetTxt("B3VhPMx",DTS(PhMax,2),0,displayColorLoss);
dDigits=Digit[ArrayBsearch(Digit,-PhMax,WHOLE_ARRAY,0,MODE_ASCEND),1];
ObjSet("B3VhPMx",308-dDigits*7);
}
if(ObjectFind("B3ShPro")==-1)CreateLabel("B3ShPro","/",0,0,342,15);
if(ObjectFind("B3VhPMn")==-1)CreateLabel("B3VhPMn","",0,0,351,15,displayColorLoss);
if(PhMin<0)ObjSet("B3VhPMn",347);
else ObjSet("B3VhPMn",351);
ObjSetTxt("B3VhPMn",DTS(PhMin,2),0,displayColorLoss);
if(ObjectFind("B3LhTyp")==-1)CreateLabel("B3LhTyp","",0,0,292,16);
if(ObjectFind("B3VhOpn")==-1)CreateLabel("B3VhOpn","",0,0,329,16);
if(ChB>0)
{ ObjSetTxt("B3LhTyp","Buy:");
DrawLabel("B3VhOpn",ChB,329,0);
}
else if(ChS>0)
{ ObjSetTxt("B3LhTyp","Sell:");
DrawLabel("B3VhOpn",ChS,329,0);
}
else
{ ObjSetTxt("B3LhTyp","");
ObjSetTxt("B3VhOpn",DTS(0,0));
ObjSet("B3VhOpn",329);
}
if(ObjectFind("B3ShOpn")==-1)CreateLabel("B3ShOpn","/",0,0,342,16);
if(ObjectFind("B3VhLot")==-1)CreateLabel("B3VhLot","",0,0,351,16);
ObjSetTxt("B3VhLot",DTS(LhT,2));
}
else
{ ObjDel("B3LHdge");
ObjDel("B3VhPro");
ObjDel("B3VhPMx");
ObjDel("B3ShPro");
ObjDel("B3VhPMn");
ObjDel("B3LhTyp");
ObjDel("B3VhOpn");
ObjDel("B3ShOpn");
ObjDel("B3VhLot");
}
}
if(displayLines)
{ if(BEb>0)
{ if(ObjectFind("B3LBELn")==-1)CreateLine("B3LBELn",DodgerBlue,1,0);
ObjectMove("B3LBELn",0,Time[1],BEb);
}
else ObjDel("B3LBELn");
if(TPa>0)
{ if(ObjectFind("B3LTPLn")==-1)CreateLine("B3LTPLn",Gold,1,0);
ObjectMove("B3LTPLn",0,Time[1],TPa);
}
else if(TPb>0&&nLots!=0)
{ if(ObjectFind("B3LTPLn")==-1)CreateLine("B3LTPLn",Gold,1,0);
ObjectMove("B3LTPLn",0,Time[1],TPb);
}
else ObjDel("B3LTPLn");
if(OPbN>0)
{ if(ObjectFind("B3LOPLn")==-1)CreateLine("B3LOPLn",Red,1,4);
ObjectMove("B3LOPLn",0,Time[1],OPbN);
}
else ObjDel("B3LOPLn");
if(bSL>0)
{ if(ObjectFind("B3LSLbT")==-1)CreateLine("B3LSLbT",Red,1,3);
ObjectMove("B3LSLbT",0,Time[1],bSL);
}
else ObjDel("B3LSLbT");
if(bTS>0)
{ if(ObjectFind("B3LTSbT")==-1)CreateLine("B3LTSbT",Gold,1,3);
ObjectMove("B3LTSbT",0,Time[1],bTS);
}
else ObjDel("B3LTSbT");
if(hActive==1&&BEa>0)
{ if(ObjectFind("B3LNBEL")==-1)CreateLine("B3LNBEL",Crimson,1,0);
ObjectMove("B3LNBEL",0,Time[1],BEa);
}
else ObjDel("B3LNBEL");
if(TPbMP>0)
{ if(ObjectFind("B3LMPLn")==-1)CreateLine("B3LMPLn",Gold,1,4);
ObjectMove("B3LMPLn",0,Time[1],TPbMP);
}
else ObjDel("B3LMPLn");
if(SLb>0)
{ if(ObjectFind("B3LTSLn")==-1)CreateLine("B3LTSLn",Gold,1,2);
ObjectMove("B3LTSLn",0,Time[1],SLb);
}
else ObjDel("B3LTSLn");
if(hThisChart&&BEh>0)
{ if(ObjectFind("B3LhBEL")==-1)CreateLine("B3LhBEL",SlateBlue,1,0);
ObjectMove("B3LhBEL",0,Time[1],BEh);
}
else ObjDel("B3LhBEL");
if(hThisChart&&SLh>0)
{ if(ObjectFind("B3LhSLL")==-1)CreateLine("B3LhSLL",SlateBlue,1,3);
ObjectMove("B3LhSLL",0,Time[1],SLh);
}
else ObjDel("B3LhSLL");
}
else
{ ObjDel("B3LBELn");
ObjDel("B3LTPLn");
ObjDel("B3LOPLn");
ObjDel("B3LSLbT");
ObjDel("B3LTSbT");
ObjDel("B3LNBEL");
ObjDel("B3LMPLn");
ObjDel("B3LTSLn");
ObjDel("B3LhBEL");
ObjDel("B3LhSLL");
}
if(CCIEntry&&displayCCI)
{ if(cci_01>0&&cci_11>0)ObjectSetText("B3VCm05","Ù",displayFontSize+6,"Wingdings",displayColorProfit);
else if(cci_01<0&&cci_11<0)ObjectSetText("B3VCm05","Ú",displayFontSize+6,"Wingdings",displayColorLoss);
else ObjectSetText("B3VCm05","Ø",displayFontSize+6,"Wingdings",Orange);
if(cci_02>0&&cci_12>0)ObjectSetText("B3VCm15","Ù",displayFontSize+6,"Wingdings",displayColorProfit);
else if(cci_02<0&&cci_12<0)ObjectSetText("B3VCm15","Ú",displayFontSize+6,"Wingdings",displayColorLoss);
else ObjectSetText("B3VCm15","Ø",displayFontSize+6,"Wingdings",Orange);
if(cci_03>0&&cci_13>0)ObjectSetText("B3VCm30","Ù",displayFontSize+6,"Wingdings",displayColorProfit);
else if(cci_03<0&&cci_13<0)ObjectSetText("B3VCm30","Ú",displayFontSize+6,"Wingdings",displayColorLoss);
else ObjectSetText("B3VCm30","Ø",displayFontSize+6,"Wingdings",Orange);
if(cci_04>0&&cci_14>0)ObjectSetText("B3VCm60","Ù",displayFontSize+6,"Wingdings",displayColorProfit);
else if(cci_04<0&&cci_14<0)ObjectSetText("B3VCm60","Ú",displayFontSize+6,"Wingdings",displayColorLoss);
else ObjectSetText("B3VCm60","Ø",displayFontSize+6,"Wingdings",Orange);
}
if(Debug)
{ string dSpace;
for(y=0;y<=175;y++)dSpace=dSpace+" ";
string dMess="\n\n"+dSpace+"Ticket Magic Type Lots OpenPrice Costs Profit Potential";
for(y=0;y<OrdersTotal();y++)
{ if(!OrderSelect(y,SELECT_BY_POS,MODE_TRADES))continue;
if(OrderMagicNumber()!=Magic&&OrderMagicNumber()!=hMagic)continue;
dMess=(dMess+"\n"+dSpace+" "+OrderTicket()+" "+DTS(OrderMagicNumber(),0)+" "+OrderType());
dMess=(dMess+" "+DTS(OrderLots(),LotDecimal)+" "+DTS(OrderOpenPrice(),Digits));
dMess=(dMess+" "+DTS(OrderSwap()+OrderCommission(),2));
dMess=(dMess+" "+DTS(OrderProfit()+OrderSwap()+OrderCommission(),2));
if(OrderMagicNumber()!=Magic)continue;
if(OrderType()==OP_BUY)dMess=(dMess+" "+DTS(OrderLots()*(TPb-OrderOpenPrice())*PipVal2+OrderSwap()+OrderCommission(),2));
if(OrderType()==OP_SELL)dMess=(dMess+" "+DTS(OrderLots()*(OrderOpenPrice()-TPb)*PipVal2+OrderSwap()+OrderCommission(),2));
}
if(!dLabels)
{ dLabels=true;
CreateLabel("B3LPipV","Pip Value",0,2,0,0);
CreateLabel("B3VPipV","",0,2,100,0);
CreateLabel("B3LDigi","Digits Value",0,2,0,1);
CreateLabel("B3VDigi","",0,2,100,1);
ObjSetTxt("B3VDigi",DTS(Digits,0));
CreateLabel("B3LPoin","Point Value",0,2,0,2);
CreateLabel("B3VPoin","",0,2,100,2);
ObjSetTxt("B3VPoin",DTS(Point,Digits));
CreateLabel("B3LSprd","Spread Value",0,2,0,3);
CreateLabel("B3VSprd","",0,2,100,3);
CreateLabel("B3LBid","Bid Value",0,2,0,4);
CreateLabel("B3VBid","",0,2,100,4);
CreateLabel("B3LAsk","Ask Value",0,2,0,5);
CreateLabel("B3VAsk","",0,2,100,5);
CreateLabel("B3LLotP","Lot Step",0,2,200,0);
CreateLabel("B3VLotP","",0,2,300,0);
ObjSetTxt("B3VLotP",DTS(MarketInfo(Symbol(),MODE_LOTSTEP),LotDecimal));
CreateLabel("B3LLotX","Lot Max",0,2,200,1);
CreateLabel("B3VLotX","",0,2,300,1);
ObjSetTxt("B3VLotX",DTS(MarketInfo(Symbol(),MODE_MAXLOT),0));
CreateLabel("B3LLotN","Lot Min",0,2,200,2);
CreateLabel("B3VLotN","",0,2,300,2);
ObjSetTxt("B3VLotN",DTS(MarketInfo(Symbol(),MODE_MINLOT),LotDecimal));
CreateLabel("B3LLotD","Lot Decimal",0,2,200,3);
CreateLabel("B3VLotD","",0,2,300,3);
ObjSetTxt("B3VLotD",DTS(LotDecimal,0));
CreateLabel("B3LAccT","Account Type",0,2,200,4);
CreateLabel("B3VAccT","",0,2,300,4);
ObjSetTxt("B3VAccT",DTS(AccountType,0));
CreateLabel("B3LPnts","Pip",0,2,200,5);
CreateLabel("B3VPnts","",0,2,300,5);
ObjSetTxt("B3VPnts",DTS(Pip,Digits));
CreateLabel("B3LTicV","Tick Value",0,2,400,0);
CreateLabel("B3VTicV","",0,2,500,0);
CreateLabel("B3LTicS","Tick Size",0,2,400,1);
CreateLabel("B3VTicS","",0,2,500,1);
ObjSetTxt("B3VTicS",DTS(MarketInfo(Symbol(),MODE_TICKSIZE),Digits));
CreateLabel("B3LLev","Leverage",0,2,400,2);
CreateLabel("B3VLev","",0,2,500,2);
ObjSetTxt("B3VLev",DTS(AccountLeverage(),0)+":1");
CreateLabel("B3LSGTF","SmartGrid",0,2,400,3);
if(UseSmartGrid)CreateLabel("B3VSGTF","True",0,2,500,3);
else CreateLabel("B3VSGTF","False",0,2,500,3);
CreateLabel("B3LCOTF","Close Oldest",0,2,400,4);
if(UseCloseOldest)CreateLabel("B3VCOTF","True",0,2,500,4);
else CreateLabel("B3VCOTF","False",0,2,500,4);
CreateLabel("B3LUHTF","Hedge",0,2,400,5);
if(UseHedge&&HedgeTypeDD)CreateLabel("B3VUHTF","DrawDown",0,2,500,5);
else if(UseHedge&&!HedgeTypeDD)CreateLabel("B3VUHTF","Level",0,2,500,5);
else CreateLabel("B3VUHTF","False",0,2,500,5);
}
ObjSetTxt("B3VPipV",DTS(PipValue,2));
ObjSetTxt("B3VSprd",DTS(ASK-BID,Digits));
ObjSetTxt("B3VBid",DTS(BID,Digits));
ObjSetTxt("B3VAsk",DTS(ASK,Digits));
ObjSetTxt("B3VTicV",DTS(MarketInfo(Symbol(),MODE_TICKVALUE),Digits));
}
if(EmergencyWarning)
{ if(ObjectFind("B3LClos")==-1)CreateLabel("B3LClos","",5,0,0,23,displayColorLoss);
ObjSetTxt("B3LClos","WARNING: EmergencyCloseAll is set to TRUE",5,displayColorLoss);
}
else if(ShutDown)
{ if(ObjectFind("B3LClos")==-1)CreateLabel("B3LClos","",5,0,0,23,displayColorLoss);
ObjSetTxt("B3LClos","Blessing will stop trading when this basket closes.",5,displayColorLoss);
}
else if(HolShutDown!=1)ObjDel("B3LClos");
}
WindowRedraw();
FirstRun=false;
Comment(CS,dMess);
return(0);
}
//+-----------------------------------------------------------------+
//| Check Lot Size Funtion |
//+-----------------------------------------------------------------+
double LotSize(double NewLot)
{ NewLot=ND(NewLot,LotDecimal);
NewLot=MathMin(NewLot,MarketInfo(Symbol(),MODE_MAXLOT));
NewLot=MathMax(NewLot,MinLotSize);
return(NewLot);
}
//+-----------------------------------------------------------------+
//| Open Order Funtion |
//+-----------------------------------------------------------------+
int SendOrder(string OSymbol,int OCmd,double OLot,double OPrice,double OSlip,int OMagic,color OColor=CLR_NONE)
{ if(FirstRun)return(-1);
int Ticket;
int retryTimes=5,i=0;
int OType=MathMod(OCmd,2);
double OrderPrice;
if(AccountFreeMarginCheck(OSymbol,OType,OLot)<=0)return(-1);
if(MaxSpread>0&&MarketInfo(OSymbol,MODE_SPREAD)*Point/Pip>MaxSpread)return(-1);
while(i<5)
{ i+=1;
while(IsTradeContextBusy())Sleep(100);
if(IsStopped())return(-1);
if(OType==0)OrderPrice=ND(MarketInfo(OSymbol,MODE_ASK)+OPrice,MarketInfo(OSymbol,MODE_DIGITS));
else OrderPrice=ND(MarketInfo(OSymbol,MODE_BID)+OPrice,MarketInfo(OSymbol,MODE_DIGITS));
Ticket=OrderSend(OSymbol,OCmd,OLot,OrderPrice,OSlip,0,0,TradeComment,OMagic,0,OColor);
if(Ticket<0)
{ Error=GetLastError();
if(Error!=0)Print("Error opening order: "+Error+" "+ErrorDescription(Error)
+" Symbol: "+OSymbol
+" TradeOP: "+OCmd
+" OType: "+OType
+" Ask: "+DTS(MarketInfo(OSymbol,MODE_ASK),Digits)
+" Bid: "+DTS(MarketInfo(OSymbol,MODE_BID),Digits)
+" OPrice: "+DTS(OPrice,Digits)
+" Price: "+DTS(OrderPrice,Digits)
+" Lots: "+DTS(OLot,2)
);
switch(Error)
{ case ERR_TRADE_DISABLED:
AllowTrading=false;
Print("Your broker has not allowed EAs on this account");
i=retryTimes;
break;
case ERR_OFF_QUOTES:
case ERR_INVALID_PRICE:
Sleep(5000);
case ERR_PRICE_CHANGED:
case ERR_REQUOTE:
RefreshRates();
case ERR_SERVER_BUSY:
case ERR_NO_CONNECTION:
case ERR_BROKER_BUSY:
case ERR_TRADE_CONTEXT_BUSY:
i++;
break;
case 149://ERR_TRADE_HEDGE_PROHIBITED:
UseHedge=false;
if(Debug)Print("Hedge trades are not allowed on this pair");
i=retryTimes;
break;
default:
i=retryTimes;
}
}
else
{ if(PlaySounds)PlaySound(AlertSound);
break;
}
}
return(Ticket);
}
//+-----------------------------------------------------------------+
//| Modify Order Function |
//+-----------------------------------------------------------------+
bool ModifyOrder(double OrderOP,double OrderSL,color Color=CLR_NONE)
{ bool Success=false;
int retryTimes=5,i=0;
while(i<5&&!Success)
{ i++;
while(IsTradeContextBusy())Sleep(100);
if(IsStopped())return(false);
Success=OrderModify(OrderTicket(),OrderOP,OrderSL,0,0,Color);
if(!Success)
{ Error=GetLastError();
if(Error>1)
{ Print(" Error Modifying Order:",OrderTicket(),", ",Error," :" +ErrorDescription(Error),", Ask:",Ask,
", Bid:",Bid," OrderPrice: ",OrderOP," StopLevel: ",StopLevel,", SL: ",OrderSL,", OSL: ",OrderStopLoss());
switch(Error)
{ case ERR_TRADE_MODIFY_DENIED:
Sleep(10000);
case ERR_OFF_QUOTES:
case ERR_INVALID_PRICE:
Sleep(5000);
case ERR_PRICE_CHANGED:
case ERR_REQUOTE:
RefreshRates();
case ERR_SERVER_BUSY:
case ERR_NO_CONNECTION:
case ERR_BROKER_BUSY:
case ERR_TRADE_CONTEXT_BUSY:
case ERR_TRADE_TIMEOUT:
i+=1;
break;
default:
i=retryTimes;
break;
}
}
else Success=true;
}
else break;
}
return(Success);
}
//+-------------------------------------------------------------------------+
//| Exit Trade Function - Type: All Basket Hedge Ticket Pending |
//+-------------------------------------------------------------------------+
int ExitTrades(int Type,color Color,string Reason,int OTicket=0)
{ static int OTicketNo;
bool Success;
int Tries,Closed,CloseCount;
int CloseTrades[,2];
double OPrice;
string s;
ca=Type;
if(Type==T)
{ if(OTicket==0)OTicket=OTicketNo;
else OTicketNo=OTicket;
}
for(y=OrdersTotal()-1;y>=0;y--)
{ if(!OrderSelect(y,SELECT_BY_POS,MODE_TRADES))continue;
if(Type==B&&OrderMagicNumber()!=Magic)continue;
else if(Type==H&&OrderMagicNumber()!=hMagic)continue;
else if(Type==A&&OrderMagicNumber()!=Magic&&OrderMagicNumber()!=hMagic)continue;
else if(Type==T&&OrderTicket()!=OTicket)continue;
else if(Type==P&&(OrderMagicNumber()!=Magic||OrderType()<=OP_SELL))continue;
ArrayResize(CloseTrades,CloseCount+1);
CloseTrades[CloseCount,0]=OrderOpenTime();
CloseTrades[CloseCount,1]=OrderTicket();
CloseCount++;
}
if(CloseCount>0)
{ if(!UseFIFO)ArraySort(CloseTrades,WHOLE_ARRAY,0,MODE_DESCEND);
else if(CloseCount!=ArraySort(CloseTrades))Print("Error sorting CloseTrades Array");
for(y=0;y<CloseCount;y++)
{ if(!OrderSelect(CloseTrades[y,1],SELECT_BY_TICKET))continue;
while(IsTradeContextBusy())Sleep(100);
if(IsStopped())return(-1);
if(OrderType()>OP_SELL)Success=OrderDelete(OrderTicket(),Color);
else
{ if(OrderType()==OP_BUY)OPrice=ND(MarketInfo(OrderSymbol(),MODE_BID),MarketInfo(OrderSymbol(),MODE_DIGITS));
else OPrice=ND(MarketInfo(OrderSymbol(),MODE_ASK),MarketInfo(OrderSymbol(),MODE_DIGITS));
Success=OrderClose(OrderTicket(),OrderLots(),OPrice,slip,Color);
}
if(Success)Closed++;
else
{ Error=GetLastError();Print("Order ",OrderTicket()," failed to close. Error:",ErrorDescription(Error));
switch(Error)
{ case ERR_NO_ERROR:
case ERR_NO_RESULT:
Success=true;
break;
case ERR_OFF_QUOTES:
case ERR_INVALID_PRICE:
Sleep(5000);
case ERR_PRICE_CHANGED:
case ERR_REQUOTE:
RefreshRates();
case ERR_SERVER_BUSY:
case ERR_NO_CONNECTION:
case ERR_BROKER_BUSY:
case ERR_TRADE_CONTEXT_BUSY:
Print("Try: "+(Tries+1)+" of 5: Order ",OrderTicket()," failed to close. Error:",ErrorDescription(Error));
Tries++;
break;
case ERR_TRADE_TIMEOUT:
default:
Print("Try: "+(Tries+1)+" of 5: Order ",OrderTicket()," failed to close. Fatal Error:",ErrorDescription(Error));
Tries=5;
ca=0;
break;
}
}
}
if(Closed==CloseCount||Closed==0)ca=0;
}
else ca=0;
if(Closed>0)
{ if(Closed!=1)s="s";
Print("Closed "+Closed+" position"+s+" because ",Reason);
if(PlaySounds)PlaySound(AlertSound);
}
return(Closed);
}
//+-----------------------------------------------------------------+
//| Find Hedge Profit |
//+-----------------------------------------------------------------+
double FindClosedPL(int Type)
{ double ClosedProfit;
if(Type==B&&UseCloseOldest)CbC=0;
if(OTbF>0)
{ for(y=OrdersHistoryTotal()-1;y>=0;y--)
{ if(!OrderSelect(y,SELECT_BY_POS,MODE_HISTORY))continue;
if(OrderOpenTime()<OTbF)continue;
if(Type==B&&OrderMagicNumber()==Magic&&OrderType()<=OP_SELL)
{ ClosedProfit+=OrderProfit()+OrderSwap()+OrderCommission();
if(UseCloseOldest)CbC++;
}
if(Type==H&&OrderMagicNumber()==hMagic)ClosedProfit+=OrderProfit()+OrderSwap()+OrderCommission();
}
}
return(ClosedProfit);
}
//+-----------------------------------------------------------------+
//| Check Correlation |
//+-----------------------------------------------------------------+
double CheckCorr()
{ double BaseDiff,HedgeDiff,BasePow,HedgePow,Mult;
for(y=CorrPeriod-1;y>=0;y--)
{ BaseDiff=iClose(Symbol(),1440,y)-iMA(Symbol(),1440,CorrPeriod,0,MODE_SMA,PRICE_CLOSE,y);
HedgeDiff=iClose(HedgeSymbol,1440,y)-iMA(HedgeSymbol,1440,CorrPeriod,0,MODE_SMA,PRICE_CLOSE,y);
Mult+=BaseDiff*HedgeDiff;
BasePow+=MathPow(BaseDiff,2);
HedgePow+=MathPow(HedgeDiff,2);
}
if(BasePow*HedgePow>0)return(Mult/MathSqrt(BasePow*HedgePow));
else return(0);
}
//+------------------------------------------------------------------+
//| Save Equity / Balance Statistics |
//+------------------------------------------------------------------+
void Stats(bool NewFile,bool IsTick,double Balance,double DrawDown)
{ double Equity=Balance+DrawDown;
datetime TimeNow=TimeCurrent();
if(IsTick)
{ if(Equity<StatLowEquity)StatLowEquity=Equity;
if(Equity>StatHighEquity)StatHighEquity=Equity;
}
else
{ while(TimeNow>=NextStats)NextStats+=StatsPeriod;
int StatHandle;
if(NewFile)
{ StatHandle=FileOpen(StatFile,FILE_WRITE|FILE_CSV,',');
Print("Stats "+StatFile+" "+StatHandle);
FileWrite(StatHandle,"Date","Time","Balance","Equity Low","Equity High",TradeComment);
}
else
{ StatHandle=FileOpen(StatFile,FILE_READ|FILE_WRITE|FILE_CSV,',');
FileSeek(StatHandle,0,SEEK_END);
}
if(StatLowEquity==0)
{ StatLowEquity=Equity;
StatHighEquity=Equity;
}
FileWrite(StatHandle,TimeToStr(TimeNow,TIME_DATE),TimeToStr(TimeNow,TIME_SECONDS),DTS(Balance,0),DTS(StatLowEquity,0),DTS(StatHighEquity,0));
FileClose(StatHandle);
StatLowEquity=Equity;
StatHighEquity=Equity;
}
}
//+-----------------------------------------------------------------+
//| Magic Number Generator |
//+-----------------------------------------------------------------+
int GenerateMagicNumber()
{ if(EANumber>99)return(EANumber);
return(JenkinsHash(EANumber+"_"+Symbol()+"__"+Period()));
}
int JenkinsHash(string Input)
{ int MagicNo;
for(y=0;y<StringLen(Input);y++)
{ MagicNo+=StringGetChar(Input,y);
MagicNo+=(MagicNo<<10);
MagicNo^=(MagicNo>>6);
}
MagicNo+=(MagicNo<<3);
MagicNo^=(MagicNo>>11);
MagicNo+=(MagicNo<<15);
MagicNo=MathAbs(MagicNo);
return(MagicNo);
}
//+-----------------------------------------------------------------+
//| Normalize Double |
//+-----------------------------------------------------------------+
double ND(double Value,int Precision){return(NormalizeDouble(Value,Precision));}
//+-----------------------------------------------------------------+
//| Double To String |
//+-----------------------------------------------------------------+
string DTS(double Value,int Precision){return(DoubleToStr(Value,Precision));}
//+-----------------------------------------------------------------+
//| Create Label Function (OBJ_LABEL ONLY) |
//+-----------------------------------------------------------------+
void CreateLabel(string Name,string Text,int FontSize,int Corner,int XOffset,double YLine,color Colour=CLR_NONE,string Font="")
{ int XDistance,YDistance;
if(Font=="")Font=displayFont;
FontSize+=displayFontSize;
YDistance=displayYcord+displaySpacing*YLine;
if(Corner==0)XDistance=displayXcord+(XOffset*displayFontSize/9*displayRatio);
else if(Corner==1)XDistance=displayCCIxCord+XOffset*displayRatio;
else if(Corner==2)XDistance=displayXcord+(XOffset*displayFontSize/9*displayRatio);
else if(Corner==3)
{ XDistance=XOffset*displayRatio;
YDistance=YLine;
}
else if(Corner==5)
{ XDistance=XOffset*displayRatio;
YDistance=14*YLine;
Corner=1;
}
if(Colour==CLR_NONE)Colour=displayColor;
ObjectCreate(Name,OBJ_LABEL,0,0,0);
ObjectSetText(Name,Text,FontSize,Font,Colour);
ObjectSet(Name,OBJPROP_CORNER,Corner);
ObjectSet(Name,OBJPROP_XDISTANCE,XDistance);
ObjectSet(Name,OBJPROP_YDISTANCE,YDistance);
}
//+-----------------------------------------------------------------+
//| Create Line Function (OBJ_HLINE ONLY) |
//+-----------------------------------------------------------------+
void CreateLine(string Name,color Colour,int Width,int Style)
{ ObjectCreate(Name,OBJ_HLINE,0,0,0);
ObjectSet(Name,OBJPROP_COLOR,Colour);
ObjectSet(Name,OBJPROP_WIDTH,Width);
ObjectSet(Name,OBJPROP_STYLE,Style);
}
//+------------------------------------------------------------------+
//| Draw Label Function (OBJ_LABEL ONLY) |
//+------------------------------------------------------------------+
void DrawLabel(string Name,double Value,int XOffset,int Decimal=2,color Colour=CLR_NONE)
{ int dDigits;
dDigits=Digit[ArrayBsearch(Digit,Value,WHOLE_ARRAY,0,MODE_ASCEND),1];
ObjectSet(Name,OBJPROP_XDISTANCE,displayXcord+(XOffset-7*dDigits)*displayFontSize/9*displayRatio);
ObjSetTxt(Name,DTS(Value,Decimal),0,Colour);
}
//+-----------------------------------------------------------------+
//| Object Set Function |
//+-----------------------------------------------------------------+
void ObjSet(string Name,int XCoord){ObjectSet(Name,OBJPROP_XDISTANCE,displayXcord+XCoord*displayFontSize/9*displayRatio);}
//+-----------------------------------------------------------------+
//| Object Set Text Function |
//+-----------------------------------------------------------------+
void ObjSetTxt(string Name,string Text,int FontSize=0,color Colour=CLR_NONE,string Font="")
{ FontSize+=displayFontSize;
if(Font=="")Font=displayFont;
if(Colour==CLR_NONE)Colour=displayColor;
ObjectSetText(Name,Text,FontSize,Font,Colour);
}
//+------------------------------------------------------------------+
//| Delete Overlay Label Function |
//+------------------------------------------------------------------+
void LabelDelete(){for(y=ObjectsTotal();y>=0;y--){if(StringSubstr(ObjectName(y),0,2)=="B3")ObjectDelete(ObjectName(y));}}
//+------------------------------------------------------------------+
//| Delete Object Function |
//+------------------------------------------------------------------+
void ObjDel(string Name){if(ObjectFind(Name)!=-1)ObjectDelete(Name);}
//+-----------------------------------------------------------------+
//| Create Object List Function |
//+-----------------------------------------------------------------+
void LabelCreate()
{ if(displayOverlay&&((Testing&&Visual)||!Testing))
{ int dDigits;
string ObjText;
color ObjClr;
CreateLabel("B3LMNum","Magic: ",8-displayFontSize,5,59,1,displayColorFGnd,"Tahoma");
CreateLabel("B3VMNum",DTS(Magic,0),8-displayFontSize,5,5,1,displayColorFGnd,"Tahoma");
CreateLabel("B3LComm","Trade Comment: "+TradeComment,8-displayFontSize,5,5,1.8,displayColorFGnd,"Tahoma");
if(displayLogo)
{ CreateLabel("B3LLogo","Q",27,3,10,10,Crimson,"Wingdings");
CreateLabel("B3LCopy","© "+DTS(Year(),0)+", Muhammad Nadeem ",10-displayFontSize,3,5,3,Silver,"Arial");
}
CreateLabel("B3LTime","Broker Time is:",0,0,0,0);
CreateLabel("B3VTime","",0,0,125,0);
CreateLabel("B3Line1","=========================",0,0,0,1);
CreateLabel("B3LEPPC","Equity Protection % Set:",0,0,0,2);
dDigits=Digit[ArrayBsearch(Digit,MaxDDPercent,WHOLE_ARRAY,0,MODE_ASCEND),1];
CreateLabel("B3VEPPC",DTS(MaxDDPercent,2),0,0,167-7*dDigits,2);
CreateLabel("B3PEPPC","%",0,0,193,2);
CreateLabel("B3LSTPC","Stop Trade % Set:",0,0,0,3);
dDigits=Digit[ArrayBsearch(Digit,StopTradePercent*100,WHOLE_ARRAY,0,MODE_ASCEND),1];
CreateLabel("B3VSTPC",DTS(StopTradePercent*100,2),0,0,167-7*dDigits,3);
CreateLabel("B3PSTPC","%",0,0,193,3);
CreateLabel("B3LSTAm","Stop Trade Amount:",0,0,0,4);
CreateLabel("B3VSTAm","",0,0,167,4,displayColorLoss);
CreateLabel("B3LAPPC","Account Portion:",0,0,0,5);
dDigits=Digit[ArrayBsearch(Digit,PortionPC*100,WHOLE_ARRAY,0,MODE_ASCEND),1];
CreateLabel("B3VAPPC",DTS(PortionPC*100,2),0,0,167-7*dDigits,5);
CreateLabel("B3PAPPC","%",0,0,193,5);
CreateLabel("B3LPBal","Portion Balance:",0,0,0,6);
CreateLabel("B3VPBal","",0,0,167,6);
CreateLabel("B3LAPCR","Account % Risked:",0,0,228,6);
CreateLabel("B3VAPCR",DTS(MaxDDPercent*PortionPC,2),0,0,347,6);
CreateLabel("B3PAPCR","%",0,0,380,6);
if(UseMM)
{ ObjText="Money Management is On";
ObjClr=displayColorProfit;
}
else
{ ObjText="Money Management is Off";
ObjClr=displayColorLoss;
}
CreateLabel("B3LMMOO",ObjText,0,0,0,7,ObjClr);
if(UsePowerOutSL)
{ ObjText="Power Off Stop Loss is On";
ObjClr=displayColorProfit;
}
else
{ ObjText="Power Off Stop Loss is Off";
ObjClr=displayColorLoss;
}
CreateLabel("B3LPOSL",ObjText,0,0,0,8,ObjClr);
CreateLabel("B3LDrDn","Draw Down %:",0,0,228,8);
CreateLabel("B3VDrDn","",0,0,315,8);
if(UseHedge)
{ if(HedgeTypeDD)
{ CreateLabel("B3LhDDn","Hedge",0,0,190,8);
CreateLabel("B3ShDDn","/",0,0,342,8);
CreateLabel("B3VhDDm","",0,0,347,8);
}
else
{ CreateLabel("B3LhLvl","Hedge Level:",0,0,228,9);
CreateLabel("B3VhLvl","",0,0,318,9);
CreateLabel("B3ShLvl","/",0,0,328,9);
CreateLabel("B3VhLvT","",0,0,333,9);
}
}
CreateLabel("B3Line2","======================",0,0,0,9);
CreateLabel("B3LSLot","Starting Lot Size:",0,0,0,10);
CreateLabel("B3VSLot","",0,0,130,10);
if(MaximizeProfit)
{ ObjText="Profit Maximizer is On";
ObjClr=displayColorProfit;
}
else
{ ObjText="Profit Maximizer is Off";
ObjClr=displayColorLoss;
}
CreateLabel("B3LPrMx",ObjText,0,0,0,11,ObjClr);
CreateLabel("B3LBask","Basket",0,0,200,11);
CreateLabel("B3LPPot","Profit Potential:",0,0,30,12);
CreateLabel("B3VPPot","",0,0,190,12);
CreateLabel("B3LPrSL","Profit Trailing Stop:",0,0,30,13);
CreateLabel("B3VPrSL","",0,0,190,13);
CreateLabel("B3LPnPL","Portion P/L / Pips:",0,0,30,14);
CreateLabel("B3VPnPL","",0,0,190,14);
CreateLabel("B3SPnPL","/",0,0,220,14);
CreateLabel("B3VPPip","",0,0,229,14);
CreateLabel("B3LPLMM","Profit/Loss Max/Min:",0,0,30,15);
CreateLabel("B3VPLMx","",0,0,190,15);
CreateLabel("B3SPLMM","/",0,0,220,15);
CreateLabel("B3VPLMn","",0,0,225,15);
CreateLabel("B3LOpen","Open Trades / Lots:",0,0,30,16);
CreateLabel("B3LType","",0,0,170,16);
CreateLabel("B3VOpen","",0,0,207,16);
CreateLabel("B3SOpen","/",0,0,220,16);
CreateLabel("B3VLots","",0,0,229,16);
CreateLabel("B3LMvTP","Move TP by:",0,0,0,17);
CreateLabel("B3VMvTP",DTS(MoveTP/Pip,0),0,0,100,17);
CreateLabel("B3LMves","# Moves:",0,0,150,17);
CreateLabel("B3VMove","",0,0,229,17);
CreateLabel("B3SMves","/",0,0,242,17);
CreateLabel("B3VMves",DTS(TotalMoves,0),0,0,249,17);
CreateLabel("B3LMxDD","Max DD:",0,0,0,18);
CreateLabel("B3VMxDD","",0,0,107,18);
CreateLabel("B3LDDPC","Max DD %:",0,0,150,18);
CreateLabel("B3VDDPC","",0,0,229,18);
CreateLabel("B3PDDPC","%",0,0,257,18);
if(ForceMarketCond<3)CreateLabel("B3LFMCn","Market trend is forced",0,0,0,19);
CreateLabel("B3LTrnd","",0,0,0,20);
if(CCIEntry>0&&displayCCI)
{ CreateLabel("B3LCCIi","CCI",2,1,12,1);
CreateLabel("B3LCm05","m5",2,1,25,2.2);
CreateLabel("B3VCm05","Ø",6,1,0,2,Orange,"Wingdings");
CreateLabel("B3LCm15","m15",2,1,25,3.4);
CreateLabel("B3VCm15","Ø",6,1,0,3.2,Orange,"Wingdings");
CreateLabel("B3LCm30","m30",2,1,25,4.6);
CreateLabel("B3VCm30","Ø",6,1,0,4.4,Orange,"Wingdings");
CreateLabel("B3LCm60","h1",2,1,25,5.8);
CreateLabel("B3VCm60","Ø",6,1,0,5.6,Orange,"Wingdings");
}
if(UseHolidayShutdown)
{ CreateLabel("B3LHols","Next Holiday Period",0,0,240,2);
CreateLabel("B3LHolD","From: (yyyy.mm.dd) To:",0,0,232,3);
CreateLabel("B3VHolF","",0,0,232,4);
CreateLabel("B3VHolT","",0,0,300,4);
}
}
}
//+-----------------------------------------------------------------+
//| expert end function |
//+-----------------------------------------------------------------+
Apprentice Please alter this code
Moderator: admin
Apprentice Please alter this code
by ADEEB786 » Sun May 09, 2021 2:29 am
- ADEEB786
- Posts: 19
- Joined: Sat Mar 24, 2018 10:14 am
Re: Apprentice Please alter this code
by Apprentice » Sun May 09, 2021 10:50 am
Your request is added to the development list.
Development reference 457.
Development reference 457.
-
Apprentice - FXCodeBase: Confirmed User
- Posts: 36435
- Joined: Thu Dec 31, 2009 11:59 am
- Location: Zagreb, Croatia
2 posts
• Page 1 of 1
Return to Indicator and Signal Requests
Who is online
Users browsing this forum: Bing [Bot] and 5 guests