Strategy_Xpert_pack_0.5.2

//+------------------------------------------------------------------+
//|                                               Strategy Xpert.mq4 |
//|                      Copyright © 2009, MetaQuotes Software Corp. |
//|                                        http://www.metaquotes.net |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2009, MetaQuotes Software Corp."
#property link      "http://www.metaquotes.net"

//#include "libraries/trade.mq4"

extern int        Magic             =  12345;

extern string     TradeLots_        =  "Åñëè 0 èñïîëüçóåòñÿ àâòîëîò, åñëè íå 0 èñïîëüçóåòñÿ çàäàííûé ôèêñèðîâàííûé";
extern double     TradeLots         =  0;
// risk for automatic lots size counting
extern string     RiskPercentage_   =  "Ðèñê â ïðîöåíòàõ (2 ýòî äâà ïðîöåíòà!, 0.1 ýòî äåñÿòàÿ ïðîöåíòà!)";
extern double     RiskPercentage    =  0;

// maximum acceptable slippage for the price
extern int        Slippage          =  30;

extern string     TimesToRepeat_    =  "Äëÿ òåñòåðà íåâàæíî. Ñêîëüêî ðàç ïîâòîðÿòü ïîïûòêè ïîñòàâèòü îðäåð";
// maximum loop count for orders opening if failed due to requoting
extern int        TimesToRepeat     =  3;

/// \brief Equal to ternar operator 
/// needed = Condition ? IfTrue : IfFalse;
/// \param IfTrue
/// \param IfFalse
/// \return matching value from parameters
double DoubleIf(bool Condition, double IfTrue, double IfFalse)
{
   if (Condition) return (IfTrue);
   else           return (IfFalse);
}

void WaitForContext()
{
   while (IsTradeContextBusy())
   {
      Sleep(100);
   }
}

void OpenBuy(int MN, int Target, int Loss, double Lot)
{
   int count = 0;
   while (count < TimesToRepeat)
   {
      WaitForContext();
      RefreshRates();
   
      double TP = DoubleIf(Target > 0, Ask + Target*Point, 0);
      double SL = DoubleIf(Loss > 0, Ask - Loss*Point, 0);
   
      double LotsToBid = DoubleIf(Lot == 0, GetLotsToBid(RiskPercentage), Lot);
   
      int res = OrderSend(Symbol(), OP_BUY, LotsToBid, Ask, Slippage, SL, TP, NULL, MN, 0, Blue);
      
      if (res > 0) return;
      
      count++;
   }
}

void OpenSell(int MN, int Target, int Loss, double Lot)
{
   int count = 0;
   while (count < TimesToRepeat)
   {
      WaitForContext();
      RefreshRates();
   
      double TP = DoubleIf(Target > 0, Bid - Target*Point, 0);
      double SL = DoubleIf(Loss > 0, Bid + Loss*Point, 0);
   
      double LotsToBid = DoubleIf(Lot == 0, GetLotsToBid(RiskPercentage), Lot);
   
      int res = OrderSend(Symbol(), OP_SELL, LotsToBid, Bid, Slippage, SL, TP, NULL, MN, 0, Red);
      
      if (res > 0) return;

      count++;
   }
}

void CloseSells(int MagicNumber, int Slippage)
{
   for(int i = OrdersTotal() - 1; i >= 0; i--)
   {
      // already closed
      if(OrderSelect(i, SELECT_BY_POS) == false) continue;
      // not current symbol
      if(OrderSymbol() != Symbol()) continue;
      // order was opened in another way
      if(OrderMagicNumber() != MagicNumber) continue;
      
      if(OrderType() == OP_SELL)
      {
         int count = 0;
         while (count < TimesToRepeat)
         {
            WaitForContext();
            
            RefreshRates();
            if (OrderClose(OrderTicket(), OrderLots(), Ask, Slippage, Red))
            {
               break;
            }
            count++;
         }
      }
   }
}

void CloseBuys(int MagicNumber, int Slippage)
{
   for(int i = OrdersTotal(); i >= 0; i--)
   {
      // already closed
      if(OrderSelect(i, SELECT_BY_POS) == false) continue;
      // not current symbol
      if(OrderSymbol() != Symbol()) continue;
      // order was opened in another way
      if(OrderMagicNumber() != MagicNumber) continue;
      
      if(OrderType() == OP_BUY)
      {
         int count = 0;
         while (count < TimesToRepeat)
         {
            WaitForContext();
            
            RefreshRates();
            if (OrderClose(OrderTicket(), OrderLots(), Bid, Slippage, Blue))
            {
               break;
            }
            count++;
         }
      }
   }
}

bool GetActiveOrders(int MagicNumber = -1)
{
   for(int i = 0; i < OrdersTotal(); i++)
   {
      // already closed
      if(OrderSelect(i, SELECT_BY_POS) == false) continue;
      // not current symbol
      if(OrderSymbol() != Symbol()) continue;
      // order was opened in another way
      if(OrderMagicNumber() != MagicNumber && MagicNumber != -1) continue;
      
      if(OrderType() == OP_SELL || OrderType() == OP_BUY)
      {
         return (true);
      }
   }
   
   return (false);
}

int GetOrdersCount(int MagicNumber = -1, int Type = -1, string symb = "")
{
   int count = 0;
   
   for(int i = 0; i < OrdersTotal(); i++)
   {
      // already closed
      if(OrderSelect(i, SELECT_BY_POS) == false) continue;
      // not current symbol
      if(OrderSymbol() != Symbol() && symb == "") continue;
      // not specified symbol
      if(OrderSymbol() != symb && symb != "" && symb != "all") continue;
      // order was opened in another way
      if(OrderMagicNumber() != MagicNumber && MagicNumber != -1) continue;
      
      if(OrderType() == Type || Type == -1)
      {
         count++;
      }
   }
   
   return (count);
}

double GetLotsToBid(double RiskPercentage)
{
   double margin  = MarketInfo(Symbol(), MODE_MARGINREQUIRED);
   double minLot  = MarketInfo(Symbol(), MODE_MINLOT);
   double maxLot  = MarketInfo(Symbol(), MODE_MAXLOT);
   double step    = MarketInfo(Symbol(), MODE_LOTSTEP);
   double account = AccountFreeMargin();
   
   double percentage = account*RiskPercentage/100;
   
   double lots = MathRound(percentage/margin/step)*step;
   
   if(lots < minLot)
   {
      lots = minLot;
   }
   
   if(lots > maxLot)
   {
      lots = maxLot;
   }

   return (lots);
}

int GetStopLevel()
{
   return (MathMax(MathRound(MarketInfo(Symbol(), MODE_STOPLEVEL)), 3));
}

///===========================================================================================
// end trade.mq4
///===========================================================================================

// Externs
extern string OpenDesc1          = "Óñëîâèÿ îòêðûòèÿ -- ñâÿçàíû ìåæäó ñîáîé îïåðàöèåé || (OR)";
extern string OpenDesc2          = "Êàæäîå óëîâèå ÿâëÿåòñÿ ñîñòàâíûì è ñîñòîèò èç ýëåìåíòàðíûõ óñëîâèé (íèæå),";
extern string OpenDesc3          = "ñâÿçàííûõ ìåæäó ñîáîé îïåðàöèåé && (AND)";

extern string OpenCondition1     = "";
extern string OpenCondition2     = "";
extern string OpenCondition3     = "";

extern string CloseDesc1         = "Óñëîâèÿ çàêðûòèÿ -- ñâÿçàíû ìåæäó ñîáîé îïåðàöèåé || (OR)";
extern string CloseDesc2         = "Êàæäîå óëîâèå ÿâëÿåòñÿ ñîñòàâíûì è ñîñòîèò èç ýëåìåíòàðíûõ óñëîâèé (íèæå),";
extern string CloseDesc3         = "ñâÿçàííûõ ìåæäó ñîáîé îïåðàöèåé && (AND)";

extern string CloseCondition1    = "";
extern string CloseCondition2    = "";
extern string CloseCondition3    = "";

extern string OptCondDesc1       = "Òåêóùåå îïòèìèçèðóåìîå óñëîâèå -- îäíîâðåìåííî ìîæåò ";
extern string OptCondDesc2       = "îïòèìèçèðîâàòüñÿ òîëüêî îäíî ñîñòàâíîå óñëîâèå";
extern string OptCondDesc3       = "-1 îïòèìèçàöèÿ îòñóòñòâóåò";
extern string OptCondDesc4       = "0 -- OpenCondition1";
extern string OptCondDesc5       = "1 -- OpenCondition2";
extern string OptCondDesc6       = "2 -- OpenCondition3";
extern string OptCondDesc7       = "3 -- CloseCondition1";
extern string OptCondDesc8       = "4 -- CloseCondition2";
extern string OptCondDesc9       = "5 -- CloseCondition3";

extern int    OptimizingCondition = 0;

extern string MaxCount_          = "Ìàêñèìàëüíîå êîëè÷åñòâî àòîìàðíûõ óñëîâèé â îïòèìèçèðóåìîì óñëîâèè";

extern int    MaxElementsCount   = 5;

extern string MaxOrders_         = "Ìàêñèìàëüíîå êîëè÷åñòâî îäíîâðåìåííî îòêðûòûõ îðäåðîâ";
extern string MaxOrders1_        = "Åñëè 0 -- êîëè÷åñòâî íåîãðàíè÷åíî";

extern int    MaxOrders          = 3;

extern string CloseWhenOpen_     = "Åñëè 1 -- ïðè íàëè÷èè ïðîòèâîïîëîæíîãî ñèãíàëà îòêðûòèÿ ñäåëêè çàêðûâàþòñÿ";
extern string CloseWhenOpen1_    = "Åñëè 0 -- ñäåëêè çàêðûâàþòñÿ òîëüêî ïî ñèãíàëó çàêðûòèÿ";

extern int    CloseWhenOpen      = 1;

extern string Condition_1_       = "Close[1] > EMA(EMAPeriod)";
extern int    Condition_1        = 0;

extern string Condition_2_       = "MACD(MACDFast, MACDSlow, MACDSignal) > 0";
extern int    Condition_2        = 0;

extern string Condition_3_       = "MACD(MACDFast, MACDSlow, MACDSignal, 1) > MACD(MACDFast, MACDSlow, MACDSignal, 2)";
extern int    Condition_3        = 0;

extern string Condition_4_       = "CCI(CCIPeriod, 1) > CCILevel";
extern int    Condition_4        = 0;

extern string Condition_5_       = "Open[1] > Open[0]";
extern int    Condition_5        = 0;

extern string Condition_6_       = "RSI(RSIPeriod, 1) > 50 + RSILevel";
extern int    Condition_6        = 0;

extern string Condition_7_       = "BullsPower(BullsBearsPeriod, 1) > 0";
extern int    Condition_7        = 0;

extern string Condition_8_       = "BearsPower(BullsBearsPeriod, 1) > 0";
extern int    Condition_8        = 0;

extern string Condition_9_       = "Close(1) < BBands(BBandsPeriod, BBandsDeviation, 1)";
extern int    Condition_9        = 0;

extern string Condition_10_      = "lower iFractals available";
extern int    Condition_10       = 0;

extern string Condition_11_      = "CCI(CCIPeriod, 1) < -CCILevel";
extern int    Condition_11       = 0;

extern string Condition_12_      = "RSI(RSIPeriod, 1) < 50 - RSILevel";
extern int    Condition_12       = 0;

extern string Condition_13_      = "Close(1) < BBands(BBandsPeriod, BBandsDeviation, 1)";
extern int    Condition_13       = 0;

extern string Condition_14_      = "upper iFractals available";
extern int    Condition_14       = 0;

// here

extern string Secondary_         = "Ïàðàìåòðû âòîðè÷íîé îïòèìèçàöèè";

extern int    EMAPeriod          = 20;

extern int    MACDFast           = 12;
extern int    MACDSlow           = 26;
extern int    MACDSignal         = 9;

extern int    CCIPeriod          = 15;
extern int    CCILevel           = 90;

extern int    RSIPeriod          = 12;
extern int    RSILevel           = 20;

extern int    BullsBearsPeriod   = 13;

extern int    BBandsPeriod       = 20;
extern int    BBandsDeviation    = 2;

extern string Stops_             = "Ñòîïû Target -- TakeProfit â ïóíêòàõ, Loss -- StopLoss";

extern int    Target             = 0;
extern int    Loss               = 100;

extern string FileSettings_      = "Íàñòðîéêè äëÿ ðàáîòû ñ ôàéëàìè";

extern int    SaveToFile         = 0;
extern int    LoadFromFile       = 0;
extern string FileName           = "Strategy.csv";


// Defines
#define CONDITION_COUNT    14

// here

// Globals
string   symbol;
datetime LastTime;
int      ElementsCount;
bool     CriticalError;

bool NeedOpenBuys;
bool NeedOpenSells;
bool NeedCloseBuys;
bool NeedCloseSells;

int OpenCondition1Array[CONDITION_COUNT];
int OpenCondition2Array[CONDITION_COUNT];
int OpenCondition3Array[CONDITION_COUNT];

int CloseCondition1Array[CONDITION_COUNT];
int CloseCondition2Array[CONDITION_COUNT];
int CloseCondition3Array[CONDITION_COUNT];

// Conditions
bool BuyCondition(int index)
{
   switch (index)
   {
      case 0:  return (BuyCondition1());
      case 1:  return (BuyCondition2());
      case 2:  return (BuyCondition3());
      case 3:  return (BuyCondition4());
      case 4:  return (BuyCondition5());
      case 5:  return (BuyCondition6());
      case 6:  return (BuyCondition7());
      case 7:  return (BuyCondition8());
      case 8:  return (BuyCondition9());
      case 9:  return (BuyCondition10());
      case 10:  return (BuyCondition11());
      case 11:  return (BuyCondition12());
      case 12:  return (BuyCondition13());
      case 13:  return (BuyCondition14());
      default: return (false);
   }
   
   // here
}

bool SellCondition(int index)
{
   switch (index)
   {
      case 0:  return (SellCondition1());
      case 1:  return (SellCondition2());
      case 2:  return (SellCondition3());
      case 3:  return (SellCondition4());
      case 4:  return (SellCondition5());
      case 5:  return (SellCondition6());
      case 6:  return (SellCondition7());
      case 7:  return (SellCondition8());
      case 8:  return (SellCondition9());
      case 9:  return (SellCondition10());
      case 10:  return (SellCondition11());
      case 11:  return (SellCondition12());
      case 12:  return (SellCondition13());
      case 13:  return (SellCondition14());
      default: return (false);
   }
   
   // here
}

///=============================================================================================

bool BuyCondition1()
{
   return (Close[1] > iMA(symbol, 0, EMAPeriod, 0, MODE_EMA, PRICE_CLOSE, 1));
}

bool SellCondition1()
{
   return (Close[1] < iMA(symbol, 0, EMAPeriod, 0, MODE_EMA, PRICE_CLOSE, 1));
}

///=============================================================================================

bool BuyCondition2()
{
   return (iMACD(symbol, 0, MACDFast, MACDSlow, MACDSignal, PRICE_CLOSE, MODE_SIGNAL, 1) > 0);
}

bool SellCondition2()
{
   return (iMACD(symbol, 0, MACDFast, MACDSlow, MACDSignal, PRICE_CLOSE, MODE_SIGNAL, 1) < 0);
}

///=============================================================================================

bool BuyCondition3()
{
   return ( iMACD(symbol, 0, MACDFast, MACDSlow, MACDSignal, PRICE_CLOSE, MODE_SIGNAL, 1) > 
            iMACD(symbol, 0, MACDFast, MACDSlow, MACDSignal, PRICE_CLOSE, MODE_SIGNAL, 2));
}

bool SellCondition3()
{
   return ( iMACD(symbol, 0, MACDFast, MACDSlow, MACDSignal, PRICE_CLOSE, MODE_SIGNAL, 1) <
            iMACD(symbol, 0, MACDFast, MACDSlow, MACDSignal, PRICE_CLOSE, MODE_SIGNAL, 2));
}

///=============================================================================================

bool BuyCondition4()
{
   return ( iCCI(symbol, 0, CCIPeriod, PRICE_CLOSE, 1) > CCILevel);
}

bool SellCondition4()
{
   return ( iCCI(symbol, 0, CCIPeriod, PRICE_CLOSE, 1) < -CCILevel);
}

///=============================================================================================

bool BuyCondition5()
{
   return ( Open[1] > Open[0]);
}

bool SellCondition5()
{
   return ( Open[1] < Open[0]);
}

///=============================================================================================

bool BuyCondition6()
{
   return ( iRSI(symbol, 0, RSIPeriod, PRICE_CLOSE, 1) > 50 + RSILevel);
}

bool SellCondition6()
{
   return ( iRSI(symbol, 0, RSIPeriod, PRICE_CLOSE, 1) < 50 - RSILevel);
}

///=============================================================================================

bool BuyCondition7()
{
   return ( iBullsPower(symbol, 0, BullsBearsPeriod, PRICE_CLOSE, 1) > 0);
}

bool SellCondition7()
{
   return ( iBullsPower(symbol, 0, BullsBearsPeriod, PRICE_CLOSE, 1) < 0);
}

///=============================================================================================

bool BuyCondition8()
{
   return ( iBearsPower(symbol, 0, BullsBearsPeriod, PRICE_CLOSE, 1) > 0);
}

bool SellCondition8()
{
   return ( iBearsPower(symbol, 0, BullsBearsPeriod, PRICE_CLOSE, 1) < 0);
}

///=============================================================================================

bool BuyCondition9()
{
   return ( iBands(symbol, 0, BBandsPeriod, BBandsDeviation, 0, PRICE_CLOSE, MODE_LOWER, 1) > Open[0]);
}

bool SellCondition9()
{
   return ( iBands(symbol, 0, BBandsPeriod, BBandsDeviation, 0, PRICE_CLOSE, MODE_UPPER, 1) < Open[0]);
}

///=============================================================================================

bool BuyCondition10()
{
   return ( iFractals(symbol, 0, MODE_LOWER, 1) != EMPTY_VALUE);
}

bool SellCondition10()
{
   return ( iFractals(symbol, 0, MODE_UPPER, 1) != EMPTY_VALUE);
}

///=============================================================================================

bool BuyCondition11()
{
   return ( SellCondition4());
}

bool SellCondition11()
{
   return ( BuyCondition4());
}

///=============================================================================================

bool BuyCondition12()
{
   return ( SellCondition6());
}

bool SellCondition12()
{
   return ( BuyCondition6());
}

///=============================================================================================

bool BuyCondition13()
{
   return ( SellCondition9());
}

bool SellCondition13()
{
   return ( BuyCondition9());
}

///=============================================================================================

bool BuyCondition14()
{
   return ( SellCondition10());
}

bool SellCondition14()
{
   return ( BuyCondition10());
}

///=============================================================================================

// here

// Functions
void SignalFromString(int& array[CONDITION_COUNT], string s)
{
   int length = StringLen(s);
   
   if (StringLen(s) != CONDITION_COUNT && s != "")
   {
      Print("Wrong string signal ", s, "! Needed mask size is ", CONDITION_COUNT);
   }
   
   for (int i = 0; i < CONDITION_COUNT; i++)
   {
      array[i] = 0;
      
      if (length != 0)
      {
         if (StringGetChar(s, i) == 'S') array[i] = 1;
         if (StringGetChar(s, i) == 'R') array[i] = 2;
      }
   }
}

string SignalToString(int array[CONDITION_COUNT])
{
   static string result;
   
   for (int i = 0; i < CONDITION_COUNT; i++)
   {
      string c = "0";
      if (array[i] == 1) c = "S";
      if (array[i] == 2) c = "R";
      
      result = result + c;
   }
   
   return(result);
}

int CorrectedCondition(int condition, string name)
{
   if (condition > 2 || condition < 0)
   {
      Print("Wrong ", name, " value -- should be {0, 1, 2}, but actual value is ", condition);
      return (0);
   }
   return (condition);
}

void SignalFromOptions(int& array[CONDITION_COUNT])
{
   array[0] = CorrectedCondition(Condition_1, "Condition_1");
   array[1] = CorrectedCondition(Condition_2, "Condition_2");
   array[2] = CorrectedCondition(Condition_3, "Condition_3");
   array[3] = CorrectedCondition(Condition_4, "Condition_4");
   array[4] = CorrectedCondition(Condition_5, "Condition_5");
   array[5] = CorrectedCondition(Condition_6, "Condition_6");
   array[6] = CorrectedCondition(Condition_7, "Condition_7");
   array[7] = CorrectedCondition(Condition_8, "Condition_8");
   array[8] = CorrectedCondition(Condition_9, "Condition_9");
   array[9] = CorrectedCondition(Condition_10, "Condition_10");
   array[10] = CorrectedCondition(Condition_11, "Condition_11");
   array[11] = CorrectedCondition(Condition_12, "Condition_12");
   array[12] = CorrectedCondition(Condition_13, "Condition_13");
   array[13] = CorrectedCondition(Condition_14, "Condition_14");
// here

   ElementsCount = 0;
   for (int i = 0; i < CONDITION_COUNT; i++)
   {
      ElementsCount += MathAbs(array[i]);
   }
}

void CreateSignal()
{
   SignalFromString(OpenCondition1Array, OpenCondition1);
   SignalFromString(OpenCondition2Array, OpenCondition2);
   SignalFromString(OpenCondition3Array, OpenCondition3);

   SignalFromString(CloseCondition1Array, CloseCondition1);
   SignalFromString(CloseCondition2Array, CloseCondition2);
   SignalFromString(CloseCondition3Array, CloseCondition3);

   switch (OptimizingCondition)
   {
      case 0:
      {
         SignalFromOptions(OpenCondition1Array);
         break;
      }
      case 1:
      {
         SignalFromOptions(OpenCondition2Array);
         break;
      }
      case 2:
      {
         SignalFromOptions(OpenCondition3Array);
         break;
      }
      case 3:
      {
         SignalFromOptions(CloseCondition1Array);
         break;
      }
      case 4:
      {
         SignalFromOptions(CloseCondition2Array);
         break;
      }
      case 5:
      {
         SignalFromOptions(CloseCondition3Array);
         break;
      }
   }
}

int GetSignal(int array[CONDITION_COUNT])
{
   bool buySignal = true;
   bool sellSignal = true;
   bool canTrust = false;
   
   for (int i = 0; i < CONDITION_COUNT; i++)
   {
      if (array[i] != 0)
      {
         canTrust = true;
      }
      else continue;
      
      if (
            !(
               (BuyCondition(i) && array[i] == 1) ||
               (!BuyCondition(i) && array[i] == 2)
            )
         )
      {
         buySignal = false;
      }

      if (
            !(
               (SellCondition(i) && array[i] == 1) ||
               (!SellCondition(i) && array[i] == 2)
            )
         )
      {
         sellSignal = false;
      }
   }
   
   buySignal = buySignal && canTrust;
   sellSignal = sellSignal && canTrust;
   
   if (buySignal) return (1);
   if (sellSignal) return (-1);
   
   return(0);
}

void GetSignals()
{
   NeedOpenBuys = false;
   NeedOpenSells = false;
   NeedCloseBuys = false;
   NeedCloseSells = false;

   int open1Res = GetSignal(OpenCondition1Array);
   int open2Res = GetSignal(OpenCondition2Array);
   int open3Res = GetSignal(OpenCondition3Array);

   NeedOpenBuys = 
      (open1Res == 1) ||
      (open2Res == 1) ||
      (open3Res == 1);
      
   NeedOpenSells = 
      (open1Res == -1) ||
      (open2Res == -1) ||
      (open3Res == -1);

   int close1Res = GetSignal(CloseCondition1Array);
   int close2Res = GetSignal(CloseCondition2Array);
   int close3Res = GetSignal(CloseCondition3Array);

   NeedCloseBuys = 
      (close1Res == 1) ||
      (close2Res == 1) ||
      (close3Res == 1);
      
   NeedCloseSells = 
      (close1Res == -1) ||
      (close2Res == -1) ||
      (close3Res == -1);
}

bool LoadStrategyFromFile()
{
   int hFile = FileOpen(FileName, FILE_READ | FILE_CSV, ' ');
   
   if (hFile < 1) return (false);
   
   OpenCondition1 = FileReadString(hFile);
   OpenCondition2 = FileReadString(hFile);
   OpenCondition3 = FileReadString(hFile);
   
   CloseCondition1 = FileReadString(hFile);
   CloseCondition2 = FileReadString(hFile);
   CloseCondition3 = FileReadString(hFile);
   
   CloseWhenOpen = FileReadNumber(hFile);
   
   FileClose(hFile);
   
   return (true);
}

void SaveStrategyToFile()
{
   int hFile = FileOpen(FileName, FILE_WRITE | FILE_CSV, ' ');
   
   if (hFile < 1) return (false);
   
   FileWrite(hFile, OpenCondition1);
   FileWrite(hFile, OpenCondition2);
   FileWrite(hFile, OpenCondition3);
   
   FileWrite(hFile, CloseCondition1);
   FileWrite(hFile, CloseCondition2);
   FileWrite(hFile, CloseCondition3);
   
   FileWrite(hFile, CloseWhenOpen);

   FileClose(hFile);
   
   return (true);
}

int init()
{
   LastTime = Time[0];
   symbol   = Symbol();
   ElementsCount = 0;
   CriticalError = false;
   
   if (LoadFromFile == 1)
   {
      LoadStrategyFromFile();
   }
   
   CreateSignal();

   return(0);
}

void ResultToString(string& s)
{
   switch (OptimizingCondition)
   {
      case 0:
      {
         s = (SignalToString(OpenCondition1Array));
         break;
      }
      case 1:
      {
         s = (SignalToString(OpenCondition2Array));
         break;
      }
      case 2:
      {
         s = (SignalToString(OpenCondition3Array));
         break;
      }
      case 3:
      {
         s = (SignalToString(CloseCondition1Array));
         break;
      }
      case 4:
      {
         s = (SignalToString(CloseCondition2Array));
         break;
      }
      case 5:
      {
         s = (SignalToString(CloseCondition3Array));
         break;
      }
   }
}

int deinit()
{
   string res;
   ResultToString(res);
   Print(res);
   
   switch (OptimizingCondition)
   {
      case 0: 
      {
         OpenCondition1 = res;
         break;
      }
      case 1:
      {
         OpenCondition2 = res;
         break;
      }
      case 2:
      {
         OpenCondition3 = res;
         break;
      }
      case 3:
      {
         CloseCondition1 = res;
         break;
      }
      case 4:
      {
         CloseCondition2 = res;
         break;
      }
      case 5:
      {
         CloseCondition3 = res;
         break;
      }
   }
   
   if (SaveToFile == 1) SaveStrategyToFile();
}

void Check()
{
   if (NeedCloseBuys)
   {
      CloseBuys(Magic, Slippage);
   }
   
   if (NeedCloseSells)
   {
      CloseSells(Magic, Slippage);
   }

   if (NeedOpenBuys)
   {
      if (CloseWhenOpen == 1)
      {
         CloseSells(Magic, Slippage);
      }

      if (GetOrdersCount(Magic) < MaxOrders || MaxOrders == 0)
      {
         OpenBuy(Magic, Target, Loss, TradeLots);
      }
   }
   
   if (NeedOpenSells)
   {
      if (CloseWhenOpen == 1)
      {
         CloseBuys(Magic, Slippage);
      }

      if (GetOrdersCount(Magic) < MaxOrders || MaxOrders == 0)
      {
         OpenSell(Magic, Target, Loss, TradeLots);
      }
   }
}

int start()
{
   if (CriticalError) return(0);
   if (!IsTradeAllowed()) return(0);
   
   if (LastTime == Time[0]) return(0);
   LastTime = Time[0];
   
   if ((ElementsCount == 0 && OptimizingCondition != -1) || ElementsCount > MaxElementsCount) return(0);
   
   double margin = AccountFreeMargin();
   double minBet = GetLotsToBid(0)*MarketInfo(symbol, MODE_MARGINREQUIRED);
   
   if (!GetActiveOrders(Magic) && minBet > margin)
   {
      CriticalError = true;
      return(0);
   }

   GetSignals();
   Check();

   return(0);
}