スキャルピングEAの作り方｜ロジック・ソースコード公開と高勝率EAの検証

//+------------------------------------------------------------------+
//| AI_HighWin_Scalper_v1.00.mq4                                    |
//| 2026 High-Win-Rate Scalping EA - Final Verified Version                 |
//| https://fx-prog.com/                                             |
//+------------------------------------------------------------------+
#property strict
#property version   "1.00"
#property description "USDJPY M5 high-win-rate scalper - verified 2025 backtest version"
#property description "EMA trend + Stochastic pullback + ATR volatility filter"
#property description "No martingale / no averaging down / one position per symbol+magic"

//--- Verified baseline
// USDJPY / M5 / 2025 full year / Every tick / spread 5 points
// EMA50/EMA200 trend filter
// Stochastic(5,3,3): BuyLevel=17 / SellLevel=90
// ATR(14): 2.5 - 12.0 pips
// TP=5 pips / SL=25 pips / Risk=0.5% of balance
// No martingale / no averaging down / one position per symbol+magic
//
// 2025 reference result (FXTF-Demo):
// 698 trades / win rate 85.39% / PF 1.18 / max DD 2.89%
// OOS 2025-10-01 to 2025-12-31: win rate 84.62% / PF 1.11
// Backtest results do not guarantee future performance.

//--- Signal settings
input ENUM_TIMEFRAMES SignalTimeframe = PERIOD_M5;

//--- Trend filter
input int FastEMAPeriod = 50;
input int SlowEMAPeriod = 200;

//--- Pullback / reversal timing
input int StochKPeriod  = 5;
input int StochDPeriod  = 3;
input int StochSlowing  = 3;
input int BuyLevel      = 17;
input int SellLevel     = 90;

//--- Volatility filter
input int    ATRPeriod  = 14;
input double ATRMinPips = 2.5;
input double ATRMaxPips = 12.0;

//--- Exit settings
input double TakeProfitPips = 5.0;
input double StopLossPips   = 25.0;

//--- Execution / risk settings
input int    MaxSpreadPoints = 5;
input double BrokerMinDistancePips = 5.0; // FXTF: minimum TP/SL distance
input double RiskPercent     = 0.5;
input int    SlippagePoints  = 20;
input int    MagicNumber     = 26082410;

//--- Internal state
datetime g_lastBarTime = 0;

//+------------------------------------------------------------------+
//| Expert initialization                                            |
//+------------------------------------------------------------------+
int OnInit()
{
   if(FastEMAPeriod <= 0 ||
      SlowEMAPeriod <= FastEMAPeriod ||
      StochKPeriod <= 0 ||
      StochDPeriod <= 0 ||
      StochSlowing <= 0 ||
      BuyLevel < 0 || BuyLevel > 100 ||
      SellLevel < 0 || SellLevel > 100 ||
      BuyLevel >= SellLevel ||
      ATRPeriod <= 0 ||
      ATRMinPips < 0.0 ||
      ATRMaxPips <= ATRMinPips ||
      TakeProfitPips <= 0.0 ||
      StopLossPips <= 0.0 ||
      MaxSpreadPoints < 0 ||
      BrokerMinDistancePips < 0.0 ||
      TakeProfitPips + 1e-8 < BrokerMinDistancePips ||
      StopLossPips + 1e-8 < BrokerMinDistancePips ||
      RiskPercent <= 0.0)
   {
      Print("Invalid input parameters.");
      return(INIT_PARAMETERS_INCORRECT);
   }

   g_lastBarTime = iTime(Symbol(), SignalTimeframe, 0);

   double brokerStopLevelPips =
      (MarketInfo(Symbol(), MODE_STOPLEVEL) * Point) / PipSize();

   Print("AI_HighWin_Scalper_v1.00 initialized. Symbol=", Symbol(),
         " TF=", SignalTimeframe,
         " Digits=", Digits,
         " Point=", DoubleToString(Point, Digits),
         " PipSize=", DoubleToString(PipSize(), Digits),
         " TP=", DoubleToString(TakeProfitPips, 1), " pips",
         " SL=", DoubleToString(StopLossPips, 1), " pips",
         " UserMinDistance=", DoubleToString(BrokerMinDistancePips, 1), " pips",
         " BrokerStopLevel=", DoubleToString(brokerStopLevelPips, 1), " pips",
         " MaxSpread=", MaxSpreadPoints, " points",
         " Risk=", DoubleToString(RiskPercent, 2), "%");

   return(INIT_SUCCEEDED);
}

//+------------------------------------------------------------------+
//| Expert tick                                                      |
//+------------------------------------------------------------------+
void OnTick()
{
   if(!IsNewSignalBar())
      return;

   if(!EnoughBars())
      return;

   // One market position per symbol + MagicNumber
   if(HasOpenPosition())
      return;

   if(!SpreadIsAcceptable())
      return;

   int signal = GetEntrySignal(); // 1=BUY, -1=SELL, 0=NONE
   if(signal == 0)
      return;

   OpenPosition(signal);
}

//+------------------------------------------------------------------+
//| Detect a new bar on the signal timeframe                         |
//+------------------------------------------------------------------+
bool IsNewSignalBar()
{
   datetime currentBarTime = iTime(Symbol(), SignalTimeframe, 0);

   if(currentBarTime <= 0)
      return(false);

   if(currentBarTime == g_lastBarTime)
      return(false);

   g_lastBarTime = currentBarTime;
   return(true);
}

//+------------------------------------------------------------------+
//| Ensure enough history exists                                     |
//+------------------------------------------------------------------+
bool EnoughBars()
{
   int required = SlowEMAPeriod + 20;
   int bars = iBars(Symbol(), SignalTimeframe);

   if(bars < required)
   {
      Print("Not enough bars. Required=", required, " Current=", bars);
      return(false);
   }

   return(true);
}

//+------------------------------------------------------------------+
//| Spread filter                                                    |
//| MaxSpreadPoints uses MT4 points.                                 |
//| Example on 3/5-digit FX: 5 points = 0.5 pip.                     |
//+------------------------------------------------------------------+
bool SpreadIsAcceptable()
{
   double spreadPoints = MarketInfo(Symbol(), MODE_SPREAD);

   if(spreadPoints > MaxSpreadPoints)
   {
      Print("Spread filter: current=", DoubleToString(spreadPoints, 0),
            " points, max=", MaxSpreadPoints);
      return(false);
   }

   return(true);
}

//+------------------------------------------------------------------+
//| Entry logic                                                      |
//| Uses only closed bars (shift 1 and 2).                           |
//+------------------------------------------------------------------+
int GetEntrySignal()
{
   //--- Trend filter: EMA50 vs EMA200 on the latest closed bar
   double fastEMA = iMA(Symbol(), SignalTimeframe, FastEMAPeriod, 0,
                        MODE_EMA, PRICE_CLOSE, 1);

   double slowEMA = iMA(Symbol(), SignalTimeframe, SlowEMAPeriod, 0,
                        MODE_EMA, PRICE_CLOSE, 1);

   //--- Stochastic 5,3,3 / SMA / Low-High
   double k1 = iStochastic(Symbol(), SignalTimeframe,
                           StochKPeriod, StochDPeriod, StochSlowing,
                           MODE_SMA, 0, MODE_MAIN, 1);

   double d1 = iStochastic(Symbol(), SignalTimeframe,
                           StochKPeriod, StochDPeriod, StochSlowing,
                           MODE_SMA, 0, MODE_SIGNAL, 1);

   double k2 = iStochastic(Symbol(), SignalTimeframe,
                           StochKPeriod, StochDPeriod, StochSlowing,
                           MODE_SMA, 0, MODE_MAIN, 2);

   double d2 = iStochastic(Symbol(), SignalTimeframe,
                           StochKPeriod, StochDPeriod, StochSlowing,
                           MODE_SMA, 0, MODE_SIGNAL, 2);

   //--- ATR volatility filter
   double atrPrice = iATR(Symbol(), SignalTimeframe, ATRPeriod, 1);
   double atrPips  = atrPrice / PipSize();

   if(atrPips < ATRMinPips || atrPips > ATRMaxPips)
      return(0);

   //--- BUY
   // Uptrend + oversold pullback + bullish Stochastic cross
   bool buySignal =
      (fastEMA > slowEMA) &&
      (k1 < BuyLevel) &&
      (k2 <= d2) &&
      (k1 > d1);

   if(buySignal)
      return(1);

   //--- SELL
   // Downtrend + overbought pullback + bearish Stochastic cross
   bool sellSignal =
      (fastEMA < slowEMA) &&
      (k1 > SellLevel) &&
      (k2 >= d2) &&
      (k1 < d1);

   if(sellSignal)
      return(-1);

   return(0);
}

//+------------------------------------------------------------------+
//| Check open positions for this symbol + MagicNumber               |
//+------------------------------------------------------------------+
bool HasOpenPosition()
{
   for(int i = OrdersTotal() - 1; i >= 0; i--)
   {
      if(!OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
         continue;

      if(OrderSymbol() != Symbol())
         continue;

      if(OrderMagicNumber() != MagicNumber)
         continue;

      if(OrderType() == OP_BUY || OrderType() == OP_SELL)
         return(true);
   }

   return(false);
}

//+------------------------------------------------------------------+
//| Open a market position                                           |
//+------------------------------------------------------------------+
bool OpenPosition(int signal)
{
   RefreshRates();

   int orderType;
   double entryPrice;
   double stopLoss;
   double takeProfit;

   double pip = PipSize();

   if(signal > 0)
   {
      orderType  = OP_BUY;
      entryPrice = Ask;
      stopLoss   = entryPrice - StopLossPips * pip;
      takeProfit = entryPrice + TakeProfitPips * pip;
   }
   else
   {
      orderType  = OP_SELL;
      entryPrice = Bid;
      stopLoss   = entryPrice + StopLossPips * pip;
      takeProfit = entryPrice - TakeProfitPips * pip;
   }

   // Minimum TP/SL distance check.
   // FXTF requires at least 5 pips; MODE_STOPLEVEL is also respected.
   double brokerStopLevelPips =
      (MarketInfo(Symbol(), MODE_STOPLEVEL) * Point) / pip;

   double requiredMinPips = MathMax(BrokerMinDistancePips,
                                    brokerStopLevelPips);

   double actualSLPips = MathAbs(entryPrice - stopLoss) / pip;
   double actualTPPips = MathAbs(entryPrice - takeProfit) / pip;

   if(actualSLPips + 1e-8 < requiredMinPips ||
      actualTPPips + 1e-8 < requiredMinPips)
   {
      Print("Order skipped: minimum distance not met.",
            " Required=", DoubleToString(requiredMinPips, 1), " pips",
            " ActualSL=", DoubleToString(actualSLPips, 1), " pips",
            " ActualTP=", DoubleToString(actualTPPips, 1), " pips",
            " MODE_STOPLEVEL=", DoubleToString(brokerStopLevelPips, 1), " pips");
      return(false);
   }

   double lots = CalculateRiskLot(StopLossPips);

   if(lots <= 0.0)
   {
      Print("Order skipped: calculated lot size is invalid.");
      return(false);
   }

   entryPrice = NormalizeDouble(entryPrice, Digits);
   stopLoss   = NormalizeDouble(stopLoss, Digits);
   takeProfit = NormalizeDouble(takeProfit, Digits);

   ResetLastError();

   int ticket = OrderSend(Symbol(),
                          orderType,
                          lots,
                          entryPrice,
                          SlippagePoints,
                          stopLoss,
                          takeProfit,
                          "AI_HighWin_Scalper_v1.00",
                          MagicNumber,
                          0,
                          (orderType == OP_BUY ? clrBlue : clrRed));

   if(ticket < 0)
   {
      int err = GetLastError();
      Print("OrderSend failed. Error=", err,
            " Type=", orderType,
            " Lots=", DoubleToString(lots, 2),
            " Entry=", DoubleToString(entryPrice, Digits),
            " SL=", DoubleToString(stopLoss, Digits),
            " TP=", DoubleToString(takeProfit, Digits));
      return(false);
   }

   Print("Order opened. Ticket=", ticket,
         " Type=", (orderType == OP_BUY ? "BUY" : "SELL"),
         " Lots=", DoubleToString(lots, 2),
         " Entry=", DoubleToString(entryPrice, Digits),
         " SL=", DoubleToString(stopLoss, Digits),
         " TP=", DoubleToString(takeProfit, Digits),
         " SLdist=", DoubleToString(MathAbs(entryPrice-stopLoss)/pip, 1), " pips",
         " TPdist=", DoubleToString(MathAbs(entryPrice-takeProfit)/pip, 1), " pips");

   return(true);
}

//+------------------------------------------------------------------+
//| Risk-based lot calculation                                       |
//| RiskPercent is account-balance based.                            |
//+------------------------------------------------------------------+
double CalculateRiskLot(double stopLossPips)
{
   double riskMoney = AccountBalance() * RiskPercent / 100.0;

   if(riskMoney <= 0.0 || stopLossPips <= 0.0)
      return(0.0);

   double pip = PipSize();
   double stopDistancePrice = stopLossPips * pip;

   // MODE_TICKVALUE = money value of one tick for 1.0 lot.
   // MODE_TICKSIZE  = minimum price movement corresponding to that tick.
   // Therefore: number of ticks to SL = price distance / tick size.
   double tickValue = MarketInfo(Symbol(), MODE_TICKVALUE);
   double tickSize  = MarketInfo(Symbol(), MODE_TICKSIZE);

   if(tickValue <= 0.0 || tickSize <= 0.0)
   {
      Print("Risk lot error: invalid tick data. TickValue=",
            DoubleToString(tickValue, 8),
            " TickSize=", DoubleToString(tickSize, Digits));
      return(0.0);
   }

   double ticksToSL = stopDistancePrice / tickSize;
   double lossPerLot = ticksToSL * tickValue;

   if(lossPerLot <= 0.0)
      return(0.0);

   double rawLots = riskMoney / lossPerLot;
   double lots = NormalizeLot(rawLots);

   double expectedLoss = lossPerLot * lots;
   double expectedRiskPct = 0.0;
   if(AccountBalance() > 0.0)
      expectedRiskPct = expectedLoss / AccountBalance() * 100.0;

   Print("Risk lot calc: Balance=", DoubleToString(AccountBalance(), 2),
         " RiskMoney=", DoubleToString(riskMoney, 2),
         " SL=", DoubleToString(stopLossPips, 1), " pips",
         " TickValue=", DoubleToString(tickValue, 8),
         " TickSize=", DoubleToString(tickSize, Digits),
         " LossPerLot=", DoubleToString(lossPerLot, 2),
         " RawLots=", DoubleToString(rawLots, 4),
         " Lots=", DoubleToString(lots, 2),
         " ExpectedLoss=", DoubleToString(expectedLoss, 2),
         " ExpectedRisk=", DoubleToString(expectedRiskPct, 3), "%");

   return(lots);
}

//+------------------------------------------------------------------+
//| Normalize lot to broker limits                                   |
//+------------------------------------------------------------------+
double NormalizeLot(double lots)
{
   double minLot  = MarketInfo(Symbol(), MODE_MINLOT);
   double maxLot  = MarketInfo(Symbol(), MODE_MAXLOT);
   double lotStep = MarketInfo(Symbol(), MODE_LOTSTEP);

   if(minLot <= 0.0)
      minLot = 0.01;

   if(maxLot <= 0.0)
      maxLot = minLot;

   if(lotStep <= 0.0)
      lotStep = 0.01;

   // Do not round a risk-based position UP to the broker minimum.
   // If the requested risk is too small for the minimum lot, skip the trade.
   if(lots + 1e-12 < minLot)
   {
      Print("Risk lot skipped: calculated lot is below broker minimum.",
            " RawLots=", DoubleToString(lots, 4),
            " MinLot=", DoubleToString(minLot, 4));
      return(0.0);
   }

   if(lots > maxLot)
      lots = maxLot;

   lots = MathFloor((lots + 1e-12) / lotStep) * lotStep;

   if(lots + 1e-12 < minLot)
      return(0.0);

   int lotDigits = 2;

   if(lotStep >= 1.0)
      lotDigits = 0;
   else if(lotStep >= 0.1)
      lotDigits = 1;
   else if(lotStep >= 0.01)
      lotDigits = 2;
   else
      lotDigits = 3;

   return(NormalizeDouble(lots, lotDigits));
}

//+------------------------------------------------------------------+
//| Pip size helper                                                  |
//| 5-digit / 3-digit FX: 1 pip = 10 points                          |
//+------------------------------------------------------------------+
double PipSize()
{
   if(Digits == 3 || Digits == 5)
      return(Point * 10.0);

   return(Point);
}
//+------------------------------------------------------------------+