Expert Advisor MT5 dengan AI di Deriv — Complete Guide

//+------------------------------------------------------------------+
//|                                       RSI_EMA_Strategy_EA.mq5     |
//|                                            IA Trader Pro (2026)   |
//|                                            https://iatraderpro.com/|
//+------------------------------------------------------------------+
#property copyright "IA Trader Pro 2026"
#property link      "https://iatraderpro.com/"
#property version   "1.00"
#property strict

#include <Trade\Trade.mqh>

//--- Inputs
input int    InpMagic         = 20260512;  // Magic number
input double InpRiskPercent   = 2.0;       // Risk per trade (%)
input int    InpSL_Pips       = 50;        // Stop Loss (pips)
input int    InpTP_Pips       = 100;       // Take Profit (pips)
input int    InpEMA_Fast      = 9;         // EMA Fast period
input int    InpEMA_Slow      = 21;        // EMA Slow period
input int    InpRSI_Period    = 14;        // RSI period
input int    InpRSI_Buy_Max   = 70;        // Max RSI for BUY
input int    InpRSI_Sell_Min  = 30;        // Min RSI for SELL
input int    InpDeviation     = 10;        // Max slippage (points)
input bool   InpUseTimeFilter = false;     // Enable trading hours filter
input int    InpStartHour     = 0;         // Start hour (server time)
input int    InpEndHour       = 23;        // End hour (server time)

//--- Globals
CTrade trade;
int    handleEmaFast = INVALID_HANDLE;
int    handleEmaSlow = INVALID_HANDLE;
int    handleRsi     = INVALID_HANDLE;
datetime lastBarTime = 0;

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
{
    trade.SetExpertMagicNumber(InpMagic);
    trade.SetDeviationInPoints(InpDeviation);
    trade.SetTypeFillingBySymbol(_Symbol);
    
    // Initialize indicator handles
    handleEmaFast = iMA(_Symbol, PERIOD_CURRENT, InpEMA_Fast, 0, MODE_EMA, PRICE_CLOSE);
    handleEmaSlow = iMA(_Symbol, PERIOD_CURRENT, InpEMA_Slow, 0, MODE_EMA, PRICE_CLOSE);
    handleRsi     = iRSI(_Symbol, PERIOD_CURRENT, InpRSI_Period, PRICE_CLOSE);
    
    if(handleEmaFast == INVALID_HANDLE || handleEmaSlow == INVALID_HANDLE || handleRsi == INVALID_HANDLE)
    {
        Print("ERROR: Failed to create indicator handles");
        return(INIT_FAILED);
    }
    
    Print("EA initialized successfully | Magic: ", InpMagic,
          " | Risk: ", InpRiskPercent, "%",
          " | SL: ", InpSL_Pips, " pips | TP: ", InpTP_Pips, " pips");
    
    return(INIT_SUCCEEDED);
}

//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
    if(handleEmaFast != INVALID_HANDLE) IndicatorRelease(handleEmaFast);
    if(handleEmaSlow != INVALID_HANDLE) IndicatorRelease(handleEmaSlow);
    if(handleRsi     != INVALID_HANDLE) IndicatorRelease(handleRsi);
    
    Print("EA deinitialized. Reason: ", reason);
}

//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
{
    // Only process new bar (M5 entries based on closed candles)
    if(!IsNewBar()) return;
    
    // Check trading hours filter
    if(InpUseTimeFilter && !IsTradingTime()) return;
    
    // Skip if already have position
    if(HasOpenPosition()) return;
    
    // Get indicator values
    double emaFast[], emaSlow[], rsi[];
    ArraySetAsSeries(emaFast, true);
    ArraySetAsSeries(emaSlow, true);
    ArraySetAsSeries(rsi, true);
    
    if(CopyBuffer(handleEmaFast, 0, 0, 3, emaFast) < 3) return;
    if(CopyBuffer(handleEmaSlow, 0, 0, 3, emaSlow) < 3) return;
    if(CopyBuffer(handleRsi,     0, 0, 3, rsi)     < 3) return;
    
    // Detect crossovers (bar [1] is the last closed bar)
    bool emaCrossUp   = emaFast[2] <= emaSlow[2] && emaFast[1] > emaSlow[1];
    bool emaCrossDown = emaFast[2] >= emaSlow[2] && emaFast[1] < emaSlow[1];
    
    // BUY signal
    if(emaCrossUp && rsi[1] < InpRSI_Buy_Max)
    {
        OpenPosition(ORDER_TYPE_BUY);
    }
    // SELL signal
    else if(emaCrossDown && rsi[1] > InpRSI_Sell_Min)
    {
        OpenPosition(ORDER_TYPE_SELL);
    }
}

//+------------------------------------------------------------------+
//| Open position with SL/TP and dynamic lot size                    |
//+------------------------------------------------------------------+
void OpenPosition(ENUM_ORDER_TYPE orderType)
{
    double price  = (orderType == ORDER_TYPE_BUY)
                    ? SymbolInfoDouble(_Symbol, SYMBOL_ASK)
                    : SymbolInfoDouble(_Symbol, SYMBOL_BID);
    
    double point  = SymbolInfoDouble(_Symbol, SYMBOL_POINT);
    int    digits = (int)SymbolInfoInteger(_Symbol, SYMBOL_DIGITS);
    int    pipFactor = (digits == 3 || digits == 5) ? 10 : 1;
    double pipSize = point * pipFactor;
    
    double slPrice, tpPrice;
    if(orderType == ORDER_TYPE_BUY)
    {
        slPrice = NormalizeDouble(price - InpSL_Pips * pipSize, digits);
        tpPrice = NormalizeDouble(price + InpTP_Pips * pipSize, digits);
    }
    else
    {
        slPrice = NormalizeDouble(price + InpSL_Pips * pipSize, digits);
        tpPrice = NormalizeDouble(price - InpTP_Pips * pipSize, digits);
    }
    
    // Validate broker stop level
    double minStopLevel = SymbolInfoInteger(_Symbol, SYMBOL_TRADE_STOPS_LEVEL) * point;
    if(MathAbs(price - slPrice) < minStopLevel)
    {
        Print("WARNING: SL too close to price. Min stop level: ", minStopLevel);
        return;
    }
    
    // Calculate lot size based on risk %
    double lotSize = CalculateLotSize(MathAbs(price - slPrice));
    if(lotSize <= 0)
    {
        Print("ERROR: Invalid lot size calculated");
        return;
    }
    
    string comment = (orderType == ORDER_TYPE_BUY) ? "RSI_EMA Long" : "RSI_EMA Short";
    
    bool result = false;
    if(orderType == ORDER_TYPE_BUY)
        result = trade.Buy(lotSize, _Symbol, price, slPrice, tpPrice, comment);
    else
        result = trade.Sell(lotSize, _Symbol, price, slPrice, tpPrice, comment);
    
    if(result)
        Print("✓ ", comment, " opened | Lot: ", lotSize,
              " | Entry: ", price, " | SL: ", slPrice, " | TP: ", tpPrice);
    else
        Print("✗ Order failed: ", trade.ResultRetcode(), " - ", trade.ResultRetcodeDescription());
}

//+------------------------------------------------------------------+
//| Calculate lot size based on risk % and stop distance             |
//+------------------------------------------------------------------+
double CalculateLotSize(double stopDistancePrice)
{
    double balance       = AccountInfoDouble(ACCOUNT_BALANCE);
    double riskAmount    = balance * InpRiskPercent / 100.0;
    double tickValue     = SymbolInfoDouble(_Symbol, SYMBOL_TRADE_TICK_VALUE);
    double tickSize      = SymbolInfoDouble(_Symbol, SYMBOL_TRADE_TICK_SIZE);
    
    if(tickValue == 0 || tickSize == 0 || stopDistancePrice == 0) return 0;
    
    double lossPerLot = (stopDistancePrice / tickSize) * tickValue;
    double lotSize    = riskAmount / lossPerLot;
    
    // Normalize to symbol's lot step
    double lotStep = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_STEP);
    double lotMin  = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MIN);
    double lotMax  = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MAX);
    
    lotSize = MathFloor(lotSize / lotStep) * lotStep;
    lotSize = MathMax(lotMin, MathMin(lotMax, lotSize));
    
    return NormalizeDouble(lotSize, 2);
}

//+------------------------------------------------------------------+
//| Check if a new bar has formed                                    |
//+------------------------------------------------------------------+
bool IsNewBar()
{
    datetime currentBarTime = iTime(_Symbol, PERIOD_CURRENT, 0);
    if(currentBarTime != lastBarTime)
    {
        lastBarTime = currentBarTime;
        return true;
    }
    return false;
}

//+------------------------------------------------------------------+
//| Check if current time within trading hours filter                |
//+------------------------------------------------------------------+
bool IsTradingTime()
{
    MqlDateTime dt;
    TimeCurrent(dt);
    int hour = dt.hour;
    
    if(InpStartHour <= InpEndHour)
        return (hour >= InpStartHour && hour < InpEndHour);
    else
        return (hour >= InpStartHour || hour < InpEndHour);  // wraps midnight
}

//+------------------------------------------------------------------+
//| Check if EA already has open position for this symbol+magic      |
//+------------------------------------------------------------------+
bool HasOpenPosition()
{
    for(int i = PositionsTotal() - 1; i >= 0; i--)
    {
        ulong ticket = PositionGetTicket(i);
        if(ticket > 0)
        {
            if(PositionGetString(POSITION_SYMBOL) == _Symbol &&
               PositionGetInteger(POSITION_MAGIC) == InpMagic)
                return true;
        }
    }
    return false;
}
//+------------------------------------------------------------------+