///////////////////////////////////////////////////////////////////////////////// // bool DetectXCAEAConditions( XBoxZone &boxes[], XCAEAConditions &conditions, XBoxZone &pivotBox, XBoxZone &box, ENUM_X_DIRECTION &dir, XCXCAEAHelper *helper, int barIndex = 0, int loopback = 10 // ) { // bool result = false; // int idx = -1; int count = 0; bool has = 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 p2IDX = pIDX + 1; int p3IDX = p2IDX + 1; int p4IDX = p3IDX + 1; // // Reading Parameters ... // // KI ... // double cKI = conditions.kiBuffer[cIDX]; double pKI = conditions.kiBuffer[pIDX]; double p2KI = conditions.kiBuffer[p2IDX]; // double cKIState = conditions.kiStateBuffer[cIDX]; double pKIState = conditions.kiStateBuffer[pIDX]; double p2KIState = conditions.kiStateBuffer[p2IDX]; // // TKI ... // double cTKI = conditions.tkiBuffer[cIDX]; double pTKI = conditions.tkiBuffer[pIDX]; double p2TKI = conditions.tkiBuffer[p2IDX]; // double cTKIState = conditions.tkiStateBuffer[cIDX]; double pTKIState = conditions.tkiStateBuffer[pIDX]; double p2TKIState = conditions.tkiStateBuffer[p2IDX]; // // TREND ... // double cTrend = conditions.trendBuffer[cIDX]; double pTrend = conditions.trendBuffer[pIDX]; double p2Trend = conditions.trendBuffer[p2IDX]; // double ctrendState = conditions.trendStateBuffer[cIDX]; double ptrendState = conditions.trendStateBuffer[pIDX]; double p2trendState = conditions.trendStateBuffer[p2IDX]; // // SWING Low ... double cSWL = conditions.swingLowBuffer[cIDX]; double pSWL = conditions.swingLowBuffer[pIDX]; double p2SWL = conditions.swingLowBuffer[p2IDX]; // // SWING High ... double cSWH = conditions.swingHighBuffer[cIDX]; double pSWH = conditions.swingHighBuffer[pIDX]; double p2SWH = conditions.swingHighBuffer[p2IDX]; // // PEAK ... double zPeak = conditions.peakBuffer[zIDX]; double cPeak = conditions.peakBuffer[cIDX]; double pPeak = conditions.peakBuffer[pIDX]; double p2Peak = conditions.peakBuffer[p2IDX]; double p3Peak = conditions.peakBuffer[p3IDX]; // // VALE ... double zVale = conditions.valeBuffer[zIDX]; double cVale = conditions.valeBuffer[cIDX]; double pVale = conditions.valeBuffer[pIDX]; double p2Vale = conditions.valeBuffer[p2IDX]; double p3Vale = conditions.valeBuffer[p3IDX]; // // RSI ... double zRSI = conditions.rsiBuffer[zIDX]; double cRSI = conditions.rsiBuffer[cIDX]; double pRSI = conditions.rsiBuffer[pIDX]; double p2RSI = conditions.rsiBuffer[p2IDX]; double p3RSI = conditions.rsiBuffer[p3IDX]; // // CCI ... double zCCI = conditions.cciBuffer[zIDX]; double cCCI = conditions.cciBuffer[cIDX]; double pCCI = conditions.cciBuffer[pIDX]; double p2CCI = conditions.cciBuffer[p2IDX]; double p3CCI = conditions.cciBuffer[p3IDX]; // // RVI ... // double zRVI = conditions.rviBuffer[zIDX]; double cRVI = conditions.rviBuffer[cIDX]; double pRVI = conditions.rviBuffer[pIDX]; double p2RVI = conditions.rviBuffer[p2IDX]; double p3RVI = conditions.rviBuffer[p3IDX]; // double zRVISignal = conditions.rviSignalBuffer[zIDX]; double cRVISignal = conditions.rviSignalBuffer[cIDX]; double pRVISignal = conditions.rviSignalBuffer[pIDX]; double p2RVISignal = conditions.rviSignalBuffer[p2IDX]; double p3RVISignal = conditions.rviSignalBuffer[p3IDX]; // // Reading Bars ... // XOHCL zBar; XOHCL cBar; XOHCL pBar; XOHCL p2Bar; XOHCL p3Bar; XOHCL p4Bar; result = zBar.Init( symbol, period, zIDX // ); result = result && zBar.GetPreviousBar(cBar); result = result && cBar.GetPreviousBar(pBar); result = result && pBar.GetPreviousBar(p2Bar); result = result && p2Bar.GetPreviousBar(p3Bar); result = result && p3Bar.GetPreviousBar(p4Bar); if (!result) { // zBar.Clean(); cBar.Clean(); pBar.Clean(); p2Bar.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); // double pBarLowShadow = pBar.GetLowShadow(); double pBarHighShadow = pBar.GetHighShadow(); // bool isPBarSwingLow = pBarLowShadow > 0 && pBar.low < p2Bar.low && pBar.low < cBar.low && p2Bar.GetUp() >= pBar.low && p2Bar.GetDown() <= pBar.high && cBar.GetUp() >= pBar.low && cBar.GetDown() <= pBar.high; // bool isPBarSwingHigh = pBarHighShadow > 0 && pBar.high > p2Bar.high && pBar.high > cBar.high && p2Bar.GetUp() >= pBar.low && p2Bar.GetDown() <= pBar.high && cBar.GetUp() >= pBar.low && cBar.GetDown() <= pBar.high; // // Score ... // double bullishScore = 0; double bearishScore = 0; conditions.GenerateScore( bullishScore, bearishScore // ); // bool isScoreBullish = bullishScore > bearishScore; // bool isScoreBearish = bearishScore > bullishScore; // string summary = conditions .GenerateSummary(); // // Detect Selected Box ... double providedSL = 0; bool isBoxRejected = false; bool isBoxActivated = false; bool hasBoxes = HasChild(boxes); if (hasBoxes) { // // Detect Selected Boxes ... XBoxZone tmp[]; Copy( boxes, tmp // ); while (HasChild(tmp)) { // idx = GetYoungest(tmp); has = IsValidIndex(idx); if (!has) { break; } // XBoxZone iBox; iBox = tmp[idx]; ArrayRemove( tmp, idx, 1 // ); // // Check Selected Box not RSI or CCI ... has = iBox.type == ToString(XCA_PEAKSWHRES) || iBox.type == ToString(XCA_VALESWLSUP); if (!has) { continue; } // bool isBullish = iBox.IsBullish(); bool isBearish = iBox.IsBearish(); // double rejectedCheckPrice = isBullish ? iBox.upper : iBox.lower; // // Check Box Selecting Senarios ... // // Selecting Rejected Boxes ... isBoxRejected = cBar.IsRejected( rejectedCheckPrice, iBox.dir, false, false // ); // // Selecting Activation Boxes ... // bool isBullishActivated = isBullish && isPBarSwingLow && cBar.IsBullish() && cBar.GetUp() > rejectedCheckPrice && cBar.GetDown() < rejectedCheckPrice; // bool isBearishActivated = isBearish && isPBarSwingHigh && cBar.IsBearish() && cBar.GetUp() > rejectedCheckPrice && cBar.GetDown() < rejectedCheckPrice; // isBoxActivated = isBullishActivated || isBearishActivated; // // Detect Box is Selected or not ... has = isBoxRejected || isBoxActivated; if (has) { // pivotBox = iBox; // iBox.Clean(); break; } // iBox.Clean(); } // Clean(tmp); } // // Force Conditions to Have Selected Box ... result = hasBoxes && pivotBox.IsValid(); if (!result) { // zBar.Clean(); cBar.Clean(); pBar.Clean(); p2Bar.Clean(); p3Bar.Clean(); p4Bar.Clean(); // box.Clean(); pivotBox.Clean(); conditions.Clean(); // return result; } // // Conditions ... // bool isRSIBullish = zRSI >= cRSI && cRSI > pRSI; bool isRSIBearish = zRSI <= cRSI && cRSI < pRSI; // bool isCCIBullish = zCCI >= cCCI && cCCI > pCCI && (zCCI > conditions.cciOSLevel || cCCI > conditions.cciOSLevel); bool isCCIBearish = zCCI >= cCCI && cCCI > pCCI && (zCCI < conditions.cciOBLevel || cCCI < conditions.cciOBLevel); // // Signaller Summarization ... // // Cond1 Act Using Box Activation ... // bool isCond1Bullish = // false && isCCIBullish && isBoxActivated && pivotBox.IsValid() && pivotBox.IsBullish() // ; // bool isCond1Bearish = // false && isCCIBearish && isBoxActivated && pivotBox.IsValid() && pivotBox.IsBearish() // ; // bool isCond1 = isCond1Bullish || isCond1Bearish; if (isCond1) { // providedSL = isCond1Bullish ? MathMin(pBar.low, pivotBox.lower) : MathMax(pBar.high, pivotBox.upper); // Print("Cond1"); } // // Cond2 Act Using Box Rejection ... // bool isCond2Bullish = // false && isBoxRejected && pivotBox.IsValid() && pivotBox.IsBullish() // ; // bool isCond2Bearish = // false && isBoxRejected && pivotBox.IsValid() && pivotBox.IsBearish() // ; // bool isCond2 = isCond2Bullish || isCond2Bearish; if (isCond2) { // providedSL = isCond1Bullish ? MathMin(pBar.low, pivotBox.lower) : MathMax(pBar.high, pivotBox.upper); // Print("Cond2"); } // // Cond3 Act Using CCi Peaks and Vales ... // bool isCond3Bullish = false; // bool isCond3Bearish = false; // bool isCond3 = isCond3Bullish || isCond3Bearish; if (isCond3) { // // Print("Cond3"); } // // Summarise Conditions ... // bool isBullish = // isCond1Bullish || isCond2Bullish; // ; // bool isBearish = // isCond1Bearish || isCond2Bearish // ; // result = isBullish || isBearish; if (result) { // dir = isBullish ? X_DIRECTION_BULLISH : X_DIRECTION_BEARISH; // double entry = GetEntry( conditions.symbol, dir // ); // double sl = providedSL > 0 ? providedSL : isBullish ? pivotBox.lower : pivotBox.upper; // 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 = "XCASignal"; } // result = box.IsValid() && HasDirection(dir); // // Cleanup Resources ... // if (!result) { // box.Clean(); pivotBox.Clean(); conditions.Clean(); } // zBar.Clean(); cBar.Clean(); pBar.Clean(); p2Bar.Clean(); p3Bar.Clean(); p4Bar.Clean(); // return result; } /////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////