Charles

#define VER "2.1.5"

#define DECIMAL_CONVERSION 10

extern string Comment_1           = " -- Comma separated list of Symbol Pairs: EURUSD,USDCHF";
extern string Comment_1a          = " --- must be equal to the string of your account provider.";
extern string Symbols             = "EURUSDm,EURGBPm,EURJPYm,CHFJPYm,GBPUSDm,GBPJPYm,GBPCHFm,GBPAUDm,USDCADm,USDCHFm,USDJPYm,AUDNZDm,AUDUSDm,NZDUSDm";

extern int    MagicNumber         = 3939;
extern double xFactor             = 1.8;
extern string TimeSet             = "07:32";

extern string Comment_2           = " -- Balance percentage order balance and Lot value";
extern double RiskPercent         = 5;

extern string Comment_3           = " -- Percentage of the risk for each Lot";
extern string Comment_3a          = " --- auto-adapted to number of pairs.";
extern double RiskPerTrade        = 10;
extern int    MaxAllowedOrders    = 15;
extern int    MaxOpenHours        = 0;
extern int    ProfitCheckPeriod   = 3;

extern string Comment_4           = " -- Whether or not use more strict supports and resistances";
extern bool   Aggressive          = false;
extern bool   UsePivots           = true;

extern string Comment_5           = " -- Whether or not leave open profitable orders";
extern int    FastPeriod          = 18;
extern int    SlowPeriod          = 60;
extern int    Selectivity         = 14;

extern string Comment_6           = " -- Fixed value if RiskPerTrade == 0";
extern double Lots                = 0.01;
extern int    Slippage            = 3;
extern string Comment_7           = " -- Set to true if broker is ECN/STP needing stops adding after order";
extern bool   ECN                 = true;
extern double MarginPercent       = 20;

extern string Comment_8           = " -- On all orders";
extern int    StopLoss            = 0;
extern int    TrailStart          = 30;
extern int    TrailingAmount      = 10;
extern int    TakeProfit          = 20;

extern string Comment_9           = " -- Whether or not manage ALL opened orders (manual too)";
extern bool   AllOrders           = true;

extern string Comment_10           = " -- Whether or not compute the Profit on ALL pairs";
extern bool   AllSymbols          = true;

extern string Comment_11          = " -- Log to console or to a file";
extern bool   LogToFile           = false;

extern string Comment_12          = " -- On init delete all pending orders";
extern bool   InitResetOrders     = true;

extern string Comment_13          = " -- Trading Time Management";
extern int    StartHour           = 0;
extern int    EndHour             = 24;
extern bool   CloseAllNow         = false;
extern int    FridayCloseTime     = 0;

int Anchor, PendingBuy, PendingSell, Buys, Sells, i, StopLevel, Spread;

int MaxOpenOrders;

double BuyLots, SellLots, PendingBuyLots, PendingSellLots;
double Amount, Profit, LastProfit, Up, Dw, SL, TP;
double LotsValue, LotsHedgeValue;
double MaxPrice,MinPrice,MaxOpenPrice,MinOpenPrice;

bool isInGain=false, blockConditionHit=false, unlockOrdersPlaced=false; 
int LastOrderTicket, UnlockingOrderTicket, Result, Error;
int Delta;        //Order price shift (in points) from High/Low price
int LastDay;

double stopLoss, delta;
double trailStart, trailAmount, takeProfit;

double lastBarTime,lastpM5BarTime,lastpM15BarTime,lastpH1BarTime;

string SymbolsArray[0], CurrentSymbol;
bool canSell[0], canBuy[0], bullish[0], bearish[0];

bool Inited[0], DayStart[0], inited=false;

bool tradingAllowed=false;

double    Pivot[0];
double  Resist1[0];
double  Resist2[0];
double  Resist3[0];
double Support1[0];
double Support2[0];
double Support3[0];
double   pPoint[0];
bool     isCals[0];
double r1[0] , s1[0] ,s2[0], r2[0], r3[0], s3[0];

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

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

int CheckForClose(int s)
{
   RefreshRates();
   Count();

   int ordersTotal=OrdersTotal();
   bool skipBasket=false;

   if(ordersTotal>0)
   {
      if(Profit>=0)
      {
         skipBasket=true;
      }

      if(skipBasket==false)
      {
         double ordersWinningBasket[],ordersWinningBasketTkts[],ordersLosingBasket[],ordersLosingBasketTkts[],ordersBasketHedgeTkts[];
         ArrayResize(ordersWinningBasket,ordersTotal);
         ArrayResize(ordersWinningBasketTkts,ordersTotal);
         ArrayResize(ordersLosingBasket,ordersTotal);
         ArrayResize(ordersLosingBasketTkts,ordersTotal);
         ArrayResize(ordersBasketHedgeTkts,ordersTotal);

         int winners=0,loosers=0;

         for(i=0; i<ordersTotal; i++)
         {
            ordersWinningBasket[i]=0;
            ordersWinningBasketTkts[i]=0;
            ordersLosingBasket[i]=0;
            ordersLosingBasketTkts[i]=0;
            ordersBasketHedgeTkts[i]=0;

             if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
             {

               if(AllSymbols==false && OrderSymbol()!=CurrentSymbol)
               {
                  continue;
               }//if

               if(AllOrders==false && OrderMagicNumber()!=MagicNumber)
               {
                  continue;
               }//if

               if(OrderType() == OP_BUY || OrderType() == OP_SELL)
               {
                  if(OrderProfit()+OrderSwap()+OrderCommission()>0)
                  {
                     ordersWinningBasket[winners]     =  OrderProfit()+OrderSwap()+OrderCommission();
                     ordersWinningBasketTkts[winners] =  OrderTicket();
                     winners++;
                  } 
                  else if(OrderProfit()+OrderSwap()+OrderCommission()<0)
                  {
                     ordersLosingBasket[loosers]     =  OrderProfit()+OrderSwap()+OrderCommission();
                     ordersLosingBasketTkts[loosers] =  OrderTicket();
                     loosers++;
                  }
               }
            }
         }//for

         Log( "[Basket] - Winners#"+winners+"; Loosers#"+loosers );

         for(int w=0;w<winners;w++)
         {
            if( OrderSelect(ordersWinningBasketTkts[w],SELECT_BY_TICKET,MODE_TRADES) )
            {
               Log( "[Basket] - Checking Order#"+OrderTicket()+"; ["+OrderSymbol()+"]#"+(OrderProfit()+OrderCommission()+OrderSwap()) );
               for(int l=0;l<loosers;l++)
               {
                  if( OrderSelect(ordersLosingBasketTkts[l],SELECT_BY_TICKET,MODE_TRADES) && MathAbs(ordersLosingBasket[l])<ordersWinningBasket[w] )
                  {

                     int sum=loosers;
                     while(sum>0)
                     {
                        for(int ls=0;ls<sum;ls++)
                        {
                           ordersBasketHedgeTkts[0]=ordersLosingBasketTkts[l];
                           double hedgeProfit=ordersLosingBasket[l];
                           int hedgePos=1;
                           for(int lsp=0;lsp<sum;lsp++)
                           {
                              if( ordersLosingBasketTkts[lsp] != ordersLosingBasketTkts[l] && MathAbs(ordersLosingBasket[lsp])<ordersWinningBasket[w] )
                              {
                                 ordersBasketHedgeTkts[hedgePos]=ordersLosingBasketTkts[lsp];
                                 hedgeProfit+=ordersLosingBasket[lsp];
                                 hedgePos++;
                              }//if
                           }//for
                        }//for

                        if(hedgePos>1)
                           Log( "[Basket - STEP 1."+ls+"] - hedgePos#"+hedgePos+"; hedgeProfit#"+MathAbs(hedgeProfit*xFactor)+"; ordersWinningBasket#"+ordersWinningBasket[w] );

                        if(hedgePos>1 && (MathAbs(hedgeProfit*xFactor)<ordersWinningBasket[w]) )
                        {
                           Log("[BASKET] hedgePos#"+hedgePos+"; hedgeProfit#"+MathAbs(ordersLosingBasket[l])+"; ordersWinningBasket#"+ordersWinningBasket[w]);
                           for(int oh=0; oh<hedgePos; oh++)
                           {
                              if(OrderSelect(ordersBasketHedgeTkts[oh],SELECT_BY_TICKET,MODE_TRADES))
                              {

                                 while (!IsTradeAllowed()) Sleep(100);
                                 RefreshRates();

                                 Log("[BASKET] - Closing Order#"+OrderTicket()+"; ["+OrderSymbol()+"]");

                                 if(OrderType()==OP_BUY)
                                 {
                                    OrderClose(OrderTicket(), OrderLots(), MarketInfo(OrderSymbol(),MODE_BID), Slippage, Blue);
                                 }
                                 else if(OrderType()==OP_SELL)
                                 {
                                    OrderClose(OrderTicket(), OrderLots(), MarketInfo(OrderSymbol(),MODE_ASK), Slippage, Red);
                                 }
                              }
                           }

                           if(OrderSelect(ordersWinningBasketTkts[w],SELECT_BY_TICKET,MODE_TRADES))
                           {

                              while (!IsTradeAllowed()) Sleep(100);
                              RefreshRates();

                              Log("[BASKET] - Closing Order#"+OrderTicket()+"; ["+OrderSymbol()+"]");

                              if(OrderType()==OP_BUY)
                              {
                                 OrderClose(OrderTicket(), OrderLots(), MarketInfo(OrderSymbol(),MODE_BID), Slippage, Blue);
                              }
                              else if(OrderType()==OP_SELL)
                              {
                                 OrderClose(OrderTicket(), OrderLots(), MarketInfo(OrderSymbol(),MODE_ASK), Slippage, Red);
                              }
                           }
                           sum=0;
                           loosers=0;
                           winners=0;
                           break;
                        }

                        sum--;
                     }//while
                  }               
               }
            }
         }

      }
   }

   RefreshRates();      
   Count();

   int sx;   
   if(Profit>=0 && Profit>=Amount)
   {
      ordersTotal=OrdersTotal();

      double gainingProfit=0,loosingProfit=0;
      if(ordersTotal>0)
      {
         for(i=ordersTotal-1; i>=0; i--)
         {
            if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES)==true)
            {
               if( (OrderProfit()+OrderSwap()+OrderCommission())>0 )
               {
                  gainingProfit+=(OrderProfit()+OrderSwap()+OrderCommission());
               }
               else
               {
                  loosingProfit+=(OrderProfit()+OrderSwap()+OrderCommission());
               }
            }
         }
      }

      if(loosingProfit==0 || gainingProfit>(MathAbs(loosingProfit)) )
      {
         isInGain=true;
      }
      else
      {
         isInGain=false;
      }

      RefreshRates();      
      Count();

      if( isInGain==false && Profit<=(LastProfit - Amount/10) )
      {
         isInGain = false;
         blockConditionHit=false;
         unlockOrdersPlaced=false;
         LastOrderTicket = -1;
         UnlockingOrderTicket = -1;
         LastProfit=0;

         for(sx=0; sx<ArraySize(canSell); sx++)
         {
            canSell[sx] = true;
            canBuy[sx] = true;
            CloseAll(sx, isInGain);
         }
      }

      if(isInGain==true )
      {
         ordersTotal=OrdersTotal();

         if(ordersTotal>0)
         {
            for(i=ordersTotal-1; i>=0; i--)
            {
               double highest=0;
               double lowest=0;
               double chgFromOpen=0,chgFromPeak=0,chgFromLown=0;
               double ceil=0,floor=0;
               if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES)==true)
               {

                  if (MarketInfo(OrderSymbol(), MODE_DIGITS) == 3 || MarketInfo(OrderSymbol(), MODE_DIGITS) == 5)   {
                     floor    = NormalizeDouble(Delta * DECIMAL_CONVERSION * MarketInfo(OrderSymbol(), MODE_POINT),MarketInfo(OrderSymbol(), MODE_DIGITS));
                     ceil     = NormalizeDouble(TakeProfit * DECIMAL_CONVERSION * MarketInfo(OrderSymbol(), MODE_POINT),MarketInfo(OrderSymbol(), MODE_DIGITS));
                  }
                  else
                  {
                     floor    = NormalizeDouble(Delta * MarketInfo(OrderSymbol(), MODE_POINT),MarketInfo(OrderSymbol(), MODE_DIGITS));
                     ceil     = NormalizeDouble(TakeProfit * MarketInfo(OrderSymbol(), MODE_POINT),MarketInfo(OrderSymbol(), MODE_DIGITS));
                  }

                  highest = iHigh(OrderSymbol(),PERIOD_M15,iHighest(CurrentSymbol,PERIOD_M15,MODE_HIGH,ProfitCheckPeriod,1));
                  lowest  = iLow(OrderSymbol(),PERIOD_M15,iLowest(CurrentSymbol,PERIOD_M15,MODE_LOW,ProfitCheckPeriod,1));

                  if( OrderType() == OP_BUY  )
                  {
                     chgFromOpen = NormalizeDouble(MarketInfo(OrderSymbol(),MODE_BID) - OrderOpenPrice(), MarketInfo(OrderSymbol(),MODE_DIGITS));
                     chgFromPeak = NormalizeDouble(MarketInfo(OrderSymbol(),MODE_BID) - highest, MarketInfo(OrderSymbol(),MODE_DIGITS));
                     chgFromLown = NormalizeDouble(lowest - MarketInfo(OrderSymbol(),MODE_ASK), MarketInfo(OrderSymbol(),MODE_DIGITS));

                     if( (TimeCurrent()-OrderOpenTime())/60>=ProfitCheckPeriod*PERIOD_M15 && 
                           OrderProfit()+OrderCommission()+OrderSwap()>0 &&
                            chgFromOpen>0 && 
                              MathAbs(chgFromOpen-chgFromPeak)>=floor && MathAbs(chgFromOpen-chgFromPeak)<=ceil &&
                               chgFromLown<0 && MathAbs(chgFromLown)>=floor)
                     {
                        for(sx=0; sx<ArraySize(canSell); sx++)
                        {
                           canSell[sx] = true;
                           canBuy[sx] = true;
                           CloseAll(sx);
                        }
                        break;
                     }
                  }
                  else if( OrderType() == OP_SELL  )
                  {
                     chgFromOpen = NormalizeDouble(OrderOpenPrice() - MarketInfo(OrderSymbol(),MODE_ASK), MarketInfo(OrderSymbol(),MODE_DIGITS));
                     chgFromPeak = NormalizeDouble(MarketInfo(OrderSymbol(),MODE_BID) - highest, MarketInfo(OrderSymbol(),MODE_DIGITS));
                     chgFromLown = NormalizeDouble(lowest - MarketInfo(OrderSymbol(),MODE_ASK), MarketInfo(OrderSymbol(),MODE_DIGITS));

                     if( (TimeCurrent()-OrderOpenTime())/60>

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