2484 lines
58 KiB
Plaintext
2484 lines
58 KiB
Plaintext
///////////////////////////////////////////////////////
|
|
//
|
|
// SaherElm IT Center MQL5 X121 SMC Signal Class
|
|
// -------------------------------------------------
|
|
// Name: XRSPVI
|
|
// Description: provide all Signalling functions ...
|
|
//
|
|
//
|
|
// 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 "../../Libraries/x-trade.lib"
|
|
#include "../Classes/x-121.smc.market.cycle.helper.class.mq5"
|
|
#include "../Libraries/x-121.smc.lib.mq5"
|
|
|
|
//
|
|
enum ENUM_X121_SMC_XRSPVI_CONDITIONS
|
|
{
|
|
//
|
|
X121_SMC_XRSPVI_CONDITION_NONE,
|
|
X121_SMC_XRSPVI_CONDITION_1,
|
|
X121_SMC_XRSPVI_CONDITION_2,
|
|
X121_SMC_XRSPVI_CONDITION_3,
|
|
X121_SMC_XRSPVI_CONDITION_4,
|
|
X121_SMC_XRSPVI_CONDITION_5,
|
|
};
|
|
|
|
//
|
|
// Definitions ...
|
|
struct X121SMCStrategyXRSPVISignalConditions
|
|
{
|
|
//
|
|
// Props ...
|
|
|
|
//
|
|
string symbol;
|
|
ENUM_TIMEFRAMES period;
|
|
|
|
//
|
|
double sl;
|
|
double target;
|
|
ENUM_X_DIRECTION dir;
|
|
ENUM_X_POSITION_TYPES type;
|
|
|
|
//
|
|
// Setup Props ...
|
|
|
|
//
|
|
datetime setupTime;
|
|
datetime triggerTime;
|
|
|
|
//
|
|
double pivot;
|
|
double point;
|
|
|
|
//
|
|
XPriceZones priceZone;
|
|
bool isPriceZoneValidForPeak;
|
|
bool isPriceZoneValidForVale;
|
|
|
|
//
|
|
XPVPivot pivotZone;
|
|
XConsolidationZone consolidationZone;
|
|
|
|
//
|
|
ENUM_X121_SMC_XRSPVI_CONDITIONS mode;
|
|
|
|
//
|
|
// Constructor ...
|
|
X121SMCStrategyXRSPVISignalConditions()
|
|
{
|
|
Clean();
|
|
}
|
|
|
|
//
|
|
// Tools ...
|
|
|
|
/**
|
|
* Cleaning Up ...
|
|
*/
|
|
void Clean()
|
|
{
|
|
//
|
|
sl = 0;
|
|
target = 0;
|
|
|
|
//
|
|
dir = X_DIRECTION_NONE;
|
|
type = X_POSITION_TYPE_NONE;
|
|
|
|
//
|
|
symbol = NULL;
|
|
period = NULL;
|
|
setupTime = NULL;
|
|
triggerTime = NULL;
|
|
|
|
//
|
|
ExtensionClean();
|
|
}
|
|
|
|
/**
|
|
* Check Condition is Setting Up ...
|
|
*
|
|
* @param dir: ENUM_X_DIRECTION member, Setting Up Direction ...
|
|
*
|
|
* @return ( bool )
|
|
*/
|
|
bool IsSetuped()
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
result = IsValid(setupTime) &&
|
|
HasDirection(dir);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Calculate Setup Age ...
|
|
*
|
|
* @return ( int )
|
|
*/
|
|
int GetSetupAge()
|
|
{
|
|
//
|
|
int result = 0;
|
|
|
|
//
|
|
if (!IsSetuped())
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
result = (int)(TimeCurrent() - setupTime) / PeriodSeconds(period);
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Detect How we Can Trigger Signal ...
|
|
*
|
|
* @return ( bool )
|
|
*/
|
|
bool CanTrigger()
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
result =
|
|
//
|
|
sl > 0 &&
|
|
IsValid(symbol) &&
|
|
IsValid(period) &&
|
|
IsValid(triggerTime) &&
|
|
type != X_POSITION_TYPE_ALL &&
|
|
type != X_POSITION_TYPE_NONE
|
|
//
|
|
;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Extensions ...
|
|
|
|
/**
|
|
* Clean Additional Properties ...
|
|
*/
|
|
void ExtensionClean()
|
|
{
|
|
//
|
|
pivot = 0;
|
|
point = 0;
|
|
|
|
//
|
|
pivotZone.Clean();
|
|
priceZone.Clean();
|
|
consolidationZone.Clean();
|
|
isPriceZoneValidForPeak = false;
|
|
isPriceZoneValidForVale = false;
|
|
|
|
//
|
|
mode = X121_SMC_XRSPVI_CONDITION_NONE;
|
|
}
|
|
|
|
//
|
|
};
|
|
|
|
//
|
|
// Signaller Data Sources ...
|
|
X121SMCStrategyXRSPVISignalConditions mXRSPVIConditions;
|
|
X121SMCStrategyXRSPVISignalConditions mXRSPVIConditionsCollection[];
|
|
|
|
//
|
|
double X121SMCXRSPVIPivotPeak;
|
|
double X121SMCXRSPVIPivotVale;
|
|
datetime X121SMCXRSPVIPivotEnd;
|
|
datetime X121SMCXRSPVIPivotStart;
|
|
ENUM_XPV_PIVOTS X121SMCXRSPVIPivotType = XPV_NONE;
|
|
|
|
//
|
|
// Extension Functions ...
|
|
|
|
//
|
|
// Detect Setup Conditions ...
|
|
bool DetectX121SMCXRSPVISiganlSetup(
|
|
string _symbol,
|
|
ENUM_TIMEFRAMES _period,
|
|
//
|
|
X121SMCStrategyXRSPVISignalConditions &conditions,
|
|
//
|
|
XC121SMCCycleHelper *triggerCycleHelper,
|
|
XC121SMCCycleHelper *decisionCycleHelper,
|
|
XC121SMCCycleHelper *analyseCycleHelper,
|
|
XC121SMCCycleHelper *verificationCycleHelper,
|
|
XC121SMCCycleHelper *consolidationCycleHelper,
|
|
XC121SMCCycleHelper *visionCycleHelper
|
|
//
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
bool isBullish = false;
|
|
bool isBearish = false;
|
|
|
|
//
|
|
int zIndex = 0;
|
|
int cIndex = zIndex + 1;
|
|
int pIndex = cIndex + 1;
|
|
int ppIndex = pIndex + 1;
|
|
|
|
//
|
|
int loopback = 10;
|
|
|
|
//
|
|
string symbol = _symbol;
|
|
ENUM_TIMEFRAMES period = _period;
|
|
|
|
//
|
|
conditions.symbol = symbol;
|
|
conditions.period = period;
|
|
|
|
//
|
|
XOHCL zBar;
|
|
result = zBar.Init(
|
|
symbol,
|
|
period,
|
|
zIndex //
|
|
);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
XOHCL cBar;
|
|
result = cBar.Init(
|
|
symbol,
|
|
period,
|
|
cIndex //
|
|
);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
XOHCL pBar;
|
|
result = pBar.Init(
|
|
symbol,
|
|
period,
|
|
pIndex //
|
|
);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
double ask = GetAsk(symbol);
|
|
double bid = GetBid(symbol);
|
|
datetime cTime = TimeCurrent();
|
|
double points = GetPoints(symbol);
|
|
|
|
//
|
|
int swingLoopback = 3;
|
|
double ll = cBar.FindLowest(swingLoopback, MODE_LOW);
|
|
double hh = cBar.FindHighest(swingLoopback, MODE_HIGH);
|
|
double llDown = cBar.FindLowesttDown(swingLoopback);
|
|
double hhUp = cBar.FindHighestUp(swingLoopback);
|
|
|
|
//
|
|
// Cycles Conditions ...
|
|
|
|
//
|
|
// Trigger ...
|
|
ENUM_XPOI_EVENTS triggerPoiEvents[];
|
|
ENUM_X_CYCLE_EVENTS triggerCycleEvents[];
|
|
X121SMCCycleConditions triggerConditions;
|
|
result = triggerCycleHelper.GetConditions(
|
|
triggerCycleEvents,
|
|
triggerPoiEvents,
|
|
triggerConditions,
|
|
zIndex,
|
|
loopback //
|
|
);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Decision ...
|
|
ENUM_XPOI_EVENTS decisionPoiEvents[];
|
|
ENUM_X_CYCLE_EVENTS decisionCycleEvents[];
|
|
X121SMCCycleConditions decisionConditions;
|
|
result = decisionCycleHelper.GetConditions(
|
|
decisionCycleEvents,
|
|
decisionPoiEvents,
|
|
decisionConditions,
|
|
zIndex,
|
|
loopback //
|
|
);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Analyse ...
|
|
ENUM_XPOI_EVENTS analysePoiEvents[];
|
|
ENUM_X_CYCLE_EVENTS analyseCycleEvents[];
|
|
X121SMCCycleConditions analyseConditions;
|
|
result = analyseCycleHelper.GetConditions(
|
|
analyseCycleEvents,
|
|
analysePoiEvents,
|
|
analyseConditions,
|
|
zIndex,
|
|
loopback //
|
|
);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Verification ...
|
|
ENUM_XPOI_EVENTS verificationPoiEvents[];
|
|
ENUM_X_CYCLE_EVENTS verificationCycleEvents[];
|
|
X121SMCCycleConditions verificationConditions;
|
|
result = verificationCycleHelper.GetConditions(
|
|
verificationCycleEvents,
|
|
verificationPoiEvents,
|
|
verificationConditions,
|
|
zIndex,
|
|
loopback //
|
|
);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Consolidation ...
|
|
ENUM_XPOI_EVENTS consolidationPoiEvents[];
|
|
ENUM_X_CYCLE_EVENTS consolidationCycleEvents[];
|
|
X121SMCCycleConditions consolidationConditions;
|
|
result = consolidationCycleHelper.GetConditions(
|
|
consolidationCycleEvents,
|
|
consolidationPoiEvents,
|
|
consolidationConditions,
|
|
zIndex,
|
|
loopback //
|
|
);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Vision ...
|
|
ENUM_XPOI_EVENTS visionPoiEvents[];
|
|
ENUM_X_CYCLE_EVENTS visionCycleEvents[];
|
|
X121SMCCycleConditions visionConditions;
|
|
result = visionCycleHelper.GetConditions(
|
|
visionCycleEvents,
|
|
visionPoiEvents,
|
|
visionConditions,
|
|
zIndex,
|
|
loopback //
|
|
);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Cycles POI States ...
|
|
XPOIState triggerState = triggerConditions.state;
|
|
XPOIState decisionState = decisionConditions.state;
|
|
XPOIState analyseState = analyseConditions.state;
|
|
XPOIState verificationState = verificationConditions.state;
|
|
XPOIState consolidationState = consolidationConditions.state;
|
|
XPOIState visionState = visionConditions.state;
|
|
|
|
//
|
|
// Cycle X121Conditions ...
|
|
X121Conditions triggerXConditions = triggerConditions.x121Conditions;
|
|
X121Conditions decisionXConditions = decisionConditions.x121Conditions;
|
|
X121Conditions analyseXConditions = analyseConditions.x121Conditions;
|
|
X121Conditions verificationXConditions = verificationConditions.x121Conditions;
|
|
X121Conditions consolidationXConditions = consolidationConditions.x121Conditions;
|
|
X121Conditions visionXConditions = visionConditions.x121Conditions;
|
|
|
|
//
|
|
// Setup Conditions ...
|
|
|
|
//
|
|
// Detect Trend ...
|
|
|
|
//
|
|
// Consolidation ...
|
|
ENUM_X_DIRECTION consolidationTrendDir;
|
|
bool hasConsolidationTrend =
|
|
consolidationCycleHelper
|
|
.DetectMarketStructure(
|
|
consolidationTrendDir //
|
|
);
|
|
bool hasConsolidationBullishTrend =
|
|
hasConsolidationTrend &&
|
|
IsBullish(consolidationTrendDir);
|
|
bool hasConsolidationBearishTrend =
|
|
hasConsolidationTrend &&
|
|
IsBearish(consolidationTrendDir);
|
|
|
|
//
|
|
// Verification ...
|
|
ENUM_X_DIRECTION verificationTrendDir;
|
|
bool hasVerificationTrend =
|
|
verificationCycleHelper
|
|
.DetectMarketStructure(
|
|
verificationTrendDir //
|
|
);
|
|
bool hasVerificationBullishTrend =
|
|
hasVerificationTrend &&
|
|
IsBullish(verificationTrendDir);
|
|
bool hasVerificationBearishTrend =
|
|
hasVerificationTrend &&
|
|
IsBearish(verificationTrendDir);
|
|
|
|
//
|
|
// Analyse ...
|
|
ENUM_X_DIRECTION analyseTrendDir;
|
|
bool hasAnalyseTrend =
|
|
analyseCycleHelper
|
|
.DetectMarketStructure(
|
|
analyseTrendDir //
|
|
);
|
|
bool hasAnalyseBullishTrend =
|
|
hasAnalyseTrend &&
|
|
IsBullish(analyseTrendDir);
|
|
bool hasAnalyseBearishTrend =
|
|
hasAnalyseTrend &&
|
|
IsBearish(analyseTrendDir);
|
|
|
|
//
|
|
// Decision ...
|
|
ENUM_X_DIRECTION decisionTrendDir;
|
|
bool hasDecisionTrend =
|
|
decisionCycleHelper
|
|
.DetectMarketStructure(
|
|
decisionTrendDir //
|
|
);
|
|
bool hasDecisionBullishTrend =
|
|
hasDecisionTrend &&
|
|
IsBullish(decisionTrendDir);
|
|
bool hasDecisionBearishTrend =
|
|
hasDecisionTrend &&
|
|
IsBearish(decisionTrendDir);
|
|
|
|
//
|
|
// Detect Bar State ...
|
|
|
|
//
|
|
// Engulf ...
|
|
ENUM_X_DIRECTION cBarEngulfDir;
|
|
bool isCBarEngulfed = decisionCycleHelper
|
|
.mBarAnalyser
|
|
.IsEngulfBar(
|
|
cBar,
|
|
cBarEngulfDir,
|
|
0 // Extended ...
|
|
);
|
|
bool isCBarBullishEngulfed =
|
|
isCBarEngulfed &&
|
|
IsBullish(cBarEngulfDir);
|
|
bool isCBarBearishEngulfed =
|
|
isCBarEngulfed &&
|
|
IsBearish(cBarEngulfDir);
|
|
|
|
//
|
|
// Momentum ...
|
|
ENUM_X_DIRECTION cBarMomentumDir;
|
|
bool isCBarMomentum = decisionCycleHelper
|
|
.mBarAnalyser
|
|
.IsMomentumBar(
|
|
cBar,
|
|
cBarMomentumDir,
|
|
0 // Extended ...
|
|
);
|
|
bool isCBarBullishMomentum =
|
|
isCBarMomentum &&
|
|
IsBullish(cBarMomentumDir);
|
|
bool isCBarBearishMomentum =
|
|
isCBarMomentum &&
|
|
IsBearish(cBarMomentumDir);
|
|
|
|
//
|
|
// Reject ...
|
|
ENUM_X_DIRECTION cBarRejectDir;
|
|
bool isCBarRejected = decisionCycleHelper
|
|
.mBarAnalyser
|
|
.IsRejectionBar(
|
|
cBar,
|
|
cBarRejectDir,
|
|
0 // Extended ...
|
|
);
|
|
bool isCBarBullishRejected =
|
|
isCBarRejected &&
|
|
IsBullish(cBarRejectDir);
|
|
bool isCBarBearishRejected =
|
|
isCBarRejected &&
|
|
IsBearish(cBarRejectDir);
|
|
|
|
//
|
|
// HH/LL Break ...
|
|
|
|
//
|
|
bool isCBarBreaksUpHH = IsBarBreak(
|
|
hh,
|
|
X_DIRECTION_BULLISH,
|
|
cBar //
|
|
);
|
|
|
|
//
|
|
bool isCBarBreaksDownLL = IsBarBreak(
|
|
hh,
|
|
X_DIRECTION_BEARISH,
|
|
cBar //
|
|
);
|
|
|
|
//
|
|
// Bar Checking Summary ...
|
|
|
|
//
|
|
// Bullish ...
|
|
bool isCBarBullishFormed =
|
|
//
|
|
isCBarBreaksUpHH ||
|
|
isCBarBullishEngulfed ||
|
|
isCBarBullishMomentum ||
|
|
isCBarBullishRejected
|
|
//
|
|
;
|
|
|
|
//
|
|
// Bearish ...
|
|
bool isCBarBearishFormed =
|
|
//
|
|
isCBarBreaksDownLL ||
|
|
isCBarBearishEngulfed ||
|
|
isCBarBearishMomentum ||
|
|
isCBarBearishRejected
|
|
//
|
|
;
|
|
|
|
//
|
|
// Detect Price Zone ...
|
|
|
|
//
|
|
double pzPeak = decisionXConditions.peaksBuffer[1];
|
|
double pzVale = decisionXConditions.valesBuffer[1];
|
|
|
|
//
|
|
// Detecting Decision Price ones ...
|
|
XPriceZones decisionPriceZone;
|
|
bool hasDecisionPriceZone = CalculatePriceInsideZones(
|
|
decisionPriceZone,
|
|
decisionState,
|
|
cBar //
|
|
);
|
|
double decisionPriceZoneUpper = 0;
|
|
double decisionPriceZoneLower = 0;
|
|
bool isDecisionPriceZoneBullish = false;
|
|
bool isDecisionPriceZoneBearish = false;
|
|
bool isDecisionPriceZoneValidForPeak = false;
|
|
bool isDecisionPriceZoneValidForVale = false;
|
|
|
|
//
|
|
if (hasDecisionPriceZone)
|
|
{
|
|
//
|
|
bool hasBoundary = decisionPriceZone.GetBoundary(
|
|
X_DIRECTION_ALL,
|
|
decisionPriceZoneUpper,
|
|
decisionPriceZoneLower //
|
|
);
|
|
|
|
//
|
|
isDecisionPriceZoneValidForPeak =
|
|
hasBoundary &&
|
|
pzPeak <= decisionPriceZoneUpper &&
|
|
pzPeak >= decisionPriceZoneLower;
|
|
|
|
//
|
|
isDecisionPriceZoneValidForVale =
|
|
hasBoundary &&
|
|
pzVale <= decisionPriceZoneUpper &&
|
|
pzVale >= decisionPriceZoneLower;
|
|
|
|
//
|
|
isDecisionPriceZoneBullish =
|
|
hasBoundary &&
|
|
decisionPriceZone.IsBullish();
|
|
|
|
//
|
|
isDecisionPriceZoneBearish =
|
|
hasBoundary &&
|
|
decisionPriceZone.IsBearish();
|
|
}
|
|
|
|
//
|
|
// Detecting Analyse Price ones ...
|
|
XPriceZones analysePriceZone;
|
|
bool hasAnalysePriceZone = CalculatePriceInsideZones(
|
|
analysePriceZone,
|
|
analyseState,
|
|
cBar //
|
|
);
|
|
double analysePriceZoneUpper = 0;
|
|
double analysePriceZoneLower = 0;
|
|
bool isAnalysePriceZoneBullish = false;
|
|
bool isAnalysePriceZoneBearish = false;
|
|
bool isAnalysePriceZoneValidForPeak = false;
|
|
bool isAnalysePriceZoneValidForVale = false;
|
|
|
|
//
|
|
if (hasAnalysePriceZone)
|
|
{
|
|
//
|
|
bool hasBoundary = analysePriceZone.GetBoundary(
|
|
X_DIRECTION_ALL,
|
|
analysePriceZoneUpper,
|
|
analysePriceZoneLower //
|
|
);
|
|
|
|
//
|
|
isAnalysePriceZoneValidForPeak =
|
|
hasBoundary &&
|
|
pzPeak <= analysePriceZoneUpper &&
|
|
pzPeak >= analysePriceZoneLower;
|
|
|
|
//
|
|
isAnalysePriceZoneValidForVale =
|
|
hasBoundary &&
|
|
pzVale <= analysePriceZoneUpper &&
|
|
pzVale >= analysePriceZoneLower;
|
|
|
|
//
|
|
isAnalysePriceZoneBullish =
|
|
hasBoundary &&
|
|
analysePriceZone.IsBullish();
|
|
|
|
//
|
|
isAnalysePriceZoneBearish =
|
|
hasBoundary &&
|
|
analysePriceZone.IsBearish();
|
|
}
|
|
|
|
//
|
|
// Detecting Verification Price ones ...
|
|
XPriceZones verificationPriceZone;
|
|
bool hasVerificationPriceZone = CalculatePriceInsideZones(
|
|
verificationPriceZone,
|
|
verificationState,
|
|
cBar //
|
|
);
|
|
double verificationPriceZoneUpper = 0;
|
|
double verificationPriceZoneLower = 0;
|
|
bool isVerificationPriceZoneBullish = false;
|
|
bool isVerificationPriceZoneBearish = false;
|
|
bool isVerificationPriceZoneValidForPeak = false;
|
|
bool isVerificationPriceZoneValidForVale = false;
|
|
|
|
//
|
|
if (hasVerificationPriceZone)
|
|
{
|
|
//
|
|
bool hasBoundary = verificationPriceZone.GetBoundary(
|
|
X_DIRECTION_ALL,
|
|
verificationPriceZoneUpper,
|
|
verificationPriceZoneLower //
|
|
);
|
|
|
|
//
|
|
isVerificationPriceZoneValidForPeak =
|
|
hasBoundary &&
|
|
pzPeak <= verificationPriceZoneUpper &&
|
|
pzPeak >= verificationPriceZoneLower;
|
|
|
|
//
|
|
isVerificationPriceZoneValidForVale =
|
|
hasBoundary &&
|
|
pzVale <= verificationPriceZoneUpper &&
|
|
pzVale >= verificationPriceZoneLower;
|
|
|
|
//
|
|
isVerificationPriceZoneBullish =
|
|
hasBoundary &&
|
|
verificationPriceZone.IsBullish();
|
|
|
|
//
|
|
isVerificationPriceZoneBearish =
|
|
hasBoundary &&
|
|
verificationPriceZone.IsBearish();
|
|
}
|
|
|
|
//
|
|
// Detect Consolidation Zone ...
|
|
int decisionConsolidationLoopback = 7;
|
|
double decisionConsolidationZoneLower = 0;
|
|
double decisionConsolidationZoneUpper = 0;
|
|
bool isDecisionConsolidationZoneBreaked = false;
|
|
bool isDecisionConsolidationZoneBreakedUp = false;
|
|
bool isDecisionConsolidationZoneBreakedDown = false;
|
|
bool hasDecisionConsolidationZone = conditions.consolidationZone.IsValid();
|
|
|
|
//
|
|
if (!hasDecisionConsolidationZone)
|
|
{
|
|
//
|
|
XOHCL decisionCBar;
|
|
bool isInited = decisionCBar.Init(
|
|
decisionCycleHelper.GetSymbol(),
|
|
decisionCycleHelper.GetPeriod(),
|
|
cIndex //
|
|
);
|
|
|
|
//
|
|
if (isInited)
|
|
{
|
|
//
|
|
double upper = 0;
|
|
double lower = 0;
|
|
hasDecisionConsolidationZone =
|
|
triggerCycleHelper
|
|
.mBarAnalyser
|
|
.IsConsolidate(
|
|
decisionCBar,
|
|
upper,
|
|
lower,
|
|
decisionConsolidationLoopback //
|
|
);
|
|
|
|
//
|
|
if (hasDecisionConsolidationZone)
|
|
{
|
|
//
|
|
hasDecisionConsolidationZone = conditions.consolidationZone.Init(
|
|
cBar.symbol,
|
|
cBar.period,
|
|
upper,
|
|
lower,
|
|
decisionConsolidationLoopback //
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
if (hasDecisionConsolidationZone)
|
|
{
|
|
//
|
|
conditions.consolidationZone.Update();
|
|
|
|
//
|
|
decisionConsolidationZoneLower = conditions.consolidationZone.upper;
|
|
decisionConsolidationZoneUpper = conditions.consolidationZone.lower;
|
|
|
|
//
|
|
isDecisionConsolidationZoneBreaked = conditions.consolidationZone.IsBreaked();
|
|
isDecisionConsolidationZoneBreakedUp =
|
|
isDecisionConsolidationZoneBreaked &&
|
|
IsBullish(conditions.consolidationZone.breakDirection);
|
|
isDecisionConsolidationZoneBreakedDown =
|
|
isDecisionConsolidationZoneBreaked &&
|
|
IsBearish(conditions.consolidationZone.breakDirection);
|
|
|
|
//
|
|
decisionConsolidationZoneLower = triggerXConditions.peaksBuffer[1];
|
|
decisionConsolidationZoneUpper = triggerXConditions.valesBuffer[1];
|
|
|
|
//
|
|
if (isDecisionConsolidationZoneBreaked)
|
|
{
|
|
conditions.consolidationZone.Clean();
|
|
}
|
|
}
|
|
|
|
//
|
|
//
|
|
//
|
|
|
|
//
|
|
double decisionPVMiddle = decisionXConditions.valesBuffer[1] +
|
|
(decisionXConditions.peaksBuffer[1] - decisionXConditions.valesBuffer[1]) / 2;
|
|
bool isInDecisionPremium =
|
|
//
|
|
ask > decisionPVMiddle &&
|
|
bid > decisionPVMiddle &&
|
|
//
|
|
ask < decisionXConditions.peaksBuffer[1] &&
|
|
bid < decisionXConditions.peaksBuffer[1]
|
|
//
|
|
;
|
|
bool isInDecisionDiscount =
|
|
//
|
|
ask < decisionPVMiddle &&
|
|
bid < decisionPVMiddle &&
|
|
//
|
|
ask < decisionXConditions.valesBuffer[1] &&
|
|
bid < decisionXConditions.valesBuffer[1]
|
|
//
|
|
;
|
|
|
|
//
|
|
double analysePVMiddle = analyseXConditions.valesBuffer[1] +
|
|
(analyseXConditions.peaksBuffer[1] - analyseXConditions.valesBuffer[1]) / 2;
|
|
bool isInAnalysePremium =
|
|
//
|
|
ask > analysePVMiddle &&
|
|
bid > analysePVMiddle &&
|
|
//
|
|
ask < analyseXConditions.peaksBuffer[1] &&
|
|
bid < analyseXConditions.peaksBuffer[1]
|
|
//
|
|
;
|
|
bool isInAnalyseDiscount =
|
|
//
|
|
ask < analysePVMiddle &&
|
|
bid < analysePVMiddle &&
|
|
//
|
|
ask < analyseXConditions.valesBuffer[1] &&
|
|
bid < analyseXConditions.valesBuffer[1]
|
|
//
|
|
;
|
|
|
|
//
|
|
double verificationPVMiddle = verificationXConditions.valesBuffer[1] +
|
|
(verificationXConditions.peaksBuffer[1] - verificationXConditions.valesBuffer[1]) / 2;
|
|
bool isInVerificationPremium =
|
|
//
|
|
ask > verificationPVMiddle &&
|
|
bid > verificationPVMiddle &&
|
|
//
|
|
ask < verificationXConditions.peaksBuffer[1] &&
|
|
bid < verificationXConditions.peaksBuffer[1]
|
|
//
|
|
;
|
|
bool isInVerificationDiscount =
|
|
//
|
|
ask < verificationPVMiddle &&
|
|
bid < verificationPVMiddle &&
|
|
//
|
|
ask < verificationXConditions.valesBuffer[1] &&
|
|
bid < verificationXConditions.valesBuffer[1]
|
|
//
|
|
;
|
|
|
|
//
|
|
// Detect PV Pivot ...
|
|
|
|
//
|
|
bool isPivotPeakZoneRejected = false;
|
|
bool isPivotPeakZoneBreakedUp = false;
|
|
bool isPivotPeakZoneBreakedDown = false;
|
|
bool isPivotValeZoneRejected = false;
|
|
bool isPivotValeZoneBreakedUp = false;
|
|
bool isPivotValeZoneBreakedDown = false;
|
|
bool hasPivot = conditions.pivotZone.IsValid();
|
|
if (!hasPivot)
|
|
{
|
|
//
|
|
hasPivot = IsValid(X121SMCXRSPVIPivotStart);
|
|
if (!hasPivot)
|
|
{
|
|
//
|
|
bool isNewVale = decisionXConditions.isNewVale;
|
|
bool isNewValeOverLast = decisionXConditions.isNewValeOverLast;
|
|
bool isNewValeUnderLast = decisionXConditions.isNewValeUnderLast;
|
|
bool isSameVales = decisionXConditions.valesBuffer[1] ==
|
|
decisionXConditions.valesBuffer[2] &&
|
|
decisionXConditions.valesBuffer[2] ==
|
|
decisionXConditions.valesBuffer[3];
|
|
bool isSameCycleVales = decisionXConditions.valesBuffer[1] ==
|
|
analyseXConditions.valesBuffer[1] &&
|
|
analyseXConditions.valesBuffer[1] ==
|
|
verificationXConditions.valesBuffer[1];
|
|
|
|
//
|
|
bool isNewPeak = decisionXConditions.isNewPeak;
|
|
bool isNewPeakOverLast = decisionXConditions.isNewPeakOverLast;
|
|
bool isNewPeakUnderLast = decisionXConditions.isNewPeakUnderLast;
|
|
bool isSamePeaks = decisionXConditions.peaksBuffer[1] ==
|
|
decisionXConditions.peaksBuffer[2] &&
|
|
decisionXConditions.peaksBuffer[2] ==
|
|
decisionXConditions.peaksBuffer[3];
|
|
bool isSameCyclePeaks = decisionXConditions.peaksBuffer[1] ==
|
|
analyseXConditions.peaksBuffer[1] &&
|
|
analyseXConditions.peaksBuffer[1] ==
|
|
verificationXConditions.peaksBuffer[1];
|
|
|
|
//
|
|
bool isValeStart =
|
|
// isSameVales;
|
|
isSameVales &&
|
|
isSameCycleVales;
|
|
bool isPeakStart =
|
|
// isSamePeaks;
|
|
isSamePeaks &&
|
|
isSameCyclePeaks;
|
|
|
|
//
|
|
bool isStart = isPeakStart ||
|
|
isValeStart;
|
|
if (isStart)
|
|
{
|
|
//
|
|
X121SMCXRSPVIPivotStart = cTime;
|
|
X121SMCXRSPVIPivotType =
|
|
isPeakStart
|
|
? XPV_PEAK
|
|
: XPV_VALE;
|
|
|
|
//
|
|
X121SMCXRSPVIPivotPeak = decisionXConditions.peaksBuffer[1];
|
|
X121SMCXRSPVIPivotVale = decisionXConditions.valesBuffer[1];
|
|
}
|
|
|
|
//
|
|
hasPivot = IsValid(X121SMCXRSPVIPivotStart);
|
|
|
|
//
|
|
// Create XPVPivot instance ...
|
|
if (hasPivot)
|
|
{
|
|
//
|
|
conditions.pivotZone.symbol = symbol;
|
|
conditions.pivotZone.period = period;
|
|
|
|
//
|
|
conditions.pivotZone.to = cTime;
|
|
conditions.pivotZone.repetition = 3;
|
|
|
|
//
|
|
conditions.pivotZone.upper = X121SMCXRSPVIPivotPeak;
|
|
conditions.pivotZone.lower = X121SMCXRSPVIPivotVale;
|
|
|
|
//
|
|
conditions.pivotZone.type = X121SMCXRSPVIPivotType;
|
|
conditions.pivotZone.from = X121SMCXRSPVIPivotStart;
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
if (hasPivot)
|
|
{
|
|
//
|
|
bool isBreaked = X121SMCXRSPVIPivotType == XPV_PEAK
|
|
? decisionXConditions.isBreakedUpPrevPeak
|
|
: decisionXConditions.isBreakedDownPrevVale;
|
|
|
|
//
|
|
if (!isBreaked)
|
|
{
|
|
//
|
|
X121SMCXRSPVIPivotPeak = decisionXConditions.peaksBuffer[1];
|
|
X121SMCXRSPVIPivotVale = decisionXConditions.valesBuffer[1];
|
|
|
|
//
|
|
conditions.pivotZone.to = cTime;
|
|
conditions.pivotZone.repetition++;
|
|
conditions.pivotZone.upper = X121SMCXRSPVIPivotPeak;
|
|
conditions.pivotZone.lower = X121SMCXRSPVIPivotVale;
|
|
}
|
|
else
|
|
{
|
|
//
|
|
X121SMCXRSPVIPivotEnd = cTime;
|
|
conditions.pivotZone.to = cTime;
|
|
}
|
|
|
|
//
|
|
// Fill Pivot State ...
|
|
|
|
//
|
|
XPOIState analysePivotState;
|
|
DetectPivotPOIs(
|
|
conditions.pivotZone,
|
|
analyseState,
|
|
analysePivotState //
|
|
);
|
|
|
|
//
|
|
XPOIState decisionPivotState;
|
|
DetectPivotPOIs(
|
|
conditions.pivotZone,
|
|
decisionState,
|
|
decisionPivotState //
|
|
);
|
|
|
|
//
|
|
// Combine two State ...
|
|
XPOIState combinedPivotState;
|
|
XPOIState iStates[];
|
|
AddRef(
|
|
analysePivotState,
|
|
iStates //
|
|
);
|
|
AddRef(
|
|
decisionPivotState,
|
|
iStates //
|
|
);
|
|
CombineStates(
|
|
combinedPivotState,
|
|
iStates //
|
|
);
|
|
combinedPivotState = decisionPivotState;
|
|
|
|
//
|
|
ArrayFree(iStates);
|
|
|
|
//
|
|
combinedPivotState.time = decisionPivotState.time;
|
|
combinedPivotState.symbol = decisionPivotState.symbol;
|
|
combinedPivotState.period = decisionPivotState.period;
|
|
|
|
//
|
|
// Hold Only Areas Which on Upper or Lower bondary of Pivot Zone ...
|
|
FilterPivotState(
|
|
conditions.pivotZone,
|
|
combinedPivotState //
|
|
);
|
|
|
|
//
|
|
conditions.pivotZone.state = combinedPivotState;
|
|
|
|
//
|
|
double peakUpper = 0;
|
|
double peakLower = 0;
|
|
double valeUpper = 0;
|
|
double valeLower = 0;
|
|
|
|
//
|
|
datetime peakTo = NULL;
|
|
datetime valeTo = NULL;
|
|
datetime peakFrom = NULL;
|
|
datetime valeFrom = NULL;
|
|
|
|
//
|
|
bool hasBoxData = DetectPivotStateBoxData(
|
|
conditions.pivotZone,
|
|
peakUpper,
|
|
peakLower,
|
|
peakFrom,
|
|
peakTo,
|
|
valeUpper,
|
|
valeLower,
|
|
valeFrom,
|
|
valeTo //
|
|
);
|
|
|
|
//
|
|
// Calculate Pivot Tick Zones ...
|
|
|
|
//
|
|
int ticksLevels = decisionCycleHelper
|
|
.mPOIDetector
|
|
.TicksRangeZoneLevel();
|
|
int ticksRange = decisionCycleHelper
|
|
.mPOIDetector
|
|
.TicksRangeZoneRange();
|
|
|
|
//
|
|
CalculatePivotTickZone(
|
|
conditions.pivotZone,
|
|
ticksLevels,
|
|
ticksRange //
|
|
);
|
|
|
|
//
|
|
isPivotPeakZoneRejected =
|
|
hasBoxData &&
|
|
(
|
|
//
|
|
IsBarReject(
|
|
peakLower,
|
|
X_DIRECTION_BEARISH,
|
|
cBar //
|
|
)
|
|
//
|
|
||
|
|
//
|
|
IsBarReject(
|
|
peakUpper,
|
|
X_DIRECTION_BEARISH,
|
|
cBar //
|
|
)
|
|
//
|
|
);
|
|
isPivotPeakZoneBreakedUp =
|
|
hasBoxData &&
|
|
IsBarBreak(
|
|
peakUpper,
|
|
X_DIRECTION_BULLISH,
|
|
cBar //
|
|
);
|
|
isPivotPeakZoneBreakedDown =
|
|
hasBoxData &&
|
|
IsBarBreak(
|
|
peakLower,
|
|
X_DIRECTION_BEARISH,
|
|
cBar //
|
|
);
|
|
|
|
//
|
|
isPivotValeZoneRejected =
|
|
hasBoxData &&
|
|
(
|
|
//
|
|
IsBarReject(
|
|
valeLower,
|
|
X_DIRECTION_BULLISH,
|
|
cBar //
|
|
)
|
|
//
|
|
||
|
|
//
|
|
IsBarReject(
|
|
valeUpper,
|
|
X_DIRECTION_BULLISH,
|
|
cBar //
|
|
)
|
|
//
|
|
);
|
|
isPivotValeZoneBreakedUp =
|
|
hasBoxData &&
|
|
IsBarBreak(
|
|
valeUpper,
|
|
X_DIRECTION_BULLISH,
|
|
cBar //
|
|
);
|
|
isPivotValeZoneBreakedDown =
|
|
hasBoxData &&
|
|
IsBarBreak(
|
|
valeLower,
|
|
X_DIRECTION_BEARISH,
|
|
cBar //
|
|
);
|
|
}
|
|
|
|
//
|
|
bool isPivotEnded = IsValid(X121SMCXRSPVIPivotEnd);
|
|
if (isPivotEnded)
|
|
{
|
|
//
|
|
X121SMCXRSPVIPivotPeak = 0;
|
|
X121SMCXRSPVIPivotVale = 0;
|
|
X121SMCXRSPVIPivotEnd = NULL;
|
|
X121SMCXRSPVIPivotStart = NULL;
|
|
X121SMCXRSPVIPivotType = XPV_NONE;
|
|
|
|
//
|
|
conditions.pivotZone.Clean();
|
|
}
|
|
|
|
//
|
|
// Summarize Conditions ...
|
|
|
|
//
|
|
bool isCond1Bullish =
|
|
//
|
|
isInAnalyseDiscount &&
|
|
isInDecisionDiscount &&
|
|
isCBarBullishFormed &&
|
|
//
|
|
hasAnalysePriceZone &&
|
|
isAnalysePriceZoneBullish &&
|
|
isAnalysePriceZoneValidForVale &&
|
|
//
|
|
analyseXConditions.isRsiCrossedOverOverSold &&
|
|
//
|
|
true
|
|
//
|
|
;
|
|
|
|
//
|
|
bool isCond1Bearish =
|
|
//
|
|
isInAnalysePremium &&
|
|
isInDecisionPremium &&
|
|
isCBarBearishFormed &&
|
|
//
|
|
hasAnalysePriceZone &&
|
|
isAnalysePriceZoneBearish &&
|
|
isAnalysePriceZoneValidForPeak &&
|
|
//
|
|
analyseXConditions.isRsiCrossedUnderOverBought &&
|
|
//
|
|
true
|
|
//
|
|
;
|
|
|
|
//
|
|
bool hasCond1Condition = isCond1Bullish ||
|
|
isCond1Bearish;
|
|
if (hasCond1Condition)
|
|
{
|
|
//
|
|
conditions.mode = X121_SMC_XRSPVI_CONDITION_1;
|
|
|
|
//
|
|
ENUM_X_DIRECTION pzDir =
|
|
isCond1Bullish
|
|
? X_DIRECTION_BULLISH
|
|
: X_DIRECTION_BEARISH;
|
|
|
|
//
|
|
conditions.priceZone = analysePriceZone;
|
|
conditions.isPriceZoneValidForPeak = isAnalysePriceZoneValidForPeak;
|
|
conditions.isPriceZoneValidForVale = isAnalysePriceZoneValidForVale;
|
|
|
|
//
|
|
pzPeak = analysePriceZoneUpper;
|
|
pzVale = analysePriceZoneLower;
|
|
|
|
//
|
|
double point = GetEntry(
|
|
conditions.symbol,
|
|
pzDir //
|
|
);
|
|
|
|
//
|
|
// Manipulate Conditions Point ...
|
|
|
|
//
|
|
conditions.point = point;
|
|
|
|
//
|
|
// Manipulate Conditions Pivot ...
|
|
|
|
//
|
|
conditions.pivot =
|
|
isCond1Bullish
|
|
? pzVale
|
|
: pzPeak;
|
|
}
|
|
|
|
//
|
|
//
|
|
//
|
|
|
|
//
|
|
bool isCond2Bullish =
|
|
//
|
|
hasDecisionBullishTrend &&
|
|
//
|
|
isCBarBullishFormed &&
|
|
isInAnalyseDiscount &&
|
|
isInVerificationDiscount &&
|
|
//
|
|
hasVerificationPriceZone &&
|
|
isVerificationPriceZoneBullish &&
|
|
isVerificationPriceZoneValidForVale &&
|
|
//
|
|
verificationXConditions.isRsiCrossedOverOverSold &&
|
|
//
|
|
true
|
|
//
|
|
;
|
|
|
|
//
|
|
bool isCond2Bearish =
|
|
//
|
|
hasDecisionBearishTrend &&
|
|
//
|
|
isCBarBearishFormed &&
|
|
isInAnalysePremium &&
|
|
isInVerificationPremium &&
|
|
//
|
|
hasVerificationPriceZone &&
|
|
isVerificationPriceZoneBearish &&
|
|
isVerificationPriceZoneValidForPeak &&
|
|
//
|
|
verificationXConditions.isRsiCrossedUnderOverBought &&
|
|
//
|
|
true
|
|
//
|
|
;
|
|
|
|
//
|
|
bool hasCond2Condition = isCond2Bullish ||
|
|
isCond2Bearish;
|
|
if (hasCond2Condition)
|
|
{
|
|
//
|
|
conditions.mode = X121_SMC_XRSPVI_CONDITION_2;
|
|
|
|
//
|
|
ENUM_X_DIRECTION pzDir =
|
|
isCond2Bullish
|
|
? X_DIRECTION_BULLISH
|
|
: X_DIRECTION_BEARISH;
|
|
|
|
//
|
|
conditions.priceZone = verificationPriceZone;
|
|
conditions.isPriceZoneValidForPeak = isVerificationPriceZoneValidForPeak;
|
|
conditions.isPriceZoneValidForVale = isVerificationPriceZoneValidForVale;
|
|
|
|
//
|
|
pzPeak = verificationPriceZoneUpper;
|
|
pzVale = verificationPriceZoneLower;
|
|
|
|
//
|
|
double point = GetEntry(
|
|
conditions.symbol,
|
|
pzDir //
|
|
);
|
|
|
|
//
|
|
// Manipulate Conditions Point ...
|
|
|
|
//
|
|
conditions.point = point;
|
|
|
|
//
|
|
// Manipulate Conditions Pivot ...
|
|
|
|
//
|
|
conditions.pivot =
|
|
isCond2Bullish
|
|
? pzVale
|
|
: pzPeak;
|
|
}
|
|
|
|
//
|
|
//
|
|
//
|
|
|
|
//
|
|
bool isCond3Bullish =
|
|
//
|
|
isCBarBullishFormed &&
|
|
hasDecisionBullishTrend &&
|
|
decisionXConditions.isSarBullish &&
|
|
decisionXConditions.isStrCrossedOverVale &&
|
|
//
|
|
true
|
|
//
|
|
;
|
|
|
|
//
|
|
bool isCond3Bearish =
|
|
//
|
|
isCBarBearishFormed &&
|
|
hasDecisionBearishTrend &&
|
|
decisionXConditions.isSarBearish &&
|
|
decisionXConditions.isStrCrossedUnderPeak &&
|
|
//
|
|
true
|
|
//
|
|
;
|
|
|
|
//
|
|
bool hasCond3Conditions = isCond3Bullish ||
|
|
isCond3Bearish;
|
|
if (hasCond3Conditions)
|
|
{
|
|
//
|
|
conditions.mode = X121_SMC_XRSPVI_CONDITION_3;
|
|
|
|
//
|
|
ENUM_X_DIRECTION pzDir =
|
|
isCond3Bullish
|
|
? X_DIRECTION_BULLISH
|
|
: X_DIRECTION_BEARISH;
|
|
|
|
//
|
|
// Manipulate Conditions Point ...
|
|
|
|
//
|
|
conditions.point = decisionXConditions.strBuffer[1];
|
|
|
|
//
|
|
// Manipulate Conditions Pivot ...
|
|
|
|
//
|
|
double pivot = decisionXConditions.sarBuffer[1];
|
|
pivot = (decisionXConditions.sarBuffer[1] + decisionXConditions.strBuffer[1]) / 2;
|
|
|
|
//
|
|
conditions.pivot =
|
|
isCond3Bullish
|
|
? pivot
|
|
: pivot;
|
|
}
|
|
|
|
//
|
|
//
|
|
//
|
|
|
|
//
|
|
bool isCond4Bullish =
|
|
//
|
|
isCBarBullishFormed &&
|
|
isInDecisionDiscount &&
|
|
hasDecisionBullishTrend &&
|
|
hasDecisionConsolidationZone &&
|
|
isDecisionConsolidationZoneBreakedUp &&
|
|
//
|
|
true
|
|
//
|
|
;
|
|
|
|
//
|
|
bool isCond4Bearish =
|
|
//
|
|
isInDecisionPremium &&
|
|
isCBarBearishFormed &&
|
|
hasDecisionBearishTrend &&
|
|
hasDecisionConsolidationZone &&
|
|
isDecisionConsolidationZoneBreakedDown &&
|
|
//
|
|
true
|
|
//
|
|
;
|
|
|
|
//
|
|
bool hasCond4Conditions = isCond4Bullish ||
|
|
isCond4Bearish;
|
|
if (hasCond4Conditions)
|
|
{
|
|
//
|
|
conditions.mode = X121_SMC_XRSPVI_CONDITION_4;
|
|
|
|
//
|
|
ENUM_X_DIRECTION pzDir =
|
|
isCond4Bullish
|
|
? X_DIRECTION_BULLISH
|
|
: X_DIRECTION_BEARISH;
|
|
|
|
//
|
|
// Manipulate Conditions Point ...
|
|
|
|
//
|
|
double point = GetEntry(
|
|
conditions.symbol,
|
|
pzDir //
|
|
);
|
|
|
|
//
|
|
conditions.point = point;
|
|
|
|
//
|
|
// Manipulate Conditions Pivot ...
|
|
|
|
//
|
|
pzPeak = decisionConsolidationZoneUpper;
|
|
pzVale = decisionConsolidationZoneLower;
|
|
|
|
//
|
|
conditions.pivot =
|
|
isCond4Bullish
|
|
? pzVale
|
|
: pzPeak;
|
|
}
|
|
|
|
//
|
|
//
|
|
//
|
|
|
|
//
|
|
bool isCond5Bullish =
|
|
//
|
|
hasDecisionBullishTrend &&
|
|
isPivotValeZoneRejected
|
|
//
|
|
;
|
|
|
|
//
|
|
bool isCond5Bearish =
|
|
//
|
|
hasDecisionBearishTrend &&
|
|
isPivotPeakZoneRejected
|
|
//
|
|
;
|
|
|
|
//
|
|
bool hasCond5Conditions = isCond5Bullish ||
|
|
isCond5Bearish;
|
|
|
|
//
|
|
isBullish =
|
|
isCond5Bullish &&
|
|
(isCond1Bullish ||
|
|
isCond2Bullish ||
|
|
isCond3Bullish ||
|
|
isCond4Bullish);
|
|
|
|
//
|
|
isBearish =
|
|
isCond5Bearish &&
|
|
(isCond1Bearish ||
|
|
isCond2Bearish ||
|
|
isCond3Bearish ||
|
|
isCond4Bearish);
|
|
|
|
//
|
|
result = isBullish ||
|
|
isBearish;
|
|
if (!result)
|
|
{
|
|
|
|
//
|
|
// Cleanup Arrays ...
|
|
ArrayFree(triggerPoiEvents);
|
|
ArrayFree(triggerCycleEvents);
|
|
ArrayFree(decisionPoiEvents);
|
|
ArrayFree(decisionCycleEvents);
|
|
ArrayFree(analysePoiEvents);
|
|
ArrayFree(analyseCycleEvents);
|
|
ArrayFree(verificationPoiEvents);
|
|
ArrayFree(verificationCycleEvents);
|
|
ArrayFree(consolidationPoiEvents);
|
|
ArrayFree(consolidationCycleEvents);
|
|
ArrayFree(visionPoiEvents);
|
|
ArrayFree(visionCycleEvents);
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
conditions.setupTime = cTime;
|
|
conditions.dir =
|
|
isBullish
|
|
? X_DIRECTION_BULLISH
|
|
: X_DIRECTION_BEARISH;
|
|
|
|
//
|
|
// Cleanup Arrays ...
|
|
ArrayFree(triggerPoiEvents);
|
|
ArrayFree(triggerCycleEvents);
|
|
ArrayFree(decisionPoiEvents);
|
|
ArrayFree(decisionCycleEvents);
|
|
ArrayFree(analysePoiEvents);
|
|
ArrayFree(analyseCycleEvents);
|
|
ArrayFree(verificationPoiEvents);
|
|
ArrayFree(verificationCycleEvents);
|
|
ArrayFree(consolidationPoiEvents);
|
|
ArrayFree(consolidationCycleEvents);
|
|
ArrayFree(visionPoiEvents);
|
|
ArrayFree(visionCycleEvents);
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Detect Trigger Conditions ...
|
|
bool DetectX121SMCXRSPVISiganlTrigger(
|
|
//
|
|
X121SMCStrategyXRSPVISignalConditions &conditions,
|
|
//
|
|
string _symbol,
|
|
ENUM_TIMEFRAMES _period,
|
|
//
|
|
XC121SMCCycleHelper *triggerCycleHelper,
|
|
XC121SMCCycleHelper *decisionCycleHelper,
|
|
XC121SMCCycleHelper *analyseCycleHelper,
|
|
XC121SMCCycleHelper *verificationCycleHelper,
|
|
XC121SMCCycleHelper *consolidationCycleHelper,
|
|
XC121SMCCycleHelper *visionCycleHelper,
|
|
//
|
|
int maxAllowedSetupAge = 60 //
|
|
//
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
result = conditions.IsSetuped();
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
datetime setupTime = conditions.setupTime;
|
|
ENUM_X_DIRECTION setupDir = conditions.dir;
|
|
|
|
//
|
|
bool isBullish = IsBullish(setupDir);
|
|
bool isBearish = IsBearish(setupDir);
|
|
|
|
//
|
|
int zIndex = 0;
|
|
int cIndex = zIndex + 1;
|
|
int pIndex = cIndex + 1;
|
|
int ppIndex = pIndex + 1;
|
|
|
|
//
|
|
int loopback = 10;
|
|
|
|
//
|
|
string symbol = _symbol;
|
|
ENUM_TIMEFRAMES period = _period;
|
|
|
|
//
|
|
XOHCL zBar;
|
|
result = zBar.Init(
|
|
symbol,
|
|
period,
|
|
zIndex //
|
|
);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
XOHCL cBar;
|
|
result = cBar.Init(
|
|
symbol,
|
|
period,
|
|
cIndex //
|
|
);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
XOHCL pBar;
|
|
result = pBar.Init(
|
|
symbol,
|
|
period,
|
|
pIndex //
|
|
);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
double ask = GetAsk(symbol);
|
|
double bid = GetBid(symbol);
|
|
datetime cTime = TimeCurrent();
|
|
double points = GetPoints(symbol);
|
|
|
|
//
|
|
int swingLoopback = 9;
|
|
double ll = cBar.FindLowest(swingLoopback, MODE_LOW);
|
|
double hh = cBar.FindHighest(swingLoopback, MODE_HIGH);
|
|
double llDown = cBar.FindLowesttDown(swingLoopback);
|
|
double hhUp = cBar.FindHighestUp(swingLoopback);
|
|
|
|
//
|
|
// Cycles Conditions ...
|
|
|
|
//
|
|
// Trigger ...
|
|
ENUM_XPOI_EVENTS triggerPoiEvents[];
|
|
ENUM_X_CYCLE_EVENTS triggerCycleEvents[];
|
|
X121SMCCycleConditions triggerConditions;
|
|
result = triggerCycleHelper.GetConditions(
|
|
triggerCycleEvents,
|
|
triggerPoiEvents,
|
|
triggerConditions,
|
|
zIndex,
|
|
loopback //
|
|
);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Decision ...
|
|
ENUM_XPOI_EVENTS decisionPoiEvents[];
|
|
ENUM_X_CYCLE_EVENTS decisionCycleEvents[];
|
|
X121SMCCycleConditions decisionConditions;
|
|
result = decisionCycleHelper.GetConditions(
|
|
decisionCycleEvents,
|
|
decisionPoiEvents,
|
|
decisionConditions,
|
|
zIndex,
|
|
loopback //
|
|
);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Analyse ...
|
|
ENUM_XPOI_EVENTS analysePoiEvents[];
|
|
ENUM_X_CYCLE_EVENTS analyseCycleEvents[];
|
|
X121SMCCycleConditions analyseConditions;
|
|
result = analyseCycleHelper.GetConditions(
|
|
analyseCycleEvents,
|
|
analysePoiEvents,
|
|
analyseConditions,
|
|
zIndex,
|
|
loopback //
|
|
);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Verification ...
|
|
ENUM_XPOI_EVENTS verificationPoiEvents[];
|
|
ENUM_X_CYCLE_EVENTS verificationCycleEvents[];
|
|
X121SMCCycleConditions verificationConditions;
|
|
result = verificationCycleHelper.GetConditions(
|
|
verificationCycleEvents,
|
|
verificationPoiEvents,
|
|
verificationConditions,
|
|
zIndex,
|
|
loopback //
|
|
);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Consolidation ...
|
|
ENUM_XPOI_EVENTS consolidationPoiEvents[];
|
|
ENUM_X_CYCLE_EVENTS consolidationCycleEvents[];
|
|
X121SMCCycleConditions consolidationConditions;
|
|
result = consolidationCycleHelper.GetConditions(
|
|
consolidationCycleEvents,
|
|
consolidationPoiEvents,
|
|
consolidationConditions,
|
|
zIndex,
|
|
loopback //
|
|
);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Vision ...
|
|
ENUM_XPOI_EVENTS visionPoiEvents[];
|
|
ENUM_X_CYCLE_EVENTS visionCycleEvents[];
|
|
X121SMCCycleConditions visionConditions;
|
|
result = visionCycleHelper.GetConditions(
|
|
visionCycleEvents,
|
|
visionPoiEvents,
|
|
visionConditions,
|
|
zIndex,
|
|
loopback //
|
|
);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Cycles POI States ...
|
|
XPOIState triggerState = triggerConditions.state;
|
|
XPOIState decisionState = decisionConditions.state;
|
|
XPOIState analyseState = analyseConditions.state;
|
|
XPOIState verificationState = verificationConditions.state;
|
|
XPOIState consolidationState = consolidationConditions.state;
|
|
XPOIState visionState = visionConditions.state;
|
|
|
|
//
|
|
// Cycle X121Conditions ...
|
|
X121Conditions triggerXConditions = triggerConditions.x121Conditions;
|
|
X121Conditions decisionXConditions = decisionConditions.x121Conditions;
|
|
X121Conditions analyseXConditions = analyseConditions.x121Conditions;
|
|
X121Conditions verificationXConditions = verificationConditions.x121Conditions;
|
|
X121Conditions consolidationXConditions = consolidationConditions.x121Conditions;
|
|
X121Conditions visionXConditions = visionConditions.x121Conditions;
|
|
|
|
//
|
|
// Trigger Conditions ...
|
|
|
|
//
|
|
// SAR ...
|
|
double sar = decisionXConditions.sarBuffer[1];
|
|
|
|
//
|
|
// STR ...
|
|
double str = decisionXConditions.strBuffer[1];
|
|
|
|
//
|
|
// CHE ...
|
|
double le1 = decisionXConditions.le1Buffer[1];
|
|
double le2 = decisionXConditions.le2Buffer[1];
|
|
double se1 = decisionXConditions.se1Buffer[1];
|
|
double se2 = decisionXConditions.se2Buffer[1];
|
|
|
|
//
|
|
// ATR ...
|
|
double atrUpper = decisionXConditions.atrUpperBuffer[1];
|
|
double atrLower = decisionXConditions.atrLowerBuffer[1];
|
|
|
|
//
|
|
// PV ...
|
|
double peak = decisionXConditions.peaksBuffer[1];
|
|
double vale = decisionXConditions.valesBuffer[1];
|
|
|
|
//
|
|
int higherPeakIDX = -1;
|
|
double higherPeak = decisionCycleHelper
|
|
.mX121Helper
|
|
.xpvHelper.GetHigherPeak(
|
|
higherPeakIDX,
|
|
peak //
|
|
);
|
|
|
|
//
|
|
int lowerValeIDX = -1;
|
|
double lowerVale = decisionCycleHelper
|
|
.mX121Helper
|
|
.xpvHelper.GetLowerVale(
|
|
lowerValeIDX,
|
|
vale //
|
|
);
|
|
|
|
//
|
|
// Slopes ...
|
|
|
|
//
|
|
bool isRsiSlopeBullish = decisionXConditions.isRsiSlopeBullish;
|
|
bool isStrSlopeBullish = decisionXConditions.isStrSlopeBullish;
|
|
bool isAtrUpperSlopeBullish = decisionXConditions.isAtrUpperSlopeBullish;
|
|
bool isAtrLowerSlopeBullish = decisionXConditions.isAtrLowerSlopeBullish;
|
|
bool isVwapFastSlopeBullish = decisionXConditions.isVwapFastSlopeBullish;
|
|
bool isVwapMidSlopeBullish = decisionXConditions.isVwapMidSlopeBullish;
|
|
bool isVwapSlowSlopeBullish = decisionXConditions.isVwapSlowSlopeBullish;
|
|
|
|
//
|
|
bool isRsiSlopeBearish = decisionXConditions.isRsiSlopeBearish;
|
|
bool isStrSlopeBearish = decisionXConditions.isStrSlopeBearish;
|
|
bool isAtrUpperSlopeBearish = decisionXConditions.isAtrUpperSlopeBearish;
|
|
bool isAtrLowerSlopeBearish = decisionXConditions.isAtrLowerSlopeBearish;
|
|
bool isVwapFastSlopeBearish = decisionXConditions.isVwapFastSlopeBearish;
|
|
bool isVwapMidSlopeBearish = decisionXConditions.isVwapMidSlopeBearish;
|
|
bool isVwapSlowSlopeBearish = decisionXConditions.isVwapSlowSlopeBearish;
|
|
|
|
//
|
|
bool isSlopesBullish =
|
|
isRsiSlopeBullish &&
|
|
isStrSlopeBullish &&
|
|
isAtrUpperSlopeBullish &&
|
|
isAtrLowerSlopeBullish &&
|
|
isVwapFastSlopeBullish &&
|
|
isVwapMidSlopeBullish &&
|
|
isVwapSlowSlopeBullish;
|
|
|
|
//
|
|
bool isSlopesBearish =
|
|
isRsiSlopeBearish &&
|
|
isStrSlopeBearish &&
|
|
isAtrUpperSlopeBearish &&
|
|
isAtrLowerSlopeBearish &&
|
|
isVwapFastSlopeBearish &&
|
|
isVwapMidSlopeBearish &&
|
|
isVwapSlowSlopeBearish;
|
|
|
|
//
|
|
double point = conditions.point;
|
|
bool isPointBreaked = IsBarBreak(
|
|
point,
|
|
setupDir,
|
|
cBar //
|
|
);
|
|
|
|
//
|
|
bool isCond124 =
|
|
//
|
|
conditions.mode == X121_SMC_XRSPVI_CONDITION_1 ||
|
|
conditions.mode == X121_SMC_XRSPVI_CONDITION_2 ||
|
|
conditions.mode == X121_SMC_XRSPVI_CONDITION_4
|
|
//
|
|
;
|
|
|
|
//
|
|
// Summary ...
|
|
|
|
//
|
|
isBullish =
|
|
//
|
|
isBullish &&
|
|
isSlopesBullish &&
|
|
cBar.IsBullish() &&
|
|
(
|
|
//
|
|
(isCond124 &&
|
|
isPointBreaked)
|
|
//
|
|
||
|
|
//
|
|
(!isCond124 &&
|
|
decisionXConditions.isStrBullish &&
|
|
decisionXConditions.isStrSlopeBullish &&
|
|
decisionXConditions.strBuffer[1] > conditions.point &&
|
|
decisionXConditions.strBuffer[1] > decisionXConditions.strBuffer[2])
|
|
//
|
|
)
|
|
//
|
|
;
|
|
|
|
//
|
|
isBearish =
|
|
//
|
|
isBearish &&
|
|
isSlopesBearish &&
|
|
cBar.IsBearish() &&
|
|
(
|
|
//
|
|
(isCond124 &&
|
|
isPointBreaked)
|
|
//
|
|
||
|
|
//
|
|
(!isCond124 &&
|
|
decisionXConditions.isStrBearish &&
|
|
decisionXConditions.isStrSlopeBearish &&
|
|
decisionXConditions.strBuffer[1] < conditions.point &&
|
|
decisionXConditions.strBuffer[1] < decisionXConditions.strBuffer[2])
|
|
//
|
|
)
|
|
//
|
|
;
|
|
|
|
//
|
|
result = isBullish ||
|
|
isBearish;
|
|
if (!result)
|
|
{
|
|
//
|
|
// Cleanup Setup Conditions ...
|
|
int setupAge = conditions.GetSetupAge();
|
|
if (IsValidSize(setupAge) &&
|
|
IsValidSize(maxAllowedSetupAge) &&
|
|
setupAge >= maxAllowedSetupAge)
|
|
{
|
|
conditions.Clean();
|
|
}
|
|
|
|
//
|
|
// Cleanup Arrays ...
|
|
ArrayFree(triggerPoiEvents);
|
|
ArrayFree(triggerCycleEvents);
|
|
ArrayFree(decisionPoiEvents);
|
|
ArrayFree(decisionCycleEvents);
|
|
ArrayFree(analysePoiEvents);
|
|
ArrayFree(analyseCycleEvents);
|
|
ArrayFree(verificationPoiEvents);
|
|
ArrayFree(verificationCycleEvents);
|
|
ArrayFree(consolidationPoiEvents);
|
|
ArrayFree(consolidationCycleEvents);
|
|
ArrayFree(visionPoiEvents);
|
|
ArrayFree(visionCycleEvents);
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Detect Nearest Pivot Point ...
|
|
|
|
//
|
|
// Detect Target ...
|
|
double target = CalculateTarget(
|
|
cBar,
|
|
decisionState,
|
|
setupDir //
|
|
);
|
|
if (target == 0)
|
|
{
|
|
//
|
|
target = CalculateTarget(
|
|
cBar,
|
|
analyseState,
|
|
setupDir //
|
|
);
|
|
|
|
//
|
|
if (target == 0)
|
|
{
|
|
//
|
|
target = CalculateTarget(
|
|
cBar,
|
|
verificationState,
|
|
setupDir //
|
|
);
|
|
}
|
|
}
|
|
target = 0;
|
|
|
|
//
|
|
double entry = GetEntry(
|
|
conditions.symbol,
|
|
setupDir //
|
|
);
|
|
|
|
//
|
|
// Filling SL Candidates ...
|
|
double momentumBarPointsDif = 30 * points;
|
|
|
|
//
|
|
// Bullish Momentum Bar Selection ...
|
|
XOHCL bullishMomentumBar;
|
|
int bullishMomentumBarsCount = decisionState.CountBullishMomentumBars();
|
|
if (IsValidSize(bullishMomentumBarsCount))
|
|
{
|
|
//
|
|
for (int i = 0; i < bullishMomentumBarsCount; i++)
|
|
{
|
|
//
|
|
XCMomentumBar *iMomentum = decisionState.bullishMomentumBars[i];
|
|
|
|
//
|
|
XOHCL iBar;
|
|
bool isFilled = iMomentum.FillBar(iBar);
|
|
if (!isFilled)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
//
|
|
bool isValidDistane = (MathAbs(iBar.low) - entry) >= momentumBarPointsDif;
|
|
if (!isValidDistane)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
//
|
|
bool isIndexPassed = iBar.Index() <= 5;
|
|
if (!isIndexPassed)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
//
|
|
bool canSet =
|
|
!bullishMomentumBar.IsValid() ||
|
|
(bullishMomentumBar.IsValid() &&
|
|
bullishMomentumBar.low < entry &&
|
|
bullishMomentumBar.Index() > iBar.Index());
|
|
if (canSet)
|
|
{
|
|
bullishMomentumBar = iBar;
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Bearish Momentum Bar Selection ...
|
|
XOHCL bearishMomentumBar;
|
|
int bearishMomentumBarsCount = decisionState.CountBearishMomentumBars();
|
|
if (IsValidSize(bearishMomentumBarsCount))
|
|
{
|
|
//
|
|
for (int i = 0; i < bearishMomentumBarsCount; i++)
|
|
{
|
|
//
|
|
XCMomentumBar *iMomentum = decisionState.bearishMomentumBars[i];
|
|
|
|
//
|
|
XOHCL iBar;
|
|
bool isFilled = iMomentum.FillBar(iBar);
|
|
if (!isFilled)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
//
|
|
bool isValidDistane = (MathAbs(iBar.high) - entry) >= momentumBarPointsDif;
|
|
if (!isValidDistane)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
//
|
|
bool isIndexPassed = iBar.Index() <= 5;
|
|
if (!isIndexPassed)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
//
|
|
bool canSet =
|
|
!bearishMomentumBar.IsValid() ||
|
|
(bearishMomentumBar.IsValid() &&
|
|
bearishMomentumBar.high > entry &&
|
|
bearishMomentumBar.Index() > iBar.Index());
|
|
if (canSet)
|
|
{
|
|
bearishMomentumBar = iBar;
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
double sls[];
|
|
Add(
|
|
sar,
|
|
sls //
|
|
);
|
|
Add(
|
|
str,
|
|
sls //
|
|
);
|
|
|
|
//
|
|
if (isBullish)
|
|
{
|
|
//
|
|
Add(
|
|
atrLower,
|
|
sls //
|
|
);
|
|
|
|
// //
|
|
// Add(
|
|
// vale,
|
|
// sls //
|
|
// );
|
|
|
|
//
|
|
if (bullishMomentumBar.IsValid())
|
|
{
|
|
//
|
|
Add(
|
|
bullishMomentumBar.low,
|
|
sls //
|
|
);
|
|
}
|
|
|
|
// //
|
|
// if (IsValidIndex(lowerValeIDX))
|
|
// {
|
|
// //
|
|
// Add(
|
|
// lowerVale,
|
|
// sls //
|
|
// );
|
|
// }
|
|
|
|
//
|
|
if (le1 != EMPTY_VALUE)
|
|
{
|
|
//
|
|
Add(
|
|
le1,
|
|
sls //
|
|
);
|
|
}
|
|
|
|
//
|
|
if (le2 != EMPTY_VALUE)
|
|
{
|
|
//
|
|
Add(
|
|
le2,
|
|
sls //
|
|
);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//
|
|
Add(
|
|
atrUpper,
|
|
sls //
|
|
);
|
|
|
|
// //
|
|
// Add(
|
|
// peak,
|
|
// sls //
|
|
// );
|
|
|
|
//
|
|
if (bearishMomentumBar.IsValid())
|
|
{
|
|
//
|
|
Add(
|
|
bearishMomentumBar.high,
|
|
sls //
|
|
);
|
|
}
|
|
|
|
//
|
|
// if (IsValidIndex(higherPeakIDX))
|
|
// {
|
|
// //
|
|
// Add(
|
|
// higherPeak,
|
|
// sls //
|
|
// );
|
|
// }
|
|
|
|
//
|
|
if (se1 != EMPTY_VALUE)
|
|
{
|
|
//
|
|
Add(
|
|
se1,
|
|
sls //
|
|
);
|
|
}
|
|
|
|
//
|
|
if (se2 != EMPTY_VALUE)
|
|
{
|
|
//
|
|
Add(
|
|
se2,
|
|
sls //
|
|
);
|
|
}
|
|
}
|
|
|
|
//
|
|
double iAtr = decisionConditions.x121Conditions.atrBuffer[1];
|
|
|
|
//
|
|
double slsMin = GetMin(sls);
|
|
double slsMax = GetMax(sls);
|
|
|
|
//
|
|
double sl = isBullish
|
|
? slsMin - iAtr
|
|
: slsMax + iAtr;
|
|
double risk = MathAbs(entry - sl);
|
|
double riskInPoints = risk / points;
|
|
if (riskInPoints >= 150)
|
|
{
|
|
//
|
|
target =
|
|
isBullish
|
|
? entry + (points * 200)
|
|
: entry - (points * 200);
|
|
|
|
//
|
|
target = 0;
|
|
}
|
|
|
|
//
|
|
// Filling Conditions Props ...
|
|
conditions.sl = sl;
|
|
conditions.target = target;
|
|
conditions.triggerTime = cTime;
|
|
conditions.type = isBullish
|
|
? X_POSITION_TYPE_LONG
|
|
: X_POSITION_TYPE_SHORT;
|
|
|
|
//
|
|
// Cleanup Arrays ...
|
|
ArrayFree(triggerPoiEvents);
|
|
ArrayFree(triggerCycleEvents);
|
|
ArrayFree(decisionPoiEvents);
|
|
ArrayFree(decisionCycleEvents);
|
|
ArrayFree(analysePoiEvents);
|
|
ArrayFree(analyseCycleEvents);
|
|
ArrayFree(verificationPoiEvents);
|
|
ArrayFree(verificationCycleEvents);
|
|
ArrayFree(consolidationPoiEvents);
|
|
ArrayFree(consolidationCycleEvents);
|
|
ArrayFree(visionPoiEvents);
|
|
ArrayFree(visionCycleEvents);
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
bool DetectX121SMCXRSPVIGuards(
|
|
X121SMCGuard &guards[],
|
|
const XPosition &positions[],
|
|
XC121SMCCycleHelper *triggerCycleHelper,
|
|
XC121SMCCycleHelper *decisionCycleHelper,
|
|
XC121SMCCycleHelper *analyseCycleHelper,
|
|
XC121SMCCycleHelper *verificationCycleHelper,
|
|
XC121SMCCycleHelper *consolidationCycleHelper,
|
|
XC121SMCCycleHelper *visionCycleHelper //
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
string provider = ToString(X_121_SMC_PROVIDER_XRSPVI);
|
|
|
|
//
|
|
result = DetectX121SMCGuards(
|
|
provider,
|
|
guards,
|
|
positions,
|
|
triggerCycleHelper,
|
|
decisionCycleHelper,
|
|
analyseCycleHelper,
|
|
verificationCycleHelper,
|
|
consolidationCycleHelper,
|
|
visionCycleHelper //
|
|
);
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
int AddX121SMCXRSPVIConditionsIfNotExists(
|
|
X121SMCStrategyXRSPVISignalConditions &item,
|
|
X121SMCStrategyXRSPVISignalConditions &items[],
|
|
int maxAllowed = 10 //
|
|
)
|
|
{
|
|
//
|
|
int result = 0;
|
|
|
|
//
|
|
bool isSetuped = IsValid(item.setupTime) &&
|
|
HasDirection(item.dir);
|
|
if (!isSetuped)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
int count = ArraySize(items);
|
|
if (IsValidSize(count))
|
|
{
|
|
//
|
|
// Copy Original Items ...
|
|
X121SMCStrategyXRSPVISignalConditions tmpItems[];
|
|
Copy(
|
|
items,
|
|
tmpItems //
|
|
);
|
|
|
|
//
|
|
// Prese Item Data ...
|
|
bool isBullish = IsBullish(item.dir);
|
|
|
|
//
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
//
|
|
X121SMCStrategyXRSPVISignalConditions iItem = tmpItems[i];
|
|
|
|
//
|
|
bool canRemove = item.dir == iItem.dir &&
|
|
item.pivot == iItem.pivot;
|
|
if (canRemove)
|
|
{
|
|
//
|
|
ArrayRemove(
|
|
items,
|
|
i,
|
|
1 //
|
|
);
|
|
}
|
|
}
|
|
|
|
//
|
|
Clean(tmpItems);
|
|
}
|
|
|
|
//
|
|
AddRef(
|
|
item,
|
|
items //
|
|
);
|
|
|
|
//
|
|
// Remove Olds ...
|
|
CleanupArray(
|
|
items,
|
|
maxAllowed //
|
|
);
|
|
|
|
//
|
|
result = ArraySize(items);
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
int DrawX121SMCXRSPVIConditions(
|
|
X121SMCStrategyXRSPVISignalConditions &conditions,
|
|
XCBaseObject *&drawnObjects[],
|
|
XCPOIDrawer *drawer //
|
|
)
|
|
{
|
|
//
|
|
int result = 0;
|
|
|
|
//
|
|
Clean(drawnObjects);
|
|
|
|
//
|
|
if (drawer == NULL)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
bool isSetuped = conditions.IsSetuped();
|
|
if (!isSetuped)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
bool hasPriceZone = conditions.priceZone.IsValid();
|
|
if (!hasPriceZone)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
int zonesObjCount = drawer.DrawPriceZone(
|
|
conditions.priceZone,
|
|
drawnObjects,
|
|
conditions.dir //
|
|
);
|
|
result = zonesObjCount;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|