3100 lines
78 KiB
Plaintext
3100 lines
78 KiB
Plaintext
//
|
|
bool IsZoneActivated(
|
|
int &zoneIDX,
|
|
int &fvgIDX,
|
|
ENUM_X_DIRECTION &dir,
|
|
ENUM_X121SMC_XWZ_PROVIDERS &signalProvider,
|
|
X121SMCStrategySignalProviderData &provider,
|
|
int barIndex = 0 //
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
fvgIDX = -1;
|
|
zoneIDX = -1;
|
|
dir = X_DIRECTION_NONE;
|
|
signalProvider = X121SMC_XWZ_PROVIDER_NONE;
|
|
|
|
//
|
|
// Normalize Bar Index ...
|
|
if (barIndex < 0)
|
|
{
|
|
barIndex = 0;
|
|
}
|
|
|
|
//
|
|
if (barIndex == 0)
|
|
{
|
|
barIndex = 1;
|
|
}
|
|
|
|
//
|
|
// Validate ...
|
|
result = IsValid() &&
|
|
HasWaitingZones();
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
XOHCL bar;
|
|
result = bar.Init(
|
|
symbol,
|
|
period,
|
|
barIndex //
|
|
);
|
|
if (!result)
|
|
{
|
|
//
|
|
bar.Clean();
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
double peak = provider.decisionXConditions.peaksBuffer[1];
|
|
double vale = provider.decisionXConditions.valesBuffer[1];
|
|
|
|
//
|
|
double analysePeak = provider.analyseXConditions.peaksBuffer[1];
|
|
double analyseVale = provider.analyseXConditions.valesBuffer[1];
|
|
|
|
//
|
|
double consolidationPeak = provider.consolidationXConditions.peaksBuffer[1];
|
|
double consolidationVale = provider.consolidationXConditions.valesBuffer[1];
|
|
|
|
//
|
|
double visionPeak = provider.visionXConditions.peaksBuffer[1];
|
|
double visionVale = provider.visionXConditions.valesBuffer[1];
|
|
|
|
//
|
|
bool isPeaksSame =
|
|
peak == analysePeak &&
|
|
analysePeak == consolidationPeak;
|
|
|
|
//
|
|
bool isValesSame =
|
|
vale == analyseVale &&
|
|
analyseVale == consolidationVale;
|
|
|
|
//
|
|
//
|
|
//
|
|
|
|
//
|
|
bool isDecisionScoreBullish =
|
|
provider.decisionBullishScore > provider.decisionBearishScore;
|
|
|
|
//
|
|
bool isDecisionScoreBearish =
|
|
provider.decisionBearishScore > provider.decisionBullishScore;
|
|
|
|
//
|
|
bool isAnalyseScoreBullish =
|
|
provider.analyseBullishScore > provider.analyseBearishScore;
|
|
|
|
//
|
|
bool isAnalyseScoreBearish =
|
|
provider.analyseBearishScore > provider.analyseBullishScore;
|
|
|
|
//
|
|
bool isConsolidationScoreBullish =
|
|
provider.consolidationBullishScore > provider.consolidationBearishScore;
|
|
|
|
//
|
|
bool isConsolidationScoreBearish =
|
|
provider.consolidationBearishScore > provider.consolidationBullishScore;
|
|
|
|
//
|
|
bool isVisionScoreBullish =
|
|
provider.visionBullishScore > provider.visionBearishScore;
|
|
|
|
//
|
|
bool isVisionScoreBearish =
|
|
provider.visionBearishScore > provider.visionBullishScore;
|
|
|
|
//
|
|
int count = CountWaitingZones();
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
//
|
|
XOBFVG iOBFVG = waitingZones[i];
|
|
|
|
//
|
|
ENUM_X_DIRECTION iDir = iOBFVG.GetDirection();
|
|
bool isBullish = iOBFVG.IsBullish();
|
|
|
|
//
|
|
int fvgsCount = iOBFVG.CountFVGs();
|
|
bool has = IsValidSize(fvgsCount);
|
|
if (has)
|
|
{
|
|
//
|
|
for (int j = 0; j < fvgsCount; j++)
|
|
{
|
|
//
|
|
XCFVG *jFVG = iOBFVG.fvgs[j];
|
|
|
|
//
|
|
XBoxZone iBox;
|
|
has = ToBox(
|
|
iBox,
|
|
jFVG //
|
|
);
|
|
if (has)
|
|
{
|
|
//
|
|
double iRange = iBox.lower + ((iBox.upper - iBox.lower) / 2);
|
|
|
|
//
|
|
// Activate Zone Using PV ...
|
|
bool isPVPassed =
|
|
isBullish
|
|
? vale <= iBox.upper &&
|
|
vale >= iBox.lower
|
|
: peak <= iBox.upper &&
|
|
peak >= iBox.lower;
|
|
bool isPV50Passed =
|
|
isBullish
|
|
? vale < iBox.upper &&
|
|
vale <= iRange &&
|
|
vale > iBox.lower
|
|
: peak < iBox.upper &&
|
|
peak >= iRange &&
|
|
peak > iBox.lower;
|
|
|
|
//
|
|
// Activate Zone using Rejection ...
|
|
bool isRejected =
|
|
isBullish
|
|
? bar.low <= iBox.upper &&
|
|
bar.GetDown() > iBox.upper
|
|
: bar.high >= iBox.lower &&
|
|
bar.GetUp() < iBox.lower;
|
|
|
|
//
|
|
// Combine Result ...
|
|
// result = isPVPassed;
|
|
// || isPVPassed
|
|
// || isPV50Passed
|
|
// || isRejected;
|
|
|
|
//
|
|
result = isPVPassed;
|
|
|
|
if (result)
|
|
{
|
|
//
|
|
fvgIDX = j;
|
|
iBox.Clean();
|
|
zoneIDX = i;
|
|
|
|
//
|
|
break;
|
|
}
|
|
}
|
|
|
|
//
|
|
if (result)
|
|
{
|
|
//
|
|
iBox.Clean();
|
|
ZeroMemory(jFVG);
|
|
|
|
//
|
|
break;
|
|
}
|
|
|
|
//
|
|
iBox.Clean();
|
|
}
|
|
}
|
|
|
|
//
|
|
if (result)
|
|
{
|
|
//
|
|
iOBFVG.Clean();
|
|
break;
|
|
}
|
|
|
|
//
|
|
iOBFVG.Clean();
|
|
}
|
|
|
|
//
|
|
result =
|
|
IsValidIndex(fvgIDX) &&
|
|
IsValidIndex(zoneIDX);
|
|
|
|
//
|
|
bar.Clean();
|
|
|
|
//
|
|
if (result)
|
|
{
|
|
bar.Clean();
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
bool IsBoxActivated(
|
|
XBoxZone &box,
|
|
ENUM_X_DIRECTION &dir,
|
|
ENUM_X121SMC_XWZ_PROVIDERS &signalProvider,
|
|
X121SMCStrategySignalProviderData &provider,
|
|
int barIndex = 0 //
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
box.Clean();
|
|
dir = X_DIRECTION_NONE;
|
|
signalProvider = X121SMC_XWZ_PROVIDER_NONE;
|
|
|
|
//
|
|
if (barIndex < 0)
|
|
{
|
|
barIndex = 0;
|
|
}
|
|
|
|
//
|
|
result = IsValid() &&
|
|
HasWaitingBoxes();
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
XOHCL bar;
|
|
XOHCL cBar;
|
|
XOHCL pBar;
|
|
result = bar.Init(
|
|
symbol,
|
|
period,
|
|
barIndex //
|
|
);
|
|
result =
|
|
result &&
|
|
bar.GetPreviousBar(cBar);
|
|
result =
|
|
result &&
|
|
cBar.GetPreviousBar(pBar);
|
|
if (!result)
|
|
{
|
|
//
|
|
bar.Clean();
|
|
cBar.Clean();
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Retrieve Some Required Data ...
|
|
|
|
//
|
|
double peakZ = provider.decisionXConditions.peaksBuffer[0];
|
|
double valeZ = provider.decisionXConditions.valesBuffer[0];
|
|
double peak = provider.decisionXConditions.peaksBuffer[1];
|
|
double vale = provider.decisionXConditions.valesBuffer[1];
|
|
|
|
//
|
|
double analysePeak = provider.analyseXConditions.peaksBuffer[1];
|
|
double analyseVale = provider.analyseXConditions.valesBuffer[1];
|
|
|
|
//
|
|
double consolidationPeak = provider.consolidationXConditions.peaksBuffer[1];
|
|
double consolidationVale = provider.consolidationXConditions.valesBuffer[1];
|
|
|
|
//
|
|
double visionPeak = provider.visionXConditions.peaksBuffer[1];
|
|
double visionVale = provider.visionXConditions.valesBuffer[1];
|
|
|
|
//
|
|
bool isPeaksSame =
|
|
peak == analysePeak &&
|
|
analysePeak == consolidationPeak;
|
|
|
|
//
|
|
bool isValesSame =
|
|
vale == analyseVale &&
|
|
analyseVale == consolidationVale;
|
|
|
|
//
|
|
// Calculate Scores Conditions ...
|
|
|
|
//
|
|
bool isDecisionScoreBullish =
|
|
provider.decisionBullishScore > provider.decisionBearishScore;
|
|
|
|
//
|
|
bool isDecisionScoreBearish =
|
|
provider.decisionBearishScore > provider.decisionBullishScore;
|
|
|
|
//
|
|
bool isAnalyseScoreBullish =
|
|
provider.analyseBullishScore > provider.analyseBearishScore;
|
|
|
|
//
|
|
bool isAnalyseScoreBearish =
|
|
provider.analyseBearishScore > provider.analyseBullishScore;
|
|
|
|
//
|
|
bool isConsolidationScoreBullish =
|
|
provider.consolidationBullishScore > provider.consolidationBearishScore;
|
|
|
|
//
|
|
bool isConsolidationScoreBearish =
|
|
provider.consolidationBearishScore > provider.consolidationBullishScore;
|
|
|
|
//
|
|
bool isVisionScoreBullish =
|
|
provider.visionBullishScore > provider.visionBearishScore;
|
|
|
|
//
|
|
bool isVisionScoreBearish =
|
|
provider.visionBearishScore > provider.visionBullishScore;
|
|
|
|
//
|
|
bool isScoreBullish =
|
|
isVisionScoreBullish &&
|
|
isAnalyseScoreBullish &&
|
|
isConsolidationScoreBullish;
|
|
|
|
//
|
|
bool isScoreBearish =
|
|
isVisionScoreBearish &&
|
|
isAnalyseScoreBearish &&
|
|
isConsolidationScoreBearish;
|
|
|
|
//
|
|
// Waiting Boxes ...
|
|
int count = CountWaitingBoxes();
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
//
|
|
XBoxZone iBox = waitingBoxes[i];
|
|
bool isBullish = iBox.IsBullish();
|
|
|
|
//
|
|
// Check Score ...
|
|
|
|
//
|
|
bool isScorePassed =
|
|
isBullish
|
|
? isScoreBullish
|
|
: isScoreBearish;
|
|
|
|
//
|
|
// Check Bar Insides ...
|
|
|
|
//
|
|
bool isPBarInside =
|
|
(pBar.high <= iBox.upper &&
|
|
pBar.low >= iBox.lower) ||
|
|
(isBullish
|
|
? pBar.low < iBox.upper &&
|
|
pBar.GetDown() < iBox.upper
|
|
: pBar.high > iBox.lower &&
|
|
pBar.GetUp() > iBox.lower);
|
|
|
|
//
|
|
bool isCBarInside =
|
|
(cBar.high <= iBox.upper &&
|
|
cBar.low >= iBox.lower) ||
|
|
(isBullish
|
|
? cBar.low < iBox.upper &&
|
|
cBar.GetDown() < iBox.upper
|
|
: cBar.high > iBox.lower &&
|
|
cBar.GetUp() > iBox.lower);
|
|
|
|
//
|
|
// Checking Rejection ...
|
|
|
|
//
|
|
// Bullish ...
|
|
bool isBullishRejected =
|
|
isBullish &&
|
|
cBar.low <= iBox.upper &&
|
|
cBar.GetDown() > iBox.upper;
|
|
|
|
//
|
|
// Bearish ...
|
|
bool isBearishRejected =
|
|
!isBullish &&
|
|
cBar.high >= iBox.lower &&
|
|
cBar.GetUp() < iBox.lower;
|
|
|
|
//
|
|
// Check Breaktion ...
|
|
|
|
//
|
|
// Bullish ...
|
|
bool isBullishBreaked =
|
|
isBullish &&
|
|
cBar.high > iBox.upper &&
|
|
cBar.GetUp() > iBox.upper &&
|
|
cBar.low >= iBox.lower;
|
|
|
|
//
|
|
// Bearish ...
|
|
bool isBearishBreaked =
|
|
!isBullish &&
|
|
cBar.low < iBox.lower &&
|
|
cBar.GetDown() < iBox.lower &&
|
|
cBar.high <= iBox.upper;
|
|
|
|
//
|
|
// Checking PV Pass ...
|
|
|
|
//
|
|
bool isBullishPVPassed =
|
|
isBullish &&
|
|
vale == valeZ &&
|
|
vale > iBox.lower &&
|
|
vale < iBox.upper;
|
|
|
|
//
|
|
bool isBearishPVPassed =
|
|
!isBullish &&
|
|
peak == peakZ &&
|
|
peak > iBox.lower &&
|
|
peak < iBox.upper;
|
|
|
|
//
|
|
// Summarise ...
|
|
|
|
//
|
|
// Rejection ...
|
|
bool isRejected = isBullishRejected ||
|
|
isBearishRejected;
|
|
|
|
//
|
|
// Breaktion ...
|
|
bool isBreaked =
|
|
isPBarInside &&
|
|
(isBullishBreaked ||
|
|
isBearishBreaked);
|
|
|
|
//
|
|
bool isPVPassed =
|
|
(isBullishPVPassed ||
|
|
isBearishPVPassed);
|
|
|
|
//
|
|
// Trend Conditions ...
|
|
|
|
//
|
|
bool isX3MABullish =
|
|
provider.decisionXConditions.isX3MaFastOverMid &&
|
|
provider.decisionXConditions.x3maMidBuffer[1] > provider.decisionXConditions.x3maSlowBuffer[1];
|
|
|
|
//
|
|
bool isX3MABearish =
|
|
provider.decisionXConditions.isX3MaFastUnderMid &&
|
|
provider.decisionXConditions.x3maMidBuffer[1] < provider.decisionXConditions.x3maSlowBuffer[1];
|
|
|
|
//
|
|
bool isVWapBullish =
|
|
provider.decisionXConditions.isVWapFastOverMid &&
|
|
provider.decisionXConditions.vwapMidBuffer[1] > provider.decisionXConditions.vwapSlowBuffer[1];
|
|
|
|
//
|
|
bool isVWapBearish =
|
|
provider.decisionXConditions.isX3MaFastUnderMid &&
|
|
provider.decisionXConditions.vwapMidBuffer[1] < provider.decisionXConditions.vwapSlowBuffer[1];
|
|
|
|
//
|
|
bool isTrendBullish =
|
|
isX3MABullish &&
|
|
isVWapBullish;
|
|
|
|
//
|
|
bool isTrendBearish =
|
|
isX3MABearish &&
|
|
isVWapBearish;
|
|
|
|
//
|
|
bool isTrendPassed =
|
|
isBullish
|
|
? isTrendBullish
|
|
: isTrendBearish;
|
|
|
|
//
|
|
// Summarize Conditions ...
|
|
|
|
//
|
|
result =
|
|
//
|
|
// isBreaked ||
|
|
// isRejected ||
|
|
isPVPassed &&
|
|
isRejected &&
|
|
isTrendPassed &&
|
|
isScorePassed
|
|
//
|
|
;
|
|
|
|
//
|
|
if (result)
|
|
{
|
|
//
|
|
box = iBox;
|
|
dir = iBox.dir;
|
|
signalProvider = X121SMC_XWZ_PROVIDER_ACTIVATED_BOX;
|
|
|
|
//
|
|
iBox.Clean();
|
|
break;
|
|
}
|
|
|
|
//
|
|
iBox.Clean();
|
|
|
|
//
|
|
}
|
|
|
|
//
|
|
// MA Trends ...
|
|
if (!result)
|
|
{
|
|
//
|
|
result = provider.analyseState.HasOrderBlocks();
|
|
if (result)
|
|
{
|
|
//
|
|
//
|
|
// Trend Conditions ...
|
|
|
|
//
|
|
bool isX3MABullish =
|
|
provider.decisionXConditions.isX3MaFastCrossedOverMid;
|
|
|
|
//
|
|
bool isX3MABearish =
|
|
provider.decisionXConditions.isX3MaFastCrossedUnderMid;
|
|
|
|
//
|
|
bool isVWapBullish =
|
|
provider.decisionXConditions.isVWapFastCrossedOverMid;
|
|
|
|
//
|
|
bool isVWapBearish =
|
|
provider.decisionXConditions.isVWapFastCrossedUnderMid;
|
|
|
|
//
|
|
//
|
|
//
|
|
|
|
//
|
|
bool isTrendBullish =
|
|
(isX3MABullish ||
|
|
isVWapBullish) &&
|
|
provider.decisionXConditions.isNewPeakOverLast;
|
|
|
|
//
|
|
bool isTrendBearish =
|
|
(isX3MABearish ||
|
|
isVWapBearish) &&
|
|
provider.decisionXConditions.isNewValeUnderLast;
|
|
|
|
//
|
|
result = isTrendBullish ||
|
|
isTrendBearish;
|
|
if (result)
|
|
{
|
|
//
|
|
// Select Signal Box ...
|
|
|
|
//
|
|
bool isScorePassed =
|
|
isTrendBullish
|
|
? isScoreBullish
|
|
: isScoreBearish;
|
|
|
|
//
|
|
XBoxZone tmpBoxes[];
|
|
ToBox(
|
|
provider.analyseState.orderBlocks,
|
|
tmpBoxes //
|
|
);
|
|
Copy(
|
|
waitingBoxes,
|
|
tmpBoxes,
|
|
false //
|
|
);
|
|
int idx = -1;
|
|
// bool has = false;
|
|
while (HasChild(tmpBoxes))
|
|
{
|
|
//
|
|
if (isTrendBullish)
|
|
{
|
|
idx = GetHighest(tmpBoxes);
|
|
}
|
|
else
|
|
{
|
|
idx = GetLowest(tmpBoxes);
|
|
}
|
|
|
|
//
|
|
result = IsValidIndex(idx);
|
|
if (!result)
|
|
{
|
|
break;
|
|
}
|
|
|
|
//
|
|
XBoxZone iBox = tmpBoxes[idx];
|
|
|
|
//
|
|
ArrayRemove(
|
|
tmpBoxes,
|
|
idx,
|
|
1 //
|
|
);
|
|
|
|
//
|
|
int insideIDX = -1;
|
|
bool hasInsideBox = HasInsideBox(
|
|
insideIDX,
|
|
iBox,
|
|
tmpBoxes //
|
|
);
|
|
if (hasInsideBox)
|
|
{
|
|
//
|
|
hasInsideBox =
|
|
isTrendBullish
|
|
? iBox.lower < tmpBoxes[insideIDX].lower
|
|
: iBox.upper > tmpBoxes[insideIDX].upper;
|
|
}
|
|
|
|
//
|
|
bool isBullishPlacePassed =
|
|
// !hasInsideBox &&
|
|
isTrendBullish &&
|
|
iBox.IsBullish() &&
|
|
bar.low >= iBox.upper &&
|
|
cBar.low >= iBox.upper &&
|
|
provider.decisionXConditions.x3maMin >= iBox.lower &&
|
|
provider.decisionXConditions.vwapMin >= iBox.lower;
|
|
|
|
//
|
|
bool isBearishPlacePassed =
|
|
// !hasInsideBox &&
|
|
isTrendBearish &&
|
|
iBox.IsBearish() &&
|
|
bar.high <= iBox.lower &&
|
|
cBar.high <= iBox.lower &&
|
|
provider.decisionXConditions.x3maMax <= iBox.upper &&
|
|
provider.decisionXConditions.vwapMax <= iBox.upper;
|
|
|
|
//
|
|
result = isScorePassed &&
|
|
(isBullishPlacePassed ||
|
|
isBearishPlacePassed);
|
|
if (result)
|
|
{
|
|
//
|
|
box = iBox;
|
|
iBox.Clean();
|
|
dir =
|
|
isTrendBullish
|
|
? X_DIRECTION_BULLISH
|
|
: X_DIRECTION_BEARISH;
|
|
signalProvider = X121SMC_XWZ_PROVIDER_ACTIVATED_MA;
|
|
break;
|
|
}
|
|
|
|
//
|
|
}
|
|
Clean(tmpBoxes);
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Supply and Demand ...
|
|
if (false && !result)
|
|
{
|
|
//
|
|
int idx = -1;
|
|
bool has = false;
|
|
XBoxZone tmpBoxes[];
|
|
|
|
//
|
|
// Detecting Youngest Zones ...
|
|
|
|
//
|
|
XBoxZone bullishBox;
|
|
bool hasBullishBox = false;
|
|
if (!hasBullishBox)
|
|
{
|
|
//
|
|
XCOrderBlock *ob = NULL;
|
|
idx = GetYoungest(provider.analyseState.bullishOrderBlocks);
|
|
has = IsValidIndex(idx);
|
|
if (has)
|
|
{
|
|
//
|
|
ob = provider.analyseState.bullishOrderBlocks[idx];
|
|
|
|
//
|
|
XOHCL startedBar;
|
|
bool isBodyOut = false;
|
|
bool isStarted = ob.IsStarted(
|
|
ob.GetDirection(),
|
|
startedBar,
|
|
isBodyOut //
|
|
);
|
|
has = isStarted &&
|
|
isBodyOut;
|
|
if (has)
|
|
{
|
|
//
|
|
hasBullishBox = ToBox(
|
|
bullishBox,
|
|
ob //
|
|
);
|
|
}
|
|
}
|
|
|
|
//
|
|
if (!hasBullishBox)
|
|
{
|
|
bullishBox.Clean();
|
|
}
|
|
|
|
//
|
|
ZeroMemory(ob);
|
|
}
|
|
|
|
//
|
|
XBoxZone bearishBox;
|
|
bool hasBearishBox = false;
|
|
if (!hasBearishBox)
|
|
{
|
|
//
|
|
XCOrderBlock *ob = NULL;
|
|
idx = GetYoungest(provider.analyseState.bearishOrderBlocks);
|
|
has = IsValidIndex(idx);
|
|
if (has)
|
|
{
|
|
//
|
|
ob = provider.analyseState.bearishOrderBlocks[idx];
|
|
|
|
//
|
|
XOHCL startedBar;
|
|
bool isBodyOut = false;
|
|
bool isStarted = ob.IsStarted(
|
|
ob.GetDirection(),
|
|
startedBar,
|
|
isBodyOut //
|
|
);
|
|
has = isStarted &&
|
|
isBodyOut;
|
|
if (has)
|
|
{
|
|
//
|
|
hasBearishBox = ToBox(
|
|
bearishBox,
|
|
ob //
|
|
);
|
|
}
|
|
}
|
|
|
|
//
|
|
if (!hasBearishBox)
|
|
{
|
|
bearishBox.Clean();
|
|
}
|
|
|
|
//
|
|
ZeroMemory(ob);
|
|
}
|
|
|
|
//
|
|
XBoxZone bullishCZBox;
|
|
bool hasBullishConsolidationZone = false;
|
|
XConsolidationZone bullishConsolidationZone;
|
|
hasBullishConsolidationZone = provider.decisionState.HasBullishConsolidationZones();
|
|
if (hasBullishConsolidationZone)
|
|
{
|
|
//
|
|
idx = GetYoungest(provider.decisionState.bullishConsolidationZones);
|
|
hasBullishConsolidationZone = IsValidIndex(idx);
|
|
if (hasBullishConsolidationZone)
|
|
{
|
|
//
|
|
bullishConsolidationZone = provider.decisionState.bullishConsolidationZones[idx];
|
|
if (hasBullishConsolidationZone)
|
|
{
|
|
//
|
|
hasBullishConsolidationZone = ToBox(
|
|
bullishCZBox,
|
|
bullishConsolidationZone //
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
XBoxZone bearishCZBox;
|
|
bool hasBearishConsolidationZone = false;
|
|
XConsolidationZone bearishConsolidationZone;
|
|
hasBearishConsolidationZone = provider.decisionState.HasBearishConsolidationZones();
|
|
if (hasBearishConsolidationZone)
|
|
{
|
|
//
|
|
idx = GetYoungest(provider.decisionState.bearishConsolidationZones);
|
|
hasBearishConsolidationZone = IsValidIndex(idx);
|
|
if (hasBearishConsolidationZone)
|
|
{
|
|
//
|
|
bearishConsolidationZone = provider.decisionState.bearishConsolidationZones[idx];
|
|
if (hasBearishConsolidationZone)
|
|
{
|
|
//
|
|
hasBearishConsolidationZone = ToBox(
|
|
bearishCZBox,
|
|
bearishConsolidationZone //
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
//
|
|
//
|
|
|
|
//
|
|
// Supply Zone ...
|
|
has = provider.visionState.HasSupplyZones();
|
|
if (has)
|
|
{
|
|
//
|
|
ToBox(
|
|
provider.visionState.supplyZones,
|
|
tmpBoxes //
|
|
);
|
|
|
|
//
|
|
while (HasChild(tmpBoxes))
|
|
{
|
|
//
|
|
idx = GetYoungest(tmpBoxes);
|
|
has = IsValidIndex(idx);
|
|
if (!has)
|
|
{
|
|
break;
|
|
}
|
|
|
|
//
|
|
XBoxZone iBox = tmpBoxes[idx];
|
|
ArrayRemove(
|
|
tmpBoxes,
|
|
idx,
|
|
1 //
|
|
);
|
|
|
|
//
|
|
// Price Must Be Inside a Zonne More Than 5 Bar ...
|
|
bool isPriceInside =
|
|
//
|
|
bar.high < iBox.upper &&
|
|
bar.low > iBox.lower &&
|
|
//
|
|
cBar.high < iBox.upper &&
|
|
cBar.low > iBox.lower &&
|
|
//
|
|
pBar.high < iBox.upper &&
|
|
pBar.low > iBox.lower
|
|
//
|
|
;
|
|
|
|
//
|
|
bool isBearishBoxPassed =
|
|
hasBearishBox &&
|
|
IsBoxInside(
|
|
bearishBox,
|
|
iBox //
|
|
);
|
|
|
|
//
|
|
bool isBearishCZBoxPassed =
|
|
hasBearishConsolidationZone &&
|
|
IsBoxInside(
|
|
bearishCZBox,
|
|
iBox //
|
|
);
|
|
|
|
//
|
|
result = isPriceInside &&
|
|
(isBearishBoxPassed ||
|
|
isBearishCZBoxPassed);
|
|
if (result)
|
|
{
|
|
//
|
|
if (isBearishBoxPassed)
|
|
{
|
|
box = bearishBox;
|
|
}
|
|
else
|
|
{
|
|
box = bearishCZBox;
|
|
}
|
|
|
|
//
|
|
iBox.to = TimeCurrent();
|
|
XCBoxObject *iObj;
|
|
provider.visionCycleHelper.mPOIDrawer.DrawBox(
|
|
iBox,
|
|
iObj //
|
|
);
|
|
|
|
//
|
|
dir = X_DIRECTION_BEARISH;
|
|
signalProvider = X121SMC_XWZ_PROVIDER_ACTIVATED_AREA;
|
|
|
|
//
|
|
iBox.Clean();
|
|
|
|
//
|
|
break;
|
|
}
|
|
|
|
//
|
|
iBox.Clean();
|
|
}
|
|
|
|
//
|
|
Clean(tmpBoxes);
|
|
}
|
|
|
|
//
|
|
// Demand Zone ...
|
|
has = provider.visionState.HasDemandZones();
|
|
if (!result && has)
|
|
{
|
|
//
|
|
ToBox(
|
|
provider.visionState.demandZones,
|
|
tmpBoxes //
|
|
);
|
|
|
|
//
|
|
while (HasChild(tmpBoxes))
|
|
{
|
|
//
|
|
idx = GetYoungest(tmpBoxes);
|
|
has = IsValidIndex(idx);
|
|
if (!has)
|
|
{
|
|
break;
|
|
}
|
|
|
|
//
|
|
XBoxZone iBox = tmpBoxes[idx];
|
|
ArrayRemove(
|
|
tmpBoxes,
|
|
idx,
|
|
1 //
|
|
);
|
|
|
|
//
|
|
// Price Must Be Inside a Zonne More Than 5 Bar ...
|
|
bool isPriceInside =
|
|
//
|
|
bar.high < iBox.upper &&
|
|
bar.low > iBox.lower &&
|
|
//
|
|
cBar.high < iBox.upper &&
|
|
cBar.low > iBox.lower &&
|
|
//
|
|
pBar.high < iBox.upper &&
|
|
pBar.low > iBox.lower
|
|
//
|
|
;
|
|
|
|
//
|
|
bool isBullishBoxPassed =
|
|
hasBullishBox &&
|
|
IsBoxInside(
|
|
bullishBox,
|
|
iBox //
|
|
);
|
|
|
|
//
|
|
bool isBullishCZBoxPassed =
|
|
hasBullishConsolidationZone &&
|
|
IsBoxInside(
|
|
bullishCZBox,
|
|
iBox //
|
|
);
|
|
|
|
//
|
|
result = isPriceInside &&
|
|
(isBullishBoxPassed ||
|
|
isBullishCZBoxPassed);
|
|
if (result)
|
|
{
|
|
//
|
|
if (isBullishBoxPassed)
|
|
{
|
|
box = bullishBox;
|
|
}
|
|
else
|
|
{
|
|
box = bullishCZBox;
|
|
}
|
|
|
|
//
|
|
iBox.to = TimeCurrent();
|
|
XCBoxObject *iObj;
|
|
provider.visionCycleHelper.mPOIDrawer.DrawBox(
|
|
iBox,
|
|
iObj //
|
|
);
|
|
|
|
//
|
|
dir = X_DIRECTION_BULLISH;
|
|
signalProvider = X121SMC_XWZ_PROVIDER_ACTIVATED_AREA;
|
|
|
|
//
|
|
iBox.Clean();
|
|
|
|
//
|
|
break;
|
|
}
|
|
|
|
//
|
|
iBox.Clean();
|
|
}
|
|
|
|
//
|
|
Clean(tmpBoxes);
|
|
}
|
|
|
|
//
|
|
Clean(tmpBoxes);
|
|
|
|
//
|
|
bullishBox.Clean();
|
|
bearishBox.Clean();
|
|
bullishCZBox.Clean();
|
|
bearishCZBox.Clean();
|
|
bullishConsolidationZone.Clean();
|
|
bearishConsolidationZone.Clean();
|
|
|
|
//
|
|
}
|
|
|
|
//
|
|
bar.Clean();
|
|
cBar.Clean();
|
|
pBar.Clean();
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
|
|
// //
|
|
// bool isZoneActivated =
|
|
// hasWorkingZone &&
|
|
// hasWaitingZones &&
|
|
// workingZone.IsZoneActivated(
|
|
// activatedZoneIDX,
|
|
// activatedFVGIDX,
|
|
// signalBoxDir,
|
|
// signalProvider,
|
|
// provider,
|
|
// zIndex //
|
|
// );
|
|
|
|
//
|
|
// hasSignalBox =
|
|
// hasWorkingZone &&
|
|
// hasWaitingBoxes &&
|
|
// workingZone.IsBoxActivated(
|
|
// signalBox,
|
|
// signalBoxDir,
|
|
// signalProvider,
|
|
// provider,
|
|
// zIndex //
|
|
// );
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
|
|
int activatedFVGIDX = -1;
|
|
int activatedZoneIDX = -1;
|
|
bool hasWaitingZones = false;
|
|
|
|
//
|
|
// Remove Invalidate Zones ...
|
|
if (hasWaitingZones)
|
|
{
|
|
//
|
|
// Validate Waiting Zones ...
|
|
workingZone.ValidateWaitingZones(zIndex);
|
|
hasWaitingZones = workingZone.HasWaitingZones();
|
|
}
|
|
|
|
//
|
|
// Detect Zones and Boxes ...
|
|
// hasWaitingZones = workingZone.DetectZone(
|
|
// provider //
|
|
// );
|
|
|
|
//
|
|
hasWaitingBoxes = workingZone.HasWaitingBoxes();
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
// Senario 1:
|
|
// ----------
|
|
bool useSenario1 = true;
|
|
bool isSenario1Happend = false;
|
|
bool isSenario1Bullish = false;
|
|
bool isSenario1Bearish = false;
|
|
if (useSenario1)
|
|
{
|
|
//
|
|
// Senario 1 Bullish Conditions ...
|
|
isSenario1Bullish =
|
|
//
|
|
// X3Ma / XVwap Switched To Bulish ...
|
|
(
|
|
//
|
|
// X3Ma Switched To Bulish ...
|
|
(
|
|
//
|
|
(provider.decisionXConditions.isX3MaFastCrossedOverMid &&
|
|
decisionParser.isX3MaBullishStateUnderValesGoldenZone)
|
|
//
|
|
)
|
|
//
|
|
||
|
|
//
|
|
// XVWap Switched To Bulish ...
|
|
(
|
|
//
|
|
(provider.decisionXConditions.isVWapFastCrossedOverMid &&
|
|
decisionParser.isVWapBullishStateUnderValesGoldenZone)
|
|
//
|
|
)
|
|
//
|
|
)
|
|
//
|
|
&&
|
|
//
|
|
// Checking other Conditions ...
|
|
(
|
|
//
|
|
// XSTR ...
|
|
provider.decisionXConditions.isStrBullish &&
|
|
//
|
|
// XCHE ...
|
|
provider.decisionXConditions.isCheBullish &&
|
|
provider.decisionXConditions.le1Buffer[cIDX] < cBar.low &&
|
|
provider.decisionXConditions.le2Buffer[cIDX] < cBar.low
|
|
//
|
|
)
|
|
//
|
|
;
|
|
|
|
//
|
|
// Senario 1 Bearish Conditions ...
|
|
isSenario1Bearish =
|
|
//
|
|
// X3Ma / XVwap Switched To Bearish ...
|
|
(
|
|
//
|
|
// X3Ma Switched To Bearish ...
|
|
(
|
|
//
|
|
(provider.decisionXConditions.isX3MaFastCrossedUnderMid &&
|
|
decisionParser.isX3MaBearishStateOverPeaksGoldenZone)
|
|
//
|
|
)
|
|
//
|
|
||
|
|
//
|
|
// XVWap Switched To Bearish ...
|
|
(
|
|
//
|
|
(provider.decisionXConditions.isVWapFastCrossedUnderMid &&
|
|
decisionParser.isVWapBearishStateOverPeaksGoldenZone)
|
|
//
|
|
)
|
|
//
|
|
)
|
|
//
|
|
&&
|
|
//
|
|
// Checking other Conditions ...
|
|
(
|
|
//
|
|
// XSTR ...
|
|
provider.decisionXConditions.isStrBearish &&
|
|
//
|
|
// XCHE ...
|
|
provider.decisionXConditions.isCheBearish &&
|
|
provider.decisionXConditions.se1Buffer[cIDX] > cBar.high &&
|
|
provider.decisionXConditions.se2Buffer[cIDX] > cBar.high
|
|
//
|
|
)
|
|
//
|
|
;
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
isSenario2Happend = cParser.HasSenario2Conditions(
|
|
X_CYCLE_DECISION, // TFT Cycle ...
|
|
X_CYCLE_ANALYSE, // MTF Cycle ...
|
|
X_CYCLE_CONSOLIDATION, // HTF Cycle ...
|
|
box,
|
|
holderBox,
|
|
dir,
|
|
provider,
|
|
barIndex //
|
|
);
|
|
|
|
//
|
|
isSenario2Bullish =
|
|
isSenario2Happend &&
|
|
IsBullish(dir);
|
|
|
|
//
|
|
isSenario2Bearish =
|
|
isSenario2Happend &&
|
|
IsBearish(dir);
|
|
|
|
//
|
|
if (isSenario2Happend)
|
|
{
|
|
signalProvider = X121SMC_XWZ_PROVIDER_ACTIVATED_BOX;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Extract Cycles ...
|
|
|
|
//
|
|
// TTF Cycle ...
|
|
XPOIState ttfState;
|
|
X121Conditions ttfXConditions;
|
|
XC121SMCCycleHelper *ttfHelper;
|
|
X121SMCCycleConditions ttfConditions;
|
|
result = provider.SelectCycle(
|
|
ttfCycle,
|
|
ttfState,
|
|
ttfXConditions,
|
|
ttfHelper,
|
|
ttfConditions //
|
|
);
|
|
if (!result)
|
|
{
|
|
//
|
|
ttfState.Clean();
|
|
ZeroMemory(ttfHelper);
|
|
ttfConditions.Clean();
|
|
ttfXConditions.Clean();
|
|
|
|
//
|
|
return result;
|
|
}
|
|
Parse(ttfXConditions);
|
|
|
|
//
|
|
// MTF Cycle ...
|
|
XPOIState mtfState;
|
|
X121Conditions mtfXConditions;
|
|
XC121SMCCycleHelper *mtfHelper;
|
|
X121SMCCycleConditions mtfConditions;
|
|
result = provider.SelectCycle(
|
|
mtfCycle,
|
|
mtfState,
|
|
mtfXConditions,
|
|
mtfHelper,
|
|
mtfConditions //
|
|
);
|
|
if (!result)
|
|
{
|
|
//
|
|
ttfState.Clean();
|
|
mtfState.Clean();
|
|
ZeroMemory(ttfHelper);
|
|
ttfConditions.Clean();
|
|
ZeroMemory(mtfHelper);
|
|
mtfConditions.Clean();
|
|
ttfXConditions.Clean();
|
|
mtfXConditions.Clean();
|
|
|
|
//
|
|
return result;
|
|
}
|
|
Parse(mtfXConditions);
|
|
|
|
//
|
|
// HTF Cycle ...
|
|
XPOIState htfState;
|
|
X121Conditions htfXConditions;
|
|
XC121SMCCycleHelper *htfHelper;
|
|
X121SMCCycleConditions htfConditions;
|
|
result = provider.SelectCycle(
|
|
htfCycle,
|
|
htfState,
|
|
htfXConditions,
|
|
htfHelper,
|
|
htfConditions //
|
|
);
|
|
if (!result)
|
|
{
|
|
//
|
|
ttfState.Clean();
|
|
mtfState.Clean();
|
|
htfState.Clean();
|
|
ZeroMemory(ttfHelper);
|
|
ZeroMemory(mtfHelper);
|
|
ZeroMemory(htfHelper);
|
|
ttfConditions.Clean();
|
|
mtfConditions.Clean();
|
|
htfConditions.Clean();
|
|
ttfXConditions.Clean();
|
|
mtfXConditions.Clean();
|
|
htfXConditions.Clean();
|
|
|
|
//
|
|
return result;
|
|
}
|
|
Parse(htfXConditions);
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
dir =
|
|
isBullish
|
|
? X_DIRECTION_BULLISH
|
|
: X_DIRECTION_BEARISH;
|
|
|
|
//
|
|
box.dir = dir;
|
|
box.to = TimeCurrent();
|
|
box.symbol = ttfXConditions.symbol;
|
|
box.period = ttfXConditions.period;
|
|
|
|
//
|
|
int fromIDX = -1;
|
|
if (isBullish)
|
|
{
|
|
//
|
|
double vale = ttfXConditions.valesBuffer[cIDX];
|
|
box.lower = vale;
|
|
box.upper = ttfXConditions.valesGoldenBuffer[cIDX];
|
|
|
|
//
|
|
int lowerValeIDX = -1;
|
|
double lowerVale = ttfHelper
|
|
.mX121Helper
|
|
.xpvHelper
|
|
.GetLowerVale(
|
|
lowerValeIDX,
|
|
vale,
|
|
cBar.Index() //
|
|
);
|
|
|
|
//
|
|
int higherValeIDX = -1;
|
|
double higherVale = ttfHelper
|
|
.mX121Helper
|
|
.xpvHelper
|
|
.GetHigherVale(
|
|
higherValeIDX,
|
|
vale,
|
|
cBar.Index() //
|
|
);
|
|
|
|
//
|
|
if (IsValidIndex(lowerValeIDX) &&
|
|
IsValidIndex(higherValeIDX))
|
|
{
|
|
//
|
|
fromIDX =
|
|
lowerValeIDX < higherValeIDX
|
|
? lowerValeIDX
|
|
: higherValeIDX;
|
|
}
|
|
else if (IsValidIndex(lowerValeIDX) &&
|
|
!IsValidIndex(higherValeIDX))
|
|
{
|
|
//
|
|
fromIDX = lowerValeIDX;
|
|
}
|
|
else if (!IsValidIndex(lowerValeIDX) &&
|
|
IsValidIndex(higherValeIDX))
|
|
{
|
|
//
|
|
fromIDX = higherValeIDX;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//
|
|
double peak = ttfXConditions.peaksBuffer[cIDX];
|
|
box.upper = peak;
|
|
|
|
//
|
|
box.lower = ttfXConditions.peaksGoldenBuffer[cIDX];
|
|
|
|
//
|
|
int lowerPeakIDX = -1;
|
|
double lowerPeak = ttfHelper
|
|
.mX121Helper
|
|
.xpvHelper
|
|
.GetLowerPeak(
|
|
lowerPeakIDX,
|
|
peak,
|
|
cBar.Index() //
|
|
);
|
|
|
|
//
|
|
int higherPeakIDX = -1;
|
|
double higherPeak = ttfHelper
|
|
.mX121Helper
|
|
.xpvHelper
|
|
.GetHigherPeak(
|
|
higherPeakIDX,
|
|
peak,
|
|
cBar.Index() //
|
|
);
|
|
|
|
//
|
|
if (IsValidIndex(lowerPeakIDX) &&
|
|
IsValidIndex(higherPeakIDX))
|
|
{
|
|
//
|
|
fromIDX =
|
|
lowerPeakIDX < higherPeakIDX
|
|
? lowerPeakIDX
|
|
: higherPeakIDX;
|
|
}
|
|
else if (IsValidIndex(lowerPeakIDX) &&
|
|
!IsValidIndex(higherPeakIDX))
|
|
{
|
|
//
|
|
fromIDX = lowerPeakIDX;
|
|
}
|
|
else if (!IsValidIndex(lowerPeakIDX) &&
|
|
IsValidIndex(higherPeakIDX))
|
|
{
|
|
//
|
|
fromIDX = higherPeakIDX;
|
|
}
|
|
}
|
|
|
|
//
|
|
if (IsValidIndex(fromIDX))
|
|
{
|
|
//
|
|
box.from = iTime(
|
|
zBar.symbol,
|
|
zBar.period,
|
|
fromIDX //
|
|
);
|
|
}
|
|
else
|
|
{
|
|
box.from = pBar.time;
|
|
}
|
|
|
|
//
|
|
// Detect Holder Box ...
|
|
XBoxZone tmpBoxes[];
|
|
if (htfState.IsValid())
|
|
{
|
|
//
|
|
if (isBullish)
|
|
{
|
|
//
|
|
// Demand Zones ...
|
|
XBoxZone tmp[];
|
|
ToBox(
|
|
htfState.demandZones,
|
|
tmp //
|
|
);
|
|
Copy(
|
|
tmp,
|
|
tmpBoxes,
|
|
false //
|
|
);
|
|
Clean(tmp);
|
|
|
|
//
|
|
// Bullish Order Blocks ...
|
|
ToBox(
|
|
htfState.bullishOrderBlocks,
|
|
tmp //
|
|
);
|
|
Copy(
|
|
tmp,
|
|
tmpBoxes,
|
|
false //
|
|
);
|
|
Clean(tmp);
|
|
|
|
//
|
|
// Bullish Fair Value Gaps ...
|
|
ToBox(
|
|
htfState.bullishFairValueGaps,
|
|
tmp //
|
|
);
|
|
Copy(
|
|
tmp,
|
|
tmpBoxes,
|
|
false //
|
|
);
|
|
Clean(tmp);
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Supply Zones ...
|
|
XBoxZone tmp[];
|
|
ToBox(
|
|
htfState.supplyZones,
|
|
tmp //
|
|
);
|
|
Copy(
|
|
tmp,
|
|
tmpBoxes,
|
|
false //
|
|
);
|
|
Clean(tmp);
|
|
|
|
//
|
|
// Bearish Order Blocks ...
|
|
ToBox(
|
|
htfState.bearishOrderBlocks,
|
|
tmp //
|
|
);
|
|
Copy(
|
|
tmp,
|
|
tmpBoxes,
|
|
false //
|
|
);
|
|
Clean(tmp);
|
|
|
|
//
|
|
// Bearish Fair Value Gaps ...
|
|
ToBox(
|
|
htfState.bearishFairValueGaps,
|
|
tmp //
|
|
);
|
|
Copy(
|
|
tmp,
|
|
tmpBoxes,
|
|
false //
|
|
);
|
|
Clean(tmp);
|
|
}
|
|
}
|
|
|
|
//
|
|
has = HasChild(tmpBoxes);
|
|
if (has)
|
|
{
|
|
//
|
|
while (HasChild(tmpBoxes))
|
|
{
|
|
//
|
|
idx = GetOldest(tmpBoxes);
|
|
has = IsValidIndex(idx);
|
|
if (!has)
|
|
{
|
|
break;
|
|
}
|
|
|
|
//
|
|
XBoxZone iBox = tmpBoxes[idx];
|
|
ArrayRemove(
|
|
tmpBoxes,
|
|
idx,
|
|
1 //
|
|
);
|
|
|
|
//
|
|
has = IsBoxInside(
|
|
box,
|
|
iBox //
|
|
);
|
|
if (has)
|
|
{
|
|
//
|
|
holderBox = iBox;
|
|
holderBox.to = TimeCurrent();
|
|
iBox.Clean();
|
|
break;
|
|
}
|
|
|
|
//
|
|
iBox.Clean();
|
|
}
|
|
}
|
|
|
|
//
|
|
Clean(tmpBoxes);
|
|
|
|
//
|
|
// Validate Conditions to Force Has Holder Box ...
|
|
result =
|
|
result &&
|
|
holderBox.IsValid();
|
|
if (!result)
|
|
{
|
|
//
|
|
isBullish = false;
|
|
isBearish = false;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
// Here we Looking for Detectiong Signal Conditions ...
|
|
if (result)
|
|
{
|
|
//
|
|
insideBox.from = insideBox.to;
|
|
insideBox.to = zBar.time;
|
|
|
|
//
|
|
XCBoxObject *iObj;
|
|
has = ttfHelper.mPOIDrawer.DrawBox(
|
|
insideBox,
|
|
iObj //
|
|
);
|
|
if (has)
|
|
{
|
|
//
|
|
iObj.Width(2);
|
|
iObj.BoxColor(clrGray);
|
|
}
|
|
|
|
//
|
|
Print("Has Inside Box ...");
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
XOBFVG waitingZones[];
|
|
XOBFVG unavailableZones[];
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
bool DetectZone(
|
|
X121SMCStrategySignalProviderData & provider //
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
result = IsValid() &&
|
|
provider.IsValid();
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
int idx = -1;
|
|
int count = 0;
|
|
bool has = false;
|
|
datetime cTime = TimeCurrent();
|
|
|
|
//
|
|
XOBFVG obFVG;
|
|
XBoxZone obBox;
|
|
XBoxZone fvgBox;
|
|
XBoxZone supplyBox;
|
|
XBoxZone demandBox;
|
|
|
|
//
|
|
XCFVG *fvg = NULL;
|
|
XCOrderBlock *ob = NULL;
|
|
XCSupplyZone *supply = NULL;
|
|
XCDemandZone *demand = NULL;
|
|
|
|
//
|
|
// Check New Supply Zone Detection ...
|
|
bool hasNewSupply =
|
|
Contains(
|
|
X_SUPPLY_ZONE_DETECTED,
|
|
provider.consolidationPoiEvents //
|
|
);
|
|
if (hasNewSupply)
|
|
{
|
|
//
|
|
idx = GetYoungest(provider
|
|
.consolidationState
|
|
.supplyZones //
|
|
);
|
|
has = IsValidIndex(idx);
|
|
if (has)
|
|
{
|
|
//
|
|
supply = provider
|
|
.consolidationState
|
|
.supplyZones[idx];
|
|
has = ToBox(
|
|
supplyBox,
|
|
supply //
|
|
);
|
|
if (has)
|
|
{
|
|
//
|
|
supply.To(cTime);
|
|
supplyBox.to = cTime;
|
|
hasNewSupply = supplyBox.IsValid();
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Check New Demand Zone Detection ...
|
|
bool hasNewDemand =
|
|
Contains(
|
|
X_DEMAND_ZONE_DETECTED,
|
|
provider
|
|
.consolidationPoiEvents //
|
|
);
|
|
if (hasNewDemand)
|
|
{
|
|
//
|
|
idx = GetYoungest(provider
|
|
.consolidationState
|
|
.demandZones //
|
|
);
|
|
has = IsValidIndex(idx);
|
|
if (has)
|
|
{
|
|
//
|
|
demand = provider
|
|
.consolidationState
|
|
.demandZones[idx];
|
|
has = ToBox(
|
|
demandBox,
|
|
demand //
|
|
);
|
|
if (has)
|
|
{
|
|
//
|
|
demand.To(cTime);
|
|
demandBox.to = cTime;
|
|
hasNewDemand = demandBox.IsValid();
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Check New Fair Value Gap Detection ...
|
|
bool hasNewFairValueGap =
|
|
Contains(
|
|
X_BULLISH_FVG_DETECTED,
|
|
provider
|
|
.analysePoiEvents //
|
|
) ||
|
|
Contains(
|
|
X_BEARISH_FVG_DETECTED,
|
|
provider
|
|
.analysePoiEvents //
|
|
);
|
|
if (hasNewFairValueGap)
|
|
{
|
|
//
|
|
idx = GetYoungest(provider
|
|
.analyseState
|
|
.fairValueGaps //
|
|
);
|
|
has = IsValidIndex(idx);
|
|
if (has)
|
|
{
|
|
//
|
|
fvg = provider
|
|
.analyseState
|
|
.fairValueGaps[idx];
|
|
has = ToBox(
|
|
fvgBox,
|
|
fvg //
|
|
);
|
|
if (has)
|
|
{
|
|
//
|
|
fvg.To(cTime);
|
|
fvgBox.to = cTime;
|
|
hasNewFairValueGap = fvgBox.IsValid();
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Check New Order Block Detection ...
|
|
bool hasNewOrderBlock =
|
|
Contains(
|
|
X_BULLISH_ORDERBLOCK_DETECTED,
|
|
provider
|
|
.consolidationPoiEvents //
|
|
) ||
|
|
Contains(
|
|
X_BEARISH_ORDERBLOCK_DETECTED,
|
|
provider
|
|
.consolidationPoiEvents //
|
|
);
|
|
if (hasNewOrderBlock)
|
|
{
|
|
//
|
|
idx = GetYoungest(provider
|
|
.consolidationState
|
|
.orderBlocks //
|
|
);
|
|
has = IsValidIndex(idx);
|
|
if (has)
|
|
{
|
|
//
|
|
ob = provider
|
|
.consolidationState
|
|
.orderBlocks[idx];
|
|
has = ToBox(
|
|
obBox,
|
|
ob //
|
|
);
|
|
if (has)
|
|
{
|
|
//
|
|
ob.To(cTime);
|
|
obBox.to = cTime;
|
|
hasNewOrderBlock = obBox.IsValid();
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Detect OB FVG ...
|
|
if (hasNewOrderBlock)
|
|
{
|
|
//
|
|
XOHCL obStartedBar;
|
|
bool isOBStartedBodyOut = false;
|
|
bool isOBStarted = ob.IsStarted(
|
|
ob.GetDirection(),
|
|
obStartedBar,
|
|
isOBStartedBodyOut //
|
|
);
|
|
|
|
//
|
|
has = isOBStarted;
|
|
if (has)
|
|
{
|
|
//
|
|
obFVG.ob = ob;
|
|
|
|
//
|
|
// Select FVGs ...
|
|
count = provider
|
|
.analyseState
|
|
.CountFairValueGaps();
|
|
has = IsValidSize(count);
|
|
if (!has)
|
|
{
|
|
obFVG.Clean();
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Select FVG ...
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
//
|
|
XCFVG *iFVG = provider
|
|
.analyseState
|
|
.fairValueGaps[i];
|
|
bool isBullish = iFVG.IsBullish();
|
|
|
|
//
|
|
XOHCL iStartedBar;
|
|
bool isBodyOut = false;
|
|
bool isStarted = iFVG.IsStarted(
|
|
iFVG.GetDirection(),
|
|
iStartedBar,
|
|
isBodyOut //
|
|
);
|
|
iStartedBar.Clean();
|
|
|
|
//
|
|
bool isKindPassed = isStarted &&
|
|
isBodyOut;
|
|
bool isSameDir = iFVG.GetDirection() == ob.GetDirection();
|
|
bool isFromPassed = iFVG.From() >= obStartedBar.time;
|
|
bool isPlacePassed =
|
|
//
|
|
IsInsideOrDiff(
|
|
iFVG,
|
|
ob //
|
|
)
|
|
//
|
|
// ||
|
|
// //
|
|
// (isBullish
|
|
// ? IsAboveDiff(
|
|
// iFVG,
|
|
// ob,
|
|
// true // Ignore Inside ...
|
|
// )
|
|
// : IsBelowDiff(
|
|
// iFVG,
|
|
// ob,
|
|
// true // Ignore Inside ...
|
|
// )
|
|
// //
|
|
// )
|
|
//
|
|
;
|
|
|
|
//
|
|
has = isSameDir &&
|
|
isKindPassed &&
|
|
isFromPassed &&
|
|
isPlacePassed;
|
|
if (has)
|
|
{
|
|
obFVG.AddFVG(iFVG);
|
|
}
|
|
|
|
//
|
|
ZeroMemory(iFVG);
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
has = obFVG.IsValid();
|
|
if (has)
|
|
{
|
|
//
|
|
has = IsExists(obFVG);
|
|
if (!has)
|
|
{
|
|
//
|
|
// New Waiting Zone ...
|
|
AddRef(
|
|
obFVG,
|
|
waitingZones //
|
|
);
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Check Item Is not Exists ...
|
|
idx = FindIndex(
|
|
obFVG,
|
|
waitingZones //
|
|
);
|
|
has = !IsValidIndex(idx);
|
|
if (!has)
|
|
{
|
|
//
|
|
// Update Exists Waiting Zone ...
|
|
waitingZones[idx].AddFVG(fvg);
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
obFVG.Clean();
|
|
obStartedBar.Clean();
|
|
}
|
|
|
|
//
|
|
//
|
|
//
|
|
|
|
//
|
|
bool lookingOthers = false;
|
|
if (lookingOthers)
|
|
{
|
|
//
|
|
// Check New Order Block Detection Analyse ...
|
|
XBoxZone analyseOBBox;
|
|
XCOrderBlock *analyseOB = NULL;
|
|
bool hasNewAnalyseOrderBlock =
|
|
Contains(
|
|
X_BULLISH_ORDERBLOCK_DETECTED,
|
|
provider
|
|
.analysePoiEvents //
|
|
) ||
|
|
Contains(
|
|
X_BEARISH_ORDERBLOCK_DETECTED,
|
|
provider
|
|
.analysePoiEvents //
|
|
);
|
|
if (hasNewAnalyseOrderBlock)
|
|
{
|
|
//
|
|
idx = GetYoungest(provider
|
|
.analyseState
|
|
.orderBlocks //
|
|
);
|
|
has = IsValidIndex(idx);
|
|
if (has)
|
|
{
|
|
//
|
|
analyseOB = provider
|
|
.analyseState
|
|
.orderBlocks[idx];
|
|
has = ToBox(
|
|
analyseOBBox,
|
|
analyseOB //
|
|
);
|
|
if (has)
|
|
{
|
|
//
|
|
analyseOB.To(cTime);
|
|
analyseOBBox.to = cTime;
|
|
hasNewAnalyseOrderBlock = analyseOBBox.IsValid();
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Checking Analyse Order Block ...
|
|
if (hasNewAnalyseOrderBlock)
|
|
{
|
|
//
|
|
XOHCL obStartedBar;
|
|
bool isOBStartedBodyOut = false;
|
|
bool isOBStarted = analyseOB.IsStarted(
|
|
analyseOB.GetDirection(),
|
|
obStartedBar,
|
|
isOBStartedBodyOut //
|
|
);
|
|
|
|
//
|
|
has = isOBStarted &&
|
|
isOBStartedBodyOut;
|
|
if (has)
|
|
{
|
|
//
|
|
analyseOBBox.from =
|
|
obStartedBar.NextAt();
|
|
|
|
//
|
|
has = IsExists(analyseOBBox);
|
|
if (!has)
|
|
{
|
|
//
|
|
AddRef(
|
|
analyseOBBox,
|
|
waitingBoxes //
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
analyseOBBox.Clean();
|
|
ZeroMemory(analyseOB);
|
|
}
|
|
|
|
//
|
|
//
|
|
//
|
|
|
|
//
|
|
result = HasWaitingZones();
|
|
|
|
//
|
|
// Cleanup Resources ...
|
|
|
|
//
|
|
obFVG.Clean();
|
|
obBox.Clean();
|
|
fvgBox.Clean();
|
|
supplyBox.Clean();
|
|
demandBox.Clean();
|
|
|
|
//
|
|
ZeroMemory(ob);
|
|
ZeroMemory(fvg);
|
|
ZeroMemory(supply);
|
|
ZeroMemory(demand);
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
int ValidateWaitingZones(
|
|
int barIndex = 0 //
|
|
)
|
|
{
|
|
//
|
|
int result = 0;
|
|
|
|
//
|
|
bool has = false;
|
|
|
|
//
|
|
if (barIndex < 0)
|
|
{
|
|
barIndex = 0;
|
|
}
|
|
|
|
//
|
|
if (barIndex == 0)
|
|
{
|
|
barIndex = 1;
|
|
}
|
|
|
|
//
|
|
has = IsValid() &&
|
|
HasWaitingZones();
|
|
if (!has)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
int removeIDX[];
|
|
result = CountWaitingZones();
|
|
for (int i = 0; i < result; i++)
|
|
{
|
|
//
|
|
has = waitingZones[i].IsValidZone(
|
|
barIndex //
|
|
);
|
|
if (!has)
|
|
{
|
|
//
|
|
Add(
|
|
i,
|
|
removeIDX //
|
|
);
|
|
|
|
//
|
|
AddRef(
|
|
waitingZones[i],
|
|
unavailableZones //
|
|
);
|
|
}
|
|
}
|
|
|
|
//
|
|
has = HasChild(removeIDX);
|
|
if (has)
|
|
{
|
|
//
|
|
CleanupArray(
|
|
removeIDX,
|
|
waitingZones //
|
|
);
|
|
}
|
|
Clean(removeIDX);
|
|
|
|
//
|
|
result = CountWaitingZones();
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
bool IsExists(XOBFVG & zone)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
// Check Validation ...
|
|
result = zone.IsValid() &&
|
|
(HasWaitingZones() ||
|
|
HasUnavailableZones());
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
int idx = -1;
|
|
|
|
//
|
|
// Check Index in Waiting Zones ...
|
|
idx = FindIndex(
|
|
zone,
|
|
waitingZones //
|
|
);
|
|
result = IsValidIndex(idx);
|
|
if (result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Check Index in Unavailable Zones ...
|
|
idx = FindIndex(
|
|
zone,
|
|
unavailableZones //
|
|
);
|
|
result = IsValidIndex(idx);
|
|
if (result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
Clean(waitingZones);
|
|
Clean(unavailableZones);
|
|
|
|
//
|
|
bool HasWaitingZones()
|
|
{
|
|
return HasChild(waitingZones);
|
|
}
|
|
|
|
//
|
|
int CountWaitingZones()
|
|
{
|
|
return ArraySize(waitingZones);
|
|
}
|
|
|
|
//
|
|
bool HasUnavailableZones()
|
|
{
|
|
return HasChild(unavailableZones);
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
has = HasWaitingZones();
|
|
if (has)
|
|
{
|
|
//
|
|
count = CountWaitingZones();
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
waitingZones[i].UpdateTo(value);
|
|
}
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
has = HasWaitingZones();
|
|
if (has)
|
|
{
|
|
//
|
|
count = CountWaitingZones();
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
//
|
|
XCBaseObject *iObjects[];
|
|
int iObjectsCount = drawer.DrawOBFVG(
|
|
waitingZones[i],
|
|
iObjects,
|
|
true, // Draw Order Block ...
|
|
true, // Draw Fair Value Gaps ...
|
|
true, // Draw All Fair Value Gaps ...
|
|
//
|
|
true, // Draw OB StartedBar ...
|
|
true, // Draw OB ActivatedBar ...
|
|
true, // Draw OB BreakedBar ...
|
|
true, // Draw OB WorkedBar ...
|
|
//
|
|
true, // Draw FVG StartedBar ...
|
|
true, // Draw FVG ActivatedBar ...
|
|
true, // Draw FVG BreakedBar ...
|
|
true // Draw FVG WorkedBar ...
|
|
//
|
|
);
|
|
has = IsValidSize(iObjectsCount);
|
|
if (has)
|
|
{
|
|
//
|
|
for (int j = 0; j < iObjectsCount; j++)
|
|
{
|
|
mDrawnObjects.Add(iObjects[j]);
|
|
}
|
|
}
|
|
|
|
//
|
|
// if (drawWaitingZonesBoxArea)
|
|
// {
|
|
// //
|
|
// XBoxZone iBox;
|
|
// has = waitingZones[i].ToZone(
|
|
// iBox //
|
|
// );
|
|
// if (has)
|
|
// {
|
|
// //
|
|
// XCBoxObject *iBoxObj;
|
|
// has = drawer.DrawBox(
|
|
// iBox,
|
|
// iBoxObj //
|
|
// );
|
|
// if (has)
|
|
// {
|
|
// mDrawnObjects.Add(iBoxObj);
|
|
// }
|
|
// }
|
|
|
|
// //
|
|
// iBox.Clean();
|
|
// }
|
|
}
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
//
|
|
bool HasSenario1Conditions(
|
|
ENUM_X_CYCLES cycle,
|
|
XBoxZone &box,
|
|
XBoxZone &holderBox,
|
|
ENUM_X_DIRECTION &dir,
|
|
X121SMCStrategySignalProviderData &provider,
|
|
ENUM_X_CYCLES holderCycle = X_CYCLE_NONE,
|
|
int barIndex = 0 //
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
// Fil Selected Data ...
|
|
XPOIState cState;
|
|
X121Conditions cXConditions;
|
|
XC121SMCCycleHelper *cHelper;
|
|
X121SMCCycleConditions cConditions;
|
|
result = provider.SelectCycle(
|
|
cycle,
|
|
cState,
|
|
cXConditions,
|
|
cHelper,
|
|
cConditions //
|
|
);
|
|
if (!result)
|
|
{
|
|
//
|
|
cState.Clean();
|
|
ZeroMemory(cHelper);
|
|
cConditions.Clean();
|
|
cXConditions.Clean();
|
|
|
|
//
|
|
return result;
|
|
}
|
|
Parse(cXConditions);
|
|
|
|
//
|
|
// Fil Selected Data ...
|
|
XPOIState chState;
|
|
X121Conditions chXConditions;
|
|
XC121SMCCycleHelper *chHelper;
|
|
X121SMCCycleConditions chConditions;
|
|
if (holderCycle != X_CYCLE_NONE)
|
|
{
|
|
//
|
|
result = provider.SelectCycle(
|
|
holderCycle,
|
|
chState,
|
|
chXConditions,
|
|
chHelper,
|
|
chConditions //
|
|
);
|
|
if (!result)
|
|
{
|
|
//
|
|
chState.Clean();
|
|
ZeroMemory(chHelper);
|
|
chConditions.Clean();
|
|
chXConditions.Clean();
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
Parse(chXConditions);
|
|
}
|
|
|
|
//
|
|
// Normalize Args ...
|
|
|
|
//
|
|
box.Clean();
|
|
holderBox.Clean();
|
|
dir = X_DIRECTION_NONE;
|
|
|
|
//
|
|
if (barIndex < 0)
|
|
{
|
|
barIndex = 0;
|
|
}
|
|
|
|
//
|
|
int idx = -1;
|
|
int count = 0;
|
|
bool has = false;
|
|
|
|
//
|
|
int zIDX = barIndex;
|
|
int cIDX = zIDX + 1;
|
|
int pIDX = cIDX + 1;
|
|
|
|
//
|
|
bool isBullish = false;
|
|
bool isBearish = false;
|
|
|
|
//
|
|
XOHCL zBar;
|
|
XOHCL cBar;
|
|
XOHCL pBar;
|
|
XOHCL cSMHKBar;
|
|
|
|
//
|
|
// Initial Bars ...
|
|
result = zBar.Init(
|
|
cState.symbol,
|
|
cState.period,
|
|
barIndex //
|
|
);
|
|
result =
|
|
result &&
|
|
zBar.GetPreviousBar(cBar);
|
|
result =
|
|
result &&
|
|
cBar.GetPreviousBar(pBar);
|
|
result =
|
|
result &&
|
|
cHelper
|
|
.mX121Helper
|
|
.xhkHelper
|
|
.GetSMHKAsXOHCL(
|
|
cIDX,
|
|
cSMHKBar //
|
|
);
|
|
if (!result)
|
|
{
|
|
//
|
|
zBar.Clean();
|
|
cBar.Clean();
|
|
pBar.Clean();
|
|
cState.Clean();
|
|
chState.Clean();
|
|
cSMHKBar.Clean();
|
|
ZeroMemory(cHelper);
|
|
cConditions.Clean();
|
|
cXConditions.Clean();
|
|
ZeroMemory(chHelper);
|
|
chConditions.Clean();
|
|
chXConditions.Clean();
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
//
|
|
// Detecting Signal Conditions ...
|
|
|
|
//
|
|
// Bullish Conditions ...
|
|
isBullish =
|
|
//
|
|
// Base Condition ...
|
|
cXConditions.isSMHKSwitchedToBullish &&
|
|
(
|
|
//
|
|
// Validate CBar ...
|
|
cBar.IsBullish() &&
|
|
(cBar.open == cSMHKBar.open ||
|
|
(cBar.low < cSMHKBar.open &&
|
|
cBar.GetDown() > cSMHKBar.close)) &&
|
|
//
|
|
cXConditions.isSarBullish
|
|
//
|
|
)
|
|
//
|
|
;
|
|
|
|
//
|
|
// Bearish Conditions ...
|
|
isBearish =
|
|
//
|
|
// Base Condition ...
|
|
cXConditions.isSMHKSwitchedToBearish &&
|
|
(
|
|
//
|
|
// Validate CBar ...
|
|
cBar.IsBearish() &&
|
|
(cBar.open == cSMHKBar.open ||
|
|
(cBar.high > cSMHKBar.open &&
|
|
cBar.GetUp() < cSMHKBar.close)) &&
|
|
//
|
|
cXConditions.isSarBearish
|
|
//
|
|
)
|
|
//
|
|
;
|
|
|
|
//
|
|
// Filling Requirements ...
|
|
result =
|
|
isBullish ||
|
|
isBearish;
|
|
if (result)
|
|
{
|
|
//
|
|
dir =
|
|
isBullish
|
|
? X_DIRECTION_BULLISH
|
|
: X_DIRECTION_BEARISH;
|
|
|
|
//
|
|
box.dir = dir;
|
|
box.to = TimeCurrent();
|
|
box.symbol = cXConditions.symbol;
|
|
box.period = cXConditions.period;
|
|
|
|
//
|
|
int fromIDX = -1;
|
|
if (isBullish)
|
|
{
|
|
//
|
|
double vale = cXConditions.valesBuffer[cIDX];
|
|
box.lower = vale;
|
|
box.upper = cXConditions.valesGoldenBuffer[cIDX];
|
|
|
|
//
|
|
int lowerValeIDX = -1;
|
|
double lowerVale = cHelper
|
|
.mX121Helper
|
|
.xpvHelper
|
|
.GetLowerVale(
|
|
lowerValeIDX,
|
|
vale,
|
|
cBar.Index() //
|
|
);
|
|
|
|
//
|
|
int higherValeIDX = -1;
|
|
double higherVale = cHelper
|
|
.mX121Helper
|
|
.xpvHelper
|
|
.GetHigherVale(
|
|
higherValeIDX,
|
|
vale,
|
|
cBar.Index() //
|
|
);
|
|
|
|
//
|
|
if (IsValidIndex(lowerValeIDX) &&
|
|
IsValidIndex(higherValeIDX))
|
|
{
|
|
//
|
|
fromIDX =
|
|
lowerValeIDX < higherValeIDX
|
|
? lowerValeIDX
|
|
: higherValeIDX;
|
|
}
|
|
else if (IsValidIndex(lowerValeIDX) &&
|
|
!IsValidIndex(higherValeIDX))
|
|
{
|
|
//
|
|
fromIDX = lowerValeIDX;
|
|
}
|
|
else if (!IsValidIndex(lowerValeIDX) &&
|
|
IsValidIndex(higherValeIDX))
|
|
{
|
|
//
|
|
fromIDX = higherValeIDX;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//
|
|
double peak = cXConditions.peaksBuffer[cIDX];
|
|
box.upper = peak;
|
|
|
|
//
|
|
box.lower = cXConditions.peaksGoldenBuffer[cIDX];
|
|
|
|
//
|
|
int lowerPeakIDX = -1;
|
|
double lowerPeak = cHelper
|
|
.mX121Helper
|
|
.xpvHelper
|
|
.GetLowerPeak(
|
|
lowerPeakIDX,
|
|
peak,
|
|
cBar.Index() //
|
|
);
|
|
|
|
//
|
|
int higherPeakIDX = -1;
|
|
double higherPeak = cHelper
|
|
.mX121Helper
|
|
.xpvHelper
|
|
.GetHigherPeak(
|
|
higherPeakIDX,
|
|
peak,
|
|
cBar.Index() //
|
|
);
|
|
|
|
//
|
|
if (IsValidIndex(lowerPeakIDX) &&
|
|
IsValidIndex(higherPeakIDX))
|
|
{
|
|
//
|
|
fromIDX =
|
|
lowerPeakIDX < higherPeakIDX
|
|
? lowerPeakIDX
|
|
: higherPeakIDX;
|
|
}
|
|
else if (IsValidIndex(lowerPeakIDX) &&
|
|
!IsValidIndex(higherPeakIDX))
|
|
{
|
|
//
|
|
fromIDX = lowerPeakIDX;
|
|
}
|
|
else if (!IsValidIndex(lowerPeakIDX) &&
|
|
IsValidIndex(higherPeakIDX))
|
|
{
|
|
//
|
|
fromIDX = higherPeakIDX;
|
|
}
|
|
}
|
|
|
|
//
|
|
if (IsValidIndex(fromIDX))
|
|
{
|
|
//
|
|
box.from = iTime(
|
|
zBar.symbol,
|
|
zBar.period,
|
|
fromIDX //
|
|
);
|
|
}
|
|
else
|
|
{
|
|
box.from = pBar.time;
|
|
}
|
|
|
|
//
|
|
// Detect Holder Box ...
|
|
XBoxZone tmpBoxes[];
|
|
if (chState.IsValid())
|
|
{
|
|
//
|
|
if (isBullish)
|
|
{
|
|
//
|
|
// Demand Zones ...
|
|
XBoxZone tmp[];
|
|
ToBox(
|
|
chState.demandZones,
|
|
tmp //
|
|
);
|
|
Copy(
|
|
tmp,
|
|
tmpBoxes,
|
|
false //
|
|
);
|
|
Clean(tmp);
|
|
|
|
//
|
|
// Bullish Order Blocks ...
|
|
ToBox(
|
|
chState.bullishOrderBlocks,
|
|
tmp //
|
|
);
|
|
Copy(
|
|
tmp,
|
|
tmpBoxes,
|
|
false //
|
|
);
|
|
Clean(tmp);
|
|
|
|
//
|
|
// Bullish Fair Value Gaps ...
|
|
ToBox(
|
|
chState.bullishFairValueGaps,
|
|
tmp //
|
|
);
|
|
Copy(
|
|
tmp,
|
|
tmpBoxes,
|
|
false //
|
|
);
|
|
Clean(tmp);
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Supply Zones ...
|
|
XBoxZone tmp[];
|
|
ToBox(
|
|
chState.supplyZones,
|
|
tmp //
|
|
);
|
|
Copy(
|
|
tmp,
|
|
tmpBoxes,
|
|
false //
|
|
);
|
|
Clean(tmp);
|
|
|
|
//
|
|
// Bearish Order Blocks ...
|
|
ToBox(
|
|
chState.bearishOrderBlocks,
|
|
tmp //
|
|
);
|
|
Copy(
|
|
tmp,
|
|
tmpBoxes,
|
|
false //
|
|
);
|
|
Clean(tmp);
|
|
|
|
//
|
|
// Bearish Fair Value Gaps ...
|
|
ToBox(
|
|
chState.bearishFairValueGaps,
|
|
tmp //
|
|
);
|
|
Copy(
|
|
tmp,
|
|
tmpBoxes,
|
|
false //
|
|
);
|
|
Clean(tmp);
|
|
}
|
|
}
|
|
|
|
//
|
|
has = HasChild(tmpBoxes);
|
|
if (has)
|
|
{
|
|
//
|
|
while (HasChild(tmpBoxes))
|
|
{
|
|
//
|
|
idx = GetOldest(tmpBoxes);
|
|
has = IsValidIndex(idx);
|
|
if (!has)
|
|
{
|
|
break;
|
|
}
|
|
|
|
//
|
|
XBoxZone iBox = tmpBoxes[idx];
|
|
ArrayRemove(
|
|
tmpBoxes,
|
|
idx,
|
|
1 //
|
|
);
|
|
|
|
//
|
|
has = IsBoxInside(
|
|
box,
|
|
iBox //
|
|
);
|
|
if (has)
|
|
{
|
|
//
|
|
holderBox = iBox;
|
|
holderBox.to = TimeCurrent();
|
|
iBox.Clean();
|
|
break;
|
|
}
|
|
|
|
//
|
|
iBox.Clean();
|
|
}
|
|
}
|
|
|
|
//
|
|
Clean(tmpBoxes);
|
|
|
|
//
|
|
// Fix Box Upper and Lower based on Strategy ...
|
|
|
|
//
|
|
double points = GetPoints(box.symbol);
|
|
double minPointsDiff = points * 20;
|
|
|
|
//
|
|
double prefferSL = 0;
|
|
|
|
//
|
|
// First Check Based on Prev Bar ...
|
|
// double prevDiff =
|
|
// isBullish
|
|
// ? cBar.low < zBar.open
|
|
// ? zBar.open - cBar.low
|
|
// : 0
|
|
// : isBearish
|
|
// ? cBar.high > zBar.open
|
|
// ? cBar.high - zBar.open
|
|
// : 0
|
|
// : 0;
|
|
// if (prevDiff >= minPointsDiff)
|
|
// {
|
|
// //
|
|
// prefferSL =
|
|
// isBullish
|
|
// ? cBar.low
|
|
// : cBar.high;
|
|
// }
|
|
|
|
//
|
|
// Other SL Conditions ...
|
|
if (prefferSL <= 0)
|
|
{
|
|
//
|
|
if (isBullish)
|
|
{
|
|
//
|
|
if (zBar.open < cXConditions.valesGoldenBuffer[cIDX])
|
|
{
|
|
prefferSL = cXConditions.valesBuffer[cIDX];
|
|
}
|
|
else if (zBar.open > cXConditions.valesGoldenBuffer[cIDX])
|
|
{
|
|
prefferSL = cXConditions.valesGoldenBuffer[cIDX];
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//
|
|
if (zBar.open > cXConditions.peaksGoldenBuffer[cIDX])
|
|
{
|
|
prefferSL = cXConditions.peaksBuffer[cIDX];
|
|
}
|
|
else if (zBar.open < cXConditions.peaksGoldenBuffer[cIDX])
|
|
{
|
|
prefferSL = cXConditions.peaksGoldenBuffer[cIDX];
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
if (prefferSL > 0)
|
|
{
|
|
//
|
|
prefferSL =
|
|
prefferSL <= minPointsDiff
|
|
? minPointsDiff
|
|
: prefferSL;
|
|
|
|
//
|
|
box.upper =
|
|
isBullish
|
|
? zBar.open
|
|
: prefferSL;
|
|
|
|
//
|
|
box.lower =
|
|
isBullish
|
|
? prefferSL
|
|
: zBar.open;
|
|
}
|
|
|
|
//
|
|
// Validate Conditions to Force Has Holder Box ...
|
|
// result =
|
|
// result &&
|
|
// holderBox.IsValid();
|
|
result = box.IsValid();
|
|
if (!result)
|
|
{
|
|
//
|
|
isBullish = false;
|
|
isBearish = false;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Check All Conditions ...
|
|
result =
|
|
box.IsValid() &&
|
|
HasDirection(dir) &&
|
|
(isBullish ||
|
|
isBearish);
|
|
|
|
//
|
|
// Cleanup Resources ...
|
|
zBar.Clean();
|
|
cBar.Clean();
|
|
pBar.Clean();
|
|
cState.Clean();
|
|
chState.Clean();
|
|
cSMHKBar.Clean();
|
|
ZeroMemory(cHelper);
|
|
cConditions.Clean();
|
|
cXConditions.Clean();
|
|
ZeroMemory(chHelper);
|
|
chConditions.Clean();
|
|
chXConditions.Clean();
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
// FRACTALS ...
|
|
int copiedFractalsUppers = CopyBuffer(fractalHandler, 0, UPPER_LINE, limit, fractalsUpperBuffer);
|
|
int copiedFractalsLowers = CopyBuffer(fractalHandler, 1, LOWER_LINE, limit, fractalsLowerBuffer);
|
|
|
|
//
|
|
// FRACTALS ...
|
|
copiedFractalsUppers > 0 &&
|
|
copiedFractalsLowers > 0
|
|
|
|
//
|
|
// FRACTALS ...
|
|
int fractalsCalculatedBars = BarsCalculated(fractalHandler);
|
|
|
|
//
|
|
// FRACTALS ...
|
|
fractalsCalculatedBars >= maxLength
|
|
|
|
|
|
//
|
|
// SUPPORT and RESISTANCE ...
|
|
|
|
//
|
|
double iHighValue = iHigh(
|
|
_Symbol,
|
|
_Period,
|
|
barIndex //
|
|
);
|
|
double iLastHighValue = iHigh(
|
|
_Symbol,
|
|
_Period,
|
|
lastIndex //
|
|
);
|
|
|
|
//
|
|
double iLowValue = iLow(
|
|
_Symbol,
|
|
_Period,
|
|
barIndex //
|
|
);
|
|
double iLastLowValue = iLow(
|
|
_Symbol,
|
|
_Period,
|
|
lastIndex //
|
|
);
|
|
|
|
//
|
|
// Resistance ...
|
|
// double lastResistance =
|
|
// lastIndex < barsCount
|
|
// ? resistancesBuffer[lastIndex]
|
|
// : iLastHighValue;
|
|
// double iFractalsUpper = fractalsUpperBuffer[barIndex];
|
|
// double iResistance =
|
|
// NotEmptyZero(iFractalsUpper)
|
|
// ? iHighValue
|
|
// : lastResistance;
|
|
// resistancesBuffer[barIndex] = iResistance;
|
|
|
|
//
|
|
// Support ...
|
|
// double lastSupport =
|
|
// lastIndex < barsCount
|
|
// ? supportsBuffer[lastIndex]
|
|
// : iLastLowValue;
|
|
// double iFractalsLower = fractalsLowerBuffer[barIndex];
|
|
// double iSupport =
|
|
// NotEmptyZero(iFractalsLower)
|
|
// ? iLowValue
|
|
// : lastSupport;
|
|
// supportsBuffer[barIndex] = iSupport;
|
|
|
|
//
|
|
double iFractalsUpper = fractalsUpperBuffer[barIndex];
|
|
double iResistance = iFractalsUpper;
|
|
resistancesBuffer[barIndex] = iResistance;
|
|
|
|
|
|
//
|
|
double iFractalsLower = fractalsLowerBuffer[barIndex];
|
|
double iSupport = iFractalsLower;
|
|
supportsBuffer[barIndex] = iSupport;
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
|
|
////////////////////////////////////////////////////////////////////////
|