277 lines
11 KiB
MQL5
277 lines
11 KiB
MQL5
//+------------------------------------------------------------------+
|
|
//| OTC Escape EA (Learning) V2 |
|
|
//| Optimized for OTC Markets |
|
|
//| With Machine Learning |
|
|
//+------------------------------------------------------------------+
|
|
#property version "2.00"
|
|
#property strict
|
|
|
|
//--- Include files
|
|
#include <Trade\PositionInfo.mqh>
|
|
#include <Trade\Trade.mqh>
|
|
#include <Trade\SymbolInfo.mqh>
|
|
#include <Trade\AccountInfo.mqh>
|
|
#include <Arrays\ArrayObj.mqh>
|
|
#include <OTCTypes.mqh>
|
|
#include <OTCLearningEngine.mqh>
|
|
|
|
//--- Global Objects
|
|
CPositionInfo m_position; // trade position object
|
|
CTrade m_trade; // trading object
|
|
CSymbolInfo m_symbol; // symbol info object
|
|
CAccountInfo m_account; // account info wrapper
|
|
CLearningEngine *learning_engine = NULL; // learning engine object
|
|
|
|
//--- Indicator Handles
|
|
int handle_ma_fast, handle_ma_slow, handle_rsi, handle_adx, handle_atr;
|
|
|
|
//--- Indicator Buffers
|
|
double ma_fast_buffer[], ma_slow_buffer[], rsi_buffer[], adx_buffer[], atr_buffer[];
|
|
|
|
//--- Input Parameters
|
|
input ulong InpMagicNumber = 12345; // Magic Number
|
|
input ushort InpTakeProfit = 40; // TakeProfit for positions (pips)
|
|
input ushort InpStopLoss = 30; // StopLoss for positions (pips)
|
|
input bool InpUseStopLoss = true; // Use stop loss
|
|
input bool InpUseTakeProfit= true; // Use take profit
|
|
input string InpName_Expert = "OTC_Escape_Learning_V2"; // Expert Name
|
|
input ulong InpSlippage = 3; // Slippage (points)
|
|
input double InpLots = 0.02; // Lot size
|
|
input int InpMAPeriod1 = 5; // Fast MA Period
|
|
input int InpMAPeriod2 = 10; // Slow MA Period
|
|
input ENUM_MA_METHOD InpMAMethod = MODE_SMA; // MA Method
|
|
input ENUM_APPLIED_PRICE InpMAPrice = PRICE_CLOSE; // MA Price
|
|
|
|
input group "=== Advanced Strategy Settings ==="
|
|
input int InpRSI_Period = 14; // RSI Period
|
|
input int InpADX_Period = 14; // ADX Period
|
|
input int InpATR_Period = 14; // ATR Period
|
|
input double InpADX_Threshold = 25.0; // ADX trend strength threshold
|
|
input double InpATR_SL_Multiplier = 2.0; // ATR multiplier for Stop Loss
|
|
input double InpATR_TP_Multiplier = 1.5; // Reward:Risk Ratio for Take Profit
|
|
|
|
input group "=== Order Settings ==="
|
|
input int InpMaxOpenTrades = 5; // Maximum number of open trades
|
|
|
|
input group "=== Learning Engine Settings ==="
|
|
input bool InpUseLearning = true; // Enable learning engine
|
|
input bool InpUseAdaptiveLogic = true; // Enable adaptive SL/TP logic
|
|
input int InpMinTradesForAnalysis = 50; // Min trades per regime to adapt
|
|
input double InpVolatilityThreshold = 0.001; // Volatility threshold for regime change
|
|
input double InpTrendThreshold = 20.0; // Trend strength threshold for regime change
|
|
|
|
//--- Global Variables for Adaptive Logic
|
|
double g_adaptive_sl_pips = 0;
|
|
double g_adaptive_tp_pips = 0;
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Expert initialization function |
|
|
//+------------------------------------------------------------------+
|
|
int OnInit()
|
|
{
|
|
m_symbol.Name(Symbol());
|
|
m_trade.SetExpertMagicNumber(InpMagicNumber);
|
|
m_trade.SetTypeFilling(ORDER_FILLING_FOK);
|
|
|
|
handle_ma_fast = iMA(Symbol(), Period(), InpMAPeriod1, 0, InpMAMethod, InpMAPrice);
|
|
handle_ma_slow = iMA(Symbol(), Period(), InpMAPeriod2, 0, InpMAMethod, InpMAPrice);
|
|
handle_rsi = iRSI(Symbol(), Period(), InpRSI_Period, InpMAPrice);
|
|
handle_adx = iADX(Symbol(), Period(), InpADX_Period);
|
|
handle_atr = iATR(Symbol(), Period(), InpATR_Period);
|
|
|
|
if(handle_ma_fast == INVALID_HANDLE || handle_ma_slow == INVALID_HANDLE || handle_rsi == INVALID_HANDLE || handle_adx == INVALID_HANDLE || handle_atr == INVALID_HANDLE)
|
|
{
|
|
Print("Error creating indicators");
|
|
return(INIT_FAILED);
|
|
}
|
|
|
|
|
|
|
|
if(InpUseLearning)
|
|
{
|
|
learning_engine = new CLearningEngine(InpVolatilityThreshold, InpTrendThreshold);
|
|
if(CheckPointer(learning_engine) == POINTER_INVALID)
|
|
{
|
|
learning_engine = new CLearningEngine();
|
|
if(CheckPointer(learning_engine) == POINTER_INVALID)
|
|
{
|
|
ExpertRemove();
|
|
return(INIT_FAILED);
|
|
}
|
|
}
|
|
learning_engine->Init(Symbol(), Period());
|
|
learning_engine->SetMinTradesForAnalysis(InpMinTradesForAnalysis);
|
|
}
|
|
|
|
Print("OTC Escape EA V2 initialized successfully");
|
|
return(INIT_SUCCEEDED);
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Expert deinitialization function |
|
|
//+------------------------------------------------------------------+
|
|
void OnDeinit(const int reason)
|
|
{
|
|
IndicatorRelease(handle_ma_fast);
|
|
IndicatorRelease(handle_ma_slow);
|
|
IndicatorRelease(handle_rsi);
|
|
IndicatorRelease(handle_adx);
|
|
IndicatorRelease(handle_atr);
|
|
|
|
if(CheckPointer(learning_engine) == POINTER_DYNAMIC)
|
|
{
|
|
delete learning_engine;
|
|
}
|
|
Print("OTC Escape EA V2 deinitialized");
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Expert tick function |
|
|
//+------------------------------------------------------------------+
|
|
void OnTick()
|
|
{
|
|
m_symbol.RefreshRates();
|
|
static datetime last_bar = 0;
|
|
datetime current_bar = (datetime)SeriesInfoInteger(Symbol(), Period(), SERIES_LASTBAR_DATE);
|
|
if(last_bar == current_bar) return;
|
|
last_bar = current_bar;
|
|
|
|
//--- Copy indicator data
|
|
ArraySetAsSeries(ma_fast_buffer, true);
|
|
ArraySetAsSeries(ma_slow_buffer, true);
|
|
ArraySetAsSeries(rsi_buffer, true);
|
|
ArraySetAsSeries(adx_buffer, true);
|
|
ArraySetAsSeries(atr_buffer, true);
|
|
|
|
if(CopyBuffer(handle_ma_fast, 0, 0, 2, ma_fast_buffer) < 2 ||
|
|
CopyBuffer(handle_ma_slow, 0, 0, 2, ma_slow_buffer) < 2 ||
|
|
CopyBuffer(handle_rsi, 0, 0, 2, rsi_buffer) < 2 ||
|
|
CopyBuffer(handle_adx, 0, 0, 2, adx_buffer) < 2 ||
|
|
CopyBuffer(handle_atr, 0, 0, 2, atr_buffer) < 2)
|
|
{
|
|
Print("Error copying indicator buffers in OnTick");
|
|
return;
|
|
}
|
|
|
|
if(InpUseAdaptiveLogic)
|
|
{
|
|
AdaptParameters();
|
|
}
|
|
|
|
CheckForOpen();
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Check for new trade signals |
|
|
//+------------------------------------------------------------------+
|
|
void CheckForOpen()
|
|
{
|
|
if(m_position.Select(Symbol()))
|
|
{
|
|
return; // Position already exists
|
|
}
|
|
|
|
bool buy_signal = ma_fast_buffer[1] > ma_slow_buffer[1] && adx_buffer[1] > InpADX_Threshold;
|
|
bool sell_signal = ma_fast_buffer[1] < ma_slow_buffer[1] && adx_buffer[1] > InpADX_Threshold;
|
|
|
|
// Determine SL and TP in pips
|
|
double sl_pips, tp_pips;
|
|
if(InpUseAdaptiveLogic && g_adaptive_sl_pips > 0)
|
|
{
|
|
sl_pips = g_adaptive_sl_pips;
|
|
tp_pips = g_adaptive_tp_pips;
|
|
}
|
|
else
|
|
{
|
|
double atr_value = atr_buffer[1];
|
|
if(atr_value <= 0) return; // Cannot set SL/TP without ATR
|
|
sl_pips = atr_value / _Point * InpATR_SL_Multiplier;
|
|
tp_pips = sl_pips * InpATR_TP_Multiplier;
|
|
}
|
|
|
|
if(buy_signal)
|
|
{
|
|
OpenTrade(ORDER_TYPE_BUY, InpLots, sl_pips, tp_pips);
|
|
}
|
|
|
|
if(sell_signal)
|
|
{
|
|
OpenTrade(ORDER_TYPE_SELL, InpLots, sl_pips, tp_pips);
|
|
}
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Open a new trade |
|
|
//+------------------------------------------------------------------+
|
|
void OpenTrade(ENUM_ORDER_TYPE OrderType, double LotSize, double sl_pips, double tp_pips)
|
|
{
|
|
double price = (OrderType == ORDER_TYPE_BUY) ? m_symbol.Ask() : m_symbol.Bid();
|
|
|
|
// Calculate SL/TP prices from pips
|
|
double sl_price = (sl_pips > 0) ? ((OrderType == ORDER_TYPE_BUY) ? price - sl_pips * _Point : price + sl_pips * _Point) : 0;
|
|
double tp_price = (tp_pips > 0) ? ((OrderType == ORDER_TYPE_BUY) ? price + tp_pips * _Point : price - tp_pips * _Point) : 0;
|
|
|
|
//--- High-Precision Diagnostic Log
|
|
string log_message = StringFormat("Attempting PositionOpen: symbol=%s, type=%s, lot=%.2f, entry=%.5f, sl=%.5f, tp=%.5f",
|
|
_Symbol, (OrderType == ORDER_TYPE_BUY ? "BUY" : "SELL"), LotSize, price, sl_price, tp_price);
|
|
Print(log_message);
|
|
|
|
// Corrected call using PositionOpen
|
|
if(!m_trade.PositionOpen(_Symbol, OrderType, LotSize, price, sl_price, tp_price, "EA V2 Trade"))
|
|
{
|
|
PrintFormat("PositionOpen failed: %d - %s", m_trade.ResultRetcode(), m_trade.ResultComment());
|
|
}
|
|
else
|
|
{
|
|
Print("Position opened successfully");
|
|
if(InpUseLearning && CheckPointer(learning_engine) == POINTER_DYNAMIC)
|
|
{
|
|
STradeRecord *trade_record = new STradeRecord();
|
|
if(CheckPointer(trade_record) != POINTER_INVALID)
|
|
{
|
|
trade_record->trade_type = OrderType;
|
|
trade_record->entry_time = TimeCurrent();
|
|
trade_record->entry_price = m_trade.ResultPrice();
|
|
trade_record->lot_size = LotSize;
|
|
trade_record->stop_loss = m_trade.ResultSL();
|
|
trade_record->take_profit = m_trade.ResultTP();
|
|
trade_record->spread = (m_symbol.Ask() - m_symbol.Bid()) / _Point;
|
|
trade_record->volatility = atr_buffer[1];
|
|
trade_record->trend_strength = adx_buffer[1];
|
|
trade_record->market_regime = learning_engine->GetCurrentMarketRegime(trade_record->volatility, trade_record->trend_strength);
|
|
learning_engine->AddTrade(trade_record);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Adapt strategy parameters based on learned data |
|
|
//+------------------------------------------------------------------+
|
|
void AdaptParameters()
|
|
{
|
|
if(CheckPointer(learning_engine) == POINTER_INVALID) return;
|
|
|
|
double current_volatility = atr_buffer[1];
|
|
double current_trend = adx_buffer[1];
|
|
|
|
SMarketState market_state;
|
|
market_state.Reset();
|
|
market_state.regime = learning_engine->GetCurrentMarketRegime(current_volatility, current_trend);
|
|
|
|
if(learning_engine->GetOptimizedParameters(market_state))
|
|
{
|
|
if(market_state.optimal_sl > 0 && market_state.optimal_tp > 0)
|
|
{
|
|
g_adaptive_tp_pips = market_state.optimal_tp;
|
|
g_adaptive_sl_pips = market_state.optimal_sl;
|
|
PrintFormat("AdaptParameters: Parameters updated for regime %s. New TP: %.1f, SL: %.1f",
|
|
EnumToString(market_state.regime), g_adaptive_tp_pips, g_adaptive_sl_pips);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
g_adaptive_sl_pips = 0;
|
|
g_adaptive_tp_pips = 0;
|
|
}
|
|
}
|