Unlocker EA

#property version   "1.00"
#property strict

#define POINTS_NEW

#include <sovetnikovGUI\Orders.mqh>
#include <sovetnikovGUI\Button.mqh>
#include <sovetnikovGUI\Time.mqh>

#define LICENSE_OFF

#define LICENSE_NAME "3v36oizf4y1nhrzysgwpb6w#08g$3v34"
#define LICENSE_FILE "unlocker"

#define VALID_KEY "Советник активен"
#define EMPTY_KEY "Необходимо активировать советник."
#define INVALID_KEY "Неверная лицензия."
#define EXPERIED "Лицензия истекла "

TF tf=PERIOD_M5; //Таймфрейм
D LockDD=500; //Убыток для активации лок
D Delta=1; //Минимальный профит
D HighLowOffset=10; //Отступ от хай\лоу
D PendingOffset=300; //Трал отложки (0 - выкл)
D FreeMargin=0; //Свободная маржа (0 - выкл)
I LockMagic=2020; //Меджик для лок ордера
C TextColor=clrBlack; //Цвет текста

class CMyOrders: public COrders
  {
public:

   void              MovePending(long iLockMagic,double dPending_MinOffset)
     {

      if(dPending_MinOffset==0)
         return;

      Magic(iLockMagic);

      double dOpen=0,dNewOpen=0;
      long tbuy=getOrderTicket(OP_BUYSTOP);

      if(OrderSelect(tbuy))
        {
         dOpen=OrderOpenPrice();
         dNewOpen=Ask(m_name)+dPending_MinOffset*p;
         if(dOpen>dNewOpen)
           {
            OrderModify(tbuy,dNewOpen,0,0);
           }
        }

      long tsell=getOrderTicket(OP_SELLSTOP);

      if(OrderSelect(tsell))
        {

         dOpen=OrderOpenPrice();
         dNewOpen=Bid(m_name)-dPending_MinOffset*p;

         if(dOpen<dNewOpen)
           {

            OrderModify(tsell,dNewOpen,0,0);
           }
        }

      Magic(-1);
     }

   bool              Stabilization(long iLockMagic,int iop,double dPending_MinOffset, double dMinProfit)
     {

      double array_order_buy[][4];
      double array_order_sell[][4];

      ArrayResize(array_order_buy,0);
      ArrayResize(array_order_sell,0);

      int cb=0,cs=0;
      double dbuyprofit=0,dsellprofit=0;

      for(int i=ArraySize(m_orders)-1; i>=0; i--)
        {
         if(m_orders[i].OrderCloseTime>0)
            continue;

         if(CheckMagic(m_orders[i].OrderMagicNumber,m_orders[i].OrderComment) && CheckSymbol(m_orders[i].OrderSymbol))
           {

            if(m_orders[i].OrderType==OP_BUY)
              {
               if(ArrayResize(array_order_buy,cb+1)!=-1)
                 {
                  array_order_buy[cb][0]=m_orders[i].OrderOpenPrice;
                  array_order_buy[cb][1]=(double)m_orders[i].OrderTicket;
                  array_order_buy[cb][2]=m_orders[i].OrderLots;
                  array_order_buy[cb][3]=m_orders[i].Profit;

                  if(array_order_buy[cb][3]>0)
                    {
                     dbuyprofit+=array_order_buy[cb][3];
                    }

                  cb++;
                 }
              }

            if(m_orders[i].OrderType==OP_SELL)
              {
               if(ArrayResize(array_order_sell,cs+1)!=-1)
                 {
                  array_order_sell[cs][0]=m_orders[i].OrderOpenPrice;
                  array_order_sell[cs][1]=(double)m_orders[i].OrderTicket;
                  array_order_sell[cs][2]=m_orders[i].OrderLots;
                  array_order_sell[cs][3]=m_orders[i].Profit;

                  if(array_order_sell[cs][3]>0)
                    {
                     dsellprofit+=array_order_sell[cs][3];
                    }
                  cs++;
                 }
              }
           }

        }

      double dlotstep=MarketInfo(_Symbol,MODE_LOTSTEP);

      int ibuystop=Count(OP_BUYSTOP,iLockMagic);
      int isellstop=Count(OP_SELLSTOP,iLockMagic);

      if(dbuyprofit-dMinProfit>dsellprofit && dbuyprofit>dMinProfit && cs>0 && iop==OP_BUY && ibuystop+isellstop==0)
        {
         dbuyprofit-=dMinProfit;//уменьшаем на гарантированный профит
         ArraySort(array_order_sell,WHOLE_ARRAY,0,MODE_ASCEND); //в сторону уветчения, нижний селл самый нижний

         bool bclose=false;

         for(int i=0; i<cs; i++)
           {
            double dprofit=array_order_sell[i][3];

            if(dprofit<0)
              {

               double dlot=array_order_sell[i][2];
               double dminuslot=NormalizeDouble(dprofit*dlotstep/dlot,2); //рассчитаем профит на минимальный шаг лота
               int imaxlots=(int)(dlot/dlotstep); //рассчитаем профит на минимальный шаг лота
               double dlotpart=0;
               if(dminuslot<0)
                 {

                  for(int j=0; j<imaxlots; j++)
                    {
                     if(dbuyprofit+dminuslot>=0)
                       {
                        dlotpart+=dlotstep;
                        dbuyprofit+=dminuslot;
                       }
                     else
                       {
                        break;
                       }
                    }

                  if(dlotpart>0)
                    {
                     PrintFormat("Close sell part lot: %.2f minus: %.2f",dlotpart,dminuslot);
                     OrderClose((long)array_order_sell[i][1],dlotpart);
                     bclose=true;
                    }
                  else
                    {
                     break; //остановим поиск ордеров для закрытия так как исчерпали профит
                    }
                 }
              }

           }

         bool bSetLock=false;

         if(bclose)
           {

            for(int i=0; i<cb; i++)
              {

               if(array_order_buy[i][3]>0)
                 {
                  PrintFormat("Close profit order: %.2f",array_order_buy[i][3]);
                  OrderClose((long)array_order_buy[i][1]);
                  bSetLock=true;
                 }

              }

           }
        }

      if(ibuystop+isellstop==0)
        {
         double dprice=MathMin(iHigh(_Symbol,tf,1),iHigh(_Symbol,tf,2))+dPending_MinOffset*p;

         Update();
         int itype=-1;

         double dlock=getLock(itype);

         if(itype==OP_SELL)
           {
            Magic(iLockMagic);
            long tt=OrderSend(OP_BUYSTOP,dlock,dprice,0,0,"lock");
            Magic(-1);
            DEBUG_OrderSend3(tt);

            if(tt>0)
               return true;
           }

        }

      if(dsellprofit-dMinProfit>dbuyprofit && dsellprofit>dMinProfit && cb>0 && iop==OP_SELL && ibuystop+isellstop==0)
        {
         dsellprofit-=dMinProfit;

         ArraySort(array_order_buy,WHOLE_ARRAY,0,MODE_DESCEND); //в сторону уменьшения, верхний это 0

         bool bclose=false;

         for(int i=0; i<cb; i++)
           {
            double dprofit=array_order_buy[i][3];

            if(dprofit<0)
              {

               double dlot=array_order_buy[i][2];
               double dminuslot=NormalizeDouble(dprofit*dlotstep/dlot,2); //рассчитаем профит на минимальный шаг лота
               int imaxlots=(int)(dlot/dlotstep); //рассчитаем профит на минимальный шаг лота
               double dlotpart=0;
               if(dminuslot<0)
                 {

                  for(int j=0; j<imaxlots; j++)
                    {
                     if(dsellprofit+dminuslot>=0)
                       {
                        dlotpart+=dlotstep;
                        dsellprofit+=dminuslot;
                       }
                     else
                       {
                        break;
                       }
                    }

                  if(dlotpart>0)
                    {
                     PrintFormat("Close buy part lot: %.2f minus: %.2f",dlotpart,dminuslot);
                     OrderClose((long)array_order_buy[i][1],dlotpart);
                     bclose=true;
                    }
                  else
                    {
                     break; //остановим поиск ордеров для закрытия так как исчерпали профит
                    }
                 }
              }

           }

         bool bSetLock=false;
         if(bclose)
           {
            for(int i=0; i<cs; i++)
              {

               if(array_order_sell[i][3]>0)
                 {
                  PrintFormat("Close profit order: %.2f",array_order_sell[i][3]);
                  OrderClose((long)array_order_sell[i][1]);
                  bSetLock=true;
                 }

              }

           }
        }

      if(ibuystop+isellstop==0)
        {
         double dprice=MathMin(iLow(_Symbol,tf,1),iLow(_Symbol,tf,2))-dPending_MinOffset*p;

         Update();
         int itype=-1;
         double dlock=getLock(itype);

         if(itype==OP_BUY)
           {
            Magic(iLockMagic);
            long tt=OrderSend(OP_SELLSTOP,dlock,dprice,0,0,"lock");
            Magic(-1);

            DEBUG_OrderSend3(tt);

            if(tt>0)
               return true;
           }

        }

      return false;
     }

  };

class CMain: public CMainDefault
  {
protected:
   CMyOrders         m_main;
   CNewBar           m_bar;
   SNButton          m_lock,m_stab;
   CDraw             m_draw;
   CTimer            m_timer;

   CDrawPos          m_pos;
   bool              bcheck;

public:
   virtual int       OnInit()
     {
      // код доступен только после оплаты
   }

   virtual void      OnDeinit(const int reason)
     {
      m_timer.OnDeinit();
      m_main.OnDeinit();
      m_draw.OnDeinit();
      m_lock.OnDeinit();
      m_stab.OnDeinit();
     }

   virtual void      OnTick()
     {
      // код доступен только после оплаты
   }

      string sLicense=VALID_KEY;

      bcheck=checkAccount(sLicense,LICENSE_NAME);
      m_pos.DrawStatus("status",sLicense,bcheck);

      OnTimer();

      if(!m_main.IsWork())
         return; //отключена торговля

      m_bar.Refresh();

      m_main.OnTick();
      m_main.Update(); //получим кол-во ордеров в структуре orders

      m_main.MovePending(LockMagic,PendingOffset);

      double dlots[2];
      double dlock=m_main.get_lots(dlots);

      bool bStatusLock=(bool)State("StatusLock");
      bool bStatusStab=(bool)State("StatusSt

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