2295 lines
58 KiB
Plaintext
2295 lines
58 KiB
Plaintext
///////////////////////////////////////////////////////
|
|
//
|
|
// SaherElm IT Center MQL5 X121 SMC Signal Class
|
|
// -------------------------------------------------
|
|
// Name: XWZ
|
|
// 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 "../Classes/x-121.smc.market.cycle.helper.class.mq5"
|
|
#include "../Libraries/x-121.smc.guard.lib.mq5"
|
|
#include "../Libraries/x-121.smc.lib.mq5"
|
|
#include "./x-121.smc.xwz.signal.lib.mq5"
|
|
|
|
//
|
|
// Definition ...
|
|
class XCX121SMCXWZSignalDetector : public XCBase
|
|
{
|
|
//
|
|
public:
|
|
//
|
|
// Props ...
|
|
X121SMCStrategyXWZWorkingZone workingZone;
|
|
X121SMCStrategyXWZSignalConditions mConditions;
|
|
X121SMCStrategyXWZSignalConditions mConditionsCollection[];
|
|
|
|
//
|
|
// Constructor(s) ...
|
|
XCX121SMCXWZSignalDetector(
|
|
string _symbol,
|
|
ENUM_TIMEFRAMES _period //
|
|
)
|
|
{
|
|
//
|
|
symbol = _symbol;
|
|
period = _period;
|
|
Init();
|
|
}
|
|
|
|
//
|
|
// Deconstructor ...
|
|
~XCX121SMCXWZSignalDetector()
|
|
{
|
|
DeInit();
|
|
}
|
|
|
|
//
|
|
//
|
|
//
|
|
|
|
//
|
|
// Detect Setup Conditions ...
|
|
bool DetectSignalSetup(
|
|
//
|
|
XC121SMCCycleHelper *decisionCycleHelper,
|
|
XC121SMCCycleHelper *analyseCycleHelper,
|
|
XC121SMCCycleHelper *consolidationCycleHelper,
|
|
XC121SMCCycleHelper *visionCycleHelper,
|
|
//
|
|
double maxAllowedSLDistanceInPoint = 300
|
|
//
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
// Validate Cycle Helpers ...
|
|
result =
|
|
//
|
|
visionCycleHelper != NULL &&
|
|
analyseCycleHelper != NULL &&
|
|
decisionCycleHelper != NULL &&
|
|
consolidationCycleHelper != NULL
|
|
//
|
|
;
|
|
if (!result)
|
|
{
|
|
//
|
|
mConditions.Clean();
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
bool isBullish = false;
|
|
bool isBearish = false;
|
|
|
|
//
|
|
int zIndex = 0;
|
|
int cIndex = zIndex + 1;
|
|
int pIndex = cIndex + 1;
|
|
int ppIndex = pIndex + 1;
|
|
|
|
//
|
|
int loopback = 10;
|
|
|
|
//
|
|
mConditions.symbol = symbol;
|
|
mConditions.period = period;
|
|
|
|
//
|
|
double ask = GetAsk(symbol);
|
|
double bid = GetBid(symbol);
|
|
datetime cTime = TimeCurrent();
|
|
double points = GetPoints(symbol);
|
|
|
|
//
|
|
// Cycles Conditions ...
|
|
|
|
//
|
|
XOHCL consolidationZBar;
|
|
result = consolidationCycleHelper.GetBar(
|
|
consolidationZBar,
|
|
zIndex //
|
|
);
|
|
if (!result)
|
|
{
|
|
//
|
|
consolidationZBar.Clean();
|
|
return result;
|
|
}
|
|
|
|
//
|
|
bool drawBar = false;
|
|
if (drawBar)
|
|
{
|
|
//
|
|
DrawBar(
|
|
consolidationZBar,
|
|
decisionCycleHelper.mPOIDrawer //
|
|
);
|
|
}
|
|
|
|
//
|
|
// Decision ...
|
|
ENUM_XPOI_EVENTS decisionPoiEvents[];
|
|
ENUM_X_CYCLE_EVENTS decisionCycleEvents[];
|
|
X121SMCCycleConditions decisionConditions;
|
|
result = decisionCycleHelper.GetConditions(
|
|
decisionCycleEvents,
|
|
decisionPoiEvents,
|
|
decisionConditions,
|
|
zIndex,
|
|
loopback //
|
|
);
|
|
if (!result)
|
|
{
|
|
//
|
|
Clean(decisionPoiEvents);
|
|
Clean(decisionCycleEvents);
|
|
|
|
//
|
|
decisionConditions.Clean();
|
|
|
|
//
|
|
mConditions.Clean();
|
|
consolidationZBar.Clean();
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Analyse ...
|
|
ENUM_XPOI_EVENTS analysePoiEvents[];
|
|
ENUM_X_CYCLE_EVENTS analyseCycleEvents[];
|
|
X121SMCCycleConditions analyseConditions;
|
|
result = analyseCycleHelper.GetConditions(
|
|
analyseCycleEvents,
|
|
analysePoiEvents,
|
|
analyseConditions,
|
|
zIndex,
|
|
loopback //
|
|
);
|
|
if (!result)
|
|
{
|
|
//
|
|
Clean(analysePoiEvents);
|
|
Clean(decisionPoiEvents);
|
|
|
|
//
|
|
Clean(analyseCycleEvents);
|
|
Clean(decisionCycleEvents);
|
|
|
|
//
|
|
analyseConditions.Clean();
|
|
decisionConditions.Clean();
|
|
|
|
//
|
|
mConditions.Clean();
|
|
consolidationZBar.Clean();
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Consolidation ...
|
|
ENUM_XPOI_EVENTS consolidationPoiEvents[];
|
|
ENUM_X_CYCLE_EVENTS consolidationCycleEvents[];
|
|
X121SMCCycleConditions consolidationConditions;
|
|
result = consolidationCycleHelper.GetConditions(
|
|
consolidationCycleEvents,
|
|
consolidationPoiEvents,
|
|
consolidationConditions,
|
|
zIndex,
|
|
loopback //
|
|
);
|
|
if (!result)
|
|
{
|
|
//
|
|
Clean(analysePoiEvents);
|
|
Clean(decisionPoiEvents);
|
|
Clean(consolidationPoiEvents);
|
|
|
|
//
|
|
Clean(analyseCycleEvents);
|
|
Clean(decisionCycleEvents);
|
|
Clean(consolidationCycleEvents);
|
|
|
|
//
|
|
analyseConditions.Clean();
|
|
decisionConditions.Clean();
|
|
consolidationConditions.Clean();
|
|
|
|
//
|
|
mConditions.Clean();
|
|
consolidationZBar.Clean();
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Vision ...
|
|
ENUM_XPOI_EVENTS visionPoiEvents[];
|
|
ENUM_X_CYCLE_EVENTS visionCycleEvents[];
|
|
X121SMCCycleConditions visionConditions;
|
|
result = visionCycleHelper.GetConditions(
|
|
visionCycleEvents,
|
|
visionPoiEvents,
|
|
visionConditions,
|
|
zIndex,
|
|
loopback //
|
|
);
|
|
if (!result)
|
|
{
|
|
//
|
|
Clean(visionPoiEvents);
|
|
Clean(analysePoiEvents);
|
|
Clean(decisionPoiEvents);
|
|
Clean(consolidationPoiEvents);
|
|
|
|
//
|
|
Clean(visionCycleEvents);
|
|
Clean(analyseCycleEvents);
|
|
Clean(decisionCycleEvents);
|
|
Clean(consolidationCycleEvents);
|
|
|
|
//
|
|
visionConditions.Clean();
|
|
analyseConditions.Clean();
|
|
decisionConditions.Clean();
|
|
consolidationConditions.Clean();
|
|
|
|
//
|
|
mConditions.Clean();
|
|
consolidationZBar.Clean();
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Cycles POI States ...
|
|
XPOIState decisionState = decisionConditions.state;
|
|
XPOIState analyseState = analyseConditions.state;
|
|
XPOIState consolidationState = consolidationConditions.state;
|
|
XPOIState visionState = visionConditions.state;
|
|
|
|
//
|
|
// Cycle X121Conditions ...
|
|
X121Conditions decisionXConditions = decisionConditions.x121Conditions;
|
|
X121Conditions analyseXConditions = analyseConditions.x121Conditions;
|
|
X121Conditions consolidationXConditions = consolidationConditions.x121Conditions;
|
|
X121Conditions visionXConditions = visionConditions.x121Conditions;
|
|
|
|
//
|
|
// Scores ...
|
|
|
|
//
|
|
// Decision ...
|
|
double decisionBullishScore = 0;
|
|
double decisionBearishScore = 0;
|
|
decisionXConditions.GenerateScore(
|
|
decisionBullishScore,
|
|
decisionBearishScore //
|
|
);
|
|
|
|
//
|
|
// Analyse ...
|
|
double analyseBullishScore = 0;
|
|
double analyseBearishScore = 0;
|
|
analyseXConditions.GenerateScore(
|
|
analyseBullishScore,
|
|
analyseBearishScore //
|
|
);
|
|
|
|
//
|
|
//
|
|
//
|
|
|
|
//
|
|
bool hasNewSupply = Contains(
|
|
X_SUPPLY_ZONE_DETECTED,
|
|
analysePoiEvents //
|
|
);
|
|
|
|
//
|
|
bool hasNewDemand = Contains(
|
|
X_DEMAND_ZONE_DETECTED,
|
|
analysePoiEvents //
|
|
);
|
|
|
|
//
|
|
bool hasNewFairValueGap =
|
|
Contains(
|
|
X_BULLISH_FVG_DETECTED,
|
|
analysePoiEvents //
|
|
) ||
|
|
Contains(
|
|
X_BEARISH_FVG_DETECTED,
|
|
analysePoiEvents //
|
|
);
|
|
|
|
//
|
|
bool hasNewOrderBlock =
|
|
Contains(
|
|
X_BULLISH_ORDERBLOCK_DETECTED,
|
|
analysePoiEvents //
|
|
) ||
|
|
Contains(
|
|
X_BEARISH_ORDERBLOCK_DETECTED,
|
|
analysePoiEvents //
|
|
);
|
|
|
|
//
|
|
//
|
|
//
|
|
|
|
//
|
|
// Select Drawer Class ...
|
|
XCPOIDrawer *drawer = visionCycleHelper.mPOIDrawer;
|
|
|
|
//
|
|
// Setup Conditions ...
|
|
double sls[];
|
|
double sl = 0;
|
|
double pivot = 0;
|
|
double point = 0;
|
|
double targets[];
|
|
double reward = 0;
|
|
XBoxZone signalBox;
|
|
double amountPercent = 0;
|
|
bool hasPriority = false;
|
|
bool hasSignalBox = false;
|
|
bool hasRewardAmount = false;
|
|
bool isSignalBoxReversal = false;
|
|
bool hasWorkingZoneOveralDirection = false;
|
|
ENUM_X_DIRECTION wzOveralDir = X_DIRECTION_NONE;
|
|
ENUM_X_DIRECTION signalBoxDir = X_DIRECTION_NONE;
|
|
ENUM_X121SMC_XWZ_PRIORITY priority = X121SMC_XWZ_PRIORITY_NONE;
|
|
ENUM_X121SMC_XWZ_PROVIDERS provider = X121SMC_XWZ_PROVIDER_NONE;
|
|
|
|
//
|
|
//
|
|
//
|
|
|
|
//
|
|
// First We Have to Has Working Zone ...
|
|
bool hasWorkingZone = workingZone.IsValid();
|
|
if (!hasWorkingZone)
|
|
{
|
|
//
|
|
hasWorkingZone = workingZone.Init(
|
|
symbol,
|
|
period,
|
|
zIndex,
|
|
visionState,
|
|
consolidationState,
|
|
analyseState,
|
|
decisionState //
|
|
);
|
|
}
|
|
|
|
//
|
|
// Update Working Zone ...
|
|
if (hasWorkingZone)
|
|
{
|
|
//
|
|
// Reset POI Detector Required POI(s) ...
|
|
visionCycleHelper.mPOIDetector.MaxRequiredPOIs(50);
|
|
analyseCycleHelper.mPOIDetector.MaxRequiredPOIs(50);
|
|
decisionCycleHelper.mPOIDetector.MaxRequiredPOIs(50);
|
|
consolidationCycleHelper.mPOIDetector.MaxRequiredPOIs(50);
|
|
|
|
//
|
|
// Reset POI Detector Allowed Loopback ...
|
|
visionCycleHelper.mPOIDetector.MaxAllowedLoopbackForInit(578);
|
|
analyseCycleHelper.mPOIDetector.MaxAllowedLoopbackForInit(578);
|
|
decisionCycleHelper.mPOIDetector.MaxAllowedLoopbackForInit(578);
|
|
consolidationCycleHelper.mPOIDetector.MaxAllowedLoopbackForInit(578);
|
|
|
|
//
|
|
// Update Working Zone ...
|
|
// workingZone.Update(
|
|
// zIndex,
|
|
// visionState,
|
|
// consolidationState,
|
|
// analyseState,
|
|
// decisionState //
|
|
// );
|
|
|
|
//
|
|
// Check Working Zone Overal Direction ...
|
|
hasWorkingZoneOveralDirection = workingZone
|
|
.DetectOveralDirection(wzOveralDir);
|
|
|
|
//
|
|
// Checking Working Zone Destory or not ...
|
|
bool isWorkingZoneDestroyed = workingZone.IsDestroyed(
|
|
zIndex,
|
|
period //
|
|
);
|
|
|
|
//
|
|
// Cleanup WorkingZone and ignore all conditions ...
|
|
if (isWorkingZoneDestroyed)
|
|
{
|
|
//
|
|
result = false;
|
|
workingZone.Clean();
|
|
hasWorkingZone = false;
|
|
|
|
//
|
|
// Cleanup Resources ...
|
|
Clean(visionPoiEvents);
|
|
Clean(analysePoiEvents);
|
|
Clean(decisionPoiEvents);
|
|
Clean(consolidationPoiEvents);
|
|
|
|
//
|
|
Clean(visionCycleEvents);
|
|
Clean(analyseCycleEvents);
|
|
Clean(decisionCycleEvents);
|
|
Clean(consolidationCycleEvents);
|
|
|
|
//
|
|
visionState.Clean();
|
|
analyseState.Clean();
|
|
decisionState.Clean();
|
|
consolidationState.Clean();
|
|
|
|
//
|
|
visionConditions.Clean();
|
|
analyseConditions.Clean();
|
|
decisionConditions.Clean();
|
|
consolidationConditions.Clean();
|
|
|
|
//
|
|
visionXConditions.Clean();
|
|
analyseXConditions.Clean();
|
|
decisionXConditions.Clean();
|
|
consolidationXConditions.Clean();
|
|
|
|
//
|
|
mConditions.Clean();
|
|
consolidationZBar.Clean();
|
|
|
|
//
|
|
return result;
|
|
}
|
|
}
|
|
|
|
//
|
|
//
|
|
//
|
|
|
|
//
|
|
// Waiting Box Detected ...
|
|
bool hasWaitingBoxes = hasWorkingZone &&
|
|
workingZone.HasWaitingBoxes();
|
|
if (hasWaitingBoxes)
|
|
{
|
|
//
|
|
XOHCL zBar;
|
|
XOHCL cBar;
|
|
XOHCL pBar;
|
|
int count = 0;
|
|
int idx = -1;
|
|
bool has = false;
|
|
|
|
//
|
|
bool isInited = zBar.Init(
|
|
symbol,
|
|
period,
|
|
zIndex //
|
|
);
|
|
isInited =
|
|
isInited &&
|
|
zBar.GetPreviousBar(cBar);
|
|
isInited =
|
|
isInited &&
|
|
cBar.GetPreviousBar(pBar);
|
|
|
|
//
|
|
count = workingZone.CountWaitingBoxes();
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
//
|
|
XBoxZone iBox = workingZone.waitingBoxes[i];
|
|
ENUM_X_DIRECTION iDir = iBox.dir;
|
|
bool isBullish = IsBullish(iDir);
|
|
|
|
//
|
|
// Check Price Rejection ...
|
|
|
|
//
|
|
bool hasBullishFiboPressure =
|
|
decisionCycleHelper
|
|
.mBarAnalyser
|
|
.HasFiboPressure(
|
|
cBar,
|
|
X_DIRECTION_BULLISH,
|
|
X_FIBO_LEVEL_382 //
|
|
);
|
|
|
|
//
|
|
bool hasBearishFiboPressure =
|
|
decisionCycleHelper
|
|
.mBarAnalyser
|
|
.HasFiboPressure(
|
|
cBar,
|
|
X_DIRECTION_BEARISH,
|
|
X_FIBO_LEVEL_382 //
|
|
);
|
|
|
|
//
|
|
// Bullish Rejection ...
|
|
bool isBullishRejected =
|
|
//
|
|
isInited &&
|
|
isBullish &&
|
|
cBar.low < pBar.low &&
|
|
zBar.low > iBox.upper &&
|
|
cBar.low <= iBox.upper &&
|
|
zBar.open > iBox.upper &&
|
|
hasBullishFiboPressure &&
|
|
cBar.GetLowShadow() > pBar.GetLowShadow()
|
|
//
|
|
;
|
|
|
|
//
|
|
// Bearish Rejection ...
|
|
bool isBearishhRejected =
|
|
//
|
|
isInited &&
|
|
!isBullish &&
|
|
cBar.high > pBar.high &&
|
|
zBar.open < iBox.lower &&
|
|
zBar.high < iBox.lower &&
|
|
hasBearishFiboPressure &&
|
|
cBar.high >= iBox.lower &&
|
|
cBar.GetHighShadow() > pBar.GetHighShadow()
|
|
//
|
|
;
|
|
|
|
//
|
|
has = isBullishRejected ||
|
|
isBearishhRejected;
|
|
if (has)
|
|
{
|
|
//
|
|
idx = i;
|
|
signalBox = iBox;
|
|
hasSignalBox = has;
|
|
signalBox.to = cTime;
|
|
signalBoxDir = iBox.dir;
|
|
isSignalBoxReversal = false;
|
|
provider = X121SMC_XWZ_PROVIDER_ACTIVATED_ZONE;
|
|
}
|
|
|
|
//
|
|
iBox.Clean();
|
|
}
|
|
|
|
//
|
|
// Remove Signal Box from Waiting Boxes of
|
|
// Working Zone ...
|
|
if (hasSignalBox)
|
|
{
|
|
//
|
|
if (IsValidIndex(idx))
|
|
{
|
|
//
|
|
ArrayRemove(
|
|
workingZone.waitingBoxes,
|
|
idx,
|
|
1 //
|
|
);
|
|
}
|
|
}
|
|
|
|
//
|
|
// Ignore Zone's Signals ...
|
|
hasSignalBox = false;
|
|
|
|
//
|
|
// Cleanup Resources ...
|
|
|
|
//
|
|
zBar.Clean();
|
|
cBar.Clean();
|
|
pBar.Clean();
|
|
}
|
|
|
|
//
|
|
// Check Conditions if Has Inside Boxes ...
|
|
bool hasInsideBoxes = hasWorkingZone &&
|
|
workingZone.HasInsideBoxes();
|
|
if (hasInsideBoxes)
|
|
{
|
|
}
|
|
|
|
//
|
|
// Check Conditions if has Breaked Boxes ...
|
|
bool hasBreakedBoxes = hasWorkingZone &&
|
|
workingZone.HasBreakedBoxes();
|
|
if (hasBreakedBoxes)
|
|
{
|
|
}
|
|
|
|
//
|
|
// Checking Other Conditions ...
|
|
if (!hasSignalBox)
|
|
{
|
|
//
|
|
// Senari A ...
|
|
// hasSignalBox = hasWorkingZone &&
|
|
// workingZone.DetectSenarioASignalBox(
|
|
// signalBox,
|
|
// signalBoxDir,
|
|
// decisionXConditions,
|
|
// analyseXConditions,
|
|
// decisionCycleHelper,
|
|
// drawer,
|
|
// zIndex //
|
|
// );
|
|
// if (hasSignalBox)
|
|
// {
|
|
// //
|
|
// signalBox.to = cTime;
|
|
// isSignalBoxReversal = false;
|
|
// provider = X121SMC_XWZ_PROVIDER_PV_ZONE;
|
|
// }
|
|
|
|
// //
|
|
// // Validating Signal Box if Exists ...
|
|
// if (hasSignalBox)
|
|
// {
|
|
// //
|
|
// // Validate Signal Boxes using Inside Box ...
|
|
// if (hasInsideBoxes)
|
|
// {
|
|
// //
|
|
// int idx = -1;
|
|
// bool has = false;
|
|
|
|
// //
|
|
// idx =
|
|
// IsBullish(signalBoxDir)
|
|
// ? GetLowest(workingZone.insideBoxes)
|
|
// : GetHighest(workingZone.insideBoxes);
|
|
// has = IsValidIndex(idx);
|
|
// if (has)
|
|
// {
|
|
// //
|
|
// hasSignalBox =
|
|
// signalBoxDir == workingZone.insideBoxes[idx].dir;
|
|
// }
|
|
// }
|
|
|
|
// //
|
|
// // Validate Signal Box Using Overal Trend ...
|
|
// if (hasWorkingZoneOveralDirection)
|
|
// {
|
|
// //
|
|
// hasSignalBox =
|
|
// signalBoxDir == wzOveralDir;
|
|
// }
|
|
// }
|
|
}
|
|
|
|
//
|
|
//
|
|
//
|
|
|
|
//
|
|
// Cleanup Signal if UnApproved ...
|
|
if (!hasSignalBox)
|
|
{
|
|
//
|
|
signalBox.Clean();
|
|
signalBoxDir = X_DIRECTION_NONE;
|
|
}
|
|
|
|
//
|
|
//
|
|
//
|
|
|
|
//
|
|
// Check Priority Exists ...
|
|
hasPriority = workingZone
|
|
.DetectPriority(
|
|
priority,
|
|
signalBoxDir,
|
|
zIndex,
|
|
period //
|
|
);
|
|
|
|
//
|
|
// Check Price Reward and Amount Exists ...
|
|
hasRewardAmount = CalculateRiskReward(
|
|
priority,
|
|
reward,
|
|
amountPercent //
|
|
);
|
|
|
|
//
|
|
// Check Signal Conditions ...
|
|
if (hasSignalBox)
|
|
{
|
|
//
|
|
int idx = -1;
|
|
bool has = false;
|
|
|
|
//
|
|
XCBoxObject *iObj;
|
|
has = drawer.DrawBox(
|
|
signalBox,
|
|
iObj //
|
|
);
|
|
if (has)
|
|
{
|
|
//
|
|
iObj.BoxWidth(1);
|
|
iObj.BoxColor(clrYellow);
|
|
iObj.BoxStyle(STYLE_SOLID);
|
|
}
|
|
|
|
//
|
|
isBullish = IsBullish(signalBoxDir);
|
|
isBearish = IsBearish(signalBoxDir);
|
|
|
|
//
|
|
pivot = isBullish
|
|
? signalBox.lower
|
|
: signalBox.upper;
|
|
|
|
//
|
|
point = isBullish
|
|
? signalBox.upper
|
|
: signalBox.lower;
|
|
|
|
//
|
|
double iSL = 0;
|
|
double signalBoxRange = (signalBox.upper - signalBox.lower);
|
|
if (signalBoxRange < points * 100)
|
|
{
|
|
iSL = pivot;
|
|
}
|
|
else
|
|
{
|
|
iSL = signalBox.lower + (signalBox.upper - signalBox.lower) / 2;
|
|
}
|
|
|
|
//
|
|
if (provider == X121SMC_XWZ_PROVIDER_PV_ZONE)
|
|
{
|
|
}
|
|
|
|
//
|
|
Add(
|
|
iSL,
|
|
sls //
|
|
);
|
|
|
|
//
|
|
// Select Condition SL ...
|
|
|
|
//
|
|
double entry = GetEntry(
|
|
signalBox.symbol,
|
|
signalBoxDir //
|
|
);
|
|
|
|
//
|
|
double slsMin = GetMin(sls);
|
|
double slsMax = GetMax(sls);
|
|
|
|
//
|
|
double longSL = slsMin;
|
|
double shortSL = slsMax;
|
|
|
|
//
|
|
sl = isBullish
|
|
? longSL
|
|
: shortSL;
|
|
|
|
//
|
|
// Targets ...
|
|
|
|
//
|
|
// Force Add TP 2 as Target ...
|
|
double risk = MathAbs(entry - sl);
|
|
double reward2 = 2 * risk;
|
|
// double iTP2 = isBullish
|
|
// ? entry + reward2
|
|
// : entry - reward2;
|
|
// Add(
|
|
// iTP2,
|
|
// targets //
|
|
// );
|
|
|
|
//
|
|
// Based On Priority ...
|
|
has = priority != X121SMC_XWZ_PRIORITY_NONE;
|
|
if (has)
|
|
{
|
|
//
|
|
switch (priority)
|
|
{
|
|
//
|
|
case X121SMC_XWZ_PRIORITY_WEAK:
|
|
//
|
|
if (isBullish)
|
|
{
|
|
//
|
|
// Weak ...
|
|
Add(
|
|
workingZone.supplyZone.Lower(),
|
|
targets //
|
|
);
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Weak ...
|
|
Add(
|
|
workingZone.demandZone.Upper(),
|
|
targets //
|
|
);
|
|
}
|
|
break;
|
|
|
|
//
|
|
case X121SMC_XWZ_PRIORITY_LOW:
|
|
//
|
|
if (isBullish)
|
|
{
|
|
//
|
|
// Weak ...
|
|
Add(
|
|
workingZone.supplyZone.Lower(),
|
|
targets //
|
|
);
|
|
|
|
//
|
|
// Low ...
|
|
Add(
|
|
workingZone.quarter1,
|
|
targets //
|
|
);
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Weak ...
|
|
Add(
|
|
workingZone.demandZone.Upper(),
|
|
targets //
|
|
);
|
|
|
|
//
|
|
// Low ...
|
|
Add(
|
|
workingZone.quarter3,
|
|
targets //
|
|
);
|
|
}
|
|
break;
|
|
|
|
//
|
|
case X121SMC_XWZ_PRIORITY_REGULAR:
|
|
//
|
|
if (isBullish)
|
|
{
|
|
//
|
|
// Weak ...
|
|
Add(
|
|
workingZone.supplyZone.Lower(),
|
|
targets //
|
|
);
|
|
|
|
//
|
|
// Low ...
|
|
Add(
|
|
workingZone.quarter1,
|
|
targets //
|
|
);
|
|
|
|
//
|
|
// Regular ...
|
|
Add(
|
|
workingZone.quarter2,
|
|
targets //
|
|
);
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Weak ...
|
|
Add(
|
|
workingZone.demandZone.Upper(),
|
|
targets //
|
|
);
|
|
|
|
//
|
|
// Low ...
|
|
Add(
|
|
workingZone.quarter3,
|
|
targets //
|
|
);
|
|
|
|
//
|
|
// Regular ...
|
|
Add(
|
|
workingZone.quarter2,
|
|
targets //
|
|
);
|
|
}
|
|
break;
|
|
|
|
//
|
|
case X121SMC_XWZ_PRIORITY_HIGH:
|
|
//
|
|
if (isBullish)
|
|
{
|
|
//
|
|
// Weak ...
|
|
Add(
|
|
workingZone.supplyZone.Lower(),
|
|
targets //
|
|
);
|
|
|
|
//
|
|
// Low ...
|
|
Add(
|
|
workingZone.quarter1,
|
|
targets //
|
|
);
|
|
|
|
//
|
|
// Regular ...
|
|
Add(
|
|
workingZone.quarter2,
|
|
targets //
|
|
);
|
|
|
|
//
|
|
// High ...
|
|
Add(
|
|
workingZone.quarter3,
|
|
targets //
|
|
);
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Weak ...
|
|
Add(
|
|
workingZone.demandZone.Upper(),
|
|
targets //
|
|
);
|
|
|
|
//
|
|
// Low ...
|
|
Add(
|
|
workingZone.quarter3,
|
|
targets //
|
|
);
|
|
|
|
//
|
|
// Regular ...
|
|
Add(
|
|
workingZone.quarter2,
|
|
targets //
|
|
);
|
|
|
|
//
|
|
// High ...
|
|
Add(
|
|
workingZone.quarter1,
|
|
targets //
|
|
);
|
|
}
|
|
break;
|
|
|
|
//
|
|
case X121SMC_XWZ_PRIORITY_STRONG_HIGH:
|
|
//
|
|
if (isBullish)
|
|
{
|
|
//
|
|
// Weak ...
|
|
Add(
|
|
workingZone.supplyZone.Lower(),
|
|
targets //
|
|
);
|
|
|
|
//
|
|
// Low ...
|
|
Add(
|
|
workingZone.quarter1,
|
|
targets //
|
|
);
|
|
|
|
//
|
|
// Regular ...
|
|
Add(
|
|
workingZone.quarter2,
|
|
targets //
|
|
);
|
|
|
|
//
|
|
// High ...
|
|
Add(
|
|
workingZone.quarter3,
|
|
targets //
|
|
);
|
|
|
|
//
|
|
// Strong High ...
|
|
Add(
|
|
workingZone.demandZone.Upper(),
|
|
targets //
|
|
);
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Weak ...
|
|
Add(
|
|
workingZone.demandZone.Upper(),
|
|
targets //
|
|
);
|
|
|
|
//
|
|
// Low ...
|
|
Add(
|
|
workingZone.quarter3,
|
|
targets //
|
|
);
|
|
|
|
//
|
|
// Regular ...
|
|
Add(
|
|
workingZone.quarter2,
|
|
targets //
|
|
);
|
|
|
|
//
|
|
// High ...
|
|
Add(
|
|
workingZone.quarter1,
|
|
targets //
|
|
);
|
|
|
|
//
|
|
// Strong High ...
|
|
Add(
|
|
workingZone.supplyZone.Lower(),
|
|
targets //
|
|
);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
//
|
|
XBoxZone waitingBoxes[];
|
|
has = workingZone.HasWaitingBoxes();
|
|
if (has)
|
|
{
|
|
//
|
|
Copy(
|
|
workingZone.waitingBoxes,
|
|
waitingBoxes //
|
|
);
|
|
|
|
//
|
|
while (HasChild(waitingBoxes))
|
|
{
|
|
//
|
|
XBoxZone iBox;
|
|
idx = GetYoungest(waitingBoxes);
|
|
has = IsValidIndex(idx);
|
|
if (!has)
|
|
{
|
|
//
|
|
iBox.Clean();
|
|
continue;
|
|
}
|
|
|
|
//
|
|
iBox = waitingBoxes[idx];
|
|
ArrayRemove(
|
|
waitingBoxes,
|
|
idx,
|
|
1 //
|
|
);
|
|
|
|
//
|
|
bool hasInside = workingZone.HasInsideBox(iBox);
|
|
if (!hasInside)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
//
|
|
double iTarget =
|
|
IsBullish(signalBoxDir)
|
|
? iBox.lower
|
|
: iBox.upper;
|
|
|
|
//
|
|
Add(
|
|
iTarget,
|
|
targets //
|
|
);
|
|
|
|
//
|
|
iBox.Clean();
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Summarize Results ...
|
|
result = hasPriority &&
|
|
hasSignalBox &&
|
|
hasRewardAmount;
|
|
|
|
//
|
|
if (result)
|
|
{
|
|
//
|
|
Copy(
|
|
sls,
|
|
mConditions.sls //
|
|
);
|
|
Copy(
|
|
targets,
|
|
mConditions.targets //
|
|
);
|
|
|
|
//
|
|
mConditions.sl = sl;
|
|
mConditions.pivot = pivot;
|
|
mConditions.point = point;
|
|
mConditions.reward = reward;
|
|
mConditions.setupTime = cTime;
|
|
mConditions.dir = signalBoxDir;
|
|
mConditions.priority = priority;
|
|
mConditions.provider = provider;
|
|
mConditions.signalBox = signalBox;
|
|
mConditions.amountPercent = amountPercent;
|
|
}
|
|
|
|
//
|
|
UpdateTo(cTime);
|
|
|
|
//
|
|
// Draw Working Zone ...
|
|
if (hasWorkingZone)
|
|
{
|
|
//
|
|
workingZone.Draw(
|
|
drawer,
|
|
//
|
|
true, // Draw Waiting Boxes ...
|
|
true, // Draw Inside Boxes ...
|
|
true, // Draw Breaked Boxes ...
|
|
true, // Draw Breaked Inside Boxes ...
|
|
//
|
|
true, // Draw Supply Zone ...
|
|
true, // Draw Demand Zone ...
|
|
true, // Draw Supply Zones ...
|
|
true, // Draw Demand Zones ...
|
|
true, // Draw Support Zones ...
|
|
true // Draw Resistance Zones ...
|
|
);
|
|
}
|
|
|
|
//
|
|
//
|
|
//
|
|
|
|
//
|
|
// Cleanup Resources ...
|
|
|
|
//
|
|
Clean(visionPoiEvents);
|
|
Clean(analysePoiEvents);
|
|
Clean(decisionPoiEvents);
|
|
Clean(consolidationPoiEvents);
|
|
|
|
//
|
|
Clean(visionCycleEvents);
|
|
Clean(analyseCycleEvents);
|
|
Clean(decisionCycleEvents);
|
|
Clean(consolidationCycleEvents);
|
|
|
|
//
|
|
visionState.Clean();
|
|
analyseState.Clean();
|
|
decisionState.Clean();
|
|
consolidationState.Clean();
|
|
|
|
//
|
|
visionConditions.Clean();
|
|
analyseConditions.Clean();
|
|
decisionConditions.Clean();
|
|
consolidationConditions.Clean();
|
|
|
|
//
|
|
visionXConditions.Clean();
|
|
analyseXConditions.Clean();
|
|
decisionXConditions.Clean();
|
|
consolidationXConditions.Clean();
|
|
|
|
//
|
|
consolidationZBar.Clean();
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Detect Trigger Conditions ...
|
|
bool DetectSignalTrigger(
|
|
//
|
|
X121SMCStrategyXWZSignalConditions &conditions,
|
|
//
|
|
XC121SMCCycleHelper *decisionCycleHelper,
|
|
XC121SMCCycleHelper *analyseCycleHelper,
|
|
XC121SMCCycleHelper *consolidationCycleHelper,
|
|
XC121SMCCycleHelper *visionCycleHelper,
|
|
//
|
|
int maxAllowedSetupAge = 60
|
|
//
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
result =
|
|
//
|
|
visionCycleHelper != NULL &&
|
|
analyseCycleHelper != NULL &&
|
|
decisionCycleHelper != NULL &&
|
|
consolidationCycleHelper != NULL
|
|
//
|
|
;
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
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;
|
|
|
|
//
|
|
double ask = GetAsk(symbol);
|
|
double bid = GetBid(symbol);
|
|
datetime cTime = TimeCurrent();
|
|
double points = GetPoints(symbol);
|
|
|
|
//
|
|
// Cycles Conditions ...
|
|
|
|
//
|
|
// Decision ...
|
|
ENUM_XPOI_EVENTS decisionPoiEvents[];
|
|
ENUM_X_CYCLE_EVENTS decisionCycleEvents[];
|
|
X121SMCCycleConditions decisionConditions;
|
|
result = decisionCycleHelper.GetConditions(
|
|
decisionCycleEvents,
|
|
decisionPoiEvents,
|
|
decisionConditions,
|
|
zIndex,
|
|
loopback //
|
|
);
|
|
if (!result)
|
|
{
|
|
//
|
|
// Cleanup ...
|
|
|
|
//
|
|
Clean(decisionPoiEvents);
|
|
Clean(decisionCycleEvents);
|
|
|
|
//
|
|
decisionConditions.Clean();
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Analyse ...
|
|
ENUM_XPOI_EVENTS analysePoiEvents[];
|
|
ENUM_X_CYCLE_EVENTS analyseCycleEvents[];
|
|
X121SMCCycleConditions analyseConditions;
|
|
result = analyseCycleHelper.GetConditions(
|
|
analyseCycleEvents,
|
|
analysePoiEvents,
|
|
analyseConditions,
|
|
zIndex,
|
|
loopback //
|
|
);
|
|
if (!result)
|
|
{
|
|
//
|
|
Clean(analysePoiEvents);
|
|
Clean(decisionPoiEvents);
|
|
|
|
//
|
|
Clean(analyseCycleEvents);
|
|
Clean(decisionCycleEvents);
|
|
|
|
//
|
|
analyseConditions.Clean();
|
|
decisionConditions.Clean();
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Cycles POI States ...
|
|
XPOIState decisionState = decisionConditions.state;
|
|
XPOIState analyseState = analyseConditions.state;
|
|
|
|
//
|
|
// Cycle X121Conditions ...
|
|
X121Conditions decisionXConditions = decisionConditions.x121Conditions;
|
|
X121Conditions analyseXConditions = analyseConditions.x121Conditions;
|
|
|
|
//
|
|
double iAtr = decisionXConditions.atrBuffer[1];
|
|
iAtr *= 1.5;
|
|
|
|
//
|
|
// Check Signal Validation ...
|
|
// IMPORTANT: since all Validations done in SetUp Process ...
|
|
// here we only Execute Signal ...
|
|
|
|
//
|
|
result = isBullish ||
|
|
isBearish;
|
|
|
|
//
|
|
if (result)
|
|
{
|
|
//
|
|
conditions.triggerTime = cTime;
|
|
conditions.type = isBullish
|
|
? X_POSITION_TYPE_LONG
|
|
: X_POSITION_TYPE_SHORT;
|
|
|
|
//
|
|
}
|
|
|
|
//
|
|
// Cleanup ...
|
|
|
|
//
|
|
Clean(decisionPoiEvents);
|
|
Clean(decisionCycleEvents);
|
|
|
|
//
|
|
decisionState.Clean();
|
|
decisionConditions.Clean();
|
|
decisionXConditions.Clean();
|
|
|
|
//
|
|
Clean(analysePoiEvents);
|
|
Clean(analyseCycleEvents);
|
|
|
|
//
|
|
analyseState.Clean();
|
|
analyseConditions.Clean();
|
|
analyseXConditions.Clean();
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Detect Guards ...
|
|
bool DetectGuards(
|
|
//
|
|
X121SMCGuard &guards[],
|
|
const XPosition &positions[],
|
|
//
|
|
XC121SMCCycleHelper *decisionCycleHelper,
|
|
XC121SMCCycleHelper *analyseCycleHelper,
|
|
XC121SMCCycleHelper *consolidationCycleHelper,
|
|
XC121SMCCycleHelper *visionCycleHelper
|
|
//
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
return false;
|
|
|
|
//
|
|
Clean(guards);
|
|
|
|
//
|
|
bool isCycleHelpersValid =
|
|
//
|
|
visionCycleHelper != NULL &&
|
|
analyseCycleHelper != NULL &&
|
|
decisionCycleHelper != NULL &&
|
|
consolidationCycleHelper != NULL
|
|
//
|
|
;
|
|
|
|
//
|
|
// Set Provider for Common Guards ...
|
|
string provider = ToString(X_121_SMC_PROVIDER_XWZ);
|
|
|
|
//
|
|
// Check Cycle Helpers Validation ...
|
|
result = isCycleHelpersValid;
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Select Own Positions ...
|
|
int count = ArraySize(positions);
|
|
result = IsValidSize(count);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
XPosition ownPositions[];
|
|
XPosition ownLongPositions[];
|
|
XPosition ownShortPositions[];
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
//
|
|
XPosition iPosition = positions[i];
|
|
bool isOwn = iPosition
|
|
.IsFiltersPassed(
|
|
symbol,
|
|
provider,
|
|
NULL,
|
|
X_POSITION_TYPE_ALL,
|
|
iPosition.magic //
|
|
);
|
|
if (isOwn)
|
|
{
|
|
//
|
|
AddRef(
|
|
iPosition,
|
|
ownPositions //
|
|
);
|
|
|
|
//
|
|
bool isLong = IsLong(positions[i].type);
|
|
if (isLong)
|
|
{
|
|
//
|
|
AddRef(
|
|
iPosition,
|
|
ownLongPositions //
|
|
);
|
|
}
|
|
else
|
|
{
|
|
//
|
|
AddRef(
|
|
iPosition,
|
|
ownShortPositions //
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Check Extracted Positions ...
|
|
|
|
//
|
|
count = ArraySize(ownPositions);
|
|
|
|
//
|
|
int longsCount = ArraySize(ownLongPositions);
|
|
bool hasLongs = IsValidSize(longsCount);
|
|
|
|
//
|
|
int shortsCount = ArraySize(ownShortPositions);
|
|
bool hasShorts = IsValidSize(shortsCount);
|
|
|
|
//
|
|
// Validate Own Positions ...
|
|
result = IsValidSize(count);
|
|
if (!result)
|
|
{
|
|
//
|
|
Clean(ownPositions);
|
|
Clean(ownLongPositions);
|
|
Clean(ownShortPositions);
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
//
|
|
//
|
|
|
|
//
|
|
// Get Global and Common Guards ...
|
|
|
|
//
|
|
ENUM_X_121_SMC_GUARD_ACTIONS ignoreGuards[1] = {
|
|
X_121_SMC_GUARD_ACTION_TRAIL_STOP //
|
|
};
|
|
result = DetectX121SMCGuards(
|
|
provider,
|
|
guards,
|
|
positions,
|
|
decisionCycleHelper,
|
|
analyseCycleHelper,
|
|
consolidationCycleHelper,
|
|
visionCycleHelper,
|
|
//
|
|
ignoreGuards
|
|
//
|
|
);
|
|
|
|
//
|
|
//
|
|
//
|
|
|
|
//
|
|
// Implement Custom Implemented Guards ...
|
|
|
|
//
|
|
// Here we Are Sure there is Positions to Guard ...
|
|
// based on Current Provider ...
|
|
|
|
//
|
|
// Detect Required Data for Analyse Market to Guard Positions ...
|
|
|
|
//
|
|
int zIndex = 0;
|
|
int cIndex = zIndex + 1;
|
|
int pIndex = cIndex + 1;
|
|
int ppIndex = pIndex + 1;
|
|
|
|
//
|
|
int loopback = 10;
|
|
|
|
//
|
|
double ask = GetAsk(symbol);
|
|
double bid = GetBid(symbol);
|
|
datetime cTime = TimeCurrent();
|
|
double points = GetPoints(symbol);
|
|
|
|
//
|
|
// Cycles Conditions ...
|
|
|
|
//
|
|
// Decision ...
|
|
ENUM_XPOI_EVENTS decisionPoiEvents[];
|
|
ENUM_X_CYCLE_EVENTS decisionCycleEvents[];
|
|
X121SMCCycleConditions decisionConditions;
|
|
result = decisionCycleHelper.GetConditions(
|
|
decisionCycleEvents,
|
|
decisionPoiEvents,
|
|
decisionConditions,
|
|
zIndex,
|
|
loopback //
|
|
);
|
|
if (!result)
|
|
{
|
|
//
|
|
Clean(decisionPoiEvents);
|
|
Clean(decisionCycleEvents);
|
|
|
|
//
|
|
decisionConditions.Clean();
|
|
|
|
//
|
|
result = HasChild(guards);
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Analyse ...
|
|
ENUM_XPOI_EVENTS analysePoiEvents[];
|
|
ENUM_X_CYCLE_EVENTS analyseCycleEvents[];
|
|
X121SMCCycleConditions analyseConditions;
|
|
result = analyseCycleHelper.GetConditions(
|
|
analyseCycleEvents,
|
|
analysePoiEvents,
|
|
analyseConditions,
|
|
zIndex,
|
|
loopback //
|
|
);
|
|
if (!result)
|
|
{
|
|
//
|
|
Clean(decisionPoiEvents);
|
|
Clean(decisionCycleEvents);
|
|
|
|
//
|
|
decisionConditions.Clean();
|
|
|
|
//
|
|
Clean(analysePoiEvents);
|
|
Clean(analyseCycleEvents);
|
|
|
|
//
|
|
analyseConditions.Clean();
|
|
|
|
//
|
|
result = HasChild(guards);
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Consolidation ...
|
|
ENUM_XPOI_EVENTS consolidationPoiEvents[];
|
|
ENUM_X_CYCLE_EVENTS consolidationCycleEvents[];
|
|
X121SMCCycleConditions consolidationConditions;
|
|
result = consolidationCycleHelper.GetConditions(
|
|
consolidationCycleEvents,
|
|
consolidationPoiEvents,
|
|
consolidationConditions,
|
|
zIndex,
|
|
loopback //
|
|
);
|
|
if (!result)
|
|
{
|
|
//
|
|
Clean(decisionPoiEvents);
|
|
Clean(decisionCycleEvents);
|
|
|
|
//
|
|
decisionConditions.Clean();
|
|
|
|
//
|
|
Clean(analysePoiEvents);
|
|
Clean(analyseCycleEvents);
|
|
|
|
//
|
|
analyseConditions.Clean();
|
|
|
|
//
|
|
Clean(consolidationPoiEvents);
|
|
Clean(consolidationCycleEvents);
|
|
|
|
//
|
|
consolidationConditions.Clean();
|
|
|
|
//
|
|
result = HasChild(guards);
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Vision ...
|
|
ENUM_XPOI_EVENTS visionPoiEvents[];
|
|
ENUM_X_CYCLE_EVENTS visionCycleEvents[];
|
|
X121SMCCycleConditions visionConditions;
|
|
result = visionCycleHelper.GetConditions(
|
|
visionCycleEvents,
|
|
visionPoiEvents,
|
|
visionConditions,
|
|
zIndex,
|
|
loopback //
|
|
);
|
|
if (!result)
|
|
{
|
|
//
|
|
Clean(decisionPoiEvents);
|
|
Clean(decisionCycleEvents);
|
|
|
|
//
|
|
decisionConditions.Clean();
|
|
|
|
//
|
|
Clean(analysePoiEvents);
|
|
Clean(analyseCycleEvents);
|
|
|
|
//
|
|
analyseConditions.Clean();
|
|
|
|
//
|
|
Clean(consolidationPoiEvents);
|
|
Clean(consolidationCycleEvents);
|
|
|
|
//
|
|
consolidationConditions.Clean();
|
|
|
|
//
|
|
Clean(visionPoiEvents);
|
|
Clean(visionCycleEvents);
|
|
|
|
//
|
|
visionConditions.Clean();
|
|
|
|
//
|
|
result = HasChild(guards);
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Cycles POI States ...
|
|
XPOIState visionState = visionConditions.state;
|
|
XPOIState analyseState = analyseConditions.state;
|
|
XPOIState decisionState = decisionConditions.state;
|
|
XPOIState consolidationState = consolidationConditions.state;
|
|
|
|
//
|
|
// Cycle X121Conditions ...
|
|
X121Conditions visionXConditions = visionConditions.x121Conditions;
|
|
X121Conditions analyseXConditions = analyseConditions.x121Conditions;
|
|
X121Conditions decisionXConditions = decisionConditions.x121Conditions;
|
|
X121Conditions consolidationXConditions = consolidationConditions.x121Conditions;
|
|
|
|
//
|
|
//
|
|
//
|
|
|
|
//
|
|
// Selected Consolidation Zones ...
|
|
|
|
//
|
|
int idx = -1;
|
|
bool has = false;
|
|
|
|
//
|
|
bool hasBullishConsolidationZone = false;
|
|
XConsolidationZone bullishConsolidationZone;
|
|
has = decisionState.HasBullishConsolidationZones();
|
|
if (has)
|
|
{
|
|
//
|
|
idx = GetYoungest(decisionState.bullishConsolidationZones);
|
|
hasBullishConsolidationZone = IsValidIndex(idx);
|
|
if (hasBullishConsolidationZone)
|
|
{
|
|
bullishConsolidationZone = decisionState.bullishConsolidationZones[idx];
|
|
}
|
|
}
|
|
|
|
//
|
|
bool hasBearishConsolidationZone = false;
|
|
XConsolidationZone bearishConsolidationZone;
|
|
has = decisionState.HasBearishConsolidationZones();
|
|
if (has)
|
|
{
|
|
//
|
|
idx = GetYoungest(decisionState.bearishConsolidationZones);
|
|
hasBearishConsolidationZone = IsValidIndex(idx);
|
|
if (hasBearishConsolidationZone)
|
|
{
|
|
bearishConsolidationZone = decisionState.bearishConsolidationZones[idx];
|
|
}
|
|
}
|
|
|
|
//
|
|
// Here We Have all Requirements for Guarding Positions ...
|
|
|
|
//
|
|
// Available Guards:
|
|
// X_121_SMC_GUARD_ACTION_NONE
|
|
// X_121_SMC_GUARD_ACTION_CLOSE
|
|
// X_121_SMC_GUARD_ACTION_CLOSE_ALL
|
|
// X_121_SMC_GUARD_ACTION_CLOSE_LONGS
|
|
// X_121_SMC_GUARD_ACTION_CLOSE_SHORTS
|
|
// X_121_SMC_GUARD_ACTION_PARTIAL_CLOSE
|
|
// X_121_SMC_GUARD_ACTION_TRAIL_STOP
|
|
// X_121_SMC_GUARD_ACTION_TRAIL_TARGET
|
|
// X_121_SMC_GUARD_ACTION_HEDGE
|
|
|
|
//
|
|
// X_121_SMC_GUARD_ACTION_CLOSE:
|
|
// Close Specified Position on Specified Conditions ...
|
|
|
|
//
|
|
// X_121_SMC_GUARD_ACTION_CLOSE_ALL:
|
|
// Close All Positions on Specified Conditions ...
|
|
|
|
//
|
|
// X_121_SMC_GUARD_ACTION_CLOSE_LONGS:
|
|
// Close All Long Positions on Specified Conditions ...
|
|
|
|
//
|
|
// X_121_SMC_GUARD_ACTION_CLOSE_SHORTS:
|
|
// Close All Short Positions on Specified Conditions ...
|
|
|
|
//
|
|
// X_121_SMC_GUARD_ACTION_PARTIAL_CLOSE:
|
|
// Partial Close Specified Position on Specified Conditions ...
|
|
|
|
//
|
|
// X_121_SMC_GUARD_ACTION_TRAIL_STOP:
|
|
// Trail Stop Specified Position on Specified Conditions ...
|
|
bool handleStoptrailingBasedOnConsolidationZones = true;
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
//
|
|
XPosition iPosition = ownPositions[i];
|
|
|
|
//
|
|
bool isLong = IsLong(iPosition.type);
|
|
bool isInProfit = iPosition.profit > 0;
|
|
|
|
//
|
|
double sl = iPosition.sl;
|
|
double tp = iPosition.tp;
|
|
|
|
//
|
|
// Trail Stops Using Consolidation Zones ...
|
|
|
|
//
|
|
bool canTraiLonglUsingCZone =
|
|
//
|
|
handleStoptrailingBasedOnConsolidationZones &&
|
|
//
|
|
(isLong &&
|
|
isInProfit &&
|
|
hasBullishConsolidationZone &&
|
|
bullishConsolidationZone.lower > iPosition.sl &&
|
|
bullishConsolidationZone.lower > iPosition.entry)
|
|
//
|
|
;
|
|
if (canTraiLonglUsingCZone)
|
|
{
|
|
sl = bullishConsolidationZone.lower;
|
|
}
|
|
|
|
//
|
|
bool canTraiShortlUsingCZone =
|
|
//
|
|
handleStoptrailingBasedOnConsolidationZones &&
|
|
//
|
|
(!isLong &&
|
|
isInProfit &&
|
|
hasBearishConsolidationZone &&
|
|
bearishConsolidationZone.upper < iPosition.sl &&
|
|
bearishConsolidationZone.upper < iPosition.entry)
|
|
//
|
|
;
|
|
if (canTraiShortlUsingCZone)
|
|
{
|
|
sl = bearishConsolidationZone.upper;
|
|
}
|
|
|
|
//
|
|
bool canTrailUsingCZone =
|
|
canTraiLonglUsingCZone ||
|
|
canTraiShortlUsingCZone;
|
|
|
|
//
|
|
bool isSLPassed =
|
|
sl > 0 &&
|
|
(isLong
|
|
? iPosition.price - sl >= points * 15
|
|
: sl - iPosition.price >= points * 15);
|
|
|
|
//
|
|
bool canTrail =
|
|
isSLPassed &&
|
|
canTrailUsingCZone;
|
|
if (canTrail)
|
|
{
|
|
//
|
|
X121SMCGuard iGuard;
|
|
|
|
//
|
|
iGuard.time = cTime;
|
|
iGuard.symbol = symbol;
|
|
iGuard.provider = provider;
|
|
iGuard.action = X_121_SMC_GUARD_ACTION_TRAIL_STOP;
|
|
|
|
//
|
|
iGuard.ticket = iPosition.ticket;
|
|
|
|
//
|
|
iGuard.sl = sl;
|
|
|
|
//
|
|
AddGuard(
|
|
iGuard,
|
|
guards //
|
|
);
|
|
}
|
|
}
|
|
|
|
//
|
|
// X_121_SMC_GUARD_ACTION_TRAIL_TARGET:
|
|
// Trail Target Specified Position on Specified Conditions ...
|
|
|
|
//
|
|
// X_121_SMC_GUARD_ACTION_HEDGE:
|
|
// Hedge all Positions on Specified Conditions ...
|
|
|
|
//
|
|
// Cleanup Collections ...
|
|
|
|
//
|
|
Clean(ownPositions);
|
|
Clean(ownLongPositions);
|
|
Clean(ownShortPositions);
|
|
|
|
//
|
|
visionState.Clean();
|
|
analyseState.Clean();
|
|
decisionState.Clean();
|
|
consolidationState.Clean();
|
|
|
|
//
|
|
visionConditions.Clean();
|
|
analyseConditions.Clean();
|
|
decisionConditions.Clean();
|
|
consolidationConditions.Clean();
|
|
|
|
//
|
|
visionXConditions.Clean();
|
|
analyseXConditions.Clean();
|
|
decisionXConditions.Clean();
|
|
consolidationXConditions.Clean();
|
|
|
|
//
|
|
Clean(visionPoiEvents);
|
|
Clean(analysePoiEvents);
|
|
Clean(decisionPoiEvents);
|
|
Clean(consolidationPoiEvents);
|
|
|
|
//
|
|
Clean(visionCycleEvents);
|
|
Clean(analyseCycleEvents);
|
|
Clean(decisionCycleEvents);
|
|
Clean(consolidationCycleEvents);
|
|
|
|
//
|
|
count = ArraySize(guards);
|
|
result = IsValidSize(count);
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Add Conditions to Conditions Collection ...
|
|
int AddConditionsIfNotExists(
|
|
int maxAllowed = 10 //
|
|
)
|
|
{
|
|
//
|
|
int result = 0;
|
|
|
|
//
|
|
bool isSetuped = IsValid(mConditions.setupTime) &&
|
|
HasDirection(mConditions.dir);
|
|
if (!isSetuped)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
int count = ArraySize(mConditionsCollection);
|
|
if (IsValidSize(count))
|
|
{
|
|
//
|
|
// Copy Original Items ...
|
|
X121SMCStrategyXWZSignalConditions tmpItems[];
|
|
Copy(
|
|
mConditionsCollection,
|
|
tmpItems //
|
|
);
|
|
|
|
//
|
|
// Prese Item Data ...
|
|
bool isBullish = IsBullish(mConditions.dir);
|
|
|
|
//
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
//
|
|
X121SMCStrategyXWZSignalConditions iItem = tmpItems[i];
|
|
|
|
//
|
|
bool canRemove = mConditions.dir == iItem.dir &&
|
|
mConditions.pivot == iItem.pivot;
|
|
if (canRemove)
|
|
{
|
|
//
|
|
ArrayRemove(
|
|
mConditionsCollection,
|
|
i,
|
|
1 //
|
|
);
|
|
}
|
|
}
|
|
|
|
//
|
|
Clean(tmpItems);
|
|
}
|
|
|
|
//
|
|
AddRef(
|
|
mConditions,
|
|
mConditionsCollection //
|
|
);
|
|
|
|
//
|
|
// Remove Olds ...
|
|
CleanupArray(
|
|
mConditionsCollection,
|
|
maxAllowed //
|
|
);
|
|
|
|
//
|
|
result = ArraySize(mConditionsCollection);
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Draw Functions ...
|
|
//
|
|
|
|
//
|
|
void DrawBar(
|
|
XOHCL &bar,
|
|
XCPOIDrawer *drawer,
|
|
bool forceClean = true //
|
|
)
|
|
{
|
|
//
|
|
if (forceClean)
|
|
{
|
|
mBarObjects.Clear();
|
|
}
|
|
|
|
//
|
|
if (drawer == NULL ||
|
|
!bar.IsValid())
|
|
{
|
|
return;
|
|
}
|
|
|
|
//
|
|
bool isBullish = bar.IsBullish();
|
|
|
|
//
|
|
int widthBar = 2;
|
|
bool fillShadowsBar = true;
|
|
ENUM_LINE_STYLE styleBar = STYLE_SOLID;
|
|
color clrBar =
|
|
isBullish
|
|
? clrAqua
|
|
: clrMagenta;
|
|
|
|
//
|
|
datetime to = bar.NextAt();
|
|
|
|
//
|
|
XCOHCLObject *iObj;
|
|
bool isCreated = drawer
|
|
.CreateBar(
|
|
bar,
|
|
iObj,
|
|
to //
|
|
);
|
|
if (isCreated)
|
|
{
|
|
//
|
|
iObj.BarSpes(
|
|
widthBar,
|
|
clrBar,
|
|
styleBar //
|
|
);
|
|
|
|
//
|
|
iObj.LowShadowFill(fillShadowsBar);
|
|
iObj.HighShadowFill(fillShadowsBar);
|
|
|
|
//
|
|
mBarObjects.Add(iObj);
|
|
}
|
|
}
|
|
|
|
//
|
|
protected:
|
|
//
|
|
|
|
//
|
|
private:
|
|
//
|
|
// Props ...
|
|
string symbol;
|
|
ENUM_TIMEFRAMES period;
|
|
CArrayObj mObjects;
|
|
CArrayObj mBarObjects;
|
|
CArrayObj mWorkingZoneObjects;
|
|
|
|
/**
|
|
* Initialize ...
|
|
*/
|
|
void Init()
|
|
{
|
|
}
|
|
|
|
/**
|
|
* DeInitialize ...
|
|
*/
|
|
void DeInit()
|
|
{
|
|
//
|
|
mConditions.Clean();
|
|
workingZone.Clean();
|
|
Clean(mConditionsCollection);
|
|
|
|
//
|
|
mBarObjects.Clear();
|
|
}
|
|
|
|
/**
|
|
* Update To Time of Exists Components ...
|
|
*
|
|
* @param value: updated time ...
|
|
*/
|
|
void UpdateTo(
|
|
datetime value = NULL //
|
|
)
|
|
{
|
|
//
|
|
value = NormalizeTime(value);
|
|
|
|
//
|
|
workingZone.UpdateTo(value);
|
|
}
|
|
|
|
//
|
|
// Helpers ...
|
|
|
|
//
|
|
bool CalculateRiskReward(
|
|
ENUM_X121SMC_XWZ_PRIORITY priority,
|
|
double &reward,
|
|
double &amountPercent //
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
reward = 0;
|
|
amountPercent = 0;
|
|
|
|
//
|
|
result = priority != X121SMC_XWZ_PRIORITY_NONE;
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
switch (priority)
|
|
{
|
|
//
|
|
case X121SMC_XWZ_PRIORITY_STRONG_HIGH:
|
|
//
|
|
reward = 6;
|
|
amountPercent = 2;
|
|
break;
|
|
|
|
//
|
|
case X121SMC_XWZ_PRIORITY_HIGH:
|
|
//
|
|
reward = 4;
|
|
amountPercent = 2;
|
|
break;
|
|
|
|
//
|
|
case X121SMC_XWZ_PRIORITY_REGULAR:
|
|
//
|
|
reward = 3;
|
|
amountPercent = 1.5;
|
|
break;
|
|
|
|
//
|
|
case X121SMC_XWZ_PRIORITY_LOW:
|
|
//
|
|
reward = 2;
|
|
amountPercent = 1;
|
|
break;
|
|
|
|
//
|
|
case X121SMC_XWZ_PRIORITY_WEAK:
|
|
//
|
|
reward = 1;
|
|
amountPercent = 0.5;
|
|
break;
|
|
}
|
|
|
|
//
|
|
result =
|
|
//
|
|
reward > 0 &&
|
|
amountPercent > 0
|
|
//
|
|
;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
};
|
|
|
|
// |