Navigation:Home > Content >

Katyxa_v1.mq4

Time: 2018-07-01 | Download file:Katyxa_v1.mq4

//+------------------------------------------------------------------+
//|                                                       Katyxa.mq4 |
//|                        Copyright 2016, MetaQuotes Software Corp. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+

#property copyright "Katyxa"
//#property link      "Katyxa"
#property version   "1.1"
//#property description "virtual stoploss"
#property strict

enum WORK_TIMEFRAME
{
   M5=5,
   M15=15,
   M30=30,
   H1=60,
   H4=240,
   D1=1440,
};

  WORK_TIMEFRAME work_tf=H1;
 string a3 = "------------------------------------";
input string a4 = " Money Management ";
input bool use_MM=true;
input double fix_lot=0.1;
input int Risk=5;
input double max_lot=100;
input bool closeFriday=true;
input int closeHour=20;
input int magic=111;
input string comment_order=" Katyxa";
input int MaxOrderTRADE = 100;
input int MaxOrderSTOP = 100;
input string a2 = "------------------------------------";
input string a1 = " Settings Spread Filter";
 bool use_spread_filter=true;
 int distance_check=70;
input int spread_max=20;
//-----------------
input string a5 = "------------------------------------";
 string a6 = " Settings Orders";
//input bool virtual_pending=false;
input int slipage=0;
 int indent_up=10;
 int indent_dn=10;
input int takeprofit=1000;
input bool virtual_sl=false;
input int stoploss=50;
input string a7 = "------------------------------------";
input string a8 = " Trailing Stop";
input int trailing=10;
input int trail_start=10;
input int step_tral=10;
input string a11 = "------------------------------------";
 string a12 = " Breakeven ";
 bool use_breakeven=false;
 int start_be=10;
 int lvl_be=5;


 string a9 = "------------------------------------";
 string a10 = "Max count orders on each side, 0-no limits";
 int limit_count=0;

////-----------------
bool new_bar_wait_buy=false;
bool new_bar_wait_sell=false;
double point;
int digits;
int count_pending=0;
int count_buy,count_sell;

//double maximal_lot;
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
{
   point=MarketInfo(Symbol(),MODE_POINT);
   digits=(int)MarketInfo(Symbol(),MODE_DIGITS);
   if(digits==2 || digits==4)
   {
      Print("EA work only with 5-digits symbols");
      return(INIT_FAILED);
   }   
   
  // if(virtual_pending && DayOfWeek()>0 && DayOfWeek()<6)
      //RealToVirtual();
   
 //  if(!virtual_pending && DayOfWeek()>0 && DayOfWeek()<6)
     // VirtualToReal();   
      
   return(INIT_SUCCEEDED);
}
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
//---
   
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void  OnTick()
{
   //if(virtual_pending && ObjectsTotal()>0) CheckVirtualOrders();
   if(!virtual_sl) TrailingStop();
   if(virtual_sl) TrailingVirtual();
   
      if(closeFriday && DayOfWeek()==5 && Hour()>=closeHour && count_pending>0)
      {
         CloseAllPending();
      }
      if(OrdersTotal()>0 && Hour()==0 && count_pending>0)
      {
         // удаляем старые дальние ордера
         DeleteOld();
      }
   
   //if(virtual_pending && OrdersTotal()>0) RealToVirtual();   
   //if(!virtual_pending && ObjectsTotal()>0) VirtualToReal(); 
   
   //--------------------------------------------------   
   if(NewBar(work_tf))
   {
      new_bar_wait_buy=false;
      new_bar_wait_sell=false;
   }
   
   double marga=CalcMargin(Autolot());
   if(marga>=AccountFreeMargin()) return;
   
   if(closeFriday && DayOfWeek()==5 && Hour()<21) Trading();
   else if(closeFriday && DayOfWeek()!=5) Trading();
   else if(!closeFriday) Trading();
}
//+------------------------------------------------------------------+


//+------------------------------------------------------------------+
//|            Проверка нового бара на старшем тф                    +                                  
//+------------------------------------------------------------------+
bool NewBar(int per)
{
  static datetime preTime;
  if(preTime == 0){preTime = iTime(Symbol(),per,0);}
  if(preTime < iTime(Symbol(),per,0))
  {
    preTime = iTime(Symbol(),per,0);
    return(true);
  }
return(false);
}



double GetMaxFractal()
{
   double max=0;
   HideTestIndicators(true);
   // ищем максимальный фрактал среди 24 свечей
   for(int i=2;i<25;i++)
   {
      double fractal=iFractals(Symbol(),work_tf,MODE_UPPER,i);
      if(fractal>0 && fractal>max)
         max=fractal;
   }
   HideTestIndicators(false);
   return(max);
}


double GetMinFractal()
{
   double min=0;
   HideTestIndicators(true);
   // ищем минимальный фрактал среди 24 свечей
   for(int i=2;i<25;i++)
   {
      double fractal=iFractals(Symbol(),work_tf,MODE_LOWER,i);
      if(fractal>0 && min==0)
         min=fractal;
      if(fractal>0 && min!=0 && fractal=AccountFreeMargin()) return(true);
   int ticket=-1;
   int error;
   double sl=0,tp=0;
   double open_price=0;
   bool result=false;
   //int stop;
   if(type=="buy")
   {
      current=MarketInfo(Symbol(),MODE_ASK);
      if(currentOrdersTotal())
         {
            open_price=price+indent_up*point;
            /*if(stoploss>0 && !virtual_sl) 
            {
               stop=MathMax(stoploss,stoplvl);
               sl=NormalizeDouble(open_price-stop*point,digits);
            }  */ 
           // if(takeprofit>0) tp=open_price+takeprofit*point;
            ticket=OrderSend(Symbol(),OP_BUYSTOP,lot,open_price,slipage,sl,tp,comment_order,magic,0);
            error=GetLastError();
            if(ticket<=0)
            {
               return(false);
            }
            else return(true);
            
         }
      }
   }
   
   if(type=="sell")
   {
      current=MarketInfo(Symbol(),MODE_BID);
      if(current>price+stoplvl*point)
      {
         if(CalcMargin(lot)OrdersTotal())
         {
            open_price=price-indent_dn*point;
            
            /*if(stoploss>0 && !virtual_sl) 
            {
               stop=MathMax(stoploss,stoplvl);
               sl=open_price+stop*point;
            }   
            if(takeprofit>0) tp=open_price-takeprofit*point;
            */
            
            ticket=OrderSend(Symbol(),OP_SELLSTOP,lot,open_price,slipage,sl,tp,comment_order,magic,0);
            error=GetLastError();
            if(ticket<=0)
            {
               return(false);
            }
            else return(true);
         }
      }
   }
   return(result);
}


double Autolot()
{
   double vol=fix_lot;
   if(!use_MM) return(fix_lot);
   else
   {
      double Free =AccountFreeMargin();
      double One_Lot =MarketInfo(Symbol(),MODE_MARGINREQUIRED);
      double Step =MarketInfo(Symbol(),MODE_LOTSTEP);
      double Min_Lot =MarketInfo(Symbol(),MODE_MINLOT);
      double Max_Lot =MarketInfo(Symbol(),MODE_MAXLOT);
      Max_Lot=MathMin(Max_Lot,max_lot);
      vol =MathFloor(Free*Risk/100/One_Lot/Step)*Step;
      if(volMax_Lot) vol=Max_Lot;

   } 
   return(vol);
}

void SetStopLoss(int ticket,double price)
{
   string name=IntegerToString(ticket);
   ObjectCreate(0,name,OBJ_HLINE,0,0,price);
   ObjectSetInteger(0,name,OBJPROP_COLOR,clrRed);
   ObjectSetInteger(0,name,OBJPROP_STYLE,STYLE_DASH);
}


void Trading()
{
   HideTestIndicators(true);
   
   int count_del;
   int count=0;
   
   if(!new_bar_wait_buy)
   {
      
      double fractal_up=0;
      double max_price=0;
      fractal_up=iFractals(Symbol(),work_tf,MODE_UPPER,2);
      if(fractal_up>0)
      {
         // если есть фрактал, ищем максимальный фрактал из 24 свечей
         max_price=GetMaxFractal();
         if(max_price!=0)
         {
            // проверим, есть ли отложенные ордера на этой свече в ту же сторону.
            if(!CheckOpenedPending(OP_BUYSTOP))
            {
               // ордеров нет
               // проверяем лимит ордеров. старые удаляем
               if(limit_count>0)
               {
                  count=CountBuySell(OP_BUY);
                  count_del=limit_count-count-1;
                  if(count_del<0)
                  {
                     count_del=count_del*(-1);
                     DeleteOrders(count_del-count_buy,OP_BUYSTOP); // удалить некоторое кол-во ордеров
                  }
               }
               if((count_buy0) || limit_count==0)
               {
                  // устанавливаем отложенный ордер
                  
                     if(PendingSetup("buy",max_price))
                        new_bar_wait_buy=true;
                 // } 
                  //
               }   
            }
         }
      }
   }
   
   if(!new_bar_wait_sell)
   {
      double fractal_dn=0;
      double min_price=0;
      fractal_dn=iFractals(Symbol(),work_tf,MODE_LOWER,2);
      if(fractal_dn>0)
      {
         // если есть фрактал, ищем максимальный фрактал из 24 свечей
         min_price=GetMinFractal();
         if(min_price!=0)
         {
            // проверим, есть ли отложенные ордера на этой свече в ту же сторону.
            if(!CheckOpenedPending(OP_SELLSTOP))
            {
               // ордеров нет
               // проверяем лимит ордеров. старые удаляем
               if(limit_count>0)
               {
                  count=CountBuySell(OP_SELL);
                  count_del=limit_count-count-1;
                  if(count_del<0)
                  {
                     count_del=count_del*(-1);
                     DeleteOrders(count_del-count_sell,OP_SELLSTOP); // удалить некоторое кол-во ордеров
                  }
               }
               if((count_sell0) || limit_count==0)
               {
                  // устанавливаем отложенный ордер
                  //if(!virtual_pending)
                 // {
                     if(PendingSetup("sell",min_price))
                        new_bar_wait_sell=true;
                 // }
                 //      
               }   
            }
         }
      }
   }
   HideTestIndicators(false);
}


bool CheckOpenedPending(int type)
{
   bool opened=false;
   // проверяем наличие отложенных ордеров на текущей свече
   for(int i=OrdersTotal()-1; i>=0; i--)
   {
      if(OrderSelect(i,SELECT_BY_POS))
      {
         if(OrderSymbol()==Symbol() && OrderMagicNumber()==magic && OrderType()==type && OrderComment()==comment_order)
         {
            if(type==OP_BUYSTOP)
            {
               if(OrderOpenTime()>=iTime(Symbol(),work_tf,0))
               {
                  // уже есть отложенный ордер
                  new_bar_wait_buy=true;
                  opened=true;
                  return(opened);
               }
            }
            
            if(type==OP_SELLSTOP)
            {
               if(OrderOpenTime()>=iTime(Symbol(),work_tf,0))
               {
                  // уже есть отложенный ордер
                  new_bar_wait_sell=true;
                  opened=true;
                  return(opened);
               }
            }
         }
      }
   }
   return(opened);
}

void CloseAllPending()
{
   bool res;
   int error;
   
   for(int i=OrdersTotal()-1; i>=0;i--)
   {  
      if(OrderSelect(i,SELECT_BY_POS)==true)
      {
         if(OrderSymbol()==Symbol() && OrderMagicNumber()==magic && OrderType()>1 && OrderComment()==comment_order)
         {
            int count=0;
            while(count<=10)
            {
               res=OrderDelete(OrderTicket(),clrViolet);
               error=GetLastError();
               if(error==0 || error==1) { count_pending--; break;}
               if (!((error == 4/* SERVER_BUSY */ 
                  || error == 137/* BROKER_BUSY */ 
                  || error == 146/* TRADE_CONTEXT_BUSY */ 
                  || error == 136/* OFF_QUOTES */))) break;
               Sleep(1000);
               count++;
            }
         }
      }
   }
}


void DeleteOld()
{
   
   bool res;
   int err;
   for(int i=0; i1 && OrderComment()==comment_order)
         {
            if(iBarShift(Symbol(),work_tf,OrderOpenTime())>=48)
            {
               res=OrderDelete(OrderTicket());
               err=GetLastError();
               if(res) count_pending--;
            }
         }
      }
   }      
}


void CheckMargin()
{
   bool res;
   int err;
   // удалим ордера, на которые не хватит маржи
   for(int i=OrdersTotal()-1; i>=0;i--)
   {
      if(OrderSelect(i,SELECT_BY_POS))
      {
         if(OrderSymbol()==Symbol() && OrderType()>1 && OrderMagicNumber()==magic && OrderComment()==comment_order)
         {
            if(AccountFreeMargin()<=CalcMargin(OrderLots()))
            {
               res=OrderDelete(OrderTicket());
               err=GetLastError();
            }   
         }
      }
   }
}

double CalcMargin(double volume)
{
   double required=MarketInfo(Symbol(),MODE_MARGINREQUIRED);
   double need_margin=required*volume;
   return(need_margin);
}



void TrailingStop()
{
   double new_sl;
   int stoplvl = (int)MarketInfo(Symbol(),MODE_STOPLEVEL);
   bool res;
   int error;
   count_pending=0;
   double tral;
   double level;
   int ticket=0;
  // double order_stop;
   double tp;
   
   for(int i=0;i0)
                  {
                     if(ObjectFind(IntegerToString(OrderTicket()))>-1)
                     {
                        new_sl=ObjectGetDouble(0,IntegerToString(OrderTicket()),OBJPROP_PRICE);
                        if(new_sl>0)
                        {
                           ObjectDelete(IntegerToString(OrderTicket()));
                        }
                     }
                     else
                        new_sl=ND(OrderOpenPrice()-MathMax(stoploss,stoplvl)*point - (Ask - Bid));
                        
                     if(OrderTakeProfit()==0) tp=ND(OrderOpenPrice()+takeprofit*point);
                     else tp = OrderTakeProfit();
                     	//Print("1");
                        res=OrderModify(OrderTicket(),OrderOpenPrice(),new_sl,tp,0);
                        error=GetLastError();
                        if(error==0 || error==1) continue;
                     
                  }
                  
                  // безубыток
                  RefreshRates();
                  if(use_breakeven && start_be!=0)
                  {
                     if(OrderStopLoss()=OrderOpenPrice())
                        {
                           new_sl=ND(OrderOpenPrice()+lvl_be*point);
                           if(ND(Bid-new_sl)>=ND(stoplvl*point))
                           {
                           		//Print("2");
                              res=OrderModify(OrderTicket(),OrderOpenPrice(),new_sl,OrderTakeProfit(),0,clrNONE);
                              error=GetLastError();
                              if(error==0 || error==1) continue;
                           }   
                        }
                     }
                  }
                  
                  RefreshRates();
                  if((use_breakeven && OrderStopLoss()>=OrderOpenPrice()) || !use_breakeven)
                  {
                     if(Bid-OrderOpenPrice()>=trail_start*Point)
                     {
                        tral=MathMax(trailing,stoplvl);
                        if(ND(Bid-tral*point)>=OrderStopLoss())
                        {
                           new_sl=ND(OrderStopLoss()+step_tral*point);
                           if(step_tral==0) new_sl=ND(OrderStopLoss()+1*point);
                           if(new_sl>OrderStopLoss() && Bid-new_sl>=stoplvl*point)
                           {
                           		//Print(3);
                              res=OrderModify(OrderTicket(),OrderOpenPrice(),new_sl,OrderTakeProfit(),0,clrNONE);
                              error=GetLastError();
                              if(res)
                                 if(error==0 || error==1) continue;
                           }   
                        }
                     }
                  }
            }
            //*****************************
            if(OrderType()==OP_SELL)
            {
                  
                  if(OrderStopLoss()==0 && stoploss>0)
                  {
                     if(ObjectFind(IntegerToString(OrderTicket()))>-1)
                     {
                        new_sl=ObjectGetDouble(0,IntegerToString(OrderTicket()),OBJPROP_PRICE);
                        if(new_sl>0)
                        {
                           ObjectDelete(IntegerToString(OrderTicket()));
                        }
                     }
                     else
                        new_sl=ND(OrderOpenPrice()+MathMax(stoploss,stoplvl)*point) + (Ask - Bid);
                        
                     if(OrderTakeProfit()==0) tp=ND(OrderOpenPrice()-takeprofit*point);
                     else tp = OrderTakeProfit();
                     //Print(4);
                     	  	res=OrderModify(OrderTicket(),OrderOpenPrice(),new_sl,tp,0);
                        	error=GetLastError();
                        if(error==0 || error==1) continue;
                     
                  }
                  
                  
                  // безубыток
                  RefreshRates();
                  if(use_breakeven && start_be>0)
                  {
                     if(OrderStopLoss()>OrderOpenPrice() || OrderStopLoss()==0)
                     {
                        level=ND(Ask+start_be*point);
                        if(level<=OrderOpenPrice())
                        {
                           new_sl=ND(OrderOpenPrice()-lvl_be*point);
                           if(ND(new_sl-Ask)>=ND(stoplvl*point) && new_sl=trail_start*point)
                     {
                        tral=MathMax(trailing,stoplvl);
                        if(ND(Ask+tral*point)<=OrderStopLoss())
                        {
                           new_sl=ND(OrderStopLoss()-step_tral*point);
                           //if(step_tral==0) new_sl=ND(OrderStopLoss()+1*point);
                           if(step_tral==0) new_sl=ND(OrderStopLoss()-1*point);
                           if(new_sl=stoplvl*point)
                           {
                           		//Print("6");
                              res=OrderModify(OrderTicket(),OrderOpenPrice(),new_sl,OrderTakeProfit(),0,clrNONE);
                              error=GetLastError();
                              if(res)
                                 if(error==0 || error==1) continue;
                           }   
                        }
                     }
                  } 
            }
            //****************************
            if(OrderType()>1)
            {
               count_pending++;
               // проверка на достаточность денег
               if(CalcMargin(OrderLots())>=AccountFreeMargin())
               {
                  res=OrderDelete(OrderTicket());
                  error=GetLastError();
               }  
               
               // spread filter
               if(use_spread_filter)
               {
                  if(OrderType()==OP_BUYSTOP)
                  {
                     RefreshRates();
                     if(OrderOpenPrice()-Bid<=distance_check*point && MarketInfo(Symbol(),MODE_SPREAD)>spread_max)
                     {
                        res=OrderDelete(OrderTicket(),clrYellow);
                        error=GetLastError();
                        if(res)
                        {
                           Print("Order BUYSTOP deleted! Spread too high!");
                           
                        }
                     }
                  }
                  
                  if(OrderType()==OP_SELLSTOP)
                  {
                     RefreshRates();
                     if(Ask-OrderOpenPrice()<=distance_check*point && MarketInfo(Symbol(),MODE_SPREAD)>spread_max)
                     {
                        res=OrderDelete(OrderTicket(),clrYellow);
                        error=GetLastError();
                        if(res)
                        {
                           Print("Order SELLSTOP deleted! Spread too high!");
                           
                        }
                     }
                  }
                  
               }
            }   
         }
      }
   }
}


double ND(double value)
{
   return NormalizeDouble(value,digits);
}

int CountBuySell(int type)
{
   int count=0;
   count_buy=0;
   count_sell=0;
   for(int i=0;i1)
         {
            int ticket=OrderTicket();
            int type=OrderType();
            double volume=OrderLots();
            double price=OrderOpenPrice();
            datetime time_open=OrderOpenTime();
            // удаляем реальный отложенник
            if(!OrderDelete(ticket))
            {
            	Print("Ошибка удаления ордера #", GetLastError());
            }
            SetVirtualOrder(price,type,time_open,volume);
         }
      }
   }      
}


void VirtualToReal()
{
   int total=ObjectsTotal();
   int opened=0;
   for(int i=0;i=0)
      {
         // наш "ордер"
         // раскидываем по кусочкам
         string sep=","; // разделитель
         ushort u_sep; // код разделителя
         string result[]; // массив данных ордера
         u_sep=StringGetCharacter(sep,0);
         StringSplit(name,u_sep,result); // разбили
         // извлекаем данные из массива
         int type=StrToInteger(result[1]);
         //double price=StrToDouble(result[2]);
         double lot=StrToDouble(result[2]);
         int mag=StrToInteger(result[3]);
         string comment=result[4];
         datetime timebar=StrToTime(result[5]);
         
         // если наш ордер
         if(mag==magic && comment==comment_order)
         {
            double price=ObjectGetDouble(0,name,OBJPROP_PRICE);
            if(type==OP_BUYSTOP && AskOrdersTotal())
            {
               if(OrderSend(Symbol(),OP_BUYSTOP,lot,price,0,0,0,comment_order,magic,0))
               	ObjectDelete(name);
            }
            
            if(type==OP_SELLSTOP && Bid>price && CalcMargin(lot)OrdersTotal())
            {
               if(OrderSend(Symbol(),OP_SELLSTOP,lot,price,0,0,0,comment_order,magic,0))
               	ObjectDelete(name);
            }
         }
      }
   }      
}


void TrailingVirtual()
{
   int total=OrdersTotal();
   bool res;
   int error;
   double sl=0;
   double tp=0;
   double new_sl=0;
   string ticket_list="";
   for(int i=total-1;i>=0;i--)
   {
      if(!OrderSelect(i,SELECT_BY_POS)) continue;
      
      if(OrderSymbol()==Symbol() && OrderMagicNumber()==magic && OrderComment()==comment_order)
      {
         int ticket=OrderTicket();
         if(OrderType()==OP_BUY)
         {
            // если есть реальный сл - виртуалим
            if(OrderStopLoss()!=0)
            {
               SetStopLoss(ticket,OrderStopLoss());
               res=OrderModify(ticket,OrderOpenPrice(),0,OrderTakeProfit(),0);
               error=GetLastError();
            }
            if(OrderTakeProfit()==0 && takeprofit>0)
            {
               tp=ND(OrderOpenPrice()+takeprofit*point);
               res=OrderModify(ticket,OrderOpenPrice(),OrderStopLoss(),tp,0);
               error=GetLastError();
            }
            // если нет виртуального сл
            if(ObjectFind(IntegerToString(ticket))==-1 && stoploss>0)
            {
               sl=ND(OrderOpenPrice()-stoploss*point);
               SetStopLoss(ticket,sl);
            }
            // виртуальный стоплосс =
            sl=ObjectGetDouble(0,IntegerToString(ticket),OBJPROP_PRICE);
            
            // проверка на лося
            RefreshRates();
            if(sl>0 && Bid<=sl)
            {
               res=ClosePos(ticket);
               if(res) ObjectDelete(IntegerToString(ticket));
               continue;
            }
            
            // безубыток
            if(use_breakeven && (sl0)
            {
               if(Bid-start_be*point>=OrderOpenPrice())
               {
                  new_sl=ND(OrderOpenPrice()+lvl_be*point);
                  ObjectSetDouble(0,IntegerToString(ticket),OBJPROP_PRICE,new_sl);
               }
            }
            
            // трейлинг
            RefreshRates();
            // виртуальный стоплосс =
            sl=ObjectGetDouble(0,IntegerToString(ticket),OBJPROP_PRICE);
            if((use_breakeven && sl>=OrderOpenPrice()) || !use_breakeven)
            {
               if(trailing>0)
               {
                  if(Bid-OrderOpenPrice()>=trail_start*point)
                  {
                     //if(sl==0) sl=OrderOpenPrice();
                     if(ND(Bid-trailing*point)>=sl)
                     {
                        new_sl=ND(sl+step_tral*point);
                        if(step_tral==0) new_sl=ND(sl+1*point);
                        if(new_sl>sl)
                        {
                           ObjectSetDouble(0,IntegerToString(ticket),OBJPROP_PRICE,new_sl);
                        }   
                     }
                  }
               }
            }
            ticket_list=ticket_list+","+IntegerToString(ticket);
         }
         
         if(OrderType()==OP_SELL)
         {
            // если есть реальный сл - виртуалим
            if(OrderStopLoss()!=0)
            {
               SetStopLoss(ticket,OrderStopLoss());
               res=OrderModify(ticket,OrderOpenPrice(),0,OrderTakeProfit(),0);
               error=GetLastError();
            }
            // если нет виртуального сл
            if(ObjectFind(IntegerToString(ticket))==-1 && stoploss>0)
            {
               sl=ND(OrderOpenPrice()+stoploss*point);
               SetStopLoss(ticket,sl);
            }
            if(OrderTakeProfit()==0 && takeprofit>0)
            {
               tp=ND(OrderOpenPrice()-takeprofit*point);
               res=OrderModify(ticket,OrderOpenPrice(),OrderStopLoss(),tp,0);
               error=GetLastError();
            }
            // виртуальный стоплосс =
            sl=ObjectGetDouble(0,IntegerToString(ticket),OBJPROP_PRICE);
            
            // проверка на лося
            RefreshRates();
            if(sl>0 && Ask>=sl)
            {
               res=ClosePos(ticket);
               if(res) ObjectDelete(IntegerToString(ticket));
               continue;
            }
            
            // безубыток
            if(use_breakeven && (sl>OrderOpenPrice() || sl==0) && start_be>0)
            {
               if(Ask+start_be*point<=OrderOpenPrice())
               {
                  new_sl=ND(OrderOpenPrice()-lvl_be*point);
                  ObjectSetDouble(0,IntegerToString(ticket),OBJPROP_PRICE,new_sl);
               }
            }
            
            // трейлинг
            RefreshRates();
            // виртуальный стоплосс =
            sl=ObjectGetDouble(0,IntegerToString(ticket),OBJPROP_PRICE);
            if((use_breakeven && sl<=OrderOpenPrice()) || !use_breakeven)
            {
               if(trailing>0)
               {
                  if(OrderOpenPrice()-Ask>=trail_start*point)
                  {
                     //if(sl==0) sl=OrderOpenPrice();
                     if(ND(Ask+trailing*point)<=sl)
                     {
                        new_sl=ND(sl-step_tral*point);
                        if(step_tral==0) new_sl=ND(sl-1*point);
                        if(new_sl1)
            {
               count_pending++;
               // проверка на достаточность денег
               if(CalcMargin(OrderLots())>=AccountFreeMargin())
               {
                  res=OrderDelete(OrderTicket());
                  error=GetLastError();
               }  
               
               // spread filter
               if(use_spread_filter)
               {
                  if(OrderType()==OP_BUYSTOP)
                  {
                     RefreshRates();
                     if(OrderOpenPrice()-Bid<=distance_check*point && MarketInfo(Symbol(),MODE_SPREAD)>spread_max)
                     {
                        res=OrderDelete(OrderTicket(),clrNONE);
                        error=GetLastError();
                        if(res)
                        {
                           Print("Order BUYSTOP deleted! Spread too high!");
                           
                        }
                     }
                  }
                  
                  if(OrderType()==OP_SELLSTOP)
                  {
                     RefreshRates();
                     if(Ask-OrderOpenPrice()<=distance_check*point && MarketInfo(Symbol(),MODE_SPREAD)>spread_max)
                     {
                        res=OrderDelete(OrderTicket(),clrNONE);
                        error=GetLastError();
                        if(res)
                        {
                           Print("Order SELLSTOP deleted! Spread too high!");
                           
                        }
                     }
                  }
                  
               }
            }
            //***********************************
            
            
      }
   } 
   // удаляем лишние объекты
   if(ticket_list!="")
   {
      int obj=ObjectsTotal();
      for(int i=0;i=0)
      {
         // наш "ордер"
         // раскидываем по кусочкам
         string sep=","; // разделитель
         ushort u_sep; // код разделителя
         string result[]; // массив данных ордера
         u_sep=StringGetCharacter(sep,0);
         StringSplit(name,u_sep,result); // разбили
         // извлекаем данные из массива
         int type=StrToInteger(result[1]);
         //double price=StrToDouble(result[2]);
         double lot=StrToDouble(result[2]);
         int mag=StrToInteger(result[3]);
         string comment=result[4];
         datetime timebar=StrToTime(result[5]);
         
         // если наш ордер
         if(mag==magic && comment==comment_order)
         {
            double price=ObjectGetDouble(0,name,OBJPROP_PRICE);
         
            // проверяем по цене и типу ордеров
            if(type==OP_BUYSTOP)
            {
               RefreshRates();
               if(Ask>=price && Ask-price<=15*point && Spread()0) || limit_count==0))
               {
                  OpenPos(OP_BUY,lot);
                  opened++;
                  ObjectDelete(name);
                  continue;
               }
               else if(Ask>=price && Ask-price>15*point)
               { 
                  ObjectDelete(name);
                  continue;
               } 
               else if(Spread()>=spread_max) 
               { 
                  ObjectDelete(name);
                  continue;
               }
               else if(opened>=limit_count && limit_count>0) 
               { 
                  ObjectDelete(name);
                  continue;
               }
               
            }
            
            if(type==OP_SELLSTOP)
            {
               RefreshRates();
               if(Bid<=price  && price-Bid<=15*point && Spread()0) || limit_count==0))
               {
                  OpenPos(OP_SELL,lot);
                  opened++;
                  ObjectDelete(name);
                  continue;
               }
                
               else if(Spread()>=spread_max) 
               { 
                  ObjectDelete(name);
                  continue;
               }
               else if(opened>=limit_count && limit_count>0)
               {
                  ObjectDelete(name);
                  continue;
               }
               else if(Bid<=price  && price-Bid>15*point)
               {
                  ObjectDelete(name);
                  continue;
               }
            }
         
            // удаляем старый
            if(Hour()==0 && iBarShift(Symbol(),Period(),timebar)>=48)
            {
               ObjectDelete(name);
               continue;
            }
            // удаляем в пятницу
            if(closeFriday && DayOfWeek()==5 && Hour()>=closeHour)
            {
               ObjectDelete(name);
            }
            
         }
      }
   }
}

int Spread()
{
   return((int)MarketInfo(Symbol(),MODE_SPREAD));
}


void OpenPos(int type,double lot)
{
   int ticket;
   int error;
   double sl=0,tp=0;
   
   if(type==OP_BUY && MaxOrderTRADE>OrdersTotal())
   {
      RefreshRates();
      if(stoploss>0 && !virtual_sl) sl=Ask-stoploss*point;
      if(takeprofit>0) tp=Ask+takeprofit*point;
      
      ticket=OrderSend(Symbol(),OP_BUY,lot,Ask,slipage,sl,tp,comment_order,magic,0);
      error=GetLastError();
      if(ticket>0 && virtual_sl)
      {
         if(OrderSelect(ticket,SELECT_BY_TICKET))
         {
            sl=OrderOpenPrice()-stoploss*point;
            SetStopLoss(ticket,sl);
         }
      }
      error=GetLastError();
   }
   
   if(type==OP_SELL && MaxOrderTRADE>OrdersTotal())
   {
      RefreshRates();
      if(stoploss>0 && !virtual_sl) sl=Bid+stoploss*point;
      if(takeprofit>0) tp=Bid-takeprofit*point;
      ticket=OrderSend(Symbol(),OP_SELL,lot,Bid,slipage,sl,tp,comment_order,magic,0);
      error=GetLastError();
      if(ticket>0 && virtual_sl)
      {
         if(OrderSelect(ticket,SELECT_BY_TICKET))
         {
            sl=OrderOpenPrice()+stoploss*Point;
            SetStopLoss(ticket,sl);
         }
      }
      error=GetLastError();
   }
}

Recommend