ironsan2kk-pixel
1264 lines
76 KiB
Plaintext
1264 lines
76 KiB
Plaintext
// ★★★ EA_SingleLogic_LongShort ★★★
|
||
//---------------------------------------------
|
||
// (1) Input parameters
|
||
//---------------------------------------------
|
||
// --- Parameters for Magic_A
|
||
input double SARStep = 0.001; // SAR acceleration factor increment
|
||
input double SARMaxStep = 0.2; // Maximum SAR acceleration factor
|
||
input double TPPips = 90; // Take Profit in pips
|
||
input double SLPips = 70; // Stop Loss in pips
|
||
// Retry control parameters
|
||
extern int RetryCount = 3; // Number of retry attempts
|
||
extern int RetryIntervalMs = 1000; // Retry interval (milliseconds)
|
||
// --- Trailing stop settings
|
||
input bool UseTrailingStop = true; // true = enable trailing stop
|
||
input int TrailStepProfit = 30; // Trail activation profit (pips)
|
||
input int TrailShiftPips = 5; // Shift TP and SL by this many pips
|
||
// --- Fixed lot or compound lot selection
|
||
input bool UseCompoundLots = true; // true = compound, false = fixed lot
|
||
input double TargetMarginPercent = 5.0; // Target margin usage (% of balance)
|
||
extern double MarginLevelAlert = 250.0; // Margin level alert threshold (%)
|
||
// --- Trading hour restriction
|
||
input bool UseTradingHour = true; // true = restrict trading hours
|
||
input int TradingStartUTC = 7; // Trading start hour (UTC)
|
||
input int TradingEndUTC = 19; // Trading end hour (UTC, exclusive)
|
||
// --- EA status notification settings
|
||
extern bool NotifyEAStatus = true; // true = send status notifications
|
||
extern int StatusIntervalMin = 60; // Notification interval (minutes)
|
||
// --- Other settings
|
||
input double MaxSpreadPips = 3.0; // Maximum allowed spread (pips)
|
||
input int SlippagePips = 3; // Slippage (pips)
|
||
input double LotSize = 0.1; // Fixed lot size (for non-compound mode)
|
||
input int MaxOpenBuyPositions = 1; // Maximum BUY positions
|
||
input int MaxOpenSellPositions = 1; // Maximum SELL positions
|
||
|
||
#define BROKER_GMT_OFFSET_HOURS 2
|
||
|
||
//---------------------------------------------
|
||
// (2) Magic number
|
||
//---------------------------------------------
|
||
input int Magic_A = 67890;
|
||
|
||
//---------------------------------------------
|
||
// (3) Internal state variables
|
||
//---------------------------------------------
|
||
datetime prevTime_A = 0;
|
||
datetime lastEntryBarA = 0; // Bar time of the last entry (Magic_A)
|
||
datetime lastStatusSend = 0; // Last EA status notification time
|
||
bool EmergencyStop = false; // Emergency stop flag (internal)
|
||
bool EmergencyLatched = false; // Indicates if an emergency has ever occurred
|
||
// Exit latch counters
|
||
int buyExitTickCount = 0;
|
||
int sellExitTickCount = 0;
|
||
const int ExitTickThreshold = 5; // Required consecutive ticks
|
||
|
||
//---------------------------------------------
|
||
// (4) ENUM: Exit / Entry signals
|
||
//---------------------------------------------
|
||
enum SignalType
|
||
{
|
||
NO_SIGNAL = 0,
|
||
BUY_ENTRY,
|
||
BUY_EXIT,
|
||
SELL_ENTRY,
|
||
SELL_EXIT
|
||
};
|
||
|
||
//---------------------------------------------
|
||
// (5) Time utility functions (DST / UTC / trading hours)
|
||
//---------------------------------------------
|
||
// Assumes broker server time is UTC+2 (winter) / UTC+3 (summer)
|
||
|
||
// --- Daylight Saving Time detection (simplified, Northern Hemisphere)
|
||
bool IsDST(datetime t)
|
||
{
|
||
int year = TimeYear(t);
|
||
|
||
// Last Sunday of March
|
||
datetime marchLastSunday = StrToTime(StringFormat("%d.03.%d 02:00", year, 31));
|
||
while (TimeDayOfWeek(marchLastSunday) != 0)
|
||
marchLastSunday -= 86400;
|
||
|
||
// Last Sunday of October
|
||
datetime octLastSunday = StrToTime(StringFormat("%d.10.%d 03:00", year, 31));
|
||
while (TimeDayOfWeek(octLastSunday) != 0)
|
||
octLastSunday -= 86400;
|
||
|
||
return (t >= marchLastSunday && t < octLastSunday);
|
||
}
|
||
|
||
// --- Get current UTC hour (with DST adjustment)
|
||
int GetUTCHour()
|
||
{
|
||
datetime t = TimeCurrent();
|
||
int hour = TimeHour(t) - BROKER_GMT_OFFSET_HOURS;
|
||
|
||
if (IsDST(t))
|
||
hour -= 1; // Adjust for DST
|
||
|
||
if (hour < 0) hour += 24;
|
||
return hour;
|
||
}
|
||
|
||
// --- Trading hour check (can be enabled or disabled)
|
||
bool IsTradingHour()
|
||
{
|
||
if (!UseTradingHour) return true;
|
||
|
||
int utcHour = GetUTCHour();
|
||
return (utcHour >= TradingStartUTC && utcHour < TradingEndUTC);
|
||
}
|
||
|
||
//---------------------------------------------
|
||
// (6) New bar detection
|
||
//---------------------------------------------
|
||
bool IsNewBar(int timeframe, datetime &lastBarTime)
|
||
{
|
||
datetime currentBar = iTime(Symbol(), timeframe, 0);
|
||
if (currentBar != lastBarTime)
|
||
{
|
||
lastBarTime = currentBar;
|
||
return true;
|
||
}
|
||
return false;
|
||
}
|
||
|
||
//---------------------------------------------
|
||
// (7) Pip size calculation
|
||
//---------------------------------------------
|
||
double Pip()
|
||
{
|
||
return (Digits == 5 || Digits == 3) ? Point * 10 : Point;
|
||
}
|
||
|
||
//---------------------------------------------
|
||
// Convert pips to points (for slippage)
|
||
int PipToPoint(double pips)
|
||
{
|
||
return (int)MathRound(pips * Pip() / Point);
|
||
}
|
||
|
||
//---------------------------------------------
|
||
// (8) Lot size calculation: compound mode or fixed-lot mode
|
||
//---------------------------------------------
|
||
double CalculateLotSize()
|
||
{
|
||
if (!UseCompoundLots)
|
||
{
|
||
// Fixed-lot mode
|
||
double SlotStep = MarketInfo(_Symbol, MODE_LOTSTEP);
|
||
double SminLot = MarketInfo(_Symbol, MODE_MINLOT);
|
||
double SmaxLot = MarketInfo(_Symbol, MODE_MAXLOT);
|
||
|
||
double fixedLot = LotSize;
|
||
|
||
// Clamp to broker limits
|
||
double SadjustedLotSize = MathMax(SminLot, MathMin(fixedLot, SmaxLot));
|
||
|
||
// Align to lot step
|
||
SadjustedLotSize = MathFloor(SadjustedLotSize / SlotStep) * SlotStep;
|
||
|
||
return SadjustedLotSize;
|
||
}
|
||
|
||
// Compound mode (margin-based)
|
||
double accountBalance = AccountBalance();
|
||
double ClotStep = MarketInfo(_Symbol, MODE_LOTSTEP);
|
||
double CminLot = MarketInfo(_Symbol, MODE_MINLOT);
|
||
double CmaxLot = MarketInfo(_Symbol, MODE_MAXLOT);
|
||
double marginRequiredPerLot = MarketInfo(_Symbol, MODE_MARGINREQUIRED);
|
||
|
||
// -------------------------------------------------------
|
||
// Defensive: if margin information cannot be obtained due to broker specifications or symbol limitations,
|
||
// place an order using the symbol's minimum lot and log a warning.
|
||
// -------------------------------------------------------
|
||
if (marginRequiredPerLot <= 0.0)
|
||
{
|
||
PrintFormat(
|
||
"⚠ CalculateLotSize: invalid MODE_MARGINREQUIRED (%.5f). "
|
||
"Fallback to MINLOT=%.2f",
|
||
marginRequiredPerLot,
|
||
CminLot
|
||
);
|
||
return CminLot;
|
||
}
|
||
|
||
double targetMargin = accountBalance * TargetMarginPercent / 100.0;
|
||
double maxLotForMargin = targetMargin / marginRequiredPerLot;
|
||
|
||
double calculatedLotSize =
|
||
MathFloor(maxLotForMargin / ClotStep) * ClotStep;
|
||
|
||
double CadjustedLotSize =
|
||
MathMax(CminLot, MathMin(calculatedLotSize, CmaxLot));
|
||
|
||
return CadjustedLotSize;
|
||
}
|
||
|
||
//---------------------------------------------
|
||
// (9) Margin level check (anti-spam notification)
|
||
//---------------------------------------------
|
||
void CheckMarginLevel()
|
||
{
|
||
// Alert state (static to persist across ticks)
|
||
static bool alerted = false;
|
||
|
||
// No positions → no alert
|
||
if (OrdersTotal() == 0)
|
||
{
|
||
alerted = false;
|
||
return;
|
||
}
|
||
|
||
double margin = AccountMargin();
|
||
if (margin == 0)
|
||
{
|
||
alerted = false;
|
||
return;
|
||
}
|
||
|
||
double marginLevel = (AccountEquity() / margin) * 100.0;
|
||
|
||
// Alert trigger
|
||
if (marginLevel <= MarginLevelAlert && !alerted)
|
||
{
|
||
string timeStr = TimeToString(TimeCurrent(), TIME_DATE | TIME_SECONDS);
|
||
|
||
string msg =
|
||
"[EA_SingleLogic_LongShort]\n"
|
||
"● Margin level below threshold ●\n"
|
||
"Symbol: " + Symbol() + "\n"
|
||
"Time: " + timeStr + "\n"
|
||
"Threshold: " + DoubleToString(MarginLevelAlert, 1) + "%\n"
|
||
"Current: " + DoubleToString(marginLevel, 1) + "%";
|
||
|
||
Print(msg);
|
||
SendNotification(msg);
|
||
|
||
alerted = true;
|
||
}
|
||
|
||
// Reset alert once margin recovers
|
||
if (marginLevel > MarginLevelAlert)
|
||
{
|
||
alerted = false;
|
||
}
|
||
}
|
||
|
||
//---------------------------------------------
|
||
// (10) EA runtime status notification
|
||
//---------------------------------------------
|
||
void CheckEAStatus()
|
||
{
|
||
if (!NotifyEAStatus) return;
|
||
|
||
if (TimeCurrent() - lastStatusSend >= StatusIntervalMin * 60)
|
||
{
|
||
string msg =
|
||
"[EA_SingleLogic_LongShort is running]\n" +
|
||
"Time: " + TimeToString(TimeCurrent(), TIME_SECONDS);
|
||
|
||
SendNotification(msg);
|
||
Print(msg);
|
||
|
||
lastStatusSend = TimeCurrent();
|
||
}
|
||
}
|
||
|
||
//---------------------------------------------
|
||
// (11) Count open positions by type
|
||
// type: OP_BUY or OP_SELL
|
||
//---------------------------------------------
|
||
int CountOrdersByTypeThisEA(int type)
|
||
{
|
||
int count = 0;
|
||
|
||
for (int i = OrdersTotal() - 1; i >= 0; i--)
|
||
{
|
||
if (OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
|
||
{
|
||
if (OrderSymbol() == Symbol() &&
|
||
OrderMagicNumber() == Magic_A &&
|
||
OrderType() == type)
|
||
{
|
||
count++;
|
||
}
|
||
}
|
||
}
|
||
|
||
return count;
|
||
}
|
||
|
||
//---------------------------------------------
|
||
// (12) Check if a new BUY order can be placed
|
||
// (emergency stop aware)
|
||
//---------------------------------------------
|
||
bool CanPlaceNewBuy()
|
||
{
|
||
if (EmergencyStop)
|
||
return false;
|
||
|
||
return CountOrdersByTypeThisEA(OP_BUY) < MaxOpenBuyPositions;
|
||
}
|
||
|
||
//---------------------------------------------
|
||
// (13) Check if a new SELL order can be placed
|
||
// (emergency stop aware)
|
||
//---------------------------------------------
|
||
bool CanPlaceNewSell()
|
||
{
|
||
if (EmergencyStop)
|
||
return false;
|
||
|
||
return CountOrdersByTypeThisEA(OP_SELL) < MaxOpenSellPositions;
|
||
}
|
||
|
||
//---------------------------------------------
|
||
// (14) Exit signal logic (BUY and SELL)
|
||
//---------------------------------------------
|
||
SignalType ExitSignalA()
|
||
{
|
||
double SAR0 = iSAR(_Symbol, 0, SARStep, SARMaxStep, 0);
|
||
double SAR1 = iSAR(_Symbol, 0, SARStep, SARMaxStep, 1);
|
||
double SAR2 = iSAR(_Symbol, 0, SARStep, SARMaxStep, 2);
|
||
|
||
// BUY exit conditions
|
||
if ((Low[1] > SAR1 && Close[0] <= SAR0) ||
|
||
(High[2] < SAR2 && High[1] < SAR1 && High[0] < SAR0))
|
||
{
|
||
buyExitTickCount++;
|
||
}
|
||
else
|
||
{
|
||
buyExitTickCount = 0;
|
||
}
|
||
|
||
// SELL exit conditions
|
||
if ((High[1] < SAR1 && Close[0] >= SAR0) ||
|
||
(Low[2] > SAR2 && Low[1] > SAR1 && Low[0] > SAR0))
|
||
{
|
||
sellExitTickCount++;
|
||
}
|
||
else
|
||
{
|
||
sellExitTickCount = 0;
|
||
}
|
||
|
||
// Return EXIT signal once latch threshold is reached
|
||
if (buyExitTickCount >= ExitTickThreshold) return BUY_EXIT;
|
||
if (sellExitTickCount >= ExitTickThreshold) return SELL_EXIT;
|
||
|
||
return NO_SIGNAL;
|
||
}
|
||
|
||
//---------------------------------------------
|
||
// (15) Entry signal logic (BUY and SELL)
|
||
//---------------------------------------------
|
||
SignalType EntrySignalA()
|
||
{
|
||
double SAR1 = iSAR(_Symbol, 0, SARStep, SARMaxStep, 1);
|
||
double SAR2 = iSAR(_Symbol, 0, SARStep, SARMaxStep, 2);
|
||
double SAR3 = iSAR(_Symbol, 0, SARStep, SARMaxStep, 3);
|
||
|
||
// BUY entry conditions
|
||
if ((High[2] < SAR2 && Close[1] >= SAR1) ||
|
||
(Low[3] > SAR3 && Low[2] > SAR2 && Low[1] > SAR1))
|
||
{
|
||
return BUY_ENTRY;
|
||
}
|
||
|
||
// SELL entry conditions
|
||
if ((Low[2] > SAR2 && Close[1] <= SAR1) ||
|
||
(High[3] < SAR3 && High[2] < SAR2 && High[1] < SAR1))
|
||
{
|
||
return SELL_ENTRY;
|
||
}
|
||
|
||
return NO_SIGNAL;
|
||
}
|
||
|
||
// ---------------------------------------------
|
||
// (16) RetryManager (single-task model)
|
||
// ---------------------------------------------
|
||
// Retry task types
|
||
enum RetryTaskType {
|
||
TASK_NONE = 0,
|
||
TASK_ENTRY,
|
||
TASK_EXIT,
|
||
TASK_MODIFY
|
||
};
|
||
|
||
// RetryTask structure
|
||
struct RetryTask {
|
||
RetryTaskType taskType;
|
||
int ticket; // Used for Exit / Modify
|
||
int orderType; // Entry: OP_BUY / OP_SELL
|
||
double lots;
|
||
double price; // Stored entry price (actual execution uses market price)
|
||
double sl;
|
||
double tp;
|
||
int slippage;
|
||
int retryLeft;
|
||
int lastAttemptMs;
|
||
};
|
||
|
||
// Global: single active retry task
|
||
RetryTask currentTask = { TASK_NONE };
|
||
|
||
// ---------------------------
|
||
// (17) EXIT-only queue (minimal implementation)
|
||
// ---------------------------
|
||
#define MAX_EXIT_QUEUE 20
|
||
|
||
RetryTask exitQueue[MAX_EXIT_QUEUE];
|
||
int exitQueueSize = 0;
|
||
|
||
bool PushExitQueue(const RetryTask &t)
|
||
{
|
||
if (exitQueueSize >= MAX_EXIT_QUEUE)
|
||
{
|
||
Print("❌ EXIT queue overflow");
|
||
return false;
|
||
}
|
||
|
||
exitQueue[exitQueueSize++] = t;
|
||
return true;
|
||
}
|
||
|
||
// EXIT queue helper functions
|
||
bool HasExitQueue()
|
||
{
|
||
return (exitQueueSize > 0);
|
||
}
|
||
|
||
RetryTask PopExitQueue()
|
||
{
|
||
RetryTask t = exitQueue[0];
|
||
|
||
for (int i = 1; i < exitQueueSize; i++)
|
||
exitQueue[i - 1] = exitQueue[i];
|
||
|
||
exitQueueSize--;
|
||
return t;
|
||
}
|
||
|
||
// ---------------------------
|
||
// (18) ResetCurrentTask
|
||
// ---------------------------
|
||
void ResetCurrentTask()
|
||
{
|
||
currentTask.taskType = TASK_NONE;
|
||
currentTask.ticket = 0;
|
||
currentTask.orderType = 0;
|
||
currentTask.lots = 0.0;
|
||
currentTask.price = 0.0;
|
||
currentTask.sl = 0.0;
|
||
currentTask.tp = 0.0;
|
||
currentTask.slippage = 0;
|
||
currentTask.retryLeft = 0;
|
||
currentTask.lastAttemptMs = 0;
|
||
}
|
||
|
||
// ---------------------------
|
||
// (19) RegisterRetryTask
|
||
// ---------------------------
|
||
bool RegisterRetryTask(const RetryTask &task)
|
||
{
|
||
if (currentTask.taskType != TASK_NONE)
|
||
{
|
||
PrintFormat(
|
||
"[RegisterRetryTask] Skip: another task active (exist=%d new=%d)",
|
||
currentTask.taskType,
|
||
task.taskType
|
||
);
|
||
return false;
|
||
}
|
||
|
||
currentTask = task;
|
||
currentTask.lastAttemptMs = 0; // Attempt immediately on next tick
|
||
|
||
PrintFormat(
|
||
"[RegisterRetryTask] Registered task type=%d ticket=%d",
|
||
currentTask.taskType,
|
||
currentTask.ticket
|
||
);
|
||
|
||
return true;
|
||
}
|
||
|
||
// ---------------------------
|
||
// (20) ProcessRetryTask
|
||
// ---------------------------
|
||
void ProcessRetryTask()
|
||
{
|
||
if (currentTask.taskType == TASK_NONE) return;
|
||
|
||
int now = GetTickCount();
|
||
|
||
// Wait until retry interval has elapsed
|
||
if (currentTask.lastAttemptMs != 0 &&
|
||
now - currentTask.lastAttemptMs < RetryIntervalMs)
|
||
{
|
||
return;
|
||
}
|
||
|
||
RefreshRates();
|
||
|
||
bool success = false;
|
||
int err = 0;
|
||
|
||
// ============================
|
||
// TASK_ENTRY
|
||
// ============================
|
||
if (currentTask.taskType == TASK_ENTRY)
|
||
{
|
||
// Always use the latest market price for entry
|
||
double execPrice = (currentTask.orderType == OP_BUY) ? Ask : Bid;
|
||
|
||
// Recalculate SL / TP based on execution price
|
||
double newSL, newTP;
|
||
if (currentTask.orderType == OP_BUY)
|
||
{
|
||
newSL = NormalizeDouble(execPrice - SLPips * Pip(), Digits);
|
||
newTP = NormalizeDouble(execPrice + TPPips * Pip(), Digits);
|
||
}
|
||
else
|
||
{
|
||
newSL = NormalizeDouble(execPrice + SLPips * Pip(), Digits);
|
||
newTP = NormalizeDouble(execPrice - TPPips * Pip(), Digits);
|
||
}
|
||
|
||
int ticket = OrderSend(
|
||
Symbol(),
|
||
currentTask.orderType,
|
||
currentTask.lots,
|
||
execPrice,
|
||
currentTask.slippage,
|
||
newSL,
|
||
newTP,
|
||
"Magic_A Entry",
|
||
Magic_A,
|
||
0,
|
||
clrOrange
|
||
);
|
||
|
||
if (ticket > 0)
|
||
{
|
||
success = true;
|
||
PrintFormat("✅ [Retry] Entry success: ticket=%d", ticket);
|
||
lastEntryBarA = iTime(Symbol(), PERIOD_CURRENT, 0);
|
||
}
|
||
else
|
||
{
|
||
err = GetLastError();
|
||
PrintFormat(
|
||
"❌ [Retry] Entry failed err=%d retryLeft=%d",
|
||
err,
|
||
currentTask.retryLeft
|
||
);
|
||
}
|
||
}
|
||
|
||
// ============================
|
||
// TASK_EXIT
|
||
// ============================
|
||
else if (currentTask.taskType == TASK_EXIT)
|
||
{
|
||
if (!OrderSelect(currentTask.ticket, SELECT_BY_TICKET))
|
||
{
|
||
// Order is already closed
|
||
success = true;
|
||
PrintFormat(
|
||
"ℹ [Retry] EXIT: ticket %d no longer exists -> treat as success",
|
||
currentTask.ticket
|
||
);
|
||
}
|
||
else
|
||
{
|
||
// Defensive handling for invalid lot size
|
||
if (currentTask.lots <= 0.0)
|
||
currentTask.lots = OrderLots();
|
||
|
||
int otype = OrderType();
|
||
double closePrice = (otype == OP_BUY) ? Bid : Ask;
|
||
|
||
bool closed = OrderClose(
|
||
currentTask.ticket,
|
||
currentTask.lots,
|
||
closePrice,
|
||
currentTask.slippage,
|
||
clrOrange
|
||
);
|
||
|
||
if (closed)
|
||
{
|
||
success = true;
|
||
PrintFormat(
|
||
"✅ [Retry] Exit success ticket=%d",
|
||
currentTask.ticket
|
||
);
|
||
}
|
||
else
|
||
{
|
||
err = GetLastError();
|
||
PrintFormat(
|
||
"❌ [Retry] Exit failed ticket=%d err=%d retryLeft=%d",
|
||
currentTask.ticket,
|
||
err,
|
||
currentTask.retryLeft
|
||
);
|
||
}
|
||
}
|
||
}
|
||
|
||
// ============================
|
||
// TASK_MODIFY
|
||
// ============================
|
||
else if (currentTask.taskType == TASK_MODIFY)
|
||
{
|
||
if (!OrderSelect(currentTask.ticket, SELECT_BY_TICKET))
|
||
{
|
||
// Order no longer exists
|
||
success = true;
|
||
PrintFormat(
|
||
"ℹ [Retry] MODIFY: ticket %d missing -> treat as success",
|
||
currentTask.ticket
|
||
);
|
||
}
|
||
else
|
||
{
|
||
double currOpen = OrderOpenPrice();
|
||
|
||
// Defensive correction for SL / TP values
|
||
double correctedSL =
|
||
(currentTask.sl <= 0) ? OrderStopLoss() : currentTask.sl;
|
||
double correctedTP =
|
||
(currentTask.tp <= 0) ? OrderTakeProfit() : currentTask.tp;
|
||
|
||
bool modified = OrderModify(
|
||
currentTask.ticket,
|
||
currOpen,
|
||
correctedSL,
|
||
correctedTP,
|
||
0,
|
||
clrAqua
|
||
);
|
||
|
||
if (modified)
|
||
{
|
||
success = true;
|
||
PrintFormat(
|
||
"✅ [Retry] Modify success ticket=%d",
|
||
currentTask.ticket
|
||
);
|
||
}
|
||
else
|
||
{
|
||
err = GetLastError();
|
||
PrintFormat(
|
||
"❌ [Retry] Modify failed ticket=%d err=%d retryLeft=%d",
|
||
currentTask.ticket,
|
||
err,
|
||
currentTask.retryLeft
|
||
);
|
||
}
|
||
}
|
||
}
|
||
|
||
// ============================
|
||
// Success handling
|
||
// ============================
|
||
if (success)
|
||
{
|
||
ResetCurrentTask();
|
||
return;
|
||
}
|
||
|
||
// ============================
|
||
// Error handling (retry or failure)
|
||
// ============================
|
||
bool transient = (
|
||
err == ERR_SERVER_BUSY ||
|
||
err == ERR_TRADE_CONTEXT_BUSY ||
|
||
err == ERR_PRICE_CHANGED ||
|
||
err == ERR_OFF_QUOTES ||
|
||
err == ERR_REQUOTE
|
||
);
|
||
|
||
if (transient && currentTask.retryLeft > 0)
|
||
{
|
||
currentTask.retryLeft--;
|
||
currentTask.lastAttemptMs = now;
|
||
|
||
PrintFormat(
|
||
"[Retry] transient error %d → retryLeft=%d",
|
||
err,
|
||
currentTask.retryLeft
|
||
);
|
||
return;
|
||
}
|
||
|
||
PrintFormat(
|
||
"[Retry] Task FAILED: type=%d ticket=%d err=%d",
|
||
currentTask.taskType,
|
||
currentTask.ticket,
|
||
err
|
||
);
|
||
|
||
ResetCurrentTask();
|
||
}
|
||
|
||
//---------------------------------------------
|
||
// (21) Exit handling (supports both BUY and SELL)
|
||
//---------------------------------------------
|
||
void HandleExitA(SignalType sig)
|
||
{
|
||
int slippagePoints = PipToPoint(SlippagePips);
|
||
|
||
// =======================
|
||
// BUY EXIT
|
||
// =======================
|
||
if (sig == BUY_EXIT)
|
||
{
|
||
for (int i = OrdersTotal() - 1; i >= 0; i--)
|
||
{
|
||
if (!OrderSelect(i, SELECT_BY_POS, MODE_TRADES)) continue;
|
||
|
||
if (OrderMagicNumber() == Magic_A &&
|
||
OrderSymbol() == _Symbol &&
|
||
OrderType() == OP_BUY)
|
||
{
|
||
RefreshRates(); // Fetch latest market prices
|
||
double BUYclosePrice = Bid;
|
||
|
||
RetryTask t;
|
||
t.taskType = TASK_EXIT;
|
||
t.ticket = OrderTicket();
|
||
t.lots = OrderLots();
|
||
t.price = BUYclosePrice; // ← added: reference close price
|
||
t.slippage = slippagePoints;
|
||
t.retryLeft = RetryCount;
|
||
|
||
if (PushExitQueue(t))
|
||
PrintFormat("📌 BUY EXIT queued (ticket=%d)", t.ticket);
|
||
}
|
||
}
|
||
return;
|
||
}
|
||
|
||
// =======================
|
||
// SELL EXIT
|
||
// =======================
|
||
if (sig == SELL_EXIT)
|
||
{
|
||
for (int m = OrdersTotal() - 1; m >= 0; m--)
|
||
{
|
||
if (!OrderSelect(m, SELECT_BY_POS, MODE_TRADES)) continue;
|
||
|
||
if (OrderMagicNumber() == Magic_A &&
|
||
OrderSymbol() == _Symbol &&
|
||
OrderType() == OP_SELL)
|
||
{
|
||
RefreshRates(); // Fetch latest market prices
|
||
double SELLclosePrice = Ask;
|
||
|
||
RetryTask t;
|
||
t.taskType = TASK_EXIT;
|
||
t.ticket = OrderTicket();
|
||
t.lots = OrderLots();
|
||
t.price = SELLclosePrice; // ← added: reference close price
|
||
t.slippage = slippagePoints;
|
||
t.retryLeft = RetryCount;
|
||
|
||
if (PushExitQueue(t))
|
||
PrintFormat("📌 SELL EXIT queued (ticket=%d)", t.ticket);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
//---------------------------------------------
|
||
// (22) Entry handling (supports both BUY and SELL)
|
||
//---------------------------------------------
|
||
void HandleEntryA(SignalType sig)
|
||
{
|
||
if (sig == NO_SIGNAL) return;
|
||
|
||
// 🚨 Block new entries while in emergency stop mode
|
||
if (EmergencyStop)
|
||
{
|
||
Print("🚫 EmergencyStop active. New entry is blocked: ", sig);
|
||
return;
|
||
}
|
||
|
||
datetime currentBarTime = iTime(Symbol(), PERIOD_CURRENT, 0);
|
||
|
||
// ▼ Second entry within the same bar → abnormal condition
|
||
if (lastEntryBarA == currentBarTime)
|
||
{
|
||
EmergencyCloseAll("Second entry detected within the same bar (abnormal)");
|
||
return;
|
||
}
|
||
|
||
if (!IsTradingHour()) return;
|
||
|
||
// Declare once and reuse
|
||
double orderLot;
|
||
|
||
// =======================
|
||
// BUY ENTRY
|
||
// =======================
|
||
if (sig == BUY_ENTRY)
|
||
{
|
||
double BUYspreadPips = (Ask - Bid) / Pip();
|
||
if (BUYspreadPips > MaxSpreadPips)
|
||
{
|
||
PrintFormat(
|
||
"❌ Spread too high (%.1f pips). Skip BUY entry.",
|
||
BUYspreadPips
|
||
);
|
||
return;
|
||
}
|
||
|
||
if (!CanPlaceNewBuy()) return;
|
||
|
||
double BUYprice = Ask;
|
||
double BUYsl = NormalizeDouble(BUYprice - SLPips * Pip(), Digits);
|
||
double BUYtp = NormalizeDouble(BUYprice + TPPips * Pip(), Digits);
|
||
int BUYslippagePoints = PipToPoint(SlippagePips);
|
||
|
||
// --- Retry-based entry (no Sleep, task registered to OnTick) ---
|
||
RefreshRates(); // Update prices
|
||
BUYprice = Ask; // Refresh execution price
|
||
|
||
orderLot = CalculateLotSize();
|
||
if (orderLot <= 0)
|
||
{
|
||
Print("[HandleEntryA] calculated lot <= 0. Fallback to LotSize param.");
|
||
orderLot = LotSize;
|
||
}
|
||
|
||
// === Register task to RetryManager ===
|
||
RetryTask t;
|
||
t.taskType = TASK_ENTRY;
|
||
t.orderType = OP_BUY;
|
||
t.lots = orderLot;
|
||
t.price = BUYprice;
|
||
t.sl = BUYsl;
|
||
t.tp = BUYtp;
|
||
t.slippage = BUYslippagePoints;
|
||
t.retryLeft = RetryCount;
|
||
|
||
if (RegisterRetryTask(t))
|
||
{
|
||
PrintFormat(
|
||
"📌 BUY ENTRY task registered. lot=%.2f sl=%.5f tp=%.5f",
|
||
orderLot,
|
||
BUYsl,
|
||
BUYtp
|
||
);
|
||
}
|
||
else
|
||
{
|
||
Print("⚠ BUY ENTRY task registration skipped (another task active)");
|
||
}
|
||
|
||
// BUY ends here (actual execution is handled in OnTick)
|
||
return;
|
||
}
|
||
|
||
// =======================
|
||
// SELL ENTRY
|
||
// =======================
|
||
if (sig == SELL_ENTRY)
|
||
{
|
||
double SELLspreadPips = (Ask - Bid) / Pip();
|
||
if (SELLspreadPips > MaxSpreadPips)
|
||
{
|
||
PrintFormat(
|
||
"❌ Spread too high (%.1f pips). Skip SELL entry.",
|
||
SELLspreadPips
|
||
);
|
||
return;
|
||
}
|
||
|
||
if (!CanPlaceNewSell()) return;
|
||
|
||
double SELLprice = Bid; // SELL uses Bid price
|
||
double SELLsl = NormalizeDouble(SELLprice + SLPips * Pip(), Digits);
|
||
double SELLtp = NormalizeDouble(SELLprice - TPPips * Pip(), Digits);
|
||
int SELLslippagePoints = PipToPoint(SlippagePips);
|
||
|
||
// --- Retry-based entry (no Sleep, task registered to OnTick) ---
|
||
RefreshRates();
|
||
SELLprice = Bid; // Refresh execution price
|
||
|
||
orderLot = CalculateLotSize();
|
||
if (orderLot <= 0)
|
||
{
|
||
Print("[HandleEntryA] calculated lot <= 0. Fallback to LotSize param.");
|
||
orderLot = LotSize;
|
||
}
|
||
|
||
// === Register task to RetryManager ===
|
||
RetryTask t;
|
||
t.taskType = TASK_ENTRY;
|
||
t.orderType = OP_SELL;
|
||
t.lots = orderLot;
|
||
t.price = SELLprice;
|
||
t.sl = SELLsl;
|
||
t.tp = SELLtp;
|
||
t.slippage = SELLslippagePoints;
|
||
t.retryLeft = RetryCount;
|
||
|
||
if (RegisterRetryTask(t))
|
||
{
|
||
PrintFormat(
|
||
"📌 SELL ENTRY task registered. lot=%.2f sl=%.5f tp=%.5f",
|
||
orderLot,
|
||
SELLsl,
|
||
SELLtp
|
||
);
|
||
}
|
||
else
|
||
{
|
||
Print("⚠ SELL ENTRY task registration skipped (another task active)");
|
||
}
|
||
|
||
// SELL ends here (actual execution is handled in OnTick)
|
||
return;
|
||
}
|
||
}
|
||
|
||
//---------------------------------------------
|
||
// (23) Step-based trailing stop
|
||
//---------------------------------------------
|
||
void ApplyTrailingStop()
|
||
{
|
||
if (!UseTrailingStop) return;
|
||
|
||
// ❗ Do not apply trailing while another retry task is active
|
||
if (currentTask.taskType != TASK_NONE) return;
|
||
|
||
for (int i = OrdersTotal() - 1; i >= 0; i--)
|
||
{
|
||
if (!OrderSelect(i, SELECT_BY_POS, MODE_TRADES)) continue;
|
||
if (OrderSymbol() != Symbol()) continue;
|
||
if (OrderMagicNumber() != Magic_A) continue;
|
||
|
||
int type = OrderType();
|
||
if (type != OP_BUY && type != OP_SELL) continue;
|
||
|
||
int ticket = OrderTicket();
|
||
double openPrice = OrderOpenPrice();
|
||
double oldSL = OrderStopLoss();
|
||
double oldTP = OrderTakeProfit();
|
||
double currentPrice = (type == OP_BUY) ? Bid : Ask;
|
||
|
||
// Floating profit in pips
|
||
double profitPips = (currentPrice - openPrice) / Pip();
|
||
if (type == OP_SELL) profitPips = -profitPips;
|
||
|
||
// Minimum trailing condition not met
|
||
if (profitPips < TrailStepProfit) continue;
|
||
|
||
// ===============================
|
||
// 🔑 Calculate trailing step count
|
||
// ===============================
|
||
int stepCount = (int)(profitPips / TrailStepProfit);
|
||
|
||
double tgtSL, tgtTP, newSL, newTP;
|
||
|
||
if (type == OP_BUY)
|
||
{
|
||
tgtSL = openPrice + (stepCount * TrailShiftPips) * Pip();
|
||
tgtTP = openPrice + (stepCount * TrailShiftPips + TPPips) * Pip();
|
||
|
||
newSL = (oldSL < tgtSL) ? tgtSL : oldSL;
|
||
newTP = (oldTP < tgtTP) ? tgtTP : oldTP;
|
||
}
|
||
else
|
||
{
|
||
tgtSL = openPrice - (stepCount * TrailShiftPips) * Pip();
|
||
tgtTP = openPrice - (stepCount * TrailShiftPips + TPPips) * Pip();
|
||
|
||
newSL = (oldSL > tgtSL) ? tgtSL : oldSL;
|
||
newTP = (oldTP > tgtTP) ? tgtTP : oldTP;
|
||
}
|
||
|
||
newSL = NormalizeDouble(newSL, Digits);
|
||
newTP = NormalizeDouble(newTP, Digits);
|
||
|
||
// Skip update if the change is negligible
|
||
if (MathAbs(oldSL - newSL) <= Point * 0.5 &&
|
||
MathAbs(oldTP - newTP) <= Point * 0.5)
|
||
{
|
||
continue;
|
||
}
|
||
|
||
// ❗ Only one modify task can be registered at a time
|
||
if (currentTask.taskType != TASK_NONE) return;
|
||
|
||
// 🚀 Register MODIFY task to RetryManager (executed on OnTick)
|
||
RetryTask t;
|
||
t.taskType = TASK_MODIFY;
|
||
t.ticket = ticket;
|
||
t.sl = newSL;
|
||
t.tp = newTP;
|
||
t.retryLeft = RetryCount;
|
||
t.lastAttemptMs = 0;
|
||
|
||
if (RegisterRetryTask(t))
|
||
{
|
||
PrintFormat(
|
||
"🔧 StepTrailing MODIFY registered. ticket=%d step=%d sl=%.5f tp=%.5f",
|
||
ticket, stepCount, newSL, newTP
|
||
);
|
||
}
|
||
|
||
// ❗ Register only one task per tick
|
||
return;
|
||
}
|
||
}
|
||
|
||
//---------------------------------------------
|
||
// (24) Fail-safe abnormal state detection
|
||
//---------------------------------------------
|
||
void CheckForAbnormalState()
|
||
{
|
||
// 🚨 If emergency stop has already been latched, do nothing
|
||
// (reset only on EA restart)
|
||
if (EmergencyLatched)
|
||
return;
|
||
|
||
int openBuyCount = 0;
|
||
int openSellCount = 0;
|
||
|
||
for (int i = OrdersTotal() - 1; i >= 0; i--)
|
||
{
|
||
if (!OrderSelect(i, SELECT_BY_POS, MODE_TRADES)) continue;
|
||
if (OrderMagicNumber() != Magic_A) continue;
|
||
if (OrderSymbol() != Symbol()) continue;
|
||
|
||
int type = OrderType();
|
||
if (type == OP_BUY) openBuyCount++;
|
||
if (type == OP_SELL) openSellCount++;
|
||
}
|
||
|
||
// ▼ Check for maximum open position count violation
|
||
if (openBuyCount > MaxOpenBuyPositions)
|
||
{
|
||
EmergencyLatched = true; // ← latch ON
|
||
EmergencyCloseAll(
|
||
StringFormat(
|
||
"Abnormal BUY position count (%d > %d)",
|
||
openBuyCount,
|
||
MaxOpenBuyPositions
|
||
)
|
||
);
|
||
return;
|
||
}
|
||
|
||
if (openSellCount > MaxOpenSellPositions)
|
||
{
|
||
EmergencyLatched = true; // ← latch ON
|
||
EmergencyCloseAll(
|
||
StringFormat(
|
||
"Abnormal SELL position count (%d > %d)",
|
||
openSellCount,
|
||
MaxOpenSellPositions
|
||
)
|
||
);
|
||
return;
|
||
}
|
||
|
||
// Note:
|
||
// Duplicate entry within the same bar is not handled here.
|
||
// It is detected immediately before entry execution.
|
||
}
|
||
|
||
// ---------------------------------------------
|
||
// (25) Emergency close all positions and block new entries
|
||
// (EA continues running)
|
||
// ---------------------------------------------
|
||
void EmergencyCloseAll(string reasonMessage)
|
||
{
|
||
EmergencyStop = true; // Completely block new entries
|
||
Print("🚨 EmergencyCloseAll triggered. Reason = ", reasonMessage);
|
||
|
||
const int maxRetry = 200;
|
||
const int retryInterval = 200; // milliseconds (0.2s interval)
|
||
|
||
for (int attempt = 0; attempt < maxRetry; attempt++)
|
||
{
|
||
RefreshRates();
|
||
|
||
// ---- Process all orders matching this EA's Magic number ----
|
||
for (int i = OrdersTotal() - 1; i >= 0; i--)
|
||
{
|
||
if (!OrderSelect(i, SELECT_BY_POS, MODE_TRADES)) continue;
|
||
if (OrderSymbol() != Symbol()) continue;
|
||
if (OrderMagicNumber() != Magic_A) continue;
|
||
|
||
int type = OrderType();
|
||
|
||
// ▼ Market positions
|
||
if (type == OP_BUY || type == OP_SELL)
|
||
{
|
||
double price = (type == OP_BUY) ? Bid : Ask; // use latest price
|
||
|
||
bool closed = OrderClose(
|
||
OrderTicket(),
|
||
OrderLots(),
|
||
price,
|
||
5,
|
||
clrRed
|
||
);
|
||
|
||
if (!closed)
|
||
{
|
||
PrintFormat(
|
||
"⚠️ OrderClose failed ticket=%d error=%d (retry=%d)",
|
||
OrderTicket(), GetLastError(), attempt
|
||
);
|
||
}
|
||
else
|
||
{
|
||
PrintFormat(
|
||
"✅ Market position closed successfully ticket=%d",
|
||
OrderTicket()
|
||
);
|
||
}
|
||
}
|
||
// ▼ Pending orders
|
||
else if (type == OP_BUYLIMIT || type == OP_SELLLIMIT ||
|
||
type == OP_BUYSTOP || type == OP_SELLSTOP)
|
||
{
|
||
bool deleted = OrderDelete(OrderTicket());
|
||
|
||
if (!deleted)
|
||
{
|
||
PrintFormat(
|
||
"⚠️ OrderDelete failed ticket=%d error=%d (retry=%d)",
|
||
OrderTicket(), GetLastError(), attempt
|
||
);
|
||
}
|
||
else
|
||
{
|
||
PrintFormat(
|
||
"🗑️ Pending order deleted successfully ticket=%d",
|
||
OrderTicket()
|
||
);
|
||
}
|
||
}
|
||
}
|
||
|
||
// ---- Are all orders cleared? ----
|
||
if (CountOrdersOfThisEA() == 0)
|
||
{
|
||
string msg =
|
||
"[Emergency Close Completed]\n" +
|
||
"Symbol: " + Symbol() + "\n" +
|
||
"Time: " + TimeToString(TimeCurrent(), TIME_DATE|TIME_SECONDS) + "\n" +
|
||
"Reason: " + reasonMessage + "\n" +
|
||
"All positions have been closed/deleted.\n" +
|
||
"EA remains active in EmergencyStop mode (no new entries).";
|
||
|
||
SendNotification(msg);
|
||
Print(msg);
|
||
return;
|
||
}
|
||
|
||
if (attempt % 10 == 0)
|
||
{
|
||
PrintFormat(
|
||
"⏳ EmergencyClose retry %d/%d",
|
||
attempt, maxRetry
|
||
);
|
||
}
|
||
|
||
Sleep(retryInterval);
|
||
}
|
||
|
||
// ---- Orders still remain after maximum retries ----
|
||
string newmsg =
|
||
"[WARNING: Emergency Close Failed]\n" +
|
||
"Symbol: " + Symbol() + "\n" +
|
||
"Time: " + TimeToString(TimeCurrent(), TIME_DATE|TIME_SECONDS) + "\n" +
|
||
"Reason: " + reasonMessage + "\n" +
|
||
"Orders still remain after maximum retry attempts.\n" +
|
||
"EmergencyStop mode is maintained (entries remain blocked).";
|
||
|
||
SendNotification(newmsg);
|
||
Print(newmsg);
|
||
}
|
||
|
||
// ---------------------------------------------
|
||
// (26) Helper: count orders belonging to Magic_A
|
||
// (used to verify completion of emergency close)
|
||
// ---------------------------------------------
|
||
int CountOrdersOfThisEA()
|
||
{
|
||
int c = 0;
|
||
for (int i = OrdersTotal() - 1; i >= 0; i--)
|
||
{
|
||
if (!OrderSelect(i, SELECT_BY_POS, MODE_TRADES)) continue;
|
||
if (OrderSymbol() != Symbol()) continue;
|
||
if (OrderMagicNumber() != Magic_A) continue;
|
||
c++;
|
||
}
|
||
return c;
|
||
}
|
||
|
||
//---------------------------------------------
|
||
// (27) Main OnTick processing
|
||
//---------------------------------------------
|
||
void OnTick()
|
||
{
|
||
RefreshRates();
|
||
|
||
// Check for abnormal/fail-safe conditions and margin alerts
|
||
CheckForAbnormalState();
|
||
CheckMarginLevel();
|
||
|
||
// =================================================
|
||
// ① Detect EXIT signals → push to EXIT queue (highest priority)
|
||
// =================================================
|
||
SignalType exitSig = ExitSignalA();
|
||
HandleExitA(exitSig); // ← does not register RetryTask directly; queued in EXIT queue
|
||
|
||
// =================================================
|
||
// ② If EXIT queue exists, flow the top task to RetryManager (highest priority)
|
||
// =================================================
|
||
if (currentTask.taskType == TASK_NONE && HasExitQueue())
|
||
{
|
||
RetryTask t = PopExitQueue();
|
||
RegisterRetryTask(t);
|
||
}
|
||
|
||
// =================================================
|
||
// ③ Trailing Stop (register MODIFY task)
|
||
// ※ Will naturally wait if an EXIT task is in progress
|
||
// =================================================
|
||
ApplyTrailingStop();
|
||
|
||
// =================================================
|
||
// ④ New bar entry (register ENTRY task)
|
||
// ※ Will naturally wait if an EXIT task is in progress
|
||
// =================================================
|
||
if (IsNewBar(PERIOD_CURRENT, prevTime_A))
|
||
{
|
||
SignalType entrySig = EntrySignalA();
|
||
HandleEntryA(entrySig);
|
||
}
|
||
|
||
// =================================================
|
||
// ⑤ Execute RetryManager
|
||
// =================================================
|
||
ProcessRetryTask();
|
||
|
||
// Send periodic EA status notification
|
||
CheckEAStatus();
|
||
}
|
||
|
||
// --- END --- |