576 lines
21 KiB
Text
576 lines
21 KiB
Text
//+------------------------------------------------------------------+
|
|
//| COMPLETE REVERSAL BOT - 127.8% + 61.8% STRATEGY |
|
|
//| Multi-Timeframe: 15M Setup | 5M Precision | 1H Trend Filter |
|
|
//| Indicators: Stoch RSI + CCI Dual Divergence |
|
|
//+------------------------------------------------------------------+
|
|
#property strict
|
|
|
|
// === INPUT PARAMETERS ===
|
|
input double FirstEntryLots = 0.03; // 127.8% entry size
|
|
input double SecondEntryLots = 0.02; // 61.8% add-on size
|
|
input int SLPips = 10; // Base SL in pips
|
|
input double MaxSpread = 3.0; // Max spread filter
|
|
input int MomentumThreshold = 70; // Min momentum score
|
|
input double Fib1278 = 1.278; // First entry fib level
|
|
input double Fib618 = 0.618; // Second entry fib level
|
|
|
|
enum EntryStyle {
|
|
STYLE_AGGRESSIVE, // Enter on touch/wick
|
|
STYLE_CONSERVATIVE // Enter on close confirmation
|
|
};
|
|
input EntryStyle EntryMode = STYLE_CONSERVATIVE;
|
|
|
|
enum TradePhase {
|
|
PHASE_NONE,
|
|
PHASE_1278_LONG,
|
|
PHASE_618_ADDON
|
|
};
|
|
|
|
// === GLOBAL VARIABLES ===
|
|
TradePhase currentPhase = PHASE_NONE;
|
|
|
|
struct SetupData {
|
|
double swingHigh;
|
|
double swingLow;
|
|
double fib1278Level;
|
|
double entry1278Price;
|
|
double newSwingHigh;
|
|
double pullbackLow;
|
|
bool swingEstablished;
|
|
};
|
|
SetupData activeSetup;
|
|
|
|
datetime last5MBar = 0;
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| EXPERT INITIALIZATION |
|
|
//+------------------------------------------------------------------+
|
|
int OnInit()
|
|
{
|
|
if(StringFind(Symbol(), "Volatility") == -1)
|
|
{
|
|
Alert("This EA is designed for Synthetic Indices!");
|
|
return(INIT_FAILED);
|
|
}
|
|
return(INIT_SUCCEEDED);
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| MAIN TICK FUNCTION |
|
|
//+------------------------------------------------------------------+
|
|
void OnTick()
|
|
{
|
|
// Spread filter
|
|
if(SymbolInfoInteger(Symbol(), SYMBOL_SPREAD) > MaxSpread * 10) return;
|
|
|
|
// Time filter
|
|
MqlDateTime dt;
|
|
TimeToStruct(TimeCurrent(), dt);
|
|
if(dt.min < 5 || dt.min > 55) return;
|
|
|
|
// Check for new 5M bar
|
|
datetime current5MBar = iTime(Symbol(), PERIOD_M5, 0);
|
|
if(current5MBar != last5MBar)
|
|
{
|
|
last5MBar = current5MBar;
|
|
|
|
// Entry logic
|
|
if(PositionsTotal() == 0 || !HasOpenPosition("1278"))
|
|
{
|
|
switch(currentPhase)
|
|
{
|
|
case PHASE_NONE:
|
|
Check1278LongEntry();
|
|
break;
|
|
case PHASE_1278_LONG:
|
|
CheckForPullbackSetup();
|
|
break;
|
|
case PHASE_618_ADDON:
|
|
Check618AddonEntry();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Manage positions
|
|
if(PositionsTotal() > 0)
|
|
ManagePositions();
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| 127.8% LONG ENTRY |
|
|
//+------------------------------------------------------------------+
|
|
void Check1278LongEntry()
|
|
{
|
|
// 15M Setup
|
|
int highestBar15M = iHighest(Symbol(), PERIOD_M15, MODE_HIGH, 30, 1);
|
|
int lowestBar15M = iLowest(Symbol(), PERIOD_M15, MODE_LOW, 30, 1);
|
|
|
|
activeSetup.swingHigh = iHigh(Symbol(), PERIOD_M15, highestBar15M);
|
|
activeSetup.swingLow = iLow(Symbol(), PERIOD_M15, lowestBar15M);
|
|
|
|
double range15M = activeSetup.swingHigh - activeSetup.swingLow;
|
|
activeSetup.fib1278Level = activeSetup.swingHigh - (range15M * Fib1278);
|
|
|
|
double low15M_0 = iLow(Symbol(), PERIOD_M15, 0);
|
|
double tolerance15M = 5 * SymbolInfoDouble(Symbol(), SYMBOL_POINT) * 10;
|
|
|
|
if(!(low15M_0 <= activeSetup.fib1278Level + tolerance15M)) return;
|
|
|
|
// 1H Trend filter
|
|
if(GetTrendDirection(PERIOD_H1) == -1) return;
|
|
|
|
// Divergence check
|
|
if(!BullishDivergenceOnTimeframe(PERIOD_M15)) return;
|
|
|
|
// Momentum score
|
|
if(CalculateMomentumScore() < MomentumThreshold) return;
|
|
|
|
// 5M Precision entry
|
|
if(Check5MPrecisionEntry())
|
|
{
|
|
Print("127.8% entry executed!");
|
|
}
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| 5M PRECISION ENTRY WITH STYLE SWITCH |
|
|
//+------------------------------------------------------------------+
|
|
bool Check5MPrecisionEntry()
|
|
{
|
|
double low5M_0 = iLow(Symbol(), PERIOD_M5, 0);
|
|
double low5M_1 = iLow(Symbol(), PERIOD_M5, 1);
|
|
double close5M_0 = iClose(Symbol(), PERIOD_M5, 0);
|
|
double close5M_1 = iClose(Symbol(), PERIOD_M5, 1);
|
|
double open5M_0 = iOpen(Symbol(), PERIOD_M5, 0);
|
|
double high5M_0 = iHigh(Symbol(), PERIOD_M5, 0);
|
|
double high5M_1 = iHigh(Symbol(), PERIOD_M5, 1);
|
|
|
|
double tolerance5M = 3 * SymbolInfoDouble(Symbol(), SYMBOL_POINT) * 10;
|
|
|
|
if(!(low5M_0 <= activeSetup.fib1278Level + tolerance5M ||
|
|
low5M_1 <= activeSetup.fib1278Level + tolerance5M)) return false;
|
|
|
|
// AGGRESSIVE MODE
|
|
if(EntryMode == STYLE_AGGRESSIVE)
|
|
{
|
|
bool quickBounce = (low5M_0 <= activeSetup.fib1278Level + tolerance5M && close5M_0 > open5M_0);
|
|
bool longWick = ((MathMin(close5M_0, open5M_0) - low5M_0) > MathAbs(close5M_0 - open5M_0) * 1.5);
|
|
|
|
double stochMain[];
|
|
ArraySetAsSeries(stochMain, true);
|
|
int stochHandle = iStochastic(Symbol(), PERIOD_M5, 14, 3, 3, MODE_SMA, STO_LOWHIGH);
|
|
CopyBuffer(stochHandle, 0, 0, 2, stochMain);
|
|
bool stochTurning = (stochMain[0] > stochMain[1] && stochMain[1] < 30);
|
|
|
|
int aggSignals = (quickBounce ? 1 : 0) + (longWick ? 1 : 0) + (stochTurning ? 1 : 0);
|
|
if(aggSignals >= 2)
|
|
return Execute5MEntry("1278_5M_Aggressive", 8);
|
|
}
|
|
|
|
// CONSERVATIVE MODE
|
|
else
|
|
{
|
|
bool bullishClose = (close5M_0 > open5M_0);
|
|
bool abovePrevious = (close5M_0 > high5M_1);
|
|
|
|
double microResistance = iHigh(Symbol(), PERIOD_M5, iHighest(Symbol(), PERIOD_M5, MODE_HIGH, 3, 1));
|
|
bool brokeResistance = (close5M_0 > microResistance);
|
|
|
|
double stochMain[], stochSignal[];
|
|
ArraySetAsSeries(stochMain, true);
|
|
ArraySetAsSeries(stochSignal, true);
|
|
int stochHandle = iStochastic(Symbol(), PERIOD_M5, 14, 3, 3, MODE_SMA, STO_LOWHIGH);
|
|
CopyBuffer(stochHandle, 0, 0, 2, stochMain);
|
|
CopyBuffer(stochHandle, 1, 0, 2, stochSignal);
|
|
bool stochCross = (stochMain[0] > stochSignal[0] && stochMain[1] <= stochSignal[1]);
|
|
|
|
double cci[];
|
|
ArraySetAsSeries(cci, true);
|
|
int cciHandle = iCCI(Symbol(), PERIOD_M5, 20, PRICE_TYPICAL);
|
|
CopyBuffer(cciHandle, 0, 0, 2, cci);
|
|
bool cciCross = (cci[0] > cci[1] && cci[1] < -100);
|
|
|
|
int confSignals = (bullishClose ? 1 : 0) + (abovePrevious ? 1 : 0) +
|
|
(brokeResistance ? 1 : 0) + (stochCross ? 1 : 0) + (cciCross ? 1 : 0);
|
|
|
|
if(confSignals >= 3)
|
|
return Execute5MEntry("1278_5M_Conservative", 6);
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| EXECUTE 5M ENTRY |
|
|
//+------------------------------------------------------------------+
|
|
bool Execute5MEntry(string comment, int slPips)
|
|
{
|
|
double entryPrice = SymbolInfoDouble(Symbol(), SYMBOL_ASK);
|
|
double sl = NormalizeDouble(entryPrice - slPips * SymbolInfoDouble(Symbol(), SYMBOL_POINT) * 10, _Digits);
|
|
double tp = NormalizeDouble(activeSetup.swingHigh, _Digits);
|
|
double lots = (EntryMode == STYLE_AGGRESSIVE) ? FirstEntryLots * 0.9 : FirstEntryLots;
|
|
|
|
if(ExecuteTrade(ORDER_TYPE_BUY, lots, sl, tp, comment))
|
|
{
|
|
currentPhase = PHASE_1278_LONG;
|
|
activeSetup.entry1278Price = entryPrice;
|
|
activeSetup.swingEstablished = false;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| CHECK FOR PULLBACK SETUP (AFTER 127.8% MOVES UP) |
|
|
//+------------------------------------------------------------------+
|
|
void CheckForPullbackSetup()
|
|
{
|
|
if(!HasOpenPosition("1278")) { ResetToPhaseNone(); return; }
|
|
|
|
double recentHigh = iHigh(Symbol(), PERIOD_M5, iHighest(Symbol(), PERIOD_M5, MODE_HIGH, 15, 0));
|
|
double moveUp = recentHigh - activeSetup.entry1278Price;
|
|
double minMove = 20 * SymbolInfoDouble(Symbol(), SYMBOL_POINT) * 10;
|
|
|
|
if(moveUp >= minMove)
|
|
{
|
|
activeSetup.newSwingHigh = recentHigh;
|
|
activeSetup.swingEstablished = true;
|
|
currentPhase = PHASE_618_ADDON;
|
|
Print("Swing established at ", recentHigh, " - waiting for 61.8% pullback");
|
|
}
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| 61.8% ADD-ON ENTRY |
|
|
//+------------------------------------------------------------------+
|
|
void Check618AddonEntry()
|
|
{
|
|
if(!activeSetup.swingEstablished) return;
|
|
|
|
double upMove = activeSetup.newSwingHigh - activeSetup.entry1278Price;
|
|
double fib618Level = activeSetup.newSwingHigh - (upMove * Fib618);
|
|
double fib786Level = activeSetup.newSwingHigh - (upMove * 0.786);
|
|
|
|
double close15M = iClose(Symbol(), PERIOD_M15, 0);
|
|
double low15M = iLow(Symbol(), PERIOD_M15, 0);
|
|
double tolerance = 5 * SymbolInfoDouble(Symbol(), SYMBOL_POINT) * 10;
|
|
|
|
if(!(low15M <= fib618Level + tolerance && low15M >= fib786Level - tolerance)) return;
|
|
|
|
if(!Check5M_618Entry(fib618Level, fib786Level)) return;
|
|
|
|
double entryPrice = SymbolInfoDouble(Symbol(), SYMBOL_ASK);
|
|
double sl = NormalizeDouble(activeSetup.entry1278Price - 5 * SymbolInfoDouble(Symbol(), SYMBOL_POINT) * 10, _Digits);
|
|
double tp = NormalizeDouble(activeSetup.newSwingHigh + (upMove * 0.5), _Digits);
|
|
|
|
if(ExecuteTrade(ORDER_TYPE_BUY, SecondEntryLots, sl, tp, "618_Addon"))
|
|
{
|
|
activeSetup.pullbackLow = low15M;
|
|
Print("61.8% add-on executed at ", entryPrice);
|
|
}
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| 5M 61.8% ENTRY WITH STYLE |
|
|
//+------------------------------------------------------------------+
|
|
bool Check5M_618Entry(double fib618, double fib786)
|
|
{
|
|
double close5M_0 = iClose(Symbol(), PERIOD_M5, 0);
|
|
double close5M_1 = iClose(Symbol(), PERIOD_M5, 1);
|
|
double low5M_0 = iLow(Symbol(), PERIOD_M5, 0);
|
|
double low5M_1 = iLow(Symbol(), PERIOD_M5, 1);
|
|
double open5M_0 = iOpen(Symbol(), PERIOD_M5, 0);
|
|
double high5M_1 = iHigh(Symbol(), PERIOD_M5, 1);
|
|
|
|
double tolerance = 3 * SymbolInfoDouble(Symbol(), SYMBOL_POINT) * 10;
|
|
|
|
bool inZone = (low5M_0 <= fib618 + tolerance && low5M_0 >= fib786 - tolerance);
|
|
if(!inZone) return false;
|
|
|
|
if(EntryMode == STYLE_AGGRESSIVE)
|
|
{
|
|
bool doubleBottom = (MathAbs(low5M_0 - low5M_1) < tolerance * 2);
|
|
bool quickBounce = (low5M_0 <= fib618 && close5M_0 > open5M_0);
|
|
bool hammer = ((MathMin(close5M_0, open5M_0) - low5M_0) > MathAbs(close5M_0 - open5M_0) * 2);
|
|
|
|
int aggCount = (doubleBottom ? 1 : 0) + (quickBounce ? 1 : 0) + (hammer ? 1 : 0);
|
|
return (aggCount >= 2);
|
|
}
|
|
else
|
|
{
|
|
double low5M_2 = iLow(Symbol(), PERIOD_M5, 2);
|
|
bool higherLow = (low5M_0 > low5M_1 && low5M_1 > low5M_2);
|
|
bool closeStrong = (close5M_0 > high5M_1);
|
|
|
|
double microRes = iHigh(Symbol(), PERIOD_M5, iHighest(Symbol(), PERIOD_M5, MODE_HIGH, 5, 1));
|
|
bool brokeRes = (close5M_0 > microRes);
|
|
bool momentumOK = BullishDivergenceOnTimeframe(PERIOD_M5);
|
|
|
|
int confCount = (higherLow ? 1 : 0) + (closeStrong ? 1 : 0) + (brokeRes ? 1 : 0) + (momentumOK ? 1 : 0);
|
|
return (confCount >= 3);
|
|
}
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| DIVERGENCE CHECKER (Stoch RSI + CCI) |
|
|
//+------------------------------------------------------------------+
|
|
bool BullishDivergenceOnTimeframe(ENUM_TIMEFRAMES tf)
|
|
{
|
|
double low1 = iLow(Symbol(), tf, 5);
|
|
double low2 = iLow(Symbol(), tf, 1);
|
|
if(low2 >= low1) return false;
|
|
|
|
double stochMain[];
|
|
ArraySetAsSeries(stochMain, true);
|
|
int stochHandle = iStochastic(Symbol(), tf, 14, 3, 3, MODE_SMA, STO_LOWHIGH);
|
|
if(CopyBuffer(stochHandle, 0, 0, 10, stochMain) < 10) return false;
|
|
|
|
double cci[];
|
|
ArraySetAsSeries(cci, true);
|
|
int cciHandle = iCCI(Symbol(), tf, 20, PRICE_TYPICAL);
|
|
if(CopyBuffer(cciHandle, 0, 0, 10, cci) < 10) return false;
|
|
|
|
return (stochMain[1] > stochMain[5] && cci[1] > cci[5]);
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| MOMENTUM SCORE |
|
|
//+------------------------------------------------------------------+
|
|
int CalculateMomentumScore()
|
|
{
|
|
int score = 0;
|
|
|
|
double rsi = iRSI(Symbol(), PERIOD_M15, 14, PRICE_CLOSE, 0);
|
|
if(rsi < 30) score += (int)MathMin((30 - rsi) * 1.2, 25);
|
|
|
|
double open = iOpen(Symbol(), PERIOD_M15, 0);
|
|
double high = iHigh(Symbol(), PERIOD_M15, 0);
|
|
double low = iLow(Symbol(), PERIOD_M15, 0);
|
|
double close = iClose(Symbol(), PERIOD_M15, 0);
|
|
|
|
double body = MathAbs(close - open);
|
|
double lowerWick = MathMin(close, open) - low;
|
|
if(body > 0 && lowerWick / body > 2.0) score += 25;
|
|
|
|
double stochMain[];
|
|
ArraySetAsSeries(stochMain, true);
|
|
int stochHandle = iStochastic(Symbol(), PERIOD_M15, 14, 3, 3, MODE_SMA, STO_LOWHIGH);
|
|
CopyBuffer(stochHandle, 0, 0, 1, stochMain);
|
|
if(stochMain[0] < 15) score += 20;
|
|
|
|
double cci[];
|
|
ArraySetAsSeries(cci, true);
|
|
int cciHandle = iCCI(Symbol(), PERIOD_M15, 20, PRICE_TYPICAL);
|
|
CopyBuffer(cciHandle, 0, 0, 1, cci);
|
|
if(cci[0] < -150) score += 20;
|
|
else if(cci[0] < -100) score += 10;
|
|
|
|
double vwap = iMA(Symbol(), PERIOD_M15, 20, 0, MODE_SMA, PRICE_TYPICAL, 0);
|
|
double distance = MathAbs(close - vwap) / vwap * 100;
|
|
score += (int)MathMin(distance * 2, 10);
|
|
|
|
return score;
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| TREND DIRECTION |
|
|
//+------------------------------------------------------------------+
|
|
int GetTrendDirection(ENUM_TIMEFRAMES tf)
|
|
{
|
|
double ma50 = iMA(Symbol(), tf, 50, 0, MODE_SMA, PRICE_CLOSE, 0);
|
|
double ma200 = iMA(Symbol(), tf, 200, 0, MODE_SMA, PRICE_CLOSE, 0);
|
|
double close = iClose(Symbol(), tf, 0);
|
|
|
|
if(close > ma50 && ma50 > ma200) return 1;
|
|
if(close < ma50 && ma50 < ma200) return -1;
|
|
return 0;
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| POSITION MANAGEMENT |
|
|
//+------------------------------------------------------------------+
|
|
void ManagePositions()
|
|
{
|
|
bool has1278 = false, has618 = false;
|
|
double avgEntry = 0, totalLots = 0;
|
|
|
|
for(int i = PositionsTotal() - 1; i >= 0; i--)
|
|
{
|
|
ulong ticket = PositionGetTicket(i);
|
|
if(ticket <= 0) continue;
|
|
if(PositionGetString(POSITION_SYMBOL) != Symbol()) continue;
|
|
|
|
string comment = PositionGetString(POSITION_COMMENT);
|
|
int posType = (int)PositionGetInteger(POSITION_TYPE);
|
|
double lots = PositionGetDouble(POSITION_VOLUME);
|
|
double openPrice = PositionGetDouble(POSITION_PRICE_OPEN);
|
|
|
|
if(StringFind(comment, "1278") != -1) has1278 = true;
|
|
if(StringFind(comment, "618") != -1) has618 = true;
|
|
|
|
avgEntry += openPrice * lots;
|
|
totalLots += lots;
|
|
|
|
ManageSinglePosition(ticket, posType, openPrice);
|
|
}
|
|
|
|
if(totalLots > 0) avgEntry /= totalLots;
|
|
|
|
if(has1278 && has618)
|
|
ManageAveragedPosition(avgEntry, totalLots);
|
|
|
|
if(!has1278 && !has618 && currentPhase != PHASE_NONE)
|
|
ResetToPhaseNone();
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| SINGLE POSITION MANAGEMENT |
|
|
//+------------------------------------------------------------------+
|
|
void ManageSinglePosition(ulong ticket, int posType, double openPrice)
|
|
{
|
|
double currentSL = PositionGetDouble(POSITION_SL);
|
|
double currentTP = PositionGetDouble(POSITION_TP);
|
|
|
|
double currentPrice = (posType == POSITION_TYPE_BUY) ?
|
|
SymbolInfoDouble(Symbol(), SYMBOL_BID) :
|
|
SymbolInfoDouble(Symbol(), SYMBOL_ASK);
|
|
|
|
double profitPips = MathAbs(currentPrice - openPrice) /
|
|
(SymbolInfoDouble(Symbol(), SYMBOL_POINT) * 10);
|
|
|
|
// Break even at 15 pips
|
|
if(profitPips >= 15 && currentSL == 0)
|
|
{
|
|
double newSL = openPrice + 2 * SymbolInfoDouble(Symbol(), SYMBOL_POINT) * 10;
|
|
ModifyPosition(ticket, NormalizeDouble(newSL, _Digits), currentTP);
|
|
}
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| AVERAGED POSITION MANAGEMENT |
|
|
//+------------------------------------------------------------------+
|
|
void ManageAveragedPosition(double avgPrice, double totalLots)
|
|
{
|
|
for(int i = PositionsTotal() - 1; i >= 0; i--)
|
|
{
|
|
ulong ticket = PositionGetTicket(i);
|
|
if(ticket <= 0) continue;
|
|
if(PositionGetString(POSITION_SYMBOL) != Symbol()) continue;
|
|
|
|
int posType = (int)PositionGetInteger(POSITION_TYPE);
|
|
double currentSL = PositionGetDouble(POSITION_SL);
|
|
double currentTP = PositionGetDouble(POSITION_TP);
|
|
|
|
double currentPrice = SymbolInfoDouble(Symbol(), SYMBOL_BID);
|
|
double profitPips = MathAbs(currentPrice - avgPrice) /
|
|
(SymbolInfoDouble(Symbol(), SYMBOL_POINT) * 10);
|
|
|
|
// Breakeven both at +10 pips averaged
|
|
if(profitPips >= 10 && currentSL < avgPrice)
|
|
{
|
|
double newSL = avgPrice + 2 * SymbolInfoDouble(Symbol(), SYMBOL_POINT) * 10;
|
|
ModifyPosition(ticket, NormalizeDouble(newSL, _Digits), currentTP);
|
|
}
|
|
|
|
// Trail at structure when +40 pips
|
|
if(profitPips >= 40)
|
|
{
|
|
double newSL = GetStructureLevel(PERIOD_M15);
|
|
double buffer = 3 * SymbolInfoDouble(Symbol(), SYMBOL_POINT) * 10;
|
|
|
|
if(newSL > currentSL)
|
|
ModifyPosition(ticket, NormalizeDouble(newSL - buffer, _Digits), currentTP);
|
|
}
|
|
}
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| GET STRUCTURE LEVEL |
|
|
//+------------------------------------------------------------------+
|
|
double GetStructureLevel(ENUM_TIMEFRAMES tf)
|
|
{
|
|
int lowest = iLowest(Symbol(), tf, MODE_LOW, 10, 1);
|
|
return iLow(Symbol(), tf, lowest);
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| EXECUTE TRADE |
|
|
//+------------------------------------------------------------------+
|
|
bool ExecuteTrade(int direction, double lots, double sl, double tp, string comment)
|
|
{
|
|
MqlTradeRequest request = {};
|
|
MqlTradeResult result = {};
|
|
|
|
double price = (direction == ORDER_TYPE_SELL) ?
|
|
SymbolInfoDouble(Symbol(), SYMBOL_BID) :
|
|
SymbolInfoDouble(Symbol(), SYMBOL_ASK);
|
|
|
|
request.action = TRADE_ACTION_DEAL;
|
|
request.symbol = Symbol();
|
|
request.volume = lots;
|
|
request.type = direction;
|
|
request.price = price;
|
|
request.sl = sl;
|
|
request.tp = tp;
|
|
request.deviation = 10;
|
|
request.magic = 123456;
|
|
request.comment = comment;
|
|
|
|
if(!OrderSend(request, result))
|
|
{
|
|
Print("OrderSend failed: ", GetLastError());
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| MODIFY POSITION |
|
|
//+------------------------------------------------------------------+
|
|
bool ModifyPosition(ulong ticket, double sl, double tp)
|
|
{
|
|
MqlTradeRequest request = {};
|
|
MqlTradeResult result = {};
|
|
|
|
request.action = TRADE_ACTION_SLTP;
|
|
request.position = ticket;
|
|
request.symbol = Symbol();
|
|
request.sl = sl;
|
|
request.tp = tp;
|
|
|
|
return OrderSend(request, result);
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| CHECK IF HAS OPEN POSITION |
|
|
//+------------------------------------------------------------------+
|
|
bool HasOpenPosition(string keyword)
|
|
{
|
|
for(int i = PositionsTotal() - 1; i >= 0; i--)
|
|
{
|
|
ulong ticket = PositionGetTicket(i);
|
|
if(ticket <= 0) continue;
|
|
if(PositionGetString(POSITION_SYMBOL) != Symbol()) continue;
|
|
|
|
string comment = PositionGetString(POSITION_COMMENT);
|
|
if(StringFind(comment, keyword) != -1) return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| RESET SETUP |
|
|
//+------------------------------------------------------------------+
|
|
void ResetToPhaseNone()
|
|
{
|
|
currentPhase = PHASE_NONE;
|
|
activeSetup.swingHigh = 0;
|
|
activeSetup.swingLow = 0;
|
|
activeSetup.fib1278Level = 0;
|
|
activeSetup.entry1278Price = 0;
|
|
activeSetup.newSwingHigh = 0;
|
|
activeSetup.swingEstablished = false;
|
|
Print("Setup reset - hunting for new 127.8% opportunity");
|
|
}
|
|
//+------------------------------------------------------------------+
|