3361 lines
74 KiB
Plaintext
3361 lines
74 KiB
Plaintext
|
|
//
|
|
// Peaks ...
|
|
int peaksCount = ArraySize(conditions.peaks);
|
|
if (IsValidSize(peaksCount))
|
|
{
|
|
//
|
|
for (int i = 0; i < peaksCount; i++)
|
|
{
|
|
//
|
|
XPVPivot iPivot = conditions.peaks[i];
|
|
|
|
//
|
|
XCXPVPivotObject *iObj;
|
|
iObj = new XCXPVPivotObject();
|
|
|
|
//
|
|
bool isCreated = iObj.Create(
|
|
mPOIDrawer.ChartIdentification(),
|
|
mPOIDrawer.SubWindowIdentification(),
|
|
iPivot //
|
|
);
|
|
if (isCreated)
|
|
{
|
|
//
|
|
iObj.PivotWidth(1);
|
|
iObj.PivotFill(false);
|
|
iObj.PivotColor(clrAqua);
|
|
iObj.PivotStyle(STYLE_SOLID);
|
|
|
|
//
|
|
AddObjectIfNotExists(iObj);
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Vales ...
|
|
int valesCount = ArraySize(conditions.vales);
|
|
if (IsValidSize(valesCount))
|
|
{
|
|
//
|
|
for (int i = 0; i < valesCount; i++)
|
|
{
|
|
//
|
|
XPVPivot iPivot = conditions.vales[i];
|
|
|
|
//
|
|
XCXPVPivotObject *iObj;
|
|
iObj = new XCXPVPivotObject();
|
|
|
|
//
|
|
bool isCreated = iObj.Create(
|
|
mPOIDrawer.ChartIdentification(),
|
|
mPOIDrawer.SubWindowIdentification(),
|
|
iPivot //
|
|
);
|
|
if (isCreated)
|
|
{
|
|
//
|
|
iObj.PivotWidth(1);
|
|
iObj.PivotFill(false);
|
|
iObj.PivotStyle(STYLE_SOLID);
|
|
iObj.PivotColor(clrMagenta);
|
|
|
|
//
|
|
AddObjectIfNotExists(iObj);
|
|
}
|
|
}
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////
|
|
// Conditions Parsing ...
|
|
///////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
// Conditions Props ...
|
|
|
|
//
|
|
// D1 ...
|
|
|
|
//
|
|
XPOIState d1State;
|
|
ENUM_X_DIRECTION d1MarketDirection;
|
|
XCSupportZone *d1SupportZones[];
|
|
XCResistanceZone *d1ResistanceZones[];
|
|
|
|
//
|
|
XCSwing *d1SwingHigh;
|
|
XCSwing *d1SwingLow;
|
|
|
|
//
|
|
// H4 ...
|
|
|
|
//
|
|
XPOIState h4State;
|
|
ENUM_X_DIRECTION h4MarketDirection;
|
|
XCSupportZone *h4SupportZones[];
|
|
XCResistanceZone *h4ResistanceZones[];
|
|
|
|
//
|
|
XCSwing *h4SwingHigh;
|
|
XCSwing *h4SwingLow;
|
|
|
|
//
|
|
// H2 ...
|
|
|
|
//
|
|
XPOIState h2State;
|
|
ENUM_X_DIRECTION h2MarketDirection;
|
|
XCSupportZone *h2SupportZones[];
|
|
XCResistanceZone *h2ResistanceZones[];
|
|
|
|
//
|
|
XCSwing *h2SwingHigh;
|
|
XCSwing *h2SwingLow;
|
|
|
|
//
|
|
// H1 ...
|
|
|
|
//
|
|
XPOIState h1State;
|
|
ENUM_X_DIRECTION h1MarketDirection;
|
|
XCSupportZone *h1SupportZones[];
|
|
XCResistanceZone *h1ResistanceZones[];
|
|
|
|
//
|
|
XCSwing *h1SwingHigh;
|
|
XCSwing *h1SwingLow;
|
|
|
|
//
|
|
// M15 ...
|
|
|
|
//
|
|
XPOIState m15State;
|
|
ENUM_X_DIRECTION m15MarketDirection;
|
|
XCSupportZone *m15SupportZones[];
|
|
XCResistanceZone *m15ResistanceZones[];
|
|
|
|
//
|
|
XCSwing *m15SwingHigh;
|
|
XCSwing *m15SwingLow;
|
|
|
|
//
|
|
// M5 ...
|
|
|
|
//
|
|
XPOIState m5State;
|
|
ENUM_X_DIRECTION m5MarketDirection;
|
|
XCSupportZone *m5SupportZones[];
|
|
XCResistanceZone *m5ResistanceZones[];
|
|
|
|
//
|
|
XCSwing *m5SwingHigh;
|
|
XCSwing *m5SwingLow;
|
|
|
|
//
|
|
// M1 ...
|
|
|
|
//
|
|
XPOIState m1State;
|
|
ENUM_X_DIRECTION m1MarketDirection;
|
|
XCSupportZone *m1SupportZones[];
|
|
XCResistanceZone *m1ResistanceZones[];
|
|
|
|
//
|
|
XCSwing *m1SwingHigh;
|
|
XCSwing *m1SwingLow;
|
|
|
|
//
|
|
// Clean Method ...
|
|
|
|
//
|
|
// D1 ...
|
|
|
|
//
|
|
d1State.Clean();
|
|
d1MarketDirection = X_DIRECTION_NONE;
|
|
Clean(d1SupportZones);
|
|
Clean(d1ResistanceZones);
|
|
|
|
//
|
|
d1SwingHigh = NULL;
|
|
d1SwingLow = NULL;
|
|
|
|
//
|
|
// H4 ...
|
|
|
|
//
|
|
h4State.Clean();
|
|
h4MarketDirection = X_DIRECTION_NONE;
|
|
Clean(h4SupportZones);
|
|
Clean(h4ResistanceZones);
|
|
|
|
//
|
|
h4SwingHigh = NULL;
|
|
h4SwingLow = NULL;
|
|
|
|
//
|
|
// H2 ...
|
|
|
|
//
|
|
h2State.Clean();
|
|
h2MarketDirection = X_DIRECTION_NONE;
|
|
Clean(h2SupportZones);
|
|
Clean(h2ResistanceZones);
|
|
|
|
//
|
|
h2SwingHigh = NULL;
|
|
h2SwingLow = NULL;
|
|
|
|
//
|
|
// H1 ...
|
|
|
|
//
|
|
h1State.Clean();
|
|
h1MarketDirection = X_DIRECTION_NONE;
|
|
Clean(h1SupportZones);
|
|
Clean(h1ResistanceZones);
|
|
|
|
//
|
|
h1SwingHigh = NULL;
|
|
h1SwingLow = NULL;
|
|
|
|
//
|
|
// M15 ...
|
|
|
|
//
|
|
m15State.Clean();
|
|
m15MarketDirection = X_DIRECTION_NONE;
|
|
Clean(m15SupportZones);
|
|
Clean(m15ResistanceZones);
|
|
|
|
//
|
|
m15SwingHigh = NULL;
|
|
m15SwingLow = NULL;
|
|
|
|
//
|
|
// M5 ...
|
|
|
|
//
|
|
m5State.Clean();
|
|
m5MarketDirection = X_DIRECTION_NONE;
|
|
Clean(m5SupportZones);
|
|
Clean(m5ResistanceZones);
|
|
|
|
//
|
|
m5SwingHigh = NULL;
|
|
m5SwingLow = NULL;
|
|
|
|
//
|
|
// M1 ...
|
|
|
|
//
|
|
m1State.Clean();
|
|
m1MarketDirection = X_DIRECTION_NONE;
|
|
Clean(m1SupportZones);
|
|
Clean(m1ResistanceZones);
|
|
|
|
//
|
|
m1SwingHigh = NULL;
|
|
m1SwingLow = NULL;
|
|
|
|
//
|
|
// Tools Functions ...
|
|
//
|
|
|
|
//
|
|
// Custom Tools ...
|
|
|
|
/**
|
|
* Check Conditions for Detect Market Structure ...
|
|
*
|
|
* @param structure: ENUM_X_DIRECTION member, Market Structure Direction reference ...
|
|
*
|
|
* @return ( bool )
|
|
*/
|
|
bool HasMarketStructure(
|
|
ENUM_X_DIRECTION &structure //
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
structure = X_DIRECTION_NONE;
|
|
|
|
//
|
|
result = IsValid();
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
bool is1DBullish = IsBullish(d1MarketDirection);
|
|
bool is1DBearish = IsBearish(d1MarketDirection);
|
|
|
|
//
|
|
bool is4HBullish = IsBullish(h4MarketDirection);
|
|
bool is4HBearish = IsBearish(h4MarketDirection);
|
|
|
|
//
|
|
bool is2HBullish = IsBullish(h2MarketDirection);
|
|
bool is2HBearish = IsBearish(h2MarketDirection);
|
|
|
|
//
|
|
bool is1HBullish = IsBullish(h1MarketDirection);
|
|
bool is1HBearish = IsBearish(h1MarketDirection);
|
|
|
|
//
|
|
bool is15MBullish = IsBullish(m15MarketDirection);
|
|
bool is15MBearish = IsBearish(m15MarketDirection);
|
|
|
|
//
|
|
bool is5MBullish = IsBullish(m5MarketDirection);
|
|
bool is5MBearish = IsBearish(m5MarketDirection);
|
|
|
|
//
|
|
bool is1MBullish = IsBullish(m1MarketDirection);
|
|
bool is1MBearish = IsBearish(m1MarketDirection);
|
|
|
|
//
|
|
bool isStructuresBullish =
|
|
//
|
|
is1HBullish &&
|
|
is15MBullish &&
|
|
is5MBullish
|
|
//
|
|
;
|
|
|
|
//
|
|
bool isStructuresBearish =
|
|
//
|
|
is1HBearish &&
|
|
is15MBearish &&
|
|
is5MBearish
|
|
//
|
|
;
|
|
|
|
//
|
|
bool hasMarketStructure =
|
|
isStructuresBullish ||
|
|
isStructuresBearish;
|
|
result = hasMarketStructure;
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
structure =
|
|
isStructuresBullish
|
|
? X_DIRECTION_BULLISH
|
|
: X_DIRECTION_BEARISH;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Strategy Class Calling on Conditions Detections ...
|
|
|
|
//
|
|
// Detect Market Structures ...
|
|
|
|
//
|
|
// 1D ...
|
|
conditions.d1State = _1DState;
|
|
result = DetectMarketStructure(
|
|
conditions.d1MarketDirection,
|
|
conditions.d1SupportZones,
|
|
conditions.d1ResistanceZones,
|
|
_1DState //
|
|
);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// 4H ...
|
|
conditions.h4State = _4HState;
|
|
result = DetectMarketStructure(
|
|
conditions.h4MarketDirection,
|
|
conditions.h4SupportZones,
|
|
conditions.h4ResistanceZones,
|
|
_4HState //
|
|
);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// 2H ...
|
|
conditions.h2State = _2HState;
|
|
result = DetectMarketStructure(
|
|
conditions.h2MarketDirection,
|
|
conditions.h2SupportZones,
|
|
conditions.h2ResistanceZones,
|
|
_2HState //
|
|
);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// 1H ...
|
|
conditions.h1State = _1HState;
|
|
result = DetectMarketStructure(
|
|
conditions.h1MarketDirection,
|
|
conditions.h1SupportZones,
|
|
conditions.h1ResistanceZones,
|
|
_1HState //
|
|
);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// 15M ...
|
|
conditions.m15State = _15MState;
|
|
result = DetectMarketStructure(
|
|
conditions.m15MarketDirection,
|
|
conditions.m15SupportZones,
|
|
conditions.m15ResistanceZones,
|
|
_15MState //
|
|
);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// 5M ...
|
|
conditions.m5State = _5MState;
|
|
result = DetectMarketStructure(
|
|
conditions.m5MarketDirection,
|
|
conditions.m5SupportZones,
|
|
conditions.m5ResistanceZones,
|
|
_5MState //
|
|
);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// 1M ...
|
|
conditions.m1State = _1MState;
|
|
result = DetectMarketStructure(
|
|
conditions.m1MarketDirection,
|
|
conditions.m1SupportZones,
|
|
conditions.m1ResistanceZones,
|
|
_1MState //
|
|
);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// 1H-15M-5M ...
|
|
ENUM_X_DIRECTION marketStructure = X_DIRECTION_NONE;
|
|
result = conditions.HasMarketStructure(marketStructure);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Detect Swing High and Swing Low ...
|
|
// 1H-15M-5M ...
|
|
int count = 0;
|
|
|
|
//
|
|
// 1H ...
|
|
|
|
//
|
|
XCSwing *h1SwingLows[];
|
|
XCSwing *h1SwingHighs[];
|
|
XCSupportZone *h1SupportZone = NULL;
|
|
XCResistanceZone *h1ResistanceZone = NULL;
|
|
|
|
//
|
|
count = ArraySize(conditions.h1SupportZones);
|
|
if (IsValidSize(count))
|
|
{
|
|
//
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
//
|
|
XCSupportZone *item = conditions.h1SupportZones[i];
|
|
|
|
//
|
|
bool canSelect =
|
|
h1SupportZone == NULL ||
|
|
h1SupportZone.Lower() < item.Lower();
|
|
if (canSelect)
|
|
{
|
|
h1SupportZone = item;
|
|
}
|
|
}
|
|
}
|
|
if (h1SupportZone != NULL)
|
|
{
|
|
//
|
|
// Detect Swings ...
|
|
count = ArraySize(conditions.h1State.swingLows);
|
|
if (IsValidSize(count))
|
|
{
|
|
//
|
|
double upper = h1SupportZone.Upper();
|
|
double lower = h1SupportZone.Lower();
|
|
|
|
//
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
//
|
|
XCSwing *item = conditions.h1State.swingLows[i];
|
|
|
|
//
|
|
XOHCL iBar;
|
|
bool isFilled = item.FillBar(iBar);
|
|
if (!isFilled)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
//
|
|
bool canSelect = (iBar.high <= upper &&
|
|
iBar.low >= lower) ||
|
|
(iBar.high >= upper &&
|
|
iBar.low <= lower);
|
|
if (canSelect)
|
|
{
|
|
//
|
|
Add(
|
|
item,
|
|
h1SwingLows //
|
|
);
|
|
|
|
//
|
|
// Draw ...
|
|
XCSwingLowObject *iObj;
|
|
bool isCreated = mPOIDrawer.CreateSwingLow(
|
|
item,
|
|
iObj //
|
|
);
|
|
if (isCreated)
|
|
{
|
|
AddObjectIfNotExists(iObj);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Draw ...
|
|
XCSupportZoneObject *iObj;
|
|
bool isCreated = mPOIDrawer.CreateSupportZone(
|
|
h1SupportZone,
|
|
iObj //
|
|
);
|
|
if (isCreated)
|
|
{
|
|
AddObjectIfNotExists(iObj);
|
|
}
|
|
}
|
|
|
|
//
|
|
count = ArraySize(conditions.h1ResistanceZones);
|
|
if (IsValidSize(count))
|
|
{
|
|
//
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
//
|
|
XCResistanceZone *item = conditions.h1ResistanceZones[i];
|
|
|
|
//
|
|
bool canSelect =
|
|
h1ResistanceZone == NULL ||
|
|
h1ResistanceZone.Upper() > item.Upper();
|
|
if (canSelect)
|
|
{
|
|
h1ResistanceZone = item;
|
|
}
|
|
}
|
|
}
|
|
if (h1ResistanceZone != NULL)
|
|
{
|
|
//
|
|
// Detect Swings ...
|
|
count = ArraySize(conditions.h1State.swingHighs);
|
|
if (IsValidSize(count))
|
|
{
|
|
//
|
|
double upper = h1ResistanceZone.Upper();
|
|
double lower = h1ResistanceZone.Lower();
|
|
|
|
//
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
//
|
|
XCSwing *item = conditions.h1State.swingHighs[i];
|
|
|
|
//
|
|
XOHCL iBar;
|
|
bool isFilled = item.FillBar(iBar);
|
|
if (!isFilled)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
//
|
|
bool canSelect = (iBar.high <= upper &&
|
|
iBar.low >= lower) ||
|
|
(iBar.high >= upper &&
|
|
iBar.low <= lower);
|
|
if (canSelect)
|
|
{
|
|
//
|
|
Add(
|
|
item,
|
|
h1SwingHighs //
|
|
);
|
|
|
|
//
|
|
// Draw ...
|
|
XCSwingHighObject *iObj;
|
|
bool isCreated = mPOIDrawer.CreateSwingHigh(
|
|
item,
|
|
iObj //
|
|
);
|
|
if (isCreated)
|
|
{
|
|
AddObjectIfNotExists(iObj);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Draw ...
|
|
XCResistanceZoneObject *iObj;
|
|
bool isCreated = mPOIDrawer.CreateResistanceZone(
|
|
h1ResistanceZone,
|
|
iObj //
|
|
);
|
|
if (isCreated)
|
|
{
|
|
AddObjectIfNotExists(iObj);
|
|
}
|
|
}
|
|
|
|
//
|
|
// 15M ...
|
|
|
|
//
|
|
XCSupportZone *m15SupportZone = NULL;
|
|
count = ArraySize(conditions.m15SupportZones);
|
|
if (IsValidSize(count))
|
|
{
|
|
//
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
//
|
|
XCSupportZone *item = conditions.m15SupportZones[i];
|
|
|
|
//
|
|
bool canSelect =
|
|
m15SupportZone == NULL ||
|
|
m15SupportZone.Lower() < item.Lower();
|
|
if (canSelect)
|
|
{
|
|
m15SupportZone = item;
|
|
}
|
|
}
|
|
}
|
|
if (m15SupportZone != NULL)
|
|
{
|
|
//
|
|
XCSupportZoneObject *iObj;
|
|
bool isCreated = mPOIDrawer.CreateSupportZone(
|
|
m15SupportZone,
|
|
iObj //
|
|
);
|
|
if (isCreated)
|
|
{
|
|
AddObjectIfNotExists(iObj);
|
|
}
|
|
}
|
|
|
|
//
|
|
XCResistanceZone *m15ResistanceZone = NULL;
|
|
count = ArraySize(conditions.m15ResistanceZones);
|
|
if (IsValidSize(count))
|
|
{
|
|
//
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
//
|
|
XCResistanceZone *item = conditions.m15ResistanceZones[i];
|
|
|
|
//
|
|
bool canSelect =
|
|
m15ResistanceZone == NULL ||
|
|
m15ResistanceZone.Upper() > item.Upper();
|
|
if (canSelect)
|
|
{
|
|
m15ResistanceZone = item;
|
|
}
|
|
}
|
|
}
|
|
if (m15ResistanceZone != NULL)
|
|
{
|
|
//
|
|
XCResistanceZoneObject *iObj;
|
|
bool isCreated = mPOIDrawer.CreateResistanceZone(
|
|
m15ResistanceZone,
|
|
iObj //
|
|
);
|
|
if (isCreated)
|
|
{
|
|
AddObjectIfNotExists(iObj);
|
|
}
|
|
}
|
|
|
|
//
|
|
// 5M ...
|
|
|
|
//
|
|
XCSupportZone *m5SupportZone = NULL;
|
|
count = ArraySize(conditions.m5SupportZones);
|
|
if (IsValidSize(count))
|
|
{
|
|
//
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
//
|
|
XCSupportZone *item = conditions.m5SupportZones[i];
|
|
|
|
//
|
|
bool canSelect =
|
|
m5SupportZone == NULL ||
|
|
m5SupportZone.Lower() < item.Lower();
|
|
if (canSelect)
|
|
{
|
|
m5SupportZone = item;
|
|
}
|
|
}
|
|
}
|
|
if (m5SupportZone != NULL)
|
|
{
|
|
//
|
|
XCSupportZoneObject *iObj;
|
|
bool isCreated = mPOIDrawer.CreateSupportZone(
|
|
m5SupportZone,
|
|
iObj //
|
|
);
|
|
if (isCreated)
|
|
{
|
|
AddObjectIfNotExists(iObj);
|
|
}
|
|
}
|
|
|
|
//
|
|
XCResistanceZone *m5ResistanceZone = NULL;
|
|
count = ArraySize(conditions.m5ResistanceZones);
|
|
if (IsValidSize(count))
|
|
{
|
|
//
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
//
|
|
XCResistanceZone *item = conditions.m5ResistanceZones[i];
|
|
|
|
//
|
|
bool canSelect =
|
|
m5ResistanceZone == NULL ||
|
|
m5ResistanceZone.Upper() > item.Upper();
|
|
if (canSelect)
|
|
{
|
|
m5ResistanceZone = item;
|
|
}
|
|
}
|
|
}
|
|
if (m5ResistanceZone != NULL)
|
|
{
|
|
//
|
|
XCResistanceZoneObject *iObj;
|
|
bool isCreated = mPOIDrawer.CreateResistanceZone(
|
|
m5ResistanceZone,
|
|
iObj //
|
|
);
|
|
if (isCreated)
|
|
{
|
|
AddObjectIfNotExists(iObj);
|
|
}
|
|
}
|
|
|
|
//
|
|
// DrawState(_5MState);
|
|
|
|
//
|
|
//
|
|
// Strategy Class Tools Functions ...
|
|
|
|
/**
|
|
* Detect Specified States Market Structure ...
|
|
*
|
|
* @param dir: ENUM_X_DIRECTION member, Refrence ...
|
|
* @param state: XPOIState instance ...
|
|
*
|
|
* @return ( bool )
|
|
*/
|
|
bool DetectMarketStructure(
|
|
ENUM_X_DIRECTION &dir,
|
|
XCSupportZone *&supportZones[],
|
|
XCResistanceZone *&resistanceZones[],
|
|
XPOIState &state //
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
int count = 0;
|
|
|
|
//
|
|
// Filter Untouched Supports ...
|
|
Clean(supportZones);
|
|
int untouchedSupportsCount = 0;
|
|
count = ArraySize(state.supportZones);
|
|
if (IsValidSize(count))
|
|
{
|
|
//
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
//
|
|
XCSupportZone *item = state.supportZones[i];
|
|
|
|
//
|
|
// Find Breakout Bar
|
|
XOHCL iBar;
|
|
bool isFilled = item.FillBar(iBar);
|
|
if (!isFilled)
|
|
{
|
|
break;
|
|
}
|
|
|
|
//
|
|
int iBarIndex = iBar.Index();
|
|
int iBarUnTouchedCount = 0;
|
|
for (int j = 0; j < iBarIndex; j++)
|
|
{
|
|
//
|
|
XOHCL jBar;
|
|
bool isInited = jBar.Init(
|
|
iBar.symbol,
|
|
iBar.period,
|
|
j //
|
|
);
|
|
if (!isInited)
|
|
{
|
|
break;
|
|
}
|
|
|
|
//
|
|
bool isUntouched =
|
|
jBar.low > item.Upper();
|
|
if (isUntouched)
|
|
{
|
|
iBarUnTouchedCount++;
|
|
}
|
|
else
|
|
{
|
|
iBarUnTouchedCount--;
|
|
}
|
|
}
|
|
|
|
//
|
|
if (iBarUnTouchedCount > 0)
|
|
{
|
|
//
|
|
Add(
|
|
item,
|
|
supportZones //
|
|
);
|
|
}
|
|
}
|
|
|
|
//
|
|
untouchedSupportsCount = ArraySize(supportZones);
|
|
if (IsValidSize(untouchedSupportsCount))
|
|
{
|
|
//
|
|
// Draw ...
|
|
// for (int i = 0; i < untouchedSupportsCount; i++)
|
|
// {
|
|
// //
|
|
// XCSupportZone *item = supportZones[i];
|
|
|
|
// //
|
|
// XCSupportZoneObject *iObj;
|
|
// bool isCreated = mPOIDrawer.CreateSupportZone(
|
|
// item,
|
|
// iObj //
|
|
// );
|
|
// if (isCreated)
|
|
// {
|
|
// AddObjectIfNotExists(iObj);
|
|
// }
|
|
// }
|
|
}
|
|
}
|
|
|
|
//
|
|
// Filter Untouched Resistances ...
|
|
Clean(resistanceZones);
|
|
int untouchedResistancesCount = 0;
|
|
count = ArraySize(state.resistanceZones);
|
|
if (IsValidSize(count))
|
|
{
|
|
//
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
//
|
|
XCResistanceZone *item = state.resistanceZones[i];
|
|
|
|
//
|
|
// Find Breakout Bar
|
|
XOHCL iBar;
|
|
bool isFilled = item.FillBar(iBar);
|
|
if (!isFilled)
|
|
{
|
|
break;
|
|
}
|
|
|
|
//
|
|
int iBarIndex = iBar.Index();
|
|
int iBarUnTouchedCount = 0;
|
|
for (int j = 0; j < iBarIndex; j++)
|
|
{
|
|
//
|
|
XOHCL jBar;
|
|
bool isInited = jBar.Init(
|
|
iBar.symbol,
|
|
iBar.period,
|
|
j //
|
|
);
|
|
if (!isInited)
|
|
{
|
|
break;
|
|
}
|
|
|
|
//
|
|
bool isUntouched =
|
|
jBar.high < item.Lower();
|
|
if (isUntouched)
|
|
{
|
|
iBarUnTouchedCount++;
|
|
}
|
|
else
|
|
{
|
|
iBarUnTouchedCount--;
|
|
}
|
|
}
|
|
|
|
//
|
|
if (iBarUnTouchedCount > 0)
|
|
{
|
|
//
|
|
Add(
|
|
item,
|
|
resistanceZones //
|
|
);
|
|
}
|
|
}
|
|
|
|
//
|
|
untouchedResistancesCount = ArraySize(resistanceZones);
|
|
if (IsValidSize(untouchedResistancesCount))
|
|
{
|
|
//
|
|
// Draw ...
|
|
// for (int i = 0; i < untouchedResistancesCount; i++)
|
|
// {
|
|
// //
|
|
// XCResistanceZone *item = resistanceZones[i];
|
|
|
|
// //
|
|
// XCResistanceZoneObject *iObj;
|
|
// bool isCreated = mPOIDrawer.CreateResistanceZone(
|
|
// item,
|
|
// iObj //
|
|
// );
|
|
// if (isCreated)
|
|
// {
|
|
// AddObjectIfNotExists(iObj);
|
|
// }
|
|
// }
|
|
}
|
|
}
|
|
|
|
//
|
|
bool hasBullishStructure =
|
|
IsValidSize(untouchedSupportsCount) &&
|
|
untouchedSupportsCount > untouchedResistancesCount;
|
|
bool hasBearishStructure =
|
|
IsValidSize(untouchedResistancesCount) &&
|
|
untouchedResistancesCount > untouchedSupportsCount;
|
|
|
|
//
|
|
result = (hasBullishStructure &&
|
|
!hasBearishStructure) ||
|
|
(hasBearishStructure &&
|
|
!hasBullishStructure);
|
|
|
|
//
|
|
if (result)
|
|
{
|
|
//
|
|
dir =
|
|
hasBullishStructure
|
|
? X_DIRECTION_BULLISH
|
|
: X_DIRECTION_BEARISH;
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
// Detect Order Blocks ...
|
|
// int obsCount = 0;
|
|
|
|
//
|
|
// Find Bullish Order Block ...
|
|
// XCOrderBlock *bullishOB = NULL;
|
|
// XCRejectionBar *bullishOBRejectionBar = NULL;
|
|
// obsCount = lastPivot.state.CountBullishOrderBlocks();
|
|
// if (IsValidSize(obsCount))
|
|
// {
|
|
// //
|
|
// for (int i = 0; i < obsCount; i++)
|
|
// {
|
|
// //
|
|
// XCOrderBlock *iOB = lastPivot.state.bullishOrderBlocks[i];
|
|
|
|
// //
|
|
// XOHCL iBar;
|
|
// bool hasBar = iOB.FillBar(iBar);
|
|
// bool isPeriodSame = hasBar &&
|
|
// iBar.period == _period;
|
|
|
|
// //
|
|
// if (iOB.Upper() <= pivotMid &&
|
|
// iOB.Lower() >= lastPivot.lower)
|
|
// {
|
|
// //
|
|
// bullishOB = iOB;
|
|
// break;
|
|
// }
|
|
// }
|
|
// }
|
|
// bool hasBullishOB = bullishOB != NULL;
|
|
// bool isBullishOBRejected = false;
|
|
// if (hasBullishOB)
|
|
// {
|
|
// //
|
|
// int bullishRejectedBarsCount = lastPivot.state.CountBullishRejectionBars();
|
|
// if (IsValidSize(bullishRejectedBarsCount))
|
|
// {
|
|
// //
|
|
// for (int i = 0; i < bullishRejectedBarsCount; i++)
|
|
// {
|
|
// //
|
|
// XCRejectionBar *item = lastPivot.state.bullishRejectionBars[i];
|
|
|
|
// //
|
|
// XOHCL iBar;
|
|
// bool isFilled = item.FillBar(iBar);
|
|
// if (!isFilled)
|
|
// {
|
|
// continue;
|
|
// }
|
|
|
|
// //
|
|
// bool isRejected = iBar.low <= bullishOB.Lower() &&
|
|
// (iBar.GetDown() <= bullishOB.Upper() ||
|
|
// iBar.GetDown() > bullishOB.Upper());
|
|
|
|
// //
|
|
// isBullishOBRejected =
|
|
// bullishOBRejectionBar == NULL
|
|
// ? isRejected
|
|
// : isRejected &&
|
|
// item.From() > bullishOBRejectionBar.From();
|
|
// if (isBullishOBRejected)
|
|
// {
|
|
// bullishOBRejectionBar = item;
|
|
// }
|
|
// }
|
|
// }
|
|
// if (isBullishOBRejected)
|
|
// {
|
|
// //
|
|
// bullishOBRejectionBar.To(cTime);
|
|
// XCBullishRejectionBarObject *iObj;
|
|
// bool isCreated = mPOIDrawer.CreateBullishRejectionBar(
|
|
// bullishOBRejectionBar,
|
|
// iObj //
|
|
// );
|
|
// if (isCreated)
|
|
// {
|
|
// AddObjectIfNotExists(iObj);
|
|
// }
|
|
// }
|
|
|
|
// //
|
|
// bullishOB.To(cTime);
|
|
// XCBullishOrderBlockObject *iObj;
|
|
// bool isCreated = mPOIDrawer.CreateBullishOrderBlock(
|
|
// bullishOB,
|
|
// iObj //
|
|
// );
|
|
// if (isCreated)
|
|
// {
|
|
// AddObjectIfNotExists(iObj);
|
|
// }
|
|
// }
|
|
|
|
//
|
|
// Find Bearish Order Block ...
|
|
// XCOrderBlock *bearishOB = NULL;
|
|
// XCRejectionBar *bearishOBRejectionBar = NULL;
|
|
// obsCount = lastPivot.state.CountBearishOrderBlocks();
|
|
// if (IsValidSize(obsCount))
|
|
// {
|
|
// //
|
|
// for (int i = 0; i < obsCount; i++)
|
|
// {
|
|
// //
|
|
// XCOrderBlock *iOB = lastPivot.state.bearishOrderBlocks[i];
|
|
|
|
// //
|
|
// XOHCL iBar;
|
|
// bool hasBar = iOB.FillBar(iBar);
|
|
// bool isPeriodSame = hasBar &&
|
|
// iBar.period == _period;
|
|
|
|
// //
|
|
// if (iOB.Lower() >= pivotMid &&
|
|
// iOB.Upper() <= lastPivot.upper)
|
|
// {
|
|
// //
|
|
// bearishOB = iOB;
|
|
// break;
|
|
// }
|
|
// }
|
|
// }
|
|
// bool hasBearishOB = bearishOB != NULL;
|
|
// bool isBearishOBRejected = false;
|
|
// if (hasBearishOB)
|
|
// {
|
|
// //
|
|
// int bearishRejectedBarsCount = lastPivot.state.CountBearishRejectionBars();
|
|
// if (IsValidSize(bearishRejectedBarsCount))
|
|
// {
|
|
// //
|
|
// for (int i = 0; i < bearishRejectedBarsCount; i++)
|
|
// {
|
|
// //
|
|
// XCRejectionBar *item = lastPivot.state.bearishRejectionBars[i];
|
|
|
|
// //
|
|
// XOHCL iBar;
|
|
// bool isFilled = item.FillBar(iBar);
|
|
// if (!isFilled)
|
|
// {
|
|
// continue;
|
|
// }
|
|
|
|
// //
|
|
// bool isRejected = iBar.high >= bearishOB.Upper() &&
|
|
// (iBar.GetUp() <= bearishOB.Lower() ||
|
|
// iBar.GetUp() > bearishOB.Lower());
|
|
|
|
// //
|
|
// isBearishOBRejected =
|
|
// bearishOBRejectionBar == NULL
|
|
// ? isRejected
|
|
// : isRejected &&
|
|
// item.From() > bearishOBRejectionBar.From();
|
|
// if (isBearishOBRejected)
|
|
// {
|
|
// bearishOBRejectionBar = item;
|
|
// }
|
|
// }
|
|
// }
|
|
// if (isBearishOBRejected)
|
|
// {
|
|
// //
|
|
// bearishOBRejectionBar.To(cTime);
|
|
// XCBearishRejectionBarObject *iObj;
|
|
// bool isCreated = mPOIDrawer.CreateBearishRejectionBar(
|
|
// bearishOBRejectionBar,
|
|
// iObj //
|
|
// );
|
|
// if (isCreated)
|
|
// {
|
|
// AddObjectIfNotExists(iObj);
|
|
// }
|
|
// }
|
|
|
|
// //
|
|
// bearishOB.To(cTime);
|
|
// XCBearishOrderBlockObject *iObj;
|
|
// bool isCreated = mPOIDrawer.CreateBearishOrderBlock(
|
|
// bearishOB,
|
|
// iObj //
|
|
// );
|
|
// if (isCreated)
|
|
// {
|
|
// AddObjectIfNotExists(iObj);
|
|
// }
|
|
// }
|
|
|
|
// //
|
|
// // Find an Order Block ...
|
|
// bool isBearishOrderBlockRejected = false;
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
RedrawOrderFlow();
|
|
|
|
//
|
|
// Check Candlestick PullBacks ...
|
|
ENUM_X_DIRECTION pullBackDir;
|
|
bool hasPullBack = mBarAnalyser.HasPullBack(
|
|
pullBackDir,
|
|
cBar,
|
|
3, // Loopback ...
|
|
true // Force Body ...
|
|
);
|
|
bool hasBullishPullback =
|
|
hasPullBack &&
|
|
pullBackDir == X_DIRECTION_BULLISH;
|
|
bool hasBearishPullback =
|
|
hasPullBack &&
|
|
pullBackDir == X_DIRECTION_BEARISH;
|
|
|
|
//
|
|
bool isInDiscount =
|
|
bid < pivotMid &&
|
|
bid > lastPivot.lower;
|
|
|
|
//
|
|
bool isInPremium =
|
|
bid > pivotMid &&
|
|
bid < lastPivot.upper;
|
|
|
|
//
|
|
// Check Order Flow Validation ...
|
|
|
|
//
|
|
// For Bullish Order Flow ...
|
|
// if Price Breakes Lower to Down, means Change of Charcter Happens ...
|
|
bool isCHOCHHappens =
|
|
isBullishOrderFlow ? bid < lastPivot.lower - pip
|
|
: bid > lastPivot.upper + pip;
|
|
|
|
//
|
|
// For Bullish Order Flow ...
|
|
// if Price Breakes Upper to Up, means Breake of Structure Happens ...
|
|
bool isBOSHappens =
|
|
isBullishOrderFlow ? bid > lastPivot.upper + pip
|
|
: bid < lastPivot.lower - pip;
|
|
|
|
//
|
|
if (isBOSHappens)
|
|
{
|
|
//
|
|
// RedrawOrderFlow();
|
|
Print("");
|
|
}
|
|
|
|
//
|
|
if (isCHOCHHappens)
|
|
{
|
|
//
|
|
result = false;
|
|
ResetOrderFlow();
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Check 3MA and 3VWAP State ...
|
|
|
|
//
|
|
bool isVWAPBullishOrdered =
|
|
//
|
|
(
|
|
//
|
|
(conditions.x3vwapConditions.isBullishOrdered ||
|
|
conditions.x3vwapConditions.isSwitchedToBullishOrdered)
|
|
//
|
|
||
|
|
//
|
|
conditions.x3vwapConditions.fasts[cIndex] > conditions.x3vwapConditions.mids[cIndex]
|
|
//
|
|
||
|
|
//
|
|
conditions.x3vwapConditions.mids[cIndex] > conditions.x3vwapConditions.slows[cIndex]
|
|
//
|
|
)
|
|
//
|
|
;
|
|
|
|
//
|
|
bool isVWAPBearishOrdered =
|
|
//
|
|
(
|
|
//
|
|
(conditions.x3vwapConditions.isBearishOrdered ||
|
|
conditions.x3vwapConditions.isSwitchedToBearishOrdered)
|
|
//
|
|
||
|
|
//
|
|
conditions.x3vwapConditions.fasts[cIndex] < conditions.x3vwapConditions.mids[cIndex]
|
|
//
|
|
||
|
|
//
|
|
conditions.x3vwapConditions.mids[cIndex] < conditions.x3vwapConditions.slows[cIndex]
|
|
//
|
|
)
|
|
//
|
|
;
|
|
|
|
//
|
|
bool isVWapBullishState =
|
|
//
|
|
(
|
|
//
|
|
(conditions.x3vwapConditions.isBullishState ||
|
|
conditions.x3vwapConditions.isSwitchedToBullishState)
|
|
//
|
|
||
|
|
//
|
|
(x3vwapHelper.IsBullish(conditions.x3vwapConditions.fastStates[cIndex]) &&
|
|
x3vwapHelper.IsBullish(conditions.x3vwapConditions.midStates[cIndex]))
|
|
//
|
|
||
|
|
//
|
|
(x3vwapHelper.IsBullish(conditions.x3vwapConditions.midStates[cIndex]) &&
|
|
x3vwapHelper.IsBullish(conditions.x3vwapConditions.slowStates[cIndex]))
|
|
//
|
|
)
|
|
//
|
|
;
|
|
|
|
//
|
|
bool isVWapBearishState =
|
|
//
|
|
(
|
|
//
|
|
(conditions.x3vwapConditions.isBearishState ||
|
|
conditions.x3vwapConditions.isSwitchedToBearishState)
|
|
//
|
|
||
|
|
//
|
|
(x3vwapHelper.IsBearish(conditions.x3vwapConditions.fastStates[cIndex]) &&
|
|
x3vwapHelper.IsBearish(conditions.x3vwapConditions.midStates[cIndex]))
|
|
//
|
|
||
|
|
//
|
|
(x3vwapHelper.IsBearish(conditions.x3vwapConditions.midStates[cIndex]) &&
|
|
x3vwapHelper.IsBearish(conditions.x3vwapConditions.slowStates[cIndex]))
|
|
//
|
|
)
|
|
//
|
|
;
|
|
|
|
//
|
|
bool isVWapOverFastMA =
|
|
//
|
|
(
|
|
//
|
|
(conditions.x3vwapConditions.fasts[cIndex] > conditions.x3maConditions.fasts[cIndex] &&
|
|
conditions.x3vwapConditions.mids[cIndex] > conditions.x3maConditions.fasts[cIndex])
|
|
//
|
|
||
|
|
//
|
|
(conditions.x3vwapConditions.fasts[cIndex] > conditions.x3maConditions.fasts[cIndex] &&
|
|
conditions.x3vwapConditions.mids[cIndex] > conditions.x3maConditions.fasts[cIndex] &&
|
|
conditions.x3vwapConditions.slows[cIndex] > conditions.x3maConditions.fasts[cIndex])
|
|
//
|
|
)
|
|
//
|
|
;
|
|
|
|
//
|
|
bool isVWapUnderFastMA =
|
|
//
|
|
(
|
|
//
|
|
(conditions.x3vwapConditions.fasts[cIndex] < conditions.x3maConditions.fasts[cIndex] &&
|
|
conditions.x3vwapConditions.mids[cIndex] < conditions.x3maConditions.fasts[cIndex])
|
|
//
|
|
||
|
|
//
|
|
(conditions.x3vwapConditions.fasts[cIndex] < conditions.x3maConditions.fasts[cIndex] &&
|
|
conditions.x3vwapConditions.mids[cIndex] < conditions.x3maConditions.fasts[cIndex] &&
|
|
conditions.x3vwapConditions.slows[cIndex] < conditions.x3maConditions.fasts[cIndex])
|
|
//
|
|
)
|
|
//
|
|
;
|
|
|
|
//
|
|
bool is3Bullish =
|
|
//
|
|
(
|
|
//
|
|
(isVWAPBullishOrdered &&
|
|
isVWapBullishState)
|
|
//
|
|
||
|
|
//
|
|
(isVWAPBullishOrdered &&
|
|
isVWapOverFastMA)
|
|
//
|
|
||
|
|
//
|
|
(isVWapBullishState &&
|
|
isVWapOverFastMA)
|
|
//
|
|
)
|
|
//
|
|
;
|
|
|
|
//
|
|
bool is3Bearish =
|
|
//
|
|
(
|
|
//
|
|
(isVWAPBearishOrdered &&
|
|
isVWapBearishState)
|
|
//
|
|
||
|
|
//
|
|
(isVWAPBearishOrdered &&
|
|
isVWapUnderFastMA)
|
|
//
|
|
||
|
|
//
|
|
(isVWapBearishState &&
|
|
isVWapUnderFastMA)
|
|
//
|
|
)
|
|
//
|
|
;
|
|
|
|
//
|
|
// Check Parabolic Sars State ...
|
|
|
|
//
|
|
bool isSarBullish =
|
|
//
|
|
(conditions.xchsarConditions.isCBullish &&
|
|
conditions.xchsarConditions.isSSwitchedBullish)
|
|
//
|
|
||
|
|
//
|
|
(conditions.xchsarConditions.isSBullish &&
|
|
conditions.xchsarConditions.isCSwitchedBullish)
|
|
//
|
|
;
|
|
bool isSarBearish =
|
|
//
|
|
(conditions.xchsarConditions.isCBearish &&
|
|
conditions.xchsarConditions.isSSwitchedBearish)
|
|
//
|
|
||
|
|
//
|
|
(conditions.xchsarConditions.isSBearish &&
|
|
conditions.xchsarConditions.isCSwitchedBearish)
|
|
//
|
|
;
|
|
|
|
// //
|
|
// hasLong =
|
|
// //
|
|
// is3Bullish &&
|
|
// // isInDiscount &&
|
|
// isSarBullish // &&
|
|
// // hasBullishPullback &&
|
|
// // bullishLiquidityPercent > 30
|
|
// //
|
|
// ;
|
|
|
|
// //
|
|
// hasShort =
|
|
// //
|
|
// is3Bearish &&
|
|
// // isInPremium &&
|
|
// isSarBearish // &&
|
|
// // hasBearishPullback &&
|
|
// // bearishLiquidityPercent > 30
|
|
// //
|
|
// ;
|
|
|
|
//////////////////////
|
|
|
|
//
|
|
XPVPivot lastPivot;
|
|
result = GetLastItem(
|
|
lastPivot,
|
|
mOrderFlow //
|
|
);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
bool isBullishOrderFlow = IsBullish(mOrderFlowDir);
|
|
bool isBearishOrderFlow = IsBearish(mOrderFlowDir);
|
|
double pivotMid = lastPivot.CalculateMid();
|
|
|
|
//
|
|
// Calculate Liquidity Percent ...
|
|
double bullishLiquidityPercent = lastPivot
|
|
.CalculateLiquidityPercent(X_DIRECTION_BULLISH);
|
|
double bearishLiquidityPercent = lastPivot
|
|
.CalculateLiquidityPercent(X_DIRECTION_BEARISH);
|
|
double minLiquidityPercent = 35;
|
|
bool hasBullishLiquidity = bullishLiquidityPercent >= minLiquidityPercent;
|
|
bool hasBearishLiquidity = bearishLiquidityPercent >= minLiquidityPercent;
|
|
result = hasBullishLiquidity ||
|
|
hasBearishLiquidity;
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////
|
|
|
|
// //
|
|
// // 1D Period ...
|
|
// // POI Detector ...
|
|
// m1DPOI = new XCPOIDetector(
|
|
// symbol,
|
|
// PERIOD_D1 //
|
|
// );
|
|
|
|
// //
|
|
// m1DPOI.MaxNumberOfRequiredPOIs(poiRequired);
|
|
|
|
// //
|
|
// m1DPOI.Init();
|
|
|
|
// //
|
|
// // 4H Period ...
|
|
// // POI Detector ...
|
|
// m4HPOI = new XCPOIDetector(
|
|
// symbol,
|
|
// PERIOD_H4 //
|
|
// );
|
|
|
|
// //
|
|
// m4HPOI.MaxNumberOfRequiredPOIs(poiRequired);
|
|
|
|
// //
|
|
// m4HPOI.Init();
|
|
|
|
// //
|
|
// // 2H Period ...
|
|
// // POI Detector ...
|
|
// m2HPOI = new XCPOIDetector(
|
|
// symbol,
|
|
// PERIOD_H2 //
|
|
// );
|
|
|
|
// //
|
|
// m2HPOI.MaxNumberOfRequiredPOIs(poiRequired);
|
|
|
|
// //
|
|
// m2HPOI.Init();
|
|
|
|
//
|
|
// 1H Period ...
|
|
// POI Detector ...
|
|
// m1HPOI = new XCPOIDetector(
|
|
// symbol,
|
|
// PERIOD_H1 //
|
|
// );
|
|
|
|
// //
|
|
// m1HPOI.MaxNumberOfRequiredPOIs(poiRequired);
|
|
|
|
// //
|
|
// m1HPOI.Init();
|
|
|
|
//
|
|
// 15M Period ...
|
|
// POI Detector ...
|
|
// m15MPOI = new XCPOIDetector(
|
|
// symbol,
|
|
// PERIOD_M15 //
|
|
// );
|
|
|
|
// //
|
|
// m15MPOI.MaxNumberOfRequiredPOIs(poiRequired);
|
|
|
|
// //
|
|
// m15MPOI.Init();
|
|
|
|
// //
|
|
// // 5M Period ...
|
|
// // POI Detector ...
|
|
// m5MPOI = new XCPOIDetector(
|
|
// symbol,
|
|
// PERIOD_M5 //
|
|
// );
|
|
|
|
// //
|
|
// m5MPOI.MaxNumberOfRequiredPOIs(poiRequired);
|
|
|
|
// //
|
|
// m5MPOI.Init();
|
|
|
|
// //
|
|
// // 1M Period ...
|
|
// // POI Detector ...
|
|
// m1MPOI = new XCPOIDetector(
|
|
// symbol,
|
|
// PERIOD_M1 //
|
|
// );
|
|
|
|
// //
|
|
// m1MPOI.MaxNumberOfRequiredPOIs(poiRequired);
|
|
|
|
// //
|
|
// m1MPOI.Init();
|
|
|
|
////////////////////////////////
|
|
|
|
// delete m1DPOI;
|
|
// delete m4HPOI;
|
|
// delete m2HPOI;
|
|
delete m1HPOI;
|
|
delete m15MPOI;
|
|
// delete m5MPOI;
|
|
// delete m1MPOI;
|
|
|
|
///////////////////////////////////
|
|
|
|
//
|
|
// Point Of Interests ...
|
|
XCPOIDetector *mTriggerPOIDetector;
|
|
XCPOIDetector *mAnalysePOIDetector;
|
|
XCPOIDetector *mVisionPOIDetector;
|
|
|
|
//
|
|
// XCPOIDetector *m1DPOI;
|
|
// XCPOIDetector *m4HPOI;
|
|
// XCPOIDetector *m2HPOI;
|
|
// XCPOIDetector *m1HPOI;
|
|
// XCPOIDetector *m15MPOI;
|
|
// XCPOIDetector *m5MPOI;
|
|
// XCPOIDetector *m1MPOI;
|
|
|
|
//
|
|
XPOIState mTriggerPOIState;
|
|
XPOIState mAnalysePOIState;
|
|
XPOIState mVisionPOIState;
|
|
|
|
// XPOIState _1DState;
|
|
// XPOIState _4HState;
|
|
// XPOIState _2HState;
|
|
// XPOIState _1HState;
|
|
// XPOIState _15MState;
|
|
// XPOIState _5MState;
|
|
// XPOIState _1MState;
|
|
// XPOIState _CombineState;
|
|
|
|
///////////////////////////////////////////
|
|
|
|
//
|
|
// Update POIs ...
|
|
|
|
//
|
|
ENUM_XPOI_EVENTS _events[];
|
|
mPOIDetector.Update(_events);
|
|
|
|
// //
|
|
// ENUM_XPOI_EVENTS _1DStates[];
|
|
// m1DPOI.Update(_1DStates);
|
|
|
|
// //
|
|
// ENUM_XPOI_EVENTS _4HStates[];
|
|
// m4HPOI.Update(_4HStates);
|
|
|
|
// //
|
|
// ENUM_XPOI_EVENTS _2HStates[];
|
|
// m2HPOI.Update(_2HStates);
|
|
|
|
//
|
|
ENUM_XPOI_EVENTS _1HStates[];
|
|
m1HPOI.Update(_1HStates);
|
|
|
|
// //
|
|
// ENUM_XPOI_EVENTS _15MStates[];
|
|
// m15MPOI.Update(_15MStates);
|
|
|
|
// //
|
|
// ENUM_XPOI_EVENTS _5MStates[];
|
|
// m5MPOI.Update(_5MStates);
|
|
|
|
// //
|
|
// ENUM_XPOI_EVENTS _1MStates[];
|
|
// m1MPOI.Update(_1MStates);
|
|
|
|
// //
|
|
// // Read all POI States ...
|
|
mPOIDetector.GetState(_state);
|
|
// m1DPOI.GetState(_1DState);
|
|
// m4HPOI.GetState(_4HState);
|
|
// m2HPOI.GetState(_2HState);
|
|
m1HPOI.GetState(_1HState);
|
|
// m15MPOI.GetState(_15MState);
|
|
// m5MPOI.GetState(_5MState);
|
|
// m1MPOI.GetState(_1MState);
|
|
|
|
//
|
|
// Combine States ...
|
|
// XPOIState _States[];
|
|
// AddRef(
|
|
// _1DState,
|
|
// _States //
|
|
// );
|
|
// AddRef(
|
|
// _4HState,
|
|
// _States //
|
|
// );
|
|
// AddRef(
|
|
// _2HState,
|
|
// _States //
|
|
// );
|
|
// AddRef(
|
|
// _1HState,
|
|
// _States //
|
|
// );
|
|
// AddRef(
|
|
// _15MState,
|
|
// _States //
|
|
// );
|
|
// AddRef(
|
|
// _5MState,
|
|
// _States //
|
|
// );
|
|
// AddRef(
|
|
// _1MState,
|
|
// _States //
|
|
// );
|
|
// CombineStates(
|
|
// _CombineState,
|
|
// _States //
|
|
// );
|
|
|
|
////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
// Works by WVAP and PSar ...
|
|
bool long1 =
|
|
//
|
|
conditions.x3vwapConditions.isBullishState &&
|
|
conditions.x3vwapConditions.isBullishOrdered &&
|
|
// conditions.xpvConditions.vales[cIndex] == conditions.xchsarConditions.cSars[cIndex] &&
|
|
conditions.xchsarConditions.cSars[cIndex] < conditions.x3vwapConditions.slows[cIndex]
|
|
//
|
|
;
|
|
if (long1)
|
|
{
|
|
//
|
|
CustomStateDrawing(_1HState);
|
|
selectedSL = conditions.xpvConditions.vales[cIndex];
|
|
}
|
|
|
|
//
|
|
// Works by WVAP and PSar ...
|
|
bool short1 =
|
|
//
|
|
conditions.x3vwapConditions.isBearishState &&
|
|
conditions.x3vwapConditions.isBearishOrdered &&
|
|
// conditions.xpvConditions.peaks[cIndex] == conditions.xchsarConditions.cSars[cIndex] &&
|
|
conditions.xchsarConditions.cSars[cIndex] > conditions.x3vwapConditions.slows[cIndex]
|
|
//
|
|
;
|
|
if (short1)
|
|
{
|
|
//
|
|
CustomStateDrawing(_1HState);
|
|
selectedSL = conditions.xpvConditions.peaks[cIndex];
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
// mOrderFlow[pivotIDX].state.ticksZone =
|
|
//_15MState.ticksZone;
|
|
|
|
// //
|
|
// // D1 ...
|
|
// XPOIState d1;
|
|
// if (_1DState.HasChild())
|
|
// {
|
|
// //
|
|
// DetectPivotPOIs(
|
|
// mOrderFlow[pivotIDX],
|
|
// _1DState,
|
|
// d1,
|
|
// lookupSwingHighs,
|
|
// lookupSwingLows,
|
|
// lookupSupportZones,
|
|
// lookupResistanceZones,
|
|
// lookupSupplyZones,
|
|
// lookupDemandZones,
|
|
// lookupBullishOrderBlocks,
|
|
// lookupBearishOrderBlocks,
|
|
// lookupBullishFairValueGaps,
|
|
// lookupBearishFairValueGaps,
|
|
// lookupBullishRejectionBars,
|
|
// lookupBearishRejectionBars,
|
|
// lookupBullishMomentumBars,
|
|
// lookupBearishMomentumBars //
|
|
// );
|
|
|
|
// //
|
|
// if (d1.HasChild())
|
|
// {
|
|
// d1.Fill(mOrderFlow[pivotIDX].state);
|
|
// }
|
|
// }
|
|
|
|
// //
|
|
// // H4 ...
|
|
// XPOIState h4;
|
|
// if (_4HState.HasChild())
|
|
// {
|
|
// //
|
|
// DetectPivotPOIs(
|
|
// mOrderFlow[pivotIDX],
|
|
// _4HState,
|
|
// h4,
|
|
// lookupSwingHighs,
|
|
// lookupSwingLows,
|
|
// lookupSupportZones,
|
|
// lookupResistanceZones,
|
|
// lookupSupplyZones,
|
|
// lookupDemandZones,
|
|
// lookupBullishOrderBlocks,
|
|
// lookupBearishOrderBlocks,
|
|
// lookupBullishFairValueGaps,
|
|
// lookupBearishFairValueGaps,
|
|
// lookupBullishRejectionBars,
|
|
// lookupBearishRejectionBars,
|
|
// lookupBullishMomentumBars,
|
|
// lookupBearishMomentumBars //
|
|
// );
|
|
|
|
// //
|
|
// if (h4.HasChild())
|
|
// {
|
|
// h4.Fill(mOrderFlow[pivotIDX].state);
|
|
// }
|
|
// }
|
|
|
|
//
|
|
// H2 ...
|
|
// XPOIState h2;
|
|
// if (_2HState.HasChild())
|
|
// {
|
|
// //
|
|
// DetectPivotPOIs(
|
|
// mOrderFlow[pivotIDX],
|
|
// _2HState,
|
|
// h2,
|
|
// lookupSwingHighs,
|
|
// lookupSwingLows,
|
|
// lookupSupportZones,
|
|
// lookupResistanceZones,
|
|
// lookupSupplyZones,
|
|
// lookupDemandZones,
|
|
// lookupBullishOrderBlocks,
|
|
// lookupBearishOrderBlocks,
|
|
// lookupBullishFairValueGaps,
|
|
// lookupBearishFairValueGaps,
|
|
// lookupBullishRejectionBars,
|
|
// lookupBearishRejectionBars,
|
|
// lookupBullishMomentumBars,
|
|
// lookupBearishMomentumBars //
|
|
// );
|
|
|
|
// //
|
|
// if (h2.HasChild())
|
|
// {
|
|
// h2.Fill(mOrderFlow[pivotIDX].state);
|
|
// }
|
|
// }
|
|
|
|
//
|
|
// H1 ...
|
|
XPOIState h1;
|
|
if (_1HState.HasChild())
|
|
{
|
|
//
|
|
DetectPivotPOIs(
|
|
mOrderFlow[pivotIDX],
|
|
_1HState,
|
|
h1,
|
|
lookupSwingHighs,
|
|
lookupSwingLows,
|
|
lookupSupportZones,
|
|
lookupResistanceZones,
|
|
lookupSupplyZones,
|
|
lookupDemandZones,
|
|
lookupBullishOrderBlocks,
|
|
lookupBearishOrderBlocks,
|
|
lookupBullishFairValueGaps,
|
|
lookupBearishFairValueGaps,
|
|
lookupBullishRejectionBars,
|
|
lookupBearishRejectionBars,
|
|
lookupBullishMomentumBars,
|
|
lookupBearishMomentumBars //
|
|
);
|
|
|
|
//
|
|
if (h1.HasChild())
|
|
{
|
|
h1.Fill(mOrderFlow[pivotIDX].state);
|
|
}
|
|
}
|
|
|
|
//
|
|
// M15 ...
|
|
// XPOIState m15;
|
|
// if (_15MState.HasChild())
|
|
// {
|
|
// //
|
|
// DetectPivotPOIs(
|
|
// mOrderFlow[pivotIDX],
|
|
// _15MState,
|
|
// m15,
|
|
// lookupSwingHighs,
|
|
// lookupSwingLows,
|
|
// lookupSupportZones,
|
|
// lookupResistanceZones,
|
|
// lookupSupplyZones,
|
|
// lookupDemandZones,
|
|
// lookupBullishOrderBlocks,
|
|
// lookupBearishOrderBlocks,
|
|
// lookupBullishFairValueGaps,
|
|
// lookupBearishFairValueGaps,
|
|
// lookupBullishRejectionBars,
|
|
// lookupBearishRejectionBars,
|
|
// lookupBullishMomentumBars,
|
|
// lookupBearishMomentumBars //
|
|
// );
|
|
|
|
// //
|
|
// if (m15.HasChild())
|
|
// {
|
|
// m15.Fill(mOrderFlow[pivotIDX].state);
|
|
// }
|
|
// }
|
|
|
|
//
|
|
// M5 ...
|
|
// XPOIState m5;
|
|
// if (_5MState.HasChild())
|
|
// {
|
|
// //
|
|
// DetectPivotPOIs(
|
|
// mOrderFlow[pivotIDX],
|
|
// _5MState,
|
|
// m5,
|
|
// lookupSwingHighs,
|
|
// lookupSwingLows,
|
|
// lookupSupportZones,
|
|
// lookupResistanceZones,
|
|
// lookupSupplyZones,
|
|
// lookupDemandZones,
|
|
// lookupBullishOrderBlocks,
|
|
// lookupBearishOrderBlocks,
|
|
// lookupBullishFairValueGaps,
|
|
// lookupBearishFairValueGaps,
|
|
// lookupBullishRejectionBars,
|
|
// lookupBearishRejectionBars,
|
|
// lookupBullishMomentumBars,
|
|
// lookupBearishMomentumBars //
|
|
// );
|
|
|
|
// //
|
|
// if (m5.HasChild())
|
|
// {
|
|
// m5.Fill(mOrderFlow[pivotIDX].state);
|
|
// }
|
|
// }
|
|
|
|
//
|
|
// M1 ...
|
|
// XPOIState m1;
|
|
// if (_1MState.HasChild())
|
|
// {
|
|
// //
|
|
// DetectPivotPOIs(
|
|
// mOrderFlow[pivotIDX],
|
|
// _1MState,
|
|
// m1,
|
|
// lookupSwingHighs,
|
|
// lookupSwingLows,
|
|
// lookupSupportZones,
|
|
// lookupResistanceZones,
|
|
// lookupSupplyZones,
|
|
// lookupDemandZones,
|
|
// lookupBullishOrderBlocks,
|
|
// lookupBearishOrderBlocks,
|
|
// lookupBullishFairValueGaps,
|
|
// lookupBearishFairValueGaps,
|
|
// lookupBullishRejectionBars,
|
|
// lookupBearishRejectionBars,
|
|
// lookupBullishMomentumBars,
|
|
// lookupBearishMomentumBars //
|
|
// );
|
|
|
|
// //
|
|
// if (m1.HasChild())
|
|
// {
|
|
// m1.Fill(mOrderFlow[pivotIDX].state);
|
|
// }
|
|
// }
|
|
|
|
//////////////////////////////////
|
|
|
|
/**
|
|
* Detect SL Candidates based on Strategy and Conditions ...
|
|
*
|
|
* @param result: Double array reference ...
|
|
* @param entry: Double, Position Entry Price ...
|
|
* @param conditions: X121SMCStrategyConditions instance, Provides Configurations ...
|
|
* @param type: ENUM_X_POSITION_TYPES member, Specified Position Type ...
|
|
*/
|
|
void DetectSLCandidates(
|
|
double &result[],
|
|
double entry,
|
|
X121SMCStrategyConditions &conditions,
|
|
ENUM_X_POSITION_TYPES type //
|
|
) override
|
|
{
|
|
//
|
|
Clean(result);
|
|
|
|
//
|
|
int cIndex = 1;
|
|
|
|
//
|
|
if (entry <= 0 ||
|
|
!conditions.IsValid() ||
|
|
type == X_POSITION_TYPE_ALL ||
|
|
type == X_POSITION_TYPE_NONE)
|
|
{
|
|
return;
|
|
}
|
|
|
|
//
|
|
Add(
|
|
conditions.x3vwapConditions.fasts[cIndex],
|
|
result //
|
|
);
|
|
|
|
//
|
|
Add(
|
|
conditions.x3vwapConditions.mids[cIndex],
|
|
result //
|
|
);
|
|
|
|
//
|
|
Add(
|
|
conditions.x3vwapConditions.slows[cIndex],
|
|
result //
|
|
);
|
|
|
|
//
|
|
Add(
|
|
conditions.x3maConditions.fasts[cIndex],
|
|
result //
|
|
);
|
|
|
|
//
|
|
Add(
|
|
conditions.xpvConditions.vales[cIndex],
|
|
result //
|
|
);
|
|
|
|
//
|
|
Add(
|
|
conditions.xpvConditions.peaks[cIndex],
|
|
result //
|
|
);
|
|
|
|
//
|
|
}
|
|
|
|
////////////////////////////////////////
|
|
|
|
bool canContinue = true;
|
|
while (canContinue)
|
|
{
|
|
//
|
|
XOHCL iBar;
|
|
bool isBarInited = iBar.Init(
|
|
mBar.symbol,
|
|
mBar.period,
|
|
barIndex //
|
|
);
|
|
if (!isBarInited)
|
|
{
|
|
break;
|
|
}
|
|
|
|
//
|
|
if (bullOB == NULL)
|
|
{
|
|
//
|
|
XCOrderBlock *ob;
|
|
bool isBullOB = cycleHelper
|
|
.mPOIDetector
|
|
.DetectBullishOrderBlock(
|
|
mBar,
|
|
ob //
|
|
);
|
|
if (isBullOB)
|
|
{
|
|
//
|
|
bool isPricePassed = bar.low > ob.Upper();
|
|
if (isPricePassed)
|
|
{
|
|
//
|
|
if (mBullOB == NULL)
|
|
{
|
|
//
|
|
mBullOB = ob;
|
|
}
|
|
else
|
|
{
|
|
//
|
|
bool isRefined = mBullOB.Upper() < ob.Upper();
|
|
if (isRefined)
|
|
{
|
|
mBullOB = ob;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
if (bearOB == NULL)
|
|
{
|
|
//
|
|
XCOrderBlock *ob;
|
|
bool isBearOB = cycleHelper
|
|
.mPOIDetector
|
|
.DetectBearishOrderBlock(
|
|
mBar,
|
|
ob //
|
|
);
|
|
if (isBearOB)
|
|
{
|
|
//
|
|
bool isPricePassed = bar.high < ob.Lower();
|
|
if (isPricePassed)
|
|
{
|
|
//
|
|
if (mBearOB == NULL)
|
|
{
|
|
//
|
|
mBearOB = ob;
|
|
}
|
|
else
|
|
{
|
|
//
|
|
bool isRefined = mBearOB.Lower() > ob.Lower();
|
|
if (isRefined)
|
|
{
|
|
mBearOB = ob;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
canContinue =
|
|
(bullOB == NULL && mBullOB == NULL) ||
|
|
(bearOB == NULL && mBearOB == NULL);
|
|
if (canContinue)
|
|
{
|
|
barIndex++;
|
|
}
|
|
}
|
|
|
|
//
|
|
if (mBullOB != NULL)
|
|
{
|
|
bullOB = mBullOB;
|
|
}
|
|
|
|
//
|
|
if (mBearOB != NULL)
|
|
{
|
|
bearOB = mBearOB;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
// Detect an Order Block in Vision ...
|
|
if (conditions.visionBullOB == NULL ||
|
|
conditions.visionBearOB == NULL)
|
|
{
|
|
//
|
|
result = DetectOrderBlocks(
|
|
NULL,
|
|
NULL,
|
|
conditions.visionBullOB,
|
|
conditions.visionBearOB,
|
|
cBar,
|
|
mVisionState //
|
|
);
|
|
if (!result)
|
|
{
|
|
//
|
|
conditions.Clean();
|
|
return result;
|
|
}
|
|
|
|
//
|
|
XCBullishOrderBlockObject *iBullOBObj;
|
|
conditions.visionBullOB.To(cTime);
|
|
result = mPOIDrawer.CreateBullishOrderBlock(
|
|
conditions.visionBullOB,
|
|
iBullOBObj //
|
|
);
|
|
if (result)
|
|
{
|
|
AddObjectIfNotExists(iBullOBObj);
|
|
}
|
|
|
|
//
|
|
XCBearishOrderBlockObject *iBearOBObj;
|
|
conditions.visionBearOB.To(cTime);
|
|
result = mPOIDrawer.CreateBearishOrderBlock(
|
|
conditions.visionBearOB,
|
|
iBearOBObj //
|
|
);
|
|
if (result)
|
|
{
|
|
AddObjectIfNotExists(iBearOBObj);
|
|
}
|
|
}
|
|
|
|
//
|
|
// Consolidation Order Blocks ...
|
|
if (conditions.consolidationBullOB == NULL ||
|
|
conditions.consolidationBearOB == NULL)
|
|
{
|
|
//
|
|
result = DetectOrderBlocks(
|
|
conditions.visionBullOB,
|
|
conditions.visionBearOB,
|
|
conditions.consolidationBullOB,
|
|
conditions.consolidationBearOB,
|
|
cBar,
|
|
mConsolidationState //
|
|
);
|
|
if (!result)
|
|
{
|
|
//
|
|
conditions.Clean();
|
|
return result;
|
|
}
|
|
|
|
//
|
|
XCBullishOrderBlockObject *iBullOBObj;
|
|
conditions.consolidationBullOB.To(cTime);
|
|
result = mPOIDrawer.CreateBullishOrderBlock(
|
|
conditions.consolidationBullOB,
|
|
iBullOBObj //
|
|
);
|
|
if (result)
|
|
{
|
|
AddObjectIfNotExists(iBullOBObj);
|
|
}
|
|
|
|
//
|
|
XCBearishOrderBlockObject *iBearOBObj;
|
|
conditions.consolidationBearOB.To(cTime);
|
|
result = mPOIDrawer.CreateBearishOrderBlock(
|
|
conditions.consolidationBearOB,
|
|
iBearOBObj //
|
|
);
|
|
if (result)
|
|
{
|
|
AddObjectIfNotExists(iBearOBObj);
|
|
}
|
|
}
|
|
|
|
//
|
|
msg = "OrderBlocks Detected ...";
|
|
Alert(msg);
|
|
|
|
//
|
|
// Detect Trigger Order Flow ...
|
|
if (!HasValidOrderFlow())
|
|
{
|
|
//
|
|
int samePivots = 40;
|
|
int requiredPivots = 10;
|
|
|
|
//
|
|
bool useVisionState = false;
|
|
bool useConsolidationState = false;
|
|
bool useVerificationState = false;
|
|
bool useAnalyseState = false;
|
|
bool useDecisionState = true;
|
|
bool useTriggerState = false;
|
|
|
|
//
|
|
DetectOrderFlow(
|
|
cIndex,
|
|
samePivots,
|
|
requiredPivots,
|
|
mTriggerCycleHelper,
|
|
mOrderFlow,
|
|
mOrderFlowDir,
|
|
//
|
|
// Filling Pivot State ...
|
|
useVisionState, // Use Vision State ...
|
|
useConsolidationState, // Use Consolidation State ...
|
|
useVerificationState, // Use Verification State ...
|
|
useAnalyseState, // Use Analyse State ...
|
|
useDecisionState, // Use Decision State ...
|
|
useTriggerState // Use Trigger State ...
|
|
);
|
|
|
|
//
|
|
result = HasValidOrderFlow();
|
|
if (!result)
|
|
{
|
|
//
|
|
conditions.Clean();
|
|
return result;
|
|
}
|
|
|
|
//
|
|
bool ignoreSwingHighs = true;
|
|
bool ignoreSwingLows = true;
|
|
bool ignoreSupportZones = true;
|
|
bool ignoreResistanceZones = true;
|
|
bool ignoreSupplyZones = true;
|
|
bool ignoreDemandZones = true;
|
|
bool ignoreBullishOrderBlocks = true;
|
|
bool ignoreBearishOrderBlocks = true;
|
|
bool ignoreBullishFairValueGaps = true;
|
|
bool ignoreBearishFairValueGaps = true;
|
|
bool ignoreBullishRejectionBars = true;
|
|
bool ignoreBearishRejectionBars = true;
|
|
bool ignoreBullishMomentumBars = true;
|
|
bool ignoreBearishMomentumBars = true;
|
|
|
|
//
|
|
RedrawOrderFlow(
|
|
false, // Force Clean ...
|
|
false, // Same Period ...
|
|
true, // Order Flow ...
|
|
true, // Order Flow State ...
|
|
false, // Only Last Order Flow ...
|
|
true, // Only Last Order Flow State ...
|
|
//
|
|
mOrderFlowDir, // Direction Force ...
|
|
ignoreSwingHighs,
|
|
ignoreSwingLows,
|
|
ignoreSupportZones,
|
|
ignoreResistanceZones,
|
|
ignoreSupplyZones,
|
|
ignoreDemandZones,
|
|
ignoreBullishOrderBlocks,
|
|
ignoreBearishOrderBlocks,
|
|
ignoreBullishFairValueGaps,
|
|
ignoreBearishFairValueGaps,
|
|
ignoreBullishRejectionBars,
|
|
ignoreBearishRejectionBars,
|
|
ignoreBullishMomentumBars,
|
|
ignoreBearishMomentumBars //
|
|
);
|
|
}
|
|
|
|
//
|
|
msg = "Found OrderFlow : " + (IsBullish(mOrderFlowDir) ? "Bullish" : "Berish");
|
|
Alert(msg);
|
|
|
|
//
|
|
// Check Market Conditions for
|
|
// Specified Structure ...
|
|
// ENUM_X_DIRECTION marketStructureDir = X_DIRECTION_NONE;
|
|
// result = conditions.HasDirection(
|
|
// marketStructureDir,
|
|
// cBar //
|
|
// );
|
|
// if (!result)
|
|
// {
|
|
// //
|
|
// conditions.Clean();
|
|
// return result;
|
|
// }
|
|
// msg = "Found Market Strucutre : " + (IsBullish(marketStructureDir) ? "Bullish" : "Berish");
|
|
// Alert(msg);
|
|
|
|
//
|
|
// conditions.marketStructureDir = marketStructureDir;
|
|
|
|
// //
|
|
// XPVPivot lastPivot;
|
|
// result = GetLastItem(
|
|
// lastPivot,
|
|
// mOrderFlow //
|
|
// );
|
|
// if (!result)
|
|
// {
|
|
// //
|
|
// conditions.Clean();
|
|
// return result;
|
|
// }
|
|
|
|
//
|
|
// Detect Last FVG ...
|
|
// XOHCL breakerBar;
|
|
// result = DetectLastBreakerBar(
|
|
// cBar,
|
|
// breakerBar,
|
|
// lastPivot,
|
|
// marketStructureDir //
|
|
// );
|
|
// if (!result)
|
|
// {
|
|
// //
|
|
// conditions.Clean();
|
|
// return result;
|
|
// }
|
|
// msg = "Found Breaker Bar: " + breakerBar.GetTag();
|
|
// Alert(msg);
|
|
|
|
// //
|
|
// // Detect Nearest Momentum or Rejection Bar ...
|
|
// XOHCL decisionBar;
|
|
// result = mDecisionCycleHelper.DetectNearestDecisionBar(
|
|
// decisionBar,
|
|
// marketStructureDir,
|
|
// cBar //
|
|
// );
|
|
// if (!result)
|
|
// {
|
|
// return result;
|
|
// }
|
|
// msg = "Found Decision Bar: " + decisionBar.GetTag();
|
|
// Alert(msg);
|
|
|
|
// //
|
|
// // Detect Nearest Sar Change ...
|
|
// XOHCL sarChangeBar;
|
|
// result = mTriggerCycleHelper.DetectNearestCSARChange(
|
|
// sarChangeBar,
|
|
// cBar //
|
|
// );
|
|
// if (!result)
|
|
// {
|
|
// //
|
|
// conditions.Clean();
|
|
// return result;
|
|
// }
|
|
// msg = "Found Sar Change Bar: " + sarChangeBar.GetTag();
|
|
// Alert(msg);
|
|
|
|
// //
|
|
// // Now we Hvae to Check Other Conditions ...
|
|
// result =
|
|
// // breakerBar.time > sarChangeBar.time &&
|
|
// // decisionBar.time > breakerBar.time;
|
|
// decisionBar.time > sarChangeBar.time;
|
|
// if (!result)
|
|
// {
|
|
// //
|
|
// conditions.Clean();
|
|
// return result;
|
|
// }
|
|
|
|
// //
|
|
// // Now we Have Check Direction Related Conditions ...
|
|
// if (IsBullish(marketStructureDir))
|
|
// {
|
|
// //
|
|
// result =
|
|
// // bid > decisionBar.high &&
|
|
// // bid > breakerBar.high &&
|
|
// bid > sarChangeBar.high &&
|
|
// bid > conditions.triggerConditions.xchsarConditions.cSars[0];
|
|
// }
|
|
// else
|
|
// {
|
|
// //
|
|
// result =
|
|
// // bid < decisionBar.low &&
|
|
// // bid < breakerBar.low &&
|
|
// bid < sarChangeBar.high &&
|
|
// bid < conditions.triggerConditions.xchsarConditions.cSars[0];
|
|
// }
|
|
// if (!result)
|
|
// {
|
|
// //
|
|
// conditions.Clean();
|
|
// return result;
|
|
// }
|
|
|
|
// //
|
|
// conditions.provider = "X121SMC";
|
|
// if (IsBullish(marketStructureDir))
|
|
// {
|
|
// //
|
|
// // conditions.sl = decisionBar.low;
|
|
// // conditions.sl = breakerBar.low;
|
|
// conditions.sl = conditions.triggerConditions.xchsarConditions.cSars[0];
|
|
// }
|
|
// else
|
|
// {
|
|
// //
|
|
// // conditions.sl = decisionBar.high;
|
|
// // conditions.sl = breakerBar.high;
|
|
// conditions.sl = conditions.triggerConditions.xchsarConditions.cSars[0];
|
|
// }
|
|
|
|
//////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
bool isSamePeaks =
|
|
//
|
|
conditions.triggerConditions.x121Conditions.peaksBuffer[0] == conditions.decisionConditions.x121Conditions.peaksBuffer[0] &&
|
|
conditions.decisionConditions.x121Conditions.peaksBuffer[0] == conditions.analyseConditions.x121Conditions.peaksBuffer[0]
|
|
// &&
|
|
// conditions.analyseConditions.x121Conditions.peaksBuffer[0] == conditions.verificationConditions.x121Conditions.peaksBuffer[0] &&
|
|
// conditions.verificationConditions.x121Conditions.peaksBuffer[0] == conditions.consolidationConditions.x121Conditions.peaksBuffer[0] &&
|
|
// conditions.consolidationConditions.x121Conditions.peaksBuffer[0] == conditions.visionConditions.x121Conditions.peaksBuffer[0]
|
|
//
|
|
;
|
|
if (isSamePeaks)
|
|
{
|
|
Print("isSamePeaks");
|
|
}
|
|
|
|
//
|
|
bool isSameVales =
|
|
//
|
|
conditions.triggerConditions.x121Conditions.valesBuffer[0] == conditions.decisionConditions.x121Conditions.valesBuffer[0] &&
|
|
conditions.decisionConditions.x121Conditions.valesBuffer[0] == conditions.analyseConditions.x121Conditions.valesBuffer[0]
|
|
// &&
|
|
// conditions.analyseConditions.x121Conditions.valesBuffer[0] == conditions.verificationConditions.x121Conditions.valesBuffer[0] &&
|
|
// conditions.verificationConditions.x121Conditions.valesBuffer[0] == conditions.consolidationConditions.x121Conditions.valesBuffer[0] &&
|
|
// conditions.consolidationConditions.x121Conditions.valesBuffer[0] == conditions.visionConditions.x121Conditions.valesBuffer[0]
|
|
//
|
|
;
|
|
if (isSameVales)
|
|
{
|
|
Print("isSameVales");
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
// Detect Valid Supply and Demand Zones ...
|
|
XCSupplyZone *supplyZone;
|
|
XCDemandZone *demandZone;
|
|
result = mTriggerCycleHelper
|
|
.DetectValisSupplyZone(
|
|
cBar,
|
|
supplyZone,
|
|
demandZone //
|
|
);
|
|
if (!result)
|
|
{
|
|
//
|
|
conditions.Clean();
|
|
return result;
|
|
}
|
|
|
|
//
|
|
supplyZone.To(cTime);
|
|
XCSupplyZoneObject *iSupplyZoneObj;
|
|
result = mPOIDrawer.CreateSupplyZone(
|
|
supplyZone,
|
|
iSupplyZoneObj //
|
|
);
|
|
if (!result)
|
|
{
|
|
//
|
|
conditions.Clean();
|
|
return result;
|
|
}
|
|
|
|
//
|
|
demandZone.To(cTime);
|
|
XCDemandZoneObject *iDemandZoneObj;
|
|
result = mPOIDrawer.CreateDemandZone(
|
|
demandZone,
|
|
iDemandZoneObj //
|
|
);
|
|
if (!result)
|
|
{
|
|
//
|
|
conditions.Clean();
|
|
return result;
|
|
}
|
|
|
|
//
|
|
Print("Supply and Demand Zone Created ...");
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
int consolidationsCount = mTriggerCycleHelper.CountConsolidationZones();
|
|
result = IsValidSize(consolidationsCount);
|
|
if (!result)
|
|
{
|
|
//
|
|
conditions.Clean();
|
|
return result;
|
|
}
|
|
XConsolidationZone consolidations[];
|
|
mTriggerCycleHelper.FillConsolidationZones(consolidations);
|
|
|
|
//
|
|
// Detect Bid inside Of Zones ...
|
|
bool hasSupply = false;
|
|
bool hasDemand = false;
|
|
XCSupplyZone *supplyZone;
|
|
XCDemandZone *demandZone;
|
|
bool isBidInsideZone = false;
|
|
XConsolidationZone bidContainsConsolidationZone;
|
|
for (int i = consolidationsCount - 1; i >= 0; i--)
|
|
{
|
|
//
|
|
XConsolidationZone iZone = consolidations[i];
|
|
|
|
//
|
|
// Check Supply or Demand Zone ...
|
|
hasSupply = iZone.HasSupplyZone(supplyZone);
|
|
hasDemand = iZone.HasDemandZone(demandZone);
|
|
|
|
//
|
|
result = hasSupply ||
|
|
hasDemand;
|
|
if (!result)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
//
|
|
// Check Bid inside Zone ...
|
|
if (hasSupply)
|
|
{
|
|
//
|
|
result = bid < supplyZone.Upper() &&
|
|
bid > supplyZone.Lower();
|
|
}
|
|
else
|
|
{
|
|
//
|
|
result = bid < demandZone.Upper() &&
|
|
bid > demandZone.Lower();
|
|
}
|
|
|
|
//
|
|
if (result)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
if (!result)
|
|
{
|
|
//
|
|
conditions.Clean();
|
|
return result;
|
|
}
|
|
|
|
//
|
|
if (hasSupply)
|
|
{
|
|
//
|
|
supplyZone.To(cTime);
|
|
XCSupplyZoneObject *iSupplyZoneObj;
|
|
result = mPOIDrawer.CreateSupplyZone(
|
|
supplyZone,
|
|
iSupplyZoneObj //
|
|
);
|
|
if (!result)
|
|
{
|
|
//
|
|
conditions.Clean();
|
|
return result;
|
|
}
|
|
}
|
|
|
|
//
|
|
if (hasDemand)
|
|
{
|
|
//
|
|
demandZone.To(cTime);
|
|
XCDemandZoneObject *iDemandZoneObj;
|
|
result = mPOIDrawer.CreateDemandZone(
|
|
demandZone,
|
|
iDemandZoneObj //
|
|
);
|
|
if (!result)
|
|
{
|
|
//
|
|
conditions.Clean();
|
|
return result;
|
|
}
|
|
}
|
|
|
|
//
|
|
Print("BID Inside Zone ...");
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
bool DetectCandlestic(
|
|
ENUM_X_DIRECTION &dir,
|
|
X121SMCStrategyConditions &conditions //
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
dir = X_DIRECTION_NONE;
|
|
|
|
//
|
|
string symbol = GetSymbol();
|
|
ENUM_TIMEFRAMES period = GetPeriod();
|
|
|
|
//
|
|
int cIndex = 1;
|
|
int pIndex = cIndex + 1;
|
|
|
|
//
|
|
XOHCL cBar;
|
|
result = cBar.Init(
|
|
symbol,
|
|
period,
|
|
cIndex //
|
|
);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
XOHCL pBar;
|
|
result = pBar.Init(
|
|
symbol,
|
|
period,
|
|
pIndex //
|
|
);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Momentum Bars ...
|
|
XCMomentumBar *cBullishMomentum = NULL;
|
|
XCMomentumBar *cBearishMomentum = NULL;
|
|
XCMomentumBar *pBullishMomentum = NULL;
|
|
XCMomentumBar *pBearishMomentum = NULL;
|
|
int bullishMomentumBarsCount = conditions.triggerConditions.state
|
|
.CountBullishMomentumBars();
|
|
int bearishMomentumBarsCount = conditions.triggerConditions.state
|
|
.CountBearishMomentumBars();
|
|
if (IsValidSize(bullishMomentumBarsCount))
|
|
{
|
|
//
|
|
cBullishMomentum = conditions.triggerConditions.state.bullishMomentumBars[bullishMomentumBarsCount - 1];
|
|
pBullishMomentum = conditions.triggerConditions.state.bullishMomentumBars[bullishMomentumBarsCount - 2];
|
|
}
|
|
if (IsValidSize(bearishMomentumBarsCount))
|
|
{
|
|
//
|
|
cBearishMomentum = conditions.triggerConditions.state.bearishMomentumBars[bearishMomentumBarsCount - 1];
|
|
pBearishMomentum = conditions.triggerConditions.state.bearishMomentumBars[bearishMomentumBarsCount - 2];
|
|
}
|
|
|
|
//
|
|
// Rejection Bars ...
|
|
XCRejectionBar *cBullishRejection = NULL;
|
|
XCRejectionBar *cBearishRejection = NULL;
|
|
XCRejectionBar *pBullishRejection = NULL;
|
|
XCRejectionBar *pBearishRejection = NULL;
|
|
int bullishRejectionBarsCount = conditions.triggerConditions.state
|
|
.CountBullishRejectionBars();
|
|
int bearishRejectionBarsCount = conditions.triggerConditions.state
|
|
.CountBearishRejectionBars();
|
|
if (IsValidSize(bullishRejectionBarsCount))
|
|
{
|
|
//
|
|
cBullishRejection = conditions.triggerConditions.state.bullishRejectionBars[bullishRejectionBarsCount - 1];
|
|
pBullishRejection = conditions.triggerConditions.state.bullishRejectionBars[bullishRejectionBarsCount - 2];
|
|
}
|
|
if (IsValidSize(bearishRejectionBarsCount))
|
|
{
|
|
//
|
|
cBearishRejection = conditions.triggerConditions.state.bearishRejectionBars[bearishRejectionBarsCount - 1];
|
|
pBearishRejection = conditions.triggerConditions.state.bearishRejectionBars[bearishRejectionBarsCount - 2];
|
|
}
|
|
|
|
//
|
|
bool isBullish =
|
|
//
|
|
// pBar is Rejection and cBar is Momentum ...
|
|
// pBar is Momentum and cBar is Rejection ...
|
|
// cBar is Momentum and Rejection ...
|
|
//
|
|
pBullishMomentum != NULL &&
|
|
pBullishMomentum.IsValid() &&
|
|
//
|
|
cBullishMomentum != NULL &&
|
|
cBullishMomentum.IsValid() &&
|
|
//
|
|
//
|
|
pBullishRejection != NULL &&
|
|
pBullishRejection.IsValid() &&
|
|
//
|
|
cBullishRejection != NULL &&
|
|
cBullishRejection.IsValid() &&
|
|
//
|
|
(
|
|
//
|
|
(pBar.time == pBullishRejection.BarTime() &&
|
|
cBar.time == cBullishMomentum.BarTime())
|
|
//
|
|
||
|
|
//
|
|
(pBar.time == pBullishMomentum.BarTime() &&
|
|
cBar.time == cBullishRejection.BarTime())
|
|
//
|
|
||
|
|
//
|
|
(cBar.time == cBullishMomentum.BarTime() &&
|
|
cBar.time == cBullishRejection.BarTime())
|
|
//
|
|
)
|
|
//
|
|
;
|
|
|
|
//
|
|
bool isBearish =
|
|
//
|
|
// pBar is Rejection and cBar is Momentum ...
|
|
// pBar is Momentum and cBar is Rejection ...
|
|
// cBar is Momentum and Rejection ...
|
|
//
|
|
pBearishMomentum != NULL &&
|
|
pBearishMomentum.IsValid() &&
|
|
//
|
|
cBearishMomentum != NULL &&
|
|
cBearishMomentum.IsValid() &&
|
|
//
|
|
//
|
|
pBearishRejection != NULL &&
|
|
pBearishRejection.IsValid() &&
|
|
//
|
|
cBearishRejection != NULL &&
|
|
cBearishRejection.IsValid() &&
|
|
//
|
|
(
|
|
//
|
|
(pBar.time == pBearishRejection.BarTime() &&
|
|
cBar.time == cBearishMomentum.BarTime())
|
|
//
|
|
||
|
|
//
|
|
(pBar.time == pBearishMomentum.BarTime() &&
|
|
cBar.time == cBearishRejection.BarTime())
|
|
//
|
|
||
|
|
//
|
|
(cBar.time == cBearishMomentum.BarTime() &&
|
|
cBar.time == cBearishRejection.BarTime())
|
|
//
|
|
)
|
|
//
|
|
;
|
|
|
|
//
|
|
result = isBullish ||
|
|
isBearish;
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
dir =
|
|
isBullish
|
|
? X_DIRECTION_BULLISH
|
|
: X_DIRECTION_BEARISH;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/**
|
|
* Detect Nearest Supply/Demand Zones ...
|
|
*
|
|
* @param bar: XOHCL instance, Start Bar ...
|
|
*
|
|
* @return ( bool )
|
|
*/
|
|
bool DetectValisSupplyZone(
|
|
XOHCL &bar,
|
|
XCSupplyZone *&supplyZone,
|
|
XCDemandZone *&demandZone //
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
result = bar.IsValid();
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
int index = bar.Index();
|
|
|
|
//
|
|
double bid = GetBid(bar.symbol);
|
|
double ask = GetAsk(bar.symbol);
|
|
|
|
//
|
|
// Retrieve X121 Cnditions ...
|
|
int conditionsLoopback = 10;
|
|
X121Conditions x121Conditions;
|
|
result = mX121Helper.GetConditions(
|
|
x121Conditions,
|
|
index,
|
|
conditionsLoopback //
|
|
);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
int validPeaksCount = ArraySize(x121Conditions.validPeaksBuffer);
|
|
int validValesCount = ArraySize(x121Conditions.validValesBuffer);
|
|
|
|
//
|
|
XPOIState state;
|
|
ENUM_XPOI_EVENTS events[];
|
|
mPOIDetector.Update(events);
|
|
mPOIDetector.GetState(state);
|
|
result = state.IsValid() &&
|
|
state.HasChild();
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Supply Zones ...
|
|
XCSupplyZone *supplies[];
|
|
int suppliesCount = state.CountSupplyZones();
|
|
|
|
//
|
|
// Select Bar Validated Supply Zones ...
|
|
if (IsValidSize(suppliesCount))
|
|
{
|
|
//
|
|
for (int i = 0; i < suppliesCount; i++)
|
|
{
|
|
//
|
|
XCSupplyZone *iZone = state.supplyZones[i];
|
|
|
|
//
|
|
// Check Zone is Valid For Bar ...
|
|
bool isValid = bar.high < iZone.Lower() &&
|
|
ask < iZone.Lower() &&
|
|
bid < iZone.Lower();
|
|
if (isValid)
|
|
{
|
|
//
|
|
Add(
|
|
iZone,
|
|
supplies //
|
|
);
|
|
}
|
|
}
|
|
}
|
|
suppliesCount = ArraySize(supplies);
|
|
|
|
//
|
|
// Select Valid Peaks Filtered Supplies ...
|
|
if (IsValidSize(suppliesCount))
|
|
{
|
|
//
|
|
// Check Valid Peaks ...
|
|
XCSupplyZone *tmp[];
|
|
if (IsValidSize(validPeaksCount))
|
|
{
|
|
//
|
|
for (int i = 0; i < suppliesCount; i++)
|
|
{
|
|
//
|
|
XCSupplyZone *iZone = supplies[i];
|
|
|
|
//
|
|
for (int j = 0; j < validPeaksCount; j++)
|
|
{
|
|
//
|
|
double value = x121Conditions.validPeaksBuffer[j];
|
|
|
|
//
|
|
// Check Valid Peaks in Zone ...
|
|
bool isZoneContainsValidValue =
|
|
value >= iZone.Lower() &&
|
|
value <= iZone.Upper();
|
|
if (isZoneContainsValidValue)
|
|
{
|
|
//
|
|
Add(
|
|
iZone,
|
|
tmp //
|
|
);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
Clean(supplies);
|
|
Copy(
|
|
tmp,
|
|
supplies //
|
|
);
|
|
}
|
|
suppliesCount = ArraySize(supplies);
|
|
|
|
//
|
|
// Select Nearest Supply Zone ...
|
|
if (IsValidSize(suppliesCount))
|
|
{
|
|
//
|
|
// Check Nearest Supplies ...
|
|
for (int i = 0; i < suppliesCount; i++)
|
|
{
|
|
//
|
|
XCSupplyZone *iZone = supplies[i];
|
|
if (supplyZone == NULL)
|
|
{
|
|
supplyZone = iZone;
|
|
}
|
|
else
|
|
{
|
|
//
|
|
bool canChange =
|
|
iZone.Lower() < supplyZone.Lower();
|
|
if (canChange)
|
|
{
|
|
supplyZone = iZone;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Demand Zones ...
|
|
XCDemandZone *demands[];
|
|
int demandsCount = state.CountDemandZones();
|
|
|
|
//
|
|
// Select Bar Validated Demand Zones ...
|
|
if (IsValidSize(demandsCount))
|
|
{
|
|
//
|
|
for (int i = 0; i < demandsCount; i++)
|
|
{
|
|
//
|
|
XCDemandZone *iZone = state.demandZones[i];
|
|
|
|
//
|
|
// Check Zone is Valid For Bar ...
|
|
bool isValid = bar.low > iZone.Upper() &&
|
|
ask > iZone.Upper() &&
|
|
bid > iZone.Upper();
|
|
if (isValid)
|
|
{
|
|
//
|
|
Add(
|
|
iZone,
|
|
demands //
|
|
);
|
|
}
|
|
}
|
|
}
|
|
demandsCount = ArraySize(demands);
|
|
|
|
//
|
|
// Select Valid Vales Filtered Demands ...
|
|
if (IsValidSize(demandsCount))
|
|
{
|
|
//
|
|
// Check Valid Vales ...
|
|
XCDemandZone *tmp[];
|
|
if (IsValidSize(validValesCount))
|
|
{
|
|
//
|
|
for (int i = 0; i < demandsCount; i++)
|
|
{
|
|
//
|
|
XCDemandZone *iZone = demands[i];
|
|
|
|
//
|
|
for (int j = 0; j < validValesCount; j++)
|
|
{
|
|
//
|
|
double value = x121Conditions.validValesBuffer[j];
|
|
|
|
//
|
|
// Check Valid Peaks in Zone ...
|
|
bool isZoneContainsValidValue =
|
|
value >= iZone.Lower() &&
|
|
value <= iZone.Upper();
|
|
if (isZoneContainsValidValue)
|
|
{
|
|
//
|
|
Add(
|
|
iZone,
|
|
tmp //
|
|
);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
Clean(demands);
|
|
Copy(
|
|
tmp,
|
|
demands //
|
|
);
|
|
}
|
|
demandsCount = ArraySize(demands);
|
|
|
|
//
|
|
// Select Nearest Demand Zone ...
|
|
if (IsValidSize(demandsCount))
|
|
{
|
|
//
|
|
// Check Nearest Demands ...
|
|
for (int i = 0; i < demandsCount; i++)
|
|
{
|
|
//
|
|
XCDemandZone *iZone = demands[i];
|
|
if (demandZone == NULL)
|
|
{
|
|
demandZone = iZone;
|
|
}
|
|
else
|
|
{
|
|
//
|
|
bool canChange =
|
|
iZone.Upper() > demandZone.Upper();
|
|
if (canChange)
|
|
{
|
|
demandZone = iZone;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Validate Founded Zones ...
|
|
result = (supplyZone != NULL &&
|
|
supplyZone.IsValid()) &&
|
|
(demandZone != NULL &&
|
|
demandZone.IsValid());
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
CustomStateDrawing(
|
|
conditions.consolidationConditions.state,
|
|
false, //
|
|
X_DIRECTION_NONE,
|
|
false, // ignoreSwingHighs
|
|
false, // ignoreSwingLows
|
|
false, // ignoreSupportZones
|
|
false, // ignoreResistanceZones
|
|
false, // ignoreSupplyZones
|
|
false, // ignoreDemandZones
|
|
true, // ignoreBullishOrderBlocks
|
|
true, // ignoreBearishOrderBlocks
|
|
true, // ignoreBullishFairValueGaps
|
|
true, // ignoreBearishFairValueGaps
|
|
true, // ignoreBullishRejectionBars
|
|
true, // ignoreBearishRejectionBars
|
|
true, // ignoreBullishMomentumBars
|
|
true // ignoreBearishMomentumBars
|
|
);
|
|
|
|
//
|
|
// TODO: Remove ...
|
|
// Draw ...
|
|
if (hasVisionSupplyZone && visionSupplyZone != NULL)
|
|
{
|
|
//
|
|
visionSupplyZone.To(TimeCurrent());
|
|
XCSupplyZoneObject *iObj;
|
|
bool isCreated = mPOIDrawer.CreateSupplyZone(
|
|
visionSupplyZone,
|
|
iObj //
|
|
);
|
|
if (isCreated)
|
|
{
|
|
//
|
|
iObj.ZoneWidth(4);
|
|
iObj.ZoneColor(clrMagenta);
|
|
AddObjectIfNotExists(iObj);
|
|
}
|
|
}
|
|
|
|
//
|
|
// TODO: Remove ...
|
|
// Draw ...
|
|
if (hasVisionDemandZone && visionDemandZone != NULL)
|
|
{
|
|
//
|
|
visionDemandZone.To(TimeCurrent());
|
|
XCDemandZoneObject *iObj;
|
|
bool isCreated = mPOIDrawer.CreateDemandZone(
|
|
visionDemandZone,
|
|
iObj //
|
|
);
|
|
if (isCreated)
|
|
{
|
|
//
|
|
iObj.ZoneWidth(4);
|
|
iObj.ZoneColor(clrAqua);
|
|
AddObjectIfNotExists(iObj);
|
|
}
|
|
}
|
|
|
|
//
|
|
if (result)
|
|
{
|
|
ClearDraws();
|
|
}
|
|
|
|
|
|
//
|
|
// TODO: Remove this ...
|
|
// Draw ...
|
|
if (hasConsolidationSupportZone &&
|
|
consolidationSupportZone != NULL)
|
|
{
|
|
//
|
|
consolidationSupportZone.To(TimeCurrent());
|
|
XCSupportZoneObject *iObj;
|
|
bool isCreated = mPOIDrawer.CreateSupportZone(
|
|
consolidationSupportZone,
|
|
iObj //
|
|
);
|
|
if (isCreated)
|
|
{
|
|
AddObjectIfNotExists(iObj);
|
|
}
|
|
}
|
|
|
|
//
|
|
// TODO: Remove this ...
|
|
// Draw ...
|
|
if (hasConsolidationResistanceZone &&
|
|
consolidationResistanceZone != NULL)
|
|
{
|
|
//
|
|
consolidationResistanceZone.To(TimeCurrent());
|
|
XCResistanceZoneObject *iObj;
|
|
bool isCreated = mPOIDrawer.CreateResistanceZone(
|
|
consolidationResistanceZone,
|
|
iObj //
|
|
);
|
|
if (isCreated)
|
|
{
|
|
AddObjectIfNotExists(iObj);
|
|
}
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
XCSwing *swingLow = NULL;
|
|
XCSwing *swingHigh = NULL;
|
|
bool isSwingLowRejected = false;
|
|
bool isSwingHighRejected = false;
|
|
int swingLowsCount = decisionConditions.state.CountSwingLows();
|
|
int swingHighsCount = decisionConditions.state.CountSwingHighs();
|
|
if (IsValidSize(swingLowsCount))
|
|
{
|
|
swingLow = decisionConditions.state.swingLows[swingLowsCount - 1];
|
|
}
|
|
if (IsValidSize(swingHighsCount))
|
|
{
|
|
swingHigh = decisionConditions.state.swingHighs[swingHighsCount - 1];
|
|
}
|
|
|
|
//
|
|
isSwingLowRejected = swingLow != NULL &&
|
|
swingLow.IsValid() &&
|
|
decisionCBar.low > swingLow.GetValue();
|
|
|
|
//
|
|
isSwingHighRejected = swingHigh != NULL &&
|
|
swingHigh.IsValid() &&
|
|
decisionCBar.high < swingHigh.GetValue();
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////
|
|
|