diff --git a/Classes/x-saherelm.x121.xtrade.handler.class.mq5 b/Classes/x-saherelm.x121.xtrade.handler.class.mq5 index 0e8eac25..f119171b 100644 --- a/Classes/x-saherelm.x121.xtrade.handler.class.mq5 +++ b/Classes/x-saherelm.x121.xtrade.handler.class.mq5 @@ -2251,6 +2251,9 @@ class X121SCTradeHandler : public XSCBaseAlert { return; } + + // + return; } // diff --git a/Strategies/x-saherelm.xch.ichwap.strategy.mq5 b/Strategies/x-saherelm.xch.ichwap.strategy.mq5 new file mode 100644 index 00000000..b9287a7a --- /dev/null +++ b/Strategies/x-saherelm.xch.ichwap.strategy.mq5 @@ -0,0 +1,1160 @@ +/////////////////////////////////////////////////////// +// +// SaherElm IT Center MQL5 Class Library +// -------------------------------------- +// Name: XSCXCHICHWAPStrategy +// 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 "./x-saherelm.xch.strategy.mq5" + +// +// Definitions ... + +// +// Specific Identifier(s) of XStrategy ... +string XCHICHWAPStartegyToken = "XCHICHWAP"; + +// +// XStrategy Class Implementation(s) ... +class XSCXCHICHWAPStrategy : public XSCBaseStrategy +{ + // + // Public ... +public: + // + // Constructor(s) ... + void XSCXCHICHWAPStrategy( + // + // Base ... + string _symbol, // Trading Symbol + ENUM_TIMEFRAMES _period, // Trading TimeFrame + ENUM_TIMEFRAMES _analizePeriod, // Important Area Detect Time Frame + double _volume, // Voluem + double _r2r, // Risk/Reward Ratio + int _slippage, // Trader Slippage + long _magicNumber, // Trader Magic Number + bool _ignoreSignalExecution = false, // Ignore Signal Execution + bool _useTPSLAsPoint = false, // Converts TP and SL by Provided Points + bool _forceMaxTPSLAsPoint = false, // Force Max TP and SL by Provided Points + double _tpPoint = 0, // TP As Point + double _slPoint = 0, // SL As Point + bool _ignoreTP = false, // TP set to 0 + bool _ignoreSL = false, // SL set to 0 + bool _allowLong = true, + bool _allowShort = true, + int _maxAllowedLongs = 0, + int _maxAllowedShorts = 0 // + ) : XSCBaseStrategy(_symbol, + _period, + _analizePeriod, + _volume, + _r2r, + _slippage, + _magicNumber, + _ignoreSignalExecution, + _useTPSLAsPoint, + _forceMaxTPSLAsPoint, + _tpPoint, + _slPoint, + _ignoreTP, + _ignoreSL, + _allowLong, + _allowShort, + _maxAllowedLongs, + _maxAllowedShorts // + ) + { + // + SetAlertPrefix(GetTag()); + + // + PrepareRequirements(); + } + + // + // Deconstructor ... + void ~XSCXCHICHWAPStrategy() + { + // + delete pvHelper; + + // + delete chmHelper; + delete chhkHelper; + delete chstrHelper; + delete chcheHelper; + } + + // + // Getter / Setter (s) ... + + // + // Event Handlers ... + + // + // On Signal Handlers ... + void AddXCHSignalEventHandler(TOnXCHSignal handler) + { + // + Add( + handler, + mOnXCHSignalEventHandlers // + ); + } + + // + // Overrides ... + + // + // Customize Strategy Identifier ... + string GetTag() override + { + return XCHICHWAPStartegyToken; + } + + // + // Check Conditions For Signal ... + bool HasSignal( + XSignal &signal // + ) override + { + // + bool result = false; + + // + signal.Clean(); + + // + double sl = 0; + double tp = 0; + double risk = 0; + double entry = 0; + double reward = 0; + double r2r = R2R(); + ENUM_POSITION_TYPE type = POSITION_TYPE_BUY; + ENUM_X_ORDER_MODES mode = X_ORDER_MODE_MARKET; + + // + bool hasLong = false; + bool hasShort = false; + + // + // Retrieve Conditions ... + + // + // XPV ... + XPVConditions pvConditions; + result = pvHelper.GetConditions(pvConditions); + if (!result) + { + return result; + } + + // + // XCHM ... + XCHMConditions chmConditions; + result = chmHelper.GetConditions(chmConditions); + if (!result) + { + return result; + } + + // + // XCHHK ... + XCHHKConditions chhkConditions; + result = chhkHelper.GetConditions(chhkConditions); + if (!result) + { + return result; + } + + // + // XCHTD ... + XCHTDConditions chtdConditions; + result = chtdHelper.GetConditions(chtdConditions); + if (!result) + { + return result; + } + + // + // XCHSTR ... + XCHSTRConditions chstrConditions; + result = chstrHelper.GetConditions(chstrConditions); + if (!result) + { + return result; + } + + // + // XCHCHE ... + XCHCHEConditions chcheConditions; + result = chcheHelper.GetConditions(chcheConditions); + if (!result) + { + return result; + } + + // + // XCHVLM ... + XCHVLMConditions chvlmConditions; + result = chvlmHelper.GetConditions(chvlmConditions); + if (!result) + { + return result; + } + + // + // XCHICH ... + XCHICHConditions chichConditions; + result = chichHelper.GetConditions(chichConditions); + if (!result) + { + return result; + } + + // + // XCHVWAP ... + XCHVWAPConditions chvwapConditions; + result = chvwapHelper.GetConditions(chvwapConditions); + if (!result) + { + return result; + } + + // + // Start Calculations ... + + // + double points = GetPoints(mSymbol); + + // + int zIndex = 0; + int cIndex = zIndex + 1; + int pIndex = cIndex + 1; + int ppIndex = pIndex + 1; + + // + // Retrieve Bars ... + + // + // Last Bar ... + XOHCL cBar; + result = cBar.Init( + mSymbol, + mPeriod, + cIndex // + ); + if (!result) + { + return result; + } + + // + // Prepare Conditions ... + + // + XCHStrategyConditions conditions; + + // + conditions.symbol = mSymbol; + conditions.period = mPeriod; + conditions.time = cBar.time; + + // + conditions.pvConditions = pvConditions; + conditions.chmConditions = chmConditions; + conditions.chhkConditions = chhkConditions; + conditions.chtdConditions = chtdConditions; + conditions.chstrConditions = chstrConditions; + conditions.chcheConditions = chcheConditions; + conditions.chvlmConditions = chvlmConditions; + conditions.chichConditions = chichConditions; + conditions.chvwapConditions = chvwapConditions; + + // + result = conditions.IsValid(); + if (!result) + { + return result; + } + + // + // Previous Bar of Last Bar ... + XOHCL pBar; + result = cBar.GetPreviousBar(pBar); + if (!result) + { + return result; + } + + // + // Last Swing Low Bar ... + XOHCL lastSwingLow; + result = cBar.FindLastSwingLow(lastSwingLow); + if (!result) + { + return result; + } + + // + // Last Swing High Bar ... + XOHCL lastSwingHigh; + result = cBar.FindLastSwingHigh(lastSwingHigh); + if (!result) + { + return result; + } + + // + int pushers = 0; + string signallers[]; + + // + // Common Conditions For Bullish and Bearish Powers ... + + // + // For Trend ... + XOHCL tmpHSW[]; + XOHCL tmpLSW[]; + + // + // Detect Bullish/Bearish Patterns and Trends ... + + // + // Bullish ... + bool hasBullishPower = cBar.HasBullishPower(); + bool hasBullishPattern = HasBullishPattern(cBar); + bool hasBullishPressure = cBar.HasBullishPressure(); + bool isBullishTrend = cBar.HasBullishTrend( + tmpHSW, + tmpLSW, + true // + ); + + // + // Bearish ... + bool hasBearishPower = cBar.HasBearishPower(); + bool hasBearishPattern = HasBearishPattern(cBar); + bool hasBearishPressure = cBar.HasBearishPressure(); + bool isBearishTrend = cBar.HasBearishTrend( + tmpHSW, + tmpLSW, + false // + ); + + // + bool notHaveBearishPower = (!chmConditions.hasBearishPower && + !chhkConditions.hasBearishPower && + !chtdConditions.hasBearishPower && + !chcheConditions.hasBearishPower && + !chstrConditions.hasBearishPower && + !chvlmConditions.hasBearishPower && + !chvwapConditions.hasBearishPower); + + // + bool notHaveBullishPower = (!chmConditions.hasBullishPower && + !chhkConditions.hasBullishPower && + !chtdConditions.hasBullishPower && + !chcheConditions.hasBullishPower && + !chstrConditions.hasBullishPower && + !chvlmConditions.hasBullishPower && + !chvwapConditions.hasBullishPower); + + // + bool isCHHKFullSwitchedToBullish = + chhkHelper.IsSwitchedToBullish(cIndex); + + // + bool isCHHKFullBullishAndSorted = + chhkHelper.IsBullishSorted(cIndex); + + // + bool isCHHKFullSwitchedToBearish = + chhkHelper.IsSwitchedToBearish(cIndex); + + // + bool isCHHKFullBearishAndSorted = + chhkHelper.IsBearishSorted(cIndex); + + // + bool isBearishPowerDecreasing = + // + conditions.chhkConditions.isBearishPowerDecreasing && + conditions.chcheConditions.isBearishPowerDecreasing + // + ; + + // + bool isBullishPowerDecreasing = + // + conditions.chhkConditions.isBullishPowerDecreasing && + conditions.chcheConditions.isBullishPowerDecreasing + // + ; + + // + bool hasBearishDecision = + // + cBar.IsBearishDecision() + // + || + // + pBar.IsBearishDecision() + // + ; + + // + bool hasBullishDecision = + // + cBar.IsBullishDecision() + // + || + // + pBar.IsBullishDecision() + // + ; + + // + double long1SL = + (cBar.IsBullishDecision() + ? cBar.low + : pBar.low) - + (10 * points); + + // + double short1SL = + (cBar.IsBearishDecision() + ? cBar.high + : pBar.high) - + (10 * points); + + // + // Detecting Signals ... + + // + // First Conditions ... + + // + bool hasLong1 = + // + isBullishTrend && + (hasBullishPower || + hasBullishPattern || + hasBullishPressure) && + hasBullishDecision && + notHaveBearishPower && + isCHHKFullSwitchedToBullish + // + ; + if (hasLong1) + { + // + pushers++; + Add( + "XCHHKE1", + signallers // + ); + + // + sl = long1SL; + type = POSITION_TYPE_BUY; + } + + // + bool hasShort1 = + // + isBearishTrend && + (hasBearishPower || + hasBearishPattern || + hasBearishPressure) && + hasBearishDecision && + notHaveBullishPower && + isCHHKFullSwitchedToBearish + // + ; + if (hasShort1) + { + // + pushers++; + Add( + "XCHHKE1", + signallers // + ); + + // + sl = short1SL; + type = POSITION_TYPE_SELL; + } + + // + // Second Condition ... + + // + bool hasLong2 = + // + isBullishTrend && + (hasBullishPower || + hasBullishPattern || + hasBullishPressure) && + hasBullishDecision && + notHaveBearishPower && + isCHHKFullBullishAndSorted + // + ; + if (hasLong2) + { + // + pushers++; + Add( + "XCHHKE2", + signallers // + ); + + // + sl = long1SL; + type = POSITION_TYPE_BUY; + } + + // + bool hasShort2 = + // + isBearishTrend && + (hasBearishPower || + hasBearishPattern || + hasBearishPressure) && + hasBearishDecision && + notHaveBullishPower && + isCHHKFullBearishAndSorted + // + ; + if (hasShort2) + { + // + pushers++; + Add( + "XCHHKE2", + signallers // + ); + + // + sl = short1SL; + type = POSITION_TYPE_SELL; + } + + // + hasLong = + // + hasLong1 + // + || + // + hasLong2 + // + ; + + // + hasShort = + // + hasShort1 + // + || + // + hasShort2 + // + ; + + // + result = hasLong || hasShort; + if (!result) + { + // + CheckImportantAreasValidation(); + + // + return result; + } + + // + DestroyImportantAreas(); + + // + // Retrieve Entry Price based on Position Type ... + entry = GetEntry(mSymbol, type); + + // + // Calculate TP and SL ... + // based on Strategy ... + // only when on of TP or SL Provides, using provided R2R ... + if ((tp <= 0 && sl > 0) || (tp > 0 && sl <= 0)) + { + // + CalculateTPSLByPrice( + sl, + tp, + type, + entry, + r2r // + ); + } + + // + // Prepare Signal ... + result = signal.Prepare( + mSymbol, + signallers[0], + mPeriod, + type, + mode, + entry, + mVolume, + sl, + tp // + ); + if (!result) + { + return result; + } + + // + signal.pushers = pushers; + + // + // Prepare and Normalize Signal for Execution in Strategy ... + result = PrepareSignal(signal); + if (!result) + { + return result; + } + + // + // Attach Strategy Lebel ... + signal.provider = XCHICHWAPStartegyToken; + + // + // Notify XCH Specified Signal Event Handlers ... + NotifyOnXCHSignalEventHandlers( + signal, + conditions // + ); + + // + // Since we Ignore Signal Execution in this Strategy ... + // Make it the result false here for Preventing Double Execution ... + result = false; + + // + return result; + } + + // + // Protected ... +protected: + // + // Props ... + + // + // XPV ... + XPVInputs pvInputs; + XSCXPVHelper *pvHelper; + + // + // XCHMA ... + XCHMInputs chmInputs; + XSCXCHMHelper *chmHelper; + + // + // XCHHK ... + XCHHKInputs chhkInputs; + XSCXCHHKHelper *chhkHelper; + + // + // XCHTD ... + XCHTDInputs chtdInputs; + XSCXCHTDHelper *chtdHelper; + + // + // XSTR ... + XCHSTRInputs chstrInputs; + XSCXCHSTRHelper *chstrHelper; + + // + // XCHICHWAP ... + XCHCHEInputs chcheInputs; + XSCXCHCHEHelper *chcheHelper; + + // + // XCHVLM ... + XCHVLMInputs chvlmInputs; + XSCXCHVLMHelper *chvlmHelper; + + // + // XCHICH ... + XCHICHInputs chichInputs; + XSCXCHICHHelper *chichHelper; + + // + // XCHVWAP ... + XCHVWAPInputs chvwapInputs; + XSCXCHVWAPHelper *chvwapHelper; + + // + + // + // Private ... +private: + // + // Props ... + + // + // On XCH Signal Recieved Event Handler(s) ... + TOnXCHSignal mOnXCHSignalEventHandlers[]; + + // + // Notified Signal Event Handler(s) ... + void NotifyOnXCHSignalEventHandlers( + XSignal &signal, + XCHStrategyConditions &conditions // + ) + { + // + if (!signal.IsValid() || !conditions.IsValid()) + { + return; + } + + // + int count = ArraySize(mOnXCHSignalEventHandlers); + if (!IsValidSize(count)) + { + return; + } + + // + for (int i = 0; i < count; i++) + { + // + mOnXCHSignalEventHandlers[i]( + signal, + conditions // + ); + } + } + + // + // Install all Helpers and Prepare all + // Configurations for required Indicators ... + void PrepareRequirements() + { + // + support.Clean(); + supportTime = NULL; + isSupportTested = false; + + // + resistance.Clean(); + resistanceTime = NULL; + isResistanceTested = false; + + // + // Short ... + ENUM_X_PERIOD_METHOD scMethod = X_PERIOD_AUTO; // X_PERIOD_MANUALLY; // How to Find Period + ENUM_TIMEFRAMES scPeriod = NULL; // PERIOD_M20; // Time Period + + // + // Medium ... + ENUM_X_PERIOD_METHOD mcMethod = X_PERIOD_AUTO; // X_PERIOD_MANUALLY; // How to Find Period + ENUM_TIMEFRAMES mcPeriod = NULL; // PERIOD_M30; // Time Period + + // + // Long ... + ENUM_X_PERIOD_METHOD lcMethod = X_PERIOD_AUTO; // X_PERIOD_MANUALLY; // How to Find Period + ENUM_TIMEFRAMES lcPeriod = NULL; // PERIOD_H1; // Time Period + + // + // Hind ... + ENUM_X_PERIOD_METHOD hcMethod = X_PERIOD_AUTO; // X_PERIOD_MANUALLY; // How to Find Period + ENUM_TIMEFRAMES hcPeriod = NULL; // PERIOD_H2; // Time Period + + // + // XPV ... + + // + pvInputs.Default(); + + // + pvInputs.scMethod = scMethod; + pvInputs.scPeriod = scPeriod; + pvInputs.mcMethod = mcMethod; + pvInputs.mcPeriod = mcPeriod; + pvInputs.lcMethod = lcMethod; + pvInputs.lcPeriod = lcPeriod; + pvInputs.hcMethod = hcMethod; + pvInputs.hcPeriod = hcPeriod; + + // + pvInputs.showPeaksAndVales = false; + pvInputs.showLevels = false; + pvInputs.showConsolidations = false; + pvInputs.showFibo1Levels = false; + pvInputs.showFibo2Levels = false; + pvInputs.showFibo3Levels = false; + pvInputs.showFibo4Levels = false; + pvInputs.showFibo5Levels = false; + + // + pvHelper = new XSCXPVHelper(); + pvHelper.Init( + mSymbol, + mPeriod, + pvInputs // + ); + + // + // XCHM ... + + // + chmInputs.Default(); + + // + chmInputs.scMethod = scMethod; + chmInputs.scPeriod = scPeriod; + chmInputs.mcMethod = mcMethod; + chmInputs.mcPeriod = mcPeriod; + chmInputs.lcMethod = lcMethod; + chmInputs.lcPeriod = lcPeriod; + chmInputs.hcMethod = hcMethod; + chmInputs.hcPeriod = hcPeriod; + + // + chmInputs.showFast = false; + chmInputs.showSlow = false; + + // + chmInputs.showAVG = false; + + // + chmInputs.showCurrent = false; + chmInputs.showShort = false; + chmInputs.showMedium = false; + chmInputs.showLong = false; + chmInputs.showHind = false; + + // + chmHelper = new XSCXCHMHelper(); + chmHelper.Init( + mSymbol, + mPeriod, + chmInputs // + ); + + // + // XCHHK ... + + // + chhkInputs.Default(); + + // + chhkInputs.scMethod = scMethod; + chhkInputs.scPeriod = scPeriod; + chhkInputs.mcMethod = mcMethod; + chhkInputs.mcPeriod = mcPeriod; + chhkInputs.lcMethod = lcMethod; + chhkInputs.lcPeriod = lcPeriod; + chhkInputs.hcMethod = hcMethod; + chhkInputs.hcPeriod = hcPeriod; + + // + chhkInputs.ignoreShadows = true; + + // + chhkInputs.showCurrent = false; + chhkInputs.showShort = false; + chhkInputs.showMedium = false; + chhkInputs.showLong = false; + chhkInputs.showHind = false; + + // + chhkHelper = new XSCXCHHKHelper(); + chhkHelper.Init( + mSymbol, + mPeriod, + chhkInputs // + ); + + // + // XCHTD ... + + // + chtdInputs.Default(); + + // + chtdInputs.scMethod = scMethod; + chtdInputs.scPeriod = scPeriod; + chtdInputs.mcMethod = mcMethod; + chtdInputs.mcPeriod = mcPeriod; + chtdInputs.lcMethod = lcMethod; + chtdInputs.lcPeriod = lcPeriod; + chtdInputs.hcMethod = hcMethod; + chtdInputs.hcPeriod = hcPeriod; + + // + chtdInputs.showCurrent = false; + chtdInputs.showShort = false; + chtdInputs.showMedium = false; + chtdInputs.showLong = false; + chtdInputs.showHind = false; + + // + chtdHelper = new XSCXCHTDHelper(); + chtdHelper.Init( + mSymbol, + mPeriod, + chtdInputs // + ); + + // + // XCHSTR ... + + // + chstrInputs.Default(); + + // + chstrInputs.scMethod = scMethod; + chstrInputs.scPeriod = scPeriod; + chstrInputs.mcMethod = mcMethod; + chstrInputs.mcPeriod = mcPeriod; + chstrInputs.lcMethod = lcMethod; + chstrInputs.lcPeriod = lcPeriod; + chstrInputs.hcMethod = hcMethod; + chstrInputs.hcPeriod = hcPeriod; + + // + chstrInputs.showCurrent = false; + chstrInputs.showShort = false; + chstrInputs.showMedium = false; + chstrInputs.showLong = false; + chstrInputs.showHind = false; + + // + chstrHelper = new XSCXCHSTRHelper(); + chstrHelper.Init( + mSymbol, + mPeriod, + chstrInputs // + ); + + // + // XCHICHWAP ... + + // + chcheInputs.Default(); + + // + chcheInputs.scMethod = scMethod; + chcheInputs.scPeriod = scPeriod; + chcheInputs.mcMethod = mcMethod; + chcheInputs.mcPeriod = mcPeriod; + chcheInputs.lcMethod = lcMethod; + chcheInputs.lcPeriod = lcPeriod; + chcheInputs.hcMethod = hcMethod; + chcheInputs.hcPeriod = hcPeriod; + + // + chcheInputs.showLE1 = false; + chcheInputs.showLE2 = false; + chcheInputs.showSE1 = false; + chcheInputs.showSE2 = false; + + // + chcheInputs.showCurrent = false; + chcheInputs.showShort = false; + chcheInputs.showMedium = false; + chcheInputs.showLong = false; + chcheInputs.showHind = false; + + // + chcheHelper = new XSCXCHCHEHelper(); + chcheHelper.Init( + mSymbol, + mPeriod, + chcheInputs // + ); + + // + // XCHVLM ... + + // + chvlmInputs.Default(); + + // + chvlmInputs.scMethod = scMethod; + chvlmInputs.scPeriod = scPeriod; + chvlmInputs.mcMethod = mcMethod; + chvlmInputs.mcPeriod = mcPeriod; + chvlmInputs.lcMethod = lcMethod; + chvlmInputs.lcPeriod = lcPeriod; + chvlmInputs.hcMethod = hcMethod; + chvlmInputs.hcPeriod = hcPeriod; + + // + chvlmInputs.showCurrent = true; + chvlmInputs.showShort = true; + chvlmInputs.showMedium = true; + chvlmInputs.showLong = true; + chvlmInputs.showHind = true; + + // + chvlmHelper = new XSCXCHVLMHelper(); + chvlmHelper.Init( + mSymbol, + mPeriod, + chvlmInputs // + ); + + // + // XCHICH ... + + // + chichInputs.Default(); + + // + chichInputs.scMethod = scMethod; + chichInputs.scPeriod = scPeriod; + chichInputs.mcMethod = mcMethod; + chichInputs.mcPeriod = mcPeriod; + chichInputs.lcMethod = lcMethod; + chichInputs.lcPeriod = lcPeriod; + chichInputs.hcMethod = hcMethod; + chichInputs.hcPeriod = hcPeriod; + + // + chichInputs.showTenkanSen = false; + chichInputs.showKijunSen = false; + chichInputs.showChikouSpan = false; + chichInputs.showSenkouSpanA = false; + chichInputs.showSenkouSpanB = false; + chichInputs.showKumo = false; + + // + chichInputs.showCurrent = false; + chichInputs.showShort = false; + chichInputs.showMedium = false; + chichInputs.showLong = false; + chichInputs.showHind = false; + + // + chichHelper = new XSCXCHICHHelper(); + chichHelper.Init( + mSymbol, + mPeriod, + chichInputs // + ); + + // + // XCHVWAP ... + + // + chvwapInputs.Default(); + + // + chvwapInputs.scMethod = scMethod; + chvwapInputs.scPeriod = scPeriod; + chvwapInputs.mcMethod = mcMethod; + chvwapInputs.mcPeriod = mcPeriod; + chvwapInputs.lcMethod = lcMethod; + chvwapInputs.lcPeriod = lcPeriod; + chvwapInputs.hcMethod = hcMethod; + chvwapInputs.hcPeriod = hcPeriod; + + // + chvwapInputs.showShort = false; + chvwapInputs.showMedium = false; + chvwapInputs.showLong = false; + chvwapInputs.showHind = false; + + // + chvwapHelper = new XSCXCHVWAPHelper(); + chvwapHelper.Init( + mSymbol, + mPeriod, + chvwapInputs // + ); + + // + } + + // + void FillConditionsImportantAreas(XCHStrategyConditions &conditions) + { + // + if (!conditions.IsValid()) + { + return; + } + + // + conditions.support = support; + conditions.resistance = resistance; + conditions.bullishOB = bullishOB; + conditions.bearishOB = bearishOB; + conditions.bullishFVG = bullishFVG; + conditions.bearishFVG = bearishFVG; + conditions.bullishTrend = bullishTrend; + conditions.bearishTrend = bearishTrend; + + // + conditions.bullishFVGUpper = bullishFVGUpper; + conditions.bullishFVGLower = bullishFVGLower; + conditions.bearishFVGUpper = bearishFVGUpper; + conditions.bearishFVGLower = bearishFVGLower; + + // + Copy( + bullishTrendSwingHighs, + conditions.bullishTrendSwingHighs, + true // + ); + + // + Copy( + bullishTrendSwingLows, + conditions.bullishTrendSwingLows, + true // + ); + + // + Copy( + bearishTrendSwingHighs, + conditions.bearishTrendSwingHighs, + true // + ); + + // + Copy( + bearishTrendSwingLows, + conditions.bearishTrendSwingLows, + true // + ); + } + + // +}; + +// \ No newline at end of file