3117 lines
111 KiB
MQL5
3117 lines
111 KiB
MQL5
//+------------------------------------------------------------------+
|
|
//| escape.mq5 |
|
|
//| Copyright 2025, EscapeEA Team |
|
|
//| es_cape77@hotmail.com |
|
|
//+------------------------------------------------------------------+
|
|
#property copyright "Copyright 2025, EscapeEA Team"
|
|
#property link "https://www.escapeea.com"
|
|
#property version "1.00"
|
|
|
|
// Include necessary files
|
|
#include <Trade\Trade.mqh> // For CTrade and error handling
|
|
#include <Trade\PositionInfo.mqh> // For position information
|
|
#include <Trade\SymbolInfo.mqh> // For symbol information
|
|
#include <Trade\AccountInfo.mqh>
|
|
#include <Trade\DealInfo.mqh>
|
|
#include <Trade\OrderInfo.mqh>
|
|
|
|
//--- Input Parameters ---
|
|
// General Settings
|
|
input group "=== General Settings ==="
|
|
input double InpLotSize = 0.1; // Lot size
|
|
input int InpStopLoss = 100; // Stop Loss in points
|
|
input int InpTakeProfit = 200; // Take Profit in points
|
|
input bool InpUseTrailingStop = false; // Use Trailing Stop
|
|
input int InpTrailingStop = 50; // Trailing Stop in points
|
|
input int InpTrailingStep = 10; // Trailing Step in points
|
|
input int InpMagicNumber = 123456; // Magic Number
|
|
input string InpTradeComment = "Escape EA"; // Trade Comment
|
|
input ENUM_TIMEFRAMES InpTimeframe = PERIOD_M15; // Timeframe
|
|
input bool InpEnableLogging = true; // Enable Logging
|
|
input bool InpEnableEmailAlerts = false; // Enable Email Alerts
|
|
input bool InpEnablePushAlerts = false; // Enable Push Notifications
|
|
|
|
// Risk Management
|
|
input group "=== Risk Management ==="
|
|
input double InpRiskPercent = 1.0; // Risk per trade (%)
|
|
input int InpMaxOpenTrades = 5; // Max Open Trades
|
|
input bool InpHideStopLoss = false; // Hide Stop Loss (for brokers that don't support SL/TP)
|
|
input bool InpUseDynamicLots = true; // Use Dynamic Lot Sizing
|
|
input double InpMinLotSize = 0.01; // Minimum Lot Size
|
|
input double InpMaxLotSize = 10.0; // Maximum Lot Size
|
|
input int InpSlippage = 30; // Slippage in points
|
|
input bool InpCloseOnOpposite = true; // Close on Opposite Signal
|
|
input int InpMaxSpread = 50; // Maximum Spread in points
|
|
|
|
// Trading Hours
|
|
input group "=== Trading Hours ==="
|
|
input bool InpTradeOnFriday = true; // Trade on Friday
|
|
input int InpHourStart = 0; // Trading Start Hour (0-23)
|
|
input int InpHourEnd = 24; // Trading End Hour (0-24)
|
|
|
|
//--- Strategy 1: Moving Average Crossover ---
|
|
input group "=== MA Crossover Strategy ==="
|
|
input bool InpEnableStrategy1 = true; // Enable MA Crossover Strategy
|
|
input int InpMAFastPeriod = 5; // MA Fast Period
|
|
input int InpMASlowPeriod = 20; // MA Slow Period
|
|
input ENUM_MA_METHOD InpMAMethod = MODE_EMA; // MA Method
|
|
input ENUM_APPLIED_PRICE InpMAPrice = PRICE_CLOSE; // MA Applied Price
|
|
input ENUM_TIMEFRAMES InpHigherTimeframe = PERIOD_H1; // Higher Timeframe for trend confirmation
|
|
|
|
//--- Strategy 2: RSI ---
|
|
input group "=== RSI Strategy ==="
|
|
input bool InpEnableStrategy2 = true; // Enable RSI Strategy
|
|
input int InpRSIPeriod = 14; // RSI Period
|
|
input double InpRSIOverbought = 70.0; // RSI Overbought Level
|
|
input double InpRSIOversold = 30.0; // RSI Oversold Level
|
|
input ENUM_APPLIED_PRICE InpRSIPrice = PRICE_CLOSE; // RSI Applied Price
|
|
|
|
//--- Strategy 3: MACD ---
|
|
input group "=== MACD Strategy ==="
|
|
input bool InpEnableStrategy3 = true; // Enable MACD Strategy
|
|
input int InpMACDFastEMA = 12; // MACD Fast EMA
|
|
input int InpMACDSlowEMA = 26; // MACD Slow EMA
|
|
input int InpMACDSignalPeriod = 9; // MACD Signal Period
|
|
input ENUM_APPLIED_PRICE InpMACDPrice = PRICE_CLOSE; // MACD Applied Price
|
|
|
|
//--- Strategy 4: Bollinger Bands ---
|
|
input group "=== Bollinger Bands Strategy ==="
|
|
input bool InpEnableStrategy4 = true; // Enable Bollinger Bands Strategy
|
|
input int InpBBPeriod = 20; // Bollinger Bands Period
|
|
input double InpBBDeviation = 2.0; // Bollinger Bands Deviation
|
|
input int InpBBShift = 0; // Bollinger Bands Shift
|
|
input ENUM_APPLIED_PRICE InpBBPrice = PRICE_CLOSE; // Bollinger Bands Applied Price
|
|
|
|
//--- Strategy Risk Management ---
|
|
input group "=== Strategy Risk Management ==="
|
|
input double InpDefaultStopLossPips = 20.0; // Default Stop Loss (pips)
|
|
input double InpDefaultTakeProfitPips = 40.0; // Default Take Profit (pips)
|
|
input double InpMaxRiskPerTrade = 1.0; // Max Risk per Trade (%)
|
|
input bool InpUseATRForSL = true; // Use ATR for Stop Loss
|
|
input int InpATRPeriod = 14; // ATR Period for Stop Loss
|
|
input double InpATRMultiplier = 2.0; // ATR Multiplier for Stop Loss
|
|
|
|
//--- Logging Configuration ---
|
|
input group "=== Logging ==="
|
|
input int MaxLogSizeKB = 1024; // Rotate when log reaches this size (KB)
|
|
input int MaxLogFiles = 5; // Number of rotated log files to keep
|
|
|
|
//--- Multi-Symbol & Runtime Controls ---
|
|
input group "=== Multi-Symbol & Controls ==="
|
|
input bool EnableMultiSymbol = true; // Enable multi-symbol scanning/management
|
|
input int ScanIntervalSeconds = 10; // OnTimer scan interval (seconds)
|
|
input string ExtraSymbolsCSV = ""; // Extra symbols (CSV) to include
|
|
input bool UseSymbolPathDiscovery = true; // Use SYMBOL_PATH to classify and discover
|
|
input bool MasterPause = false; // Pause all trading activity
|
|
input bool PauseOpenNew = false; // Pause opening new trades (management still runs)
|
|
input bool EmergencyHalt = false; // Emergency halt (no new trades, mgmt only)
|
|
|
|
//--- News Filter (hooks only for Phase 1) ---
|
|
input group "=== News Filter (Hooks) ==="
|
|
input bool UseNewsFilter = false; // Enable calendar-based news filter
|
|
input bool NewsHighImpact = true; // Consider high impact
|
|
input bool NewsMediumImpact = false; // Consider medium impact
|
|
input bool NewsLowImpact = false; // Consider low impact
|
|
input int NewsPreEventMin = 30; // Minutes before event to block
|
|
input int NewsPostEventMin = 30; // Minutes after event to block
|
|
|
|
//--- Asset Class Controls & Risk ---
|
|
input group "=== Asset Class Controls & Risk ==="
|
|
input bool EnableFX = true; // Trade FX pairs
|
|
input bool EnableMetals = true; // Trade Metals (XAU, XAG)
|
|
input bool EnableIndices = true; // Trade Indices (US500, GER40, etc.)
|
|
input bool EnableEnergies = true; // Trade Energies (XTI, XBR, etc.)
|
|
input bool EnableCrypto = false; // Trade Crypto (BTCUSD, ETHUSD)
|
|
input double RiskMultFX = 1.0; // Risk multiplier for FX
|
|
input double RiskMultMetals = 1.0; // Risk multiplier for Metals
|
|
input double RiskMultIndices = 1.0; // Risk multiplier for Indices
|
|
input double RiskMultEnergies = 1.0; // Risk multiplier for Energies
|
|
input double RiskMultCrypto = 0.5; // Risk multiplier for Crypto
|
|
input int FX_SessionStart = 0; // Hour (server time) trading start for FX
|
|
input int FX_SessionEnd = 24; // Hour (server time) trading end for FX
|
|
input int Metals_SessionStart = 0; // Hour trading start for Metals
|
|
input int Metals_SessionEnd = 24; // Hour trading end for Metals
|
|
input int Indices_SessionStart = 0; // Hour trading start for Indices
|
|
input int Indices_SessionEnd = 24; // Hour trading end for Indices
|
|
input int Energies_SessionStart= 0; // Hour trading start for Energies
|
|
input int Energies_SessionEnd = 24; // Hour trading end for Energies
|
|
input int Crypto_SessionStart = 0; // Hour trading start for Crypto
|
|
input int Crypto_SessionEnd = 24; // Hour trading end for Crypto
|
|
|
|
//--- Position Manager (Phase 1) ---
|
|
input group "=== Position Manager (Phase 1) ==="
|
|
input bool PM_EnableBreakEven = true; // Enable break-even move
|
|
input int PM_BETriggerPips = 15; // Profit in pips to trigger BE
|
|
input int PM_BEOffsetPips = 2; // Offset beyond BE in pips
|
|
input bool PM_EnableTrailing = true; // Enable trailing stop
|
|
input int PM_TrailStartPips = 20; // Start trailing at profit (pips)
|
|
input int PM_TrailStepPips = 10; // Trail step (pips)
|
|
input bool PM_EnableTimeExit = true; // Enable max holding time exit
|
|
input int PM_MaxPositionMinutes = 240; // Max minutes to hold a position
|
|
input int PM_ATRPeriod = 14; // ATR period for future exits
|
|
input double PM_ATRExitMultiplier = 2.0; // ATR multiplier for future exits
|
|
|
|
// Constants
|
|
const int MIN_PAPER_TRADES = 10; // Minimum number of paper trades before considering live trading
|
|
const double PAPER_TRADING_TARGET = 70.0; // Target win rate percentage for paper trading
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Trading Modes |
|
|
//+------------------------------------------------------------------+
|
|
enum ENUM_TRADING_MODE
|
|
{
|
|
MODE_PAPER, // Paper trading only
|
|
MODE_HYBRID, // Paper trading with live execution (when conditions met)
|
|
MODE_LIVE // Live trading (when consistently profitable)
|
|
};
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Market Condition Analysis |
|
|
//+------------------------------------------------------------------+
|
|
enum ENUM_MARKET_CONDITION
|
|
{
|
|
MARKET_RANGING = 0, // Sideways market
|
|
MARKET_TREND_UP = 1, // Uptrend
|
|
MARKET_TREND_DOWN = 2, // Downtrend
|
|
MARKET_VOLATILE = 3, // High volatility
|
|
MARKET_HIGH_SPREAD = 4, // High spread
|
|
MARKET_NORMAL = 5 // Normal conditions
|
|
};
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Trade Record Structure |
|
|
//+------------------------------------------------------------------+
|
|
struct STradeRecord
|
|
{
|
|
ulong ticket; // Trade ticket
|
|
string symbol; // Symbol
|
|
ENUM_ORDER_TYPE type; // Order type
|
|
double volume; // Volume in lots
|
|
double openPrice; // Open price
|
|
double stopLoss; // Stop loss level
|
|
double takeProfit; // Take profit level
|
|
datetime openTime; // Open time
|
|
datetime closeTime; // Close time
|
|
double closePrice; // Close price
|
|
double commission; // Commission
|
|
double swap; // Swap
|
|
double profit; // Profit/Loss
|
|
string comment; // Comment
|
|
bool isLive; // True if live trade, false if paper trade
|
|
|
|
// Initialize the structure
|
|
void Init()
|
|
{
|
|
ticket = 0;
|
|
symbol = "";
|
|
type = WRONG_VALUE;
|
|
volume = 0.0;
|
|
openPrice = 0.0;
|
|
stopLoss = 0.0;
|
|
takeProfit = 0.0;
|
|
openTime = 0;
|
|
closeTime = 0;
|
|
closePrice = 0.0;
|
|
commission = 0.0;
|
|
swap = 0.0;
|
|
profit = 0.0;
|
|
comment = "";
|
|
isLive = false;
|
|
}
|
|
};
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Trading Statistics Structure |
|
|
//+------------------------------------------------------------------+
|
|
struct STradingStats
|
|
{
|
|
int totalTrades; // Total number of trades
|
|
int winningTrades; // Number of winning trades
|
|
double totalProfit; // Total profit
|
|
double totalLoss; // Total loss
|
|
double maxDrawdown; // Maximum drawdown
|
|
double maxProfit; // Maximum profit
|
|
double winRate; // Win rate in percentage
|
|
double profitFactor; // Profit factor (gross profit / gross loss)
|
|
|
|
// Initialize the structure
|
|
void Init()
|
|
{
|
|
totalTrades = 0;
|
|
winningTrades = 0;
|
|
totalProfit = 0.0;
|
|
totalLoss = 0.0;
|
|
maxDrawdown = 0.0;
|
|
maxProfit = 0.0;
|
|
winRate = 0.0;
|
|
profitFactor = 0.0;
|
|
}
|
|
|
|
// Update statistics with a new trade
|
|
void Update(const STradeRecord &trade)
|
|
{
|
|
if(trade.profit > 0)
|
|
{
|
|
winningTrades++;
|
|
totalProfit += trade.profit;
|
|
}
|
|
else
|
|
{
|
|
totalLoss += MathAbs(trade.profit);
|
|
}
|
|
|
|
totalTrades++;
|
|
|
|
// Update win rate
|
|
if(totalTrades > 0)
|
|
{
|
|
winRate = (double)winningTrades / totalTrades * 100.0;
|
|
}
|
|
|
|
// Update profit factor
|
|
if(totalLoss > 0)
|
|
{
|
|
profitFactor = totalProfit / totalLoss;
|
|
}
|
|
else
|
|
if(totalProfit > 0)
|
|
{
|
|
profitFactor = DBL_MAX; // Perfect profit factor (no losses)
|
|
}
|
|
|
|
// Update max profit/drawdown
|
|
if(trade.profit > maxProfit)
|
|
{
|
|
maxProfit = trade.profit;
|
|
}
|
|
|
|
double currentDrawdown = (totalLoss > 0) ? (totalLoss / (totalProfit + totalLoss)) * 100.0 : 0.0;
|
|
if(currentDrawdown > maxDrawdown)
|
|
{
|
|
maxDrawdown = currentDrawdown;
|
|
}
|
|
}
|
|
|
|
// Reset all statistics
|
|
void Reset()
|
|
{
|
|
Init();
|
|
}
|
|
|
|
// Calculate maximum drawdown for the trading stats
|
|
double CalculateDrawdown()
|
|
{
|
|
if(totalProfit <= 0)
|
|
return 0.0;
|
|
double total = totalProfit + MathAbs(totalLoss);
|
|
return total > 0 ? (MathAbs(totalLoss) / total) * 100.0 : 0.0;
|
|
}
|
|
};
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Timer handler for multi-symbol scan and position management |
|
|
//+------------------------------------------------------------------+
|
|
void OnTimer()
|
|
{
|
|
if(!EnableMultiSymbol)
|
|
return;
|
|
if(g_inTimer)
|
|
return; // prevent re-entrancy
|
|
g_inTimer = true;
|
|
|
|
static int timerCount = 0; timerCount++;
|
|
// Optional: portfolio level guards can be added here later
|
|
int n = ArraySize(g_symbols);
|
|
for(int i=0; i<n; i++)
|
|
{
|
|
string sym = g_symbols[i];
|
|
if(sym == NULL || sym == "")
|
|
continue;
|
|
// Ensure symbol is selected in MarketWatch
|
|
SymbolSelect(sym, true);
|
|
// Manage existing positions for this symbol (works for both hedging & netting)
|
|
ManagePositionsForSymbol(sym);
|
|
|
|
// Attempt new entries per symbol when allowed
|
|
if(!EmergencyHalt && !MasterPause && !PauseOpenNew)
|
|
{
|
|
CheckSignalsForSymbol(sym, timerCount);
|
|
}
|
|
}
|
|
|
|
g_inTimer = false;
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Build symbol universe (best-effort discovery) |
|
|
//+------------------------------------------------------------------+
|
|
void BuildSymbolUniverse()
|
|
{
|
|
// Start with a preset cross-asset core set
|
|
string bases[] = {
|
|
"EURUSD","GBPUSD","USDJPY","AUDUSD","USDCAD",
|
|
"XAUUSD","XAGUSD",
|
|
"XTIUSD","XBRUSD","WTICOUSD", // energies variants
|
|
"US500","US30","US100","GER40","UK100","JPN225",
|
|
"BTCUSD","ETHUSD"
|
|
};
|
|
|
|
// Append extra symbols from CSV
|
|
string extra[]; ParseCSVToArray(ExtraSymbolsCSV, extra);
|
|
|
|
// Build candidate list
|
|
string candidates[];
|
|
int count = 0;
|
|
for(int i=0;i<ArraySize(bases);i++)
|
|
{
|
|
ArrayResize(candidates, ++count);
|
|
candidates[count-1] = bases[i];
|
|
}
|
|
for(int j=0;j<ArraySize(extra);j++)
|
|
{
|
|
if(StringLen(extra[j])==0) continue;
|
|
ArrayResize(candidates, ++count);
|
|
candidates[count-1] = StringTrim(extra[j]);
|
|
}
|
|
|
|
// Map candidates to actual broker symbols using best-effort matching
|
|
ArrayResize(g_symbols, 0);
|
|
int selected_total = SymbolsTotal(true);
|
|
int total = (selected_total>0 ? selected_total : SymbolsTotal(false));
|
|
for(int k=0;k<count;k++)
|
|
{
|
|
string base = candidates[k];
|
|
string matched = FindBestSymbolMatch(base, total, selected_total>0);
|
|
if(matched != "")
|
|
{
|
|
int newSize = ArraySize(g_symbols) + 1;
|
|
ArrayResize(g_symbols, newSize);
|
|
g_symbols[newSize-1] = matched;
|
|
}
|
|
}
|
|
|
|
// Deduplicate
|
|
UniqueStringsInPlace(g_symbols);
|
|
|
|
// Log results
|
|
Print("BuildSymbolUniverse: ", ArraySize(g_symbols), " symbols prepared.");
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Manage positions for a specific symbol |
|
|
//+------------------------------------------------------------------+
|
|
void ManagePositionsForSymbol(const string symbol)
|
|
{
|
|
// Iterate all positions and apply PM rules to those matching 'symbol'
|
|
int totalPos = (int)PositionsTotal();
|
|
for(int i=totalPos-1; i>=0; --i)
|
|
{
|
|
if(!m_position.SelectByIndex(i))
|
|
continue;
|
|
if(m_position.Symbol() != symbol)
|
|
continue;
|
|
|
|
ulong ticket = m_position.Ticket();
|
|
ENUM_POSITION_TYPE type = (ENUM_POSITION_TYPE)m_position.PositionType();
|
|
double openPrice = m_position.PriceOpen();
|
|
double current = m_position.PriceCurrent();
|
|
double sl = m_position.StopLoss();
|
|
double tp = m_position.TakeProfit();
|
|
datetime openTime = (datetime)m_position.Time();
|
|
|
|
// Time-based exit
|
|
if(PM_EnableTimeExit && PM_MaxPositionMinutes > 0)
|
|
{
|
|
if((int)((TimeCurrent() - openTime)/60) >= PM_MaxPositionMinutes)
|
|
{
|
|
if(m_trade.PositionClose(ticket))
|
|
Print("PM: Time-exit closed position ", ticket, " on ", symbol);
|
|
else
|
|
Print("PM: Failed to close (time-exit) ", ticket, " ret=", (int)m_trade.ResultRetcode(), " (", m_trade.ResultRetcodeDescription(), ")");
|
|
continue; // move next
|
|
}
|
|
}
|
|
|
|
// Break-even & Trailing
|
|
double point = SymbolInfoDouble(symbol, SYMBOL_POINT);
|
|
int ppp = PointsPerPip(symbol);
|
|
double profitPips = 0.0;
|
|
if(type == POSITION_TYPE_BUY)
|
|
profitPips = (current - openPrice) / point / ppp;
|
|
else if(type == POSITION_TYPE_SELL)
|
|
profitPips = (openPrice - current) / point / ppp;
|
|
|
|
bool modified = false;
|
|
double newSL = sl;
|
|
|
|
// Break-even
|
|
if(PM_EnableBreakEven && profitPips >= PM_BETriggerPips)
|
|
{
|
|
if(type == POSITION_TYPE_BUY)
|
|
{
|
|
double be = openPrice + (PM_BEOffsetPips * ppp * point);
|
|
if(sl < be)
|
|
{
|
|
newSL = MathMax(newSL, be);
|
|
modified = true;
|
|
}
|
|
}
|
|
else if(type == POSITION_TYPE_SELL)
|
|
{
|
|
double be = openPrice - (PM_BEOffsetPips * ppp * point);
|
|
if(sl == 0.0 || sl > be)
|
|
{
|
|
newSL = MathMin((sl==0.0?be:sl), be);
|
|
modified = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Trailing
|
|
if(PM_EnableTrailing && profitPips >= PM_TrailStartPips)
|
|
{
|
|
if(type == POSITION_TYPE_BUY)
|
|
{
|
|
double trailSL = current - (PM_TrailStepPips * ppp * point);
|
|
if(trailSL > newSL && trailSL < current)
|
|
{
|
|
newSL = trailSL;
|
|
modified = true;
|
|
}
|
|
}
|
|
else if(type == POSITION_TYPE_SELL)
|
|
{
|
|
double trailSL = current + (PM_TrailStepPips * ppp * point);
|
|
if((newSL==0.0 || trailSL < newSL) && trailSL > current)
|
|
{
|
|
newSL = trailSL;
|
|
modified = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
if(modified)
|
|
{
|
|
if(ModifyPositionSLTP(ticket, symbol, newSL, tp))
|
|
Print("PM: Modified SL for ", symbol, " ticket=", ticket, " SL=", newSL, " TP=", tp);
|
|
else
|
|
Print("PM: Failed SL modify for ", symbol, " ticket=", ticket);
|
|
}
|
|
}
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Helper: modify position SL/TP by ticket (hedging & netting) |
|
|
//+------------------------------------------------------------------+
|
|
bool ModifyPositionSLTP(const ulong ticket, const string symbol, const double sl, const double tp)
|
|
{
|
|
MqlTradeRequest req; MqlTradeResult res; ZeroMemory(req); ZeroMemory(res);
|
|
req.action = TRADE_ACTION_SLTP;
|
|
req.position = ticket;
|
|
req.symbol = symbol;
|
|
req.sl = sl;
|
|
req.tp = tp;
|
|
bool ok = OrderSend(req, res);
|
|
if(!ok)
|
|
{
|
|
Print("OrderSend SLTP failed for ", symbol, " ticket=", ticket, " ret=", (int)res.retcode);
|
|
return false;
|
|
}
|
|
return (res.retcode == TRADE_RETCODE_DONE || res.retcode == TRADE_RETCODE_DONE_PARTIAL);
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Helper: determine points per pip for a symbol |
|
|
//+------------------------------------------------------------------+
|
|
int PointsPerPip(const string symbol)
|
|
{
|
|
int digits = (int)SymbolInfoInteger(symbol, SYMBOL_DIGITS);
|
|
// Common heuristic: 5-digit (or 3-digit JPY) symbols have 10 points per pip
|
|
if(digits == 3 || digits == 5)
|
|
return 10;
|
|
return 1; // otherwise treat 1 point as 1 pip-equivalent
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Helper: CSV parser |
|
|
//+------------------------------------------------------------------+
|
|
void ParseCSVToArray(const string csv, string &out[])
|
|
{
|
|
ArrayResize(out, 0);
|
|
if(StringLen(csv) == 0) return;
|
|
int start = 0; int len = StringLen(csv);
|
|
while(start < len)
|
|
{
|
|
int comma = StringFind(csv, ",", start);
|
|
if(comma == -1) comma = len;
|
|
string token = StringSubstr(csv, start, comma - start);
|
|
token = StringTrim(token);
|
|
int n = ArraySize(out) + 1; ArrayResize(out, n); out[n-1] = token;
|
|
start = comma + 1;
|
|
}
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Helper: trim spaces |
|
|
//+------------------------------------------------------------------+
|
|
string StringTrim(const string s)
|
|
{
|
|
string r = s;
|
|
// left trim
|
|
while(StringLen(r)>0 && StringGetCharacter(r,0)==' ') r = StringSubstr(r,1);
|
|
// right trim
|
|
while(StringLen(r)>0 && StringGetCharacter(r,StringLen(r)-1)==' ') r = StringSubstr(r,0,StringLen(r)-1);
|
|
return r;
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Helper: best-effort symbol match |
|
|
//+------------------------------------------------------------------+
|
|
string FindBestSymbolMatch(const string base, int total, bool onlySelected)
|
|
{
|
|
// 1) Exact match among selected symbols
|
|
int n = SymbolsTotal(onlySelected);
|
|
for(int i=0; i<n; i++)
|
|
{
|
|
string s = SymbolName(i, onlySelected);
|
|
if(s == base) return s;
|
|
}
|
|
// 2) Substring contains (suffix/prefix tolerant)
|
|
for(int i=0; i<n; i++)
|
|
{
|
|
string s = SymbolName(i, onlySelected);
|
|
if(StringFind(s, base) >= 0) return s;
|
|
}
|
|
// 3) Fallback: search all if onlySelected was used
|
|
if(onlySelected)
|
|
{
|
|
int m = SymbolsTotal(false);
|
|
for(int j=0; j<m; j++)
|
|
{
|
|
string s2 = SymbolName(j, false);
|
|
if(s2 == base) return s2;
|
|
}
|
|
for(int j=0; j<m; j++)
|
|
{
|
|
string s2 = SymbolName(j, false);
|
|
if(StringFind(s2, base) >= 0) return s2;
|
|
}
|
|
}
|
|
return "";
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Helper: deduplicate string array in-place |
|
|
//+------------------------------------------------------------------+
|
|
void UniqueStringsInPlace(string &arr[])
|
|
{
|
|
int n = ArraySize(arr);
|
|
for(int i=0; i<n; i++)
|
|
{
|
|
for(int j=i+1; j<n; j++)
|
|
{
|
|
if(arr[i] == arr[j])
|
|
{
|
|
// shift left
|
|
for(int k=j; k<n-1; k++) arr[k] = arr[k+1];
|
|
n--; ArrayResize(arr, n); j--;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| News filter stub (Phase 1) |
|
|
//+------------------------------------------------------------------+
|
|
bool IsNewsWindow(const string symbol)
|
|
{
|
|
// Phase 1: placeholder returns false. Will integrate Economic Calendar later.
|
|
return false;
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Helper: count open positions for a symbol |
|
|
//+------------------------------------------------------------------+
|
|
int CountOpenPositions(const string symbol)
|
|
{
|
|
int count = 0;
|
|
int total = (int)PositionsTotal();
|
|
for(int i=0;i<total;i++)
|
|
{
|
|
if(!m_position.SelectByIndex(i)) continue;
|
|
if(m_position.Symbol() == symbol) count++;
|
|
}
|
|
return count;
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Helper: asset class detection from name/path |
|
|
//+------------------------------------------------------------------+
|
|
string DetectAssetClass(const string symbol)
|
|
{
|
|
string path;
|
|
if(SymbolInfoString(symbol, SYMBOL_PATH, path))
|
|
{
|
|
// Normalize path to upper for matching
|
|
StringToUpper(path);
|
|
if(StringFind(path, "FOREX")>=0 || StringFind(path, "FX")>=0) return "FX";
|
|
if(StringFind(path, "METAL")>=0) return "METAL";
|
|
if(StringFind(path, "INDEX")>=0 || StringFind(path, "INDICES")>=0) return "INDEX";
|
|
if(StringFind(path, "ENERGY")>=0 || StringFind(path, "OIL")>=0) return "ENERGY";
|
|
if(StringFind(path, "CRYPTO")>=0 || StringFind(path, "DIGITAL")>=0) return "CRYPTO";
|
|
}
|
|
// Heuristic fallback by symbol
|
|
string s = symbol;
|
|
StringToUpper(s);
|
|
if(StringFind(s, "XAU")==0 || StringFind(s, "XAG")==0) return "METAL";
|
|
if(StringFind(s, "US500")==0 || StringFind(s, "US30")==0 || StringFind(s, "US100")==0 || StringFind(s, "GER")==0 || StringFind(s, "UK")==0 || StringFind(s, "JPN")==0) return "INDEX";
|
|
if(StringFind(s, "XTI")==0 || StringFind(s, "XBR")==0 || StringFind(s, "WTI")>=0 || StringFind(s, "BRENT")>=0) return "ENERGY";
|
|
if(StringFind(s, "BTC")==0 || StringFind(s, "ETH")==0) return "CRYPTO";
|
|
// Default FX if looks like 6-letter pair (alphabetic at 0 and 5)
|
|
if(StringLen(s)>=6)
|
|
{
|
|
int c0 = StringGetCharacter(s,0);
|
|
int c5 = StringGetCharacter(s,5);
|
|
bool a0 = ((c0>='A' && c0<='Z'));
|
|
bool a5 = ((c5>='A' && c5<='Z'));
|
|
if(a0 && a5) return "FX";
|
|
}
|
|
return "OTHER";
|
|
}
|
|
|
|
bool IsClassEnabled(const string assetClass)
|
|
{
|
|
if(assetClass=="FX") return EnableFX;
|
|
if(assetClass=="METAL") return EnableMetals;
|
|
if(assetClass=="INDEX") return EnableIndices;
|
|
if(assetClass=="ENERGY") return EnableEnergies;
|
|
if(assetClass=="CRYPTO") return EnableCrypto;
|
|
return true;
|
|
}
|
|
|
|
double ClassRiskMult(const string assetClass)
|
|
{
|
|
if(assetClass=="FX") return RiskMultFX;
|
|
if(assetClass=="METAL") return RiskMultMetals;
|
|
if(assetClass=="INDEX") return RiskMultIndices;
|
|
if(assetClass=="ENERGY") return RiskMultEnergies;
|
|
if(assetClass=="CRYPTO") return RiskMultCrypto;
|
|
return 1.0;
|
|
}
|
|
|
|
bool IsWithinClassSession(const string assetClass, datetime t)
|
|
{
|
|
MqlDateTime dt; TimeToStruct(t, dt);
|
|
int hour = (int)dt.hour;
|
|
if(assetClass=="FX") return (hour>=FX_SessionStart && hour<FX_SessionEnd);
|
|
if(assetClass=="METAL") return (hour>=Metals_SessionStart && hour<Metals_SessionEnd);
|
|
if(assetClass=="INDEX") return (hour>=Indices_SessionStart && hour<Indices_SessionEnd);
|
|
if(assetClass=="ENERGY") return (hour>=Energies_SessionStart && hour<Energies_SessionEnd);
|
|
if(assetClass=="CRYPTO") return (hour>=Crypto_SessionStart && hour<Crypto_SessionEnd);
|
|
return true;
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Symbol-aware indicator checks (simple MA cross, like existing) |
|
|
//+------------------------------------------------------------------+
|
|
bool CheckBuySignalForSymbol(const string symbol)
|
|
{
|
|
// Use same periods as existing handles represent (fast=4, slow=10)
|
|
int fastPeriod = 4;
|
|
int slowPeriod = 10;
|
|
int handleFast = iMA(symbol, PERIOD_CURRENT, fastPeriod, 0, MODE_EMA, PRICE_CLOSE);
|
|
int handleSlow = iMA(symbol, PERIOD_CURRENT, slowPeriod, 0, MODE_EMA, PRICE_CLOSE);
|
|
if(handleFast==INVALID_HANDLE || handleSlow==INVALID_HANDLE) return false;
|
|
double fast[]; double slow[]; ArraySetAsSeries(fast,true); ArraySetAsSeries(slow,true); ArrayResize(fast,3); ArrayResize(slow,3);
|
|
bool ok = (CopyBuffer(handleFast,0,0,3,fast)==3 && CopyBuffer(handleSlow,0,0,3,slow)==3);
|
|
IndicatorRelease(handleFast); IndicatorRelease(handleSlow);
|
|
if(!ok) return false;
|
|
if(fast[1] <= slow[1] && fast[0] > slow[0]) return true;
|
|
return false;
|
|
}
|
|
|
|
bool CheckSellSignalForSymbol(const string symbol)
|
|
{
|
|
int fastPeriod = 4;
|
|
int slowPeriod = 10;
|
|
int handleFast = iMA(symbol, PERIOD_CURRENT, fastPeriod, 0, MODE_EMA, PRICE_CLOSE);
|
|
int handleSlow = iMA(symbol, PERIOD_CURRENT, slowPeriod, 0, MODE_EMA, PRICE_CLOSE);
|
|
if(handleFast==INVALID_HANDLE || handleSlow==INVALID_HANDLE) return false;
|
|
double fast[]; double slow[]; ArraySetAsSeries(fast,true); ArraySetAsSeries(slow,true); ArrayResize(fast,3); ArrayResize(slow,3);
|
|
bool ok = (CopyBuffer(handleFast,0,0,3,fast)==3 && CopyBuffer(handleSlow,0,0,3,slow)==3);
|
|
IndicatorRelease(handleFast); IndicatorRelease(handleSlow);
|
|
if(!ok) return false;
|
|
if(fast[1] >= slow[1] && fast[0] < slow[0]) return true;
|
|
return false;
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Position sizing for a symbol (risk % uses class multiplier) |
|
|
//+------------------------------------------------------------------+
|
|
double CalculatePositionSizeForSymbol(const string symbol, double stopLossPips, double riskPercent)
|
|
{
|
|
double balance = AccountInfoDouble(ACCOUNT_BALANCE);
|
|
string cls = DetectAssetClass(symbol);
|
|
double rp = riskPercent * ClassRiskMult(cls);
|
|
rp = MathMax(0.01, rp); // at least 0.01%
|
|
double riskAmount = balance * (rp/100.0);
|
|
|
|
double tickSize = SymbolInfoDouble(symbol, SYMBOL_TRADE_TICK_SIZE);
|
|
double tickValue = SymbolInfoDouble(symbol, SYMBOL_TRADE_TICK_VALUE);
|
|
double point = SymbolInfoDouble(symbol, SYMBOL_POINT);
|
|
int ppp = PointsPerPip(symbol);
|
|
double slPoints = stopLossPips * ppp * point;
|
|
if(slPoints <= 0.0 || tickValue<=0.0) return 0.0;
|
|
// Approximate: cost per lot at SL
|
|
double ticksAtSL = slPoints / tickSize;
|
|
double costPerLot = ticksAtSL * tickValue;
|
|
if(costPerLot <= 0.0) return 0.0;
|
|
|
|
double lot = riskAmount / costPerLot;
|
|
// Normalize to symbol lot step/min/max
|
|
double lotStep = SymbolInfoDouble(symbol, SYMBOL_VOLUME_STEP);
|
|
double minLot = SymbolInfoDouble(symbol, SYMBOL_VOLUME_MIN);
|
|
double maxLot = SymbolInfoDouble(symbol, SYMBOL_VOLUME_MAX);
|
|
lot = MathFloor(lot/lotStep)*lotStep;
|
|
lot = MathMax(minLot, MathMin(maxLot, lot));
|
|
return lot;
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Place market order for a specific symbol |
|
|
//+------------------------------------------------------------------+
|
|
bool ExecuteMarketOrderForSymbol(const string symbol, ENUM_ORDER_TYPE orderType, double lots, double stopLossPips, double takeProfitPips, string comment)
|
|
{
|
|
if(!g_tradingEnabled) return false;
|
|
bool isLive = (g_tradingMode == MODE_LIVE || (g_tradingMode == MODE_HYBRID && MathRand() % 2 == 0));
|
|
if(!isLive)
|
|
{
|
|
MqlTick t; if(!SymbolInfoTick(symbol, t)) return false;
|
|
// record paper trade
|
|
STradeRecord trade={}; trade.Init();
|
|
trade.openTime = TimeCurrent(); trade.symbol = symbol; trade.type = orderType; trade.volume = lots; trade.isLive = false;
|
|
int ppp = PointsPerPip(symbol);
|
|
double point = SymbolInfoDouble(symbol, SYMBOL_POINT);
|
|
if(orderType==ORDER_TYPE_BUY)
|
|
{
|
|
trade.openPrice=t.ask; trade.stopLoss = trade.openPrice - stopLossPips * ppp * point; trade.takeProfit = trade.openPrice + takeProfitPips * ppp * point;
|
|
}
|
|
else
|
|
{
|
|
trade.openPrice=t.bid; trade.stopLoss = trade.openPrice + stopLossPips * ppp * point; trade.takeProfit = trade.openPrice - takeProfitPips * ppp * point;
|
|
}
|
|
RecordTrade(trade);
|
|
return true;
|
|
}
|
|
double price = (orderType==ORDER_TYPE_BUY) ? SymbolInfoDouble(symbol, SYMBOL_ASK) : SymbolInfoDouble(symbol, SYMBOL_BID);
|
|
double point = SymbolInfoDouble(symbol, SYMBOL_POINT);
|
|
int ppp = PointsPerPip(symbol);
|
|
double sl = (orderType==ORDER_TYPE_BUY) ? price - stopLossPips * ppp * point : price + stopLossPips * ppp * point;
|
|
double tp = (orderType==ORDER_TYPE_BUY) ? price + takeProfitPips * ppp * point : price - takeProfitPips * ppp * point;
|
|
bool ok = (orderType==ORDER_TYPE_BUY) ? m_trade.Buy(lots, symbol, price, sl, tp, comment) : m_trade.Sell(lots, symbol, price, sl, tp, comment);
|
|
if(ok)
|
|
{
|
|
STradeRecord tr={}; tr.Init(); tr.ticket=m_trade.ResultOrder(); tr.openTime=TimeCurrent(); tr.type=orderType; tr.symbol=symbol; tr.volume=lots; tr.openPrice=price; tr.stopLoss=sl; tr.takeProfit=tp; tr.isLive=true; RecordTrade(tr);
|
|
}
|
|
return ok;
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Symbol-aware signal + entry orchestrator |
|
|
//+------------------------------------------------------------------+
|
|
void CheckSignalsForSymbol(const string symbol, int tickOrTimerCount)
|
|
{
|
|
// Class gating
|
|
string cls = DetectAssetClass(symbol);
|
|
if(!IsClassEnabled(cls))
|
|
{
|
|
if(tickOrTimerCount % 60 == 0) Print("Class disabled for ", symbol, " (", cls, ")");
|
|
return;
|
|
}
|
|
if(!IsWithinClassSession(cls, TimeCurrent()))
|
|
{
|
|
if(tickOrTimerCount % 60 == 0) Print("Session gate for ", symbol, " (", cls, ")");
|
|
return;
|
|
}
|
|
|
|
// News gating
|
|
if(UseNewsFilter && IsNewsWindow(symbol))
|
|
{
|
|
if(tickOrTimerCount % 60 == 0) Print("News gate for ", symbol);
|
|
return;
|
|
}
|
|
|
|
// Per-symbol open cap
|
|
int openCount = CountOpenPositions(symbol);
|
|
if(openCount >= MAX_OPEN_TRADES)
|
|
{
|
|
if(tickOrTimerCount % 60 == 0) Print("Open trades cap reached for ", symbol, " (", openCount, "/", MAX_OPEN_TRADES, ")");
|
|
return;
|
|
}
|
|
|
|
bool longSignal = CheckBuySignalForSymbol(symbol);
|
|
bool shortSignal = CheckSellSignalForSymbol(symbol);
|
|
if(tickOrTimerCount % 50 == 0)
|
|
Print("[", symbol, "] Signals - Long:", (longSignal?"YES":"no"), " Short:", (shortSignal?"YES":"no"));
|
|
|
|
if(longSignal)
|
|
{
|
|
double stopLoss = g_strategyManager.GetStopLossPips(true);
|
|
double takeProfit = g_strategyManager.GetTakeProfitPips(true);
|
|
double lotSize = CalculatePositionSizeForSymbol(symbol, stopLoss, InpMaxRiskPerTrade);
|
|
if(lotSize > 0)
|
|
{
|
|
if(ExecuteMarketOrderForSymbol(symbol, ORDER_TYPE_BUY, lotSize, stopLoss, takeProfit, "Strategy Buy"))
|
|
Print("[", symbol, "] BUY executed, lot=", lotSize);
|
|
}
|
|
}
|
|
if(shortSignal && !longSignal)
|
|
{
|
|
double stopLoss = g_strategyManager.GetStopLossPips(false);
|
|
double takeProfit = g_strategyManager.GetTakeProfitPips(false);
|
|
double lotSize = CalculatePositionSizeForSymbol(symbol, stopLoss, InpMaxRiskPerTrade);
|
|
if(lotSize > 0)
|
|
{
|
|
if(ExecuteMarketOrderForSymbol(symbol, ORDER_TYPE_SELL, lotSize, stopLoss, takeProfit, "Strategy Sell"))
|
|
Print("[", symbol, "] SELL executed, lot=", lotSize);
|
|
}
|
|
}
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Learning Parameters Structure |
|
|
//+------------------------------------------------------------------+
|
|
struct SLearningParams
|
|
{
|
|
int maFastPeriod; // Fast MA period
|
|
int maSlowPeriod; // Slow MA period
|
|
double stopLossPips; // Stop loss in pips
|
|
double takeProfitPips; // Take profit in pips
|
|
double riskPerTrade; // Risk per trade as percentage of balance
|
|
|
|
// Initialize the structure
|
|
void Init()
|
|
{
|
|
maFastPeriod = 10;
|
|
maSlowPeriod = 20;
|
|
stopLossPips = 30.0;
|
|
takeProfitPips = 60.0;
|
|
riskPerTrade = 1.0; // 1% risk per trade by default
|
|
}
|
|
};
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Market Condition Structure |
|
|
//+------------------------------------------------------------------+
|
|
struct SMarketCondition
|
|
{
|
|
ENUM_MARKET_CONDITION condition; // Current market condition
|
|
double strength; // 0-100% strength of the condition
|
|
double volatility; // Current market volatility (ATR based)
|
|
double trend; // Current trend strength (-1 to 1)
|
|
double volume; // Volume indicator value
|
|
double spread; // Current spread in points
|
|
datetime lastUpdate; // Timestamp of last update
|
|
|
|
// Default constructor
|
|
SMarketCondition()
|
|
{
|
|
Init();
|
|
}
|
|
|
|
// Copy constructor
|
|
SMarketCondition(const SMarketCondition &other)
|
|
{
|
|
condition = other.condition;
|
|
strength = other.strength;
|
|
volatility = other.volatility;
|
|
trend = other.trend;
|
|
volume = other.volume;
|
|
spread = other.spread;
|
|
lastUpdate = other.lastUpdate;
|
|
}
|
|
|
|
// Assignment operator
|
|
void operator=(const SMarketCondition &other)
|
|
{
|
|
// No need for self-assignment check in MQL5 structs
|
|
condition = other.condition;
|
|
strength = other.strength;
|
|
volatility = other.volatility;
|
|
trend = other.trend;
|
|
volume = other.volume;
|
|
spread = other.spread;
|
|
lastUpdate = other.lastUpdate;
|
|
}
|
|
|
|
// Initialize the structure
|
|
void Init()
|
|
{
|
|
condition = MARKET_NORMAL;
|
|
strength = 0;
|
|
volatility = 0;
|
|
trend = 0;
|
|
volume = 0;
|
|
spread = 0;
|
|
lastUpdate = 0;
|
|
}
|
|
};
|
|
ENUM_TRADING_MODE g_tradingMode = MODE_PAPER; // Current trading mode
|
|
STradeRecord g_tradeHistory[]; // Dynamic array for trade history
|
|
STradingStats g_paperStats; // Paper trading statistics
|
|
STradingStats g_liveStats; // Live trading statistics
|
|
SLearningParams g_learningParams; // Learning parameters
|
|
int g_currentOpenTrades = 0; // Current number of open trades
|
|
bool g_tradingEnabled = true; // Global trading flag
|
|
CTrade m_trade; // Trade object for order execution
|
|
CPositionInfo m_position; // Position info helper (from PositionInfo.mqh)
|
|
|
|
//--- Multi-Symbol State ---
|
|
string g_symbols[]; // Discovered/selected symbols to manage
|
|
bool g_inTimer = false; // Reentrancy guard for OnTimer
|
|
|
|
// Indicator handles
|
|
int handle_iMA_4 = INVALID_HANDLE; // Handle for 4-period MA
|
|
int handle_iMA_5 = INVALID_HANDLE; // Handle for 10-period MA
|
|
|
|
// Input parameters
|
|
input int LearningWindow = 20; // Number of trades to analyze for learning
|
|
input double MinWinRateForLive = 80.0; // Minimum win rate % to enable live trading
|
|
input double MinLiveWinRate = 70.0; // Minimum win rate to stay in live mode
|
|
input double MaxDrawdownPct = 20.0; // Maximum drawdown % before disabling live trading
|
|
input int MAX_OPEN_TRADES = 5; // Maximum number of open trades allowed
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Global variables for paper trading timing and state |
|
|
//+------------------------------------------------------------------+
|
|
datetime g_lastSignalCheck = 0; // Last time signals were checked (1-minute interval)
|
|
datetime g_lastLogUpdate = 0; // Last time logs were updated (15-minute interval)
|
|
int g_signalsSentThisMinute = 0; // Number of signals sent in current minute
|
|
const int MAX_SIGNALS_PER_MINUTE = 10; // Maximum signals to send per minute
|
|
const int SIGNAL_CHECK_INTERVAL = 60; // Check signals every 60 seconds
|
|
const int LOG_UPDATE_INTERVAL = 900; // Update logs every 15 minutes (900 seconds)
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Draw a buy signal arrow on the chart |
|
|
//+------------------------------------------------------------------+
|
|
void DrawBuySignal()
|
|
{
|
|
string objName = "BuySignal_" + IntegerToString(TimeCurrent());
|
|
|
|
// Create an up arrow for buy signals
|
|
if(ObjectCreate(0, objName, OBJ_ARROW_UP, 0, TimeCurrent(), iLow(_Symbol, _Period, 0)))
|
|
{
|
|
ObjectSetInteger(0, objName, OBJPROP_COLOR, clrLime);
|
|
ObjectSetInteger(0, objName, OBJPROP_WIDTH, 2);
|
|
ObjectSetInteger(0, objName, OBJPROP_ANCHOR, ANCHOR_BOTTOM);
|
|
ObjectSetString(0, objName, OBJPROP_TOOLTIP, "Paper Buy Signal\n" + TimeToString(TimeCurrent()));
|
|
|
|
// Set the arrow to be visible on all timeframes
|
|
long chartId = ChartID();
|
|
ChartRedraw(chartId);
|
|
}
|
|
else
|
|
{
|
|
Print("Failed to create buy signal arrow. Error: ", GetLastError());
|
|
}
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Draw a sell signal arrow on the chart |
|
|
//+------------------------------------------------------------------+
|
|
void DrawSellSignal()
|
|
{
|
|
string objName = "SellSignal_" + IntegerToString(TimeCurrent());
|
|
|
|
// Create a down arrow for sell signals
|
|
if(ObjectCreate(0, objName, OBJ_ARROW_DOWN, 0, TimeCurrent(), iHigh(_Symbol, _Period, 0)))
|
|
{
|
|
ObjectSetInteger(0, objName, OBJPROP_COLOR, clrRed);
|
|
ObjectSetInteger(0, objName, OBJPROP_WIDTH, 2);
|
|
ObjectSetInteger(0, objName, OBJPROP_ANCHOR, ANCHOR_TOP);
|
|
ObjectSetString(0, objName, OBJPROP_TOOLTIP, "Paper Sell Signal\n" + TimeToString(TimeCurrent()));
|
|
|
|
// Set the arrow to be visible on all timeframes
|
|
long chartId = ChartID();
|
|
ChartRedraw(chartId);
|
|
}
|
|
else
|
|
{
|
|
Print("Failed to create sell signal arrow. Error: ", GetLastError());
|
|
}
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Clean up old signal objects to prevent chart clutter |
|
|
//+------------------------------------------------------------------+
|
|
void CleanupOldSignals()
|
|
{
|
|
datetime oneWeekAgo = TimeCurrent() - 7 * 24 * 60 * 60; // One week ago
|
|
|
|
for(int i = ObjectsTotal(0, 0, -1) - 1; i >= 0; i--)
|
|
{
|
|
string name = ObjectName(0, i, 0, -1);
|
|
|
|
// Check if this is one of our signal objects
|
|
if(StringFind(name, "BuySignal_") == 0 || StringFind(name, "SellSignal_") == 0)
|
|
{
|
|
// Get the time from the object name
|
|
string timeStr = "";
|
|
if(StringFind(name, "BuySignal_") == 0)
|
|
timeStr = StringSubstr(name, 10);
|
|
else if(StringFind(name, "SellSignal_") == 0)
|
|
timeStr = StringSubstr(name, 11);
|
|
|
|
// Convert to datetime and check if it's older than one week
|
|
datetime signalTime = (datetime)StringToInteger(timeStr);
|
|
if(signalTime < oneWeekAgo)
|
|
{
|
|
ObjectDelete(0, name);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Redraw the chart to update the display
|
|
ChartRedraw();
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Rotate log files to prevent them from growing too large |
|
|
//+------------------------------------------------------------------+
|
|
void RotateLogs()
|
|
{
|
|
string log_path = TerminalInfoString(TERMINAL_DATA_PATH) + "\\MQL5\\Logs\\";
|
|
string log_file = log_path + "escape.log";
|
|
|
|
// Check if log file exists and is too large
|
|
int handle = FileOpen(log_file, FILE_READ|FILE_BIN|FILE_COMMON);
|
|
if(handle != INVALID_HANDLE)
|
|
{
|
|
ulong file_size = FileSize(handle) / 1024; // Size in KB
|
|
FileClose(handle);
|
|
|
|
if(file_size >= (ulong)MaxLogSizeKB)
|
|
{
|
|
// Delete oldest log file if we've reached max number of logs
|
|
string oldest_log = log_path + "escape_" + IntegerToString(MaxLogFiles-1) + ".log";
|
|
if(FileIsExist(oldest_log, FILE_COMMON))
|
|
{
|
|
FileDelete(oldest_log, FILE_COMMON);
|
|
}
|
|
|
|
// Rotate existing log files
|
|
for(int i = MaxLogFiles-2; i >= 0; i--)
|
|
{
|
|
string src = (i == 0) ? log_file : log_path + "escape_" + IntegerToString(i) + ".log";
|
|
string dst = log_path + "escape_" + IntegerToString(i+1) + ".log";
|
|
|
|
if(FileIsExist(src, FILE_COMMON))
|
|
{
|
|
if(FileIsExist(dst, FILE_COMMON))
|
|
{
|
|
FileDelete(dst, FILE_COMMON);
|
|
}
|
|
FileMove(src, 0, dst, FILE_COMMON);
|
|
}
|
|
}
|
|
|
|
// Create new empty log file
|
|
int handle = FileOpen("escape.log", FILE_WRITE|FILE_TXT|FILE_COMMON);
|
|
if(handle != INVALID_HANDLE)
|
|
{
|
|
FileWriteString(handle, "Log file rotated at " + TimeToString(TimeCurrent()) + "\r\n");
|
|
FileClose(handle);
|
|
}
|
|
Print("Log file rotated. Current size: ", file_size, "KB");
|
|
}
|
|
}
|
|
}
|
|
|
|
void Print(string message) {
|
|
// Rotate logs if needed (check every 100 prints to avoid performance hit)
|
|
static int printCount = 0;
|
|
if(++printCount % 100 == 0) {
|
|
RotateLogs();
|
|
}
|
|
|
|
string timestamp = TimeToString(TimeCurrent(), TIME_DATE|TIME_SECONDS);
|
|
printf("%s: %s", timestamp, message);
|
|
|
|
// Also write to log file
|
|
int handle = FileOpen("escape.log", FILE_READ|FILE_WRITE|FILE_TXT|FILE_COMMON);
|
|
if(handle != INVALID_HANDLE) {
|
|
FileSeek(handle, 0, SEEK_END);
|
|
FileWriteString(handle, timestamp + ": " + message + "\r\n");
|
|
FileClose(handle);
|
|
}
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Expert initialization function |
|
|
//+------------------------------------------------------------------+
|
|
int OnInit()
|
|
{
|
|
// Rotate logs if needed
|
|
RotateLogs();
|
|
|
|
// Initialize trading objects
|
|
m_trade.SetExpertMagicNumber(123456);
|
|
m_trade.SetDeviationInPoints(10);
|
|
m_trade.SetTypeFilling(ORDER_FILLING_FOK);
|
|
|
|
// Initialize learning parameters with default values if needed
|
|
g_learningParams.Init();
|
|
|
|
// Set default MA periods if not already set
|
|
if(g_learningParams.maFastPeriod < 1) g_learningParams.maFastPeriod = 5;
|
|
if(g_learningParams.maSlowPeriod <= g_learningParams.maFastPeriod)
|
|
g_learningParams.maSlowPeriod = g_learningParams.maFastPeriod * 2;
|
|
|
|
Print("Initializing indicators with MA periods: Fast=", g_learningParams.maFastPeriod,
|
|
", Slow=", g_learningParams.maSlowPeriod);
|
|
|
|
// Initialize indicator handles with validated periods
|
|
handle_iMA_4 = iMA(Symbol(), 0, g_learningParams.maFastPeriod, 0, MODE_EMA, PRICE_CLOSE);
|
|
handle_iMA_5 = iMA(Symbol(), 0, g_learningParams.maSlowPeriod, 0, MODE_EMA, PRICE_CLOSE);
|
|
|
|
// Check if indicators were created successfully and have enough data
|
|
if(handle_iMA_4 == INVALID_HANDLE || handle_iMA_5 == INVALID_HANDLE)
|
|
{
|
|
int error = GetLastError();
|
|
Print("Error creating indicators. Error code: ", error);
|
|
if(error == 4002)
|
|
{
|
|
Print("Error 4002: Invalid parameters for iMA. Please check the MA periods.");
|
|
}
|
|
return(INIT_FAILED);
|
|
}
|
|
|
|
// Wait for indicators to calculate
|
|
int retries = 0;
|
|
while(BarsCalculated(handle_iMA_4) == 0 || BarsCalculated(handle_iMA_5) == 0)
|
|
{
|
|
retries++;
|
|
if(retries > 10)
|
|
{
|
|
Print("Error: Indicators not ready after 10 retries");
|
|
return(INIT_FAILED);
|
|
}
|
|
Sleep(100);
|
|
}
|
|
|
|
Print("Indicators initialized successfully");
|
|
|
|
// Initialize and add trading strategies
|
|
if(!AddStrategies())
|
|
{
|
|
Print("Failed to initialize trading strategies");
|
|
return(INIT_FAILED);
|
|
}
|
|
Print("Trading strategies initialized successfully");
|
|
Print("Total strategies loaded: ", g_strategyManager.GetTotalStrategies());
|
|
|
|
// Initialize trading statistics
|
|
g_paperStats.Init();
|
|
g_liveStats.Init();
|
|
|
|
// Load any saved state
|
|
LoadTradingState();
|
|
|
|
Print("EA initialized in ", EnumToString(g_tradingMode), " mode");
|
|
Print("Learning Window: ", LearningWindow, " trades");
|
|
Print("Minimum Win Rate for Live: ", MinWinRateForLive, "%");
|
|
Print("Minimum Live Win Rate: ", MinLiveWinRate, "%");
|
|
Print("Maximum Drawdown: ", MaxDrawdownPct, "%");
|
|
Print("Max Open Trades (per symbol): ", MAX_OPEN_TRADES);
|
|
|
|
// Build symbol universe and start timer (Phase 1)
|
|
if(EnableMultiSymbol)
|
|
{
|
|
BuildSymbolUniverse();
|
|
int sec = (ScanIntervalSeconds < 1 ? 10 : ScanIntervalSeconds);
|
|
EventSetTimer(sec);
|
|
Print("Multi-Symbol enabled. Symbols discovered: ", ArraySize(g_symbols));
|
|
}
|
|
|
|
return(INIT_SUCCEEDED);
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Expert deinitialization function |
|
|
//+------------------------------------------------------------------+
|
|
void OnDeinit(const int reason)
|
|
{
|
|
// Release indicator handles
|
|
if(handle_iMA_4 != INVALID_HANDLE)
|
|
{
|
|
IndicatorRelease(handle_iMA_4);
|
|
}
|
|
|
|
if(handle_iMA_5 != INVALID_HANDLE)
|
|
{
|
|
IndicatorRelease(handle_iMA_5);
|
|
}
|
|
|
|
// Save trading state
|
|
SaveTradingState();
|
|
|
|
// Kill timer if used
|
|
if(EnableMultiSymbol)
|
|
EventKillTimer();
|
|
|
|
Print("EA deinitialized. Reason: ", GetUninitReasonText(reason));
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Get uninitialization reason text |
|
|
//+------------------------------------------------------------------+
|
|
string GetUninitReasonText(int reasonCode)
|
|
{
|
|
string text="";
|
|
switch(reasonCode)
|
|
{
|
|
case REASON_ACCOUNT:
|
|
text = "Account was changed";
|
|
break;
|
|
case REASON_CHARTCHANGE:
|
|
text = "Symbol or timeframe was changed";
|
|
break;
|
|
case REASON_CHARTCLOSE:
|
|
text = "Chart was closed";
|
|
break;
|
|
case REASON_PARAMETERS:
|
|
text = "Input-parameter was changed";
|
|
break;
|
|
case REASON_RECOMPILE:
|
|
text = "Program was recompiled";
|
|
break;
|
|
case REASON_REMOVE:
|
|
text = "Program was removed from chart";
|
|
break;
|
|
case REASON_TEMPLATE:
|
|
text = "New template was applied to chart";
|
|
break;
|
|
default:
|
|
text = "Unknown reason";
|
|
}
|
|
return text;
|
|
}
|
|
|
|
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Reset trading statistics |
|
|
//+------------------------------------------------------------------+
|
|
void ResetTradingStats()
|
|
{
|
|
g_paperStats.Init();
|
|
g_liveStats.Init();
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Update trading statistics with a new trade |
|
|
//+------------------------------------------------------------------+
|
|
void UpdateTradingStats(const STradeRecord &trade)
|
|
{
|
|
if(trade.isLive)
|
|
{
|
|
g_liveStats.Update(trade);
|
|
}
|
|
else
|
|
{
|
|
g_paperStats.Update(trade);
|
|
}
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Record a new trade |
|
|
//+------------------------------------------------------------------+
|
|
void RecordTrade(const STradeRecord &trade)
|
|
{
|
|
int size = ArraySize(g_tradeHistory);
|
|
ArrayResize(g_tradeHistory, size + 1);
|
|
g_tradeHistory[size] = trade;
|
|
|
|
// Update statistics
|
|
UpdateTradingStats(trade);
|
|
|
|
// Check if it's time to learn
|
|
// Trigger learning based on combined paper + live trades
|
|
int totalTradesCombined = g_paperStats.totalTrades + g_liveStats.totalTrades;
|
|
if(totalTradesCombined > 0 && (totalTradesCombined % LearningWindow) == 0)
|
|
{
|
|
LearnFromTrades();
|
|
}
|
|
|
|
// Check if we should switch modes
|
|
CheckTradingMode();
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Get market condition |
|
|
//+------------------------------------------------------------------+
|
|
SMarketCondition GetMarketCondition()
|
|
{
|
|
SMarketCondition condition;
|
|
condition.Init();
|
|
|
|
// Get technical indicators using helper functions
|
|
double rsi = GetRSI(Symbol(), PERIOD_CURRENT, 14, 0);
|
|
double atr = GetATR(Symbol(), PERIOD_CURRENT, 14, 0);
|
|
double spread = (double)SymbolInfoInteger(Symbol(), SYMBOL_SPREAD) * _Point;
|
|
|
|
// Calculate trend and volatility
|
|
condition.trend = (rsi - 50.0) * 2.0; // Convert RSI to -100 to +100 range
|
|
condition.volatility = MathMin(atr / _Point / 10.0, 100.0); // Scale ATR to 0-100 range
|
|
condition.volume = 50.0; // Placeholder for volume analysis
|
|
condition.spread = spread / _Point;
|
|
|
|
// Determine market state based on conditions
|
|
if(spread > 30 * _Point)
|
|
{
|
|
condition.condition = MARKET_HIGH_SPREAD;
|
|
}
|
|
else
|
|
if(condition.volatility > 70)
|
|
{
|
|
condition.condition = MARKET_VOLATILE;
|
|
}
|
|
else
|
|
if(condition.trend > 70)
|
|
{
|
|
condition.condition = MARKET_TREND_UP;
|
|
}
|
|
else
|
|
if(condition.trend < 30)
|
|
{
|
|
condition.condition = MARKET_TREND_DOWN;
|
|
}
|
|
else
|
|
{
|
|
condition.condition = MARKET_NORMAL;
|
|
}
|
|
|
|
condition.lastUpdate = TimeCurrent();
|
|
return condition;
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Get RSI value |
|
|
//+------------------------------------------------------------------+
|
|
double GetRSI(string symbol, ENUM_TIMEFRAMES timeframe, int period, int shift = 0)
|
|
{
|
|
double buffer[];
|
|
ArraySetAsSeries(buffer, true);
|
|
int handle = iRSI(symbol, timeframe, period, PRICE_CLOSE);
|
|
if(handle == INVALID_HANDLE)
|
|
return 0;
|
|
|
|
// wait for indicator data readiness
|
|
int tries = 0;
|
|
while(BarsCalculated(handle) <= shift && tries++ < 10) Sleep(50);
|
|
if(CopyBuffer(handle, 0, shift, 1, buffer) <= 0)
|
|
{
|
|
IndicatorRelease(handle);
|
|
return 0;
|
|
}
|
|
|
|
double value = buffer[0];
|
|
IndicatorRelease(handle);
|
|
return value;
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Get ATR value |
|
|
//+------------------------------------------------------------------+
|
|
double GetATR(string symbol, ENUM_TIMEFRAMES timeframe, int period, int shift = 0)
|
|
{
|
|
double buffer[];
|
|
ArraySetAsSeries(buffer, true);
|
|
int handle = iATR(symbol, timeframe, period);
|
|
if(handle == INVALID_HANDLE)
|
|
return 0;
|
|
|
|
// wait for indicator data readiness
|
|
int tries = 0;
|
|
while(BarsCalculated(handle) <= shift && tries++ < 10) Sleep(50);
|
|
if(CopyBuffer(handle, 0, shift, 1, buffer) <= 0)
|
|
{
|
|
IndicatorRelease(handle);
|
|
return 0;
|
|
}
|
|
|
|
double value = buffer[0];
|
|
IndicatorRelease(handle);
|
|
return value;
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Market Condition Analysis |
|
|
//+------------------------------------------------------------------+
|
|
enum ENUM_MARKET_STATE
|
|
{
|
|
MARKET_STATE_NORMAL = 0, // Normal market conditions
|
|
MARKET_STATE_HIGH_VOLATILITY = 1, // High volatility detected
|
|
MARKET_STATE_LOW_VOLATILITY = 2, // Low volatility detected
|
|
MARKET_STATE_STRONG_TREND_UP = 3, // Strong uptrend
|
|
MARKET_STATE_STRONG_TREND_DOWN = 4, // Strong downtrend
|
|
MARKET_STATE_RANGING = 5, // Sideways market
|
|
MARKET_STATE_BREAKOUT = 6, // Breakout detected
|
|
MARKET_STATE_HIGH_SPREAD = 7, // High spread detected
|
|
MARKET_STATE_NEWS_EVENT = 8, // News event detected
|
|
MARKET_STATE_OPENING = 9, // Market opening
|
|
MARKET_STATE_CLOSING = 10, // Market closing
|
|
MARKET_STATE_THIN = 11, // Thin market (low liquidity)
|
|
MARKET_STATE_GAP = 12 // Price gap detected
|
|
};
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
double MarketInfo(string symbol, int type)
|
|
{
|
|
switch(type)
|
|
{
|
|
case 6: // MODE_MARGINREQUIRED
|
|
return SymbolInfoDouble(symbol, SYMBOL_MARGIN_INITIAL);
|
|
// Add other cases as needed
|
|
default:
|
|
return 0.0;
|
|
}
|
|
}
|
|
|
|
// Using MathAbs() instead of redefining abs()
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Execute a market order |
|
|
//+------------------------------------------------------------------+
|
|
bool ExecuteMarketOrder(ENUM_ORDER_TYPE orderType, double lots, double stopLossPips, double takeProfitPips, string comment = "")
|
|
{
|
|
if(!g_tradingEnabled)
|
|
{
|
|
Print("Trading is currently disabled");
|
|
return false;
|
|
}
|
|
|
|
bool isLive = (g_tradingMode == MODE_LIVE || (g_tradingMode == MODE_HYBRID && MathRand() % 2 == 0));
|
|
|
|
// For paper trades, just record the trade without executing
|
|
if(!isLive)
|
|
{
|
|
MqlTick last_tick;
|
|
if(!SymbolInfoTick(Symbol(), last_tick))
|
|
{
|
|
Print("Error getting tick data for paper trading");
|
|
return false;
|
|
}
|
|
|
|
STradeRecord trade = {};
|
|
trade.Init();
|
|
trade.openTime = TimeCurrent();
|
|
trade.symbol = Symbol();
|
|
trade.type = orderType;
|
|
trade.volume = lots;
|
|
trade.isLive = false;
|
|
|
|
// Log paper trade details
|
|
string orderTypeStr = (orderType == ORDER_TYPE_BUY) ? "BUY" : "SELL";
|
|
Print("Paper Trade Signal: ", orderTypeStr, " ", DoubleToString(lots, 2), " lots");
|
|
Print("Current Ask: ", last_tick.ask, " Bid: ", last_tick.bid);
|
|
|
|
// Set prices based on order type
|
|
if(orderType == ORDER_TYPE_BUY)
|
|
{
|
|
trade.openPrice = last_tick.ask;
|
|
trade.stopLoss = trade.openPrice - stopLossPips * _Point * 10;
|
|
trade.takeProfit = trade.openPrice + takeProfitPips * _Point * 10;
|
|
Print("BUY Order - Price: ", trade.openPrice, " SL: ", trade.stopLoss, " TP: ", trade.takeProfit);
|
|
}
|
|
else
|
|
{
|
|
trade.openPrice = last_tick.bid;
|
|
trade.stopLoss = trade.openPrice + stopLossPips * _Point * 10;
|
|
trade.takeProfit = trade.openPrice - takeProfitPips * _Point * 10;
|
|
Print("SELL Order - Price: ", trade.openPrice, " SL: ", trade.stopLoss, " TP: ", trade.takeProfit);
|
|
}
|
|
|
|
// Log the paper trade execution
|
|
Print("Paper Trade Executed - ", orderTypeStr, " ", DoubleToString(lots, 2), " lots at ",
|
|
trade.openPrice, " (SL: ", trade.stopLoss, " TP: ", trade.takeProfit, ")");
|
|
|
|
// Simulate trade close after a random period
|
|
trade.closeTime = trade.openTime + (MathRand() % 86400 + 3600);
|
|
|
|
// Simulate random win/loss for paper trading
|
|
bool isWin = (MathRand() % 100) < (g_learningParams.maFastPeriod > g_learningParams.maSlowPeriod ? 60 : 40);
|
|
if(isWin)
|
|
{
|
|
trade.closePrice = orderType == ORDER_TYPE_BUY ?
|
|
trade.openPrice + (MathRand() % (int)(takeProfitPips * 10) + 10) * _Point :
|
|
trade.openPrice - (MathRand() % (int)(takeProfitPips * 10) + 10) * _Point;
|
|
}
|
|
else
|
|
{
|
|
trade.closePrice = orderType == ORDER_TYPE_BUY ?
|
|
trade.openPrice - (MathRand() % (int)(stopLossPips * 10) + 5) * _Point :
|
|
trade.openPrice + (MathRand() % (int)(stopLossPips * 10) + 5) * _Point;
|
|
}
|
|
|
|
trade.profit = (orderType == ORDER_TYPE_BUY) ?
|
|
(trade.closePrice - trade.openPrice) * trade.volume * 100000 :
|
|
(trade.openPrice - trade.closePrice) * trade.volume * 100000;
|
|
|
|
// Store trade parameters in the comment field since we don't have separate fields anymore
|
|
trade.comment = StringFormat("MA_Fast=%.0f,MA_Slow=%.0f,SL=%.1f,TP=%.1f,Win=%d",
|
|
g_learningParams.maFastPeriod,
|
|
g_learningParams.maSlowPeriod,
|
|
stopLossPips,
|
|
takeProfitPips,
|
|
(int)isWin);
|
|
|
|
RecordTrade(trade);
|
|
|
|
// Update statistics
|
|
if(trade.profit > 0)
|
|
Print("Paper Trade Result: PROFIT ", trade.profit);
|
|
else if(trade.profit < 0)
|
|
Print("Paper Trade Result: LOSS ", trade.profit);
|
|
else
|
|
Print("Paper Trade Result: BREAKEVEN");
|
|
|
|
return true;
|
|
}
|
|
|
|
// Live trade execution
|
|
double price = (orderType == ORDER_TYPE_BUY) ? SymbolInfoDouble(Symbol(), SYMBOL_ASK) :
|
|
SymbolInfoDouble(Symbol(), SYMBOL_BID);
|
|
|
|
double sl = (orderType == ORDER_TYPE_BUY) ? price - stopLossPips * _Point * 10 :
|
|
price + stopLossPips * _Point * 10;
|
|
|
|
double tp = (orderType == ORDER_TYPE_BUY) ? price + takeProfitPips * _Point * 10 :
|
|
price - takeProfitPips * _Point * 10;
|
|
|
|
bool result = false;
|
|
if(orderType == ORDER_TYPE_BUY)
|
|
{
|
|
result = m_trade.Buy(lots, Symbol(), price, sl, tp, comment);
|
|
}
|
|
else
|
|
{
|
|
result = m_trade.Sell(lots, Symbol(), price, sl, tp, comment);
|
|
}
|
|
|
|
if(result)
|
|
{
|
|
STradeRecord tradeRecord = {};
|
|
tradeRecord.Init();
|
|
tradeRecord.ticket = m_trade.ResultOrder();
|
|
tradeRecord.openTime = TimeCurrent();
|
|
tradeRecord.type = orderType;
|
|
tradeRecord.symbol = Symbol();
|
|
tradeRecord.volume = lots;
|
|
tradeRecord.openPrice = price;
|
|
tradeRecord.stopLoss = sl;
|
|
tradeRecord.takeProfit = tp;
|
|
tradeRecord.isLive = true;
|
|
|
|
// Store trade parameters in the comment field
|
|
tradeRecord.comment = StringFormat("MA_Fast=%.0f,MA_Slow=%.0f,SL=%.1f,TP=%.1f",
|
|
g_learningParams.maFastPeriod,
|
|
g_learningParams.maSlowPeriod,
|
|
stopLossPips,
|
|
takeProfitPips);
|
|
|
|
RecordTrade(tradeRecord);
|
|
Print("Live trade executed: ", EnumToString(orderType), " ", tradeRecord.volume, " lots at ", price);
|
|
}
|
|
else
|
|
{
|
|
Print("Failed to execute live trade. Error: ", GetLastError());
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Strategy Interface |
|
|
//+------------------------------------------------------------------+
|
|
interface IStrategy
|
|
{
|
|
public:
|
|
virtual bool Init() = 0;
|
|
virtual void Deinit() = 0;
|
|
virtual bool CheckLongSignal() = 0;
|
|
virtual bool CheckShortSignal() = 0;
|
|
virtual double GetStopLossPips(bool isLong) = 0;
|
|
virtual double GetTakeProfitPips(bool isLong) = 0;
|
|
virtual string GetName() = 0;
|
|
};
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Strategy Manager |
|
|
//+------------------------------------------------------------------+
|
|
class CStrategyManager
|
|
{
|
|
private:
|
|
IStrategy* m_strategies[];
|
|
int m_totalStrategies;
|
|
|
|
public:
|
|
CStrategyManager() : m_totalStrategies(0) {}
|
|
|
|
~CStrategyManager()
|
|
{
|
|
for(int i = 0; i < m_totalStrategies; i++)
|
|
delete m_strategies[i];
|
|
ArrayFree(m_strategies);
|
|
}
|
|
|
|
bool AddStrategy(IStrategy* strategy)
|
|
{
|
|
if(!strategy.Init())
|
|
{
|
|
Print("Failed to initialize strategy: ", strategy.GetName());
|
|
delete strategy;
|
|
return false;
|
|
}
|
|
|
|
int size = ArraySize(m_strategies);
|
|
if(ArrayResize(m_strategies, size + 1) == -1)
|
|
{
|
|
Print("Failed to resize strategies array");
|
|
delete strategy;
|
|
return false;
|
|
}
|
|
|
|
m_strategies[size] = strategy;
|
|
m_totalStrategies++;
|
|
Print("Strategy added: ", strategy.GetName());
|
|
return true;
|
|
}
|
|
|
|
bool CheckLongSignal()
|
|
{
|
|
for(int i = 0; i < m_totalStrategies; i++)
|
|
{
|
|
if(m_strategies[i].CheckLongSignal())
|
|
{
|
|
Print("Long signal from strategy: ", m_strategies[i].GetName());
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool CheckShortSignal()
|
|
{
|
|
for(int i = 0; i < m_totalStrategies; i++)
|
|
{
|
|
if(m_strategies[i].CheckShortSignal())
|
|
{
|
|
Print("Short signal from strategy: ", m_strategies[i].GetName());
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
double GetStopLossPips(bool isLong)
|
|
{
|
|
// Default values
|
|
double sl = isLong ? 20.0 : 20.0; // Default 20 pips
|
|
|
|
// Get the most conservative (largest) stop loss from all strategies
|
|
for(int i = 0; i < m_totalStrategies; i++)
|
|
{
|
|
double strategySL = m_strategies[i].GetStopLossPips(isLong);
|
|
if(strategySL > sl)
|
|
sl = strategySL;
|
|
}
|
|
|
|
return sl;
|
|
}
|
|
|
|
double GetTakeProfitPips(bool isLong)
|
|
{
|
|
// Default values
|
|
double tp = isLong ? 40.0 : 40.0; // Default 40 pips
|
|
|
|
// Get the most conservative (smallest) take profit from all strategies
|
|
for(int i = 0; i < m_totalStrategies; i++)
|
|
{
|
|
double strategyTP = m_strategies[i].GetTakeProfitPips(isLong);
|
|
if(strategyTP > 0 && (strategyTP < tp || tp == 0))
|
|
tp = strategyTP;
|
|
}
|
|
|
|
return tp;
|
|
}
|
|
|
|
// Get the total number of strategies currently loaded
|
|
int GetTotalStrategies() const { return m_totalStrategies; }
|
|
};
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Bollinger Bands Strategy |
|
|
//+------------------------------------------------------------------+
|
|
class CBollingerBandsStrategy : public IStrategy
|
|
{
|
|
private:
|
|
int m_bbHandle;
|
|
int m_bbPeriod;
|
|
double m_bbDeviation;
|
|
int m_atrHandle;
|
|
|
|
public:
|
|
CBollingerBandsStrategy(int period = 20, double deviation = 2.0) :
|
|
m_bbHandle(INVALID_HANDLE),
|
|
m_bbPeriod(period),
|
|
m_bbDeviation(deviation),
|
|
m_atrHandle(INVALID_HANDLE) {}
|
|
|
|
~CBollingerBandsStrategy()
|
|
{
|
|
if(m_bbHandle != INVALID_HANDLE) IndicatorRelease(m_bbHandle);
|
|
if(m_atrHandle != INVALID_HANDLE) IndicatorRelease(m_atrHandle);
|
|
}
|
|
|
|
bool Init() override
|
|
{
|
|
m_bbHandle = iBands(_Symbol, _Period, m_bbPeriod, 0, m_bbDeviation, PRICE_CLOSE);
|
|
m_atrHandle = iATR(_Symbol, _Period, 14);
|
|
|
|
if(m_bbHandle == INVALID_HANDLE || m_atrHandle == INVALID_HANDLE)
|
|
{
|
|
Print("Failed to create indicators for Bollinger Bands Strategy");
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void Deinit() override
|
|
{
|
|
if(m_bbHandle != INVALID_HANDLE) IndicatorRelease(m_bbHandle);
|
|
if(m_atrHandle != INVALID_HANDLE) IndicatorRelease(m_atrHandle);
|
|
|
|
m_bbHandle = INVALID_HANDLE;
|
|
m_atrHandle = INVALID_HANDLE;
|
|
}
|
|
|
|
bool CheckLongSignal() override
|
|
{
|
|
double upperBand[2], middleBand[2], lowerBand[2], close[2];
|
|
|
|
if(CopyBuffer(m_bbHandle, 1, 0, 2, upperBand) != 2 ||
|
|
CopyBuffer(m_bbHandle, 0, 0, 2, middleBand) != 2 ||
|
|
CopyBuffer(m_bbHandle, 2, 0, 2, lowerBand) != 2)
|
|
{
|
|
Print("Error getting Bollinger Bands values");
|
|
return false;
|
|
}
|
|
|
|
// Get close prices
|
|
if(CopyClose(_Symbol, _Period, 0, 2, close) != 2)
|
|
{
|
|
Print("Error getting close prices");
|
|
return false;
|
|
}
|
|
|
|
// Buy when price bounces off the lower band
|
|
return (close[1] <= lowerBand[1] && close[0] > lowerBand[0]);
|
|
}
|
|
|
|
bool CheckShortSignal() override
|
|
{
|
|
double upperBand[2], middleBand[2], lowerBand[2], close[2];
|
|
|
|
if(CopyBuffer(m_bbHandle, 1, 0, 2, upperBand) != 2 ||
|
|
CopyBuffer(m_bbHandle, 0, 0, 2, middleBand) != 2 ||
|
|
CopyBuffer(m_bbHandle, 2, 0, 2, lowerBand) != 2)
|
|
{
|
|
Print("Error getting Bollinger Bands values");
|
|
return false;
|
|
}
|
|
|
|
// Get close prices
|
|
if(CopyClose(_Symbol, _Period, 0, 2, close) != 2)
|
|
{
|
|
Print("Error getting close prices");
|
|
return false;
|
|
}
|
|
|
|
// Sell when price bounces off the upper band
|
|
return (close[1] >= upperBand[1] && close[0] < upperBand[0]);
|
|
}
|
|
|
|
double GetStopLossPips(bool isLong) override
|
|
{
|
|
double atr[1];
|
|
if(CopyBuffer(m_atrHandle, 0, 0, 1, atr) != 1)
|
|
return isLong ? 20.0 : 20.0; // Default 20 pips
|
|
|
|
// Use 1.8 * ATR for dynamic stop loss
|
|
double atrPips = atr[0] / _Point;
|
|
return MathMax(atrPips * 1.8, 10.0); // Minimum 10 pips
|
|
}
|
|
|
|
double GetTakeProfitPips(bool isLong) override
|
|
{
|
|
// 2:1 risk-reward ratio
|
|
return GetStopLossPips(isLong) * 2.0;
|
|
}
|
|
|
|
string GetName() override
|
|
{
|
|
return StringFormat("Bollinger Bands(%d,%.1f) Strategy", m_bbPeriod, m_bbDeviation);
|
|
}
|
|
};
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| MACD Strategy |
|
|
//+------------------------------------------------------------------+
|
|
class CMACDStrategy : public IStrategy
|
|
{
|
|
private:
|
|
int m_macdHandle;
|
|
int m_fastEMA;
|
|
int m_slowEMA;
|
|
int m_signalPeriod;
|
|
int m_atrHandle;
|
|
|
|
public:
|
|
CMACDStrategy(int fastEMA = 12, int slowEMA = 26, int signalPeriod = 9) :
|
|
m_macdHandle(INVALID_HANDLE),
|
|
m_fastEMA(fastEMA),
|
|
m_slowEMA(slowEMA),
|
|
m_signalPeriod(signalPeriod),
|
|
m_atrHandle(INVALID_HANDLE) {}
|
|
|
|
~CMACDStrategy()
|
|
{
|
|
if(m_macdHandle != INVALID_HANDLE) IndicatorRelease(m_macdHandle);
|
|
if(m_atrHandle != INVALID_HANDLE) IndicatorRelease(m_atrHandle);
|
|
}
|
|
|
|
bool Init() override
|
|
{
|
|
m_macdHandle = iMACD(_Symbol, _Period, m_fastEMA, m_slowEMA, m_signalPeriod, PRICE_CLOSE);
|
|
m_atrHandle = iATR(_Symbol, _Period, 14);
|
|
|
|
if(m_macdHandle == INVALID_HANDLE || m_atrHandle == INVALID_HANDLE)
|
|
{
|
|
Print("Failed to create indicators for MACD Strategy");
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void Deinit() override
|
|
{
|
|
if(m_macdHandle != INVALID_HANDLE) IndicatorRelease(m_macdHandle);
|
|
if(m_atrHandle != INVALID_HANDLE) IndicatorRelease(m_atrHandle);
|
|
|
|
m_macdHandle = INVALID_HANDLE;
|
|
m_atrHandle = INVALID_HANDLE;
|
|
}
|
|
|
|
bool CheckLongSignal() override
|
|
{
|
|
double macdMain[3], macdSignal[3];
|
|
|
|
if(CopyBuffer(m_macdHandle, 0, 0, 3, macdMain) != 3 ||
|
|
CopyBuffer(m_macdHandle, 1, 0, 3, macdSignal) != 3)
|
|
{
|
|
Print("Error getting MACD values");
|
|
return false;
|
|
}
|
|
|
|
// Buy when MACD crosses above signal line
|
|
return (macdMain[1] <= macdSignal[1] && macdMain[0] > macdSignal[0]);
|
|
}
|
|
|
|
bool CheckShortSignal() override
|
|
{
|
|
double macdMain[3], macdSignal[3];
|
|
|
|
if(CopyBuffer(m_macdHandle, 0, 0, 3, macdMain) != 3 ||
|
|
CopyBuffer(m_macdHandle, 1, 0, 3, macdSignal) != 3)
|
|
{
|
|
Print("Error getting MACD values");
|
|
return false;
|
|
}
|
|
|
|
// Sell when MACD crosses below signal line
|
|
return (macdMain[1] >= macdSignal[1] && macdMain[0] < macdSignal[0]);
|
|
}
|
|
|
|
double GetStopLossPips(bool isLong) override
|
|
{
|
|
double atr[1];
|
|
if(CopyBuffer(m_atrHandle, 0, 0, 1, atr) != 1)
|
|
return isLong ? 20.0 : 20.0; // Default 20 pips
|
|
|
|
// Use 2.0 * ATR for dynamic stop loss
|
|
double atrPips = atr[0] / _Point;
|
|
return MathMax(atrPips * 2.0, 10.0); // Minimum 10 pips
|
|
}
|
|
|
|
double GetTakeProfitPips(bool isLong) override
|
|
{
|
|
// 3:1 risk-reward ratio for MACD strategy
|
|
return GetStopLossPips(isLong) * 3.0;
|
|
}
|
|
|
|
string GetName() override
|
|
{
|
|
return StringFormat("MACD(%d,%d,%d) Strategy", m_fastEMA, m_slowEMA, m_signalPeriod);
|
|
}
|
|
};
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| RSI Strategy |
|
|
//+------------------------------------------------------------------+
|
|
class CRSIStrategy : public IStrategy
|
|
{
|
|
private:
|
|
int m_rsiHandle;
|
|
int m_rsiPeriod;
|
|
double m_overbought;
|
|
double m_oversold;
|
|
int m_maHandle;
|
|
int m_atrHandle;
|
|
|
|
bool CheckDivergence(bool isBullish)
|
|
{
|
|
// Simple divergence detection
|
|
double rsi[5], low[5], high[5];
|
|
|
|
if(CopyBuffer(m_rsiHandle, 0, 0, 5, rsi) != 5 ||
|
|
CopyLow(_Symbol, _Period, 0, 5, low) != 5 ||
|
|
CopyHigh(_Symbol, _Period, 0, 5, high) != 5)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if(isBullish)
|
|
{
|
|
// Bullish divergence: price makes lower low but RSI makes higher low
|
|
return (low[0] < low[2] && rsi[0] > rsi[2]);
|
|
}
|
|
else
|
|
{
|
|
// Bearish divergence: price makes higher high but RSI makes lower high
|
|
return (high[0] > high[2] && rsi[0] < rsi[2]);
|
|
}
|
|
}
|
|
|
|
bool CheckMAConfirmation()
|
|
{
|
|
double rsi[2], ma[2];
|
|
|
|
if(CopyBuffer(m_rsiHandle, 0, 0, 2, rsi) != 2 ||
|
|
CopyBuffer(m_maHandle, 0, 0, 2, ma) != 2)
|
|
{
|
|
return true; // Default to true if we can't get the data
|
|
}
|
|
|
|
// Check if RSI is above its MA (bullish) or below (bearish)
|
|
return (rsi[0] > ma[0]);
|
|
}
|
|
|
|
public:
|
|
CRSIStrategy(int period = 14, double overbought = 70.0, double oversold = 30.0) :
|
|
m_rsiHandle(INVALID_HANDLE),
|
|
m_rsiPeriod(period),
|
|
m_overbought(overbought),
|
|
m_oversold(oversold),
|
|
m_maHandle(INVALID_HANDLE),
|
|
m_atrHandle(INVALID_HANDLE) {}
|
|
|
|
~CRSIStrategy()
|
|
{
|
|
if(m_rsiHandle != INVALID_HANDLE) IndicatorRelease(m_rsiHandle);
|
|
if(m_maHandle != INVALID_HANDLE) IndicatorRelease(m_maHandle);
|
|
if(m_atrHandle != INVALID_HANDLE) IndicatorRelease(m_atrHandle);
|
|
}
|
|
|
|
bool Init() override
|
|
{
|
|
// Initialize RSI indicator
|
|
m_rsiHandle = iRSI(_Symbol, _Period, m_rsiPeriod, PRICE_CLOSE);
|
|
if(m_rsiHandle == INVALID_HANDLE)
|
|
{
|
|
Print("Failed to create RSI indicator. Error: ", GetLastError());
|
|
return false;
|
|
}
|
|
|
|
// Initialize Moving Average indicator
|
|
m_maHandle = iMA(_Symbol, _Period, 14, 0, MODE_SMA, PRICE_CLOSE);
|
|
if(m_maHandle == INVALID_HANDLE)
|
|
{
|
|
Print("Failed to create MA indicator. Error: ", GetLastError());
|
|
return false;
|
|
}
|
|
|
|
// Initialize ATR indicator for dynamic stop loss
|
|
m_atrHandle = iATR(_Symbol, _Period, 14);
|
|
if(m_atrHandle == INVALID_HANDLE)
|
|
{
|
|
Print("Failed to create ATR indicator. Error: ", GetLastError());
|
|
return false;
|
|
}
|
|
|
|
// Wait for indicators to calculate
|
|
int retries = 0;
|
|
while(BarsCalculated(m_rsiHandle) == 0 || BarsCalculated(m_maHandle) == 0 || BarsCalculated(m_atrHandle) == 0)
|
|
{
|
|
retries++;
|
|
if(retries > 10)
|
|
{
|
|
Print("Error: Indicators not ready after 10 retries");
|
|
return false;
|
|
}
|
|
Sleep(100);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void Deinit() override
|
|
{
|
|
if(m_rsiHandle != INVALID_HANDLE) IndicatorRelease(m_rsiHandle);
|
|
if(m_maHandle != INVALID_HANDLE) IndicatorRelease(m_maHandle);
|
|
if(m_atrHandle != INVALID_HANDLE) IndicatorRelease(m_atrHandle);
|
|
|
|
m_rsiHandle = INVALID_HANDLE;
|
|
m_maHandle = INVALID_HANDLE;
|
|
m_atrHandle = INVALID_HANDLE;
|
|
}
|
|
|
|
bool CheckLongSignal() override
|
|
{
|
|
// Check if indicator handle is valid
|
|
if(m_rsiHandle == INVALID_HANDLE)
|
|
{
|
|
Print("RSI handle not valid in CheckLongSignal");
|
|
return false;
|
|
}
|
|
|
|
// Get RSI values with error checking
|
|
double rsi[3] = {0};
|
|
int needed = 3;
|
|
if(BarsCalculated(m_rsiHandle) < needed)
|
|
return false;
|
|
int copied = CopyBuffer(m_rsiHandle, 0, 0, needed, rsi);
|
|
if(copied != needed)
|
|
{
|
|
int err = GetLastError();
|
|
if(err == ERR_INDICATOR_WRONG_HANDLE || m_rsiHandle == INVALID_HANDLE)
|
|
{
|
|
ResetLastError();
|
|
if(m_rsiHandle != INVALID_HANDLE) IndicatorRelease(m_rsiHandle);
|
|
m_rsiHandle = iRSI(_Symbol, _Period, m_rsiPeriod, PRICE_CLOSE);
|
|
if(m_rsiHandle == INVALID_HANDLE)
|
|
return false;
|
|
int retries = 0;
|
|
while(BarsCalculated(m_rsiHandle) == 0 && retries++ < 10) Sleep(50);
|
|
ArrayInitialize(rsi, 0.0);
|
|
copied = CopyBuffer(m_rsiHandle, 0, 0, needed, rsi);
|
|
}
|
|
if(copied != needed)
|
|
{
|
|
Print("Error getting RSI values. Copied: ", copied, ", Error: ", err);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// Check for valid RSI values
|
|
if(rsi[0] == 0 || rsi[1] == 0 || rsi[2] == 0)
|
|
{
|
|
Print("Invalid RSI values: ", rsi[0], ", ", rsi[1], ", ", rsi[2]);
|
|
return false;
|
|
}
|
|
|
|
// Check for oversold condition
|
|
bool isOversold = (rsi[1] <= m_oversold && rsi[0] > m_oversold);
|
|
|
|
// Check for bullish divergence
|
|
bool hasBullishDivergence = CheckDivergence(true);
|
|
|
|
// Check MA confirmation
|
|
bool maConfirmation = CheckMAConfirmation();
|
|
|
|
// Buy when RSI crosses above oversold level with confirmation
|
|
return (isOversold || hasBullishDivergence) && maConfirmation;
|
|
}
|
|
|
|
bool CheckShortSignal() override
|
|
{
|
|
// Check if indicator handle is valid
|
|
if(m_rsiHandle == INVALID_HANDLE)
|
|
{
|
|
Print("RSI handle not valid in CheckShortSignal");
|
|
return false;
|
|
}
|
|
|
|
// Get RSI values with error checking
|
|
double rsi[3] = {0};
|
|
int needed = 3;
|
|
if(BarsCalculated(m_rsiHandle) < needed)
|
|
return false;
|
|
int copied = CopyBuffer(m_rsiHandle, 0, 0, needed, rsi);
|
|
if(copied != needed)
|
|
{
|
|
int err = GetLastError();
|
|
if(err == ERR_INDICATOR_WRONG_HANDLE || m_rsiHandle == INVALID_HANDLE)
|
|
{
|
|
ResetLastError();
|
|
if(m_rsiHandle != INVALID_HANDLE) IndicatorRelease(m_rsiHandle);
|
|
m_rsiHandle = iRSI(_Symbol, _Period, m_rsiPeriod, PRICE_CLOSE);
|
|
if(m_rsiHandle == INVALID_HANDLE)
|
|
return false;
|
|
int retries = 0;
|
|
while(BarsCalculated(m_rsiHandle) == 0 && retries++ < 10) Sleep(50);
|
|
ArrayInitialize(rsi, 0.0);
|
|
copied = CopyBuffer(m_rsiHandle, 0, 0, needed, rsi);
|
|
}
|
|
if(copied != needed)
|
|
{
|
|
Print("Error getting RSI values. Copied: ", copied, ", Error: ", err);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// Check for valid RSI values
|
|
if(rsi[0] == 0 || rsi[1] == 0 || rsi[2] == 0)
|
|
{
|
|
Print("Invalid RSI values: ", rsi[0], ", ", rsi[1], ", ", rsi[2]);
|
|
return false;
|
|
}
|
|
|
|
// Check for overbought condition
|
|
bool isOverbought = (rsi[1] >= m_overbought && rsi[0] < m_overbought);
|
|
|
|
// Check for bearish divergence
|
|
bool hasBearishDivergence = CheckDivergence(false);
|
|
|
|
// Check MA confirmation (inverse for short)
|
|
bool maConfirmation = !CheckMAConfirmation();
|
|
|
|
// Sell when RSI crosses below overbought level with confirmation
|
|
return (isOverbought || hasBearishDivergence) && maConfirmation;
|
|
}
|
|
|
|
double GetStopLossPips(bool isLong) override
|
|
{
|
|
double atr[1];
|
|
if(CopyBuffer(m_atrHandle, 0, 0, 1, atr) != 1)
|
|
return isLong ? 20.0 : 20.0; // Default 20 pips
|
|
|
|
// Use 1.5 * ATR for dynamic stop loss
|
|
double atrPips = atr[0] / _Point;
|
|
return MathMax(atrPips * 1.5, 10.0); // Minimum 10 pips
|
|
}
|
|
|
|
double GetTakeProfitPips(bool isLong) override
|
|
{
|
|
// 2.5:1 risk-reward ratio for RSI strategy
|
|
return GetStopLossPips(isLong) * 2.5;
|
|
}
|
|
|
|
string GetName() override
|
|
{
|
|
return StringFormat("RSI(%d) Strategy", m_rsiPeriod);
|
|
}
|
|
};
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Moving Average Crossover Strategy |
|
|
//+------------------------------------------------------------------+
|
|
class CMAStrategy : public IStrategy
|
|
{
|
|
private:
|
|
int m_maFastHandle;
|
|
int m_maSlowHandle;
|
|
int m_volumeHandle;
|
|
int m_atrHandle;
|
|
int m_maFastPeriod;
|
|
int m_maSlowPeriod;
|
|
ENUM_TIMEFRAMES m_higherTimeframe;
|
|
int m_maFastHandleHTF;
|
|
int m_maSlowHandleHTF;
|
|
|
|
bool CheckVolumeConfirmation()
|
|
{
|
|
double volume[2];
|
|
if(CopyBuffer(m_volumeHandle, 0, 0, 2, volume) != 2)
|
|
return true; // Default to true if we can't get volume data
|
|
|
|
// Get more volume data for the moving average calculation
|
|
double volumeData[20];
|
|
if(CopyBuffer(m_volumeHandle, 0, 0, 20, volumeData) != 20)
|
|
return true; // Default to true if we can't get enough volume data
|
|
|
|
// Calculate 20-period SMA of volume using iMAOnArray
|
|
double avgVolume = 0;
|
|
for(int i = 0; i < 20; i++)
|
|
avgVolume += volumeData[i];
|
|
avgVolume /= 20.0;
|
|
|
|
return (volume[1] > avgVolume);
|
|
}
|
|
|
|
bool CheckVolatility()
|
|
{
|
|
double atr[1];
|
|
if(CopyBuffer(m_atrHandle, 0, 0, 1, atr) != 1)
|
|
return true; // Default to true if we can't get ATR data
|
|
|
|
// Only trade if volatility is above minimum threshold
|
|
return (atr[0] > (10 * _Point));
|
|
}
|
|
|
|
bool CheckHigherTimeframeTrend()
|
|
{
|
|
double maFastHTF[2], maSlowHTF[2];
|
|
|
|
if(CopyBuffer(m_maFastHandleHTF, 0, 0, 2, maFastHTF) != 2 ||
|
|
CopyBuffer(m_maSlowHandleHTF, 0, 0, 2, maSlowHTF) != 2)
|
|
return true; // Default to true if we can't get HTF data
|
|
|
|
// Check if higher timeframe trend is up
|
|
return (maFastHTF[0] > maSlowHTF[0]);
|
|
}
|
|
|
|
public:
|
|
CMAStrategy(int fastPeriod = 10, int slowPeriod = 20, ENUM_TIMEFRAMES higherTimeframe = PERIOD_H1) :
|
|
m_maFastHandle(INVALID_HANDLE),
|
|
m_maSlowHandle(INVALID_HANDLE),
|
|
m_volumeHandle(INVALID_HANDLE),
|
|
m_atrHandle(INVALID_HANDLE),
|
|
m_maFastPeriod(fastPeriod),
|
|
m_maSlowPeriod(slowPeriod),
|
|
m_higherTimeframe(higherTimeframe),
|
|
m_maFastHandleHTF(INVALID_HANDLE),
|
|
m_maSlowHandleHTF(INVALID_HANDLE) {}
|
|
|
|
~CMAStrategy()
|
|
{
|
|
if(m_maFastHandle != INVALID_HANDLE) IndicatorRelease(m_maFastHandle);
|
|
if(m_maSlowHandle != INVALID_HANDLE) IndicatorRelease(m_maSlowHandle);
|
|
if(m_volumeHandle != INVALID_HANDLE) IndicatorRelease(m_volumeHandle);
|
|
if(m_atrHandle != INVALID_HANDLE) IndicatorRelease(m_atrHandle);
|
|
if(m_maFastHandleHTF != INVALID_HANDLE) IndicatorRelease(m_maFastHandleHTF);
|
|
if(m_maSlowHandleHTF != INVALID_HANDLE) IndicatorRelease(m_maSlowHandleHTF);
|
|
}
|
|
|
|
bool Init() override
|
|
{
|
|
// Initialize indicators for current timeframe
|
|
m_maFastHandle = iMA(_Symbol, _Period, m_maFastPeriod, 0, MODE_EMA, PRICE_CLOSE);
|
|
m_maSlowHandle = iMA(_Symbol, _Period, m_maSlowPeriod, 0, MODE_EMA, PRICE_CLOSE);
|
|
m_volumeHandle = iVolumes(_Symbol, _Period, VOLUME_TICK);
|
|
m_atrHandle = iATR(_Symbol, _Period, 14);
|
|
|
|
// Initialize indicators for higher timeframe
|
|
m_maFastHandleHTF = iMA(_Symbol, m_higherTimeframe, m_maFastPeriod, 0, MODE_EMA, PRICE_CLOSE);
|
|
m_maSlowHandleHTF = iMA(_Symbol, m_higherTimeframe, m_maSlowPeriod, 0, MODE_EMA, PRICE_CLOSE);
|
|
|
|
if(m_maFastHandle == INVALID_HANDLE || m_maSlowHandle == INVALID_HANDLE ||
|
|
m_volumeHandle == INVALID_HANDLE || m_atrHandle == INVALID_HANDLE ||
|
|
m_maFastHandleHTF == INVALID_HANDLE || m_maSlowHandleHTF == INVALID_HANDLE)
|
|
{
|
|
Print("Failed to create indicators for MA Crossover Strategy");
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void Deinit() override
|
|
{
|
|
if(m_maFastHandle != INVALID_HANDLE) IndicatorRelease(m_maFastHandle);
|
|
if(m_maSlowHandle != INVALID_HANDLE) IndicatorRelease(m_maSlowHandle);
|
|
if(m_volumeHandle != INVALID_HANDLE) IndicatorRelease(m_volumeHandle);
|
|
if(m_atrHandle != INVALID_HANDLE) IndicatorRelease(m_atrHandle);
|
|
if(m_maFastHandleHTF != INVALID_HANDLE) IndicatorRelease(m_maFastHandleHTF);
|
|
if(m_maSlowHandleHTF != INVALID_HANDLE) IndicatorRelease(m_maSlowHandleHTF);
|
|
|
|
m_maFastHandle = INVALID_HANDLE;
|
|
m_maSlowHandle = INVALID_HANDLE;
|
|
m_volumeHandle = INVALID_HANDLE;
|
|
m_atrHandle = INVALID_HANDLE;
|
|
m_maFastHandleHTF = INVALID_HANDLE;
|
|
m_maSlowHandleHTF = INVALID_HANDLE;
|
|
}
|
|
|
|
bool CheckLongSignal() override
|
|
{
|
|
double maFast[3], maSlow[3];
|
|
|
|
if(CopyBuffer(m_maFastHandle, 0, 0, 3, maFast) != 3 ||
|
|
CopyBuffer(m_maSlowHandle, 0, 0, 3, maSlow) != 3)
|
|
{
|
|
Print("Error getting MA values");
|
|
return false;
|
|
}
|
|
|
|
// Check for MA crossover
|
|
bool maCrossover = (maFast[1] <= maSlow[1] && maFast[0] > maSlow[0]);
|
|
|
|
// Additional confirmations
|
|
bool volumeConfirm = CheckVolumeConfirmation();
|
|
bool volatilityConfirm = CheckVolatility();
|
|
bool trendConfirm = CheckHigherTimeframeTrend();
|
|
|
|
// All conditions must be true for a valid signal
|
|
return (maCrossover && volumeConfirm && volatilityConfirm && trendConfirm);
|
|
}
|
|
|
|
bool CheckShortSignal() override
|
|
{
|
|
double maFast[3], maSlow[3];
|
|
|
|
if(CopyBuffer(m_maFastHandle, 0, 0, 3, maFast) != 3 ||
|
|
CopyBuffer(m_maSlowHandle, 0, 0, 3, maSlow) != 3)
|
|
{
|
|
Print("Error getting MA values");
|
|
return false;
|
|
}
|
|
|
|
// Check for MA crossunder
|
|
bool maCrossunder = (maFast[1] >= maSlow[1] && maFast[0] < maSlow[0]);
|
|
|
|
// Additional confirmations
|
|
bool volumeConfirm = CheckVolumeConfirmation();
|
|
bool volatilityConfirm = CheckVolatility();
|
|
bool trendConfirm = !CheckHigherTimeframeTrend(); // Inverse for short
|
|
|
|
// All conditions must be true for a valid signal
|
|
return (maCrossunder && volumeConfirm && volatilityConfirm && trendConfirm);
|
|
}
|
|
|
|
double GetStopLossPips(bool isLong) override
|
|
{
|
|
double atr[1];
|
|
if(CopyBuffer(m_atrHandle, 0, 0, 1, atr) != 1)
|
|
return isLong ? 20.0 : 20.0; // Default 20 pips
|
|
|
|
// Use 1.5 * ATR for dynamic stop loss
|
|
double atrPips = atr[0] / _Point;
|
|
return MathMax(atrPips * 1.5, 10.0); // Minimum 10 pips
|
|
}
|
|
|
|
double GetTakeProfitPips(bool isLong) override
|
|
{
|
|
// 2:1 risk-reward ratio
|
|
return GetStopLossPips(isLong) * 2.0;
|
|
}
|
|
|
|
string GetName() override
|
|
{
|
|
return StringFormat("MA Crossover(%d,%d) Strategy", m_maFastPeriod, m_maSlowPeriod);
|
|
}
|
|
};
|
|
|
|
// Global strategy manager
|
|
CStrategyManager g_strategyManager;
|
|
|
|
// In OnInit() - Add this after other initializations
|
|
bool AddStrategies()
|
|
{
|
|
// Add MA Crossover Strategy
|
|
if(InpEnableStrategy1)
|
|
{
|
|
if(!g_strategyManager.AddStrategy(new CMAStrategy(InpMAFastPeriod, InpMASlowPeriod, InpHigherTimeframe)))
|
|
{
|
|
Print("Failed to add MA Crossover strategy");
|
|
return false;
|
|
}
|
|
Print("MA Crossover Strategy enabled (Fast:", InpMAFastPeriod, ", Slow:", InpMASlowPeriod, ")");
|
|
}
|
|
|
|
// Add RSI Strategy
|
|
if(InpEnableStrategy2)
|
|
{
|
|
if(!g_strategyManager.AddStrategy(new CRSIStrategy(InpRSIPeriod, InpRSIOverbought, InpRSIOversold)))
|
|
{
|
|
Print("Failed to add RSI strategy");
|
|
return false;
|
|
}
|
|
Print("RSI Strategy enabled (Period:", InpRSIPeriod, ", Overbought:", InpRSIOverbought, ", Oversold:", InpRSIOversold, ")");
|
|
}
|
|
|
|
// Add MACD Strategy
|
|
if(InpEnableStrategy3)
|
|
{
|
|
if(!g_strategyManager.AddStrategy(new CMACDStrategy(InpMACDFastEMA, InpMACDSlowEMA, InpMACDSignalPeriod)))
|
|
{
|
|
Print("Failed to add MACD strategy");
|
|
return false;
|
|
}
|
|
Print("MACD Strategy enabled (Fast:", InpMACDFastEMA, ", Slow:", InpMACDSlowEMA, ", Signal:", InpMACDSignalPeriod, ")");
|
|
}
|
|
|
|
// Add Bollinger Bands Strategy
|
|
if(InpEnableStrategy4)
|
|
{
|
|
if(!g_strategyManager.AddStrategy(new CBollingerBandsStrategy(InpBBPeriod, InpBBDeviation)))
|
|
{
|
|
Print("Failed to add Bollinger Bands strategy");
|
|
return false;
|
|
}
|
|
Print("Bollinger Bands Strategy enabled (Period:", InpBBPeriod, ", Deviation:", InpBBDeviation, ")");
|
|
}
|
|
|
|
// Check if at least one strategy is enabled
|
|
if(g_strategyManager.GetTotalStrategies() == 0)
|
|
{
|
|
Print("Error: No trading strategies are enabled!");
|
|
return false;
|
|
}
|
|
|
|
Print("Total strategies enabled: ", g_strategyManager.GetTotalStrategies());
|
|
return true;
|
|
}
|
|
|
|
// Check trading signals and execute trades if conditions are met
|
|
void CheckSignals(int tickCount)
|
|
{
|
|
// Runtime gates for new entries
|
|
if(MasterPause || PauseOpenNew || EmergencyHalt)
|
|
{
|
|
if(tickCount % 50 == 0)
|
|
Print("Entry gated by runtime controls. MasterPause=", MasterPause,
|
|
", PauseOpenNew=", PauseOpenNew, ", EmergencyHalt=", EmergencyHalt);
|
|
return;
|
|
}
|
|
if(UseNewsFilter && IsNewsWindow(_Symbol))
|
|
{
|
|
if(tickCount % 50 == 0)
|
|
Print("Entry gated by NewsFilter for symbol ", _Symbol);
|
|
return;
|
|
}
|
|
|
|
// Check if we can enter new trades
|
|
if(g_currentOpenTrades >= MAX_OPEN_TRADES)
|
|
{
|
|
if(tickCount % 100 == 0)
|
|
Print("Maximum number of open trades per symbol reached (", g_currentOpenTrades, "/", MAX_OPEN_TRADES, ")");
|
|
return;
|
|
}
|
|
|
|
// Check for signals from all strategies
|
|
bool longSignal = g_strategyManager.CheckLongSignal();
|
|
bool shortSignal = g_strategyManager.CheckShortSignal();
|
|
|
|
if(tickCount % 50 == 0) // Log signal status every 50 ticks
|
|
{
|
|
Print("Signal Status - Long: ", (longSignal ? "YES" : "no"), ", Short: ", (shortSignal ? "YES" : "no"));
|
|
}
|
|
|
|
if(longSignal)
|
|
{
|
|
Print("Processing BUY signal...");
|
|
double stopLoss = g_strategyManager.GetStopLossPips(true);
|
|
double takeProfit = g_strategyManager.GetTakeProfitPips(true);
|
|
double lotSize = CalculatePositionSize(stopLoss);
|
|
|
|
Print(" Stop Loss: ", stopLoss, " pips, Take Profit: ", takeProfit, " pips, Lot Size: ", lotSize);
|
|
|
|
if(lotSize > 0)
|
|
{
|
|
// Draw buy signal on chart
|
|
DrawBuySignal();
|
|
|
|
if(ExecuteMarketOrder(ORDER_TYPE_BUY, lotSize, stopLoss, takeProfit, "Strategy Buy"))
|
|
{
|
|
Print("Successfully executed BUY order");
|
|
g_currentOpenTrades++;
|
|
}
|
|
else
|
|
Print("Failed to execute BUY order");
|
|
}
|
|
}
|
|
if(shortSignal && !longSignal) // Only process short if not already processing long
|
|
{
|
|
Print("Processing SELL signal...");
|
|
double stopLoss = g_strategyManager.GetStopLossPips(false);
|
|
double takeProfit = g_strategyManager.GetTakeProfitPips(false);
|
|
double lotSize = CalculatePositionSize(stopLoss);
|
|
|
|
Print(" Stop Loss: ", stopLoss, " pips, Take Profit: ", takeProfit, " pips, Lot Size: ", lotSize);
|
|
|
|
if(lotSize > 0)
|
|
{
|
|
// Draw sell signal on chart
|
|
DrawSellSignal();
|
|
|
|
if(ExecuteMarketOrder(ORDER_TYPE_SELL, lotSize, stopLoss, takeProfit, "Strategy Sell"))
|
|
{
|
|
Print("Successfully executed SELL order");
|
|
g_currentOpenTrades++;
|
|
}
|
|
else
|
|
Print("Failed to execute SELL order");
|
|
}
|
|
}
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Expert tick function |
|
|
//+------------------------------------------------------------------+
|
|
void OnTick()
|
|
{
|
|
// Log tick processing
|
|
static int tickCount = 0;
|
|
tickCount++;
|
|
if(tickCount % 100 == 0) // Log every 100 ticks to avoid flooding
|
|
Print("OnTick: Open trades (per symbol): ", g_currentOpenTrades, "/", MAX_OPEN_TRADES);
|
|
|
|
// Check for trading signals
|
|
if(tickCount % 50 == 0) // Log status every 50 ticks
|
|
{
|
|
Print("=== Trading Status ===");
|
|
Print("Current Time: ", TimeToString(TimeCurrent()));
|
|
Print("Trading Allowed: ", (TerminalInfoInteger(TERMINAL_TRADE_ALLOWED) ? "Yes" : "No"));
|
|
Print("Expert Enabled: ", (MQLInfoInteger(MQL_TRADE_ALLOWED) ? "Yes" : "No"));
|
|
Print("Current Open Trades (per symbol): ", g_currentOpenTrades, "/", MAX_OPEN_TRADES);
|
|
Print("Last Signal Check: ", (g_lastSignalCheck == 0 ? "Never" : TimeToString(g_lastSignalCheck)));
|
|
Print("Last Log Update: ", (g_lastLogUpdate == 0 ? "Never" : TimeToString(g_lastLogUpdate)));
|
|
Print("Signals This Minute: ", g_signalsSentThisMinute, "/", MAX_SIGNALS_PER_MINUTE);
|
|
}
|
|
|
|
// Note: CheckSignals is invoked later after updating per-symbol open trade count.
|
|
|
|
// Get current price and time
|
|
MqlTick last_tick;
|
|
double current_price = 0.0;
|
|
datetime current_time = TimeCurrent();
|
|
|
|
if(SymbolInfoTick(_Symbol, last_tick))
|
|
{
|
|
current_price = last_tick.last;
|
|
if(tickCount % 100 == 0)
|
|
Print("Current price: ", current_price, " (Ask: ", last_tick.ask, ", Bid: ", last_tick.bid, ")");
|
|
}
|
|
else
|
|
{
|
|
Print("Error getting tick data");
|
|
return;
|
|
}
|
|
|
|
// Check if trading is allowed
|
|
if(!TerminalInfoInteger(TERMINAL_TRADE_ALLOWED) || !MQLInfoInteger(MQL_TRADE_ALLOWED))
|
|
{
|
|
Print("Trading is not allowed. Check AutoTrading button and Expert Advisors settings.");
|
|
return;
|
|
}
|
|
|
|
// Implement your position closing logic here
|
|
// For now, return false to indicate no action needed
|
|
// Update market condition
|
|
SMarketCondition condition = GetMarketCondition();
|
|
|
|
// Get current price and time for position management
|
|
// Update current open trades count
|
|
g_currentOpenTrades = 0;
|
|
for(int i = 0; i < (int)PositionsTotal(); i++)
|
|
{
|
|
if(m_position.SelectByIndex(i) && m_position.Symbol() == _Symbol)
|
|
g_currentOpenTrades++;
|
|
}
|
|
|
|
// Clean up old signals periodically
|
|
static datetime lastCleanup = 0;
|
|
if(TimeCurrent() - lastCleanup > 3600) // Clean up every hour
|
|
{
|
|
CleanupOldSignals();
|
|
lastCleanup = TimeCurrent();
|
|
}
|
|
|
|
// Check if we should close any positions
|
|
if(PositionsTotal() > 0)
|
|
{
|
|
for(int i = (int)PositionsTotal() - 1; i >= 0; i--)
|
|
{
|
|
if(m_position.SelectByIndex(i))
|
|
{
|
|
ulong ticket = m_position.Ticket();
|
|
string pos_symbol = m_position.Symbol();
|
|
if(ShouldClosePosition(ticket))
|
|
{
|
|
// Close the position by ticket using CTrade (works for netting & hedging)
|
|
if(m_trade.PositionClose(ticket))
|
|
{
|
|
Print("Position closed: ", ticket);
|
|
}
|
|
else
|
|
{
|
|
Print(
|
|
"Failed to close position ", ticket,
|
|
". Retcode=", (int)m_trade.ResultRetcode(),
|
|
" (", m_trade.ResultRetcodeDescription(), ")"
|
|
);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Check if we can open new positions
|
|
if(g_currentOpenTrades < MAX_OPEN_TRADES)
|
|
{
|
|
if(!EnableMultiSymbol)
|
|
CheckSignals(tickCount); // In multi-symbol mode, entries are handled by OnTimer per symbol
|
|
}
|
|
else
|
|
{
|
|
if(tickCount % 100 == 0)
|
|
Print("Maximum number of open trades per symbol reached (", g_currentOpenTrades, "/", MAX_OPEN_TRADES, ")");
|
|
}
|
|
|
|
// Update trading statistics and check trading modes once per 15 minutes
|
|
static datetime lastUpdateTime = 0;
|
|
datetime currentTime = TimeCurrent();
|
|
|
|
if(currentTime - lastUpdateTime >= 900) // Only update once every 15 minutes
|
|
{
|
|
// Create a string with all the information
|
|
string info = "=== 15-Minute Update ===\n";
|
|
info += "Time: " + TimeToString(currentTime) + "\n";
|
|
info += "Open Positions: " + IntegerToString(PositionsTotal()) + "\n";
|
|
info += "Trading Mode: " + EnumToString(g_tradingMode) + "\n\n";
|
|
info += "=== Trading Stats ===\n";
|
|
info += "Paper Trades: " + IntegerToString(g_paperStats.totalTrades) + "\n";
|
|
info += "Winners: " + IntegerToString(g_paperStats.winningTrades) + "\n";
|
|
info += "Win Rate: " + DoubleToString(g_paperStats.winRate, 2) + "%\n\n";
|
|
info += "Live Trades: " + IntegerToString(g_liveStats.totalTrades) + "\n";
|
|
info += "Winners: " + IntegerToString(g_liveStats.winningTrades) + "\n";
|
|
info += "Win Rate: " + DoubleToString(g_liveStats.winRate, 2) + "%";
|
|
|
|
// Display on chart
|
|
Comment(info);
|
|
|
|
// Also print to log
|
|
Print("=== 15-Minute Update ===");
|
|
Print("Current time: ", TimeToString(currentTime));
|
|
Print("Open positions: ", PositionsTotal());
|
|
Print("Current trading mode: ", EnumToString(g_tradingMode));
|
|
Print("Paper trades: ", g_paperStats.totalTrades, " (Winners: ", g_paperStats.winningTrades, ", Win rate: ", g_paperStats.winRate, "%)");
|
|
Print("Live trades: ", g_liveStats.totalTrades, " (Winners: ", g_liveStats.winningTrades, ", Win rate: ", g_liveStats.winRate, "%)");
|
|
|
|
UpdateTradingStats();
|
|
CheckTradingMode();
|
|
lastUpdateTime = currentTime;
|
|
|
|
// Log current indicator values for debugging
|
|
double maFast[3], maSlow[3];
|
|
if(CopyBuffer(handle_iMA_4, 0, 0, 3, maFast) == 3 &&
|
|
CopyBuffer(handle_iMA_5, 0, 0, 3, maSlow) == 3)
|
|
{
|
|
string maInfo = "\n\n=== Current MA Values ===\n";
|
|
maInfo += "Fast MA: " + DoubleToString(maFast[0], 6) + ", " + DoubleToString(maFast[1], 6) + ", " + DoubleToString(maFast[2], 6) + "\n";
|
|
maInfo += "Slow MA: " + DoubleToString(maSlow[0], 6) + ", " + DoubleToString(maSlow[1], 6) + ", " + DoubleToString(maSlow[2], 6);
|
|
|
|
// Add MA info to chart
|
|
Comment(info + maInfo);
|
|
|
|
// Also print to log
|
|
Print("Current MA Values - Fast: ", maFast[0], ", ", maFast[1], ", ", maFast[2]);
|
|
Print("Current MA Values - Slow: ", maSlow[0], ", ", maSlow[1], ", ", maSlow[2]);
|
|
}
|
|
}
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Check for buy signal based on MA crossover |
|
|
//+------------------------------------------------------------------+
|
|
bool CheckBuySignal()
|
|
{
|
|
// Check if indicators are valid
|
|
if(handle_iMA_4 == INVALID_HANDLE || handle_iMA_5 == INVALID_HANDLE)
|
|
{
|
|
Print("Error: Indicator handles not valid in CheckBuySignal");
|
|
return false;
|
|
}
|
|
|
|
// Use dynamic arrays for indicator values
|
|
double maFast[];
|
|
double maSlow[];
|
|
|
|
// Set as series and resize arrays
|
|
ArraySetAsSeries(maFast, true);
|
|
ArraySetAsSeries(maSlow, true);
|
|
|
|
// Resize arrays to hold 3 values (current and 2 previous)
|
|
ArrayResize(maFast, 3);
|
|
ArrayResize(maSlow, 3);
|
|
|
|
// Copy more bars to ensure we have enough data
|
|
if(CopyBuffer(handle_iMA_4, 0, 0, 3, maFast) != 3 ||
|
|
CopyBuffer(handle_iMA_5, 0, 0, 3, maSlow) != 3)
|
|
{
|
|
Print("Error copying indicator buffers in CheckBuySignal");
|
|
return false;
|
|
}
|
|
|
|
// Check for valid values
|
|
if(maFast[0] == 0 || maFast[1] == 0 || maSlow[0] == 0 || maSlow[1] == 0)
|
|
{
|
|
Print("Warning: Indicator values not ready");
|
|
return false;
|
|
}
|
|
|
|
// Check for buy signal (fast MA crosses above slow MA)
|
|
bool signal = (maFast[1] <= maSlow[1] && maFast[0] > maSlow[0]);
|
|
|
|
if(signal)
|
|
{
|
|
Print("BUY Signal: Fast MA(", maFast[0], ") crossed above Slow MA(", maSlow[0], ")");
|
|
}
|
|
|
|
return signal;
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Check for sell signal based on MA crossover |
|
|
//+------------------------------------------------------------------+
|
|
bool CheckSellSignal()
|
|
{
|
|
// Check if indicators are valid
|
|
if(handle_iMA_4 == INVALID_HANDLE || handle_iMA_5 == INVALID_HANDLE)
|
|
{
|
|
Print("Error: Indicator handles not valid in CheckSellSignal");
|
|
return false;
|
|
}
|
|
|
|
// Use dynamic arrays for indicator values
|
|
double maFast[];
|
|
double maSlow[];
|
|
|
|
// Set as series and resize arrays
|
|
ArraySetAsSeries(maFast, true);
|
|
ArraySetAsSeries(maSlow, true);
|
|
|
|
// Resize arrays to hold 3 values (current and 2 previous)
|
|
ArrayResize(maFast, 3);
|
|
ArrayResize(maSlow, 3);
|
|
|
|
// Copy more bars to ensure we have enough data
|
|
if(CopyBuffer(handle_iMA_4, 0, 0, 3, maFast) != 3 ||
|
|
CopyBuffer(handle_iMA_5, 0, 0, 3, maSlow) != 3)
|
|
{
|
|
Print("Error copying indicator buffers in CheckSellSignal");
|
|
return false;
|
|
}
|
|
|
|
// Check for valid values
|
|
if(maFast[0] == 0 || maFast[1] == 0 || maSlow[0] == 0 || maSlow[1] == 0)
|
|
{
|
|
Print("Warning: Indicator values not ready");
|
|
return false;
|
|
}
|
|
|
|
// Check for sell signal (fast MA crosses below slow MA)
|
|
bool signal = (maFast[1] >= maSlow[1] && maFast[0] < maSlow[0]);
|
|
|
|
if(signal)
|
|
{
|
|
Print("SELL Signal: Fast MA(", maFast[0], ") crossed below Slow MA(", maSlow[0], ")");
|
|
}
|
|
|
|
return signal;
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
void CheckTradingMode()
|
|
{
|
|
// Check if we should switch to live mode
|
|
if(g_tradingMode == MODE_PAPER &&
|
|
g_paperStats.totalTrades >= MIN_PAPER_TRADES &&
|
|
g_paperStats.winRate >= MinWinRateForLive)
|
|
{
|
|
g_tradingMode = MODE_HYBRID;
|
|
Print("Switching to HYBRID trading mode. Paper performance: ", g_paperStats.winRate, "% win rate");
|
|
}
|
|
|
|
// Check if we should switch back to paper mode
|
|
if((g_tradingMode == MODE_HYBRID || g_tradingMode == MODE_LIVE) &&
|
|
(g_paperStats.winRate < (MinWinRateForLive * 0.8) || g_paperStats.profitFactor < 1.2))
|
|
{
|
|
g_tradingMode = MODE_PAPER;
|
|
Print("Switching back to PAPER trading mode due to performance drop");
|
|
}
|
|
|
|
// Check if we should switch to full live mode
|
|
if(g_tradingMode == MODE_HYBRID &&
|
|
g_paperStats.totalTrades >= MIN_PAPER_TRADES * 2 &&
|
|
g_paperStats.winRate >= MinLiveWinRate)
|
|
{
|
|
g_tradingMode = MODE_LIVE;
|
|
Print("Switching to FULL LIVE trading mode. Performance: ", g_paperStats.winRate, "% win rate");
|
|
}
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
void LearnFromTrades()
|
|
{
|
|
// Simple learning logic - can be enhanced with more sophisticated algorithms
|
|
// Use combined statistics from paper + live trades
|
|
int totalTrades = g_paperStats.totalTrades + g_liveStats.totalTrades;
|
|
int winningTrades = g_paperStats.winningTrades + g_liveStats.winningTrades;
|
|
double combinedWinRate = (totalTrades > 0) ? ((double)winningTrades / (double)totalTrades) * 100.0 : 0.0;
|
|
|
|
if(combinedWinRate > 70.0)
|
|
{
|
|
// If winning, be more aggressive
|
|
g_learningParams.riskPerTrade = MathMin(2.0, g_learningParams.riskPerTrade * 1.1);
|
|
g_learningParams.takeProfitPips = MathMin(100.0, g_learningParams.takeProfitPips * 1.05);
|
|
g_learningParams.stopLossPips = MathMax(10.0, g_learningParams.stopLossPips * 0.95);
|
|
}
|
|
else
|
|
{
|
|
// If losing, be more conservative
|
|
g_learningParams.riskPerTrade = MathMax(0.1, g_learningParams.riskPerTrade * 0.9);
|
|
g_learningParams.takeProfitPips = MathMax(20.0, g_learningParams.takeProfitPips * 0.95);
|
|
g_learningParams.stopLossPips = MathMin(50.0, g_learningParams.stopLossPips * 1.05);
|
|
}
|
|
|
|
// Adjust MA periods based on volatility
|
|
SMarketCondition condition = GetMarketCondition();
|
|
if(condition.volatility > 70)
|
|
{
|
|
// In high volatility, use slower MAs
|
|
g_learningParams.maFastPeriod = MathMin(14, g_learningParams.maFastPeriod + 1);
|
|
g_learningParams.maSlowPeriod = MathMin(28, g_learningParams.maSlowPeriod + 1);
|
|
}
|
|
else
|
|
if(condition.volatility < 30)
|
|
{
|
|
// In low volatility, use faster MAs
|
|
g_learningParams.maFastPeriod = MathMax(5, g_learningParams.maFastPeriod - 1);
|
|
g_learningParams.maSlowPeriod = MathMax(10, g_learningParams.maSlowPeriod - 1);
|
|
}
|
|
|
|
// Ensure fast MA is always faster than slow MA
|
|
if(g_learningParams.maFastPeriod >= g_learningParams.maSlowPeriod)
|
|
{
|
|
g_learningParams.maSlowPeriod = g_learningParams.maFastPeriod + 5;
|
|
}
|
|
|
|
Print("Learning complete. New parameters: ",
|
|
"Risk: ", g_learningParams.riskPerTrade,
|
|
", TP: ", g_learningParams.takeProfitPips,
|
|
", SL: ", g_learningParams.stopLossPips,
|
|
", MA Fast: ", g_learningParams.maFastPeriod,
|
|
", MA Slow: ", g_learningParams.maSlowPeriod);
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
void SaveTradingState()
|
|
{
|
|
// Implementation to save trading state to a file
|
|
// This is a placeholder - implement actual file I/O as needed
|
|
Print("Trading state saved");
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
void LoadTradingState()
|
|
{
|
|
// Implementation to load trading state from a file
|
|
// This is a placeholder - implement actual file I/O as needed
|
|
Print("Trading state loaded");
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
//+------------------------------------------------------------------+
|
|
//| Calculate position size based on risk percentage |
|
|
//+------------------------------------------------------------------+
|
|
double CalculatePositionSize(double stopLossPips, double riskPercent = 1.0)
|
|
{
|
|
// Get symbol and account information
|
|
double tickSize = SymbolInfoDouble(_Symbol, SYMBOL_TRADE_TICK_SIZE);
|
|
double tickValue = SymbolInfoDouble(_Symbol, SYMBOL_TRADE_TICK_VALUE);
|
|
double lotStep = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_STEP);
|
|
double minLot = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MIN);
|
|
double maxLot = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MAX);
|
|
double balance = AccountInfoDouble(ACCOUNT_BALANCE);
|
|
|
|
// Log input parameters
|
|
Print("Calculating position size:");
|
|
Print(" Stop Loss: ", stopLossPips, " pips");
|
|
Print(" Risk %: ", riskPercent);
|
|
Print(" Account Balance: $", balance);
|
|
Print(" Symbol Info - Tick Size: ", tickSize, ", Tick Value: $", tickValue, ", Lot Step: ", lotStep);
|
|
|
|
// Validate inputs
|
|
if(stopLossPips <= 0)
|
|
{
|
|
Print("Error: Invalid stop loss pips: ", stopLossPips);
|
|
return 0.0;
|
|
}
|
|
|
|
if(tickSize <= 0 || tickValue <= 0 || lotStep <= 0)
|
|
{
|
|
Print("Error: Invalid symbol parameters - TickSize: ", tickSize, ", TickValue: ", tickValue, ", LotStep: ", lotStep);
|
|
return 0.0;
|
|
}
|
|
|
|
// Calculate risk amount in account currency
|
|
double riskAmount = balance * (riskPercent / 100.0);
|
|
Print(" Risk Amount: $", riskAmount);
|
|
|
|
// Calculate value per pip
|
|
double pipValue = tickValue / (tickSize / _Point);
|
|
Print(" Pip Value: $", pipValue);
|
|
|
|
// Calculate money at risk per lot
|
|
double moneyRiskPerLot = stopLossPips * pipValue;
|
|
Print(" Money Risk per Lot: $", moneyRiskPerLot);
|
|
|
|
if(moneyRiskPerLot <= 0)
|
|
{
|
|
Print("Error: Invalid money risk per lot calculation: ", moneyRiskPerLot);
|
|
return 0.0;
|
|
}
|
|
|
|
// Calculate position size in lots
|
|
double lots = riskAmount / moneyRiskPerLot;
|
|
Print(" Raw Lots: ", lots);
|
|
|
|
// Round to nearest lot step
|
|
lots = MathFloor(lots / lotStep) * lotStep;
|
|
Print(" Rounded Lots: ", lots);
|
|
|
|
// Ensure position size is within allowed range
|
|
lots = MathMax(minLot, MathMin(lots, maxLot));
|
|
Print(" Final Lots (after min/max check): ", lots);
|
|
|
|
if(lots < minLot)
|
|
{
|
|
Print("Error: Calculated lot size (", lots, ") is below minimum allowed (", minLot, ")");
|
|
return 0.0;
|
|
}
|
|
|
|
if(lots > maxLot)
|
|
{
|
|
Print("Warning: Calculated lot size (", lots, ") exceeds maximum allowed (", maxLot, "). Using maximum.");
|
|
lots = maxLot;
|
|
}
|
|
|
|
Print(" Final Position Size: ", lots, " lots");
|
|
return lots;
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Check if a position should be closed |
|
|
//+------------------------------------------------------------------+
|
|
bool ShouldClosePosition(ulong ticket)
|
|
{
|
|
if(!PositionSelectByTicket(ticket))
|
|
{
|
|
Print("Failed to select position ", ticket);
|
|
return false;
|
|
}
|
|
|
|
// Get position details
|
|
double openPrice = PositionGetDouble(POSITION_PRICE_OPEN);
|
|
double currentPrice = PositionGetDouble(POSITION_PRICE_CURRENT);
|
|
double profit = PositionGetDouble(POSITION_PROFIT);
|
|
double stopLoss = PositionGetDouble(POSITION_SL);
|
|
double takeProfit = PositionGetDouble(POSITION_TP);
|
|
ENUM_POSITION_TYPE posType = (ENUM_POSITION_TYPE)PositionGetInteger(POSITION_TYPE);
|
|
|
|
// Check if stop loss or take profit was hit
|
|
if((posType == POSITION_TYPE_BUY && (currentPrice <= stopLoss || currentPrice >= takeProfit)) ||
|
|
(posType == POSITION_TYPE_SELL && (currentPrice >= stopLoss || currentPrice <= takeProfit)))
|
|
{
|
|
return true;
|
|
}
|
|
|
|
// Check for reversal signals
|
|
bool isBuy = (posType == POSITION_TYPE_BUY);
|
|
bool reversalSignal = isBuy ? CheckSellSignal() : CheckBuySignal();
|
|
|
|
// Consider taking profits if we have a reversal signal
|
|
if(reversalSignal && profit > 0)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
// Check for extreme market conditions
|
|
SMarketCondition condition = GetMarketCondition();
|
|
if(condition.volatility > 80)
|
|
{
|
|
// Close position if volatility is too high and we have a decent profit
|
|
if(profit > 0)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Update trading statistics |
|
|
//+------------------------------------------------------------------+
|
|
void UpdateTradingStats()
|
|
{
|
|
// Update live trading statistics
|
|
g_liveStats.Init();
|
|
|
|
// Get all closed positions from history
|
|
HistorySelect(0, TimeCurrent());
|
|
int totalDeals = HistoryDealsTotal();
|
|
|
|
for(int i = 0; i < totalDeals; i++)
|
|
{
|
|
ulong ticket = HistoryDealGetTicket(i);
|
|
if(ticket > 0)
|
|
{
|
|
// Process deal information
|
|
STradeRecord trade = {};
|
|
trade.Init();
|
|
trade.ticket = ticket;
|
|
trade.symbol = HistoryDealGetString(ticket, DEAL_SYMBOL);
|
|
trade.type = (ENUM_ORDER_TYPE)HistoryDealGetInteger(ticket, DEAL_TYPE);
|
|
trade.volume = HistoryDealGetDouble(ticket, DEAL_VOLUME);
|
|
trade.openPrice = HistoryDealGetDouble(ticket, DEAL_PRICE);
|
|
trade.profit = HistoryDealGetDouble(ticket, DEAL_PROFIT);
|
|
trade.commission = HistoryDealGetDouble(ticket, DEAL_COMMISSION);
|
|
trade.swap = HistoryDealGetDouble(ticket, DEAL_SWAP);
|
|
trade.openTime = (datetime)HistoryDealGetInteger(ticket, DEAL_TIME);
|
|
trade.isLive = true;
|
|
|
|
// Update statistics (isWin is calculated in STradingStats.Update)
|
|
g_liveStats.Update(trade);
|
|
}
|
|
}
|
|
|
|
// Log current status
|
|
Print("=== Trading Status ===");
|
|
Print("Mode: ", EnumToString(g_tradingMode));
|
|
Print("Paper Trades: ", g_paperStats.totalTrades, ", Win Rate: ", g_paperStats.winRate, "%");
|
|
Print("Live Trades: ", g_liveStats.totalTrades, ", Win Rate: ", g_liveStats.winRate, "%");
|
|
Print("Current Open Trades: ", g_currentOpenTrades, " (Max: ", MAX_OPEN_TRADES, ")");
|
|
Print("Current Balance: ", AccountInfoDouble(ACCOUNT_BALANCE));
|
|
Print("Current Equity: ", AccountInfoDouble(ACCOUNT_EQUITY));
|
|
Print("Free Margin: ", AccountInfoDouble(ACCOUNT_MARGIN_FREE));
|
|
Print("Max Drawdown: ", g_liveStats.maxDrawdown, "%");
|
|
Print("====================");
|
|
}
|
|
//+------------------------------------------------------------------+
|