// // Checking Conditions ... // // Retrieve Some Values ... // double peak = cXConditions.peaksBuffer[cIDX]; double peakZ = cXConditions.peaksBuffer[zIDX]; double peakP = cXConditions.peaksBuffer[pIDX]; double peakPP = cXConditions.peaksBuffer[ppIDX]; // double vale = cXConditions.valesBuffer[cIDX]; double valeZ = cXConditions.valesBuffer[zIDX]; double valeP = cXConditions.valesBuffer[pIDX]; double valePP = cXConditions.valesBuffer[ppIDX]; // double cSMHKOpen = cXConditions.xhkSMOpenBuffer[cIDX]; double cSMHKHigh = cXConditions.xhkSMHighBuffer[cIDX]; double cSMHKClose = cXConditions.xhkSMCloseBuffer[cIDX]; double cSMHKLow = cXConditions.xhkSMLowBuffer[cIDX]; double cSMHKMin = MathMin(cSMHKOpen, cSMHKClose); double cSMHKMax = MathMax(cSMHKOpen, cSMHKClose); // double pSMHKOpen = cXConditions.xhkSMOpenBuffer[pIDX]; double pSMHKHigh = cXConditions.xhkSMHighBuffer[pIDX]; double pSMHKClose = cXConditions.xhkSMCloseBuffer[pIDX]; double pSMHKLow = cXConditions.xhkSMLowBuffer[pIDX]; double pSMHKMin = MathMin(pSMHKOpen, pSMHKClose); double pSMHKMax = MathMax(pSMHKOpen, pSMHKClose); // double atrUpperSM = cXConditions.atrUpperSMBuffer[cIDX]; double atrLowerSM = cXConditions.atrLowerSMBuffer[cIDX]; // double atrUpperSMZ = cXConditions.atrUpperSMBuffer[zIDX]; double atrLowerSMZ = cXConditions.atrLowerSMBuffer[zIDX]; // double atrUpperSMP = cXConditions.atrUpperSMBuffer[pIDX]; double atrLowerSMP = cXConditions.atrLowerSMBuffer[pIDX]; // double atrUpperSMPP = cXConditions.atrUpperSMBuffer[ppIDX]; double atrLowerSMPP = cXConditions.atrLowerSMBuffer[ppIDX]; // double rsiChange = cXConditions.rsiChangeBuffer[cIDX]; double rsiChangeZ = cXConditions.rsiChangeBuffer[zIDX]; double rsiChangeP = cXConditions.rsiChangeBuffer[pIDX]; double rsiChangePP = cXConditions.rsiChangeBuffer[ppIDX]; // double rsiChangeSM = cXConditions.rsiChangeSMBuffer[cIDX]; double rsiChangeSMZ = cXConditions.rsiChangeSMBuffer[zIDX]; double rsiChangeSMP = cXConditions.rsiChangeSMBuffer[pIDX]; double rsiChangeSMPP = cXConditions.rsiChangeSMBuffer[ppIDX]; // double peaksGolden = cXConditions.peaksGoldenBuffer[cIDX]; double peaksGoldenZ = cXConditions.peaksGoldenBuffer[zIDX]; double peaksGoldenP = cXConditions.peaksGoldenBuffer[pIDX]; double peaksGoldenPP = cXConditions.peaksGoldenBuffer[ppIDX]; // double valesGolden = cXConditions.valesGoldenBuffer[cIDX]; double valesGoldenZ = cXConditions.valesGoldenBuffer[zIDX]; double valesGoldenP = cXConditions.valesGoldenBuffer[pIDX]; double valesGoldenPP = cXConditions.valesGoldenBuffer[ppIDX]; // double priceChange = cXConditions.priceChangeBuffer[cIDX]; double priceChangeZ = cXConditions.priceChangeBuffer[zIDX]; double priceChangeP = cXConditions.priceChangeBuffer[pIDX]; double priceChangePP = cXConditions.priceChangeBuffer[ppIDX]; // double priceChangeSM = cXConditions.priceChangeSMBuffer[cIDX]; double priceChangeSMZ = cXConditions.priceChangeSMBuffer[zIDX]; double priceChangeSMP = cXConditions.priceChangeSMBuffer[pIDX]; double priceChangeSMPP = cXConditions.priceChangeSMBuffer[ppIDX]; // // // // // XHK ... // bool isPBarClosedOverSMHK = // pBar.IsBullish() && pBar.GetUp() > pSMHKMax && pBar.GetDown() < pSMHKMin // ; // bool isPBarClosedUnderSMHK = // pBar.IsBearish() && pBar.GetUp() > pSMHKMax && pBar.GetDown() < pSMHKMin // ; // bool isPBarBullishPriceChangeVPattern = priceChangeP > priceChangePP && priceChangeP > priceChange; // bool isPBarBerishPriceChangeVPattern = priceChangeP < priceChangePP && priceChangeP < priceChange; // bool isPBarPriceChangeOverPeak = priceChangeP > peak && priceChangeP > peakP && priceChangeP > peakPP; // bool isPBarPriceChangeUnderVale = priceChangeP < vale && priceChangeP < valeP && priceChangeP < valePP; // bool isPBarCloseOverPeaksGoldenZone = pBar.close > peaksGoldenP; // bool isPBarCloseUnderValesGoldenZone = pBar.close < valesGoldenP; // bool isPBarPriceChangeOverAtrUpper = priceChangeP > atrUpperSMP; // bool isPBarPriceChangeUnderAtrLower = priceChangeP < atrLowerSMP; // isBullish = // // false // hasSelectedBox && selectedBox.IsBullish() && cXConditions.isStrBullish // // cBar.IsBullish() && // isPBarPriceChangeUnderVale && // isPBarPriceChangeUnderAtrLower && // isPBarBerishPriceChangeVPattern && // isPBarCloseUnderValesGoldenZone // ; // isBearish = // // false // hasSelectedBox && selectedBox.IsBearish() && cXConditions.isStrBearish // // cBar.IsBearish() && // isPBarPriceChangeOverPeak && // isPBarPriceChangeOverAtrUpper && // isPBarCloseOverPeaksGoldenZone && // isPBarBullishPriceChangeVPattern // ; ///////////////////////////////////////////////////////// // double xhkSL; ENUM_X_DIRECTION xhkDir; bool isXHKPassed = IsHKConditionsPassed( xhkSL, xhkDir, cHelper, cXConditions, barIndex // ); bool isXHKBullish = isXHKPassed && IsBullish(xhkDir); bool isXHKBearish = isXHKPassed && IsBearish(xhkDir); ///////////////////////////////////////////////////////// // bool IsRejectedBox( XOHCL &bar, // CBar ... XBoxZone &box, X121Conditions &conditions // ) { // bool result = false; // result = bar.IsValid() && box.IsValid(); if (!result) { return result; } // bool isBullish = box.IsBullish(); // bool isBullishRejected = isBullish && bar.IsRejected( box.upper, box.dir, true, // Force Type ... true // Force Pressure ... ); // bool isBearishRejected = !isBullish && bar.IsRejected( box.lower, box.dir, true, // Force Type ... true // Force Pressure ... ); // result = isBullishRejected || isBearishRejected; // return result; } // bool IsPeaksOrValesPassedBox( XBoxZone &box, X121Conditions &conditions // ) { // bool result = false; // result = box.IsValid(); if (!result) { return result; } // double peakZ = conditions.peaksBuffer[0]; double peakC = conditions.peaksBuffer[1]; double peakP = conditions.peaksBuffer[2]; double peakPP = conditions.peaksBuffer[3]; // double valeZ = conditions.valesBuffer[0]; double valeC = conditions.valesBuffer[1]; double valeP = conditions.valesBuffer[2]; double valePP = conditions.valesBuffer[3]; // double boxQ = ((box.upper - box.lower) / 100) * 25; double upperQuarter = box.upper - boxQ; double lowerQuarter = box.lower + boxQ; // bool isPPeakInsideUpperQ = peakP < box.upper && peakP > upperQuarter; // bool isPValeInsideLowerQ = valeP > box.lower && valeP < lowerQuarter; // bool isPPPeakInsideUpperQ = peakPP < box.upper && peakPP > upperQuarter; // bool isPPValeInsideLowerQ = valePP > box.lower && valePP < lowerQuarter; // result = // (box.IsBullish() && (isPValeInsideLowerQ || isPPValeInsideLowerQ) && (valeC == valeP || valeP == valePP)) // || // (box.IsBearish() && (isPPeakInsideUpperQ || isPPPeakInsideUpperQ) && (peakC == peakP || peakP == peakPP)) // ; // return result; } // bool IsX3MaPassedBox( XOHCL &bar, // CBar ... XBoxZone &box, X121Conditions &conditions // ) { // bool result = false; // result = bar.IsValid() && box.IsValid(); if (!result) { return result; } // double x3maFast = conditions.x3maFastBuffer[1]; double x3maMid = conditions.x3maMidBuffer[1]; double x3maSlow = conditions.x3maSlowBuffer[1]; // bool isx3MaInsideBox = // // Fast ... x3maFast < box.upper && x3maFast > box.lower // && // // Mid ... x3maMid < box.upper && x3maMid > box.lower // && // // Slow ... x3maSlow < box.upper && x3maSlow > box.lower // ; // bool isX3maSwitchedToBullishOrdered = bar.IsBullish() && box.IsBullish() && isx3MaInsideBox && bar.close > conditions.x3maFastBuffer[1] && conditions.isX3MaSwitchedToBullishOrdered; // bool isX3maSwitchedToBearishOrdered = bar.IsBearish() && box.IsBearish() && isx3MaInsideBox && bar.close < conditions.x3maFastBuffer[1] && conditions.isX3MaSwitchedToBearishOrdered; // result = isX3maSwitchedToBullishOrdered || isX3maSwitchedToBearishOrdered; // return result; } // // TODO: Complete this ... bool IsActivatedBoxPassed( XBoxZone &box, X121Conditions &conditions // ) { // bool result = false; // result = box.IsValid(); if (!result) { return result; } // return result; } // // // // bool IsHKConditionsPassed( double &sl, ENUM_X_DIRECTION &dir, XC121SMCCycleHelper *helper, X121Conditions &conditions, int barIndex = 0 // ) { // bool result = false; // sl = 0; dir = X_DIRECTION_NONE; // if (barIndex < 0) { barIndex = 0; } // int zIDX = 0; int cIDX = zIDX + 1; int pIDX = cIDX + 1; int ppIDX = pIDX + 1; // XOHCL zBar; XOHCL cBar; XOHCL pBar; XOHCL ppBar; // // Retrieve Bars ... result = zBar.Init( conditions.symbol, conditions.period, barIndex // ); result = result && zBar.GetPreviousBar(cBar); result = result && cBar.GetPreviousBar(pBar); result = result && pBar.GetPreviousBar(ppBar); if (!result) { // zBar.Clean(); cBar.Clean(); pBar.Clean(); ppBar.Clean(); // return result; } // // Check PBar Swing ... ENUM_X_DIRECTION pBarSwingDir; bool isPBarSwing = helper .mBarAnalyser .IsSwing( pBar, pBarSwingDir, 3 // ); // bool isPBarSwingLow = isPBarSwing && IsBullish(pBarSwingDir); // bool isPBarSwingHigh = isPBarSwing && IsBearish(pBarSwingDir); // // Check PBar Rejection ... ENUM_X_DIRECTION pBarRejectionDir; bool isPBarRejected = helper .mBarAnalyser .IsRejected( pBar, pBarRejectionDir, false, true // ); // bool isPBarBullishRejected = isPBarRejected && IsBullish(pBarRejectionDir); // bool isPBarBearishRejected = isPBarRejected && IsBearish(pBarRejectionDir); // // Checking Str Incresing/Decreasing ... // bool isStrIncresing = // (conditions.strBuffer[zIDX] > conditions.strBuffer[cIDX] && conditions.strBuffer[zIDX] > conditions.strBuffer[pIDX] && conditions.strBuffer[zIDX] > conditions.strBuffer[ppIDX]) // && // ( // (conditions.strBuffer[zIDX] > conditions.strBuffer[cIDX] && conditions.strBuffer[cIDX] > conditions.strBuffer[pIDX]) // || // (conditions.strBuffer[cIDX] > conditions.strBuffer[pIDX] && conditions.strBuffer[pIDX] > conditions.strBuffer[ppIDX]) // ) // ; // bool isStrDecreasing = // (conditions.strBuffer[zIDX] < conditions.strBuffer[cIDX] && conditions.strBuffer[zIDX] < conditions.strBuffer[pIDX] && conditions.strBuffer[zIDX] < conditions.strBuffer[ppIDX]) // && // ( // (conditions.strBuffer[zIDX] < conditions.strBuffer[cIDX] && conditions.strBuffer[cIDX] < conditions.strBuffer[pIDX]) // || // (conditions.strBuffer[cIDX] < conditions.strBuffer[pIDX] && conditions.strBuffer[pIDX] < conditions.strBuffer[ppIDX]) // ) // ; // bool isBullish = // isPBarSwingLow && isStrIncresing && cBar.IsBullish() && cBar.low > pBar.low && cBar.open > pBar.low && zBar.open > cBar.low && // isPBarBullishRejected && conditions.isSarBullish && conditions.isStrBullish && conditions.isSMHKBullish // ; // bool isBearish = // isPBarSwingHigh && isStrDecreasing && cBar.IsBearish() && cBar.high < pBar.high && cBar.open < pBar.high && zBar.open < cBar.high && // isPBarBearishRejected && conditions.isSarBearish && conditions.isStrBearish && conditions.isSMHKBearish // ; // result = isBullish || isBearish; if (result) { // dir = isBullish ? X_DIRECTION_BULLISH : X_DIRECTION_BEARISH; // // Selecting SL ... sl = isBullish ? cBar.low : cBar.high; } // // Cleanup Resources ... zBar.Clean(); cBar.Clean(); pBar.Clean(); ppBar.Clean(); // return result; } // bool IsSARConditionsPassed( double &sl, ENUM_X_DIRECTION &dir, XC121SMCCycleHelper *helper, X121Conditions &conditions, int barIndex = 0 // ) { // bool result = false; // sl = 0; dir = X_DIRECTION_NONE; // if (barIndex < 0) { barIndex = 0; } // int zIDX = 0; int cIDX = zIDX + 1; int pIDX = cIDX + 1; int ppIDX = pIDX + 1; // XOHCL zBar; XOHCL cBar; XOHCL pBar; XOHCL ppBar; // // Retrieve Bars ... result = zBar.Init( conditions.symbol, conditions.period, barIndex // ); result = result && zBar.GetPreviousBar(cBar); result = result && cBar.GetPreviousBar(pBar); result = result && pBar.GetPreviousBar(ppBar); if (!result) { // zBar.Clean(); cBar.Clean(); pBar.Clean(); ppBar.Clean(); // return result; } // // Check PBar Swing ... ENUM_X_DIRECTION pBarSwingDir; bool isPBarSwing = helper .mBarAnalyser .IsSwing( pBar, pBarSwingDir, 3 // ); // bool isPBarSwingLow = isPBarSwing && IsBullish(pBarSwingDir); // bool isPBarSwingHigh = isPBarSwing && IsBearish(pBarSwingDir); // bool isBullish = // isPBarSwingLow && cBar.IsBullish() && cBar.low > pBar.low && cBar.open > pBar.low && zBar.open > cBar.low && conditions.isSarSwitchedToBullish // ; // bool isBearish = // isPBarSwingHigh && isStrDecreasing && cBar.IsBearish() && cBar.high < pBar.high && cBar.open < pBar.high && zBar.open < cBar.high && conditions.isSarSwitchedToBearish // ; // result = isBullish || isBearish; if (result) { // dir = isBullish ? X_DIRECTION_BULLISH : X_DIRECTION_BEARISH; // // Selecting SL ... sl = isBullish ? cBar.low : cBar.high; } // // Cleanup Resources ... zBar.Clean(); cBar.Clean(); pBar.Clean(); ppBar.Clean(); // return result; } ///////////////////////////////////////////////////////// // // // bool isPVPassed = IsPeaksOrValesPassedBox( // iBox, // cXConditions // // ); // if (isPVPassed) // { // // // selectedBox = iBox; // iBox.Clean(); // break; // } // // bool isx3MaPassed = IsX3MaPassedBox( // cBar, // iBox, // cXConditions // // ); // if (isx3MaPassed) // { // // // selectedBox = iBox; // iBox.Clean(); // break; // } // // bool isRejected = IsRejectedBox( // cBar, // iBox, // cXConditions // // ); // if (isRejected) // { // // // selectedBox = iBox; // iBox.Clean(); // break; // } ///////////////////////////////////////////////////////// // // Checking Bullish Fair Value Gaps ... has = cState.HasBullishFairValueGaps(); if (has) { // XBoxZone tmpBoxes[]; ToBox( cState.bullishFairValueGaps, tmpBoxes // ); // count = ArraySize(tmpBoxes); has = IsValidSize(count); if (has) { // for (int i = 0; i < count; i++) { // XBoxZone iBox = tmpBoxes[i]; bool isValid = IsBoxValid( iBox, 0, iBox.period // ); if (!isValid) { // iBox.Clean(); continue; } // has = IsBoxExists(iBox); if (!has) { // AddRef( iBox, mWaitingBoxes // ); } // iBox.Clean(); } } // Clean(tmpBoxes); } // // Checking Bearish Fair Value Gaps ... has = cState.HasBearishFairValueGaps(); if (has) { // XBoxZone tmpBoxes[]; ToBox( cState.bearishFairValueGaps, tmpBoxes // ); // count = ArraySize(tmpBoxes); has = IsValidSize(count); if (has) { // for (int i = 0; i < count; i++) { // XBoxZone iBox = tmpBoxes[i]; bool isValid = IsBoxValid( iBox, 0, iBox.period // ); if (!isValid) { // iBox.Clean(); continue; ; } // has = IsBoxExists(iBox); if (!has) { // AddRef( iBox, mWaitingBoxes // ); } // iBox.Clean(); } } // Clean(tmpBoxes); } ///////////////////////////////////////////////////////// // bool GeneratePVBox( XBoxZone &box, int barIndex = 0 // ) { // bool result = false; // if (barIndex < 0) { barIndex = 0; } // box.Clean(); box.symbol = GetSymbol(); box.period = GetPeriod(); // int index = barIndex; // // Peak ... datetime peaksSameFrom = NULL; double peak = mX121Helper.xpvHelper.GetPeak(index); double prevPeak = mX121Helper.xpvHelper.GetPeak(index + 1); bool startsByPeak = peak == prevPeak; // // Vale ... datetime valesSameFrom = NULL; double vale = mX121Helper.xpvHelper.GetVale(index); double prevVale = mX121Helper.xpvHelper.GetVale(index + 1); bool startsByVale = !startsByPeak && vale == prevVale; // bool canBreak = false; while (!canBreak) { // index++; // datetime cTime = iTime( box.symbol, box.period, index // ); // // Peak ... double iPeak = mX121Helper.xpvHelper.GetPeak(index); // // Vale ... double iVale = mX121Helper.xpvHelper.GetVale(index); // // Start By Peak or Value ... bool isSame = false; if (startsByPeak) { // isSame = iPeak == peak; bool canSetVale = vale == 0 ? true : iVale > vale; if (canSetVale) { vale = iVale; } } else if (startsByVale) { // isSame = iVale == vale; bool canSetPeak = peak == 0 ? true : iPeak < peak; if (canSetPeak) { peak = iPeak; } } // if (isSame) { // box.from = cTime; box.upper = peak; box.lower = vale; } else if (IsValid(box.from)) { // // Complete Box ... box.to = iTime( box.symbol, box.period, barIndex // ); // box.type = "XPVBox"; box.dir = startsByPeak ? X_DIRECTION_BEARISH : startsByVale ? X_DIRECTION_BULLISH : X_DIRECTION_NONE; } // canBreak = !isSame; } // result = box.IsValid(); if (!result) { box.Clean(); } // return result; } // void DetectPVPivots( int barIndex = 0, int validation = 50, int loopback = 100 // ) { // if (barIndex < 0) { barIndex = 0; } // loopback = NormalizeInt(loopback, 10); validation = NormalizeInt(validation, 5); // int iPeakVerified = 0; int iValeVerified = 0; datetime iPeakTo = GetBarTime( GetSymbol(), GetPeriod(), barIndex // ); datetime iValeTo = GetBarTime( GetSymbol(), GetPeriod(), barIndex // ); double iPeak = mX121Helper.xpvHelper.GetPeak(barIndex); double iVale = mX121Helper.xpvHelper.GetVale(barIndex); double iPeakGolden = mX121Helper.xpvHelper.GetPeakGoldenZone(barIndex); double iValeGolden = mX121Helper.xpvHelper.GetValeGoldenZone(barIndex); for (int i = barIndex + 1; i < barIndex + 1 + loopback; i++) { // double iiPeak = mX121Helper.xpvHelper.GetPeak(i); double iiVale = mX121Helper.xpvHelper.GetVale(i); double iiPeakGolden = mX121Helper.xpvHelper.GetPeakGoldenZone(i); double iiValeGolden = mX121Helper.xpvHelper.GetValeGoldenZone(i); // if (iiPeak == iPeak) { // iPeakVerified++; iPeakGolden = iPeakGolden < iiPeakGolden ? iiPeakGolden : iPeakGolden; } else { // if (iPeakVerified > 0 && iPeakVerified < validation) { // // Reset ... iPeak = iiPeak; iPeakVerified = 0; iPeakGolden = iiPeakGolden; iPeakTo = GetBarTime( GetSymbol(), GetPeriod(), i // ); } } // if (iiVale == iVale) { // iValeVerified++; iValeGolden = iValeGolden > iiValeGolden ? iiValeGolden : iValeGolden; } else { // if (iValeVerified > 0 && iValeVerified < validation) { // // Reset ... iVale = iiVale; iValeVerified = 0; iValeGolden = iiValeGolden; iValeTo = GetBarTime( GetSymbol(), GetPeriod(), i // ); } } // if (iPeakVerified >= validation && iValeVerified >= validation) { break; } } // // Checking PV Pivots ... // if (iPeakVerified >= validation) { // XPVPivot iPivot; // iPivot.to = iPeakTo; iPivot.value = iPeak; iPivot.type = X_PV_PEAK; iPivot.golden = iPeakGolden; iPivot.symbol = GetSymbol(); iPivot.period = GetPeriod(); iPivot.from = ((datetime)iPeakTo - (PeriodSeconds(GetPeriod()) * iPeakVerified)); // if (iPivot.IsValid()) { // AddRef( iPivot, mPVPivots // ); // XBoxZone iBox; XCBoxObject *iObj; bool iHas = iPivot.AsBox(iBox); if (iHas) { // iHas = mPOIDrawer.DrawBox( iBox, iObj // ); if (iHas) { Print("Peak Pivot ..."); } } } // iPivot.Clean(); } // if (iValeVerified >= validation) { // XPVPivot iPivot; // iPivot.to = iValeTo; iPivot.value = iVale; iPivot.type = X_PV_VALE; iPivot.symbol = GetSymbol(); iPivot.period = GetPeriod(); iPivot.golden = iValeGolden; iPivot.from = ((datetime)iValeTo - (PeriodSeconds(GetPeriod()) * iValeVerified)); // if (iPivot.IsValid()) { // AddRef( iPivot, mPVPivots // ); // XBoxZone iBox; XCBoxObject *iObj; bool iHas = iPivot.AsBox(iBox); if (iHas) { // iHas = mPOIDrawer.DrawBox( iBox, iObj // ); if (iHas) { Print("Vale Pivot ..."); } } } // iPivot.Clean(); } // } // DetectPVPivots(barIndex); ///////////////////////////////////////////////////////// // // Detect Support and Resistances ... XBoxZone tmpBoxes[]; XBoxZone selectedSupRes[]; count = provider.triggerState.SupportResistancesAsBox(tmpBoxes); has = IsValidSize(count); if (has) { // for (int i = 0; i < count; i++) { // XBoxZone iBox = tmpBoxes[i]; // // Validate Box ... bool isDirPassed = iBox.dir == selectedBox.dir; bool isPlacePassed = IsBoxInsideOr(iBox, selectedBox, true); has = isDirPassed && isPlacePassed; if (has) { // AddRef( iBox, selectedSupRes // ); } // iBox.Clean(); } // Clean(tmpBoxes); } has = HasChild(selectedSupRes); if (has) { // count = ArraySize(selectedSupRes); for (int i = 0; i < count; i++) { // selectedSupRes[i].to = TimeCurrent(); // XCBoxObject *iObj; has = drawer.DrawBox( selectedSupRes[i], iObj // ); } } ///////////////////////////////////////////////////////// // // double strSupport = 0; // datetime strIn = NULL; // datetime strOut = NULL; // bool isStrInBox = false; // double strResistance = 0; // bool isStrOutBox = false; // Checking STR Variables ... // CheckBoxStr( // cHelper, // selectedBox, // isStrInBox, // strIn, // isStrOutBox, // strOut, // strSupport, // strResistance // // ); ///////////////////////////////////////////////////////// // bool IsFVGBoxValid( XBoxZone &box, ENUM_X_CYCLES cycle, X121SMCStrategySignalProviderData &provider // ) { // bool result = false; // result = box.IsValid(); if (!result) { return result; } // // Fil Selected Data ... XPOIState cState; X121Conditions cXConditions; XPOIStateEvents cStateEvents; XC121SMCCycleHelper *cHelper; X121SMCCycleConditions cConditions; result = provider.SelectCycle( cycle, cState, cStateEvents, cXConditions, cHelper, cConditions // ); if (!result) { // cState.Clean(); ZeroMemory(cHelper); cConditions.Clean(); cXConditions.Clean(); cStateEvents.Clean(); // return result; } // bool isBoxBullish = box.IsBullish(); // int count = 0; bool has = false; // XBoxZone tmpBoxes[]; count = cState.FairValueGapsAsBox(tmpBoxes); has = IsValidSize(count); // // Check Must Contains Inner Cycle FVG ... XBoxZone selectedBox; bool hasSelectedBox = false; if (has) { // for (int i = 0; i < count; i++) { // XBoxZone iBox = tmpBoxes[i]; // // Regular Validation of Boxes ... bool isValid = IsBoxValid( iBox, 0, iBox.period // ); bool isTypePassed = iBox.dir == box.dir; bool isFromPssed = iBox.from >= box.from; bool isPlacePassed = IsBoxInsideOr( iBox, box // ) && (isBoxBullish ? iBox.lower >= box.lower : iBox.upper <= box.upper); has = isValid && isFromPssed && isTypePassed && isPlacePassed; if (!has) { // iBox.Clean(); continue; } // has = !hasSelectedBox ? true : isBoxBullish ? selectedBox.upper > iBox.upper : selectedBox.lower < iBox.lower; if (has) { // selectedBox = iBox; hasSelectedBox = selectedBox.IsValid(); } // iBox.Clean(); } } // result = hasSelectedBox; // // IGNORE Box Validations ... // if (result) // { // // // // // // From Index ... // // int fromIndex = GetBarIndex( // // selectedBox.symbol, // // selectedBox.period, // // selectedBox.from // // // ) + // // 1; // // result = IsValidIndex(fromIndex); // // // // // // To Index ... // // int toIndex = GetBarIndex( // // selectedBox.symbol, // // selectedBox.period, // // selectedBox.to // // // ); // // if (toIndex < 1) // // { // // toIndex = 1; // // } // // result = IsValidIndex(toIndex); // // // // // // Now we Have Retrieve X121Conditions between from and to Indexes ... // // // for Check States ... // // // // // bool hasNewValeUnderLast = false; // // bool isStrSwitchedToBullish = false; // // bool isSarSwitchedToBullish = false; // // bool hasValueGoldenZoneBreak = false; // // bool isSMHKSwitchedToBullish = false; // // bool isVWapSwitchedToBullishState = false; // // bool isX3MaSwitchedToBullishState = false; // // bool isVWapSwitchedToBullishOrdered = false; // // bool isX3MaSwitchedToBullishOrdered = false; // // // // // bool hasNewPeakOverLast = false; // // bool isStrSwitchedToBearish = false; // // bool isSarSwitchedToBearish = false; // // bool hasPeakGoldenZoneBreak = false; // // bool isSMHKSwitchedToBearish = false; // // bool isVWapSwitchedToBearishState = false; // // bool isX3MaSwitchedToBearishState = false; // // bool isVWapSwitchedToBearishOrdered = false; // // bool isX3MaSwitchedToBearishOrdered = false; // // // // // for (int i = fromIndex; i >= toIndex; i--) // // { // // // // // XOHCL iBar; // // has = iBar.Init( // // cState.symbol, // // cState.period, // // i // // // ); // // X121Conditions iConditions; // // has = has && // // cHelper.mX121Helper.GetConditions( // // iConditions, // // i // // // ); // // if (!has) // // { // // continue; // // } // // // // // // Bullish ... // // // // // if (!hasNewValeUnderLast) // // { // // hasNewValeUnderLast = iConditions.isNewValeUnderLast; // // } // // // // // if (!isStrSwitchedToBullish) // // { // // isStrSwitchedToBullish = iConditions.isStrSwitchedToBullish; // // } // // // // // if (!isSarSwitchedToBullish) // // { // // isSarSwitchedToBullish = iConditions.isSarSwitchedToBullish; // // } // // // // // if (!hasValueGoldenZoneBreak) // // { // // // // // hasValueGoldenZoneBreak = // // iBar.IsBullish() && // // iBar.GetUp() > iConditions.valesGoldenBuffer[1] && // // iBar.GetDown() < iConditions.valesGoldenBuffer[1]; // // } // // // // // if (!isSMHKSwitchedToBullish) // // { // // isSMHKSwitchedToBullish = iConditions.isSMHKSwitchedToBullish; // // } // // // // // if (!isVWapSwitchedToBullishState) // // { // // isVWapSwitchedToBullishState = iConditions.isVWapSwitchedToBullishState; // // } // // // // // if (!isX3MaSwitchedToBullishState) // // { // // isX3MaSwitchedToBullishState = iConditions.isX3MaSwitchedToBullishState; // // } // // // // // if (!isVWapSwitchedToBullishOrdered) // // { // // isVWapSwitchedToBullishOrdered = iConditions.isVWapSwitchedToBullishOrdered; // // } // // // // // if (!isX3MaSwitchedToBullishOrdered) // // { // // isX3MaSwitchedToBullishOrdered = iConditions.isX3MaSwitchedToBullishOrdered; // // } // // // // // // Bearish ... // // // // // if (!hasNewPeakOverLast) // // { // // hasNewPeakOverLast = iConditions.isNewPeakOverLast; // // } // // // // // if (!isStrSwitchedToBearish) // // { // // isStrSwitchedToBearish = iConditions.isStrSwitchedToBearish; // // } // // // // // if (!isSarSwitchedToBearish) // // { // // isSarSwitchedToBearish = iConditions.isSarSwitchedToBearish; // // } // // // // // if (!hasPeakGoldenZoneBreak) // // { // // // // // hasPeakGoldenZoneBreak = // // iBar.IsBearish() && // // iBar.GetUp() > iConditions.peaksGoldenBuffer[1] && // // iBar.GetDown() < iConditions.peaksGoldenBuffer[1]; // // } // // // // // if (!isSMHKSwitchedToBearish) // // { // // isSMHKSwitchedToBearish = iConditions.isSMHKSwitchedToBearish; // // } // // // // // if (!isVWapSwitchedToBearishState) // // { // // isVWapSwitchedToBearishState = iConditions.isVWapSwitchedToBearishState; // // } // // // // // if (!isX3MaSwitchedToBearishState) // // { // // isX3MaSwitchedToBearishState = iConditions.isX3MaSwitchedToBearishState; // // } // // // // // if (!isVWapSwitchedToBearishOrdered) // // { // // isVWapSwitchedToBearishOrdered = iConditions.isVWapSwitchedToBearishOrdered; // // } // // // // // if (!isX3MaSwitchedToBearishOrdered) // // { // // isX3MaSwitchedToBearishOrdered = iConditions.isX3MaSwitchedToBearishOrdered; // // } // // // // // iConditions.Clean(); // // } // // // // // // Bullish Conditions Summary ... // // // // // bool hasBullishOrConditions = // // hasNewValeUnderLast || // // isStrSwitchedToBullish || // // isSarSwitchedToBullish || // // hasValueGoldenZoneBreak || // // isSMHKSwitchedToBullish || // // isVWapSwitchedToBullishState || // // isX3MaSwitchedToBullishState || // // isVWapSwitchedToBullishOrdered || // // isX3MaSwitchedToBullishOrdered; // // // // // bool hasBullishAndConditions = // // hasNewValeUnderLast && // // hasValueGoldenZoneBreak && // // (isStrSwitchedToBullish || // // isSarSwitchedToBullish || // // isSMHKSwitchedToBullish || // // isVWapSwitchedToBullishState || // // isX3MaSwitchedToBullishState || // // isVWapSwitchedToBullishOrdered || // // isX3MaSwitchedToBullishOrdered); // // // // // // Bearish Conditions Summary ... // // // // // bool hasBearishOrConditions = // // hasNewPeakOverLast || // // isStrSwitchedToBearish || // // isSarSwitchedToBearish || // // hasPeakGoldenZoneBreak || // // isSMHKSwitchedToBearish || // // isVWapSwitchedToBearishState || // // isX3MaSwitchedToBearishState || // // isVWapSwitchedToBearishOrdered || // // isX3MaSwitchedToBearishOrdered; // // // // // bool hasBearishAndConditions = // // hasNewPeakOverLast && // // hasPeakGoldenZoneBreak && // // (isStrSwitchedToBearish || // // isSarSwitchedToBearish || // // isSMHKSwitchedToBearish || // // isVWapSwitchedToBearishState || // // isX3MaSwitchedToBearishState || // // isVWapSwitchedToBearishOrdered || // // isX3MaSwitchedToBearishOrdered); // // // bool isBullish = // isBoxBullish // // && // // !hasBearishOrConditions && // // hasBullishOrConditions // ; // // // bool isBearish = // !isBoxBullish // // && // // !hasBullishOrConditions && // // hasBearishOrConditions // ; // // // result = isBullish || // isBearish; // // // // if (result) // // { // // // // // XCBoxObject *iBoxObj; // // XCBoxObject *iInBoxObj; // // // // // has = provider // // .verificationCycleHelper // // .mPOIDrawer // // .DrawBox( // // box, // // iBoxObj // // // ); // // if (has) // // { // // // // // iBoxObj.BoxWidth(2); // // iBoxObj.BoxStyle(STYLE_SOLID); // // } // // // // // has = provider // // .verificationCycleHelper // // .mPOIDrawer // // .DrawBox( // // selectedBox, // // iInBoxObj // // // ); // // if (has) // // { // // // // // iInBoxObj.BoxWidth(2); // // iInBoxObj.BoxStyle(STYLE_DASH); // // } // // // // // Print("Inside Selected Box ..."); // // } // } // // Cleanup Resources ... // cState.Clean(); Clean(tmpBoxes); selectedBox.Clean(); ZeroMemory(cHelper); cConditions.Clean(); cXConditions.Clean(); cStateEvents.Clean(); // return result; } ///////////////////////////////////////////////////////// // bool DetectXCAEAConditions( XCAEAConditions &conditions, XBoxZone &box, ENUM_X_DIRECTION &dir, XCXCAEAHelper *helper, int barIndex = 0, int loopback = 10 // ) { // bool result = false; // box.Clean(); conditions.Clean(); dir = X_DIRECTION_NONE; // if (barIndex < 0) { barIndex = 0; } loopback = NormalizeInt(loopback, 5); // string symbol = helper.GetSymbol(); ENUM_TIMEFRAMES period = helper.GetPeriod(); // result = helper.GetConditions( conditions, barIndex, loopback // ); if (!result) { // conditions.Clean(); return result; } // int zIDX = barIndex; int cIDX = zIDX + 1; int pIDX = cIDX + 1; int ppIDX = pIDX + 1; int p3IDX = ppIDX + 1; int p4IDX = p3IDX + 1; // XOHCL zBar; XOHCL cBar; XOHCL pBar; XOHCL ppBar; XOHCL p3Bar; XOHCL p4Bar; result = zBar.Init( symbol, period, zIDX // ); result = result && zBar.GetPreviousBar(cBar); result = result && cBar.GetPreviousBar(pBar); result = result && pBar.GetPreviousBar(ppBar); result = result && ppBar.GetPreviousBar(p3Bar); result = result && p3Bar.GetPreviousBar(p4Bar); if (!result) { // zBar.Clean(); cBar.Clean(); pBar.Clean(); ppBar.Clean(); p3Bar.Clean(); p4Bar.Clean(); // box.Clean(); conditions.Clean(); // return result; } // // Bars Conditions ... // ENUM_X_DIRECTION cBarDir; // // Hammer ... bool isCBarHammer = helper .barAnalyser .IsHammer( cBar, cBarDir // ); bool isCBarBullishHammer = isCBarHammer && IsBullish(cBarDir); bool isCBarBearishHammer = isCBarHammer && IsBearish(cBarDir); // // Rejected ... bool isCBarRejected = helper .barAnalyser .IsRejected( cBar, cBarDir, false, // Force Type ... true // Force Fibo Pressure ... ); bool isCBarBullishRejected = isCBarRejected && IsBullish(cBarDir); bool isCBarBearishRejected = isCBarRejected && IsBearish(cBarDir); // // Engulfed ... bool isCBarEngulfed = helper .barAnalyser .IsEngulfed( cBar, cBarDir // ); bool isCBarBullishEngulfed = isCBarEngulfed && IsBullish(cBarDir); bool isCBarBearishEngulfed = isCBarEngulfed && IsBearish(cBarDir); // // Momentum ... bool isCBarMomentum = helper .barAnalyser .IsMomentum( cBar, cBarDir, 1 // ); bool isCBarBullishMomentum = isCBarMomentum && IsBullish(cBarDir); bool isCBarBearishMomentum = isCBarMomentum && IsBearish(cBarDir); // // Bar Sumarise ... // bool isCBarValidForBullish = (isCBarBullishHammer || isCBarBullishRejected || isCBarBullishMomentum || isCBarBullishEngulfed); // bool isCBarValidForBearish = (isCBarBearishHammer || isCBarBearishRejected || isCBarBearishMomentum || isCBarBearishEngulfed); // // Conditions ... // bool isLowsUnderValesGolden = // pBar.low < conditions.valesGoldenBuffer[pIDX] && ppBar.low < conditions.valesGoldenBuffer[ppIDX] && p3Bar.low < conditions.valesGoldenBuffer[p3IDX] && p4Bar.low < conditions.valesGoldenBuffer[p4IDX] // ; // bool isHighsOverPeaksGolden = // pBar.high > conditions.peaksGoldenBuffer[pIDX] && ppBar.high > conditions.peaksGoldenBuffer[ppIDX] && p3Bar.high > conditions.peaksGoldenBuffer[p3IDX] && p4Bar.high > conditions.peaksGoldenBuffer[p4IDX] // ; // bool isSwingLowSameAsVale = conditions.swingLowsBuffer[p4IDX] == conditions.valesBuffer[p4IDX]; // bool isSwingHighSameAsPeak = conditions.swingHighsBuffer[p4IDX] == conditions.peaksBuffer[p4IDX]; // bool isStrSame = conditions.strBuffer[cIDX] == conditions.strBuffer[pIDX] && conditions.strBuffer[pIDX] == conditions.strBuffer[ppIDX]; // bool isSameStrBreakedUp = isStrSame && conditions.strBuffer[zIDX] > conditions.strBuffer[cIDX]; // bool isSameStrBreakedDown = isStrSame && conditions.strBuffer[zIDX] < conditions.strBuffer[cIDX]; // bool isStrBullishVPattern = // conditions.strStateBuffer[zIDX] > 0 && conditions.strStateBuffer[cIDX] > 0 && conditions.strStateBuffer[pIDX] > 0 && conditions.strBuffer[pIDX] < conditions.strBuffer[ppIDX] && conditions.strBuffer[pIDX] < conditions.strBuffer[cIDX] && conditions.strBuffer[pIDX] < conditions.strBuffer[zIDX] && conditions.strBuffer[zIDX] > conditions.strBuffer[cIDX] // ; // bool isStrBearishVPattern = // conditions.strStateBuffer[zIDX] < 0 && conditions.strStateBuffer[cIDX] < 0 && conditions.strStateBuffer[pIDX] < 0 && conditions.strBuffer[pIDX] > conditions.strBuffer[ppIDX] && conditions.strBuffer[pIDX] > conditions.strBuffer[cIDX] && conditions.strBuffer[pIDX] > conditions.strBuffer[zIDX] && conditions.strBuffer[zIDX] < conditions.strBuffer[cIDX] // ; // bool isCBarLowInTKZone = // cBar.low < conditions.tenkanSenBuffer[cIDX] && cBar.low > conditions.kijunSenBuffer[cIDX] // ; // bool isCBarHighInTKZone = // cBar.high > conditions.tenkanSenBuffer[cIDX] && cBar.high < conditions.kijunSenBuffer[cIDX] // ; // // Summarise Conditions ... // bool isBullish = // isCBarLowInTKZone && isCBarBullishRejected && isCBarValidForBullish && conditions.isX3MaSlowBullish && conditions.isTenkanSenOverKijunSen && conditions.kijunSenBuffer[cIDX] > conditions.x3maSlowBuffer[cIDX] // ; // bool isBearish = // isCBarHighInTKZone && isCBarBearishRejected && isCBarValidForBearish && conditions.isX3MaSlowBearish && conditions.isTenkanSenUnderKijunSen && conditions.kijunSenBuffer[cIDX] < conditions.x3maSlowBuffer[cIDX] // ; // result = isBullish || isBearish; if (result) { // dir = isBullish ? X_DIRECTION_BULLISH : X_DIRECTION_BEARISH; // double entry = GetEntry( conditions.symbol, dir // ); double sl = conditions.kijunSenBuffer[cIDX]; // box.dir = dir; box.symbol = conditions.symbol; box.period = conditions.period; // box.upper = isBullish ? entry : sl; // box.lower = isBullish ? sl : entry; // box.to = zBar.time; box.from = p4Bar.time; // box.type = ToString(dir) + "_Signal_" + conditions.symbol + "_" + ToString(conditions.period); } // result = box.IsValid() && HasDirection(dir); // // Cleanup Resources ... // if (!result) { // box.Clean(); conditions.Clean(); } // zBar.Clean(); cBar.Clean(); pBar.Clean(); ppBar.Clean(); p3Bar.Clean(); p4Bar.Clean(); // return result; } ///////////////////////////////////////////////////////// ///////////////////////////////////////////////////////// ///////////////////////////////////////////////////////// ///////////////////////////////////////////////////////// ///////////////////////////////////////////////////////// ///////////////////////////////////////////////////////// ///////////////////////////////////////////////////////// /////////////////////////////////////////////////////////