Sniper Pro

#property version     "5.00"
#property indicator_chart_window
#property indicator_buffers 5
#property indicator_plots   5

#property indicator_label1  "EMA 9"
#property indicator_type1   DRAW_LINE
#property indicator_color1  clrLime
#property indicator_style1  STYLE_SOLID
#property indicator_width1  2

#property indicator_label2  "EMA 21"
#property indicator_type2   DRAW_LINE
#property indicator_color2  clrTomato
#property indicator_style2  STYLE_SOLID
#property indicator_width2  2

#property indicator_label3  "VWAP"
#property indicator_type3   DRAW_LINE
#property indicator_color3  clrDeepSkyBlue
#property indicator_style3  STYLE_SOLID
#property indicator_width3  2

#property indicator_label4  "BUY"
#property indicator_type4   DRAW_ARROW
#property indicator_color4  clrLime
#property indicator_width4  3

#property indicator_label5  "SELL"
#property indicator_type5   DRAW_ARROW
#property indicator_color5  clrTomato
#property indicator_width5  3

input group  "=== Risk ==="
input double  InpATRMult      = 1.5;
input int     InpATRPeriod    = 14;

input group  "=== Periods ==="
input int     InpEMAFast      = 50;
input int     InpEMASlow      = 200;
input int     InpRSI          = 14;
input int     InpMACDFast     = 12;
input int     InpMACDSlow     = 26;
input int     InpMACDSig      = 9;
input int     InpADX          = 14;
input int     InpVolMA        = 20;

input group  "=== Smart Entry Filter ==="
input bool    InpUseFilter    = true;  // Enable smart filter
input int     InpMinScore     = 4;     // Min conditions out of 7 (4 = balanced)

input group  "=== Session Filter ==="
input bool    InpUseSession   = false; // OFF by default — turn ON if needed
input bool    InpAsian        = true;  // Asian   00:00-08:00 GMT
input bool    InpLondon       = true;  // London  08:00-17:00 GMT
input bool    InpNewYork      = true;  // New York 13:00-22:00 GMT

input group  "=== Lot Size Calculator ==="
input bool    InpLotCalc      = true;
input double  InpAccountBal   = 0;     // 0 = auto detect
input double  InpRiskPercent  = 1.0;   // Risk % per trade

input group  "=== Candle Patterns ==="
input bool    InpPatterns     = true;

input group  "=== Display ==="
input bool    InpDashboard    = true;
input bool    InpLevels       = true;
input bool    InpSignals      = true;
input bool    InpAlerts       = true;  // Enable TP hit alerts

double B_EMA9[], B_EMA21[], B_VWAP[], B_BUY[], B_SELL[];

int hEma9, hEma21, hRSI, hATR, hMACD, hADX, hRSI5m;

double   gEntry=0, gSL=0;
double   gTP1=0, gTP2=0, gTP3=0, gTP4=0, gTP5=0;
int      gSig=0;
bool     gT1=false,gT2=false,gT3=false,gT4=false,gT5=false;
datetime gSigTime=0;
string   gPattern="";
double   gRR=0;
double   gLotSize=0;

string P = "SNP_";
string D = "DSH_";

color C_BG      = C'10,12,20';
color C_PANEL   = C'20,24,40';
color C_BORDER  = C'70,80,120';
color C_HEADER  = C'28,34,58';
color C_GREEN   = C'0,230,110';
color C_RED     = C'255,70,70';
color C_YELLOW  = C'255,220,0';
color C_BLUE    = C'80,160,255';
color C_CYAN    = C'0,220,220';
color C_GRAY    = C'160,170,200';
color C_WHITE   = C'240,245,255';
color C_BULL_BG = C'0,100,50';
color C_BEAR_BG = C'110,25,25';
color C_ORANGE  = C'255,165,0';
color C_PURPLE  = C'180,100,255';
color C_GOLD    = C'255,200,50';

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

void OnDeinit(const int reason)
{
   ClearAll();
   Comment("");
   IndicatorRelease(hEma9); IndicatorRelease(hEma21);
   IndicatorRelease(hRSI);  IndicatorRelease(hATR);
   IndicatorRelease(hMACD); IndicatorRelease(hADX);
   IndicatorRelease(hRSI5m);
}

bool IsActiveSession()
{
   if(!InpUseSession) return true;
   MqlDateTime dt;
   TimeToStruct(TimeGMT(),dt);
   int h=dt.hour;
   bool asian   = InpAsian   && (h>=0  && h<8);
   bool london  = InpLondon  && (h>=8  && h<17);
   bool newyork = InpNewYork && (h>=13 && h<22);
   return (asian||london||newyork);
}

void CalcScoreAtBar(
   int r,
   const double &e9[], const double &e21[],
   const double &rsi[], const double &mm[], const double &ms[],
   const double &adx[],
   const double &vwap_arr[],   // forward indexed (B_VWAP)
   const double &open_arr[],   // forward indexed
   const double &close_arr[],  // forward indexed
   const long   &tvol[],       // forward indexed
   int rates_total,
   int &bScore, int &rScore)
{
   bScore=0; rScore=0;

   int fi = rates_total-1-r;

   double cC   = (fi>=0&&fi<rates_total)? close_arr[fi] : 0;
   double cO   = (fi>=0&&fi<rates_total)? open_arr[fi]  : 0;
   double cVwap= (fi>=0&&fi<rates_total)? vwap_arr[fi]  : 0;
   double cE9  = (r<ArraySize(e9))  ? e9[r]  : 0;
   double cE21 = (r<ArraySize(e21)) ? e21[r] : 0;
   double cRSI = (r<ArraySize(rsi)) ? rsi[r] : 50;
   double cMm  = (r<ArraySize(mm))  ? mm[r]  : 0;
   double cMs  = (r<ArraySize(ms))  ? ms[r]  : 0;
   double cADX = (r<ArraySize(adx)) ? adx[r] : 0;

   double cVolMA=0;
   int vb=MathMin(20,fi+1);
   for(int k=fi-vb+1;k<=fi;k++)
      if(k>=0&&k<rates_total) cVolMA+=(double)tvol[k];
   if(vb>0) cVolMA/=vb;
   long cVol=(fi>=0&&fi<rates_total)?tvol[fi]:0;

   if(cC>cVwap)             bScore++; else rScore++;
   if(cRSI>50)              bScore++; else rScore++;
   if(cMm>cMs)              bScore++; else rScore++;
   if(cE9>cE21)             bScore++; else rScore++;
   if(cADX>25&&cC>cE9)    bScore++; else if(cADX>25&&cC<cE9) rScore++;
   if(cVol>cVolMA&&cC>cO) bScore++; else if(cVol>cVolMA&&cC<cO) rScore++;

}

string DetectPattern(const double &open[], const double &high[],
                     const double &low[],  const double &close[],
                     int r, double atr)
{
   if(!InpPatterns) return "";
   if(r+2>=ArraySize(open)) return "";

   double body   = MathAbs(close[r]-open[r]);
   double bodyP  = close[r]-open[r];
   double hiWick = high[r] -MathMax(close[r],open[r]);
   double loWick = MathMin(close[r],open[r])-low[r];
   double small  = atr*0.3;
   double big    = atr*0.6;

   if(close[r+1]<open[r+1]&&close[r]>open[r]&&
      open[r]<=close[r+1]&&close[r]>=open[r+1])   return "Bullish Engulfing";
   if(close[r+1]>open[r+1]&&close[r]<open[r]&&
      open[r]>=close[r+1]&&close[r]<=open[r+1])   return "Bearish Engulfing";
   if(loWick>=body*2.0&&hiWick<=body*0.5&&body>=small)  return "Hammer";
   if(hiWick>=body*2.0&&loWick<=body*0.5&&body>=small)  return "Shooting Star";
   if(loWick>=atr*0.6&&body<=small)                      return "Bull Pin Bar";
   if(hiWick>=atr*0.6&&body<=small)                      return "Bear Pin Bar";
   if(body<=atr*0.1&&(hiWick+loWick)>=atr*0.4)           return "Doji";
   if(bodyP>=big&&loWick<=body*0.2&&hiWick<=body*0.2)    return "Strong Bull Bar";
   if(-bodyP>=big&&loWick<=body*0.2&&hiWick<=body*0.2)   return "Strong Bear Bar";
   return "";
}

double CalcLotSize(double slDist)
{
   if(!InpLotCalc||slDist<=0) return 0;
   double balance  = (InpAccountBal>0)?InpAccountBal:AccountInfoDouble(ACCOUNT_BALANCE);
   double riskAmt  = balance*(InpRiskPercent/100.0);
   double tickVal  = SymbolInfoDouble(_Symbol,SYMBOL_TRADE_TICK_VALUE);
   double tickSize = SymbolInfoDouble(_Symbol,SYMBOL_TRADE_TICK_SIZE);
   double lotStep  = SymbolInfoDouble(_Symbol,SYMBOL_VOLUME_STEP);
   double minLot   = SymbolInfoDouble(_Symbol,SYMBOL_VOLUME_MIN);
   double maxLot   = SymbolInfoDouble(_Symbol,SYMBOL_VOLUME_MAX);
   if(tickVal<=0||tickSize<=0) return 0;
   double valPerPoint = tickVal/tickSize;
   if(valPerPoint<=0) return 0;
   double lot = riskAmt/(slDist/tickSize*tickVal);
   lot = MathFloor(lot/lotStep)*lotStep;
   lot = MathMax(minLot,MathMin(maxLot,lot));
   return NormalizeDouble(lot,2);
}

int OnCalculate(const int rates_total,
                const int prev_calculated,
                const datetime &time[],
                const double   &open[],
                const double   &high[],
                const double   &low[],
                const double   &close[],
                const long     &tick_volume[],
                const long     &volume[],
                const int      &spread[])
{
      // код доступен только после оплаты
   }
   if(rates_total<InpEMASlow+30) return 0;

   double e9[],e21[],rsi[],atr[],mm[],ms[],adx[],r5m[];
   ArraySetAsSeries(e9,true);  ArraySetAsSeries(e21,true);
   ArraySetAsSeries(rsi,true); ArraySetAsSeries(atr,true);
   ArraySetAsSeries(mm,true);  ArraySetAsSeries(ms,true);
   ArraySetAsSeries(adx,true); ArraySetAsSeries(r5m,true);

   if(CopyBuffer(hEma9, 0,0,rates_total,e9)  <=0) return 0;
   if(CopyBuffer(hEma21,0,0,rates_total,e21) <=0) return 0;
   if(CopyBuffer(hRSI,  0,0,rates_total,rsi) <=0) return 0;
   if(CopyBuffer(hATR,  0,0,rates_total,atr) <=0) return 0;
   if(CopyBuffer(hMACD, 0,0,rates_total,mm)  <=0) return 0;
   if(CopyBuffer(hMACD, 1,0,rates_total,ms)  <=0) return 0;
   if(CopyBuffer(hADX,  0,0,rates_total,adx) <=0) return 0;
   CopyBuffer(hRSI5m,0,0,MathMin(10,rates_total),r5m);

   ArraySetAsSeries(B_EMA9,false);  ArraySetAsSeries(B_EMA21,false);
   ArraySetAsSeries(B_VWAP,false);  ArraySetAsSeries(B_BUY,false);
   ArraySetAsSeries(B_SELL,false);

   int s=(prev_calculated<=1)?0:prev_calculated-1;
   double cumTPV=0,cumVol=0;

   for(int i=s;i<rates_total;i++)
   {
      int r=rates_total-1-i;
      B_EMA9[i]  = (r<ArraySize(e9))  ? e9[r]  : EMPTY_VALUE;
      B_EMA21[i] = (r<ArraySize(e21)) ? e21[r] : EMPTY_VALUE;

      if(i==0){cumTPV=0;cumVol=0;}
      else
      {
         MqlDateTime d1,d2;
         TimeToStruct(time[i],d1);
         TimeToStruct(time[i-1],d2);
         if(d1.day!=d2.day){cumTPV=0;cumVol=0;}
      }
      double hlc3=(high[i]+low[i]+close[i])/3.0;
      double v=(double)tick_volume[i];
      cumTPV+=hlc3*v; cumVol+=v;
      B_VWAP[i]=(cumVol>0)?cumTPV/cumVol:close[i];
      B_BUY[i]=0; B_SELL[i]=0;
   }

   int sf=(prev_calculated<=2)?1:prev_calculated-1;

   for(int i=sf; i<rates_total-1; i++)
   {
      int r  = rates_total-1-i;   // series index (0=latest)
      int r1 = r+1;
      if(r1>=ArraySize(e9)||r1>=ArraySize(e21)) continue;

      bool crossUp = (e9[r1] <= e21[r1]) && (e9[r] > e21[r]);  // 9 crossed above 21
      bool crossDn = (e9[r1] >= e21[r1]) && (e9[r] < e21[r]);  // 9 crossed below 21

      if(!crossUp && !crossDn) continue;  // no crossover this bar
      if(time[i] == gSigTime)  continue;  // same bar, skip

      bool doBuy  = crossUp;
      bool doSell = crossDn;

      if(InpUseFilter)
      {
         int bSc=0, rSc=0;
         CalcScoreAtBar(r,e9,e21,rsi,mm,ms,adx,
                        B_VWAP,open,close,tick_volume,
                        rates_total,bSc,rSc);
         if(doBuy  && bSc < InpMinScore) continue;
         if(doSell && rSc < InpMinScore) continue;
      }

      if(InpUseSession && i==(rates_total-2))
      {
         if(!IsActiveSession()) continue;
      }

      gSig     = doBuy ? 1 : -1;
      gSigTime = time[i];
      gEntry   = close[i];

      double atrVal = (r<ArraySize(atr)) ? atr[r] : atr[0];
      double risk   = atrVal * InpATRMult;

      gSL  = doBuy ? gEntry-risk     : gEntry+risk;
      gTP1 = doBuy ? gEntry+risk     : gEntry-risk;
      gTP2 = doBuy ? gEntry+risk*2.0 : gEntry-risk*2.0;
      gTP3 = doBuy ? gEntry+risk*3.0 : gEntry-risk*3.0;
      gTP4 = doBuy ? gEntry+risk*4.0 : gEntry-risk*4.0;
      gTP5 = doBuy ? gEntry+risk*5.0 : gEntry-risk*5.0;
      gT1=gT2=gT3=gT4=gT5=false;

      double rwd = MathAbs(gTP3-gEntry);
      double rsk = MathAbs(gSL-gEntry);
      gRR = (rsk>0) ? NormalizeDouble(rwd/rsk,1) : 0;

      gPattern = DetectPattern(open,high,low,close,r,atrVal);

      gLotSize = CalcLotSize(MathAbs(gEntry-gSL));

      if(InpSignals)
      {
         if(doBuy)  B_BUY[i]  = low[i]  - atrVal*0.5;
         else       B_SELL[i] = high[i] + atrVal*0.5;
      }

      if(InpLevels) DrawLevels();
   }

   int last=rates_total-1;
   if(gSig!=0)
   {
      double cH=high[last], cL=low[last];
      if(gSig==1)
      {
         if(!gT1&&cH>=gTP1){gT1=true;HitLine(P+"TP1");if(InpAlerts)Alert("Sniper TP1 HIT @ "+DoubleToString(gTP1,_Digits));}
         if(!gT2&&cH>=gTP2){gT2=true;HitLine(P+"TP2");if(InpAlerts)Alert("Sniper TP2 HIT @ "+DoubleToString(gTP2,_Digits));}
         if

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