← Назад к списку файлов

gold scalper pro.mq4

Поиск по коду файла

#property icon "\\Images\\icon.ico"

#property description "====================="
#property description "Advisor for ECN accounts"
#property description "Gold (XAUUSD,XAUEUR)"
#property description "====================="
#property version   "1.61"
#property strict

const int PRODUCT_ID=10572;//Gold Scalper PRO
const string VERSION="1.61"; //номер версии при обновлении меняем тоже, это на будущее когда будет доступна првоерка версий и обновления
#include <EA_Protect/Protect.mqh>
SHOW_LICENSE_PARAMS
PROTECT_CREATE

/*
в начале кода подключаем и настраиваем на ID товара. ID берем из вкладки Дополнительно при создании товара, либо в EA Protect - Продукты
const int PRODUCT_ID=3265;//Index Scalper PRO MT4
const string VERSION="3.50"; //номер версии при обновлении меняем тоже, это на будущее когда будет доступна првоерка версий и обновления
#include <EA_Protect/Protect.mqh>
SHOW_LICENSE_PARAMS
PROTECT_CREATE

----
Данные макросы нужно встроить в указаные функции.

PROTECT_INIT - в функцию OnInit, инициализация
PROTECT_DEINIT в функцию OnDeinit, деинициализация
PROTECT_EVENT в функцию OnChartEvent, прием сообщений внутренних и резервный таймер
PROTECT_TIMER в функцию OnTimer, опрос по таймеру данных с сайта
статус защиты в любом месте можно получить через переменную PROTECT_STATUS
возвращает true - если все в порядке или false если проблемы. Статус при опросах пишет в журнал.

После компиляции компилируем дополнительно с помощью защиты от MQL5 Сервис - MQL5 Cloud Protector - это обязательно делать необходимо.

На сайт загружать все в архиве zip
желательно в архиве чтобы было все по папкам
MQL4 / MQL5
Experts
Indicators

*/

extern double Sar_period = 0.61;
extern int Step = 28;
extern int Acceleration = 9;
extern double Lots = 0.05; //Lots
extern int StopLoss = 300; // Stop Loss
extern int TrailingStop = 25; //Trailing Stop
extern int Max_Spread = 20; //Maximum allowed spread
extern int Magic = 1111111; //Magic Number
string  Comment = "Gold "; //Comments
bool returned_b;
double Ind_000;
double Ind_002;
double Gd_00001;
double Gd_00002;
double Gd_00003;
bool Gb_00001;
double Gd_00004;
double Gd_00005;
bool Gb_00004;
bool Gb_00006;
string Gs_00000;
double Gd_00008;
double Gd_00009;
double Gd_0000A;
bool Gb_00008;
double Gd_0000B;
double Gd_0000C;
bool Gb_0000B;
int Gi_0000B;
double Gd_0000D;
double Gd_0000E;
double Gd_0000F;
double Gd_00010;
bool Gb_0000F;
int Gi_0000F;
double Gd_00011;
double Gd_00012;
double Gd_00013;
double Gd_00014;
bool Gb_00013;
int Gi_00013;
long returned_l;
int Gi_00015;
double Id_00030;
double Id_00038;
double Id_00040;
double Gd_00016;
double Id_00058;
int Ii_0002C;
int Ii_00018;
double Id_00060;
int Ii_00028;
int Ii_0001C;
int Gi_00016;
int Gi_000E1;
double Ind_004;
double Gd_00017;
double Id_00068;
int returned_i;
int Ii_00024;
int Gi_00017;
int Ii_00188;
bool Gb_00017;
double Id_00078;
bool Gb_0001F;
double Gd_0001F;
double Gd_00020;
int Gi_00021;
double Gd_00021;
double Gd_00022;
int Gi_00023;
int Ii_00014;
bool Gb_00023;
double Gd_00023;
int Gi_00024;
double Gd_00024;
int Gi_00025;
int Ii_00020;
double Gd_00026;
double Gd_00027;
double Gd_00028;
double Gd_00029;
bool Gb_00027;
string Is_00008;
int Ii_00184;
int Gi_0002A;
double Gd_0002A;
int Gi_00027;
int Gi_0002B;
double Gd_0002C;
double Gd_0002D;
double Gd_0002E;
double Gd_0002F;
bool Gb_0002D;
double Gd_00030;
int Gi_00031;
double Gd_00031;
double Gd_00032;
int Gi_00033;
double Gd_00033;
bool Gb_00033;
int Ii_00000;
long Gl_00033;
int Gi_00034;
bool Gb_00034;
int Gi_00035;
double Gd_00036;
double Gd_00037;
double Gd_00038;
double Gd_00039;
bool Gb_00037;
int Gi_00037;
long Gl_00037;
int Gi_0003A;
double Gd_0003A;
bool Gb_0003A;
double Id_00190;
int Gi_0003B;
double Gd_0003C;
double Gd_0003D;
double Gd_0003E;
double Gd_0003F;
bool Gb_0003D;
bool Gb_0001B;
double Gd_0001B;
double Gd_0001C;
bool Gb_0001C;
double Gd_0001D;
double Gd_0001E;
int Gi_0001F;
double Gd_00018;
bool Gb_00018;
double Gd_00019;
double Gd_0001A;
int Gi_0001B;
bool Gb_00016;
bool Gb_00007;
double Gd_00007;
int Gi_00007;
double Id_00048;
double Id_00050;
double Id_00070;
double Id_00080;
double Id_00088;
double Id_00090;
string Is_00168;
string Is_00178;
int Gi_00000;
double Gd_00000;
int Gi_00001;
int Gi_00002;
int Gi_00003;
int Gi_00004;
int Gi_00005;
int Gi_00006;
double Gd_00006;
long Gl_00000;
double Id_00098[];
double Id_000CC[];
double Id_00100[];
int Ii_00134[];
double returned_double;
int OnInit()
  {
      // код доступен только после оплаты
   }

/*void CreateObj(string name,ENUM_OBJECT objType,int zOrder,ENUM_ANCHOR_POINT anchor,string text,int fontSize, string fontName,string colorText,ENUM_BASE_CORNER corner,
               int xDist,int yDist,int ySize, int xSize,bool readonly,string colorBack,string colorBorder,ENUM_ALIGN_MODE align)
  {

   ObjectCreate(0,name,objType,0,0,0);
   ObjectSetInteger(0,name,OBJPROP_ZORDER,zOrder);
   ObjectSetInteger(0,name,OBJPROP_ANCHOR,anchor);
   ObjectSetInteger(0,name,OBJPROP_CORNER,corner);
   ObjectSetInteger(0,name,OBJPROP_XDISTANCE,xDist);
   ObjectSetInteger(0,name,OBJPROP_YDISTANCE,yDist);
   ObjectSetInteger(0,name,OBJPROP_XSIZE,xSize);
   ObjectSetInteger(0,name,OBJPROP_YSIZE,ySize);
   ObjectSetInteger(0,name,OBJPROP_STATE,false);
   ObjectSetInteger(0,name,OBJPROP_SELECTABLE,false);
   ObjectSetInteger(0,name,OBJPROP_SELECTED,false);
   ObjectSetInteger(0,name,OBJPROP_BACK,false);
   ObjectSetInteger(0,name,OBJPROP_HIDDEN,True);
   ObjectSetString(0,name,OBJPROP_TOOLTIP,"\n");
   ObjectSetInteger(0,name,OBJPROP_READONLY,readonly);
   ObjectSetInteger(0,name,OBJPROP_BORDER_COLOR,StringToColor(colorBorder));
   ObjectSetInteger(0,name,OBJPROP_BGCOLOR,StringToColor(colorBack));
   ObjectSetInteger(0,name,OBJPROP_ALIGN,align);
   ObjectSetInteger(0,name,OBJPROP_COLOR,StringToColor(colorText));
   ObjectSetInteger(0,name,OBJPROP_FONTSIZE,fontSize);
   ObjectSetString(0,name,OBJPROP_FONT,fontName);
   ObjectSetString(0,name,OBJPROP_TEXT,text);

  }
*/  

int OnStart()
  {
      // код доступен только после оплаты
   }
   string Ls_FFFF0;
   int Li_FFFFC;
   int Li_FFFEC;
   int Li_FFFE8;
   int Li_FFFE4;
   int Li_FFFE0;
   int Li_FFFDC;
   double Ld_FFFD0;
   double Ld_FFFC8;
   double Ld_FFFC0;
   double Ld_FFFB8;
   int Li_FFFB4;
   int Li_FFFB0;
   int Li_FFFAC;
   int Li_FFFA8;
   int Li_FFFA4;
   int Li_FFFA0;
   double Ld_FFF98;
   double Ld_FFF90;
   double Ld_FFF88;
   int Li_FFF84;
   int Li_FFF80;
   int Li_FFF7C;
   int Li_FFF78;
   int Li_FFF74;
   int Li_FFF70;
   int Li_FFF6C;
   int Li_FFF68;
   int Li_FFF64;
   int Li_FFF60;
   int Li_FFF5C;
   int Li_FFF58;
   int Li_FFF54;
   int Li_FFF50;
   int Li_FFF4C;
   int Li_FFF48;
   int Li_FFF44;

   if(IsTesting())
     {
      returned_double = MarketInfo(_Symbol, MODE_LOTSTEP);
      Gd_00001 = round((Lots / returned_double));
      Gd_00001 = (Gd_00001 * returned_double);
      Gd_00002 = MarketInfo(_Symbol, MODE_LOTSTEP);
      Gd_00001 = (NormalizeDouble((Gd_00001 / Gd_00002), 0) * Gd_00002);
      Gd_00003 = Gd_00001;
      if((Gd_00001 >= MarketInfo(_Symbol, MODE_MAXLOT)))
        {
         Gd_00003 = MarketInfo(_Symbol, MODE_MAXLOT);
        }
      if((Gd_00003 <= MarketInfo(_Symbol, MODE_MINLOT)))
        {
         Gd_00003 = MarketInfo(_Symbol, MODE_MINLOT);
        }
      Gd_00001 = MarketInfo(_Symbol, MODE_LOTSTEP);
      Gd_00004 = (NormalizeDouble((Gd_00003 / Gd_00001), 0) * Gd_00001);
      Gd_00005 = Gd_00004;
      if((Gd_00004 >= MarketInfo(_Symbol, MODE_MAXLOT)))
        {
         Gd_00005 = MarketInfo(_Symbol, MODE_MAXLOT);
        }
      if((Gd_00005 <= MarketInfo(_Symbol, MODE_MINLOT)))
        {
         Gd_00005 = MarketInfo(_Symbol, MODE_MINLOT);
        }
      Gd_00004 = Gd_00005;
      returned_double = SymbolInfoDouble(NULL, 34);
      Gb_00006 = (Gd_00005 < returned_double);
      if(Gb_00006)
        {
         Ls_FFFF0 = StringFormat("Volume is less than the minimum allowable", returned_double);
         Gb_00006 = false;
        }
      else
        {
         returned_double = SymbolInfoDouble(NULL, 35);
         if((Gd_00004 > returned_double))
           {
            Ls_FFFF0 = StringFormat("Volume is more than the maximum allowable", returned_double);
            Gb_00006 = false;
           }
         else
           {
            returned_double = SymbolInfoDouble(NULL, 36);
            Gd_00007 = round((Gd_00004 / returned_double));
            Gi_00007 = (int) Gd_00007;
            Gd_00008 = fabs(((Gi_00007 * returned_double) - Gd_00004));
            if((Gd_00008 > 1E-07))
              {
               Ls_FFFF0 = StringFormat("The volume is not a multiple of", returned_double, (Gi_00007 * returned_double));
               Gb_00006 = false;
              }
            else
              {
               Ls_FFFF0 = "Correct value of volume";
               Gb_00006 = true;
              }
           }
        }
      if(Gb_00006 == 0)
        {
         Li_FFFFC = 0;
         return Li_FFFFC;
        }
      returned_double = MarketInfo(_Symbol, MODE_LOTSTEP);
      Gd_00008 = round((Lots / returned_double));
      Gd_00008 = (Gd_00008 * returned_double);
      Gd_00009 = MarketInfo(_Symbol, MODE_LOTSTEP);
      Gd_00008 = (NormalizeDouble((Gd_00008 / Gd_00009), 0) * Gd_00009);
      Gd_0000A = Gd_00008;
      if((Gd_00008 >= MarketInfo(_Symbol, MODE_MAXLOT)))
        {
         Gd_0000A = MarketInfo(_Symbol, MODE_MAXLOT);
        }
      if((Gd_0000A <= MarketInfo(_Symbol, MODE_MINLOT)))
        {
         Gd_0000A = MarketInfo(_Symbol, MODE_MINLOT);
        }
      Gd_00008 = MarketInfo(_Symbol, MODE_LOTSTEP);
      Gd_0000B = (NormalizeDouble((Gd_0000A / Gd_00008), 0) * Gd_00008);
      Gd_0000C = Gd_0000B;
      if((Gd_0000B >= MarketInfo(_Symbol, MODE_MAXLOT)))
        {
         Gd_0000C = MarketInfo(_Symbol, MODE_MAXLOT);
        }
      if((Gd_0000C <= MarketInfo(_Symbol, MODE_MINLOT)))
        {
         Gd_0000C = MarketInfo(_Symbol, MODE_MINLOT);
        }
      if(AccountFreeMarginCheck(_Symbol, 0, Gd_0000C) <= 0 || GetLastError() == 134)
        {

         Alert("Not enough money on the account!");
         Li_FFFFC = 0;
         return Li_FFFFC;
        }
      returned_double = MarketInfo(_Symbol, MODE_LOTSTEP);
      Gd_0000B = round((Lots / returned_double));
      Gd_0000B = (Gd_0000B * returned_double);
      Gd_0000D = MarketInfo(_Symbol, MODE_LOTSTEP);
      Gd_0000B = (NormalizeDouble((Gd_0000B / Gd_0000D), 0) * Gd_0000D);
      Gd_0000E = Gd_0000B;
      if((Gd_0000B >= MarketInfo(_Symbol, MODE_MAXLOT)))
        {
         Gd_0000E = MarketInfo(_Symbol, MODE_MAXLOT);
        }
      if((Gd_0000E <= MarketInfo(_Symbol, MODE_MINLOT)))
        {
         Gd_0000E = MarketInfo(_Symbol, MODE_MINLOT);
        }
      Gd_0000B = MarketInfo(_Symbol, MODE_LOTSTEP);
      Gd_0000F = (NormalizeDouble((Gd_0000E / Gd_0000B), 0) * Gd_0000B);
      Gd_00010 = Gd_0000F;
      if((Gd_0000F >= MarketInfo(_Symbol, MODE_MAXLOT)))
        {
         Gd_00010 = MarketInfo(_Symbol, MODE_MAXLOT);
        }
      if((Gd_00010 <= MarketInfo(_Symbol, MODE_MINLOT)))
        {
         Gd_00010 = MarketInfo(_Symbol, MODE_MINLOT);
        }
      if(AccountFreeMarginCheck(_Symbol, 1, Gd_00010) <= 0 || GetLastError() == 134)
        {

         Alert("Not enough money on the account!");
         Li_FFFFC = 0;
         return Li_FFFFC;
        }
      returned_double = MarketInfo(_Symbol, MODE_LOTSTEP);
      Gd_0000F = round((Lots / returned_double));
      Gd_0000F = (Gd_0000F * returned_double);
      Gd_00011 = MarketInfo(_Symbol, MODE_LOTSTEP);
      Gd_0000F = (NormalizeDouble((Gd_0000F / Gd_00011), 0) * Gd_00011);
      Gd_00012 = Gd_0000F;
      if((Gd_0000F >= MarketInfo(_Symbol, MODE_MAXLOT)))
        {
         Gd_00012 = MarketInfo(_Symbol, MODE_MAXLOT);
        }
      if((Gd_00012 <= MarketInfo(_Symbol, MODE_MINLOT)))
        {
         Gd_00012 = MarketInfo(_Symbol, MODE_MINLOT);
        }
      Gd_0000F = MarketInfo(_Symbol, MODE_LOTSTEP);
      Gd_00013 = (NormalizeDouble((Gd_00012 / Gd_0000F), 0) * Gd_0000F);
      Gd_00014 = Gd_00013;
      if((Gd_00013 >= MarketInfo(_Symbol, MODE_MAXLOT)))
        {
         Gd_00014 = MarketInfo(_Symbol, MODE_MAXLOT);
        }
      if((Gd_00014 <= MarketInfo(_Symbol, MODE_MINLOT)))
        {
         Gd_00014 = MarketInfo(_Symbol, MODE_MINLOT);
        }
      Gd_00013 = (Gd_00014 * MarketInfo(_Symbol, MODE_MARGINREQUIRED));
      Gb_00013 = (Gd_00013 > AccountFreeMargin());
      if(Gb_00013)
        {
         Alert("Not enough money on the account!");
         Li_FFFFC = 0;
         return Li_FFFFC;
        }
      Gi_00013 = (int) SymbolInfoInteger(NULL, SYMBOL_TRADE_STOPS_LEVEL);
      if(TrailingStop <= Gi_00013)
        {
         Gi_00013 = (int) SymbolInfoInteger(NULL, SYMBOL_TRADE_STOPS_LEVEL);
         TrailingStop = Gi_00013 + 1;
        }
      Gi_00013 = (int) SymbolInfoInteger(NULL, SYMBOL_TRADE_STOPS_LEVEL);
      if(Step <= Gi_00013)
        {
         Gi_00013 = (int) SymbolInfoInteger(NULL, SYMBOL_TRADE_STOPS_LEVEL);
         Step = Gi_00013 + 1;
        }
      Gi_00013 = (int) AccountInfoInteger(ACCOUNT_LIMIT_ORDERS);
      Gi_00015 = Gi_00013;
      if(Gi_00013 == 0)
        {
         Gb_00013 = true;
        }
      else
        {
         Gb_00016 = (OrdersTotal() < Gi_00015);
         Gb_00013 = Gb_00016;
        }
      if(Gb_00013 != true)
        {
         Li_FFFFC = 0;
         return Li_FFFFC;
        }
      Id_00030 = (MarketInfo(_Symbol, MODE_MARGINREQUIRED) * 0.01);
      Id_00038 = MarketInfo(_Symbol, MODE_MAXLOT);
      Id_00040 = MarketInfo(_Symbol, MODE_MINLOT);
      Id_00058 = NormalizeDouble((Ask - Bid), _Digits);
      Ii_0002C = 33;
      if(Ii_00018 < 33)
        {
         Ii_00018 = 33;
        }
      if(Ii_0002C > TrailingStop)
        {
         TrailingStop = Ii_0002C;
        }
      Id_00060 = Id_00058;
      Ii_00028 = Ii_0001C;
      ArrayResize(Id_00098, Ii_0001C, 0);
      if(Ii_00028 != 0)
        {
         Gi_00016 = Ii_00028;
         ArrayFill(Id_00098, 0, Ii_00028, Id_00060);
        }
      Id_00068 = NormalizeDouble((Max_Spread * _Point), _Digits);
      Li_FFFEC = 0;
      Li_FFFE8 = 0;
      Li_FFFE4 = 0;
      func_1011();
      Li_FFFE0 = 0;
      Li_FFFDC = 0;
      if(OrdersTotal() > 0)
        {
         do
           {
            Ii_00024 = OrderSelect(Li_FFFDC, 0, 0);
            if(OrderSymbol() == _Symbol && OrderMagicNumber() == Magic)
              {
               Li_FFFE0 = Li_FFFE0 + 1;
               returned_i = OrderType();
               if(returned_i <= 5)
                 {
                  if(returned_i == 4)
                    {

                     Gi_00017 = (int) TimeCurrent();
                     Gi_00017 = Gi_00017 - Ii_00184;
                     if(Gi_00017 > Acceleration && (Id_00078 < (_Point * 70)))
                       {
                        Ii_00024 = OrderDelete(OrderTicket(), 4294967295);
                       }
                     Li_FFFEC = Li_FFFEC + 1;

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

Как получить полную версию?

Введите ваш email и нажмите кнопку, чтобы перейти к оплате.