4781 lines
124 KiB
Plaintext
4781 lines
124 KiB
Plaintext
///////////////////////////////////////////////////////
|
|
//
|
|
// SaherElm IT Center MQL5 Class Library
|
|
// --------------------------------------
|
|
// Name: XC121SMCCycleHelper
|
|
// Description: provides all based classes for use ...
|
|
//
|
|
//
|
|
// Maintainer:
|
|
// ------------
|
|
// Hadi Khazaee Asl (hadi_khazaee_asl@yahoo.com)
|
|
//
|
|
//////////////////////////////////////////////////////
|
|
//
|
|
// Global Properties ...
|
|
#property library
|
|
#property copyright "Copyright 2023, SaherElm IT Center"
|
|
#property link "https://www.saherelm.ir"
|
|
#property version "1.00"
|
|
#property strict
|
|
|
|
//
|
|
// Imports ...
|
|
#include "../../Classes/x-saherelm.x-bar.analyser.class.mq5"
|
|
#include "../../Classes/x-saherelm.x-poi.class.mq5"
|
|
#include "../Libraries/x-121.smc.lib.mq5"
|
|
|
|
//
|
|
// Definitions ...
|
|
|
|
//
|
|
// Implementations ...
|
|
|
|
//
|
|
// Cycles Enumeration ...
|
|
enum ENUM_X_CYCLES
|
|
{
|
|
X_CYCLE_NONE,
|
|
X_CYCLE_TRIGGER,
|
|
X_CYCLE_DECISION,
|
|
X_CYCLE_ANALYSE,
|
|
X_CYCLE_VERIFICATION,
|
|
X_CYCLE_CONSOLIDATION,
|
|
X_CYCLE_VISION,
|
|
};
|
|
|
|
//
|
|
// String Representation of Cycles Enumeration ...
|
|
string ToString(ENUM_X_CYCLES value)
|
|
{
|
|
//
|
|
string result = EnumToString(value);
|
|
|
|
//
|
|
StringReplace(result, "X_CYCLE_", "");
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Validate a Cycle ...
|
|
bool IsValid(ENUM_X_CYCLES value)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
result =
|
|
value != X_CYCLE_NONE;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Cycle Events Enumeration ...
|
|
enum ENUM_X_CYCLE_EVENTS
|
|
{
|
|
SAR_CHANGE_DETECTED,
|
|
NEW_PEAK_DETECTED,
|
|
NEW_VALE_DETECTED,
|
|
PIVOT_POINT_DETECTED,
|
|
VWAP_ORDER_CHANGE_ETECTED,
|
|
VWAP_STATE_CHANGE_DETCTED,
|
|
CONSOLIDATION_BREAKED_DETECTED,
|
|
PEAK_PIVOT_STARTED,
|
|
PEAK_PIVOT_ENDED,
|
|
VALE_PIVOT_STARTED,
|
|
VALE_PIVOT_ENDED,
|
|
};
|
|
|
|
//
|
|
// Cycle Helper ...
|
|
class XC121SMCCycleHelper : public XCBase
|
|
{
|
|
//
|
|
public:
|
|
//
|
|
// Props ...
|
|
|
|
//
|
|
// X121 ...
|
|
XCX121Helper *mX121Helper;
|
|
|
|
//
|
|
// POI Detector ...
|
|
XCPOIDrawer *mPOIDrawer;
|
|
XCPOIDetector *mPOIDetector;
|
|
|
|
//
|
|
// Bar Analyser
|
|
XCBarAnalyser *mBarAnalyser;
|
|
|
|
//
|
|
// Constructor(s) ...
|
|
XC121SMCCycleHelper()
|
|
{
|
|
Default();
|
|
}
|
|
|
|
//
|
|
// Deconstructor ...
|
|
~XC121SMCCycleHelper()
|
|
{
|
|
DeInit();
|
|
}
|
|
|
|
//
|
|
// Getter/Setter(s) ...
|
|
|
|
//
|
|
// Actions ...
|
|
|
|
/**
|
|
* Initialize ...
|
|
*
|
|
* @param symbol: String ...
|
|
* @param period: ENUM_TIMEFRAMES member ...
|
|
* @param x121Inputs: X121Inputs instance ...
|
|
*
|
|
* @return ( bool )
|
|
*/
|
|
bool Init(
|
|
string symbol,
|
|
ENUM_TIMEFRAMES period,
|
|
X121Inputs &x121Inputs,
|
|
int requiredPOIs = 50 //
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
if (requiredPOIs < 0)
|
|
{
|
|
requiredPOIs = 0;
|
|
}
|
|
|
|
//
|
|
result = IsValid(symbol) &&
|
|
IsValid(period);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
mSymbol = symbol;
|
|
mPeriod = period;
|
|
|
|
//
|
|
// X121 ...
|
|
mX121Helper = new XCX121Helper();
|
|
result = mX121Helper.Init(
|
|
symbol,
|
|
period,
|
|
x121Inputs //
|
|
);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
mPOIDetector = new XCPOIDetector(
|
|
symbol,
|
|
period //
|
|
);
|
|
mPOIDetector.MaxRequiredPOIs(requiredPOIs);
|
|
|
|
//
|
|
int maxLoopbackBars = mPOIDetector.MaxAllowedLoopbackForInit();
|
|
int periodSeconds = PeriodSeconds(period);
|
|
if (periodSeconds > PeriodSeconds(PERIOD_M15))
|
|
{
|
|
//
|
|
int multiplier = periodSeconds / PeriodSeconds(PERIOD_M15);
|
|
|
|
//
|
|
if (multiplier >= 1)
|
|
{
|
|
maxLoopbackBars *= 2;
|
|
}
|
|
}
|
|
mPOIDetector.MaxAllowedLoopbackForInit(maxLoopbackBars);
|
|
mPOIDetector.Init();
|
|
|
|
//
|
|
// Initialize Bar Analyser Class Instance ...
|
|
mBarAnalyser = new XCBarAnalyser();
|
|
|
|
//
|
|
// Initial and Configure POI Drawer if Required ...
|
|
mPOIDrawer = new XCPOIDrawer();
|
|
mPOIDrawer.ChartIdentification(0);
|
|
mPOIDrawer.SubWindowIdentification(0);
|
|
|
|
//
|
|
mPOIDrawer.DemandZoneFill(false);
|
|
mPOIDrawer.SupplyZoneFill(false);
|
|
mPOIDrawer.BullishFVGFill(false);
|
|
mPOIDrawer.BearishFVGFill(false);
|
|
mPOIDrawer.SupportZoneFill(false);
|
|
mPOIDrawer.ResistanceZoneFill(false);
|
|
mPOIDrawer.BullishOrderBlockFill(false);
|
|
mPOIDrawer.BearishOrderBlockFill(false);
|
|
|
|
//
|
|
// Set Chart Style ...
|
|
ApplyChartStyle();
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Retrieve Symbol ...
|
|
*
|
|
* @return ( string )
|
|
*/
|
|
string GetSymbol()
|
|
{
|
|
return mSymbol;
|
|
}
|
|
|
|
/**
|
|
* Retrieve TimeFrame (Period) ...
|
|
*
|
|
* @return ( ENUM_TIMEFRAMES )
|
|
*/
|
|
ENUM_TIMEFRAMES GetPeriod()
|
|
{
|
|
return mPeriod;
|
|
}
|
|
|
|
/**
|
|
* Get Specified Bar ...
|
|
*
|
|
* @param source: XOHCL instance, Source Bar ...
|
|
* @param bar: XOHCL instance, Dest Bar ...
|
|
*
|
|
* @return ( bool )
|
|
*/
|
|
bool GetBar(
|
|
XOHCL &source,
|
|
XOHCL &bar //
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
bar.Clean();
|
|
|
|
//
|
|
string symbol = GetSymbol();
|
|
ENUM_TIMEFRAMES period = GetPeriod();
|
|
|
|
//
|
|
result =
|
|
IsValid(symbol) &&
|
|
IsValid(period) &&
|
|
source.IsValid();
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
int index = iBarShift(
|
|
symbol,
|
|
period,
|
|
source.time //
|
|
);
|
|
result = bar.Init(
|
|
symbol,
|
|
period,
|
|
index //
|
|
);
|
|
if (!result)
|
|
{
|
|
//
|
|
bar.Clean();
|
|
return result;
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Retrieve Specified Bar ...
|
|
*
|
|
* @param bar: XOHCL instance ...
|
|
* @param index: Integer ...
|
|
*
|
|
* @return ( bool )
|
|
*/
|
|
bool GetBar(
|
|
XOHCL &bar,
|
|
int index = 0 //
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
bar.Clean();
|
|
|
|
//
|
|
if (index < 0)
|
|
{
|
|
index = 0;
|
|
}
|
|
|
|
//
|
|
string symbol = GetSymbol();
|
|
ENUM_TIMEFRAMES period = GetPeriod();
|
|
|
|
//
|
|
result = bar.Init(
|
|
symbol,
|
|
period,
|
|
index //
|
|
);
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Retrieve Specified Bar ...
|
|
*
|
|
* @param bar: XOHCL instance ...
|
|
* @param time: Datetime ...
|
|
*
|
|
* @return ( bool )
|
|
*/
|
|
bool GetBar(
|
|
XOHCL &bar,
|
|
datetime time = NULL //
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
int index = GetBarIndex(time);
|
|
result = GetBar(bar,
|
|
index //
|
|
);
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Retrieve Specified Time Bar Index ...
|
|
*
|
|
* @param time: DateTime ...
|
|
*
|
|
* @return ( int )
|
|
*/
|
|
int GetBarIndex(datetime time = NULL)
|
|
{
|
|
//
|
|
int result = -1;
|
|
|
|
//
|
|
time = NormalizeTime(time);
|
|
|
|
//
|
|
string symbol = GetSymbol();
|
|
ENUM_TIMEFRAMES period = GetPeriod();
|
|
|
|
//
|
|
result = iBarShift(
|
|
symbol,
|
|
period,
|
|
time //
|
|
);
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Retrieve Cycle Conditions ...
|
|
*
|
|
* @param events: ENUM_X_CYCLE_EVENTS member, Array ...
|
|
* @param conditions: X121SMCCycleConditions instance ...
|
|
* @param barIndex: Integer ...
|
|
* @param loopback: Integer ...
|
|
*
|
|
* @return ( bool )
|
|
*/
|
|
bool GetConditions(
|
|
ENUM_X_CYCLE_EVENTS &events[],
|
|
ENUM_XPOI_EVENTS &poiEvents[],
|
|
X121SMCCycleConditions &conditions,
|
|
int barIndex = 0,
|
|
int loopback = 7 //
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
if (barIndex < 0)
|
|
{
|
|
barIndex = 0;
|
|
}
|
|
|
|
//
|
|
if (loopback < 5)
|
|
{
|
|
loopback = 5;
|
|
}
|
|
|
|
//
|
|
Clean(events);
|
|
Clean(poiEvents);
|
|
conditions.Clean();
|
|
|
|
//
|
|
result = mX121Helper.GetConditions(
|
|
conditions.x121Conditions,
|
|
barIndex,
|
|
loopback //
|
|
);
|
|
if (!result)
|
|
{
|
|
//
|
|
conditions.Clean();
|
|
return result;
|
|
}
|
|
|
|
//
|
|
mPOIDetector.Update(poiEvents);
|
|
mPOIDetector.GetState(conditions.state);
|
|
|
|
//
|
|
conditions.symbol = GetSymbol();
|
|
conditions.period = GetPeriod();
|
|
conditions.time = TimeCurrent();
|
|
|
|
//
|
|
// Update();
|
|
|
|
//
|
|
result = conditions.IsValid();
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
bool GeneratePVBox(
|
|
XBoxZone &box,
|
|
int barIndex = 0 //
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
if (barIndex < 0)
|
|
{
|
|
barIndex = 0;
|
|
}
|
|
|
|
//
|
|
box.Clean();
|
|
box.symbol = GetSymbol();
|
|
box.period = GetPeriod();
|
|
|
|
//
|
|
int index = barIndex;
|
|
|
|
//
|
|
// Peak ...
|
|
datetime peaksSameFrom = NULL;
|
|
double peak = mX121Helper.xpvHelper.GetPeak(index);
|
|
double prevPeak = mX121Helper.xpvHelper.GetPeak(index + 1);
|
|
bool startsByPeak = peak == prevPeak;
|
|
|
|
//
|
|
// Vale ...
|
|
datetime valesSameFrom = NULL;
|
|
double vale = mX121Helper.xpvHelper.GetVale(index);
|
|
double prevVale = mX121Helper.xpvHelper.GetVale(index + 1);
|
|
bool startsByVale =
|
|
!startsByPeak &&
|
|
vale == prevVale;
|
|
|
|
//
|
|
bool canBreak = false;
|
|
while (!canBreak)
|
|
{
|
|
//
|
|
index++;
|
|
|
|
//
|
|
datetime cTime = iTime(
|
|
box.symbol,
|
|
box.period,
|
|
index //
|
|
);
|
|
|
|
//
|
|
// Peak ...
|
|
double iPeak = mX121Helper.xpvHelper.GetPeak(index);
|
|
|
|
//
|
|
// Vale ...
|
|
double iVale = mX121Helper.xpvHelper.GetVale(index);
|
|
|
|
//
|
|
// Start By Peak or Value ...
|
|
bool isSame = false;
|
|
if (startsByPeak)
|
|
{
|
|
//
|
|
isSame = iPeak == peak;
|
|
bool canSetVale = vale == 0
|
|
? true
|
|
: iVale > vale;
|
|
if (canSetVale)
|
|
{
|
|
vale = iVale;
|
|
}
|
|
}
|
|
else if (startsByVale)
|
|
{
|
|
//
|
|
isSame = iVale == vale;
|
|
bool canSetPeak = peak == 0
|
|
? true
|
|
: iPeak < peak;
|
|
if (canSetPeak)
|
|
{
|
|
peak = iPeak;
|
|
}
|
|
}
|
|
|
|
//
|
|
if (isSame)
|
|
{
|
|
//
|
|
box.from = cTime;
|
|
box.upper = peak;
|
|
box.lower = vale;
|
|
}
|
|
else if (IsValid(box.from))
|
|
{
|
|
//
|
|
// Complete Box ...
|
|
box.to = iTime(
|
|
box.symbol,
|
|
box.period,
|
|
barIndex //
|
|
);
|
|
|
|
//
|
|
box.type = "XPVBox";
|
|
box.dir = startsByPeak
|
|
? X_DIRECTION_BEARISH
|
|
: startsByVale
|
|
? X_DIRECTION_BULLISH
|
|
: X_DIRECTION_NONE;
|
|
}
|
|
|
|
//
|
|
canBreak = !isSame;
|
|
}
|
|
|
|
//
|
|
result = box.IsValid();
|
|
if (!result)
|
|
{
|
|
box.Clean();
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
int DetectRejections(
|
|
XBoxZone &rejections[],
|
|
int barIndex = 0,
|
|
bool forceBarType = true,
|
|
bool forceFiboPressure = true,
|
|
bool forceUnUsedRejections = true,
|
|
int maxAllowedLoopback = 587 //
|
|
)
|
|
{
|
|
//
|
|
int result = 0;
|
|
|
|
//
|
|
// Normalize Args ...
|
|
Clean(rejections);
|
|
|
|
//
|
|
if (barIndex < 0)
|
|
{
|
|
barIndex = 0;
|
|
}
|
|
|
|
//
|
|
int idx = -1;
|
|
bool has = false;
|
|
for (int i = barIndex + 1; i < barIndex + maxAllowedLoopback; i++)
|
|
{
|
|
//
|
|
// Init Indexed Bar ...
|
|
XOHCL iBar;
|
|
XOHCL iCBar;
|
|
XOHCL iPBar;
|
|
has = GetBar(iBar, i);
|
|
has =
|
|
has &&
|
|
iBar.GetPreviousBar(iCBar);
|
|
has =
|
|
has &&
|
|
iCBar.GetPreviousBar(iPBar);
|
|
if (!has)
|
|
{
|
|
//
|
|
iBar.Clean();
|
|
iCBar.Clean();
|
|
iPBar.Clean();
|
|
break;
|
|
}
|
|
|
|
//
|
|
// Check CBar Bullish Fibo Pressure ...
|
|
bool cBarHasBullishFiboPressure =
|
|
mBarAnalyser
|
|
.HasFiboPressure(
|
|
iCBar,
|
|
X_DIRECTION_BULLISH,
|
|
X_FIBO_LEVEL_382 //
|
|
);
|
|
|
|
//
|
|
// Check CBar Bearish Fibo Pressure ...
|
|
bool cBarHasBearishFiboPressure =
|
|
mBarAnalyser
|
|
.HasFiboPressure(
|
|
iCBar,
|
|
X_DIRECTION_BEARISH,
|
|
X_FIBO_LEVEL_382 //
|
|
);
|
|
|
|
//
|
|
// Check Bar is Bullish Rejection Swing ...
|
|
bool isBullishRejection =
|
|
//
|
|
iCBar.low < iBar.low &&
|
|
iCBar.low < iPBar.low &&
|
|
//
|
|
iCBar.low < iCBar.GetDown() &&
|
|
iCBar.GetLowShadow() > iCBar.GetBody() &&
|
|
iCBar.GetLowShadow() > iCBar.GetHighShadow()
|
|
//
|
|
;
|
|
|
|
//
|
|
// Check Bar is Bearish Rejection Swing ...
|
|
bool isBearishRejection =
|
|
//
|
|
iCBar.high > iBar.high &&
|
|
iCBar.high > iPBar.high &&
|
|
//
|
|
iCBar.high > iCBar.GetUp() &&
|
|
iCBar.GetHighShadow() > iCBar.GetBody() &&
|
|
iCBar.GetHighShadow() > iCBar.GetLowShadow()
|
|
//
|
|
;
|
|
|
|
//
|
|
// Apply Fibo Pressure ...
|
|
if (forceFiboPressure)
|
|
{
|
|
//
|
|
isBullishRejection =
|
|
isBullishRejection &&
|
|
cBarHasBullishFiboPressure;
|
|
|
|
//
|
|
isBearishRejection =
|
|
isBearishRejection &&
|
|
cBarHasBearishFiboPressure;
|
|
}
|
|
|
|
//
|
|
// Apply Force Bar Type ...
|
|
if (forceBarType)
|
|
{
|
|
//
|
|
isBullishRejection =
|
|
isBullishRejection &&
|
|
iCBar.IsBullish();
|
|
|
|
//
|
|
isBearishRejection =
|
|
isBearishRejection &&
|
|
iCBar.IsBearish();
|
|
}
|
|
|
|
//
|
|
// Summarize Result ...
|
|
has = isBullishRejection ||
|
|
isBearishRejection;
|
|
if (has)
|
|
{
|
|
//
|
|
XBoxZone iBox;
|
|
|
|
//
|
|
iBox.to = iBar.time;
|
|
iBox.from = iCBar.time;
|
|
iBox.period = iBar.period;
|
|
iBox.symbol = iBar.symbol;
|
|
|
|
//
|
|
iBox.dir =
|
|
isBullishRejection
|
|
? X_DIRECTION_BULLISH
|
|
: X_DIRECTION_BEARISH;
|
|
|
|
//
|
|
iBox.upper =
|
|
isBullishRejection
|
|
? iCBar.GetDown()
|
|
: iCBar.high;
|
|
|
|
//
|
|
iBox.lower =
|
|
isBullishRejection
|
|
? iCBar.low
|
|
: iCBar.GetUp();
|
|
|
|
//
|
|
iBox.type =
|
|
isBullishRejection
|
|
? "XSwingLow"
|
|
: "XSwingHigh";
|
|
|
|
//
|
|
// Validate Box ...
|
|
has = iBox.IsValid();
|
|
if (has)
|
|
{
|
|
//
|
|
// Apply Force Unused Rejections ...
|
|
if (forceUnUsedRejections)
|
|
{
|
|
//
|
|
has = !IsBoxBreaked(
|
|
iBox,
|
|
iCBar.Index() + 1,
|
|
barIndex //
|
|
);
|
|
}
|
|
|
|
//
|
|
if (has)
|
|
{
|
|
//
|
|
idx = FindIndex(
|
|
iBox,
|
|
rejections //
|
|
);
|
|
has = !IsValidIndex(idx);
|
|
if (has)
|
|
{
|
|
//
|
|
AddRef(
|
|
iBox,
|
|
rejections //
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
iBox.Clean();
|
|
}
|
|
|
|
//
|
|
iBar.Clean();
|
|
iCBar.Clean();
|
|
iPBar.Clean();
|
|
}
|
|
|
|
//
|
|
result = ArraySize(rejections);
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
datetime GetNearestCloseOverX3MAFast(
|
|
XOHCL &bar,
|
|
int maxAllowedBars = 20 //
|
|
)
|
|
{
|
|
//
|
|
datetime result = NULL;
|
|
|
|
//
|
|
if (!bar.IsValid())
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
bool has = false;
|
|
int idx = bar.Index();
|
|
int start = idx;
|
|
int end = start + maxAllowedBars;
|
|
bool canContinue = true;
|
|
while (canContinue)
|
|
{
|
|
//
|
|
XOHCL iBar;
|
|
has = iBar.Init(
|
|
bar.symbol,
|
|
bar.period,
|
|
start //
|
|
);
|
|
if (!has)
|
|
{
|
|
//
|
|
iBar.Clean();
|
|
break;
|
|
}
|
|
|
|
//
|
|
double iFast = mX121Helper
|
|
.x3maHelper
|
|
.GetX3MaFast(start);
|
|
|
|
//
|
|
has = iBar.close > iFast &&
|
|
iBar.open < iFast;
|
|
if (has)
|
|
{
|
|
result = iBar.time;
|
|
}
|
|
|
|
//
|
|
canContinue =
|
|
start < end &&
|
|
!IsValid(result);
|
|
|
|
//
|
|
start++;
|
|
|
|
//
|
|
iBar.Clean();
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
datetime GetNearestCloseUnderX3MAFast(
|
|
XOHCL &bar,
|
|
int maxAllowedBars = 20 //
|
|
)
|
|
{
|
|
//
|
|
datetime result = NULL;
|
|
|
|
//
|
|
if (!bar.IsValid())
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
bool has = false;
|
|
int idx = bar.Index();
|
|
int start = idx;
|
|
int end = start + maxAllowedBars;
|
|
bool canContinue = true;
|
|
while (canContinue)
|
|
{
|
|
//
|
|
XOHCL iBar;
|
|
has = iBar.Init(
|
|
bar.symbol,
|
|
bar.period,
|
|
start //
|
|
);
|
|
if (!has)
|
|
{
|
|
//
|
|
iBar.Clean();
|
|
break;
|
|
}
|
|
|
|
//
|
|
double iFast = mX121Helper
|
|
.x3maHelper
|
|
.GetX3MaFast(start);
|
|
|
|
//
|
|
has = iBar.close < iFast &&
|
|
iBar.open > iFast;
|
|
if (has)
|
|
{
|
|
result = iBar.time;
|
|
}
|
|
|
|
//
|
|
canContinue =
|
|
start < end &&
|
|
!IsValid(result);
|
|
|
|
//
|
|
start++;
|
|
|
|
//
|
|
iBar.Clean();
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Virtuals ...
|
|
|
|
/**
|
|
* Set Default Properties Values ...
|
|
*/
|
|
virtual void Default()
|
|
{
|
|
}
|
|
|
|
//
|
|
protected:
|
|
//
|
|
|
|
//
|
|
private:
|
|
//
|
|
// Props ...
|
|
string mSymbol;
|
|
ENUM_TIMEFRAMES mPeriod;
|
|
|
|
//
|
|
// Actions ...
|
|
|
|
/**
|
|
* Release All Resources ...
|
|
*/
|
|
void DeInit()
|
|
{
|
|
//
|
|
ZeroMemory(mX121Helper);
|
|
ZeroMemory(mPOIDetector);
|
|
ZeroMemory(mBarAnalyser);
|
|
|
|
//
|
|
delete mX121Helper;
|
|
delete mPOIDetector;
|
|
delete mBarAnalyser;
|
|
}
|
|
|
|
/**
|
|
* Apply Chart Style ...
|
|
*/
|
|
void ApplyChartStyle()
|
|
{
|
|
//
|
|
// Retrieve Current Chart ID ...
|
|
long chartId = ChartID();
|
|
|
|
//
|
|
ENUM_CHART_MODE mMode = CHART_CANDLES; // chart's mMode
|
|
bool mShowBidLine = true; // show bid line
|
|
bool mShowAskLine = true; // show ask line
|
|
bool mShowGrid = false; // show grids on chart
|
|
bool mShowVolumes = true; // show volumes
|
|
bool mShowTradeLevels = true; // Displaying trade levels in the chart (levels of open positions, Stop Loss, Take Profit and pending orders)
|
|
bool mAutoScroll = true; // chart autoscroll
|
|
bool mQuickNavigation = true; // chart quick navigation state
|
|
color mForeGroundColor = clrWhite; // chart's foreground color
|
|
color mBackGroundColor = clrBlack; // chart's background color
|
|
color mUpColor = clrGreen; // Up Color
|
|
color mDownColor = clrRed; // Down Color
|
|
color mBullishColor = clrGreen; // Bullish color
|
|
color mBearishColor = clrRed; // Bearish color
|
|
color mGridColor = clrGray; // grid color
|
|
color mBidLineColor = clrGray; // bid line color
|
|
color mAskLineColor = clrRed; // ask line color
|
|
color mLineColor = clrLime; // line mMode and doji candlestick color
|
|
color mStopColor = clrGold; // Color of stop order levels (Stop Loss and Take Profit)
|
|
color mVolumesColor = clrGreen; // volumes color
|
|
|
|
//
|
|
ChartSetInteger(chartId, CHART_SHOW_BID_LINE, mShowBidLine);
|
|
ChartSetInteger(chartId, CHART_SHOW_ASK_LINE, mShowAskLine);
|
|
ChartSetInteger(chartId, CHART_SHOW_GRID, mShowGrid);
|
|
ChartSetInteger(chartId, CHART_SHOW_VOLUMES, mShowVolumes);
|
|
ChartSetInteger(chartId, CHART_SHOW_TRADE_LEVELS, mShowTradeLevels);
|
|
ChartSetInteger(chartId, CHART_AUTOSCROLL, mAutoScroll);
|
|
ChartSetInteger(chartId, CHART_QUICK_NAVIGATION, mQuickNavigation);
|
|
ChartSetInteger(chartId, CHART_COLOR_FOREGROUND, mForeGroundColor);
|
|
ChartSetInteger(chartId, CHART_COLOR_BACKGROUND, mBackGroundColor);
|
|
ChartSetInteger(chartId, CHART_COLOR_GRID, mGridColor);
|
|
ChartSetInteger(chartId, CHART_COLOR_BID, mBidLineColor);
|
|
ChartSetInteger(chartId, CHART_COLOR_ASK, mAskLineColor);
|
|
ChartSetInteger(chartId, CHART_COLOR_STOP_LEVEL, mStopColor);
|
|
ChartSetInteger(chartId, CHART_COLOR_VOLUME, mVolumesColor);
|
|
|
|
//
|
|
// For Enabling XCC ...
|
|
// ChartSetInteger(chartId, CHART_MODE, mMode);
|
|
// ChartSetInteger(chartId, CHART_COLOR_CHART_UP, mUpColor);
|
|
// ChartSetInteger(chartId, CHART_COLOR_CHART_DOWN, mDownColor);
|
|
// ChartSetInteger(chartId, CHART_COLOR_CANDLE_BULL, mBullishColor);
|
|
// ChartSetInteger(chartId, CHART_COLOR_CANDLE_BEAR, mBearishColor);
|
|
// ChartSetInteger(chartId, CHART_COLOR_CHART_LINE, mLineColor);
|
|
}
|
|
|
|
//
|
|
};
|
|
|
|
//
|
|
// Signal Provider Data ...
|
|
struct X121SMCStrategySignalProviderData
|
|
{
|
|
//
|
|
// Props ...
|
|
|
|
//
|
|
// Trigger ...
|
|
XPOIState triggerState;
|
|
double triggerBullishScore;
|
|
double triggerBearishScore;
|
|
X121Conditions triggerXConditions;
|
|
ENUM_XPOI_EVENTS triggerPoiEvents[];
|
|
XC121SMCCycleHelper *triggerCycleHelper;
|
|
ENUM_X_CYCLE_EVENTS triggerCycleEvents[];
|
|
X121SMCCycleConditions triggerConditions;
|
|
|
|
//
|
|
// Decision ...
|
|
XPOIState decisionState;
|
|
double decisionBullishScore;
|
|
double decisionBearishScore;
|
|
X121Conditions decisionXConditions;
|
|
ENUM_XPOI_EVENTS decisionPoiEvents[];
|
|
XC121SMCCycleHelper *decisionCycleHelper;
|
|
ENUM_X_CYCLE_EVENTS decisionCycleEvents[];
|
|
X121SMCCycleConditions decisionConditions;
|
|
|
|
//
|
|
// Analyse ...
|
|
XPOIState analyseState;
|
|
double analyseBullishScore;
|
|
double analyseBearishScore;
|
|
X121Conditions analyseXConditions;
|
|
ENUM_XPOI_EVENTS analysePoiEvents[];
|
|
XC121SMCCycleHelper *analyseCycleHelper;
|
|
ENUM_X_CYCLE_EVENTS analyseCycleEvents[];
|
|
X121SMCCycleConditions analyseConditions;
|
|
|
|
//
|
|
// Verification ...
|
|
XPOIState verificationState;
|
|
double verificationBullishScore;
|
|
double verificationBearishScore;
|
|
X121Conditions verificationXConditions;
|
|
ENUM_XPOI_EVENTS verificationPoiEvents[];
|
|
XC121SMCCycleHelper *verificationCycleHelper;
|
|
ENUM_X_CYCLE_EVENTS verificationCycleEvents[];
|
|
X121SMCCycleConditions verificationConditions;
|
|
|
|
//
|
|
// Consolidation ...
|
|
XPOIState consolidationState;
|
|
double consolidationBullishScore;
|
|
double consolidationBearishScore;
|
|
X121Conditions consolidationXConditions;
|
|
ENUM_XPOI_EVENTS consolidationPoiEvents[];
|
|
XC121SMCCycleHelper *consolidationCycleHelper;
|
|
ENUM_X_CYCLE_EVENTS consolidationCycleEvents[];
|
|
X121SMCCycleConditions consolidationConditions;
|
|
|
|
//
|
|
// Vision ...
|
|
XPOIState visionState;
|
|
double visionBullishScore;
|
|
double visionBearishScore;
|
|
X121Conditions visionXConditions;
|
|
ENUM_XPOI_EVENTS visionPoiEvents[];
|
|
XC121SMCCycleHelper *visionCycleHelper;
|
|
ENUM_X_CYCLE_EVENTS visionCycleEvents[];
|
|
X121SMCCycleConditions visionConditions;
|
|
|
|
//
|
|
// Constructor ...
|
|
X121SMCStrategySignalProviderData()
|
|
{
|
|
Clean();
|
|
}
|
|
|
|
//
|
|
// Tools ...
|
|
|
|
//
|
|
// Cleanup ...
|
|
void Clean()
|
|
{
|
|
//
|
|
// Trigger ...
|
|
triggerState.Clean();
|
|
triggerBullishScore = 0;
|
|
triggerBearishScore = 0;
|
|
Clean(triggerPoiEvents);
|
|
Clean(triggerCycleEvents);
|
|
triggerConditions.Clean();
|
|
triggerXConditions.Clean();
|
|
|
|
//
|
|
// Decision ...
|
|
decisionState.Clean();
|
|
decisionBullishScore = 0;
|
|
decisionBearishScore = 0;
|
|
Clean(decisionPoiEvents);
|
|
Clean(decisionCycleEvents);
|
|
decisionConditions.Clean();
|
|
decisionXConditions.Clean();
|
|
|
|
//
|
|
// Analyse ...
|
|
analyseState.Clean();
|
|
analyseBullishScore = 0;
|
|
analyseBearishScore = 0;
|
|
Clean(analysePoiEvents);
|
|
Clean(analyseCycleEvents);
|
|
analyseConditions.Clean();
|
|
analyseXConditions.Clean();
|
|
|
|
//
|
|
// Verification ...
|
|
verificationState.Clean();
|
|
verificationBullishScore = 0;
|
|
verificationBearishScore = 0;
|
|
Clean(verificationPoiEvents);
|
|
Clean(verificationCycleEvents);
|
|
verificationConditions.Clean();
|
|
verificationXConditions.Clean();
|
|
|
|
//
|
|
// Consolidation ...
|
|
consolidationState.Clean();
|
|
consolidationBullishScore = 0;
|
|
consolidationBearishScore = 0;
|
|
Clean(consolidationPoiEvents);
|
|
Clean(consolidationCycleEvents);
|
|
consolidationConditions.Clean();
|
|
consolidationXConditions.Clean();
|
|
|
|
//
|
|
// Vision ...
|
|
visionState.Clean();
|
|
visionBullishScore = 0;
|
|
visionBearishScore = 0;
|
|
Clean(visionPoiEvents);
|
|
Clean(visionCycleEvents);
|
|
visionConditions.Clean();
|
|
visionXConditions.Clean();
|
|
}
|
|
|
|
//
|
|
void Destroy()
|
|
{
|
|
//
|
|
Clean();
|
|
|
|
//
|
|
ZeroMemory(visionCycleHelper);
|
|
ZeroMemory(triggerCycleHelper);
|
|
ZeroMemory(analyseCycleHelper);
|
|
ZeroMemory(decisionCycleHelper);
|
|
ZeroMemory(verificationCycleHelper);
|
|
ZeroMemory(consolidationCycleHelper);
|
|
|
|
//
|
|
ZeroMemory(this);
|
|
}
|
|
|
|
//
|
|
bool IsValid()
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
result =
|
|
visionCycleHelper != NULL &&
|
|
triggerCycleHelper != NULL &&
|
|
analyseCycleHelper != NULL &&
|
|
decisionCycleHelper != NULL &&
|
|
verificationCycleHelper != NULL &&
|
|
consolidationCycleHelper != NULL;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Initialize ...
|
|
bool Init(
|
|
XC121SMCCycleHelper *_triggerCycleHelper,
|
|
XC121SMCCycleHelper *_decisionCycleHelper,
|
|
XC121SMCCycleHelper *_analyseCycleHelper,
|
|
XC121SMCCycleHelper *_verificationCycleHelper,
|
|
XC121SMCCycleHelper *_consolidationCycleHelper,
|
|
XC121SMCCycleHelper *_visionCycleHelper //
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
// Validate Cycle Helpers ...
|
|
result =
|
|
//
|
|
_visionCycleHelper != NULL &&
|
|
_triggerCycleHelper != NULL &&
|
|
_analyseCycleHelper != NULL &&
|
|
_decisionCycleHelper != NULL &&
|
|
_verificationCycleHelper != NULL &&
|
|
_consolidationCycleHelper != NULL
|
|
//
|
|
;
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
visionCycleHelper = _visionCycleHelper;
|
|
triggerCycleHelper = _triggerCycleHelper;
|
|
analyseCycleHelper = _analyseCycleHelper;
|
|
decisionCycleHelper = _decisionCycleHelper;
|
|
verificationCycleHelper = _verificationCycleHelper;
|
|
consolidationCycleHelper = _consolidationCycleHelper;
|
|
|
|
//
|
|
result = IsValid();
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Prepare all ...
|
|
bool Prepare(
|
|
int barIndex = 0,
|
|
int loopback = 10,
|
|
bool trigger = false,
|
|
bool decision = true,
|
|
bool analyse = true,
|
|
bool verification = false,
|
|
bool consolidation = true,
|
|
bool vision = true //
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
if (barIndex < 0)
|
|
{
|
|
barIndex = 0;
|
|
}
|
|
|
|
//
|
|
if (loopback < 7)
|
|
{
|
|
loopback = 7;
|
|
}
|
|
|
|
//
|
|
result = IsValid();
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Trigger ...
|
|
if (trigger)
|
|
{
|
|
//
|
|
result = triggerCycleHelper.GetConditions(
|
|
triggerCycleEvents,
|
|
triggerPoiEvents,
|
|
triggerConditions,
|
|
barIndex,
|
|
loopback //
|
|
);
|
|
if (!result)
|
|
{
|
|
//
|
|
Clean(triggerPoiEvents);
|
|
Clean(triggerCycleEvents);
|
|
|
|
//
|
|
triggerConditions.Clean();
|
|
|
|
//
|
|
return result;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Decision ...
|
|
if (decision)
|
|
{
|
|
//
|
|
result = decisionCycleHelper.GetConditions(
|
|
decisionCycleEvents,
|
|
decisionPoiEvents,
|
|
decisionConditions,
|
|
barIndex,
|
|
loopback //
|
|
);
|
|
if (!result)
|
|
{
|
|
//
|
|
Clean(triggerPoiEvents);
|
|
Clean(decisionPoiEvents);
|
|
Clean(triggerCycleEvents);
|
|
triggerConditions.Clean();
|
|
Clean(decisionCycleEvents);
|
|
decisionConditions.Clean();
|
|
|
|
//
|
|
return result;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Analyse ...
|
|
if (analyse)
|
|
{
|
|
//
|
|
result = analyseCycleHelper.GetConditions(
|
|
analyseCycleEvents,
|
|
analysePoiEvents,
|
|
analyseConditions,
|
|
barIndex,
|
|
loopback //
|
|
);
|
|
if (!result)
|
|
{
|
|
//
|
|
Clean(triggerPoiEvents);
|
|
Clean(analysePoiEvents);
|
|
Clean(decisionPoiEvents);
|
|
Clean(triggerCycleEvents);
|
|
Clean(analyseCycleEvents);
|
|
triggerConditions.Clean();
|
|
analyseConditions.Clean();
|
|
Clean(decisionCycleEvents);
|
|
decisionConditions.Clean();
|
|
|
|
//
|
|
return result;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Verification ...
|
|
if (verification)
|
|
{
|
|
//
|
|
result = verificationCycleHelper.GetConditions(
|
|
verificationCycleEvents,
|
|
verificationPoiEvents,
|
|
verificationConditions,
|
|
barIndex,
|
|
loopback //
|
|
);
|
|
if (!result)
|
|
{
|
|
//
|
|
Clean(triggerPoiEvents);
|
|
Clean(analysePoiEvents);
|
|
Clean(decisionPoiEvents);
|
|
Clean(triggerCycleEvents);
|
|
Clean(analyseCycleEvents);
|
|
triggerConditions.Clean();
|
|
analyseConditions.Clean();
|
|
Clean(decisionCycleEvents);
|
|
decisionConditions.Clean();
|
|
Clean(verificationPoiEvents);
|
|
Clean(verificationCycleEvents);
|
|
verificationConditions.Clean();
|
|
|
|
//
|
|
return result;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Consolidation ...
|
|
if (consolidation)
|
|
{
|
|
//
|
|
result = consolidationCycleHelper.GetConditions(
|
|
consolidationCycleEvents,
|
|
consolidationPoiEvents,
|
|
consolidationConditions,
|
|
barIndex,
|
|
loopback //
|
|
);
|
|
if (!result)
|
|
{
|
|
//
|
|
Clean(triggerPoiEvents);
|
|
Clean(analysePoiEvents);
|
|
Clean(decisionPoiEvents);
|
|
Clean(triggerCycleEvents);
|
|
Clean(analyseCycleEvents);
|
|
triggerConditions.Clean();
|
|
analyseConditions.Clean();
|
|
Clean(decisionCycleEvents);
|
|
decisionConditions.Clean();
|
|
Clean(verificationPoiEvents);
|
|
Clean(consolidationPoiEvents);
|
|
Clean(verificationCycleEvents);
|
|
verificationConditions.Clean();
|
|
Clean(consolidationCycleEvents);
|
|
consolidationConditions.Clean();
|
|
|
|
//
|
|
return result;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Vision ...
|
|
if (vision)
|
|
{
|
|
result = visionCycleHelper.GetConditions(
|
|
visionCycleEvents,
|
|
visionPoiEvents,
|
|
visionConditions,
|
|
barIndex,
|
|
loopback //
|
|
);
|
|
if (!result)
|
|
{
|
|
//
|
|
Clean(visionPoiEvents);
|
|
Clean(triggerPoiEvents);
|
|
Clean(analysePoiEvents);
|
|
Clean(visionCycleEvents);
|
|
visionConditions.Clean();
|
|
Clean(decisionPoiEvents);
|
|
Clean(triggerCycleEvents);
|
|
Clean(analyseCycleEvents);
|
|
triggerConditions.Clean();
|
|
analyseConditions.Clean();
|
|
Clean(decisionCycleEvents);
|
|
decisionConditions.Clean();
|
|
Clean(verificationPoiEvents);
|
|
Clean(consolidationPoiEvents);
|
|
Clean(verificationCycleEvents);
|
|
verificationConditions.Clean();
|
|
Clean(consolidationCycleEvents);
|
|
consolidationConditions.Clean();
|
|
|
|
//
|
|
return result;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Cycles POI States ...
|
|
visionState = visionConditions.state;
|
|
triggerState = triggerConditions.state;
|
|
analyseState = analyseConditions.state;
|
|
decisionState = decisionConditions.state;
|
|
verificationState = verificationConditions.state;
|
|
consolidationState = consolidationConditions.state;
|
|
|
|
//
|
|
// Cycle X121Conditions ...
|
|
visionXConditions = visionConditions.x121Conditions;
|
|
triggerXConditions = triggerConditions.x121Conditions;
|
|
analyseXConditions = analyseConditions.x121Conditions;
|
|
decisionXConditions = decisionConditions.x121Conditions;
|
|
verificationXConditions = verificationConditions.x121Conditions;
|
|
consolidationXConditions = consolidationConditions.x121Conditions;
|
|
|
|
//
|
|
// Trigger ...
|
|
triggerXConditions.GenerateScore(
|
|
triggerBullishScore,
|
|
triggerBearishScore //
|
|
);
|
|
|
|
//
|
|
// Decision ...
|
|
decisionXConditions.GenerateScore(
|
|
decisionBullishScore,
|
|
decisionBearishScore //
|
|
);
|
|
|
|
//
|
|
// Analyse ...
|
|
analyseXConditions.GenerateScore(
|
|
analyseBullishScore,
|
|
analyseBearishScore //
|
|
);
|
|
|
|
//
|
|
// Verification ...
|
|
verificationXConditions.GenerateScore(
|
|
verificationBullishScore,
|
|
verificationBearishScore //
|
|
);
|
|
|
|
//
|
|
// Consolidation ...
|
|
consolidationXConditions.GenerateScore(
|
|
consolidationBullishScore,
|
|
consolidationBearishScore //
|
|
);
|
|
|
|
//
|
|
// Vision ...
|
|
visionXConditions.GenerateScore(
|
|
visionBullishScore,
|
|
visionBearishScore //
|
|
);
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
bool SelectCycle(
|
|
ENUM_X_CYCLES cycle,
|
|
XPOIState &cState,
|
|
XPOIStateEvents &cStateEvents,
|
|
X121Conditions &cXConditions,
|
|
XC121SMCCycleHelper *&cHelper,
|
|
X121SMCCycleConditions &cConditions //
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
cState.Clean();
|
|
ZeroMemory(cHelper);
|
|
cConditions.Clean();
|
|
cStateEvents.Clean();
|
|
cXConditions.Clean();
|
|
|
|
//
|
|
result = cycle != X_CYCLE_NONE;
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
if (cycle == X_CYCLE_TRIGGER)
|
|
{
|
|
//
|
|
cState = triggerState;
|
|
cHelper = triggerCycleHelper;
|
|
cConditions = triggerConditions;
|
|
cXConditions = triggerXConditions;
|
|
cStateEvents.Init(triggerPoiEvents);
|
|
}
|
|
else if (cycle == X_CYCLE_DECISION)
|
|
{
|
|
//
|
|
cState = decisionState;
|
|
cHelper = decisionCycleHelper;
|
|
cConditions = decisionConditions;
|
|
cXConditions = decisionXConditions;
|
|
cStateEvents.Init(decisionPoiEvents);
|
|
}
|
|
else if (cycle == X_CYCLE_ANALYSE)
|
|
{
|
|
//
|
|
cState = analyseState;
|
|
cHelper = analyseCycleHelper;
|
|
cConditions = analyseConditions;
|
|
cXConditions = analyseXConditions;
|
|
cStateEvents.Init(analysePoiEvents);
|
|
}
|
|
else if (cycle == X_CYCLE_VERIFICATION)
|
|
{
|
|
//
|
|
cState = verificationState;
|
|
cHelper = verificationCycleHelper;
|
|
cConditions = verificationConditions;
|
|
cXConditions = verificationXConditions;
|
|
cStateEvents.Init(verificationPoiEvents);
|
|
}
|
|
else if (cycle == X_CYCLE_CONSOLIDATION)
|
|
{
|
|
//
|
|
cState = consolidationState;
|
|
cHelper = consolidationCycleHelper;
|
|
cConditions = consolidationConditions;
|
|
cXConditions = consolidationXConditions;
|
|
cStateEvents.Init(consolidationPoiEvents);
|
|
}
|
|
else if (cycle == X_CYCLE_VISION)
|
|
{
|
|
//
|
|
cState = visionState;
|
|
cHelper = visionCycleHelper;
|
|
cConditions = visionConditions;
|
|
cXConditions = visionXConditions;
|
|
cStateEvents.Init(visionPoiEvents);
|
|
}
|
|
|
|
//
|
|
result = cState.IsValid() &&
|
|
cHelper != NULL;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
void MaxRequiredPOIs(int value)
|
|
{
|
|
//
|
|
if (!IsValid())
|
|
{
|
|
return;
|
|
}
|
|
|
|
//
|
|
visionCycleHelper.mPOIDetector.MaxRequiredPOIs(value);
|
|
analyseCycleHelper.mPOIDetector.MaxRequiredPOIs(value);
|
|
decisionCycleHelper.mPOIDetector.MaxRequiredPOIs(value);
|
|
consolidationCycleHelper.mPOIDetector.MaxRequiredPOIs(value);
|
|
}
|
|
|
|
//
|
|
void MaxAllowedLoopbackForInit(int value)
|
|
{
|
|
//
|
|
if (!IsValid())
|
|
{
|
|
return;
|
|
}
|
|
|
|
//
|
|
visionCycleHelper.mPOIDetector.MaxAllowedLoopbackForInit(value);
|
|
analyseCycleHelper.mPOIDetector.MaxAllowedLoopbackForInit(value);
|
|
decisionCycleHelper.mPOIDetector.MaxAllowedLoopbackForInit(value);
|
|
consolidationCycleHelper.mPOIDetector.MaxAllowedLoopbackForInit(value);
|
|
}
|
|
|
|
//
|
|
};
|
|
|
|
//
|
|
// Condition Parser ...
|
|
struct X121SMCStrategyConditionParser
|
|
{
|
|
//
|
|
// Props ...
|
|
|
|
//
|
|
// XSAR ...
|
|
|
|
//
|
|
bool isSarBullishOverPeaksGoldenZone;
|
|
bool isSarSwitchedToBullishOverPeaksGoldenZone;
|
|
bool isSarBearishOverPeaksGoldenZone;
|
|
bool isSarSwitchedToBearishOverPeaksGoldenZone;
|
|
bool isSarBullishUnderValesGoldenZone;
|
|
bool isSarSwitchedToBullishUnderValesGoldenZone;
|
|
bool isSarBearishUnderValesGoldenZone;
|
|
bool isSarSwitchedToBearishUnderValesGoldenZone;
|
|
|
|
//
|
|
// XMA ...
|
|
|
|
//
|
|
bool isX3MaFastUnderValesGoldenZone;
|
|
bool isX3MaFastCrossedUnderValesGoldenZone;
|
|
bool isX3MaFastOverPeaksGoldenZone;
|
|
bool isX3MaFastCrossedOverPeaksGoldenZone;
|
|
|
|
//
|
|
bool isX3MaInsidePeaksGoldenZone;
|
|
bool isX3MaCrossedInsidePeaksGoldenZone;
|
|
bool isX3MaInsideValesGoldenZone;
|
|
bool isX3MaCrossedInsideValesGoldenZone;
|
|
|
|
//
|
|
bool isX3MaBullishStateOverPeaksGoldenZone;
|
|
bool isX3MaBearishStateOverPeaksGoldenZone;
|
|
bool isX3MaSwitchedToBullishStateOverPeaksGoldenZone;
|
|
bool isX3MaSwitchedToBearishStateOverPeaksGoldenZone;
|
|
|
|
//
|
|
bool isX3MaBullishOrderedOverPeaksGoldenZone;
|
|
bool isX3MaBearishOrderedOverPeaksGoldenZone;
|
|
bool isX3MaSwitchedToBullishOrderedOverPeaksGoldenZone;
|
|
bool isX3MaSwitchedToBearishOrderedOverPeaksGoldenZone;
|
|
|
|
//
|
|
bool isX3MaBullishStateUnderValesGoldenZone;
|
|
bool isX3MaBearishStateUnderValesGoldenZone;
|
|
bool isX3MaSwitchedToBullishStateUnderValesGoldenZone;
|
|
bool isX3MaSwitchedToBearishStateUnderValesGoldenZone;
|
|
|
|
//
|
|
bool isX3MaBullishOrderedUnderValesGoldenZone;
|
|
bool isX3MaBearishOrderedUnderValesGoldenZone;
|
|
bool isX3MaSwitchedToBullishOrderedUnderValesGoldenZone;
|
|
bool isX3MaSwitchedToBearishOrderedUnderValesGoldenZone;
|
|
|
|
//
|
|
// XVWAP ...
|
|
|
|
//
|
|
bool isVWapFastUnderValesGoldenZone;
|
|
bool isVWapFastCrossedUnderValesGoldenZone;
|
|
bool isVWapFastOverPeaksGoldenZone;
|
|
bool isVWapFastCrossedOverPeaksGoldenZone;
|
|
|
|
//
|
|
bool isVWapInsidePeaksGoldenZone;
|
|
bool isVWapCrossedInsidePeaksGoldenZone;
|
|
bool isVWapInsideValesGoldenZone;
|
|
bool isVWapCrossedInsideValesGoldenZone;
|
|
|
|
//
|
|
bool isVWapBullishStateOverPeaksGoldenZone;
|
|
bool isVWapBearishStateOverPeaksGoldenZone;
|
|
bool isVWapSwitchedToBullishStateOverPeaksGoldenZone;
|
|
bool isVWapSwitchedToBearishStateOverPeaksGoldenZone;
|
|
|
|
//
|
|
bool isVWapBullishOrderedOverPeaksGoldenZone;
|
|
bool isVWapBearishOrderedOverPeaksGoldenZone;
|
|
bool isVWapSwitchedToBullishOrderedOverPeaksGoldenZone;
|
|
bool isVWapSwitchedToBearishOrderedOverPeaksGoldenZone;
|
|
|
|
//
|
|
bool isVWapBullishStateUnderValesGoldenZone;
|
|
bool isVWapBearishStateUnderValesGoldenZone;
|
|
bool isVWapSwitchedToBullishStateUnderValesGoldenZone;
|
|
bool isVWapSwitchedToBearishStateUnderValesGoldenZone;
|
|
|
|
//
|
|
bool isVWapBullishOrderedUnderValesGoldenZone;
|
|
bool isVWapBearishOrderedUnderValesGoldenZone;
|
|
bool isVWapSwitchedToBullishOrderedUnderValesGoldenZone;
|
|
bool isVWapSwitchedToBearishOrderedUnderValesGoldenZone;
|
|
|
|
//
|
|
// XHK ...
|
|
|
|
//
|
|
// XRWHK ...
|
|
|
|
//
|
|
bool isRawHKBearishOverPeaksGoldenZone;
|
|
bool isRawHKSwitchedToBearishOverPeaksGoldenZone;
|
|
bool isRawHKBullishUnderValesGoldenZone;
|
|
bool isRawHKSwitchedToBullishUnderValesGoldenZone;
|
|
|
|
//
|
|
// XSMHK ...
|
|
|
|
//
|
|
bool isSMHKBearishOverPeaksGoldenZone;
|
|
bool isSMHKSwitchedToBearishOverPeaksGoldenZone;
|
|
bool isSMHKBullishUnderValesGoldenZone;
|
|
bool isSMHKSwitchedToBullishUnderValesGoldenZone;
|
|
|
|
//
|
|
// XATR ...
|
|
|
|
//
|
|
bool isAtrUpperOverPeaksGoldenZone;
|
|
bool isAtrLowerOverPeaksGoldenZone;
|
|
bool isAtrOverPeaksGoldenZone;
|
|
bool isAtrCrossedOverPeaksGoldenZone;
|
|
|
|
//
|
|
bool isAtrUpperUnderValesGoldenZone;
|
|
bool isAtrLowerUnderValesGoldenZone;
|
|
bool isAtrUnderValesGoldenZone;
|
|
bool isAtrCrossedUnderValesGoldenZone;
|
|
|
|
//
|
|
// XSTR ...
|
|
|
|
//
|
|
bool isStrBullishOverPeaksGoldenZone;
|
|
bool isStrBearishOverPeaksGoldenZone;
|
|
bool isStrSwitchedToBullishOverPeaksGoldenZone;
|
|
bool isStrSwitchedToBearishOverPeaksGoldenZone;
|
|
|
|
//
|
|
bool isStrBullishUnderValesGoldenZone;
|
|
bool isStrBearishUnderValesGoldenZone;
|
|
bool isStrSwitchedToBullishUnderValesGoldenZone;
|
|
bool isStrSwitchedToBearishUnderValesGoldenZone;
|
|
|
|
//
|
|
// XCHE ...
|
|
|
|
//
|
|
bool isCheBullishOverPeaksGoldenZone;
|
|
bool isCheBearishOverPeaksGoldenZone;
|
|
bool isCheSwitchedBullishOverPeaksGoldenZone;
|
|
bool isCheSwitchedBearishOverPeaksGoldenZone;
|
|
|
|
//
|
|
bool isCheBullishUnderValesGoldenZone;
|
|
bool isCheBearishUnderValesGoldenZone;
|
|
bool isCheSwitchedBullishUnderValesGoldenZone;
|
|
bool isCheSwitchedBearishUnderValesGoldenZone;
|
|
|
|
//
|
|
// Constructor ...
|
|
X121SMCStrategyConditionParser()
|
|
{
|
|
Clean();
|
|
}
|
|
|
|
//
|
|
// Tools ...
|
|
|
|
//
|
|
void Clean()
|
|
{
|
|
//
|
|
// XSAR ...
|
|
|
|
//
|
|
isSarBullishOverPeaksGoldenZone = false;
|
|
isSarSwitchedToBullishOverPeaksGoldenZone = false;
|
|
isSarBearishOverPeaksGoldenZone = false;
|
|
isSarSwitchedToBearishOverPeaksGoldenZone = false;
|
|
isSarBullishUnderValesGoldenZone = false;
|
|
isSarSwitchedToBullishUnderValesGoldenZone = false;
|
|
isSarBearishUnderValesGoldenZone = false;
|
|
isSarSwitchedToBearishUnderValesGoldenZone = false;
|
|
|
|
//
|
|
// X3MA ...
|
|
|
|
//
|
|
isX3MaFastUnderValesGoldenZone = false;
|
|
isX3MaFastCrossedUnderValesGoldenZone = false;
|
|
isX3MaFastOverPeaksGoldenZone = false;
|
|
isX3MaFastCrossedOverPeaksGoldenZone = false;
|
|
|
|
//
|
|
isX3MaInsidePeaksGoldenZone = false;
|
|
isX3MaCrossedInsidePeaksGoldenZone = false;
|
|
isX3MaInsideValesGoldenZone = false;
|
|
isX3MaCrossedInsideValesGoldenZone = false;
|
|
|
|
//
|
|
isX3MaBullishStateOverPeaksGoldenZone = false;
|
|
isX3MaBearishStateOverPeaksGoldenZone = false;
|
|
isX3MaSwitchedToBullishStateOverPeaksGoldenZone = false;
|
|
isX3MaSwitchedToBearishStateOverPeaksGoldenZone = false;
|
|
|
|
//
|
|
isX3MaBullishOrderedOverPeaksGoldenZone = false;
|
|
isX3MaBearishOrderedOverPeaksGoldenZone = false;
|
|
isX3MaSwitchedToBullishOrderedOverPeaksGoldenZone = false;
|
|
isX3MaSwitchedToBearishOrderedOverPeaksGoldenZone = false;
|
|
|
|
//
|
|
isX3MaBullishStateUnderValesGoldenZone = false;
|
|
isX3MaBearishStateUnderValesGoldenZone = false;
|
|
isX3MaSwitchedToBullishStateUnderValesGoldenZone = false;
|
|
isX3MaSwitchedToBearishStateUnderValesGoldenZone = false;
|
|
|
|
//
|
|
isX3MaBullishOrderedUnderValesGoldenZone = false;
|
|
isX3MaBearishOrderedUnderValesGoldenZone = false;
|
|
isX3MaSwitchedToBullishOrderedUnderValesGoldenZone = false;
|
|
isX3MaSwitchedToBearishOrderedUnderValesGoldenZone = false;
|
|
|
|
//
|
|
// XVWAP ...
|
|
|
|
//
|
|
isVWapFastUnderValesGoldenZone = false;
|
|
isVWapFastCrossedUnderValesGoldenZone = false;
|
|
isVWapFastOverPeaksGoldenZone = false;
|
|
isVWapFastCrossedOverPeaksGoldenZone = false;
|
|
|
|
//
|
|
isVWapInsidePeaksGoldenZone = false;
|
|
isVWapCrossedInsidePeaksGoldenZone = false;
|
|
isVWapInsideValesGoldenZone = false;
|
|
isVWapCrossedInsideValesGoldenZone = false;
|
|
|
|
//
|
|
isVWapBullishStateOverPeaksGoldenZone = false;
|
|
isVWapBearishStateOverPeaksGoldenZone = false;
|
|
isVWapSwitchedToBullishStateOverPeaksGoldenZone = false;
|
|
isVWapSwitchedToBearishStateOverPeaksGoldenZone = false;
|
|
|
|
//
|
|
isVWapBullishOrderedOverPeaksGoldenZone = false;
|
|
isVWapBearishOrderedOverPeaksGoldenZone = false;
|
|
isVWapSwitchedToBullishOrderedOverPeaksGoldenZone = false;
|
|
isVWapSwitchedToBearishOrderedOverPeaksGoldenZone = false;
|
|
|
|
//
|
|
isVWapBullishStateUnderValesGoldenZone = false;
|
|
isVWapBearishStateUnderValesGoldenZone = false;
|
|
isVWapSwitchedToBullishStateUnderValesGoldenZone = false;
|
|
isVWapSwitchedToBearishStateUnderValesGoldenZone = false;
|
|
|
|
//
|
|
isVWapBullishOrderedUnderValesGoldenZone = false;
|
|
isVWapBearishOrderedUnderValesGoldenZone = false;
|
|
isVWapSwitchedToBullishOrderedUnderValesGoldenZone = false;
|
|
isVWapSwitchedToBearishOrderedUnderValesGoldenZone = false;
|
|
|
|
//
|
|
// XHK ...
|
|
|
|
//
|
|
// XRWHK ...
|
|
|
|
//
|
|
isRawHKBearishOverPeaksGoldenZone = false;
|
|
isRawHKSwitchedToBearishOverPeaksGoldenZone = false;
|
|
isRawHKBullishUnderValesGoldenZone = false;
|
|
isRawHKSwitchedToBullishUnderValesGoldenZone = false;
|
|
|
|
//
|
|
// XSMHK ...
|
|
|
|
//
|
|
isSMHKBearishOverPeaksGoldenZone = false;
|
|
isSMHKSwitchedToBearishOverPeaksGoldenZone = false;
|
|
isSMHKBullishUnderValesGoldenZone = false;
|
|
isSMHKSwitchedToBullishUnderValesGoldenZone = false;
|
|
|
|
//
|
|
// XATR ...
|
|
|
|
//
|
|
isAtrUpperOverPeaksGoldenZone = false;
|
|
isAtrLowerOverPeaksGoldenZone = false;
|
|
isAtrOverPeaksGoldenZone = false;
|
|
isAtrCrossedOverPeaksGoldenZone = false;
|
|
|
|
//
|
|
isAtrUpperUnderValesGoldenZone = false;
|
|
isAtrLowerUnderValesGoldenZone = false;
|
|
isAtrUnderValesGoldenZone = false;
|
|
isAtrCrossedUnderValesGoldenZone = false;
|
|
|
|
//
|
|
// XSTR ...
|
|
|
|
//
|
|
isStrBullishOverPeaksGoldenZone = false;
|
|
isStrBearishOverPeaksGoldenZone = false;
|
|
isStrSwitchedToBullishOverPeaksGoldenZone = false;
|
|
isStrSwitchedToBearishOverPeaksGoldenZone = false;
|
|
|
|
//
|
|
isStrBullishUnderValesGoldenZone = false;
|
|
isStrBearishUnderValesGoldenZone = false;
|
|
isStrSwitchedToBullishUnderValesGoldenZone = false;
|
|
isStrSwitchedToBearishUnderValesGoldenZone = false;
|
|
|
|
//
|
|
// XCHE ...
|
|
|
|
//
|
|
isCheBullishOverPeaksGoldenZone = false;
|
|
isCheBearishOverPeaksGoldenZone = false;
|
|
isCheSwitchedBullishOverPeaksGoldenZone = false;
|
|
isCheSwitchedBearishOverPeaksGoldenZone = false;
|
|
|
|
//
|
|
isCheBullishUnderValesGoldenZone = false;
|
|
isCheBearishUnderValesGoldenZone = false;
|
|
isCheSwitchedBullishUnderValesGoldenZone = false;
|
|
isCheSwitchedBearishUnderValesGoldenZone = false;
|
|
|
|
//
|
|
ZeroMemory(this);
|
|
}
|
|
|
|
//
|
|
void Parse(
|
|
X121Conditions &conditions //
|
|
)
|
|
{
|
|
//
|
|
Clean();
|
|
|
|
//
|
|
//
|
|
int zIDX = 0;
|
|
int cIDX = zIDX + 1;
|
|
int pIDX = cIDX + 1;
|
|
|
|
//
|
|
// XSAR ...
|
|
|
|
//
|
|
isSarBullishOverPeaksGoldenZone =
|
|
conditions.isSarBullish &&
|
|
conditions.sarBuffer[cIDX] > conditions.peaksGoldenBuffer[cIDX];
|
|
|
|
//
|
|
isSarSwitchedToBullishOverPeaksGoldenZone =
|
|
conditions.isSarSwitchedToBullish &&
|
|
conditions.sarBuffer[cIDX] > conditions.peaksGoldenBuffer[cIDX];
|
|
|
|
//
|
|
isSarBearishOverPeaksGoldenZone =
|
|
conditions.isSarBearish &&
|
|
conditions.sarBuffer[cIDX] > conditions.peaksGoldenBuffer[cIDX];
|
|
|
|
//
|
|
isSarSwitchedToBearishOverPeaksGoldenZone =
|
|
conditions.isSarSwitchedToBearish &&
|
|
conditions.sarBuffer[cIDX] > conditions.peaksGoldenBuffer[cIDX];
|
|
|
|
//
|
|
isSarBullishUnderValesGoldenZone =
|
|
conditions.isSarBullish &&
|
|
conditions.sarBuffer[cIDX] < conditions.valesGoldenBuffer[cIDX];
|
|
|
|
//
|
|
isSarSwitchedToBullishUnderValesGoldenZone =
|
|
conditions.isSarSwitchedToBullish &&
|
|
conditions.sarBuffer[cIDX] < conditions.valesGoldenBuffer[cIDX];
|
|
|
|
//
|
|
isSarBearishUnderValesGoldenZone =
|
|
conditions.isSarBearish &&
|
|
conditions.sarBuffer[cIDX] < conditions.valesGoldenBuffer[cIDX];
|
|
|
|
//
|
|
isSarSwitchedToBearishUnderValesGoldenZone =
|
|
conditions.isSarSwitchedToBearish &&
|
|
conditions.sarBuffer[cIDX] < conditions.valesGoldenBuffer[cIDX];
|
|
|
|
//
|
|
// X3MA ...
|
|
|
|
//
|
|
isX3MaFastUnderValesGoldenZone =
|
|
conditions.x3maFastBuffer[cIDX] < conditions.valesGoldenBuffer[cIDX];
|
|
|
|
//
|
|
isX3MaFastCrossedUnderValesGoldenZone =
|
|
isX3MaFastUnderValesGoldenZone &&
|
|
conditions.x3maFastBuffer[pIDX] >= conditions.valesGoldenBuffer[pIDX];
|
|
|
|
//
|
|
isX3MaFastOverPeaksGoldenZone =
|
|
conditions.x3maFastBuffer[cIDX] > conditions.peaksGoldenBuffer[cIDX];
|
|
|
|
//
|
|
isX3MaFastCrossedOverPeaksGoldenZone =
|
|
isX3MaFastOverPeaksGoldenZone &&
|
|
conditions.x3maFastBuffer[pIDX] <= conditions.peaksGoldenBuffer[pIDX];
|
|
|
|
//
|
|
isX3MaInsidePeaksGoldenZone =
|
|
//
|
|
conditions.x3maMin < conditions.peaksBuffer[cIDX] &&
|
|
conditions.x3maMin > conditions.peaksGoldenBuffer[cIDX] &&
|
|
//
|
|
conditions.x3maMax < conditions.peaksBuffer[cIDX] &&
|
|
conditions.x3maMax > conditions.peaksGoldenBuffer[cIDX]
|
|
//
|
|
;
|
|
|
|
//
|
|
isX3MaCrossedInsidePeaksGoldenZone =
|
|
isX3MaInsidePeaksGoldenZone &&
|
|
!(
|
|
//
|
|
conditions.x3maMin < conditions.peaksBuffer[pIDX] &&
|
|
conditions.x3maMin > conditions.peaksGoldenBuffer[pIDX] &&
|
|
//
|
|
conditions.x3maMax < conditions.peaksBuffer[pIDX] &&
|
|
conditions.x3maMax > conditions.peaksGoldenBuffer[pIDX]
|
|
//
|
|
);
|
|
|
|
//
|
|
isX3MaInsideValesGoldenZone =
|
|
//
|
|
conditions.x3maMin > conditions.valesBuffer[cIDX] &&
|
|
conditions.x3maMin < conditions.valesGoldenBuffer[cIDX] &&
|
|
//
|
|
conditions.x3maMax > conditions.valesBuffer[cIDX] &&
|
|
conditions.x3maMax < conditions.valesGoldenBuffer[cIDX]
|
|
//
|
|
;
|
|
|
|
isX3MaCrossedInsideValesGoldenZone =
|
|
isX3MaInsideValesGoldenZone &&
|
|
!(
|
|
//
|
|
conditions.x3maMin > conditions.valesBuffer[pIDX] &&
|
|
conditions.x3maMin < conditions.valesGoldenBuffer[pIDX] &&
|
|
//
|
|
conditions.x3maMax > conditions.valesBuffer[pIDX] &&
|
|
conditions.x3maMax < conditions.valesGoldenBuffer[pIDX]
|
|
//
|
|
);
|
|
|
|
//
|
|
isX3MaBullishStateOverPeaksGoldenZone =
|
|
isX3MaInsidePeaksGoldenZone &&
|
|
conditions.isX3MaBullishState;
|
|
|
|
//
|
|
isX3MaBearishStateOverPeaksGoldenZone =
|
|
isX3MaInsidePeaksGoldenZone &&
|
|
conditions.isX3MaBearishState;
|
|
|
|
//
|
|
isX3MaSwitchedToBullishStateOverPeaksGoldenZone =
|
|
isX3MaInsidePeaksGoldenZone &&
|
|
conditions.isX3MaSwitchedToBullishState;
|
|
|
|
//
|
|
isX3MaSwitchedToBearishStateOverPeaksGoldenZone =
|
|
isX3MaInsidePeaksGoldenZone &&
|
|
conditions.isX3MaSwitchedToBearishState;
|
|
|
|
//
|
|
isX3MaBullishOrderedOverPeaksGoldenZone =
|
|
isX3MaInsidePeaksGoldenZone &&
|
|
conditions.isX3MaBullishOrdered;
|
|
|
|
//
|
|
isX3MaBearishOrderedOverPeaksGoldenZone =
|
|
isX3MaInsidePeaksGoldenZone &&
|
|
conditions.isX3MaBearishOrdered;
|
|
|
|
//
|
|
isX3MaSwitchedToBullishOrderedOverPeaksGoldenZone =
|
|
isX3MaInsidePeaksGoldenZone &&
|
|
conditions.isX3MaSwitchedToBullishOrdered;
|
|
|
|
//
|
|
isX3MaSwitchedToBearishOrderedOverPeaksGoldenZone =
|
|
isX3MaInsidePeaksGoldenZone &&
|
|
conditions.isX3MaSwitchedToBearishOrdered;
|
|
|
|
//
|
|
isX3MaBullishStateUnderValesGoldenZone =
|
|
isX3MaInsideValesGoldenZone &&
|
|
conditions.isX3MaBullishState;
|
|
|
|
//
|
|
isX3MaBearishStateUnderValesGoldenZone =
|
|
isX3MaInsideValesGoldenZone &&
|
|
conditions.isX3MaBearishState;
|
|
|
|
//
|
|
isX3MaSwitchedToBullishStateUnderValesGoldenZone =
|
|
isX3MaInsideValesGoldenZone &&
|
|
conditions.isX3MaSwitchedToBullishState;
|
|
|
|
//
|
|
isX3MaSwitchedToBearishStateUnderValesGoldenZone =
|
|
isX3MaInsideValesGoldenZone &&
|
|
conditions.isX3MaSwitchedToBearishState;
|
|
|
|
//
|
|
isX3MaBullishOrderedUnderValesGoldenZone =
|
|
isX3MaInsideValesGoldenZone &&
|
|
conditions.isX3MaBullishOrdered;
|
|
|
|
//
|
|
isX3MaBearishOrderedUnderValesGoldenZone =
|
|
isX3MaInsideValesGoldenZone &&
|
|
conditions.isX3MaBearishOrdered;
|
|
|
|
//
|
|
isX3MaSwitchedToBullishOrderedUnderValesGoldenZone =
|
|
isX3MaInsideValesGoldenZone &&
|
|
conditions.isX3MaSwitchedToBullishOrdered;
|
|
|
|
//
|
|
isX3MaSwitchedToBearishOrderedUnderValesGoldenZone =
|
|
isX3MaInsideValesGoldenZone &&
|
|
conditions.isX3MaSwitchedToBearishOrdered;
|
|
|
|
//
|
|
// XVWAP ...
|
|
|
|
//
|
|
isVWapFastUnderValesGoldenZone =
|
|
conditions.vwapFastBuffer[cIDX] < conditions.valesGoldenBuffer[cIDX];
|
|
|
|
//
|
|
isVWapFastCrossedUnderValesGoldenZone =
|
|
isVWapFastUnderValesGoldenZone &&
|
|
conditions.vwapFastBuffer[pIDX] >= conditions.valesGoldenBuffer[pIDX];
|
|
|
|
//
|
|
isVWapFastOverPeaksGoldenZone =
|
|
conditions.vwapFastBuffer[cIDX] > conditions.peaksGoldenBuffer[cIDX];
|
|
|
|
//
|
|
isVWapFastCrossedOverPeaksGoldenZone =
|
|
isVWapFastOverPeaksGoldenZone &&
|
|
conditions.vwapFastBuffer[pIDX] <= conditions.peaksGoldenBuffer[pIDX];
|
|
|
|
//
|
|
isVWapInsidePeaksGoldenZone =
|
|
//
|
|
conditions.vwapMin < conditions.peaksBuffer[cIDX] &&
|
|
conditions.vwapMin > conditions.peaksGoldenBuffer[cIDX] &&
|
|
//
|
|
conditions.vwapMax < conditions.peaksBuffer[cIDX] &&
|
|
conditions.vwapMax > conditions.peaksGoldenBuffer[cIDX]
|
|
//
|
|
;
|
|
|
|
//
|
|
isVWapCrossedInsidePeaksGoldenZone =
|
|
isVWapInsidePeaksGoldenZone &&
|
|
!(
|
|
//
|
|
conditions.vwapMin < conditions.peaksBuffer[pIDX] &&
|
|
conditions.vwapMin > conditions.peaksGoldenBuffer[pIDX] &&
|
|
//
|
|
conditions.vwapMax < conditions.peaksBuffer[pIDX] &&
|
|
conditions.vwapMax > conditions.peaksGoldenBuffer[pIDX]
|
|
//
|
|
);
|
|
|
|
//
|
|
isVWapInsideValesGoldenZone =
|
|
//
|
|
conditions.vwapMin > conditions.valesBuffer[cIDX] &&
|
|
conditions.vwapMin < conditions.valesGoldenBuffer[cIDX] &&
|
|
//
|
|
conditions.vwapMax > conditions.valesBuffer[cIDX] &&
|
|
conditions.vwapMax < conditions.valesGoldenBuffer[cIDX]
|
|
//
|
|
;
|
|
|
|
//
|
|
isVWapCrossedInsideValesGoldenZone =
|
|
isVWapInsideValesGoldenZone &&
|
|
!(
|
|
//
|
|
conditions.vwapMin > conditions.valesBuffer[pIDX] &&
|
|
conditions.vwapMin < conditions.valesGoldenBuffer[pIDX] &&
|
|
//
|
|
conditions.vwapMax > conditions.valesBuffer[pIDX] &&
|
|
conditions.vwapMax < conditions.valesGoldenBuffer[pIDX]
|
|
//
|
|
);
|
|
|
|
//
|
|
isVWapBullishStateOverPeaksGoldenZone =
|
|
isVWapInsidePeaksGoldenZone &&
|
|
conditions.isVWapBullishState;
|
|
|
|
//
|
|
isVWapBearishStateOverPeaksGoldenZone =
|
|
isVWapInsidePeaksGoldenZone &&
|
|
conditions.isVWapBearishState;
|
|
|
|
//
|
|
isVWapSwitchedToBullishStateOverPeaksGoldenZone =
|
|
isVWapInsidePeaksGoldenZone &&
|
|
conditions.isVWapSwitchedToBullishState;
|
|
|
|
//
|
|
isVWapSwitchedToBearishStateOverPeaksGoldenZone =
|
|
isVWapInsidePeaksGoldenZone &&
|
|
conditions.isVWapSwitchedToBearishState;
|
|
|
|
//
|
|
isVWapBullishOrderedOverPeaksGoldenZone =
|
|
isVWapInsidePeaksGoldenZone &&
|
|
conditions.isVWapBullishOrdered;
|
|
|
|
//
|
|
isVWapBearishOrderedOverPeaksGoldenZone =
|
|
isVWapInsidePeaksGoldenZone &&
|
|
conditions.isVWapBearishOrdered;
|
|
|
|
//
|
|
isVWapSwitchedToBullishOrderedOverPeaksGoldenZone =
|
|
isVWapInsidePeaksGoldenZone &&
|
|
conditions.isVWapSwitchedToBullishOrdered;
|
|
|
|
//
|
|
isVWapSwitchedToBearishOrderedOverPeaksGoldenZone =
|
|
isVWapInsidePeaksGoldenZone &&
|
|
conditions.isVWapSwitchedToBearishOrdered;
|
|
|
|
//
|
|
isVWapBullishStateUnderValesGoldenZone =
|
|
isVWapInsideValesGoldenZone &&
|
|
conditions.isVWapBullishState;
|
|
|
|
//
|
|
isVWapBearishStateUnderValesGoldenZone =
|
|
isVWapInsideValesGoldenZone &&
|
|
conditions.isVWapBearishState;
|
|
|
|
//
|
|
isVWapSwitchedToBullishStateUnderValesGoldenZone =
|
|
isVWapInsideValesGoldenZone &&
|
|
conditions.isVWapSwitchedToBullishState;
|
|
|
|
//
|
|
isVWapSwitchedToBearishStateUnderValesGoldenZone =
|
|
isVWapInsideValesGoldenZone &&
|
|
conditions.isVWapSwitchedToBearishState;
|
|
|
|
//
|
|
isVWapBullishOrderedUnderValesGoldenZone =
|
|
isVWapInsideValesGoldenZone &&
|
|
conditions.isVWapBullishOrdered;
|
|
|
|
//
|
|
isVWapBearishOrderedUnderValesGoldenZone =
|
|
isVWapInsideValesGoldenZone &&
|
|
conditions.isVWapBearishOrdered;
|
|
|
|
//
|
|
isVWapSwitchedToBullishOrderedUnderValesGoldenZone =
|
|
isVWapInsideValesGoldenZone &&
|
|
conditions.isVWapSwitchedToBullishOrdered;
|
|
|
|
//
|
|
isVWapSwitchedToBearishOrderedUnderValesGoldenZone =
|
|
isVWapInsideValesGoldenZone &&
|
|
conditions.isVWapSwitchedToBearishOrdered;
|
|
|
|
//
|
|
// XHK ...
|
|
|
|
//
|
|
// XRWHK ...
|
|
|
|
//
|
|
isRawHKBearishOverPeaksGoldenZone =
|
|
conditions.isRawHKBearish &&
|
|
conditions.xhkRawHighBuffer[cIDX] > conditions.peaksGoldenBuffer[cIDX];
|
|
|
|
//
|
|
isRawHKSwitchedToBearishOverPeaksGoldenZone =
|
|
conditions.isRawHKSwitchedToBearish &&
|
|
conditions.xhkRawHighBuffer[cIDX] > conditions.peaksGoldenBuffer[cIDX];
|
|
|
|
//
|
|
isRawHKBullishUnderValesGoldenZone =
|
|
conditions.isRawHKBullish &&
|
|
conditions.xhkRawLowBuffer[cIDX] < conditions.valesGoldenBuffer[cIDX];
|
|
|
|
//
|
|
isRawHKSwitchedToBullishUnderValesGoldenZone =
|
|
conditions.isRawHKSwitchedToBullish &&
|
|
conditions.xhkRawLowBuffer[cIDX] < conditions.valesGoldenBuffer[cIDX];
|
|
|
|
//
|
|
// XSMHK ...
|
|
|
|
//
|
|
isSMHKBearishOverPeaksGoldenZone =
|
|
conditions.isSMHKBearish &&
|
|
conditions.xhkSMHighBuffer[cIDX] > conditions.peaksGoldenBuffer[cIDX];
|
|
|
|
//
|
|
isSMHKSwitchedToBearishOverPeaksGoldenZone =
|
|
conditions.isSMHKSwitchedToBearish &&
|
|
conditions.xhkSMHighBuffer[cIDX] > conditions.peaksGoldenBuffer[cIDX];
|
|
|
|
//
|
|
isSMHKBullishUnderValesGoldenZone =
|
|
conditions.isSMHKBullish &&
|
|
conditions.xhkSMLowBuffer[cIDX] < conditions.valesGoldenBuffer[cIDX];
|
|
|
|
//
|
|
isSMHKSwitchedToBullishUnderValesGoldenZone =
|
|
conditions.isSMHKSwitchedToBullish &&
|
|
conditions.xhkSMLowBuffer[cIDX] < conditions.valesGoldenBuffer[cIDX];
|
|
|
|
//
|
|
// XATR ...
|
|
|
|
//
|
|
isAtrUpperOverPeaksGoldenZone =
|
|
conditions.atrUpperBuffer[cIDX] < conditions.peaksBuffer[cIDX] &&
|
|
conditions.atrUpperBuffer[cIDX] > conditions.peaksGoldenBuffer[cIDX];
|
|
|
|
//
|
|
isAtrLowerOverPeaksGoldenZone =
|
|
conditions.atrLowerBuffer[cIDX] < conditions.peaksBuffer[cIDX] &&
|
|
conditions.atrLowerBuffer[cIDX] > conditions.peaksGoldenBuffer[cIDX];
|
|
|
|
//
|
|
isAtrOverPeaksGoldenZone =
|
|
isAtrUpperOverPeaksGoldenZone &&
|
|
isAtrLowerOverPeaksGoldenZone;
|
|
|
|
//
|
|
isAtrCrossedOverPeaksGoldenZone =
|
|
isAtrOverPeaksGoldenZone &&
|
|
!(
|
|
//
|
|
conditions.atrUpperBuffer[pIDX] < conditions.peaksBuffer[pIDX] &&
|
|
conditions.atrUpperBuffer[pIDX] > conditions.peaksGoldenBuffer[pIDX]
|
|
//
|
|
&&
|
|
//
|
|
conditions.atrLowerBuffer[pIDX] < conditions.peaksBuffer[pIDX] &&
|
|
conditions.atrLowerBuffer[pIDX] > conditions.peaksGoldenBuffer[pIDX]
|
|
//
|
|
);
|
|
|
|
//
|
|
isAtrUpperUnderValesGoldenZone =
|
|
conditions.atrUpperBuffer[cIDX] > conditions.valesBuffer[cIDX] &&
|
|
conditions.atrUpperBuffer[cIDX] < conditions.valesGoldenBuffer[cIDX];
|
|
|
|
//
|
|
isAtrLowerUnderValesGoldenZone =
|
|
conditions.atrLowerBuffer[cIDX] > conditions.valesBuffer[cIDX] &&
|
|
conditions.atrLowerBuffer[cIDX] < conditions.valesGoldenBuffer[cIDX];
|
|
|
|
//
|
|
isAtrUnderValesGoldenZone =
|
|
isAtrUpperUnderValesGoldenZone &&
|
|
isAtrLowerUnderValesGoldenZone;
|
|
|
|
//
|
|
isAtrCrossedUnderValesGoldenZone =
|
|
isAtrUnderValesGoldenZone &&
|
|
!(
|
|
//
|
|
conditions.atrUpperBuffer[pIDX] > conditions.valesBuffer[pIDX] &&
|
|
conditions.atrUpperBuffer[pIDX] < conditions.valesGoldenBuffer[pIDX]
|
|
//
|
|
&&
|
|
//
|
|
conditions.atrLowerBuffer[pIDX] > conditions.valesBuffer[pIDX] &&
|
|
conditions.atrLowerBuffer[pIDX] < conditions.valesGoldenBuffer[pIDX]
|
|
//
|
|
);
|
|
|
|
//
|
|
// XSTR ...
|
|
|
|
//
|
|
isStrBullishOverPeaksGoldenZone =
|
|
conditions.isStrBullish &&
|
|
conditions.strBuffer[cIDX] < conditions.peaksBuffer[cIDX] &&
|
|
conditions.strBuffer[cIDX] > conditions.peaksGoldenBuffer[cIDX];
|
|
|
|
//
|
|
isStrBearishOverPeaksGoldenZone =
|
|
conditions.isStrBearish &&
|
|
conditions.strBuffer[cIDX] < conditions.peaksBuffer[cIDX] &&
|
|
conditions.strBuffer[cIDX] > conditions.peaksGoldenBuffer[cIDX];
|
|
|
|
//
|
|
isStrSwitchedToBullishOverPeaksGoldenZone =
|
|
conditions.isStrSwitchedToBullish &&
|
|
conditions.strBuffer[cIDX] < conditions.peaksBuffer[cIDX] &&
|
|
conditions.strBuffer[cIDX] > conditions.peaksGoldenBuffer[cIDX];
|
|
|
|
//
|
|
isStrSwitchedToBearishOverPeaksGoldenZone =
|
|
conditions.isStrSwitchedToBearish &&
|
|
conditions.strBuffer[cIDX] < conditions.peaksBuffer[cIDX] &&
|
|
conditions.strBuffer[cIDX] > conditions.peaksGoldenBuffer[cIDX];
|
|
|
|
//
|
|
isStrBullishUnderValesGoldenZone =
|
|
conditions.isStrBullish &&
|
|
conditions.strBuffer[cIDX] > conditions.valesBuffer[cIDX] &&
|
|
conditions.strBuffer[cIDX] < conditions.valesGoldenBuffer[cIDX];
|
|
|
|
//
|
|
isStrBearishUnderValesGoldenZone =
|
|
conditions.isStrBearish &&
|
|
conditions.strBuffer[cIDX] > conditions.valesBuffer[cIDX] &&
|
|
conditions.strBuffer[cIDX] < conditions.valesGoldenBuffer[cIDX];
|
|
|
|
//
|
|
isStrSwitchedToBullishUnderValesGoldenZone =
|
|
conditions.isStrSwitchedToBullish &&
|
|
conditions.strBuffer[cIDX] > conditions.valesBuffer[cIDX] &&
|
|
conditions.strBuffer[cIDX] < conditions.valesGoldenBuffer[cIDX];
|
|
|
|
//
|
|
isStrSwitchedToBearishUnderValesGoldenZone =
|
|
conditions.isStrSwitchedToBearish &&
|
|
conditions.strBuffer[cIDX] > conditions.valesBuffer[cIDX] &&
|
|
conditions.strBuffer[cIDX] < conditions.valesGoldenBuffer[cIDX];
|
|
|
|
//
|
|
// XCHE ...
|
|
|
|
//
|
|
isCheBullishOverPeaksGoldenZone =
|
|
conditions.isCheBullish &&
|
|
conditions.le1Buffer[cIDX] < conditions.peaksBuffer[cIDX] &&
|
|
conditions.le1Buffer[cIDX] > conditions.peaksGoldenBuffer[cIDX] &&
|
|
conditions.le2Buffer[cIDX] < conditions.peaksBuffer[cIDX] &&
|
|
conditions.le2Buffer[cIDX] > conditions.peaksGoldenBuffer[cIDX];
|
|
|
|
//
|
|
isCheBearishOverPeaksGoldenZone =
|
|
conditions.isCheSwitchedToBullish &&
|
|
conditions.se1Buffer[cIDX] < conditions.peaksBuffer[cIDX] &&
|
|
conditions.se1Buffer[cIDX] > conditions.peaksGoldenBuffer[cIDX] &&
|
|
conditions.se2Buffer[cIDX] < conditions.peaksBuffer[cIDX] &&
|
|
conditions.se2Buffer[cIDX] > conditions.peaksGoldenBuffer[cIDX];
|
|
|
|
//
|
|
isCheSwitchedBullishOverPeaksGoldenZone =
|
|
conditions.isCheSwitchedToBullish &&
|
|
conditions.le1Buffer[cIDX] < conditions.peaksBuffer[cIDX] &&
|
|
conditions.le1Buffer[cIDX] > conditions.peaksGoldenBuffer[cIDX] &&
|
|
conditions.le2Buffer[cIDX] < conditions.peaksBuffer[cIDX] &&
|
|
conditions.le2Buffer[cIDX] > conditions.peaksGoldenBuffer[cIDX];
|
|
|
|
//
|
|
isCheSwitchedBearishOverPeaksGoldenZone =
|
|
conditions.isCheSwitchedToBearish &&
|
|
conditions.se1Buffer[cIDX] < conditions.peaksBuffer[cIDX] &&
|
|
conditions.se1Buffer[cIDX] > conditions.peaksGoldenBuffer[cIDX] &&
|
|
conditions.se2Buffer[cIDX] < conditions.peaksBuffer[cIDX] &&
|
|
conditions.se2Buffer[cIDX] > conditions.peaksGoldenBuffer[cIDX];
|
|
|
|
//
|
|
isCheBullishUnderValesGoldenZone =
|
|
conditions.isCheBullish &&
|
|
conditions.cheMin > conditions.valesBuffer[cIDX] &&
|
|
conditions.cheMin < conditions.valesGoldenBuffer[cIDX] &&
|
|
conditions.cheMax > conditions.valesBuffer[cIDX] &&
|
|
conditions.cheMax < conditions.valesGoldenBuffer[cIDX];
|
|
|
|
//
|
|
isCheBearishUnderValesGoldenZone =
|
|
conditions.isCheBearish &&
|
|
conditions.cheMin > conditions.valesBuffer[cIDX] &&
|
|
conditions.cheMin < conditions.valesGoldenBuffer[cIDX] &&
|
|
conditions.cheMax > conditions.valesBuffer[cIDX] &&
|
|
conditions.cheMax < conditions.valesGoldenBuffer[cIDX];
|
|
|
|
//
|
|
isCheSwitchedBullishUnderValesGoldenZone =
|
|
conditions.isCheSwitchedToBullish &&
|
|
conditions.cheMin > conditions.valesBuffer[cIDX] &&
|
|
conditions.cheMin < conditions.valesGoldenBuffer[cIDX] &&
|
|
conditions.cheMax > conditions.valesBuffer[cIDX] &&
|
|
conditions.cheMax < conditions.valesGoldenBuffer[cIDX];
|
|
|
|
//
|
|
isCheSwitchedBearishUnderValesGoldenZone =
|
|
conditions.isCheSwitchedToBearish &&
|
|
conditions.cheMin > conditions.valesBuffer[cIDX] &&
|
|
conditions.cheMin < conditions.valesGoldenBuffer[cIDX] &&
|
|
conditions.cheMax > conditions.valesBuffer[cIDX] &&
|
|
conditions.cheMax < conditions.valesGoldenBuffer[cIDX];
|
|
}
|
|
|
|
//
|
|
// Rejected Box ...
|
|
bool HasSenario1Conditions(
|
|
ENUM_X_CYCLES cycle,
|
|
XBoxZone &box,
|
|
XBoxZone &holderBox,
|
|
ENUM_X_DIRECTION &dir,
|
|
XSignalBox &waitingBoxes[],
|
|
X121SMCStrategySignalProviderData &provider,
|
|
int barIndex = 0 //
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
// Configure ...
|
|
bool forceRetestBox = false;
|
|
bool forceHolderBox = false;
|
|
bool forceConsolidationZone = false;
|
|
|
|
//
|
|
// Fil Selected Data ...
|
|
XPOIState cState;
|
|
X121Conditions cXConditions;
|
|
XPOIStateEvents cStateEvents;
|
|
XC121SMCCycleHelper *cHelper;
|
|
X121SMCCycleConditions cConditions;
|
|
result = provider.SelectCycle(
|
|
cycle,
|
|
cState,
|
|
cStateEvents,
|
|
cXConditions,
|
|
cHelper,
|
|
cConditions //
|
|
);
|
|
if (!result)
|
|
{
|
|
//
|
|
cState.Clean();
|
|
ZeroMemory(cHelper);
|
|
cConditions.Clean();
|
|
cXConditions.Clean();
|
|
cStateEvents.Clean();
|
|
|
|
//
|
|
return result;
|
|
}
|
|
Parse(cXConditions);
|
|
|
|
//
|
|
// Checking Waiting Baoxes Exists ...
|
|
result = HasChild(waitingBoxes);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// 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;
|
|
int ppIDX = pIDX + 1;
|
|
|
|
//
|
|
bool isBullish = false;
|
|
bool isBearish = false;
|
|
|
|
//
|
|
XOHCL zBar;
|
|
XOHCL cBar;
|
|
XOHCL pBar;
|
|
|
|
//
|
|
// Initial Bars ...
|
|
result = zBar.Init(
|
|
cState.symbol,
|
|
cState.period,
|
|
barIndex //
|
|
);
|
|
result =
|
|
result &&
|
|
zBar.GetPreviousBar(cBar);
|
|
result =
|
|
result &&
|
|
cBar.GetPreviousBar(pBar);
|
|
if (!result)
|
|
{
|
|
//
|
|
zBar.Clean();
|
|
cBar.Clean();
|
|
pBar.Clean();
|
|
cState.Clean();
|
|
ZeroMemory(cHelper);
|
|
cConditions.Clean();
|
|
cXConditions.Clean();
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
ENUM_X_DIRECTION iBarPosDir;
|
|
bool isBarValidForDir = cHelper
|
|
.mBarAnalyser
|
|
.IsValidForPosition(
|
|
cBar,
|
|
iBarPosDir //
|
|
);
|
|
bool isBarValidForBullish =
|
|
isBarValidForDir &&
|
|
IsBullish(iBarPosDir);
|
|
bool isBarValidForBearish =
|
|
isBarValidForDir &&
|
|
IsBearish(iBarPosDir);
|
|
|
|
//
|
|
XBoxZone selectedBox;
|
|
XSignalBox iSignalBox;
|
|
count = ArraySize(waitingBoxes);
|
|
has = IsValidSize(count);
|
|
if (has)
|
|
{
|
|
//
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
//
|
|
XSignalBox iBox = waitingBoxes[i];
|
|
|
|
//
|
|
bool isBullish = iBox.ob.IsBullish();
|
|
bool hasFVG = iBox.fvg.IsValid();
|
|
|
|
//
|
|
bool isFVGBullishRejected =
|
|
//
|
|
hasFVG &&
|
|
cBar.low < iBox.fvg.upper &&
|
|
cBar.GetDown() > iBox.fvg.upper
|
|
//
|
|
;
|
|
|
|
//
|
|
bool isFVGBearishRejected =
|
|
//
|
|
hasFVG &&
|
|
cBar.high > iBox.fvg.lower &&
|
|
cBar.GetUp() < iBox.fvg.lower
|
|
//
|
|
;
|
|
|
|
//
|
|
bool isOBBullishRejected =
|
|
//
|
|
cBar.low < iBox.ob.upper &&
|
|
cBar.GetDown() > iBox.ob.upper
|
|
//
|
|
;
|
|
|
|
//
|
|
bool isOBBearishRejected =
|
|
//
|
|
cBar.high > iBox.ob.lower &&
|
|
cBar.GetUp() < iBox.ob.lower
|
|
//
|
|
;
|
|
|
|
//
|
|
has =
|
|
isBullish
|
|
? (hasFVG
|
|
? isFVGBullishRejected
|
|
: isOBBullishRejected)
|
|
: (hasFVG
|
|
? isFVGBearishRejected
|
|
: isOBBearishRejected);
|
|
|
|
//
|
|
// Force Using OB ...
|
|
if (!has && hasFVG)
|
|
{
|
|
//
|
|
has = isBullish
|
|
? isOBBullishRejected
|
|
: isOBBearishRejected;
|
|
|
|
//
|
|
selectedBox = iBox.ob;
|
|
}
|
|
if (has)
|
|
{
|
|
//
|
|
iSignalBox = iBox;
|
|
if (!selectedBox.IsValid())
|
|
{
|
|
//
|
|
if (hasFVG)
|
|
{
|
|
selectedBox = iBox.fvg;
|
|
}
|
|
else
|
|
{
|
|
selectedBox = iBox.ob;
|
|
}
|
|
}
|
|
iBox.Clean();
|
|
break;
|
|
}
|
|
|
|
//
|
|
iBox.Clean();
|
|
}
|
|
}
|
|
has =
|
|
iSignalBox.IsValid() &&
|
|
selectedBox.IsValid();
|
|
|
|
//
|
|
// Retest Signal ...
|
|
int retests = 0;
|
|
if (has)
|
|
{
|
|
//
|
|
int iFromIDX = GetBarIndex(
|
|
cBar.symbol,
|
|
cBar.period,
|
|
selectedBox.from //
|
|
);
|
|
has = IsValidIndex(iFromIDX);
|
|
if (has)
|
|
{
|
|
//
|
|
// Counting Retests ...
|
|
for (int i = iFromIDX; i >= barIndex; i--)
|
|
{
|
|
//
|
|
XOHCL iBar;
|
|
has = iBar.Init(
|
|
cBar.symbol,
|
|
cBar.period,
|
|
i //
|
|
);
|
|
|
|
//
|
|
bool isBullishRetested =
|
|
//
|
|
iBar.low < selectedBox.upper &&
|
|
iBar.GetDown() > selectedBox.upper
|
|
//
|
|
;
|
|
|
|
//
|
|
bool isBearishRetested =
|
|
//
|
|
iBar.high > selectedBox.lower &&
|
|
iBar.GetUp() < selectedBox.lower
|
|
//
|
|
;
|
|
|
|
//
|
|
has = selectedBox.IsBullish()
|
|
? isBullishRetested
|
|
: isBearishRetested;
|
|
if (has)
|
|
{
|
|
retests++;
|
|
}
|
|
|
|
//
|
|
iBar.Clean();
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
bool isSignalBoxRetested =
|
|
!forceRetestBox
|
|
? retests >= 1
|
|
: retests >= 2;
|
|
bool hasSignalBox = iSignalBox.IsValid();
|
|
bool isSignalBoxBullish = IsBullish(iSignalBox.ob.dir);
|
|
|
|
//
|
|
// Check Consolidation Zone ...
|
|
bool hasBullishCZone = true;
|
|
bool hasBearishCZone = true;
|
|
if (forceConsolidationZone)
|
|
{
|
|
//
|
|
XBoxZone cZone;
|
|
XBoxZone tmpBoxes[];
|
|
if (isSignalBoxBullish)
|
|
{
|
|
//
|
|
ToBox(
|
|
cState.bullishConsolidationZones,
|
|
tmpBoxes //
|
|
);
|
|
}
|
|
else
|
|
{
|
|
//
|
|
ToBox(
|
|
cState.bearishConsolidationZones,
|
|
tmpBoxes //
|
|
);
|
|
}
|
|
has = HasChild(tmpBoxes);
|
|
if (has)
|
|
{
|
|
//
|
|
XBoxZone selectedBox;
|
|
if (iSignalBox.fvg.IsValid())
|
|
{
|
|
selectedBox = iSignalBox.fvg;
|
|
}
|
|
else
|
|
{
|
|
selectedBox = iSignalBox.ob;
|
|
}
|
|
|
|
//
|
|
idx = GetYoungest(tmpBoxes);
|
|
has = IsValidIndex(idx);
|
|
if (has)
|
|
{
|
|
//
|
|
cZone = tmpBoxes[idx];
|
|
|
|
//
|
|
// Check Consolidation Zone Place ...
|
|
has =
|
|
//
|
|
(
|
|
//
|
|
IsBoxInsideOr(
|
|
cZone,
|
|
selectedBox //
|
|
)
|
|
//
|
|
&&
|
|
//
|
|
cZone.from >= selectedBox.from
|
|
//
|
|
)
|
|
//
|
|
||
|
|
//
|
|
(
|
|
//
|
|
IsBoxInsideOr(
|
|
selectedBox,
|
|
cZone //
|
|
)
|
|
//
|
|
&&
|
|
//
|
|
selectedBox.from >= cZone.from
|
|
//
|
|
)
|
|
//
|
|
;
|
|
if (!has)
|
|
{
|
|
cZone.Clean();
|
|
}
|
|
}
|
|
|
|
//
|
|
selectedBox.Clean();
|
|
}
|
|
Clean(tmpBoxes);
|
|
|
|
//
|
|
hasBullishCZone = cZone.IsValid() &&
|
|
cZone.IsBullish();
|
|
|
|
//
|
|
hasBearishCZone = cZone.IsValid() &&
|
|
cZone.IsBearish();
|
|
|
|
//
|
|
cZone.Clean();
|
|
}
|
|
|
|
//
|
|
// Bullish Conditions ...
|
|
isBullish =
|
|
//
|
|
// Base Condition ...
|
|
(
|
|
//
|
|
hasSignalBox &&
|
|
hasBullishCZone &&
|
|
isSignalBoxBullish &&
|
|
isSignalBoxRetested &&
|
|
isBarValidForBullish
|
|
//
|
|
)
|
|
//
|
|
;
|
|
|
|
//
|
|
// Bearish Conditions ...
|
|
isBearish =
|
|
//
|
|
// Base Condition ...
|
|
(
|
|
//
|
|
hasSignalBox &&
|
|
hasBearishCZone &&
|
|
!isSignalBoxBullish &&
|
|
isSignalBoxRetested &&
|
|
isBarValidForBearish
|
|
//
|
|
)
|
|
//
|
|
;
|
|
|
|
//
|
|
// Filling Requirements ...
|
|
result =
|
|
isBullish ||
|
|
isBearish;
|
|
if (result)
|
|
{
|
|
//
|
|
dir =
|
|
isBullish
|
|
? X_DIRECTION_BULLISH
|
|
: X_DIRECTION_BEARISH;
|
|
|
|
//
|
|
box = selectedBox;
|
|
box.to = TimeCurrent();
|
|
|
|
//
|
|
// Detect Holder Box ...
|
|
if (forceHolderBox)
|
|
{
|
|
//
|
|
XBoxZone tmpBoxes[];
|
|
if (isBullish)
|
|
{
|
|
//
|
|
// Order Blocks ...
|
|
XBoxZone tmp[];
|
|
ToBox(
|
|
cState.bullishOrderBlocks,
|
|
tmp //
|
|
);
|
|
Copy(
|
|
tmp,
|
|
tmpBoxes //
|
|
);
|
|
Clean(tmp);
|
|
|
|
//
|
|
// Fair Value Gaps ...
|
|
ToBox(
|
|
cState.bullishFairValueGaps,
|
|
tmp //
|
|
);
|
|
Copy(
|
|
tmp,
|
|
tmpBoxes,
|
|
false // Ignore Clean ...
|
|
);
|
|
Clean(tmp);
|
|
|
|
//
|
|
// Support Zones ...
|
|
ToBox(
|
|
cState.supportZones,
|
|
tmp //
|
|
);
|
|
Copy(
|
|
tmp,
|
|
tmpBoxes,
|
|
false // Ignore Clean ...
|
|
);
|
|
Clean(tmp);
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Order Blocks ...
|
|
XBoxZone tmp[];
|
|
ToBox(
|
|
cState.bearishOrderBlocks,
|
|
tmp //
|
|
);
|
|
Copy(
|
|
tmp,
|
|
tmpBoxes //
|
|
);
|
|
Clean(tmp);
|
|
|
|
//
|
|
// Fair Value Gaps ...
|
|
ToBox(
|
|
cState.bearishFairValueGaps,
|
|
tmp //
|
|
);
|
|
Copy(
|
|
tmp,
|
|
tmpBoxes,
|
|
false // Ignore Clean ...
|
|
);
|
|
Clean(tmp);
|
|
|
|
//
|
|
// Resistance Zones ...
|
|
ToBox(
|
|
cState.resistanceZones,
|
|
tmp //
|
|
);
|
|
Copy(
|
|
tmp,
|
|
tmpBoxes,
|
|
false // Ignore Clean ...
|
|
);
|
|
Clean(tmp);
|
|
}
|
|
|
|
//
|
|
count = ArraySize(tmpBoxes);
|
|
has = IsValidSize(count);
|
|
if (has)
|
|
{
|
|
//
|
|
while (HasChild(tmpBoxes))
|
|
{
|
|
//
|
|
idx = GetOldest(tmpBoxes);
|
|
has = IsValidIndex(idx);
|
|
if (!has)
|
|
{
|
|
break;
|
|
}
|
|
|
|
//
|
|
XBoxZone iBox = tmpBoxes[idx];
|
|
ArrayRemove(
|
|
tmpBoxes,
|
|
idx,
|
|
1 //
|
|
);
|
|
|
|
//
|
|
has = IsBoxInside(
|
|
iBox,
|
|
box //
|
|
);
|
|
if (has)
|
|
{
|
|
//
|
|
holderBox = iBox;
|
|
holderBox.to = TimeCurrent();
|
|
iBox.Clean();
|
|
break;
|
|
}
|
|
|
|
//
|
|
iBox.Clean();
|
|
}
|
|
}
|
|
|
|
//
|
|
Clean(tmpBoxes);
|
|
|
|
//
|
|
result =
|
|
result &&
|
|
holderBox.IsValid() &&
|
|
holderBox.dir == dir;
|
|
if (!result)
|
|
{
|
|
//
|
|
box.Clean();
|
|
isBullish = false;
|
|
isBearish = false;
|
|
holderBox.Clean();
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Check All Conditions ...
|
|
result =
|
|
box.IsValid() &&
|
|
HasDirection(dir) &&
|
|
(isBullish ||
|
|
isBearish);
|
|
|
|
//
|
|
// Cleanup Resources ...
|
|
zBar.Clean();
|
|
cBar.Clean();
|
|
pBar.Clean();
|
|
cState.Clean();
|
|
iSignalBox.Clean();
|
|
selectedBox.Clean();
|
|
ZeroMemory(cHelper);
|
|
cConditions.Clean();
|
|
cStateEvents.Clean();
|
|
cXConditions.Clean();
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Activated Box
|
|
bool HasSenario2Conditions(
|
|
ENUM_X_CYCLES cycle,
|
|
XBoxZone &box,
|
|
XBoxZone &holderBox,
|
|
ENUM_X_DIRECTION &dir,
|
|
XSignalBox &waitingBoxes[],
|
|
X121SMCStrategySignalProviderData &provider,
|
|
int barIndex = 0 //
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
// Fil Selected Data ...
|
|
XPOIState cState;
|
|
X121Conditions cXConditions;
|
|
XPOIStateEvents cStateEvents;
|
|
XC121SMCCycleHelper *cHelper;
|
|
X121SMCCycleConditions cConditions;
|
|
result = provider.SelectCycle(
|
|
cycle,
|
|
cState,
|
|
cStateEvents,
|
|
cXConditions,
|
|
cHelper,
|
|
cConditions //
|
|
);
|
|
if (!result)
|
|
{
|
|
//
|
|
cState.Clean();
|
|
ZeroMemory(cHelper);
|
|
cConditions.Clean();
|
|
cXConditions.Clean();
|
|
cStateEvents.Clean();
|
|
|
|
//
|
|
return result;
|
|
}
|
|
Parse(cXConditions);
|
|
|
|
//
|
|
// Checking Waiting Baoxes Exists ...
|
|
result = HasChild(waitingBoxes);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// 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;
|
|
int ppIDX = pIDX + 1;
|
|
|
|
//
|
|
bool isBullish = false;
|
|
bool isBearish = false;
|
|
|
|
//
|
|
XOHCL zBar;
|
|
XOHCL cBar;
|
|
XOHCL pBar;
|
|
XOHCL pPBar;
|
|
|
|
//
|
|
// Initial Bars ...
|
|
result = zBar.Init(
|
|
cState.symbol,
|
|
cState.period,
|
|
barIndex //
|
|
);
|
|
result =
|
|
result &&
|
|
zBar.GetPreviousBar(cBar);
|
|
result =
|
|
result &&
|
|
cBar.GetPreviousBar(pBar);
|
|
result =
|
|
result &&
|
|
pBar.GetPreviousBar(pPBar);
|
|
if (!result)
|
|
{
|
|
//
|
|
zBar.Clean();
|
|
cBar.Clean();
|
|
pBar.Clean();
|
|
pPBar.Clean();
|
|
cState.Clean();
|
|
ZeroMemory(cHelper);
|
|
cConditions.Clean();
|
|
cXConditions.Clean();
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
ENUM_X_DIRECTION iBarPosDir;
|
|
bool isBarValidForDir = cHelper
|
|
.mBarAnalyser
|
|
.IsValidForPosition(
|
|
cBar,
|
|
iBarPosDir //
|
|
);
|
|
bool isBarValidForBullish =
|
|
isBarValidForDir &&
|
|
IsBullish(iBarPosDir);
|
|
bool isBarValidForBearish =
|
|
isBarValidForDir &&
|
|
IsBearish(iBarPosDir);
|
|
|
|
//
|
|
XSignalBox iSignalBox;
|
|
count = ArraySize(waitingBoxes);
|
|
has = IsValidSize(count);
|
|
if (has)
|
|
{
|
|
//
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
//
|
|
XSignalBox iBox = waitingBoxes[i];
|
|
|
|
//
|
|
bool isBullish = iBox.ob.IsBullish();
|
|
bool hasFVG = iBox.fvg.IsValid();
|
|
|
|
//
|
|
// Checking Inside ...
|
|
|
|
//
|
|
bool isBullishInsideFVG =
|
|
//
|
|
hasFVG &&
|
|
pBar.high < iBox.fvg.upper &&
|
|
pPBar.high < iBox.fvg.upper
|
|
//
|
|
;
|
|
|
|
//
|
|
bool isBearishInsideFVG =
|
|
//
|
|
hasFVG &&
|
|
pBar.low > iBox.fvg.lower &&
|
|
pPBar.low > iBox.fvg.lower
|
|
//
|
|
;
|
|
|
|
//
|
|
bool isBullishInsideOB =
|
|
//
|
|
pBar.high < iBox.ob.upper &&
|
|
pPBar.high < iBox.ob.upper
|
|
//
|
|
;
|
|
|
|
//
|
|
bool isBearishInsideOB =
|
|
//
|
|
pBar.low > iBox.ob.lower &&
|
|
pPBar.low > iBox.ob.lower
|
|
//
|
|
;
|
|
|
|
//
|
|
// Checking Breakes Box ...
|
|
|
|
//
|
|
bool isFVGBullishBreaked =
|
|
//
|
|
hasFVG &&
|
|
isBullishInsideFVG &&
|
|
//
|
|
cBar.high > iBox.fvg.upper &&
|
|
cBar.close > iBox.fvg.upper &&
|
|
//
|
|
zBar.open > iBox.fvg.upper
|
|
//
|
|
;
|
|
|
|
//
|
|
bool isFVGBearishBreaked =
|
|
//
|
|
hasFVG &&
|
|
isBearishInsideFVG &&
|
|
//
|
|
cBar.low < iBox.fvg.lower &&
|
|
cBar.close < iBox.fvg.lower &&
|
|
//
|
|
zBar.open > iBox.fvg.lower
|
|
//
|
|
;
|
|
|
|
//
|
|
bool isOBBullishBreaked =
|
|
//
|
|
isBullishInsideOB &&
|
|
//
|
|
cBar.high > iBox.ob.upper &&
|
|
cBar.close > iBox.ob.upper &&
|
|
//
|
|
zBar.open > iBox.ob.upper
|
|
//
|
|
;
|
|
|
|
//
|
|
bool isOBBearishBreaked =
|
|
//
|
|
isBearishInsideOB &&
|
|
//
|
|
cBar.low < iBox.ob.lower &&
|
|
cBar.close < iBox.ob.lower &&
|
|
//
|
|
zBar.open > iBox.ob.lower
|
|
//
|
|
;
|
|
|
|
//
|
|
// Summarise ...
|
|
|
|
//
|
|
bool isBullishBreaked =
|
|
isBarValidForBullish &&
|
|
(hasFVG
|
|
? isFVGBullishBreaked
|
|
: isOBBullishBreaked);
|
|
|
|
//
|
|
bool isBearishBreaked =
|
|
isBarValidForBearish &&
|
|
(hasFVG
|
|
? isFVGBearishBreaked
|
|
: isOBBearishBreaked);
|
|
|
|
//
|
|
has = isBullishBreaked ||
|
|
isBearishBreaked;
|
|
//
|
|
if (has)
|
|
{
|
|
//
|
|
iSignalBox = iBox;
|
|
iBox.Clean();
|
|
|
|
//
|
|
dir =
|
|
isBullishBreaked
|
|
? X_DIRECTION_BULLISH
|
|
: isBearishBreaked
|
|
? X_DIRECTION_BEARISH
|
|
: X_DIRECTION_NONE;
|
|
|
|
//
|
|
break;
|
|
}
|
|
|
|
//
|
|
iBox.Clean();
|
|
}
|
|
}
|
|
|
|
//
|
|
bool hasSignalBox = HasDirection(dir) &&
|
|
iSignalBox.IsValid();
|
|
bool isSignalBoxBullish = IsBullish(dir);
|
|
|
|
//
|
|
// Bullish Conditions ...
|
|
isBullish =
|
|
//
|
|
// Base Condition ...
|
|
(
|
|
//
|
|
hasSignalBox &&
|
|
isSignalBoxBullish &&
|
|
isBarValidForBullish
|
|
//
|
|
)
|
|
//
|
|
;
|
|
|
|
//
|
|
// Bearish Conditions ...
|
|
isBearish =
|
|
//
|
|
// Base Condition ...
|
|
(
|
|
//
|
|
hasSignalBox &&
|
|
!isSignalBoxBullish &&
|
|
isBarValidForBearish
|
|
//
|
|
)
|
|
//
|
|
;
|
|
|
|
//
|
|
// Filling Requirements ...
|
|
result =
|
|
isBullish ||
|
|
isBearish;
|
|
if (result)
|
|
{
|
|
//
|
|
dir =
|
|
isBullish
|
|
? X_DIRECTION_BULLISH
|
|
: X_DIRECTION_BEARISH;
|
|
|
|
//
|
|
if (iSignalBox.fvg.IsValid())
|
|
{
|
|
box = iSignalBox.fvg;
|
|
}
|
|
else
|
|
{
|
|
box = iSignalBox.ob;
|
|
}
|
|
|
|
//
|
|
box.to = TimeCurrent();
|
|
|
|
//
|
|
// Detect Holder Box ...
|
|
XBoxZone tmpBoxes[];
|
|
if (isBullish)
|
|
{
|
|
//
|
|
// Order Blocks ...
|
|
XBoxZone tmp[];
|
|
ToBox(
|
|
cState.bullishOrderBlocks,
|
|
tmp //
|
|
);
|
|
Copy(
|
|
tmp,
|
|
tmpBoxes //
|
|
);
|
|
Clean(tmp);
|
|
|
|
//
|
|
// Fair Value Gaps ...
|
|
ToBox(
|
|
cState.bullishFairValueGaps,
|
|
tmp //
|
|
);
|
|
Copy(
|
|
tmp,
|
|
tmpBoxes,
|
|
false // Ignore Clean ...
|
|
);
|
|
Clean(tmp);
|
|
|
|
//
|
|
// Support Zones ...
|
|
ToBox(
|
|
cState.supportZones,
|
|
tmp //
|
|
);
|
|
Copy(
|
|
tmp,
|
|
tmpBoxes,
|
|
false // Ignore Clean ...
|
|
);
|
|
Clean(tmp);
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Order Blocks ...
|
|
XBoxZone tmp[];
|
|
ToBox(
|
|
cState.bearishOrderBlocks,
|
|
tmp //
|
|
);
|
|
Copy(
|
|
tmp,
|
|
tmpBoxes //
|
|
);
|
|
Clean(tmp);
|
|
|
|
//
|
|
// Fair Value Gaps ...
|
|
ToBox(
|
|
cState.bearishFairValueGaps,
|
|
tmp //
|
|
);
|
|
Copy(
|
|
tmp,
|
|
tmpBoxes,
|
|
false // Ignore Clean ...
|
|
);
|
|
Clean(tmp);
|
|
|
|
//
|
|
// Resistance Zones ...
|
|
ToBox(
|
|
cState.resistanceZones,
|
|
tmp //
|
|
);
|
|
Copy(
|
|
tmp,
|
|
tmpBoxes,
|
|
false // Ignore Clean ...
|
|
);
|
|
Clean(tmp);
|
|
}
|
|
|
|
//
|
|
count = ArraySize(tmpBoxes);
|
|
has = IsValidSize(count);
|
|
if (has)
|
|
{
|
|
//
|
|
while (HasChild(tmpBoxes))
|
|
{
|
|
//
|
|
idx = GetOldest(tmpBoxes);
|
|
has = IsValidIndex(idx);
|
|
if (!has)
|
|
{
|
|
break;
|
|
}
|
|
|
|
//
|
|
XBoxZone iBox = tmpBoxes[idx];
|
|
ArrayRemove(
|
|
tmpBoxes,
|
|
idx,
|
|
1 //
|
|
);
|
|
|
|
//
|
|
has = IsBoxInside(
|
|
iBox,
|
|
box //
|
|
);
|
|
if (has)
|
|
{
|
|
//
|
|
holderBox = iBox;
|
|
holderBox.to = TimeCurrent();
|
|
iBox.Clean();
|
|
break;
|
|
}
|
|
|
|
//
|
|
iBox.Clean();
|
|
}
|
|
}
|
|
|
|
//
|
|
Clean(tmpBoxes);
|
|
|
|
//
|
|
result =
|
|
result &&
|
|
holderBox.IsValid() &&
|
|
holderBox.dir == dir;
|
|
if (!result)
|
|
{
|
|
//
|
|
box.Clean();
|
|
isBullish = false;
|
|
isBearish = false;
|
|
holderBox.Clean();
|
|
}
|
|
}
|
|
|
|
//
|
|
// Check All Conditions ...
|
|
result =
|
|
box.IsValid() &&
|
|
HasDirection(dir) &&
|
|
(isBullish ||
|
|
isBearish);
|
|
|
|
//
|
|
// Cleanup Resources ...
|
|
zBar.Clean();
|
|
cBar.Clean();
|
|
pBar.Clean();
|
|
pPBar.Clean();
|
|
cState.Clean();
|
|
iSignalBox.Clean();
|
|
ZeroMemory(cHelper);
|
|
cConditions.Clean();
|
|
cStateEvents.Clean();
|
|
cXConditions.Clean();
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Breaked Box
|
|
bool HasSenario3Conditions(
|
|
ENUM_X_CYCLES cycle,
|
|
XBoxZone &box,
|
|
XBoxZone &holderBox,
|
|
ENUM_X_DIRECTION &dir,
|
|
XSignalBox &waitingBoxes[],
|
|
X121SMCStrategySignalProviderData &provider,
|
|
int barIndex = 0 //
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
// Fil Selected Data ...
|
|
XPOIState cState;
|
|
X121Conditions cXConditions;
|
|
XPOIStateEvents cStateEvents;
|
|
XC121SMCCycleHelper *cHelper;
|
|
X121SMCCycleConditions cConditions;
|
|
result = provider.SelectCycle(
|
|
cycle,
|
|
cState,
|
|
cStateEvents,
|
|
cXConditions,
|
|
cHelper,
|
|
cConditions //
|
|
);
|
|
if (!result)
|
|
{
|
|
//
|
|
cState.Clean();
|
|
ZeroMemory(cHelper);
|
|
cConditions.Clean();
|
|
cXConditions.Clean();
|
|
cStateEvents.Clean();
|
|
|
|
//
|
|
return result;
|
|
}
|
|
Parse(cXConditions);
|
|
|
|
//
|
|
// Checking Waiting Baoxes Exists ...
|
|
result = HasChild(waitingBoxes);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// 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;
|
|
int ppIDX = pIDX + 1;
|
|
|
|
//
|
|
bool isBullish = false;
|
|
bool isBearish = false;
|
|
|
|
//
|
|
XOHCL zBar;
|
|
XOHCL cBar;
|
|
XOHCL pBar;
|
|
XOHCL pPBar;
|
|
|
|
//
|
|
// Initial Bars ...
|
|
result = zBar.Init(
|
|
cState.symbol,
|
|
cState.period,
|
|
barIndex //
|
|
);
|
|
result =
|
|
result &&
|
|
zBar.GetPreviousBar(cBar);
|
|
result =
|
|
result &&
|
|
cBar.GetPreviousBar(pBar);
|
|
result =
|
|
result &&
|
|
pBar.GetPreviousBar(pPBar);
|
|
if (!result)
|
|
{
|
|
//
|
|
zBar.Clean();
|
|
cBar.Clean();
|
|
pBar.Clean();
|
|
pPBar.Clean();
|
|
cState.Clean();
|
|
ZeroMemory(cHelper);
|
|
cConditions.Clean();
|
|
cXConditions.Clean();
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
ENUM_X_DIRECTION iBarPosDir;
|
|
bool isBarValidForDir = cHelper
|
|
.mBarAnalyser
|
|
.IsValidForPosition(
|
|
cBar,
|
|
iBarPosDir //
|
|
);
|
|
bool isBarValidForBullish =
|
|
isBarValidForDir &&
|
|
IsBullish(iBarPosDir);
|
|
bool isBarValidForBearish =
|
|
isBarValidForDir &&
|
|
IsBearish(iBarPosDir);
|
|
|
|
//
|
|
XSignalBox iSignalBox;
|
|
count = ArraySize(waitingBoxes);
|
|
has = IsValidSize(count);
|
|
if (has)
|
|
{
|
|
//
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
//
|
|
XSignalBox iBox = waitingBoxes[i];
|
|
|
|
//
|
|
bool isBullish = iBox.ob.IsBullish();
|
|
bool hasFVG = iBox.fvg.IsValid();
|
|
|
|
//
|
|
// Checking Breakes Box ...
|
|
|
|
//
|
|
bool isFVGBullishBreaked =
|
|
//
|
|
hasFVG &&
|
|
//
|
|
pBar.low < iBox.fvg.upper &&
|
|
//
|
|
cBar.high > iBox.fvg.upper &&
|
|
cBar.close > iBox.fvg.upper &&
|
|
//
|
|
zBar.open > iBox.fvg.upper
|
|
//
|
|
;
|
|
|
|
//
|
|
bool isFVGBearishBreaked =
|
|
//
|
|
hasFVG &&
|
|
//
|
|
pBar.high > iBox.fvg.lower &&
|
|
//
|
|
cBar.low < iBox.fvg.lower &&
|
|
cBar.close < iBox.fvg.lower &&
|
|
//
|
|
zBar.open > iBox.fvg.lower
|
|
//
|
|
;
|
|
|
|
//
|
|
bool isOBBullishBreaked =
|
|
//
|
|
pBar.low < iBox.ob.upper &&
|
|
//
|
|
cBar.high > iBox.ob.upper &&
|
|
cBar.close > iBox.ob.upper &&
|
|
//
|
|
zBar.open > iBox.ob.upper
|
|
//
|
|
;
|
|
|
|
//
|
|
bool isOBBearishBreaked =
|
|
//
|
|
pBar.high > iBox.ob.lower &&
|
|
//
|
|
cBar.low < iBox.ob.lower &&
|
|
cBar.close < iBox.ob.lower &&
|
|
//
|
|
zBar.open > iBox.ob.lower
|
|
//
|
|
;
|
|
|
|
//
|
|
// Summarise ...
|
|
|
|
//
|
|
bool isBullishBreaked =
|
|
isBarValidForBullish &&
|
|
(hasFVG
|
|
? isFVGBullishBreaked
|
|
: isOBBullishBreaked);
|
|
|
|
//
|
|
bool isBearishBreaked =
|
|
isBarValidForBearish &&
|
|
(hasFVG
|
|
? isFVGBearishBreaked
|
|
: isOBBearishBreaked);
|
|
|
|
//
|
|
has = isBullishBreaked ||
|
|
isBearishBreaked;
|
|
//
|
|
if (has)
|
|
{
|
|
//
|
|
iSignalBox = iBox;
|
|
iBox.Clean();
|
|
|
|
//
|
|
dir =
|
|
isBullishBreaked
|
|
? X_DIRECTION_BULLISH
|
|
: isBearishBreaked
|
|
? X_DIRECTION_BEARISH
|
|
: X_DIRECTION_NONE;
|
|
|
|
//
|
|
break;
|
|
}
|
|
|
|
//
|
|
iBox.Clean();
|
|
}
|
|
}
|
|
|
|
//
|
|
bool hasSignalBox = HasDirection(dir) &&
|
|
iSignalBox.IsValid();
|
|
bool isSignalBoxBullish = IsBullish(dir);
|
|
|
|
//
|
|
// Bullish Conditions ...
|
|
isBullish =
|
|
//
|
|
// Base Condition ...
|
|
(
|
|
//
|
|
hasSignalBox &&
|
|
isSignalBoxBullish &&
|
|
isBarValidForBullish
|
|
//
|
|
)
|
|
//
|
|
;
|
|
|
|
//
|
|
// Bearish Conditions ...
|
|
isBearish =
|
|
//
|
|
// Base Condition ...
|
|
(
|
|
//
|
|
hasSignalBox &&
|
|
!isSignalBoxBullish &&
|
|
isBarValidForBearish
|
|
//
|
|
)
|
|
//
|
|
;
|
|
|
|
//
|
|
// Filling Requirements ...
|
|
result =
|
|
isBullish ||
|
|
isBearish;
|
|
if (result)
|
|
{
|
|
//
|
|
dir =
|
|
isBullish
|
|
? X_DIRECTION_BULLISH
|
|
: X_DIRECTION_BEARISH;
|
|
|
|
//
|
|
if (iSignalBox.fvg.IsValid())
|
|
{
|
|
box = iSignalBox.fvg;
|
|
}
|
|
else
|
|
{
|
|
box = iSignalBox.ob;
|
|
}
|
|
|
|
//
|
|
box.to = TimeCurrent();
|
|
|
|
//
|
|
// Detect Holder Box ...
|
|
XBoxZone tmpBoxes[];
|
|
if (isBullish)
|
|
{
|
|
//
|
|
// Order Blocks ...
|
|
XBoxZone tmp[];
|
|
ToBox(
|
|
cState.bullishOrderBlocks,
|
|
tmp //
|
|
);
|
|
Copy(
|
|
tmp,
|
|
tmpBoxes //
|
|
);
|
|
Clean(tmp);
|
|
|
|
//
|
|
// Fair Value Gaps ...
|
|
ToBox(
|
|
cState.bullishFairValueGaps,
|
|
tmp //
|
|
);
|
|
Copy(
|
|
tmp,
|
|
tmpBoxes,
|
|
false // Ignore Clean ...
|
|
);
|
|
Clean(tmp);
|
|
|
|
//
|
|
// Support Zones ...
|
|
ToBox(
|
|
cState.supportZones,
|
|
tmp //
|
|
);
|
|
Copy(
|
|
tmp,
|
|
tmpBoxes,
|
|
false // Ignore Clean ...
|
|
);
|
|
Clean(tmp);
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Order Blocks ...
|
|
XBoxZone tmp[];
|
|
ToBox(
|
|
cState.bearishOrderBlocks,
|
|
tmp //
|
|
);
|
|
Copy(
|
|
tmp,
|
|
tmpBoxes //
|
|
);
|
|
Clean(tmp);
|
|
|
|
//
|
|
// Fair Value Gaps ...
|
|
ToBox(
|
|
cState.bearishFairValueGaps,
|
|
tmp //
|
|
);
|
|
Copy(
|
|
tmp,
|
|
tmpBoxes,
|
|
false // Ignore Clean ...
|
|
);
|
|
Clean(tmp);
|
|
|
|
//
|
|
// Resistance Zones ...
|
|
ToBox(
|
|
cState.resistanceZones,
|
|
tmp //
|
|
);
|
|
Copy(
|
|
tmp,
|
|
tmpBoxes,
|
|
false // Ignore Clean ...
|
|
);
|
|
Clean(tmp);
|
|
}
|
|
|
|
//
|
|
count = ArraySize(tmpBoxes);
|
|
has = IsValidSize(count);
|
|
if (has)
|
|
{
|
|
//
|
|
while (HasChild(tmpBoxes))
|
|
{
|
|
//
|
|
idx = GetOldest(tmpBoxes);
|
|
has = IsValidIndex(idx);
|
|
if (!has)
|
|
{
|
|
break;
|
|
}
|
|
|
|
//
|
|
XBoxZone iBox = tmpBoxes[idx];
|
|
ArrayRemove(
|
|
tmpBoxes,
|
|
idx,
|
|
1 //
|
|
);
|
|
|
|
//
|
|
has = IsBoxInside(
|
|
iBox,
|
|
box //
|
|
);
|
|
if (has)
|
|
{
|
|
//
|
|
holderBox = iBox;
|
|
holderBox.to = TimeCurrent();
|
|
iBox.Clean();
|
|
break;
|
|
}
|
|
|
|
//
|
|
iBox.Clean();
|
|
}
|
|
}
|
|
|
|
//
|
|
Clean(tmpBoxes);
|
|
|
|
//
|
|
result =
|
|
result &&
|
|
holderBox.IsValid() &&
|
|
holderBox.dir == dir;
|
|
if (!result)
|
|
{
|
|
//
|
|
box.Clean();
|
|
isBullish = false;
|
|
isBearish = false;
|
|
holderBox.Clean();
|
|
}
|
|
}
|
|
|
|
//
|
|
// Check All Conditions ...
|
|
result =
|
|
box.IsValid() &&
|
|
HasDirection(dir) &&
|
|
(isBullish ||
|
|
isBearish);
|
|
|
|
//
|
|
// Cleanup Resources ...
|
|
zBar.Clean();
|
|
cBar.Clean();
|
|
pBar.Clean();
|
|
pPBar.Clean();
|
|
cState.Clean();
|
|
iSignalBox.Clean();
|
|
ZeroMemory(cHelper);
|
|
cConditions.Clean();
|
|
cStateEvents.Clean();
|
|
cXConditions.Clean();
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// XHKMA ...
|
|
bool HasSenario4Conditions(
|
|
ENUM_X_CYCLES cycle,
|
|
ENUM_X_DIRECTION trend,
|
|
XBoxZone &box,
|
|
XBoxZone &holderBox,
|
|
ENUM_X_DIRECTION &dir,
|
|
XSignalBox &waitingBoxes[],
|
|
X121SMCStrategySignalProviderData &provider,
|
|
int barIndex = 0 //
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
int idx = -1;
|
|
int count = 0;
|
|
bool has = false;
|
|
|
|
//
|
|
// Normalize Args ...
|
|
|
|
//
|
|
box.Clean();
|
|
holderBox.Clean();
|
|
dir = X_DIRECTION_NONE;
|
|
|
|
//
|
|
if (barIndex < 0)
|
|
{
|
|
barIndex = 0;
|
|
}
|
|
|
|
//
|
|
// Check Trend Exists ...
|
|
result = HasDirection(trend);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Extrand Trend Direction ...
|
|
bool hasBullishTrend = IsBullish(trend);
|
|
bool hasBearishTrend = IsBearish(trend);
|
|
|
|
//
|
|
// Checking Waiting Baoxes Exists ...
|
|
result = HasChild(waitingBoxes);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Check Current Waiting Box is Directional To Trend ...
|
|
XSignalBox iSignalBox;
|
|
idx = GetYoungest(waitingBoxes);
|
|
result = IsValidIndex(idx);
|
|
if (!result)
|
|
{
|
|
//
|
|
iSignalBox.Clean();
|
|
return result;
|
|
}
|
|
iSignalBox = waitingBoxes[idx];
|
|
result = iSignalBox.IsValid() &&
|
|
iSignalBox.ob.dir == trend;
|
|
if (!result)
|
|
{
|
|
//
|
|
iSignalBox.Clean();
|
|
return result;
|
|
}
|
|
|
|
//
|
|
bool hasBullishSignalBox = iSignalBox.IsValid() &&
|
|
iSignalBox.ob.IsBullish();
|
|
|
|
//
|
|
bool hasBearishSignalBox = iSignalBox.IsValid() &&
|
|
iSignalBox.ob.IsBearish();
|
|
|
|
//
|
|
// Fil Selected Data ...
|
|
XPOIState cState;
|
|
X121Conditions cXConditions;
|
|
XPOIStateEvents cStateEvents;
|
|
XC121SMCCycleHelper *cHelper;
|
|
X121SMCCycleConditions cConditions;
|
|
result = provider.SelectCycle(
|
|
cycle,
|
|
cState,
|
|
cStateEvents,
|
|
cXConditions,
|
|
cHelper,
|
|
cConditions //
|
|
);
|
|
if (!result)
|
|
{
|
|
//
|
|
cState.Clean();
|
|
ZeroMemory(cHelper);
|
|
cConditions.Clean();
|
|
cXConditions.Clean();
|
|
cStateEvents.Clean();
|
|
|
|
//
|
|
return result;
|
|
}
|
|
Parse(cXConditions);
|
|
|
|
//
|
|
int zIDX = barIndex;
|
|
int cIDX = zIDX + 1;
|
|
int pIDX = cIDX + 1;
|
|
int ppIDX = pIDX + 1;
|
|
|
|
//
|
|
bool isBullish = false;
|
|
bool isBearish = false;
|
|
|
|
//
|
|
XOHCL zBar;
|
|
XOHCL cBar;
|
|
XOHCL pBar;
|
|
XOHCL pPBar;
|
|
|
|
//
|
|
// Initial Bars ...
|
|
result = zBar.Init(
|
|
cState.symbol,
|
|
cState.period,
|
|
barIndex //
|
|
);
|
|
result =
|
|
result &&
|
|
zBar.GetPreviousBar(cBar);
|
|
result =
|
|
result &&
|
|
cBar.GetPreviousBar(pBar);
|
|
result =
|
|
result &&
|
|
pBar.GetPreviousBar(pPBar);
|
|
if (!result)
|
|
{
|
|
//
|
|
zBar.Clean();
|
|
cBar.Clean();
|
|
pBar.Clean();
|
|
pPBar.Clean();
|
|
cState.Clean();
|
|
ZeroMemory(cHelper);
|
|
cConditions.Clean();
|
|
cXConditions.Clean();
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
ENUM_X_DIRECTION iBarPosDir;
|
|
bool isBarValidForDir = cHelper
|
|
.mBarAnalyser
|
|
.IsValidForPosition(
|
|
cBar,
|
|
iBarPosDir //
|
|
);
|
|
bool isBarValidForBullish =
|
|
isBarValidForDir &&
|
|
IsBullish(iBarPosDir);
|
|
bool isBarValidForBearish =
|
|
isBarValidForDir &&
|
|
IsBearish(iBarPosDir);
|
|
|
|
//
|
|
// Check Bar Validation for Trend Based Directions ...
|
|
result =
|
|
isBarValidForDir &&
|
|
iBarPosDir == trend &&
|
|
HasDirection(iBarPosDir);
|
|
if (!result)
|
|
{
|
|
//
|
|
// Cleanup Resources ...
|
|
zBar.Clean();
|
|
cBar.Clean();
|
|
pBar.Clean();
|
|
pPBar.Clean();
|
|
cState.Clean();
|
|
iSignalBox.Clean();
|
|
ZeroMemory(cHelper);
|
|
cConditions.Clean();
|
|
cStateEvents.Clean();
|
|
cXConditions.Clean();
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Here we Have to Check Other Consitions Based On Current
|
|
// Stuffs ...
|
|
XBoxZone zoneBox;
|
|
|
|
//
|
|
// Select Boxes for Zones ...
|
|
XBoxZone tmpBoxes[];
|
|
if (hasBullishTrend)
|
|
{
|
|
//
|
|
XBoxZone tmp[];
|
|
|
|
//
|
|
// Order Blocks ...
|
|
// ToBox(
|
|
// cState.bullishOrderBlocks,
|
|
// tmp //
|
|
// );
|
|
// Copy(
|
|
// tmp,
|
|
// tmpBoxes //
|
|
// );
|
|
// Clean(tmp);
|
|
|
|
//
|
|
// Fair Value Gaps ...
|
|
ToBox(
|
|
cState.bullishFairValueGaps,
|
|
tmp //
|
|
);
|
|
Copy(
|
|
tmp,
|
|
tmpBoxes,
|
|
false // Ignore Clean ...
|
|
);
|
|
Clean(tmp);
|
|
}
|
|
else if (hasBearishTrend)
|
|
{
|
|
//
|
|
XBoxZone tmp[];
|
|
|
|
//
|
|
// Order Blocks ...
|
|
// ToBox(
|
|
// cState.bearishOrderBlocks,
|
|
// tmp //
|
|
// );
|
|
// Copy(
|
|
// tmp,
|
|
// tmpBoxes //
|
|
// );
|
|
// Clean(tmp);
|
|
|
|
//
|
|
// Fair Value Gaps ...
|
|
ToBox(
|
|
cState.bearishFairValueGaps,
|
|
tmp //
|
|
);
|
|
Copy(
|
|
tmp,
|
|
tmpBoxes,
|
|
false // Ignore Clean ...
|
|
);
|
|
Clean(tmp);
|
|
}
|
|
has = HasChild(tmpBoxes);
|
|
if (has)
|
|
{
|
|
//
|
|
while (HasChild(tmpBoxes))
|
|
{
|
|
//
|
|
// Select Box based on Trend ...
|
|
idx = hasBullishTrend
|
|
? GetLowest(tmpBoxes)
|
|
: hasBearishTrend
|
|
? GetHighest(tmpBoxes)
|
|
: -1;
|
|
has = IsValidIndex(idx);
|
|
if (!has)
|
|
{
|
|
break;
|
|
}
|
|
|
|
//
|
|
XBoxZone iBox = tmpBoxes[idx];
|
|
ArrayRemove(
|
|
tmpBoxes,
|
|
idx,
|
|
1 //
|
|
);
|
|
|
|
//
|
|
// Validate Selected Box ...
|
|
bool isDirPassed = iBox.dir == trend;
|
|
bool isFromPassed =
|
|
iSignalBox.fvg.IsValid()
|
|
? iBox.from > iSignalBox.fvg.from
|
|
: iBox.from > iSignalBox.ob.from;
|
|
bool isPriceInsidePassed =
|
|
hasBullishTrend
|
|
? cBar.low < iBox.upper &&
|
|
cBar.low > iBox.lower
|
|
: hasBearishTrend
|
|
? cBar.high > iBox.lower &&
|
|
cBar.high < iBox.upper
|
|
: false;
|
|
has = isDirPassed &&
|
|
isFromPassed &&
|
|
isPriceInsidePassed;
|
|
if (has)
|
|
{
|
|
//
|
|
zoneBox = iBox;
|
|
iBox.Clean();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
Clean(tmpBoxes);
|
|
|
|
//
|
|
bool hasBullishZoneBox = zoneBox.IsValid() &&
|
|
zoneBox.IsBullish();
|
|
|
|
//
|
|
bool hasBearishZoneBox = zoneBox.IsValid() &&
|
|
zoneBox.IsBearish();
|
|
|
|
//
|
|
// Detecting Consolidation Zone ...
|
|
XBoxZone cZone;
|
|
if (hasBullishTrend)
|
|
{
|
|
//
|
|
ToBox(
|
|
cState.bullishConsolidationZones,
|
|
tmpBoxes //
|
|
);
|
|
}
|
|
else if (hasBearishTrend)
|
|
{
|
|
//
|
|
ToBox(
|
|
cState.bearishConsolidationZones,
|
|
tmpBoxes //
|
|
);
|
|
}
|
|
has = HasChild(tmpBoxes);
|
|
if (has)
|
|
{
|
|
//
|
|
idx = GetYoungest(tmpBoxes);
|
|
has = IsValidIndex(idx);
|
|
if (has)
|
|
{
|
|
//
|
|
cZone = tmpBoxes[idx];
|
|
|
|
//
|
|
// Check Consolidation Zone Place ...
|
|
has =
|
|
//
|
|
(
|
|
//
|
|
IsBoxInsideOr(
|
|
cZone,
|
|
zoneBox //
|
|
)
|
|
//
|
|
&&
|
|
//
|
|
cZone.from >= zoneBox.from
|
|
//
|
|
)
|
|
//
|
|
||
|
|
//
|
|
(
|
|
//
|
|
IsBoxInsideOr(
|
|
zoneBox,
|
|
cZone //
|
|
)
|
|
//
|
|
&&
|
|
//
|
|
zoneBox.from >= cZone.from
|
|
//
|
|
)
|
|
//
|
|
;
|
|
if (!has)
|
|
{
|
|
cZone.Clean();
|
|
}
|
|
}
|
|
}
|
|
Clean(tmpBoxes);
|
|
|
|
//
|
|
bool hasBullishCZone = cZone.IsValid() &&
|
|
cZone.IsBullish();
|
|
|
|
//
|
|
bool hasBearishCZone = cZone.IsValid() &&
|
|
cZone.IsBearish();
|
|
|
|
//
|
|
// Summarize Conditions ...
|
|
|
|
//
|
|
// Bullish ...
|
|
isBullish =
|
|
//
|
|
// Base Bullish Conditions ...
|
|
hasBullishTrend &&
|
|
hasBullishCZone &&
|
|
hasBullishZoneBox &&
|
|
hasBullishSignalBox &&
|
|
isBarValidForBullish &&
|
|
//
|
|
// Other Additional Conditions ...
|
|
true
|
|
//
|
|
;
|
|
|
|
//
|
|
// Bearish ...
|
|
isBearish =
|
|
//
|
|
// Base Bearish Conditions ...
|
|
hasBearishTrend &&
|
|
hasBearishCZone &&
|
|
hasBearishZoneBox &&
|
|
hasBearishSignalBox &&
|
|
isBarValidForBearish &&
|
|
//
|
|
// Other Additional Conditions ...
|
|
true
|
|
//
|
|
;
|
|
|
|
//
|
|
// Filling Requirements ...
|
|
result =
|
|
isBullish ||
|
|
isBearish;
|
|
if (result)
|
|
{
|
|
//
|
|
dir =
|
|
isBullish
|
|
? X_DIRECTION_BULLISH
|
|
: X_DIRECTION_BEARISH;
|
|
|
|
//
|
|
box = zoneBox;
|
|
|
|
//
|
|
box.to = TimeCurrent();
|
|
cZone.to = TimeCurrent();
|
|
|
|
//
|
|
if (result)
|
|
{
|
|
//
|
|
XCPOIDrawer *drawer = provider.visionCycleHelper.mPOIDrawer;
|
|
|
|
//
|
|
XCBoxObject *iObj;
|
|
has = drawer.DrawBox(
|
|
box,
|
|
iObj //
|
|
);
|
|
|
|
//
|
|
XCBoxObject *iCObject;
|
|
has = drawer.DrawBox(
|
|
cZone,
|
|
iCObject //
|
|
);
|
|
if (has)
|
|
{
|
|
//
|
|
iCObject.BoxColor(clrLime);
|
|
iCObject.BoxStyle(STYLE_SOLID);
|
|
}
|
|
|
|
//
|
|
Print("Found ...");
|
|
|
|
//
|
|
ZeroMemory(drawer);
|
|
}
|
|
}
|
|
|
|
//
|
|
// Cleanup Resources ...
|
|
zBar.Clean();
|
|
cBar.Clean();
|
|
pBar.Clean();
|
|
pPBar.Clean();
|
|
cZone.Clean();
|
|
cState.Clean();
|
|
zoneBox.Clean();
|
|
iSignalBox.Clean();
|
|
ZeroMemory(cHelper);
|
|
cConditions.Clean();
|
|
cStateEvents.Clean();
|
|
cXConditions.Clean();
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
};
|