351 lines
11 KiB
Plaintext
351 lines
11 KiB
Plaintext
//+------------------------------------------------------------------+
|
|
//| double-top-bottom-catcher.mq5 |
|
|
//| Lab EA: Double top/bottom catcher with EMA distance + HTF trend |
|
|
//+------------------------------------------------------------------+
|
|
#property copyright "Lab"
|
|
#property version "1.00"
|
|
|
|
#include <Trade\Trade.mqh>
|
|
|
|
input ENUM_TIMEFRAMES InpTf = PERIOD_M1; // Signal timeframe
|
|
input ENUM_TIMEFRAMES InpHtf = PERIOD_M5; // Higher timeframe
|
|
input bool InpUseHtfFilter = true; // Require HTF trend alignment
|
|
input int InpEmaFast = 9; // Fast EMA
|
|
input int InpEmaSlow = 21; // Slow EMA
|
|
|
|
input int InpPivotLeft = 2; // Pivot bars left
|
|
input int InpPivotRight = 2; // Pivot bars right
|
|
input int InpPatternLookbackBars = 180; // Search range for patterns
|
|
input int InpMinPatternSeparation = 6; // Min bars between tops/bottoms
|
|
input int InpMaxPatternSeparation = 50; // Max bars between tops/bottoms
|
|
input double InpTopBottomTolPts = 120; // Max diff between top/top or bottom/bottom
|
|
input double InpMinEmaPriceDistPts = 80; // Min stretch from EMA at 2nd touch
|
|
input int InpPrevLevelLookback = 120; // Lookback to find previous support/resistance
|
|
|
|
input double InpLots = 0.01;
|
|
input int InpSlBufferPts = 25; // SL buffer beyond pattern extreme
|
|
input ulong InpMagic = 20260425;
|
|
input int InpSlippagePts = 30;
|
|
|
|
CTrade g_trade;
|
|
|
|
int g_hEmaFast = INVALID_HANDLE;
|
|
int g_hEmaSlow = INVALID_HANDLE;
|
|
int g_hEmaFastHtf = INVALID_HANDLE;
|
|
int g_hEmaSlowHtf = INVALID_HANDLE;
|
|
|
|
double g_emaFast[];
|
|
double g_emaSlow[];
|
|
double g_emaFastHtf[];
|
|
double g_emaSlowHtf[];
|
|
|
|
int OnInit()
|
|
{
|
|
g_trade.SetExpertMagicNumber(InpMagic);
|
|
g_trade.SetDeviationInPoints(InpSlippagePts);
|
|
SetTradeFillingBySymbol();
|
|
|
|
g_hEmaFast = iMA(_Symbol, InpTf, InpEmaFast, 0, MODE_EMA, PRICE_CLOSE);
|
|
g_hEmaSlow = iMA(_Symbol, InpTf, InpEmaSlow, 0, MODE_EMA, PRICE_CLOSE);
|
|
g_hEmaFastHtf = iMA(_Symbol, InpHtf, InpEmaFast, 0, MODE_EMA, PRICE_CLOSE);
|
|
g_hEmaSlowHtf = iMA(_Symbol, InpHtf, InpEmaSlow, 0, MODE_EMA, PRICE_CLOSE);
|
|
|
|
if(g_hEmaFast == INVALID_HANDLE || g_hEmaSlow == INVALID_HANDLE ||
|
|
g_hEmaFastHtf == INVALID_HANDLE || g_hEmaSlowHtf == INVALID_HANDLE)
|
|
return INIT_FAILED;
|
|
|
|
ArraySetAsSeries(g_emaFast, true);
|
|
ArraySetAsSeries(g_emaSlow, true);
|
|
ArraySetAsSeries(g_emaFastHtf, true);
|
|
ArraySetAsSeries(g_emaSlowHtf, true);
|
|
|
|
return INIT_SUCCEEDED;
|
|
}
|
|
|
|
void OnDeinit(const int reason)
|
|
{
|
|
if(g_hEmaFast != INVALID_HANDLE) IndicatorRelease(g_hEmaFast);
|
|
if(g_hEmaSlow != INVALID_HANDLE) IndicatorRelease(g_hEmaSlow);
|
|
if(g_hEmaFastHtf != INVALID_HANDLE) IndicatorRelease(g_hEmaFastHtf);
|
|
if(g_hEmaSlowHtf != INVALID_HANDLE) IndicatorRelease(g_hEmaSlowHtf);
|
|
}
|
|
|
|
void OnTick()
|
|
{
|
|
static datetime lastBar = 0;
|
|
datetime barTime = iTime(_Symbol, InpTf, 0);
|
|
if(barTime == lastBar)
|
|
return;
|
|
lastBar = barTime;
|
|
|
|
const int need = MathMax(260, InpPatternLookbackBars + InpPrevLevelLookback + 20);
|
|
if(CopyBuffer(g_hEmaFast, 0, 0, need, g_emaFast) < need) return;
|
|
if(CopyBuffer(g_hEmaSlow, 0, 0, need, g_emaSlow) < need) return;
|
|
if(CopyBuffer(g_hEmaFastHtf, 0, 0, 5, g_emaFastHtf) < 5) return;
|
|
if(CopyBuffer(g_hEmaSlowHtf, 0, 0, 5, g_emaSlowHtf) < 5) return;
|
|
|
|
if(PositionExistsForMagic())
|
|
return;
|
|
|
|
TryEnterLongDoubleBottom();
|
|
if(!PositionExistsForMagic())
|
|
TryEnterShortDoubleTop();
|
|
}
|
|
|
|
void TryEnterLongDoubleBottom()
|
|
{
|
|
int firstBottom = -1; // older
|
|
int secondBottom = -1; // newer
|
|
double neckline = 0.0;
|
|
double lowA = 0.0;
|
|
double lowB = 0.0;
|
|
|
|
if(!FindDoubleBottom(firstBottom, secondBottom, neckline, lowA, lowB))
|
|
return;
|
|
|
|
const int c = 1;
|
|
double close1 = iClose(_Symbol, InpTf, c);
|
|
if(close1 <= neckline)
|
|
return; // wait for neckline break confirmation
|
|
|
|
double pt = SymbolInfoDouble(_Symbol, SYMBOL_POINT);
|
|
double stretched = g_emaFast[secondBottom] - lowB;
|
|
if(stretched < InpMinEmaPriceDistPts * pt)
|
|
return; // no enough EMA/price displacement for reversal
|
|
|
|
if(close1 <= g_emaFast[c])
|
|
return; // keep confirmation strict: close above EMA fast
|
|
|
|
if(InpUseHtfFilter && !(g_emaFastHtf[c] > g_emaSlowHtf[c]))
|
|
return;
|
|
|
|
double ask = SymbolInfoDouble(_Symbol, SYMBOL_ASK);
|
|
int digits = (int)SymbolInfoInteger(_Symbol, SYMBOL_DIGITS);
|
|
double sl = MathMin(lowA, lowB) - InpSlBufferPts * pt;
|
|
double tp = FindPreviousResistance(firstBottom);
|
|
if(tp <= ask + pt)
|
|
return;
|
|
if(sl >= ask - pt)
|
|
return;
|
|
|
|
sl = NormalizeDouble(sl, digits);
|
|
tp = NormalizeDouble(tp, digits);
|
|
g_trade.Buy(InpLots, _Symbol, ask, sl, tp, "Double bottom");
|
|
}
|
|
|
|
void TryEnterShortDoubleTop()
|
|
{
|
|
int firstTop = -1; // older
|
|
int secondTop = -1; // newer
|
|
double neckline = 0.0;
|
|
double hiA = 0.0;
|
|
double hiB = 0.0;
|
|
|
|
if(!FindDoubleTop(firstTop, secondTop, neckline, hiA, hiB))
|
|
return;
|
|
|
|
const int c = 1;
|
|
double close1 = iClose(_Symbol, InpTf, c);
|
|
if(close1 >= neckline)
|
|
return; // wait for neckline break confirmation
|
|
|
|
double pt = SymbolInfoDouble(_Symbol, SYMBOL_POINT);
|
|
double stretched = hiB - g_emaFast[secondTop];
|
|
if(stretched < InpMinEmaPriceDistPts * pt)
|
|
return; // no enough EMA/price displacement for reversal
|
|
|
|
if(close1 >= g_emaFast[c])
|
|
return; // keep confirmation strict: close below EMA fast
|
|
|
|
if(InpUseHtfFilter && !(g_emaFastHtf[c] < g_emaSlowHtf[c]))
|
|
return;
|
|
|
|
double bid = SymbolInfoDouble(_Symbol, SYMBOL_BID);
|
|
int digits = (int)SymbolInfoInteger(_Symbol, SYMBOL_DIGITS);
|
|
double sl = MathMax(hiA, hiB) + InpSlBufferPts * pt;
|
|
double tp = FindPreviousSupport(firstTop);
|
|
if(tp >= bid - pt)
|
|
return;
|
|
if(sl <= bid + pt)
|
|
return;
|
|
|
|
sl = NormalizeDouble(sl, digits);
|
|
tp = NormalizeDouble(tp, digits);
|
|
g_trade.Sell(InpLots, _Symbol, bid, sl, tp, "Double top");
|
|
}
|
|
|
|
bool FindDoubleBottom(int &firstBottom, int &secondBottom, double &neckline, double &lowA, double &lowB)
|
|
{
|
|
double pt = SymbolInfoDouble(_Symbol, SYMBOL_POINT);
|
|
int minShift = InpPivotRight + 1;
|
|
int maxShift = MathMin(InpPatternLookbackBars, Bars(_Symbol, InpTf) - InpPivotLeft - 2);
|
|
if(maxShift <= minShift + InpPivotLeft + InpPivotRight + 2)
|
|
return false;
|
|
|
|
for(int newer = minShift; newer <= maxShift; newer++)
|
|
{
|
|
if(!IsPivotLow(newer))
|
|
continue;
|
|
for(int older = newer + InpMinPatternSeparation; older <= maxShift; older++)
|
|
{
|
|
int sep = older - newer;
|
|
if(sep > InpMaxPatternSeparation)
|
|
break;
|
|
if(!IsPivotLow(older))
|
|
continue;
|
|
|
|
double lNew = iLow(_Symbol, InpTf, newer);
|
|
double lOld = iLow(_Symbol, InpTf, older);
|
|
if(MathAbs(lNew - lOld) > InpTopBottomTolPts * pt)
|
|
continue;
|
|
|
|
double neck = HighestHighBetween(newer, older);
|
|
if(neck <= 0.0)
|
|
continue;
|
|
|
|
firstBottom = older;
|
|
secondBottom = newer;
|
|
lowA = lOld;
|
|
lowB = lNew;
|
|
neckline = neck;
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool FindDoubleTop(int &firstTop, int &secondTop, double &neckline, double &hiA, double &hiB)
|
|
{
|
|
double pt = SymbolInfoDouble(_Symbol, SYMBOL_POINT);
|
|
int minShift = InpPivotRight + 1;
|
|
int maxShift = MathMin(InpPatternLookbackBars, Bars(_Symbol, InpTf) - InpPivotLeft - 2);
|
|
if(maxShift <= minShift + InpPivotLeft + InpPivotRight + 2)
|
|
return false;
|
|
|
|
for(int newer = minShift; newer <= maxShift; newer++)
|
|
{
|
|
if(!IsPivotHigh(newer))
|
|
continue;
|
|
for(int older = newer + InpMinPatternSeparation; older <= maxShift; older++)
|
|
{
|
|
int sep = older - newer;
|
|
if(sep > InpMaxPatternSeparation)
|
|
break;
|
|
if(!IsPivotHigh(older))
|
|
continue;
|
|
|
|
double hNew = iHigh(_Symbol, InpTf, newer);
|
|
double hOld = iHigh(_Symbol, InpTf, older);
|
|
if(MathAbs(hNew - hOld) > InpTopBottomTolPts * pt)
|
|
continue;
|
|
|
|
double neck = LowestLowBetween(newer, older);
|
|
if(neck <= 0.0)
|
|
continue;
|
|
|
|
firstTop = older;
|
|
secondTop = newer;
|
|
hiA = hOld;
|
|
hiB = hNew;
|
|
neckline = neck;
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool IsPivotLow(const int shift)
|
|
{
|
|
double v = iLow(_Symbol, InpTf, shift);
|
|
for(int i = 1; i <= InpPivotLeft; i++)
|
|
if(iLow(_Symbol, InpTf, shift + i) <= v) return false;
|
|
for(int i = 1; i <= InpPivotRight; i++)
|
|
if(iLow(_Symbol, InpTf, shift - i) < v) return false;
|
|
return true;
|
|
}
|
|
|
|
bool IsPivotHigh(const int shift)
|
|
{
|
|
double v = iHigh(_Symbol, InpTf, shift);
|
|
for(int i = 1; i <= InpPivotLeft; i++)
|
|
if(iHigh(_Symbol, InpTf, shift + i) >= v) return false;
|
|
for(int i = 1; i <= InpPivotRight; i++)
|
|
if(iHigh(_Symbol, InpTf, shift - i) > v) return false;
|
|
return true;
|
|
}
|
|
|
|
double HighestHighBetween(const int shiftA, const int shiftB)
|
|
{
|
|
int from = MathMin(shiftA, shiftB);
|
|
int to = MathMax(shiftA, shiftB);
|
|
double v = -DBL_MAX;
|
|
for(int i = from; i <= to; i++)
|
|
v = MathMax(v, iHigh(_Symbol, InpTf, i));
|
|
return v;
|
|
}
|
|
|
|
double LowestLowBetween(const int shiftA, const int shiftB)
|
|
{
|
|
int from = MathMin(shiftA, shiftB);
|
|
int to = MathMax(shiftA, shiftB);
|
|
double v = DBL_MAX;
|
|
for(int i = from; i <= to; i++)
|
|
v = MathMin(v, iLow(_Symbol, InpTf, i));
|
|
return v;
|
|
}
|
|
|
|
double FindPreviousResistance(const int firstBottomShift)
|
|
{
|
|
int start = firstBottomShift + 1;
|
|
int end = firstBottomShift + InpPrevLevelLookback;
|
|
int bars = Bars(_Symbol, InpTf);
|
|
end = MathMin(end, bars - 2);
|
|
if(start > end)
|
|
return 0.0;
|
|
|
|
double r = -DBL_MAX;
|
|
for(int i = start; i <= end; i++)
|
|
r = MathMax(r, iHigh(_Symbol, InpTf, i));
|
|
return r;
|
|
}
|
|
|
|
double FindPreviousSupport(const int firstTopShift)
|
|
{
|
|
int start = firstTopShift + 1;
|
|
int end = firstTopShift + InpPrevLevelLookback;
|
|
int bars = Bars(_Symbol, InpTf);
|
|
end = MathMin(end, bars - 2);
|
|
if(start > end)
|
|
return 0.0;
|
|
|
|
double s = DBL_MAX;
|
|
for(int i = start; i <= end; i++)
|
|
s = MathMin(s, iLow(_Symbol, InpTf, i));
|
|
return s;
|
|
}
|
|
|
|
bool PositionExistsForMagic()
|
|
{
|
|
for(int i = PositionsTotal() - 1; i >= 0; i--)
|
|
{
|
|
ulong ticket = PositionGetTicket(i);
|
|
if(ticket == 0) continue;
|
|
if(!PositionSelectByTicket(ticket)) continue;
|
|
if(PositionGetString(POSITION_SYMBOL) != _Symbol) continue;
|
|
if((ulong)PositionGetInteger(POSITION_MAGIC) == InpMagic)
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void SetTradeFillingBySymbol()
|
|
{
|
|
long mask = SymbolInfoInteger(_Symbol, SYMBOL_FILLING_MODE);
|
|
if((mask & SYMBOL_FILLING_IOC) != 0)
|
|
g_trade.SetTypeFilling(ORDER_FILLING_IOC);
|
|
else if((mask & SYMBOL_FILLING_FOK) != 0)
|
|
g_trade.SetTypeFilling(ORDER_FILLING_FOK);
|
|
else
|
|
g_trade.SetTypeFilling(ORDER_FILLING_RETURN);
|
|
}
|