From 59770cbe991799f27c8b0fc44c9669f4a86c63e2 Mon Sep 17 00:00:00 2001 From: Hadi Khazaee Asl Date: Sat, 8 Feb 2025 18:53:32 +0330 Subject: [PATCH] last ... --- .../x-121.smc.xsupdemobs.signal.lib.mq5 | 1849 ++++++++++++++++- .../Strategy/x-121.smc.strategy.class.mq5 | 4 +- 2 files changed, 1790 insertions(+), 63 deletions(-) diff --git a/X121SMCEA/Signals/x-121.smc.xsupdemobs.signal.lib.mq5 b/X121SMCEA/Signals/x-121.smc.xsupdemobs.signal.lib.mq5 index c7d9d16b..8b3d3d75 100644 --- a/X121SMCEA/Signals/x-121.smc.xsupdemobs.signal.lib.mq5 +++ b/X121SMCEA/Signals/x-121.smc.xsupdemobs.signal.lib.mq5 @@ -35,6 +35,607 @@ enum ENUM_X121SMC_XSUPDEMOBS_PRIORITY X121SMC_XSUPDEMOBS_PRIORITY_HIGH, }; +// +struct XOBFVG +{ + // + string symbol; + ENUM_TIMEFRAMES period; + + // + datetime time; + + // + XCOrderBlock *ob; + XCFVG *fvg; + + // + XCFVG *unActivatedFVGs[]; + XCOrderBlock *unActivatedOBs[]; + + // + XCOrderBlock *insideOB; + XCFVG *insideFVG; + + // + XOBFVG() + { + Clean(); + } + + // + void Clean() + { + // + ob = NULL; + fvg = NULL; + time = NULL; + symbol = NULL; + period = NULL; + + // + Clean(unActivatedOBs); + Clean(unActivatedFVGs); + + // + ZeroMemory(this); + } + + // + bool IsValid() + { + // + bool result = false; + + // + result = + // + ob != NULL && + ob.IsValid() && + fvg != NULL && + fvg.IsValid() && + ob.From() < fvg.From() && + IsValid(time) && + IsValid(symbol) && + IsValid(period) + // + ; + if (!result) + { + return result; + } + + // + ENUM_X_DIRECTION mDir = GetDirection(); + + // + // Validate Order Block ... + + // + // Validate Started Zones ... + XOHCL obStartedBar; + ENUM_X_DIRECTION obStartedDir; + bool isStarted = ob.IsStarted( + mDir, + obStartedBar, + obStartedDir // + ); + result = isStarted; + if (!result) + { + return result; + } + + // + // Validate InActive Zone ... + XOHCL obActivatedBar; + ENUM_X_DIRECTION obActivatedDir; + bool isActivated = ob.IsActivated( + mDir, + obActivatedBar, + obActivatedDir // + ); + result = !isActivated; + if (!result) + { + return result; + } + + // + // Validate Zone Iverse Breake ... + XOHCL obBreakedBar; + ENUM_X_DIRECTION obBreakedDir; + bool isBreaked = ob.IsBreaked( + Opposit(mDir), + obBreakedBar, + obBreakedDir, + true // Ignore Activation ... + ); + result = !isBreaked; + if (!result) + { + return result; + } + + // + // Checking Dirction(s) ... + result = + HasDirection(mDir) && + mDir == fvg.GetDirection(); + if (!result) + { + return result; + } + + // + // Validate FVG From Date ... + + // + // Checking FVG Place ... + + // + bool isBullish = IsBullish(mDir); + + // + bool isAbove = IsAboveDiff( + fvg, + ob, + true // Ignore Inside ... + ); + + // + bool isBelow = IsBelowDiff( + fvg, + ob, + true // Ignore Inside ... + ); + + // + result = + isBullish + ? isAbove + : isBelow; + + // + // Check FVG Must Be Started ... + XOHCL fvgStartedBar; + ENUM_X_DIRECTION fvgStartedDir; + isStarted = fvg.IsStarted( + mDir, + fvgStartedBar, + fvgStartedDir // + ); + result = isStarted; + if (!result) + { + return result; + } + + // + // Check FVg Not Breaked in Reversal Direction ... + XOHCL fvgBreakedBar; + ENUM_X_DIRECTION fvgBreakedDir; + isBreaked = fvg.IsBreaked( + Opposit(mDir), + fvgBreakedBar, + fvgBreakedDir, + true // Ignore Activation ... + ); + result = !isBreaked; + if (!result) + { + return result; + } + + // + return result; + } + + // + ENUM_X_DIRECTION GetDirection() + { + return ob.GetDirection(); + } + + // + int CountUnActivatedOBs() + { + return ArraySize(unActivatedOBs); + } + + // + bool HasUnActivatedOBs() + { + return IsValidSize(CountUnActivatedOBs()); + } + + // + bool AddUnActivatedOB( + XCOrderBlock *_ob, + XOHCL &bar // + ) + { + // + bool result = false; + + // + result = IsValid() && + bar.IsValid() && + _ob != NULL && + _ob.IsValid(); + if (!result) + { + return result; + } + + // + // Check Order Block is not Same as Current OB ... + bool isSame = IsSame( + _ob, + ob // + ); + result = !isSame; + if (!result) + { + return result; + } + + // + ENUM_X_DIRECTION mDir = GetDirection(); + bool isBullish = IsBullish(mDir); + + // + // Check Bars ... + XOHCL pBar; + result = bar.GetPreviousBar(pBar); + if (!result) + { + return result; + } + + // + bool isPricePassed = + isBullish + ? IsAbove( + bar.low, + _ob // + ) && + IsAbove( + pBar.low, + _ob // + ) + : IsBelow( + bar.high, + _ob // + ) && + IsBelow( + pBar.high, + _ob // + ); + result = isPricePassed; + if (!result) + { + return result; + } + + // + // Validate Order Block is Not Activated ... + + // + // Validate Started Zones ... + XOHCL obStartedBar; + ENUM_X_DIRECTION obStartedDir; + bool isStarted = _ob.IsStarted( + mDir, + obStartedBar, + obStartedDir // + ); + result = isStarted; + if (!result) + { + return result; + } + + // + // Validate InActive Zone ... + XOHCL obActivatedBar; + ENUM_X_DIRECTION obActivatedDir; + bool isActivated = _ob.IsActivated( + mDir, + obActivatedBar, + obActivatedDir // + ); + result = !isActivated; + if (!result) + { + return result; + } + + // + // Validate Zone Iverse Breake ... + XOHCL obBreakedBar; + ENUM_X_DIRECTION obBreakedDir; + bool isBreaked = _ob.IsBreaked( + Opposit(mDir), + obBreakedBar, + obBreakedDir, + true // Ignore Activation ... + ); + result = !isBreaked; + if (!result) + { + return result; + } + + // + int idx = FindIndex( + _ob, + unActivatedOBs // + ); + result = !IsValidIndex(idx); + if (!result) + { + return result; + } + + // + bool isLastPassed = true; + bool isAboveLast = false; + bool isBelowLast = false; + XCOrderBlock *lastOB = NULL; + int unActivatedOBsCount = CountUnActivatedOBs(); + bool hasUnActivatedOBs = HasUnActivatedOBs(); + if (hasUnActivatedOBs) + { + lastOB = unActivatedOBs[unActivatedOBsCount - 1]; + } + bool hasLastOB = lastOB != NULL && + lastOB.IsValid(); + if (hasLastOB) + { + // + isAboveLast = IsAbove( + _ob, + lastOB, + true // Ignore Inside ... + ); + + // + isBelowLast = IsBelow( + _ob, + lastOB, + true // Ignore Inside ... + ); + + // + isLastPassed = + isBullish + ? isAboveLast + : isBelowLast; + } + result = isLastPassed; + if (!result) + { + return result; + } + + // + Add( + _ob, + unActivatedOBs // + ); + + // + return result; + } + + // + int CountUnActivatedFVGs() + { + return ArraySize(unActivatedFVGs); + } + + // + bool HasUnActivatedFVGs() + { + return IsValidSize(CountUnActivatedFVGs()); + } + + // + bool AddUnActivatedFVG( + XCFVG *_fvg, + XOHCL &bar // + ) + { + // + bool result = false; + + // + result = IsValid() && + bar.IsValid() && + _fvg != NULL && + _fvg.IsValid(); + if (!result) + { + return result; + } + + // + // Check Order Block is not Same as Current OB ... + bool isSame = IsSame( + _fvg, + fvg // + ); + result = !isSame; + if (!result) + { + return result; + } + + // + ENUM_X_DIRECTION mDir = GetDirection(); + bool isBullish = IsBullish(mDir); + + // + // Check Bars ... + XOHCL pBar; + result = bar.GetPreviousBar(pBar); + if (!result) + { + return result; + } + + // + bool isPricePassed = + isBullish + ? IsAbove( + bar.low, + _fvg // + ) && + IsAbove( + pBar.low, + _fvg // + ) + : IsBelow( + bar.high, + _fvg // + ) && + IsBelow( + pBar.high, + _fvg // + ); + result = isPricePassed; + if (!result) + { + return result; + } + + // + // Validate Order Block is Not Activated ... + + // + // Validate Started Zones ... + XOHCL fvgStartedBar; + ENUM_X_DIRECTION fvgStartedDir; + bool isStarted = _fvg.IsStarted( + mDir, + fvgStartedBar, + fvgStartedDir // + ); + result = isStarted; + if (!result) + { + return result; + } + + // + // Validate InActive Zone ... + XOHCL fvgActivatedBar; + ENUM_X_DIRECTION fvgActivatedDir; + bool isActivated = _fvg.IsActivated( + mDir, + fvgActivatedBar, + fvgActivatedDir // + ); + result = !isActivated; + if (!result) + { + return result; + } + + // + // Validate Zone Iverse Breake ... + XOHCL fvgBreakedBar; + ENUM_X_DIRECTION fvgBreakedDir; + bool isBreaked = _fvg.IsBreaked( + Opposit(mDir), + fvgBreakedBar, + fvgBreakedDir, + true // Ignore Activation ... + ); + result = !isBreaked; + if (!result) + { + return result; + } + + // + int idx = FindIndex( + _fvg, + unActivatedFVGs // + ); + result = !IsValidIndex(idx); + if (!result) + { + return result; + } + + // + XCFVG *lastFVG = NULL; + bool isLastPassed = true; + bool isAboveLast = false; + bool isBelowLast = false; + int unActivatedFVGsCount = CountUnActivatedFVGs(); + bool hasUnActivatedFVGs = HasUnActivatedFVGs(); + if (hasUnActivatedFVGs) + { + lastFVG = unActivatedFVGs[unActivatedFVGsCount - 1]; + } + bool hasLastFVG = lastFVG != NULL && + lastFVG.IsValid(); + if (hasLastFVG) + { + // + isAboveLast = IsAbove( + _fvg, + lastFVG, + true // Ignore Inside ... + ); + + // + isBelowLast = IsBelow( + _fvg, + lastFVG, + true // Ignore Inside ... + ); + + // + isLastPassed = + isBullish + ? isAboveLast + : isBelowLast; + } + result = isLastPassed; + if (!result) + { + return result; + } + + // + Add( + _fvg, + unActivatedFVGs // + ); + + // + return result; + } + + // + bool HasInsideOB() + { + return insideOB != NULL && + insideOB.IsValid(); + } + + // + bool HasInsideFVG() + { + return insideFVG != NULL && + insideFVG.IsValid(); + } +}; + // struct X121SMCXSupDemOBSWorkingZone { @@ -225,7 +826,7 @@ struct X121SMCXSupDemOBSWorkingZone { // trendDir = - nearestUpperTouchedBar.time > nearestLowerTouchedBar.time + nearestUpperTouchedBar.time < nearestLowerTouchedBar.time ? X_DIRECTION_BULLISH : X_DIRECTION_BEARISH; @@ -357,6 +958,9 @@ struct X121SMCStrategyXSupDemOBSSignalConditions XCDemandZone *visionLowestDemandZone; XCDemandZone *consolidationLowestDemandZone; + // + XOBFVG obFVGs[]; + // X121SMCXSupDemOBSWorkingZone workingZone; @@ -482,6 +1086,7 @@ struct X121SMCStrategyXSupDemOBSSignalConditions point = 0; // + Clean(obFVGs); workingZone.Clean(); // @@ -720,6 +1325,18 @@ struct X121SMCStrategyXSupDemOBSSignalConditions return result; } + // + int CountOBFVGs() + { + return ArraySize(obFVGs); + } + + // + bool HasOBFVGs() + { + return IsValidSize(CountOBFVGs()); + } + // // Working Zone is an Area which // we decide to trade inside it ... @@ -957,7 +1574,7 @@ struct X121SMCStrategyXSupDemOBSSignalConditions } // - void UpdateTo(datetime value) + void UpdateTo(datetime value = NULL) { // value = NormalizeTime(value); @@ -986,6 +1603,58 @@ struct X121SMCStrategyXSupDemOBSSignalConditions { consolidationHighestSupplyZone.To(value); } + + // + bool hasOBFVGs = HasOBFVGs(); + int obFVGsCount = CountOBFVGs(); + if (hasOBFVGs) + { + // + for (int i = 0; i < obFVGsCount; i++) + { + // + obFVGs[i].ob.To(value); + obFVGs[i].fvg.To(value); + + // + bool hasUnActivatedOBs = obFVGs[i].HasUnActivatedOBs(); + int unActivatedOBsCount = obFVGs[i].CountUnActivatedOBs(); + if (hasUnActivatedOBs) + { + // + for (int j = 0; j < unActivatedOBsCount; j++) + { + obFVGs[i].unActivatedOBs[j].To(value); + } + } + + // + bool hasUnActivatedFVGs = obFVGs[i].HasUnActivatedFVGs(); + int unActivatedFVGsCount = obFVGs[i].CountUnActivatedFVGs(); + if (hasUnActivatedFVGs) + { + // + for (int j = 0; j < unActivatedFVGsCount; j++) + { + obFVGs[i].unActivatedFVGs[j].To(value); + } + } + + // + bool hasInsideOB = obFVGs[i].HasInsideOB(); + if (hasInsideOB) + { + obFVGs[i].insideOB.To(value); + } + + // + bool hasInsideFVG = obFVGs[i].HasInsideFVG(); + if (hasInsideFVG) + { + obFVGs[i].insideFVG.To(value); + } + } + } } // @@ -1013,9 +1682,7 @@ bool DetectX121SMCXSupDemOBSSignalSetup( XC121SMCCycleHelper *analyseCycleHelper, XC121SMCCycleHelper *verificationCycleHelper, XC121SMCCycleHelper *consolidationCycleHelper, - XC121SMCCycleHelper *visionCycleHelper, - // - int resetAfterUnActedZoneInMinutes = 120 + XC121SMCCycleHelper *visionCycleHelper // ) { @@ -1190,6 +1857,44 @@ bool DetectX121SMCXSupDemOBSSignalSetup( ); if (!result) { + // + Clean(triggerPoiEvents); + Clean(triggerCycleEvents); + Clean(decisionPoiEvents); + Clean(decisionCycleEvents); + Clean(analysePoiEvents); + Clean(analyseCycleEvents); + Clean(verificationPoiEvents); + Clean(verificationCycleEvents); + Clean(consolidationPoiEvents); + Clean(consolidationCycleEvents); + Clean(visionPoiEvents); + Clean(visionCycleEvents); + + // + visionState.Clean(); + triggerState.Clean(); + analyseState.Clean(); + decisionZBar.Clean(); + decisionCBar.Clean(); + decisionPBar.Clean(); + decisionState.Clean(); + visionConditions.Clean(); + visionXConditions.Clean(); + verificationState.Clean(); + triggerConditions.Clean(); + analyseConditions.Clean(); + consolidationState.Clean(); + triggerXConditions.Clean(); + analyseXConditions.Clean(); + decisionConditions.Clean(); + decisionXConditions.Clean(); + verificationConditions.Clean(); + verificationXConditions.Clean(); + consolidationConditions.Clean(); + consolidationXConditions.Clean(); + + // return result; } @@ -1198,6 +1903,44 @@ bool DetectX121SMCXSupDemOBSSignalSetup( .GetPreviousBar(decisionCBar); if (!result) { + // + Clean(triggerPoiEvents); + Clean(triggerCycleEvents); + Clean(decisionPoiEvents); + Clean(decisionCycleEvents); + Clean(analysePoiEvents); + Clean(analyseCycleEvents); + Clean(verificationPoiEvents); + Clean(verificationCycleEvents); + Clean(consolidationPoiEvents); + Clean(consolidationCycleEvents); + Clean(visionPoiEvents); + Clean(visionCycleEvents); + + // + visionState.Clean(); + triggerState.Clean(); + analyseState.Clean(); + decisionZBar.Clean(); + decisionCBar.Clean(); + decisionPBar.Clean(); + decisionState.Clean(); + visionConditions.Clean(); + visionXConditions.Clean(); + verificationState.Clean(); + triggerConditions.Clean(); + analyseConditions.Clean(); + consolidationState.Clean(); + triggerXConditions.Clean(); + analyseXConditions.Clean(); + decisionConditions.Clean(); + decisionXConditions.Clean(); + verificationConditions.Clean(); + verificationXConditions.Clean(); + consolidationConditions.Clean(); + consolidationXConditions.Clean(); + + // return result; } @@ -1206,6 +1949,44 @@ bool DetectX121SMCXSupDemOBSSignalSetup( .GetPreviousBar(decisionPBar); if (!result) { + // + Clean(triggerPoiEvents); + Clean(triggerCycleEvents); + Clean(decisionPoiEvents); + Clean(decisionCycleEvents); + Clean(analysePoiEvents); + Clean(analyseCycleEvents); + Clean(verificationPoiEvents); + Clean(verificationCycleEvents); + Clean(consolidationPoiEvents); + Clean(consolidationCycleEvents); + Clean(visionPoiEvents); + Clean(visionCycleEvents); + + // + visionState.Clean(); + triggerState.Clean(); + analyseState.Clean(); + decisionZBar.Clean(); + decisionCBar.Clean(); + decisionPBar.Clean(); + decisionState.Clean(); + visionConditions.Clean(); + visionXConditions.Clean(); + verificationState.Clean(); + triggerConditions.Clean(); + analyseConditions.Clean(); + consolidationState.Clean(); + triggerXConditions.Clean(); + analyseXConditions.Clean(); + decisionConditions.Clean(); + decisionXConditions.Clean(); + verificationConditions.Clean(); + verificationXConditions.Clean(); + consolidationConditions.Clean(); + consolidationXConditions.Clean(); + + // return result; } @@ -1215,6 +1996,9 @@ bool DetectX121SMCXSupDemOBSSignalSetup( decisionCBarBearishZoneChechValue = decisionCBar .GetZoneCheckValue(X_DIRECTION_BEARISH); + // + conditions.UpdateTo(); + // // 1- Detect Valid Working Area ... @@ -1401,15 +2185,6 @@ bool DetectX121SMCXSupDemOBSSignalSetup( hasWorkingZone = conditions.ExtractWorkingZone(); } - // - conditions.UpdateTo(cTime); - - // - DrawX121SMCXSupDemOBSConditions( - conditions, - visionCycleHelper.mPOIDrawer // - ); - // // Check Working Zone Destroy ... isDestroyed = conditions.IsWorkingZoneDestroyed( @@ -1419,6 +2194,43 @@ bool DetectX121SMCXSupDemOBSSignalSetup( ); if (isDestroyed) { + // + Clean(triggerPoiEvents); + Clean(triggerCycleEvents); + Clean(decisionPoiEvents); + Clean(decisionCycleEvents); + Clean(analysePoiEvents); + Clean(analyseCycleEvents); + Clean(verificationPoiEvents); + Clean(verificationCycleEvents); + Clean(consolidationPoiEvents); + Clean(consolidationCycleEvents); + Clean(visionPoiEvents); + Clean(visionCycleEvents); + + // + visionState.Clean(); + triggerState.Clean(); + analyseState.Clean(); + decisionZBar.Clean(); + decisionCBar.Clean(); + decisionPBar.Clean(); + decisionState.Clean(); + visionConditions.Clean(); + visionXConditions.Clean(); + verificationState.Clean(); + triggerConditions.Clean(); + analyseConditions.Clean(); + consolidationState.Clean(); + triggerXConditions.Clean(); + analyseXConditions.Clean(); + decisionConditions.Clean(); + decisionXConditions.Clean(); + verificationConditions.Clean(); + verificationXConditions.Clean(); + consolidationConditions.Clean(); + consolidationXConditions.Clean(); + // result = false; conditions.Clean(); @@ -1440,6 +2252,47 @@ bool DetectX121SMCXSupDemOBSSignalSetup( result = hasTrend; if (!result) { + // + Clean(triggerPoiEvents); + Clean(triggerCycleEvents); + Clean(decisionPoiEvents); + Clean(decisionCycleEvents); + Clean(analysePoiEvents); + Clean(analyseCycleEvents); + Clean(verificationPoiEvents); + Clean(verificationCycleEvents); + Clean(consolidationPoiEvents); + Clean(consolidationCycleEvents); + Clean(visionPoiEvents); + Clean(visionCycleEvents); + + // + visionState.Clean(); + triggerState.Clean(); + analyseState.Clean(); + decisionZBar.Clean(); + decisionCBar.Clean(); + decisionPBar.Clean(); + decisionState.Clean(); + visionConditions.Clean(); + visionXConditions.Clean(); + verificationState.Clean(); + triggerConditions.Clean(); + analyseConditions.Clean(); + consolidationState.Clean(); + triggerXConditions.Clean(); + analyseXConditions.Clean(); + decisionConditions.Clean(); + decisionXConditions.Clean(); + verificationConditions.Clean(); + verificationXConditions.Clean(); + consolidationConditions.Clean(); + consolidationXConditions.Clean(); + + // + RemoveX121SMCXSupDemOBSDraws(); + + // return result; } @@ -1463,8 +2316,8 @@ bool DetectX121SMCXSupDemOBSSignalSetup( // - if Price Below Quarter 2: NONE; // - ENUM_X121SMC_XSUPDEMOBS_PRIORITY bullishPriority; - ENUM_X121SMC_XSUPDEMOBS_PRIORITY bearishPriority; + ENUM_X121SMC_XSUPDEMOBS_PRIORITY bullishPriority = X121SMC_XSUPDEMOBS_PRIORITY_NONE; + ENUM_X121SMC_XSUPDEMOBS_PRIORITY bearishPriority = X121SMC_XSUPDEMOBS_PRIORITY_NONE; // bool isPriceAboveUpper = @@ -1569,33 +2422,629 @@ bool DetectX121SMCXSupDemOBSSignalSetup( } // - bool lookingForLong = bullishPeriority != X121SMC_XSUPDEMOBS_PRIORITY_NONE; - bool lookingForShort = bearishPeriority != X121SMC_XSUPDEMOBS_PRIORITY_NONE; + bool lookingForLong = bullishPriority != X121SMC_XSUPDEMOBS_PRIORITY_NONE; + bool lookingForShort = bearishPriority != X121SMC_XSUPDEMOBS_PRIORITY_NONE; // result = lookingForLong || lookingForShort; - if (result) + if (!result) { + // + Clean(triggerPoiEvents); + Clean(triggerCycleEvents); + Clean(decisionPoiEvents); + Clean(decisionCycleEvents); + Clean(analysePoiEvents); + Clean(analyseCycleEvents); + Clean(verificationPoiEvents); + Clean(verificationCycleEvents); + Clean(consolidationPoiEvents); + Clean(consolidationCycleEvents); + Clean(visionPoiEvents); + Clean(visionCycleEvents); + + // + visionState.Clean(); + triggerState.Clean(); + analyseState.Clean(); + decisionZBar.Clean(); + decisionCBar.Clean(); + decisionPBar.Clean(); + decisionState.Clean(); + visionConditions.Clean(); + visionXConditions.Clean(); + verificationState.Clean(); + triggerConditions.Clean(); + analyseConditions.Clean(); + consolidationState.Clean(); + triggerXConditions.Clean(); + analyseXConditions.Clean(); + decisionConditions.Clean(); + decisionXConditions.Clean(); + verificationConditions.Clean(); + verificationXConditions.Clean(); + consolidationConditions.Clean(); + consolidationXConditions.Clean(); + + // + RemoveX121SMCXSupDemOBSDraws(); + + // return result; } // - // 4- Detect Order Blocks in Direction of Trend ... + // Detect Order Blocks in Direction of Trend ... + XCOrderBlock *obs[]; + Copy( + consolidationState.bullishOrderBlocks, + obs // + ); + Copy( + consolidationState.bearishOrderBlocks, + obs // + ); // - // In Direction of Trend Order Blocks ... + // Validate OB FVG ... + XCFVG *fvgs[]; + Copy( + analyseState.bullishFairValueGaps, + fvgs // + ); + Copy( + analyseState.bearishFairValueGaps, + fvgs // + ); // - return false; + int obsCount = ArraySize(obs); + bool hasOBs = IsValidSize(obsCount); + + // + int fvgsCount = ArraySize(fvgs); + bool hasFVGs = IsValidSize(fvgsCount); + + // + bool hasOBFVGs = conditions.HasOBFVGs(); + int obFVGsCount = conditions.CountOBFVGs(); + if (hasOBs && + hasFVGs && + !hasOBFVGs) + { + // + for (int i = 0; i < obsCount; i++) + { + // + XCOrderBlock *iOB = obs[i]; + + // + // Check Ob Index inside OB FVGS ... + bool isOBFVGExists = false; + bool hasOBFVGs = conditions.HasOBFVGs(); + int obFVGsCount = conditions.CountOBFVGs(); + if (hasOBFVGs) + { + // + for (int j = 0; j < obFVGsCount; j++) + { + // + bool isSame = IsSame( + conditions.obFVGs[j].ob, + iOB // + ); + + // + if (isSame) + { + // + isOBFVGExists = true; + break; + } + } + } + if (isOBFVGExists) + { + continue; + } + + // + for (int j = 0; j < fvgsCount; j++) + { + // + XCFVG *jFVG = fvgs[j]; + + // + XOBFVG iOBFVG; + + // + iOBFVG.time = cTime; + iOBFVG.symbol = iOB.GetSymbol(); + iOBFVG.period = iOB.GetPeriod(); + + // + iOBFVG.ob = iOB; + iOBFVG.fvg = jFVG; + + // + bool isValidOBFVG = iOBFVG.IsValid(); + if (isValidOBFVG) + { + // + AddRef( + iOBFVG, + conditions.obFVGs // + ); + + // + iOBFVG.Clean(); + + // + break; + } + + // + iOBFVG.Clean(); + } + } + + // + hasOBFVGs = conditions.HasOBFVGs(); + obFVGsCount = conditions.CountOBFVGs(); + } + + // + // Now We Have to Check OBFVGs ... + result = hasOBFVGs; + if (!result) + { + // + Clean(obs); + Clean(fvgs); + + // + Clean(triggerPoiEvents); + Clean(triggerCycleEvents); + Clean(decisionPoiEvents); + Clean(decisionCycleEvents); + Clean(analysePoiEvents); + Clean(analyseCycleEvents); + Clean(verificationPoiEvents); + Clean(verificationCycleEvents); + Clean(consolidationPoiEvents); + Clean(consolidationCycleEvents); + Clean(visionPoiEvents); + Clean(visionCycleEvents); + + // + visionState.Clean(); + triggerState.Clean(); + analyseState.Clean(); + decisionZBar.Clean(); + decisionCBar.Clean(); + decisionPBar.Clean(); + decisionState.Clean(); + visionConditions.Clean(); + visionXConditions.Clean(); + verificationState.Clean(); + triggerConditions.Clean(); + analyseConditions.Clean(); + consolidationState.Clean(); + triggerXConditions.Clean(); + analyseXConditions.Clean(); + decisionConditions.Clean(); + decisionXConditions.Clean(); + verificationConditions.Clean(); + verificationXConditions.Clean(); + consolidationConditions.Clean(); + consolidationXConditions.Clean(); + + // + RemoveX121SMCXSupDemOBSDraws(); + + // + return result; + } + + // + // Detect Un Activated POI(s) ... + // including: + // - Order Blocks; + // - Fair Value Gaps; + + // + bool hasUnActivatedOBs = false; + bool hasUnActivatedFVGs = false; + for (int i = 0; i < obFVGsCount; i++) + { + // + bool iHasUnActivatedOBs = conditions.obFVGs[i].HasUnActivatedOBs(); + bool iHasUnActivatedFVGs = conditions.obFVGs[i].HasUnActivatedFVGs(); + + // + if (hasOBs) + { + // + for (int j = 0; j < obsCount; j++) + { + conditions.obFVGs[i].AddUnActivatedOB( + obs[j], + decisionZBar // + ); + } + + // + iHasUnActivatedOBs = conditions.obFVGs[i].HasUnActivatedOBs(); + } + + // + if (hasFVGs) + { + // + for (int j = 0; j < fvgsCount; j++) + { + conditions.obFVGs[i].AddUnActivatedFVG( + fvgs[j], + decisionZBar // + ); + } + + // + iHasUnActivatedFVGs = conditions.obFVGs[i].HasUnActivatedFVGs(); + } + + // + if (iHasUnActivatedOBs && + !hasUnActivatedOBs) + { + hasUnActivatedOBs = iHasUnActivatedOBs; + } + + // + if (iHasUnActivatedFVGs && + !hasUnActivatedFVGs) + { + hasUnActivatedFVGs = iHasUnActivatedFVGs; + } + } + + // + result = hasUnActivatedOBs || + hasUnActivatedFVGs; + if (!result) + { + // + Clean(obs); + Clean(fvgs); + + // + Clean(triggerPoiEvents); + Clean(triggerCycleEvents); + Clean(decisionPoiEvents); + Clean(decisionCycleEvents); + Clean(analysePoiEvents); + Clean(analyseCycleEvents); + Clean(verificationPoiEvents); + Clean(verificationCycleEvents); + Clean(consolidationPoiEvents); + Clean(consolidationCycleEvents); + Clean(visionPoiEvents); + Clean(visionCycleEvents); + + // + visionState.Clean(); + triggerState.Clean(); + analyseState.Clean(); + decisionZBar.Clean(); + decisionCBar.Clean(); + decisionPBar.Clean(); + decisionState.Clean(); + visionConditions.Clean(); + visionXConditions.Clean(); + verificationState.Clean(); + triggerConditions.Clean(); + analyseConditions.Clean(); + consolidationState.Clean(); + triggerXConditions.Clean(); + analyseXConditions.Clean(); + decisionConditions.Clean(); + decisionXConditions.Clean(); + verificationConditions.Clean(); + verificationXConditions.Clean(); + consolidationConditions.Clean(); + consolidationXConditions.Clean(); + + // + RemoveX121SMCXSupDemOBSDraws(); + + // + return result; + } + + // + Clean(obs); + Clean(fvgs); + + // + Clean(triggerPoiEvents); + Clean(triggerCycleEvents); + Clean(decisionPoiEvents); + Clean(decisionCycleEvents); + Clean(analysePoiEvents); + Clean(analyseCycleEvents); + Clean(verificationPoiEvents); + Clean(verificationCycleEvents); + Clean(consolidationPoiEvents); + Clean(consolidationCycleEvents); + Clean(visionPoiEvents); + Clean(visionCycleEvents); + + // + visionState.Clean(); + triggerState.Clean(); + analyseState.Clean(); + decisionState.Clean(); + visionConditions.Clean(); + visionXConditions.Clean(); + verificationState.Clean(); + triggerConditions.Clean(); + analyseConditions.Clean(); + consolidationState.Clean(); + triggerXConditions.Clean(); + analyseXConditions.Clean(); + decisionConditions.Clean(); + decisionXConditions.Clean(); + verificationConditions.Clean(); + verificationXConditions.Clean(); + consolidationConditions.Clean(); + consolidationXConditions.Clean(); + + // + // Now We Have to Wait for Price Inside Box ... + + // + DrawX121SMCXSupDemOBSConditions( + conditions, + visionCycleHelper.mPOIDrawer // + ); + + // + XCFVG *insideFVG = NULL; + XCOrderBlock *insideOB = NULL; + for (int i = 0; i < obFVGsCount; i++) + { + // + bool iOBFVGHasInsideOB = conditions.obFVGs[i].HasInsideOB(); + bool iOBFVGHasInsideFVG = conditions.obFVGs[i].HasInsideFVG(); + + // + bool iOBFVGHasUnActivatedOBs = conditions.obFVGs[i].HasUnActivatedOBs(); + int iOBFVGUnActivatedOBsCount = conditions.obFVGs[i].CountUnActivatedOBs(); + + // + bool iOBFVGHasUnActivatedFVGs = conditions.obFVGs[i].HasUnActivatedFVGs(); + int iOBFVGUnActivatedFVGsCount = conditions.obFVGs[i].CountUnActivatedFVGs(); + + // + // Detect Inside Zones ... + + // + if (!iOBFVGHasInsideOB && + iOBFVGHasUnActivatedOBs) + { + // + int idx = -1; + for (int j = 0; j < iOBFVGUnActivatedOBsCount; j++) + { + // + ENUM_X_DIRECTION iForDir = conditions.obFVGs[i].unActivatedOBs[j].GetDirection(); + bool isIBullish = IsBullish(iForDir); + + // + bool isInsideFromUpper = IsInside( + decisionZBar.low, + conditions.obFVGs[i].unActivatedOBs[j] // + ); + bool isInsideFromLower = IsInside( + decisionZBar.high, + conditions.obFVGs[i].unActivatedOBs[j] // + ); + + // + bool isInside = + isBullish + ? isInsideFromUpper + : isInsideFromLower; + if (isInside) + { + // + idx = j; + insideOB = conditions.obFVGs[i].unActivatedOBs[j]; + conditions.obFVGs[i].insideOB = insideOB; + break; + } + } + + // + if (IsValidIndex(idx)) + { + // + ArrayRemove( + conditions.obFVGs[i].unActivatedOBs, + idx, + 1 // + ); + } + } + + // + if (insideOB == NULL && + !iOBFVGHasInsideFVG && + iOBFVGHasUnActivatedFVGs) + { + // + int idx = -1; + for (int j = 0; j < iOBFVGUnActivatedFVGsCount; j++) + { + // + ENUM_X_DIRECTION iForDir = conditions.obFVGs[i].unActivatedFVGs[j].GetDirection(); + bool isIBullish = IsBullish(iForDir); + + // + bool isInsideFromUpper = IsInside( + decisionZBar.low, + conditions.obFVGs[i].unActivatedFVGs[j] // + ); + bool isInsideFromLower = IsInside( + decisionZBar.high, + conditions.obFVGs[i].unActivatedFVGs[j] // + ); + + // + bool isInside = + isBullish + ? isInsideFromUpper + : isInsideFromLower; + if (isInside) + { + // + idx = j; + insideFVG = conditions.obFVGs[i].unActivatedFVGs[j]; + conditions.obFVGs[i].insideFVG = insideFVG; + break; + } + } + + // + if (IsValidIndex(idx)) + { + // + ArrayRemove( + conditions.obFVGs[i].unActivatedFVGs, + idx, + 1 // + ); + } + } + + // + // Use Detected Inside Zones ... + + // + if (insideOB == NULL && + insideFVG == NULL) + { + // + if (iOBFVGHasInsideOB) + { + // + insideOB = conditions.obFVGs[i].insideOB; + break; + } + else if (iOBFVGHasInsideFVG) + { + // + insideFVG = conditions.obFVGs[i].insideFVG; + break; + } + } + } + + // + bool hasPriceInsideOB = insideOB != NULL; + bool hasPriceInsideFVG = insideFVG != NULL; + bool hasPriceInsideZone = hasPriceInsideOB || + hasPriceInsideFVG; + result = hasPriceInsideZone; + if (!result) + { + // + decisionZBar.Clean(); + decisionCBar.Clean(); + decisionPBar.Clean(); + + // + return result; + } + + // + conditions.UpdateTo(cTime); + + // + // Waiting for Price Breakes Inside Zone ... // double upper = 0; double lower = 0; + bool isInsideZoneDirectionBullish = false; + bool isInsideZoneDirectionBearish = false; // + if (hasPriceInsideOB) + { + // + upper = insideOB.Upper(); + lower = insideOB.Lower(); + + // + isInsideZoneDirectionBullish = insideOB.IsBullish(); + isInsideZoneDirectionBearish = insideOB.IsBearish(); + } + else if (hasPriceInsideFVG) + { + // + upper = insideFVG.Upper(); + lower = insideFVG.Lower(); + + // + isInsideZoneDirectionBullish = insideFVG.IsBullish(); + isInsideZoneDirectionBearish = insideFVG.IsBearish(); + } + // + // Cleanup Unused Objects ... + // + ZeroMemory(insideOB); + ZeroMemory(insideFVG); + + // + Clean(triggerPoiEvents); + Clean(triggerCycleEvents); + Clean(decisionPoiEvents); + Clean(decisionCycleEvents); + Clean(analysePoiEvents); + Clean(analyseCycleEvents); + Clean(verificationPoiEvents); + Clean(verificationCycleEvents); + Clean(consolidationPoiEvents); + Clean(consolidationCycleEvents); + Clean(visionPoiEvents); + Clean(visionCycleEvents); + + // + visionState.Clean(); + triggerState.Clean(); + analyseState.Clean(); + decisionZBar.Clean(); + decisionCBar.Clean(); + decisionPBar.Clean(); + decisionState.Clean(); + visionConditions.Clean(); + visionXConditions.Clean(); + verificationState.Clean(); + triggerConditions.Clean(); + analyseConditions.Clean(); + consolidationState.Clean(); + triggerXConditions.Clean(); + analyseXConditions.Clean(); + decisionConditions.Clean(); + decisionXConditions.Clean(); + verificationConditions.Clean(); + verificationXConditions.Clean(); + consolidationConditions.Clean(); + consolidationXConditions.Clean(); // // Summarize Conditions ... @@ -1603,14 +3052,16 @@ bool DetectX121SMCXSupDemOBSSignalSetup( // bool isCondition1Bullish = // - false + hasBullishTrend && + isInsideZoneDirectionBullish // ; // bool isCondition1Bearish = // - false + hasBearishTrend && + isInsideZoneDirectionBearish // ; @@ -1677,25 +3128,6 @@ bool DetectX121SMCXSupDemOBSSignalSetup( isBearish; if (!result) { - // - // Detect PriceOB Lifetime Bars ... - - // - // Cleanup Arrays ... - Clean(triggerPoiEvents); - Clean(triggerCycleEvents); - Clean(decisionPoiEvents); - Clean(decisionCycleEvents); - Clean(analysePoiEvents); - Clean(analyseCycleEvents); - Clean(verificationPoiEvents); - Clean(verificationCycleEvents); - Clean(consolidationPoiEvents); - Clean(consolidationCycleEvents); - Clean(visionPoiEvents); - Clean(visionCycleEvents); - - // return result; } @@ -1707,19 +3139,7 @@ bool DetectX121SMCXSupDemOBSSignalSetup( : X_DIRECTION_BEARISH; // - // Cleanup Arrays ... - Clean(triggerPoiEvents); - Clean(triggerCycleEvents); - Clean(decisionPoiEvents); - Clean(decisionCycleEvents); - Clean(analysePoiEvents); - Clean(analyseCycleEvents); - Clean(verificationPoiEvents); - Clean(verificationCycleEvents); - Clean(consolidationPoiEvents); - Clean(consolidationCycleEvents); - Clean(visionPoiEvents); - Clean(visionCycleEvents); + RemoveX121SMCXSupDemOBSDraws(); // return result; @@ -1839,6 +3259,20 @@ bool DetectX121SMCXSupDemOBSSignalTrigger( ); if (!result) { + // + // Cleanup ... + zBar.Clean(); + cBar.Clean(); + pBar.Clean(); + + // + Clean(decisionPoiEvents); + Clean(decisionCycleEvents); + + // + decisionConditions.Clean(); + + // return result; } @@ -1909,8 +3343,7 @@ bool DetectX121SMCXSupDemOBSSignalTrigger( isBullish = // isBullish && - isPointBreaked && - isSlopesBullish + isPointBreaked // ; @@ -1918,8 +3351,7 @@ bool DetectX121SMCXSupDemOBSSignalTrigger( isBearish = // isBearish && - isPointBreaked && - isSlopesBearish + isPointBreaked // ; @@ -1939,10 +3371,20 @@ bool DetectX121SMCXSupDemOBSSignalTrigger( } // - // Cleanup Arrays ... + // Cleanup ... + zBar.Clean(); + cBar.Clean(); + pBar.Clean(); + + // Clean(decisionPoiEvents); Clean(decisionCycleEvents); + // + decisionState.Clean(); + decisionConditions.Clean(); + decisionXConditions.Clean(); + // return result; } @@ -1987,10 +3429,20 @@ bool DetectX121SMCXSupDemOBSSignalTrigger( : X_POSITION_TYPE_SHORT; // - // Cleanup Arrays ... + // Cleanup ... + zBar.Clean(); + cBar.Clean(); + pBar.Clean(); + + // Clean(decisionPoiEvents); Clean(decisionCycleEvents); + // + decisionState.Clean(); + decisionConditions.Clean(); + decisionXConditions.Clean(); + // return result; } @@ -2228,6 +3680,104 @@ void DrawX121SMCXSupDemOBSOrderBlock( } } +// +void DrawX121SMCXSupDemOBSFairValueGap( + XCFVG *fvg, + XCPOIDrawer *drawer // +) +{ + // + if (fvg == NULL || + drawer == NULL) + { + return; + } + + // + ENUM_X_DIRECTION forDir = fvg.GetDirection(); + + // + color bullishColor = drawer.BarBullishColor(); + color bearishColor = drawer.BarBearishColor(); + color forColor = IsBullish(forDir) + ? bullishColor + : bearishColor; + + // + // Draw Order Block ... + XCBaseObject *obj; + bool isCreated = drawer.CreateFairValueGap( + fvg, + obj // + ); + if (isCreated) + { + mX121SMCXSupDemOBSObjects.Add(obj); + } + + // + ulong chartID = drawer.ChartIdentification(); + int subWindow = drawer.SubWindowIdentification(); + + // + XOHCL startedBar; + ENUM_X_DIRECTION startedDir; + bool isStarted = fvg.IsStarted( + forDir, + startedBar, + startedDir // + ); + if (isStarted) + { + // + datetime to = startedBar.time + (PeriodSeconds(startedBar.period)); + + // + XCOHCLObject *obj; + bool isCreated = drawer.CreateBar( + startedBar, + obj, + to // + ); + if (isCreated) + { + // + obj.BodyColor(clrYellow); + obj.HighShadowColor(clrYellow); + obj.LowShadowColor(clrYellow); + + // + obj.BodyStyle(STYLE_SOLID); + obj.HighShadowStyle(STYLE_SOLID); + obj.LowShadowStyle(STYLE_SOLID); + + // + mX121SMCXSupDemOBSObjects.Add(obj); + } + + // + string startVLineName = "Start_" + fvg.GetTag(); + + // + CChartObjectVLine *startVLine; + startVLine = new CChartObjectVLine(); + isCreated = startVLine.Create( + chartID, + startVLineName, + subWindow, + startedBar.time // + ); + if (isCreated) + { + // + startVLine.Color(forColor); + + // + mX121SMCXSupDemOBSObjects.Add(startVLine); + } + } +} + // void DrawX121SMCXSupDemOBSConditions( X121SMCStrategyXSupDemOBSSignalConditions &conditions, @@ -2498,6 +4048,181 @@ void DrawX121SMCXSupDemOBSConditions( // } // } } + + // + int obFVGsCount = ArraySize(conditions.obFVGs); + bool hasOBFVGs = IsValidSize(obFVGsCount); + if (hasOBFVGs) + { + // + for (int i = 0; i < obFVGsCount; i++) + { + // + XOBFVG iOBFVG = conditions.obFVGs[i]; + + // + DrawX121SMCXSupDemOBSOrderBlock( + iOBFVG.ob, + drawer // + ); + + // + DrawX121SMCXSupDemOBSFairValueGap( + iOBFVG.fvg, + drawer // + ); + + // + int hasUnActivatedOBs = iOBFVG.HasUnActivatedOBs(); + int unActivatedOBsCount = iOBFVG.CountUnActivatedOBs(); + if (hasUnActivatedOBs) + { + // + for (int j = 0; j < unActivatedOBsCount; j++) + { + // + DrawX121SMCXSupDemOBSOrderBlock( + iOBFVG.unActivatedOBs[j], + drawer // + ); + } + } + + // + int hasUnActivatedFVGs = iOBFVG.HasUnActivatedFVGs(); + int unActivatedFVGsCount = iOBFVG.CountUnActivatedFVGs(); + if (hasUnActivatedFVGs) + { + // + for (int j = 0; j < unActivatedFVGsCount; j++) + { + // + DrawX121SMCXSupDemOBSFairValueGap( + iOBFVG.unActivatedFVGs[j], + drawer // + ); + } + } + + // + int insideZoneWidth = 1; + color insideZoneColor = clrYellow; + bool hasInsideOB = iOBFVG.HasInsideOB(); + if (hasInsideOB) + { + // + bool isBullish = iOBFVG.insideOB.IsBullish(); + + // + XCBaseObject *iObj = NULL; + isCreated = false; + if (isBullish) + { + // + XCBullishOrderBlockObject *iiObj; + isCreated = drawer.CreateBullishOrderBlock( + iOBFVG.insideOB, + iiObj // + ); + + // + if (isCreated) + { + // + iiObj.ZoneColor(insideZoneColor); + iiObj.ZoneWidth(insideZoneWidth); + + // + iObj = (XCBaseObject *)iiObj; + } + } + else + { + // + XCBearishOrderBlockObject *iiObj; + isCreated = drawer.CreateBearishOrderBlock( + iOBFVG.insideOB, + iiObj // + ); + + // + if (isCreated) + { + // + iiObj.ZoneColor(insideZoneColor); + iiObj.ZoneWidth(insideZoneWidth); + + // + iObj = (XCBaseObject *)iiObj; + } + } + + // + if (isCreated) + { + mX121SMCXSupDemOBSObjects.Add(iObj); + } + } + + // + bool hasInsideFVG = iOBFVG.HasInsideFVG(); + if (hasInsideFVG) + { + // + bool isBullish = iOBFVG.insideFVG.IsBullish(); + + // + XCBaseObject *iObj = NULL; + isCreated = false; + if (isBullish) + { + // + XCBullishFairValueGapObject *iiObj; + isCreated = drawer.CreateBullishFairValueGap( + iOBFVG.insideFVG, + iiObj // + ); + + // + if (isCreated) + { + // + iiObj.ZoneColor(insideZoneColor); + iiObj.ZoneWidth(insideZoneWidth); + + // + iObj = (XCBaseObject *)iiObj; + } + } + else + { + // + XCBearishFairValueGapObject *iiObj; + isCreated = drawer.CreateBearishFairValueGap( + iOBFVG.insideFVG, + iiObj // + ); + + // + if (isCreated) + { + // + iiObj.ZoneColor(insideZoneColor); + iiObj.ZoneWidth(insideZoneWidth); + + // + iObj = (XCBaseObject *)iiObj; + } + } + + // + if (isCreated) + { + mX121SMCXSupDemOBSObjects.Add(iObj); + } + } + } + } } // diff --git a/X121SMCEA/Strategy/x-121.smc.strategy.class.mq5 b/X121SMCEA/Strategy/x-121.smc.strategy.class.mq5 index 3fca7063..502d4f4a 100644 --- a/X121SMCEA/Strategy/x-121.smc.strategy.class.mq5 +++ b/X121SMCEA/Strategy/x-121.smc.strategy.class.mq5 @@ -862,6 +862,9 @@ class XCX121SMCStrategy : public XCX121SMCBaseStrategy 1 // ); + // + RemoveX121SMCXSupDemOBSDraws(); + // // Check Signal Direction ... isBullish = IsBullish(mConditions.dir); @@ -884,7 +887,6 @@ class XCX121SMCStrategy : public XCX121SMCBaseStrategy return result; } - // // Private ... private: