From 09edc32c96b6f694c6fc95060f28e9ee337c1c58 Mon Sep 17 00:00:00 2001 From: Hadi Khazaee Asl Date: Sun, 29 Sep 2024 21:55:25 +0330 Subject: [PATCH] start implementing XCHICHWAP Strategy ... --- Experts/x-saherelm.xch.ichwap.ea.mq5 | 981 ++++++++++++++++++ Helpers/x-saherelm.xchvwap.helper.mq5 | 102 +- Parsers/x-saherelm.xch.ichwap.parser.mq5 | 695 +++++++++++++ Strategies/x-saherelm.xch.ichwap.strategy.mq5 | 261 +++-- 4 files changed, 1894 insertions(+), 145 deletions(-) create mode 100644 Experts/x-saherelm.xch.ichwap.ea.mq5 create mode 100644 Parsers/x-saherelm.xch.ichwap.parser.mq5 diff --git a/Experts/x-saherelm.xch.ichwap.ea.mq5 b/Experts/x-saherelm.xch.ichwap.ea.mq5 new file mode 100644 index 00000000..55f3a6e0 --- /dev/null +++ b/Experts/x-saherelm.xch.ichwap.ea.mq5 @@ -0,0 +1,981 @@ +/////////////////////////////////////////////////////// +// +// SaherElm IT Center XTest MQL5 Expert Advisor +// ------------------------------------------------- +// Name: XCHICHWAP +// Description: an Exper Advisor which used to +// XCH and XCHCHE Strategy to Analyse Market ... +// +// Maintainer: +// ------------ +// Hadi Khazaee Asl (hadi_khazaee_asl@yahoo.com) +// +//////////////////////////////////////////////////////x +// +// Global Properties ... +#property copyright "Copyright 2023, SaherElm IT Center" +#property link "https://saherelm.ir" +#property version "1.00" +#property description "SaherElm XCHICHWAP" +#property strict + +// +#define ShortName "XCHICHWAP" + +// +// Imports ... +#include "../Classes/x-saherelm.x121.xtrade.handler.class.mq5" +#include "../Helpers/x-saherelm.xcc.helper.mq5" +#include "../Helpers/x-saherelm.xct.helper.mq5" + +// +#include "../Parsers/x-saherelm.xch.ichwap.parser.mq5" +#include "../Strategies/x-saherelm.xch.ichwap.strategy.mq5" + +// +// Inputs ... + +// +// Common ... +input group "Common"; +input long eaMagicNumber = 78692110; // Magic Number +input int eaSlippage = 10; // Slippgae +input string eaLogSuffix = ""; // Log Suffix + +// +// Symbols ... +input group "Symbols"; +input bool eaMultiSymbol = false; // Use Multi Symbol +input bool eaUseMaxAllowedTradesPerSymbol = true; // Use Max Allowed Trades Per Symbol +input string eaSymbols = "EURUSDb,GBPUSDb,EURGBPb,USDJPYb,EURJPYb,USDCHFb,EURCHFb,AUDUSDb,EURAUDb,NZDUSDb,EURNZDb,USDCADb,EURCADb,XAUUSDb,XAGUSDb,BRENT,DowJones30"; // Trading Symbols + +// +// Risk Management ... +input group "Risk Management"; + +// +// Risk Management > Risk / Reward Calculation ... +input group "Risk/Reward"; +input bool eaIgnoreTP = false; // Ignore TP +input bool eaIgnoreSL = false; // Ignore SL +input double eaTPPoint = 200; // Static TP Point +input double eaSLPoint = 200; // Static SL Point + +// +// Risk Management > Volume Calculation ... +input group "Volume"; +input bool eaUseDynamicVolume = false; // Use Dynamic Volume +input double eaDynamicVolumeStep = 0.01; // Increase Volume Step +input double eaDynamicVolumeBalanceFactor = 200; // Balance Factor for Generate Dynamic Volume +input double eaVolume = 0.02; // Static Volume + +// +// Risk Management > Trade Management ... +input group "Trade Management"; +input bool eaAllowLong = true; // Allow Long Positions +input bool eaAllowShort = true; // Allow Short Positions +input int eaMaxAllowedLongs = 2; // Max Allowed Long Positions +input int eaMaxAllowedShorts = 2; // Max Allowed Short Positions +input double eaMaxDrawdownPercentForOpenTrades = 3; // Max Drawdown Percent for Open Trades + +// +// Protector ... +input group "Protector"; +input int eaDelayBarBetweenTwoSameSignal = 5; // Delay Bars Between Two Same Type Signal + +// +// Protector > Hedging Properties ... +input group "Hedging"; +input bool eaAllowHedge = false; // Allow Hedge Positions +input double eaHedgeMinVolumeStep = 0.01; // Minimum Volume Step For Hedge +input int eaMinimumOpenPositionsForHEHedge = 2; // Minimum Open Positions For HE Hedge +input double eaHedgeHEMinProfitPerVolumeStep = 1; // Minimum Required Profit For HE Hedge Per Volume Step +input double eaHedgeBEMinProfitPerVolumeStep = 0.5; // Minimum Required Profit For BE Hedge Per Volume Step + +// +// Protector > In Profit Positions Protecting ... +input group "In Profit Positions Protecting"; + +// +// Trail ... +input group "Trail"; +input bool eaAllowTrail = false; // Allow Trail Stop for Positions +input double eaTrailStartDistance = 35; // Specify Trail Start in Point +input double eaTrailStep = 10; // Trail Step in Point +input bool eaOnlyTrailUnprotected = true; // Only Trail Unprotected Positionss + +// +// Partial Close (In Profit) ... +input group "Partial Close"; +input double eaPartialCloseInProfitDistance = 0; // Specify Partial Close Profit in Point +input double eaPartialCloseInProfitVolume = 0; // Specify Partial Close in Profit Volume + +// +// Protector > In Drawdown Positions Protecting ... +input group "In Drawdown Positions Protecting"; + +// +// Protect ... +input group "Protect"; +input bool eaAllowProtect = false; // Allow Proptecting +input int eaProtectionDelay = 300; // Delay Between two Protection in Secconds +input bool eaProtectOnConditions = true; // Do Protection only when Conditions happens +input bool eaAllowDirectionProtct = false; // Allow also Directional Protect +input double eaProtectionStartDistance = 100; // Protection Start Drawdown in Profit +input double eaProtectionVolumeMultiplier = 1; // Protection Volume Multiplier + +// +// Partial Close (In Drawdown) ... +input group "Partial Close"; +input double eaPartialCloseInDrawdownDistance = 0; // Specify Partial Close Drawdown in Point +input double eaPartialCloseInDrawdownVolume = 0; // Specify Partial Close in Drawdown Volume + +// +// Alert ... +input group "Alert"; +input bool eAEnableAlerts = true; // Enable Alerts +input bool eALogAlerts = true; // Log Alerts +input bool eAMailAlerts = false; // Mail Alerts +input bool eAPushAlerts = false; // Push Alerts +input bool eATerminalAlerts = false; // Terminal Alerts + +// +// Time Report ... +input group "Reports"; +input bool eaAlertNewMonths = false; // Alert New Month +input bool eaAlertNewWeeks = false; // Alert New Weeks +input bool eaAlertNewDays = true; // Alert New Days +input bool eaAlertNewHours = false; // Alert New Hours +input bool eaAlertRawSignals = false; // Alert Raw Signals +input bool eaAlertStrongSignals = false; // Alert Strong Signals + +// +// Variables ... + +// +// Bar Style nad Time Instances ... +XSCXCTHelper *mCTHelper; +XSCXCCHelper *mCCHelper; + +// +// Registred Strategies ... +XSCBaseStrategy *strategies[]; + +// +// Trader Instance Class ... +XSCTrade *eaTrader; + +// +// Alert Class ... +XSCAlert *eaAlert; + +// +// Time Tracker ... +XTimeTracker eaTimeTracker; + +// +// Trade Handler Instance Class ... +X121SCTradeHandler *eaTradeHandler; + +// +string mTag = ""; + +// +double eaR2R = 1.5; +datetime lastSignalOn = NULL; +bool eaUseFixedTPSLPoints = true; +bool eaEnableLongs = eaAllowLong && eaMaxAllowedLongs >= 0; +bool eaEnableShorts = eaAllowShort && eaMaxAllowedShorts >= 0; + +// +// Event Handlers ... + +// +// Initialization ... +int OnInit() +{ + // + if (!ValidateInputs()) + { + return INIT_PARAMETERS_INCORRECT; + } + + // + if (!InitEA()) + { + return INIT_FAILED; + } + + // + mTag = + !IsValid(eaLogSuffix) + ? ShortName + : ShortName + "_" + eaLogSuffix; + + // + drawPrefix = mTag; + + // + // EventSetTimer(1); + // EventSetMillisecondTimer(100); + + // + // Alert Initialization ... + string msg = "Initialized Successfully ..."; + eaAlert.Alert(msg); + + // + // Init Succeed ... + return INIT_SUCCEEDED; +} + +// +// DeInitialization ... +void OnDeinit(const int reason) +{ + // + // REASON_PROGRAM 0 The EA has stopped working calling the ExpertRemove() function + // REASON_REMOVE 1 Program removed from a chart + // REASON_RECOMPILE 2 Program recompiled + // REASON_CHARTCHANGE 3 A symbol or a chart period is changed + // REASON_CHARTCLOSE 4 Chart closed + // REASON_PARAMETERS 5 Inputs changed by a user + // REASON_ACCOUNT 6 Another account has been activated or reconnection to the trade server has occurred due to changes in the account settings + // REASON_TEMPLATE 7 Another chart template applied + // REASON_INITFAILED 8 The OnInit() handler returned a non-zero value + // REASON_CLOSE 9 Terminal closed + + // + // Alert De Initialization Succeeded ... + string msg = "De Initialized Successfully ..."; + eaAlert.Alert(msg); + + // + // De Initialize XSampleEA Providers ... + delete mCTHelper; + delete mCCHelper; + + // + delete eaAlert; + delete eaTrader; + delete eaTradeHandler; + + // + Clean(strategies); +} + +// +// On Tick Handler ... +void OnTick() +{ + // + HandleTradeState(); + HandleTimeReport(); + HandleStrategiesOnTick(); +} + +// +// Handle On Trade Event ... +void OnTrade() +{ + eaTrader.HandleOnTrade(); +} + +// +// On Timer ... +void OnTimer() +{ + // + // HandleTradeState(); + // HandleTimeReport(); + // HandleStrategiesOnTick(); +} + +// +// Custom Functions ... + +// +// Validate Inputs ... +bool ValidateInputs() +{ + // + bool result = false; + + // + string errMessage = ""; + + // + bool isCommonValid = ( + // + eaSlippage > 0 && + eaMagicNumber > 0 + // + ); + if (!isCommonValid) + { + // + errMessage += "common configurations error;" + "\n"; + } + + // + bool isSymbolsValid = ( + // + eaMultiSymbol + ? IsValid(eaSymbols) + : true + // + ); + if (!isSymbolsValid) + { + // + errMessage += "symbols configurations error;" + "\n"; + } + + // + bool isRiskRewardValid = ( + // + (eaUseFixedTPSLPoints + ? eaTPPoint > 0 || + eaSLPoint > 0 + : eaR2R > 0) && + !(eaIgnoreTP && + eaIgnoreSL) + // + ); + if (!isRiskRewardValid) + { + // + errMessage += "risk/reward configurations error;" + "\n"; + } + + // + bool isVolumeValid = ( + // + eaUseDynamicVolume + ? eaDynamicVolumeStep >= 0.01 && + eaDynamicVolumeBalanceFactor > 0 + : eaVolume >= 0.01 + // + ); + if (!isVolumeValid) + { + // + errMessage += "volume configurations error;" + "\n"; + } + + // + bool isTradeManagementValid = ( + // + !(!eaAllowLong && !eaAllowShort) && + eaMaxAllowedLongs >= 0 && + eaMaxAllowedShorts >= 0 + // + ); + if (!isTradeManagementValid) + { + // + errMessage += "trade management configurations error;" + "\n"; + } + + // + result = + // + // Common ... + isCommonValid && + // + // Symbols ... + isSymbolsValid && + // + // Risk/Reward ... + isRiskRewardValid && + // + // Volume ... + isVolumeValid && + // + // Trade Management ... + isTradeManagementValid + // + ; + + // + if (!result) + { + Print("Errors: \n", errMessage); + } + + // + return result; +} + +// +// Initialize all Requirements ... +bool InitEA() +{ + // + bool result = false; + + // + // Bar Timer ... + XCTInputs ctInputs; + ctInputs.Default(); + mCTHelper = new XSCXCTHelper(); + result = mCTHelper.Init( + _Symbol, + _Period, + ctInputs // + ); + if (!result) + { + return result; + } + + // + // Bar Styles ... + XCCInputs ccInputs; + ccInputs.Default(); + mCCHelper = new XSCXCCHelper(); + result = mCCHelper.Init( + _Symbol, + _Period, + ccInputs // + ); + if (!result) + { + return result; + } + + // + // Create Instance of Alert Class ... + eaAlert = new XSCAlert(); + eaAlert.SetPrefix(mTag); + eaAlert.SetLogAlerts(eALogAlerts); + eaAlert.SetMailAlerts(eAMailAlerts); + eaAlert.SetPushAlerts(eAPushAlerts); + eaAlert.SetEnableAlerts(eAEnableAlerts); + eaAlert.SetTerminalAlerts(eATerminalAlerts); + + // + // Create Trader Instance ... + eaTrader = new XSCTrade( + eaSlippage, + eaMagicNumber // + ); + eaTrader.AddOnStopLossEventHandler(OnStopLossTriggered); + eaTrader.AddOnTakeProfitEventHandler(OnTakeProfitTriggered); + eaTrader.AddOnForceClosePositionEventHandler(OnPositionForceClosed); + + // + // Initialize Trade Handler ... + eaTradeHandler = new X121SCTradeHandler(eaTrader); + eaTradeHandler.SaveTrades(true); + eaTradeHandler.SaveSignals(true); + eaTradeHandler.SaveConditions(true); + + // + // Configure Alerts ... + eaTradeHandler.SetAlertPrefix(mTag); + eaTradeHandler.SetAlertEnableAlerts(eAEnableAlerts); + eaTradeHandler.SetAlertLogAlerts(eALogAlerts); + eaTradeHandler.SetAlertMailAlerts(eAMailAlerts); + eaTradeHandler.SetAlertPushAlerts(eAPushAlerts); + eaTradeHandler.SetAlertTerminalAlerts(eATerminalAlerts); + + // + // Configure Trade Management ... + eaTradeHandler.AllowLong(eaAllowLong); + eaTradeHandler.AllowShort(eaAllowShort); + eaTradeHandler.MaxAllowedLongs(eaMaxAllowedLongs); + eaTradeHandler.MaxAllowedShorts(eaMaxAllowedShorts); + eaTradeHandler.UseMaxAllowedTradesPerSymbol(eaUseMaxAllowedTradesPerSymbol); + eaTradeHandler.MaxDrawdownPercentForOpenTrades(eaMaxDrawdownPercentForOpenTrades); + + // + // Configure Position Protector ... + + // + eaTradeHandler.DelayBarBetweenTwoSameSignal(eaDelayBarBetweenTwoSameSignal); + + // + // Configure Hedging ... + eaTradeHandler.AllowHedge(eaAllowHedge); + eaTradeHandler.HedgeMinVolumeStep(eaHedgeMinVolumeStep); + eaTradeHandler.MinimumOpenPositionsForHEHedge(eaMinimumOpenPositionsForHEHedge); + eaTradeHandler.HedgeHEMinProfitPerVolumeStep(eaHedgeHEMinProfitPerVolumeStep); + eaTradeHandler.HedgeBEMinProfitPerVolumeStep(eaHedgeBEMinProfitPerVolumeStep); + + // + // In Profit Position Protecting ... + + // + // Trail ... + eaTradeHandler.AllowTrail(eaAllowTrail); + eaTradeHandler.TrailStartDistance(eaTrailStartDistance); + eaTradeHandler.TrailStep(eaTrailStep); + eaTradeHandler.OnlyTrailUnprotected(eaOnlyTrailUnprotected); + + // + // Partial Close (In Profit) ... + eaTradeHandler.PartialCloseInProfitDistance(eaPartialCloseInProfitDistance); + eaTradeHandler.PartialCloseInProfitVolume(eaPartialCloseInProfitVolume); + + // + // In Drawdown Positions Protecting ... + + // + // Protect ... + eaTradeHandler.AllowProtect(eaAllowProtect); + eaTradeHandler.ProtectionDelay(eaProtectionDelay); + eaTradeHandler.ProtectOnConditions(eaProtectOnConditions); + eaTradeHandler.AllowDirectionProtct(eaAllowDirectionProtct); + eaTradeHandler.ProtectionStartDistance(eaProtectionStartDistance); + eaTradeHandler.ProtectionVolumeMultiplier(eaProtectionVolumeMultiplier); + + // + // Partial Close (In Profit) ... + eaTradeHandler.PartialCloseInDrawdownDistance(eaPartialCloseInDrawdownDistance); + eaTradeHandler.PartialCloseInDrawdownVolume(eaPartialCloseInDrawdownVolume); + + // + // Configure Strategies ... + + // + // Single Symbol ... + if (!eaMultiSymbol) + { + // + // Register XCHICHWAP Strategy ... + + // + // Create Class Instance ... + XSCXCHICHWAPStrategy *xchichwapStrategy; + xchichwapStrategy = new XSCXCHICHWAPStrategy( + _Symbol, + _Period, + PERIOD_H1, // Analyzing Period + eaVolume, + eaR2R, // R2R ... + eaSlippage, + eaMagicNumber, + true, // Ignore Signal Execution + eaUseFixedTPSLPoints, // Use TP SL Point + false, // Use Max + eaTPPoint, // TP + eaSLPoint, // SL + eaIgnoreTP, + eaIgnoreSL, + eaAllowLong, + eaAllowShort, + eaMaxAllowedLongs, // Max Longs + eaMaxAllowedShorts // Max Shorts + ); + + // + // Configuere Strategy ... + xchichwapStrategy.DrawImportantAreas(false); + xchichwapStrategy.AddXCHSignalEventHandler(OnSignalRecieved); + + // + // Configure Alerts ... + xchichwapStrategy.SetAlertPrefix(mTag); + xchichwapStrategy.SetAlertEnableAlerts(eAEnableAlerts); + xchichwapStrategy.SetAlertLogAlerts(eALogAlerts); + xchichwapStrategy.SetAlertMailAlerts(eAMailAlerts); + xchichwapStrategy.SetAlertPushAlerts(eAPushAlerts); + xchichwapStrategy.SetAlertTerminalAlerts(eATerminalAlerts); + + // + // Register Strategy ... + RegisterStrategy(xchichwapStrategy); + } + // + // Multi Symbol ... + else + { + // + // Parse Symbols ... + string symbols[]; + int symbolsCount = SplitContent( + symbols, + eaSymbols // + ); + result = IsValidSize(symbolsCount); + if (!result) + { + return result; + } + + // + for (int i = 0; i < symbolsCount; i++) + { + // + // Select Symbol ... + string iSymbol = symbols[i]; + + // + // Register XCHICHWAP Strategy ... + + // + // Create Class Instance ... + XSCXCHICHWAPStrategy *iXCHICHWAPStrategy; + iXCHICHWAPStrategy = new XSCXCHICHWAPStrategy( + iSymbol, + _Period, + PERIOD_H1, // Analyzing Period + eaVolume, + eaR2R, // R2R ... + eaSlippage, + eaMagicNumber, + true, // Ignore Signal Execution + eaUseFixedTPSLPoints, // Use TP SL Point + false, // Use Max + eaTPPoint, // TP + eaSLPoint, // SL + eaIgnoreTP, + eaIgnoreSL, + eaAllowLong, + eaAllowShort, + eaMaxAllowedLongs, // Max Longs + eaMaxAllowedShorts // Max Shorts + ); + + // + // Configuere Strategy ... + iXCHICHWAPStrategy.DrawImportantAreas(false); + iXCHICHWAPStrategy.AddXCHSignalEventHandler(OnSignalRecieved); + + // + // Configure Alerts ... + iXCHICHWAPStrategy.SetAlertPrefix(mTag); + iXCHICHWAPStrategy.SetAlertEnableAlerts(eAEnableAlerts); + iXCHICHWAPStrategy.SetAlertLogAlerts(eALogAlerts); + iXCHICHWAPStrategy.SetAlertMailAlerts(eAMailAlerts); + iXCHICHWAPStrategy.SetAlertPushAlerts(eAPushAlerts); + iXCHICHWAPStrategy.SetAlertTerminalAlerts(eATerminalAlerts); + + // + // Register Strategy ... + RegisterStrategy(iXCHICHWAPStrategy); + } + } + + // + return result; +} + +// +// HANDLERS ... + +// +// Call All Registered Strategis Tick Handler Functions ... +void HandleStrategiesOnTick() +{ + // + int count = ArraySize(strategies); + if (!IsValidSize(count)) + { + return; + } + + // + for (int i = 0; i < count; i++) + { + // + // Call Tick Handler Function ... + strategies[i].HandleTick(); + } +} + +// +// Manage Trading States ... +void HandleTradeState() +{ + // + // Implement All Trade States here ... + eaTradeHandler.UpdateData(); + + // + // Do Protection Senarios ... + eaTradeHandler.HandleProtection(); +} + +// +// Time Reporting ... +void HandleTimeReport() +{ + // + // Monthly Report .... + if (eaAlertNewMonths && + eaTimeTracker.IsNewMonth()) + { + // + string msg = "New Month ..."; + + // + eaAlert.Alert(msg); + } + + // + // Weekly Report .... + if (eaAlertNewWeeks && + eaTimeTracker.IsNewWeek()) + { + // + string msg = "New Week ..."; + + // + eaAlert.Alert(msg); + } + + // + // Daily Report .... + if (eaAlertNewDays && + eaTimeTracker.IsNewDay()) + { + // + string msg = "New Day ..."; + + // + eaAlert.Alert(msg); + } + + // + // Hourly Report .... + if (eaAlertNewHours && + eaTimeTracker.IsNewHour()) + { + // + string msg = "New Hour ..."; + + // + eaAlert.Alert(msg); + } +} + +// +// Report Account Balance ... +void HandleReportBalance() +{ + // + if (!IsRunningOnTestMode()) + { + return; + } + + // + string msg = "Balance: " + ToString(eaTrader.mAccount.GetBalance()); + eaAlert.Log(msg); +} + +// +// SIGNAL EVENT Handlers ... + +// +// All Signals from Strategies Comming Here for Execution or +// Analyzing ... +void OnSignalRecieved( + XSignal &signal, + XCHStrategyConditions &conditions // +) +{ + // + // Check Signal and Conditions Validations ... + + // + if (!signal.IsValid()) + { + return; + } + + // + if (!conditions.IsValid()) + { + return; + } + + // + bool isLong = IsLong(signal.type); + + // + // Notify When a Raw (Unfiltered) Signal Recieved + // if it's Provided ... + if (eaAlertRawSignals) + { + // + string msg = "Raw " + (IsLong(signal.type) ? "Long" : "Short") + " Signal Recieved: (" + signal.provider + "," + signal.symbol + "," + ToString(signal.period) + ") ..."; + eaAlert.Alert(msg); + } + + // + // Prepare Signal Dynamic Volume + // if Provided ... + if (eaUseDynamicVolume && + eaDynamicVolumeStep > 0 && + eaDynamicVolumeBalanceFactor > 0) + { + // + double dVolume = eaTrader.GetDynamicVolume( + signal.symbol, + eaDynamicVolumeBalanceFactor, + eaDynamicVolumeStep // + ); + + // + if (dVolume > 0) + { + signal.volume = dVolume; + } + else + { + signal.volume = eaVolume; + } + + // + eaTradeHandler.UpdateSignal(signal); + } + else + { + signal.volume = eaVolume; + } + + // + // Chekc Signalling Enable or not ... + bool canContinue = + isLong + ? eaEnableLongs + : eaEnableShorts; + if (!canContinue) + { + return; + } + + // + // Since Signal Filtering done based on + // Strategy and it's not related to Public + // TradeHandler for Seperation of Concern issue, + // we do this here ... + XCHICHWAPStartegyConditionsParser chcichwapParser; + + // + bool isFiltered = chcichwapParser.IsFiltered( + signal, + conditions // + ); + if (isFiltered) + { + // + eaTradeHandler.RemoveSignal(signal); + return; + } + + // + // Attach Conditions Summary to Signal ... + string conditionsSummary = conditions.GenerateSummary( + false, + false, + true, + false // + ); + + // + signal.conditions = chcichwapParser.GenerateSignalConditions( + signal, + conditions // + ); + + // + // Check Signal Delay ... + datetime currentTime = TimeCurrent(); + int delay = eaDelayBarBetweenTwoSameSignal; + bool isDelayPassed = delay <= 0 + ? true + : !IsValid(lastSignalOn) + ? true + : MathAbs(TimeToSeconds(currentTime)) - MathAbs(TimeToSeconds(lastSignalOn)) >= ulong(delay * PeriodSeconds(_Period)); + if (!isDelayPassed) + { + return; + } + + // + // Execute Signal Using Trade Handler ... + ENUM_X_SIGNAL_EXECUTION_RESULT state; + bool isExecuted = eaTradeHandler.ExecuteSignal( + signal, + state // + ); + + // + if (isExecuted) + { + lastSignalOn = currentTime; + } +} + +// +// Handle StopLoss Triggered Positions ... +void OnStopLossTriggered(const XDeal &deal) +{ + // + // Finish ... + eaTradeHandler.Finish(deal); + + // + HandleReportBalance(); +} + +// +// Handle Take Profit Triggered Positions ... +void OnTakeProfitTriggered(const XDeal &deal) +{ + // + // Finish ... + eaTradeHandler.Finish(deal); + + // + HandleReportBalance(); +} + +// +// Handle Force Close a Position ... +void OnPositionForceClosed( + const ulong ticket, + const XPosition &position, + const string comment // +) +{ + // + // Finish ... + eaTradeHandler.Finish( + ticket, + position, + comment // + ); + + // + HandleReportBalance(); +} + +// +// HELPERS ... + +// +// Register Strategy ... +void RegisterStrategy(XSCBaseStrategy *strategy) +{ + // + if (strategy == NULL) + { + return; + } + + // + ArrayResize( + strategies, + ArraySize(strategies) + 1 // + ); + + // + strategies[ArraySize(strategies) - 1] = strategy; +} + +// \ No newline at end of file diff --git a/Helpers/x-saherelm.xchvwap.helper.mq5 b/Helpers/x-saherelm.xchvwap.helper.mq5 index d2b1e26c..dda8248a 100644 --- a/Helpers/x-saherelm.xchvwap.helper.mq5 +++ b/Helpers/x-saherelm.xchvwap.helper.mq5 @@ -578,13 +578,14 @@ class XSCXCHVWAPHelper : public XSCBaseHelper { // // Public ... -public: + public: // // Props ... // // Constructors ... - XSCXCHVWAPHelper() : XSCBaseHelper(_Symbol, _Period) + XSCXCHVWAPHelper() + : XSCBaseHelper(_Symbol, _Period) { } @@ -2236,6 +2237,99 @@ public: return result; } + // + // Check Order of VWaps ... + + // + // Only Check Orders of VWap Buffers + // not State of them ... + bool IsBullishOrder( + int barIndex // Bar Index + ) + { + // + bool result = false; + + // + double shortVWap = GetS(barIndex); + double mediumVWap = GetM(barIndex); + double longVWap = GetL(barIndex); + double hindVWap = GetH(barIndex); + + // + result = shortVWap > mediumVWap && + mediumVWap > longVWap && + longVWap > hindVWap; + + // + return result; + } + + bool IsSwitchedToBullishOrder( + int barIndex // Bar Index + ) + { + // + bool result = false; + + // + bool isCBullishOrder = IsBullishOrder(barIndex); + bool isPBullishOrder = IsBullishOrder(barIndex + 1); + + // + result = + isCBullishOrder && + !isPBullishOrder; + + // + return result; + } + + // + // Only Check Orders of VWap Buffers + // not State of them ... + bool IsBearishOrder( + int barIndex // Bar Index + ) + { + // + bool result = false; + + // + double shortVWap = GetS(barIndex); + double mediumVWap = GetM(barIndex); + double longVWap = GetL(barIndex); + double hindVWap = GetH(barIndex); + + // + result = shortVWap < mediumVWap && + mediumVWap < longVWap && + longVWap < hindVWap; + + // + return result; + } + + bool IsSwitchedToBearishOrder( + int barIndex // Bar Index + ) + { + // + bool result = false; + + // + bool isCBearishOrder = IsBearishOrder(barIndex); + bool isPBearishOrder = IsBearishOrder(barIndex + 1); + + // + result = + isCBearishOrder && + !isPBearishOrder; + + // + return result; + } + // // Conditions ... @@ -2482,10 +2576,10 @@ public: // // Protected ... -protected: + protected: // // Private ... -private: + private: // // Props ... XCHVWAPInputs mInputs; // Inputs ... diff --git a/Parsers/x-saherelm.xch.ichwap.parser.mq5 b/Parsers/x-saherelm.xch.ichwap.parser.mq5 new file mode 100644 index 00000000..582e42c9 --- /dev/null +++ b/Parsers/x-saherelm.xch.ichwap.parser.mq5 @@ -0,0 +1,695 @@ +/////////////////////////////////////////////////////// +// +// SaherElm IT Center MQL5 Strategy Parser Library +// ------------------------------------------------ +// Name: XCHICHWAPStartegyConditionsParser +// Description: provide all conditions parsing +// for XCH Strategy ... +// +// +// 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 "../Strategies/x-saherelm.xch.ichwap.strategy.mq5" + +// +// Conditions Parser ... +struct XCHICHWAPStartegyConditionsParser +{ + // + string _version; + + // + // Parsers ... + + // + XSCAccount _account; + XMarketParser _marketParser; + + // + // XCHCHEStartegyIngotConditionsParser _ingotParser; + // XCHCHEStartegyAlpariConditionsParser _alpariParser; + // XCHCHEStartegyErranteConditionsParser _erranteParser; + // XCHCHEStartegyAMarketsConditionsParser _amarketsParser; + // XCHCHEStartegyIFCMarketsConditionsParser _ifcmarketsParser; + // XCHCHEStartegyOtetMarketsConditionsParser _otetmarketsParser; + + // + string GenerateSignalConditions( + XSignal &signal, + XCHStrategyConditions &conditions // + ) + { + // + // Calculate Score ... + double bullishScore = 0; + double bearishScore = 0; + conditions.GenerateScore( + bullishScore, + bearishScore // + ); + + // + // Generate Signal Parser Structured Conditions ... + string result = + "(" + + "\n" + + "// Symbol: " + signal.symbol + "\n" + + "// ---------------" + "\n" + + "// Scores:" + "\n" + + "// ---------------" + "\n" + + "// Bullish: " + ToString(bullishScore) + "\n" + + "// Bearish: " + ToString(bearishScore) + "\n" + + "// ---------------" + "\n" + + "// Time: " + ToString(TimeCurrent()) + "\n" + + "// ---------------" + "\n" + + "//" + "\n" + + "// XPV ..." + "\n" + + "//" + "\n" + + // + // True(s) ... + (conditions.pvConditions.isNewPeak ? "conditions.pvConditions.isNewPeak &&" + "\n" : "") + + (conditions.pvConditions.isNewPeakOverLast ? "conditions.pvConditions.isNewPeakOverLast &&" + "\n" : "") + + (conditions.pvConditions.isNewPeakUnderLast ? "conditions.pvConditions.isNewPeakUnderLast &&" + "\n" : "") + + (conditions.pvConditions.isNewVale ? "conditions.pvConditions.isNewVale &&" + "\n" : "") + + (conditions.pvConditions.isNewValeOverLast ? "conditions.pvConditions.isNewValeOverLast &&" + "\n" : "") + + (conditions.pvConditions.isNewValeUnderLast ? "conditions.pvConditions.isNewValeUnderLast &&" + "\n" : "") + + (conditions.pvConditions.isFiboIncreased ? "conditions.pvConditions.isFiboIncreased &&" + "\n" : "") + + (conditions.pvConditions.isFiboDecreased ? "conditions.pvConditions.isFiboDecreased &&" + "\n" : "") + + (conditions.pvConditions.isFiboSectionChanged ? "conditions.pvConditions.isFiboSectionChanged &&" + "\n" : "") + + (conditions.pvConditions.isCloseOverFib1 ? "conditions.pvConditions.isCloseOverFib1 &&" + "\n" : "") + + (conditions.pvConditions.isCloseOverFib2 ? "conditions.pvConditions.isCloseOverFib2 &&" + "\n" : "") + + (conditions.pvConditions.isCloseOverFib3 ? "conditions.pvConditions.isCloseOverFib3 &&" + "\n" : "") + + (conditions.pvConditions.isCloseOverFib4 ? "conditions.pvConditions.isCloseOverFib4 &&" + "\n" : "") + + (conditions.pvConditions.isCloseOverFib5 ? "conditions.pvConditions.isCloseOverFib5 &&" + "\n" : "") + + (conditions.pvConditions.isCloseUnderFib1 ? "conditions.pvConditions.isCloseUnderFib1 &&" + "\n" : "") + + (conditions.pvConditions.isCloseUnderFib2 ? "conditions.pvConditions.isCloseUnderFib2 &&" + "\n" : "") + + (conditions.pvConditions.isCloseUnderFib3 ? "conditions.pvConditions.isCloseUnderFib3 &&" + "\n" : "") + + (conditions.pvConditions.isCloseUnderFib4 ? "conditions.pvConditions.isCloseUnderFib4 &&" + "\n" : "") + + (conditions.pvConditions.isCloseUnderFib5 ? "conditions.pvConditions.isCloseUnderFib5 &&" + "\n" : "") + + (conditions.pvConditions.isCloseCrossedOverFib1 ? "conditions.pvConditions.isCloseCrossedOverFib1 &&" + "\n" : "") + + (conditions.pvConditions.isCloseCrossedOverFib2 ? "conditions.pvConditions.isCloseCrossedOverFib2 &&" + "\n" : "") + + (conditions.pvConditions.isCloseCrossedOverFib3 ? "conditions.pvConditions.isCloseCrossedOverFib3 &&" + "\n" : "") + + (conditions.pvConditions.isCloseCrossedOverFib4 ? "conditions.pvConditions.isCloseCrossedOverFib4 &&" + "\n" : "") + + (conditions.pvConditions.isCloseCrossedOverFib5 ? "conditions.pvConditions.isCloseCrossedOverFib5 &&" + "\n" : "") + + (conditions.pvConditions.isCloseCrossedUnderFib1 ? "conditions.pvConditions.isCloseCrossedUnderFib1 &&" + "\n" : "") + + (conditions.pvConditions.isCloseCrossedUnderFib2 ? "conditions.pvConditions.isCloseCrossedUnderFib2 &&" + "\n" : "") + + (conditions.pvConditions.isCloseCrossedUnderFib3 ? "conditions.pvConditions.isCloseCrossedUnderFib3 &&" + "\n" : "") + + (conditions.pvConditions.isCloseCrossedUnderFib4 ? "conditions.pvConditions.isCloseCrossedUnderFib4 &&" + "\n" : "") + + (conditions.pvConditions.isCloseCrossedUnderFib5 ? "conditions.pvConditions.isCloseCrossedUnderFib5 &&" + "\n" : "") + + (conditions.pvConditions.isSCBullish ? "conditions.pvConditions.isSCBullish &&" + "\n" : "") + + (conditions.pvConditions.isSCHHBullish ? "conditions.pvConditions.isSCHHBullish &&" + "\n" : "") + + (conditions.pvConditions.isSCLLBullish ? "conditions.pvConditions.isSCLLBullish &&" + "\n" : "") + + (conditions.pvConditions.isSCSwitchedToBullish ? "conditions.pvConditions.isSCSwitchedToBullish &&" + "\n" : "") + + (conditions.pvConditions.isSCHHSwitchedToBullish ? "conditions.pvConditions.isSCHHSwitchedToBullish &&" + "\n" : "") + + (conditions.pvConditions.isSCLLSwitchedToBullish ? "conditions.pvConditions.isSCLLSwitchedToBullish &&" + "\n" : "") + + (conditions.pvConditions.isSCBearish ? "conditions.pvConditions.isSCBearish &&" + "\n" : "") + + (conditions.pvConditions.isSCHHBearish ? "conditions.pvConditions.isSCHHBearish &&" + "\n" : "") + + (conditions.pvConditions.isSCLLBearish ? "conditions.pvConditions.isSCLLBearish &&" + "\n" : "") + + (conditions.pvConditions.isSCSwitchedToBearish ? "conditions.pvConditions.isSCSwitchedToBearish &&" + "\n" : "") + + (conditions.pvConditions.isSCHHSwitchedToBearish ? "conditions.pvConditions.isSCHHSwitchedToBearish &&" + "\n" : "") + + (conditions.pvConditions.isSCLLSwitchedToBeraish ? "conditions.pvConditions.isSCLLSwitchedToBeraish &&" + "\n" : "") + + (conditions.pvConditions.isMCBullish ? "conditions.pvConditions.isMCBullish &&" + "\n" : "") + + (conditions.pvConditions.isMCHHBullish ? "conditions.pvConditions.isMCHHBullish &&" + "\n" : "") + + (conditions.pvConditions.isMCLLBullish ? "conditions.pvConditions.isMCLLBullish &&" + "\n" : "") + + (conditions.pvConditions.isMCSwitchedToBullish ? "conditions.pvConditions.isMCSwitchedToBullish &&" + "\n" : "") + + (conditions.pvConditions.isMCHHSwitchedToBullish ? "conditions.pvConditions.isMCHHSwitchedToBullish &&" + "\n" : "") + + (conditions.pvConditions.isMCLLSwitchedToBullish ? "conditions.pvConditions.isMCLLSwitchedToBullish &&" + "\n" : "") + + (conditions.pvConditions.isMCBearish ? "conditions.pvConditions.isMCBearish &&" + "\n" : "") + + (conditions.pvConditions.isMCHHBearish ? "conditions.pvConditions.isMCHHBearish &&" + "\n" : "") + + (conditions.pvConditions.isMCLLBearish ? "conditions.pvConditions.isMCLLBearish &&" + "\n" : "") + + (conditions.pvConditions.isMCSwitchedToBearish ? "conditions.pvConditions.isMCSwitchedToBearish &&" + "\n" : "") + + (conditions.pvConditions.isMCHHSwitchedToBearish ? "conditions.pvConditions.isMCHHSwitchedToBearish &&" + "\n" : "") + + (conditions.pvConditions.isMCLLSwitchedToBeraish ? "conditions.pvConditions.isMCLLSwitchedToBeraish &&" + "\n" : "") + + (conditions.pvConditions.isLCBullish ? "conditions.pvConditions.isLCBullish &&" + "\n" : "") + + (conditions.pvConditions.isLCHHBullish ? "conditions.pvConditions.isLCHHBullish &&" + "\n" : "") + + (conditions.pvConditions.isLCLLBullish ? "conditions.pvConditions.isLCLLBullish &&" + "\n" : "") + + (conditions.pvConditions.isLCSwitchedToBullish ? "conditions.pvConditions.isLCSwitchedToBullish &&" + "\n" : "") + + (conditions.pvConditions.isLCHHSwitchedToBullish ? "conditions.pvConditions.isLCHHSwitchedToBullish &&" + "\n" : "") + + (conditions.pvConditions.isLCLLSwitchedToBullish ? "conditions.pvConditions.isLCLLSwitchedToBullish &&" + "\n" : "") + + (conditions.pvConditions.isLCBearish ? "conditions.pvConditions.isLCBearish &&" + "\n" : "") + + (conditions.pvConditions.isLCHHBearish ? "conditions.pvConditions.isLCHHBearish &&" + "\n" : "") + + (conditions.pvConditions.isLCLLBearish ? "conditions.pvConditions.isLCLLBearish &&" + "\n" : "") + + (conditions.pvConditions.isLCSwitchedToBearish ? "conditions.pvConditions.isLCSwitchedToBearish &&" + "\n" : "") + + (conditions.pvConditions.isLCHHSwitchedToBearish ? "conditions.pvConditions.isLCHHSwitchedToBearish &&" + "\n" : "") + + (conditions.pvConditions.isLCLLSwitchedToBeraish ? "conditions.pvConditions.isLCLLSwitchedToBeraish &&" + "\n" : "") + + (conditions.pvConditions.isHCBullish ? "conditions.pvConditions.isHCBullish &&" + "\n" : "") + + (conditions.pvConditions.isHCHHBullish ? "conditions.pvConditions.isHCHHBullish &&" + "\n" : "") + + (conditions.pvConditions.isHCLLBullish ? "conditions.pvConditions.isHCLLBullish &&" + "\n" : "") + + (conditions.pvConditions.isHCSwitchedToBullish ? "conditions.pvConditions.isHCSwitchedToBullish &&" + "\n" : "") + + (conditions.pvConditions.isHCHHSwitchedToBullish ? "conditions.pvConditions.isHCHHSwitchedToBullish &&" + "\n" : "") + + (conditions.pvConditions.isHCLLSwitchedToBullish ? "conditions.pvConditions.isHCLLSwitchedToBullish &&" + "\n" : "") + + (conditions.pvConditions.isHCBearish ? "conditions.pvConditions.isHCBearish &&" + "\n" : "") + + (conditions.pvConditions.isHCHHBearish ? "conditions.pvConditions.isHCHHBearish &&" + "\n" : "") + + (conditions.pvConditions.isHCLLBearish ? "conditions.pvConditions.isHCLLBearish &&" + "\n" : "") + + (conditions.pvConditions.isHCSwitchedToBearish ? "conditions.pvConditions.isHCSwitchedToBearish &&" + "\n" : "") + + (conditions.pvConditions.isHCHHSwitchedToBearish ? "conditions.pvConditions.isHCHHSwitchedToBearish &&" + "\n" : "") + + (conditions.pvConditions.isHCLLSwitchedToBeraish ? "conditions.pvConditions.isHCLLSwitchedToBeraish &&" + "\n" : "") + + "//" + "\n" + + "// XCHM ..." + "\n" + + "//" + "\n" + + (conditions.chmConditions.hasBullishPower ? "conditions.chmConditions.hasBullishPower &&" + "\n" : "") + + (conditions.chmConditions.hasBearishPower ? "conditions.chmConditions.hasBearishPower &&" + "\n" : "") + + (conditions.chmConditions.isBullishPowerUp ? "conditions.chmConditions.isBullishPowerUp &&" + "\n" : "") + + (conditions.chmConditions.isBearishPowerUp ? "conditions.chmConditions.isBearishPowerUp &&" + "\n" : "") + + (conditions.chmConditions.isBullishPowerIncreasing ? "conditions.chmConditions.isBullishPowerIncreasing &&" + "\n" : "") + + (conditions.chmConditions.isBullishPowerDecreasing ? "conditions.chmConditions.isBullishPowerDecreasing &&" + "\n" : "") + + (conditions.chmConditions.isBearishPowerIncreasing ? "conditions.chmConditions.isBearishPowerIncreasing &&" + "\n" : "") + + (conditions.chmConditions.isBearishPowerDecreasing ? "conditions.chmConditions.isBearishPowerDecreasing &&" + "\n" : "") + + (conditions.chmConditions.isFastOverSlow ? "conditions.chmConditions.isFastOverSlow &&" + "\n" : "") + + (conditions.chmConditions.isFastUnderSlow ? "conditions.chmConditions.isFastUnderSlow &&" + "\n" : "") + + (conditions.chmConditions.isFastCrossedOverSlow ? "conditions.chmConditions.isFastCrossedOverSlow &&" + "\n" : "") + + (conditions.chmConditions.isFastCrossedUnderSlow ? "conditions.chmConditions.isFastCrossedUnderSlow &&" + "\n" : "") + + (conditions.chmConditions.isClosedOverFast ? "conditions.chmConditions.isClosedOverFast &&" + "\n" : "") + + (conditions.chmConditions.isClosedUnderFast ? "conditions.chmConditions.isClosedUnderFast &&" + "\n" : "") + + (conditions.chmConditions.isCFastOverSlow ? "conditions.chmConditions.isCFastOverSlow &&" + "\n" : "") + + (conditions.chmConditions.isCFastUnderSlow ? "conditions.chmConditions.isCFastUnderSlow &&" + "\n" : "") + + (conditions.chmConditions.isCFastCrossedOverSlow ? "conditions.chmConditions.isCFastCrossedOverSlow &&" + "\n" : "") + + (conditions.chmConditions.isCFastCrossedUnderSlow ? "conditions.chmConditions.isCFastCrossedUnderSlow &&" + "\n" : "") + + (conditions.chmConditions.isClosedOverCFast ? "conditions.chmConditions.isClosedOverCFast &&" + "\n" : "") + + (conditions.chmConditions.isClosedUnderCFast ? "conditions.chmConditions.isClosedUnderCFast &&" + "\n" : "") + + (conditions.chmConditions.isSFastOverSlow ? "conditions.chmConditions.isSFastOverSlow &&" + "\n" : "") + + (conditions.chmConditions.isSFastUnderSlow ? "conditions.chmConditions.isSFastUnderSlow &&" + "\n" : "") + + (conditions.chmConditions.isSFastCrossedOverSlow ? "conditions.chmConditions.isSFastCrossedOverSlow &&" + "\n" : "") + + (conditions.chmConditions.isSFastCrossedUnderSlow ? "conditions.chmConditions.isSFastCrossedUnderSlow &&" + "\n" : "") + + (conditions.chmConditions.isClosedOverSFast ? "conditions.chmConditions.isClosedOverSFast &&" + "\n" : "") + + (conditions.chmConditions.isClosedUnderSFast ? "conditions.chmConditions.isClosedUnderSFast &&" + "\n" : "") + + (conditions.chmConditions.isMFastOverSlow ? "conditions.chmConditions.isMFastOverSlow &&" + "\n" : "") + + (conditions.chmConditions.isMFastUnderSlow ? "conditions.chmConditions.isMFastUnderSlow &&" + "\n" : "") + + (conditions.chmConditions.isMFastCrossedOverSlow ? "conditions.chmConditions.isMFastCrossedOverSlow &&" + "\n" : "") + + (conditions.chmConditions.isMFastCrossedUnderSlow ? "conditions.chmConditions.isMFastCrossedUnderSlow &&" + "\n" : "") + + (conditions.chmConditions.isClosedOverMFast ? "conditions.chmConditions.isClosedOverMFast &&" + "\n" : "") + + (conditions.chmConditions.isClosedUnderMFast ? "conditions.chmConditions.isClosedUnderMFast &&" + "\n" : "") + + (conditions.chmConditions.isLFastOverSlow ? "conditions.chmConditions.isLFastOverSlow &&" + "\n" : "") + + (conditions.chmConditions.isLFastUnderSlow ? "conditions.chmConditions.isLFastUnderSlow &&" + "\n" : "") + + (conditions.chmConditions.isLFastCrossedOverSlow ? "conditions.chmConditions.isLFastCrossedOverSlow &&" + "\n" : "") + + (conditions.chmConditions.isLFastCrossedUnderSlow ? "conditions.chmConditions.isLFastCrossedUnderSlow &&" + "\n" : "") + + (conditions.chmConditions.isClosedOverLFast ? "conditions.chmConditions.isClosedOverLFast &&" + "\n" : "") + + (conditions.chmConditions.isClosedUnderLFast ? "conditions.chmConditions.isClosedUnderLFast &&" + "\n" : "") + + (conditions.chmConditions.isHFastOverSlow ? "conditions.chmConditions.isHFastOverSlow &&" + "\n" : "") + + (conditions.chmConditions.isHFastUnderSlow ? "conditions.chmConditions.isHFastUnderSlow &&" + "\n" : "") + + (conditions.chmConditions.isHFastCrossedOverSlow ? "conditions.chmConditions.isHFastCrossedOverSlow &&" + "\n" : "") + + (conditions.chmConditions.isHFastCrossedUnderSlow ? "conditions.chmConditions.isHFastCrossedUnderSlow &&" + "\n" : "") + + (conditions.chmConditions.isClosedOverHFast ? "conditions.chmConditions.isClosedOverHFast &&" + "\n" : "") + + (conditions.chmConditions.isClosedUnderHFast ? "conditions.chmConditions.isClosedUnderHFast &&" + "\n" : "") + + "//" + "\n" + + "// XCHHK ..." + "\n" + + "//" + "\n" + + (conditions.chhkConditions.hasBullishPower ? "conditions.chhkConditions.hasBullishPower &&" + "\n" : "") + + (conditions.chhkConditions.hasBearishPower ? "conditions.chhkConditions.hasBearishPower &&" + "\n" : "") + + (conditions.chhkConditions.isBullishPowerUp ? "conditions.chhkConditions.isBullishPowerUp &&" + "\n" : "") + + (conditions.chhkConditions.isBearishPowerUp ? "conditions.chhkConditions.isBearishPowerUp &&" + "\n" : "") + + (conditions.chhkConditions.isBullishPowerIncreasing ? "conditions.chhkConditions.isBullishPowerIncreasing &&" + "\n" : "") + + (conditions.chhkConditions.isBullishPowerDecreasing ? "conditions.chhkConditions.isBullishPowerDecreasing &&" + "\n" : "") + + (conditions.chhkConditions.isBearishPowerIncreasing ? "conditions.chhkConditions.isBearishPowerIncreasing &&" + "\n" : "") + + (conditions.chhkConditions.isBearishPowerDecreasing ? "conditions.chhkConditions.isBearishPowerDecreasing &&" + "\n" : "") + + (conditions.chhkConditions.isCBullish ? "conditions.chhkConditions.isCBullish &&" + "\n" : "") + + (conditions.chhkConditions.isCSwitchedToBullish ? "conditions.chhkConditions.isCSwitchedToBullish &&" + "\n" : "") + + (conditions.chhkConditions.isCBearish ? "conditions.chhkConditions.isCBearish &&" + "\n" : "") + + (conditions.chhkConditions.isCSwitchedToBearish ? "conditions.chhkConditions.isCSwitchedToBearish &&" + "\n" : "") + + (conditions.chhkConditions.isCloseOverCHigh ? "conditions.chhkConditions.isCloseOverCHigh &&" + "\n" : "") + + (conditions.chhkConditions.isCloseUnderCLow ? "conditions.chhkConditions.isCloseUnderCLow &&" + "\n" : "") + + (conditions.chhkConditions.isSBullish ? "conditions.chhkConditions.isSBullish &&" + "\n" : "") + + (conditions.chhkConditions.isSSwitchedToBullish ? "conditions.chhkConditions.isSSwitchedToBullish &&" + "\n" : "") + + (conditions.chhkConditions.isSBearish ? "conditions.chhkConditions.isSBearish &&" + "\n" : "") + + (conditions.chhkConditions.isSSwitchedToBearish ? "conditions.chhkConditions.isSSwitchedToBearish &&" + "\n" : "") + + (conditions.chhkConditions.isCloseOverSHigh ? "conditions.chhkConditions.isCloseOverSHigh &&" + "\n" : "") + + (conditions.chhkConditions.isCloseUnderSLow ? "conditions.chhkConditions.isCloseUnderSLow &&" + "\n" : "") + + (conditions.chhkConditions.isMBullish ? "conditions.chhkConditions.isMBullish &&" + "\n" : "") + + (conditions.chhkConditions.isMSwitchedToBullish ? "conditions.chhkConditions.isMSwitchedToBullish &&" + "\n" : "") + + (conditions.chhkConditions.isMBearish ? "conditions.chhkConditions.isMBearish &&" + "\n" : "") + + (conditions.chhkConditions.isMSwitchedToBearish ? "conditions.chhkConditions.isMSwitchedToBearish &&" + "\n" : "") + + (conditions.chhkConditions.isCloseOverMHigh ? "conditions.chhkConditions.isCloseOverMHigh &&" + "\n" : "") + + (conditions.chhkConditions.isCloseUnderMLow ? "conditions.chhkConditions.isCloseUnderMLow &&" + "\n" : "") + + (conditions.chhkConditions.isLBullish ? "conditions.chhkConditions.isLBullish &&" + "\n" : "") + + (conditions.chhkConditions.isLSwitchedToBullish ? "conditions.chhkConditions.isLSwitchedToBullish &&" + "\n" : "") + + (conditions.chhkConditions.isLBearish ? "conditions.chhkConditions.isLBearish &&" + "\n" : "") + + (conditions.chhkConditions.isLSwitchedToBearish ? "conditions.chhkConditions.isLSwitchedToBearish &&" + "\n" : "") + + (conditions.chhkConditions.isCloseOverLHigh ? "conditions.chhkConditions.isCloseOverLHigh &&" + "\n" : "") + + (conditions.chhkConditions.isCloseUnderLLow ? "conditions.chhkConditions.isCloseUnderLLow &&" + "\n" : "") + + (conditions.chhkConditions.isHBullish ? "conditions.chhkConditions.isHBullish &&" + "\n" : "") + + (conditions.chhkConditions.isHSwitchedToBullish ? "conditions.chhkConditions.isHSwitchedToBullish &&" + "\n" : "") + + (conditions.chhkConditions.isHBearish ? "conditions.chhkConditions.isHBearish &&" + "\n" : "") + + (conditions.chhkConditions.isHSwitchedToBearish ? "conditions.chhkConditions.isHSwitchedToBearish &&" + "\n" : "") + + (conditions.chhkConditions.isCloseOverHHigh ? "conditions.chhkConditions.isCloseOverHHigh &&" + "\n" : "") + + (conditions.chhkConditions.isCloseUnderHLow ? "conditions.chhkConditions.isCloseUnderHLow &&" + "\n" : "") + + "//" + "\n" + + "// XCHTD ..." + "\n" + + "//" + "\n" + + (conditions.chtdConditions.hasBullishPower ? "conditions.chtdConditions.hasBullishPower &&" + "\n" : "") + + (conditions.chtdConditions.hasBearishPower ? "conditions.chtdConditions.hasBearishPower &&" + "\n" : "") + + (conditions.chtdConditions.isBullishPowerUp ? "conditions.chtdConditions.isBullishPowerUp &&" + "\n" : "") + + (conditions.chtdConditions.isBearishPowerUp ? "conditions.chtdConditions.isBearishPowerUp &&" + "\n" : "") + + (conditions.chtdConditions.isBullishPowerIncreasing ? "conditions.chtdConditions.isBullishPowerIncreasing &&" + "\n" : "") + + (conditions.chtdConditions.isBullishPowerDecreasing ? "conditions.chtdConditions.isBullishPowerDecreasing &&" + "\n" : "") + + (conditions.chtdConditions.isBearishPowerIncreasing ? "conditions.chtdConditions.isBearishPowerIncreasing &&" + "\n" : "") + + (conditions.chtdConditions.isBearishPowerDecreasing ? "conditions.chtdConditions.isBearishPowerDecreasing &&" + "\n" : "") + + (conditions.chtdConditions.isCBullish ? "conditions.chtdConditions.isCBullish &&" + "\n" : "") + + (conditions.chtdConditions.isCBearish ? "conditions.chtdConditions.isCBearish &&" + "\n" : "") + + (conditions.chtdConditions.isCSwitchedToBullish ? "conditions.chtdConditions.isCSwitchedToBullish &&" + "\n" : "") + + (conditions.chtdConditions.isCSwitchedToBearish ? "conditions.chtdConditions.isCSwitchedToBearish &&" + "\n" : "") + + (conditions.chtdConditions.isSBullish ? "conditions.chtdConditions.isSBullish &&" + "\n" : "") + + (conditions.chtdConditions.isSBearish ? "conditions.chtdConditions.isSBearish &&" + "\n" : "") + + (conditions.chtdConditions.isSSwitchedToBullish ? "conditions.chtdConditions.isSSwitchedToBullish &&" + "\n" : "") + + (conditions.chtdConditions.isSSwitchedToBearish ? "conditions.chtdConditions.isSSwitchedToBearish &&" + "\n" : "") + + (conditions.chtdConditions.isMBullish ? "conditions.chtdConditions.isMBullish &&" + "\n" : "") + + (conditions.chtdConditions.isMBearish ? "conditions.chtdConditions.isMBearish &&" + "\n" : "") + + (conditions.chtdConditions.isMSwitchedToBullish ? "conditions.chtdConditions.isMSwitchedToBullish &&" + "\n" : "") + + (conditions.chtdConditions.isMSwitchedToBearish ? "conditions.chtdConditions.isMSwitchedToBearish &&" + "\n" : "") + + (conditions.chtdConditions.isLBullish ? "conditions.chtdConditions.isLBullish &&" + "\n" : "") + + (conditions.chtdConditions.isLBearish ? "conditions.chtdConditions.isLBearish &&" + "\n" : "") + + (conditions.chtdConditions.isLSwitchedToBullish ? "conditions.chtdConditions.isLSwitchedToBullish &&" + "\n" : "") + + (conditions.chtdConditions.isLSwitchedToBearish ? "conditions.chtdConditions.isLSwitchedToBearish &&" + "\n" : "") + + (conditions.chtdConditions.isHBullish ? "conditions.chtdConditions.isHBullish &&" + "\n" : "") + + (conditions.chtdConditions.isHBearish ? "conditions.chtdConditions.isHBearish &&" + "\n" : "") + + (conditions.chtdConditions.isHSwitchedToBullish ? "conditions.chtdConditions.isHSwitchedToBullish &&" + "\n" : "") + + (conditions.chtdConditions.isHSwitchedToBearish ? "conditions.chtdConditions.isHSwitchedToBearish &&" + "\n" : "") + + "//" + "\n" + + "// XCHCHE ..." + "\n" + + "//" + "\n" + + (conditions.chcheConditions.hasBullishPower ? "conditions.chcheConditions.hasBullishPower &&" + "\n" : "") + + (conditions.chcheConditions.hasBearishPower ? "conditions.chcheConditions.hasBearishPower &&" + "\n" : "") + + (conditions.chcheConditions.isBullishPowerUp ? "conditions.chcheConditions.isBullishPowerUp &&" + "\n" : "") + + (conditions.chcheConditions.isBearishPowerUp ? "conditions.chcheConditions.isBearishPowerUp &&" + "\n" : "") + + (conditions.chcheConditions.isBullishPowerIncreasing ? "conditions.chcheConditions.isBullishPowerIncreasing &&" + "\n" : "") + + (conditions.chcheConditions.isBullishPowerDecreasing ? "conditions.chcheConditions.isBullishPowerDecreasing &&" + "\n" : "") + + (conditions.chcheConditions.isBearishPowerIncreasing ? "conditions.chcheConditions.isBearishPowerIncreasing &&" + "\n" : "") + + (conditions.chcheConditions.isBearishPowerDecreasing ? "conditions.chcheConditions.isBearishPowerDecreasing &&" + "\n" : "") + + (conditions.chcheConditions.isCBullish ? "conditions.chcheConditions.isCBullish &&" + "\n" : "") + + (conditions.chcheConditions.isCBearish ? "conditions.chcheConditions.isCBearish &&" + "\n" : "") + + (conditions.chcheConditions.isCStrongBullish ? "conditions.chcheConditions.isCStrongBullish &&" + "\n" : "") + + (conditions.chcheConditions.isCStrongBearish ? "conditions.chcheConditions.isCStrongBearish &&" + "\n" : "") + + (conditions.chcheConditions.isCSwitchedToBullish ? "conditions.chcheConditions.isCSwitchedToBullish &&" + "\n" : "") + + (conditions.chcheConditions.isCSwitchedToBearish ? "conditions.chcheConditions.isCSwitchedToBearish &&" + "\n" : "") + + (conditions.chcheConditions.isCStrongSwitchedToBullish ? "conditions.chcheConditions.isCStrongSwitchedToBullish &&" + "\n" : "") + + (conditions.chcheConditions.isCStrongSwitchedToBearish ? "conditions.chcheConditions.isCStrongSwitchedToBearish &&" + "\n" : "") + + (conditions.chcheConditions.isSBullish ? "conditions.chcheConditions.isSBullish &&" + "\n" : "") + + (conditions.chcheConditions.isSBearish ? "conditions.chcheConditions.isSBearish &&" + "\n" : "") + + (conditions.chcheConditions.isSStrongBullish ? "conditions.chcheConditions.isSStrongBullish &&" + "\n" : "") + + (conditions.chcheConditions.isSStrongBearish ? "conditions.chcheConditions.isSStrongBearish &&" + "\n" : "") + + (conditions.chcheConditions.isSSwitchedToBullish ? "conditions.chcheConditions.isSSwitchedToBullish &&" + "\n" : "") + + (conditions.chcheConditions.isSSwitchedToBearish ? "conditions.chcheConditions.isSSwitchedToBearish &&" + "\n" : "") + + (conditions.chcheConditions.isSStrongSwitchedToBullish ? "conditions.chcheConditions.isSStrongSwitchedToBullish &&" + "\n" : "") + + (conditions.chcheConditions.isSStrongSwitchedToBearish ? "conditions.chcheConditions.isSStrongSwitchedToBearish &&" + "\n" : "") + + (conditions.chcheConditions.isMBullish ? "conditions.chcheConditions.isMBullish &&" + "\n" : "") + + (conditions.chcheConditions.isMBearish ? "conditions.chcheConditions.isMBearish &&" + "\n" : "") + + (conditions.chcheConditions.isMStrongBullish ? "conditions.chcheConditions.isMStrongBullish &&" + "\n" : "") + + (conditions.chcheConditions.isMStrongBearish ? "conditions.chcheConditions.isMStrongBearish &&" + "\n" : "") + + (conditions.chcheConditions.isMSwitchedToBullish ? "conditions.chcheConditions.isMSwitchedToBullish &&" + "\n" : "") + + (conditions.chcheConditions.isMSwitchedToBearish ? "conditions.chcheConditions.isMSwitchedToBearish &&" + "\n" : "") + + (conditions.chcheConditions.isMStrongSwitchedToBullish ? "conditions.chcheConditions.isMStrongSwitchedToBullish &&" + "\n" : "") + + (conditions.chcheConditions.isMStrongSwitchedToBearish ? "conditions.chcheConditions.isMStrongSwitchedToBearish &&" + "\n" : "") + + (conditions.chcheConditions.isLBullish ? "conditions.chcheConditions.isLBullish &&" + "\n" : "") + + (conditions.chcheConditions.isLBearish ? "conditions.chcheConditions.isLBearish &&" + "\n" : "") + + (conditions.chcheConditions.isLStrongBullish ? "conditions.chcheConditions.isLStrongBullish &&" + "\n" : "") + + (conditions.chcheConditions.isLStrongBearish ? "conditions.chcheConditions.isLStrongBearish &&" + "\n" : "") + + (conditions.chcheConditions.isLSwitchedToBullish ? "conditions.chcheConditions.isLSwitchedToBullish &&" + "\n" : "") + + (conditions.chcheConditions.isLSwitchedToBearish ? "conditions.chcheConditions.isLSwitchedToBearish &&" + "\n" : "") + + (conditions.chcheConditions.isLStrongSwitchedToBullish ? "conditions.chcheConditions.isLStrongSwitchedToBullish &&" + "\n" : "") + + (conditions.chcheConditions.isLStrongSwitchedToBearish ? "conditions.chcheConditions.isLStrongSwitchedToBearish &&" + "\n" : "") + + (conditions.chcheConditions.isHBullish ? "conditions.chcheConditions.isHBullish &&" + "\n" : "") + + (conditions.chcheConditions.isHBearish ? "conditions.chcheConditions.isHBearish &&" + "\n" : "") + + (conditions.chcheConditions.isHStrongBullish ? "conditions.chcheConditions.isHStrongBullish &&" + "\n" : "") + + (conditions.chcheConditions.isHStrongBearish ? "conditions.chcheConditions.isHStrongBearish &&" + "\n" : "") + + (conditions.chcheConditions.isHSwitchedToBullish ? "conditions.chcheConditions.isHSwitchedToBullish &&" + "\n" : "") + + (conditions.chcheConditions.isHSwitchedToBearish ? "conditions.chcheConditions.isHSwitchedToBearish &&" + "\n" : "") + + (conditions.chcheConditions.isHStrongSwitchedToBullish ? "conditions.chcheConditions.isHStrongSwitchedToBullish &&" + "\n" : "") + + (conditions.chcheConditions.isHStrongSwitchedToBearish ? "conditions.chcheConditions.isHStrongSwitchedToBearish &&" + "\n" : "") + + "//" + "\n" + + "// XCHSTR ..." + "\n" + + "//" + "\n" + + (conditions.chstrConditions.hasBullishPower ? "conditions.chstrConditions.hasBullishPower &&" + "\n" : "") + + (conditions.chstrConditions.hasBearishPower ? "conditions.chstrConditions.hasBearishPower &&" + "\n" : "") + + (conditions.chstrConditions.isBullishPowerUp ? "conditions.chstrConditions.isBullishPowerUp &&" + "\n" : "") + + (conditions.chstrConditions.isBearishPowerUp ? "conditions.chstrConditions.isBearishPowerUp &&" + "\n" : "") + + (conditions.chstrConditions.isBullishPowerIncreasing ? "conditions.chstrConditions.isBullishPowerIncreasing &&" + "\n" : "") + + (conditions.chstrConditions.isBullishPowerDecreasing ? "conditions.chstrConditions.isBullishPowerDecreasing &&" + "\n" : "") + + (conditions.chstrConditions.isBearishPowerIncreasing ? "conditions.chstrConditions.isBearishPowerIncreasing &&" + "\n" : "") + + (conditions.chstrConditions.isBearishPowerDecreasing ? "conditions.chstrConditions.isBearishPowerDecreasing &&" + "\n" : "") + + (conditions.chstrConditions.isCBullish ? "conditions.chstrConditions.isCBullish &&" + "\n" : "") + + (conditions.chstrConditions.isCBearish ? "conditions.chstrConditions.isCBearish &&" + "\n" : "") + + (conditions.chstrConditions.isCSwitchedToBullish ? "conditions.chstrConditions.isCSwitchedToBullish &&" + "\n" : "") + + (conditions.chstrConditions.isCSwitchedToBearish ? "conditions.chstrConditions.isCSwitchedToBearish &&" + "\n" : "") + + (conditions.chstrConditions.isSBullish ? "conditions.chstrConditions.isSBullish &&" + "\n" : "") + + (conditions.chstrConditions.isSBearish ? "conditions.chstrConditions.isSBearish &&" + "\n" : "") + + (conditions.chstrConditions.isSSwitchedToBullish ? "conditions.chstrConditions.isSSwitchedToBullish &&" + "\n" : "") + + (conditions.chstrConditions.isSSwitchedToBearish ? "conditions.chstrConditions.isSSwitchedToBearish &&" + "\n" : "") + + (conditions.chstrConditions.isMBullish ? "conditions.chstrConditions.isMBullish &&" + "\n" : "") + + (conditions.chstrConditions.isMBearish ? "conditions.chstrConditions.isMBearish &&" + "\n" : "") + + (conditions.chstrConditions.isMSwitchedToBullish ? "conditions.chstrConditions.isMSwitchedToBullish &&" + "\n" : "") + + (conditions.chstrConditions.isMSwitchedToBearish ? "conditions.chstrConditions.isMSwitchedToBearish &&" + "\n" : "") + + (conditions.chstrConditions.isLBullish ? "conditions.chstrConditions.isLBullish &&" + "\n" : "") + + (conditions.chstrConditions.isLBearish ? "conditions.chstrConditions.isLBearish &&" + "\n" : "") + + (conditions.chstrConditions.isLSwitchedToBullish ? "conditions.chstrConditions.isLSwitchedToBullish &&" + "\n" : "") + + (conditions.chstrConditions.isLSwitchedToBearish ? "conditions.chstrConditions.isLSwitchedToBearish &&" + "\n" : "") + + (conditions.chstrConditions.isHBullish ? "conditions.chstrConditions.isHBullish &&" + "\n" : "") + + (conditions.chstrConditions.isHBearish ? "conditions.chstrConditions.isHBearish &&" + "\n" : "") + + (conditions.chstrConditions.isHSwitchedToBullish ? "conditions.chstrConditions.isHSwitchedToBullish &&" + "\n" : "") + + (conditions.chstrConditions.isHSwitchedToBearish ? "conditions.chstrConditions.isHSwitchedToBearish &&" + "\n" : "") + + "//" + "\n" + + "// XCHVLM ..." + "\n" + + "//" + "\n" + + (conditions.chvlmConditions.hasBullishPower ? "conditions.chvlmConditions.hasBullishPower &&" + "\n" : "") + + (conditions.chvlmConditions.hasBearishPower ? "conditions.chvlmConditions.hasBearishPower &&" + "\n" : "") + + (conditions.chvlmConditions.isBullishPowerUp ? "conditions.chvlmConditions.isBullishPowerUp &&" + "\n" : "") + + (conditions.chvlmConditions.isBearishPowerUp ? "conditions.chvlmConditions.isBearishPowerUp &&" + "\n" : "") + + (conditions.chvlmConditions.isBullishPowerIncreasing ? "conditions.chvlmConditions.isBullishPowerIncreasing &&" + "\n" : "") + + (conditions.chvlmConditions.isBullishPowerDecreasing ? "conditions.chvlmConditions.isBullishPowerDecreasing &&" + "\n" : "") + + (conditions.chvlmConditions.isBearishPowerIncreasing ? "conditions.chvlmConditions.isBearishPowerIncreasing &&" + "\n" : "") + + (conditions.chvlmConditions.isBearishPowerDecreasing ? "conditions.chvlmConditions.isBearishPowerDecreasing &&" + "\n" : "") + + (conditions.chvlmConditions.isCBullish ? "conditions.chvlmConditions.isCBullish &&" + "\n" : "") + + (conditions.chvlmConditions.isCBearish ? "conditions.chvlmConditions.isCBearish &&" + "\n" : "") + + (conditions.chvlmConditions.isCSwitchedToBullish ? "conditions.chvlmConditions.isCSwitchedToBullish &&" + "\n" : "") + + (conditions.chvlmConditions.isCSwitchedToBearish ? "conditions.chvlmConditions.isCSwitchedToBearish &&" + "\n" : "") + + (conditions.chvlmConditions.isSBullish ? "conditions.chvlmConditions.isSBullish &&" + "\n" : "") + + (conditions.chvlmConditions.isSBearish ? "conditions.chvlmConditions.isSBearish &&" + "\n" : "") + + (conditions.chvlmConditions.isSSwitchedToBullish ? "conditions.chvlmConditions.isSSwitchedToBullish &&" + "\n" : "") + + (conditions.chvlmConditions.isSSwitchedToBearish ? "conditions.chvlmConditions.isSSwitchedToBearish &&" + "\n" : "") + + (conditions.chvlmConditions.isMBullish ? "conditions.chvlmConditions.isMBullish &&" + "\n" : "") + + (conditions.chvlmConditions.isMBearish ? "conditions.chvlmConditions.isMBearish &&" + "\n" : "") + + (conditions.chvlmConditions.isMSwitchedToBullish ? "conditions.chvlmConditions.isMSwitchedToBullish &&" + "\n" : "") + + (conditions.chvlmConditions.isMSwitchedToBearish ? "conditions.chvlmConditions.isMSwitchedToBearish &&" + "\n" : "") + + (conditions.chvlmConditions.isLBullish ? "conditions.chvlmConditions.isLBullish &&" + "\n" : "") + + (conditions.chvlmConditions.isLBearish ? "conditions.chvlmConditions.isLBearish &&" + "\n" : "") + + (conditions.chvlmConditions.isLSwitchedToBullish ? "conditions.chvlmConditions.isLSwitchedToBullish &&" + "\n" : "") + + (conditions.chvlmConditions.isLSwitchedToBearish ? "conditions.chvlmConditions.isLSwitchedToBearish &&" + "\n" : "") + + (conditions.chvlmConditions.isHBullish ? "conditions.chvlmConditions.isHBullish &&" + "\n" : "") + + (conditions.chvlmConditions.isHBearish ? "conditions.chvlmConditions.isHBearish &&" + "\n" : "") + + (conditions.chvlmConditions.isHSwitchedToBullish ? "conditions.chvlmConditions.isHSwitchedToBullish &&" + "\n" : "") + + (conditions.chvlmConditions.isHSwitchedToBearish ? "conditions.chvlmConditions.isHSwitchedToBearish &&" + "\n" : "") + + "//" + "\n" + + "// XCHVWAP ..." + "\n" + + "//" + "\n" + + (conditions.chvwapConditions.hasBullishPower ? "conditions.chvwapConditions.hasBullishPower &&" + "\n" : "") + + (conditions.chvwapConditions.hasBearishPower ? "conditions.chvwapConditions.hasBearishPower &&" + "\n" : "") + + (conditions.chvwapConditions.isBullishPowerUp ? "conditions.chvwapConditions.isBullishPowerUp &&" + "\n" : "") + + (conditions.chvwapConditions.isBearishPowerUp ? "conditions.chvwapConditions.isBearishPowerUp &&" + "\n" : "") + + (conditions.chvwapConditions.isBullishPowerIncreasing ? "conditions.chvwapConditions.isBullishPowerIncreasing &&" + "\n" : "") + + (conditions.chvwapConditions.isBullishPowerDecreasing ? "conditions.chvwapConditions.isBullishPowerDecreasing &&" + "\n" : "") + + (conditions.chvwapConditions.isBearishPowerIncreasing ? "conditions.chvwapConditions.isBearishPowerIncreasing &&" + "\n" : "") + + (conditions.chvwapConditions.isBearishPowerDecreasing ? "conditions.chvwapConditions.isBearishPowerDecreasing &&" + "\n" : "") + + (conditions.chvwapConditions.isSBullish ? "conditions.chvwapConditions.isSBullish &&" + "\n" : "") + + (conditions.chvwapConditions.isSBearish ? "conditions.chvwapConditions.isSBearish &&" + "\n" : "") + + (conditions.chvwapConditions.isSSwitchedToBullish ? "conditions.chvwapConditions.isSSwitchedToBullish &&" + "\n" : "") + + (conditions.chvwapConditions.isSSwitchedToBearish ? "conditions.chvwapConditions.isSSwitchedToBearish &&" + "\n" : "") + + (conditions.chvwapConditions.isMBullish ? "conditions.chvwapConditions.isMBullish &&" + "\n" : "") + + (conditions.chvwapConditions.isMBearish ? "conditions.chvwapConditions.isMBearish &&" + "\n" : "") + + (conditions.chvwapConditions.isMSwitchedToBullish ? "conditions.chvwapConditions.isMSwitchedToBullish &&" + "\n" : "") + + (conditions.chvwapConditions.isMSwitchedToBearish ? "conditions.chvwapConditions.isMSwitchedToBearish &&" + "\n" : "") + + (conditions.chvwapConditions.isLBullish ? "conditions.chvwapConditions.isLBullish &&" + "\n" : "") + + (conditions.chvwapConditions.isLBearish ? "conditions.chvwapConditions.isLBearish &&" + "\n" : "") + + (conditions.chvwapConditions.isLSwitchedToBullish ? "conditions.chvwapConditions.isLSwitchedToBullish &&" + "\n" : "") + + (conditions.chvwapConditions.isLSwitchedToBearish ? "conditions.chvwapConditions.isLSwitchedToBearish &&" + "\n" : "") + + (conditions.chvwapConditions.isHBullish ? "conditions.chvwapConditions.isHBullish &&" + "\n" : "") + + (conditions.chvwapConditions.isHBearish ? "conditions.chvwapConditions.isHBearish &&" + "\n" : "") + + (conditions.chvwapConditions.isHSwitchedToBullish ? "conditions.chvwapConditions.isHSwitchedToBullish &&" + "\n" : "") + + (conditions.chvwapConditions.isHSwitchedToBearish ? "conditions.chvwapConditions.isHSwitchedToBearish &&" + "\n" : "") + + "//" + "\n" + + "// XCHICH ..." + "\n" + + "//" + "\n" + + (conditions.chichConditions.isCClosedOverKijunSen ? "conditions.chichConditions.isCClosedOverKijunSen &&" + "\n" : "") + + (conditions.chichConditions.isCClosedUnderKijunSen ? "conditions.chichConditions.isCClosedUnderKijunSen &&" + "\n" : "") + + (conditions.chichConditions.isCTenkanSenOverKijunSen ? "conditions.chichConditions.isCTenkanSenOverKijunSen &&" + "\n" : "") + + (conditions.chichConditions.isCTenkanSenUnderKijunSen ? "conditions.chichConditions.isCTenkanSenUnderKijunSen &&" + "\n" : "") + + (conditions.chichConditions.isCTenkanSenCrossedOverKijunSen ? "conditions.chichConditions.isCTenkanSenCrossedOverKijunSen &&" + "\n" : "") + + (conditions.chichConditions.isCTenkanSenCrossedUnderKijunSen ? "conditions.chichConditions.isCTenkanSenCrossedUnderKijunSen &&" + "\n" : "") + + (conditions.chichConditions.isCSenkouSpanAOverB ? "conditions.chichConditions.isCSenkouSpanAOverB &&" + "\n" : "") + + (conditions.chichConditions.isCSenkouSpanAUnderB ? "conditions.chichConditions.isCSenkouSpanAUnderB &&" + "\n" : "") + + (conditions.chichConditions.isCSenkouSpanAOverLast ? "conditions.chichConditions.isCSenkouSpanAOverLast &&" + "\n" : "") + + (conditions.chichConditions.isCSenkouSpanAUnderLast ? "conditions.chichConditions.isCSenkouSpanAUnderLast &&" + "\n" : "") + + (conditions.chichConditions.isCFutureSenkouSpanAOverB ? "conditions.chichConditions.isCFutureSenkouSpanAOverB &&" + "\n" : "") + + (conditions.chichConditions.isCFutureSenkouSpanAUnderB ? "conditions.chichConditions.isCFutureSenkouSpanAUnderB &&" + "\n" : "") + + (conditions.chichConditions.isCFutureSenkouSpanAOverLast ? "conditions.chichConditions.isCFutureSenkouSpanAOverLast &&" + "\n" : "") + + (conditions.chichConditions.isCFutureSenkouSpanAUnderLast ? "conditions.chichConditions.isCFutureSenkouSpanAUnderLast &&" + "\n" : "") + + (conditions.chichConditions.isCSenkouSpanACrossedOverB ? "conditions.chichConditions.isCSenkouSpanACrossedOverB &&" + "\n" : "") + + (conditions.chichConditions.isCSenkouSpanACrossedUnderB ? "conditions.chichConditions.isCSenkouSpanACrossedUnderB &&" + "\n" : "") + + (conditions.chichConditions.isCSenkouSpanACrossedOverLast ? "conditions.chichConditions.isCSenkouSpanACrossedOverLast &&" + "\n" : "") + + (conditions.chichConditions.isCSenkouSpanACrossedUnderLast ? "conditions.chichConditions.isCSenkouSpanACrossedUnderLast &&" + "\n" : "") + + (conditions.chichConditions.isCFutureSenkouSpanACrossedOverB ? "conditions.chichConditions.isCFutureSenkouSpanACrossedOverB &&" + "\n" : "") + + (conditions.chichConditions.isCFutureSenkouSpanACrossedUnderB ? "conditions.chichConditions.isCFutureSenkouSpanACrossedUnderB &&" + "\n" : "") + + (conditions.chichConditions.isCFutureSenkouSpanACrossedOverLast ? "conditions.chichConditions.isCFutureSenkouSpanACrossedOverLast &&" + "\n" : "") + + (conditions.chichConditions.isCFutureSenkouSpanACrossedUnderLast ? "conditions.chichConditions.isCFutureSenkouSpanACrossedUnderLast &&" + "\n" : "") + + (conditions.chichConditions.isSClosedOverKijunSen ? "conditions.chichConditions.isSClosedOverKijunSen &&" + "\n" : "") + + (conditions.chichConditions.isSClosedUnderKijunSen ? "conditions.chichConditions.isSClosedUnderKijunSen &&" + "\n" : "") + + (conditions.chichConditions.isSTenkanSenOverKijunSen ? "conditions.chichConditions.isSTenkanSenOverKijunSen &&" + "\n" : "") + + (conditions.chichConditions.isSTenkanSenUnderKijunSen ? "conditions.chichConditions.isSTenkanSenUnderKijunSen &&" + "\n" : "") + + (conditions.chichConditions.isSTenkanSenCrossedOverKijunSen ? "conditions.chichConditions.isSTenkanSenCrossedOverKijunSen &&" + "\n" : "") + + (conditions.chichConditions.isSTenkanSenCrossedUnderKijunSen ? "conditions.chichConditions.isSTenkanSenCrossedUnderKijunSen &&" + "\n" : "") + + (conditions.chichConditions.isSSenkouSpanAOverB ? "conditions.chichConditions.isSSenkouSpanAOverB &&" + "\n" : "") + + (conditions.chichConditions.isSSenkouSpanAUnderB ? "conditions.chichConditions.isSSenkouSpanAUnderB &&" + "\n" : "") + + (conditions.chichConditions.isSSenkouSpanAOverLast ? "conditions.chichConditions.isSSenkouSpanAOverLast &&" + "\n" : "") + + (conditions.chichConditions.isSSenkouSpanAUnderLast ? "conditions.chichConditions.isSSenkouSpanAUnderLast &&" + "\n" : "") + + (conditions.chichConditions.isSFutureSenkouSpanAOverB ? "conditions.chichConditions.isSFutureSenkouSpanAOverB &&" + "\n" : "") + + (conditions.chichConditions.isSFutureSenkouSpanAUnderB ? "conditions.chichConditions.isSFutureSenkouSpanAUnderB &&" + "\n" : "") + + (conditions.chichConditions.isSFutureSenkouSpanAOverLast ? "conditions.chichConditions.isSFutureSenkouSpanAOverLast &&" + "\n" : "") + + (conditions.chichConditions.isSFutureSenkouSpanAUnderLast ? "conditions.chichConditions.isSFutureSenkouSpanAUnderLast &&" + "\n" : "") + + (conditions.chichConditions.isSSenkouSpanACrossedOverB ? "conditions.chichConditions.isSSenkouSpanACrossedOverB &&" + "\n" : "") + + (conditions.chichConditions.isSSenkouSpanACrossedUnderB ? "conditions.chichConditions.isSSenkouSpanACrossedUnderB &&" + "\n" : "") + + (conditions.chichConditions.isSSenkouSpanACrossedOverLast ? "conditions.chichConditions.isSSenkouSpanACrossedOverLast &&" + "\n" : "") + + (conditions.chichConditions.isSSenkouSpanACrossedUnderLast ? "conditions.chichConditions.isSSenkouSpanACrossedUnderLast &&" + "\n" : "") + + (conditions.chichConditions.isSFutureSenkouSpanACrossedOverB ? "conditions.chichConditions.isSFutureSenkouSpanACrossedOverB &&" + "\n" : "") + + (conditions.chichConditions.isSFutureSenkouSpanACrossedUnderB ? "conditions.chichConditions.isSFutureSenkouSpanACrossedUnderB &&" + "\n" : "") + + (conditions.chichConditions.isSFutureSenkouSpanACrossedOverLast ? "conditions.chichConditions.isSFutureSenkouSpanACrossedOverLast &&" + "\n" : "") + + (conditions.chichConditions.isSFutureSenkouSpanACrossedUnderLast ? "conditions.chichConditions.isSFutureSenkouSpanACrossedUnderLast &&" + "\n" : "") + + (conditions.chichConditions.isMClosedOverKijunSen ? "conditions.chichConditions.isMClosedOverKijunSen &&" + "\n" : "") + + (conditions.chichConditions.isMClosedUnderKijunSen ? "conditions.chichConditions.isMClosedUnderKijunSen &&" + "\n" : "") + + (conditions.chichConditions.isMTenkanSenOverKijunSen ? "conditions.chichConditions.isMTenkanSenOverKijunSen &&" + "\n" : "") + + (conditions.chichConditions.isMTenkanSenUnderKijunSen ? "conditions.chichConditions.isMTenkanSenUnderKijunSen &&" + "\n" : "") + + (conditions.chichConditions.isMTenkanSenCrossedOverKijunSen ? "conditions.chichConditions.isMTenkanSenCrossedOverKijunSen &&" + "\n" : "") + + (conditions.chichConditions.isMTenkanSenCrossedUnderKijunSen ? "conditions.chichConditions.isMTenkanSenCrossedUnderKijunSen &&" + "\n" : "") + + (conditions.chichConditions.isMSenkouSpanAOverB ? "conditions.chichConditions.isMSenkouSpanAOverB &&" + "\n" : "") + + (conditions.chichConditions.isMSenkouSpanAUnderB ? "conditions.chichConditions.isMSenkouSpanAUnderB &&" + "\n" : "") + + (conditions.chichConditions.isMSenkouSpanAOverLast ? "conditions.chichConditions.isMSenkouSpanAOverLast &&" + "\n" : "") + + (conditions.chichConditions.isMSenkouSpanAUnderLast ? "conditions.chichConditions.isMSenkouSpanAUnderLast &&" + "\n" : "") + + (conditions.chichConditions.isMFutureSenkouSpanAOverB ? "conditions.chichConditions.isMFutureSenkouSpanAOverB &&" + "\n" : "") + + (conditions.chichConditions.isMFutureSenkouSpanAUnderB ? "conditions.chichConditions.isMFutureSenkouSpanAUnderB &&" + "\n" : "") + + (conditions.chichConditions.isMFutureSenkouSpanAOverLast ? "conditions.chichConditions.isMFutureSenkouSpanAOverLast &&" + "\n" : "") + + (conditions.chichConditions.isMFutureSenkouSpanAUnderLast ? "conditions.chichConditions.isMFutureSenkouSpanAUnderLast &&" + "\n" : "") + + (conditions.chichConditions.isMSenkouSpanACrossedOverB ? "conditions.chichConditions.isMSenkouSpanACrossedOverB &&" + "\n" : "") + + (conditions.chichConditions.isMSenkouSpanACrossedUnderB ? "conditions.chichConditions.isMSenkouSpanACrossedUnderB &&" + "\n" : "") + + (conditions.chichConditions.isMSenkouSpanACrossedOverLast ? "conditions.chichConditions.isMSenkouSpanACrossedOverLast &&" + "\n" : "") + + (conditions.chichConditions.isMSenkouSpanACrossedUnderLast ? "conditions.chichConditions.isMSenkouSpanACrossedUnderLast &&" + "\n" : "") + + (conditions.chichConditions.isMFutureSenkouSpanACrossedOverB ? "conditions.chichConditions.isMFutureSenkouSpanACrossedOverB &&" + "\n" : "") + + (conditions.chichConditions.isMFutureSenkouSpanACrossedUnderB ? "conditions.chichConditions.isMFutureSenkouSpanACrossedUnderB &&" + "\n" : "") + + (conditions.chichConditions.isMFutureSenkouSpanACrossedOverLast ? "conditions.chichConditions.isMFutureSenkouSpanACrossedOverLast &&" + "\n" : "") + + (conditions.chichConditions.isMFutureSenkouSpanACrossedUnderLast ? "conditions.chichConditions.isMFutureSenkouSpanACrossedUnderLast &&" + "\n" : "") + + (conditions.chichConditions.isLClosedOverKijunSen ? "conditions.chichConditions.isLClosedOverKijunSen &&" + "\n" : "") + + (conditions.chichConditions.isLClosedUnderKijunSen ? "conditions.chichConditions.isLClosedUnderKijunSen &&" + "\n" : "") + + (conditions.chichConditions.isLTenkanSenOverKijunSen ? "conditions.chichConditions.isLTenkanSenOverKijunSen &&" + "\n" : "") + + (conditions.chichConditions.isLTenkanSenUnderKijunSen ? "conditions.chichConditions.isLTenkanSenUnderKijunSen &&" + "\n" : "") + + (conditions.chichConditions.isLTenkanSenCrossedOverKijunSen ? "conditions.chichConditions.isLTenkanSenCrossedOverKijunSen &&" + "\n" : "") + + (conditions.chichConditions.isLTenkanSenCrossedUnderKijunSen ? "conditions.chichConditions.isLTenkanSenCrossedUnderKijunSen &&" + "\n" : "") + + (conditions.chichConditions.isLSenkouSpanAOverB ? "conditions.chichConditions.isLSenkouSpanAOverB &&" + "\n" : "") + + (conditions.chichConditions.isLSenkouSpanAUnderB ? "conditions.chichConditions.isLSenkouSpanAUnderB &&" + "\n" : "") + + (conditions.chichConditions.isLSenkouSpanAOverLast ? "conditions.chichConditions.isLSenkouSpanAOverLast &&" + "\n" : "") + + (conditions.chichConditions.isLSenkouSpanAUnderLast ? "conditions.chichConditions.isLSenkouSpanAUnderLast &&" + "\n" : "") + + (conditions.chichConditions.isLFutureSenkouSpanAOverB ? "conditions.chichConditions.isLFutureSenkouSpanAOverB &&" + "\n" : "") + + (conditions.chichConditions.isLFutureSenkouSpanAUnderB ? "conditions.chichConditions.isLFutureSenkouSpanAUnderB &&" + "\n" : "") + + (conditions.chichConditions.isLFutureSenkouSpanAOverLast ? "conditions.chichConditions.isLFutureSenkouSpanAOverLast &&" + "\n" : "") + + (conditions.chichConditions.isLFutureSenkouSpanAUnderLast ? "conditions.chichConditions.isLFutureSenkouSpanAUnderLast &&" + "\n" : "") + + (conditions.chichConditions.isLSenkouSpanACrossedOverB ? "conditions.chichConditions.isLSenkouSpanACrossedOverB &&" + "\n" : "") + + (conditions.chichConditions.isLSenkouSpanACrossedUnderB ? "conditions.chichConditions.isLSenkouSpanACrossedUnderB &&" + "\n" : "") + + (conditions.chichConditions.isLSenkouSpanACrossedOverLast ? "conditions.chichConditions.isLSenkouSpanACrossedOverLast &&" + "\n" : "") + + (conditions.chichConditions.isLSenkouSpanACrossedUnderLast ? "conditions.chichConditions.isLSenkouSpanACrossedUnderLast &&" + "\n" : "") + + (conditions.chichConditions.isLFutureSenkouSpanACrossedOverB ? "conditions.chichConditions.isLFutureSenkouSpanACrossedOverB &&" + "\n" : "") + + (conditions.chichConditions.isLFutureSenkouSpanACrossedUnderB ? "conditions.chichConditions.isLFutureSenkouSpanACrossedUnderB &&" + "\n" : "") + + (conditions.chichConditions.isLFutureSenkouSpanACrossedOverLast ? "conditions.chichConditions.isLFutureSenkouSpanACrossedOverLast &&" + "\n" : "") + + (conditions.chichConditions.isLFutureSenkouSpanACrossedUnderLast ? "conditions.chichConditions.isLFutureSenkouSpanACrossedUnderLast &&" + "\n" : "") + + (conditions.chichConditions.isHClosedOverKijunSen ? "conditions.chichConditions.isHClosedOverKijunSen &&" + "\n" : "") + + (conditions.chichConditions.isHClosedUnderKijunSen ? "conditions.chichConditions.isHClosedUnderKijunSen &&" + "\n" : "") + + (conditions.chichConditions.isHTenkanSenOverKijunSen ? "conditions.chichConditions.isHTenkanSenOverKijunSen &&" + "\n" : "") + + (conditions.chichConditions.isHTenkanSenUnderKijunSen ? "conditions.chichConditions.isHTenkanSenUnderKijunSen &&" + "\n" : "") + + (conditions.chichConditions.isHTenkanSenCrossedOverKijunSen ? "conditions.chichConditions.isHTenkanSenCrossedOverKijunSen &&" + "\n" : "") + + (conditions.chichConditions.isHTenkanSenCrossedUnderKijunSen ? "conditions.chichConditions.isHTenkanSenCrossedUnderKijunSen &&" + "\n" : "") + + (conditions.chichConditions.isHSenkouSpanAOverB ? "conditions.chichConditions.isHSenkouSpanAOverB &&" + "\n" : "") + + (conditions.chichConditions.isHSenkouSpanAUnderB ? "conditions.chichConditions.isHSenkouSpanAUnderB &&" + "\n" : "") + + (conditions.chichConditions.isHSenkouSpanAOverLast ? "conditions.chichConditions.isHSenkouSpanAOverLast &&" + "\n" : "") + + (conditions.chichConditions.isHSenkouSpanAUnderLast ? "conditions.chichConditions.isHSenkouSpanAUnderLast &&" + "\n" : "") + + (conditions.chichConditions.isHFutureSenkouSpanAOverB ? "conditions.chichConditions.isHFutureSenkouSpanAOverB &&" + "\n" : "") + + (conditions.chichConditions.isHFutureSenkouSpanAUnderB ? "conditions.chichConditions.isHFutureSenkouSpanAUnderB &&" + "\n" : "") + + (conditions.chichConditions.isHFutureSenkouSpanAOverLast ? "conditions.chichConditions.isHFutureSenkouSpanAOverLast &&" + "\n" : "") + + (conditions.chichConditions.isHFutureSenkouSpanAUnderLast ? "conditions.chichConditions.isHFutureSenkouSpanAUnderLast &&" + "\n" : "") + + (conditions.chichConditions.isHSenkouSpanACrossedOverB ? "conditions.chichConditions.isHSenkouSpanACrossedOverB &&" + "\n" : "") + + (conditions.chichConditions.isHSenkouSpanACrossedUnderB ? "conditions.chichConditions.isHSenkouSpanACrossedUnderB &&" + "\n" : "") + + (conditions.chichConditions.isHSenkouSpanACrossedOverLast ? "conditions.chichConditions.isHSenkouSpanACrossedOverLast &&" + "\n" : "") + + (conditions.chichConditions.isHSenkouSpanACrossedUnderLast ? "conditions.chichConditions.isHSenkouSpanACrossedUnderLast &&" + "\n" : "") + + (conditions.chichConditions.isHFutureSenkouSpanACrossedOverB ? "conditions.chichConditions.isHFutureSenkouSpanACrossedOverB &&" + "\n" : "") + + (conditions.chichConditions.isHFutureSenkouSpanACrossedUnderB ? "conditions.chichConditions.isHFutureSenkouSpanACrossedUnderB &&" + "\n" : "") + + (conditions.chichConditions.isHFutureSenkouSpanACrossedOverLast ? "conditions.chichConditions.isHFutureSenkouSpanACrossedOverLast &&" + "\n" : "") + + (conditions.chichConditions.isHFutureSenkouSpanACrossedUnderLast ? "conditions.chichConditions.isHFutureSenkouSpanACrossedUnderLast &&" + "\n" : "") + + "//" + "\n" + + ")" + "\n" + "//" + + "\n" + + "||" + "\n" + + "//"; + + // + string query = "&&"; + int andIndexes[]; + int andIndexesCount = FindIndexes( + query, + result, + andIndexes // + ); + if (IsValidSize(andIndexesCount)) + { + // + int lastAndIndex = andIndexes[ArraySize(andIndexes) - 1]; + + // + string beforeStr = StringSubstr( + result, + 0, + lastAndIndex // + ); + string afterStr = StringSubstr( + result, + lastAndIndex + StringLen(query)); + + // + result = beforeStr + afterStr; + } + + // + return result; + } + + // + bool IsFiltered( + XSignal &signal, // Provided Signal + XCHStrategyConditions &conditions, // Market Conditions + bool force = false // + ) + { + // + bool result = false; + + // + // Validate Args ... + if (!signal.IsValid() || !conditions.IsValid()) + { + // + result = true; + return result; + } + + // // + // string market = _account.GetCompany(); + // bool isIngot = _marketParser.IsIngot(market); + // bool isErrante = _marketParser.IsErrante(market); + // bool isAMarkets = _marketParser.IsAMarkets(market); + // bool isIFCMarkets = _marketParser.IsIFCMarkets(market); + // bool isOtetMarkets = _marketParser.IsOtetMarkets(market); + + // // + // // Ingot ... + // bool isIngotFiltered = false; + // // _ingotParser.IsFiltered( + // // signal, + // // conditions, + // // force // + // // ); + + // // + // // Errante ... + // bool isErranteFiltered = false; + // // _erranteParser.IsFiltered( + // // signal, + // // conditions, + // // force // + // // ); + + // // + // // AMarkets ... + // bool isAMarketsFiltered = _amarketsParser.IsFiltered( + // signal, + // conditions, + // force // + // ); + + // // + // // IFCMarkets ... + // bool isIFCMarketsFiltered = false; + // // _ifcmarketsParser.IsFiltered( + // // signal, + // // conditions, + // // force // + // // ); + + // // + // // OtetMarkets ... + // bool isOtetMarketsFiltered = false; + // // _otetmarketsParser.IsFiltered( + // // signal, + // // conditions, + // // force // + // // ); + + // // + // if (!force) + // { + // // + // if (isIngot) + // { + // result = isIngotFiltered; + // } + // else if (isErrante) + // { + // result = isErranteFiltered; + // } + // else if (isAMarkets) + // { + // result = isAMarketsFiltered; + // } + // else if (isIFCMarkets) + // { + // result = isIFCMarketsFiltered; + // } + // else if (isOtetMarkets) + // { + // result = isOtetMarketsFiltered; + // } + // } + // else + // { + // // + // result = + // // + // isIngotFiltered + // // + // || + // // + // isErranteFiltered + // // + // || + // // + // isAMarketsFiltered + // // + // || + // // + // isIFCMarketsFiltered + // // + // || + // // + // isOtetMarketsFiltered + // // + // ; + // } + + // + return result; + } +}; \ No newline at end of file diff --git a/Strategies/x-saherelm.xch.ichwap.strategy.mq5 b/Strategies/x-saherelm.xch.ichwap.strategy.mq5 index b9287a7a..d83d518e 100644 --- a/Strategies/x-saherelm.xch.ichwap.strategy.mq5 +++ b/Strategies/x-saherelm.xch.ichwap.strategy.mq5 @@ -36,7 +36,7 @@ class XSCXCHICHWAPStrategy : public XSCBaseStrategy { // // Public ... -public: + public: // // Constructor(s) ... void XSCXCHICHWAPStrategy( @@ -60,25 +60,26 @@ public: 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 // - ) + ) + : XSCBaseStrategy(_symbol, + _period, + _analizePeriod, + _volume, + _r2r, + _slippage, + _magicNumber, + _ignoreSignalExecution, + _useTPSLAsPoint, + _forceMaxTPSLAsPoint, + _tpPoint, + _slPoint, + _ignoreTP, + _ignoreSL, + _allowLong, + _allowShort, + _maxAllowedLongs, + _maxAllowedShorts // + ) { // SetAlertPrefix(GetTag()); @@ -347,6 +348,20 @@ public: tmpLSW, true // ); + bool isBullishTrend1 = cBar.HasBullishTrend( + tmpHSW, + tmpLSW, + false // + ); + bool hasBullishTrend = + // + isBullishTrend + // + || + // + isBullishTrend1 + // + ; // // Bearish ... @@ -354,10 +369,71 @@ public: bool hasBearishPattern = HasBearishPattern(cBar); bool hasBearishPressure = cBar.HasBearishPressure(); bool isBearishTrend = cBar.HasBearishTrend( + tmpHSW, + tmpLSW, + true // + ); + bool isBearishTrend1 = cBar.HasBearishTrend( tmpHSW, tmpLSW, false // ); + bool hasBearishTrend = + // + isBearishTrend + // + || + // + isBearishTrend1 + // + ; + + // + // Define Conditions ... + MqlTick ticks[]; + int ticksCount = CopyTicks( + mSymbol, + ticks, + COPY_TICKS_ALL, + 0, + 5 // + ); + + // + bool isTicksBullishForLong = + // + GetTickEntry(ticks[0], POSITION_TYPE_BUY, mSymbol) > GetTickEntry(ticks[1], POSITION_TYPE_BUY, mSymbol) && + GetTickEntry(ticks[1], POSITION_TYPE_BUY, mSymbol) > GetTickEntry(ticks[2], POSITION_TYPE_BUY, mSymbol) && + GetTickEntry(ticks[2], POSITION_TYPE_BUY, mSymbol) > GetTickEntry(ticks[3], POSITION_TYPE_BUY, mSymbol) + // + ; + + // + bool isTicksBearishForLong = + // + GetTickEntry(ticks[0], POSITION_TYPE_BUY, mSymbol) < GetTickEntry(ticks[1], POSITION_TYPE_BUY, mSymbol) && + GetTickEntry(ticks[1], POSITION_TYPE_BUY, mSymbol) < GetTickEntry(ticks[2], POSITION_TYPE_BUY, mSymbol) && + GetTickEntry(ticks[2], POSITION_TYPE_BUY, mSymbol) < GetTickEntry(ticks[3], POSITION_TYPE_BUY, mSymbol) + // + ; + + // + bool isTicksBullishForShort = + // + GetTickEntry(ticks[0], POSITION_TYPE_SELL, mSymbol) > GetTickEntry(ticks[1], POSITION_TYPE_SELL, mSymbol) && + GetTickEntry(ticks[1], POSITION_TYPE_SELL, mSymbol) > GetTickEntry(ticks[2], POSITION_TYPE_SELL, mSymbol) && + GetTickEntry(ticks[2], POSITION_TYPE_SELL, mSymbol) > GetTickEntry(ticks[3], POSITION_TYPE_SELL, mSymbol) + // + ; + + // + bool isTicksBearishForShort = + // + GetTickEntry(ticks[0], POSITION_TYPE_SELL, mSymbol) < GetTickEntry(ticks[1], POSITION_TYPE_SELL, mSymbol) && + GetTickEntry(ticks[1], POSITION_TYPE_SELL, mSymbol) < GetTickEntry(ticks[2], POSITION_TYPE_SELL, mSymbol) && + GetTickEntry(ticks[2], POSITION_TYPE_SELL, mSymbol) < GetTickEntry(ticks[3], POSITION_TYPE_SELL, mSymbol) + // + ; // bool notHaveBearishPower = (!chmConditions.hasBearishPower && @@ -378,58 +454,20 @@ public: !chvwapConditions.hasBullishPower); // - bool isCHHKFullSwitchedToBullish = - chhkHelper.IsSwitchedToBullish(cIndex); + bool isVWapBullishOrder = + chvwapHelper.IsBullishOrder(cIndex); // - bool isCHHKFullBullishAndSorted = - chhkHelper.IsBullishSorted(cIndex); + bool isVWapSwitchedToBullishOrder = + chvwapHelper.IsSwitchedToBullishOrder(cIndex); // - bool isCHHKFullSwitchedToBearish = - chhkHelper.IsSwitchedToBearish(cIndex); + bool isVWapBearishOrder = + chvwapHelper.IsBearishOrder(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() - // - ; + bool isVWapSwitchedToBearishOrder = + chvwapHelper.IsSwitchedToBearishOrder(cIndex); // double long1SL = @@ -454,13 +492,15 @@ public: // bool hasLong1 = // - isBullishTrend && + hasBullishTrend && (hasBullishPower || hasBullishPattern || hasBullishPressure) && - hasBullishDecision && notHaveBearishPower && - isCHHKFullSwitchedToBullish + isTicksBullishForLong && + (isVWapBullishOrder || + isVWapSwitchedToBullishOrder) && + chvwapConditions.hasBullishPower // ; if (hasLong1) @@ -480,13 +520,15 @@ public: // bool hasShort1 = // - isBearishTrend && + hasBearishTrend && (hasBearishPower || hasBearishPattern || hasBearishPressure) && - hasBearishDecision && notHaveBullishPower && - isCHHKFullSwitchedToBearish + isTicksBullishForShort && + (isVWapBearishOrder || + isVWapSwitchedToBearishOrder) && + chvwapConditions.hasBearishPower // ; if (hasShort1) @@ -503,70 +545,11 @@ public: 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 - // ; // @@ -574,10 +557,6 @@ public: // hasShort1 // - || - // - hasShort2 - // ; // @@ -665,7 +644,7 @@ public: // // Protected ... -protected: + protected: // // Props ... @@ -718,7 +697,7 @@ protected: // // Private ... -private: + private: // // Props ... @@ -1084,10 +1063,10 @@ private: chvwapInputs.hcPeriod = hcPeriod; // - chvwapInputs.showShort = false; - chvwapInputs.showMedium = false; - chvwapInputs.showLong = false; - chvwapInputs.showHind = false; + chvwapInputs.showShort = true; + chvwapInputs.showMedium = true; + chvwapInputs.showLong = true; + chvwapInputs.showHind = true; // chvwapHelper = new XSCXCHVWAPHelper();