/////////////////////////////////////////////////////// // // SaherElm IT Center MQL5 Class Library // -------------------------------------- // Name: XSCXCHCHEStrategy // 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 XCHCHEStartegyToken = "XCHCHE"; // // XStrategy Class Implementation(s) ... class XSCXCHCHEStrategy : public XSCBaseStrategy { // // Public ... public: // // Constructor(s) ... void XSCXCHCHEStrategy( // // 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 ~XSCXCHCHEStrategy() { // 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 XCHCHEStartegyToken; } // // 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 = XCHCHEStartegyToken; // // 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; // // XCHCHE ... 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 // ); // // XCHCHE ... // 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 // ); } // }; //