Indo Run 1.5

#include <stdlib.mqh>
#include <WinUser32.mqh>

extern string Menu = "Indo Run Setup";
extern string EAName = "";            //Comment for your orders, you might better leave it empty ;) 
extern bool IndoRunLabelOn = true;   //Switches Chart Label on/off
extern string MagicNumber = "Random Magic will overide manual set Magic Number";
extern int Magic = 128738;            //Order Magic Number
extern bool UseRandomMagic = false;   //Switches the Random Magic Number on/off
extern int RandomMagicLower = 100000; //Sets the lower Magic Number boundry
extern int RandomMagicUpper = 200000; //Sets the upper Magic Number boundry
extern string DayFilter = "Select the days for Indo Run to trade";
extern bool Monday = true;              // Selecting a day true/false will hold the EA off trading that day if no trades are open
extern bool Tuesday = true;             // Overides day filter if trades are open (Basket)
extern bool Wednesday = true;
extern bool Thursday = true;
extern bool Friday = true; 
extern bool Saturday = true; 
extern bool Sunday = true;
extern bool TradeMonthEnd = true;
extern int MonthEndOffset = 3;   //Offset to define the last trading day of a month (31 - Offset)
extern bool TradeFirstDayOffMonth = true; 
extern int DayOffset = 0;     //Per default the Offset is 0 thus the 1st of a month is filtered
extern double GMTOffset = 0;
extern bool TradeNFP = true;  //Trade Day of Non Farm Employment
extern bool TradeMondayAfterNFP = true;  //Trade Monday till US Session after Non Farm Employment / TradeNFP must be set to true
extern bool TradeADP = true;  //Trade Day of ADP Non Farm Employment
extern string HourFilter = "Select the Trading Hours or set to 24h";
extern bool Trading24h = true;      
extern int HoursFrom = 10;          //Start Trading Hour Broker Time (Standad Settings GMT), the EA overides time if trades are open (Basket)
extern int HoursTo = 6;            //Stop Trading Hour Broker Time Standard Setting GMT), the EA overides time if trades are open (Basket)
extern string Session_Filter = "Only in 24 Mode: Use both Session Filter together only!";
extern string Session_Filter1 = "Filters per default London Session (GMT)!";
extern bool SessionFilter1 = false;   //Session Filter Settings in GMT / Use only in combination with SessionFilter 2
extern double SF1Hour_On = 5;
extern double SF1MinuteOn =45;
extern double SF1Hour_Off = 9;
extern double SF1MinuteOff = 0;
extern string Session_Filter2 = "Filters per default NY Session (GMT)!";
extern bool SessionFilter2 = false;   //Session Filter Settings in GMT / Use only in combination with SessionFilter 1
extern double SF2Hour_On = 11;
extern double SF2MinuteOn =45;
extern double SF2Hour_Off = 17;
extern double SF2MinuteOff = 30;
extern string Info9 = "News Filter Setup";
extern bool AvoidNews = true; //Switches News Filter on/off
extern bool High_Impact=true;
extern int MinsUntilNextHighNews=90;
extern int MinsSincePrevHighNews=90;
extern bool Medium_Impact=true;
extern int MinsUntilNextMediumNews=90;
extern int MinsSincePrevMediumNews=90;
extern bool Low_Impact=false;
extern int MinsUntilNextLowNews=60;
extern int MinsSincePrevLowNews=60;
extern string Info10 = "News Currency Filter";  //Select the Currency which News should be filtered
extern bool USD = true;
extern bool EUR = false;
extern bool GBP = true;
extern bool JPY = false;
extern bool AUD = false;
extern bool CAD = false;
extern bool CHF = false;
extern bool NZD = false;
extern int TSD_CalendarID = 4;  //  TSD News Calendar ID reference on the TSD Homepage
extern string TSD_Calendar_URL = "";
extern string Info5 = "Main Order Setup";
extern string PAO = " ProfitAllOrder will calculate automatically while the Lotssize is changed!";
extern double ProfitAllOrder = 15; //Cumulated Sell Order Take Profit in Account Currency based on 0.1 Lotsize!!! 
extern bool FixedProfitAO = false; // If true, ProfitAllOrder amount set will be used only/Have to be set to tru while using Martingale!!!
extern bool ADVProfitMode = false; //Advanced Profit Modue which reduces the Profit Target on increasing opened Orders in the Basket
extern bool ATRProfitMode = false; //This Mode will take the Profit (>=ATR Profit) while the ATR is Filtering on open trades
extern double ATRProfit = 4;        //This value does not adjusts automatically while the Lotsize is changed.
extern bool ADVATRProfit = false;   //Overrides ATRProfit set and will apply ProfitAllOrders/ADVATRProfitx
extern double ADVATRProfitx = 3;      //ProfitAllOrders/ADVATRProfitx
extern bool DynamicProfit = false;  //If true, when ProfitAllOrder limit is reached the profit will trail by the defined step
extern double DynamicProfitStep = 1;  //Inc of the ProfitAllOrder value
extern bool Trailing = false; //If true, Profit will be trailed while if Drawdown as set in TrailingStop and BE
extern int OrderTreshold = 20; //Number of open trades for the trailing to start
extern bool Breakeven = false; //Breakeven Profit upon Order Treshold. Requires Trailing to be set to true
extern double BE = 0; //Breakeven in Account Currency
extern bool OrderTrailing = false; //If true Order Profits will be trailed downwards while in DD after Breakeven
extern double TrailingStop = 15; //Profit of Account Currency on which the Profit is reduced/trailed per open Order after Breakeven.
int OpenOrdersLimit = 0;            //Limits the number of open orders
extern bool DeletePOMode = true;           // Bug: if false Sell Open Orders are not registered and counted
extern bool ReverseOrder = false;   //Reverse/Hedging Trades from a defined Treshold of trades onwards
extern int OpenOrderTreshold = 10;   //Reverse/Hedging Trade Treshold
extern double ReverseOrderLotDiv = 2;   //Lot divider for Reverse/Hedging Trades (Lot/ReverseOrderLotDiv)
extern bool ReversalContBasket = true;  //Continue Basket while Orders are reversed in addition
extern int SingleOrderSL = 0;       //Stop Loss of each individual Order in Pips
extern int SingleOrderTP = 0;       //Take Profit of each individual Order in Pips
extern bool ADVOffsetMode = false;  //If false Pending Orders are placed on the current ASK/Bid Price
extern bool ATRStepOn = false;    //If true the step value/price offset is linked to the current ATRPips value
extern bool ATRPipsToStep = false; //If true the ATRPips value will be used as Step/Price Offset
extern int PriceOffset = -16;     //Step/Gap in Pips where Pending Order is placed to current price basic
extern bool StepFactorOn = false; //Factor which increases the Step per Order
extern int StepFactor = 10;       //ProfitOffset*(OrderCounter/StepFactor+1)
extern int PriceOffset1 = 0;       ////Step/PriceOffset added in Low Range ATR while ATRStepOn is set to true
extern int PriceOffset2 = -1;      //Step/PriceOffset added in Mid Range ATR while ATRStepOn is set to true
extern int PriceOffset3 = -2;      //Step/PriceOffset added in High Range ATR while ATRStepOn is set to true
extern double Lot = 0.1;      //Single Order Lotsize / If FixedProfitAO = false Profit Target will be calculated automatically to the Profit Target set on 0.1 base (0.1 Lot = 15$ standard setting)
extern int  Slippage=4;       //Price Change in Pips allowed during Order Processing
extern string AutomaticLots1 = "Automatic Lotsize based on Account Balance!";
extern string AutomaticLots2 = "ProfitAllOrder gets adjusted automatically!";
extern bool AutoLotSize = false;  //Automatic Lotsize based on Account Balance (Account Balance/300*MinLots)
extern double Risk = 2;           //"Risk Factor on which the Lotsize increases
extern double MinLots = 0.01;      //minimum Lotsize only used when Autolotsize is activated
extern bool KLotSize = false;      // if true Lot Size will double every 10K+
extern bool DoubleLots = false;   //Doubles the Lotsize in the Asian Session
extern bool Martingale = false;   //Need to set FixedProfitAO=true!!!!
extern double LotFactor = 1.4;    //Increasing Factor of Martingale Lotsize  
extern double MartingaleMaxLot = 0.5;  //Limit of Losize of Martingale!!!
extern bool DoubleBasket = false;  //if true the EA will trade with two Order Baskets (First Basket opens Trade second Basket comes online in addition)
extern bool TripleBasket = false;  //if true the EA will trade with three Order Baskets (Second Basket opens Trade third Basket comes online in addition)
extern string Timed_Stop = "Stops Trading and closes all trades at selected time of a day!";
extern bool TimedStop = false;        //Switches Time to close all open orders once a day on/off
extern int StopHour = 14;             //Timed Stop Hour GMT
extern int StopMinute = 0;            //Timed Stop Minute 
extern string ATR_Filter = "ATR Filter selection and setup!";
extern bool ATROn = true;             //Switches ATR Filter on/off
extern bool FilterMod = false;
extern int ATR_Period1 = 7;
extern int ATR_Period2 = 7;
extern int ATR_Period3 = 7;
extern double ATRShift1 = 0.0;
extern double ATRShift2 = 3.0;
extern double ATRShift3 = 5.0;
extern double ATRUpLimit1 = 13.0;
extern double ATRDnLimit1 = 7.0;
extern double ATRUpLimit2 = 21.0; 
extern double ATRDnLimit2 = 16.0;
extern double ATRUpLimit3 = 26.0;
extern double ATRDnLimit3 = 24.0;
extern string Info15 = "CCI Filter Settings";
extern bool CCIFilterOn = false;
extern double CCIPeriod1 = 14;
extern double CCIPeriod2 = 14;
extern double CCIShift1 = 0;
extern double CCIShift2 = 5;
extern double CCICurrentUp = 65;
extern double CCICurrentDown = -65;
extern double CCIPreviousUp = 75;
extern double CCIPreviousDown = -75;
extern string Info16 = "Momentum Filter Settings";
extern bool MomentumFilterOn = false;
extern double MomentumPeriod1 = 3;
extern double MomentumPeriod2 = 3;
extern double MomentumShift1 = 0;
extern double MomentumShift2 = 3;
extern double MomentumCurrentUp = 100.1;
extern double MomentumCurrentDown = 99.9;
extern double MomentumPreviousUp = 100.2;
extern double MomentumPreviousDown = 99.8;
extern string Info17 = "RSI Filter Settings";
extern bool RSIFilterOn = false;
extern double RSIPeriod1 = 3;
extern double RSIPeriod2 = 3;
extern double RSIShift1 = 0;
extern double RSIShift2 = 3;
extern double RSICurrentUp = 51;
extern double RSICurrentDown = 49;
extern double RSIPreviousUp = 53;
extern double RSIPreviousDown = 47;
extern string Info18 = "MA Filter Settings";
extern bool MAFilterOn = false;  
extern double MAPeriod1 = 3;
extern double MAPeriod2 = 3;
extern double MAIShift1 = 0;
extern double MAIShift2 = 0;
extern double MAMethod = 0;
extern double MAShift1 = 0;
extern double MAShift2 = 3;
extern double MACurrentUp = 0.00025;
extern double MACurrentDown = 0.00025;
extern double MAPreviousUp = 0.0005;
extern double MAPreviousDown = 0.0005;
extern string Info19 = "Envelopes Filter Settings";
extern bool EnvelopesFilterOn = false;
extern int EnvelopesTimeFrame = 0;  //Indicator timeframe in minutes (0 = current chart timeframe)
extern int EnvelopesMAPeriod1 = 14;
extern int EnvelopesMAPeriod2 = 14;
extern int EnvelopesMAMethod = 0;
extern int EnvelopesMAShift1 = 0;
extern int EnvelopesMAShift2 = 0;
extern int EnvelopesAppliedPrice = 0;
extern double EnvelopesDeviation = 0.1;  //Sets the distance/deviation of the upper and lower indicator line
extern int EnvelopesShift1 = 0;
extern int EnvelopesShift2 = 0;
extern string Info20 = "Specific Order and Emergency Functions";
extern bool DeletePOATR = true;      // Switch to delete all pending orders while ATR is active
extern bool DeleteOrderATR = false;  // Switch to close all open orders while ATR is active (disabled due to current strategy set
extern string Stop_Out = "Closes all trades in basket on cummulated Profit/Loss!";
extern bool LossStopOutOn = false;  //Switches Cumulated Loss Stop Out On on/off
extern int LossStopOut = -5000;     // Cumulated Loss in Account Currency which will close all open orders
extern string CAT = "!!!Closes all trades in basket when true!!!";
extern bool CloseAllTrades = false; // Closes all open orders

double PipValue=1;    // this variable is here to support 5-digit brokers
bool Terminated = false;
string LF = "\n";  // use this in custom or utility blocks where you need line feeds
int NDigits = 4;   // used mostly for NormalizeDouble in Flex type blocks
int ObjCount = 0;  // count of all objects created on the chart, allows creation of objects with unique names
bool FirstTime33 = false;
bool FirstTime35 = false;
int Today6 = -1;
int Count32 = 0;
double dblProfit=0;
string ATR = "";
string Trading = "";
int OrderCounter =0;  //counts open orders including pending orders
bool Overide = false;
int Hour1 = 1;
int Minute1 = 2;
string MagicChange = "Waiting...";
string RMStatus = "Waiting...";
bool Buffer = true;
double ProfitAllOrders = 0;
double TrailingStops =0;
string SessionFilter = "Waiting...";
double ATRPips;
double ATRPrePips1;
double ATRPrePips2;
string Zone1;
string Zone2;
string Zone3;
string Zone4;
string Zone5;
string AutoLot;
string FilterMods;
bool AsianSession = false;
double Lots;
string Double_Lot;
double TotalTradeLots;
double BuyLots;
double SellLots;
bool NewsFilter;
string Filter;
string NewsF;
string CCIStatus;
string MomentumStatus;
string RSIStatus;
string MAStatus;
string EnvelopeStatus;
bool ATRProfitTrigger=false;
double MagicBuffer;
double DDBuffer=0;
string Basket="1";
double TrailingProfit[4];
int BasketTrailing=1;
bool BuyBasket;
bool SellBasket;
datetime NewsTimes[1000];
int NewsRatings[1000];
int NewsTotal;
bool EnableFileErrorLogging = false;
int logHandle=-1;

int init()
{
      // код доступен только после оплаты
   }

int start()
{
      // код доступен только после оплаты
   }

void OnEveryTick24()
{
    if (true == false && true) PipValue = 10;
    if (true && (NDigits == 3 || NDigits == 5)) PipValue = 10;

    if(TripleBasket||DoubleBasket)
    {
      TripleBasket();
    }
    else
    {
      Sequence();
    }
}

void Sequence()
{
    ReadATR();
    News();
    CCI();
    Momentum();
    RSI();
    MA();
    Envelopes();
    Filter();
    if (CloseAllTrades == false)
    {
      LotSize();
      OnceAnHour1(); 
      WeekdayFilter23();
      AtCertainTime6();      
    }
    PrintInfoToChart32();
    CloseOrderIf21();
}

bool MonthEnd(string symb, int year1, int month1, int day1, int ofs)
{   
   if (!TradeMonthEnd)
   {
      if (day1 > (31 - ofs)) return(false);
      if (month1 == 2 && day1 > (29 - ofs)) return(false);
   }
   return(true);
}

bool MonthFirst(string symb, int year1, int month1, int day1, int ofs)
{   
   if (!TradeFirstDayOffMonth)
   {
      if (day1 == 1 - ofs) return(false);
   }
   return(true);
}

bool NFP(string symb, int year1, int month1, int day1, int ofs)
{
   if(!TradeNFP)
   {
      if(!TradeMondayAfterNFP)
      {
         if(DayOfWeek()==0&&day1>3&&day1<11)return(false);
         if(DayOfWeek()==1&&day1>4&&day1<12)return(false);   
      }
      if(DayOfWeek()==5&&day1>1&&day1<9)return(false);
   }
   return(true);
}

bool ADP(string symb, int year1, int month1, int day1, int ofs)
{
   if(!TradeADP)
   {
      if((DayOfWeek()==3&&day1>=1&&day1<=8)||(DayOfWeek()==3&&day1==30))return(false);
   }
   return(true);
}

void WeekdayFilter23()
{
    double GMT_Hour;
    int servertime = TimeCurrent();
    int GMT_time = servertime - 3600.0 * GMTOffset;

    if (((Monday && DayOfWeek() == 1) || (Tuesday && DayOfWeek() == 2) || (Wednesday && DayOfWeek() == 3) ||
    (Thursday && DayOfWeek() == 4) || (Friday && DayOfWeek() == 5) || (Saturday && DayOfWeek() == 6) || (Sunday && DayOfWeek() == 0))
    &&(MonthEnd(Symbol(), TimeYear(GMT_time), TimeMonth(GMT_time), TimeDay(GMT_time), MonthEndOffset))
    &&(MonthFirst(Symbol(), TimeYear(GMT_time), TimeMonth(GMT_time), TimeDay(GMT_time), DayOffset))
    &&(NFP(Symbol(), TimeYear(GMT_time), TimeMonth(GMT_time), TimeDay(GMT_time), 0))
    &&(ADP(Symbol(), TimeYear(GMT_time), TimeMonth(GMT_time), TimeDay(GMT_time), 0)))
    {
        Overide = false;
        HoursFilter22();       
    }
    else
    {       
        if ((!IfOrderDoesNotExist(1))&&(!IfOrderDoesNotExist(0)))
        {
           Trading = "Not Trading!";
           DeletePendingOrder(2);
           DeletePendingOrder(3);
               if(!MonthEnd(Symbol(), TimeYear(GMT_time), TimeMonth(GMT_time), TimeDay(GMT_time), MonthEndOffset))
               {
                  Trading = "Not Trading Months End!";
               }
               if(!MonthFirst(Symbol(), TimeYear(GMT_time), TimeMonth(GMT_time), TimeDay(GMT_time), DayOffset))
               {
                  Trading = "Not Trading 1st Day/Month!";
               }
               if(!NFP(Symbol(), TimeYear(GMT_time), TimeMonth(GMT_time), TimeDay(GMT_time), 0))
               {
                  Trading = "Not Trading NFP!";
               }
               if(!NFP(Symbol(), TimeYear(GMT_time), TimeMonth(GMT_time), TimeDay(GMT_time), 0))
               {
                  Trading = "Not Trading ADP!";
               }               
        }
        else
        {
           Overide = true;
           HoursFilter22();
        }
    }
}

void HoursFilter22()
{
    int datetime800 = TimeCurrent();
    int hour0 = TimeHour(datetime800);
    datetime currTime = TimeCurrent();
    double SF1HourOn = SF1Hour_On + GMTOffset;
    double SF1HourOff = SF1Hour_Off + GMTOffset;
    double SF2HourOn = SF2Hour_On + GMTOffset;
    double SF2HourOff = SF2Hour_Off + GMTOffset;
    datetime fromTime1 = StrToTime(DoubleToStr(SF1HourOn,0)+":"+DoubleToStr(SF1MinuteOn,0));
    datetime toTime1 = StrToTime(DoubleToStr(SF1HourOff,0)+":"+DoubleToStr(SF1MinuteOff,0));
    datetime fromTime2 = StrToTime(DoubleToStr(SF2HourOn,0)+":"+DoubleToStr(SF2MinuteOn,0));
    datetime toTime2 = StrToTime(DoubleToStr(SF2HourOff,0)+":"+DoubleToStr(SF2MinuteOff,0));
    int Hours_To = HoursTo + GMTOffset;
    int Hours_From = HoursFrom + GMTOffset;

    if (toTime2 > fromTime1 && (currTime < fromTime1 || currTime >= toTime2))
    {
      AsianSession = true;
    }
    else
    {
      AsianSession = false;
    }

    if (((Hours_From < Hours_To && hour0 >= Hours_From && hour0 < Hours_To) ||
    (Hours_From > Hours_To && (hour0 < Hours_To || hour0 >= Hours_From)))&& (Trading24h == false))
    {
        Trading = "Trading";
        CheckLastOrderType33();
        LimitOpenOrders28();
        CheckLastOrderType35();
    }
    else
    {
        if ((Trading24h == false)&&((!IfOrderDoesNotExist(1))&&(!IfOrderDoesNotExist(0))))
        {
            Trading = "Not Trading!";
            DeletePendingOrder(2);
            DeletePendingOrder(3);
        }
        else
        {
            if (Trading24h == false)
            {
               Trading = "Overide Hour/Day Filter";
               CheckLastOrderType33();
               LimitOpenOrders28();
               CheckLastOrderType35();
            }
        }
    }
    if (Trading24h == true)
    {
        if (Overide == true)
        {
            Trading = "Overide Hour/Day Filter";
        }
        else
        {
            Trading = "Trading 24h";
        }
        if (((SessionFilter1 == true) && (fromTime1 < toTime1 && (currTime < fromTime1 || currTime >= toTime1)))
           && ((SessionFilter2 == true) && (fromTime2 < toTime2 && (currTime < fromTime2 || currTime >= toTime2))))

        {
               SessionFilter = "Session opened for trading!";
               CheckLastOrderType33();
               LimitOpenOrders28();
               CheckLastOrderType35();   
        }
        else
        {
            if (((SessionFilter1 == true)||(SessionFilter2 == true))&&((!IfOrderDoesNotExist(1)) && (!IfOrderDoesNotExist(0))))
            {
               SessionFilter = "Session filtered!";
               DeletePendingOrder(2);
               DeletePendingOrder(3);
            }
            else
            {
               if ((SessionFilter1 == true)||(SessionFilter2 == true))
               {
                  SessionFilter = "Session Overide!";
                  CheckLastOrderType33();
                  LimitOpenOrders28();
                  CheckLastOrderType35();
               } 
            }    
        }
        if ((SessionFilter1 == false)&&(SessionFilter2 == false))
        {
            SessionFilter = "Sessions not filtered!";
            CheckLastOrderType33();
            LimitOpenOrders28();
            CheckLastOrderType35();
        }        
    }
}

void CloseOrderIf21()
{
    int POS=0;
    bool boolTerm=false;

    dblProfit=0;
    RefreshRates();
    while(boolTerm==false)
      {
       if(OrderSelect(POS,SELECT_BY_POS))
         {
         if(OrderMagicNumber()==Magic) dblProfit=dblProfit+OrderProfit();
         POS++;
         }
        else
        boolTerm=true;
      }
   if ((!DynamicProfit&&dblProfit>= Profit())||(dblProfit<=LossStopOut&&LossStopOutOn==true)||CloseAllTrades==true)
      {
         CloseOrder(1);
         CloseOrder(0);
      }
   if (DynamicProfit)
      {
            while(dblProfit-Profit()>DynamicProfitStep&&dblProfit-TrailingProfit[BasketTrailing]>DynamicProfitStep)TrailingProfit[BasketTrailing]=TrailingProfit[BasketTrailing]+DynamicProfitStep;
            if(dblProfit<TrailingProfit[BasketTrailing]&&dblProfit>=Profit())
            {
               CloseOrder(1);
               CloseOrder(0);
               TrailingProfit[BasketTrailing]=0;
            }
            if(ATRProfitMode&&ATRProfitTrigger&&dblProfit>=Profit())
            {
               CloseOrder(1);
               CloseOrder(0);
               TrailingProfit[BasketTrailing]=0;
            }
      }
  return(0);
}

void LimitOpenOrders28()
{
    int count = 0;
    int z = 0;
    for (int i=OrdersTotal()-1; i >= 0; i--)
    if (OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
    {
        if (OrderSymbol() == Symbol())
        if (OrderMagicNumber() == Magic)
        {
            count++;
        }
    }
    else
    {
        Print("OrderSend() error - ", ErrorDescription(GetLastError()));
    }

    if ((count < OpenOrdersLimit)||(OpenOrdersLimit==0))
    {
          SendOrder();     
    }    
    if ((!IfOrderDoesNotExist(1))&&(!IfOrderDoesNotExist(0)))
    {
         count = 0;
         OrderCounter = count;
    }
    else
    {
         if (DeletePOMode == false)
         {
            z = 2;
         }
         else
         {
            z = 1;
         }
         count = count - z;
         OrderCounter = count;
    }
}

bool ReadATR()
{
    Zone1 = "Closed!";
    Zone2 = "Closed!";
    Zone3 = "Closed!";
    Zone4 = "Closed!";
    Zone5 = "Closed!";    

   double point=Point;
   if (point==0.00001) point=0.0001;
   else if (point==0.001) point=0.01;

   ATRPips =MathRound(iATR(Symbol(),PERIOD_M15,ATR_Period1,ATRShift1) / point);
   ATRPrePips1 =MathRound(iATR(Symbol(),PERIOD_M15,ATR_Period2,ATRShift2) / point);
   ATRPrePips2 =MathRound(iATR(Symbol(),PERIOD_M15,ATR_Period3,ATRShift3) / point);

   if(ATROn)
   {
      if (FilterMod == true)
      {
         FilterMods = "Modified!";

         if (ATRPrePips1 >= ATRDnLimit1 && ATRPrePips1 <= ATRUpLimit1
         && ATRPrePips2 >= ATRDnLimit1 && ATRPrePips2 <= ATRUpLimit1
         && ATRPips >= ATRDnLimit1 && ATRPips <= ATRUpLimit1) 
         {
            ATR = "ATR not filtering!";
            Zone1 = "Open!";
            return(1);
         }

         if (ATRPrePips1 >= ATRDnLimit2 && ATRPrePips1 <= ATRUpLimit2
         && ATRPrePips2 >= ATRDnLimit2 && ATRPrePips2 <= ATRUpLimit2
         && ATRPips >= ATRDnLimit2 && ATRPips <= ATRUpLimit2) 
         {
            ATR = "ATR not filtering!";
            Zone2 = "Open!";
            return(1);
         }

         if (ATRPrePips1 >= ATRDnLimit3 && ATRPrePips1 <= ATRUpLimit3
         && ATRPrePips2 >= ATRDnLimit3 && ATRPrePips2 <= ATRUpLimit3
         && ATRPips >= ATRDnLimit3 && ATRPips <= ATRUpLimit3) 
         {
            ATR = "ATR not filtering!";
            Zone3 = "Open!";
            return(1);
         } 

         if (ATRPrePips1 >= ATRDnLimit2 && ATRPrePips1 <= ATRUpLimit2
         && ATRPrePips2 >= ATRDnLimit2 && ATRPrePips2 <= ATRUpLimit2
         && ATRPips >= ATRDnLimit1 && ATRPips <= ATRUpLimit1) 
         {
            ATR = "ATR not filtering!";
            Zone4 = "Open!";
            return(1);
         } 

         if (ATRPrePips1 >= ATRDnLimit1 && ATRPrePips1 <= ATRUpLimit1
         && ATRPrePips2 >= ATRDnLimit2 && ATRPrePips2 <= ATRUpLimit2
         && ATRPips >= ATRDnLimit1 && ATRPips <= ATRUpLimit1) 
         {
            ATR = "ATR not filtering!";
            Zone5 = "Open!";
            return(1);
         } 
       }
       else
       {  
          FilterMods = "Standard!";

          if (ATRPrePips1 >= ATRDnLimit1 && ATRPrePips1 <= ATRUpLimit1 && ATRPrePips2 >= ATRDnLimit1 && ATRPrePips2 <= ATRUpLimit1 && ATRPips >= ATRDnLimit1 && ATRPips <= ATRUpLimit1 )
           {
            ATR = "ATR not filtering!";
            Zone1 = "Open!";
            return(1);
          }      
          if (ATRPrePips1 >= ATRDnLimit2 && ATRPrePips1 <= ATRUpLimit2 && ATRPrePips2 >= ATRDnLimit2 && ATRPrePips2 <= ATRUpLimit2 && ATRPips >= ATRDnLimit2 && ATRPips <= ATRUpLimit2 )  
          {
            ATR = "ATR not filtering!";
            Zone2 = "Open!";
            return(1);
          }       
          if (ATRPrePips1 >= ATRDnLimit3 && ATRPrePips1 <= ATRUpLimit3 && ATRPrePips2 >= ATRDnLimit3 && ATRPrePips2 <= ATRUpLimit3 && ATRPips >= ATRDnLimit3 && ATRPips <= ATRUpLimit3 )
          {
            ATR = "ATR not filtering!";
            Zone3 = "Open!";
            return(1);
          }
       }
       ATR = "ATR filtering!";
       return(0);
    }
    if (!ATROn)
    {
        ATR = "ATR Filter off!";
        FilterMods = "ATR Filter off!";
        return(1);
    }    
}

bool Filter()
{
    ATRProfitTrigger=false;
    if ((ReadATR()&&News()&&CCI()&&Momentum()&&RSI()&&MA()&&Envelopes())
    ||(IfOrderDoesNotExist(1))||(IfOrderDoesNotExist(0)))
    {
        Filter = "Not Filtering!";
        if (!ReadATR()&&((IfOrderDoesNotExist(1))||(IfOrderDoesNotExist(0))))
        {
           Filter = "Filter Overide!";
           ATRProfitTrigger=true;
        }
        if ((!News()||!CCI()||!Momentum()||!RSI()||!MA()||!Envelopes())&&(IfOrderDoesNotExist(1)||IfOrderDoesNotExist(0)))
        {
           Filter = "Filter Overide!";
           ATRProfitTrigger=true;
        }
        return(1);
    }
    else
    {
           Filter = "Filtering!";
           if (DeletePOATR)
           {
               DeletePendingOrder(2);
               DeletePendingOrder(3);
           }
           if (DeleteOrderATR)
           {
               CloseOrder(1);
               CloseOrder(0);
           }
           return(0);
    }
}

void SendOrder()
{
   if(!ReverseOrder)
   {
      if(IfOrderDoesNotExist(2)&&IfOrderDoesNotExist(1)&&DeletePOMode)DeletePendingOrder(2);
      if(IfOrderDoesNotExist(3)&&IfOrderDoesNotExist(0)&&DeletePOMode)DeletePendingOrder(3);
      if(!IfOrderDoesNotExist(2)&&!IfOrderDoesNotExist(1)&&Filter())PendingOrder(2);
      if(!IfOrderDoesNotExist(3)&&!IfOrderDoesNotExist(0)&&Filter())PendingOrder(3);
   }
   else
   {            
      if(IfOrderDoesNotExist(2)&&IfOrderDoesNotExist(1)&&DeletePOMode&&OrderCounter<OpenOrderTreshold)DeletePendingOrder(2);
      if(IfOrderDoesNotExist(3)&&IfOrderDoesNotExist(0)&&DeletePOMode&&OrderCounter<OpenOrderTreshold)DeletePendingOrder(3);
      if(!IfOrderDoesNotExist(2)&&!IfOrderDoesNotExist(1)&&Filter()&&OrderCounter<OpenOrderTreshold)PendingOrder(2);
      if(!IfOrderDoesNotExist(3)&&!IfOrderDoesNotExist(0)&&Filter()&&OrderCounter<OpenOrderTreshold)PendingOrder(3);

      if(IfOrderDoesNotExist(0)&&OrderCounter<OpenOrderTreshold)
      {
         BuyBasket=true;
         SellBasket=false;
      }
      if(IfOrderDoesNotExist(1)&&OrderCounter<OpenOrderTreshold)
      {
         SellBasket=true;
         BuyBasket=false;
      }

      if(!IfOrderDoesNotExist(2)&&BuyBasket&&!SellBasket)
      {
         if(ReversalContBasket)
            if(OrderCounter>=OpenOrderTreshold)PendingOrder(2);
         if(OrderCounter>=OpenOrderTreshold)MarketOrder(1);
      }
      if(!IfOrderDoesNotExist(3)&&!BuyBasket&&SellBasket)
      {
         if(ReversalContBasket)
            if(OrderCounter>=OpenOrderTreshold)PendingOrder(3);
         if(OrderCounter>=OpenOrderTreshold)MarketOrder(0);
      }
   }      
}

void MarketOrder(int Mode)
{
    double price;
    color ColorSet;
    double SL;
    double TP;
    double MarketLot=(LotSize()/ReverseOrderLotDiv);
    int SlippageOrder=Slippage*PipValue;

    if(Mode==1)
    {
      price = NormalizeDouble(Bid, NDigits);
      SL = price + SingleOrderSL*PipValue*Point;
      TP = price - SingleOrderTP*PipValue*Point;
      ColorSet=Red;
    }
    if(Mode==0)
    {
      price = NormalizeDouble(Ask, NDigits);
      SL = price - SingleOrderSL*PipValue*Point;
      TP = price + SingleOrderTP*PipValue*Point;
      ColorSet=Blue;
    }
    if (SingleOrderSL == 0) SL = 0;
    if (SingleOrderTP == 0) TP = 0;
    while (!IsTradeAllowed()) Sleep(100);
    int ticket = OrderSend(Symbol(), Mode, MarketLot, price, SlippageOrder, SL, TP, EAName, Magic, 0, ColorSet);
    Print("MarketLot: "+MarketLot);
    if (ticket == -1)
    {
        Print("OrderSend() error - ", ErrorDescription(GetLastError()));
    }
}

bool IfOrderDoesNotExist(int Type)
{
    for (int i=OrdersTotal()-1; i >= 0; i--)
    if (OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
    {
        if (OrderType() == Type && OrderSymbol() == Symbol() && OrderMagicNumber() == Magic)
        {
            return(1);
        }
    }
    else
    {
        Print("OrderSelect() error - ", ErrorDescription(GetLastError()));
    }
}

void PendingOrder(int Mode)
{
    int expire = TimeCurrent() + 60 * 0;
    double price;
    color ColorSet;
    double PriceType;
    int CallLastOrder;
    double SL;
    double TP;
    int SlippageOrder=Slippage*PipValue;

    if(Mode==2)
    {
      ColorSet=Blue;
      PriceType=Ask;
      CallLastOrder=0;
    }
    if(Mode==3)
    {
      ColorSet=Red;
      PriceType=Bid;
      CallLastOrder=1;
    }
    if(Mode==3)
    {
      if(!ADVOffsetMode)price = NormalizeDouble(PriceType, NDigits) - Step()*PipValue*Point;
      if(ADVOffsetMode&&!IfOrderDoesNotExist(CallLastOrder))price = NormalizeDouble(PriceType, NDigits) - Step()*PipValue*Point;
      if(ADVOffsetMode&&IfOrderDoesNotExist(CallLastOrder))price = NormalizeDouble(GetLastOrderPrice(CallLastOrder), NDigits) - Step()*PipValue*Point;
      SL = price + SingleOrderSL*PipValue*Point;
      TP = price - SingleOrderTP*PipValue*Point;
    }
    if(Mode==2)
    {
      if(!ADVOffsetMode)price = NormalizeDouble(PriceType, NDigits) + Step()*PipValue*Point;
      if(ADVOffsetMode&&!IfOrderDoesNotExist(CallLastOrder))price = NormalizeDou

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