AurumBreak Clone V0.16

#property strict
#property version   "0.16"
#property description "AurumBreak Clone V0.16 - selective-active structure classifier"

#include <Trade/Trade.mqh>
CTrade trade;

input group "===== RISK PROFILE ====="
input int      InpRiskProfile          = 1;

input group "===== VOLUME ====="
input int      InpVolMode              = 0;
input double   InpVolRiskPct           = 1.0;
input double   InpVolMaxCap            = 0.0;
input double   InpVolFixed             = 0.01;

input group "===== FILTERS ====="
input bool     InpFltMomentum          = true;
input bool     InpFltTrend             = true;
input bool     InpFltHours             = true;
input int      InpFltHourShift         = 0;

input group "===== PROTECTION ====="
input bool     InpGuardBE              = true;
input bool     InpGuardTrail           = true;
input bool     InpGuardFlipClose       = true;
input bool     InpGuardScaleIn         = true;
input bool     InpGuardScaleBuy        = true;
input bool     InpGuardScaleSell       = true;
input int      InpGuardMaxPos          = 6;
input double   InpGuardMaxVol          = 1.0;
input double   InpGuardDayLoss         = 3.0;
input double   InpGuardMaxRiskPct      = 20.0;
input double   InpGuardMaxTotRisk      = 35.0;
input double   InpGuardMinMarginLvl    = 200.0;

input group "===== SESSION ====="
input bool     InpSessUse              = false;
input int      InpSessOffset           = 7;
input int      InpSessStart            = 15;
input int      InpSessEnd              = 1;

input group "===== EXECUTION ====="
input long     InpSysMagic             = 50356;
input string   InpSysTag               = "AurumBreakClone";
input int      InpExecSpreadMax        = 800;
input int      InpExecSlip             = 30;
input bool     InpSysVerbose           = false;

input group "===== STRUCTURE CORE V0.16 ====="
input int      InpReconFastPivot       = 5;      // validated entry swing
input int      InpReconHigherPivot     = 16;     // higher-swing directional bias
input int      InpReconSwingLookback   = 220;
input bool     InpReconFreshCrossOnly  = true;
input int      InpReconADXPeriod       = 14;
input double   InpReconADXMin          = 29.0;
input int      InpReconRSIPeriod       = 14;
input double   InpReconRSIMaxDir       = 78.0;   // anti-overextension (SELL mirror = 22)
input int      InpReconATRPeriod       = 14;
input double   InpReconSL_ATR          = 2.60;
input double   InpReconTP_ATR          = 2.50;
input string   InpReconAllowedHours    = "0,1,3,5,6,7,8,10,11,12,17,18,20,22,23";
input bool     InpReconOnePositionOnly = true;

input group "===== CONTINUATION BRANCH ====="
input bool     InpReconUseContinuation = true;
input double   InpContRSIMinDir        = 60.0;
input double   InpContDIGapMin         = 0.0;
input double   InpContRet3Min          = 0.20;
input int      InpContMaxPivotAge      = 30;
input double   InpContMinRangeATR      = 0.30;

input bool     InpContUseExtension     = true;
input int      InpContExtMaxPivotAge   = 40;
input double   InpContExtADXMin        = 32.0;
input double   InpContExtRSIMinDir     = 64.0;
input double   InpContExtDIGapMin      = 10.0;
input double   InpContExtRet3Min       = 0.80;
input double   InpContExtMinRangeATR   = 0.50;

input group "===== TRANSITION / NEUTRAL BRANCH ====="
input bool     InpReconUseTransition   = true;
input double   InpTransRSIMinDir       = 62.0;
input double   InpTransDIGapMin        = 0.0;
input double   InpTransRet3Min         = 0.00;
input double   InpTransMaxClosePosDir  = 0.80;
input int      InpTransMaxPivotAge     = 30;
input double   InpTransMinRangeATR     = 0.00;

input bool     InpTransUseExtension    = true;
input int      InpTransExtMaxPivotAge  = 40;
input double   InpTransExtADXMin       = 29.0;
input double   InpTransExtRSIMinDir    = 62.0;
input double   InpTransExtDIGapMin     = 12.0;
input double   InpTransExtRet3Min      = 0.80;
input double   InpTransExtMinClosePos  = 0.84;
input double   InpTransExtMaxClosePos  = 0.88;
input double   InpTransExtMinRangeATR  = 0.60;
input double   InpTransExtMaxRangeATR  = 3.00;

input group "===== REVERSAL BRANCH ====="
input bool     InpReconUseReversal     = true;
input double   InpRevADXMin            = 31.0;
input double   InpRevRSIMinDir         = 64.0;
input double   InpRevDIGapMin          = 15.0;
input double   InpRevRet3Min           = 1.20;
input int      InpRevEMAPeriod         = 44;
input double   InpRevMinEMADistATR     = 2.00;   // directional displacement from EMA / ATR
input double   InpRevMinEff6           = 0.20;   // six-bar directional efficiency
input double   InpRevMaxEff24          = 1.00;   // disabled at 1.00; retain V0.14-style REV
input int      InpRevMaxPivotAge       = 30;
input double   InpRevMinRangeATR       = 0.00;

input group "===== RECON GUARD MANAGEMENT ====="
input bool     InpReconActiveGuards    = false;
input double   InpReconBEArmR          = 0.70;
input double   InpReconBELockR         = 0.05;
input double   InpReconTrailArmR       = 0.85;
input double   InpReconTrailATRMult    = 1.00;

#define SIGNAL_TF PERIOD_M15

int hRSI=INVALID_HANDLE, hATR=INVALID_HANDLE, hADX=INVALID_HANDLE, hEMARev=INVALID_HANDLE;
datetime lastBarTime=0;
double dayStartEquity=0.0;
int dayKey=-1;
string lastBranch="";

struct PivotInfo
{
   datetime t;
   double price;
   int shift;
};

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

void OnDeinit(const int reason)
{
   if(hRSI!=INVALID_HANDLE) IndicatorRelease(hRSI);
   if(hATR!=INVALID_HANDLE) IndicatorRelease(hATR);
   if(hADX!=INVALID_HANDLE) IndicatorRelease(hADX);
   if(hEMARev!=INVALID_HANDLE) IndicatorRelease(hEMARev);
}

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

bool IsNewSignalBar()
{
   datetime t=iTime(_Symbol,SIGNAL_TF,0);
   if(t<=0 || t==lastBarTime) return false;
   lastBarTime=t;
   return true;
}

bool FindPivots(const int strength,
                PivotInfo &hi1,PivotInfo &hi2,
                PivotInfo &lo1,PivotInfo &lo2)
{
   int need=InpReconSwingLookback+strength*2+30;
   MqlRates r[]; ArraySetAsSeries(r,true);
   if(CopyRates(_Symbol,SIGNAL_TF,0,need,r)<need) return false;

   hi1.t=hi2.t=lo1.t=lo2.t=0;
   hi1.price=hi2.price=lo1.price=lo2.price=0.0;
   hi1.shift=hi2.shift=lo1.shift=lo2.shift=-1;

   int start=strength+2;
   int end=MathMin(ArraySize(r)-strength-1,InpReconSwingLookback);

   for(int s=start;s<=end;s++)
   {
      bool isH=true,isL=true;
      double ph=r[s].high,pl=r[s].low;
      for(int j=1;j<=strength;j++)
      {
         if(ph<=r[s+j].high) isH=false;
         if(pl>=r[s+j].low)  isL=false;
      }
      for(int j=1;j<=strength;j++)
      {
         if(ph<r[s-j].high) isH=false;
         if(pl>r[s-j].low)  isL=false;
      }

      if(isH)
      {
         if(hi1.t==0) { hi1.t=r[s].time; hi1.price=ph; hi1.shift=s; }
         else if(hi2.t==0) { hi2.t=r[s].time; hi2.price=ph; hi2.shift=s; }
      }
      if(isL)
      {
         if(lo1.t==0) { lo1.t=r[s].time; lo1.price=pl; lo1.shift=s; }
         else if(lo2.t==0) { lo2.t=r[s].time; lo2.price=pl; lo2.shift=s; }
      }
      if(hi1.t>0 && hi2.t>0 && lo1.t>0 && lo2.t>0) break;
   }
   return (hi1.t>0 && lo1.t>0);
}

int HigherSwingBias()
{
   PivotInfo h1,h2,l1,l2;
   if(!FindPivots(InpReconHigherPivot,h1,h2,l1,l2)) return 0;
   if(h2.t==0 || l2.t==0) return 0;

   bool hh=h1.price>h2.price, lh=h1.price<h2.price;
   bool hl=l1.price>l2.price, ll=l1.price<l2.price;
   if(hh && hl) return +1;
   if(lh && ll) return -1;
   return 0;
}

bool BranchPass(const int sig,const int normalizedBias,
                const double dirRSI,const double dirDIGap,
                const double dirRet3,const double dirClosePos,
                const double dirEMADist,const double eff6,const double eff24,
                const double adxNow,const int pivotAge,const double rangeATR)
{
   double maxDir=InpReconRSIMaxDir;
   if(InpFltMomentum && dirRSI>maxDir) return false;

   if(normalizedBias>0)
   {
      if(!InpReconUseContinuation) return false;

      bool baseMom=(!InpFltMomentum || (dirRSI>=InpContRSIMinDir && dirDIGap>=InpContDIGapMin && dirRet3>=InpContRet3Min));
      bool baseAge=(InpContMaxPivotAge<=0 || pivotAge<=InpContMaxPivotAge);
      if(baseMom && baseAge && rangeATR>=InpContMinRangeATR)
      {
         lastBranch="CONT";
         return true;
      }

      if(InpContUseExtension && pivotAge>InpContMaxPivotAge && pivotAge<=InpContExtMaxPivotAge &&
         adxNow>=InpContExtADXMin && dirRSI>=InpContExtRSIMinDir && dirRSI<=maxDir &&
         dirDIGap>=InpContExtDIGapMin && dirRet3>=InpContExtRet3Min && rangeATR>=InpContExtMinRangeATR)
      {
         lastBranch="CONT_X";
         return true;
      }
      return false;
   }
   if(normalizedBias==0)
   {
      if(!InpReconUseTransition) return false;

      bool baseMom=(!InpFltMomentum || (dirRSI>=InpTransRSIMinDir && dirDIGap>=InpTransDIGapMin && dirRet3>=InpTransRet3Min));
      bool baseAge=(InpTransMaxPivotAge<=0 || pivotAge<=InpTransMaxPivotAge);
      if(baseMom && baseAge && dirClosePos<=InpTransMaxClosePosDir && rangeATR>=InpTransMinRangeATR)
      {
         lastBranch="TRANS";
         return true;
      }

      if(InpTransUseExtension && pivotAge<=InpTransExtMaxPivotAge &&
         adxNow>=InpTransExtADXMin && dirRSI>=InpTransExtRSIMinDir && dirRSI<=maxDir &&
         dirDIGap>=InpTransExtDIGapMin 

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