Experty10_v1_3

extern bool UseEURUSD = true;
extern bool UseGBPUSD = false;
extern bool UseUSDCHF = false;
extern bool UseUSDJPY = false;

extern bool UseAUDUSD = false;
extern bool UseUSDCAD = false;
extern bool UseNZDUSD = false;
extern bool UseEURGBP = false;
extern bool UseEURCHF = false;
extern bool UseEURJPY = false;
extern bool UseGBPJPY = false;
extern bool UseGBPCHF = false;
extern bool UseEURAUD = false;
extern bool UseEURCAD = false;
extern bool UseGBPAUD = false;
extern bool UseGBPCAD = false;
extern bool UseCHFJPY = false;
extern bool UseCADJPY = false;
extern bool UseAUDJPY = false;
extern bool UseAUDCAD = false;
extern bool UseUSDSGD = false;
extern bool UseUSDNOK = false;
extern bool UseUSDSEK = false;
extern bool UseUSDDKK = false;
extern bool UseUSDRUB = false;

extern double Lot = 0.1;
 
extern int StopLoss = 50;
extern int TakeProfit = 150;

extern int MinSpread = 20;

extern bool UseTrailing = false;
extern int TrailingStopLoss = 50;
extern int TrailingStep = 25;

extern bool UseWithoutLoss = false;
extern int WithoutLoss = 50;

extern int MagicNumber = 888;

int MAX_TRAILING_STEP = 15;

string activePairs[];
bool initialized[];

int init() {
   if (IsTesting()) {
      ArrayResize(activePairs, 1);
      activePairs[0] = Symbol();
   } else {
      InitializeActivePairs();
   }
   ArrayResize(initialized, ArraySize(activePairs));
   for (int i = 0; i < ArraySize(activePairs); i++) {
      if (IsTesting()) {
         initialized[i] = true;
      } else {
         initialized[i] = InitializeSymbol(activePairs[i]);
      }
   }
}

bool InitializeSymbol(string symbol) {
   double stopLevel = MarketInfo(symbol, MODE_STOPLEVEL);
   if (StopLoss < stopLevel) {
      Alert(symbol, " => StopLoss óñòàíîâëåí ìåíüøå, ÷åì ðàçðåøåí âàøèì ÄÖ. Ìèíèìàëüíîå çíà÷åíèå: ", stopLevel);
      return (false);
   }
   if (TakeProfit < stopLevel && !UseTrailing) {
      Alert(symbol, " => TakeProfit óñòàíîâëåí ìåíüøå, ÷åì ðàçðåøåí âàøèì ÄÖ. Ìèíèìàëüíîå çíà÷åíèå: ", stopLevel);
      return (false);
   }
   double minLot = MarketInfo(symbol, MODE_MINLOT);
   if (Lot < minLot) {
      Alert(symbol, " => Lot óñòàíîâëåí ìåíüøå, ÷åì ðàçðåøåí âàøèì ÄÖ. Ìèíèìàëüíîå çíà÷åíèå: ", minLot);
      return (false);
   }
   double maxLot = MarketInfo(symbol, MODE_MAXLOT);
   if (Lot > maxLot) {
      Alert(symbol, " => Lot óñòàíîâëåí áîëüøå, ÷åì ðàçðåøåí âàøèì ÄÖ. Ìàêñèìàëüíîå çíà÷åíèå: ", maxLot);
      return (false);
   }
   double lotStep = MarketInfo(symbol, MODE_LOTSTEP);
   for (double i = minLot; i <= maxLot; i += lotStep) {
      if (i == Lot) {
         break;
      }
      if (i + lotStep > maxLot) {
         Alert(symbol, " => Lot óñòàíîâëåí íåïðàâèëüíûé, øàã ëîòà äëÿ âàøåãî ÄÖ: ", lotStep);
         return (false);
      }
   }
   if (UseTrailing) {
      if (TrailingStopLoss < stopLevel) {
         Alert(symbol, " => TrailingStopLoss óñòàíîâëåí ìåíüøå, ÷åì ðàçðåøåí âàøèì ÄÖ. Ìèíèìàëüíîå çíà÷åíèå: ", stopLevel);
         return (false);
      }
      if (TrailingStep < MAX_TRAILING_STEP) {
         Alert(symbol, " => TrailingStep óñòàíîâëåí ìàëåíüêèé, âðÿä ëè ýòî ïîíðàâèòüñÿ âàøåìó ÄÖ. Åñëè íå õîòèòå øòðàôíûõ ñàíêöèé îò ÄÖ ñòàâüòå íå ìåíüøå, ÷åì ", MAX_TRAILING_STEP);
         return (false);
      }
   }
   if (UseWithoutLoss) {
      if (WithoutLoss < stopLevel) {
         Alert(symbol, " => WithoutLoss óñòàíîâëåí ìåíüøå, ÷åì ðàçðåøåí âàøèì ÄÖ. Ìèíèìàëüíîå çíà÷åíèå: ", stopLevel);
         return (false);
      }
   }
   return (true);
}

int deinit() {
}

int start() {
   if (DayOfWeek() == 0 || DayOfWeek() == 6) {
      // â âûõîäíûå íå ðàáîòàåì
      return(0);
   }
   if (!IsTradeAllowed()) {
      // ïðîïóñòèì òèê åñëè òåðìèíàë çàíÿò
      return(0);
   }
   if (UseWithoutLoss) {
      CheckWithoutLossPositions(MinSpread, WithoutLoss, MagicNumber);
   }
   if (UseTrailing) {
      TrailingPositions(MinSpread, TrailingStopLoss, TrailingStep, MagicNumber, UseWithoutLoss);
   }
   
   for (int i = 0; i < ArraySize(activePairs); i++) {
      if (!initialized[i]) {
         // íå ïðîèçîøëà èíèöèàëèçàöèÿ, çíà÷èò óñòàíîâëåííûå âõîäíûå çíà÷åíèÿ ìîãóò íàïîðòà÷èòü, à çíà÷èò âûõîäèì...
         continue;
      }
      LogicTick(activePairs[i], PERIOD_D1);
   }
   
}

void LogicTick(string symbol, int period) {
   
   int ticket;
 
   double L = iLow(symbol, period, 1);
   double H = iHigh(symbol, period, 1);
   double C = iClose(symbol, period, 0);
   double O = iOpen(symbol, period, 0);
   double point = MarketInfo(symbol, MODE_POINT);
   double spred = MarketInfo(symbol, MODE_SPREAD);
   if (spred < MinSpread) {
      spred = MinSpread;
   }
   spred *= point;
   double sl = StopLoss * point;
   double tp = TakeProfit * point;
   
   datetime endPeriodTime = iTime(symbol, period, 0) + period * 60 - 40;
   
   if (TimeCurrent() > endPeriodTime) {
      // íèêàêèõ îòêðûòèé âáëèçè ñìåíû ïåðèîäà
      return (0);
   }
   
   // Ïðîâåðêà íà ïðîáîé High èëè Low Day (çàùèòà îò ÃÝÏ)
   if  (O >= H || O <= L) {
      Comment(symbol, "\nÇàùèòà îò ÃÝÏ (ñêà÷åê öåíû íîâîãî äíÿ)\nÍå âîçìîæíî âûñòàâèòü OP_BUYSTOP è OP_SELLSTOP\nÖåíà Open ïðîáèëà High èëè Low ïðåäûäóùåãî äíÿ");
      return (0);
   }
   
   // ïðîâåðÿåì îðäåðà íà îòêðûòèå
   for (int i = 0; i < OrdersTotal(); i++) {
      if (OrderSelect(i, SELECT_BY_POS) && OrderSymbol() == symbol && OrderMagicNumber() == MagicNumber) {
         // ïðîâåðÿåì ïîçèöèè åñëè åñòü îòêðûòûå îðäåðà è ñðàâíèâàåì ïîêàçàòåëè ñ èíäèêàòîðîì
         return (0);
      }
   }
   for (i = 0; i < OrdersHistoryTotal(); i++) {
      if (OrderSelect(i, SELECT_BY_POS, MODE_HISTORY) && OrderSymbol() == symbol && OrderMagicNumber() == MagicNumber) {
         if (TimeDayOfYear(OrderCloseTime()) == TimeDayOfYear(TimeCurrent()) && TimeYear(OrderCloseTime()) == TimeYear(TimeCurrent())) {
            return (0);
         }
      }
   }
   
   double stopLevel = MarketInfo(symbol, MODE_STOPLEVEL) * point;
 
   // óñëîâèå íà ORDER BUY
   if (H - C >= stopLevel && C - L >= stopLevel && O < H) {
      double tpReal = 0;
      if (!UseTrailing) {
         tpReal = H + tp + spred * 2;
      }
      ticket = OrderSend(symbol, OP_BUYSTOP, Lot, H + spred * 2, 0, H - sl + spred * 2, tpReal, NULL, MagicNumber, endPeriodTime);
      ChechAndPrintError(ticket);
   } else {
      Comment("\nÍå âîçìîæíî âûñòàâèòü OP_BUYSTOP\nÖåíà íå ñîîòâåòñòâóåò óñëîâèþ âõîäà â ðûíîê");
   }     
  
   // óñëîâèå íà ORDER SELL
   if (H - C >= stopLevel && C - L >= stopLevel && O > L) {
      tpReal = 0;
      if (!UseTrailing) {
         tpReal = L - spred - tp;
      }
      ticket = OrderSend(symbol, OP_SELLSTOP, Lot, L - spred, 0, L - spred + sl, tpReal, NULL, MagicNumber, endPeriodTime);
      ChechAndPrintError(ticket);
   } else {
      Comment("\nÍå âîçìîæíî âûñòàâèòü OP_SELLSTOP\nÖåíà íå ñîîòâåòñòâóåò óñëîâèþ âõîäà â ðûíîê");
   }
}

void TrailingPositions(int minSpread, int trailingStopLoss, int trailingStep, int magicNumber, bool useWithoutLoss = false) {
   double bid = 0;
   double ask = 0;
   for (int i = 0; i < OrdersTotal(); i++) {
      if (!(OrderSelect(i, SELECT_BY_POS)) || OrderMagicNumber() != magicNumber) {
         continue;
      }
      
      bid = MarketInfo(OrderSymbol(), MODE_BID);
      ask = MarketInfo(OrderSymbol(), MODE_ASK);
      double point = MarketInfo(OrderSymbol(), MODE_POINT);
      double spread = MarketInfo(OrderSymbol(), MODE_SPREAD);
      if (spread < minSpread) {
         spread = minSpread;
      }
      spread *= point;
      
      if (OrderType() == OP_BUY) {
         if (!useWithoutLoss || (useWithoutLoss && OrderStopLoss() >= OrderOpenPrice() + spread)) {
            if (bid - OrderOpenPrice() > trailingStopLoss * point) {
               if (OrderStopLoss() < bid - (trailingStopLoss + trailingStopLoss - 1) * point || OrderStopLoss() == 0) {
                  OrderModify(OrderTicket(), OrderOpenPrice(), bid - trailingStopLoss * point, OrderTakeProfit(), OrderExpiration());
               }
            }
         }
      } else if (OrderType() == OP_SELL) {
         if (!useWithoutLoss || (useWithoutLoss && OrderStopLoss() <= OrderOpenPrice() - spread)) {
            if (OrderOpenPrice() - ask > trailingStopLoss * point) {
               if (OrderStopLoss() > ask + (trailingStopLoss + trailingStep - 1) * point || OrderStopLoss() == 0) {
                  OrderModify(OrderTicket(), OrderOpenPrice(), ask + trailingStopLoss * point, OrderTakeProfit(), OrderExpiration());
               }
            }
         }
      }
   }
}

void CheckWithoutLossPositions(int minSpread, int withoutLoss, int magicNumber) {
   if (withoutLoss < 0) {
      return;
   }
   double bid = 0;
   double ask = 0;
   for (int i = 0; i < OrdersTotal(); i++) {
      if (!(OrderSelect(i, SELECT_BY_POS)) || OrderMagicNumber() != magicNumber) {
         continue;
      }
      
      bid = MarketInfo(OrderSymbol(), MODE_BID);
      ask = MarketInfo(OrderSymbol(), MODE_ASK);
      double point = MarketInfo(OrderSymbol(), MODE_POINT);
      double spread = MarketInfo(OrderSymbol(), MODE_SPREAD);
      if (spread < minSpread) {
         spread = minSpread;
      }
      spread *= point;
      
      if (OrderType() == OP_BUY) {
         if (bid - OrderOpenPrice() + spread > withoutLoss * point) {
            if (OrderStopLoss() < OrderOpenPrice() + spread) {
               OrderModify(OrderTicket(), OrderOpenPrice(), OrderOpenPrice() + spread, OrderTakeProfit(), OrderExpiration());
            }
         }
      } else if (OrderType() == OP_SELL) {
         if (OrderOpenPrice() - spread - ask > withoutLoss * point) {
            if (OrderStopLoss() > OrderOpenPrice() - spread) {
               OrderModify(OrderTicket(), OrderOpenPrice(), OrderOpenPrice() - spread, OrderTakeProfit(), OrderExpiration());
            }
         }
      }
   }
}

void ChechAndPrintError(int result) {
   if (result < 0) {
      int err = GetLastError();
      Print("Expert+10 >> error(", err, ")");
   }
}

void InitializeActivePairs() {
   string ret[];
   if (UseEURUSD) {
      ArrayResize(ret, ArraySize(ret) + 1);
      ret[ArraySize(ret) - 1] = "EURUSD";
   }
   if (UseGBPUSD) {
      ArrayResize(ret, ArraySize(ret) + 1);
      ret[ArraySize(ret) - 1] = "GBPUSD";
   }
   if (UseUSDCHF) {
      ArrayResize(ret, ArraySize(ret) + 1);
      ret[ArraySize(ret) - 1] = "USDCHF";
   }
   if (UseUSDJPY) {
      ArrayResize(ret, ArraySize(ret) + 1);
      ret[ArraySize(ret) - 1] = "USDJPY";
   }
   if (UseAUDUSD) {
      ArrayResize(ret, ArraySize(ret) + 1);
      ret[ArraySize(ret) - 1] = "AUDUSD";
   }
   if (UseUSDCAD) {
      ArrayResize(ret, ArraySize(ret) + 1);
      ret[ArraySize(ret) - 1] = "USDCAD";
   }
   if (UseNZDUSD) {
      ArrayResize(ret, ArraySize(ret) + 1);
      ret[ArraySize(ret) - 1] = "NZDUSD";
   }
   if (UseEURGBP) {
      ArrayResize(ret, ArraySize(ret) + 1);
      ret[ArraySize(ret) - 1] = "EURGBP";
   }
   if (UseEURCHF) {
      ArrayResize(ret, ArraySize(ret) + 1);
      ret[ArraySize(ret) - 1] = "EURCHF";
   }
   if (UseEURJPY) {
      ArrayResize(ret, ArraySize(ret) + 1);
      ret[ArraySize(ret) - 1] = "EURJPY";
   }
   if (UseGBPJPY) {
      ArrayResize(ret, ArraySize(ret) + 1);
      ret[ArraySize(ret) - 1] = "GBPJPY";
   }
   if (UseGBPCHF) {
      ArrayResize(ret, ArraySize(ret) + 1);
      ret[ArraySize(ret) - 1] = "GBPCHF";
   }
   if (UseEURAUD) {
      ArrayResize(ret, ArraySize(ret) + 1);
      ret[ArraySize(ret) - 1] = "EURAUD";
   }
   if (UseEURCAD) {
      ArrayResize(ret, ArraySize(ret) + 1);
      ret[ArraySize(ret) - 1] = "EURCAD";
   }
   if (UseGBPAUD) {
      ArrayResize(ret, ArraySize(ret) + 1);
      ret[ArraySize(ret) - 1] = "GBPAUD";
   }
   if (UseGBPCAD) {
      ArrayResize(ret, ArraySize(ret) + 1);
      ret[ArraySize(ret) - 1] = "GBPCAD";
   }
   if (UseCHFJPY) {
      ArrayResize(ret, ArraySize(ret) + 1);
      ret[ArraySize(ret) - 1] = "CHFJPY";
   }
   if (UseCADJPY) {
      ArrayResize(ret, ArraySize(ret) + 1);
      ret[ArraySize(ret) - 1] = "CADJPY";
   }
   if (UseAUDJPY) {
      ArrayResize(ret, ArraySize(ret) + 1);
      ret[ArraySize(ret) - 1] = "AUDJPY";
   }
   if (UseAUDCAD) {
      ArrayResize(ret, ArraySize(ret) + 1);
      ret[ArraySize(ret) - 1] = "AUDCAD";
   }
   if (UseUSDSGD) {
      ArrayResize(ret, ArraySize(ret) + 1);
      ret[ArraySize(ret) - 1] = "USDSGD";
   }
   if (UseUSDNOK) {
      ArrayResize(ret, ArraySize(ret) + 1);
      ret[ArraySize(ret) - 1] = "USDNOK";
   }
   if (UseUSDSEK) {
      ArrayResize(ret, ArraySize(ret) + 1);
      ret[ArraySize(ret) - 1] = "USDSEK";
   }
   if (UseUSDDKK) {
      ArrayResize(ret, ArraySize(ret) + 1);
      ret[ArraySize(ret) - 1] = "USDDKK";
   }
   if (UseUSDRUB) {
      ArrayResize(ret, ArraySize(ret) + 1);
      ret[ArraySize(ret) - 1] = "USDRUB";
   }
   ArrayResize(activePairs, ArraySize(ret));
   ArrayCopy(activePairs, ret);
}