From c1d35aed0368b9ceab29a71d54805b926b2d56a4 Mon Sep 17 00:00:00 2001 From: Hadi Khazaee Asl Date: Wed, 25 Dec 2024 21:11:54 +0330 Subject: [PATCH] last ... --- X121SMCEA/Libraries/x-121.smc.lib.mq5 | 11 + .../Signals/x-121.smc.xpvob.signal.lib.mq5 | 34 +- .../x-121.smc.xpvsupdem.signal.lib.mq5 | 49 + .../Signals/x-121.smc.xvwpb.signal.lib.mq5 | 950 ++++++++++++++++++ .../Strategy/x-121.smc.strategy.class.mq5 | 139 ++- 5 files changed, 1176 insertions(+), 7 deletions(-) create mode 100644 X121SMCEA/Signals/x-121.smc.xvwpb.signal.lib.mq5 diff --git a/X121SMCEA/Libraries/x-121.smc.lib.mq5 b/X121SMCEA/Libraries/x-121.smc.lib.mq5 index 24b9b798..9348dcc0 100644 --- a/X121SMCEA/Libraries/x-121.smc.lib.mq5 +++ b/X121SMCEA/Libraries/x-121.smc.lib.mq5 @@ -37,6 +37,7 @@ const string X121SMCStrategyToken = "X121SMC"; const string X121SMCXTestToken = "X121XTest"; const string X121SMCXPVOBToken = "X121XPVOB"; const string X121SMCXPVDPToken = "X121XPVDP"; +const string X121SMCXVWPBToken = "X121XVWPB"; const string X121SMCXPVSupDemToken = "X121XPVSUPDEM"; // @@ -48,6 +49,7 @@ enum ENUM_X_121_SMC_PROVIDERS X_121_SMC_PROVIDER_XTEST, X_121_SMC_PROVIDER_XPVOB, X_121_SMC_PROVIDER_XPVDP, + X_121_SMC_PROVIDER_XVWPB, X_121_SMC_PROVIDER_XPVSUPDEM, }; @@ -1967,6 +1969,11 @@ string ToString(ENUM_X_121_SMC_PROVIDERS value) result = X121SMCXPVDPToken; break; + // + case X_121_SMC_PROVIDER_XVWPB: + result = X121SMCXVWPBToken; + break; + // case X_121_SMC_PROVIDER_XPVSUPDEM: result = X121SMCXPVSupDemToken; @@ -2008,6 +2015,10 @@ ENUM_X_121_SMC_PROVIDERS ParseProvider(string value) { result = X_121_SMC_PROVIDER_XPVDP; } + else if (Contains(X121SMCXVWPBToken, value)) + { + result = X_121_SMC_PROVIDER_XVWPB; + } else if (Contains(X121SMCXPVSupDemToken, value)) { result = X_121_SMC_PROVIDER_XPVSUPDEM; diff --git a/X121SMCEA/Signals/x-121.smc.xpvob.signal.lib.mq5 b/X121SMCEA/Signals/x-121.smc.xpvob.signal.lib.mq5 index f4d87a02..df024e04 100644 --- a/X121SMCEA/Signals/x-121.smc.xpvob.signal.lib.mq5 +++ b/X121SMCEA/Signals/x-121.smc.xpvob.signal.lib.mq5 @@ -419,13 +419,29 @@ bool DetectX121SMCXPVOBSiganlSetup( // // Setup Conditions ... + // + // Detect Market Trend ... + ENUM_X_DIRECTION trend; + bool hasTrend = consolidationCycleHelper + .DetectTrend(trend); + bool hasBullishTrend = hasTrend && + IsBullish(trend); + bool hasBearishTrend = hasTrend && + IsBearish(trend); + result = hasBullishTrend || + hasBearishTrend; + if (!result) + { + return result; + } + // // Select Source State ... XPOIState state = decisionState; // // Detect Imbalance ... - + // bool hasBullishOB = conditions.HasBullishOB(); if (!hasBullishOB) @@ -638,8 +654,20 @@ bool DetectX121SMCXPVOBSiganlSetup( // // Detect Setup Conditions based on Peaks or Vales Occurance ... - bool lookupForLong = isNewVale && hasBullishOB && hasBullishFVG; - bool lookupForShort = isNewPeak && hasBearishOB && hasBearishFVG; + + // + bool lookupForLong = isNewVale && + hasBullishOB && + hasBullishFVG && + hasBullishTrend; + + // + bool lookupForShort = isNewPeak && + hasBearishOB && + hasBearishFVG && + hasBearishTrend; + + // result = lookupForLong || lookupForShort; if (!result) diff --git a/X121SMCEA/Signals/x-121.smc.xpvsupdem.signal.lib.mq5 b/X121SMCEA/Signals/x-121.smc.xpvsupdem.signal.lib.mq5 index a54aff02..5a84cfd8 100644 --- a/X121SMCEA/Signals/x-121.smc.xpvsupdem.signal.lib.mq5 +++ b/X121SMCEA/Signals/x-121.smc.xpvsupdem.signal.lib.mq5 @@ -300,6 +300,17 @@ struct X121SMCStrategyXPVSUPDEMSignalConditions return result; } + /** + * Clean Active Zone ... + */ + void CleanActiveZone() + { + // + activeSupplyZone = NULL; + activeDemandZone = NULL; + activeZoneFoundedAt = NULL; + } + /** * Check Ticks Zone is Initialized or not ... * @return ( bool ) @@ -527,6 +538,22 @@ bool DetectX121SMCXPVSUPDEMSiganlSetup( // // Setup Conditions ... + // + // Detect Market Trend ... + ENUM_X_DIRECTION trend; + bool hasTrend = consolidationCycleHelper + .DetectTrend(trend); + bool hasBullishTrend = hasTrend && + IsBullish(trend); + bool hasBearishTrend = hasTrend && + IsBearish(trend); + result = hasBullishTrend || + hasBearishTrend; + if (!result) + { + return result; + } + // // Select Source State ... XPOIState state = consolidationState; @@ -703,6 +730,28 @@ bool DetectX121SMCXPVSUPDEMSiganlSetup( // // Now we Have to Calculate Active Zones Ticks ... + // + bool isValidDemandZone = + hasActiveZone && + hasBullishTrend && + IsBullish(activeZoneDir); + + // + bool isValidSupplyZone = + hasActiveZone && + hasBearishTrend && + IsBearish(activeZoneDir); + + // + result = isValidDemandZone || + isValidSupplyZone; + if (!result) + { + // + conditions.CleanActiveZone(); + return result; + } + // // Select Active Zone ... XCBarZone *activeZone = NULL; diff --git a/X121SMCEA/Signals/x-121.smc.xvwpb.signal.lib.mq5 b/X121SMCEA/Signals/x-121.smc.xvwpb.signal.lib.mq5 new file mode 100644 index 00000000..8de306d7 --- /dev/null +++ b/X121SMCEA/Signals/x-121.smc.xvwpb.signal.lib.mq5 @@ -0,0 +1,950 @@ +/////////////////////////////////////////////////////// +// +// SaherElm IT Center MQL5 X121 SMC Signal Class +// ------------------------------------------------- +// Name: +// Description: provide all Signalling functions ... +// +// +// Maintainer: +// ------------ +// Hadi Khazaee Asl (hadi_khazaee_asl@yahoo.com) +// +////////////////////////////////////////////////////// +// +// Global Properties ... +#property library +#property copyright "Copyright 2023, SaherElm IT Center" +#property link "https://www.saherelm.ir" +#property version "1.00" +#property strict + +// +// Imports ... +#include "../Classes/x-121.smc.market.cycle.helper.class.mq5" +#include "../Libraries/x-121.smc.lib.mq5" + +// +// Definitions ... +struct X121SMCStrategyXVWPBSignalConditions +{ + // + // Props ... + + // + string symbol; + ENUM_TIMEFRAMES period; + + // + double sl; + ENUM_X_DIRECTION dir; + ENUM_X_POSITION_TYPES type; + + // + // Setup Props ... + + // + datetime setupTime; + datetime triggerTime; + + // + // Constructor ... + X121SMCStrategyXVWPBSignalConditions() + { + Clean(); + } + + // + // Tools ... + + /** + * Cleaning Up ... + */ + void Clean() + { + // + sl = 0; + + // + dir = X_DIRECTION_NONE; + type = X_POSITION_TYPE_NONE; + + // + symbol = NULL; + period = NULL; + setupTime = NULL; + triggerTime = NULL; + + // + ExtensionClean(); + } + + /** + * Check Condition is Setting Up ... + * + * @param dir: ENUM_X_DIRECTION member, Setting Up Direction ... + * + * @return ( bool ) + */ + bool IsSetuped() + { + // + bool result = false; + + // + result = IsValid(setupTime) && + HasDirection(dir); + if (!result) + { + return result; + } + + // + return result; + } + + /** + * Calculate Setup Age ... + * + * @return ( int ) + */ + int GetSetupAge() + { + // + int result = 0; + + // + if (!IsSetuped()) + { + return result; + } + + // + result = (int)(TimeCurrent() - setupTime) / PeriodSeconds(period); + + // + return result; + } + + /** + * Detect How we Can Trigger Signal ... + * + * @return ( bool ) + */ + bool CanTrigger() + { + // + bool result = false; + + // + result = + // + sl > 0 && + IsValid(symbol) && + IsValid(period) && + IsValid(triggerTime) && + type != X_POSITION_TYPE_ALL && + type != X_POSITION_TYPE_NONE + // + ; + + // + return result; + } + + // + // Extensions ... + + /** + * Clean Additional Properties ... + */ + void ExtensionClean() + { + } + + // +}; + +// +// Extension Functions ... + +// +// Detect Setup Conditions ... +bool DetectX121SMCXVWPBSiganlSetup( + string _symbol, + ENUM_TIMEFRAMES _period, + // + X121SMCStrategyXVWPBSignalConditions &conditions, + // + XC121SMCCycleHelper *triggerCycleHelper, + XC121SMCCycleHelper *decisionCycleHelper, + XC121SMCCycleHelper *analyseCycleHelper, + XC121SMCCycleHelper *verificationCycleHelper, + XC121SMCCycleHelper *consolidationCycleHelper, + XC121SMCCycleHelper *visionCycleHelper + // +) +{ + // + bool result = false; + + // + bool isBullish = false; + bool isBearish = false; + + // + int zIndex = 0; + int cIndex = zIndex + 1; + int pIndex = cIndex + 1; + int ppIndex = pIndex + 1; + + // + int loopback = 10; + + // + string symbol = _symbol; + ENUM_TIMEFRAMES period = _period; + + // + conditions.symbol = symbol; + conditions.period = period; + + // + XOHCL zBar; + result = zBar.Init( + symbol, + period, + zIndex // + ); + if (!result) + { + return result; + } + + // + XOHCL cBar; + result = cBar.Init( + symbol, + period, + cIndex // + ); + if (!result) + { + return result; + } + + // + XOHCL pBar; + result = pBar.Init( + symbol, + period, + pIndex // + ); + if (!result) + { + return result; + } + + // + double ask = GetAsk(symbol); + double bid = GetBid(symbol); + datetime cTime = TimeCurrent(); + + // + double ll = cBar.FindLowest(9, MODE_LOW); + double hh = cBar.FindHighest(9, MODE_HIGH); + + // + int zoneValidationDivider = 10; + int validPivotRepetition = triggerCycleHelper.mX121Helper + .GetDonChainLength(); + + // + double selectedSL = 0; + + // + // Cycles Conditions ... + + // + // Trigger ... + ENUM_XPOI_EVENTS triggerPoiEvents[]; + ENUM_X_CYCLE_EVENTS triggerCycleEvents[]; + X121SMCCycleConditions triggerConditions; + result = triggerCycleHelper.GetConditions( + triggerCycleEvents, + triggerPoiEvents, + triggerConditions, + zIndex, + loopback // + ); + if (!result) + { + return result; + } + + // + // Decision ... + ENUM_XPOI_EVENTS decisionPoiEvents[]; + ENUM_X_CYCLE_EVENTS decisionCycleEvents[]; + X121SMCCycleConditions decisionConditions; + result = decisionCycleHelper.GetConditions( + decisionCycleEvents, + decisionPoiEvents, + decisionConditions, + zIndex, + loopback // + ); + if (!result) + { + return result; + } + + // + // Analyse ... + ENUM_XPOI_EVENTS analysePoiEvents[]; + ENUM_X_CYCLE_EVENTS analyseCycleEvents[]; + X121SMCCycleConditions analyseConditions; + result = analyseCycleHelper.GetConditions( + analyseCycleEvents, + analysePoiEvents, + analyseConditions, + zIndex, + loopback // + ); + if (!result) + { + return result; + } + + // + // Verification ... + ENUM_XPOI_EVENTS verificationPoiEvents[]; + ENUM_X_CYCLE_EVENTS verificationCycleEvents[]; + X121SMCCycleConditions verificationConditions; + result = verificationCycleHelper.GetConditions( + verificationCycleEvents, + verificationPoiEvents, + verificationConditions, + zIndex, + loopback // + ); + if (!result) + { + return result; + } + + // + // Consolidation ... + ENUM_XPOI_EVENTS consolidationPoiEvents[]; + ENUM_X_CYCLE_EVENTS consolidationCycleEvents[]; + X121SMCCycleConditions consolidationConditions; + result = consolidationCycleHelper.GetConditions( + consolidationCycleEvents, + consolidationPoiEvents, + consolidationConditions, + zIndex, + loopback // + ); + if (!result) + { + return result; + } + + // + // Vision ... + ENUM_XPOI_EVENTS visionPoiEvents[]; + ENUM_X_CYCLE_EVENTS visionCycleEvents[]; + X121SMCCycleConditions visionConditions; + result = visionCycleHelper.GetConditions( + visionCycleEvents, + visionPoiEvents, + visionConditions, + zIndex, + loopback // + ); + if (!result) + { + return result; + } + + // + // Cycles POI States ... + XPOIState triggerState = triggerConditions.state; + XPOIState decisionState = decisionConditions.state; + XPOIState analyseState = analyseConditions.state; + XPOIState verificationState = verificationConditions.state; + XPOIState consolidationState = consolidationConditions.state; + XPOIState visionState = visionConditions.state; + + // + // Setup Conditions ... + + // + // Detect Market Trend ... + // ENUM_X_DIRECTION trend; + // bool hasTrend = consolidationCycleHelper + // .DetectTrend(trend); + // bool hasBullishTrend = hasTrend && + // IsBullish(trend); + // bool hasBearishTrend = hasTrend && + // IsBearish(trend); + // result = hasBullishTrend || + // hasBearishTrend; + // if (!result) + // { + // return result; + // } + + // + // Detect VWAP Bearish ... + + // + double vwapFast = triggerConditions.x121Conditions.vwapFastBuffer[1]; + double vwapMid = triggerConditions.x121Conditions.vwapMidBuffer[1]; + double vwapSlow = triggerConditions.x121Conditions.vwapSlowBuffer[1]; + + // + double vwaps[3] = { + vwapFast, + vwapMid, + vwapSlow, + }; + double vwapMax = GetMax(vwaps); + double vwapMin = GetMin(vwaps); + + // + bool isCloseOverVwapMax = + // + ask > vwapMax && + bid > vwapMax && + (cBar.low > vwapMax || + cBar.close > vwapMax) + // + ; + + // + bool isCloseUnderVwapMin = + // + ask < vwapMin && + bid < vwapMin && + (cBar.high < vwapMin || + cBar.close < vwapMin) + // + ; + + // + bool isVWapBullishState = triggerConditions.x121Conditions.isVWapBullishState; + bool isVWapSwitchedToBullishState = triggerConditions.x121Conditions.isVWapSwitchedToBullishState; + + // + bool isVWapBearishState = triggerConditions.x121Conditions.isVWapBearishState; + bool isVWapSwitchedToBearishState = triggerConditions.x121Conditions.isVWapSwitchedToBearishState; + + // + bool isVWapBullishOrdered = triggerConditions.x121Conditions.isVWapBullishOrdered; + bool isVWapSwitchedToBullishOrdered = triggerConditions.x121Conditions.isVWapSwitchedToBullishOrdered; + + // + bool isVWapBearishOrdered = triggerConditions.x121Conditions.isVWapBearishOrdered; + bool isVWapSwitchedToBearishOrdered = triggerConditions.x121Conditions.isVWapSwitchedToBearishOrdered; + + // + // Summary VWap ... + + // + bool isVwapBullishFormed = + // + isVWapSwitchedToBullishState + // isCloseOverVwapMax + // // + // && + // + // ( + // // + // // (isVWapBullishOrdered && + // // isVWapSwitchedToBullishState) + // // // + // // || + // // // + // // (isVWapBullishState && + // // isVWapSwitchedToBullishOrdered) + // // + // ) + // + ; + + // + bool isVwapBearishFormed = + // + isVWapSwitchedToBearishState + // isCloseUnderVwapMin + // // + // && + // + // ( + // // + // // (isVWapBearishOrdered && + // // isVWapSwitchedToBearishState) + // // // + // // || + // // // + // // (isVWapBearishState && + // // isVWapSwitchedToBearishOrdered) + // // + // ) + // + ; + + // + isBullish = + // hasBullishTrend && + isVwapBullishFormed; + + // + isBearish = + // hasBearishTrend && + isVwapBearishFormed; + + // + result = isBullish || + isBearish; + + // + // if (!result) + // { + // return result; + // } + + // // + // double sar = triggerConditions.x121Conditions.sarBuffer[1]; + + // // + // bool isSarBullish = triggerConditions.x121Conditions.isSarBullish; + // bool isSarSwitchedToBullish = triggerConditions.x121Conditions.isSarSwitchedToBullish; + + // // + // bool isSarBearish = triggerConditions.x121Conditions.isSarBearish; + // bool isSarSwitchedToBearish = triggerConditions.x121Conditions.isSarSwitchedToBearish; + + // // + // bool isSarBullishFormed = isSarBullish || + // isSarSwitchedToBullish; + + // // + // bool isSarBearishFormed = isSarBearish || + // isSarSwitchedToBearish; + + // // + // isBullish = + // isBullish && + // isSarBullishFormed; + + // // + // isBearish = + // isBearish && + // isSarBearishFormed; + + // // + // result = isBullish || + // isBearish; + // if (!result) + // { + // return result; + // } + + // // + // // Detect Pull Backs ... + + // // + // bool isSignalBarBullishPullBackFormed = + // cBar.IsBearish() && + // pBar.IsBullish() && + // cBar.low > pBar.low; + + // // + // bool isSignalBarBearishPullBackFormed = + // cBar.IsBullish() && + // pBar.IsBearish() && + // cBar.high < pBar.high; + + // // + // // Summary Pull Backs ... + + // // + // bool isBullishBarFormed = + // isSignalBarBullishPullBackFormed; + + // // + // bool isBearishhBarFormed = + // isSignalBarBearishPullBackFormed; + + // // + // isBullish = + // isBullish && + // isBullishBarFormed; + + // // + // isBearish = + // isBearish && + // isBearishhBarFormed; + + // // + // result = isBullish || + // isBearish; + // if (!result) + // { + // return result; + // } + + // // + // isBullish = + // // + // false + // // + // ; + + // // + // isBearish = + // // + // false + // // + // ; + + // + result = isBullish || + isBearish; + if (!result) + { + // + // Clean Conditions for Regenerate ... + + // + return result; + } + + // + conditions.setupTime = cTime; + conditions.dir = + isBullish + ? X_DIRECTION_BULLISH + : X_DIRECTION_BEARISH; + + // + return result; +} + +// +// Detect Trigger Conditions ... +bool DetectX121SMCXVWPBSiganlTrigger( + // + X121SMCStrategyXVWPBSignalConditions &conditions, + // + string _symbol, + ENUM_TIMEFRAMES _period, + // + XC121SMCCycleHelper *triggerCycleHelper, + XC121SMCCycleHelper *decisionCycleHelper, + XC121SMCCycleHelper *analyseCycleHelper, + XC121SMCCycleHelper *verificationCycleHelper, + XC121SMCCycleHelper *consolidationCycleHelper, + XC121SMCCycleHelper *visionCycleHelper, + // + int maxAllowedSetupAge = 60 // + // +) +{ + // + bool result = false; + + // + result = conditions.IsSetuped(); + if (!result) + { + return result; + } + + // + datetime setupTime = conditions.setupTime; + ENUM_X_DIRECTION setupDir = conditions.dir; + + // + bool isBullish = false; + bool isBearish = false; + + // + int zIndex = 0; + int cIndex = zIndex + 1; + int pIndex = cIndex + 1; + int ppIndex = pIndex + 1; + + // + int loopback = 10; + + // + string symbol = _symbol; + ENUM_TIMEFRAMES period = _period; + + // + XOHCL zBar; + result = zBar.Init( + symbol, + period, + zIndex // + ); + if (!result) + { + return result; + } + + // + XOHCL cBar; + result = cBar.Init( + symbol, + period, + cIndex // + ); + if (!result) + { + return result; + } + + // + XOHCL pBar; + result = pBar.Init( + symbol, + period, + pIndex // + ); + if (!result) + { + return result; + } + + // + double ask = GetAsk(symbol); + double bid = GetBid(symbol); + datetime cTime = TimeCurrent(); + + // + double ll = cBar.FindLowest(9, MODE_LOW); + double hh = cBar.FindHighest(9, MODE_HIGH); + + // + int zoneValidationDivider = 10; + int validPivotRepetition = triggerCycleHelper.mX121Helper + .GetDonChainLength(); + + // + double selectedSL = 0; + + // + // Cycles Conditions ... + + // + // Trigger ... + ENUM_XPOI_EVENTS triggerPoiEvents[]; + ENUM_X_CYCLE_EVENTS triggerCycleEvents[]; + X121SMCCycleConditions triggerConditions; + result = triggerCycleHelper.GetConditions( + triggerCycleEvents, + triggerPoiEvents, + triggerConditions, + zIndex, + loopback // + ); + if (!result) + { + return result; + } + + // + // Decision ... + ENUM_XPOI_EVENTS decisionPoiEvents[]; + ENUM_X_CYCLE_EVENTS decisionCycleEvents[]; + X121SMCCycleConditions decisionConditions; + result = decisionCycleHelper.GetConditions( + decisionCycleEvents, + decisionPoiEvents, + decisionConditions, + zIndex, + loopback // + ); + if (!result) + { + return result; + } + + // + // Analyse ... + ENUM_XPOI_EVENTS analysePoiEvents[]; + ENUM_X_CYCLE_EVENTS analyseCycleEvents[]; + X121SMCCycleConditions analyseConditions; + result = analyseCycleHelper.GetConditions( + analyseCycleEvents, + analysePoiEvents, + analyseConditions, + zIndex, + loopback // + ); + if (!result) + { + return result; + } + + // + // Verification ... + ENUM_XPOI_EVENTS verificationPoiEvents[]; + ENUM_X_CYCLE_EVENTS verificationCycleEvents[]; + X121SMCCycleConditions verificationConditions; + result = verificationCycleHelper.GetConditions( + verificationCycleEvents, + verificationPoiEvents, + verificationConditions, + zIndex, + loopback // + ); + if (!result) + { + return result; + } + + // + // Consolidation ... + ENUM_XPOI_EVENTS consolidationPoiEvents[]; + ENUM_X_CYCLE_EVENTS consolidationCycleEvents[]; + X121SMCCycleConditions consolidationConditions; + result = consolidationCycleHelper.GetConditions( + consolidationCycleEvents, + consolidationPoiEvents, + consolidationConditions, + zIndex, + loopback // + ); + if (!result) + { + return result; + } + + // + // Vision ... + ENUM_XPOI_EVENTS visionPoiEvents[]; + ENUM_X_CYCLE_EVENTS visionCycleEvents[]; + X121SMCCycleConditions visionConditions; + result = visionCycleHelper.GetConditions( + visionCycleEvents, + visionPoiEvents, + visionConditions, + zIndex, + loopback // + ); + if (!result) + { + return result; + } + + // + // Cycles POI States ... + XPOIState triggerState = triggerConditions.state; + XPOIState decisionState = decisionConditions.state; + XPOIState analyseState = analyseConditions.state; + XPOIState verificationState = verificationConditions.state; + XPOIState consolidationState = consolidationConditions.state; + XPOIState visionState = visionConditions.state; + + // + // Trigger Conditions ... + + // + double triggerPeak = triggerConditions.x121Conditions.peaksBuffer[1]; + double decisionPeak = decisionConditions.x121Conditions.peaksBuffer[1]; + double analysePeak = analyseConditions.x121Conditions.peaksBuffer[1]; + double verificationPeak = verificationConditions.x121Conditions.peaksBuffer[1]; + double consolidationPeak = consolidationConditions.x121Conditions.peaksBuffer[1]; + + // + double triggerVale = triggerConditions.x121Conditions.valesBuffer[1]; + double decisionVale = decisionConditions.x121Conditions.valesBuffer[1]; + double analyseVale = analyseConditions.x121Conditions.valesBuffer[1]; + double verificationVale = verificationConditions.x121Conditions.valesBuffer[1]; + double consolidationVale = consolidationConditions.x121Conditions.valesBuffer[1]; + + // + bool isPeaksSame = + // + triggerPeak == decisionPeak && + triggerPeak == analysePeak && + triggerPeak == verificationPeak && + triggerPeak == consolidationPeak + // + ; + + // + bool isValesSame = + // + triggerVale == decisionVale && + triggerVale == analyseVale && + triggerVale == verificationVale && + triggerVale == consolidationVale + // + ; + + // + isBullish = + isValesSame && + IsBullish(setupDir); + + // + isBearish = + isPeaksSame && + IsBearish(setupDir); + + // + result = isBullish || + isBearish; + if (!result) + { + return result; + } + + // + conditions.Clean(); + + // + isBullish = + // + false + // + ; + + // + isBearish = + // + false + // + ; + + // + result = isBullish || + isBearish; + if (!result) + { + // + // Cleanup Setup Conditions ... + + // + return result; + } + + // + conditions.triggerTime = cTime; + conditions.sl = isBullish + ? 0 + : 0; + conditions.type = isBullish + ? X_POSITION_TYPE_LONG + : X_POSITION_TYPE_SHORT; + // + return result; +} + +// diff --git a/X121SMCEA/Strategy/x-121.smc.strategy.class.mq5 b/X121SMCEA/Strategy/x-121.smc.strategy.class.mq5 index 2a3e5086..d9b48fa5 100644 --- a/X121SMCEA/Strategy/x-121.smc.strategy.class.mq5 +++ b/X121SMCEA/Strategy/x-121.smc.strategy.class.mq5 @@ -30,6 +30,7 @@ #include "../Signals/x-121.smc.test.signal.lib.mq5" #include "../Signals/x-121.smc.xpvdp.signal.lib.mq5" #include "../Signals/x-121.smc.xpvob.signal.lib.mq5" +#include "../Signals/x-121.smc.xvwpb.signal.lib.mq5" #include "../Signals/x-121.smc.xpvsupdem.signal.lib.mq5" // @@ -156,15 +157,23 @@ class XCX121SMCStrategy : public XCX121SMCBaseStrategy // Detect Signal Conditions ... bool hasSignal = false; + // + bool useTestSignal = false; + bool useXPVOBSignal = false; + bool useXPVDPSignal = false; + bool useXVWPBSignal = true; + bool useXPVSUPDEMSignal = false; + // bool hasTestSignal = false; bool hasXPVOBSignal = false; bool hasXPVDPSignal = false; + bool hasXVWPBSignal = false; bool hasXPVSUPDEMSignal = false; // // Test Signal ... - if (!hasSignal) + if (useTestSignal && !hasSignal) { // hasTestSignal = DetectTestSignal(conditions); @@ -173,7 +182,7 @@ class XCX121SMCStrategy : public XCX121SMCBaseStrategy // // XPVOB Signal ... - if (!hasSignal) + if (useXPVOBSignal && !hasSignal) { // hasXPVOBSignal = DetectXPVOBSignal(conditions); @@ -182,16 +191,25 @@ class XCX121SMCStrategy : public XCX121SMCBaseStrategy // // XPVDP Signal ... - if (!hasSignal) + if (useXPVDPSignal && !hasSignal) { // hasXPVDPSignal = DetectXPVDPSignal(conditions); hasSignal = hasXPVDPSignal; } + // + // XVWPB Signal ... + if (useXVWPBSignal && !hasSignal) + { + // + hasXVWPBSignal = DetectXVWPBSignal(conditions); + hasSignal = hasXVWPBSignal; + } + // // XPVSUPDEM Signal ... - if (!hasSignal) + if (useXPVSUPDEMSignal && !hasSignal) { // hasXPVSUPDEMSignal = DetectXPVSUPDEMSignal(conditions); @@ -953,6 +971,119 @@ class XCX121SMCStrategy : public XCX121SMCBaseStrategy return result; } + // + // XVWPB Signal ... + X121SMCStrategyXVWPBSignalConditions mXVWPBConditions; + bool DetectXVWPBSignal( + X121SMCStrategyConditions &conditions // + ) + { + // + bool result = false; + + // + bool isBullish = false; + bool isBearish = false; + + // + string symbol = GetSymbol(); + ENUM_TIMEFRAMES period = GetPeriod(); + + // + datetime cTime = TimeCurrent(); + + // + ENUM_X_121_SMC_PROVIDERS provider = X_121_SMC_PROVIDER_XVWPB; + string providerStr = ToString(provider); + + // + // Detect Setup Conditions ... + datetime setupTime = mXVWPBConditions.setupTime; + bool isSetuped = mXVWPBConditions.IsSetuped(); + ENUM_X_DIRECTION setupDir = mXVWPBConditions.dir; + if (!isSetuped) + { + // + // Detect Signal Setup ... + isSetuped = DetectX121SMCXVWPBSiganlSetup( + symbol, + period, + mXVWPBConditions, + mTriggerCycleHelper, + mDecisionCycleHelper, + mAnalyseCycleHelper, + mVerificationCycleHelper, + mConsolidationCycleHelper, + mVisionCycleHelper // + ); + + // + setupDir = mXVWPBConditions.dir; + setupTime = mXVWPBConditions.setupTime; + } + result = isSetuped; + if (!result) + { + return result; + } + + // + // Detect Trigger Conditions ... + bool canTrigger = mXVWPBConditions.CanTrigger(); + datetime triggerTime = mXVWPBConditions.triggerTime; + if (!canTrigger) + { + // + // Detect Signal Trigger ... + canTrigger = DetectX121SMCXVWPBSiganlTrigger( + mXVWPBConditions, + symbol, + period, + mTriggerCycleHelper, + mDecisionCycleHelper, + mAnalyseCycleHelper, + mVerificationCycleHelper, + mConsolidationCycleHelper, + mVisionCycleHelper // + ); + + // + result = canTrigger; + if (!result) + { + return result; + } + + // + triggerTime = mXVWPBConditions.triggerTime; + } + + // + // Check Signal Direction ... + + // + isBullish = IsBullish(setupDir); + isBearish = IsBearish(setupDir); + result = isBullish || + isBearish; + if (!result) + { + return result; + } + + // + // Issues Signal on Conditions ... + conditions.signalDir = setupDir; + conditions.provider = providerStr; + conditions.sl = mXVWPBConditions.sl; + + // + mXVWPBConditions.Clean(); + + // + return result; + } + // // XPVSUPDEM Signal ... X121SMCStrategyXPVSUPDEMSignalConditions mXPVSUPDEMConditions;