diff --git a/Libraries/x-saherelm.x-poi.extensions.lib.mq5 b/Libraries/x-saherelm.x-poi.extensions.lib.mq5 index 3fb842bd..8fe8d297 100644 --- a/Libraries/x-saherelm.x-poi.extensions.lib.mq5 +++ b/Libraries/x-saherelm.x-poi.extensions.lib.mq5 @@ -1908,7 +1908,7 @@ void SortZones( if (!hasLast) { // - idx = GetYoungest(source); + idx = GetOldest(source); hasLast = IsValidIndex(idx); if (hasLast) { @@ -1923,7 +1923,7 @@ void SortZones( // Add( last, - source // + tmpItems // ); } @@ -1946,7 +1946,7 @@ void SortZones( // T *item = NULL; - idx = GetYoungest(source); + idx = GetOldest(source); has = IsValidIndex(idx); if (!has) { @@ -3548,7 +3548,7 @@ void Sort( if (!hasLast) { // - idx = GetYoungest(source); + idx = GetOldest(source); hasLast = IsValidIndex(idx); if (hasLast) { @@ -3563,7 +3563,7 @@ void Sort( // AddRef( last, - source // + tmpItems // ); } @@ -3580,13 +3580,13 @@ void Sort( if (!hasLast) { // - ZeroMemory(last); + last.Clean(); break; } // XOBFVG item; - idx = GetYoungest(source); + idx = GetOldest(source); has = IsValidIndex(idx); if (!has) { diff --git a/Libraries/x-saherelm.x-poi.lib.mq5 b/Libraries/x-saherelm.x-poi.lib.mq5 index a8b4e3e4..bda99aab 100644 --- a/Libraries/x-saherelm.x-poi.lib.mq5 +++ b/Libraries/x-saherelm.x-poi.lib.mq5 @@ -6639,6 +6639,196 @@ struct XOBFVG return result; } + // + void UpdateZones( + XPOIState &state // + ) + { + // + Clean(supplyZones); + Clean(demandZones); + Clean(supportZones); + Clean(resistanceZones); + + // + bool isValid = + IsValid() && + state.HasChild(); + if (!isValid) + { + return; + } + + // + int count = 0; + bool has = false; + bool isPassed = false; + + // + // Supply Zones ... + has = state.HasSupplyZones(); + if (has) + { + // + count = state.CountSupplyZones(); + for (int i = 0; i < count; i++) + { + // + XCSupplyZone *iZone = state.supplyZones[i]; + + // + isPassed = iZone.From() > ob.From(); + if (!isPassed) + { + // + ZeroMemory(iZone); + continue; + } + + // + isPassed = IsInsideDiff( + iZone, + ob // + ); + if (!isPassed) + { + // + ZeroMemory(iZone); + continue; + } + + // + Add( + iZone, + supplyZones // + ); + } + } + + // + // Demand Zones ... + has = state.HasDemandZones(); + if (has) + { + // + count = state.CountDemandZones(); + for (int i = 0; i < count; i++) + { + // + XCDemandZone *iZone = state.demandZones[i]; + + // + isPassed = iZone.From() > ob.From(); + if (!isPassed) + { + // + ZeroMemory(iZone); + continue; + } + + // + isPassed = IsInsideDiff( + iZone, + ob // + ); + if (!isPassed) + { + // + ZeroMemory(iZone); + continue; + } + + // + Add( + iZone, + demandZones // + ); + } + } + + // + // Support Zones ... + has = state.HasSupportZones(); + if (has) + { + // + count = state.CountSupportZones(); + for (int i = 0; i < count; i++) + { + // + XCSupportZone *iZone = state.supportZones[i]; + + // + isPassed = iZone.From() > ob.From(); + if (!isPassed) + { + // + ZeroMemory(iZone); + continue; + } + + // + isPassed = IsInsideDiff( + iZone, + ob // + ); + if (!isPassed) + { + // + ZeroMemory(iZone); + continue; + } + + // + Add( + iZone, + supportZones // + ); + } + } + + // + // Resistance Zones ... + has = state.HasResistanceZones(); + if (has) + { + // + count = state.CountResistanceZones(); + for (int i = 0; i < count; i++) + { + // + XCResistanceZone *iZone = state.resistanceZones[i]; + + // + isPassed = iZone.From() > ob.From(); + if (!isPassed) + { + // + ZeroMemory(iZone); + continue; + } + + // + isPassed = IsInsideDiff( + iZone, + ob // + ); + if (!isPassed) + { + // + ZeroMemory(iZone); + continue; + } + + // + Add( + iZone, + resistanceZones // + ); + } + } + } + // void UpdateTo(datetime value = NULL) { diff --git a/X121SMCEA/Signals/x-121.smc.xwz.signal.class.mq5 b/X121SMCEA/Signals/x-121.smc.xwz.signal.class.mq5 index 75885f10..44903236 100644 --- a/X121SMCEA/Signals/x-121.smc.xwz.signal.class.mq5 +++ b/X121SMCEA/Signals/x-121.smc.xwz.signal.class.mq5 @@ -169,8 +169,16 @@ class XCX121SMCXWZSignalDetector : public XCBase ); if (!result) { + // + Clean(decisionPoiEvents); + Clean(decisionCycleEvents); + + // + decisionConditions.Clean(); + // mConditions.Clean(); + consolidationZBar.Clean(); // return result; @@ -190,8 +198,21 @@ class XCX121SMCXWZSignalDetector : public XCBase ); if (!result) { + // + Clean(analysePoiEvents); + Clean(decisionPoiEvents); + + // + Clean(analyseCycleEvents); + Clean(decisionCycleEvents); + + // + analyseConditions.Clean(); + decisionConditions.Clean(); + // mConditions.Clean(); + consolidationZBar.Clean(); // return result; @@ -211,8 +232,24 @@ class XCX121SMCXWZSignalDetector : public XCBase ); if (!result) { + // + Clean(analysePoiEvents); + Clean(decisionPoiEvents); + Clean(consolidationPoiEvents); + + // + Clean(analyseCycleEvents); + Clean(decisionCycleEvents); + Clean(consolidationCycleEvents); + + // + analyseConditions.Clean(); + decisionConditions.Clean(); + consolidationConditions.Clean(); + // mConditions.Clean(); + consolidationZBar.Clean(); // return result; @@ -232,8 +269,27 @@ class XCX121SMCXWZSignalDetector : public XCBase ); if (!result) { + // + Clean(visionPoiEvents); + Clean(analysePoiEvents); + Clean(decisionPoiEvents); + Clean(consolidationPoiEvents); + + // + Clean(visionCycleEvents); + Clean(analyseCycleEvents); + Clean(decisionCycleEvents); + Clean(consolidationCycleEvents); + + // + visionConditions.Clean(); + analyseConditions.Clean(); + decisionConditions.Clean(); + consolidationConditions.Clean(); + // mConditions.Clean(); + consolidationZBar.Clean(); // return result; @@ -257,6 +313,195 @@ class XCX121SMCXWZSignalDetector : public XCBase // Setup Conditions ... // + // Choch Trading Senario ... + bool hasChochBullishConditions = false; + bool hasChochBearishConditions = false; + + // + // Order Flow Side Trading Senario ... + bool hasOrderFlowhBullishConditions = false; + bool hasOrderFlowhBearishConditions = false; + + // + // Trend Line Trading Senario ... + bool hasTrendLineBullishConditions = false; + bool hasTrendLineBearishConditions = false; + + // + // Quarter Line Trading Senario ... + bool hasBQuarterLineBullishConditions = false; + bool hasBQuarterLineBearishConditions = false; + + // + // Supply and Demand Trading Senario ... + bool hasSupDemBullishConditions = false; + bool hasSupDemBearishConditions = false; + + // + // Support and Resistance Trading Senario ... + bool hasSupResBullishConditions = false; + bool hasSupResBearishConditions = false; + + // + // Detect Working Zone ... + bool hasWorkingZone = workingZone.IsValid(); + if (!hasWorkingZone) + { + hasWorkingZone = DetectWorkingZone(visionState); + } + result = hasWorkingZone; + if (!result) + { + // + Clean(visionPoiEvents); + Clean(analysePoiEvents); + Clean(decisionPoiEvents); + Clean(consolidationPoiEvents); + + // + Clean(visionCycleEvents); + Clean(analyseCycleEvents); + Clean(decisionCycleEvents); + Clean(consolidationCycleEvents); + + // + visionState.Clean(); + analyseState.Clean(); + decisionState.Clean(); + consolidationState.Clean(); + + // + visionConditions.Clean(); + analyseConditions.Clean(); + decisionConditions.Clean(); + consolidationConditions.Clean(); + + // + visionXConditions.Clean(); + analyseXConditions.Clean(); + decisionXConditions.Clean(); + consolidationXConditions.Clean(); + + // + mConditions.Clean(); + consolidationZBar.Clean(); + + // + return result; + } + + // + // TODO: Remove this ... + UpdateTo(cTime); + DrawWorkingZone( + visionCycleHelper.mPOIDrawer // + ); + + // + // Detect Working Zone Destroy ... + bool isWorkingZoneDetroyed = workingZone.IsDestroyed(); + result = !isWorkingZoneDetroyed; + if (!result) + { + // + workingZone.Clean(); + mWorkingZoneObjects.Clear(); + + // + Clean(visionPoiEvents); + Clean(analysePoiEvents); + Clean(decisionPoiEvents); + Clean(consolidationPoiEvents); + + // + Clean(visionCycleEvents); + Clean(analyseCycleEvents); + Clean(decisionCycleEvents); + Clean(consolidationCycleEvents); + + // + visionState.Clean(); + analyseState.Clean(); + decisionState.Clean(); + consolidationState.Clean(); + + // + visionConditions.Clean(); + analyseConditions.Clean(); + decisionConditions.Clean(); + consolidationConditions.Clean(); + + // + visionXConditions.Clean(); + analyseXConditions.Clean(); + decisionXConditions.Clean(); + consolidationXConditions.Clean(); + + // + mConditions.Clean(); + consolidationZBar.Clean(); + + // + return result; + } + + // + // Checking Target Zone Breaked ... + bool hasTargetZone = targetZone.IsValid(); + if (hasTargetZone) + { + // + XOHCL bar; + bool isInited = bar.Init( + symbol, + period, + zIndex // + ); + + XOHCL cBar; + isInited = + isInited && + bar.GetPreviousBar(cBar); + + // + bool isBullish = targetZone.IsBullish(); + + // + bool isLowerBreaked = + // + bar.high < targetZone.ob.Lower() && + cBar.high < targetZone.ob.Lower() + // + ; + + // + bool isUpperBreaked = + // + bar.low > targetZone.ob.Upper() && + cBar.low > targetZone.ob.Upper() + // + ; + + // + bool isBreaked = isBullish + ? isLowerBreaked + : isUpperBreaked; + if (isBreaked) + { + // + mWorkingZoneObjects.Clear(); + targetZone.Clean(); + + // + // TODO: Remove this ... + DrawWorkingZone( + visionCycleHelper.mPOIDrawer // + ); + } + } + + // + // Detect Order Flow ... ENUM_X_DIRECTION trend = X_DIRECTION_NONE; bool hasOrderFlow = workingZone.HasOrderFlow(trend); if (!hasOrderFlow) @@ -273,18 +518,55 @@ class XCX121SMCXWZSignalDetector : public XCBase ); hasOrderFlow = IsValidSize(orderFlowCount); } - - // result = hasOrderFlow; if (!result) { + // - // TODO: Implement Clean ... + Clean(visionPoiEvents); + Clean(analysePoiEvents); + Clean(decisionPoiEvents); + Clean(consolidationPoiEvents); + + // + Clean(visionCycleEvents); + Clean(analyseCycleEvents); + Clean(decisionCycleEvents); + Clean(consolidationCycleEvents); + + // + visionState.Clean(); + analyseState.Clean(); + decisionState.Clean(); + consolidationState.Clean(); + + // + visionConditions.Clean(); + analyseConditions.Clean(); + decisionConditions.Clean(); + consolidationConditions.Clean(); + + // + visionXConditions.Clean(); + analyseXConditions.Clean(); + decisionXConditions.Clean(); + consolidationXConditions.Clean(); + + // + mConditions.Clean(); + consolidationZBar.Clean(); // return result; } + // + // TODO: Remove this ... + UpdateTo(cTime); + DrawWorkingZone( + visionCycleHelper.mPOIDrawer // + ); + // isBullish = IsBullish(trend); isBearish = IsBearish(trend); @@ -305,24 +587,6 @@ class XCX121SMCXWZSignalDetector : public XCBase amountPercent // ); - // - // Has Order Flow ... - UpdateTo(cTime); - - // - // TODO: Remove this ... - - // - DrawWorkingZone( - visionCycleHelper.mPOIDrawer // - ); - - // - DrawConditions( - mConditions, - visionCycleHelper.mPOIDrawer // - ); - // // Checking Order Flow Break ... int breakedIDX = -1; @@ -364,7 +628,38 @@ class XCX121SMCXWZSignalDetector : public XCBase if (!result) { // - // TODO: Implement Clean ... + Clean(visionPoiEvents); + Clean(analysePoiEvents); + Clean(decisionPoiEvents); + Clean(consolidationPoiEvents); + + // + Clean(visionCycleEvents); + Clean(analyseCycleEvents); + Clean(decisionCycleEvents); + Clean(consolidationCycleEvents); + + // + visionState.Clean(); + analyseState.Clean(); + decisionState.Clean(); + consolidationState.Clean(); + + // + visionConditions.Clean(); + analyseConditions.Clean(); + decisionConditions.Clean(); + consolidationConditions.Clean(); + + // + visionXConditions.Clean(); + analyseXConditions.Clean(); + decisionXConditions.Clean(); + consolidationXConditions.Clean(); + + // + mConditions.Clean(); + consolidationZBar.Clean(); // return result; @@ -438,6 +733,9 @@ class XCX121SMCXWZSignalDetector : public XCBase { // // TODO: Implement Order Flow Side Trading Senario ... + youngestOrderFlow + .UpdateZones(decisionState); + } // @@ -809,13 +1107,31 @@ class XCX121SMCXWZSignalDetector : public XCBase // TODO: Implement Support and Resistance Trading Senario ... // - // TODO: these are Trends ... - isBullish = false; - isBearish = false; + // Summarize ... // - bool hasBullishConditions = false; - bool hasBearishConditions = false; + bool hasBullishConditions = + // + hasChochBullishConditions || + hasSupDemBullishConditions || + hasSupResBullishConditions || + hasTrendLineBullishConditions || + hasOrderFlowhBullishConditions || + hasBQuarterLineBullishConditions + // + ; + + // + bool hasBearishConditions = + // + hasChochBearishConditions || + hasSupDemBearishConditions || + hasSupResBearishConditions || + hasTrendLineBearishConditions || + hasOrderFlowhBearishConditions || + hasBQuarterLineBearishConditions + // + ; // result = @@ -823,52 +1139,56 @@ class XCX121SMCXWZSignalDetector : public XCBase hasBearishConditions; // - // TODO: Implement All Cleanups ... + if (result) + { + // + mConditions.dir = trend; + mConditions.pivot = pivot; + mConditions.point = point; + mConditions.reward = reward; + mConditions.target = target; + mConditions.setupTime = cTime; + mConditions.priority = priority; + mConditions.amountPercent = amountPercent; + } // - return result; - - // - // Summarise Conditions ... - // - - // - mConditions.dir = trend; - mConditions.pivot = pivot; - mConditions.point = point; - mConditions.reward = reward; - mConditions.target = target; - mConditions.setupTime = cTime; - mConditions.priority = priority; - mConditions.amountPercent = amountPercent; - - // - mConditions.UpdateTo(cTime); + // Cleanups ... // Clean(visionPoiEvents); Clean(analysePoiEvents); Clean(decisionPoiEvents); + Clean(consolidationPoiEvents); + + // Clean(visionCycleEvents); Clean(analyseCycleEvents); Clean(decisionCycleEvents); - Clean(consolidationPoiEvents); Clean(consolidationCycleEvents); // visionState.Clean(); analyseState.Clean(); decisionState.Clean(); + consolidationState.Clean(); + + // visionConditions.Clean(); analyseConditions.Clean(); - visionXConditions.Clean(); - consolidationState.Clean(); decisionConditions.Clean(); + consolidationConditions.Clean(); + + // + visionXConditions.Clean(); analyseXConditions.Clean(); decisionXConditions.Clean(); - consolidationConditions.Clean(); consolidationXConditions.Clean(); + // + mConditions.Clean(); + consolidationZBar.Clean(); + // return result; } @@ -1891,6 +2211,89 @@ class XCX121SMCXWZSignalDetector : public XCBase return result; } + // + bool DetectWorkingZone( + XPOIState <fState // + ) + { + // + bool result = false; + + // + result = IsValid(symbol) && + IsValid(period); + if (!result) + { + return result; + } + + // + result = !workingZone.IsValid(); + if (!result) + { + return result; + } + + // + workingZone.symbol = symbol; + workingZone.period = period; + + // + int idx = -1; + bool has = false; + + // + has = ltfState.HasSupplyZones(); + if (has) + { + // + idx = GetHighest(ltfState.supplyZones); + if (IsValidIndex(idx)) + { + workingZone.supplyZone = ltfState.supplyZones[idx]; + } + } + + // + has = ltfState.HasDemandZones(); + if (has) + { + // + idx = GetLowest(ltfState.demandZones); + if (IsValidIndex(idx)) + { + workingZone.demandZone = ltfState.demandZones[idx]; + } + } + + // + bool hasWorkingZone = workingZone.HasSupplyZone() && + workingZone.HasDemandZone(); + if (hasWorkingZone) + { + // + double upper = workingZone.supplyZone.Lower(); + double lower = workingZone.demandZone.Upper(); + + // + double delta = ((upper - lower) / 100) * 25; + + // + workingZone.quarter1 = upper - (1 * delta); + workingZone.quarter2 = upper - (2 * delta); + workingZone.quarter3 = upper - (3 * delta); + + // + hasWorkingZone = workingZone.IsValid(); + } + + // + result = hasWorkingZone; + + // + return result; + } + // // Draw Functions ... // diff --git a/X121SMCEA/Signals/x-121.smc.xwz.signal.lib.mq5 b/X121SMCEA/Signals/x-121.smc.xwz.signal.lib.mq5 index 1a35449d..5d408c3a 100644 --- a/X121SMCEA/Signals/x-121.smc.xwz.signal.lib.mq5 +++ b/X121SMCEA/Signals/x-121.smc.xwz.signal.lib.mq5 @@ -725,6 +725,89 @@ struct X121SMCStrategyXWZWorkingZone ); } + // + bool IsDestroyed( + int barIndex = 0, + ENUM_TIMEFRAMES forPeriod = NULL // + ) + { + // + bool result = false; + + // + if (barIndex < 0) + { + barIndex = 0; + } + + // + if (!IsValid(forPeriod)) + { + forPeriod = period; + } + + // + result = IsValid(); + if (!result) + { + return result; + } + + // + XOHCL bar; + result = bar.Init( + symbol, + period, + barIndex // + ); + if (!result) + { + // + bar.Clean(); + return result; + } + + // + XOHCL cBar; + result = bar.GetPreviousBar(cBar); + if (!result) + { + // + bar.Clean(); + cBar.Clean(); + + // + return result; + } + + // + bool isSupplyZoneBreaked = + // + bar.low > supplyZone.Upper() && + cBar.low > supplyZone.Upper() + // + ; + + // + bool isDemandZoneBreaked = + // + bar.high < demandZone.Lower() && + cBar.high < demandZone.Lower() + // + ; + + // + bar.Clean(); + cBar.Clean(); + + // + result = isSupplyZoneBreaked || + isDemandZoneBreaked; + + // + return result; + } + // bool IsOrderFlowBreaked( int &breakedIndex,