ICT POWER GOLD EA

#property strict
#property version   "1.0"
#property description ""

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

enum ENUM_ALGO_MODE   { ALGO_SMALL_MANIPULATION, ALGO_SHORT_ACCUMULATION, ALGO_BIG_MANIPULATION };
enum ENUM_BREAKOUT    { BRK_CLOSE, BRK_WICK };
enum ENUM_TPSL_METHOD { METHOD_DYNAMIC, METHOD_FIXED };
enum ENUM_RISK        { RISK_HIGHEST, RISK_HIGH, RISK_NORMAL, RISK_LOW, RISK_LOWEST };
enum ENUM_LOT_MODE    { LOT_FIXED, LOT_RISK_PERCENT };
enum ENUM_PO3_STATE   { ST_WAIT_ACC, ST_WAIT_ACC_END, ST_WAIT_MANIP, ST_WAIT_DIST, ST_ENTRY, ST_TP, ST_SL, ST_DONE };

input group "ICT POWER Strategy"
input ENUM_ALGO_MODE   InpAlgoMode  = ALGO_SMALL_MANIPULATION;
input ENUM_BREAKOUT    InpBreakout  = BRK_WICK;
input ENUM_TPSL_METHOD InpMethod    = METHOD_DYNAMIC;
input ENUM_RISK        InpRisk      = RISK_NORMAL;
input double           InpTPPercent = 0.3;
input double           InpSLPercent = 0.4;

input group "Trading"
input bool             TradingEnabled = true;
input bool             AllowBuy = true;
input bool             AllowSell = true;
input ENUM_LOT_MODE    LotMode = LOT_FIXED;
input double           FixedLot = 0.01;
input double           RiskPercent = 1.0;
input int              MaxOpenTrades = 1;
input bool             OneTradePerSignal = true;
input bool             CloseOnOppositeSignal = false;
input ulong            MagicNumber = 260101;
input int              MaxDeviationPoints = 30;
input int              ExtraStopBufferPoints = 10; // extra broker-safe distance beyond Stops Level

input group "Gold / Execution Protection"
input bool             UseSpreadFilter = true;
input double           MaxSpreadPrice = 0.80; // price units, e.g. 0.80 on XAUUSD
input bool             RequireGoldSymbol = false;

input group "Stops"
input bool             UseIndicatorSL = true;
input bool             UseIndicatorTP = true;

#define ATR_LEN 50
#define ACC_EXPAND 0.5
#define RR_RATIO 0.86

struct PO3
{
   ENUM_PO3_STATE state;
   double accTop,accBottom,accEndTop,accEndBottom;
   int accEndIdx;
   double manTop,manBottom;
   int manDir;
   double slTarget,tpTarget;
   int entryType;
   datetime entryTime;
   double entryPrice;

   void Init()
   {
      state=ST_WAIT_ACC;
      accTop=accBottom=accEndTop=accEndBottom=EMPTY_VALUE;
      accEndIdx=-1;
      manTop=manBottom=EMPTY_VALUE;
      manDir=0;
      slTarget=tpTarget=EMPTY_VALUE;
      entryType=0;
      entryTime=0;
      entryPrice=EMPTY_VALUE;
   }
};

PO3 g_po3;
int g_accLen=40;
double g_accMult=5.0,g_manMult=0.6,g_slMult=5.0;
datetime g_lastBar=0;
datetime g_lastSignalTime=0;
bool g_liveSignalExecution=false;
datetime g_expectedSignalBar=0;

int VolumeDigits(double step)
{
   int d=0;
   while(d<8 && MathAbs(step*MathPow(10,d)-MathRound(step*MathPow(10,d)))>1e-8) d++;
   return d;
}

double NormalizeVolume(double lots)
{
   double minv=SymbolInfoDouble(_Symbol,SYMBOL_VOLUME_MIN);
   double maxv=SymbolInfoDouble(_Symbol,SYMBOL_VOLUME_MAX);
   double step=SymbolInfoDouble(_Symbol,SYMBOL_VOLUME_STEP);
   if(step<=0) return 0;
   lots=MathMax(minv,MathMin(maxv,lots));
   lots=MathFloor(lots/step+1e-9)*step;
   return NormalizeDouble(lots,VolumeDigits(step));
}

bool IsGold()
{
   string s=_Symbol; StringToUpper(s);
   return StringFind(s,"XAU")>=0 || StringFind(s,"GOLD")>=0;
}

int MyPositions()
{
   int n=0;
   for(int i=PositionsTotal()-1;i>=0;i--)
   {
      ulong t=PositionGetTicket(i);
      if(t && PositionSelectByTicket(t) &&
         PositionGetString(POSITION_SYMBOL)==_Symbol &&
         (ulong)PositionGetInteger(POSITION_MAGIC)==MagicNumber) n++;
   }
   return n;
}

double CalcLots(double entry,double sl)
{
   if(LotMode==LOT_FIXED || sl<=0 || entry<=0) return NormalizeVolume(FixedLot);
   double money=AccountInfoDouble(ACCOUNT_EQUITY)*RiskPercent/100.0;
   double tickSize=SymbolInfoDouble(_Symbol,SYMBOL_TRADE_TICK_SIZE);
   double tickValue=SymbolInfoDouble(_Symbol,SYMBOL_TRADE_TICK_VALUE_LOSS);
   if(tickValue<=0) tickValue=SymbolInfoDouble(_Symbol,SYMBOL_TRADE_TICK_VALUE);
   double dist=MathAbs(entry-sl);
   if(money<=0 || tickSize<=0 || tickValue<=0 || dist<=0) return NormalizeVolume(FixedLot);
   double lossPerLot=(dist/tickSize)*tickValue;
   return NormalizeVolume(money/lossPerLot);
}

bool SpreadOK()
{
   if(!UseSpreadFilter) return true;
   MqlTick tick;
   if(!SymbolInfoTick(_Symbol,tick)) return false;
   return (tick.ask-tick.bid)<=MaxSpreadPrice;
}

void CloseOpposite(int signal)
{
   if(!CloseOnOppositeSignal) return;
   for(int i=PositionsTotal()-1;i>=0;i--)
   {
      ulong t=PositionGetTicket(i);
      if(!t || !PositionSelectByTicket(t)) continue;
      if(PositionGetString(POSITION_SYMBOL)!=_Symbol ||
         (ulong)PositionGetInteger(POSITION_MAGIC)!=MagicNumber) continue;
      ENUM_POSITION_TYPE type=(ENUM_POSITION_TYPE)PositionGetInteger(POSITION_TYPE);
      if((signal==1 && type==POSITION_TYPE_SELL) || (signal==-1 && type==POSITION_TYPE_BUY))
         trade.PositionClose(t);
   }
}

double BrokerMinStopDistance()
{
   long stops=SymbolInfoInteger(_Symbol,SYMBOL_TRADE_STOPS_LEVEL);
   double point=SymbolInfoDouble(_Symbol,SYMBOL_POINT);
   return MathMax(0.0,(double)(stops+ExtraStopBufferPoints)*point);
}

void BuildBrokerSafeStops(const int signal,const double actualEntry,
                          const double indicatorEntry,const double indicatorSL,const double indicatorTP,
                          double &safeSL,double &safeTP)
{
   safeSL=0.0;
   safeTP=0.0;

   double slDist=MathAbs(indicatorEntry-indicatorSL);
   double tpDist=MathAbs(indicatorTP-indicatorEntry);
   double minDist=BrokerMinStopDistance();

   if(UseIndicatorSL && slDist>0.0)
   {
      slDist=MathMax(slDist,minDist);
      safeSL=(signal==1 ? actualEntry-slDist : actualEntry+slDist);
      safeSL=NormalizeDouble(safeSL,_Digits);
   }

   if(UseIndicatorTP && tpDist>0.0)
   {
      tpDist=MathMax(tpDist,minDist);
      safeTP=(signal==1 ? actualEntry+tpDist : actualEntry-tpDist);
      safeTP=NormalizeDouble(safeTP,_Digits);
   }
}

bool StopsAreValid(const int signal,const double entry,const double sl,const double tp)
{
   double minDist=BrokerMinStopDistance();
   double eps=SymbolInfoDouble(_Symbol,SYMBOL_POINT)*0.5;

   if(signal==1)
   {
      if(sl>0.0 && (sl>=entry || entry-sl+eps<minDist)) return false;
      if(tp>0.0 && (tp<=entry || tp-entry+eps<minDist)) return false;
   }
   else
   {
      if(sl>0.0 && (sl<=entry || sl-entry+eps<minDist)) return false;
      if(tp>0.0 && (tp>=entry || entry-tp+eps<minDist)) return false;
   }
   return true;
}

void ExecuteSignal(int signal,double sl,double tp,datetime signalTime)
{
   if(!TradingEnabled || signal==0) return;

   if(!g_liveSignalExecution || signalTime!=g_expectedSignalBar) return;

   if(OneTradePerSi

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