saherelm/MQL5Data
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
fb305bbaddc0f415a64a72a3c4c849ddbf1b13b5
MQL5Data/Documents/BKP/x-121.smc.market.cycle.helper.class.mq5
T

4034 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;
}
//
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;
}
//
// 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,
X121Conditions &cXConditions,
XC121SMCCycleHelper *&cHelper,
X121SMCCycleConditions &cConditions //
)
{
//
bool result = false;
//
cState.Clean();
ZeroMemory(cHelper);
cConditions.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;
}
else if (cycle == X_CYCLE_DECISION)
{
//
cState = decisionState;
cHelper = decisionCycleHelper;
cConditions = decisionConditions;
cXConditions = decisionXConditions;
}
else if (cycle == X_CYCLE_ANALYSE)
{
//
cState = analyseState;
cHelper = analyseCycleHelper;
cConditions = analyseConditions;
cXConditions = analyseXConditions;
}
else if (cycle == X_CYCLE_VERIFICATION)
{
//
cState = verificationState;
cHelper = verificationCycleHelper;
cConditions = verificationConditions;
cXConditions = verificationXConditions;
}
else if (cycle == X_CYCLE_CONSOLIDATION)
{
//
cState = consolidationState;
cHelper = consolidationCycleHelper;
cConditions = consolidationConditions;
cXConditions = consolidationXConditions;
}
else if (cycle == X_CYCLE_VISION)
{
//
cState = visionState;
cHelper = visionCycleHelper;
cConditions = visionConditions;
cXConditions = visionXConditions;
}
//
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];
}
//
bool HasSenario1Conditions(
ENUM_X_CYCLES cycle,
XBoxZone &box,
XBoxZone &holderBox,
ENUM_X_DIRECTION &dir,
X121SMCStrategySignalProviderData &provider,
ENUM_X_CYCLES holderCycle = X_CYCLE_NONE,
int barIndex = 0 //
)
{
//
bool result = false;
//
// Fil Selected Data ...
XPOIState cState;
X121Conditions cXConditions;
XC121SMCCycleHelper *cHelper;
X121SMCCycleConditions cConditions;
result = provider.SelectCycle(
cycle,
cState,
cXConditions,
cHelper,
cConditions //
);
if (!result)
{
//
cState.Clean();
ZeroMemory(cHelper);
cConditions.Clean();
cXConditions.Clean();
//
return result;
}
Parse(cXConditions);
//
// Fil Selected Data ...
XPOIState chState;
X121Conditions chXConditions;
XC121SMCCycleHelper *chHelper;
X121SMCCycleConditions chConditions;
if (holderCycle != X_CYCLE_NONE)
{
//
result = provider.SelectCycle(
holderCycle,
chState,
chXConditions,
chHelper,
chConditions //
);
if (!result)
{
//
chState.Clean();
ZeroMemory(chHelper);
chConditions.Clean();
chXConditions.Clean();
//
return result;
}
//
Parse(chXConditions);
}
//
// Normalize Args ...
//
box.Clean();
holderBox.Clean();
dir = X_DIRECTION_NONE;
//
if (barIndex < 0)
{
barIndex = 0;
}
//
int idx = -1;
int count = 0;
bool has = false;
//
int zIDX = barIndex;
int cIDX = zIDX + 1;
int pIDX = cIDX + 1;
//
bool isBullish = false;
bool isBearish = false;
//
XOHCL zBar;
XOHCL cBar;
XOHCL pBar;
//
// 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();
chState.Clean();
ZeroMemory(cHelper);
cConditions.Clean();
cXConditions.Clean();
ZeroMemory(chHelper);
chConditions.Clean();
chXConditions.Clean();
//
return result;
}
//
// Detecting Signal Conditions ...
//
// Bullish Conditions ...
isBullish =
//
// Base Condition ...
(
//
cXConditions.supportsBuffer[cIDX] == cXConditions.valesBuffer[zIDX]
//
// cXConditions.isSarSwitchedToBullish &&
// cXConditions.isSMHKSwitchedToBullish &&
// cBar.low < cXConditions.masLowerBuffer[cIDX] &&
// cBar.low < cXConditions.valesGoldenBuffer[cIDX] &&
// zBar.close < cXConditions.valesGoldenBuffer[cIDX] &&
// cXConditions.xhkSMCloseBuffer[cIDX] < cXConditions.valesGoldenBuffer[cIDX]
//
)
//
;
//
// Bearish Conditions ...
isBearish =
//
// Base Condition ...
(
//
false
//
)
//
;
//
// Filling Requirements ...
result =
isBullish ||
isBearish;
if (result)
{
//
dir =
isBullish
? X_DIRECTION_BULLISH
: X_DIRECTION_BEARISH;
//
box.dir = dir;
box.to = TimeCurrent();
box.symbol = cXConditions.symbol;
box.period = cXConditions.period;
//
int fromIDX = -1;
if (isBullish)
{
//
double vale = cXConditions.valesBuffer[cIDX];
box.lower = vale;
box.upper = cXConditions.valesGoldenBuffer[cIDX];
//
int lowerValeIDX = -1;
double lowerVale = cHelper
.mX121Helper
.xpvHelper
.GetLowerVale(
lowerValeIDX,
vale,
cBar.Index() //
);
//
int higherValeIDX = -1;
double higherVale = cHelper
.mX121Helper
.xpvHelper
.GetHigherVale(
higherValeIDX,
vale,
cBar.Index() //
);
//
if (IsValidIndex(lowerValeIDX) &&
IsValidIndex(higherValeIDX))
{
//
fromIDX =
lowerValeIDX < higherValeIDX
? lowerValeIDX
: higherValeIDX;
}
else if (IsValidIndex(lowerValeIDX) &&
!IsValidIndex(higherValeIDX))
{
//
fromIDX = lowerValeIDX;
}
else if (!IsValidIndex(lowerValeIDX) &&
IsValidIndex(higherValeIDX))
{
//
fromIDX = higherValeIDX;
}
}
else
{
//
double peak = cXConditions.peaksBuffer[cIDX];
box.upper = peak;
//
box.lower = cXConditions.peaksGoldenBuffer[cIDX];
//
int lowerPeakIDX = -1;
double lowerPeak = cHelper
.mX121Helper
.xpvHelper
.GetLowerPeak(
lowerPeakIDX,
peak,
cBar.Index() //
);
//
int higherPeakIDX = -1;
double higherPeak = cHelper
.mX121Helper
.xpvHelper
.GetHigherPeak(
higherPeakIDX,
peak,
cBar.Index() //
);
//
if (IsValidIndex(lowerPeakIDX) &&
IsValidIndex(higherPeakIDX))
{
//
fromIDX =
lowerPeakIDX < higherPeakIDX
? lowerPeakIDX
: higherPeakIDX;
}
else if (IsValidIndex(lowerPeakIDX) &&
!IsValidIndex(higherPeakIDX))
{
//
fromIDX = lowerPeakIDX;
}
else if (!IsValidIndex(lowerPeakIDX) &&
IsValidIndex(higherPeakIDX))
{
//
fromIDX = higherPeakIDX;
}
}
//
if (IsValidIndex(fromIDX))
{
//
box.from = iTime(
zBar.symbol,
zBar.period,
fromIDX //
);
}
else
{
box.from = pBar.time;
}
//
// Detect Holder Box ...
XBoxZone tmpBoxes[];
if (chState.IsValid())
{
//
if (isBullish)
{
//
// Demand Zones ...
XBoxZone tmp[];
ToBox(
chState.demandZones,
tmp //
);
Copy(
tmp,
tmpBoxes,
false //
);
Clean(tmp);
//
// Bullish Order Blocks ...
ToBox(
chState.bullishOrderBlocks,
tmp //
);
Copy(
tmp,
tmpBoxes,
false //
);
Clean(tmp);
//
// Bullish Fair Value Gaps ...
ToBox(
chState.bullishFairValueGaps,
tmp //
);
Copy(
tmp,
tmpBoxes,
false //
);
Clean(tmp);
}
else
{
//
// Supply Zones ...
XBoxZone tmp[];
ToBox(
chState.supplyZones,
tmp //
);
Copy(
tmp,
tmpBoxes,
false //
);
Clean(tmp);
//
// Bearish Order Blocks ...
ToBox(
chState.bearishOrderBlocks,
tmp //
);
Copy(
tmp,
tmpBoxes,
false //
);
Clean(tmp);
//
// Bearish Fair Value Gaps ...
ToBox(
chState.bearishFairValueGaps,
tmp //
);
Copy(
tmp,
tmpBoxes,
false //
);
Clean(tmp);
}
}
//
has = HasChild(tmpBoxes);
if (has)
{
//
while (HasChild(tmpBoxes))
{
//
idx = GetOldest(tmpBoxes);
has = IsValidIndex(idx);
if (!has)
{
break;
}
//
XBoxZone iBox = tmpBoxes[idx];
ArrayRemove(
tmpBoxes,
idx,
1 //
);
//
has = IsBoxInside(
box,
iBox //
);
if (has)
{
//
holderBox = iBox;
holderBox.to = TimeCurrent();
iBox.Clean();
break;
}
//
iBox.Clean();
}
}
//
Clean(tmpBoxes);
//
// Fix Box Upper and Lower based on Strategy ...
//
double points = GetPoints(box.symbol);
double minPointsDiff = points * 20;
//
double prefferSL = 0;
//
// Other SL Conditions ...
if (prefferSL <= 0)
{
//
if (isBullish)
{
//
if (zBar.open < cXConditions.valesGoldenBuffer[cIDX])
{
prefferSL = cXConditions.valesBuffer[cIDX];
}
else if (zBar.open > cXConditions.valesGoldenBuffer[cIDX] &&
zBar.open < cXConditions.peaksGoldenBuffer[cIDX])
{
prefferSL = cXConditions.valesGoldenBuffer[cIDX];
}
else if (zBar.open > cXConditions.peaksGoldenBuffer[cIDX])
{
//
if (cXConditions.sarBuffer[cIDX] > cXConditions.peaksGoldenBuffer[cIDX])
{
prefferSL = cXConditions.sarBuffer[cIDX];
}
else
{
prefferSL = zBar.open > cXConditions.peaksGoldenBuffer[cIDX];
}
}
}
else
{
//
if (zBar.open > cXConditions.peaksGoldenBuffer[cIDX])
{
prefferSL = cXConditions.peaksBuffer[cIDX];
}
else if (zBar.open < cXConditions.peaksGoldenBuffer[cIDX] &&
zBar.open > cXConditions.valesGoldenBuffer[cIDX])
{
prefferSL = cXConditions.peaksGoldenBuffer[cIDX];
}
else if (zBar.open < cXConditions.valesGoldenBuffer[cIDX])
{
//
if (cXConditions.sarBuffer[cIDX] < cXConditions.valesGoldenBuffer[cIDX])
{
prefferSL = cXConditions.sarBuffer[cIDX];
}
else
{
prefferSL = cXConditions.valesGoldenBuffer[cIDX];
}
}
}
}
//
if (prefferSL > 0)
{
//
box.upper =
isBullish
? zBar.open
: prefferSL;
//
box.lower =
isBullish
? prefferSL
: zBar.open;
}
//
// Validate Conditions to Force Has Holder Box ...
result =
result &&
holderBox.IsValid() &&
dir == holderBox.dir;
//
if (!result)
{
//
isBullish = false;
isBearish = false;
}
}
//
// Check All Conditions ...
result =
box.IsValid() &&
HasDirection(dir) &&
(isBullish ||
isBearish);
//
// Cleanup Resources ...
zBar.Clean();
cBar.Clean();
pBar.Clean();
cState.Clean();
chState.Clean();
ZeroMemory(cHelper);
cConditions.Clean();
cXConditions.Clean();
ZeroMemory(chHelper);
chConditions.Clean();
chXConditions.Clean();
//
return result;
}
//
bool HasSenario2Conditions(
ENUM_X_CYCLES ttfCycle,
XBoxZone &breakedBoxes[],
XBoxZone &box,
ENUM_X_DIRECTION &dir,
X121SMCStrategySignalProviderData &provider,
int barIndex = 0,
bool forceBarType = false,
bool forceFiboPressure = false //
)
{
//
bool result = false;
//
// Validate Args ...
result =
IsValid(ttfCycle) &&
HasChild(breakedBoxes);
if (!result)
{
return result;
}
//
// TODO: Add support for Extracting Trend ...
ENUM_X_DIRECTION trend = X_DIRECTION_NONE;
bool hasBullishTrend = IsBullish(trend);
bool hasBearishTrend = IsBearish(trend);
//
// TTF Cycle Extract ...
XPOIState ttfState;
X121Conditions ttfXConditions;
XC121SMCCycleHelper *ttfHelper;
X121SMCCycleConditions ttfConditions;
result = provider.SelectCycle(
ttfCycle,
ttfState,
ttfXConditions,
ttfHelper,
ttfConditions //
);
if (!result)
{
//
ttfState.Clean();
ZeroMemory(ttfHelper);
ttfConditions.Clean();
ttfXConditions.Clean();
//
return result;
}
Parse(ttfXConditions);
//
// Normalize Args ...
//
box.Clean();
dir = X_DIRECTION_NONE;
//
if (barIndex < 0)
{
barIndex = 0;
}
//
// Define Resources ...
//
int idx = -1;
int count = 0;
bool has = false;
//
int zIDX = barIndex;
int cIDX = zIDX + 1;
int pIDX = cIDX + 1;
//
double ask = GetAsk(ttfState.symbol);
double bid = GetBid(ttfState.symbol);
//
bool isBullish = false;
bool isBearish = false;
//
XOHCL zBar;
XOHCL cBar;
XOHCL pBar;
//
// Initial Bars ...
result = zBar.Init(
ttfState.symbol,
ttfState.period,
barIndex //
);
result =
result &&
zBar.GetPreviousBar(cBar);
result =
result &&
cBar.GetPreviousBar(pBar);
if (!result)
{
//
zBar.Clean();
cBar.Clean();
pBar.Clean();
ttfState.Clean();
ZeroMemory(ttfHelper);
ttfConditions.Clean();
ttfXConditions.Clean();
//
return result;
}
//
// Conditions ...
//
// First we Have to Detect Inside Box ...
XBoxZone insideBox;
count = ArraySize(breakedBoxes);
for (int i = 0; i < count; i++)
{
//
XBoxZone iBox = breakedBoxes[i];
//
bool isInside =
IsInsideBox(
zBar,
iBox //
);
if (isInside)
{
//
// Since we have to Follow Trend based on Breaked Boxes ...
// we have to use:
// - Breaked Bullish Boxes on Bearish Trend ...
// - Breaked Bearish Boxes on Bullish Trend ...
isInside =
hasBullishTrend
? iBox.IsBearish()
: hasBearishTrend
? iBox.IsBullish()
: false;
//
// Check Inside ...
if (isInside)
{
//
insideBox = iBox;
iBox.Clean();
//
break;
}
}
//
iBox.Clean();
}
//
// Check Inside Box is Valid or not ...
result = insideBox.IsValid();
if (!result)
{
//
zBar.Clean();
cBar.Clean();
pBar.Clean();
ttfState.Clean();
insideBox.Clean();
ZeroMemory(ttfHelper);
ttfConditions.Clean();
ttfXConditions.Clean();
}
//
// Update Inside Box From and To ...
// Based on Breaked ...
insideBox.from = insideBox.to;
insideBox.to = TimeCurrent();
//
// Detect Breaked Box Direction ...
bool isInsideBoxBullish = insideBox.IsBullish();
bool isInsideBoxBearish = insideBox.IsBearish();
//
// Detect Inside Box Rejection ...
//
bool isUpperBearishReject =
cBar.high >= insideBox.upper &&
cBar.GetUp() < insideBox.upper;
//
bool isUpperBullishReject =
cBar.low <= insideBox.upper &&
cBar.GetDown() > insideBox.upper;
//
bool isLowerBearishReject =
cBar.high >= insideBox.lower &&
cBar.GetUp() < insideBox.lower;
//
bool isLowerBullishReject =
cBar.low <= insideBox.lower &&
cBar.GetDown() > insideBox.lower;
//
// Apply Force Bar Type ...
if (forceBarType)
{
//
isUpperBearishReject =
isUpperBearishReject &&
cBar.IsBearish();
//
isUpperBullishReject =
isUpperBullishReject &&
cBar.IsBullish();
//
isLowerBearishReject =
isLowerBearishReject &&
cBar.IsBearish();
//
isLowerBullishReject =
isLowerBullishReject &&
cBar.IsBullish();
}
//
// Apply Force Fibo Pressure ...
if (forceBarType)
{
//
isUpperBearishReject =
isUpperBearishReject &&
ttfHelper
.mBarAnalyser
.HasFiboPressure(
cBar,
X_DIRECTION_BEARISH,
X_FIBO_LEVEL_382 //
);
//
isUpperBullishReject =
isUpperBullishReject &&
ttfHelper
.mBarAnalyser
.HasFiboPressure(
cBar,
X_DIRECTION_BULLISH,
X_FIBO_LEVEL_382 //
);
//
isLowerBearishReject =
isLowerBearishReject &&
ttfHelper
.mBarAnalyser
.HasFiboPressure(
cBar,
X_DIRECTION_BEARISH,
X_FIBO_LEVEL_382 //
);
//
isLowerBullishReject =
isLowerBullishReject &&
ttfHelper
.mBarAnalyser
.HasFiboPressure(
cBar,
X_DIRECTION_BULLISH,
X_FIBO_LEVEL_382 //
);
}
//
// Bullish Conditions ...
isBullish = (
//
hasBullishTrend &&
isInsideBoxBearish &&
isLowerBullishReject
//
);
//
// Bearish Conditions ...
isBearish = (
//
hasBearishTrend &&
isInsideBoxBullish &&
isUpperBearishReject
//
);
//
// Filling Requirements ...
result =
isBullish ||
isBearish;
if (result)
{
//
box = insideBox;
//
dir =
isBullish
? X_DIRECTION_BULLISH
: X_DIRECTION_BEARISH;
}
//
// Check All Conditions ...
result =
box.IsValid() &&
HasDirection(dir) &&
(isBullish ||
isBearish //
);
//
// Cleanup Resource ...
//
zBar.Clean();
cBar.Clean();
pBar.Clean();
//
ttfState.Clean();
insideBox.Clean();
ZeroMemory(ttfHelper);
ttfConditions.Clean();
ttfXConditions.Clean();
//
return result;
}
//
bool HasSenario4Conditions(
ENUM_X_CYCLES cycle,
XBoxZone &box,
XBoxZone &holderBox,
ENUM_X_DIRECTION &dir,
X121SMCStrategySignalProviderData &provider,
ENUM_X_CYCLES holderCycle = X_CYCLE_NONE,
int barIndex = 0 //
)
{
//
bool result = false;
//
// Fil Selected Data ...
XPOIState cState;
X121Conditions cXConditions;
XC121SMCCycleHelper *cHelper;
X121SMCCycleConditions cConditions;
result = provider.SelectCycle(
cycle,
cState,
cXConditions,
cHelper,
cConditions //
);
if (!result)
{
//
cState.Clean();
ZeroMemory(cHelper);
cConditions.Clean();
cXConditions.Clean();
//
return result;
}
Parse(cXConditions);
//
// Fil Selected Data ...
XPOIState chState;
X121Conditions chXConditions;
XC121SMCCycleHelper *chHelper;
X121SMCCycleConditions chConditions;
if (holderCycle != X_CYCLE_NONE)
{
//
result = provider.SelectCycle(
holderCycle,
chState,
chXConditions,
chHelper,
chConditions //
);
if (!result)
{
//
chState.Clean();
ZeroMemory(chHelper);
chConditions.Clean();
chXConditions.Clean();
//
return result;
}
//
Parse(chXConditions);
}
//
// Normalize Args ...
//
box.Clean();
holderBox.Clean();
dir = X_DIRECTION_NONE;
//
if (barIndex < 0)
{
barIndex = 0;
}
//
int idx = -1;
int count = 0;
bool has = false;
//
int zIDX = barIndex;
int cIDX = zIDX + 1;
int pIDX = cIDX + 1;
//
bool isBullish = false;
bool isBearish = false;
//
XOHCL zBar;
XOHCL cBar;
XOHCL pBar;
//
// 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();
chState.Clean();
ZeroMemory(cHelper);
cConditions.Clean();
cXConditions.Clean();
ZeroMemory(chHelper);
chConditions.Clean();
chXConditions.Clean();
//
return result;
}
//
// Detecting Signal Conditions ...
//
// Bullish Conditions ...
isBullish =
//
// Base Condition ...
(
//
cBar.IsBullish() &&
zBar.open >= cBar.close &&
(
//
// Regular Reject ...
(pBar.low > cBar.low &&
cBar.low < cXConditions.valesGoldenBuffer[cIDX] &&
cBar.GetDown() > cXConditions.valesGoldenBuffer[cIDX])
//
||
//
// Regular Exit ...
(pBar.low < cXConditions.valesGoldenBuffer[cIDX] &&
(cBar.low > cXConditions.valesGoldenBuffer[cIDX] ||
cBar.GetUp() > cXConditions.valesGoldenBuffer[cIDX]))
//
||
//
IsBarBreak(
cXConditions.valesGoldenBuffer[cIDX],
X_DIRECTION_BULLISH,
cBar //
)
//
||
//
IsBarReject(
cXConditions.valesGoldenBuffer[cIDX],
X_DIRECTION_BULLISH,
cBar //
)
//
)
//
)
//
&&
//
// Checking other Conditions ...
(
//
// XSAR ...
cXConditions.isSarBullish &&
//
// XSTR ...
cXConditions.isStrSwitchedToBullish &&
//
// // X3MA ...
// // XVWAP ...
// (cXConditions.isX3MaFastOverMid ||
// cXConditions.isVWapFastOverMid) &&
//
// XHK ...
cXConditions.isSMHKBullish &&
cXConditions.isRawHKBullish &&
//
// XCHE ...
cXConditions.isCheBullish &&
cXConditions.le1Buffer[cIDX] < cBar.low &&
cXConditions.le2Buffer[cIDX] < cBar.low
//
)
//
;
//
// Bearish Conditions ...
isBearish =
//
// Base Condition ...
(
//
cBar.IsBearish() &&
zBar.open <= cBar.close &&
(
//
// Regular Reject ...
(pBar.high < cBar.high &&
cBar.high > cXConditions.peaksGoldenBuffer[cIDX] &&
cBar.GetUp() < cXConditions.peaksGoldenBuffer[cIDX])
//
||
//
// Regular Exit ...
(pBar.high > cXConditions.peaksGoldenBuffer[cIDX] &&
(cBar.high < cXConditions.peaksGoldenBuffer[cIDX] ||
cBar.GetDown() < cXConditions.peaksGoldenBuffer[cIDX]))
//
||
//
IsBarBreak(
cXConditions.peaksGoldenBuffer[cIDX],
X_DIRECTION_BEARISH,
cBar //
)
//
||
//
IsBarReject(
cXConditions.peaksGoldenBuffer[cIDX],
X_DIRECTION_BEARISH,
cBar //
)
//
)
//
)
//
&&
//
// Checking other Conditions ...
(
//
// XSAR ...
cXConditions.isSarBearish &&
//
// XSTR ...
cXConditions.isStrSwitchedToBearish &&
//
// // X3MA ...
// // XVWAP ...
// (cXConditions.isX3MaFastUnderMid ||
// cXConditions.isVWapFastUnderMid) &&
//
// XHK ...
cXConditions.isSMHKBearish &&
cXConditions.isRawHKBearish &&
//
// XCHE ...
cXConditions.isCheBearish &&
cXConditions.se1Buffer[cIDX] > cBar.high &&
cXConditions.se2Buffer[cIDX] > cBar.high
//
)
//
;
//
// Filling Requirements ...
result =
isBullish ||
isBearish;
if (result)
{
//
dir =
isBullish
? X_DIRECTION_BULLISH
: X_DIRECTION_BEARISH;
//
box.dir = dir;
box.to = TimeCurrent();
box.symbol = cXConditions.symbol;
box.period = cXConditions.period;
//
int fromIDX = -1;
if (isBullish)
{
//
double vale = cXConditions.valesBuffer[cIDX];
box.lower = vale;
box.upper = cXConditions.valesGoldenBuffer[cIDX];
//
int lowerValeIDX = -1;
double lowerVale = cHelper
.mX121Helper
.xpvHelper
.GetLowerVale(
lowerValeIDX,
vale,
cBar.Index() //
);
//
int higherValeIDX = -1;
double higherVale = cHelper
.mX121Helper
.xpvHelper
.GetHigherVale(
higherValeIDX,
vale,
cBar.Index() //
);
//
if (IsValidIndex(lowerValeIDX) &&
IsValidIndex(higherValeIDX))
{
//
fromIDX =
lowerValeIDX < higherValeIDX
? lowerValeIDX
: higherValeIDX;
}
else if (IsValidIndex(lowerValeIDX) &&
!IsValidIndex(higherValeIDX))
{
//
fromIDX = lowerValeIDX;
}
else if (!IsValidIndex(lowerValeIDX) &&
IsValidIndex(higherValeIDX))
{
//
fromIDX = higherValeIDX;
}
}
else
{
//
double peak = cXConditions.peaksBuffer[cIDX];
box.upper = peak;
//
box.lower = cXConditions.peaksGoldenBuffer[cIDX];
//
int lowerPeakIDX = -1;
double lowerPeak = cHelper
.mX121Helper
.xpvHelper
.GetLowerPeak(
lowerPeakIDX,
peak,
cBar.Index() //
);
//
int higherPeakIDX = -1;
double higherPeak = cHelper
.mX121Helper
.xpvHelper
.GetHigherPeak(
higherPeakIDX,
peak,
cBar.Index() //
);
//
if (IsValidIndex(lowerPeakIDX) &&
IsValidIndex(higherPeakIDX))
{
//
fromIDX =
lowerPeakIDX < higherPeakIDX
? lowerPeakIDX
: higherPeakIDX;
}
else if (IsValidIndex(lowerPeakIDX) &&
!IsValidIndex(higherPeakIDX))
{
//
fromIDX = lowerPeakIDX;
}
else if (!IsValidIndex(lowerPeakIDX) &&
IsValidIndex(higherPeakIDX))
{
//
fromIDX = higherPeakIDX;
}
}
//
if (IsValidIndex(fromIDX))
{
//
box.from = iTime(
zBar.symbol,
zBar.period,
fromIDX //
);
}
else
{
box.from = pBar.time;
}
//
// Detect Holder Box ...
XBoxZone tmpBoxes[];
if (chState.IsValid())
{
//
if (isBullish)
{
//
// Demand Zones ...
XBoxZone tmp[];
ToBox(
chState.demandZones,
tmp //
);
Copy(
tmp,
tmpBoxes,
false //
);
Clean(tmp);
//
// Bullish Order Blocks ...
ToBox(
chState.bullishOrderBlocks,
tmp //
);
Copy(
tmp,
tmpBoxes,
false //
);
Clean(tmp);
//
// Bullish Fair Value Gaps ...
ToBox(
chState.bullishFairValueGaps,
tmp //
);
Copy(
tmp,
tmpBoxes,
false //
);
Clean(tmp);
}
else
{
//
// Supply Zones ...
XBoxZone tmp[];
ToBox(
chState.supplyZones,
tmp //
);
Copy(
tmp,
tmpBoxes,
false //
);
Clean(tmp);
//
// Bearish Order Blocks ...
ToBox(
chState.bearishOrderBlocks,
tmp //
);
Copy(
tmp,
tmpBoxes,
false //
);
Clean(tmp);
//
// Bearish Fair Value Gaps ...
ToBox(
chState.bearishFairValueGaps,
tmp //
);
Copy(
tmp,
tmpBoxes,
false //
);
Clean(tmp);
}
}
//
has = HasChild(tmpBoxes);
if (has)
{
//
while (HasChild(tmpBoxes))
{
//
idx = GetOldest(tmpBoxes);
has = IsValidIndex(idx);
if (!has)
{
break;
}
//
XBoxZone iBox = tmpBoxes[idx];
ArrayRemove(
tmpBoxes,
idx,
1 //
);
//
has = IsBoxInside(
box,
iBox //
);
if (has)
{
//
holderBox = iBox;
holderBox.to = TimeCurrent();
iBox.Clean();
break;
}
//
iBox.Clean();
}
}
//
Clean(tmpBoxes);
//
// Validate Conditions to Force Has Holder Box ...
result =
result &&
holderBox.IsValid();
if (!result)
{
//
isBullish = false;
isBearish = false;
}
}
//
// Check All Conditions ...
result =
box.IsValid() &&
HasDirection(dir) &&
(isBullish ||
isBearish);
//
// Cleanup Resources ...
zBar.Clean();
cBar.Clean();
pBar.Clean();
cState.Clean();
chState.Clean();
ZeroMemory(cHelper);
cConditions.Clean();
cXConditions.Clean();
ZeroMemory(chHelper);
chConditions.Clean();
chXConditions.Clean();
//
return result;
}
//
};
Reference in New Issue View Git Blame Copy Permalink