/////////////////////////////////////////////////////// // // SaherElm IT Center MQL5 Class Library // -------------------------------------- // Name: XC121SMCCycleHelper // Description: provides all based classes for use ... // // // Maintainer: // ------------ // Hadi Khazaee Asl (hadi_khazaee_asl@yahoo.com) // ////////////////////////////////////////////////////// // // Global Properties ... #property library #property copyright "Copyright 2023, SaherElm IT Center" #property link "https://www.saherelm.ir" #property version "1.00" #property strict // // Imports ... #include "../../Classes/x-saherelm.x-bar.analyser.class.mq5" #include "../../Classes/x-saherelm.x-poi.class.mq5" #include "../Libraries/x-121.smc.lib.mq5" // // Definitions ... // // Implementations ... // // Cycles Enumeration ... enum ENUM_X_CYCLES { X_CYCLE_NONE, X_CYCLE_TRIGGER, X_CYCLE_DECISION, X_CYCLE_ANALYSE, X_CYCLE_VERIFICATION, X_CYCLE_CONSOLIDATION, X_CYCLE_VISION, }; // // String Representation of Cycles Enumeration ... string ToString(ENUM_X_CYCLES value) { // string result = EnumToString(value); // StringReplace(result, "X_CYCLE_", ""); // return result; } // // Validate a Cycle ... bool IsValid(ENUM_X_CYCLES value) { // bool result = false; // result = value != X_CYCLE_NONE; // return result; } // // Cycle Events Enumeration ... enum ENUM_X_CYCLE_EVENTS { SAR_CHANGE_DETECTED, NEW_PEAK_DETECTED, NEW_VALE_DETECTED, PIVOT_POINT_DETECTED, VWAP_ORDER_CHANGE_ETECTED, VWAP_STATE_CHANGE_DETCTED, CONSOLIDATION_BREAKED_DETECTED, PEAK_PIVOT_STARTED, PEAK_PIVOT_ENDED, VALE_PIVOT_STARTED, VALE_PIVOT_ENDED, }; // // Cycle Helper ... class XC121SMCCycleHelper : public XCBase { // public: // // Props ... // // X121 ... XCX121Helper *mX121Helper; // // POI Detector ... XCPOIDrawer *mPOIDrawer; XCPOIDetector *mPOIDetector; // // Bar Analyser XCBarAnalyser *mBarAnalyser; // // Constructor(s) ... XC121SMCCycleHelper() { Default(); } // // Deconstructor ... ~XC121SMCCycleHelper() { DeInit(); } // // Getter/Setter(s) ... // // Actions ... /** * Initialize ... * * @param symbol: String ... * @param period: ENUM_TIMEFRAMES member ... * @param x121Inputs: X121Inputs instance ... * * @return ( bool ) */ bool Init( string symbol, ENUM_TIMEFRAMES period, X121Inputs &x121Inputs, int requiredPOIs = 50 // ) { // bool result = false; // if (requiredPOIs < 0) { requiredPOIs = 0; } // result = IsValid(symbol) && IsValid(period); if (!result) { return result; } // mSymbol = symbol; mPeriod = period; // // X121 ... mX121Helper = new XCX121Helper(); result = mX121Helper.Init( symbol, period, x121Inputs // ); if (!result) { return result; } // mPOIDetector = new XCPOIDetector( symbol, period // ); mPOIDetector.MaxRequiredPOIs(requiredPOIs); // int maxLoopbackBars = mPOIDetector.MaxAllowedLoopbackForInit(); int periodSeconds = PeriodSeconds(period); if (periodSeconds > PeriodSeconds(PERIOD_M15)) { // int multiplier = periodSeconds / PeriodSeconds(PERIOD_M15); // if (multiplier >= 1) { maxLoopbackBars *= 2; } } mPOIDetector.MaxAllowedLoopbackForInit(maxLoopbackBars); mPOIDetector.Init(); // // Initialize Bar Analyser Class Instance ... mBarAnalyser = new XCBarAnalyser(); // // Initial and Configure POI Drawer if Required ... mPOIDrawer = new XCPOIDrawer(); mPOIDrawer.ChartIdentification(0); mPOIDrawer.SubWindowIdentification(0); // mPOIDrawer.DemandZoneFill(false); mPOIDrawer.SupplyZoneFill(false); mPOIDrawer.BullishFVGFill(false); mPOIDrawer.BearishFVGFill(false); mPOIDrawer.SupportZoneFill(false); mPOIDrawer.ResistanceZoneFill(false); mPOIDrawer.BullishOrderBlockFill(false); mPOIDrawer.BearishOrderBlockFill(false); // // Set Chart Style ... ApplyChartStyle(); // return result; } /** * Retrieve Symbol ... * * @return ( string ) */ string GetSymbol() { return mSymbol; } /** * Retrieve TimeFrame (Period) ... * * @return ( ENUM_TIMEFRAMES ) */ ENUM_TIMEFRAMES GetPeriod() { return mPeriod; } /** * Get Specified Bar ... * * @param source: XOHCL instance, Source Bar ... * @param bar: XOHCL instance, Dest Bar ... * * @return ( bool ) */ bool GetBar( XOHCL &source, XOHCL &bar // ) { // bool result = false; // bar.Clean(); // string symbol = GetSymbol(); ENUM_TIMEFRAMES period = GetPeriod(); // result = IsValid(symbol) && IsValid(period) && source.IsValid(); if (!result) { return result; } // int index = iBarShift( symbol, period, source.time // ); result = bar.Init( symbol, period, index // ); if (!result) { // bar.Clean(); return result; } // return result; } /** * Retrieve Specified Bar ... * * @param bar: XOHCL instance ... * @param index: Integer ... * * @return ( bool ) */ bool GetBar( XOHCL &bar, int index = 0 // ) { // bool result = false; // bar.Clean(); // if (index < 0) { index = 0; } // string symbol = GetSymbol(); ENUM_TIMEFRAMES period = GetPeriod(); // result = bar.Init( symbol, period, index // ); // return result; } /** * Retrieve Specified Bar ... * * @param bar: XOHCL instance ... * @param time: Datetime ... * * @return ( bool ) */ bool GetBar( XOHCL &bar, datetime time = NULL // ) { // bool result = false; // int index = GetBarIndex(time); result = GetBar(bar, index // ); // return result; } /** * Retrieve Specified Time Bar Index ... * * @param time: DateTime ... * * @return ( int ) */ int GetBarIndex(datetime time = NULL) { // int result = -1; // time = NormalizeTime(time); // string symbol = GetSymbol(); ENUM_TIMEFRAMES period = GetPeriod(); // result = iBarShift( symbol, period, time // ); // return result; } /** * Retrieve Cycle Conditions ... * * @param events: ENUM_X_CYCLE_EVENTS member, Array ... * @param conditions: X121SMCCycleConditions instance ... * @param barIndex: Integer ... * @param loopback: Integer ... * * @return ( bool ) */ bool GetConditions( ENUM_X_CYCLE_EVENTS &events[], ENUM_XPOI_EVENTS &poiEvents[], X121SMCCycleConditions &conditions, int barIndex = 0, int loopback = 7 // ) { // bool result = false; // if (barIndex < 0) { barIndex = 0; } // if (loopback < 5) { loopback = 5; } // Clean(events); Clean(poiEvents); conditions.Clean(); // result = mX121Helper.GetConditions( conditions.x121Conditions, barIndex, loopback // ); if (!result) { // conditions.Clean(); return result; } // mPOIDetector.Update(poiEvents); mPOIDetector.GetState(conditions.state); // conditions.symbol = GetSymbol(); conditions.period = GetPeriod(); conditions.time = TimeCurrent(); // // Update(); // result = conditions.IsValid(); // return result; } // // Tools ... // 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; } // int DetectRejections( XBoxZone &rejections[], int barIndex = 0, bool forceBarType = true, bool forceFiboPressure = true, bool forceUnUsedRejections = true, int maxAllowedLoopback = 587 // ) { // int result = 0; // // Normalize Args ... Clean(rejections); // if (barIndex < 0) { barIndex = 0; } // int idx = -1; bool has = false; for (int i = barIndex + 1; i < barIndex + maxAllowedLoopback; i++) { // // Init Indexed Bar ... XOHCL iBar; XOHCL iCBar; XOHCL iPBar; has = GetBar(iBar, i); has = has && iBar.GetPreviousBar(iCBar); has = has && iCBar.GetPreviousBar(iPBar); if (!has) { // iBar.Clean(); iCBar.Clean(); iPBar.Clean(); break; } // // Check CBar Bullish Fibo Pressure ... bool cBarHasBullishFiboPressure = mBarAnalyser .HasFiboPressure( iCBar, X_DIRECTION_BULLISH, X_FIBO_LEVEL_382 // ); // // Check CBar Bearish Fibo Pressure ... bool cBarHasBearishFiboPressure = mBarAnalyser .HasFiboPressure( iCBar, X_DIRECTION_BEARISH, X_FIBO_LEVEL_382 // ); // // Check Bar is Bullish Rejection Swing ... bool isBullishRejection = // iCBar.low < iBar.low && iCBar.low < iPBar.low && // iCBar.low < iCBar.GetDown() && iCBar.GetLowShadow() > iCBar.GetBody() && iCBar.GetLowShadow() > iCBar.GetHighShadow() // ; // // Check Bar is Bearish Rejection Swing ... bool isBearishRejection = // iCBar.high > iBar.high && iCBar.high > iPBar.high && // iCBar.high > iCBar.GetUp() && iCBar.GetHighShadow() > iCBar.GetBody() && iCBar.GetHighShadow() > iCBar.GetLowShadow() // ; // // Apply Fibo Pressure ... if (forceFiboPressure) { // isBullishRejection = isBullishRejection && cBarHasBullishFiboPressure; // isBearishRejection = isBearishRejection && cBarHasBearishFiboPressure; } // // Apply Force Bar Type ... if (forceBarType) { // isBullishRejection = isBullishRejection && iCBar.IsBullish(); // isBearishRejection = isBearishRejection && iCBar.IsBearish(); } // // Summarize Result ... has = isBullishRejection || isBearishRejection; if (has) { // XBoxZone iBox; // iBox.to = iBar.time; iBox.from = iCBar.time; iBox.period = iBar.period; iBox.symbol = iBar.symbol; // iBox.dir = isBullishRejection ? X_DIRECTION_BULLISH : X_DIRECTION_BEARISH; // iBox.upper = isBullishRejection ? iCBar.GetDown() : iCBar.high; // iBox.lower = isBullishRejection ? iCBar.low : iCBar.GetUp(); // iBox.type = isBullishRejection ? "XSwingLow" : "XSwingHigh"; // // Validate Box ... has = iBox.IsValid(); if (has) { // // Apply Force Unused Rejections ... if (forceUnUsedRejections) { // has = !IsBoxBreaked( iBox, iCBar.Index() + 1, barIndex // ); } // if (has) { // idx = FindIndex( iBox, rejections // ); has = !IsValidIndex(idx); if (has) { // AddRef( iBox, rejections // ); } } } // iBox.Clean(); } // iBar.Clean(); iCBar.Clean(); iPBar.Clean(); } // result = ArraySize(rejections); // return result; } // datetime DetectNearestCloseOverX3MAFast( XOHCL &bar, int maxAllowedBars = 20 // ) { // datetime result = NULL; // if (!bar.IsValid()) { return result; } // bool has = false; int idx = bar.Index(); int start = idx; int end = start + maxAllowedBars; bool canContinue = true; while (canContinue) { // XOHCL iBar; has = iBar.Init( bar.symbol, bar.period, start // ); if (!has) { // iBar.Clean(); break; } // double iFast = mX121Helper .x3maHelper .GetX3MaFast(start); // has = iBar.close > iFast && iBar.open < iFast; if (has) { result = iBar.time; } // canContinue = start < end && !IsValid(result); // start++; // iBar.Clean(); } // return result; } // datetime DetectNearestCloseUnderX3MAFast( XOHCL &bar, int maxAllowedBars = 20 // ) { // datetime result = NULL; // if (!bar.IsValid()) { return result; } // bool has = false; int idx = bar.Index(); int start = idx; int end = start + maxAllowedBars; bool canContinue = true; while (canContinue) { // XOHCL iBar; has = iBar.Init( bar.symbol, bar.period, start // ); if (!has) { // iBar.Clean(); break; } // double iFast = mX121Helper .x3maHelper .GetX3MaFast(start); // has = iBar.close < iFast && iBar.open > iFast; if (has) { result = iBar.time; } // canContinue = start < end && !IsValid(result); // start++; // iBar.Clean(); } // return result; } // bool DetectNearestTenKijCross( XOHCL &bar, ENUM_X_DIRECTION &dir, int barIndex = 0, int maxAllowedBars = 20 // ) { // bool result = false; // bar.Clean(); dir = X_DIRECTION_NONE; barIndex = NormalizeInt(barIndex, 0); maxAllowedBars = NormalizeInt(maxAllowedBars, 20); // // Looping Through LoopBack Period ... // for Detecting Result ... for (int i = barIndex; i < barIndex + maxAllowedBars; i++) { // XOHCL iBar; result = iBar.Init( GetSymbol(), GetPeriod(), i // ); if (!result) { // iBar.Clean(); break; } // double iTSen = mX121Helper.xichHelper.GetTenkanSen(i); double iTSenP = mX121Helper.xichHelper.GetTenkanSen(i + 1); // double iKSen = mX121Helper.xichHelper.GetKijunSen(i); double iKSenP = mX121Helper.xichHelper.GetKijunSen(i + 1); // bool isTSenOverKSen = iTSen > iKSen; bool isTSenOverKSenP = iTSenP > iKSenP; // bool isTSenUnderKSen = iTSen < iKSen; bool isTSenUnderKSenP = iTSenP < iKSenP; // // bool isTSenCrossedOverKSen = isTSenOverKSen && !isTSenOverKSenP; // bool isTSenCrossedUnderKSen = isTSenUnderKSen && !isTSenUnderKSenP; // result = isTSenCrossedOverKSen || isTSenCrossedUnderKSen; if (result) { // bar = iBar; // dir = isTSenCrossedOverKSen ? X_DIRECTION_BULLISH : X_DIRECTION_BEARISH; // iBar.Clean(); break; } // iBar.Clean(); } // return result; } // bool DetectNearestVolumeSwitched( XOHCL &bar, ENUM_X_DIRECTION &dir, int barIndex = 0, int maxAllowedBars = 20 // ) { // bool result = false; // bar.Clean(); dir = X_DIRECTION_NONE; barIndex = NormalizeInt(barIndex, 0); maxAllowedBars = NormalizeInt(maxAllowedBars, 20); // // Looping Through LoopBack Period ... // for Detecting Result ... for (int i = barIndex; i < barIndex + maxAllowedBars; i++) { // XOHCL iBar; result = iBar.Init( GetSymbol(), GetPeriod(), i // ); if (!result) { // iBar.Clean(); break; } // double iBullVMa = mX121Helper.xvolumeHelper.GetBullishVolumeMa(i); double iBullVMaP = mX121Helper.xvolumeHelper.GetBullishVolumeMa(i + 1); // double iBearVMa = mX121Helper.xvolumeHelper.GetBearishVolumeMa(i); double iBearVMaP = mX121Helper.xvolumeHelper.GetBearishVolumeMa(i + 1); // bool isBullVMaOverBearVMa = iBullVMa > iBearVMa; bool isBullVMaOverBearVMaP = iBullVMaP > iBearVMaP; bool isCrossOver = isBullVMaOverBearVMa && !isBullVMaOverBearVMaP; // bool isBullVMaUnderBearVMa = iBullVMa < iBearVMa; bool isBullVMaUnderBearVMaP = iBullVMaP < iBearVMaP; bool isCrossUnder = isBullVMaUnderBearVMa && !isBullVMaUnderBearVMaP; // result = isCrossOver || isCrossUnder; if (result) { // bar = iBar; // dir = isCrossOver ? X_DIRECTION_BULLISH : X_DIRECTION_BEARISH; // iBar.Clean(); break; } // iBar.Clean(); } // return result; } // bool DetectNearestDeltaSwitched( XOHCL &bar, ENUM_X_DIRECTION &dir, int barIndex = 0, int maxAllowedBars = 20 // ) { // bool result = false; // bar.Clean(); dir = X_DIRECTION_NONE; barIndex = NormalizeInt(barIndex, 0); maxAllowedBars = NormalizeInt(maxAllowedBars, 20); // // Looping Through LoopBack Period ... // for Detecting Result ... for (int i = barIndex; i < barIndex + maxAllowedBars; i++) { // XOHCL iBar; result = iBar.Init( GetSymbol(), GetPeriod(), i // ); if (!result) { // iBar.Clean(); break; } // double iDelta = mX121Helper.xdeltaHelper.GetDelta(i); double iDeltaP = mX121Helper.xdeltaHelper.GetDelta(i + 1); // double iDeltaMa = mX121Helper.xdeltaHelper.GetDeltaMa(i); double iDeltaMaP = mX121Helper.xdeltaHelper.GetDeltaMa(i + 1); // bool isDeltaOverMa = iDelta > iDeltaMa; bool isDeltaOverMaP = iDeltaP > iDeltaMaP; // bool isDeltaUnderMa = iDelta < iDeltaMa; bool isDeltaUnderMaP = iDeltaP < iDeltaMaP; // bool isCrossOver = isDeltaOverMa && !isDeltaOverMaP; // bool isCrossUnder = isDeltaUnderMa && !isDeltaUnderMaP; // result = isCrossOver || isCrossUnder; if (result) { // bar = iBar; // dir = isCrossOver ? X_DIRECTION_BULLISH : X_DIRECTION_BEARISH; // iBar.Clean(); break; } // iBar.Clean(); } // return result; } // bool DetectNearestStrSwitched( XOHCL &bar, ENUM_X_DIRECTION &dir, int barIndex = 0, int maxAllowedBars = 20 // ) { // bool result = false; // bar.Clean(); dir = X_DIRECTION_NONE; barIndex = NormalizeInt(barIndex, 0); maxAllowedBars = NormalizeInt(maxAllowedBars, 20); // // Looping Through LoopBack Period ... // for Detecting Result ... for (int i = barIndex; i < barIndex + maxAllowedBars; i++) { // XOHCL iBar; result = iBar.Init( GetSymbol(), GetPeriod(), i // ); if (!result) { // iBar.Clean(); break; } // double iStrState = mX121Helper.xstrHelper.GetSTRState(i); double iStrStateP = mX121Helper.xstrHelper.GetSTRState(i + 1); // bool isStrBullish = iStrState > 0; bool isStrBullishP = iStrStateP > 0; // bool isStrBearish = iStrState < 0; bool isStrBearishP = iStrStateP < 0; // bool isBullish = isStrBullish && !isStrBullishP; // bool isBearish = isStrBearish && !isStrBearishP; // result = isBullish || isBearish; if (result) { // bar = iBar; // dir = isBullish ? X_DIRECTION_BULLISH : X_DIRECTION_BEARISH; // iBar.Clean(); break; } // iBar.Clean(); } // return result; } // // Virtuals ... /** * Set Default Properties Values ... */ virtual void Default() { } // protected: // // private: // // Props ... string mSymbol; ENUM_TIMEFRAMES mPeriod; // // Actions ... /** * Release All Resources ... */ void DeInit() { // ZeroMemory(mX121Helper); ZeroMemory(mPOIDetector); ZeroMemory(mBarAnalyser); // delete mX121Helper; delete mPOIDetector; delete mBarAnalyser; } /** * Apply Chart Style ... */ void ApplyChartStyle() { // // Retrieve Current Chart ID ... long chartId = ChartID(); // ENUM_CHART_MODE mMode = CHART_CANDLES; // chart's mMode bool mShowBidLine = true; // show bid line bool mShowAskLine = true; // show ask line bool mShowGrid = false; // show grids on chart bool mShowVolumes = true; // show volumes bool mShowTradeLevels = true; // Displaying trade levels in the chart (levels of open positions, Stop Loss, Take Profit and pending orders) bool mAutoScroll = true; // chart autoscroll bool mQuickNavigation = true; // chart quick navigation state color mForeGroundColor = clrWhite; // chart's foreground color color mBackGroundColor = clrBlack; // chart's background color color mUpColor = clrGreen; // Up Color color mDownColor = clrRed; // Down Color color mBullishColor = clrGreen; // Bullish color color mBearishColor = clrRed; // Bearish color color mGridColor = clrGray; // grid color color mBidLineColor = clrGray; // bid line color color mAskLineColor = clrRed; // ask line color color mLineColor = clrLime; // line mMode and doji candlestick color color mStopColor = clrGold; // Color of stop order levels (Stop Loss and Take Profit) color mVolumesColor = clrGreen; // volumes color // ChartSetInteger(chartId, CHART_SHOW_BID_LINE, mShowBidLine); ChartSetInteger(chartId, CHART_SHOW_ASK_LINE, mShowAskLine); ChartSetInteger(chartId, CHART_SHOW_GRID, mShowGrid); ChartSetInteger(chartId, CHART_SHOW_VOLUMES, mShowVolumes); ChartSetInteger(chartId, CHART_SHOW_TRADE_LEVELS, mShowTradeLevels); ChartSetInteger(chartId, CHART_AUTOSCROLL, mAutoScroll); ChartSetInteger(chartId, CHART_QUICK_NAVIGATION, mQuickNavigation); ChartSetInteger(chartId, CHART_COLOR_FOREGROUND, mForeGroundColor); ChartSetInteger(chartId, CHART_COLOR_BACKGROUND, mBackGroundColor); ChartSetInteger(chartId, CHART_COLOR_GRID, mGridColor); ChartSetInteger(chartId, CHART_COLOR_BID, mBidLineColor); ChartSetInteger(chartId, CHART_COLOR_ASK, mAskLineColor); ChartSetInteger(chartId, CHART_COLOR_STOP_LEVEL, mStopColor); ChartSetInteger(chartId, CHART_COLOR_VOLUME, mVolumesColor); // // For Enabling XCC ... // ChartSetInteger(chartId, CHART_MODE, mMode); // ChartSetInteger(chartId, CHART_COLOR_CHART_UP, mUpColor); // ChartSetInteger(chartId, CHART_COLOR_CHART_DOWN, mDownColor); // ChartSetInteger(chartId, CHART_COLOR_CANDLE_BULL, mBullishColor); // ChartSetInteger(chartId, CHART_COLOR_CANDLE_BEAR, mBearishColor); // ChartSetInteger(chartId, CHART_COLOR_CHART_LINE, mLineColor); } // }; // // Signal Provider Data ... struct X121SMCStrategySignalProviderData { // // Props ... // // Trigger ... XPOIState triggerState; double triggerBullishScore; double triggerBearishScore; X121Conditions triggerXConditions; ENUM_XPOI_EVENTS triggerPoiEvents[]; XC121SMCCycleHelper *triggerCycleHelper; ENUM_X_CYCLE_EVENTS triggerCycleEvents[]; X121SMCCycleConditions triggerConditions; // // Decision ... XPOIState decisionState; double decisionBullishScore; double decisionBearishScore; X121Conditions decisionXConditions; ENUM_XPOI_EVENTS decisionPoiEvents[]; XC121SMCCycleHelper *decisionCycleHelper; ENUM_X_CYCLE_EVENTS decisionCycleEvents[]; X121SMCCycleConditions decisionConditions; // // Analyse ... XPOIState analyseState; double analyseBullishScore; double analyseBearishScore; X121Conditions analyseXConditions; ENUM_XPOI_EVENTS analysePoiEvents[]; XC121SMCCycleHelper *analyseCycleHelper; ENUM_X_CYCLE_EVENTS analyseCycleEvents[]; X121SMCCycleConditions analyseConditions; // // Verification ... XPOIState verificationState; double verificationBullishScore; double verificationBearishScore; X121Conditions verificationXConditions; ENUM_XPOI_EVENTS verificationPoiEvents[]; XC121SMCCycleHelper *verificationCycleHelper; ENUM_X_CYCLE_EVENTS verificationCycleEvents[]; X121SMCCycleConditions verificationConditions; // // Consolidation ... XPOIState consolidationState; double consolidationBullishScore; double consolidationBearishScore; X121Conditions consolidationXConditions; ENUM_XPOI_EVENTS consolidationPoiEvents[]; XC121SMCCycleHelper *consolidationCycleHelper; ENUM_X_CYCLE_EVENTS consolidationCycleEvents[]; X121SMCCycleConditions consolidationConditions; // // Vision ... XPOIState visionState; double visionBullishScore; double visionBearishScore; X121Conditions visionXConditions; ENUM_XPOI_EVENTS visionPoiEvents[]; XC121SMCCycleHelper *visionCycleHelper; ENUM_X_CYCLE_EVENTS visionCycleEvents[]; X121SMCCycleConditions visionConditions; // // Constructor ... X121SMCStrategySignalProviderData() { Clean(); } // // Tools ... // // Cleanup ... void Clean() { // // Trigger ... triggerState.Clean(); triggerBullishScore = 0; triggerBearishScore = 0; Clean(triggerPoiEvents); Clean(triggerCycleEvents); triggerConditions.Clean(); triggerXConditions.Clean(); // // Decision ... decisionState.Clean(); decisionBullishScore = 0; decisionBearishScore = 0; Clean(decisionPoiEvents); Clean(decisionCycleEvents); decisionConditions.Clean(); decisionXConditions.Clean(); // // Analyse ... analyseState.Clean(); analyseBullishScore = 0; analyseBearishScore = 0; Clean(analysePoiEvents); Clean(analyseCycleEvents); analyseConditions.Clean(); analyseXConditions.Clean(); // // Verification ... verificationState.Clean(); verificationBullishScore = 0; verificationBearishScore = 0; Clean(verificationPoiEvents); Clean(verificationCycleEvents); verificationConditions.Clean(); verificationXConditions.Clean(); // // Consolidation ... consolidationState.Clean(); consolidationBullishScore = 0; consolidationBearishScore = 0; Clean(consolidationPoiEvents); Clean(consolidationCycleEvents); consolidationConditions.Clean(); consolidationXConditions.Clean(); // // Vision ... visionState.Clean(); visionBullishScore = 0; visionBearishScore = 0; Clean(visionPoiEvents); Clean(visionCycleEvents); visionConditions.Clean(); visionXConditions.Clean(); } // void Destroy() { // Clean(); // ZeroMemory(visionCycleHelper); ZeroMemory(triggerCycleHelper); ZeroMemory(analyseCycleHelper); ZeroMemory(decisionCycleHelper); ZeroMemory(verificationCycleHelper); ZeroMemory(consolidationCycleHelper); // ZeroMemory(this); } // bool IsValid() { // bool result = false; // result = visionCycleHelper != NULL && triggerCycleHelper != NULL && analyseCycleHelper != NULL && decisionCycleHelper != NULL && verificationCycleHelper != NULL && consolidationCycleHelper != NULL; // return result; } // // Initialize ... bool Init( XC121SMCCycleHelper *_triggerCycleHelper, XC121SMCCycleHelper *_decisionCycleHelper, XC121SMCCycleHelper *_analyseCycleHelper, XC121SMCCycleHelper *_verificationCycleHelper, XC121SMCCycleHelper *_consolidationCycleHelper, XC121SMCCycleHelper *_visionCycleHelper // ) { // bool result = false; // // Validate Cycle Helpers ... result = // _visionCycleHelper != NULL && _triggerCycleHelper != NULL && _analyseCycleHelper != NULL && _decisionCycleHelper != NULL && _verificationCycleHelper != NULL && _consolidationCycleHelper != NULL // ; if (!result) { return result; } // visionCycleHelper = _visionCycleHelper; triggerCycleHelper = _triggerCycleHelper; analyseCycleHelper = _analyseCycleHelper; decisionCycleHelper = _decisionCycleHelper; verificationCycleHelper = _verificationCycleHelper; consolidationCycleHelper = _consolidationCycleHelper; // result = IsValid(); // return result; } // // Prepare all ... bool Prepare( int barIndex = 0, int loopback = 10, bool trigger = false, bool decision = true, bool analyse = true, bool verification = false, bool consolidation = true, bool vision = true // ) { // bool result = false; // if (barIndex < 0) { barIndex = 0; } // if (loopback < 7) { loopback = 7; } // result = IsValid(); if (!result) { return result; } // // Trigger ... if (trigger) { // result = triggerCycleHelper.GetConditions( triggerCycleEvents, triggerPoiEvents, triggerConditions, barIndex, loopback // ); if (!result) { // Clean(triggerPoiEvents); Clean(triggerCycleEvents); // triggerConditions.Clean(); // return result; } } // // Decision ... if (decision) { // result = decisionCycleHelper.GetConditions( decisionCycleEvents, decisionPoiEvents, decisionConditions, barIndex, loopback // ); if (!result) { // Clean(triggerPoiEvents); Clean(decisionPoiEvents); Clean(triggerCycleEvents); triggerConditions.Clean(); Clean(decisionCycleEvents); decisionConditions.Clean(); // return result; } } // // Analyse ... if (analyse) { // result = analyseCycleHelper.GetConditions( analyseCycleEvents, analysePoiEvents, analyseConditions, barIndex, loopback // ); if (!result) { // Clean(triggerPoiEvents); Clean(analysePoiEvents); Clean(decisionPoiEvents); Clean(triggerCycleEvents); Clean(analyseCycleEvents); triggerConditions.Clean(); analyseConditions.Clean(); Clean(decisionCycleEvents); decisionConditions.Clean(); // return result; } } // // Verification ... if (verification) { // result = verificationCycleHelper.GetConditions( verificationCycleEvents, verificationPoiEvents, verificationConditions, barIndex, loopback // ); if (!result) { // Clean(triggerPoiEvents); Clean(analysePoiEvents); Clean(decisionPoiEvents); Clean(triggerCycleEvents); Clean(analyseCycleEvents); triggerConditions.Clean(); analyseConditions.Clean(); Clean(decisionCycleEvents); decisionConditions.Clean(); Clean(verificationPoiEvents); Clean(verificationCycleEvents); verificationConditions.Clean(); // return result; } } // // Consolidation ... if (consolidation) { // result = consolidationCycleHelper.GetConditions( consolidationCycleEvents, consolidationPoiEvents, consolidationConditions, barIndex, loopback // ); if (!result) { // Clean(triggerPoiEvents); Clean(analysePoiEvents); Clean(decisionPoiEvents); Clean(triggerCycleEvents); Clean(analyseCycleEvents); triggerConditions.Clean(); analyseConditions.Clean(); Clean(decisionCycleEvents); decisionConditions.Clean(); Clean(verificationPoiEvents); Clean(consolidationPoiEvents); Clean(verificationCycleEvents); verificationConditions.Clean(); Clean(consolidationCycleEvents); consolidationConditions.Clean(); // return result; } } // // Vision ... if (vision) { result = visionCycleHelper.GetConditions( visionCycleEvents, visionPoiEvents, visionConditions, barIndex, loopback // ); if (!result) { // Clean(visionPoiEvents); Clean(triggerPoiEvents); Clean(analysePoiEvents); Clean(visionCycleEvents); visionConditions.Clean(); Clean(decisionPoiEvents); Clean(triggerCycleEvents); Clean(analyseCycleEvents); triggerConditions.Clean(); analyseConditions.Clean(); Clean(decisionCycleEvents); decisionConditions.Clean(); Clean(verificationPoiEvents); Clean(consolidationPoiEvents); Clean(verificationCycleEvents); verificationConditions.Clean(); Clean(consolidationCycleEvents); consolidationConditions.Clean(); // return result; } } // // Cycles POI States ... visionState = visionConditions.state; triggerState = triggerConditions.state; analyseState = analyseConditions.state; decisionState = decisionConditions.state; verificationState = verificationConditions.state; consolidationState = consolidationConditions.state; // // Cycle X121Conditions ... visionXConditions = visionConditions.x121Conditions; triggerXConditions = triggerConditions.x121Conditions; analyseXConditions = analyseConditions.x121Conditions; decisionXConditions = decisionConditions.x121Conditions; verificationXConditions = verificationConditions.x121Conditions; consolidationXConditions = consolidationConditions.x121Conditions; // // Trigger ... triggerXConditions.GenerateScore( triggerBullishScore, triggerBearishScore // ); // // Decision ... decisionXConditions.GenerateScore( decisionBullishScore, decisionBearishScore // ); // // Analyse ... analyseXConditions.GenerateScore( analyseBullishScore, analyseBearishScore // ); // // Verification ... verificationXConditions.GenerateScore( verificationBullishScore, verificationBearishScore // ); // // Consolidation ... consolidationXConditions.GenerateScore( consolidationBullishScore, consolidationBearishScore // ); // // Vision ... visionXConditions.GenerateScore( visionBullishScore, visionBearishScore // ); // return result; } // bool SelectCycle( ENUM_X_CYCLES cycle, XPOIState &cState, XPOIStateEvents &cStateEvents, X121Conditions &cXConditions, XC121SMCCycleHelper *&cHelper, X121SMCCycleConditions &cConditions // ) { // bool result = false; // cState.Clean(); ZeroMemory(cHelper); cConditions.Clean(); cStateEvents.Clean(); cXConditions.Clean(); // result = cycle != X_CYCLE_NONE; if (!result) { return result; } // if (cycle == X_CYCLE_TRIGGER) { // cState = triggerState; cHelper = triggerCycleHelper; cConditions = triggerConditions; cXConditions = triggerXConditions; cStateEvents.Init(triggerPoiEvents); } else if (cycle == X_CYCLE_DECISION) { // cState = decisionState; cHelper = decisionCycleHelper; cConditions = decisionConditions; cXConditions = decisionXConditions; cStateEvents.Init(decisionPoiEvents); } else if (cycle == X_CYCLE_ANALYSE) { // cState = analyseState; cHelper = analyseCycleHelper; cConditions = analyseConditions; cXConditions = analyseXConditions; cStateEvents.Init(analysePoiEvents); } else if (cycle == X_CYCLE_VERIFICATION) { // cState = verificationState; cHelper = verificationCycleHelper; cConditions = verificationConditions; cXConditions = verificationXConditions; cStateEvents.Init(verificationPoiEvents); } else if (cycle == X_CYCLE_CONSOLIDATION) { // cState = consolidationState; cHelper = consolidationCycleHelper; cConditions = consolidationConditions; cXConditions = consolidationXConditions; cStateEvents.Init(consolidationPoiEvents); } else if (cycle == X_CYCLE_VISION) { // cState = visionState; cHelper = visionCycleHelper; cConditions = visionConditions; cXConditions = visionXConditions; cStateEvents.Init(visionPoiEvents); } // result = cState.IsValid() && cHelper != NULL; // return result; } // void MaxRequiredPOIs(int value) { // if (!IsValid()) { return; } // visionCycleHelper.mPOIDetector.MaxRequiredPOIs(value); analyseCycleHelper.mPOIDetector.MaxRequiredPOIs(value); decisionCycleHelper.mPOIDetector.MaxRequiredPOIs(value); consolidationCycleHelper.mPOIDetector.MaxRequiredPOIs(value); } // void MaxAllowedLoopbackForInit(int value) { // if (!IsValid()) { return; } // visionCycleHelper.mPOIDetector.MaxAllowedLoopbackForInit(value); analyseCycleHelper.mPOIDetector.MaxAllowedLoopbackForInit(value); decisionCycleHelper.mPOIDetector.MaxAllowedLoopbackForInit(value); consolidationCycleHelper.mPOIDetector.MaxAllowedLoopbackForInit(value); } // }; // // Condition Parser ... struct X121SMCStrategyConditionParser { // // Props ... // // XMA ... // bool isX3MaFastUnderValesGoldenZone; bool isX3MaMidUnderValesGoldenZone; bool isX3MaSlowUnderValesGoldenZone; // bool isX3MaFastCrossedUnderValesGoldenZone; bool isX3MaMidCrossedUnderValesGoldenZone; bool isX3MaSlowCrossedUnderValesGoldenZone; // bool isX3MaFastOverPeaksGoldenZone; bool isX3MaMidOverPeaksGoldenZone; bool isX3MaSlowOverPeaksGoldenZone; // bool isX3MaFastCrossedOverPeaksGoldenZone; bool isX3MaMidCrossedOverPeaksGoldenZone; bool isX3MaSlowCrossedOverPeaksGoldenZone; // // XVWAP ... // bool isVWapFastUnderValesGoldenZone; bool isVWapMidUnderValesGoldenZone; bool isVWapSlowUnderValesGoldenZone; // bool isVWapFastCrossedUnderValesGoldenZone; bool isVWapMidCrossedUnderValesGoldenZone; bool isVWapSlowCrossedUnderValesGoldenZone; // bool isVWapFastOverPeaksGoldenZone; bool isVWapMidOverPeaksGoldenZone; bool isVWapSlowOverPeaksGoldenZone; // bool isVWapFastCrossedOverPeaksGoldenZone; bool isVWapMidCrossedOverPeaksGoldenZone; bool isVWapSlowCrossedOverPeaksGoldenZone; // // XHK ... // bool isSMHKUnderValesGoldenZone; bool isRawHKUnderValesGoldenZone; // bool isSMHKCrossedUnderValesGoldenZone; bool isRawHKCrossedUnderValesGoldenZone; // bool isSMHKOverPeaksGoldenZone; bool isRawHKOverPeaksGoldenZone; // bool isSMHKCrossedOverPeaksGoldenZone; bool isRawHKCrossedOverPeaksGoldenZone; // // XSTR ... // bool isStrUnderValesGoldenZone; bool isStrCrossedUnderValesGoldenZone; // bool isStrOverPeaksGoldenZone; bool isStrCrossedOverPeaksGoldenZone; // // // Constructor ... X121SMCStrategyConditionParser() { Clean(); } // // Tools ... // void Clean() { // isX3MaFastUnderValesGoldenZone = false; isX3MaFastCrossedUnderValesGoldenZone = false; // isX3MaMidUnderValesGoldenZone = false; isX3MaMidCrossedUnderValesGoldenZone = false; // isX3MaSlowUnderValesGoldenZone = false; isX3MaSlowCrossedUnderValesGoldenZone = false; // isX3MaFastOverPeaksGoldenZone = false; isX3MaFastCrossedOverPeaksGoldenZone = false; // isX3MaMidOverPeaksGoldenZone = false; isX3MaMidCrossedOverPeaksGoldenZone = false; // isX3MaSlowOverPeaksGoldenZone = false; isX3MaSlowCrossedOverPeaksGoldenZone = false; // isVWapFastUnderValesGoldenZone = false; isVWapFastCrossedUnderValesGoldenZone = false; // isVWapMidUnderValesGoldenZone = false; isVWapMidCrossedUnderValesGoldenZone = false; // isVWapSlowUnderValesGoldenZone = false; isVWapSlowCrossedUnderValesGoldenZone = false; // isVWapFastOverPeaksGoldenZone = false; isVWapFastCrossedOverPeaksGoldenZone = false; // isVWapMidOverPeaksGoldenZone = false; isVWapMidCrossedOverPeaksGoldenZone = false; // isVWapSlowOverPeaksGoldenZone = false; isVWapSlowCrossedOverPeaksGoldenZone = false; // isSMHKUnderValesGoldenZone = false; isSMHKCrossedUnderValesGoldenZone = false; // isRawHKUnderValesGoldenZone = false; isRawHKCrossedUnderValesGoldenZone = false; // isSMHKOverPeaksGoldenZone = false; isSMHKCrossedOverPeaksGoldenZone = false; // isRawHKOverPeaksGoldenZone = false; isRawHKCrossedOverPeaksGoldenZone = false; // isStrUnderValesGoldenZone = false; isStrCrossedUnderValesGoldenZone = false; // isStrOverPeaksGoldenZone = false; isStrCrossedOverPeaksGoldenZone = false; // ZeroMemory(this); } // void Parse( X121Conditions &conditions // ) { // Clean(); // // int zIDX = 0; int cIDX = zIDX + 1; int pIDX = cIDX + 1; // // Reading Required Materials ... // // // double peak = conditions.peaksBuffer[cIDX]; double vale = conditions.valesBuffer[cIDX]; // double peakP = conditions.peaksBuffer[pIDX]; double valeP = conditions.valesBuffer[pIDX]; // // // double str = conditions.strBuffer[cIDX]; double strP = conditions.strBuffer[pIDX]; // // // double smhkO = conditions.xhkSMOpenBuffer[cIDX]; double smhkC = conditions.xhkSMCloseBuffer[cIDX]; // double smhkMax = MathMax(smhkO, smhkC); double smhkMin = MathMin(smhkO, smhkC); // double smhkOP = conditions.xhkSMOpenBuffer[pIDX]; double smhkCP = conditions.xhkSMCloseBuffer[pIDX]; // double smhkMaxP = MathMax(smhkOP, smhkCP); double smhkMinP = MathMin(smhkOP, smhkCP); // double rawhkO = conditions.xhkRawOpenBuffer[cIDX]; double rawhkH = conditions.xhkRawHighBuffer[cIDX]; double rawhkC = conditions.xhkRawCloseBuffer[cIDX]; double rawhkL = conditions.xhkRawLowBuffer[cIDX]; // double rawhkOP = conditions.xhkRawOpenBuffer[pIDX]; double rawhkHP = conditions.xhkRawHighBuffer[pIDX]; double rawhkCP = conditions.xhkRawCloseBuffer[pIDX]; double rawhkLP = conditions.xhkRawLowBuffer[pIDX]; // // // double support = conditions.supportsBuffer[cIDX]; double resistance = conditions.resistancesBuffer[cIDX]; // double supportP = conditions.supportsBuffer[pIDX]; double resistanceP = conditions.resistancesBuffer[pIDX]; // double peakGolden = conditions.peaksGoldenBuffer[cIDX]; double valeGolden = conditions.valesGoldenBuffer[cIDX]; // double peakGoldenP = conditions.peaksGoldenBuffer[pIDX]; double valeGoldenP = conditions.valesGoldenBuffer[pIDX]; // // // double x3maFast = conditions.x3maFastBuffer[cIDX]; double x3maMid = conditions.x3maMidBuffer[cIDX]; double x3maSlow = conditions.x3maSlowBuffer[cIDX]; // double x3maFastP = conditions.x3maFastBuffer[pIDX]; double x3maMidP = conditions.x3maMidBuffer[pIDX]; double x3maSlowP = conditions.x3maSlowBuffer[pIDX]; // double vwapFast = conditions.vwapFastBuffer[cIDX]; double vwapMid = conditions.vwapMidBuffer[cIDX]; double vwapSlow = conditions.vwapSlowBuffer[cIDX]; // double vwapFastP = conditions.vwapFastBuffer[pIDX]; double vwapMidP = conditions.vwapMidBuffer[pIDX]; double vwapSlowP = conditions.vwapSlowBuffer[pIDX]; // // X3MA ... // isX3MaFastUnderValesGoldenZone = x3maFast >= vale && x3maFast <= valeGolden; // bool isX3MaFastUnderValesGoldenZoneP = x3maFastP >= valeP && x3maFastP <= valeGoldenP; // isX3MaFastCrossedUnderValesGoldenZone = isX3MaFastUnderValesGoldenZone && !isX3MaFastUnderValesGoldenZoneP; // // // isX3MaMidUnderValesGoldenZone = x3maMid >= vale && x3maMid <= valeGolden; // bool isX3MaMidUnderValesGoldenZoneP = x3maMidP >= valeP && x3maMidP <= valeGoldenP; // isX3MaMidCrossedUnderValesGoldenZone = isX3MaMidUnderValesGoldenZone && !isX3MaMidUnderValesGoldenZoneP; // // // isX3MaSlowUnderValesGoldenZone = x3maSlow >= vale && x3maSlow <= valeGolden; // bool isX3MaSlowUnderValesGoldenZoneP = x3maSlowP >= valeP && x3maSlowP <= valeGoldenP; // isX3MaSlowCrossedUnderValesGoldenZone = isX3MaSlowUnderValesGoldenZone && !isX3MaSlowUnderValesGoldenZoneP; // // // isX3MaFastOverPeaksGoldenZone = x3maFast <= peak && x3maFast >= peakGolden; // bool isX3MaFastOverPeaksGoldenZoneP = x3maFastP <= peakP && x3maFastP >= peakGoldenP; // isX3MaFastCrossedOverPeaksGoldenZone = isX3MaFastOverPeaksGoldenZone && !isX3MaFastOverPeaksGoldenZoneP; // // // isX3MaMidOverPeaksGoldenZone = x3maMid <= peak && x3maMid >= peakGolden; // bool isX3MaMidOverPeaksGoldenZoneP = x3maMidP <= peakP && x3maMidP >= peakGoldenP; // isX3MaMidCrossedOverPeaksGoldenZone = isX3MaMidOverPeaksGoldenZone && !isX3MaMidOverPeaksGoldenZoneP; // // // isX3MaSlowOverPeaksGoldenZone = x3maSlow <= peak && x3maSlow >= peakGolden; // bool isX3MaSlowOverPeaksGoldenZoneP = x3maSlowP <= peakP && x3maSlowP >= peakGoldenP; // isX3MaSlowCrossedOverPeaksGoldenZone = isX3MaSlowOverPeaksGoldenZone && !isX3MaSlowOverPeaksGoldenZoneP; // // XVWAP ... // // // isVWapFastUnderValesGoldenZone = vwapFast >= vale && vwapFast <= valeGolden; // bool isVWapFastUnderValesGoldenZoneP = vwapFastP >= valeP && vwapFastP <= valeGoldenP; // isVWapFastCrossedUnderValesGoldenZone = isVWapFastUnderValesGoldenZone && !isVWapFastUnderValesGoldenZoneP; // // // isVWapMidUnderValesGoldenZone = vwapMid >= vale && vwapMid <= valeGolden; // bool isVWapMidUnderValesGoldenZoneP = vwapMidP >= valeP && vwapMidP <= valeGoldenP; // isVWapMidCrossedUnderValesGoldenZone = isVWapMidUnderValesGoldenZone && !isVWapMidUnderValesGoldenZoneP; // // // isVWapSlowUnderValesGoldenZone = vwapSlow >= vale && vwapSlow <= valeGolden; // bool isVWapSlowUnderValesGoldenZoneP = vwapSlowP >= valeP && vwapSlowP <= valeGoldenP; // isVWapSlowCrossedUnderValesGoldenZone = isVWapSlowUnderValesGoldenZone && !isVWapSlowUnderValesGoldenZoneP; // // // isVWapFastOverPeaksGoldenZone = vwapFast <= peak && vwapFast >= peakGolden; // bool isVWapFastOverPeaksGoldenZoneP = vwapFastP <= peakP && vwapFastP >= peakGoldenP; // isVWapFastCrossedOverPeaksGoldenZone = isVWapFastOverPeaksGoldenZone && !isVWapFastOverPeaksGoldenZoneP; // // // isVWapMidOverPeaksGoldenZone = vwapMid <= peak && vwapMid >= peakGolden; // bool isVWapMidOverPeaksGoldenZoneP = vwapMidP <= peakP && vwapMidP >= peakGoldenP; // isVWapMidCrossedOverPeaksGoldenZone = isVWapMidOverPeaksGoldenZone && !isVWapMidOverPeaksGoldenZoneP; // // // isVWapSlowOverPeaksGoldenZone = vwapSlow <= peak && vwapSlow >= peakGolden; // bool isVWapSlowOverPeaksGoldenZoneP = vwapSlowP <= peakP && vwapSlowP >= peakGoldenP; // isVWapSlowCrossedOverPeaksGoldenZone = isVWapSlowOverPeaksGoldenZone && !isVWapSlowOverPeaksGoldenZoneP; // // XHK ... // // // isSMHKUnderValesGoldenZone = smhkMax >= vale && smhkMax <= valeGolden; // bool isSMHKUnderValesGoldenZoneP = smhkMaxP >= valeP && smhkMaxP <= valeGoldenP; // isSMHKCrossedUnderValesGoldenZone = isSMHKUnderValesGoldenZone && !isSMHKUnderValesGoldenZoneP; // // // isRawHKUnderValesGoldenZone = rawhkH >= vale && rawhkH <= valeGolden; // bool isRawHKUnderValesGoldenZoneP = rawhkHP >= valeP && rawhkHP <= valeGoldenP; // isRawHKCrossedUnderValesGoldenZone = isRawHKUnderValesGoldenZone && !isRawHKUnderValesGoldenZoneP; // // // isSMHKOverPeaksGoldenZone = smhkMin <= peak && smhkMin >= peakGolden; // bool isSMHKOverPeaksGoldenZoneP = smhkMinP <= peakP && smhkMinP >= peakGoldenP; // isSMHKCrossedOverPeaksGoldenZone = isSMHKOverPeaksGoldenZone && !isSMHKOverPeaksGoldenZoneP; // // // isRawHKOverPeaksGoldenZone = rawhkL <= peak && rawhkL >= peakGolden; // bool isRawHKOverPeaksGoldenZoneP = rawhkLP <= peakP && rawhkLP >= peakGoldenP; // isRawHKCrossedOverPeaksGoldenZone = isRawHKOverPeaksGoldenZone && !isRawHKOverPeaksGoldenZoneP; // // XSTR ... // // // isStrUnderValesGoldenZone = str >= vale && str <= valeGolden; // bool isStrUnderValesGoldenZoneP = strP >= valeP && strP <= valeGoldenP; // isStrCrossedUnderValesGoldenZone = isStrUnderValesGoldenZone && !isStrUnderValesGoldenZoneP; // // // isStrOverPeaksGoldenZone = str <= peak && str >= peakGolden; // bool isStrOverPeaksGoldenZoneP = strP <= peakP && strP >= peakGoldenP; // isStrCrossedOverPeaksGoldenZone = isStrOverPeaksGoldenZone && !isStrOverPeaksGoldenZoneP; } // // Rejected Boxes ... bool HasRejectedBocXConditions( ENUM_X_CYCLES cycle, XSignalBox &box, ENUM_X_DIRECTION &dir, XSignalBox &waitingBoxes[], X121SMCStrategySignalProviderData &provider, int barIndex = 0 // ) { // bool result = false; // box.Clean(); dir = X_DIRECTION_NONE; // // Checking Waiting Baoxes Exists ... result = HasChild(waitingBoxes); 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; } Parse(cXConditions); // // Normalize Args ... // if (barIndex < 0) { barIndex = 0; } // int idx = -1; int count = 0; bool has = false; // int zIDX = barIndex; int cIDX = zIDX + 1; int pIDX = cIDX + 1; int ppIDX = pIDX + 1; // bool isBullish = false; bool isBearish = false; // XOHCL zBar; XOHCL cBar; XOHCL pBar; // // Initial Bars ... result = zBar.Init( cState.symbol, cState.period, barIndex // ); result = result && zBar.GetPreviousBar(cBar); result = result && cBar.GetPreviousBar(pBar); if (!result) { // zBar.Clean(); cBar.Clean(); pBar.Clean(); cState.Clean(); ZeroMemory(cHelper); cConditions.Clean(); cXConditions.Clean(); // return result; } // // Checking Bar Based on Positions State ... ENUM_X_DIRECTION iBarPosDir; bool isBarValidForDir = cHelper .mBarAnalyser .IsValidForPosition( cBar, iBarPosDir // ); bool isBarValidForBullish = isBarValidForDir && IsBullish(iBarPosDir); bool isBarValidForBearish = isBarValidForDir && IsBearish(iBarPosDir); // // Extract Selected Boxes ... XBoxZone selectedBox; XSignalBox iSignalBox; count = ArraySize(waitingBoxes); has = IsValidSize(count); if (has) { // for (int i = 0; i < count; i++) { // XSignalBox iBox = waitingBoxes[i]; // bool isBullish = iBox.ob.IsBullish(); // bool isOBBullishRejected = // cBar.low < iBox.ob.upper && cBar.GetDown() > iBox.ob.upper // ; // bool isOBBearishRejected = // cBar.high > iBox.ob.lower && cBar.GetUp() < iBox.ob.lower // ; // has = isBullish ? isOBBullishRejected : isOBBearishRejected; // // Force Using OB ... if (has) { // iSignalBox = iBox; if (!selectedBox.IsValid()) { selectedBox = iBox.ob; } iBox.Clean(); break; } // iBox.Clean(); } } result = iSignalBox.IsValid() && selectedBox.IsValid(); if (!result) { // zBar.Clean(); cBar.Clean(); pBar.Clean(); cState.Clean(); iSignalBox.Clean(); selectedBox.Clean(); ZeroMemory(cHelper); cConditions.Clean(); cXConditions.Clean(); // return result; } // bool hasSignalBox = iSignalBox.IsValid(); bool isSignalBoxBullish = IsBullish(iSignalBox.ob.dir); // // Checking Other Conditions ... bool isVWapSlowPassed = isSignalBoxBullish ? cXConditions.isVWapSlowBullish : cXConditions.isVWapSlowBearish; // // Bullish Conditions ... isBullish = // // Base Condition ... ( // hasSignalBox && isVWapSlowPassed && isSignalBoxBullish && isBarValidForBullish // ) // ; // // Bearish Conditions ... isBearish = // // Base Condition ... ( // hasSignalBox && isVWapSlowPassed && !isSignalBoxBullish && isBarValidForBearish // ) // ; // // Filling Requirements ... result = isBullish || isBearish; if (result) { // dir = isBullish ? X_DIRECTION_BULLISH : X_DIRECTION_BEARISH; // box = iSignalBox; box.UpdateTo(TimeCurrent()); } // // Check All Conditions ... result = box.IsValid() && HasDirection(dir) && (isBullish || isBearish); // // Cleanup Resources ... zBar.Clean(); cBar.Clean(); pBar.Clean(); cState.Clean(); iSignalBox.Clean(); selectedBox.Clean(); ZeroMemory(cHelper); cConditions.Clean(); cStateEvents.Clean(); cXConditions.Clean(); // return result; } // // Activated Boxes ... bool HasActivatedBocXConditions( ENUM_X_CYCLES cycle, XSignalBox &box, ENUM_X_DIRECTION &dir, XSignalBox &waitingBoxes[], X121SMCStrategySignalProviderData &provider, int barIndex = 0 // ) { // bool result = false; // box.Clean(); dir = X_DIRECTION_NONE; // // Checking Waiting Baoxes Exists ... result = HasChild(waitingBoxes); 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; } Parse(cXConditions); // // Normalize Args ... // if (barIndex < 0) { barIndex = 0; } // int idx = -1; int count = 0; bool has = false; // int zIDX = barIndex; int cIDX = zIDX + 1; int pIDX = cIDX + 1; int ppIDX = pIDX + 1; // bool isBullish = false; bool isBearish = false; // XOHCL zBar; XOHCL cBar; XOHCL pBar; // // Initial Bars ... result = zBar.Init( cState.symbol, cState.period, barIndex // ); result = result && zBar.GetPreviousBar(cBar); result = result && cBar.GetPreviousBar(pBar); if (!result) { // zBar.Clean(); cBar.Clean(); pBar.Clean(); cState.Clean(); ZeroMemory(cHelper); cConditions.Clean(); cXConditions.Clean(); // return result; } // // Checking Bar Based on Positions State ... ENUM_X_DIRECTION iBarPosDir; bool isBarValidForDir = cHelper .mBarAnalyser .IsValidForPosition( cBar, iBarPosDir // ); bool isBarValidForBullish = isBarValidForDir && IsBullish(iBarPosDir); bool isBarValidForBearish = isBarValidForDir && IsBearish(iBarPosDir); // // Extract Selected Boxes ... XBoxZone selectedBox; XSignalBox iSignalBox; count = ArraySize(waitingBoxes); has = IsValidSize(count); if (has) { // for (int i = 0; i < count; i++) { // XSignalBox iBox = waitingBoxes[i]; // bool isBullish = iBox.ob.IsBullish(); // has = cBar.low < iBox.sharp.upper && cBar.low > iBox.sharp.lower && cBar.high > iBox.sharp.lower && cBar.high < iBox.sharp.upper; // // Force Using OB ... if (has) { // iSignalBox = iBox; if (!selectedBox.IsValid()) { selectedBox = iBox.ob; } iBox.Clean(); break; } // iBox.Clean(); } } result = iSignalBox.IsValid() && selectedBox.IsValid(); if (!result) { // zBar.Clean(); cBar.Clean(); pBar.Clean(); cState.Clean(); iSignalBox.Clean(); selectedBox.Clean(); ZeroMemory(cHelper); cConditions.Clean(); cXConditions.Clean(); // return result; } // bool hasSignalBox = iSignalBox.IsValid(); bool isSignalBoxBullish = IsBullish(iSignalBox.ob.dir); // // Checking Other Conditions ... // // XVWAP ... // bool isVWapSlopeBullish = cXConditions.isVwapFastSlopeBullish && cXConditions.isVwapMidSlopeBullish && cXConditions.isVwapSlowSlopeBullish; // bool isVWapSlopeBearish = cXConditions.isVwapFastSlopeBearish && cXConditions.isVwapMidSlopeBearish && cXConditions.isVwapSlowSlopeBearish; // bool isVWapBullishCondition = (cXConditions.isVWapBullishOrdered && cXConditions.isVWapSwitchedToBullishState) || (cXConditions.isVWapBullishState && cXConditions.isVWapSwitchedToBullishOrdered); // bool isVWapBearishCondition = (cXConditions.isVWapBearishOrdered && cXConditions.isVWapSwitchedToBearishState) || (cXConditions.isVWapBearishState && cXConditions.isVWapSwitchedToBearishOrdered); // // Bullish Conditions ... isBullish = // // Base Condition ... ( // hasSignalBox && isSignalBoxBullish && isVWapSlopeBullish && isBarValidForBullish && isVWapBullishCondition // ) // ; // // Bearish Conditions ... isBearish = // // Base Condition ... ( // hasSignalBox && isVWapSlopeBearish && !isSignalBoxBullish && isBarValidForBearish && isVWapBearishCondition // ) // ; // // Filling Requirements ... result = isBullish || isBearish; if (result) { // dir = isBullish ? X_DIRECTION_BULLISH : X_DIRECTION_BEARISH; // box = iSignalBox; box.UpdateTo(TimeCurrent()); // // Provide TP/SL ... // box.sl = isBullish ? cXConditions.vwapMin : cXConditions.vwapMax; // box.tp = isBullish ? box.sharp.upper : box.sharp.lower; } // // Check All Conditions ... result = box.IsValid() && HasDirection(dir) && (isBullish || isBearish); // // Cleanup Resources ... zBar.Clean(); cBar.Clean(); pBar.Clean(); cState.Clean(); iSignalBox.Clean(); selectedBox.Clean(); ZeroMemory(cHelper); cConditions.Clean(); cStateEvents.Clean(); cXConditions.Clean(); // return result; } // // Breaked Boxes ... bool HasBreakedBocXConditions( ENUM_X_CYCLES cycle, XSignalBox &box, ENUM_X_DIRECTION &dir, XSignalBox &breakedBoxes[], X121SMCStrategySignalProviderData &provider, int barIndex = 0 // ) { // bool result = false; // box.Clean(); dir = X_DIRECTION_NONE; // // Checking Waiting Baoxes Exists ... result = HasChild(breakedBoxes); 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; } Parse(cXConditions); // // Normalize Args ... // if (barIndex < 0) { barIndex = 0; } // int idx = -1; int count = 0; bool has = false; // int zIDX = barIndex; int cIDX = zIDX + 1; int pIDX = cIDX + 1; int ppIDX = pIDX + 1; // bool isBullish = false; bool isBearish = false; // XOHCL zBar; XOHCL cBar; XOHCL pBar; // // Initial Bars ... result = zBar.Init( cState.symbol, cState.period, barIndex // ); result = result && zBar.GetPreviousBar(cBar); result = result && cBar.GetPreviousBar(pBar); if (!result) { // zBar.Clean(); cBar.Clean(); pBar.Clean(); cState.Clean(); ZeroMemory(cHelper); cConditions.Clean(); cXConditions.Clean(); // return result; } // // Checking Bar Based on Positions State ... ENUM_X_DIRECTION iBarPosDir; bool isBarValidForDir = cHelper .mBarAnalyser .IsValidForPosition( cBar, iBarPosDir // ); bool isBarValidForBullish = isBarValidForDir && IsBullish(iBarPosDir); bool isBarValidForBearish = isBarValidForDir && IsBearish(iBarPosDir); // // Extract Selected Boxes ... XBoxZone selectedBox; XSignalBox iSignalBox; count = ArraySize(breakedBoxes); has = IsValidSize(count); if (has) { // for (int i = 0; i < count; i++) { // XSignalBox iBox = breakedBoxes[i]; // bool isBullish = iBox.ob.IsBullish(); // has = cBar.low < iBox.sharp.upper && cBar.low > iBox.sharp.lower && cBar.high > iBox.sharp.lower && cBar.high < iBox.sharp.upper; // // Force Using OB ... if (has) { // iSignalBox = iBox; if (!selectedBox.IsValid()) { selectedBox = iBox.ob; } iBox.Clean(); break; } // iBox.Clean(); } } result = iSignalBox.IsValid() && selectedBox.IsValid(); if (!result) { // zBar.Clean(); cBar.Clean(); pBar.Clean(); cState.Clean(); iSignalBox.Clean(); selectedBox.Clean(); ZeroMemory(cHelper); cConditions.Clean(); cXConditions.Clean(); // return result; } // bool hasSignalBox = iSignalBox.IsValid(); bool isSignalBoxBullish = IsBullish(iSignalBox.ob.dir); // // Checking Other Conditions ... // // XVWAP ... // bool isVWapSlopeBullish = cXConditions.isVwapFastSlopeBullish && cXConditions.isVwapMidSlopeBullish && cXConditions.isVwapSlowSlopeBullish; // bool isVWapSlopeBearish = cXConditions.isVwapFastSlopeBearish && cXConditions.isVwapMidSlopeBearish && cXConditions.isVwapSlowSlopeBearish; // bool isVWapBullishCondition = (cXConditions.isVWapBullishOrdered && cXConditions.isVWapSwitchedToBullishState) || (cXConditions.isVWapBullishState && cXConditions.isVWapSwitchedToBullishOrdered); // bool isVWapBearishCondition = (cXConditions.isVWapBearishOrdered && cXConditions.isVWapSwitchedToBearishState) || (cXConditions.isVWapBearishState && cXConditions.isVWapSwitchedToBearishOrdered); // // Bullish Conditions ... isBullish = // // Base Condition ... ( // hasSignalBox && isSignalBoxBullish && isVWapSlopeBullish && isBarValidForBullish && isVWapBullishCondition // ) // ; // // Bearish Conditions ... isBearish = // // Base Condition ... ( // hasSignalBox && isVWapSlopeBearish && !isSignalBoxBullish && isBarValidForBearish && isVWapBearishCondition // ) // ; // // Filling Requirements ... result = isBullish || isBearish; if (result) { // dir = isBullish ? X_DIRECTION_BULLISH : X_DIRECTION_BEARISH; // box = iSignalBox; box.UpdateTo(TimeCurrent()); // // Provide TP/SL ... // box.sl = isBullish ? cXConditions.vwapMin : cXConditions.vwapMax; // box.tp = isBullish ? box.sharp.upper : box.sharp.lower; } // // Check All Conditions ... result = box.IsValid() && HasDirection(dir) && (isBullish || isBearish); // // Cleanup Resources ... zBar.Clean(); cBar.Clean(); pBar.Clean(); cState.Clean(); iSignalBox.Clean(); selectedBox.Clean(); ZeroMemory(cHelper); cConditions.Clean(); cStateEvents.Clean(); cXConditions.Clean(); // return result; } // // XFVGMA ... bool HasXFVGMAConditions( ENUM_X_CYCLES cycle, XSignalBox &box, ENUM_X_DIRECTION &dir, XSignalBox &waitingBoxes[], X121SMCStrategySignalProviderData &provider, int barIndex = 0 // ) { // bool result = false; // box.Clean(); dir = X_DIRECTION_NONE; // result = HasChild(waitingBoxes); 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; } Parse(cXConditions); // // Normalize Args ... // if (barIndex < 0) { barIndex = 0; } // int idx = -1; int count = 0; bool has = false; // int zIDX = barIndex; int cIDX = zIDX + 1; int pIDX = cIDX + 1; int ppIDX = pIDX + 1; // bool isBullish = false; bool isBearish = false; // XOHCL zBar; XOHCL cBar; XOHCL pBar; // // Initial Bars ... result = zBar.Init( cState.symbol, cState.period, barIndex // ); result = result && zBar.GetPreviousBar(cBar); result = result && cBar.GetPreviousBar(pBar); if (!result) { // zBar.Clean(); cBar.Clean(); pBar.Clean(); cState.Clean(); ZeroMemory(cHelper); cConditions.Clean(); cXConditions.Clean(); // return result; } // // Select Waiting Box ... XBoxZone selectedBox; XSignalBox selectedSignalBox; count = ArraySize(waitingBoxes); for (int i = 0; i < count; i++) { // XSignalBox iSBox = waitingBoxes[i]; bool isBullish = iSBox.ob.IsBullish(); // bool isInsidePassed = isBullish ? cBar.low < iSBox.ob.upper && cBar.low > iSBox.ob.lower : cBar.high > iSBox.ob.lower && cBar.high < iSBox.ob.upper; // bool isTypePassed = iSBox.sharp.type == "XSHPOBX"; // has = isTypePassed && isInsidePassed; if (has) { // selectedBox = iSBox.ob; selectedSignalBox = iSBox; break; } } result = selectedBox.IsValid() && selectedSignalBox.IsValid(); if (!result) { // zBar.Clean(); cBar.Clean(); pBar.Clean(); cState.Clean(); ZeroMemory(cHelper); cConditions.Clean(); selectedBox.Clean(); cXConditions.Clean(); selectedSignalBox.Clean(); // return result; } // bool isSignalBoxBullish = selectedBox.IsBullish(); // // Checking Other Conditions ... // // Checking Bar Based on Positions State ... ENUM_X_DIRECTION iBarPosDir; bool isBarValidForDir = cHelper .mBarAnalyser .IsValidForPosition( cBar, iBarPosDir // ); bool isBarValidForBullish = isBarValidForDir && IsBullish(iBarPosDir); bool isBarValidForBearish = isBarValidForDir && IsBearish(iBarPosDir); // // Bullish Conditions ... isBullish = // // Base Condition ... ( // isSignalBoxBullish && isBarValidForBullish // ) // ; // // Bearish Conditions ... isBearish = // // Base Condition ... ( // !isSignalBoxBullish && isBarValidForBearish // ) // ; // // Filling Requirements ... result = isBullish || isBearish; if (result) { // dir = isBullish ? X_DIRECTION_BULLISH : X_DIRECTION_BEARISH; // box = selectedSignalBox; box.ob.to = TimeCurrent(); } // // Check All Conditions ... result = box.IsValid() && HasDirection(dir) && (isBullish || isBearish); // // Cleanup Resources ... zBar.Clean(); cBar.Clean(); pBar.Clean(); cState.Clean(); selectedBox.Clean(); ZeroMemory(cHelper); cConditions.Clean(); cStateEvents.Clean(); cXConditions.Clean(); selectedSignalBox.Clean(); // return result; } // // XWPVZ ... bool HasXWPVZConditions( ENUM_X_CYCLES cycle, ENUM_X_CYCLES vCycle, XSignalBox &box, ENUM_X_DIRECTION &dir, X121SMCStrategySignalProviderData &provider, int barIndex = 0 // ) { // bool result = false; // box.Clean(); dir = X_DIRECTION_NONE; // // 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; } Parse(cXConditions); // // Fil Selected Data ... XPOIState vState; X121Conditions vXConditions; XPOIStateEvents vStateEvents; XC121SMCCycleHelper *vHelper; X121SMCCycleConditions vConditions; result = provider.SelectCycle( vCycle, vState, vStateEvents, vXConditions, vHelper, vConditions // ); if (!result) { // cState.Clean(); ZeroMemory(cHelper); cConditions.Clean(); cXConditions.Clean(); cStateEvents.Clean(); // vState.Clean(); ZeroMemory(vHelper); cConditions.Clean(); vXConditions.Clean(); vStateEvents.Clean(); // return result; } Parse(vXConditions); // // Normalize Args ... // if (barIndex < 0) { barIndex = 0; } // int idx = -1; int count = 0; bool has = false; // int zIDX = barIndex; int cIDX = zIDX + 1; int pIDX = cIDX + 1; int ppIDX = pIDX + 1; // bool isBullish = false; bool isBearish = false; // XOHCL zBar; XOHCL cBar; XOHCL pBar; XOHCL pPBar; // // Initial Bars ... result = zBar.Init( cState.symbol, cState.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(); cState.Clean(); ZeroMemory(cHelper); cConditions.Clean(); cXConditions.Clean(); // return result; } // XCPOIDrawer *drawer = provider.visionCycleHelper.mPOIDrawer; // // Checking Other Conditions ... // // Checking Bar Based on Positions State ... ENUM_X_DIRECTION iBarPosDir; bool isBarValidForDir = cHelper .mBarAnalyser .IsValidForPosition( cBar, iBarPosDir // ); bool isBarValidForBullish = isBarValidForDir && IsBullish(iBarPosDir); bool isBarValidForBearish = isBarValidForDir && IsBearish(iBarPosDir); // // Senkou Span A/B Rejections ... // bool forceType = false; bool forcePressure = true; // bool isBullishRejectSenkouAB = cBar.IsRejected( cXConditions.senkouMax, X_DIRECTION_BULLISH, forceType, // Force Type ... forcePressure // Force Pressure ... ); // bool isBearishRejectSenkouAB = cBar.IsRejected( cXConditions.senkouMin, X_DIRECTION_BEARISH, forceType, // Force Type ... forcePressure // Force Pressure ... ); // // TenkanSen/KijunSen Rejections ... // bool isBullishRejectTenKij = cBar.IsRejected( cXConditions.tenKijMax, X_DIRECTION_BULLISH, forceType, // Force Type ... forcePressure // Force Pressure ... ); // bool isBearishRejectTenKij = cBar.IsRejected( cXConditions.tenKijMin, X_DIRECTION_BEARISH, forceType, // Force Type ... forcePressure // Force Pressure ... ); // // X3MaFast Rejections ... // bool isBullishRejectedFastMa = cBar.IsRejected( cXConditions.x3maFastBuffer[cIDX], X_DIRECTION_BULLISH, forceType, // Force Type ... forcePressure // Force Pressure ... ); // bool isBearishRejectedFastMa = cBar.IsRejected( cXConditions.x3maFastBuffer[cIDX], X_DIRECTION_BEARISH, forceType, // Force Type ... forcePressure // Force Pressure ... ); // bool isValidBullishRejectedFastMa = isBullishRejectedFastMa && cBar.low > cXConditions.senkouMax; // bool isValidBearishRejectedFastMa = isBearishRejectedFastMa && cBar.high < cXConditions.senkouMin; // // Bigger Cycle Verification ... // double vBullishScore = 0; double vBearishScore = 0; vXConditions.GenerateScore( vBullishScore, vBearishScore // ); // bool isVBUllishPassed = cBar.low > vXConditions.senkouMax && vBullishScore > (vBearishScore * 1.5); // bool isVBearishPassed = cBar.high < vXConditions.senkouMin && vBearishScore > (vBullishScore * 1.5); // // ichimokou ... // // Bullish Conditions ... isBullish = // isVBUllishPassed && isBullishRejectSenkouAB // ; // // Bearish Conditions ... isBearish = // isVBearishPassed && isBearishRejectSenkouAB // ; // result = isBullish || isBearish; if (result) { // dir = isBullish ? X_DIRECTION_BULLISH : X_DIRECTION_BEARISH; } // // Detecting a Zone and Validate it ... // XBoxZone tmpBoxes[]; // XBoxZone obBox; XBoxZone fvgBox; XBoxZone supResBox; bool hasOB = false; bool hasFVG = false; bool hasSupRes = false; // // Select Support and Resistance ... if (result) { // if (!hasSupRes) { // cState.OrderBlocksAsBox(tmpBoxes); cState.FairValueGapsAsBox(tmpBoxes); cState.SupplyDemandsAsBox(tmpBoxes); cState.SupportResistancesAsBox(tmpBoxes); // has = HasChild(tmpBoxes); if (has) { // while (HasChild(tmpBoxes)) { // idx = GetOldest(tmpBoxes); has = IsValidIndex(idx); if (!has) { break; } // XBoxZone iBox = tmpBoxes[idx]; ArrayRemove( tmpBoxes, idx, 1 // ); iBox.to = TimeCurrent(); // // Try to Validate Support and Resistance ... int retests = CountBoxRetest( iBox, dir, cBar.period // ); bool isTyped = isBullish ? iBox.IsBullish() : iBox.IsBearish(); bool isRetested = retests >= 1; bool isPlaced = isBullish ? ( // (cBar.low < iBox.upper && cBar.low > iBox.lower) // ) : ( // (cBar.high < iBox.upper && cBar.high > iBox.lower) // ); // has = isTyped && isPlaced && isRetested; if (has) { // supResBox = iBox; iBox.Clean(); break; } // iBox.Clean(); } } // hasSupRes = supResBox.IsValid(); Clean(tmpBoxes); } } // Clean(tmpBoxes); // // Bullish Conditions ... isBullish = // isBullish && hasSupRes // ; // // Bearish Conditions ... isBearish = // isBearish && hasSupRes // ; // // Filling Requirements ... result = isBullish || isBearish; if (result) { // bool drawBoxes = true; if (drawBoxes) { // if (hasSupRes) { // supResBox.to = TimeCurrent(); // XCBoxObject *iObj; has = drawer.DrawBox( supResBox, iObj // ); // if (has) { iObj.BoxWidth(2); iObj.BoxStyle(STYLE_DOT); } } } // Print("Signal ..."); result = false; isBearish = false; isBullish = false; } // // Check All Conditions ... result = box.IsValid() && HasDirection(dir) && (isBullish || isBearish); // // Cleanup Resources ... zBar.Clean(); cBar.Clean(); pBar.Clean(); pPBar.Clean(); cState.Clean(); vState.Clean(); cConditions.Clean(); cConditions.Clean(); ZeroMemory(cHelper); ZeroMemory(vHelper); cStateEvents.Clean(); cXConditions.Clean(); vXConditions.Clean(); vStateEvents.Clean(); // return result; } // bool HasXICHConditions( ENUM_X_CYCLES cycle, XBoxZone &box, ENUM_X_DIRECTION &dir, X121SMCStrategySignalProviderData &provider, int barIndex = 0 // ) { // bool result = false; // box.Clean(); dir = X_DIRECTION_NONE; // // 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; } Parse(cXConditions); // // Normalize Args ... // if (barIndex < 0) { barIndex = 0; } // int idx = -1; int count = 0; bool has = false; // int zIDX = barIndex; int cIDX = zIDX + 1; int pIDX = cIDX + 1; int ppIDX = pIDX + 1; // bool isBullish = false; bool isBearish = false; // XOHCL zBar; XOHCL cBar; XOHCL pBar; XOHCL pPBar; // // Initial Bars ... result = zBar.Init( cState.symbol, cState.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(); cState.Clean(); ZeroMemory(cHelper); cConditions.Clean(); cXConditions.Clean(); // return result; } // // Checking Conditions ... // // XDELTA ... // bool isDeltaSwitchedToBullish = (cXConditions.isDeltaCrossedOverMa && cXConditions.isDeltaSwitchedToBullish); bool isDeltaBullish = (cXConditions.isDeltaOverMa && cXConditions.isDeltaBullish); bool isDeltaIsBullish = isDeltaBullish || isDeltaSwitchedToBullish; // bool isDeltaSwitchedToBearish = (cXConditions.isDeltaCrossedUnderMa && cXConditions.isDeltaSwitchedToBearish); bool isDeltaBearish = (cXConditions.isDeltaUnderMa && cXConditions.isDeltaBearish); bool isDeltaIsBearish = isDeltaBearish || isDeltaSwitchedToBearish; // // XVOLUME ... // bool isVolumeSwitchedToBullish = (cXConditions.isVolumeSwitchedToBullish && cXConditions.isBullishVolumeSwitchedToIncreased); bool isVolumeBullish = (cXConditions.isBullishVolumeIncreased && cXConditions.isBullishVolumeMaOverBearishVolumeMa); bool isVolumeIsBullish = isVolumeBullish || isVolumeSwitchedToBullish; // bool isVolumeSwitchedToBearish = (cXConditions.isVolumeSwitchedToBearish && cXConditions.isBearishVolumeSwitchedToIncreased); bool isVolumeBearish = (cXConditions.isBullishVolumeMaUnderBearishVolumeMa && cXConditions.isBearishVolumeIncreased); bool isVolumeIsBearish = isVolumeBearish || isVolumeSwitchedToBearish; // // XSTR ... bool isStrIsBullish = (cXConditions.isStrBullish || cXConditions.isStrSwitchedToBullish); bool isStrIsBearish = (cXConditions.isStrBearish || cXConditions.isStrSwitchedToBearish); // // XICH ... bool isIchIsBullish = (cXConditions.isTenkanSenOverKijunSen || cXConditions.isTenkanSenCrossedOverKijunSen); bool isIchIsBearish = (cXConditions.isTenkanSenUnderKijunSen || cXConditions.isTenkanSenCrossedUnderKijunSen); // // Checking TK Zone ... // bool isBullishTKZone = isIchIsBullish && cBar.low < cXConditions.tenkanSenBuffer[cIndex] && cBar.low > cXConditions.kijunSenBuffer[cIndex] && cBar.low < pBar.low && zBar.open > cBar.low; // bool isBearishTKZone = isIchIsBearish && cBar.high > cXConditions.tenkanSenBuffer[cIndex] && cBar.high < cXConditions.kijunSenBuffer[cIndex] && cBar.high > pBar.high && zBar.open < cBar.high; // // Summarize Conditions ... // isBullish = // // false isStrIsBullish && isIchIsBullish && isBullishTKZone && isDeltaIsBullish && isVolumeIsBullish // // ; // isBearish = // // false isStrIsBearish && isIchIsBearish && isBearishTKZone && isDeltaIsBearish && isVolumeIsBearish // ; // // Filling Requirements ... result = isBullish || isBearish; if (result) { // dir = isBullish ? X_DIRECTION_BULLISH : X_DIRECTION_BEARISH; // box.dir = dir; box.from = pPBar.time; box.to = TimeCurrent(); box.symbol = cBar.symbol; box.period = cBar.period; // pivot = isBullish ? cBar.low - (points * 5) : cBar.high + (points * 5); // point = GetEntry( cBar.symbol, signalBoxDir // ); // box.upper = isBullish ? point : pivot; // box.lower = isBullish ? pivot : point; // bool drawBoxes = true; if (drawBoxes) { // } // Print("Signal ..."); result = false; isBearish = false; isBullish = false; } // // Check All Conditions ... result = box.IsValid() && HasDirection(dir) && (isBullish || isBearish); // // Cleanup Resources ... zBar.Clean(); cBar.Clean(); pBar.Clean(); pPBar.Clean(); cState.Clean(); cConditions.Clean(); cConditions.Clean(); ZeroMemory(cHelper); cStateEvents.Clean(); cXConditions.Clean(); // return result; } // };