<code>//+------------------------------------------------------------------+
//|                                                 Asia Session KAE |
//+------------------------------------------------------------------+
#property description "Asia Session KAE"
#property version   "1.00"
#property strict

extern string s0 = "<== General Settings ==>"; //>  >  >
extern double  Lot                  = 0.01;
extern double  LotK                  =1.8;  
extern int     Slippage             = 30;
extern int     StopLoss             = 349;
extern int     TakeProfit           = 103;
extern int     MagicNumber          = 1961;
extern double  MaxSpread            = 30;

extern string s1 = "<== Stochastic Settings ==>"; //>  >  >
extern int     StohLevel            = 92;
extern int     InpKPeriod           = 5;   // K Period
extern int     InpDPeriod           = 5;    // D Period
extern int     InpSlowing           = 3;    // Slowing

extern string s2 = "<== Breakeven ==>"; //>  >  >
extern double  SetBEDistance        = 66;   // BU Distance % 
extern int     BE_Step              = 1;   // BU Step pips

extern string s3 = "<== Time Settings ==>"; //>  >  >
extern int     GMT_Offset           = 2;    //GMT Offset
extern int     Start_Trade_Hour     = 23;   //Start Trade Hour
extern int     Start_Trade_Minute   = 0;    //Start Trade Minute
extern int     End_Trade_Hour       = 8;    //End Trade Hour
extern int     End_Trade_Minute     = 0;    //End Trade Minute 

datetime StartTime, EndTime;
datetime Update_Time  = 0;
int day_of_year_trade = 0;
double Stoh           = 0;
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit() 
{
   return(INIT_SUCCEEDED);  
}
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick() 
{
   if (day_of_year_trade != DayOfYear()) 
      {
      day_of_year_trade = DayOfYear();
      
      datetime _CurrentDate = StrToTime(TimeToStr(TimeCurrent(),TIME_DATE));//??????????????

      StartTime =_CurrentDate+Start_Trade_Hour*60*60+Start_Trade_Minute*60+GMT_Offset*60*60;
      EndTime = _CurrentDate+End_Trade_Hour*60*60+End_Trade_Minute*60+GMT_Offset*60*60;
      }
   
   //модификация открытых ордеров
   int cnt_b = 0, cnt_s = 0;
   int _OrdersTotal = OrdersTotal();
   
   for(int pos = _OrdersTotal - 1; pos >= 0; pos--)  //цикл по всем открытым ордерам
      {
      if(!OrderSelect(pos, SELECT_BY_POS, MODE_TRADES))  //выделение ордера для получения его данных
		   Print(" не удалось выделить ордер! " , GetLastError());   
      else 
         if(OrderType() <= 2 && OrderSymbol() == Symbol() && OrderMagicNumber() == MagicNumber) //проверка, чтобы ордер относился в нашему советнику
            { 
            if(OrderType() == OP_BUY) 
               cnt_b++; //подсчет ордеров на покупку
            else 
               cnt_s++; //подсчет ордеров на продажу
            
            if(SetBEDistance > 0) //проверка для перевода в БУ 
               CheckBE(OrderType());                                               
            
            if(OrderTakeProfit() == 0 || OrderStopLoss() == 0)  //если у ордера нет одной из целей - модификация
               {
               double SL = 0, TP = 0;
               
               if(OrderType() == OP_BUY)  //определение целей текущего ордера
                  {
                  SL = OrderOpenPrice()-StopLoss*Point;
                  TP = OrderOpenPrice()+TakeProfit*Point;
                  }
               else 
                  {
                  SL = OrderOpenPrice()+StopLoss*Point;
                  TP = OrderOpenPrice()-TakeProfit*Point;
                  }
               if(!OrderModify(OrderTicket(), OrderOpenPrice(), SL, TP, 0, clrNONE))  //модификация ордера
                  {
                  int Error = GetLastError();
                  Print("Ошибка модификации ордера ", GetLastError()); //принт от ошибки модификации
                  }
               else 
                  Print("Ордер #" + IntegerToString(OrderTicket()) + " успешно модифицирован");
               }
            }      
      }         
      //--- end for
</code>

bool _IsTime = IsTime(); //узнаем, подходит ли текущее время для торговли
   
   if(Update_Time != iTime(NULL,0,0) && _IsTime) //обновлять данные всех индикаторов   раз в период   //   < ???
      { 
      Update_Time = iTime(NULL,0,0); //перезаписываем значение переменной для хранения времени текущей свечи
      //импорт данных индикатора Stochastic для предыдущей свечи [1]
      Stoh = iStochastic(NULL,0,InpKPeriod,InpDPeriod,InpSlowing,MODE_SMA,1,MODE_MAIN,1);
      }
   if(_IsTime) 
      {
      if(cnt_b == 0 && Stoh < 100-StohLevel)   //условие для открытия ордера на покупку
         OpenTrade(OP_BUY);                    //открытие ордера на покупку
      if(cnt_s == 0 && Stoh > StohLevel)       //условие для открытия ордера на продажу
         OpenTrade(OP_SELL);                   //открытие ордера на продажу
      }   
   int Error = GetLastError(); //поиск ошибок по завершению тика
   if(Error != 0) Print("OnTick() Error ", GetLastError());   
}
//+------------------------------------------------------------------+
bool OpenTrade(int OP_Type)  //функция для открытия рыночного ордера  
{   
   if(MaxSpread > 0 && (Ask - Bid) > MaxSpread*Point) 
      return(false);     
   
   double price    = (OP_Type == OP_BUY ? Ask : Bid);                   //определение цены для открытия рыночного ордера
   color  col_type = (OP_Type == OP_BUY ? clrBlue : clrRed);            //определение цвета стрелки ордера
   string op_str   = (OP_Type == OP_BUY ? "на покупку" : "на продажу"); //определение текста для принта
   double lot      = getLastCloseLot (OP_Type);
   
   int ticket = OrderSend(Symbol(), OP_Type, lot, price, Slippage, 0, 0, "", MagicNumber, 0, col_type); //открытие ордера
   if(ticket > 0)  //Если ордер был открыт
      {
      Print("Ордер #",IntegerToString(ticket)," успешно открыт");
      return(true);
      }
   else  //при ошибке открытия ордера
      {
      int Error = GetLastError();
      Update_Time = 0;
      Print("Ошибка открытия ордера ", GetLastError());
      }
   return(false);
}
//+------------------------------------------------------------------+
bool IsTime() //проверка разрешенного времени для торговли 
{
   datetime _TimeCurrent = TimeCurrent();
   
   if(StartTime > EndTime) 
      if ((_TimeCurrent >= StartTime && _TimeCurrent < EndTime+60*60*60*24) || (_TimeCurrent >= StartTime-60*60*60*24 && _TimeCurrent < EndTime)) 
         return(true);
   else 
      if(StartTime < EndTime) 
         if (_TimeCurrent >= StartTime && _TimeCurrent < EndTime)  
            return(true);
   return(false);
}
//+------------------------------------------------------------------+
void CheckBE(int OP_Type)  //проверка для перевода ордеров в безубыток
{   
      if(OP_Type == OP_BUY)  //если ордер на покупку
         {
         double NewSL = NormalizeDouble(OrderOpenPrice()+BE_Step*Point,Digits);
         
         if(OrderStopLoss() < NewSL)  //если СЛ еще не был перенесен
            {
            if((Bid - OrderOpenPrice()) >= TakeProfit*SetBEDistance/100*Point && NewSL != OrderStopLoss()) 
               {
               if(!OrderModify(OrderTicket(), OrderOpenPrice(), NewSL, OrderTakeProfit(), 0, clrNONE))  //модификация ордера
                  {
                  int Error = GetLastError();
                  Print("Ошибка модификации ордера ", GetLastError()); //принт от ошибки модификации
                  }
               else 
                  Print("Перевод ордера на покупку в Безубыток с отступом " + IntegerToString(BE_Step) + " пунктов.");
               }
            }
         }
      //---
      else 
         if(OP_Type == OP_SELL)  //если ордер на продажу
            {
            double NewSL = NormalizeDouble(OrderOpenPrice()-BE_Step*Point,Digits);
            
            if(OrderStopLoss() > NewSL)  //если СЛ еще не был перенесен
               {
               if((OrderOpenPrice() - Ask) >= TakeProfit*SetBEDistance/100*Point && NewSL != OrderStopLoss()) 
                  {
                  if(!OrderModify(OrderTicket(), OrderOpenPrice(), NewSL, OrderTakeProfit(), 0, clrNONE))  //модификация ордера
                     {
                     int Error = GetLastError();
                     Print("Ошибка модификации ордера ", GetLastError()); //принт от ошибки модификации
                     }
                  else 
                     Print("Перевод ордера на продажу в Безубыток с отступом " + IntegerToString(BE_Step) + " пунктов.");
                  }
               }
            }   
}
//+------------------------------------------------------------------+
double getLastCloseLot (int o_type)
{
      double   lot    = 0;
      double   prof_B = 0;
      double   prof_S = 0;
      int      type   =-1;
      datetime time   = 0;
      
      for(int pos = OrdersHistoryTotal() - 1; pos >= 0; pos--)                 //цикл по всем закрытым ордерам
         if(OrderSelect(pos, SELECT_BY_POS, MODE_HISTORY))                     //выделение закрытого ордера для получения его данных
            if(OrderSymbol() == Symbol() && OrderMagicNumber() == MagicNumber) //проверка, чтобы ордер относился в нашему советнику
               {
               if(OrderType()==OP_BUY)
                  if (time<OrderCloseTime())
                     {
                     time   = OrderCloseTime();
                     prof_B = OrderProfit();
                     lot    = OrderLots();
                     }
               if(OrderType()==OP_SELL)
                  if (time<OrderCloseTime())
                     {
                     time   = OrderCloseTime();
                     prof_S = OrderProfit();
                     lot    = OrderLots();
                     }
               } 
      if(o_type == OP_SELL)
         {
         if((prof_B == 0 && time == 0)|| prof_B>0)
            lot = Lot;
         else
            lot = MathCeil(lot*100*LotK)/100;
         }
      //---  
      if(o_type == OP_BUY)
         {
         if((prof_S == 0 && time == 0)|| prof_S>0)
            lot = Lot;
         else
            lot = MathCeil(lot*100*LotK)/100;
         }  
          
   return (NormalizeDouble(lot,2));
}
//+------------------------------------------------------------------+

<code>//---
   green_value<<=8;
   blue_value<<=16;
   return(red_value+green_value+blue_value);
  }
//+------------------------------------------------------------------+
//| right comparison of 2 doubles                                    |
//+------------------------------------------------------------------+
bool CompareDoubles(double number1,double number2)
  {
   if(NormalizeDouble(number1-number2,8)==0) return(true);
   else return(false);
  }
//+------------------------------------------------------------------+
//| up to 16 digits after decimal point                              |
//+------------------------------------------------------------------+
string DoubleToStrMorePrecision(double number,int precision)
  {
   static double DecimalArray[17]=
     {
      1.0,
      10.0,
      100.0,
      1000.0,
      10000.0,
      100000.0,
      1000000.0,
      10000000.0,
      100000000.0,
      1000000000.0,
      10000000000.0,
      100000000000.0,
      1000000000000.0,
      10000000000000.0,
      100000000000000.0,
      1000000000000000.0,
      10000000000000000.0
     };

   double rem,integer,integer2;
   string intstring,remstring,retstring;
   bool   isnegative=false;
   int    rem2;
//---
   if(precision<0)  precision=0;
   if(precision>16) precision=16;
//---
   double p=DecimalArray[precision];
   if(number<0.0)
     {
      isnegative=true;
      number=-number;
     }
   integer=MathFloor(number);
   rem=MathRound((number-integer)*p);
   remstring="";
   for(int i=0; i<precision; i++)
     {
      integer2=MathFloor(rem/10);
      rem2=(int)NormalizeDouble(rem-integer2*10,0);
      remstring=IntegerToString(rem2)+remstring;
      rem=integer2;
     }
//---
   intstring=DoubleToStr(integer,0);
   if(isnegative)
      retstring="-"+intstring;
   else
      retstring=intstring;

   if(precision>0)
      retstring=retstring+"."+remstring;
//---
   return(retstring);
  }
//+------------------------------------------------------------------+
//| convert integer to string contained input's hexadecimal notation |
//+------------------------------------------------------------------+
string IntegerToHexString(int integer_number)
  {
   string hex_string="00000000";
   int    value,shift=28;
//---
   for(int i=0; i<8; i++)
     {
      value=(integer_number>>shift)&0x0F;
      if(value<10)
         hex_string=StringSetChar(hex_string,i,ushort(value+'0'));
      else
         hex_string=StringSetChar(hex_string,i,ushort((value-10)+'A'));
      shift-=4;
     }
//---
   return(hex_string);
  }
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
//|                                                       stdlib.mq4 |
//|                   Copyright 2005-2015, MetaQuotes Software Corp. |
//|                                              http://www.mql4.com |
//+------------------------------------------------------------------+
#property copyright "2005-2015, MetaQuotes Software Corp."
#property link      "http://www.mql4.com"
#property library
//+------------------------------------------------------------------+
//| return error description                                         |
//+------------------------------------------------------------------+
string ErrorDescription(int error_code)
  {
   string error_string;

</code>