saherelm/MQL5Data
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
ac95a26e246674ad4254c01af55cca623849211b
MQL5Data/X121SMCEA/Classes/x-121.smc.market.cycle.helper.class.mq5
T
saherelm ac95a26e24 last ...
2025-03-30 01:20:09 +03:30

4629 lines
110 KiB
Plaintext
Raw Blame History

///////////////////////////////////////////////////////
//
// 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;
}
//
// Tools ...
//
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 DetectNearestCloseOverX3MAFast(
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 DetectNearestCloseUnderX3MAFast(
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;
}
//
bool DetectNearestTenKijCross(
XOHCL &bar,
ENUM_X_DIRECTION &dir,
int barIndex = 0,
int maxAllowedBars = 20 //
)
{
//
bool result = false;
//
bar.Clean();
dir = X_DIRECTION_NONE;
barIndex = NormalizeInt(barIndex, 0);
maxAllowedBars = NormalizeInt(maxAllowedBars, 20);
//
// Looping Through LoopBack Period ...
// for Detecting Result ...
for (int i = barIndex; i < barIndex + maxAllowedBars; i++)
{
//
XOHCL iBar;
result = iBar.Init(
GetSymbol(),
GetPeriod(),
i //
);
if (!result)
{
//
iBar.Clean();
break;
}
//
double iTSen = mX121Helper.xichHelper.GetTenkanSen(i);
double iTSenP = mX121Helper.xichHelper.GetTenkanSen(i + 1);
//
double iKSen = mX121Helper.xichHelper.GetKijunSen(i);
double iKSenP = mX121Helper.xichHelper.GetKijunSen(i + 1);
//
bool isTSenOverKSen = iTSen > iKSen;
bool isTSenOverKSenP = iTSenP > iKSenP;
//
bool isTSenUnderKSen = iTSen < iKSen;
bool isTSenUnderKSenP = iTSenP < iKSenP;
//
//
bool isTSenCrossedOverKSen = isTSenOverKSen &&
!isTSenOverKSenP;
//
bool isTSenCrossedUnderKSen = isTSenUnderKSen &&
!isTSenUnderKSenP;
//
result = isTSenCrossedOverKSen ||
isTSenCrossedUnderKSen;
if (result)
{
//
bar = iBar;
//
dir = isTSenCrossedOverKSen
? X_DIRECTION_BULLISH
: X_DIRECTION_BEARISH;
//
iBar.Clean();
break;
}
//
iBar.Clean();
}
//
return result;
}
//
bool DetectNearestVolumeSwitched(
XOHCL &bar,
ENUM_X_DIRECTION &dir,
int barIndex = 0,
int maxAllowedBars = 20 //
)
{
//
bool result = false;
//
bar.Clean();
dir = X_DIRECTION_NONE;
barIndex = NormalizeInt(barIndex, 0);
maxAllowedBars = NormalizeInt(maxAllowedBars, 20);
//
// Looping Through LoopBack Period ...
// for Detecting Result ...
for (int i = barIndex; i < barIndex + maxAllowedBars; i++)
{
//
XOHCL iBar;
result = iBar.Init(
GetSymbol(),
GetPeriod(),
i //
);
if (!result)
{
//
iBar.Clean();
break;
}
//
double iBullVMa = mX121Helper.xvolumeHelper.GetBullishVolumeMa(i);
double iBullVMaP = mX121Helper.xvolumeHelper.GetBullishVolumeMa(i + 1);
//
double iBearVMa = mX121Helper.xvolumeHelper.GetBearishVolumeMa(i);
double iBearVMaP = mX121Helper.xvolumeHelper.GetBearishVolumeMa(i + 1);
//
bool isBullVMaOverBearVMa = iBullVMa > iBearVMa;
bool isBullVMaOverBearVMaP = iBullVMaP > iBearVMaP;
bool isCrossOver = isBullVMaOverBearVMa &&
!isBullVMaOverBearVMaP;
//
bool isBullVMaUnderBearVMa = iBullVMa < iBearVMa;
bool isBullVMaUnderBearVMaP = iBullVMaP < iBearVMaP;
bool isCrossUnder = isBullVMaUnderBearVMa &&
!isBullVMaUnderBearVMaP;
//
result = isCrossOver ||
isCrossUnder;
if (result)
{
//
bar = iBar;
//
dir = isCrossOver
? X_DIRECTION_BULLISH
: X_DIRECTION_BEARISH;
//
iBar.Clean();
break;
}
//
iBar.Clean();
}
//
return result;
}
//
bool DetectNearestDeltaSwitched(
XOHCL &bar,
ENUM_X_DIRECTION &dir,
int barIndex = 0,
int maxAllowedBars = 20 //
)
{
//
bool result = false;
//
bar.Clean();
dir = X_DIRECTION_NONE;
barIndex = NormalizeInt(barIndex, 0);
maxAllowedBars = NormalizeInt(maxAllowedBars, 20);
//
// Looping Through LoopBack Period ...
// for Detecting Result ...
for (int i = barIndex; i < barIndex + maxAllowedBars; i++)
{
//
XOHCL iBar;
result = iBar.Init(
GetSymbol(),
GetPeriod(),
i //
);
if (!result)
{
//
iBar.Clean();
break;
}
//
double iDelta = mX121Helper.xdeltaHelper.GetDelta(i);
double iDeltaP = mX121Helper.xdeltaHelper.GetDelta(i + 1);
//
double iDeltaMa = mX121Helper.xdeltaHelper.GetDeltaMa(i);
double iDeltaMaP = mX121Helper.xdeltaHelper.GetDeltaMa(i + 1);
//
bool isDeltaOverMa = iDelta > iDeltaMa;
bool isDeltaOverMaP = iDeltaP > iDeltaMaP;
//
bool isDeltaUnderMa = iDelta < iDeltaMa;
bool isDeltaUnderMaP = iDeltaP < iDeltaMaP;
//
bool isCrossOver = isDeltaOverMa &&
!isDeltaOverMaP;
//
bool isCrossUnder = isDeltaUnderMa &&
!isDeltaUnderMaP;
//
result = isCrossOver ||
isCrossUnder;
if (result)
{
//
bar = iBar;
//
dir = isCrossOver
? X_DIRECTION_BULLISH
: X_DIRECTION_BEARISH;
//
iBar.Clean();
break;
}
//
iBar.Clean();
}
//
return result;
}
//
bool DetectNearestStrSwitched(
XOHCL &bar,
ENUM_X_DIRECTION &dir,
int barIndex = 0,
int maxAllowedBars = 20 //
)
{
//
bool result = false;
//
bar.Clean();
dir = X_DIRECTION_NONE;
barIndex = NormalizeInt(barIndex, 0);
maxAllowedBars = NormalizeInt(maxAllowedBars, 20);
//
// Looping Through LoopBack Period ...
// for Detecting Result ...
for (int i = barIndex; i < barIndex + maxAllowedBars; i++)
{
//
XOHCL iBar;
result = iBar.Init(
GetSymbol(),
GetPeriod(),
i //
);
if (!result)
{
//
iBar.Clean();
break;
}
//
double iStrState = mX121Helper.xstrHelper.GetSTRState(i);
double iStrStateP = mX121Helper.xstrHelper.GetSTRState(i + 1);
//
bool isStrBullish = iStrState > 0;
bool isStrBullishP = iStrStateP > 0;
//
bool isStrBearish = iStrState < 0;
bool isStrBearishP = iStrStateP < 0;
//
bool isBullish = isStrBullish &&
!isStrBullishP;
//
bool isBearish = isStrBearish &&
!isStrBearishP;
//
result = isBullish ||
isBearish;
if (result)
{
//
bar = iBar;
//
dir = isBullish
? X_DIRECTION_BULLISH
: X_DIRECTION_BEARISH;
//
iBar.Clean();
break;
}
//
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 ...
//
// XMA ...
//
bool isX3MaFastUnderValesGoldenZone;
bool isX3MaMidUnderValesGoldenZone;
bool isX3MaSlowUnderValesGoldenZone;
//
bool isX3MaFastCrossedUnderValesGoldenZone;
bool isX3MaMidCrossedUnderValesGoldenZone;
bool isX3MaSlowCrossedUnderValesGoldenZone;
//
bool isX3MaFastOverPeaksGoldenZone;
bool isX3MaMidOverPeaksGoldenZone;
bool isX3MaSlowOverPeaksGoldenZone;
//
bool isX3MaFastCrossedOverPeaksGoldenZone;
bool isX3MaMidCrossedOverPeaksGoldenZone;
bool isX3MaSlowCrossedOverPeaksGoldenZone;
//
// XVWAP ...
//
bool isVWapFastUnderValesGoldenZone;
bool isVWapMidUnderValesGoldenZone;
bool isVWapSlowUnderValesGoldenZone;
//
bool isVWapFastCrossedUnderValesGoldenZone;
bool isVWapMidCrossedUnderValesGoldenZone;
bool isVWapSlowCrossedUnderValesGoldenZone;
//
bool isVWapFastOverPeaksGoldenZone;
bool isVWapMidOverPeaksGoldenZone;
bool isVWapSlowOverPeaksGoldenZone;
//
bool isVWapFastCrossedOverPeaksGoldenZone;
bool isVWapMidCrossedOverPeaksGoldenZone;
bool isVWapSlowCrossedOverPeaksGoldenZone;
//
// XHK ...
//
bool isSMHKUnderValesGoldenZone;
bool isRawHKUnderValesGoldenZone;
//
bool isSMHKCrossedUnderValesGoldenZone;
bool isRawHKCrossedUnderValesGoldenZone;
//
bool isSMHKOverPeaksGoldenZone;
bool isRawHKOverPeaksGoldenZone;
//
bool isSMHKCrossedOverPeaksGoldenZone;
bool isRawHKCrossedOverPeaksGoldenZone;
//
// XSTR ...
//
bool isStrUnderValesGoldenZone;
bool isStrCrossedUnderValesGoldenZone;
//
bool isStrOverPeaksGoldenZone;
bool isStrCrossedOverPeaksGoldenZone;
//
//
// Constructor ...
X121SMCStrategyConditionParser()
{
Clean();
}
//
// Tools ...
//
void Clean()
{
//
isX3MaFastUnderValesGoldenZone = false;
isX3MaFastCrossedUnderValesGoldenZone = false;
//
isX3MaMidUnderValesGoldenZone = false;
isX3MaMidCrossedUnderValesGoldenZone = false;
//
isX3MaSlowUnderValesGoldenZone = false;
isX3MaSlowCrossedUnderValesGoldenZone = false;
//
isX3MaFastOverPeaksGoldenZone = false;
isX3MaFastCrossedOverPeaksGoldenZone = false;
//
isX3MaMidOverPeaksGoldenZone = false;
isX3MaMidCrossedOverPeaksGoldenZone = false;
//
isX3MaSlowOverPeaksGoldenZone = false;
isX3MaSlowCrossedOverPeaksGoldenZone = false;
//
isVWapFastUnderValesGoldenZone = false;
isVWapFastCrossedUnderValesGoldenZone = false;
//
isVWapMidUnderValesGoldenZone = false;
isVWapMidCrossedUnderValesGoldenZone = false;
//
isVWapSlowUnderValesGoldenZone = false;
isVWapSlowCrossedUnderValesGoldenZone = false;
//
isVWapFastOverPeaksGoldenZone = false;
isVWapFastCrossedOverPeaksGoldenZone = false;
//
isVWapMidOverPeaksGoldenZone = false;
isVWapMidCrossedOverPeaksGoldenZone = false;
//
isVWapSlowOverPeaksGoldenZone = false;
isVWapSlowCrossedOverPeaksGoldenZone = false;
//
isSMHKUnderValesGoldenZone = false;
isSMHKCrossedUnderValesGoldenZone = false;
//
isRawHKUnderValesGoldenZone = false;
isRawHKCrossedUnderValesGoldenZone = false;
//
isSMHKOverPeaksGoldenZone = false;
isSMHKCrossedOverPeaksGoldenZone = false;
//
isRawHKOverPeaksGoldenZone = false;
isRawHKCrossedOverPeaksGoldenZone = false;
//
isStrUnderValesGoldenZone = false;
isStrCrossedUnderValesGoldenZone = false;
//
isStrOverPeaksGoldenZone = false;
isStrCrossedOverPeaksGoldenZone = false;
//
ZeroMemory(this);
}
//
void Parse(
X121Conditions &conditions //
)
{
//
Clean();
//
//
int zIDX = 0;
int cIDX = zIDX + 1;
int pIDX = cIDX + 1;
//
// Reading Required Materials ...
//
//
//
double peak = conditions.peaksBuffer[cIDX];
double vale = conditions.valesBuffer[cIDX];
//
double peakP = conditions.peaksBuffer[pIDX];
double valeP = conditions.valesBuffer[pIDX];
//
//
//
double str = conditions.strBuffer[cIDX];
double strP = conditions.strBuffer[pIDX];
//
//
//
double smhkO = conditions.xhkSMOpenBuffer[cIDX];
double smhkC = conditions.xhkSMCloseBuffer[cIDX];
//
double smhkMax = MathMax(smhkO, smhkC);
double smhkMin = MathMin(smhkO, smhkC);
//
double smhkOP = conditions.xhkSMOpenBuffer[pIDX];
double smhkCP = conditions.xhkSMCloseBuffer[pIDX];
//
double smhkMaxP = MathMax(smhkOP, smhkCP);
double smhkMinP = MathMin(smhkOP, smhkCP);
//
double rawhkO = conditions.xhkRawOpenBuffer[cIDX];
double rawhkH = conditions.xhkRawHighBuffer[cIDX];
double rawhkC = conditions.xhkRawCloseBuffer[cIDX];
double rawhkL = conditions.xhkRawLowBuffer[cIDX];
//
double rawhkOP = conditions.xhkRawOpenBuffer[pIDX];
double rawhkHP = conditions.xhkRawHighBuffer[pIDX];
double rawhkCP = conditions.xhkRawCloseBuffer[pIDX];
double rawhkLP = conditions.xhkRawLowBuffer[pIDX];
//
//
//
double support = conditions.supportsBuffer[cIDX];
double resistance = conditions.resistancesBuffer[cIDX];
//
double supportP = conditions.supportsBuffer[pIDX];
double resistanceP = conditions.resistancesBuffer[pIDX];
//
double peakGolden = conditions.peaksGoldenBuffer[cIDX];
double valeGolden = conditions.valesGoldenBuffer[cIDX];
//
double peakGoldenP = conditions.peaksGoldenBuffer[pIDX];
double valeGoldenP = conditions.valesGoldenBuffer[pIDX];
//
//
//
double x3maFast = conditions.x3maFastBuffer[cIDX];
double x3maMid = conditions.x3maMidBuffer[cIDX];
double x3maSlow = conditions.x3maSlowBuffer[cIDX];
//
double x3maFastP = conditions.x3maFastBuffer[pIDX];
double x3maMidP = conditions.x3maMidBuffer[pIDX];
double x3maSlowP = conditions.x3maSlowBuffer[pIDX];
//
double vwapFast = conditions.vwapFastBuffer[cIDX];
double vwapMid = conditions.vwapMidBuffer[cIDX];
double vwapSlow = conditions.vwapSlowBuffer[cIDX];
//
double vwapFastP = conditions.vwapFastBuffer[pIDX];
double vwapMidP = conditions.vwapMidBuffer[pIDX];
double vwapSlowP = conditions.vwapSlowBuffer[pIDX];
//
// X3MA ...
//
isX3MaFastUnderValesGoldenZone =
x3maFast >= vale &&
x3maFast <= valeGolden;
//
bool isX3MaFastUnderValesGoldenZoneP =
x3maFastP >= valeP &&
x3maFastP <= valeGoldenP;
//
isX3MaFastCrossedUnderValesGoldenZone =
isX3MaFastUnderValesGoldenZone &&
!isX3MaFastUnderValesGoldenZoneP;
//
//
//
isX3MaMidUnderValesGoldenZone =
x3maMid >= vale &&
x3maMid <= valeGolden;
//
bool isX3MaMidUnderValesGoldenZoneP =
x3maMidP >= valeP &&
x3maMidP <= valeGoldenP;
//
isX3MaMidCrossedUnderValesGoldenZone =
isX3MaMidUnderValesGoldenZone &&
!isX3MaMidUnderValesGoldenZoneP;
//
//
//
isX3MaSlowUnderValesGoldenZone =
x3maSlow >= vale &&
x3maSlow <= valeGolden;
//
bool isX3MaSlowUnderValesGoldenZoneP =
x3maSlowP >= valeP &&
x3maSlowP <= valeGoldenP;
//
isX3MaSlowCrossedUnderValesGoldenZone =
isX3MaSlowUnderValesGoldenZone &&
!isX3MaSlowUnderValesGoldenZoneP;
//
//
//
isX3MaFastOverPeaksGoldenZone =
x3maFast <= peak &&
x3maFast >= peakGolden;
//
bool isX3MaFastOverPeaksGoldenZoneP =
x3maFastP <= peakP &&
x3maFastP >= peakGoldenP;
//
isX3MaFastCrossedOverPeaksGoldenZone =
isX3MaFastOverPeaksGoldenZone &&
!isX3MaFastOverPeaksGoldenZoneP;
//
//
//
isX3MaMidOverPeaksGoldenZone =
x3maMid <= peak &&
x3maMid >= peakGolden;
//
bool isX3MaMidOverPeaksGoldenZoneP =
x3maMidP <= peakP &&
x3maMidP >= peakGoldenP;
//
isX3MaMidCrossedOverPeaksGoldenZone =
isX3MaMidOverPeaksGoldenZone &&
!isX3MaMidOverPeaksGoldenZoneP;
//
//
//
isX3MaSlowOverPeaksGoldenZone =
x3maSlow <= peak &&
x3maSlow >= peakGolden;
//
bool isX3MaSlowOverPeaksGoldenZoneP =
x3maSlowP <= peakP &&
x3maSlowP >= peakGoldenP;
//
isX3MaSlowCrossedOverPeaksGoldenZone =
isX3MaSlowOverPeaksGoldenZone &&
!isX3MaSlowOverPeaksGoldenZoneP;
//
// XVWAP ...
//
//
//
isVWapFastUnderValesGoldenZone =
vwapFast >= vale &&
vwapFast <= valeGolden;
//
bool isVWapFastUnderValesGoldenZoneP =
vwapFastP >= valeP &&
vwapFastP <= valeGoldenP;
//
isVWapFastCrossedUnderValesGoldenZone =
isVWapFastUnderValesGoldenZone &&
!isVWapFastUnderValesGoldenZoneP;
//
//
//
isVWapMidUnderValesGoldenZone =
vwapMid >= vale &&
vwapMid <= valeGolden;
//
bool isVWapMidUnderValesGoldenZoneP =
vwapMidP >= valeP &&
vwapMidP <= valeGoldenP;
//
isVWapMidCrossedUnderValesGoldenZone =
isVWapMidUnderValesGoldenZone &&
!isVWapMidUnderValesGoldenZoneP;
//
//
//
isVWapSlowUnderValesGoldenZone =
vwapSlow >= vale &&
vwapSlow <= valeGolden;
//
bool isVWapSlowUnderValesGoldenZoneP =
vwapSlowP >= valeP &&
vwapSlowP <= valeGoldenP;
//
isVWapSlowCrossedUnderValesGoldenZone =
isVWapSlowUnderValesGoldenZone &&
!isVWapSlowUnderValesGoldenZoneP;
//
//
//
isVWapFastOverPeaksGoldenZone =
vwapFast <= peak &&
vwapFast >= peakGolden;
//
bool isVWapFastOverPeaksGoldenZoneP =
vwapFastP <= peakP &&
vwapFastP >= peakGoldenP;
//
isVWapFastCrossedOverPeaksGoldenZone =
isVWapFastOverPeaksGoldenZone &&
!isVWapFastOverPeaksGoldenZoneP;
//
//
//
isVWapMidOverPeaksGoldenZone =
vwapMid <= peak &&
vwapMid >= peakGolden;
//
bool isVWapMidOverPeaksGoldenZoneP =
vwapMidP <= peakP &&
vwapMidP >= peakGoldenP;
//
isVWapMidCrossedOverPeaksGoldenZone =
isVWapMidOverPeaksGoldenZone &&
!isVWapMidOverPeaksGoldenZoneP;
//
//
//
isVWapSlowOverPeaksGoldenZone =
vwapSlow <= peak &&
vwapSlow >= peakGolden;
//
bool isVWapSlowOverPeaksGoldenZoneP =
vwapSlowP <= peakP &&
vwapSlowP >= peakGoldenP;
//
isVWapSlowCrossedOverPeaksGoldenZone =
isVWapSlowOverPeaksGoldenZone &&
!isVWapSlowOverPeaksGoldenZoneP;
//
// XHK ...
//
//
//
isSMHKUnderValesGoldenZone =
smhkMax >= vale &&
smhkMax <= valeGolden;
//
bool isSMHKUnderValesGoldenZoneP =
smhkMaxP >= valeP &&
smhkMaxP <= valeGoldenP;
//
isSMHKCrossedUnderValesGoldenZone =
isSMHKUnderValesGoldenZone &&
!isSMHKUnderValesGoldenZoneP;
//
//
//
isRawHKUnderValesGoldenZone =
rawhkH >= vale &&
rawhkH <= valeGolden;
//
bool isRawHKUnderValesGoldenZoneP =
rawhkHP >= valeP &&
rawhkHP <= valeGoldenP;
//
isRawHKCrossedUnderValesGoldenZone =
isRawHKUnderValesGoldenZone &&
!isRawHKUnderValesGoldenZoneP;
//
//
//
isSMHKOverPeaksGoldenZone =
smhkMin <= peak &&
smhkMin >= peakGolden;
//
bool isSMHKOverPeaksGoldenZoneP =
smhkMinP <= peakP &&
smhkMinP >= peakGoldenP;
//
isSMHKCrossedOverPeaksGoldenZone =
isSMHKOverPeaksGoldenZone &&
!isSMHKOverPeaksGoldenZoneP;
//
//
//
isRawHKOverPeaksGoldenZone =
rawhkL <= peak &&
rawhkL >= peakGolden;
//
bool isRawHKOverPeaksGoldenZoneP =
rawhkLP <= peakP &&
rawhkLP >= peakGoldenP;
//
isRawHKCrossedOverPeaksGoldenZone =
isRawHKOverPeaksGoldenZone &&
!isRawHKOverPeaksGoldenZoneP;
//
// XSTR ...
//
//
//
isStrUnderValesGoldenZone =
str >= vale &&
str <= valeGolden;
//
bool isStrUnderValesGoldenZoneP =
strP >= valeP &&
strP <= valeGoldenP;
//
isStrCrossedUnderValesGoldenZone =
isStrUnderValesGoldenZone &&
!isStrUnderValesGoldenZoneP;
//
//
//
isStrOverPeaksGoldenZone =
str <= peak &&
str >= peakGolden;
//
bool isStrOverPeaksGoldenZoneP =
strP <= peakP &&
strP >= peakGoldenP;
//
isStrCrossedOverPeaksGoldenZone =
isStrOverPeaksGoldenZone &&
!isStrOverPeaksGoldenZoneP;
}
//
// Rejected Boxes ...
bool HasRejectedBocXConditions(
ENUM_X_CYCLES cycle,
XSignalBox &box,
ENUM_X_DIRECTION &dir,
XSignalBox &waitingBoxes[],
X121SMCStrategySignalProviderData &provider,
int barIndex = 0 //
)
{
//
bool result = false;
//
box.Clean();
dir = X_DIRECTION_NONE;
//
// Checking Waiting Baoxes Exists ...
result = HasChild(waitingBoxes);
if (!result)
{
return result;
}
//
// 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);
//
// Normalize Args ...
//
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;
}
//
// Checking Bar Based on Positions State ...
ENUM_X_DIRECTION iBarPosDir;
bool isBarValidForDir = cHelper
.mBarAnalyser
.IsValidForPosition(
cBar,
iBarPosDir //
);
bool isBarValidForBullish =
isBarValidForDir &&
IsBullish(iBarPosDir);
bool isBarValidForBearish =
isBarValidForDir &&
IsBearish(iBarPosDir);
//
// Extract Selected Boxes ...
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 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
? isOBBullishRejected
: isOBBearishRejected;
//
// Force Using OB ...
if (has)
{
//
iSignalBox = iBox;
if (!selectedBox.IsValid())
{
selectedBox = iBox.ob;
}
iBox.Clean();
break;
}
//
iBox.Clean();
}
}
result =
iSignalBox.IsValid() &&
selectedBox.IsValid();
if (!result)
{
//
zBar.Clean();
cBar.Clean();
pBar.Clean();
cState.Clean();
iSignalBox.Clean();
selectedBox.Clean();
ZeroMemory(cHelper);
cConditions.Clean();
cXConditions.Clean();
//
return result;
}
//
bool hasSignalBox = iSignalBox.IsValid();
bool isSignalBoxBullish = IsBullish(iSignalBox.ob.dir);
//
// Checking Other Conditions ...
bool isVWapSlowPassed =
isSignalBoxBullish
? cXConditions.isVWapSlowBullish
: cXConditions.isVWapSlowBearish;
//
// Bullish Conditions ...
isBullish =
//
// Base Condition ...
(
//
hasSignalBox &&
isVWapSlowPassed &&
isSignalBoxBullish &&
isBarValidForBullish
//
)
//
;
//
// Bearish Conditions ...
isBearish =
//
// Base Condition ...
(
//
hasSignalBox &&
isVWapSlowPassed &&
!isSignalBoxBullish &&
isBarValidForBearish
//
)
//
;
//
// Filling Requirements ...
result =
isBullish ||
isBearish;
if (result)
{
//
dir =
isBullish
? X_DIRECTION_BULLISH
: X_DIRECTION_BEARISH;
//
box = iSignalBox;
box.UpdateTo(TimeCurrent());
}
//
// 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 Boxes ...
bool HasActivatedBocXConditions(
ENUM_X_CYCLES cycle,
XSignalBox &box,
ENUM_X_DIRECTION &dir,
XSignalBox &waitingBoxes[],
X121SMCStrategySignalProviderData &provider,
int barIndex = 0 //
)
{
//
bool result = false;
//
box.Clean();
dir = X_DIRECTION_NONE;
//
// Checking Waiting Baoxes Exists ...
result = HasChild(waitingBoxes);
if (!result)
{
return result;
}
//
// 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);
//
// Normalize Args ...
//
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;
}
//
// Checking Bar Based on Positions State ...
ENUM_X_DIRECTION iBarPosDir;
bool isBarValidForDir = cHelper
.mBarAnalyser
.IsValidForPosition(
cBar,
iBarPosDir //
);
bool isBarValidForBullish =
isBarValidForDir &&
IsBullish(iBarPosDir);
bool isBarValidForBearish =
isBarValidForDir &&
IsBearish(iBarPosDir);
//
// Extract Selected Boxes ...
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();
//
has = cBar.low < iBox.sharp.upper &&
cBar.low > iBox.sharp.lower &&
cBar.high > iBox.sharp.lower &&
cBar.high < iBox.sharp.upper;
//
// Force Using OB ...
if (has)
{
//
iSignalBox = iBox;
if (!selectedBox.IsValid())
{
selectedBox = iBox.ob;
}
iBox.Clean();
break;
}
//
iBox.Clean();
}
}
result =
iSignalBox.IsValid() &&
selectedBox.IsValid();
if (!result)
{
//
zBar.Clean();
cBar.Clean();
pBar.Clean();
cState.Clean();
iSignalBox.Clean();
selectedBox.Clean();
ZeroMemory(cHelper);
cConditions.Clean();
cXConditions.Clean();
//
return result;
}
//
bool hasSignalBox = iSignalBox.IsValid();
bool isSignalBoxBullish = IsBullish(iSignalBox.ob.dir);
//
// Checking Other Conditions ...
//
// XVWAP ...
//
bool isVWapSlopeBullish =
cXConditions.isVwapFastSlopeBullish &&
cXConditions.isVwapMidSlopeBullish &&
cXConditions.isVwapSlowSlopeBullish;
//
bool isVWapSlopeBearish =
cXConditions.isVwapFastSlopeBearish &&
cXConditions.isVwapMidSlopeBearish &&
cXConditions.isVwapSlowSlopeBearish;
//
bool isVWapBullishCondition =
(cXConditions.isVWapBullishOrdered &&
cXConditions.isVWapSwitchedToBullishState) ||
(cXConditions.isVWapBullishState &&
cXConditions.isVWapSwitchedToBullishOrdered);
//
bool isVWapBearishCondition =
(cXConditions.isVWapBearishOrdered &&
cXConditions.isVWapSwitchedToBearishState) ||
(cXConditions.isVWapBearishState &&
cXConditions.isVWapSwitchedToBearishOrdered);
//
// Bullish Conditions ...
isBullish =
//
// Base Condition ...
(
//
hasSignalBox &&
isSignalBoxBullish &&
isVWapSlopeBullish &&
isBarValidForBullish &&
isVWapBullishCondition
//
)
//
;
//
// Bearish Conditions ...
isBearish =
//
// Base Condition ...
(
//
hasSignalBox &&
isVWapSlopeBearish &&
!isSignalBoxBullish &&
isBarValidForBearish &&
isVWapBearishCondition
//
)
//
;
//
// Filling Requirements ...
result =
isBullish ||
isBearish;
if (result)
{
//
dir =
isBullish
? X_DIRECTION_BULLISH
: X_DIRECTION_BEARISH;
//
box = iSignalBox;
box.UpdateTo(TimeCurrent());
//
// Provide TP/SL ...
//
box.sl = isBullish
? cXConditions.vwapMin
: cXConditions.vwapMax;
//
box.tp = isBullish
? box.sharp.upper
: box.sharp.lower;
}
//
// 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;
}
//
// Breaked Boxes ...
bool HasBreakedBocXConditions(
ENUM_X_CYCLES cycle,
XSignalBox &box,
ENUM_X_DIRECTION &dir,
XSignalBox &breakedBoxes[],
X121SMCStrategySignalProviderData &provider,
int barIndex = 0 //
)
{
//
bool result = false;
//
box.Clean();
dir = X_DIRECTION_NONE;
//
// Checking Waiting Baoxes Exists ...
result = HasChild(breakedBoxes);
if (!result)
{
return result;
}
//
// 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);
//
// Normalize Args ...
//
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;
}
//
// Checking Bar Based on Positions State ...
ENUM_X_DIRECTION iBarPosDir;
bool isBarValidForDir = cHelper
.mBarAnalyser
.IsValidForPosition(
cBar,
iBarPosDir //
);
bool isBarValidForBullish =
isBarValidForDir &&
IsBullish(iBarPosDir);
bool isBarValidForBearish =
isBarValidForDir &&
IsBearish(iBarPosDir);
//
// Extract Selected Boxes ...
XBoxZone selectedBox;
XSignalBox iSignalBox;
count = ArraySize(breakedBoxes);
has = IsValidSize(count);
if (has)
{
//
for (int i = 0; i < count; i++)
{
//
XSignalBox iBox = breakedBoxes[i];
//
bool isBullish = iBox.ob.IsBullish();
//
has = cBar.low < iBox.sharp.upper &&
cBar.low > iBox.sharp.lower &&
cBar.high > iBox.sharp.lower &&
cBar.high < iBox.sharp.upper;
//
// Force Using OB ...
if (has)
{
//
iSignalBox = iBox;
if (!selectedBox.IsValid())
{
selectedBox = iBox.ob;
}
iBox.Clean();
break;
}
//
iBox.Clean();
}
}
result =
iSignalBox.IsValid() &&
selectedBox.IsValid();
if (!result)
{
//
zBar.Clean();
cBar.Clean();
pBar.Clean();
cState.Clean();
iSignalBox.Clean();
selectedBox.Clean();
ZeroMemory(cHelper);
cConditions.Clean();
cXConditions.Clean();
//
return result;
}
//
bool hasSignalBox = iSignalBox.IsValid();
bool isSignalBoxBullish = IsBullish(iSignalBox.ob.dir);
//
// Checking Other Conditions ...
//
// XVWAP ...
//
bool isVWapSlopeBullish =
cXConditions.isVwapFastSlopeBullish &&
cXConditions.isVwapMidSlopeBullish &&
cXConditions.isVwapSlowSlopeBullish;
//
bool isVWapSlopeBearish =
cXConditions.isVwapFastSlopeBearish &&
cXConditions.isVwapMidSlopeBearish &&
cXConditions.isVwapSlowSlopeBearish;
//
bool isVWapBullishCondition =
(cXConditions.isVWapBullishOrdered &&
cXConditions.isVWapSwitchedToBullishState) ||
(cXConditions.isVWapBullishState &&
cXConditions.isVWapSwitchedToBullishOrdered);
//
bool isVWapBearishCondition =
(cXConditions.isVWapBearishOrdered &&
cXConditions.isVWapSwitchedToBearishState) ||
(cXConditions.isVWapBearishState &&
cXConditions.isVWapSwitchedToBearishOrdered);
//
// Bullish Conditions ...
isBullish =
//
// Base Condition ...
(
//
hasSignalBox &&
isSignalBoxBullish &&
isVWapSlopeBullish &&
isBarValidForBullish &&
isVWapBullishCondition
//
)
//
;
//
// Bearish Conditions ...
isBearish =
//
// Base Condition ...
(
//
hasSignalBox &&
isVWapSlopeBearish &&
!isSignalBoxBullish &&
isBarValidForBearish &&
isVWapBearishCondition
//
)
//
;
//
// Filling Requirements ...
result =
isBullish ||
isBearish;
if (result)
{
//
dir =
isBullish
? X_DIRECTION_BULLISH
: X_DIRECTION_BEARISH;
//
box = iSignalBox;
box.UpdateTo(TimeCurrent());
//
// Provide TP/SL ...
//
box.sl = isBullish
? cXConditions.vwapMin
: cXConditions.vwapMax;
//
box.tp = isBullish
? box.sharp.upper
: box.sharp.lower;
}
//
// 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;
}
//
// XFVGMA ...
bool HasXFVGMAConditions(
ENUM_X_CYCLES cycle,
XSignalBox &box,
ENUM_X_DIRECTION &dir,
XSignalBox &waitingBoxes[],
X121SMCStrategySignalProviderData &provider,
int barIndex = 0 //
)
{
//
bool result = false;
//
box.Clean();
dir = X_DIRECTION_NONE;
//
result = HasChild(waitingBoxes);
if (!result)
{
return result;
}
//
// 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);
//
// Normalize Args ...
//
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;
}
//
// Select Waiting Box ...
XBoxZone selectedBox;
XSignalBox selectedSignalBox;
count = ArraySize(waitingBoxes);
for (int i = 0; i < count; i++)
{
//
XSignalBox iSBox = waitingBoxes[i];
bool isBullish = iSBox.ob.IsBullish();
//
bool isInsidePassed =
isBullish
? cBar.low < iSBox.ob.upper &&
cBar.low > iSBox.ob.lower
: cBar.high > iSBox.ob.lower &&
cBar.high < iSBox.ob.upper;
//
bool isTypePassed = iSBox.sharp.type == "XSHPOBX";
//
has = isTypePassed &&
isInsidePassed;
if (has)
{
//
selectedBox = iSBox.ob;
selectedSignalBox = iSBox;
break;
}
}
result = selectedBox.IsValid() &&
selectedSignalBox.IsValid();
if (!result)
{
//
zBar.Clean();
cBar.Clean();
pBar.Clean();
cState.Clean();
ZeroMemory(cHelper);
cConditions.Clean();
selectedBox.Clean();
cXConditions.Clean();
selectedSignalBox.Clean();
//
return result;
}
//
bool isSignalBoxBullish = selectedBox.IsBullish();
//
// Checking Other Conditions ...
//
// Checking Bar Based on Positions State ...
ENUM_X_DIRECTION iBarPosDir;
bool isBarValidForDir = cHelper
.mBarAnalyser
.IsValidForPosition(
cBar,
iBarPosDir //
);
bool isBarValidForBullish =
isBarValidForDir &&
IsBullish(iBarPosDir);
bool isBarValidForBearish =
isBarValidForDir &&
IsBearish(iBarPosDir);
//
// Bullish Conditions ...
isBullish =
//
// Base Condition ...
(
//
isSignalBoxBullish &&
isBarValidForBullish
//
)
//
;
//
// Bearish Conditions ...
isBearish =
//
// Base Condition ...
(
//
!isSignalBoxBullish &&
isBarValidForBearish
//
)
//
;
//
// Filling Requirements ...
result =
isBullish ||
isBearish;
if (result)
{
//
dir =
isBullish
? X_DIRECTION_BULLISH
: X_DIRECTION_BEARISH;
//
box = selectedSignalBox;
box.ob.to = TimeCurrent();
}
//
// Check All Conditions ...
result =
box.IsValid() &&
HasDirection(dir) &&
(isBullish ||
isBearish);
//
// Cleanup Resources ...
zBar.Clean();
cBar.Clean();
pBar.Clean();
cState.Clean();
selectedBox.Clean();
ZeroMemory(cHelper);
cConditions.Clean();
cStateEvents.Clean();
cXConditions.Clean();
selectedSignalBox.Clean();
//
return result;
}
//
// XWPVZ ...
bool HasXWPVZConditions(
ENUM_X_CYCLES cycle,
ENUM_X_CYCLES vCycle,
XSignalBox &box,
ENUM_X_DIRECTION &dir,
X121SMCStrategySignalProviderData &provider,
int barIndex = 0 //
)
{
//
bool result = false;
//
box.Clean();
dir = X_DIRECTION_NONE;
//
// 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);
//
// Fil Selected Data ...
XPOIState vState;
X121Conditions vXConditions;
XPOIStateEvents vStateEvents;
XC121SMCCycleHelper *vHelper;
X121SMCCycleConditions vConditions;
result = provider.SelectCycle(
vCycle,
vState,
vStateEvents,
vXConditions,
vHelper,
vConditions //
);
if (!result)
{
//
cState.Clean();
ZeroMemory(cHelper);
cConditions.Clean();
cXConditions.Clean();
cStateEvents.Clean();
//
vState.Clean();
ZeroMemory(vHelper);
cConditions.Clean();
vXConditions.Clean();
vStateEvents.Clean();
//
return result;
}
Parse(vXConditions);
//
// Normalize Args ...
//
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();
cState.Clean();
ZeroMemory(cHelper);
cConditions.Clean();
cXConditions.Clean();
//
return result;
}
//
XCPOIDrawer *drawer = provider.visionCycleHelper.mPOIDrawer;
//
// Checking Other Conditions ...
//
// Checking Bar Based on Positions State ...
ENUM_X_DIRECTION iBarPosDir;
bool isBarValidForDir = cHelper
.mBarAnalyser
.IsValidForPosition(
cBar,
iBarPosDir //
);
bool isBarValidForBullish =
isBarValidForDir &&
IsBullish(iBarPosDir);
bool isBarValidForBearish =
isBarValidForDir &&
IsBearish(iBarPosDir);
//
// Senkou Span A/B Rejections ...
//
bool forceType = false;
bool forcePressure = true;
//
bool isBullishRejectSenkouAB = cBar.IsRejected(
cXConditions.senkouMax,
X_DIRECTION_BULLISH,
forceType, // Force Type ...
forcePressure // Force Pressure ...
);
//
bool isBearishRejectSenkouAB = cBar.IsRejected(
cXConditions.senkouMin,
X_DIRECTION_BEARISH,
forceType, // Force Type ...
forcePressure // Force Pressure ...
);
//
// TenkanSen/KijunSen Rejections ...
//
bool isBullishRejectTenKij = cBar.IsRejected(
cXConditions.tenKijMax,
X_DIRECTION_BULLISH,
forceType, // Force Type ...
forcePressure // Force Pressure ...
);
//
bool isBearishRejectTenKij = cBar.IsRejected(
cXConditions.tenKijMin,
X_DIRECTION_BEARISH,
forceType, // Force Type ...
forcePressure // Force Pressure ...
);
//
// X3MaFast Rejections ...
//
bool isBullishRejectedFastMa = cBar.IsRejected(
cXConditions.x3maFastBuffer[cIDX],
X_DIRECTION_BULLISH,
forceType, // Force Type ...
forcePressure // Force Pressure ...
);
//
bool isBearishRejectedFastMa = cBar.IsRejected(
cXConditions.x3maFastBuffer[cIDX],
X_DIRECTION_BEARISH,
forceType, // Force Type ...
forcePressure // Force Pressure ...
);
//
bool isValidBullishRejectedFastMa =
isBullishRejectedFastMa &&
cBar.low > cXConditions.senkouMax;
//
bool isValidBearishRejectedFastMa =
isBearishRejectedFastMa &&
cBar.high < cXConditions.senkouMin;
//
// Bigger Cycle Verification ...
//
double vBullishScore = 0;
double vBearishScore = 0;
vXConditions.GenerateScore(
vBullishScore,
vBearishScore //
);
//
bool isVBUllishPassed =
cBar.low > vXConditions.senkouMax &&
vBullishScore > (vBearishScore * 1.5);
//
bool isVBearishPassed =
cBar.high < vXConditions.senkouMin &&
vBearishScore > (vBullishScore * 1.5);
//
// ichimokou ...
//
// Bullish Conditions ...
isBullish =
//
isVBUllishPassed &&
isBullishRejectSenkouAB
//
;
//
// Bearish Conditions ...
isBearish =
//
isVBearishPassed &&
isBearishRejectSenkouAB
//
;
//
result = isBullish ||
isBearish;
if (result)
{
//
dir =
isBullish
? X_DIRECTION_BULLISH
: X_DIRECTION_BEARISH;
}
//
// Detecting a Zone and Validate it ...
//
XBoxZone tmpBoxes[];
//
XBoxZone obBox;
XBoxZone fvgBox;
XBoxZone supResBox;
bool hasOB = false;
bool hasFVG = false;
bool hasSupRes = false;
//
// Select Support and Resistance ...
if (result)
{
//
if (!hasSupRes)
{
//
cState.OrderBlocksAsBox(tmpBoxes);
cState.FairValueGapsAsBox(tmpBoxes);
cState.SupplyDemandsAsBox(tmpBoxes);
cState.SupportResistancesAsBox(tmpBoxes);
//
has = HasChild(tmpBoxes);
if (has)
{
//
while (HasChild(tmpBoxes))
{
//
idx = GetOldest(tmpBoxes);
has = IsValidIndex(idx);
if (!has)
{
break;
}
//
XBoxZone iBox = tmpBoxes[idx];
ArrayRemove(
tmpBoxes,
idx,
1 //
);
iBox.to = TimeCurrent();
//
// Try to Validate Support and Resistance ...
int retests = CountBoxRetest(
iBox,
dir,
cBar.period //
);
bool isTyped =
isBullish
? iBox.IsBullish()
: iBox.IsBearish();
bool isRetested = retests >= 1;
bool isPlaced =
isBullish
? (
//
(cBar.low < iBox.upper &&
cBar.low > iBox.lower)
//
)
: (
//
(cBar.high < iBox.upper &&
cBar.high > iBox.lower)
//
);
//
has =
isTyped &&
isPlaced &&
isRetested;
if (has)
{
//
supResBox = iBox;
iBox.Clean();
break;
}
//
iBox.Clean();
}
}
//
hasSupRes = supResBox.IsValid();
Clean(tmpBoxes);
}
}
//
Clean(tmpBoxes);
//
// Bullish Conditions ...
isBullish =
//
isBullish &&
hasSupRes
//
;
//
// Bearish Conditions ...
isBearish =
//
isBearish &&
hasSupRes
//
;
//
// Filling Requirements ...
result =
isBullish ||
isBearish;
if (result)
{
//
bool drawBoxes = true;
if (drawBoxes)
{
//
if (hasSupRes)
{
//
supResBox.to = TimeCurrent();
//
XCBoxObject *iObj;
has = drawer.DrawBox(
supResBox,
iObj //
);
//
if (has)
{
iObj.BoxWidth(2);
iObj.BoxStyle(STYLE_DOT);
}
}
}
//
Print("Signal ...");
result = false;
isBearish = false;
isBullish = false;
}
//
// Check All Conditions ...
result =
box.IsValid() &&
HasDirection(dir) &&
(isBullish ||
isBearish);
//
// Cleanup Resources ...
zBar.Clean();
cBar.Clean();
pBar.Clean();
pPBar.Clean();
cState.Clean();
vState.Clean();
cConditions.Clean();
cConditions.Clean();
ZeroMemory(cHelper);
ZeroMemory(vHelper);
cStateEvents.Clean();
cXConditions.Clean();
vXConditions.Clean();
vStateEvents.Clean();
//
return result;
}
//
bool HasXICHConditions(
ENUM_X_CYCLES cycle,
XBoxZone &box,
ENUM_X_DIRECTION &dir,
X121SMCStrategySignalProviderData &provider,
int barIndex = 0 //
)
{
//
bool result = false;
//
box.Clean();
dir = X_DIRECTION_NONE;
//
// 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);
//
// Normalize Args ...
//
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();
cState.Clean();
ZeroMemory(cHelper);
cConditions.Clean();
cXConditions.Clean();
//
return result;
}
//
// Checking Conditions ...
//
// XDELTA ...
//
bool isDeltaSwitchedToBullish =
(cXConditions.isDeltaCrossedOverMa &&
cXConditions.isDeltaSwitchedToBullish);
bool isDeltaBullish =
(cXConditions.isDeltaOverMa &&
cXConditions.isDeltaBullish);
bool isDeltaIsBullish =
isDeltaBullish ||
isDeltaSwitchedToBullish;
//
bool isDeltaSwitchedToBearish =
(cXConditions.isDeltaCrossedUnderMa &&
cXConditions.isDeltaSwitchedToBearish);
bool isDeltaBearish =
(cXConditions.isDeltaUnderMa &&
cXConditions.isDeltaBearish);
bool isDeltaIsBearish =
isDeltaBearish ||
isDeltaSwitchedToBearish;
//
// XVOLUME ...
//
bool isVolumeSwitchedToBullish =
(cXConditions.isVolumeSwitchedToBullish &&
cXConditions.isBullishVolumeSwitchedToIncreased);
bool isVolumeBullish =
(cXConditions.isBullishVolumeIncreased &&
cXConditions.isBullishVolumeMaOverBearishVolumeMa);
bool isVolumeIsBullish =
isVolumeBullish ||
isVolumeSwitchedToBullish;
//
bool isVolumeSwitchedToBearish =
(cXConditions.isVolumeSwitchedToBearish &&
cXConditions.isBearishVolumeSwitchedToIncreased);
bool isVolumeBearish =
(cXConditions.isBullishVolumeMaUnderBearishVolumeMa &&
cXConditions.isBearishVolumeIncreased);
bool isVolumeIsBearish =
isVolumeBearish ||
isVolumeSwitchedToBearish;
//
// XSTR ...
bool isStrIsBullish =
(cXConditions.isStrBullish ||
cXConditions.isStrSwitchedToBullish);
bool isStrIsBearish =
(cXConditions.isStrBearish ||
cXConditions.isStrSwitchedToBearish);
//
// XICH ...
bool isIchIsBullish =
(cXConditions.isTenkanSenOverKijunSen ||
cXConditions.isTenkanSenCrossedOverKijunSen);
bool isIchIsBearish =
(cXConditions.isTenkanSenUnderKijunSen ||
cXConditions.isTenkanSenCrossedUnderKijunSen);
//
// Checking TK Zone ...
//
bool isBullishTKZone =
isIchIsBullish &&
cBar.low < cXConditions.tenkanSenBuffer[cIndex] &&
cBar.low > cXConditions.kijunSenBuffer[cIndex] &&
cBar.low < pBar.low &&
zBar.open > cBar.low;
//
bool isBearishTKZone =
isIchIsBearish &&
cBar.high > cXConditions.tenkanSenBuffer[cIndex] &&
cBar.high < cXConditions.kijunSenBuffer[cIndex] &&
cBar.high > pBar.high &&
zBar.open < cBar.high;
//
// Summarize Conditions ...
//
isBullish =
//
// false
isStrIsBullish &&
isIchIsBullish &&
isBullishTKZone &&
isDeltaIsBullish &&
isVolumeIsBullish
//
//
;
//
isBearish =
//
// false
isStrIsBearish &&
isIchIsBearish &&
isBearishTKZone &&
isDeltaIsBearish &&
isVolumeIsBearish
//
;
//
// Filling Requirements ...
result =
isBullish ||
isBearish;
if (result)
{
//
dir =
isBullish
? X_DIRECTION_BULLISH
: X_DIRECTION_BEARISH;
//
box.dir = dir;
box.from = pPBar.time;
box.to = TimeCurrent();
box.symbol = cBar.symbol;
box.period = cBar.period;
//
pivot = isBullish
? cBar.low - (points * 5)
: cBar.high + (points * 5);
//
point = GetEntry(
cBar.symbol,
signalBoxDir //
);
//
box.upper =
isBullish
? point
: pivot;
//
box.lower =
isBullish
? pivot
: point;
//
bool drawBoxes = true;
if (drawBoxes)
{
//
}
//
Print("Signal ...");
result = false;
isBearish = false;
isBullish = false;
}
//
// Check All Conditions ...
result =
box.IsValid() &&
HasDirection(dir) &&
(isBullish ||
isBearish);
//
// Cleanup Resources ...
zBar.Clean();
cBar.Clean();
pBar.Clean();
pPBar.Clean();
cState.Clean();
cConditions.Clean();
cConditions.Clean();
ZeroMemory(cHelper);
cStateEvents.Clean();
cXConditions.Clean();
//
return result;
}
//
};
Reference in New Issue View Git Blame Copy Permalink