| //+------------------------------------------------------------------+
|
| //| StrategySignalGenerators.mqh - Extensible Signal Generator Framework |
|
| //| Provides actual indicator-based signal generation for all strategies |
|
| //+------------------------------------------------------------------+
|
| #ifndef __STRATEGY_SIGNAL_GENERATORS_MQH__
|
| #define __STRATEGY_SIGNAL_GENERATORS_MQH__
|
|
|
| #include "GateManager.mqh"
|
|
|
| //+------------------------------------------------------------------+
|
| //| Base Interface for Strategy Signal Generators |
|
| //+------------------------------------------------------------------+
|
| class ISignalGenerator
|
| {
|
| public:
|
| virtual ~ISignalGenerator() {}
|
| virtual string GetName() = 0;
|
| virtual bool GenerateSignal(string symbol, ENUM_TIMEFRAMES tf, TradingSignal &signal) = 0;
|
| virtual string GetDescription() { return ""; }
|
| };
|
|
|
| //+------------------------------------------------------------------+
|
| //| Helper Functions for All Strategies |
|
| //+------------------------------------------------------------------+
|
| double GetATR(string symbol, ENUM_TIMEFRAMES tf, int period = 14)
|
| {
|
| int handle = iATR(symbol, tf, period);
|
| if(handle == INVALID_HANDLE) return 0.0;
|
| double buf[1];
|
| if(CopyBuffer(handle, 0, 0, 1, buf) != 1) { IndicatorRelease(handle); return 0.0; }
|
| IndicatorRelease(handle);
|
| return buf[0];
|
| }
|
|
|
| double GetCurrentPrice(string symbol, bool bid = true)
|
| {
|
| return bid ? SymbolInfoDouble(symbol, SYMBOL_BID) : SymbolInfoDouble(symbol, SYMBOL_ASK);
|
| }
|
|
|
| void SetSignalDefaults(TradingSignal &signal, string symbol, ENUM_TIMEFRAMES tf, string strategy, int type, double price)
|
| {
|
| // Initialize all fields first to prevent garbage values
|
| signal.Init();
|
|
|
| signal.id = strategy + "_" + IntegerToString(TimeCurrent());
|
| signal.symbol = symbol;
|
| signal.timeframe = tf;
|
| signal.timestamp = TimeCurrent();
|
| signal.price = price;
|
| signal.type = type;
|
| signal.order_type = (type == 0) ? ORDER_TYPE_BUY : ORDER_TYPE_SELL; // Set order_type based on type
|
| signal.strategy = strategy;
|
| signal.volume = 0.1;
|
| signal.confidence = 0.6;
|
|
|
| double atr = GetATR(symbol, tf, 14);
|
| if(atr <= 0) atr = 100 * SymbolInfoDouble(symbol, SYMBOL_POINT);
|
|
|
| // TIMEFRAME-BASED MULTIPLIER: Longer timeframes = wider SL/TP
|
| double tf_multiplier = 1.0;
|
| switch(tf)
|
| {
|
| case PERIOD_M1: tf_multiplier = 0.5; break; // Tightest stops
|
| case PERIOD_M5: tf_multiplier = 0.7; break;
|
| case PERIOD_M15: tf_multiplier = 0.85; break;
|
| case PERIOD_M30: tf_multiplier = 1.0; break; // Baseline
|
| case PERIOD_H1: tf_multiplier = 1.3; break;
|
| case PERIOD_H4: tf_multiplier = 1.6; break;
|
| case PERIOD_D1: tf_multiplier = 2.0; break; // Wider stops
|
| case PERIOD_W1: tf_multiplier = 2.5; break;
|
| case PERIOD_MN1: tf_multiplier = 3.0; break; // Widest stops
|
| default: tf_multiplier = 1.0; break;
|
| }
|
|
|
| // Set SL/TP based on signal type with timeframe adjustment
|
| double sl_mult = 1.5 * tf_multiplier;
|
| double tp_mult = 2.5 * tf_multiplier;
|
|
|
| if(type == 0) // Buy
|
| {
|
| signal.sl = price - atr * sl_mult;
|
| signal.tp = price + atr * tp_mult;
|
| }
|
| else // Sell
|
| {
|
| signal.sl = price + atr * sl_mult;
|
| signal.tp = price - atr * tp_mult;
|
| }
|
|
|
| // Final safety check - ensure TP is never garbage
|
| if(signal.tp <= 0.0 || signal.tp > 1e10 || MathIsValidNumber(signal.tp) == false)
|
| {
|
| signal.tp = (type == 0) ? price + atr * tp_mult : price - atr * tp_mult;
|
| }
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| ADX Strategy - Trend Strength |
|
| //+------------------------------------------------------------------+
|
| class CADXSignalGenerator : public ISignalGenerator
|
| {
|
| private:
|
| int m_period;
|
| double m_threshold;
|
| public:
|
| CADXSignalGenerator(int period = 14, double threshold = 25.0) { m_period = period; m_threshold = threshold; }
|
| string GetName() override { return "ADXStrategy"; }
|
| string GetDescription() override { return "ADX trend strength with DI+/DI- crossover"; }
|
|
|
| bool GenerateSignal(string symbol, ENUM_TIMEFRAMES tf, TradingSignal &signal) override
|
| {
|
| int handle = iADX(symbol, tf, m_period);
|
| if(handle == INVALID_HANDLE) return false;
|
|
|
| double adx[2], di_plus[2], di_minus[2];
|
| if(CopyBuffer(handle, 0, 0, 2, adx) != 2) { IndicatorRelease(handle); return false; }
|
| if(CopyBuffer(handle, 1, 0, 2, di_plus) != 2) { IndicatorRelease(handle); return false; }
|
| if(CopyBuffer(handle, 2, 0, 2, di_minus) != 2) { IndicatorRelease(handle); return false; }
|
| IndicatorRelease(handle);
|
|
|
| if(adx[0] < m_threshold) return false;
|
|
|
| double price = GetCurrentPrice(symbol);
|
|
|
| // DI+ crosses above DI- = Buy
|
| if(di_plus[1] <= di_minus[1] && di_plus[0] > di_minus[0])
|
| {
|
| SetSignalDefaults(signal, symbol, tf, GetName(), 0, price);
|
| signal.confidence = 0.5 + (adx[0] / 100.0) * 0.3;
|
| return true;
|
| }
|
| // DI- crosses above DI+ = Sell
|
| if(di_minus[1] <= di_plus[1] && di_minus[0] > di_plus[0])
|
| {
|
| SetSignalDefaults(signal, symbol, tf, GetName(), 1, price);
|
| signal.confidence = 0.5 + (adx[0] / 100.0) * 0.3;
|
| return true;
|
| }
|
| return false;
|
| }
|
| };
|
|
|
| //+------------------------------------------------------------------+
|
| //| RSI Strategy - Overbought/Oversold |
|
| //+------------------------------------------------------------------+
|
| class CRSISignalGenerator : public ISignalGenerator
|
| {
|
| private:
|
| int m_period;
|
| double m_overbought, m_oversold;
|
| public:
|
| CRSISignalGenerator(int period = 14, double ob = 70.0, double os = 30.0)
|
| { m_period = period; m_overbought = ob; m_oversold = os; }
|
| string GetName() override { return "RSIStrategy"; }
|
| string GetDescription() override { return "RSI overbought/oversold reversal"; }
|
|
|
| bool GenerateSignal(string symbol, ENUM_TIMEFRAMES tf, TradingSignal &signal) override
|
| {
|
| int handle = iRSI(symbol, tf, m_period, PRICE_CLOSE);
|
| if(handle == INVALID_HANDLE) return false;
|
|
|
| double rsi[2];
|
| if(CopyBuffer(handle, 0, 0, 2, rsi) != 2) { IndicatorRelease(handle); return false; }
|
| IndicatorRelease(handle);
|
|
|
| double price = GetCurrentPrice(symbol);
|
|
|
| // RSI crosses above oversold = Buy
|
| if(rsi[1] < m_oversold && rsi[0] >= m_oversold)
|
| {
|
| SetSignalDefaults(signal, symbol, tf, GetName(), 0, price);
|
| signal.confidence = 0.55 + (m_oversold - rsi[1]) / 100.0;
|
| return true;
|
| }
|
| // RSI crosses below overbought = Sell
|
| if(rsi[1] > m_overbought && rsi[0] <= m_overbought)
|
| {
|
| SetSignalDefaults(signal, symbol, tf, GetName(), 1, price);
|
| signal.confidence = 0.55 + (rsi[1] - m_overbought) / 100.0;
|
| return true;
|
| }
|
| return false;
|
| }
|
| };
|
|
|
| //+------------------------------------------------------------------+
|
| //| MACD Strategy - Crossover |
|
| //+------------------------------------------------------------------+
|
| class CMACDSignalGenerator : public ISignalGenerator
|
| {
|
| private:
|
| int m_fast, m_slow, m_signal;
|
| public:
|
| CMACDSignalGenerator(int fast = 12, int slow = 26, int sig = 9)
|
| { m_fast = fast; m_slow = slow; m_signal = sig; }
|
| string GetName() override { return "MACDStrategy"; }
|
| string GetDescription() override { return "MACD line/signal crossover"; }
|
|
|
| bool GenerateSignal(string symbol, ENUM_TIMEFRAMES tf, TradingSignal &signal) override
|
| {
|
| int handle = iMACD(symbol, tf, m_fast, m_slow, m_signal, PRICE_CLOSE);
|
| if(handle == INVALID_HANDLE) return false;
|
|
|
| double macd[2], sig_line[2];
|
| if(CopyBuffer(handle, 0, 0, 2, macd) != 2) { IndicatorRelease(handle); return false; }
|
| if(CopyBuffer(handle, 1, 0, 2, sig_line) != 2) { IndicatorRelease(handle); return false; }
|
| IndicatorRelease(handle);
|
|
|
| double price = GetCurrentPrice(symbol);
|
|
|
| // MACD crosses above signal = Buy
|
| if(macd[1] <= sig_line[1] && macd[0] > sig_line[0])
|
| {
|
| SetSignalDefaults(signal, symbol, tf, GetName(), 0, price);
|
| signal.confidence = 0.6;
|
| return true;
|
| }
|
| // MACD crosses below signal = Sell
|
| if(macd[1] >= sig_line[1] && macd[0] < sig_line[0])
|
| {
|
| SetSignalDefaults(signal, symbol, tf, GetName(), 1, price);
|
| signal.confidence = 0.6;
|
| return true;
|
| }
|
| return false;
|
| }
|
| };
|
|
|
| //+------------------------------------------------------------------+
|
| //| Stochastic Strategy - Crossover in OB/OS zones |
|
| //+------------------------------------------------------------------+
|
| class CStochasticSignalGenerator : public ISignalGenerator
|
| {
|
| private:
|
| int m_k, m_d, m_slowing;
|
| double m_overbought, m_oversold;
|
| public:
|
| CStochasticSignalGenerator(int k = 14, int d = 3, int slowing = 3, double ob = 80.0, double os = 20.0)
|
| { m_k = k; m_d = d; m_slowing = slowing; m_overbought = ob; m_oversold = os; }
|
| string GetName() override { return "StochasticStrategy"; }
|
| string GetDescription() override { return "Stochastic K/D crossover in OB/OS zones"; }
|
|
|
| bool GenerateSignal(string symbol, ENUM_TIMEFRAMES tf, TradingSignal &signal) override
|
| {
|
| int handle = iStochastic(symbol, tf, m_k, m_d, m_slowing, MODE_SMA, STO_LOWHIGH);
|
| if(handle == INVALID_HANDLE) return false;
|
|
|
| double k_line[2], d_line[2];
|
| if(CopyBuffer(handle, 0, 0, 2, k_line) != 2) { IndicatorRelease(handle); return false; }
|
| if(CopyBuffer(handle, 1, 0, 2, d_line) != 2) { IndicatorRelease(handle); return false; }
|
| IndicatorRelease(handle);
|
|
|
| double price = GetCurrentPrice(symbol);
|
|
|
| // K crosses above D in oversold = Buy
|
| if(k_line[0] < m_oversold && k_line[1] <= d_line[1] && k_line[0] > d_line[0])
|
| {
|
| SetSignalDefaults(signal, symbol, tf, GetName(), 0, price);
|
| signal.confidence = 0.58;
|
| return true;
|
| }
|
| // K crosses below D in overbought = Sell
|
| if(k_line[0] > m_overbought && k_line[1] >= d_line[1] && k_line[0] < d_line[0])
|
| {
|
| SetSignalDefaults(signal, symbol, tf, GetName(), 1, price);
|
| signal.confidence = 0.58;
|
| return true;
|
| }
|
| return false;
|
| }
|
| };
|
|
|
| //+------------------------------------------------------------------+
|
| //| CCI Strategy - Commodity Channel Index |
|
| //+------------------------------------------------------------------+
|
| class CCCISignalGenerator : public ISignalGenerator
|
| {
|
| private:
|
| int m_period;
|
| double m_overbought, m_oversold;
|
| public:
|
| CCCISignalGenerator(int period = 20, double ob = 100.0, double os = -100.0)
|
| { m_period = period; m_overbought = ob; m_oversold = os; }
|
| string GetName() override { return "CCIStrategy"; }
|
| string GetDescription() override { return "CCI overbought/oversold crossover"; }
|
|
|
| bool GenerateSignal(string symbol, ENUM_TIMEFRAMES tf, TradingSignal &signal) override
|
| {
|
| int handle = iCCI(symbol, tf, m_period, PRICE_TYPICAL);
|
| if(handle == INVALID_HANDLE) return false;
|
|
|
| double cci[2];
|
| if(CopyBuffer(handle, 0, 0, 2, cci) != 2) { IndicatorRelease(handle); return false; }
|
| IndicatorRelease(handle);
|
|
|
| double price = GetCurrentPrice(symbol);
|
|
|
| // CCI crosses above oversold = Buy
|
| if(cci[1] < m_oversold && cci[0] >= m_oversold)
|
| {
|
| SetSignalDefaults(signal, symbol, tf, GetName(), 0, price);
|
| signal.confidence = 0.55;
|
| return true;
|
| }
|
| // CCI crosses below overbought = Sell
|
| if(cci[1] > m_overbought && cci[0] <= m_overbought)
|
| {
|
| SetSignalDefaults(signal, symbol, tf, GetName(), 1, price);
|
| signal.confidence = 0.55;
|
| return true;
|
| }
|
| return false;
|
| }
|
| };
|
|
|
| //+------------------------------------------------------------------+
|
| //| Momentum Strategy |
|
| //+------------------------------------------------------------------+
|
| class CMomentumSignalGenerator : public ISignalGenerator
|
| {
|
| private:
|
| int m_period;
|
| public:
|
| CMomentumSignalGenerator(int period = 14) { m_period = period; }
|
| string GetName() override { return "MomentumStrategy"; }
|
| string GetDescription() override { return "Momentum zero-line crossover"; }
|
|
|
| bool GenerateSignal(string symbol, ENUM_TIMEFRAMES tf, TradingSignal &signal) override
|
| {
|
| int handle = iMomentum(symbol, tf, m_period, PRICE_CLOSE);
|
| if(handle == INVALID_HANDLE) return false;
|
|
|
| double mom[2];
|
| if(CopyBuffer(handle, 0, 0, 2, mom) != 2) { IndicatorRelease(handle); return false; }
|
| IndicatorRelease(handle);
|
|
|
| double price = GetCurrentPrice(symbol);
|
| double zero_line = 100.0;
|
|
|
| // Momentum crosses above 100 = Buy
|
| if(mom[1] < zero_line && mom[0] >= zero_line)
|
| {
|
| SetSignalDefaults(signal, symbol, tf, GetName(), 0, price);
|
| signal.confidence = 0.55;
|
| return true;
|
| }
|
| // Momentum crosses below 100 = Sell
|
| if(mom[1] > zero_line && mom[0] <= zero_line)
|
| {
|
| SetSignalDefaults(signal, symbol, tf, GetName(), 1, price);
|
| signal.confidence = 0.55;
|
| return true;
|
| }
|
| return false;
|
| }
|
| };
|
|
|
| //+------------------------------------------------------------------+
|
| //| Williams %R Strategy |
|
| //+------------------------------------------------------------------+
|
| class CWilliamsPercentRangeSignalGenerator : public ISignalGenerator
|
| {
|
| private:
|
| int m_period;
|
| double m_overbought, m_oversold;
|
| public:
|
| CWilliamsPercentRangeSignalGenerator(int period = 14, double ob = -20.0, double os = -80.0)
|
| { m_period = period; m_overbought = ob; m_oversold = os; }
|
| string GetName() override { return "WilliamsPercentRangeStrategy"; }
|
| string GetDescription() override { return "Williams %R overbought/oversold"; }
|
|
|
| bool GenerateSignal(string symbol, ENUM_TIMEFRAMES tf, TradingSignal &signal) override
|
| {
|
| int handle = iWPR(symbol, tf, m_period);
|
| if(handle == INVALID_HANDLE) return false;
|
|
|
| double wpr[2];
|
| if(CopyBuffer(handle, 0, 0, 2, wpr) != 2) { IndicatorRelease(handle); return false; }
|
| IndicatorRelease(handle);
|
|
|
| double price = GetCurrentPrice(symbol);
|
|
|
| // WPR crosses above oversold = Buy
|
| if(wpr[1] < m_oversold && wpr[0] >= m_oversold)
|
| {
|
| SetSignalDefaults(signal, symbol, tf, GetName(), 0, price);
|
| signal.confidence = 0.55;
|
| return true;
|
| }
|
| // WPR crosses below overbought = Sell
|
| if(wpr[1] > m_overbought && wpr[0] <= m_overbought)
|
| {
|
| SetSignalDefaults(signal, symbol, tf, GetName(), 1, price);
|
| signal.confidence = 0.55;
|
| return true;
|
| }
|
| return false;
|
| }
|
| };
|
|
|
| //+------------------------------------------------------------------+
|
| //| DeMarker Strategy |
|
| //+------------------------------------------------------------------+
|
| class CDeMarkerSignalGenerator : public ISignalGenerator
|
| {
|
| private:
|
| int m_period;
|
| double m_overbought, m_oversold;
|
| public:
|
| CDeMarkerSignalGenerator(int period = 14, double ob = 0.7, double os = 0.3)
|
| { m_period = period; m_overbought = ob; m_oversold = os; }
|
| string GetName() override { return "DeMarkerStrategy"; }
|
| string GetDescription() override { return "DeMarker overbought/oversold"; }
|
|
|
| bool GenerateSignal(string symbol, ENUM_TIMEFRAMES tf, TradingSignal &signal) override
|
| {
|
| int handle = iDeMarker(symbol, tf, m_period);
|
| if(handle == INVALID_HANDLE) return false;
|
|
|
| double dem[2];
|
| if(CopyBuffer(handle, 0, 0, 2, dem) != 2) { IndicatorRelease(handle); return false; }
|
| IndicatorRelease(handle);
|
|
|
| double price = GetCurrentPrice(symbol);
|
|
|
| // DeMarker crosses above oversold = Buy
|
| if(dem[1] < m_oversold && dem[0] >= m_oversold)
|
| {
|
| SetSignalDefaults(signal, symbol, tf, GetName(), 0, price);
|
| signal.confidence = 0.55;
|
| return true;
|
| }
|
| // DeMarker crosses below overbought = Sell
|
| if(dem[1] > m_overbought && dem[0] <= m_overbought)
|
| {
|
| SetSignalDefaults(signal, symbol, tf, GetName(), 1, price);
|
| signal.confidence = 0.55;
|
| return true;
|
| }
|
| return false;
|
| }
|
| };
|
|
|
| //+------------------------------------------------------------------+
|
| //| Force Index Strategy |
|
| //+------------------------------------------------------------------+
|
| class CForceIndexSignalGenerator : public ISignalGenerator
|
| {
|
| private:
|
| int m_period;
|
| public:
|
| CForceIndexSignalGenerator(int period = 13) { m_period = period; }
|
| string GetName() override { return "ForceIndexStrategy"; }
|
| string GetDescription() override { return "Force Index zero-line crossover"; }
|
|
|
| bool GenerateSignal(string symbol, ENUM_TIMEFRAMES tf, TradingSignal &signal) override
|
| {
|
| int handle = iForce(symbol, tf, m_period, MODE_EMA, VOLUME_TICK);
|
| if(handle == INVALID_HANDLE) return false;
|
|
|
| double force[2];
|
| if(CopyBuffer(handle, 0, 0, 2, force) != 2) { IndicatorRelease(handle); return false; }
|
| IndicatorRelease(handle);
|
|
|
| double price = GetCurrentPrice(symbol);
|
|
|
| // Force crosses above 0 = Buy
|
| if(force[1] < 0 && force[0] >= 0)
|
| {
|
| SetSignalDefaults(signal, symbol, tf, GetName(), 0, price);
|
| signal.confidence = 0.55;
|
| return true;
|
| }
|
| // Force crosses below 0 = Sell
|
| if(force[1] > 0 && force[0] <= 0)
|
| {
|
| SetSignalDefaults(signal, symbol, tf, GetName(), 1, price);
|
| signal.confidence = 0.55;
|
| return true;
|
| }
|
| return false;
|
| }
|
| };
|
|
|
| //+------------------------------------------------------------------+
|
| //| Bears Power Strategy |
|
| //+------------------------------------------------------------------+
|
| class CBearsPowerSignalGenerator : public ISignalGenerator
|
| {
|
| private:
|
| int m_period;
|
| public:
|
| CBearsPowerSignalGenerator(int period = 13) { m_period = period; }
|
| string GetName() override { return "BearsPowerStrategy"; }
|
| string GetDescription() override { return "Bears Power zero-line crossover with trend filter"; }
|
|
|
| bool GenerateSignal(string symbol, ENUM_TIMEFRAMES tf, TradingSignal &signal) override
|
| {
|
| int handle = iBearsPower(symbol, tf, m_period);
|
| if(handle == INVALID_HANDLE) return false;
|
|
|
| double bears[2];
|
| if(CopyBuffer(handle, 0, 0, 2, bears) != 2) { IndicatorRelease(handle); return false; }
|
| IndicatorRelease(handle);
|
|
|
| // Get EMA for trend filter
|
| int ema_handle = iMA(symbol, tf, m_period, 0, MODE_EMA, PRICE_CLOSE);
|
| if(ema_handle == INVALID_HANDLE) return false;
|
| double ema[1], close[1];
|
| CopyBuffer(ema_handle, 0, 0, 1, ema);
|
| IndicatorRelease(ema_handle);
|
| close[0] = GetCurrentPrice(symbol);
|
|
|
| double price = close[0];
|
|
|
| // Bears Power rising from below 0 while price above EMA = Buy
|
| if(bears[1] < bears[0] && bears[0] < 0 && price > ema[0])
|
| {
|
| SetSignalDefaults(signal, symbol, tf, GetName(), 0, price);
|
| signal.confidence = 0.55;
|
| return true;
|
| }
|
| // Bears Power falling while price below EMA = Sell
|
| if(bears[1] > bears[0] && bears[0] > 0 && price < ema[0])
|
| {
|
| SetSignalDefaults(signal, symbol, tf, GetName(), 1, price);
|
| signal.confidence = 0.55;
|
| return true;
|
| }
|
| return false;
|
| }
|
| };
|
|
|
| //+------------------------------------------------------------------+
|
| //| Bulls Power Strategy |
|
| //+------------------------------------------------------------------+
|
| class CBullsPowerSignalGenerator : public ISignalGenerator
|
| {
|
| private:
|
| int m_period;
|
| public:
|
| CBullsPowerSignalGenerator(int period = 13) { m_period = period; }
|
| string GetName() override { return "BullsPowerStrategy"; }
|
| string GetDescription() override { return "Bulls Power zero-line crossover with trend filter"; }
|
|
|
| bool GenerateSignal(string symbol, ENUM_TIMEFRAMES tf, TradingSignal &signal) override
|
| {
|
| int handle = iBullsPower(symbol, tf, m_period);
|
| if(handle == INVALID_HANDLE) return false;
|
|
|
| double bulls[2];
|
| if(CopyBuffer(handle, 0, 0, 2, bulls) != 2) { IndicatorRelease(handle); return false; }
|
| IndicatorRelease(handle);
|
|
|
| // Get EMA for trend filter
|
| int ema_handle = iMA(symbol, tf, m_period, 0, MODE_EMA, PRICE_CLOSE);
|
| if(ema_handle == INVALID_HANDLE) return false;
|
| double ema[1];
|
| CopyBuffer(ema_handle, 0, 0, 1, ema);
|
| IndicatorRelease(ema_handle);
|
|
|
| double price = GetCurrentPrice(symbol);
|
|
|
| // Bulls Power rising while price above EMA = Buy
|
| if(bulls[1] < bulls[0] && bulls[0] > 0 && price > ema[0])
|
| {
|
| SetSignalDefaults(signal, symbol, tf, GetName(), 0, price);
|
| signal.confidence = 0.55;
|
| return true;
|
| }
|
| // Bulls Power falling from above 0 while price below EMA = Sell
|
| if(bulls[1] > bulls[0] && bulls[0] < 0 && price < ema[0])
|
| {
|
| SetSignalDefaults(signal, symbol, tf, GetName(), 1, price);
|
| signal.confidence = 0.55;
|
| return true;
|
| }
|
| return false;
|
| }
|
| };
|
|
|
| //+------------------------------------------------------------------+
|
| //| RVI Strategy - Relative Vigor Index |
|
| //+------------------------------------------------------------------+
|
| class CRVISignalGenerator : public ISignalGenerator
|
| {
|
| private:
|
| int m_period;
|
| public:
|
| CRVISignalGenerator(int period = 10) { m_period = period; }
|
| string GetName() override { return "RVIStrategy"; }
|
| string GetDescription() override { return "RVI signal line crossover"; }
|
|
|
| bool GenerateSignal(string symbol, ENUM_TIMEFRAMES tf, TradingSignal &signal) override
|
| {
|
| int handle = iRVI(symbol, tf, m_period);
|
| if(handle == INVALID_HANDLE) return false;
|
|
|
| double rvi[2], sig_line[2];
|
| if(CopyBuffer(handle, 0, 0, 2, rvi) != 2) { IndicatorRelease(handle); return false; }
|
| if(CopyBuffer(handle, 1, 0, 2, sig_line) != 2) { IndicatorRelease(handle); return false; }
|
| IndicatorRelease(handle);
|
|
|
| double price = GetCurrentPrice(symbol);
|
|
|
| // RVI crosses above signal = Buy
|
| if(rvi[1] <= sig_line[1] && rvi[0] > sig_line[0])
|
| {
|
| SetSignalDefaults(signal, symbol, tf, GetName(), 0, price);
|
| signal.confidence = 0.55;
|
| return true;
|
| }
|
| // RVI crosses below signal = Sell
|
| if(rvi[1] >= sig_line[1] && rvi[0] < sig_line[0])
|
| {
|
| SetSignalDefaults(signal, symbol, tf, GetName(), 1, price);
|
| signal.confidence = 0.55;
|
| return true;
|
| }
|
| return false;
|
| }
|
| };
|
|
|
| //+------------------------------------------------------------------+
|
| //| OsMA Strategy - Moving Average of Oscillator |
|
| //+------------------------------------------------------------------+
|
| class COsMASignalGenerator : public ISignalGenerator
|
| {
|
| private:
|
| int m_fast, m_slow, m_signal;
|
| public:
|
| COsMASignalGenerator(int fast = 12, int slow = 26, int sig = 9)
|
| { m_fast = fast; m_slow = slow; m_signal = sig; }
|
| string GetName() override { return "OsMAStrategy"; }
|
| string GetDescription() override { return "OsMA zero-line crossover"; }
|
|
|
| bool GenerateSignal(string symbol, ENUM_TIMEFRAMES tf, TradingSignal &signal) override
|
| {
|
| int handle = iOsMA(symbol, tf, m_fast, m_slow, m_signal, PRICE_CLOSE);
|
| if(handle == INVALID_HANDLE) return false;
|
|
|
| double osma[2];
|
| if(CopyBuffer(handle, 0, 0, 2, osma) != 2) { IndicatorRelease(handle); return false; }
|
| IndicatorRelease(handle);
|
|
|
| double price = GetCurrentPrice(symbol);
|
|
|
| // OsMA crosses above 0 = Buy
|
| if(osma[1] < 0 && osma[0] >= 0)
|
| {
|
| SetSignalDefaults(signal, symbol, tf, GetName(), 0, price);
|
| signal.confidence = 0.55;
|
| return true;
|
| }
|
| // OsMA crosses below 0 = Sell
|
| if(osma[1] > 0 && osma[0] <= 0)
|
| {
|
| SetSignalDefaults(signal, symbol, tf, GetName(), 1, price);
|
| signal.confidence = 0.55;
|
| return true;
|
| }
|
| return false;
|
| }
|
| };
|
|
|
| //+------------------------------------------------------------------+
|
| //| TriX Strategy - Triple Exponential Average |
|
| //+------------------------------------------------------------------+
|
| class CTriXSignalGenerator : public ISignalGenerator
|
| {
|
| private:
|
| int m_period;
|
| public:
|
| CTriXSignalGenerator(int period = 14) { m_period = period; }
|
| string GetName() override { return "TriXStrategy"; }
|
| string GetDescription() override { return "TriX zero-line crossover"; }
|
|
|
| bool GenerateSignal(string symbol, ENUM_TIMEFRAMES tf, TradingSignal &signal) override
|
| {
|
| int handle = iTriX(symbol, tf, m_period, PRICE_CLOSE);
|
| if(handle == INVALID_HANDLE) return false;
|
|
|
| double trix[2];
|
| if(CopyBuffer(handle, 0, 0, 2, trix) != 2) { IndicatorRelease(handle); return false; }
|
| IndicatorRelease(handle);
|
|
|
| double price = GetCurrentPrice(symbol);
|
|
|
| // TriX crosses above 0 = Buy
|
| if(trix[1] < 0 && trix[0] >= 0)
|
| {
|
| SetSignalDefaults(signal, symbol, tf, GetName(), 0, price);
|
| signal.confidence = 0.55;
|
| return true;
|
| }
|
| // TriX crosses below 0 = Sell
|
| if(trix[1] > 0 && trix[0] <= 0)
|
| {
|
| SetSignalDefaults(signal, symbol, tf, GetName(), 1, price);
|
| signal.confidence = 0.55;
|
| return true;
|
| }
|
| return false;
|
| }
|
| };
|
|
|
| //+------------------------------------------------------------------+
|
| //| Accelerator Oscillator Strategy |
|
| //+------------------------------------------------------------------+
|
| class CAcceleratorOscillatorSignalGenerator : public ISignalGenerator
|
| {
|
| public:
|
| string GetName() override { return "AcceleratorOscillatorStrategy"; }
|
| string GetDescription() override { return "AC zero-line crossover with color confirmation"; }
|
|
|
| bool GenerateSignal(string symbol, ENUM_TIMEFRAMES tf, TradingSignal &signal) override
|
| {
|
| int handle = iAC(symbol, tf);
|
| if(handle == INVALID_HANDLE) return false;
|
|
|
| double ac[3];
|
| if(CopyBuffer(handle, 0, 0, 3, ac) != 3) { IndicatorRelease(handle); return false; }
|
| IndicatorRelease(handle);
|
|
|
| double price = GetCurrentPrice(symbol);
|
|
|
| // AC crosses above 0 with rising momentum = Buy
|
| if(ac[2] < 0 && ac[1] < 0 && ac[0] >= 0 && ac[0] > ac[1])
|
| {
|
| SetSignalDefaults(signal, symbol, tf, GetName(), 0, price);
|
| signal.confidence = 0.55;
|
| return true;
|
| }
|
| // AC crosses below 0 with falling momentum = Sell
|
| if(ac[2] > 0 && ac[1] > 0 && ac[0] <= 0 && ac[0] < ac[1])
|
| {
|
| SetSignalDefaults(signal, symbol, tf, GetName(), 1, price);
|
| signal.confidence = 0.55;
|
| return true;
|
| }
|
| return false;
|
| }
|
| };
|
|
|
| //+------------------------------------------------------------------+
|
| //| Awesome Oscillator Strategy |
|
| //+------------------------------------------------------------------+
|
| class CAwesomeOscillatorSignalGenerator : public ISignalGenerator
|
| {
|
| public:
|
| string GetName() override { return "AwesomeOscillatorStrategy"; }
|
| string GetDescription() override { return "AO zero-line crossover"; }
|
|
|
| bool GenerateSignal(string symbol, ENUM_TIMEFRAMES tf, TradingSignal &signal) override
|
| {
|
| int handle = iAO(symbol, tf);
|
| if(handle == INVALID_HANDLE) return false;
|
|
|
| double ao[2];
|
| if(CopyBuffer(handle, 0, 0, 2, ao) != 2) { IndicatorRelease(handle); return false; }
|
| IndicatorRelease(handle);
|
|
|
| double price = GetCurrentPrice(symbol);
|
|
|
| // AO crosses above 0 = Buy
|
| if(ao[1] < 0 && ao[0] >= 0)
|
| {
|
| SetSignalDefaults(signal, symbol, tf, GetName(), 0, price);
|
| signal.confidence = 0.55;
|
| return true;
|
| }
|
| // AO crosses below 0 = Sell
|
| if(ao[1] > 0 && ao[0] <= 0)
|
| {
|
| SetSignalDefaults(signal, symbol, tf, GetName(), 1, price);
|
| signal.confidence = 0.55;
|
| return true;
|
| }
|
| return false;
|
| }
|
| };
|
|
|
| //+------------------------------------------------------------------+
|
| //| Alligator Strategy |
|
| //+------------------------------------------------------------------+
|
| class CAlligatorSignalGenerator : public ISignalGenerator
|
| {
|
| private:
|
| int m_jaw, m_teeth, m_lips;
|
| public:
|
| CAlligatorSignalGenerator(int jaw = 13, int teeth = 8, int lips = 5)
|
| { m_jaw = jaw; m_teeth = teeth; m_lips = lips; }
|
| string GetName() override { return "AlligatorStrategy"; }
|
| string GetDescription() override { return "Alligator awakening - lines spread apart"; }
|
|
|
| bool GenerateSignal(string symbol, ENUM_TIMEFRAMES tf, TradingSignal &signal) override
|
| {
|
| int handle = iAlligator(symbol, tf, m_jaw, 8, m_teeth, 5, m_lips, 3, MODE_SMMA, PRICE_MEDIAN);
|
| if(handle == INVALID_HANDLE) return false;
|
|
|
| double jaw[2], teeth[2], lips[2];
|
| if(CopyBuffer(handle, 0, 0, 2, jaw) != 2) { IndicatorRelease(handle); return false; }
|
| if(CopyBuffer(handle, 1, 0, 2, teeth) != 2) { IndicatorRelease(handle); return false; }
|
| if(CopyBuffer(handle, 2, 0, 2, lips) != 2) { IndicatorRelease(handle); return false; }
|
| IndicatorRelease(handle);
|
|
|
| double price = GetCurrentPrice(symbol);
|
|
|
| // Bullish: Lips > Teeth > Jaw and spreading
|
| if(lips[0] > teeth[0] && teeth[0] > jaw[0] &&
|
| (lips[0] - jaw[0]) > (lips[1] - jaw[1]))
|
| {
|
| SetSignalDefaults(signal, symbol, tf, GetName(), 0, price);
|
| signal.confidence = 0.58;
|
| return true;
|
| }
|
| // Bearish: Lips < Teeth < Jaw and spreading
|
| if(lips[0] < teeth[0] && teeth[0] < jaw[0] &&
|
| (jaw[0] - lips[0]) > (jaw[1] - lips[1]))
|
| {
|
| SetSignalDefaults(signal, symbol, tf, GetName(), 1, price);
|
| signal.confidence = 0.58;
|
| return true;
|
| }
|
| return false;
|
| }
|
| };
|
|
|
| //+------------------------------------------------------------------+
|
| //| Gator Oscillator Strategy |
|
| //+------------------------------------------------------------------+
|
| class CGatorSignalGenerator : public ISignalGenerator
|
| {
|
| public:
|
| string GetName() override { return "GatorStrategy"; }
|
| string GetDescription() override { return "Gator awakening - bars expanding"; }
|
|
|
| bool GenerateSignal(string symbol, ENUM_TIMEFRAMES tf, TradingSignal &signal) override
|
| {
|
| int handle = iGator(symbol, tf, 13, 8, 8, 5, 5, 3, MODE_SMMA, PRICE_MEDIAN);
|
| if(handle == INVALID_HANDLE) return false;
|
|
|
| double upper[3], lower[3];
|
| if(CopyBuffer(handle, 0, 0, 3, upper) != 3) { IndicatorRelease(handle); return false; }
|
| if(CopyBuffer(handle, 2, 0, 3, lower) != 3) { IndicatorRelease(handle); return false; }
|
| IndicatorRelease(handle);
|
|
|
| double price = GetCurrentPrice(symbol);
|
|
|
| // Gator awakening (bars expanding) = trend starting
|
| double spread_now = MathAbs(upper[0]) + MathAbs(lower[0]);
|
| double spread_prev = MathAbs(upper[1]) + MathAbs(lower[1]);
|
| double spread_prev2 = MathAbs(upper[2]) + MathAbs(lower[2]);
|
|
|
| if(spread_now > spread_prev && spread_prev > spread_prev2)
|
| {
|
| // Determine direction from upper histogram
|
| if(upper[0] > 0)
|
| {
|
| SetSignalDefaults(signal, symbol, tf, GetName(), 0, price);
|
| signal.confidence = 0.55;
|
| return true;
|
| }
|
| else
|
| {
|
| SetSignalDefaults(signal, symbol, tf, GetName(), 1, price);
|
| signal.confidence = 0.55;
|
| return true;
|
| }
|
| }
|
| return false;
|
| }
|
| };
|
|
|
| //+------------------------------------------------------------------+
|
| //| Ichimoku Strategy |
|
| //+------------------------------------------------------------------+
|
| class CIchimokuSignalGenerator : public ISignalGenerator
|
| {
|
| private:
|
| int m_tenkan, m_kijun, m_senkou;
|
| public:
|
| CIchimokuSignalGenerator(int tenkan = 9, int kijun = 26, int senkou = 52)
|
| { m_tenkan = tenkan; m_kijun = kijun; m_senkou = senkou; }
|
| string GetName() override { return "IchimokuStrategy"; }
|
| string GetDescription() override { return "Ichimoku Tenkan/Kijun crossover with cloud filter"; }
|
|
|
| bool GenerateSignal(string symbol, ENUM_TIMEFRAMES tf, TradingSignal &signal) override
|
| {
|
| int handle = iIchimoku(symbol, tf, m_tenkan, m_kijun, m_senkou);
|
| if(handle == INVALID_HANDLE) return false;
|
|
|
| double tenkan[2], kijun[2], senkou_a[1], senkou_b[1];
|
| if(CopyBuffer(handle, 0, 0, 2, tenkan) != 2) { IndicatorRelease(handle); return false; }
|
| if(CopyBuffer(handle, 1, 0, 2, kijun) != 2) { IndicatorRelease(handle); return false; }
|
| if(CopyBuffer(handle, 2, 0, 1, senkou_a) != 1) { IndicatorRelease(handle); return false; }
|
| if(CopyBuffer(handle, 3, 0, 1, senkou_b) != 1) { IndicatorRelease(handle); return false; }
|
| IndicatorRelease(handle);
|
|
|
| double price = GetCurrentPrice(symbol);
|
| double cloud_top = MathMax(senkou_a[0], senkou_b[0]);
|
| double cloud_bottom = MathMin(senkou_a[0], senkou_b[0]);
|
|
|
| // Tenkan crosses above Kijun, price above cloud = Buy
|
| if(tenkan[1] <= kijun[1] && tenkan[0] > kijun[0] && price > cloud_top)
|
| {
|
| SetSignalDefaults(signal, symbol, tf, GetName(), 0, price);
|
| signal.confidence = 0.62;
|
| return true;
|
| }
|
| // Tenkan crosses below Kijun, price below cloud = Sell
|
| if(tenkan[1] >= kijun[1] && tenkan[0] < kijun[0] && price < cloud_bottom)
|
| {
|
| SetSignalDefaults(signal, symbol, tf, GetName(), 1, price);
|
| signal.confidence = 0.62;
|
| return true;
|
| }
|
| return false;
|
| }
|
| };
|
|
|
| //+------------------------------------------------------------------+
|
| //| Fractals Strategy |
|
| //+------------------------------------------------------------------+
|
| class CFractalsSignalGenerator : public ISignalGenerator
|
| {
|
| public:
|
| string GetName() override { return "FractalsStrategy"; }
|
| string GetDescription() override { return "Fractal breakout"; }
|
|
|
| bool GenerateSignal(string symbol, ENUM_TIMEFRAMES tf, TradingSignal &signal) override
|
| {
|
| int handle = iFractals(symbol, tf);
|
| if(handle == INVALID_HANDLE) return false;
|
|
|
| double upper[10], lower[10];
|
| if(CopyBuffer(handle, 0, 0, 10, upper) != 10) { IndicatorRelease(handle); return false; }
|
| if(CopyBuffer(handle, 1, 0, 10, lower) != 10) { IndicatorRelease(handle); return false; }
|
| IndicatorRelease(handle);
|
|
|
| // Find last valid fractal
|
| double last_upper = 0, last_lower = 0;
|
| for(int i = 2; i < 10; i++)
|
| {
|
| if(upper[i] != EMPTY_VALUE && upper[i] > 0) { last_upper = upper[i]; break; }
|
| }
|
| for(int i = 2; i < 10; i++)
|
| {
|
| if(lower[i] != EMPTY_VALUE && lower[i] > 0) { last_lower = lower[i]; break; }
|
| }
|
|
|
| if(last_upper == 0 && last_lower == 0) return false;
|
|
|
| double price = GetCurrentPrice(symbol);
|
|
|
| // Price breaks above upper fractal = Buy
|
| if(last_upper > 0 && price > last_upper)
|
| {
|
| SetSignalDefaults(signal, symbol, tf, GetName(), 0, price);
|
| signal.confidence = 0.55;
|
| return true;
|
| }
|
| // Price breaks below lower fractal = Sell
|
| if(last_lower > 0 && price < last_lower)
|
| {
|
| SetSignalDefaults(signal, symbol, tf, GetName(), 1, price);
|
| signal.confidence = 0.55;
|
| return true;
|
| }
|
| return false;
|
| }
|
| };
|
|
|
| //+------------------------------------------------------------------+
|
| //| ZigZag Strategy |
|
| //+------------------------------------------------------------------+
|
| class CZigZagSignalGenerator : public ISignalGenerator
|
| {
|
| private:
|
| int m_depth, m_deviation, m_backstep;
|
| public:
|
| CZigZagSignalGenerator(int depth = 12, int deviation = 5, int backstep = 3)
|
| { m_depth = depth; m_deviation = deviation; m_backstep = backstep; }
|
| string GetName() override { return "ZigZagStrategy"; }
|
| string GetDescription() override { return "ZigZag swing point breakout"; }
|
|
|
| bool GenerateSignal(string symbol, ENUM_TIMEFRAMES tf, TradingSignal &signal) override
|
| {
|
| int handle = iCustom(symbol, tf, "Examples\\ZigZag", m_depth, m_deviation, m_backstep);
|
| if(handle == INVALID_HANDLE) return false;
|
|
|
| double zz[50];
|
| if(CopyBuffer(handle, 0, 0, 50, zz) != 50) { IndicatorRelease(handle); return false; }
|
| IndicatorRelease(handle);
|
|
|
| // Find last two swing points
|
| double swing1 = 0, swing2 = 0;
|
| int swing1_idx = -1, swing2_idx = -1;
|
| for(int i = 0; i < 50; i++)
|
| {
|
| if(zz[i] != 0 && zz[i] != EMPTY_VALUE)
|
| {
|
| if(swing1 == 0) { swing1 = zz[i]; swing1_idx = i; }
|
| else if(swing2 == 0) { swing2 = zz[i]; swing2_idx = i; break; }
|
| }
|
| }
|
|
|
| if(swing1 == 0 || swing2 == 0) return false;
|
|
|
| double price = GetCurrentPrice(symbol);
|
|
|
| // Higher high = uptrend, buy on pullback
|
| if(swing1 > swing2 && price > swing2)
|
| {
|
| SetSignalDefaults(signal, symbol, tf, GetName(), 0, price);
|
| signal.confidence = 0.55;
|
| return true;
|
| }
|
| // Lower low = downtrend, sell on pullback
|
| if(swing1 < swing2 && price < swing2)
|
| {
|
| SetSignalDefaults(signal, symbol, tf, GetName(), 1, price);
|
| signal.confidence = 0.55;
|
| return true;
|
| }
|
| return false;
|
| }
|
| };
|
|
|
| //+------------------------------------------------------------------+
|
| //| Ultimate Oscillator Strategy |
|
| //+------------------------------------------------------------------+
|
| class CUltimateOscillatorSignalGenerator : public ISignalGenerator
|
| {
|
| private:
|
| int m_fast, m_middle, m_slow;
|
| double m_overbought, m_oversold;
|
| public:
|
| CUltimateOscillatorSignalGenerator(int fast = 7, int middle = 14, int slow = 28, double ob = 70.0, double os = 30.0)
|
| { m_fast = fast; m_middle = middle; m_slow = slow; m_overbought = ob; m_oversold = os; }
|
| string GetName() override { return "UltimateOscillatorStrategy"; }
|
| string GetDescription() override { return "Ultimate Oscillator overbought/oversold with divergence"; }
|
|
|
| bool GenerateSignal(string symbol, ENUM_TIMEFRAMES tf, TradingSignal &signal) override
|
| {
|
| // Ultimate Oscillator is not a built-in indicator, calculate manually
|
| // Using a simplified approach with ATR and price action
|
| double close[30], high[30], low[30];
|
| if(CopyClose(symbol, tf, 0, 30, close) != 30) return false;
|
| if(CopyHigh(symbol, tf, 0, 30, high) != 30) return false;
|
| if(CopyLow(symbol, tf, 0, 30, low) != 30) return false;
|
|
|
| // Calculate buying pressure and true range
|
| double bp_sum_fast = 0, tr_sum_fast = 0;
|
| double bp_sum_mid = 0, tr_sum_mid = 0;
|
| double bp_sum_slow = 0, tr_sum_slow = 0;
|
|
|
| for(int i = 1; i < 29; i++)
|
| {
|
| double true_low = MathMin(low[i], close[i+1]);
|
| double true_high = MathMax(high[i], close[i+1]);
|
| double bp = close[i] - true_low;
|
| double tr = true_high - true_low;
|
|
|
| if(i < m_fast) { bp_sum_fast += bp; tr_sum_fast += tr; }
|
| if(i < m_middle) { bp_sum_mid += bp; tr_sum_mid += tr; }
|
| if(i < m_slow) { bp_sum_slow += bp; tr_sum_slow += tr; }
|
| }
|
|
|
| if(tr_sum_fast == 0 || tr_sum_mid == 0 || tr_sum_slow == 0) return false;
|
|
|
| double avg_fast = bp_sum_fast / tr_sum_fast;
|
| double avg_mid = bp_sum_mid / tr_sum_mid;
|
| double avg_slow = bp_sum_slow / tr_sum_slow;
|
|
|
| double uo = 100.0 * ((4.0 * avg_fast) + (2.0 * avg_mid) + avg_slow) / 7.0;
|
|
|
| double price = GetCurrentPrice(symbol);
|
|
|
| // UO crosses above oversold = Buy
|
| if(uo < m_oversold + 5 && uo > m_oversold)
|
| {
|
| SetSignalDefaults(signal, symbol, tf, GetName(), 0, price);
|
| signal.confidence = 0.55;
|
| return true;
|
| }
|
| // UO crosses below overbought = Sell
|
| if(uo > m_overbought - 5 && uo < m_overbought)
|
| {
|
| SetSignalDefaults(signal, symbol, tf, GetName(), 1, price);
|
| signal.confidence = 0.55;
|
| return true;
|
| }
|
| return false;
|
| }
|
| };
|
|
|
| //+------------------------------------------------------------------+
|
| //| Moving Average Strategy (default fallback) |
|
| //+------------------------------------------------------------------+
|
| class CMovingAverageSignalGenerator : public ISignalGenerator
|
| {
|
| private:
|
| int m_fast, m_slow;
|
| public:
|
| CMovingAverageSignalGenerator(int fast = 20, int slow = 50) { m_fast = fast; m_slow = slow; }
|
| string GetName() override { return "MovingAverageStrategy"; }
|
| string GetDescription() override { return "MA crossover"; }
|
|
|
| bool GenerateSignal(string symbol, ENUM_TIMEFRAMES tf, TradingSignal &signal) override
|
| {
|
| int fast_handle = iMA(symbol, tf, m_fast, 0, MODE_SMA, PRICE_CLOSE);
|
| int slow_handle = iMA(symbol, tf, m_slow, 0, MODE_SMA, PRICE_CLOSE);
|
| if(fast_handle == INVALID_HANDLE || slow_handle == INVALID_HANDLE) return false;
|
|
|
| double fast_ma[2], slow_ma[2];
|
| if(CopyBuffer(fast_handle, 0, 0, 2, fast_ma) != 2) { IndicatorRelease(fast_handle); IndicatorRelease(slow_handle); return false; }
|
| if(CopyBuffer(slow_handle, 0, 0, 2, slow_ma) != 2) { IndicatorRelease(fast_handle); IndicatorRelease(slow_handle); return false; }
|
| IndicatorRelease(fast_handle);
|
| IndicatorRelease(slow_handle);
|
|
|
| double price = GetCurrentPrice(symbol);
|
|
|
| // Fast MA crosses above Slow MA = Buy
|
| if(fast_ma[1] <= slow_ma[1] && fast_ma[0] > slow_ma[0])
|
| {
|
| SetSignalDefaults(signal, symbol, tf, GetName(), 0, price);
|
| signal.confidence = 0.6;
|
| return true;
|
| }
|
| // Fast MA crosses below Slow MA = Sell
|
| if(fast_ma[1] >= slow_ma[1] && fast_ma[0] < slow_ma[0])
|
| {
|
| SetSignalDefaults(signal, symbol, tf, GetName(), 1, price);
|
| signal.confidence = 0.6;
|
| return true;
|
| }
|
| return false;
|
| }
|
| };
|
|
|
| //+------------------------------------------------------------------+
|
| //| STRATEGY SIGNAL GENERATOR REGISTRY |
|
| //| Maps strategy names to their signal generators |
|
| //+------------------------------------------------------------------+
|
| class CStrategySignalRegistry
|
| {
|
| private:
|
| ISignalGenerator* m_generators[];
|
| int m_count;
|
|
|
| public:
|
| CStrategySignalRegistry()
|
| {
|
| m_count = 0;
|
| ArrayResize(m_generators, 0);
|
| }
|
|
|
| ~CStrategySignalRegistry()
|
| {
|
| for(int i = 0; i < m_count; i++)
|
| {
|
| if(m_generators[i] != NULL)
|
| delete m_generators[i];
|
| }
|
| }
|
|
|
| void RegisterGenerator(ISignalGenerator* generator)
|
| {
|
| if(generator == NULL) return;
|
| ArrayResize(m_generators, m_count + 1);
|
| m_generators[m_count] = generator;
|
| m_count++;
|
| }
|
|
|
| ISignalGenerator* GetGenerator(const string &strategy_name)
|
| {
|
| for(int i = 0; i < m_count; i++)
|
| {
|
| if(m_generators[i] != NULL && m_generators[i].GetName() == strategy_name)
|
| return m_generators[i];
|
| }
|
| return NULL;
|
| }
|
|
|
| bool GenerateSignal(const string &strategy_name, string symbol, ENUM_TIMEFRAMES tf, TradingSignal &signal)
|
| {
|
| // CRITICAL: Always initialize signal to safe defaults before generation
|
| signal.Init();
|
|
|
| ISignalGenerator* gen = GetGenerator(strategy_name);
|
| if(gen == NULL) return false;
|
| return gen.GenerateSignal(symbol, tf, signal);
|
| }
|
|
|
| int GetCount() { return m_count; }
|
|
|
| void InitializeAllStrategies()
|
| {
|
| RegisterGenerator(new CADXSignalGenerator());
|
| RegisterGenerator(new CRSISignalGenerator());
|
| RegisterGenerator(new CMACDSignalGenerator());
|
| RegisterGenerator(new CStochasticSignalGenerator());
|
| RegisterGenerator(new CCCISignalGenerator());
|
| RegisterGenerator(new CMomentumSignalGenerator());
|
| RegisterGenerator(new CWilliamsPercentRangeSignalGenerator());
|
| RegisterGenerator(new CDeMarkerSignalGenerator());
|
| RegisterGenerator(new CForceIndexSignalGenerator());
|
| RegisterGenerator(new CBearsPowerSignalGenerator());
|
| RegisterGenerator(new CBullsPowerSignalGenerator());
|
| RegisterGenerator(new CRVISignalGenerator());
|
| RegisterGenerator(new COsMASignalGenerator());
|
| RegisterGenerator(new CTriXSignalGenerator());
|
| RegisterGenerator(new CAcceleratorOscillatorSignalGenerator());
|
| RegisterGenerator(new CAwesomeOscillatorSignalGenerator());
|
| RegisterGenerator(new CAlligatorSignalGenerator());
|
| RegisterGenerator(new CGatorSignalGenerator());
|
| RegisterGenerator(new CIchimokuSignalGenerator());
|
| RegisterGenerator(new CFractalsSignalGenerator());
|
| RegisterGenerator(new CZigZagSignalGenerator());
|
| RegisterGenerator(new CUltimateOscillatorSignalGenerator());
|
| RegisterGenerator(new CMovingAverageSignalGenerator());
|
| }
|
|
|
| string GetRegisteredStrategies()
|
| {
|
| string result = "";
|
| for(int i = 0; i < m_count; i++)
|
| {
|
| if(m_generators[i] != NULL)
|
| {
|
| if(result != "") result += ",";
|
| result += m_generators[i].GetName();
|
| }
|
| }
|
| return result;
|
| }
|
| };
|
|
|
| #endif // __STRATEGY_SIGNAL_GENERATORS_MQH__
|
