有您的持续关注
我们会做得更好

智能交易系统 blessing_3_v3.7-5 EA



blessing_3_v3.7-5 EA程序复杂,能够完整的读完读懂所有函数,也够费时,整理也是大概看了下。

本网收集整理智能交易EA仅为MQL4编程爱好者提供语法及相关编程技巧的学习研究之用,智能交易存在极高的风险测试请用模拟盘,请勿用于实盘。blessing_3_v3.7-5 EA源码:

//+---------------------------------------------------------------------+
//|                                                     Blessing 3 v3.7 |
//|                                                        May 13, 2010 |
//|                                  Copyright @2007-2010, MQLCoder.com |
//|     In no event will authors be liable for any damages whatsoever.  |
//|                         Use at your own risk.                       |
//+---------------------------------------------------------------------+

#property copyright "Copyright @2007-2010, J Talon LLC/FiFtHeLeMeNt"
#property link      "http://www.jtatoday.com"
#include <stdlib.mqh>
#include <stderror.mqh>
#include <WinUser32.mqh>

extern string   Version_3_7_5       = "EA Settings:";
extern string   TradeComment        = "Blessing 3.7";

extern int      EANumber            = 1;        // Enter a unique number to identify this EA

extern string   LabelAcc            = "Account Trading Settings:";
extern bool     ShutDown            = false;    // Setting this to true will stop the EA trading after any open trades have been closed

extern double   StopTradePercent    = 10;       // percent of account balance lost before trading stops

extern bool     IBFXmicro           = false;    // set to true for IBFX micro "penny a pip"

extern double   PortionPC           = 100;      // Percentage of account you want to trade on this pair

extern double   MaxDDPercent        = 50;       // Percent of portion for max drawdown level.

extern bool     UseHolidayShutdown  = false;     // Will shutdown over holiday period
extern string   Holidays            = "18/12-01/01"; // List of holidays, each seperated by a comma, [day]/[mth]-[day]/[mth], dates inclusive

extern string   LabelIES            = "Indicator / Entry Settings:";
extern bool     B3Traditional       = true;     // Stop/Limits for entry if true, Buys/Sells if false
extern int      ForceMarketCond     = 3;        // Market condition 0=uptrend 1=downtrend 2=range 3=off

extern bool     UseAnyEntry         = false;    // true = ANY entry can be used to open orders, false = ALL entries used to open orders
extern int      MAEntry             = 1;        // 0 = Off, 1 = will base entry on MA channel, 2 = will trade in reverse
extern int      CCIEntry            = 0;        // 0 = Off, 1 = will base entry on CCI indicator, 2 = will trade in reverse
extern int      BollingerStochEntry = 0;        // 0 = Off, 1 = will base entry on BB, with Stoch confirmation, 2 = will trade in reverse

extern string   LabelLS             = "Lot Size Settings:";
extern bool     UseMM               = true;    // Money Management

extern double   LAF                 = 0.5;      // Adjusts MM base lot for large accounts

extern double   lot                 = 0.01;     // Starting lots if Money Management is off

extern double   Multiplier          = 1.4;      // Multiplier on each level

extern bool     LinearLotSize       = false;    // Use linear increment of lots, if this is true, ignores multiplier

extern string   LabelGS             = "Grid Settings:";
extern bool     AutoCal             = false;    // Auto calculation of TakeProfit and Grid size;

extern double   GAF                 = 1.0;      // Widens/Squishes Grid on increments/decrements of .1

extern int      EntryDelay          = 2400;     // Time Grid in seconds, to avoid opening of lots of levels in fast market

extern double   EntryOffset         = 5;        // In pips, used in conjunction with logic to offset first trade entry

extern bool     UseSmartGrid        = true;     // True = use RSI/MA calculation for next grid order

extern string   LabelTS             = "Trading Settings:";
extern int      MaxTrades           = 15;       // Maximum number of trades to place (stops placing orders when reaches MaxTrades)

extern int      BreakEvenTrade      = 12;       // Close All level, when reaches this level, doesn't wait for TP to be hit

extern bool     UseCloseOldest      = false;    // True = will close the oldest open trade after CloseTradesLevel is reached

extern int      CloseTradesLevel    = 5;        // will start closing oldest open trade at this level
extern int      MaxCloseTrades      = 4;        // Maximum number of oldest trades to close
extern double   CloseTPPips         = 10;       // After Oldest Trades have closed, Forces Take Profit to BE +/- xx Pips

extern double   ForceTPPips         = 0;        // Force Take Profit to BE +/- xx Pips
extern double   MinTPPips           = 0;        // Ensure Take Profit is at least BE +/- xx Pips
 
extern string   LabelHS             = "Hedge Settings:";
extern string   HedgeSymbol         = "";       // Enter the Symbol of the same/correlated pair EXACTLY as used by your broker.
extern int      CorrPeriod          = 30;       // Number of days for checking Hedge Correlation

extern bool     UseHedge            = false;    // Turns DD hedge on/off
extern string   DDorLevel           = "DD";     // DD = start hedge at set DD; Level = Start at set level
extern double   HedgeStart          = 20;       // DD Percent or Level at which Hedge starts
extern double   hLotMult            = 0.8;      // Hedge Lots = Open Lots * hLotMult
extern double   hMaxLossPips        = 30;       // DD Hedge maximum pip loss - also hedge trailing stop
extern double   hReEntryPC          = 5;        // Increase to HedgeStart to stop early re-entry of the hedge
extern bool     StopTrailAtBE       = true;     // True = Trailing Stop will stop at BE; False = Hedge will continue into profit
extern bool     ReduceTrailStop     = true;     // False = Trailing Stop is Fixed; True = Trailing Stop will reduce after BE is reached

extern string   LabelES             = "Exit Settings:";
extern bool     EmergencyCloseAll   = false;    // Setting this to true will close all open orders immediately

extern bool     MaximizeProfit      = false;    // Turns on TP move and Profit Trailing Stop Feature

extern double   ProfitSet           = 70;       // Locks in Profit at this percent of Total Profit Potential

extern double   MoveTP              = 30;       // Moves TP this amount in pips

extern int      TotalMoves          = 2;        // Number of times you want TP to move before stopping movement

extern bool     UsePowerOutSL       = false;    // Transmits a SL in case of internet loss
extern double   POSLPips            = 600;      // Power Out Stop Loss in pips

extern bool     UseEarlyExit        = false;    // Reduces ProfitTarget by a percentage over time and number of levels open
extern double   EEStartHours        = 3;        // Number of Hours to wait before EE over time starts
extern bool     EEFirstTrade        = true;     // true = StartHours from FIRST trade: false = StartHours from LAST trade
extern double   EEHoursPC           = 0.5;      // Percentage reduction per hour (0 = OFF)
extern int      EEStartLevel        = 5;        // Number of Open Trades before EE over levels starts
extern double   EELevelPC           = 10;       // Percentage reduction at each level (0 = OFF)
extern bool     EEAllowLoss         = false;    // true = Will allow the basket to close at a loss : false = Minimum profit is Break Even

extern string   LabelAdv            = "Advanced Settings Change sparingly";

extern string   LabelGrid           = "Grid Size Settings:";
extern string   SetCountArray       = "4,4";    // Specifies number of open trades in each block (separated by a comma) 
extern string   GridSetArray        = "25,50,100"; // Specifies number of pips away to issue limit order (separated by a comma)
extern string   TP_SetArray         = "50,100,200"; // Take profit for each block (separated by a comma)

extern string   LabelMA             = "MA Entry Settings:";
extern int      MAPeriod            = 100;      // Period of MA (H4 = 100, H1 = 400)
extern double   MADistance          = 10;       // Distance from MA to be treated as Ranging Market

extern string   LabelCCI            = "CCI Entry Settings:";
extern int      CCIPeriod           = 14;       // Period for CCI calculation

extern string   LabelBBS            = "BollingerStoch Entry Settings:";
extern int      BollPeriod          = 10;       // Period for Bollinger
extern double   BollDistance        = 10;       // Up/Down spread
extern double   BollDeviation       = 2.0;      // Standard deviation multiplier for channel
extern int      BuySellStochZone    = 20;       // Determines Overbought and Oversold Zones
extern int      KPeriod             = 10;       // Stochastic parameters
extern int      DPeriod             = 2;        // Stochastic parameters
extern int      Slowing             = 2;        // Stochastic parameters

extern string   LabelSG             = "Smart Grid Settings:";
extern int      RSI_TF              = 15;       // Timeframe for RSI calculation - should be less than chart TF.
extern int      RSI_Period          = 14;       // Period for RSI calculation
extern int      RSI_Price           = 0;        // 0=close, 1=open, 2=high, 3=low, 4=HL/2, 5=HLC/3 6=HLCC/4
extern int      RSI_MA_Period       = 10;       // Period for MA of RSI calculation
extern int      RSI_MA_Method       = 0;        // 0=Simple MA, 1=Exponential MA, 2=Smoothed MA, 3=Linear Weighted MA

extern string   LabelOS             = "Other Settings:";
extern bool     RecoupClosedLoss    = true;     // true = Recoup any Hedge/CloseOldest losses: false = Use original profit target.
extern bool     RecoverBrokerCosts  = true;     // true = will recover any negative broker costs, eg swap, commission

extern int      Level               = 7;        // Largest Assumed Basket size.  Lower number = higher start lots

extern int      slip                = 99;       // Adjusts opening and closing orders by "slipping" this amount

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            = 25;
extern double   EmailDD2            = 35;
extern double   EmailDD3            = 45;
extern string   LabelEH             = "Number of hours before DD timer resets";
extern double   EmailHours          = 1;        // Minimum number of hours between emails

extern string   LabelDisplay        = "Used to Adjust Overlay";
extern bool     displayOverlay      = true;     // Turns the display on and off
extern bool     displayLogo         = true;     // Turns off copyright and icon
extern bool     displayCCI          = true;     // Turns off the CCI display
extern bool     displayLines        = true;     // Show BE, TP and TS lines
extern int      displayXcord        = 100;      // Moves display left and right
extern int      displayYcord        = 22;       // Moves display up and down
extern int      displayCCIxCord     = 10;       // Moves CCI display left and right 
extern int      displayFontSize     = 9;        // Changes size of display characters
extern int      displaySpacing      = 14;       // Changes space between lines
extern color    displayColor        = DeepSkyBlue; // default color of display characters

extern bool     debug_msgs          = false;

//+-----------------------------------------------------------------+
//| Internal Parameters Set                                         |
//+-----------------------------------------------------------------+

int         ca                  = 0;
int         Magic,hMagic;
int         to,tpo,hto;
int         BrokerDecimal;
int         POSLCount;
double      counter;
int         moves;
double      MaxDD;
double      ProfitSL;
int         AccountType;
double      StopTradeBalance;
double      InitialAB;
bool        Testing,Visual;
double      BaseTarget;
bool        AllowTrading;
bool        EmergencyWarning;
double      MaxDDPer;
int         Error,y;
int         Set1Level,Set2Level,Set3Level,Set4Level;
int         EmailCount;
string      TF;
datetime    EmailSent;
int         GridArray[,2];
int         GridSet;
double      MinLotSize,MinLotStep,LotDecimal;
bool        PendLot;
string      CS,UAE;
int         HolShutDown;
datetime    HolArray[,2,2];
datetime    HolFirst,HolLast;
double      RSI[];
int         Digit[,2];
double      Email[3];
double      EETime,ClosedPL,hDDStart,prMax,prMin,hprMax,hprMin,LastClosedPL,ClosedPips,hSL,hLvlStart;
int         EECount,fopt,OldestTicket,cco,TPo,FileHandle,hLevel;
bool        hActive,TradesOpen,FileClosed,CalcTP,HedgeTypeDD,hThisChart,hPosCorr;
string      FileName;
double      TakeProfit,StopLevel;

//+-----------------------------------------------------------------+
//| 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="";

        Magic=GenerateMagicNumber();
        hMagic=JenkinsHash(Magic);
        if(debug_msgs){
                Print("Magic Number: "+DoubleToStr(Magic,0));
                Print("Hedge Number: "+DoubleToStr(hMagic,0));
        }

        if(Digits==3||Digits==5)BrokerDecimal=10;
        else BrokerDecimal=1;
        if(IBFXmicro)AccountType=10;
        else AccountType=1;

        MoveTP=NormalizeDouble(MoveTP*BrokerDecimal*Point,Digits);
        EntryOffset=NormalizeDouble(EntryOffset*BrokerDecimal*Point,Digits);
        MADistance=NormalizeDouble(MADistance*BrokerDecimal*Point,Digits);
        BollDistance=NormalizeDouble(BollDistance*BrokerDecimal*Point,Digits);
        POSLPips=NormalizeDouble(POSLPips*BrokerDecimal*Point,Digits);
        hMaxLossPips=NormalizeDouble(hMaxLossPips*BrokerDecimal*Point,Digits);
        CloseTPPips=NormalizeDouble(CloseTPPips*BrokerDecimal*Point,Digits);
        ForceTPPips=NormalizeDouble(ForceTPPips*BrokerDecimal*Point,Digits);
        MinTPPips=NormalizeDouble(MinTPPips*BrokerDecimal*Point,Digits);
        slip*=BrokerDecimal;

        if(UseHedge){
                if(HedgeSymbol=="")HedgeSymbol=Symbol();
                if(HedgeSymbol==Symbol())hThisChart=true;
                else hThisChart=false;
                if(CheckCorr()>0.9)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(StopTradePercent>=1)StopTradePercent=MathMin(StopTradePercent/100,1);
        if(ProfitSet>=1)ProfitSet=MathMin(ProfitSet/100,1);
        EEHoursPC/=100;
        EELevelPC/=100;
        if(HedgeTypeDD)HedgeStart/=100;
        if(hReEntryPC>=1)hReEntryPC=MathMin(hReEntryPC/100,1);
        if(PortionPC>1)PortionPC=MathMin(PortionPC/100,1);

        InitialAB=AccountBalance();
        StopTradeBalance=InitialAB*(1-StopTradePercent);
        Testing=IsTesting();
        Visual=IsVisualMode();
        HideTestIndicators(true);
        MinLotSize=MathMax(lot,MarketInfo(Symbol(),MODE_MINLOT));
        MinLotStep=MarketInfo(Symbol(),MODE_LOTSTEP);
        AllowTrading=true;
        EmergencyWarning=EmergencyCloseAll;

        if(IsOptimization())debug_msgs=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(BollingerStochEntry<0||BollingerStochEntry>2)BollingerStochEntry=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_msgs)Print("Digit: "+y+" ["+Digit[y,0]+","+Digit[y,1]+"]");
        }

        LabelCreate();

        LotDecimal=Digit[ArrayBsearch(Digit,1/MinLotStep,WHOLE_ARRAY,0,MODE_ASCEND),1];
        if(debug_msgs)Print("Lot Decimal: "+DoubleToStr(LotDecimal,0));

        //+-----------------------------------------------------------------+
        //| Set Grid and TP array                                           |
        //+-----------------------------------------------------------------+

        if(!AutoCal){
                int GridTemp,GridTP,GridIndex,GridLevel,GridError;
                ArrayResize(GridArray,MaxTrades);
                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_msgs)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,DoubleToStr(GridSet,0))+2);
                        if(GridIndex==0&&GridSet<1){
                                GridError=1;
                                break;
                        }
                        if(GridIndex==0)Set1Level=GridSet;
                        else if(GridIndex==1&&GridSet>0)Set2Level=Set1Level+GridSet;
                        else if(GridIndex==1)Set2Level=0;
                        else if(GridIndex==2&&GridSet>0)Set3Level=Set2Level+GridSet;
                        else if(GridIndex==2)Set3Level=0;
                        else if(GridIndex==3&&GridSet>0)Set4Level=Set3Level+GridSet;
                        else if(GridIndex==3)Set4Level=0;
                        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);
                                if(debug_msgs)Print("Holidays - From: ",StringSubstr(HolTempStr,0,StringFind(HolTempStr,"-",0))," To: ",
                                        StringSubstr(HolTempStr,StringFind(HolTempStr,"-",0)+1));
                                HolArray[HolCounter,0,0]=StrToInteger(StringSubstr(StringSubstr(HolTempStr,0,StringFind(HolTempStr,"-",0)),
                                        StringFind(StringSubstr(HolTempStr,0,StringFind(HolTempStr,"-",0)),"/")+1));
                                HolArray[HolCounter,0,1]=StrToInteger(StringSubstr(StringSubstr(HolTempStr,0,StringFind(HolTempStr,"-",0)),0,
                                        StringFind(StringSubstr(HolTempStr,0,StringFind(HolTempStr,"-",0)),"/")));
                                HolArray[HolCounter,1,0]=StrToInteger(StringSubstr(StringSubstr(HolTempStr,StringFind(HolTempStr,"-",0)+1),
                                    StringFind(StringSubstr(HolTempStr,StringFind(HolTempStr,"-",0)+1),"/")+1));
                                HolArray[HolCounter,1,1]=StrToInteger(StringSubstr(StringSubstr(HolTempStr,StringFind(HolTempStr,"-",0)+1),0,
                                        StringFind(StringSubstr(HolTempStr,StringFind(HolTempStr,"-",0)+1),"/")));
                                HolCounter+=1;
                        }
                }
        }

        //+-----------------------------------------------------------------+
        //| Set email parameters                                            |
        //+-----------------------------------------------------------------+

        if(UseEmail){
                if(Period()==43200)TF="MN1";
                else if(Period()==10800)TF="W1";
                else if(Period()==1440)TF="D1";
                else if(Period()==240)TF="H4";
                else if(Period()==60)TF="H1";
                else if(Period()==30)TF="M30";
                else if(Period()==15)TF="M15";
                else if(Period()==5)TF="M5";
                else if(Period()==1)TF="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_msgs)Print("Email ["+(z+1)+"] : "+Email[z]);
                }
        }

        //+-----------------------------------------------------------------+
        //| Set SmartGrid parameters                                        |
        //+-----------------------------------------------------------------+

        if(UseSmartGrid){
                ArrayResize(RSI,RSI_Period);
                ArraySetAsSeries(RSI,true);
        }

        //+-----------------------------------------------------------------+
        //| Find Closed Trades Profit/Loss & set hActive and cco            |
        //+-----------------------------------------------------------------+

        FileName="B3_"+Magic+".dat";
        if(debug_msgs)Print("FileName: "+FileName);
        FileHandle=FileOpen(FileName,FILE_BIN|FILE_READ);
        if(FileHandle!=-1){
                fopt=FileReadInteger(FileHandle,LONG_VALUE);
                FileClose(FileHandle);
                ClosedPL=FindClosedPL();
                TradesOpen=true;
                if(debug_msgs)Print(FileName+" File Read: "+fopt);
        }
        return(0);
}

//+-----------------------------------------------------------------+
//| expert deinitialization function                                |
//+-----------------------------------------------------------------+

int deinit(){
        
        LabelDelete();

        switch(UninitializeReason()){
                case REASON_REMOVE:
                case REASON_CHARTCLOSE:
                        if(IsDemo()&&tpo>0)while(tpo>0)tpo-=ExitTrades(5,Red,"Blessing Removed");
                case REASON_RECOMPILE:
                case REASON_PARAMETERS:
                case REASON_CHARTCHANGE:
                case REASON_ACCOUNT:
                        break;
        Comment("www.125808047.com");
        }
        return(0);
}

//+-----------------------------------------------------------------+
//| expert start function                                           |
//+-----------------------------------------------------------------+

int start(){
        int     cb          =0;     // Count buy
        int     cs          =0;     // Count sell
        int     cbl         =0;     // Count buy limit
        int     csl         =0;     // Count sell limit
        int     cbs         =0;     // Count buy stop
        int     css         =0;     // Count sell stop
        double  tbl         =0;     // Count buy lots
        double  tsl         =0;     // Count sell lots
        double  tl          =0;     // total lots out
        double  blo         =0;     // Buy limit open price
        double  slo         =0;     // Sell limit open price
        double  buysl       =0;     // stop losses are set to zero if POSL off
        double  sellsl      =0;     // stop losses are set to zero if POSL off
        double  bc          =0;     // Broker costs (swap + commission)
        double  ProfitPot   =0;     // The Potential Profit of a basket of Trades
        double  PipValue;
        double  lot2;
        double  lp;                 // last open price
        double  ll;                 // last lot
        int     lopt;               // last open time
        double  g2,tp2,Entry,RSI_MA,hbl,hsl,htl,hPr,OldestPrice,OldestOpenTime;
        int     Ticket,hcb,hcs;
        double  pr,prPips,ProfitTarget,ProfitTotal,DrawDownPC,BEPoint,hBEPoint;
        bool    BuyMe,SellMe,IndEntry,Success,SetPOSL;
        string  IndicatorUsed;

        //+-----------------------------------------------------------------+
        //| Calculate Total Profits, Profit Potential and Total Orders      |
        //+-----------------------------------------------------------------+

        PipValue=MarketInfo(Symbol(),MODE_TICKVALUE)/Point;
        StopLevel=MarketInfo(Symbol(),MODE_STOPLEVEL)*Point;
        for(y=0;y<OrdersTotal();y++){
                if(!OrderSelect(y,SELECT_BY_POS,MODE_TRADES))continue;
                int Type=OrderType();
                if(OrderMagicNumber()==hMagic){
                        hPr+=OrderProfit()+OrderSwap()+OrderCommission();
                        hBEPoint+=OrderLots()*OrderOpenPrice();
                        if(Type==OP_BUY){
                                hcb++;
                                hbl+=OrderLots();
                        }else if(Type==OP_SELL){
                                hcs++;
                                hsl+=OrderLots();
                        }
                        continue;
                }
                if(OrderMagicNumber()!=Magic||OrderSymbol()!=Symbol())continue;
                if(OrderTakeProfit()>0)ModifyOrder(OrderOpenPrice(),OrderStopLoss());
                if(Type<=OP_SELL){
                        pr+=OrderProfit();
                        bc+=OrderSwap()+OrderCommission();
                        BEPoint+=OrderLots()*OrderOpenPrice();
                        if(OrderOpenTime()>=lopt){
                                lopt=OrderOpenTime();
                                ll=OrderLots();
                                lp=OrderOpenPrice();
                        }
                        if(OrderOpenTime()<fopt||fopt==0)fopt=OrderOpenTime();
                        if(OrderOpenTime()<OldestOpenTime||OldestOpenTime==0){
                                OldestOpenTime=OrderOpenTime();      
                                OldestTicket=OrderTicket();
                                OldestPrice=OrderOpenPrice();
                        }
                        if(UsePowerOutSL&&OrderStopLoss()==0)SetPOSL=true;
                        if(Type==OP_BUY){
                                cb++;
                                tbl+=OrderLots();
                                continue;
                        }else{
                                cs++;
                                tsl+=OrderLots();
                                continue;
                        }
                }else{
                        if(Type==OP_BUYLIMIT){
                                cbl++;
                                blo=OrderOpenPrice();
                                continue;
                        }else if(Type==OP_SELLLIMIT){
                                csl++;
                                slo=OrderOpenPrice();
                                continue;
                        }else if(Type==OP_BUYSTOP)cbs++;
                        else css++;
                }
        }
        to=cb+cs;
        tpo=cbl+csl+cbs+css;
        tl=tbl+tsl;
        if(tl>0){
                BEPoint=NormalizeDouble(BEPoint/tl,Digits);
                pr=NormalizeDouble(pr+bc,2);
                if(pr>prMax||prMax==0)prMax=pr;
                if(pr<prMin||prMin==0)prMin=pr;
                if(cb>0&&TakeProfit>0){
                        ProfitPot=NormalizeDouble((TakeProfit-BEPoint)*PipValue*tl+bc,2);
                        prPips=NormalizeDouble((Bid-BEPoint)/Point/BrokerDecimal,1);
                }
                if(cs>0&&TakeProfit>0){
                        ProfitPot=NormalizeDouble((BEPoint-TakeProfit)*PipValue*tl+bc,2);
                        prPips=NormalizeDouble((BEPoint-Ask)/Point/BrokerDecimal,1);
                }
                if(!TradesOpen){
                        FileHandle=FileOpen(FileName,FILE_BIN|FILE_WRITE);
                        if(FileHandle>-1){
                                FileWriteInteger(FileHandle,fopt);
                                FileClose(FileHandle);
                                TradesOpen=true;
                                if(debug_msgs)Print(FileName+" File Written: "+fopt);
                        }
                }
        }else if(TradesOpen){
                BaseTarget=0;
                TakeProfit=0;
                prMax=0;
                prMin=0;
                fopt=0;
                ClosedPL=0;
                ClosedPips=0;
                cco=0;
                TPo=0;
                if(!HedgeTypeDD)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_msgs)Print(FileName+" File Deleted");
                                TradesOpen=false;
                        }
                        else Print("Error deleting file: "+FileName+" "+Error+" "+ErrorDescription(Error));
                }else TradesOpen=false;
        }
        hto=hcb+hcs;
        htl=hbl+hsl;
        if(htl>0){
                hBEPoint=NormalizeDouble(hBEPoint/htl,Digits);
                if(hLevel==0)hLevel=to+cco;
                if(hPr>hprMax||hprMax==0)hprMax=hPr;
                if(hPr<hprMin||hprMin==0)hprMin=hPr;
        }else{
                hprMax=0;
                hprMin=0;
                hSL=0;
                hLevel=0;
                if(HedgeTypeDD)hDDStart=HedgeStart;
        }

        //+-----------------------------------------------------------------+
        //| Check for and Delete hanging pending orders                     |
        //+-----------------------------------------------------------------+

        if(to==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(OrderLots()>lot){
                                PendLot=false;
                                Success=OrderDelete(OrderTicket());
                                if(Success){
                                        PendLot=true;
                                        if(debug_msgs)Print("Delete pending > lot");
                                }
                                return(0);
                        }
                }
        }else if(to>0&&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(OrderLots()==lot){
                                PendLot=true;
                                Success=OrderDelete(OrderTicket());
                                if(Success){
                                        PendLot=false;
                                        if(debug_msgs)Print("Delete pending = lot");
                                }
                                return(0);
                        }
                }
        }

        //+-----------------------------------------------------------------+
        //| Close oldest open trade after CloseTradesLevel reached          |
        //+-----------------------------------------------------------------+

        if(UseCloseOldest&&to>=CloseTradesLevel&&cco<MaxCloseTrades){
                if((TakeProfit>0&&!CalcTP)&&((cb>0&&OldestPrice>TakeProfit)||(cs>0&&OldestPrice<TakeProfit))){
                        y=ExitTrades(4,DarkViolet,"Close Oldest Trade");
                        if(y==1){
                                ClosedPL=FindClosedPL();
                                ca=0;
                                return(0);
                        }
                }
        }

        //+-----------------------------------------------------------------+
        //| Hedge/Basket/ClosedTrades Profit Management                     |
        //+-----------------------------------------------------------------+

        if(hActive&&hto==0){
                ClosedPL=FindClosedPL();
                hActive=false;
                CalcTP=true;
        }
        if(to>0){
                if(ClosedPL<0&&!RecoupClosedLoss){
                        ClosedPL=0;
                        CalcTP=true;
                }
                ProfitTotal=pr+ClosedPL;
                if(ClosedPL!=LastClosedPL){
                        CalcTP=true;
                        LastClosedPL=ClosedPL;
                        ClosedPips=NormalizeDouble(ClosedPL/PipValue/tl,Digits);
                }
                if(hPr>0||(hPr<0&&RecoupClosedLoss))ProfitTotal+=hPr;
        }
        if(to==0&&hto>0){
                ExitTrades(2,Red,"Basket Closed");
                return(0);
        }

        //+-----------------------------------------------------------------+
        //| Check ca, Breakeven Trades and Emergency Close All              |
        //+-----------------------------------------------------------------+

        switch(ca){
                case 0:  break;
                case 1:  if(to==0&&tpo==0)ca=0;
                            break;
                case 2:  if(hto==0)ca=0;
                            break;
                case 3:  if(to==0&&tpo==0&&hto==0)ca=0;
                            break;
                default: ca=0;
                            break;
        }

        if(ca>0){
                ExitTrades(ca,Red,"Close All");
                return(0);
        }

        if(((to+cco)>=BreakEvenTrade&&ProfitTotal>0)){
                ExitTrades(3,Lime,"Break Even Function Triggered");
                return(0);
        }

        if(EmergencyCloseAll){
                ExitTrades(3,Red,"Emergency Close All Trades");
                EmergencyCloseAll=false;
                return(0);
        }

        //+-----------------------------------------------------------------+
        //| Check if trading is allowed                                     |
        //+-----------------------------------------------------------------+

        if(to==0&&hto==0&&ShutDown){
                if(AllowTrading){
                        Print("Blessing has ShutDown. Set ShutDown = 'false' to continue trading");
                        AllowTrading=false;
                }
                if(tpo>0)ExitTrades(5,Red,"Blessing is shutting down");

                if(UseEmail&&EmailCount<4&&!Testing){
                        SendMail("Blessing EA","Blessing has shut down on "+Symbol()+" "+TF+
                                ". 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){
                LabelDelete();
                if(ObjectFind("B3LStop")==-1)CreateLabel("B3LStop","Trading has been stopped on this pair.",10,0,0,3,Red);
                if(ObjectFind("B3LExpt")==-1)CreateLabel("B3LExpt","Check the Experts tab for the reason why.",10,0,0,6,Red);
                if(ObjectFind("B3LResm")==-1)CreateLabel("B3LResm","Reset Blessing to resume trading.",10,0,0,9,Red);
                return(0);
        }else{
                if(ObjectFind("B3LStop")!=-1)ObjectDelete("B3LStop");
                if(ObjectFind("B3LExpt")!=-1)ObjectDelete("B3LExpt");
                if(ObjectFind("B3LResm")!=-1)ObjectDelete("B3LResm");
        }

        //+-----------------------------------------------------------------+
        //| Check Holiday Shutdown                                          |
        //+-----------------------------------------------------------------+

        if(UseHolidayShutdown){
                datetime HolStart,HolEnd;
                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();
                }else if((HolShutDown==0&&TimeCurrent()>=HolLast)||HolFirst==0){
                        for(y=0;y<ArraySize(HolArray);y++){
                                if(HolArray[y,0,0]>HolArray[y,1,0]){
                                        HolFirst=StrToTime(DoubleToStr(Year()-1,0)+"."+HolArray[y,0,0]+"."+HolArray[y,0,1]);
                                        HolLast=StrToTime(Year()+"."+HolArray[y,1,0]+"."+HolArray[y,1,1]+" 23:59:59");
                                        if(TimeCurrent()>=HolFirst&&TimeCurrent()<=HolLast){
                                                HolShutDown=1;
                                                HolStart=HolFirst;
                                                HolEnd=HolLast;
                                                break;
                                        }
                                }
                                HolFirst=StrToTime(Year()+"."+HolArray[y,0,0]+"."+HolArray[y,0,1]);
                                if(HolArray[y,0,0]>HolArray[y,1,0])HolLast=StrToTime(DoubleToStr(Year()+1,0)+"."+
                                        HolArray[y,1,0]+"."+HolArray[y,1,1]+" 23:59:59");
                                else HolLast=StrToTime(Year()+"."+HolArray[y,1,0]+"."+HolArray[y,1,1]+" 23:59:59");
                                if(TimeCurrent()>=HolFirst&&TimeCurrent()<=HolLast){
                                        HolShutDown=1;
                                        HolStart=HolFirst;
                                        HolEnd=HolLast;
                                        break;
                                }
                                if(HolStart==0||(HolStart>HolFirst&&TimeCurrent()<HolFirst)){
                                        HolStart=HolFirst;
                                        HolEnd=HolLast;
                                }
                        }
                        HolFirst=HolStart;
                        HolLast=HolEnd;
                }else if(HolShutDown==0&&TimeCurrent()>=HolFirst&&TimeCurrent()<HolLast)HolShutDown=1;
                else if(HolShutDown==1&&to==0){
                        Print("Blessing has shut down for the holidays. From: "+TimeToStr(HolFirst,TIME_DATE)+
                                " To: "+TimeToStr(HolLast,TIME_DATE));
                        if(tpo>0)ExitTrades(1,Red,"Holiday Shutdown");
                        HolShutDown=2;
                        if(ObjectFind("B3LClos")!=-1)ObjectDelete("B3LClos");
                }else if(HolShutDown==1){
                        if(ObjectFind("B3LClos")==-1)CreateLabel("B3LClos","",5,0,0,23,Red);
                        ObjectSetText("B3LClos","Blessing will shutdown for the holidays when this basket closes",displayFontSize+5);
                }
                if(HolShutDown==2){
                        LabelDelete();
                        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,Red);
                        if(ObjectFind("B3LResm")==-1)CreateLabel("B3LResm","Blessing will resume trading after "+TimeToStr(HolLast,TIME_DATE)+".",10,0,0,9,Red);
                        return(0);
                }
        }

        //+-----------------------------------------------------------------+
        //| ATR for Auto Grid Calculation and Grid Set Block                |
        //+-----------------------------------------------------------------+

        if(AutoCal){
                double atrvalue=iATR(NULL,PERIOD_D1,21,0);

                if(Digits<4)GridSet=atrvalue*100/5;
                else GridSet=atrvalue*10000/5;

                if((to+cco>=Set4Level)&&Set4Level>0){
                        g2=GridSet*12;    //GS*2*2*2*1.5
                        tp2=GridSet*18;   //GS*2*2*2*1.5*1.5
                }else if((to+cco>=Set3Level)&&Set3Level>0){
                        g2=GridSet*8;     //GS*2*2*2
                        tp2=GridSet*12;   //GS*2*2*2*1.5
                }else if((to+cco>=Set2Level)&&Set2Level>0){
                        g2=GridSet*4;     //GS*2*2
                        tp2=GridSet*8;    //GS*2*2*2
                }else if((to+cco>=Set1Level)&&Set1Level>0){
                        g2=GridSet*2;     //GS*2
                        tp2=GridSet*4;    //GS*2*2
                }else{
                        g2=GridSet;
                        tp2=GridSet*2;
                }
        }else{
                if((to+cco)<=MaxTrades){
                        y=MathMax((to+cco)-1,0);
                        g2=GridArray[y,0];
                        tp2=GridArray[y,1];
                }else{
                        g2=GridArray[MaxTrades-1,0];
                        tp2=GridArray[MaxTrades-1,1];
                }
        }
        g2=NormalizeDouble(g2*GAF*BrokerDecimal*Point,Digits);
        tp2=NormalizeDouble(tp2*GAF*BrokerDecimal*Point,Digits);

        //+-----------------------------------------------------------------+
        //| Calculate Take Profit                                           |
        //+-----------------------------------------------------------------+

        if((to>0&&TakeProfit==0)||to+hto!=TPo||CalcTP){
                string sCalcTP;
                double NewTP;
                TPo=to+hto;
                sCalcTP="Set and Sync new TP: ";
                if(cb>0){
                        if(ForceTPPips>0){
                                NewTP=BEPoint+ForceTPPips;
                                sCalcTP=sCalcTP+" + Force TP ";
                        }else if(cco>0&&CloseTPPips>0){
                                NewTP=BEPoint+CloseTPPips;
                                sCalcTP=sCalcTP+" + Close TP ";
                        }else NewTP=lp+tp2;
                        if(MinTPPips>0)NewTP=MathMax(NewTP,BEPoint+MinTPPips);
                        if(ClosedPips!=0){
                                NewTP-=ClosedPips;
                                sCalcTP=sCalcTP+" - ClosedPips ";
                        }
                        sCalcTP=(sCalcTP+"Buy: TakeProfit: ");
                }else if(cs>0){
                        if(ForceTPPips>0){
                                NewTP=BEPoint-ForceTPPips;
                                sCalcTP=sCalcTP+" - Force TP ";
                        }else if(cco>0&&CloseTPPips>0){
                                NewTP=BEPoint-CloseTPPips;
                                sCalcTP=sCalcTP+" - Close TP ";
                        }else NewTP=lp-tp2;
                        if(MinTPPips>0)NewTP=MathMin(NewTP,BEPoint-MinTPPips);
                        if(ClosedPips!=0){
                                NewTP+=ClosedPips;
                                sCalcTP=sCalcTP+" + ClosedPips ";
                        }
                        sCalcTP=(sCalcTP+"Sell: TakeProfit: ");
                }
                CalcTP=false;
                if(TakeProfit!=NewTP){
                        TakeProfit=NewTP;
                        if(debug_msgs)Print(sCalcTP+DoubleToStr(NewTP,Digits));
                        return(0);
                }
        }

        //+-----------------------------------------------------------------+
        //| Account Protection                                              |
        //+-----------------------------------------------------------------+

        double PortionBalance=NormalizeDouble(AccountBalance()*PortionPC,2);

        if(ProfitTotal<0)DrawDownPC=-ProfitTotal/PortionBalance;
        if(DrawDownPC>=MaxDDPercent/100){
                ExitTrades(3,Red,"Equity Stop Loss Reached");
                return(0);
        }
        if(-ProfitTotal>MaxDD)MaxDD=-ProfitTotal;
        MaxDDPer=MathMax(MaxDDPer,MaxDD/PortionBalance*100);

        //+-----------------------------------------------------------------+
        //| Check DD% and send Email                                        |
        //+-----------------------------------------------------------------+

        if(UseEmail&&!Testing){
                if(EmailCount==0&&Email[EmailCount]>0&&DrawDownPC>Email[EmailCount]){
                        SendMail("Blessing EA","Blessing has exceeded a drawdown of "+Email[EmailCount]*100+"% on "+Symbol()+" "+TF);
                        Error=GetLastError();
                        if(Error>0)Print("Email DD: "+DoubleToStr(DrawDownPC*100,2)+" Error: "+Error+" "+ErrorDescription(Error));
                        else{
                                if(debug_msgs)Print("DrawDown Email sent on "+Symbol()+" "+TF+ " DD: "+DoubleToStr(DrawDownPC*100,2));
                                EmailSent=TimeCurrent();
                                EmailCount=1;
                        }
                }
                if(EmailCount==1&&Email[EmailCount]>0&&DrawDownPC>Email[EmailCount]){
                        SendMail("Blessing EA","Blessing has exceeded a drawdown of "+Email[EmailCount]*100+"% on "+Symbol()+" "+TF);
                        Error=GetLastError();
                        if(Error>0)Print("Email DD: "+DoubleToStr(DrawDownPC*100,2)+" Error: "+Error+" "+ErrorDescription(Error));
                        else{
                                if(debug_msgs)Print("DrawDown Email sent on "+Symbol()+" "+TF+ " DD: "+DoubleToStr(DrawDownPC*100,2));
                                EmailSent=TimeCurrent();
                                EmailCount=2;
                        }
                }else if(EmailCount==1&&DrawDownPC<Email[EmailCount]&&TimeCurrent()>EmailSent+EmailHours*3600)EmailCount=0;
                if(EmailCount==2&&Email[EmailCount]>0&&DrawDownPC>Email[EmailCount]){
                        SendMail("Blessing EA","Blessing has exceeded a drawdown of "+Email[EmailCount]*100+"% on "+Symbol()+" "+TF);
                        Error=GetLastError();
                        if(Error>0)Print("Email DD: "+DoubleToStr(DrawDownPC*100,2)+" Error: "+Error+" "+ErrorDescription(Error));
                        else{
                                if(debug_msgs)Print("DrawDown Email sent on "+Symbol()+" "+TF+ " DD: "+DoubleToStr(DrawDownPC*100,2));
                                EmailSent=TimeCurrent();
                                EmailCount=3;
                        }
                }else if(EmailCount==2&&DrawDownPC<Email[EmailCount]&&TimeCurrent()>EmailSent+EmailHours*3600)EmailCount=1;
        }

        //+-----------------------------------------------------------------+
        //| Trading with EA Criteria                                        |
        //+-----------------------------------------------------------------+

        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){
                PlaySound("alert.wav");
                Print("Account Balance dropped below stop trade percent");
                MessageBox("Reset Blessing, account balance dropped below stop trade percent on "+Symbol()+Period(),"Blessing 3: Warning",48);
                AllowTrading=false;
                return(0);
        }

        //+-----------------------------------------------------------------+
        //| Hedge Trades Set-Up and Monitoring                              |
        //+-----------------------------------------------------------------+

        if(UseHedge&&to>0){
                double hAsk=MarketInfo(HedgeSymbol,MODE_ASK);
                double hBid=MarketInfo(HedgeSymbol,MODE_BID);
                if(HedgeTypeDD){
                        hDDStart=MathMax(hDDStart,HedgeStart);
                        if(hDDStart>HedgeStart&&hDDStart>DrawDownPC+hReEntryPC)hDDStart=DrawDownPC+hReEntryPC;    
                }else{
                        if(hLevel==0&&hto>0)hLevel=to+cco;
                        if(hLvlStart==0)hLvlStart=MathMax(HedgeStart,hLevel+1);
                }
                if(!hActive){
                        if((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,Red);
                        }
                        else if(ObjectFind("B3LhCor")!=-1)ObjectDelete("B3LhCor");
                        if((HedgeTypeDD&&DrawDownPC>hDDStart)||(!HedgeTypeDD&&to+cco>=hLvlStart)){
                                lot2=LotSize(tl*hLotMult);
                                if((cb>0&&!hPosCorr)||(cs>0&&hPosCorr)){
                                        Ticket=SendOrder(HedgeSymbol,OP_BUY,lot2,0,slip,hMagic,MidnightBlue);
                                        if(Ticket>0){
                                                hActive=true;
                                                hLevel=to+cco;
                                                hSL=hAsk-hMaxLossPips;
                                                if(HedgeTypeDD)hDDStart+=hReEntryPC;
                                                else hLvlStart++;
                                                if(debug_msgs)Print("Hedge Buy");
                                                return(0);
                                        }
                                }
                                if((cb>0&&hPosCorr)||(cs>0&&!hPosCorr)){
                                        Ticket=SendOrder(HedgeSymbol,OP_SELL,lot2,0,slip,hMagic,Maroon);
                                        if(Ticket>0){
                                                hActive=true;
                                                hLevel=to+cco;
                                                hSL=hBid+hMaxLossPips;
                                                if(HedgeTypeDD)hDDStart+=hReEntryPC;
                                                else hLvlStart++;
                                                if(debug_msgs)Print("Hedge Sell");
                                                return(0);
                                        }
                                }
                        }
                }
                else if(hActive){
                        if(HedgeTypeDD&&hDDStart>HedgeStart&&DrawDownPC>hDDStart-hReEntryPC)hDDStart=DrawDownPC+hReEntryPC;        
                        if(hLevel<to+cco){
                                lot2=LotSize(tl*hLotMult)-htl;
                                if((lot2>0&&(cb>0&&!hPosCorr))||((cs>0&&hPosCorr))){
                                        Ticket=SendOrder(HedgeSymbol,OP_BUY,lot2,0,slip,hMagic,MidnightBlue);
                                        if(Ticket>0){
                                                if(!HedgeTypeDD)hLvlStart=to+cco+1;
                                                hLevel=to+cco;
                                                if(debug_msgs)Print("Hedge Buy");
                                                return(0);
                                        }
                                }
                                if((lot2>0&&(cb>0&&hPosCorr))||((cs>0&&!hPosCorr))){
                                        Ticket=SendOrder(HedgeSymbol,OP_SELL,lot2,0,slip,hMagic,Maroon);
                                        if(Ticket>0){
                                                if(!HedgeTypeDD)hLvlStart=to+cco+1;
                                                hLevel=to+cco;
                                                if(debug_msgs)Print("Hedge Sell");
                                                return(0);
                                        }
                                }
                        }
                        if(hcb>0&&hMaxLossPips>0){
                                if(hSL==0||(hSL<hBEPoint&&hSL<hAsk-hMaxLossPips))hSL=MathMax(hSL,hAsk-hMaxLossPips);
                                else if(StopTrailAtBE&&hAsk-hMaxLossPips>=hBEPoint)hSL=hBEPoint;
                                else if(hSL>hBEPoint&&!StopTrailAtBE&&!ReduceTrailStop)hSL=MathMax(hSL,hAsk-hMaxLossPips);
                                else if(hSL>hBEPoint&&!StopTrailAtBE&&ReduceTrailStop)
                                        hSL=MathMax(hSL,hAsk-MathMax(StopLevel,hMaxLossPips*(1-(hAsk-hMaxLossPips-hBEPoint)/(hMaxLossPips*2))));
                                if(hBid<=hSL){
                                        y=ExitTrades(2,DarkViolet,"Hedge Stop Loss");
                                        if(y>0){
                                                ClosedPL=FindClosedPL();
                                                hActive=false;
                                                return(0);
                                        }
                                }
                        }
                        else if(hcs>0&&hMaxLossPips>0){
                                if(hSL==0||(hSL>hBEPoint&&hSL>hBid+hMaxLossPips))hSL=MathMin(hSL,hBid+hMaxLossPips);
                                else if(StopTrailAtBE&&hBid+hMaxLossPips<=hBEPoint)hSL=hBEPoint;
                                else if(hSL<hBEPoint&&!StopTrailAtBE&&!ReduceTrailStop)hSL=MathMin(hSL,hBid+hMaxLossPips);
                                else if(hSL<hBEPoint&&!StopTrailAtBE&&ReduceTrailStop)
                                        hSL=MathMin(hSL,hBid+MathMax(StopLevel,hMaxLossPips*(1-(hBEPoint-hBid-hMaxLossPips)/(hMaxLossPips*2))));
                                if(hAsk>=hSL){
                                        y=ExitTrades(2,DarkViolet,"Hedge Stop Loss");
                                        if(y>0){
                                                ClosedPL=FindClosedPL();
                                                hActive=false;
                                                return(0);
                                        }
                                }
                        }
                }
        }

        //+-----------------------------------------------------------------+
        //| Money Management and Lot size coding                            |
        //+-----------------------------------------------------------------+

        if(UseMM){
                double Contracts,Factor,Lotsize;
                Contracts=(AccountBalance()/10000)*PortionPC;
                if(Multiplier==1)Factor=Level;
                else Factor=(MathPow(Multiplier,Level+1)-Multiplier)/(Multiplier-1);
                Lotsize=LAF*AccountType*(Contracts/(1.0+Factor));

                if(Lotsize>100/MathPow(Multiplier,(Level-1))&&AccountType==1)Lotsize=100/MathPow(Multiplier,(Level-1));
                if(Lotsize>50/MathPow(Multiplier,(Level-1))&&AccountType==10)Lotsize=50/MathPow(Multiplier,(Level-1));
                lot=LotSize(Lotsize);
        }

        //+-----------------------------------------------------------------+
        //| Adjust TP if ProfitPot is negative/low/below grid profit        |
        //+-----------------------------------------------------------------+

        if((to>0&&ForceTPPips==0&&!UseCloseOldest)||((UseCloseOldest&&(CloseTPPips==0)||((CloseTPPips>0&&to+cco<CloseTradesLevel))))){
                if(BaseTarget<=0)BaseTarget=lot*PipValue*Point*BrokerDecimal*GridArray[0,1];

                ProfitTarget=NormalizeDouble(BaseTarget*(to+cco),2);
                if(RecoverBrokerCosts)ProfitTarget=ProfitTarget-bc*(bc<0);
                if(ProfitPot<ProfitTarget){
                        if(cb>0)NewTP=NormalizeDouble(BEPoint+ProfitTarget/PipValue/tl,Digits);
                        else if(cs>0)NewTP=NormalizeDouble(BEPoint-ProfitTarget/PipValue/tl,Digits);
                        if(TakeProfit!=NewTP){
                                TakeProfit=NewTP;
                                if(debug_msgs)Print("Adjust TakeProfit: "+DoubleToStr(TakeProfit,Digits));
                                return(0);
                        }
                }
        }
        ProfitTarget=ProfitPot+ClosedPL;

        //+-----------------------------------------------------------------+
        //| Adjust BEPoint/TakeProfit if Hedge is active                    |
        //+-----------------------------------------------------------------+

        double nLots=tbl-tsl+hbl-hsl;
        if(hThisChart&&hActive){
                double nBEPoint,nTakeProfit;
                if(tl-htl==0)nBEPoint=0;
                else nBEPoint=NormalizeDouble(((BEPoint*tl-hBEPoint*htl)/(tl-htl)),Digits);
                if(ClosedPL!=0)nBEPoint=NormalizeDouble(nBEPoint-(ClosedPL/PipValue/nLots),Digits);
                nTakeProfit=NormalizeDouble(nBEPoint+ProfitTarget/PipValue/nLots,Digits);
        }else if(hActive){
                nBEPoint=0;
                nTakeProfit=0;
        }else if(nLots!=0)BEPoint=NormalizeDouble(BEPoint-(ClosedPL/PipValue/nLots),Digits);

        //+-----------------------------------------------------------------+
        //| Calculate Early Exit Percentage                                 |
        //+-----------------------------------------------------------------+

        if(UseEarlyExit&&to>0){
                double EEpc,EEopt,EEStartTime,EEPoint,EEBEPoint,EETakeProfit;
                if(EEFirstTrade)EEopt=fopt;
                else EEopt=lopt;
                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&&(to+cco)>=EEStartLevel)EEpc+=EELevelPC*(to+cco-EEStartLevel+1);
                EEpc=1-EEpc;
                if(!EEAllowLoss&&EEpc<0)EEpc=0;
                ProfitTarget*=EEpc;
                if(displayOverlay&&displayLines&&(!hActive||(hActive&&hThisChart))&&(!Testing||(Testing&&Visual))&&(EEpc<1&&
                        (EEHoursPC>0&&EEopt+EEStartHours*3600<Time[0]&&EETime!=Time[0])||(EELevelPC>0&&(to+cco>EECount||EETime!=Time[0])))){
                        EETime=Time[0];
                        EECount=to+cco;
                        if(nBEPoint>0){
                                EEBEPoint=nBEPoint;
                                EETakeProfit=nTakeProfit;
                        }else{
                                EEBEPoint=NormalizeDouble(BEPoint-(ClosedPL/PipValue/nLots),Digits);
                                EETakeProfit=TakeProfit;
                        }
                        if(ObjectFind("B3LEELn")==-1){
                                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);
                        }
                        EEPoint=NormalizeDouble((EETakeProfit-EEBEPoint)*EEpc+EEBEPoint,Digits);
                        if(EEHoursPC>0)ObjectMove("B3LEELn",0,MathFloor(EEopt/3600+EEStartHours)*3600,EETakeProfit);
                        else ObjectMove("B3LEELn",0,MathFloor(EEopt/3600)*3600,EEPoint);
                        ObjectMove("B3LEELn",1,Time[0],EEPoint);
                        if(ObjectFind("B3VEELn")==-1){
                                ObjectCreate("B3VEELn",OBJ_TEXT,0,0,0);
                                ObjectSet("B3VEELn",OBJPROP_COLOR,Yellow);
                                ObjectSet("B3VEELn",OBJPROP_WIDTH,1);
                                ObjectSet("B3VEELn",OBJPROP_STYLE,0);
                        }
                        ObjectSetText("B3VEELn","              "+DoubleToStr(EEPoint,Digits),7,"Arial Bold",Yellow);
                        ObjectSet("B3VEELn",OBJPROP_PRICE1,EEPoint+2*BrokerDecimal*Point);
                        ObjectSet("B3VEELn",OBJPROP_TIME1,Time[0]);
                }else if((!displayLines||EEpc==1||(!EEAllowLoss&&EEpc==0)||(EEHoursPC>0&&EEopt+EEStartHours*3600>=Time[0]))){
                        if(ObjectFind("B3LEELn")!=-1)ObjectDelete("B3LEELn");
                        if(ObjectFind("B3VEELn")!=-1)ObjectDelete("B3VEELn");
                }
        }else{
                EETime=0;
                EECount=0;
                if(ObjectFind("B3LEELn")!=-1)ObjectDelete("B3LEELn");
                if(ObjectFind("B3VEELn")!=-1)ObjectDelete("B3VEELn");
        }

        //+-----------------------------------------------------------------+
        //| Maximize Profit with Moving TP and setting Trailing Profit Stop |
        //+-----------------------------------------------------------------+

        if(MaximizeProfit){
                if(to==0){
                        counter=0;
                        moves=0;
                        ProfitSL=0;
                }
                if(to>0){
                        if(ProfitSL>0&&ProfitTotal<=ProfitSL){
                                ExitTrades(3,Green,"Profit Trailing Stop Reached ("+DoubleToStr(ProfitSet*100,2)+"%)");
                                return(0);
                        }
                        if(ProfitTarget>0&&ProfitTotal>ProfitTarget*ProfitSet)ProfitSL=ProfitTarget*ProfitSet;

                        if(ProfitSL>0&&ProfitSL>counter&&MoveTP>0&&TotalMoves>moves){
                                if(cb>0)TakeProfit+=MoveTP;
                                else if(cs>0)TakeProfit-=MoveTP;
                                if(debug_msgs)Print("MoveTP TakeProfit: "+DoubleToStr(TakeProfit,Digits));
                                moves++;
                                counter=ProfitSL;
                                return(0);
                        }
                }
        }else if(ProfitTotal>ProfitTarget){
                ExitTrades(3,Green,"Profit Target Reached");
                return(0);
        }

        //+-----------------------------------------------------------------+
        //| Power Out Stop Loss Protection                                  |
        //+-----------------------------------------------------------------+

        if(UsePowerOutSL){
                if(to==0)POSLCount=0;
                if((to>0&&to+cco>POSLCount)||SetPOSL){
                        double POSL=MathMin(PortionBalance*(MaxDDPercent+1)/100/PipValue/tl,POSLPips);
                        buysl=NormalizeDouble(BEPoint-POSL,Digits);
                        sellsl=NormalizeDouble(BEPoint+POSL,Digits);

                        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()!=buysl){
                                        Success=ModifyOrder(OrderOpenPrice(),buysl,Purple);
                                        if(debug_msgs&&Success)Print("Sync POSL Buy");
                                }else if(OrderType()==OP_SELL&&OrderStopLoss()!=sellsl){
                                        Success=ModifyOrder(OrderOpenPrice(),sellsl,Purple);
                                        if(debug_msgs&&Success)Print("Sync POSL Sell");
                                }
                        }
                        POSLCount=to+cco;
                }
        }

        //+-----------------------------------------------------------------+
        //| Moving Average Indicator for Calculation of Trend Direction     |
        //+-----------------------------------------------------------------+

        int MC_final;
        double ima_0=iMA(Symbol(),0,MAPeriod,0,MODE_EMA,PRICE_CLOSE,0);

        if(ForceMarketCond==3){
                if(Bid>ima_0+MADistance)MC_final=0;
                else if(Ask<ima_0-MADistance)MC_final=1;
                else MC_final=2;
        }else MC_final=ForceMarketCond;

        //+-----------------------------------------------------------------+  << 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&&to==0&&tpo<2){
                if(Bid>ima_0+MADistance&&(!B3Traditional||(B3Traditional&&MC_final!=2))){
                        if(MAEntry==1){
                                if(ForceMarketCond!=1&&(UseAnyEntry||!IndEntry||(!UseAnyEntry&&IndEntry&&BuyMe)))BuyMe=true;
                                else BuyMe=false;
                                if(!UseAnyEntry&&IndEntry&&SellMe&&(!B3Traditional||(B3Traditional&&MC_final!=2)))SellMe=false;
                        }else if(MAEntry==2){
                                if(ForceMarketCond!=0&&(UseAnyEntry||!IndEntry||(!UseAnyEntry&&IndEntry&&SellMe)))SellMe=true;
                                else SellMe=false;
                                if(!UseAnyEntry&&IndEntry&&BuyMe&&(!B3Traditional||(B3Traditional&&MC_final!=2)))BuyMe=false;
                        }
                }else if(Ask<ima_0-MADistance&&(!B3Traditional||(B3Traditional&&MC_final!=2))){
                        if(MAEntry==1){
                                if(ForceMarketCond!=0&&(UseAnyEntry||!IndEntry||(!UseAnyEntry&&IndEntry&&SellMe)))SellMe=true;
                                else SellMe=false;
                                if(!UseAnyEntry&&IndEntry&&BuyMe&&(!B3Traditional||(B3Traditional&&MC_final!=2)))BuyMe=false;
                        }else if(MAEntry==2){
                                if(ForceMarketCond!=1&&(UseAnyEntry||!IndEntry||(!UseAnyEntry&&IndEntry&&BuyMe)))BuyMe=true;
                                else BuyMe=false;
                                if(!UseAnyEntry&&IndEntry&&SellMe&&(!B3Traditional||(B3Traditional&&MC_final!=2)))SellMe=false;
                        }
                }else if(B3Traditional&&MC_final==2){
                        if(ForceMarketCond!=1&&(UseAnyEntry||!IndEntry||(!UseAnyEntry&&IndEntry&&BuyMe)))BuyMe=true;
                        if(ForceMarketCond!=0&&(UseAnyEntry||!IndEntry||(!UseAnyEntry&&IndEntry&&SellMe)))SellMe=true;
                }else{
                        BuyMe=false;
                        SellMe=false;
                }
                if(IndEntry)IndicatorUsed=IndicatorUsed+UAE;
                IndEntry=true;
                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&&to==0&&tpo<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)MC_final=0;
                        if(CCIEntry==1){
                                if(ForceMarketCond!=1&&(UseAnyEntry||!IndEntry||(!UseAnyEntry&&IndEntry&&BuyMe)))BuyMe=true;
                                else BuyMe=false;
                                if(!UseAnyEntry&&IndEntry&&SellMe&&(!B3Traditional||(B3Traditional&&MC_final!=2)))SellMe=false;
                        }else if(CCIEntry==2){
                                if(ForceMarketCond!=0&&(UseAnyEntry||!IndEntry||(!UseAnyEntry&&IndEntry&&SellMe)))SellMe=true;
                                else SellMe=false;
                                if(!UseAnyEntry&&IndEntry&&BuyMe&&(!B3Traditional||(B3Traditional&&MC_final!=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)MC_final=1;
                        if(CCIEntry==1){
                                if(ForceMarketCond!=0&&(UseAnyEntry||!IndEntry||(!UseAnyEntry&&IndEntry&&SellMe)))SellMe=true;
                                else SellMe=false;
                                if(!UseAnyEntry&&IndEntry&&BuyMe&&(!B3Traditional||(B3Traditional&&MC_final!=2)))BuyMe=false;
                        }else if(CCIEntry==2){
                                if(ForceMarketCond!=1&&(UseAnyEntry||!IndEntry||(!UseAnyEntry&&IndEntry&&BuyMe)))BuyMe=true;
                                else BuyMe=false;
                                if(!UseAnyEntry&&IndEntry&&SellMe&&(!B3Traditional||(B3Traditional&&MC_final!=2)))SellMe=false;
                        }
                }else if(!UseAnyEntry&&IndEntry){
                        BuyMe=false;
                        SellMe=false;
                }
                if(IndEntry)IndicatorUsed=IndicatorUsed+UAE;
                IndEntry=true;
                IndicatorUsed=IndicatorUsed+" CCI ";
        }

        //+----------------------------------------------------------------+
        //| Bollinger Band Indicator for Order Entry                       |
        //+----------------------------------------------------------------+

        if(BollingerStochEntry>0&&to==0&&tpo<2){
                int zoneBUY=BuySellStochZone;
                int zoneSELL=100-BuySellStochZone;
                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;

                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(Ask<bdx&&stoc_0<zoneBUY&&stoc_1<zoneBUY){
                        if(BollingerStochEntry==1){
                                if(ForceMarketCond!=1&&(UseAnyEntry||!IndEntry||(!UseAnyEntry&&IndEntry&&BuyMe)))BuyMe=true;
                                else BuyMe=false;
                                if(!UseAnyEntry&&IndEntry&&SellMe&&(!B3Traditional||(B3Traditional&&MC_final!=2)))SellMe=false;
                        }else if(BollingerStochEntry==2){
                                if(ForceMarketCond!=0&&(UseAnyEntry||!IndEntry||(!UseAnyEntry&&IndEntry&&SellMe)))SellMe=true;
                                else SellMe=false;
                                if(!UseAnyEntry&&IndEntry&&BuyMe&&(!B3Traditional||(B3Traditional&&MC_final!=2)))BuyMe=false;
                        }
                }else if(Bid>bux&&stoc_0>zoneSELL&&stoc_1>zoneSELL){
                        if(BollingerStochEntry==1){
                                if(ForceMarketCond!=0&&(UseAnyEntry||!IndEntry||(!UseAnyEntry&&IndEntry&&SellMe)))SellMe=true;
                                else SellMe=false;
                                if(!UseAnyEntry&&IndEntry&&BuyMe&&(!B3Traditional||(B3Traditional&&MC_final!=2)))BuyMe=false;
                        }else if(BollingerStochEntry==2){
                                if(ForceMarketCond!=1&&(UseAnyEntry||!IndEntry||(!UseAnyEntry&&IndEntry&&BuyMe)))BuyMe=true;
                                else BuyMe=false;
                                if(!UseAnyEntry&&IndEntry&&SellMe&&(!B3Traditional||(B3Traditional&&MC_final!=2)))SellMe=false;
                        }
                }else if(!UseAnyEntry&&IndEntry){
                        BuyMe=false;
                        SellMe=false;
                }
                if(IndEntry)IndicatorUsed=IndicatorUsed+UAE;
                IndEntry=true;
                IndicatorUsed=IndicatorUsed+" BBStoch ";
        }

        //+-----------------------------------------------------------------+  << This must be the last Entry check before
        //| Force Market Condition Buy/Sell Entry                           |  << the Trade Selection Logic. Add checks for
        //+-----------------------------------------------------------------+  << additional indicators before this block.

        if(ForceMarketCond<2&&!IndEntry&&to==0){
                if(ForceMarketCond==0)BuyMe=true;
                if(ForceMarketCond==1)SellMe=true;
                IndicatorUsed=" FMC ";
        }

        //+-----------------------------------------------------------------+
        //| Trade Selection Logic                                           |
        //+-----------------------------------------------------------------+

        if(to==0&&tpo<2){
                if(B3Traditional){
                        if(BuyMe){
                                if((cbs==0&&csl==0&&(MC_final!=2||MAEntry==0))||(cbs==0&&csl==0&&MC_final==2&&MAEntry==1)){
                                        Entry=g2-MathMod(Ask,g2)+EntryOffset;
                                        if(Entry>StopLevel){
                                                Ticket=SendOrder(Symbol(),OP_BUYSTOP,lot,Entry,0,Magic,CLR_NONE);
                                                if(Ticket>0&&debug_msgs)Print("Indicator Entry - ("+IndicatorUsed+") BuyStop MC = "+MC_final);
                                        }
                                }
                                if((cbl==0&&css==0&&(MC_final!=2||MAEntry==0))||(cbl==0&&css==0&&MC_final==2&&MAEntry==2)){
                                        Entry=MathMod(Ask,g2)+EntryOffset;
                                        if(Entry>StopLevel){
                                                Ticket=SendOrder(Symbol(),OP_BUYLIMIT,lot,-Entry,0,Magic,CLR_NONE);
                                                if(Ticket>0&&debug_msgs)Print("Indicator Entry - ("+IndicatorUsed+") BuyLimit MC = "+MC_final);
                                        }
                                }
                        }
                        if(SellMe){
                                if((csl==0&&cbs==0&&(MC_final!=2||MAEntry==0))||(csl==0&&cbs==0&&MC_final==2&&MAEntry==2)){
                                        Entry=g2-MathMod(Bid,g2)-EntryOffset;
                                        if(Entry>StopLevel){
                                                Ticket=SendOrder(Symbol(),OP_SELLLIMIT,lot,Entry,0,Magic,CLR_NONE);
                                                if(Ticket>0&&debug_msgs)Print("Indicator Entry - ("+IndicatorUsed+") SellLimit MC = "+MC_final);
                                        }
                                }
                                if((css==0&&cbl==0&&(MC_final!=2||MAEntry==0))||(css==0&&cbl==0&&MC_final==2&&MAEntry==1)){
                                        Entry=MathMod(Bid,g2)+EntryOffset;
                                        if(Entry>StopLevel){
                                                Ticket=SendOrder(Symbol(),OP_SELLSTOP,lot,-Entry,0,Magic,CLR_NONE);
                                                if(Ticket>0&&debug_msgs)Print("Indicator Entry - ("+IndicatorUsed+") SellStop MC = "+MC_final);
                                        }
                                }
                        }
                        if(Ticket>0)return(0);
                }else{
                        if(BuyMe){
                                Ticket=SendOrder(Symbol(),OP_BUY,lot,0,slip,Magic,Blue);
                                if(Ticket>0){
                                        if(debug_msgs)Print("Indicator Entry - ("+IndicatorUsed+") Buy");
                                        return(0);
                                }
                        }
                        if(SellMe){
                                Ticket=SendOrder(Symbol(),OP_SELL,lot,0,slip,Magic,Red);
                                if(Ticket>0){
                                        if(debug_msgs)Print("Indicator Entry - ("+IndicatorUsed+") Sell");
                                        return(0);
                                }
                        }
                }
        }else if(cb>0){
                if((TimeCurrent()-EntryDelay>lopt)&&(cb+cco<MaxTrades)){
                        if(lp>Ask)Entry=lp-(MathRound((lp-Ask)/g2)+1)*g2;
                        else Entry=lp-g2;
                        if(LinearLotSize)lot2=LotSize(ll+MathMax(lot,MinLotStep));
                        else lot2=LotSize(MathMax(ll*Multiplier,ll+MinLotStep));
                        if(UseSmartGrid){
                                if(Ask<lp-g2){
                                        for(y=0;y<RSI_Period;y++)RSI[y]=iRSI(NULL,RSI_TF,RSI_Period,RSI_Price,y);
                                        RSI_MA=iMAOnArray(RSI,0,RSI_MA_Period,0,RSI_MA_Method,0);
                                        if(RSI[0]>RSI_MA){
                                                Ticket=SendOrder(Symbol(),OP_BUY,lot2,0,slip,Magic,Blue);
                                                if(Ticket>0){
                                                        CalcTP=true;
                                                        if(debug_msgs)Print("SmartGrid Buy");
                                                        return(0);
                                                }
                                        }
                                }
                        }else if(cbl==0){
                                if(Ask-Entry>StopLevel){
                                        Ticket=SendOrder(Symbol(),OP_BUYLIMIT,lot2,Entry-Ask,0,Magic,SkyBlue);
                                        if(Ticket>0){
                                                if(debug_msgs)Print("BuyLimit grid");
                                                return(0);
                                        }
                                }
                        }else if(cbl==1&&Entry-blo>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){
                                                if(debug_msgs)Print("Mod BuyLimit Entry");
                                                return(0);
                                        }
                                }
                        }
                }
        }else if(cs>0){
                if((TimeCurrent()-EntryDelay>lopt)&&(cs+cco<MaxTrades)){
                        if(Bid>lp)Entry=lp+(MathRound((-lp+Bid)/g2)+1)*g2;
                        else Entry=lp+g2;
                        if(LinearLotSize)lot2=LotSize(ll+MathMax(lot,MinLotStep));
                        else lot2=LotSize(MathMax(ll*Multiplier,ll+MinLotStep));
                        if(UseSmartGrid){
                                if(Bid>lp+g2){
                                        for(y=0;y<RSI_Period;y++)RSI[y]=iRSI(NULL,RSI_TF,RSI_Period,RSI_Price,y);
                                        RSI_MA=iMAOnArray(RSI,0,RSI_MA_Period,0,RSI_MA_Method,0);
                                        if(RSI[0]<RSI_MA){
                                                Ticket=SendOrder(Symbol(),OP_SELL,lot2,0,slip,Magic,Red);
                                                if(Ticket>0){
                                                        CalcTP=true;
                                                        if(debug_msgs)Print("SmartGrid Sell");
                                                        return(0);
                                                }
                                        }
                                }
                        }else if(csl==0){
                                if(Entry-Bid>StopLevel){
                                        Ticket=SendOrder(Symbol(),OP_SELLLIMIT,lot2,Entry-Bid,0,Magic,Coral);
                                        if(Ticket>0){
                                                if(debug_msgs)Print("SellLimit grid");
                                                return(0);
                                    }
                                }
                        }else if(csl==1&&slo-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){
                                                if(debug_msgs)Print("Mod SellLimit Entry");
                                                return(0);
                                        }
                                }
                        }
                }
        }

        //+-----------------------------------------------------------------+
        //| External Script Code                                            |
        //+-----------------------------------------------------------------+

        if((Testing&&Visual)||!Testing){
                if(displayOverlay){
                        int dDigits;
                        ObjectSetText("B3VTime",TimeToStr(TimeCurrent(),TIME_SECONDS),displayFontSize);
                        ObjectSetText("B3VSTAm",DoubleToStr(InitialAccountMultiPortion,2),displayFontSize);
                        dDigits=Digit[ArrayBsearch(Digit,InitialAccountMultiPortion,WHOLE_ARRAY,0,MODE_ASCEND),1];
                        ObjectSet("B3VSTAm",OBJPROP_XDISTANCE,displayXcord+167-7*dDigits);
                        if(UseHolidayShutdown){
                                ObjectSetText("B3VHolF",TimeToStr(HolFirst,TIME_DATE),displayFontSize);
                                ObjectSetText("B3VHolT",TimeToStr(HolLast,TIME_DATE),displayFontSize);
                        }
                        ObjectSetText("B3VPBal",DoubleToStr(PortionBalance,2),displayFontSize);
                        dDigits=Digit[ArrayBsearch(Digit,PortionBalance,WHOLE_ARRAY,0,MODE_ASCEND),1];
                        ObjectSet("B3VPBal",OBJPROP_XDISTANCE,displayXcord+167-7*dDigits);
                        ObjectSetText("B3VDrDn",DoubleToStr(DrawDownPC*100,2),displayFontSize);
                        dDigits=Digit[ArrayBsearch(Digit,DrawDownPC*100,WHOLE_ARRAY,0,MODE_ASCEND),1];
                        ObjectSet("B3VDrDn",OBJPROP_XDISTANCE,(displayXcord+315-dDigits*7));
                        if(UseHedge&&HedgeTypeDD)ObjectSetText("B3VhDDm",DoubleToStr(hDDStart*100,2),displayFontSize);
                        else if(UseHedge&&!HedgeTypeDD){
                                ObjectSetText("B3VhLvl",DoubleToStr(to+cco,0),displayFontSize);
                                dDigits=Digit[ArrayBsearch(Digit,to+cco,WHOLE_ARRAY,0,MODE_ASCEND),1];
                                ObjectSet("B3VhLvl",OBJPROP_XDISTANCE,(displayXcord+315-dDigits*7));
                                ObjectSetText("B3VhLvT",DoubleToStr(hLvlStart,0),displayFontSize);
                        }
                        ObjectSetText("B3VSLot",DoubleToStr(lot,2),displayFontSize);
                        ObjectSetText("B3VPPot",DoubleToStr(ProfitPot+ClosedPL,2),displayFontSize);
                        dDigits=Digit[ArrayBsearch(Digit,ProfitPot+ClosedPL,WHOLE_ARRAY,0,MODE_ASCEND),1];
                        ObjectSet("B3VPPot",OBJPROP_XDISTANCE,(displayXcord+190-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);
                                ObjectSetText("B3VEEPr",DoubleToStr(ProfitTarget,2),displayFontSize);
                        }else{
                                if(ObjectFind("B3SEEPr")!=-1)ObjectDelete("B3SEEPr");
                                if(ObjectFind("B3VEEPr")!=-1)ObjectDelete("B3VEEPr");
                        }
                        ObjectSetText("B3VPrSL",DoubleToStr(ProfitSL,2),displayFontSize);
                        if(pr>=0){
                                ObjectSetText("B3VPnPL",DoubleToStr(pr,2),displayFontSize,"Arial Bold",Green);
                                dDigits=Digit[ArrayBsearch(Digit,pr,WHOLE_ARRAY,0,MODE_ASCEND),1];
                                ObjectSet("B3VPnPL",OBJPROP_XDISTANCE,(displayXcord+190-dDigits*7));
                                ObjectSetText("B3VPPip",DoubleToStr(prPips,1),displayFontSize,"Arial Bold",Green);
                                ObjectSet("B3VPPip",OBJPROP_XDISTANCE,(displayXcord+229));
                        }else{
                                ObjectSetText("B3VPnPL",DoubleToStr(pr,2),displayFontSize,"Arial Bold",Red);
                                dDigits=Digit[ArrayBsearch(Digit,-pr,WHOLE_ARRAY,0,MODE_ASCEND),1];
                                ObjectSet("B3VPnPL",OBJPROP_XDISTANCE,(displayXcord+186-dDigits*7));
                                ObjectSetText("B3VPPip",DoubleToStr(prPips,1),displayFontSize,"Arial Bold",Red);
                                ObjectSet("B3VPPip",OBJPROP_XDISTANCE,(displayXcord+225));
                        }
                        if(prMax>=0){
                                ObjectSetText("B3VPLMx",DoubleToStr(prMax,2),displayFontSize,"Arial Bold",Green);
                                dDigits=Digit[ArrayBsearch(Digit,prMax,WHOLE_ARRAY,0,MODE_ASCEND),1];
                                ObjectSet("B3VPLMx",OBJPROP_XDISTANCE,(displayXcord+190-dDigits*7));
                        }else{
                                ObjectSetText("B3VPLMx",DoubleToStr(prMax,2),displayFontSize,"Arial Bold",Red);
                                dDigits=Digit[ArrayBsearch(Digit,-prMax,WHOLE_ARRAY,0,MODE_ASCEND),1];
                                ObjectSet("B3VPLMx",OBJPROP_XDISTANCE,(displayXcord+186-dDigits*7));
                        }
                        ObjectSetText("B3VPLMn",DoubleToStr(prMin,2),displayFontSize,"Arial Bold",Red);
                        if(cb>0){
                                ObjectSetText("B3LType","Buy:",displayFontSize);
                                ObjectSetText("B3VOpen",DoubleToStr(cb,0),displayFontSize);
                                dDigits=Digit[ArrayBsearch(Digit,cb,WHOLE_ARRAY,0,MODE_ASCEND),1];
                                ObjectSet("B3VOpen",OBJPROP_XDISTANCE,(displayXcord+207-dDigits*7));
                        }else if(cs>0){
                                ObjectSetText("B3LType","Sell:",displayFontSize);
                                ObjectSetText("B3VOpen",DoubleToStr(cs,0),displayFontSize);
                                dDigits=Digit[ArrayBsearch(Digit,cs,WHOLE_ARRAY,0,MODE_ASCEND),1];
                                ObjectSet("B3VOpen",OBJPROP_XDISTANCE,(displayXcord+207-dDigits*7));
                        }else{
                                ObjectSetText("B3LType","",displayFontSize);
                                ObjectSetText("B3VOpen",DoubleToStr(0,0),displayFontSize);
                                ObjectSet("B3VOpen",OBJPROP_XDISTANCE,(displayXcord+207));
                        }
                        if(to+cco<BreakEvenTrade)ObjectSet("B3VOpen",OBJPROP_COLOR,displayColor);
                        else if(to+cco<MaxTrades)ObjectSet("B3VOpen",OBJPROP_COLOR,Green);
                        else ObjectSet("B3VOpen",OBJPROP_COLOR,Red);
                        ObjectSetText("B3VLots",DoubleToStr(tl,2),displayFontSize);
                        ObjectSetText("B3VMove",DoubleToStr(moves,0),displayFontSize);
                        ObjectSetText("B3VMxDD",DoubleToStr(MaxDD,2),displayFontSize);
                        dDigits=Digit[ArrayBsearch(Digit,MaxDD,WHOLE_ARRAY,0,MODE_ASCEND),1];
                        ObjectSet("B3VMxDD",OBJPROP_XDISTANCE,(displayXcord+107-dDigits*7));
                        ObjectSetText("B3VDDPC",DoubleToStr(MaxDDPer,2),displayFontSize);
                        dDigits=Digit[ArrayBsearch(Digit,MaxDDPer,WHOLE_ARRAY,0,MODE_ASCEND),1];
                        ObjectSet("B3VDDPC",OBJPROP_XDISTANCE,(displayXcord+240-dDigits*7));
                        if(MC_final==0){
                                ObjectSetText("B3LTrnd","Trend is UP",displayFontSize+10,"Arial Bold",Green);
                                if(ObjectFind("B3ATrnd")==-1)CreateLabel("B3ATrnd","",0,0,160,20,Green,"Wingdings");
                                ObjectSetText("B3ATrnd","",displayFontSize+9,"Wingdings",Green);
                                ObjectSet("B3ATrnd",OBJPROP_XDISTANCE,displayXcord+160);
                                ObjectSet("B3ATrnd",OBJPROP_YDISTANCE,displayYcord+displaySpacing*20);
                        }else if(MC_final==1){
                                ObjectSetText("B3LTrnd","Trend is DOWN",displayFontSize+10,"Arial Bold",Red);
                                if(ObjectFind("B3ATrnd")==-1)CreateLabel("B3ATrnd","",0,0,210,20,Red,"WingDings");
                                ObjectSetText("B3ATrnd","",displayFontSize+9,"Wingdings",Red);
                                ObjectSet("B3ATrnd",OBJPROP_XDISTANCE,displayXcord+210);
                                ObjectSet("B3ATrnd",OBJPROP_YDISTANCE,displayYcord+displaySpacing*20+5);
                        }else if(MC_final==2){
                                ObjectSetText("B3LTrnd","Trend is Ranging",displayFontSize+10,"Arial Bold",Orange);
                                if(ObjectFind("B3ATrnd")!=-1)ObjectDelete("B3ATrnd");
                        }
                        if(ClosedPL!=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(ClosedPL>=0){
                                        ObjectSetText("B3VClPL",DoubleToStr(ClosedPL,2),displayFontSize,"Arial Bold",Green);
                                        dDigits=Digit[ArrayBsearch(Digit,ClosedPL,WHOLE_ARRAY,0,MODE_ASCEND),1];
                                        ObjectSet("B3VClPL",OBJPROP_XDISTANCE,displayXcord+327-dDigits*7);
                                }else{
                                        ObjectSetText("B3VClPL",DoubleToStr(ClosedPL,2),displayFontSize,"Arial Bold",Red);
                                        dDigits=Digit[ArrayBsearch(Digit,-ClosedPL,WHOLE_ARRAY,0,MODE_ASCEND),1];
                                        ObjectSet("B3VClPL",OBJPROP_XDISTANCE,displayXcord+323-dDigits*7);
                                }
                        }else{
                                if(ObjectFind("B3LClPL")!=-1)ObjectDelete("B3LClPL");
                                if(ObjectFind("B3VClPL")!=-1)ObjectDelete("B3VClPL");
                        }
                        if(hActive){
                                if(ObjectFind("B3LHdge")==-1)CreateLabel("B3LHdge","Hedge",0,0,323,13);
                                if(ObjectFind("B3VhPro")==-1)CreateLabel("B3VhPro","",0,0,312,14);
                                if(hPr>=0){
                                        ObjectSetText("B3VhPro",DoubleToStr(hPr,2),displayFontSize,"Arial Bold",Green);
                                        dDigits=Digit[ArrayBsearch(Digit,hPr,WHOLE_ARRAY,0,MODE_ASCEND),1];
                                        ObjectSet("B3VhPro",OBJPROP_XDISTANCE,displayXcord+312-dDigits*7);
                                }else{
                                        ObjectSetText("B3VhPro",DoubleToStr(hPr,2),displayFontSize,"Arial Bold",Red);
                                        dDigits=Digit[ArrayBsearch(Digit,-hPr,WHOLE_ARRAY,0,MODE_ASCEND),1];
                                        ObjectSet("B3VhPro",OBJPROP_XDISTANCE,displayXcord+308-dDigits*7);
                                }
                                if(ObjectFind("B3VhPMx")==-1)CreateLabel("B3VhPMx","",0,0,312,15);
                                if(hprMax>=0){
                                        ObjectSetText("B3VhPMx",DoubleToStr(hprMax,2),displayFontSize,"Arial Bold",Green);
                                        dDigits=Digit[ArrayBsearch(Digit,hprMax,WHOLE_ARRAY,0,MODE_ASCEND),1];
                                        ObjectSet("B3VhPMx",OBJPROP_XDISTANCE,displayXcord+312-dDigits*7);
                                }else{
                                        ObjectSetText("B3VhPMx",DoubleToStr(hprMax,2),displayFontSize,"Arial Bold",Red);
                                        dDigits=Digit[ArrayBsearch(Digit,-hprMax,WHOLE_ARRAY,0,MODE_ASCEND),1];
                                        ObjectSet("B3VhPMx",OBJPROP_XDISTANCE,displayXcord+308-dDigits*7);
                                }
                                if(ObjectFind("B3ShPro")==-1)CreateLabel("B3ShPro","/",0,0,342,15);
                                if(ObjectFind("B3VhPMn")==-1)CreateLabel("B3VhPMn","",0,0,351,15,Red);
                                if(hprMin<0)ObjectSet("B3VhPMn",OBJPROP_XDISTANCE,displayXcord+347);
                                else ObjectSet("B3VhPMn",OBJPROP_XDISTANCE,displayXcord+351);
                                ObjectSetText("B3VhPMn",DoubleToStr(hprMin,2),displayFontSize);
                                if(ObjectFind("B3LhTyp")==-1)CreateLabel("B3LhTyp","",0,0,292,16);
                                if(ObjectFind("B3VhOpn")==-1)CreateLabel("B3VhOpn","",0,0,329,16);
                                if(hcb>0){
                                        ObjectSetText("B3LhTyp","Buy:",displayFontSize);
                                        ObjectSetText("B3VhOpn",DoubleToStr(hcb,0),displayFontSize);
                                        dDigits=Digit[ArrayBsearch(Digit,hcb,WHOLE_ARRAY,0,MODE_ASCEND),1];
                                        ObjectSet("B3VhOpn",OBJPROP_XDISTANCE,displayXcord+329-dDigits*7);
                                }else if(hcs>0){
                                        ObjectSetText("B3LhTyp","Sell:",displayFontSize);
                                        ObjectSetText("B3VhOpn",DoubleToStr(hcs,0),displayFontSize);
                                        dDigits=Digit[ArrayBsearch(Digit,hcs,WHOLE_ARRAY,0,MODE_ASCEND),1];
                                        ObjectSet("B3VhOpn",OBJPROP_XDISTANCE,displayXcord+329-dDigits*7);
                                }else{
                                        ObjectSetText("B3LhTyp","",displayFontSize);
                                        ObjectSetText("B3VhOpn",DoubleToStr(0,0),displayFontSize);
                                        ObjectSet("B3VhOpn",OBJPROP_XDISTANCE,displayXcord+329);
                                }
                                if(ObjectFind("B3ShOpn")==-1)CreateLabel("B3ShOpn","/",0,0,342,16);
                                if(ObjectFind("B3VhLot")==-1)CreateLabel("B3VhLot","",0,0,351,16);
                                ObjectSetText("B3VhLot",DoubleToStr(htl,2),displayFontSize);
                        }else{
                                if(ObjectFind("B3LHdge")!=-1)ObjectDelete("B3LHdge");
                                if(ObjectFind("B3VhPro")!=-1)ObjectDelete("B3VhPro");
                                if(ObjectFind("B3VhPMx")!=-1)ObjectDelete("B3VhPMx");
                                if(ObjectFind("B3ShPro")!=-1)ObjectDelete("B3ShPro");
                                if(ObjectFind("B3VhPMn")!=-1)ObjectDelete("B3VhPMn");
                                if(ObjectFind("B3LhTyp")!=-1)ObjectDelete("B3LhTyp");
                                if(ObjectFind("B3VhOpn")!=-1)ObjectDelete("B3VhOpn");
                                if(ObjectFind("B3ShOpn")!=-1)ObjectDelete("B3ShOpn");
                                if(ObjectFind("B3VhLot")!=-1)ObjectDelete("B3VhLot");
                        }
                        if(displayLines){
                                if(BEPoint>0){
                                        if(ObjectFind("B3LBELn")==-1)CreateLine("B3LBELn",DodgerBlue,1,0);
                                        ObjectMove("B3LBELn",0,Time[0],BEPoint);
                                }else if(ObjectFind("B3LBELn")!=-1)ObjectDelete("B3LBELn");
                                if(nTakeProfit>0){
                                        if(ObjectFind("B3LTPLn")==-1)CreateLine("B3LTPLn",Gold,1,0);
                                        ObjectMove("B3LTPLn",0,Time[0],nTakeProfit);
                                }
                                else if(TakeProfit>0){
                                        if(ObjectFind("B3LTPLn")==-1)CreateLine("B3LTPLn",Gold,1,0);
                                        ObjectMove("B3LTPLn",0,Time[0],TakeProfit);
                                }else if(ObjectFind("B3LTPLn")!=-1)ObjectDelete("B3LTPLn");
                                if(hActive&&nBEPoint>0){
                                        if(ObjectFind("B3LNBEL")==-1)CreateLine("B3LNBEL",Crimson,1,0);
                                        ObjectMove("B3LNBEL",0,Time[0],nBEPoint);
                                }else if(ObjectFind("B3LNBEL")!=-1)ObjectDelete("B3LNBEL");
                                if(ProfitSL>0){
                                        double TSLine,TSBEPoint;
                                        if(ObjectFind("B3LTSLn")==-1)CreateLine("B3LTSLn",Gold,1,3);
                                        if(nBEPoint>0)TSBEPoint=nBEPoint;
                                        else TSBEPoint=BEPoint;
                                        if(nLots>0)TSLine=NormalizeDouble(TSBEPoint+ProfitSL/PipValue/tl,Digits);
                                        else if(nLots<0)TSLine=NormalizeDouble(TSBEPoint-ProfitSL/PipValue/tl,Digits);
                                        ObjectMove("B3LTSLn",0,Time[0],TSLine);
                                }else if(ObjectFind("B3LTSLn")!=-1)ObjectDelete("B3LTSLn");
                                if(hThisChart&&hBEPoint>0){
                                        if(ObjectFind("B3LhBEL")==-1)CreateLine("B3LhBEL",SlateBlue,1,0);
                                        ObjectMove("B3LhBEL",0,Time[0],hBEPoint);
                                }else if(ObjectFind("B3LhBEL")!=-1)ObjectDelete("B3LhBEL");
                                if(hThisChart&&hSL>0){
                                        if(ObjectFind("B3LhSLL")==-1)CreateLine("B3LhSLL",SlateBlue,1,3);
                                        ObjectMove("B3LhSLL",0,Time[0],hSL);
                                }else if(ObjectFind("B3LhSLL")!=-1)ObjectDelete("B3LhSLL");
                        }else{
                                if(ObjectFind("B3LBELn")!=-1)ObjectDelete("B3LBELn");
                                if(ObjectFind("B3LTPLn")!=-1)ObjectDelete("B3LTPLn");
                                if(ObjectFind("B3LTSLn")!=-1)ObjectDelete("B3LTSLn");
                                if(ObjectFind("B3LhBEL")!=-1)ObjectDelete("B3LhBEL");
                                if(ObjectFind("B3LhSLL")!=-1)ObjectDelete("B3LhSLL");
                                if(ObjectFind("B3LNBEL")!=-1)ObjectDelete("B3LNBEL");
                        }
                        if(CCIEntry&&displayCCI){
                                if(cci_01>0&&cci_11>0)ObjectSetText("B3VCm05","",displayFontSize+6,"Wingdings",Green);
                                else if(cci_01<0&&cci_11<0)ObjectSetText("B3VCm05","",displayFontSize+6,"Wingdings",Red);
                                else ObjectSetText("B3VCm05","",displayFontSize+6,"Wingdings",Orange);
                                if(cci_02>0&&cci_12>0)ObjectSetText("B3VCm15","",displayFontSize+6,"Wingdings",Green);
                                else if(cci_02<0&&cci_12<0)ObjectSetText("B3VCm15","",displayFontSize+6,"Wingdings",Red);
                                else ObjectSetText("B3VCm15","",displayFontSize+6,"Wingdings",Orange);
                                if(cci_03>0&&cci_13>0)ObjectSetText("B3VCm30","",displayFontSize+6,"Wingdings",Green);
                                else if(cci_03<0&&cci_13<0)ObjectSetText("B3VCm30","",displayFontSize+6,"Wingdings",Red);
                                else ObjectSetText("B3VCm30","",displayFontSize+6,"Wingdings",Orange);
                                if(cci_04>0&&cci_14>0)ObjectSetText("B3VCm60","",displayFontSize+6,"Wingdings",Green);
                                else if(cci_04<0&&cci_14<0)ObjectSetText("B3VCm60","",displayFontSize+6,"Wingdings",Red);
                                else ObjectSetText("B3VCm60","",displayFontSize+6,"Wingdings",Orange);
                        }
                        if(debug_msgs){
                                string dSpace;
                                for(y=0;y<=175;y++)dSpace=dSpace+" ";
                                string dMess="\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()+"  "+DoubleToStr(OrderMagicNumber(),0)+"   "+OrderType());
                                        dMess=(dMess+"   "+DoubleToStr(OrderLots(),LotDecimal)+"  "+DoubleToStr(OrderOpenPrice(),Digits));
                                        dMess=(dMess+"     "+DoubleToStr(OrderSwap()+OrderCommission(),2));
                                        dMess=(dMess+"    "+DoubleToStr(OrderProfit()+OrderSwap()+OrderCommission(),2));
                                        if(OrderMagicNumber()!=Magic)continue;
                                        if(OrderType()==OP_BUY)dMess=(dMess+"      "+DoubleToStr(OrderLots()*(TakeProfit-OrderOpenPrice())*
                                                PipValue+OrderSwap()+OrderCommission(),2));
                                        if(OrderType()==OP_SELL)dMess=(dMess+"      "+DoubleToStr(OrderLots()*(OrderOpenPrice()-TakeProfit)*
                                                PipValue+OrderSwap()+OrderCommission(),2));
                                }
                        }
                }
                if(EmergencyWarning){
                        if(ObjectFind("B3LClos")==-1)CreateLabel("B3LClos","",5,0,0,23,Red);
                        ObjectSetText("B3LClos","WARNING: EmergencyCloseAll is set to TRUE",displayFontSize+5);
                }else if(ShutDown){
                        if(ObjectFind("B3LClos")==-1)CreateLabel("B3LClos","",5,0,0,23,Red);
                        ObjectSetText("B3LClos","Blessing will stop trading when this basket closes.",displayFontSize+5);
                }else if(HolShutDown!=1&&ObjectFind("B3LClos")!=-1)ObjectDelete("B3LClos");
        }
        Comment(CS+dMess);
        return(0);
}

//+-----------------------------------------------------------------+
//| Check Lot Size Funtion                                          |
//+-----------------------------------------------------------------+

double LotSize(double Lot){
        Lot=NormalizeDouble(Lot,LotDecimal);
        Lot=MathMin(Lot,MarketInfo(Symbol(),MODE_MAXLOT));
        Lot=MathMax(Lot,MinLotSize);
        return(Lot);
}

//+-----------------------------------------------------------------+
//| Open Order Funtion                                              |
//+-----------------------------------------------------------------+

int SendOrder(string OSymbol,int OCmd,double OLot,double OPrice,double OSlip,int OMagic,color OColor=CLR_NONE){
        int Ticket;
        int retryTimes=5,i=0;
        int OType=MathMod(OCmd,2);
        double OrderPrice;
        if(AccountFreeMarginCheck(OSymbol,OType,OLot)<=0)return(-1);
        while(true&&i<5){
                i+=1;
                while(IsTradeContextBusy())Sleep(100);
                if(IsStopped())return(-1);
                if(OType==0)OrderPrice=NormalizeDouble(MarketInfo(OSymbol,MODE_ASK)+OPrice,MarketInfo(OSymbol,MODE_DIGITS));
                else OrderPrice=NormalizeDouble(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: "+MarketInfo(OSymbol,MODE_ASK)
                                +" Bid: "+MarketInfo(OSymbol,MODE_BID)
                                +" OPrice: "+DoubleToStr(OPrice,Digits)
                                +" Price: "+DoubleToStr(OrderPrice,Digits)
                                +" Lots: "+DoubleToStr(OLot,2)
                                );
                        switch(Error){
                                case ERR_SERVER_BUSY:
                                case ERR_NO_CONNECTION:
                                case ERR_INVALID_PRICE:
                                case ERR_BROKER_BUSY:
                                case ERR_TRADE_CONTEXT_BUSY:
                                        i+=1;
                                        break;
                                case ERR_TRADE_HEDGE_PROHIBITED:
                                        UseHedge=false;
                                        if(debug_msgs)Print("Hedge trades are not allowed on this pair");
                                        i=retryTimes;
                                        break; 
                                case ERR_PRICE_CHANGED:
                                case ERR_OFF_QUOTES:
                                case ERR_REQUOTE:
                                        RefreshRates();
                                        continue;
                                default:
                                        i=retryTimes;
                        }
                }else 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(true&&i<5&&!Success){
                i+=1;
                while(IsTradeContextBusy())Sleep(100);
                if(IsStopped())return(-1);
                Success=OrderModify(OrderTicket(),OrderOP,OrderSL,0,0,Color);
                if(!Success){
                        Error=GetLastError();
                        if(Error>0)Print(" Error Modifying Order:",OrderTicket(),", ",Error," :" +ErrorDescription(Error),", Ask:",Ask,
                                ", Bid:",Bid," OrderPrice: ",OrderOP," StopLevel: ",StopLevel,", SL: ",OrderSL,", OSL: ",OrderStopLoss());
                        else Success=true;
                        switch(Error){
                                case ERR_NO_ERROR:
                                case ERR_NO_RESULT:
                                        i=retryTimes;
                                        break;
                                case ERR_SERVER_BUSY:
                                case ERR_NO_CONNECTION:
                                case ERR_INVALID_PRICE:
                                case ERR_OFF_QUOTES:
                                case ERR_BROKER_BUSY:
                                case ERR_TRADE_CONTEXT_BUSY:
                                case ERR_TRADE_TIMEOUT:
                                        i+=1;
                                        break;
                                case ERR_PRICE_CHANGED:
                                case ERR_REQUOTE:
                                        RefreshRates();
                                        continue;
                                default:
                                        i=retryTimes;
                                        break;
                        }
                }else break;
        }
        return(Success);
}

//+-------------------------------------------------------------------------+
//| Exit Trade Function - Type: 1=Basket, 2=Hedge, 3=All 4=Oldest 5=Pending |
//+-------------------------------------------------------------------------+

int ExitTrades(int Type,color Color,string reason){
        bool Success;
        int Closed;
        string s;

        ca=Type;
        for(y=OrdersTotal()-1;y>=0;y--){
                if(!OrderSelect(y,SELECT_BY_POS,MODE_TRADES))continue;
                if(Type==1&&OrderMagicNumber()!=Magic)continue;
                else if(Type==2&&OrderMagicNumber()!=hMagic)continue;
                else if(Type==3&&OrderMagicNumber()!=Magic&&OrderMagicNumber()!=hMagic)continue;
                else if(Type==4&&OrderTicket()!=OldestTicket)continue;
                else if(Type==5&&(OrderMagicNumber()!=Magic||OrderType()<=OP_SELL))continue;
                while(IsTradeContextBusy())Sleep(100);
                if(IsStopped())return(-1);
                if(OrderType()>OP_SELL)Success=OrderDelete(OrderTicket(),Color);
                else Success=OrderClose(OrderTicket(),OrderLots(),OrderClosePrice(),slip,Color);
                if(Success)Closed++;
                else Print("Order ",OrderTicket()," failed to close. Error:",ErrorDescription(GetLastError()));
        }
        if(Closed!=1)s="s";
        Print("Closed "+Closed+" position"+s+" because ",reason);
        return(Closed);
}

//+-----------------------------------------------------------------+
//| Find Hedge Profit                                               |
//+-----------------------------------------------------------------+

double FindClosedPL(){
        double ClosedProfit;
        cco=0;
        if(fopt>0){
                for(y=OrdersHistoryTotal()-1;y>=0;y--){
                        if(!OrderSelect(y,SELECT_BY_POS,MODE_HISTORY))continue;
                        if(OrderOpenTime()<fopt)continue;
                        if(OrderMagicNumber()==Magic||OrderMagicNumber()==hMagic){
                                ClosedProfit+=OrderProfit()+OrderSwap()+OrderCommission();
                                if(OrderMagicNumber()==Magic&&OrderType()<=OP_SELL)cco++;
                                if(!hActive&&OrderMagicNumber()==hMagic)hActive=true;
                        }
                }
        }
        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));
return(0);
}

//+-----------------------------------------------------------------+
//| Magic Number Generator                                          |
//+-----------------------------------------------------------------+

int GenerateMagicNumber(){
        if(EANumber>99)return(EANumber);
        return(JenkinsHash(EANumber+"_"+Symbol()+"__"+Period()));
}

int JenkinsHash(string Input){
        for(y=0;y<StringLen(Input);y++){
                Magic+=StringGetChar(Input,y);
                Magic+=(Magic<<10);
                Magic^=(Magic>>6);
        }
        Magic+=(Magic<<3);
        Magic^=(Magic>>11);
        Magic+=(Magic<<15);
        Magic=MathAbs(Magic);
        return(Magic);
}

//+------------------------------------------------------------------+
//| Delete Overlay Label Function                                    |
//+------------------------------------------------------------------+

void LabelDelete(){
        for(y=ObjectsTotal();y>=0;y--){
                if(StringSubstr(ObjectName(y),0,2)=="B3")ObjectDelete(ObjectName(y));
        }
}

//+-----------------------------------------------------------------+
//| Create Object List Function                                     |
//+-----------------------------------------------------------------+

void LabelCreate(){
        if(displayOverlay&&((Testing&&Visual)||!Testing)){
                int dDigits;
                string ObjText;
                color ObjClr;
                if(displayLogo){
                        CreateLabel("B3LLogo","Q",27,3,10,10,Crimson,"Wingdings");
                        CreateLabel("B3LCopy","?2010, J Talon LLC/FiFtHeLeMeNt",1,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",DoubleToStr(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",DoubleToStr(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,Red);
                CreateLabel("B3LAPPC","Account Portion:",0,0,0,5);
                dDigits=Digit[ArrayBsearch(Digit,PortionPC*100,WHOLE_ARRAY,0,MODE_ASCEND),1];
                CreateLabel("B3VAPPC",DoubleToStr(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,230,6);
                CreateLabel("B3VAPCR",DoubleToStr(MaxDDPercent*PortionPC,2),0,0,347,6);
                CreateLabel("B3PAPCR","%",0,0,380,6);
                if(UseMM){
                        ObjText="Money Management is On";
                        ObjClr=Green;
                }else{
                        ObjText="Money Management is Off";
                        ObjClr=Red;
                }
                CreateLabel("B3LMMOO",ObjText,0,0,0,7,ObjClr);
                if(UsePowerOutSL){
                        ObjText="Power Off Stop Loss is On";
                        ObjClr=Green;
                }else{
                        ObjText="Power Off Stop Loss is Off";
                        ObjClr=Red;
                }
                CreateLabel("B3LPOSL",ObjText,0,0,0,8,ObjClr);
                CreateLabel("B3LDrDn","Draw Down %:",0,0,228,8);
                CreateLabel("B3VDrDn","",0,0,315,8);
                if(UseHedge&&HedgeTypeDD){
                        CreateLabel("B3LhDDn","Hedge",0,0,190,8);
                        CreateLabel("B3ShDDn","/",0,0,342,8);
                        CreateLabel("B3VhDDm","",0,0,347,8);
                }
                else if(UseHedge&&!HedgeTypeDD){
                        CreateLabel("B3LhLvl","Hedge Level:",0,0,228,9);
                        CreateLabel("B3VhLvl","",0,0,315,9);
                        CreateLabel("B3ShLvl","/",0,0,325,9);
                        CreateLabel("B3VhLvT","",0,0,330,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=Green;
                }else{
                        ObjText="Profit Maximizer is Off";
                        ObjClr=Red;
                }
                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",DoubleToStr(MoveTP/Point/BrokerDecimal,0),0,0,100,17);
                CreateLabel("B3LMves","# Moves:",0,0,150,17);
                CreateLabel("B3VMove","",0,0,240,17);
                CreateLabel("B3SMves","/",0,0,253,17);
                CreateLabel("B3VMves",DoubleToStr(TotalMoves,0),0,0,260,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,240,18);
                CreateLabel("B3PDDPC","%",0,0,268,18);
                if(ForceMarketCond<3)CreateLabel("B3LFMCn","Market trend is forced",0,0,0,19);
                CreateLabel("B3LTrnd","",0,0,0,20);
                if(CCIEntry>0){
                        CreateLabel("B3LCCIi","CCI",2,1,12,0);
                        CreateLabel("B3LCm05","m5",2,1,25,1.2);
                        CreateLabel("B3VCm05","",6,1,0,1,Orange,"Wingdings");
                        CreateLabel("B3LCm15","m15",2,1,25,2.4);
                        CreateLabel("B3VCm15","",6,1,0,2.2,Orange,"Wingdings");
                        CreateLabel("B3LCm30","m30",2,1,25,3.6);
                        CreateLabel("B3VCm30","",6,1,0,3.4,Orange,"Wingdings");
                        CreateLabel("B3LCm60","h1",2,1,25,4.8);
                        CreateLabel("B3VCm60","",6,1,0,4.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);
                }
        }
        return(0);
}

//+-----------------------------------------------------------------+
//| Create Label Function (OBJ_LABEL ONLY)                          |
//+-----------------------------------------------------------------+

void CreateLabel(string Name,string Text,int FontSize,int Corner,int XOffset,int YLine,color Colour=CLR_NONE,string Font="Arial Bold"){
        int XDistance,YDistance;
        FontSize+=displayFontSize;
        YDistance=displayYcord+displaySpacing*YLine;
        if(Corner==0)XDistance=displayXcord+XOffset;
        else if(Corner==1)XDistance=displayCCIxCord+XOffset;
        else if(Corner==3){
                XDistance=XOffset;
                YDistance=YLine;
        }
        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);
}

//+-----------------------------------------------------------------+
//| expert end function                                             |
//+-----------------------------------------------------------------+

如您喜欢此文章请点下面分享按钮↴峰汇在线 » 智能交易系统 blessing_3_v3.7-5 EA
上一篇:
下一篇:
分享到:更多 ()