From c6b7bb06f401e2d5b197922b7819c76f2b8c0ed0 Mon Sep 17 00:00:00 2001 From: Hadi Khazaee Asl Date: Tue, 22 Apr 2025 22:32:52 +0330 Subject: [PATCH] last ... --- Documents/BKP/xcaea.tmp.signal.lib.mq5 | 712 ++++++++++++++++++++++++ XCAEA/Libraries/xcaea.signaller.lib.mq5 | 230 +++++--- XCAEA/Signals/xcaea.signaller.class.mq5 | 19 +- 3 files changed, 869 insertions(+), 92 deletions(-) create mode 100644 Documents/BKP/xcaea.tmp.signal.lib.mq5 diff --git a/Documents/BKP/xcaea.tmp.signal.lib.mq5 b/Documents/BKP/xcaea.tmp.signal.lib.mq5 new file mode 100644 index 00000000..51735a9b --- /dev/null +++ b/Documents/BKP/xcaea.tmp.signal.lib.mq5 @@ -0,0 +1,712 @@ +///////////////////////////////////////////////////////////////////////////////// + +// +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; +} + +/////////////////////////////////////////////////////////////////////////////////// + +/////////////////////////////////////////////////////////////////////////////////// + +/////////////////////////////////////////////////////////////////////////////////// + +/////////////////////////////////////////////////////////////////////////////////// + +/////////////////////////////////////////////////////////////////////////////////// + +/////////////////////////////////////////////////////////////////////////////////// + +/////////////////////////////////////////////////////////////////////////////////// diff --git a/XCAEA/Libraries/xcaea.signaller.lib.mq5 b/XCAEA/Libraries/xcaea.signaller.lib.mq5 index f100771d..1230ed7a 100644 --- a/XCAEA/Libraries/xcaea.signaller.lib.mq5 +++ b/XCAEA/Libraries/xcaea.signaller.lib.mq5 @@ -425,6 +425,7 @@ bool DetectXCAEAConditions( XCAEAConditions &conditions, XBoxZone &pivotBox, XBoxZone &box, + double &additionalSL, ENUM_X_DIRECTION &dir, XCXCAEAHelper *helper, int barIndex = 0, @@ -441,6 +442,7 @@ bool DetectXCAEAConditions( // box.Clean(); + additionalSL = 0; conditions.Clean(); dir = X_DIRECTION_NONE; @@ -454,17 +456,28 @@ bool DetectXCAEAConditions( // string symbol = helper.GetSymbol(); ENUM_TIMEFRAMES period = helper.GetPeriod(); + double points = GetPoints(symbol); // + XCAEAConditions pConditions; result = helper.GetConditions( conditions, barIndex, loopback // ); + result = result && + helper.GetConditions( + pConditions, + barIndex + 1, + loopback // + ); if (!result) { // conditions.Clean(); + pConditions.Clean(); + + // return result; } @@ -622,6 +635,7 @@ bool DetectXCAEAConditions( // box.Clean(); conditions.Clean(); + pConditions.Clean(); // return result; @@ -713,30 +727,6 @@ bool DetectXCAEAConditions( 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 ... @@ -761,11 +751,38 @@ bool DetectXCAEAConditions( conditions .GenerateSummary(); + // + // 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); + // // Detect Selected Box ... double providedSL = 0; + bool isBoxFVG = false; + bool hasPivotBox = false; + bool isBoxPeakVale = false; bool isBoxRejected = false; bool isBoxActivated = false; + bool isBoxFullSifeRejected = false; bool hasBoxes = HasChild(boxes); if (hasBoxes) { @@ -797,10 +814,27 @@ bool DetectXCAEAConditions( // // Check Selected Box not RSI or CCI ... - has = iBox.type == ToString(XCA_PEAKSWHRES) || - iBox.type == ToString(XCA_VALESWLSUP); + isBoxFVG = Contains( + "XCA_FVG", + iBox.type // + ); + isBoxPeakVale = + Contains( + "XCA_PEAKSWHRES", + iBox.type // + ) || + Contains( + "XCA_VALESWLSUP", + iBox.type // + ); + has = isBoxFVG || + isBoxPeakVale; if (!has) { + // + iBox.Clean(); + + // continue; } @@ -813,6 +847,10 @@ bool DetectXCAEAConditions( isBullish ? iBox.upper : iBox.lower; + double rejectedFullCheckPrice = + isBullish + ? iBox.lower + : iBox.upper; // // Check Box Selecting Senarios ... @@ -826,13 +864,21 @@ bool DetectXCAEAConditions( false // ); + // + // Selecting Rejected Boxes ... + isBoxFullSifeRejected = cBar.IsRejected( + rejectedFullCheckPrice, + iBox.dir, + false, + false // + ); + // // Selecting Activation Boxes ... // bool isBullishActivated = isBullish && - isPBarSwingLow && cBar.IsBullish() && cBar.GetUp() > rejectedCheckPrice && cBar.GetDown() < rejectedCheckPrice; @@ -840,7 +886,6 @@ bool DetectXCAEAConditions( // bool isBearishActivated = isBearish && - isPBarSwingHigh && cBar.IsBearish() && cBar.GetUp() > rejectedCheckPrice && cBar.GetDown() < rejectedCheckPrice; @@ -853,7 +898,8 @@ bool DetectXCAEAConditions( // Detect Box is Selected or not ... has = isBoxRejected || - isBoxActivated; + isBoxActivated || + isBoxFullSifeRejected; if (has) { // @@ -874,79 +920,87 @@ bool DetectXCAEAConditions( // // Force Conditions to Have Selected Box ... - result = hasBoxes && - pivotBox.IsValid(); - if (!result) + hasPivotBox = hasBoxes && + pivotBox.IsValid(); + if (hasPivotBox) { // - zBar.Clean(); - cBar.Clean(); - pBar.Clean(); - p2Bar.Clean(); - p3Bar.Clean(); - p4Bar.Clean(); + pivotBox.to = TimeCurrent(); // - box.Clean(); - pivotBox.Clean(); - conditions.Clean(); - - // - return result; + // Draw Pivot Box Here ... + if (isBoxPeakVale) + { + // + XCBoxObject *iObj; + has = helper.poiDrawer.DrawBox( + pivotBox, + iObj // + ); + if (has) + { + // + iObj.BoxWidth(5); + iObj.BoxColor(clrDodgerBlue); + Print("Draw Pivot Box ..."); + } + } } // - // Conditions ... + // If all Conditions required Boxes ... + // if (!result) + // { + // // + // zBar.Clean(); + // cBar.Clean(); + // pBar.Clean(); + // p2Bar.Clean(); + // p3Bar.Clean(); + // p4Bar.Clean(); - // - bool isRSIBullish = - zRSI >= cRSI && - cRSI > pRSI; - bool isRSIBearish = - zRSI <= cRSI && - cRSI < pRSI; + // // + // box.Clean(); + // pivotBox.Clean(); + // conditions.Clean(); - // - bool isCCIBullish = - zCCI >= cCCI && - cCCI > pCCI && - (zCCI > conditions.cciOSLevel || - cCCI > conditions.cciOSLevel); - bool isCCIBearish = - zCCI >= cCCI && - cCCI > pCCI && - (zCCI < conditions.cciOBLevel || - cCCI < conditions.cciOBLevel); - - // - bool isRVIBullish = false; - bool isRVIBearish = false; + // // + // return result; + // } // // Signaller Summarization ... // - // Cond1 Act Using Box Activation ... + // Cond1 Act Using PEAK VALE Box Activation or Rejection ... // bool isCond1Bullish = // - false && - isCCIBullish && - isBoxActivated && - pivotBox.IsValid() && - pivotBox.IsBullish() + hasPivotBox && + isBoxPeakVale && + isScoreBullish && + pivotBox.IsBullish() && + (conditions.isValeUnderLast || + (conditions.isValeSameLast && + pConditions.isValeUnderLast)) && + conditions.isRSICrossedOverOS && + conditions.isCCICrossedOverOS // ; // bool isCond1Bearish = // - false && - isCCIBearish && - isBoxActivated && - pivotBox.IsValid() && - pivotBox.IsBearish() + hasPivotBox && + isBoxPeakVale && + isScoreBearish && + pivotBox.IsBearish() && + (conditions.isPeakOverLast || + (conditions.isPeakSameLast && + pConditions.isPeakOverLast)) && + conditions.isRSICrossedUnderOB && + conditions.isCCICrossedUnderOB // ; @@ -961,6 +1015,9 @@ bool DetectXCAEAConditions( ? MathMin(pBar.low, pivotBox.lower) : MathMax(pBar.high, pivotBox.upper); + // + additionalSL = 0.5 * conditions.atrBuffer[cIDX]; + // Print("Cond1"); } @@ -971,20 +1028,14 @@ bool DetectXCAEAConditions( // bool isCond2Bullish = // - false && - isBoxRejected && - pivotBox.IsValid() && - pivotBox.IsBullish() + false // ; // bool isCond2Bearish = // - false && - isBoxRejected && - pivotBox.IsValid() && - pivotBox.IsBearish() + false // ; @@ -1030,7 +1081,8 @@ bool DetectXCAEAConditions( bool isBullish = // isCond1Bullish || - isCond2Bullish; + isCond2Bullish || + isCond3Bullish; // ; @@ -1038,7 +1090,8 @@ bool DetectXCAEAConditions( bool isBearish = // isCond1Bearish || - isCond2Bearish + isCond2Bearish || + isCond3Bearish // ; @@ -1115,6 +1168,7 @@ bool DetectXCAEAConditions( p2Bar.Clean(); p3Bar.Clean(); p4Bar.Clean(); + pConditions.Clean(); // return result; diff --git a/XCAEA/Signals/xcaea.signaller.class.mq5 b/XCAEA/Signals/xcaea.signaller.class.mq5 index 24c7d654..8bec4402 100644 --- a/XCAEA/Signals/xcaea.signaller.class.mq5 +++ b/XCAEA/Signals/xcaea.signaller.class.mq5 @@ -170,6 +170,7 @@ class XCXCAEASignaller : XCBase XBoxZone boxes[]; XBoxZone pivotBox; XBoxZone signalBox; + double additionalSL = 0; XBoxZone bullishBoxes[]; XBoxZone bearishBoxes[]; bool hasSignalBox = false; @@ -275,6 +276,7 @@ class XCXCAEASignaller : XCBase conditions, pivotBox, signalBox, + additionalSL, signalBoxDir, helper, zIndex, @@ -346,6 +348,14 @@ class XCXCAEASignaller : XCBase isBullish ? signalBox.lower : signalBox.upper; + if (additionalSL > 0) + { + // + sl = + isBullish + ? sl - additionalSL + : sl + additionalSL; + } // double risk = @@ -421,7 +431,7 @@ class XCXCAEASignaller : XCBase else { // - double rfReward = 2; + double rfReward = 1; // double rewardRF = risk * rfReward; @@ -660,7 +670,7 @@ class XCXCAEASignaller : XCBase { // useGuards = false; - continuesRFTillTarget = false; + continuesRFTillTarget = true; // barTraker.Init( @@ -708,10 +718,10 @@ class XCXCAEASignaller : XCBase // // XOSCS ... - // inputs.oscsInputs.rsiLength = 5; + inputs.oscsInputs.rsiLength = 5; + inputs.oscsInputs.cciLength = 5; // inputs.oscsInputs.mfiLength = 5; // inputs.oscsInputs.rviLength = 5; - // inputs.oscsInputs.cciLength = 5; // // Oscillators Views ... @@ -719,6 +729,7 @@ class XCXCAEASignaller : XCBase inputs.showRSI = false; inputs.showMFI = false; inputs.showRVI = false; + inputs.showADX = false; inputs.showMACD = false; //