4070 lines
112 KiB
Plaintext
4070 lines
112 KiB
Plaintext
///////////////////////////////////////////////////////
|
|
//
|
|
// SaherElm IT Center MQL5 Class Library
|
|
// --------------------------------------
|
|
// Name: XCX121SMCTestStrategy
|
|
// 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-121.smc.base.strategy.class.mq5"
|
|
#include "../Classes/x-121.smc.market.cycle.helper.class.mq5"
|
|
|
|
//
|
|
// Definitions ...
|
|
|
|
//
|
|
// XStrategy Class Implementation(s) ...
|
|
class XCX121SMCTestStrategy : public XCX121SMCBaseStrategy
|
|
{
|
|
//
|
|
// Public ...
|
|
public:
|
|
//
|
|
|
|
//
|
|
// Constructor(s) ...
|
|
void XCX121SMCTestStrategy(
|
|
//
|
|
// Base ...
|
|
string _symbol, // Trading Symbol
|
|
ENUM_TIMEFRAMES _period // Trading TimeFrame
|
|
)
|
|
: XCX121SMCBaseStrategy(_symbol, _period)
|
|
{
|
|
InitialHelpers();
|
|
}
|
|
|
|
//
|
|
// Deconstructur ...
|
|
void ~XCX121SMCTestStrategy()
|
|
{
|
|
}
|
|
|
|
//
|
|
// Overrides Actions ...
|
|
|
|
/**
|
|
* Destroy All Class Implementations ...
|
|
*/
|
|
void Destroy() override
|
|
{
|
|
//
|
|
delete mTriggerCycleHelper;
|
|
delete mDecisionCycleHelper;
|
|
delete mAnalyseCycleHelper;
|
|
delete mVerificationCycleHelper;
|
|
delete mConsolidationCycleHelper;
|
|
delete mVisionCycleHelper;
|
|
}
|
|
|
|
/**
|
|
* Check Conditions For Signal ...
|
|
*/
|
|
bool HasSignal(
|
|
XSignal &signal,
|
|
X121SMCStrategyConditions &conditions //
|
|
) override
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
signal.Clean();
|
|
conditions.Clean();
|
|
|
|
//
|
|
int pushers = 0;
|
|
|
|
//
|
|
double sl = 0;
|
|
double tp = 0;
|
|
double risk = 0;
|
|
double entry = 0;
|
|
double reward = 0;
|
|
double r2r = R2R();
|
|
string provider = "";
|
|
double volume = Volume();
|
|
ENUM_POSITION_TYPE type = POSITION_TYPE_BUY;
|
|
ENUM_X_ORDER_MODES mode = X_ORDER_MODE_MARKET;
|
|
|
|
//
|
|
bool hasLong = false;
|
|
bool hasShort = false;
|
|
|
|
//
|
|
double selectedSL = 0;
|
|
|
|
//
|
|
// Start Calculations ...
|
|
|
|
//
|
|
// Retrieve Common Data ...
|
|
string symbol = GetSymbol();
|
|
ENUM_TIMEFRAMES period = GetPeriod();
|
|
|
|
//
|
|
// Required Value For SL/TP Calculations ...
|
|
double points = GetPoints(symbol);
|
|
double pip = GetPipPrice(symbol);
|
|
double pip2 = 2 * pip;
|
|
|
|
//
|
|
// Retrieve and Fill Cycle Conditions ...
|
|
result = GetCyclesConditions(conditions);
|
|
if (!result)
|
|
{
|
|
//
|
|
conditions.Clean();
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Check Spread for Signalling Conditions ...
|
|
bool isSpreadPassed = IsSpreadPass();
|
|
result = isSpreadPassed;
|
|
if (!result)
|
|
{
|
|
//
|
|
conditions.Clean();
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Detect Signal Conditions ...
|
|
bool hasSignal = false;
|
|
|
|
//
|
|
bool hasSMPVSignal = false;
|
|
bool hasRJBPVSignal = false;
|
|
bool hasVWAPCSignal = false;
|
|
bool hasTestSignal = false;
|
|
|
|
//
|
|
// X_121_SMC_PROVIDER_SMPV ...
|
|
if (!hasSignal)
|
|
{
|
|
//
|
|
// hasSMPVSignal = DetectSamePeaksAndValesSignal(conditions);
|
|
// hasSignal = hasSMPVSignal;
|
|
}
|
|
|
|
//
|
|
// X_121_SMC_PROVIDER_RJBPV ...
|
|
if (!hasSignal)
|
|
{
|
|
// //
|
|
// hasRJBPVSignal = DetectRJBPVSignal(conditions);
|
|
// hasSignal = hasRJBPVSignal;
|
|
}
|
|
|
|
//
|
|
// X_121_SMC_PROVIDER_VWAPC ...
|
|
if (!hasSignal)
|
|
{
|
|
// //
|
|
// hasVWAPCSignal = DetectVWAPCSignal(conditions);
|
|
// hasSignal = hasVWAPCSignal;
|
|
}
|
|
|
|
//
|
|
if (!hasSignal)
|
|
{
|
|
//
|
|
hasTestSignal = DetectTestSignal(conditions);
|
|
hasSignal = hasTestSignal;
|
|
}
|
|
|
|
//
|
|
result = hasSignal;
|
|
if (!result)
|
|
{
|
|
//
|
|
conditions.Clean();
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Combine all Signals Conditions ...
|
|
selectedSL = conditions.sl;
|
|
provider = conditions.provider;
|
|
|
|
//
|
|
hasLong =
|
|
//
|
|
IsBullish(conditions.signalDir)
|
|
//
|
|
;
|
|
|
|
//
|
|
hasShort =
|
|
//
|
|
IsBearish(conditions.signalDir)
|
|
//
|
|
;
|
|
|
|
//
|
|
result = hasLong ||
|
|
hasShort;
|
|
|
|
//
|
|
// Rmove Signal Condition ...
|
|
if (result)
|
|
{
|
|
//
|
|
// TYPE ...
|
|
type =
|
|
hasLong
|
|
? POSITION_TYPE_BUY
|
|
: POSITION_TYPE_SELL;
|
|
ENUM_X_POSITION_TYPES xType =
|
|
hasLong
|
|
? X_POSITION_TYPE_LONG
|
|
: X_POSITION_TYPE_SHORT;
|
|
|
|
//
|
|
entry = GetEntry(
|
|
conditions.symbol,
|
|
type //
|
|
);
|
|
|
|
//
|
|
double slAddition = 0;
|
|
sl =
|
|
hasLong
|
|
? selectedSL - slAddition
|
|
: selectedSL + slAddition;
|
|
|
|
//
|
|
// RISK Reward ...
|
|
risk =
|
|
hasLong
|
|
? entry - sl
|
|
: sl - entry;
|
|
reward = risk * r2r;
|
|
tp =
|
|
hasLong
|
|
? entry + reward
|
|
: entry - reward;
|
|
|
|
//
|
|
signal.sl = sl;
|
|
signal.tp = tp;
|
|
signal.type = type;
|
|
signal.mode = mode;
|
|
signal.entry = entry;
|
|
signal.volume = volume;
|
|
signal.symbol = symbol;
|
|
signal.period = period;
|
|
signal.pushers = pushers;
|
|
signal.provider = provider;
|
|
signal.time = TimeCurrent();
|
|
|
|
//
|
|
result = PrepareSignal(signal);
|
|
if (result)
|
|
{
|
|
DrawSignal(signal);
|
|
}
|
|
|
|
//
|
|
hasLong = false;
|
|
hasShort = false;
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Customize Strategy Identifier ...
|
|
*/
|
|
string GetTag() override
|
|
{
|
|
return X121SMCStrategyToken;
|
|
}
|
|
|
|
//
|
|
// Protected ...
|
|
protected:
|
|
//
|
|
|
|
//
|
|
// Props ...
|
|
|
|
//
|
|
// Trigger Order Flow ...
|
|
XPVPivot mOrderFlow[];
|
|
ENUM_X_DIRECTION mOrderFlowDir;
|
|
|
|
//
|
|
ENUM_X_CYCLE_EVENTS mTriggerCycleEvents[];
|
|
XC121SMCCycleHelper *mTriggerCycleHelper;
|
|
|
|
//
|
|
ENUM_X_CYCLE_EVENTS mDecisionCycleEvents[];
|
|
XC121SMCCycleHelper *mDecisionCycleHelper;
|
|
|
|
//
|
|
ENUM_X_CYCLE_EVENTS mAnalyseCycleEvents[];
|
|
XC121SMCCycleHelper *mAnalyseCycleHelper;
|
|
|
|
//
|
|
ENUM_X_CYCLE_EVENTS mVerificationCycleEvents[];
|
|
XC121SMCCycleHelper *mVerificationCycleHelper;
|
|
|
|
//
|
|
ENUM_X_CYCLE_EVENTS mConsolidationCycleEvents[];
|
|
XC121SMCCycleHelper *mConsolidationCycleHelper;
|
|
|
|
//
|
|
ENUM_X_CYCLE_EVENTS mVisionCycleEvents[];
|
|
XC121SMCCycleHelper *mVisionCycleHelper;
|
|
|
|
//
|
|
// Actions ...
|
|
|
|
/**
|
|
* Retrieve Cycles Conditions ...
|
|
*
|
|
* @param conditions: X121SMCStrategyConditions instance Reference ...
|
|
*
|
|
* @return ( bool )
|
|
*/
|
|
bool GetCyclesConditions(
|
|
X121SMCStrategyConditions &conditions //
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
string symbol = GetSymbol();
|
|
ENUM_TIMEFRAMES period = GetPeriod();
|
|
|
|
//
|
|
int zIndex = 0;
|
|
int cIndex = zIndex + 1;
|
|
int pIndex = cIndex + 1;
|
|
int ppIndex = pIndex + 1;
|
|
|
|
//
|
|
datetime cTime = TimeCurrent();
|
|
|
|
//
|
|
conditions.time = cTime;
|
|
conditions.symbol = symbol;
|
|
conditions.period = period;
|
|
|
|
//
|
|
int conditionsLoopback = 7;
|
|
|
|
//
|
|
// Fill Cycles Conditions ...
|
|
|
|
//
|
|
// Trigger ...
|
|
result = mTriggerCycleHelper.GetConditions(
|
|
mTriggerCycleEvents,
|
|
conditions.triggerConditions,
|
|
zIndex,
|
|
conditionsLoopback //
|
|
);
|
|
if (!result)
|
|
{
|
|
//
|
|
conditions.Clean();
|
|
return result;
|
|
}
|
|
conditions.triggerConditions.state = mTriggerState;
|
|
|
|
//
|
|
// Decision ...
|
|
result = mDecisionCycleHelper.GetConditions(
|
|
mDecisionCycleEvents,
|
|
conditions.decisionConditions,
|
|
zIndex,
|
|
conditionsLoopback //
|
|
);
|
|
if (!result)
|
|
{
|
|
//
|
|
conditions.Clean();
|
|
return result;
|
|
}
|
|
conditions.decisionConditions.state = mDecisionState;
|
|
|
|
//
|
|
// Analyse ...
|
|
result = mAnalyseCycleHelper.GetConditions(
|
|
mAnalyseCycleEvents,
|
|
conditions.analyseConditions,
|
|
zIndex,
|
|
conditionsLoopback //
|
|
);
|
|
if (!result)
|
|
{
|
|
//
|
|
conditions.Clean();
|
|
return result;
|
|
}
|
|
conditions.analyseConditions.state = mAnalyseState;
|
|
|
|
//
|
|
// Verification ...
|
|
result = mVerificationCycleHelper.GetConditions(
|
|
mVerificationCycleEvents,
|
|
conditions.verificationConditions,
|
|
zIndex,
|
|
conditionsLoopback //
|
|
);
|
|
if (!result)
|
|
{
|
|
//
|
|
conditions.Clean();
|
|
return result;
|
|
}
|
|
conditions.verificationConditions.state = mVerificationState;
|
|
|
|
//
|
|
// Consolidation ...
|
|
result = mConsolidationCycleHelper.GetConditions(
|
|
mConsolidationCycleEvents,
|
|
conditions.consolidationConditions,
|
|
zIndex,
|
|
conditionsLoopback //
|
|
);
|
|
if (!result)
|
|
{
|
|
//
|
|
conditions.Clean();
|
|
return result;
|
|
}
|
|
conditions.consolidationConditions.state = mConsolidationState;
|
|
|
|
//
|
|
// Vision ...
|
|
result = mVisionCycleHelper.GetConditions(
|
|
mVisionCycleEvents,
|
|
conditions.visionConditions,
|
|
zIndex,
|
|
conditionsLoopback //
|
|
);
|
|
if (!result)
|
|
{
|
|
//
|
|
conditions.Clean();
|
|
return result;
|
|
}
|
|
conditions.visionConditions.state = mVisionState;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Signalling Functions ...
|
|
|
|
/**
|
|
* Detect and Parse Market Conditions for Signalling ...
|
|
*
|
|
* @param conditions: X121SMCStrategyConditions instance Reference ...
|
|
*
|
|
* @return ( bool )
|
|
*/
|
|
bool DetectSamePeaksAndValesSignal(
|
|
X121SMCStrategyConditions &conditions //
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
string symbol = GetSymbol();
|
|
ENUM_TIMEFRAMES period = GetPeriod();
|
|
|
|
//
|
|
ENUM_X_121_SMC_PROVIDERS provider = X_121_SMC_PROVIDER_SMPV;
|
|
string providerStr = ToString(provider);
|
|
|
|
//
|
|
int zIndex = 0;
|
|
int cIndex = zIndex + 1;
|
|
int pIndex = cIndex + 1;
|
|
int ppIndex = pIndex + 1;
|
|
|
|
//
|
|
XOHCL zBar;
|
|
result = zBar.Init(
|
|
symbol,
|
|
period,
|
|
zIndex //
|
|
);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
XOHCL cBar;
|
|
result = cBar.Init(
|
|
symbol,
|
|
period,
|
|
cIndex //
|
|
);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
string msg = NULL;
|
|
|
|
//
|
|
double bid = GetBid(symbol);
|
|
datetime cTime = TimeCurrent();
|
|
|
|
//
|
|
double selectedSL = 0;
|
|
|
|
//
|
|
// Here We Select Cycles For Conditions Check ...
|
|
ENUM_X_CYCLES cycles[5] = {
|
|
X_CYCLE_TRIGGER,
|
|
X_CYCLE_DECISION,
|
|
X_CYCLE_ANALYSE,
|
|
X_CYCLE_VERIFICATION,
|
|
X_CYCLE_CONSOLIDATION //
|
|
};
|
|
bool hasSamePeaks = DetectSamePeaks(
|
|
cycles,
|
|
conditions //
|
|
);
|
|
bool hasSameVales = DetectSameVales(
|
|
cycles,
|
|
conditions //
|
|
);
|
|
result =
|
|
hasSamePeaks ||
|
|
hasSameVales;
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Check Peaks And Vales Order ...
|
|
bool hasPeakBreak = false;
|
|
bool hasValeBreak = false;
|
|
|
|
//
|
|
// Retrieve Last Sar Change ...
|
|
XOHCL cSarChangeBar;
|
|
XOHCL pSarChangeBar;
|
|
XValueChange cSarChange; // Current Sar Change (IsDirect) ...
|
|
XValueChange pSarChange; // Prev Sar Change (Direct) ...
|
|
XValueChange sarChanges[];
|
|
int sarChangesCount = mTriggerCycleHelper
|
|
.FillSarChanges(sarChanges);
|
|
if (IsValidSize(sarChangesCount) &&
|
|
sarChangesCount > 2)
|
|
{
|
|
//
|
|
cSarChange = sarChanges[sarChangesCount - 1];
|
|
pSarChange = sarChanges[sarChangesCount - 2];
|
|
|
|
//
|
|
result = cSarChange.FillBar(
|
|
cSarChangeBar,
|
|
symbol,
|
|
period //
|
|
);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
result = pSarChange.FillBar(
|
|
pSarChangeBar,
|
|
symbol,
|
|
period //
|
|
);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
int start = cSarChangeBar.Index();
|
|
int end = pSarChangeBar.Index();
|
|
for (int i = start; i < end; i++)
|
|
{
|
|
//
|
|
ENUM_X_CYCLE_EVENTS iEvents[];
|
|
X121SMCCycleConditions iConditions;
|
|
result = mTriggerCycleHelper.GetConditions(
|
|
iEvents,
|
|
iConditions,
|
|
i //
|
|
);
|
|
if (!result)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
//
|
|
hasPeakBreak =
|
|
iConditions.x121Conditions.isNewPeakOverLast;
|
|
hasValeBreak =
|
|
iConditions.x121Conditions.isNewValeUnderLast;
|
|
result = hasPeakBreak ||
|
|
hasValeBreak;
|
|
if (result)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Check Sar State ...
|
|
ENUM_X_DIRECTION sarDir;
|
|
result = DetectSarState(
|
|
provider,
|
|
sarDir,
|
|
conditions //
|
|
);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Check VWAP State ...
|
|
ENUM_X_DIRECTION vwapDir;
|
|
result = DetectVWapState(
|
|
provider,
|
|
vwapDir,
|
|
conditions //
|
|
);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Detect a Valid Peaks Break ...
|
|
|
|
//
|
|
// Find Supply and Demand Zones ...
|
|
// XPOIState state = conditions.visionConditions.state;
|
|
// int supplyZonesCount =
|
|
|
|
//
|
|
bool isBullish =
|
|
//
|
|
hasSamePeaks &&
|
|
hasPeakBreak &&
|
|
IsBullish(sarDir) &&
|
|
IsBullish(vwapDir)
|
|
//
|
|
;
|
|
|
|
//
|
|
bool isBearish =
|
|
//
|
|
hasSameVales &&
|
|
hasValeBreak &&
|
|
IsBearish(sarDir) &&
|
|
IsBearish(vwapDir)
|
|
//
|
|
;
|
|
|
|
//
|
|
result =
|
|
isBullish ||
|
|
isBearish;
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
CustomStateDrawing(
|
|
conditions.visionConditions.state,
|
|
false, //
|
|
X_DIRECTION_NONE,
|
|
false, // ignoreSwingHighs
|
|
false, // ignoreSwingLows
|
|
true, // ignoreSupportZones
|
|
true, // ignoreResistanceZones
|
|
false, // ignoreSupplyZones
|
|
false, // ignoreDemandZones
|
|
true, // ignoreBullishOrderBlocks
|
|
true, // ignoreBearishOrderBlocks
|
|
true, // ignoreBullishFairValueGaps
|
|
true, // ignoreBearishFairValueGaps
|
|
true, // ignoreBullishRejectionBars
|
|
true, // ignoreBearishRejectionBars
|
|
true, // ignoreBullishMomentumBars
|
|
true // ignoreBearishMomentumBars
|
|
);
|
|
|
|
//
|
|
// Set SL, Provider and Direction ...
|
|
conditions.signalDir =
|
|
isBullish
|
|
? X_DIRECTION_BULLISH
|
|
: X_DIRECTION_BEARISH;
|
|
conditions.provider = providerStr;
|
|
|
|
//
|
|
// Selectiong SL ...
|
|
double selectedSLRJ = SelectSL(
|
|
conditions,
|
|
conditions.signalDir,
|
|
X_121_SMC_SL_TYPE_REJECTION //
|
|
);
|
|
double selectedSLMN = SelectSL(
|
|
conditions,
|
|
conditions.signalDir,
|
|
X_121_SMC_SL_TYPE_MOMENTUM //
|
|
);
|
|
double selectedSLSW = SelectSL(
|
|
conditions,
|
|
conditions.signalDir,
|
|
X_121_SMC_SL_TYPE_SWING //
|
|
);
|
|
double selectedSLSR = SelectSL(
|
|
conditions,
|
|
conditions.signalDir,
|
|
X_121_SMC_SL_TYPE_CURRENT_SAR //
|
|
);
|
|
|
|
//
|
|
double slCandidates[4] = {
|
|
selectedSLRJ,
|
|
selectedSLMN,
|
|
selectedSLSW,
|
|
selectedSLSR //
|
|
};
|
|
selectedSL = isBullish
|
|
? GetMin(slCandidates)
|
|
: GetMax(slCandidates);
|
|
|
|
//
|
|
// Normalizing SL ...
|
|
double entry = GetEntry(
|
|
symbol,
|
|
conditions.signalDir //
|
|
);
|
|
double pip = GetPipPrice(symbol);
|
|
double spread = GetSpread(symbol);
|
|
double points = GetPoints(symbol);
|
|
|
|
//
|
|
if (isBullish && selectedSL <= entry)
|
|
{
|
|
selectedSL -= (points * 30) - spread;
|
|
}
|
|
else if (isBearish && selectedSL >= entry)
|
|
{
|
|
selectedSL += (points * 30) + spread;
|
|
}
|
|
|
|
//
|
|
// Detect SL and TP ...
|
|
conditions.sl = selectedSL;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Detect and Parse Market Conditions for Signalling ...
|
|
*
|
|
* @param conditions: X121SMCStrategyConditions instance Reference ...
|
|
*
|
|
* @return ( bool )
|
|
*/
|
|
bool DetectRJBPVSignal(
|
|
X121SMCStrategyConditions &conditions //
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
string symbol = GetSymbol();
|
|
ENUM_TIMEFRAMES period = GetPeriod();
|
|
|
|
//
|
|
int zIndex = 0;
|
|
int cIndex = zIndex + 1;
|
|
int pIndex = cIndex + 1;
|
|
int ppIndex = pIndex + 1;
|
|
|
|
//
|
|
XOHCL zBar;
|
|
result = zBar.Init(
|
|
symbol,
|
|
period,
|
|
zIndex //
|
|
);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
XOHCL cBar;
|
|
result = cBar.Init(
|
|
symbol,
|
|
period,
|
|
cIndex //
|
|
);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
XOHCL pBar;
|
|
result = pBar.Init(
|
|
symbol,
|
|
period,
|
|
pIndex //
|
|
);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
string msg = NULL;
|
|
|
|
//
|
|
double bid = GetBid(symbol);
|
|
datetime cTime = TimeCurrent();
|
|
|
|
//
|
|
ENUM_X_121_SMC_PROVIDERS provider = X_121_SMC_PROVIDER_RJBPV;
|
|
string providerStr = ToString(provider);
|
|
|
|
//
|
|
// Bar High Eqauls to Peaks or Vale ...
|
|
double peak = conditions.triggerConditions.x121Conditions.peaksBuffer[2];
|
|
double vale = conditions.triggerConditions.x121Conditions.valesBuffer[2];
|
|
bool isNewPeak = conditions.triggerConditions.x121Conditions.peaksBuffer[2] != conditions.triggerConditions.x121Conditions.peaksBuffer[3];
|
|
bool isNewVale = conditions.triggerConditions.x121Conditions.valesBuffer[2] != conditions.triggerConditions.x121Conditions.valesBuffer[3];
|
|
bool isClosedUnderDonCloseUpper = cBar.close <
|
|
conditions.triggerConditions.x121Conditions.donCloseUpperBuffer[1];
|
|
bool isClosedOverDonCloseLower = cBar.close >
|
|
conditions.triggerConditions.x121Conditions.donCloseLowerBuffer[1];
|
|
bool isSarBullish =
|
|
zBar.low > conditions.triggerConditions.x121Conditions.sarBuffer[0];
|
|
bool isSarBearish =
|
|
zBar.high < conditions.triggerConditions.x121Conditions.sarBuffer[0];
|
|
|
|
//
|
|
// XPVPivot orderFlow[];
|
|
// ENUM_X_DIRECTION orderFlowDir;
|
|
// mTriggerCycleHelper
|
|
// .DetectOrderFlow(
|
|
// zIndex,
|
|
// orderFlow,
|
|
// orderFlowDir //
|
|
// );
|
|
// int pivotsCount = ArraySize(orderFlow);
|
|
// result = IsValidSize(pivotsCount);
|
|
// if (!result)
|
|
// {
|
|
// return result;
|
|
// }
|
|
// XPVPivot lastPivot = orderFlow[pivotsCount - 1];
|
|
|
|
//
|
|
double zoneVerificationDivider = 10;
|
|
bool isPeakInsideSupplyZone = false;
|
|
bool isValeInsideDemandZone = false;
|
|
|
|
//
|
|
XPOIState state = conditions.verificationConditions.state;
|
|
|
|
// //
|
|
// // Detect Order Block ...
|
|
// XCOrderBlock *orderBlock = NULL;
|
|
|
|
// //
|
|
// int bullishOBCount = state.CountBullishOrderBlocks();
|
|
// if (IsValidSize(bullishOBCount))
|
|
// {
|
|
// //
|
|
// for (int i = 0; i < bullishOBCount; i++)
|
|
// {
|
|
// //
|
|
// XCOrderBlock *iZone = state.bullishOrderBlocks[i];
|
|
|
|
// //
|
|
// bool isInside = vale >= iZone.Lower() &&
|
|
// vale <= iZone.Upper() &&
|
|
// bid <= iZone.Lower() + ((iZone.Upper() - iZone.Lower()) / zoneVerificationDivider);
|
|
// if (isInside)
|
|
// {
|
|
// //
|
|
// orderBlock = iZone;
|
|
// break;
|
|
// }
|
|
// }
|
|
// }
|
|
|
|
// //
|
|
// int bearishOBCount = state.CountBearishOrderBlocks();
|
|
// if (IsValidSize(bearishOBCount))
|
|
// {
|
|
// //
|
|
// for (int i = 0; i < bearishOBCount; i++)
|
|
// {
|
|
// //
|
|
// XCOrderBlock *iZone = state.bearishOrderBlocks[i];
|
|
|
|
// //
|
|
// bool isInside = peak >= iZone.Lower() &&
|
|
// peak <= iZone.Upper() &&
|
|
// bid >= iZone.Upper() - ((iZone.Upper() - iZone.Lower()) / zoneVerificationDivider);
|
|
// if (isInside)
|
|
// {
|
|
// //
|
|
// orderBlock = iZone;
|
|
// break;
|
|
// }
|
|
// }
|
|
// }
|
|
|
|
// //
|
|
// result = orderBlock != NULL &&
|
|
// orderBlock.IsValid();
|
|
// if (!result)
|
|
// {
|
|
// return result;
|
|
// }
|
|
|
|
// //
|
|
// // Draw Order Block ...
|
|
// orderBlock.To(TimeCurrent());
|
|
// if (orderBlock.IsBullish())
|
|
// {
|
|
// //
|
|
// XCBullishOrderBlockObject *iObj;
|
|
// bool isCreated = mPOIDrawer.CreateBullishOrderBlock(
|
|
// orderBlock,
|
|
// iObj //
|
|
// );
|
|
// if (isCreated)
|
|
// {
|
|
// AddObjectIfNotExists(iObj);
|
|
// }
|
|
// }
|
|
// else
|
|
// {
|
|
// //
|
|
// XCBearishOrderBlockObject *iObj;
|
|
// bool isCreated = mPOIDrawer.CreateBearishOrderBlock(
|
|
// orderBlock,
|
|
// iObj //
|
|
// );
|
|
// if (isCreated)
|
|
// {
|
|
// AddObjectIfNotExists(iObj);
|
|
// }
|
|
// }
|
|
|
|
//
|
|
XCSupplyZone *supplyZone;
|
|
int supplyCount = state.CountSupplyZones();
|
|
if (IsValidSize(supplyCount))
|
|
{
|
|
//
|
|
for (int i = 0; i < supplyCount; i++)
|
|
{
|
|
//
|
|
XCSupplyZone *iZone = state.supplyZones[i];
|
|
isPeakInsideSupplyZone = peak >= iZone.Lower() &&
|
|
peak <= iZone.Upper() &&
|
|
bid >= iZone.Lower() + ((iZone.Upper() - iZone.Lower()) / zoneVerificationDivider);
|
|
if (isPeakInsideSupplyZone)
|
|
{
|
|
//
|
|
supplyZone = iZone;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
XCDemandZone *demandZone;
|
|
int demandCount = state.CountDemandZones();
|
|
if (IsValidSize(demandCount))
|
|
{
|
|
//
|
|
for (int i = 0; i < demandCount; i++)
|
|
{
|
|
//
|
|
XCDemandZone *iZone = state.demandZones[i];
|
|
isValeInsideDemandZone = vale >= iZone.Lower() &&
|
|
vale <= iZone.Upper() &&
|
|
bid <= iZone.Lower() + ((iZone.Upper() - iZone.Lower()) / zoneVerificationDivider);
|
|
if (isValeInsideDemandZone)
|
|
{
|
|
//
|
|
demandZone = iZone;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
bool isPeakAttacked =
|
|
isNewPeak &&
|
|
isSarBearish &&
|
|
pBar.high == peak &&
|
|
isPeakInsideSupplyZone &&
|
|
isClosedUnderDonCloseUpper;
|
|
|
|
//
|
|
bool isValeAttacked =
|
|
isNewVale &&
|
|
isSarBullish &&
|
|
pBar.low == vale &&
|
|
isValeInsideDemandZone &&
|
|
isClosedOverDonCloseLower;
|
|
|
|
//
|
|
result = isPeakAttacked ||
|
|
isValeAttacked;
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
if (isPeakAttacked)
|
|
{
|
|
//
|
|
supplyZone.To(TimeCurrent());
|
|
XCSupplyZoneObject *iObj;
|
|
bool isCreated = mPOIDrawer.CreateSupplyZone(
|
|
supplyZone,
|
|
iObj //
|
|
);
|
|
if (isCreated)
|
|
{
|
|
AddObjectIfNotExists(iObj);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//
|
|
demandZone.To(TimeCurrent());
|
|
XCDemandZoneObject *iObj;
|
|
bool isCreated = mPOIDrawer.CreateDemandZone(
|
|
demandZone,
|
|
iObj //
|
|
);
|
|
if (isCreated)
|
|
{
|
|
AddObjectIfNotExists(iObj);
|
|
}
|
|
}
|
|
|
|
//
|
|
bool isBullish =
|
|
//
|
|
isValeAttacked
|
|
//
|
|
;
|
|
|
|
//
|
|
bool isBearish =
|
|
//
|
|
isPeakAttacked
|
|
//
|
|
;
|
|
|
|
//
|
|
result =
|
|
//
|
|
isBullish ||
|
|
isBearish
|
|
//
|
|
;
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Set SL, Provider and Direction ...
|
|
conditions.signalDir =
|
|
isBullish
|
|
? X_DIRECTION_BULLISH
|
|
: X_DIRECTION_BEARISH;
|
|
conditions.provider = providerStr;
|
|
|
|
//
|
|
conditions.sl =
|
|
isBullish
|
|
? demandZone.Lower()
|
|
: supplyZone.Upper();
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Detect and Parse Market Conditions for Signalling ...
|
|
*
|
|
* @param conditions: X121SMCStrategyConditions instance Reference ...
|
|
*
|
|
* @return ( bool )
|
|
*/
|
|
// TODO: Required Calibrate ...
|
|
bool DetectVWAPCSignal(
|
|
X121SMCStrategyConditions &conditions //
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
return false;
|
|
|
|
//
|
|
string symbol = GetSymbol();
|
|
ENUM_TIMEFRAMES period = GetPeriod();
|
|
|
|
//
|
|
int zIndex = 0;
|
|
int cIndex = zIndex + 1;
|
|
int pIndex = cIndex + 1;
|
|
int ppIndex = pIndex + 1;
|
|
|
|
//
|
|
XOHCL zBar;
|
|
result = zBar.Init(
|
|
symbol,
|
|
period,
|
|
zIndex //
|
|
);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
XOHCL cBar;
|
|
result = cBar.Init(
|
|
symbol,
|
|
period,
|
|
cIndex //
|
|
);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
string msg = NULL;
|
|
|
|
//
|
|
double bid = GetBid(symbol);
|
|
datetime cTime = TimeCurrent();
|
|
|
|
//
|
|
ENUM_X_121_SMC_PROVIDERS provider = X_121_SMC_PROVIDER_VWAPC;
|
|
string providerStr = ToString(provider);
|
|
|
|
//
|
|
// Check Candlestic State ...
|
|
ENUM_X_DIRECTION candlesticDir;
|
|
result = DetectCandlestic(
|
|
provider,
|
|
candlesticDir,
|
|
conditions //
|
|
);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Check Sar State ...
|
|
ENUM_X_DIRECTION sarDir;
|
|
result = DetectSarState(
|
|
provider,
|
|
sarDir,
|
|
conditions //
|
|
);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Check VWAP State ...
|
|
ENUM_X_DIRECTION vwapDir;
|
|
result = DetectVWapState(
|
|
provider,
|
|
vwapDir,
|
|
conditions //
|
|
);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
bool isBullish =
|
|
//
|
|
IsBullish(sarDir) &&
|
|
IsBullish(vwapDir) &&
|
|
IsBullish(candlesticDir)
|
|
//
|
|
;
|
|
|
|
//
|
|
bool isBearish =
|
|
//
|
|
IsBearish(sarDir) &&
|
|
IsBearish(vwapDir) &&
|
|
IsBearish(candlesticDir)
|
|
//
|
|
;
|
|
|
|
//
|
|
result =
|
|
//
|
|
isBullish ||
|
|
isBearish
|
|
//
|
|
;
|
|
|
|
//
|
|
Print("VWap Signal ...");
|
|
|
|
//
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// TODO: Remove this ...
|
|
XTestProiderConditions mTestConditions;
|
|
bool DetectTestSignal(
|
|
X121SMCStrategyConditions &conditions //
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
string symbol = GetSymbol();
|
|
ENUM_TIMEFRAMES period = GetPeriod();
|
|
|
|
//
|
|
ENUM_X_121_SMC_PROVIDERS provider = X_121_SMC_PROVIDER_SMPV;
|
|
string providerStr = ToString(provider);
|
|
|
|
//
|
|
int zIndex = 0;
|
|
int cIndex = zIndex + 1;
|
|
int pIndex = cIndex + 1;
|
|
int ppIndex = pIndex + 1;
|
|
|
|
//
|
|
XOHCL zBar;
|
|
result = zBar.Init(
|
|
symbol,
|
|
period,
|
|
zIndex //
|
|
);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
XOHCL cBar;
|
|
result = cBar.Init(
|
|
symbol,
|
|
period,
|
|
cIndex //
|
|
);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
bool isBullish = false;
|
|
bool isBearish = false;
|
|
|
|
//
|
|
double bid = GetBid(symbol);
|
|
datetime cTime = TimeCurrent();
|
|
|
|
//
|
|
double selectedSL = 0;
|
|
|
|
//
|
|
// Retrieve Peak and Vale ...
|
|
double peak = conditions.triggerConditions.x121Conditions.peaksBuffer[0];
|
|
double vale = conditions.triggerConditions.x121Conditions.valesBuffer[0];
|
|
|
|
//
|
|
X121SMCCycleConditions triggerConditions = conditions.triggerConditions;
|
|
X121SMCCycleConditions decisionConditions = conditions.decisionConditions;
|
|
X121SMCCycleConditions analyseConditions = conditions.analyseConditions;
|
|
X121SMCCycleConditions verificationConditions = conditions.verificationConditions;
|
|
X121SMCCycleConditions consolidationConditions = conditions.consolidationConditions;
|
|
X121SMCCycleConditions visionConditions = conditions.visionConditions;
|
|
|
|
//
|
|
XPOIState triggerState = triggerConditions.state;
|
|
XPOIState decisionState = decisionConditions.state;
|
|
XPOIState analyseState = analyseConditions.state;
|
|
XPOIState verificationState = verificationConditions.state;
|
|
XPOIState consolidationState = consolidationConditions.state;
|
|
XPOIState visionState = visionConditions.state;
|
|
|
|
//
|
|
int zoneValidationDivider = 10;
|
|
|
|
//
|
|
// Try to Detect Setup Conditions ...
|
|
ENUM_X_DIRECTION setupDir;
|
|
result = mTestConditions.IsSetuped(setupDir);
|
|
if (!result)
|
|
{
|
|
//
|
|
// First we must check a new Peak or Vale Happens ...
|
|
bool isNewPeak = conditions.triggerConditions.x121Conditions.isNewPeak;
|
|
bool isNewVale = conditions.triggerConditions.x121Conditions.isNewVale;
|
|
|
|
//
|
|
result = isNewPeak ||
|
|
isNewVale;
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
mTestConditions.isNewPeak = isNewPeak;
|
|
mTestConditions.isNewVale = isNewVale;
|
|
|
|
//
|
|
// We have to Check the Peaks and Vales Happens inside a Demand or Supply Zone ...
|
|
// in Vision State ...
|
|
|
|
//
|
|
bool hasVisionSupplyZone = false;
|
|
XCSupplyZone *visionSupplyZone = NULL;
|
|
int visionSupplyZonesCount = visionState.CountSupplyZones();
|
|
if (isNewPeak &&
|
|
IsValidSize(visionSupplyZonesCount))
|
|
{
|
|
//
|
|
// Try to Find Inside Zone ...
|
|
for (int i = 0; i < visionSupplyZonesCount; i++)
|
|
{
|
|
//
|
|
XCSupplyZone *iZone = visionState.supplyZones[i];
|
|
double zoneValidRange = (iZone.Upper() - iZone.Lower()) / zoneValidationDivider;
|
|
|
|
//
|
|
hasVisionSupplyZone =
|
|
//
|
|
peak >= iZone.Lower() &&
|
|
peak <= iZone.Upper() &&
|
|
peak > iZone.Upper() - zoneValidRange
|
|
//
|
|
;
|
|
if (hasVisionSupplyZone)
|
|
{
|
|
//
|
|
visionSupplyZone = iZone;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
bool hasVisionDemandZone = false;
|
|
XCDemandZone *visionDemandZone = NULL;
|
|
int visionDemandZonesCount = visionState.CountDemandZones();
|
|
if (isNewVale &&
|
|
IsValidSize(visionDemandZonesCount))
|
|
{
|
|
//
|
|
// Try to Find Inside Zone ...
|
|
for (int i = 0; i < visionDemandZonesCount; i++)
|
|
{
|
|
//
|
|
XCDemandZone *iZone = visionState.demandZones[i];
|
|
double zoneValidRange = (iZone.Upper() - iZone.Lower()) / zoneValidationDivider;
|
|
|
|
//
|
|
hasVisionDemandZone =
|
|
//
|
|
vale >= iZone.Lower() &&
|
|
vale <= iZone.Upper() &&
|
|
vale < iZone.Lower() + zoneValidRange
|
|
//
|
|
;
|
|
if (hasVisionDemandZone)
|
|
{
|
|
//
|
|
visionDemandZone = iZone;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
result = hasVisionSupplyZone ||
|
|
hasVisionDemandZone;
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
mTestConditions.visionSupplyZone = visionSupplyZone;
|
|
mTestConditions.visionDemandZone = visionDemandZone;
|
|
|
|
//
|
|
mTestConditions.hasVisionSupplyZone = hasVisionSupplyZone;
|
|
mTestConditions.hasVisionDemandZone = hasVisionDemandZone;
|
|
|
|
//
|
|
double triggerPeak = conditions.triggerConditions.x121Conditions.peaksBuffer[0];
|
|
double decisionPeak = conditions.decisionConditions.x121Conditions.peaksBuffer[0];
|
|
double analysePeak = conditions.analyseConditions.x121Conditions.peaksBuffer[0];
|
|
double verificationPeak = conditions.verificationConditions.x121Conditions.peaksBuffer[0];
|
|
double consolidationPeak = conditions.consolidationConditions.x121Conditions.peaksBuffer[0];
|
|
double visionPeak = conditions.visionConditions.x121Conditions.peaksBuffer[0];
|
|
|
|
//
|
|
bool isPeaksSame =
|
|
//
|
|
triggerPeak &&
|
|
decisionPeak &&
|
|
analysePeak &&
|
|
verificationPeak &&
|
|
consolidationPeak &&
|
|
visionPeak
|
|
//
|
|
;
|
|
|
|
//
|
|
double triggerVale = conditions.triggerConditions.x121Conditions.valesBuffer[0];
|
|
double decisionVale = conditions.decisionConditions.x121Conditions.valesBuffer[0];
|
|
double analyseVale = conditions.analyseConditions.x121Conditions.valesBuffer[0];
|
|
double verificationVale = conditions.verificationConditions.x121Conditions.valesBuffer[0];
|
|
double consolidationVale = conditions.consolidationConditions.x121Conditions.valesBuffer[0];
|
|
double visionVale = conditions.visionConditions.x121Conditions.valesBuffer[0];
|
|
|
|
//
|
|
bool isValesSame =
|
|
//
|
|
triggerVale &&
|
|
decisionVale &&
|
|
analyseVale &&
|
|
verificationVale &&
|
|
consolidationVale &&
|
|
visionVale
|
|
//
|
|
;
|
|
|
|
//
|
|
mTestConditions.hasSamePeaks = isPeaksSame;
|
|
mTestConditions.hasSameVales = isValesSame;
|
|
|
|
//
|
|
isBullish =
|
|
//
|
|
isNewVale &&
|
|
isPeaksSame &&
|
|
isValesSame &&
|
|
hasVisionDemandZone
|
|
//
|
|
;
|
|
|
|
//
|
|
isBearish =
|
|
//
|
|
isNewPeak &&
|
|
isPeaksSame &&
|
|
isValesSame &&
|
|
hasVisionSupplyZone
|
|
//
|
|
;
|
|
|
|
//
|
|
result =
|
|
isBullish ||
|
|
isBearish;
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
mTestConditions.setupTime = TimeCurrent();
|
|
|
|
//
|
|
result = mTestConditions.IsSetuped(setupDir);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Alert ...
|
|
string message = providerStr + " Conditions Set Upped: " + ToString(setupDir);
|
|
Alert(message);
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Try to Detect Trigger Conditions ...
|
|
mTestConditions.symbol = symbol;
|
|
mTestConditions.period = period;
|
|
|
|
//
|
|
// Try to Find Support Zone which Vales Inside it ...
|
|
bool hasConsolidationSupportZone = false;
|
|
XCSupportZone *consolidationSupportZone = NULL;
|
|
int consolidationSupportZonesCount = consolidationState.CountSupportZones();
|
|
if (IsValidSize(consolidationSupportZonesCount))
|
|
{
|
|
//
|
|
for (int i = 0; i < consolidationSupportZonesCount; i++)
|
|
{
|
|
//
|
|
XCSupportZone *iZone = consolidationState.supportZones[i];
|
|
// double zoneValidRange = (iZone.Upper() - iZone.Lower()) / zoneValidationDivider;
|
|
|
|
//
|
|
hasConsolidationSupportZone =
|
|
//
|
|
peak >= iZone.Lower() &&
|
|
peak <= iZone.Upper()
|
|
// &&
|
|
// vale < iZone.Upper() - zoneValidRange
|
|
//
|
|
;
|
|
if (hasConsolidationSupportZone)
|
|
{
|
|
//
|
|
consolidationSupportZone = iZone;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Try to Find Resistance Zone which Peaks Inside it ...
|
|
bool hasConsolidationResistanceZone = false;
|
|
XCResistanceZone *consolidationResistanceZone = NULL;
|
|
int consolidationResistanceZonesCount = consolidationState.CountResistanceZones();
|
|
if (IsValidSize(consolidationResistanceZonesCount))
|
|
{
|
|
//
|
|
for (int i = 0; i < consolidationResistanceZonesCount; i++)
|
|
{
|
|
//
|
|
XCResistanceZone *iZone = consolidationState.resistanceZones[i];
|
|
// double zoneValidRange = (iZone.Upper() - iZone.Lower()) / zoneValidationDivider;
|
|
|
|
//
|
|
hasConsolidationResistanceZone =
|
|
//
|
|
vale >= iZone.Lower() &&
|
|
vale <= iZone.Upper()
|
|
// &&
|
|
// peak > iZone.Lower() + zoneValidRange
|
|
//
|
|
;
|
|
if (hasConsolidationResistanceZone)
|
|
{
|
|
//
|
|
consolidationResistanceZone = iZone;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
result = hasConsolidationSupportZone ||
|
|
hasConsolidationResistanceZone;
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
result =
|
|
//
|
|
(IsBullish(setupDir) &&
|
|
hasConsolidationResistanceZone)
|
|
//
|
|
||
|
|
//
|
|
(IsBearish(setupDir) &&
|
|
hasConsolidationSupportZone)
|
|
//
|
|
;
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Detect State Conditions ...
|
|
|
|
//
|
|
// Vision ...
|
|
|
|
//
|
|
bool isVisionBullishPassed =
|
|
//
|
|
// Sar ...
|
|
visionConditions.x121Conditions.isSarBullish
|
|
//
|
|
&&
|
|
//
|
|
// VWap ...
|
|
visionConditions.x121Conditions.isVWapFastBullish
|
|
//
|
|
;
|
|
|
|
//
|
|
bool isVisionBearishPassed =
|
|
//
|
|
// Sar ...
|
|
visionConditions.x121Conditions.isSarBearish
|
|
//
|
|
&&
|
|
//
|
|
// VWap ...
|
|
visionConditions.x121Conditions.isVWapFastBearish
|
|
//
|
|
;
|
|
|
|
//
|
|
bool isVisionPassed = isVisionBullishPassed ||
|
|
isVisionBearishPassed;
|
|
result = isVisionPassed;
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Consolidation ...
|
|
|
|
//
|
|
bool isConsolidationBullishPassed =
|
|
//
|
|
// Sar ...
|
|
consolidationConditions.x121Conditions.isSarBullish
|
|
//
|
|
&&
|
|
//
|
|
// VWap State ...
|
|
consolidationConditions.x121Conditions.isVWapBullishState
|
|
//
|
|
&&
|
|
//
|
|
// VWap Order ...
|
|
consolidationConditions.x121Conditions.isVWapBullishOrdered
|
|
//
|
|
;
|
|
|
|
//
|
|
bool isConsolidationBearishPassed =
|
|
//
|
|
//
|
|
// Sar ...
|
|
consolidationConditions.x121Conditions.isSarBearish
|
|
//
|
|
&&
|
|
//
|
|
// VWap State ...
|
|
consolidationConditions.x121Conditions.isVWapBearishState
|
|
//
|
|
&&
|
|
//
|
|
// VWap Order ...
|
|
consolidationConditions.x121Conditions.isVWapBearishOrdered
|
|
//
|
|
;
|
|
|
|
//
|
|
bool isConsolidationPassed = isConsolidationBullishPassed ||
|
|
isConsolidationBearishPassed;
|
|
result = isConsolidationPassed;
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Verification ...
|
|
|
|
//
|
|
bool isVerificationBullishPassed =
|
|
//
|
|
// Sar ...
|
|
verificationConditions.x121Conditions.isSarBullish
|
|
//
|
|
&&
|
|
//
|
|
// VWap State ...
|
|
verificationConditions.x121Conditions.isVWapBullishState
|
|
//
|
|
&&
|
|
//
|
|
// VWap Order ...
|
|
verificationConditions.x121Conditions.isVWapBullishOrdered
|
|
//
|
|
;
|
|
|
|
//
|
|
bool isVerificationBearishPassed =
|
|
//
|
|
// Sar ...
|
|
verificationConditions.x121Conditions.isSarBearish
|
|
//
|
|
&&
|
|
//
|
|
// VWap State ...
|
|
verificationConditions.x121Conditions.isVWapBearishState
|
|
//
|
|
&&
|
|
//
|
|
// VWap Order ...
|
|
verificationConditions.x121Conditions.isVWapBearishOrdered
|
|
//
|
|
;
|
|
|
|
//
|
|
bool isVerificationPassed = isVerificationBullishPassed ||
|
|
isVerificationBearishPassed;
|
|
result = isVerificationPassed;
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Analyse ...
|
|
|
|
//
|
|
bool isAnalyseBullishPassed =
|
|
//
|
|
// Sar ...
|
|
analyseConditions.x121Conditions.isSarBullish
|
|
//
|
|
&&
|
|
//
|
|
// VWap Order ...
|
|
analyseConditions.x121Conditions.isVWapBullishOrdered
|
|
//
|
|
&&
|
|
//
|
|
// VWap State ...
|
|
(analyseConditions.x121Conditions.isVWapBullishState ||
|
|
(analyseConditions.x121Conditions.isVWapMidBullish &&
|
|
analyseConditions.x121Conditions.isVWapSlowBullish))
|
|
//
|
|
;
|
|
|
|
//
|
|
bool isAnalyseBearishPassed =
|
|
//
|
|
// Sar ...
|
|
analyseConditions.x121Conditions.isSarBearish
|
|
//
|
|
&&
|
|
//
|
|
// VWap Order ...
|
|
analyseConditions.x121Conditions.isVWapBearishOrdered
|
|
//
|
|
&&
|
|
//
|
|
// VWap State ...
|
|
(analyseConditions.x121Conditions.isVWapBearishState ||
|
|
(analyseConditions.x121Conditions.isVWapMidBearish &&
|
|
analyseConditions.x121Conditions.isVWapSlowBearish))
|
|
//
|
|
;
|
|
|
|
//
|
|
bool isAnalysePassed = isAnalyseBullishPassed ||
|
|
isAnalyseBearishPassed;
|
|
result = isAnalysePassed;
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Decision ...
|
|
|
|
//
|
|
double decisionPeak = decisionConditions.x121Conditions.peaksBuffer[1];
|
|
double decisionVale = decisionConditions.x121Conditions.valesBuffer[1];
|
|
|
|
//
|
|
XOHCL decisionCBar;
|
|
result = mDecisionCycleHelper.GetBar(
|
|
decisionCBar,
|
|
cIndex //
|
|
);
|
|
|
|
//
|
|
// Check Fibo Pressure ...
|
|
ENUM_X_DIRECTION pressureDir;
|
|
bool hasPressurePin = mBarAnalyser.HasFiboPressure(
|
|
decisionCBar,
|
|
pressureDir //
|
|
);
|
|
|
|
//
|
|
bool isBarBullish =
|
|
//
|
|
(hasPressurePin &&
|
|
IsBullish(pressureDir))
|
|
//
|
|
&&
|
|
//
|
|
decisionCBar.low == decisionVale
|
|
//
|
|
;
|
|
|
|
//
|
|
bool isBarBearish =
|
|
//
|
|
(hasPressurePin &&
|
|
IsBearish(pressureDir))
|
|
//
|
|
&&
|
|
//
|
|
decisionCBar.high == decisionPeak
|
|
//
|
|
;
|
|
|
|
//
|
|
bool isBarPassed = isBarBullish ||
|
|
isBarBearish;
|
|
result = isBarPassed;
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
bool isDecisionBullishPassed =
|
|
//
|
|
// Bar ...
|
|
isBarBullish
|
|
//
|
|
&&
|
|
//
|
|
// VWap Order ...
|
|
decisionConditions.x121Conditions.isVWapBullishOrdered
|
|
//
|
|
;
|
|
|
|
//
|
|
bool isDecisionBearishPassed =
|
|
//
|
|
// Bar ...
|
|
isBarBearish
|
|
//
|
|
&&
|
|
//
|
|
// VWap Order ...
|
|
decisionConditions.x121Conditions.isVWapBearishOrdered
|
|
//
|
|
;
|
|
|
|
//
|
|
bool isDecisionPassed = isDecisionBullishPassed ||
|
|
isDecisionBearishPassed;
|
|
result = isDecisionPassed;
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Trigger ...
|
|
|
|
//
|
|
double donOpenUpper = triggerConditions.x121Conditions.donOpenUpperBuffer[1];
|
|
double donOpenLower = triggerConditions.x121Conditions.donOpenLowerBuffer[1];
|
|
|
|
//
|
|
double donCloseUpper = triggerConditions.x121Conditions.donCloseUpperBuffer[1];
|
|
double donCloseLower = triggerConditions.x121Conditions.donCloseLowerBuffer[1];
|
|
|
|
//
|
|
bool isDonBullish =
|
|
//
|
|
donCloseLower > donOpenUpper
|
|
//
|
|
&&
|
|
//
|
|
cBar.low > donCloseLower &&
|
|
cBar.high > donCloseLower
|
|
//
|
|
;
|
|
|
|
//
|
|
bool isDonBearish =
|
|
//
|
|
donOpenUpper > donCloseUpper
|
|
//
|
|
&&
|
|
//
|
|
cBar.low < donCloseUpper &&
|
|
cBar.high < donCloseUpper
|
|
//
|
|
;
|
|
|
|
//
|
|
bool isTriggerBullishPassed =
|
|
//
|
|
// Don ...
|
|
isDonBullish
|
|
//
|
|
&&
|
|
//
|
|
// Sar ...
|
|
triggerConditions.x121Conditions.isSarBullish
|
|
//
|
|
;
|
|
|
|
//
|
|
bool isTriggerBearishPassed =
|
|
//
|
|
// Don ...
|
|
isDonBearish
|
|
//
|
|
&&
|
|
//
|
|
// Sar ...
|
|
triggerConditions.x121Conditions.isSarBearish
|
|
//
|
|
;
|
|
|
|
//
|
|
bool isTriggerPassed = isTriggerBullishPassed ||
|
|
isTriggerBearishPassed;
|
|
result = isTriggerPassed;
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
//
|
|
//
|
|
|
|
//
|
|
bool isBullishTriggerConditionsPassed =
|
|
//
|
|
isConsolidationBullishPassed &&
|
|
isVerificationBullishPassed &&
|
|
isAnalyseBullishPassed &&
|
|
isDecisionBullishPassed &&
|
|
isTriggerBullishPassed
|
|
//
|
|
;
|
|
|
|
//
|
|
bool isBearishTriggerConditionsPassed =
|
|
//
|
|
isConsolidationBearishPassed &&
|
|
isVerificationBearishPassed &&
|
|
isAnalyseBearishPassed &&
|
|
isDecisionBearishPassed &&
|
|
isTriggerBearishPassed
|
|
//
|
|
;
|
|
|
|
//
|
|
//
|
|
//
|
|
|
|
//
|
|
bool isBullish =
|
|
//
|
|
IsBullish(setupDir) &&
|
|
hasConsolidationSupportZone &&
|
|
isBullishTriggerConditionsPassed
|
|
//
|
|
;
|
|
|
|
//
|
|
bool isBearish =
|
|
//
|
|
IsBearish(setupDir) &&
|
|
hasConsolidationResistanceZone &&
|
|
isBearishTriggerConditionsPassed
|
|
//
|
|
;
|
|
|
|
//
|
|
result =
|
|
isBullish ||
|
|
isBearish;
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
double entry = GetEntry(
|
|
symbol,
|
|
setupDir //
|
|
);
|
|
double spread = GetSpread(
|
|
symbol //
|
|
);
|
|
|
|
//
|
|
zoneValidationDivider = 8;
|
|
double selectedSL = isBullish
|
|
? consolidationResistanceZone.Upper() - spread -
|
|
((consolidationResistanceZone.Upper() - consolidationResistanceZone.Lower()) /
|
|
zoneValidationDivider)
|
|
: consolidationSupportZone.Lower() + spread +
|
|
((consolidationSupportZone.Upper() - consolidationSupportZone.Lower()) /
|
|
zoneValidationDivider);
|
|
|
|
//
|
|
mTestConditions.sl = selectedSL;
|
|
mTestConditions.type =
|
|
isBullish
|
|
? X_POSITION_TYPE_LONG
|
|
: X_POSITION_TYPE_SHORT;
|
|
mTestConditions.triggerTime = TimeCurrent();
|
|
}
|
|
|
|
//
|
|
// Check Conditions is Prepared for Trigger ...
|
|
result = mTestConditions.CanTrigger();
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
conditions.signalDir = setupDir;
|
|
conditions.provider = providerStr;
|
|
conditions.sl = mTestConditions.sl;
|
|
|
|
//
|
|
mTestConditions.Clean();
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Helper Functions ...
|
|
|
|
/**
|
|
* Detect Where Cycles has Same Peaks ...
|
|
*
|
|
* @param cycles: ENUM_X_CYCLES members, Array ...
|
|
* @param conditions: X121SMCStrategyConditions instance, Reference ...
|
|
*
|
|
* @return ( bool )
|
|
*/
|
|
bool DetectSamePeaks(
|
|
ENUM_X_CYCLES &cycles[],
|
|
X121SMCStrategyConditions &conditions //
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
int count = ArraySize(cycles);
|
|
result = IsValidSize(count);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
double value = -1;
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
//
|
|
ENUM_X_CYCLES iCycle = cycles[i];
|
|
|
|
//
|
|
double iValue = -1;
|
|
switch (iCycle)
|
|
{
|
|
//
|
|
case X_CYCLE_TRIGGER:
|
|
iValue = conditions.triggerConditions.x121Conditions.peaksBuffer[0];
|
|
break;
|
|
|
|
//
|
|
case X_CYCLE_DECISION:
|
|
iValue = conditions.decisionConditions.x121Conditions.peaksBuffer[0];
|
|
break;
|
|
|
|
//
|
|
case X_CYCLE_ANALYSE:
|
|
iValue = conditions.analyseConditions.x121Conditions.peaksBuffer[0];
|
|
break;
|
|
|
|
//
|
|
case X_CYCLE_VERIFICATION:
|
|
iValue = conditions.verificationConditions.x121Conditions.peaksBuffer[0];
|
|
break;
|
|
|
|
//
|
|
case X_CYCLE_CONSOLIDATION:
|
|
iValue = conditions.consolidationConditions.x121Conditions.peaksBuffer[0];
|
|
break;
|
|
|
|
//
|
|
case X_CYCLE_VISION:
|
|
iValue = conditions.visionConditions.x121Conditions.peaksBuffer[0];
|
|
break;
|
|
}
|
|
|
|
//
|
|
if (iValue > 0)
|
|
{
|
|
//
|
|
if (value <= 0)
|
|
{
|
|
value = iValue;
|
|
}
|
|
|
|
//
|
|
result = value == iValue;
|
|
if (!result)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Detect Where Cycles has Same Vales ...
|
|
*
|
|
* @param cycles: ENUM_X_CYCLES members, Array ...
|
|
* @param conditions: X121SMCStrategyConditions instance, Reference ...
|
|
*
|
|
* @return ( bool )
|
|
*/
|
|
bool DetectSameVales(
|
|
ENUM_X_CYCLES &cycles[],
|
|
X121SMCStrategyConditions &conditions //
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
int count = ArraySize(cycles);
|
|
result = IsValidSize(count);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
double value = -1;
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
//
|
|
ENUM_X_CYCLES iCycle = cycles[i];
|
|
|
|
//
|
|
double iValue = -1;
|
|
switch (iCycle)
|
|
{
|
|
//
|
|
case X_CYCLE_TRIGGER:
|
|
iValue = conditions.triggerConditions.x121Conditions.valesBuffer[0];
|
|
break;
|
|
|
|
//
|
|
case X_CYCLE_DECISION:
|
|
iValue = conditions.decisionConditions.x121Conditions.valesBuffer[0];
|
|
break;
|
|
|
|
//
|
|
case X_CYCLE_ANALYSE:
|
|
iValue = conditions.analyseConditions.x121Conditions.valesBuffer[0];
|
|
break;
|
|
|
|
//
|
|
case X_CYCLE_VERIFICATION:
|
|
iValue = conditions.verificationConditions.x121Conditions.valesBuffer[0];
|
|
break;
|
|
|
|
//
|
|
case X_CYCLE_CONSOLIDATION:
|
|
iValue = conditions.consolidationConditions.x121Conditions.valesBuffer[0];
|
|
break;
|
|
|
|
//
|
|
case X_CYCLE_VISION:
|
|
iValue = conditions.visionConditions.x121Conditions.valesBuffer[0];
|
|
break;
|
|
}
|
|
|
|
//
|
|
if (iValue > 0)
|
|
{
|
|
//
|
|
if (value <= 0)
|
|
{
|
|
value = iValue;
|
|
}
|
|
|
|
//
|
|
result = value == iValue;
|
|
if (!result)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Detect Sar State for Signalling ...
|
|
*
|
|
* @param forProvider: ENUM_X_121_SMC_PROVIDERS member ...
|
|
* @param dir: ENUM_X_DIRECTION member Reference ...
|
|
* @param conditions: X121SMCStrategyConditions instance, Reference ...
|
|
*
|
|
* @return ( bool )
|
|
*/
|
|
bool DetectSarState(
|
|
ENUM_X_121_SMC_PROVIDERS forProvider,
|
|
ENUM_X_DIRECTION &dir,
|
|
X121SMCStrategyConditions &conditions //
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
dir = X_DIRECTION_NONE;
|
|
|
|
//
|
|
bool isBullish = false;
|
|
bool isBearish = false;
|
|
|
|
//
|
|
if (forProvider == X_121_SMC_PROVIDER_SMPV)
|
|
{
|
|
//
|
|
isBullish =
|
|
//
|
|
// Check One of Verification or Consolidation Cycles Must be Sar Bullish ...
|
|
(conditions.verificationConditions.x121Conditions.isSarBullish ||
|
|
conditions.consolidationConditions.x121Conditions.isSarBullish)
|
|
//
|
|
&&
|
|
//
|
|
// Decision and Analyse Cycles Must be Bullish ...
|
|
(conditions.decisionConditions.x121Conditions.isSarBullish &&
|
|
conditions.analyseConditions.x121Conditions.isSarBullish)
|
|
//
|
|
&&
|
|
//
|
|
// Trigger State Must be Bearish ...
|
|
conditions.triggerConditions.x121Conditions.isSarBearish
|
|
//
|
|
;
|
|
|
|
//
|
|
isBearish =
|
|
//
|
|
// Check One of Verification or Consolidation Cycles Must be Sar Bearish ...
|
|
(conditions.verificationConditions.x121Conditions.isSarBearish ||
|
|
conditions.consolidationConditions.x121Conditions.isSarBearish)
|
|
//
|
|
&&
|
|
//
|
|
// Decision and Analyse Cycles Must be Bearish ...
|
|
(conditions.decisionConditions.x121Conditions.isSarBearish &&
|
|
conditions.analyseConditions.x121Conditions.isSarBearish)
|
|
//
|
|
&&
|
|
//
|
|
// Trigger State Must be Bullish ...
|
|
conditions.triggerConditions.x121Conditions.isSarBullish
|
|
//
|
|
;
|
|
}
|
|
|
|
//
|
|
if (forProvider == X_121_SMC_PROVIDER_RJBPV)
|
|
{
|
|
//
|
|
isBullish =
|
|
//
|
|
// Trigger, Decision and Analyse must be Directional ...
|
|
conditions.triggerConditions.x121Conditions.isSarBullish &&
|
|
conditions.decisionConditions.x121Conditions.isSarBullish &&
|
|
conditions.analyseConditions.x121Conditions.isSarBullish
|
|
//
|
|
;
|
|
|
|
//
|
|
isBearish =
|
|
//
|
|
// Trigger, Decision and Analyse must be Directional ...
|
|
conditions.triggerConditions.x121Conditions.isSarBearish &&
|
|
conditions.decisionConditions.x121Conditions.isSarBearish &&
|
|
conditions.analyseConditions.x121Conditions.isSarBearish
|
|
//
|
|
;
|
|
}
|
|
|
|
//
|
|
if (forProvider == X_121_SMC_PROVIDER_VWAPC)
|
|
{
|
|
//
|
|
isBullish =
|
|
//
|
|
// All Cycles Sars Must be Directional exept Vision ...
|
|
conditions.triggerConditions.x121Conditions.isSarBullish &&
|
|
conditions.decisionConditions.x121Conditions.isSarBullish &&
|
|
conditions.analyseConditions.x121Conditions.isSarBullish &&
|
|
conditions.verificationConditions.x121Conditions.isSarBullish &&
|
|
conditions.consolidationConditions.x121Conditions.isSarBullish
|
|
//
|
|
;
|
|
|
|
//
|
|
isBearish =
|
|
//
|
|
// All Cycles Sars Must be Directional exept Vision ...
|
|
conditions.triggerConditions.x121Conditions.isSarBearish &&
|
|
conditions.decisionConditions.x121Conditions.isSarBearish &&
|
|
conditions.analyseConditions.x121Conditions.isSarBearish &&
|
|
conditions.verificationConditions.x121Conditions.isSarBearish &&
|
|
conditions.consolidationConditions.x121Conditions.isSarBearish
|
|
//
|
|
;
|
|
}
|
|
|
|
//
|
|
result = isBullish ||
|
|
isBearish;
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
dir =
|
|
isBullish
|
|
? X_DIRECTION_BULLISH
|
|
: X_DIRECTION_BEARISH;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Detect Sar State for Signalling ...
|
|
*
|
|
* @param forProvider: ENUM_X_121_SMC_PROVIDERS member ...
|
|
* @param dir: ENUM_X_DIRECTION member Reference ...
|
|
* @param conditions: X121SMCStrategyConditions instance, Reference ...
|
|
*
|
|
* @return ( bool )
|
|
*/
|
|
bool DetectVWapState(
|
|
ENUM_X_121_SMC_PROVIDERS forProvider,
|
|
ENUM_X_DIRECTION &dir,
|
|
X121SMCStrategyConditions &conditions //
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
dir = X_DIRECTION_NONE;
|
|
|
|
//
|
|
bool isBullish = false;
|
|
bool isBearish = false;
|
|
|
|
//
|
|
if (forProvider == X_121_SMC_PROVIDER_SMPV)
|
|
{
|
|
//
|
|
isBullish =
|
|
//
|
|
// Trigger, Decision and Analyse Cycles Must be in Direction Order and State ...
|
|
//
|
|
// Orders ...
|
|
(conditions.triggerConditions.x121Conditions.isVWapBullishOrdered &&
|
|
conditions.decisionConditions.x121Conditions.isVWapBullishOrdered &&
|
|
conditions.analyseConditions.x121Conditions.isVWapBullishOrdered)
|
|
//
|
|
&&
|
|
//
|
|
// State ...
|
|
(conditions.triggerConditions.x121Conditions.isVWapBullishState &&
|
|
conditions.decisionConditions.x121Conditions.isVWapBullishState &&
|
|
conditions.analyseConditions.x121Conditions.isVWapBullishState)
|
|
//
|
|
&&
|
|
//
|
|
// One of Verification and Consolidation must Be in Direction State ...
|
|
(conditions.verificationConditions.x121Conditions.isVWapBullishState ||
|
|
conditions.consolidationConditions.x121Conditions.isVWapBullishState)
|
|
//
|
|
;
|
|
|
|
//
|
|
isBearish =
|
|
//
|
|
// Trigger, Decision and Analyse Cycles Must be in Direction Order and State ...
|
|
//
|
|
// Orders ...
|
|
(conditions.triggerConditions.x121Conditions.isVWapBearishOrdered &&
|
|
conditions.decisionConditions.x121Conditions.isVWapBearishOrdered &&
|
|
conditions.analyseConditions.x121Conditions.isVWapBearishOrdered)
|
|
//
|
|
&&
|
|
//
|
|
// State ...
|
|
(conditions.triggerConditions.x121Conditions.isVWapBearishState &&
|
|
conditions.decisionConditions.x121Conditions.isVWapBearishState &&
|
|
conditions.analyseConditions.x121Conditions.isVWapBearishState)
|
|
//
|
|
&&
|
|
//
|
|
// One of Verification and Consolidation must Be in Direction State ...
|
|
(conditions.verificationConditions.x121Conditions.isVWapBearishState ||
|
|
conditions.consolidationConditions.x121Conditions.isVWapBearishState)
|
|
//
|
|
;
|
|
}
|
|
|
|
//
|
|
if (forProvider == X_121_SMC_PROVIDER_VWAPC)
|
|
{
|
|
//
|
|
isBullish =
|
|
//
|
|
// All Cycles Must be State and Ordered Directional Except Vision ...
|
|
// State ...
|
|
conditions.triggerConditions.x121Conditions.isVWapBullishState &&
|
|
conditions.decisionConditions.x121Conditions.isVWapBullishState &&
|
|
conditions.analyseConditions.x121Conditions.isVWapBullishState &&
|
|
conditions.verificationConditions.x121Conditions.isVWapBullishState &&
|
|
conditions.consolidationConditions.x121Conditions.isVWapBullishState
|
|
//
|
|
&&
|
|
// Order ...
|
|
conditions.triggerConditions.x121Conditions.isVWapBullishOrdered &&
|
|
conditions.decisionConditions.x121Conditions.isVWapBullishOrdered &&
|
|
conditions.analyseConditions.x121Conditions.isVWapBullishOrdered &&
|
|
conditions.verificationConditions.x121Conditions.isVWapBullishOrdered &&
|
|
conditions.consolidationConditions.x121Conditions.isVWapBullishOrdered
|
|
//
|
|
;
|
|
|
|
//
|
|
isBearish =
|
|
//
|
|
// All Cycles Must be State and Ordered Directional Except Vision ...
|
|
// State ...
|
|
conditions.triggerConditions.x121Conditions.isVWapBearishState &&
|
|
conditions.decisionConditions.x121Conditions.isVWapBearishState &&
|
|
conditions.analyseConditions.x121Conditions.isVWapBearishState &&
|
|
conditions.verificationConditions.x121Conditions.isVWapBearishState &&
|
|
conditions.consolidationConditions.x121Conditions.isVWapBearishState
|
|
//
|
|
&&
|
|
// Order ...
|
|
conditions.triggerConditions.x121Conditions.isVWapBearishOrdered &&
|
|
conditions.decisionConditions.x121Conditions.isVWapBearishOrdered &&
|
|
conditions.analyseConditions.x121Conditions.isVWapBearishOrdered &&
|
|
conditions.verificationConditions.x121Conditions.isVWapBearishOrdered &&
|
|
conditions.consolidationConditions.x121Conditions.isVWapBearishOrdered
|
|
//
|
|
;
|
|
}
|
|
|
|
//
|
|
result = isBullish ||
|
|
isBearish;
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
dir =
|
|
isBullish
|
|
? X_DIRECTION_BULLISH
|
|
: X_DIRECTION_BEARISH;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Detect Candlestic Patters for Signalling ...
|
|
*
|
|
* @param forProvider: ENUM_X_121_SMC_PROVIDERS member ...
|
|
* @param dir: ENUM_X_DIRECTION member Reference ...
|
|
* @param conditions: X121SMCStrategyConditions instance, Reference ...
|
|
*
|
|
* @return ( bool )
|
|
*/
|
|
bool DetectCandlestic(
|
|
ENUM_X_121_SMC_PROVIDERS forProvider,
|
|
ENUM_X_DIRECTION &dir,
|
|
X121SMCStrategyConditions &conditions //
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
dir = X_DIRECTION_NONE;
|
|
|
|
//
|
|
int cIndex = 1;
|
|
int pIndex = cIndex + 1;
|
|
|
|
//
|
|
// Select Specified Cycle Helper ...
|
|
XC121SMCCycleHelper *cycleHelper = mTriggerCycleHelper;
|
|
|
|
//
|
|
string symbol = GetSymbol();
|
|
ENUM_TIMEFRAMES period = cycleHelper.GetPeriod();
|
|
|
|
//
|
|
XOHCL cBar;
|
|
result = cBar.Init(
|
|
symbol,
|
|
period,
|
|
cIndex //
|
|
);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Momentum Bar ...
|
|
ENUM_X_DIRECTION cBarMomentumDir;
|
|
bool isCBarMomentum = cycleHelper.mBarAnalyser.IsMomentumBar(
|
|
cBar,
|
|
cBarMomentumDir //
|
|
);
|
|
|
|
//
|
|
// Rejection Bar ...
|
|
ENUM_X_DIRECTION cBarRejectionDir;
|
|
bool isCBarRejection = cycleHelper.mBarAnalyser.IsRejectionBar(
|
|
cBar,
|
|
cBarRejectionDir //
|
|
);
|
|
|
|
//
|
|
// Engulf Bar ...
|
|
ENUM_X_DIRECTION cBarEngulfDir;
|
|
bool isCBarEngulf = cycleHelper.mBarAnalyser.IsEngulfBar(
|
|
cBar,
|
|
cBarEngulfDir //
|
|
);
|
|
|
|
//
|
|
// Pin Bar ...
|
|
ENUM_X_DIRECTION cBarPinDir;
|
|
bool isCBarPin = cycleHelper.mBarAnalyser.IsPinBar(
|
|
cBar,
|
|
cBarPinDir //
|
|
);
|
|
|
|
//
|
|
XOHCL pBar;
|
|
result = pBar.Init(
|
|
symbol,
|
|
period,
|
|
pIndex //
|
|
);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Momentum Bar ...
|
|
ENUM_X_DIRECTION pBarMomentumDir;
|
|
bool isPBarMomentum = cycleHelper.mBarAnalyser.IsMomentumBar(
|
|
pBar,
|
|
pBarMomentumDir //
|
|
);
|
|
|
|
//
|
|
// Rejection Bar ...
|
|
ENUM_X_DIRECTION pBarRejectionDir;
|
|
bool isPBarRejection = cycleHelper.mBarAnalyser.IsRejectionBar(
|
|
pBar,
|
|
pBarRejectionDir //
|
|
);
|
|
|
|
//
|
|
// Engulf Bar ...
|
|
ENUM_X_DIRECTION pBarEngulfDir;
|
|
bool isPBarEngulf = cycleHelper.mBarAnalyser.IsEngulfBar(
|
|
pBar,
|
|
pBarEngulfDir //
|
|
);
|
|
|
|
//
|
|
// Pin Bar ...
|
|
ENUM_X_DIRECTION pBarPinDir;
|
|
bool isPBarPin = cycleHelper.mBarAnalyser.IsPinBar(
|
|
pBar,
|
|
pBarPinDir //
|
|
);
|
|
|
|
//
|
|
bool isBullish = false;
|
|
bool isBearish = false;
|
|
|
|
//
|
|
if (forProvider == X_121_SMC_PROVIDER_VWAPC)
|
|
{
|
|
//
|
|
isBullish =
|
|
//
|
|
// pBar is Pin and cBar is Momentum or Rejection or Engulf
|
|
(
|
|
//
|
|
(isPBarPin &&
|
|
IsBullish(pBarPinDir) &&
|
|
(
|
|
//
|
|
(isCBarMomentum &&
|
|
IsBullish(cBarMomentumDir))
|
|
//
|
|
||
|
|
//
|
|
(isCBarRejection &&
|
|
IsBullish(cBarRejectionDir))
|
|
//
|
|
||
|
|
//
|
|
(isCBarEngulf &&
|
|
IsBullish(cBarEngulfDir))
|
|
//
|
|
)
|
|
//
|
|
)
|
|
//
|
|
||
|
|
//
|
|
// pBar is Engulf and cBar is Momentum or Rejection or Pin ...
|
|
(isPBarEngulf &&
|
|
IsBullish(pBarEngulfDir) &&
|
|
(
|
|
//
|
|
(isCBarMomentum &&
|
|
IsBullish(cBarMomentumDir))
|
|
//
|
|
||
|
|
//
|
|
(isCBarRejection &&
|
|
IsBullish(cBarRejectionDir))
|
|
//
|
|
||
|
|
//
|
|
(isCBarPin &&
|
|
IsBullish(cBarPinDir))
|
|
//
|
|
)
|
|
//
|
|
)
|
|
//
|
|
||
|
|
//
|
|
// pBar is Rejection and cBar is Momentum or Engulf or Pin ...
|
|
(isPBarRejection &&
|
|
IsBullish(pBarRejectionDir) &&
|
|
(
|
|
//
|
|
(isCBarMomentum &&
|
|
IsBullish(cBarMomentumDir))
|
|
//
|
|
||
|
|
//
|
|
(isCBarEngulf &&
|
|
IsBullish(cBarEngulfDir))
|
|
//
|
|
||
|
|
//
|
|
(isCBarPin &&
|
|
IsBullish(cBarPinDir))
|
|
//
|
|
)
|
|
//
|
|
)
|
|
//
|
|
||
|
|
//
|
|
// pBar is Momentum and cBar is Rejection or Engulf or Pin ...
|
|
(isPBarMomentum &&
|
|
IsBullish(pBarMomentumDir) &&
|
|
(
|
|
//
|
|
(isCBarRejection &&
|
|
IsBullish(cBarRejectionDir))
|
|
//
|
|
||
|
|
//
|
|
(isCBarEngulf &&
|
|
IsBullish(cBarEngulfDir))
|
|
//
|
|
||
|
|
//
|
|
(isCBarPin &&
|
|
IsBullish(cBarPinDir))
|
|
//
|
|
)
|
|
//
|
|
)
|
|
//
|
|
||
|
|
//
|
|
// cBar is Pin and Momentum and Rejection and Engulf ...
|
|
(
|
|
//
|
|
(isCBarPin &&
|
|
IsBullish(cBarPinDir))
|
|
//
|
|
&&
|
|
//
|
|
(isCBarMomentum &&
|
|
IsBullish(cBarMomentumDir))
|
|
//
|
|
&&
|
|
//
|
|
(isCBarRejection &&
|
|
IsBullish(cBarRejectionDir))
|
|
//
|
|
&&
|
|
//
|
|
(isCBarEngulf &&
|
|
IsBullish(cBarEngulfDir))
|
|
//
|
|
)
|
|
//
|
|
)
|
|
//
|
|
;
|
|
|
|
//
|
|
isBearish =
|
|
//
|
|
// pBar is Pin and cBar is Momentum or Rejection or Engulf
|
|
(
|
|
//
|
|
(isPBarPin &&
|
|
IsBearish(pBarPinDir) &&
|
|
(
|
|
//
|
|
(isCBarMomentum &&
|
|
IsBearish(cBarMomentumDir))
|
|
//
|
|
||
|
|
//
|
|
(isCBarRejection &&
|
|
IsBearish(cBarRejectionDir))
|
|
//
|
|
||
|
|
//
|
|
(isCBarEngulf &&
|
|
IsBearish(cBarEngulfDir))
|
|
//
|
|
)
|
|
//
|
|
)
|
|
//
|
|
||
|
|
//
|
|
// pBar is Engulf and cBar is Momentum or Rejection or Pin ...
|
|
(isPBarEngulf &&
|
|
IsBearish(pBarEngulfDir) &&
|
|
(
|
|
//
|
|
(isCBarMomentum &&
|
|
IsBearish(cBarMomentumDir))
|
|
//
|
|
||
|
|
//
|
|
(isCBarRejection &&
|
|
IsBearish(cBarRejectionDir))
|
|
//
|
|
||
|
|
//
|
|
(isCBarPin &&
|
|
IsBearish(cBarPinDir))
|
|
//
|
|
)
|
|
//
|
|
)
|
|
//
|
|
||
|
|
//
|
|
// pBar is Rejection and cBar is Momentum or Engulf or Pin ...
|
|
(isPBarRejection &&
|
|
IsBearish(pBarRejectionDir) &&
|
|
(
|
|
//
|
|
(isCBarMomentum &&
|
|
IsBearish(cBarMomentumDir))
|
|
//
|
|
||
|
|
//
|
|
(isCBarEngulf &&
|
|
IsBearish(cBarEngulfDir))
|
|
//
|
|
||
|
|
//
|
|
(isCBarPin &&
|
|
IsBearish(cBarPinDir))
|
|
//
|
|
)
|
|
//
|
|
)
|
|
//
|
|
||
|
|
//
|
|
// pBar is Momentum and cBar is Rejection or Engulf or Pin ...
|
|
(isPBarMomentum &&
|
|
IsBearish(pBarMomentumDir) &&
|
|
(
|
|
//
|
|
(isCBarRejection &&
|
|
IsBearish(cBarRejectionDir))
|
|
//
|
|
||
|
|
//
|
|
(isCBarEngulf &&
|
|
IsBearish(cBarEngulfDir))
|
|
//
|
|
||
|
|
//
|
|
(isCBarPin &&
|
|
IsBearish(cBarPinDir))
|
|
//
|
|
)
|
|
//
|
|
)
|
|
//
|
|
||
|
|
//
|
|
// cBar is Pin and Momentum and Rejection and Engulf ...
|
|
(
|
|
//
|
|
(isCBarPin &&
|
|
IsBearish(cBarPinDir))
|
|
//
|
|
&&
|
|
//
|
|
(isCBarMomentum &&
|
|
IsBearish(cBarMomentumDir))
|
|
//
|
|
&&
|
|
//
|
|
(isCBarRejection &&
|
|
IsBearish(cBarRejectionDir))
|
|
//
|
|
&&
|
|
//
|
|
(isCBarEngulf &&
|
|
IsBearish(cBarEngulfDir))
|
|
//
|
|
)
|
|
//
|
|
)
|
|
//
|
|
;
|
|
}
|
|
|
|
//
|
|
if (forProvider == X_121_SMC_PROVIDER_RJBPV)
|
|
{
|
|
//
|
|
isBullish =
|
|
//
|
|
// CBar is Pin, Engulf, Momentum or Rejection ...
|
|
(
|
|
// //
|
|
// (isCBarMomentum &&
|
|
// IsBullish(cBarMomentumDir))
|
|
// //
|
|
// ||
|
|
// //
|
|
(isCBarRejection &&
|
|
IsBullish(cBarRejectionDir))
|
|
// //
|
|
// ||
|
|
// //
|
|
// (isCBarEngulf &&
|
|
// IsBullish(cBarEngulfDir))
|
|
//
|
|
||
|
|
//
|
|
(isCBarPin &&
|
|
IsBullish(cBarPinDir))
|
|
//
|
|
)
|
|
//
|
|
;
|
|
|
|
//
|
|
isBearish =
|
|
//
|
|
// CBar is Pin, Engulf, Momentum or Rejection ...
|
|
(
|
|
//
|
|
// (isCBarMomentum &&
|
|
// IsBearish(cBarMomentumDir))
|
|
// //
|
|
// ||
|
|
// //
|
|
(isCBarRejection &&
|
|
IsBearish(cBarRejectionDir))
|
|
// //
|
|
// ||
|
|
// //
|
|
// (isCBarEngulf &&
|
|
// IsBearish(cBarEngulfDir))
|
|
//
|
|
||
|
|
//
|
|
(isCBarPin &&
|
|
IsBearish(cBarPinDir))
|
|
//
|
|
)
|
|
//
|
|
;
|
|
}
|
|
|
|
//
|
|
result = isBullish ||
|
|
isBearish;
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
dir =
|
|
isBullish
|
|
? X_DIRECTION_BULLISH
|
|
: X_DIRECTION_BEARISH;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Private ...
|
|
private:
|
|
//
|
|
// Props ...
|
|
|
|
/**
|
|
* Initial Required Indicators Helper ...
|
|
*/
|
|
void InitialHelpers()
|
|
{
|
|
//
|
|
string symbol = GetSymbol();
|
|
ENUM_TIMEFRAMES period = GetPeriod();
|
|
|
|
//
|
|
// Short ...
|
|
ENUM_X_PERIOD_METHOD scMethod = X_PERIOD_AUTO; // How to Find Period
|
|
ENUM_TIMEFRAMES scPeriod = NULL; // Time Period
|
|
|
|
//
|
|
// Medium ...
|
|
ENUM_X_PERIOD_METHOD mcMethod = X_PERIOD_AUTO; // How to Find Period
|
|
ENUM_TIMEFRAMES mcPeriod = NULL; // Time Period
|
|
|
|
//
|
|
// Long ...
|
|
ENUM_X_PERIOD_METHOD lcMethod = X_PERIOD_AUTO; // How to Find Period
|
|
ENUM_TIMEFRAMES lcPeriod = NULL; // Time Period
|
|
|
|
//
|
|
// Hind ...
|
|
ENUM_X_PERIOD_METHOD hcMethod = X_PERIOD_AUTO; // How to Find Period
|
|
ENUM_TIMEFRAMES hcPeriod = NULL; // Time Period
|
|
|
|
//
|
|
// XPV ...
|
|
X121Inputs x121Inputs;
|
|
|
|
//
|
|
x121Inputs.Default();
|
|
|
|
//
|
|
x121Inputs.scMethod = scMethod;
|
|
x121Inputs.scPeriod = scPeriod;
|
|
x121Inputs.mcMethod = mcMethod;
|
|
x121Inputs.mcPeriod = mcPeriod;
|
|
x121Inputs.lcMethod = lcMethod;
|
|
x121Inputs.lcPeriod = lcPeriod;
|
|
x121Inputs.hcMethod = hcMethod;
|
|
x121Inputs.hcPeriod = hcPeriod;
|
|
|
|
//
|
|
// Initialize Cycle Helpers ...
|
|
|
|
//
|
|
mTriggerCycleHelper = new XC121SMCCycleHelper();
|
|
mTriggerCycleHelper.Init(
|
|
symbol,
|
|
PERIOD_M1,
|
|
x121Inputs //
|
|
);
|
|
|
|
//
|
|
mDecisionCycleHelper = new XC121SMCCycleHelper();
|
|
mDecisionCycleHelper.Init(
|
|
symbol,
|
|
PERIOD_M5,
|
|
x121Inputs //
|
|
);
|
|
|
|
//
|
|
mAnalyseCycleHelper = new XC121SMCCycleHelper();
|
|
mAnalyseCycleHelper.Init(
|
|
symbol,
|
|
PERIOD_M15,
|
|
x121Inputs //
|
|
);
|
|
|
|
//
|
|
mVerificationCycleHelper = new XC121SMCCycleHelper();
|
|
mVerificationCycleHelper.Init(
|
|
symbol,
|
|
PERIOD_M30,
|
|
x121Inputs //
|
|
);
|
|
|
|
//
|
|
mConsolidationCycleHelper = new XC121SMCCycleHelper();
|
|
mConsolidationCycleHelper.Init(
|
|
symbol,
|
|
PERIOD_H1,
|
|
x121Inputs //
|
|
);
|
|
|
|
//
|
|
mVisionCycleHelper = new XC121SMCCycleHelper();
|
|
mVisionCycleHelper.Init(
|
|
symbol,
|
|
PERIOD_H4,
|
|
x121Inputs //
|
|
);
|
|
}
|
|
|
|
//
|
|
// SL Selector Methods ...
|
|
|
|
/**
|
|
* Select Specified Type of Stop Loss ...
|
|
*
|
|
* @param conditions: X121SMCStrategyConditions instance Reference ...
|
|
* @param forDir: ENUM_X_DIRECTION member, Signal Direction ...
|
|
* @param type: ENUM_X_121_SMC_SL_TYPES member, Specified Required SL Type ...
|
|
*
|
|
* @return ( double )
|
|
*/
|
|
double SelectSL(
|
|
X121SMCStrategyConditions &conditions,
|
|
ENUM_X_DIRECTION forDir,
|
|
ENUM_X_121_SMC_SL_TYPES type //
|
|
)
|
|
{
|
|
//
|
|
double result = 0;
|
|
|
|
//
|
|
string symbol = GetSymbol();
|
|
ENUM_TIMEFRAMES period = GetPeriod();
|
|
|
|
//
|
|
bool isValid =
|
|
//
|
|
HasDirection(forDir) &&
|
|
conditions.IsValid() &&
|
|
type != X_121_SMC_SL_TYPE_NONE
|
|
//
|
|
;
|
|
if (!isValid)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
XOHCL zBar;
|
|
bool isInited = zBar.Init(
|
|
symbol,
|
|
period,
|
|
0 //
|
|
);
|
|
if (!isInited)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
bool isBullish = IsBullish(forDir);
|
|
|
|
//
|
|
if (type == X_121_SMC_SL_TYPE_FIBO_LEVEL_3)
|
|
{
|
|
result = conditions.triggerConditions.x121Conditions.fl3Buffer[0];
|
|
}
|
|
else if (type == X_121_SMC_SL_TYPE_FIBO_LEVEL_1_5)
|
|
{
|
|
//
|
|
result =
|
|
isBullish
|
|
? conditions.triggerConditions.x121Conditions.fl1Buffer[0]
|
|
: conditions.triggerConditions.x121Conditions.fl5Buffer[0];
|
|
}
|
|
else if (type == X_121_SMC_SL_TYPE_DON_CLOSE_BOX)
|
|
{
|
|
//
|
|
result =
|
|
isBullish
|
|
? conditions.triggerConditions.x121Conditions.donCloseLowerBuffer[0]
|
|
: conditions.triggerConditions.x121Conditions.donCloseUpperBuffer[0];
|
|
}
|
|
else if (type == X_121_SMC_SL_TYPE_SWING)
|
|
{
|
|
//
|
|
int swingLowsCount = conditions.triggerConditions.state.CountSwingLows();
|
|
int swingHighsCount = conditions.triggerConditions.state.CountSwingHighs();
|
|
result =
|
|
isBullish
|
|
? conditions.triggerConditions.state.swingLows[swingLowsCount - 1].GetValue()
|
|
: conditions.triggerConditions.state.swingHighs[swingHighsCount - 1].GetValue();
|
|
}
|
|
else if (type == X_121_SMC_SL_TYPE_REJECTION)
|
|
{
|
|
//
|
|
result =
|
|
isBullish
|
|
? conditions.triggerConditions.state.bullishRejectionBars[conditions.triggerConditions.state.CountBullishRejectionBars() - 1].Lower()
|
|
: conditions.triggerConditions.state.bearishRejectionBars[conditions.triggerConditions.state.CountBearishRejectionBars() - 1].Upper();
|
|
}
|
|
else if (type == X_121_SMC_SL_TYPE_MOMENTUM)
|
|
{
|
|
//
|
|
result =
|
|
isBullish
|
|
? conditions.triggerConditions.state.bullishMomentumBars[conditions.triggerConditions.state.CountBullishMomentumBars() - 1].Lower()
|
|
: conditions.triggerConditions.state.bearishMomentumBars[conditions.triggerConditions.state.CountBearishMomentumBars() - 1].Upper();
|
|
}
|
|
else if (type == X_121_SMC_SL_TYPE_VWAP_FAST)
|
|
{
|
|
result = conditions.triggerConditions.x121Conditions.vwapFastBuffer[0];
|
|
}
|
|
else if (type == X_121_SMC_SL_TYPE_VWAP_MID)
|
|
{
|
|
result = conditions.triggerConditions.x121Conditions.vwapMidBuffer[0];
|
|
}
|
|
else if (type == X_121_SMC_SL_TYPE_VWAP_SLOW)
|
|
{
|
|
result = conditions.triggerConditions.x121Conditions.vwapSlowBuffer[0];
|
|
}
|
|
else if (type == X_121_SMC_SL_TYPE_CURRENT_SAR)
|
|
{
|
|
result = conditions.triggerConditions.x121Conditions.sarBuffer[0];
|
|
}
|
|
else if (type == X_121_SMC_SL_TYPE_TENKAN_SEN)
|
|
{
|
|
//
|
|
double hh = zBar.FindHighest(
|
|
9,
|
|
MODE_HIGH //
|
|
);
|
|
double ll = zBar.FindLowest(
|
|
9,
|
|
MODE_LOW //
|
|
);
|
|
double mid = (hh - ll) / 2;
|
|
result = isBullish
|
|
? ll - mid
|
|
: hh + mid;
|
|
}
|
|
else if (type == X_121_SMC_SL_TYPE_CURRENT_SAR_BOX ||
|
|
type == X_121_SMC_SL_TYPE_LAST_SAR_CHANGED_BAR ||
|
|
type == X_121_SMC_SL_TYPE_LAST_DIRECTIONAL_SAR)
|
|
{
|
|
//
|
|
XOHCL cSarChangeBar;
|
|
XOHCL pSarChangeBar;
|
|
XValueChange cSarChange; // Current Sar Change (IsDirect) ...
|
|
XValueChange pSarChange; // Prev Sar Change (Direct) ...
|
|
XValueChange sarChanges[];
|
|
int sarChangesCount = mTriggerCycleHelper
|
|
.FillSarChanges(sarChanges);
|
|
if (!IsValidSize(sarChangesCount) || sarChangesCount < 2)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
//
|
|
cSarChange = sarChanges[sarChangesCount - 1];
|
|
pSarChange = sarChanges[sarChangesCount - 2];
|
|
|
|
//
|
|
bool isFilled = cSarChange.FillBar(
|
|
cSarChangeBar,
|
|
symbol,
|
|
period //
|
|
);
|
|
if (!isFilled)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
isFilled = pSarChange.FillBar(
|
|
pSarChangeBar,
|
|
symbol,
|
|
period //
|
|
);
|
|
if (!isFilled)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
if (type == X_121_SMC_SL_TYPE_LAST_SAR_CHANGED_BAR)
|
|
{
|
|
//
|
|
result = isBullish
|
|
? pSarChangeBar.low
|
|
: pSarChangeBar.high;
|
|
}
|
|
else if (type == X_121_SMC_SL_TYPE_CURRENT_SAR_BOX)
|
|
{
|
|
//
|
|
result =
|
|
isBullish
|
|
? zBar.FindLowest(
|
|
MathAbs(cSarChangeBar.Index() - 1),
|
|
MODE_LOW //
|
|
)
|
|
: zBar.FindHighest(
|
|
MathAbs(cSarChangeBar.Index() - 1),
|
|
MODE_HIGH //
|
|
);
|
|
}
|
|
else if (type == X_121_SMC_SL_TYPE_LAST_DIRECTIONAL_SAR)
|
|
{
|
|
//
|
|
XOHCL prevBar;
|
|
bool isInited = cSarChangeBar.GetPreviousBar(prevBar);
|
|
if (!isInited)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
result = isBullish
|
|
? prevBar.low
|
|
: prevBar.high;
|
|
}
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Drawing Functions ...
|
|
|
|
/**
|
|
* Draw Pivot ...
|
|
*
|
|
* @param pivot: XPVPivot instance Reference ...
|
|
*/
|
|
void DrawPivot(XPVPivot &pivot)
|
|
{
|
|
//
|
|
if (!pivot.IsValid())
|
|
{
|
|
return;
|
|
}
|
|
|
|
//
|
|
XCXPVPivotObject *iObj;
|
|
iObj = new XCXPVPivotObject();
|
|
bool isCreated = iObj.Create(
|
|
mPOIDrawer.ChartIdentification(),
|
|
mPOIDrawer.SubWindowIdentification(),
|
|
pivot //
|
|
);
|
|
if (isCreated)
|
|
{
|
|
//
|
|
if (pivot.IsPeak())
|
|
{
|
|
//
|
|
iObj.PivotWidth(1);
|
|
iObj.PivotFill(false);
|
|
iObj.PivotColor(clrAqua);
|
|
iObj.PivotStyle(STYLE_SOLID);
|
|
}
|
|
|
|
//
|
|
if (pivot.IsVale())
|
|
{
|
|
//
|
|
iObj.PivotWidth(1);
|
|
iObj.PivotFill(false);
|
|
iObj.PivotStyle(STYLE_SOLID);
|
|
iObj.PivotColor(clrMagenta);
|
|
}
|
|
|
|
//
|
|
AddObjectIfNotExists(iObj);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Custom Drawing State ...
|
|
*
|
|
* @param state: XPOIState instance reference, Specified Which state to Draw ...
|
|
* @param forceDrawSamePeriod: Boolean ...
|
|
*/
|
|
void CustomStateDrawing(
|
|
XPOIState &state,
|
|
bool forceDrawSamePeriod = false,
|
|
ENUM_X_DIRECTION forDir = X_DIRECTION_NONE,
|
|
//
|
|
// Ignores List ...
|
|
bool ignoreSwingHighs = false,
|
|
bool ignoreSwingLows = false,
|
|
bool ignoreSupportZones = false,
|
|
bool ignoreResistanceZones = false,
|
|
bool ignoreSupplyZones = false,
|
|
bool ignoreDemandZones = false,
|
|
bool ignoreBullishOrderBlocks = false,
|
|
bool ignoreBearishOrderBlocks = false,
|
|
bool ignoreBullishFairValueGaps = false,
|
|
bool ignoreBearishFairValueGaps = false,
|
|
bool ignoreBullishRejectionBars = false,
|
|
bool ignoreBearishRejectionBars = false,
|
|
bool ignoreBullishMomentumBars = false,
|
|
bool ignoreBearishMomentumBars = false //
|
|
)
|
|
{
|
|
//
|
|
XPOIState tmpState = state;
|
|
if (forceDrawSamePeriod)
|
|
{
|
|
//
|
|
int count = 0;
|
|
ENUM_TIMEFRAMES period = GetPeriod();
|
|
|
|
//
|
|
count = state.CountSwingHighs();
|
|
if (IsValidSize(count))
|
|
{
|
|
//
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
//
|
|
XCSwing iSwing = state.swingHighs[i];
|
|
|
|
//
|
|
XOHCL iBar;
|
|
bool isFilled = iSwing.FillBar(iBar);
|
|
if (!isFilled)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
//
|
|
bool isSamePeriod = iBar.period == period;
|
|
if (!isSamePeriod)
|
|
{
|
|
//
|
|
ArrayRemove(
|
|
tmpState.swingHighs,
|
|
i,
|
|
1 //
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
count = state.CountSwingLows();
|
|
if (IsValidSize(count))
|
|
{
|
|
//
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
//
|
|
XCSwing iSwing = state.swingLows[i];
|
|
|
|
//
|
|
XOHCL iBar;
|
|
bool isFilled = iSwing.FillBar(iBar);
|
|
if (!isFilled)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
//
|
|
bool isSamePeriod = iBar.period == period;
|
|
if (!isSamePeriod)
|
|
{
|
|
//
|
|
ArrayRemove(
|
|
tmpState.swingLows,
|
|
i,
|
|
1 //
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
count = state.CountBullishMomentumBars();
|
|
if (IsValidSize(count))
|
|
{
|
|
//
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
//
|
|
XCMomentumBar iMomentum = state.bullishMomentumBars[i];
|
|
|
|
//
|
|
XOHCL iBar;
|
|
bool isFilled = iMomentum.FillBar(iBar);
|
|
if (!isFilled)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
//
|
|
bool isSamePeriod = iBar.period == period;
|
|
if (!isSamePeriod)
|
|
{
|
|
//
|
|
ArrayRemove(
|
|
tmpState.bullishMomentumBars,
|
|
i,
|
|
1 //
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
count = state.CountBearishMomentumBars();
|
|
if (IsValidSize(count))
|
|
{
|
|
//
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
//
|
|
XCMomentumBar iMomentum = state.bearishMomentumBars[i];
|
|
|
|
//
|
|
XOHCL iBar;
|
|
bool isFilled = iMomentum.FillBar(iBar);
|
|
if (!isFilled)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
//
|
|
bool isSamePeriod = iBar.period == period;
|
|
if (!isSamePeriod)
|
|
{
|
|
//
|
|
ArrayRemove(
|
|
tmpState.bearishMomentumBars,
|
|
i,
|
|
1 //
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
count = state.CountBullishRejectionBars();
|
|
if (IsValidSize(count))
|
|
{
|
|
//
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
//
|
|
XCRejectionBar iRejection = state.bullishRejectionBars[i];
|
|
|
|
//
|
|
XOHCL iBar;
|
|
bool isFilled = iRejection.FillBar(iBar);
|
|
if (!isFilled)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
//
|
|
bool isSamePeriod = iBar.period == period;
|
|
if (!isSamePeriod)
|
|
{
|
|
//
|
|
ArrayRemove(
|
|
tmpState.bullishRejectionBars,
|
|
i,
|
|
1 //
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
count = state.CountBearishRejectionBars();
|
|
if (IsValidSize(count))
|
|
{
|
|
//
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
//
|
|
XCRejectionBar iRejection = state.bearishRejectionBars[i];
|
|
|
|
//
|
|
XOHCL iBar;
|
|
bool isFilled = iRejection.FillBar(iBar);
|
|
if (!isFilled)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
//
|
|
bool isSamePeriod = iBar.period == period;
|
|
if (!isSamePeriod)
|
|
{
|
|
//
|
|
ArrayRemove(
|
|
tmpState.bearishRejectionBars,
|
|
i,
|
|
1 //
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
count = state.CountSupportZones();
|
|
if (IsValidSize(count))
|
|
{
|
|
//
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
//
|
|
XCSupportZone iZone = state.supportZones[i];
|
|
|
|
//
|
|
XOHCL iBar;
|
|
bool isFilled = iZone.FillBar(iBar);
|
|
if (!isFilled)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
//
|
|
bool isSamePeriod = iBar.period == period;
|
|
if (!isSamePeriod)
|
|
{
|
|
//
|
|
ArrayRemove(
|
|
tmpState.supportZones,
|
|
i,
|
|
1 //
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
count = state.CountResistanceZones();
|
|
if (IsValidSize(count))
|
|
{
|
|
//
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
//
|
|
XCResistanceZone iZone = state.resistanceZones[i];
|
|
|
|
//
|
|
XOHCL iBar;
|
|
bool isFilled = iZone.FillBar(iBar);
|
|
if (!isFilled)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
//
|
|
bool isSamePeriod = iBar.period == period;
|
|
if (!isSamePeriod)
|
|
{
|
|
//
|
|
ArrayRemove(
|
|
tmpState.resistanceZones,
|
|
i,
|
|
1 //
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
count = state.CountSupplyZones();
|
|
if (IsValidSize(count))
|
|
{
|
|
//
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
//
|
|
XCSupplyZone iZone = state.supplyZones[i];
|
|
|
|
//
|
|
XOHCL iBar;
|
|
bool isFilled = iZone.FillBar(iBar);
|
|
if (!isFilled)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
//
|
|
bool isSamePeriod = iBar.period == period;
|
|
if (!isSamePeriod)
|
|
{
|
|
//
|
|
ArrayRemove(
|
|
tmpState.supplyZones,
|
|
i,
|
|
1 //
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
count = state.CountDemandZones();
|
|
if (IsValidSize(count))
|
|
{
|
|
//
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
//
|
|
XCDemandZone iZone = state.demandZones[i];
|
|
|
|
//
|
|
XOHCL iBar;
|
|
bool isFilled = iZone.FillBar(iBar);
|
|
if (!isFilled)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
//
|
|
bool isSamePeriod = iBar.period == period;
|
|
if (!isSamePeriod)
|
|
{
|
|
//
|
|
ArrayRemove(
|
|
tmpState.demandZones,
|
|
i,
|
|
1 //
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
count = state.CountBullishOrderBlocks();
|
|
if (IsValidSize(count))
|
|
{
|
|
//
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
//
|
|
XCOrderBlock iZone = state.bullishOrderBlocks[i];
|
|
|
|
//
|
|
XOHCL iBar;
|
|
bool isFilled = iZone.FillBar(iBar);
|
|
if (!isFilled)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
//
|
|
bool isSamePeriod = iBar.period == period;
|
|
if (!isSamePeriod)
|
|
{
|
|
//
|
|
ArrayRemove(
|
|
tmpState.bullishOrderBlocks,
|
|
i,
|
|
1 //
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
count = state.CountBearishOrderBlocks();
|
|
if (IsValidSize(count))
|
|
{
|
|
//
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
//
|
|
XCOrderBlock iZone = state.bearishOrderBlocks[i];
|
|
|
|
//
|
|
XOHCL iBar;
|
|
bool isFilled = iZone.FillBar(iBar);
|
|
if (!isFilled)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
//
|
|
bool isSamePeriod = iBar.period == period;
|
|
if (!isSamePeriod)
|
|
{
|
|
//
|
|
ArrayRemove(
|
|
tmpState.bearishOrderBlocks,
|
|
i,
|
|
1 //
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
count = state.CountBullishFairValueGaps();
|
|
if (IsValidSize(count))
|
|
{
|
|
//
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
//
|
|
XCFVG iZone = state.bullishFairValueGaps[i];
|
|
|
|
//
|
|
XOHCL iBar;
|
|
bool isFilled = iZone.FillStartBar(iBar);
|
|
if (!isFilled)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
//
|
|
bool isSamePeriod = iBar.period == period;
|
|
if (!isSamePeriod)
|
|
{
|
|
//
|
|
ArrayRemove(
|
|
tmpState.bullishFairValueGaps,
|
|
i,
|
|
1 //
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
count = state.CountBearishFairValueGaps();
|
|
if (IsValidSize(count))
|
|
{
|
|
//
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
//
|
|
XCFVG iZone = state.bearishFairValueGaps[i];
|
|
|
|
//
|
|
XOHCL iBar;
|
|
bool isFilled = iZone.FillStartBar(iBar);
|
|
if (!isFilled)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
//
|
|
bool isSamePeriod = iBar.period == period;
|
|
if (!isSamePeriod)
|
|
{
|
|
//
|
|
ArrayRemove(
|
|
tmpState.bearishFairValueGaps,
|
|
i,
|
|
1 //
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
}
|
|
|
|
//
|
|
bool drawSwingHighs = true;
|
|
bool drawSwingLows = true;
|
|
bool drawSupportZones = true;
|
|
bool drawResistanceZones = true;
|
|
bool drawSupplyZones = true;
|
|
bool drawDemandZones = true;
|
|
bool drawBullishOrderBlocks = true;
|
|
bool drawBearishOrderBlocks = true;
|
|
bool drawBullishFairValueGaps = true;
|
|
bool drawBearishFairValueGaps = true;
|
|
bool drawBullishRejectionBars = true;
|
|
bool drawBearishRejectionBars = true;
|
|
bool drawBullishMomentumBars = true;
|
|
bool drawBearishMomentumBars = true;
|
|
|
|
//
|
|
// Change Drawing Specs Conditions based on
|
|
// Provided Direction ...
|
|
if (forDir == X_DIRECTION_BULLISH)
|
|
{
|
|
//
|
|
drawSwingLows = true;
|
|
drawDemandZones = true;
|
|
drawSupportZones = true;
|
|
drawBullishOrderBlocks = true;
|
|
drawBullishFairValueGaps = true;
|
|
drawBullishRejectionBars = true;
|
|
drawBullishMomentumBars = true;
|
|
|
|
//
|
|
drawSwingHighs = false;
|
|
drawSupplyZones = false;
|
|
drawResistanceZones = false;
|
|
drawBearishOrderBlocks = false;
|
|
drawBearishFairValueGaps = false;
|
|
drawBearishRejectionBars = false;
|
|
drawBearishMomentumBars = false;
|
|
}
|
|
else if (forDir == X_DIRECTION_BEARISH)
|
|
{
|
|
//
|
|
drawSwingLows = false;
|
|
drawDemandZones = false;
|
|
drawSupportZones = false;
|
|
drawBullishOrderBlocks = false;
|
|
drawBullishFairValueGaps = false;
|
|
drawBullishRejectionBars = false;
|
|
drawBullishMomentumBars = false;
|
|
|
|
//
|
|
drawSwingHighs = true;
|
|
drawSupplyZones = true;
|
|
drawResistanceZones = true;
|
|
drawBearishOrderBlocks = true;
|
|
drawBearishFairValueGaps = true;
|
|
drawBearishRejectionBars = true;
|
|
drawBearishMomentumBars = true;
|
|
}
|
|
|
|
//
|
|
// Apply Ignore List ...
|
|
|
|
//
|
|
if (ignoreSwingHighs)
|
|
{
|
|
drawSwingHighs = false;
|
|
}
|
|
|
|
//
|
|
if (ignoreSwingLows)
|
|
{
|
|
drawSwingLows = false;
|
|
}
|
|
|
|
//
|
|
if (ignoreSupportZones)
|
|
{
|
|
drawSupportZones = false;
|
|
}
|
|
|
|
//
|
|
if (ignoreResistanceZones)
|
|
{
|
|
drawResistanceZones = false;
|
|
}
|
|
|
|
//
|
|
if (ignoreSupplyZones)
|
|
{
|
|
drawSupplyZones = false;
|
|
}
|
|
|
|
//
|
|
if (ignoreDemandZones)
|
|
{
|
|
drawDemandZones = false;
|
|
}
|
|
|
|
//
|
|
if (ignoreBullishOrderBlocks)
|
|
{
|
|
drawBullishOrderBlocks = false;
|
|
}
|
|
|
|
//
|
|
if (ignoreBearishOrderBlocks)
|
|
{
|
|
drawBearishOrderBlocks = false;
|
|
}
|
|
|
|
//
|
|
if (ignoreBullishFairValueGaps)
|
|
{
|
|
drawBullishFairValueGaps = false;
|
|
}
|
|
|
|
//
|
|
if (ignoreBearishFairValueGaps)
|
|
{
|
|
drawBearishFairValueGaps = false;
|
|
}
|
|
|
|
//
|
|
if (ignoreBullishRejectionBars)
|
|
{
|
|
drawBullishRejectionBars = false;
|
|
}
|
|
|
|
//
|
|
if (ignoreBearishRejectionBars)
|
|
{
|
|
drawBearishRejectionBars = false;
|
|
}
|
|
|
|
//
|
|
if (ignoreBullishMomentumBars)
|
|
{
|
|
drawBullishMomentumBars = false;
|
|
}
|
|
|
|
//
|
|
if (ignoreBearishMomentumBars)
|
|
{
|
|
drawBearishMomentumBars = false;
|
|
}
|
|
|
|
//
|
|
DrawState(
|
|
tmpState, // State ...
|
|
true, // Update To of all Drawings Till now ...
|
|
drawSwingHighs, // Draw SwingHighs ..
|
|
drawSwingLows, // Draw SwingLows ..
|
|
drawSupportZones, // Draw SupportZones ..
|
|
drawResistanceZones, // Draw ResistanceZones ..
|
|
drawSupplyZones, // Draw SupplyZones ..
|
|
drawDemandZones, // Draw DemandZones ..
|
|
drawBullishOrderBlocks, // Draw BullishOrderBlocks ..
|
|
drawBearishOrderBlocks, // Draw BearishOrderBlocks ..
|
|
drawBullishFairValueGaps, // Draw BullishFairValueGaps ..
|
|
drawBearishFairValueGaps, // Draw BearishFairValueGaps ..
|
|
drawBullishRejectionBars, // Draw BullishRejectionBars ..
|
|
drawBearishRejectionBars, // Draw BearishRejectionBars ..
|
|
drawBullishMomentumBars, // Draw BullishMomentumBars ..
|
|
drawBearishMomentumBars, // Draw BearishMomentumBars ..
|
|
true // Draw Ticks Zone ...
|
|
);
|
|
}
|
|
|
|
//
|
|
};
|
|
|
|
// |