anggol23
1245 lines
44 KiB
Plaintext
1245 lines
44 KiB
Plaintext
//+------------------------------------------------------------------+
|
||
//| HEDGE FUND ULTIMATE PRO v5.1 – DUAL ENGINE (MT5) |
|
||
//| Swing Trend-Follow + Scalp Mean-Reversion |
|
||
//| God-Tier: Adaptive Risk + Anti-MC + Profit Accumulator |
|
||
//+------------------------------------------------------------------+
|
||
#property strict
|
||
#property copyright "Hedge Ultimate Pro v5.1"
|
||
#property version "5.10"
|
||
|
||
#include <Trade/Trade.mqh>
|
||
CTrade trade;
|
||
|
||
//============================================================
|
||
// RISK MANAGEMENT
|
||
//============================================================
|
||
input group "=== Risk Management ==="
|
||
input double RiskPercent = 0.75; // Risk per trade swing (% balance)
|
||
input double ScalpRiskPercent = 0.3; // Risk per trade scalp (% balance) - kecil!
|
||
input double MaxDailyLossP = 3.0; // Max daily loss (% balance)
|
||
input double MaxDrawdownP = 8.0; // Max equity drawdown (%) - circuit breaker
|
||
input int MaxSwingPos = 2; // Max open swing positions
|
||
input int MaxScalpPos = 3; // Max open scalp positions
|
||
input int MagicSwing = 778899; // Magic Number swing
|
||
input int MagicScalp = 778900; // Magic Number scalp
|
||
input int CooldownBars = 3; // Cooldown bars setelah loss
|
||
input int MaxConsecLoss = 3; // N loss berturut → risk -50%
|
||
input int MaxTotalPos = 4; // Max TOTAL posisi (swing+scalp combined)
|
||
input double DailyProfitTarget = 2.0; // Stop trading jika profit hari ini >= % balance (0=off)
|
||
input double MinMarginLevel = 200.0; // Min margin level % untuk entry baru
|
||
|
||
//============================================================
|
||
// TREND FILTER (SWING)
|
||
//============================================================
|
||
input group "=== Swing: Trend Filter ==="
|
||
input int EMA_Fast = 50;
|
||
input int EMA_Slow = 200;
|
||
input ENUM_TIMEFRAMES HTF = PERIOD_H1; // HTF untuk trend direction
|
||
input int ADX_Period = 14;
|
||
input double ADX_Min = 20.0;
|
||
|
||
//============================================================
|
||
// SWING ENTRY
|
||
//============================================================
|
||
input group "=== Swing: Entry ==="
|
||
input int RSI_Period = 14;
|
||
input double RSI_OB = 70.0;
|
||
input double RSI_OS = 30.0;
|
||
input double ATR_SL_Multi = 1.5; // SL = ATR x multi
|
||
input double Swing_RR = 2.5; // R:R ratio swing
|
||
input int ATR_Period = 14;
|
||
|
||
//============================================================
|
||
// SWING TRADE MANAGEMENT
|
||
//============================================================
|
||
input group "=== Swing: Management ==="
|
||
input bool UsePartialClose = true;
|
||
input double PartialCloseRR = 1.0;
|
||
input double PartialPercent = 50.0;
|
||
input double BE_ATR_Multi = 1.0;
|
||
input double Trail_ATR_Multi = 1.5;
|
||
input double Trail_Step_ATR = 0.8;
|
||
input bool CloseOnOpposite = true;
|
||
|
||
//============================================================
|
||
// SCALP SETTINGS
|
||
//============================================================
|
||
input group "=== Scalp: Settings ==="
|
||
input bool EnableScalp = true; // Aktifkan scalp mode
|
||
input int BB_Period = 20; // Bollinger Band period
|
||
input double BB_Dev = 2.0; // BB deviasi
|
||
input int Scalp_RSI_Period = 7; // RSI cepat untuk scalp
|
||
input double Scalp_RSI_OB = 75.0; // RSI overbought scalp trigger
|
||
input double Scalp_RSI_OS = 25.0; // RSI oversold scalp trigger
|
||
input double Scalp_RR = 1.2; // R:R ratio scalp (cepat ambil profit)
|
||
input double Scalp_SL_ATR = 0.8; // SL scalp = ATR x multi (ketat)
|
||
input double Scalp_MaxSpread = 15; // Max spread untuk scalp (lebih ketat)
|
||
input double Scalp_BE_ATR = 0.3; // Scalp BE trigger = ATR × multi (adaptive)
|
||
input double Scalp_Trail_ATR = 0.15; // Scalp trail distance = ATR × multi (adaptive)
|
||
|
||
//============================================================
|
||
// FILTERS
|
||
//============================================================
|
||
input group "=== Filters ==="
|
||
input double MaxSpread = 30;
|
||
input bool UseSessionFilter = true;
|
||
input int SessionStartHour = 2; // London open
|
||
input int SessionEndHour = 20; // NY close
|
||
input int ScalpStartHour = 7; // Scalp hanya jam sibuk
|
||
input int ScalpEndHour = 17; // Scalp stop sebelum NY close
|
||
input bool CloseBeforeWeekend = true;
|
||
input bool AvoidHighImpactHour = true; // Skip entry 30m sebelum/sesudah news hour
|
||
input string NewsHours = "8,13,15"; // Jam server rawan news (pisah koma)
|
||
|
||
//============================================================
|
||
// GLOBAL VARIABLES
|
||
//============================================================
|
||
int ema_fast_handle, ema_slow_handle;
|
||
int adx_handle, rsi_handle, atr_handle;
|
||
int bb_handle, scalp_rsi_handle;
|
||
double ema_fast_val[], ema_slow_val[];
|
||
double adx_val[], plus_di[], minus_di[];
|
||
double rsi_val[], atr_val[];
|
||
double bb_upper[], bb_lower[], bb_mid[];
|
||
double scalp_rsi_val[];
|
||
|
||
datetime lastSwingBar = 0;
|
||
datetime lastLossTime = 0;
|
||
int consecLosses = 0;
|
||
datetime lastTradeDay = 0; // Track hari terakhir untuk OnTrade reset
|
||
int lastDealsTotal = 0; // Track total deal terakhir untuk OnTrade
|
||
|
||
string gvPeakEquity;
|
||
|
||
// News hours parsed
|
||
int newsHourArr[10];
|
||
int newsHourCount = 0;
|
||
|
||
//============================================================
|
||
// AUTO-DETECT FILLING MODE
|
||
//============================================================
|
||
ENUM_ORDER_TYPE_FILLING DetectFilling()
|
||
{
|
||
long fillMode = 0;
|
||
SymbolInfoInteger(_Symbol, SYMBOL_FILLING_MODE, fillMode);
|
||
if((fillMode & SYMBOL_FILLING_FOK) != 0) return ORDER_FILLING_FOK;
|
||
if((fillMode & SYMBOL_FILLING_IOC) != 0) return ORDER_FILLING_IOC;
|
||
return ORDER_FILLING_RETURN;
|
||
}
|
||
|
||
//============================================================
|
||
// PARSE NEWS HOURS STRING
|
||
//============================================================
|
||
void ParseNewsHours()
|
||
{
|
||
newsHourCount = 0;
|
||
string parts[];
|
||
int count = StringSplit(NewsHours, ',', parts);
|
||
for(int i = 0; i < count && i < 10; i++)
|
||
{
|
||
StringTrimLeft(parts[i]);
|
||
StringTrimRight(parts[i]);
|
||
newsHourArr[newsHourCount] = (int)StringToInteger(parts[i]);
|
||
newsHourCount++;
|
||
}
|
||
}
|
||
|
||
bool IsNearNewsHour()
|
||
{
|
||
if(!AvoidHighImpactHour || newsHourCount == 0) return false;
|
||
|
||
MqlDateTime dt;
|
||
TimeCurrent(dt);
|
||
int min = dt.hour * 60 + dt.min;
|
||
|
||
for(int i = 0; i < newsHourCount; i++)
|
||
{
|
||
int newsMin = newsHourArr[i] * 60;
|
||
// Hindari 30 menit sebelum dan 15 menit sesudah
|
||
if(min >= newsMin - 30 && min <= newsMin + 15)
|
||
return true;
|
||
}
|
||
return false;
|
||
}
|
||
|
||
//============================================================
|
||
// INIT
|
||
//============================================================
|
||
int OnInit()
|
||
{
|
||
trade.SetExpertMagicNumber(MagicSwing);
|
||
trade.SetDeviationInPoints(10);
|
||
trade.SetTypeFilling(DetectFilling());
|
||
|
||
// Swing indicators
|
||
ema_fast_handle = iMA(_Symbol, HTF, EMA_Fast, 0, MODE_EMA, PRICE_CLOSE);
|
||
ema_slow_handle = iMA(_Symbol, HTF, EMA_Slow, 0, MODE_EMA, PRICE_CLOSE);
|
||
adx_handle = iADX(_Symbol, _Period, ADX_Period);
|
||
rsi_handle = iRSI(_Symbol, _Period, RSI_Period, PRICE_CLOSE);
|
||
atr_handle = iATR(_Symbol, _Period, ATR_Period);
|
||
|
||
// Scalp indicators
|
||
bb_handle = iBands(_Symbol, _Period, BB_Period, 0, BB_Dev, PRICE_CLOSE);
|
||
scalp_rsi_handle = iRSI(_Symbol, _Period, Scalp_RSI_Period, PRICE_CLOSE);
|
||
|
||
if(ema_fast_handle==INVALID_HANDLE || ema_slow_handle==INVALID_HANDLE ||
|
||
adx_handle==INVALID_HANDLE || rsi_handle==INVALID_HANDLE ||
|
||
atr_handle==INVALID_HANDLE || bb_handle==INVALID_HANDLE ||
|
||
scalp_rsi_handle==INVALID_HANDLE)
|
||
{
|
||
Print("ERROR: Gagal membuat indicator handle!");
|
||
return(INIT_FAILED);
|
||
}
|
||
|
||
ArraySetAsSeries(ema_fast_val, true);
|
||
ArraySetAsSeries(ema_slow_val, true);
|
||
ArraySetAsSeries(adx_val, true);
|
||
ArraySetAsSeries(plus_di, true);
|
||
ArraySetAsSeries(minus_di, true);
|
||
ArraySetAsSeries(rsi_val, true);
|
||
ArraySetAsSeries(atr_val, true);
|
||
ArraySetAsSeries(bb_upper, true);
|
||
ArraySetAsSeries(bb_lower, true);
|
||
ArraySetAsSeries(bb_mid, true);
|
||
ArraySetAsSeries(scalp_rsi_val, true);
|
||
|
||
// Peak equity persistent
|
||
gvPeakEquity = "HUP5_PeakEq_" + _Symbol + "_" + IntegerToString(MagicSwing);
|
||
if(GlobalVariableCheck(gvPeakEquity))
|
||
{
|
||
double stored = GlobalVariableGet(gvPeakEquity);
|
||
double current = AccountInfoDouble(ACCOUNT_EQUITY);
|
||
if(stored > current && stored < current * 2.0)
|
||
current = stored;
|
||
GlobalVariableSet(gvPeakEquity, current);
|
||
}
|
||
else
|
||
GlobalVariableSet(gvPeakEquity, AccountInfoDouble(ACCOUNT_EQUITY));
|
||
|
||
CountRecentLosses();
|
||
ParseNewsHours();
|
||
|
||
// Inisialisasi tracking bar dan trade history untuk mencegah double-counting & entry tengah bar saat startup
|
||
lastSwingBar = iTime(_Symbol, _Period, 0);
|
||
lastTradeDay = iTime(_Symbol, PERIOD_D1, 0);
|
||
HistorySelect(lastTradeDay, TimeCurrent());
|
||
lastDealsTotal = HistoryDealsTotal();
|
||
|
||
Print("HUP v5.0 DUAL ENGINE | Filling=", EnumToString(DetectFilling()),
|
||
" | Scalp=", EnableScalp ? "ON" : "OFF",
|
||
" | ConsecLoss=", consecLosses);
|
||
|
||
return(INIT_SUCCEEDED);
|
||
}
|
||
|
||
void OnDeinit(const int reason)
|
||
{
|
||
if(ema_fast_handle!=INVALID_HANDLE) IndicatorRelease(ema_fast_handle);
|
||
if(ema_slow_handle!=INVALID_HANDLE) IndicatorRelease(ema_slow_handle);
|
||
if(adx_handle!=INVALID_HANDLE) IndicatorRelease(adx_handle);
|
||
if(rsi_handle!=INVALID_HANDLE) IndicatorRelease(rsi_handle);
|
||
if(atr_handle!=INVALID_HANDLE) IndicatorRelease(atr_handle);
|
||
if(bb_handle!=INVALID_HANDLE) IndicatorRelease(bb_handle);
|
||
if(scalp_rsi_handle!=INVALID_HANDLE) IndicatorRelease(scalp_rsi_handle);
|
||
}
|
||
|
||
//============================================================
|
||
// COUNT RECENT CONSECUTIVE LOSSES
|
||
//============================================================
|
||
void CountRecentLosses()
|
||
{
|
||
consecLosses = 0;
|
||
// Scan history 30 hari ke belakang untuk consec losses lintas hari
|
||
HistorySelect(TimeCurrent() - 30 * 24 * 3600, TimeCurrent());
|
||
|
||
int total = HistoryDealsTotal();
|
||
for(int i = total - 1; i >= 0; i--)
|
||
{
|
||
ulong ticket = HistoryDealGetTicket(i);
|
||
if(ticket == 0) continue;
|
||
long magic = (long)HistoryDealGetInteger(ticket, DEAL_MAGIC);
|
||
if(magic != MagicSwing && magic != MagicScalp) continue;
|
||
if(HistoryDealGetString(ticket, DEAL_SYMBOL) != _Symbol) continue;
|
||
if(HistoryDealGetInteger(ticket, DEAL_ENTRY) != DEAL_ENTRY_OUT) continue;
|
||
|
||
double profit = HistoryDealGetDouble(ticket, DEAL_PROFIT)
|
||
+ HistoryDealGetDouble(ticket, DEAL_SWAP)
|
||
+ HistoryDealGetDouble(ticket, DEAL_COMMISSION);
|
||
|
||
if(profit < 0)
|
||
{
|
||
consecLosses++;
|
||
if(consecLosses == 1)
|
||
lastLossTime = (datetime)HistoryDealGetInteger(ticket, DEAL_TIME);
|
||
}
|
||
else
|
||
break;
|
||
}
|
||
}
|
||
|
||
//============================================================
|
||
// COUNT POSITIONS (by magic)
|
||
//============================================================
|
||
int CountPositions(int magic)
|
||
{
|
||
int count = 0;
|
||
for(int i = PositionsTotal()-1; i >= 0; i--)
|
||
{
|
||
ulong ticket = PositionGetTicket(i);
|
||
if(!PositionSelectByTicket(ticket)) continue;
|
||
if(PositionGetString(POSITION_SYMBOL) != _Symbol) continue;
|
||
if(PositionGetInteger(POSITION_MAGIC) != magic) continue;
|
||
count++;
|
||
}
|
||
return count;
|
||
}
|
||
|
||
//============================================================
|
||
// CLOSE POSITIONS (by magic + optional direction filter)
|
||
//============================================================
|
||
void ClosePositions(int magic, int dirFilter=0)
|
||
{
|
||
for(int i = PositionsTotal()-1; i >= 0; i--)
|
||
{
|
||
ulong ticket = PositionGetTicket(i);
|
||
if(!PositionSelectByTicket(ticket)) continue;
|
||
if(PositionGetString(POSITION_SYMBOL) != _Symbol) continue;
|
||
if(PositionGetInteger(POSITION_MAGIC) != magic) continue;
|
||
|
||
if(dirFilter != 0)
|
||
{
|
||
int type = (int)PositionGetInteger(POSITION_TYPE);
|
||
if(dirFilter == +1 && type != POSITION_TYPE_SELL) continue; // close sells only
|
||
if(dirFilter == -1 && type != POSITION_TYPE_BUY) continue; // close buys only
|
||
}
|
||
trade.SetExpertMagicNumber(magic);
|
||
trade.PositionClose(ticket);
|
||
}
|
||
}
|
||
|
||
void CloseAllMyPositions()
|
||
{
|
||
ClosePositions(MagicSwing);
|
||
ClosePositions(MagicScalp);
|
||
}
|
||
|
||
//============================================================
|
||
// DAILY LOSS CHECK (both engines combined)
|
||
//============================================================
|
||
double GetTodayPnL()
|
||
{
|
||
double pnl = 0;
|
||
datetime dayStart = iTime(_Symbol, PERIOD_D1, 0);
|
||
HistorySelect(dayStart, TimeCurrent());
|
||
|
||
for(int i = 0; i < HistoryDealsTotal(); i++)
|
||
{
|
||
ulong ticket = HistoryDealGetTicket(i);
|
||
if(ticket == 0) continue;
|
||
long magic = (long)HistoryDealGetInteger(ticket, DEAL_MAGIC);
|
||
if(magic != MagicSwing && magic != MagicScalp) continue;
|
||
if(HistoryDealGetString(ticket, DEAL_SYMBOL) != _Symbol) continue;
|
||
|
||
pnl += HistoryDealGetDouble(ticket, DEAL_PROFIT)
|
||
+ HistoryDealGetDouble(ticket, DEAL_SWAP)
|
||
+ HistoryDealGetDouble(ticket, DEAL_COMMISSION);
|
||
}
|
||
return pnl;
|
||
}
|
||
|
||
bool DailySafe()
|
||
{
|
||
double balance = AccountInfoDouble(ACCOUNT_BALANCE);
|
||
double maxLoss = balance * MaxDailyLossP / 100.0;
|
||
double closedPnL = GetTodayPnL();
|
||
|
||
// Cek closed PnL
|
||
if(closedPnL < -maxLoss)
|
||
{
|
||
CloseAllMyPositions();
|
||
Print("DAILY LOSS LIMIT: closed PnL=", DoubleToString(closedPnL,2));
|
||
return false;
|
||
}
|
||
|
||
// Cek closed + floating PnL combined
|
||
double floatingPnL = GetFloatingPnL();
|
||
if((closedPnL + floatingPnL) < -maxLoss)
|
||
{
|
||
CloseAllMyPositions();
|
||
Print("DAILY LOSS LIMIT (floating): total=", DoubleToString(closedPnL+floatingPnL,2));
|
||
return false;
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
//============================================================
|
||
// FLOATING PnL (posisi terbuka milik EA ini)
|
||
//============================================================
|
||
double GetFloatingPnL()
|
||
{
|
||
double pnl = 0;
|
||
for(int i = PositionsTotal()-1; i >= 0; i--)
|
||
{
|
||
ulong ticket = PositionGetTicket(i);
|
||
if(!PositionSelectByTicket(ticket)) continue;
|
||
if(PositionGetString(POSITION_SYMBOL) != _Symbol) continue;
|
||
long magic = (long)PositionGetInteger(POSITION_MAGIC);
|
||
if(magic != MagicSwing && magic != MagicScalp) continue;
|
||
pnl += PositionGetDouble(POSITION_PROFIT)
|
||
+ PositionGetDouble(POSITION_SWAP);
|
||
}
|
||
return pnl;
|
||
}
|
||
|
||
//============================================================
|
||
// DAILY PROFIT TARGET (stop trading kalau sudah cukup)
|
||
//============================================================
|
||
bool DailyTargetReached()
|
||
{
|
||
if(DailyProfitTarget <= 0) return false;
|
||
double balance = AccountInfoDouble(ACCOUNT_BALANCE);
|
||
double target = balance * DailyProfitTarget / 100.0;
|
||
double todayPnL = GetTodayPnL();
|
||
return (todayPnL >= target);
|
||
}
|
||
|
||
//============================================================
|
||
// MARGIN CHECK
|
||
//============================================================
|
||
bool MarginOK()
|
||
{
|
||
double marginLevel = AccountInfoDouble(ACCOUNT_MARGIN_LEVEL);
|
||
// marginLevel=0 berarti tidak ada posisi terbuka (unlimited)
|
||
if(marginLevel == 0) return true;
|
||
return (marginLevel >= MinMarginLevel);
|
||
}
|
||
|
||
//============================================================
|
||
// TOTAL POSITION CHECK (combined)
|
||
//============================================================
|
||
int CountAllMyPositions()
|
||
{
|
||
int count = 0;
|
||
for(int i = PositionsTotal()-1; i >= 0; i--)
|
||
{
|
||
ulong ticket = PositionGetTicket(i);
|
||
if(!PositionSelectByTicket(ticket)) continue;
|
||
if(PositionGetString(POSITION_SYMBOL) != _Symbol) continue;
|
||
long magic = (long)PositionGetInteger(POSITION_MAGIC);
|
||
if(magic == MagicSwing || magic == MagicScalp)
|
||
count++;
|
||
}
|
||
return count;
|
||
}
|
||
|
||
//============================================================
|
||
// EQUITY CIRCUIT BREAKER
|
||
//============================================================
|
||
bool EquitySafe()
|
||
{
|
||
double equity = AccountInfoDouble(ACCOUNT_EQUITY);
|
||
double peak = GlobalVariableGet(gvPeakEquity);
|
||
if(peak <= 0) peak = equity;
|
||
|
||
if(equity > peak)
|
||
{
|
||
peak = equity;
|
||
GlobalVariableSet(gvPeakEquity, peak);
|
||
}
|
||
|
||
double ddPercent = (peak - equity) / peak * 100.0;
|
||
if(ddPercent >= MaxDrawdownP)
|
||
{
|
||
CloseAllMyPositions();
|
||
Print("CIRCUIT BREAKER: DD ", DoubleToString(ddPercent,1), "%");
|
||
return false;
|
||
}
|
||
return true;
|
||
}
|
||
|
||
//============================================================
|
||
// FILTERS
|
||
//============================================================
|
||
bool SpreadOK(double maxSpr)
|
||
{
|
||
double s = (SymbolInfoDouble(_Symbol,SYMBOL_ASK) - SymbolInfoDouble(_Symbol,SYMBOL_BID)) / _Point;
|
||
return s <= maxSpr;
|
||
}
|
||
|
||
bool SessionOK()
|
||
{
|
||
if(!UseSessionFilter) return true;
|
||
MqlDateTime dt;
|
||
TimeCurrent(dt);
|
||
return (dt.hour >= SessionStartHour && dt.hour < SessionEndHour);
|
||
}
|
||
|
||
bool ScalpSessionOK()
|
||
{
|
||
MqlDateTime dt;
|
||
TimeCurrent(dt);
|
||
return (dt.hour >= ScalpStartHour && dt.hour < ScalpEndHour);
|
||
}
|
||
|
||
void CheckWeekendClose()
|
||
{
|
||
if(!CloseBeforeWeekend) return;
|
||
MqlDateTime dt;
|
||
TimeCurrent(dt);
|
||
if(dt.day_of_week == 5 && dt.hour >= 20)
|
||
CloseAllMyPositions();
|
||
}
|
||
|
||
bool CooldownOK()
|
||
{
|
||
if(CooldownBars <= 0 || lastLossTime == 0) return true;
|
||
int barsSinceLoss = iBarShift(_Symbol, _Period, lastLossTime, false);
|
||
return (barsSinceLoss >= CooldownBars);
|
||
}
|
||
|
||
//============================================================
|
||
// DYNAMIC RISK
|
||
//============================================================
|
||
double GetEffectiveRisk(double baseRisk)
|
||
{
|
||
double risk = baseRisk;
|
||
if(consecLosses >= MaxConsecLoss)
|
||
risk *= 0.5;
|
||
return risk;
|
||
}
|
||
|
||
//============================================================
|
||
// LOAD ALL INDICATORS
|
||
//============================================================
|
||
bool LoadIndicators()
|
||
{
|
||
if(CopyBuffer(ema_fast_handle, 0, 0, 3, ema_fast_val) < 3) return false;
|
||
if(CopyBuffer(ema_slow_handle, 0, 0, 3, ema_slow_val) < 3) return false;
|
||
if(CopyBuffer(adx_handle, 0, 0, 3, adx_val) < 3) return false;
|
||
if(CopyBuffer(adx_handle, 1, 0, 3, plus_di) < 3) return false;
|
||
if(CopyBuffer(adx_handle, 2, 0, 3, minus_di) < 3) return false;
|
||
if(CopyBuffer(rsi_handle, 0, 0, 3, rsi_val) < 3) return false;
|
||
if(CopyBuffer(atr_handle, 0, 0, 50, atr_val) < 50) return false;
|
||
if(CopyBuffer(bb_handle, 1, 0, 3, bb_upper) < 3) return false; // Upper
|
||
if(CopyBuffer(bb_handle, 2, 0, 3, bb_lower) < 3) return false; // Lower
|
||
if(CopyBuffer(bb_handle, 0, 0, 3, bb_mid) < 3) return false; // Middle
|
||
if(CopyBuffer(scalp_rsi_handle, 0, 0, 3, scalp_rsi_val)< 3) return false;
|
||
return true;
|
||
}
|
||
|
||
//============================================================
|
||
// VOLATILITY FILTER (DYNAMIC ATR)
|
||
//============================================================
|
||
bool IsVolatilityOk()
|
||
{
|
||
int totalATR = ArraySize(atr_val);
|
||
if(totalATR < 10) return true; // fallback jika data kurang
|
||
double sum = 0;
|
||
for(int i = 0; i < totalATR; i++) sum += atr_val[i];
|
||
double avgATR = sum / totalATR;
|
||
// Volatilitas OK jika ATR saat ini >= 60% dari rata-rata 50 bar terakhir
|
||
return (atr_val[1] >= avgATR * 0.6);
|
||
}
|
||
|
||
//============================================================
|
||
// LOT CALCULATION
|
||
//============================================================
|
||
double LotCalc(double sl_points, double baseRisk)
|
||
{
|
||
double balance = AccountInfoDouble(ACCOUNT_BALANCE);
|
||
double risk = balance * GetEffectiveRisk(baseRisk) / 100.0;
|
||
|
||
double tickvalue = SymbolInfoDouble(_Symbol, SYMBOL_TRADE_TICK_VALUE);
|
||
double ticksize = SymbolInfoDouble(_Symbol, SYMBOL_TRADE_TICK_SIZE);
|
||
|
||
if(sl_points <= 0 || tickvalue <= 0 || ticksize <= 0)
|
||
return 0.0;
|
||
|
||
double lot = risk / (sl_points * (tickvalue / ticksize) * _Point);
|
||
|
||
double minLot = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MIN);
|
||
double maxLot = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MAX);
|
||
double lotStep = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_STEP);
|
||
if(lotStep <= 0) lotStep = 0.01;
|
||
|
||
lot = MathFloor(lot / lotStep) * lotStep;
|
||
lot = MathMax(minLot, MathMin(maxLot, lot));
|
||
return NormalizeDouble(lot, 2);
|
||
}
|
||
|
||
//============================================================
|
||
// VALIDATE SL/TP vs BROKER LIMITS
|
||
//============================================================
|
||
bool ValidateSLTP(double price, double sl, double tp, int direction)
|
||
{
|
||
long stopsLevel = 0;
|
||
SymbolInfoInteger(_Symbol, SYMBOL_TRADE_STOPS_LEVEL, stopsLevel);
|
||
double minDist = stopsLevel * _Point;
|
||
|
||
if(minDist > 0)
|
||
{
|
||
if(direction == +1)
|
||
{
|
||
if((sl > 0 && (price - sl) < minDist) || (tp > 0 && (tp - price) < minDist)) return false;
|
||
}
|
||
else
|
||
{
|
||
if((sl > 0 && (sl - price) < minDist) || (tp > 0 && (price - tp) < minDist)) return false;
|
||
}
|
||
}
|
||
|
||
long freezeLevel = 0;
|
||
SymbolInfoInteger(_Symbol, SYMBOL_TRADE_FREEZE_LEVEL, freezeLevel);
|
||
double freezeDist = freezeLevel * _Point;
|
||
if(freezeDist > 0)
|
||
{
|
||
double bid = SymbolInfoDouble(_Symbol, SYMBOL_BID);
|
||
double ask = SymbolInfoDouble(_Symbol, SYMBOL_ASK);
|
||
if(direction == +1 && sl > 0 && (ask - sl) < freezeDist) return false;
|
||
if(direction == -1 && sl > 0 && (sl - bid) < freezeDist) return false;
|
||
}
|
||
return true;
|
||
}
|
||
|
||
double NormalizePrice(double price)
|
||
{
|
||
double tickSize = SymbolInfoDouble(_Symbol, SYMBOL_TRADE_TICK_SIZE);
|
||
if(tickSize <= 0) return NormalizeDouble(price, _Digits);
|
||
return NormalizeDouble(MathRound(price / tickSize) * tickSize, _Digits);
|
||
}
|
||
|
||
//============================================================
|
||
// TREND ANALYSIS (SWING)
|
||
//============================================================
|
||
int GetTrend()
|
||
{
|
||
if(ema_fast_val[0] > ema_slow_val[0]) return +1;
|
||
if(ema_fast_val[0] < ema_slow_val[0]) return -1;
|
||
return 0;
|
||
}
|
||
|
||
bool TrendStrong() { return adx_val[0] >= ADX_Min; }
|
||
|
||
//============================================================
|
||
// DETECT PIN BAR PATTERN
|
||
//============================================================
|
||
bool IsPinBar(int barIndex, int direction)
|
||
{
|
||
double open = iOpen(_Symbol, _Period, barIndex);
|
||
double close = iClose(_Symbol, _Period, barIndex);
|
||
double high = iHigh(_Symbol, _Period, barIndex);
|
||
double low = iLow(_Symbol, _Period, barIndex);
|
||
|
||
double range = high - low;
|
||
if(range <= 0) return false;
|
||
|
||
double body = MathAbs(close - open);
|
||
|
||
if(direction == +1) // Bullish Pin Bar (Hammer)
|
||
{
|
||
double lowerShadow = MathMin(open, close) - low;
|
||
double upperShadow = high - MathMax(open, close);
|
||
return (lowerShadow >= range * 0.6 && body <= range * 0.3 && upperShadow <= range * 0.2);
|
||
}
|
||
else if(direction == -1) // Bearish Pin Bar (Shooting Star)
|
||
{
|
||
double lowerShadow = MathMin(open, close) - low;
|
||
double upperShadow = high - MathMax(open, close);
|
||
return (upperShadow >= range * 0.6 && body <= range * 0.3 && lowerShadow <= range * 0.2);
|
||
}
|
||
return false;
|
||
}
|
||
|
||
//============================================================
|
||
// SWING BUY SIGNAL
|
||
//============================================================
|
||
bool SwingBuySignal()
|
||
{
|
||
if(GetTrend() != +1) return false;
|
||
double bid = SymbolInfoDouble(_Symbol, SYMBOL_BID);
|
||
if(bid <= ema_fast_val[0]) return false;
|
||
|
||
if(!TrendStrong()) return false;
|
||
if(plus_di[0] <= minus_di[0]) return false;
|
||
|
||
// Dioptimalkan menjadi 35.0 (sebelumnya 40.0) agar bisa menangkap pullback sehat yang lebih dalam
|
||
if(rsi_val[0] >= RSI_OB || rsi_val[0] < 35.0) return false;
|
||
|
||
double open1 = iOpen(_Symbol, _Period, 1);
|
||
double close1 = iClose(_Symbol, _Period, 1);
|
||
double open2 = iOpen(_Symbol, _Period, 2);
|
||
double close2 = iClose(_Symbol, _Period, 2);
|
||
|
||
double body1 = close1 - open1;
|
||
double body2 = close2 - open2;
|
||
double range1 = iHigh(_Symbol, _Period, 1) - iLow(_Symbol, _Period, 1);
|
||
|
||
double atr = atr_val[1];
|
||
if(atr <= 0) return false;
|
||
|
||
if(body1 <= 0 || body1 < atr * 0.4) return false;
|
||
if(range1 > 0 && body1 / range1 < 0.5) return false;
|
||
|
||
bool breakout = close1 > iHigh(_Symbol, _Period, 2);
|
||
bool engulfing = (body2 < 0) && (close1 > open2) && (open1 < close2);
|
||
bool pinbar = IsPinBar(1, +1);
|
||
return (breakout || engulfing || pinbar);
|
||
}
|
||
|
||
//============================================================
|
||
// SWING SELL SIGNAL
|
||
//============================================================
|
||
bool SwingSellSignal()
|
||
{
|
||
if(GetTrend() != -1) return false;
|
||
double ask = SymbolInfoDouble(_Symbol, SYMBOL_ASK);
|
||
if(ask >= ema_fast_val[0]) return false;
|
||
|
||
if(!TrendStrong()) return false;
|
||
if(minus_di[0] <= plus_di[0]) return false;
|
||
|
||
// Dioptimalkan menjadi 65.0 (sebelumnya 60.0) agar bisa menangkap pullback sehat yang lebih tinggi
|
||
if(rsi_val[0] <= RSI_OS || rsi_val[0] > 65.0) return false;
|
||
|
||
double open1 = iOpen(_Symbol, _Period, 1);
|
||
double close1 = iClose(_Symbol, _Period, 1);
|
||
double open2 = iOpen(_Symbol, _Period, 2);
|
||
double close2 = iClose(_Symbol, _Period, 2);
|
||
|
||
double body1 = open1 - close1;
|
||
double body2 = open2 - close2;
|
||
double range1 = iHigh(_Symbol, _Period, 1) - iLow(_Symbol, _Period, 1);
|
||
|
||
double atr = atr_val[1];
|
||
if(atr <= 0) return false;
|
||
|
||
if(body1 <= 0 || body1 < atr * 0.4) return false;
|
||
if(range1 > 0 && body1 / range1 < 0.5) return false;
|
||
|
||
bool breakout = close1 < iLow(_Symbol, _Period, 2);
|
||
bool engulfing = (body2 < 0) && (close1 < open2) && (open1 > close2);
|
||
bool pinbar = IsPinBar(1, -1);
|
||
return (breakout || engulfing || pinbar);
|
||
}
|
||
|
||
//============================================================
|
||
// SCALP BUY SIGNAL (BB Lower bounce + RSI oversold)
|
||
//============================================================
|
||
bool ScalpBuySignal()
|
||
{
|
||
if(!EnableScalp) return false;
|
||
|
||
double close1 = iClose(_Symbol, _Period, 1);
|
||
double low1 = iLow(_Symbol, _Period, 1);
|
||
double close2 = iClose(_Symbol, _Period, 2);
|
||
|
||
// Kondisi 1: Candle sebelumnya menyentuh/menembus BB lower
|
||
if(low1 > bb_lower[1]) return false;
|
||
|
||
// Kondisi 2: Close kembali di atas BB lower (bounce, bukan tembus terus)
|
||
if(close1 < bb_lower[1]) return false;
|
||
|
||
// Kondisi 3: RSI cepat di area oversold
|
||
if(scalp_rsi_val[1] > Scalp_RSI_OS) return false;
|
||
|
||
// Kondisi 4: Candle bounce bullish (close > open)
|
||
if(close1 <= iOpen(_Symbol, _Period, 1)) return false;
|
||
|
||
// Kondisi 5: Harga di bawah BB middle (masih ada ruang ke atas)
|
||
if(close1 > bb_mid[0]) return false;
|
||
|
||
// Kondisi 6: Tidak melawan trend kuat (ADX > 30 + bearish = skip)
|
||
if(adx_val[0] > 30.0 && GetTrend() == -1) return false;
|
||
|
||
return true;
|
||
}
|
||
|
||
//============================================================
|
||
// SCALP SELL SIGNAL (BB Upper bounce + RSI overbought)
|
||
//============================================================
|
||
bool ScalpSellSignal()
|
||
{
|
||
if(!EnableScalp) return false;
|
||
|
||
double close1 = iClose(_Symbol, _Period, 1);
|
||
double high1 = iHigh(_Symbol, _Period, 1);
|
||
double close2 = iClose(_Symbol, _Period, 2);
|
||
|
||
// Kondisi 1: Candle sebelumnya menyentuh/menembus BB upper
|
||
if(high1 < bb_upper[1]) return false;
|
||
|
||
// Kondisi 2: Close kembali di bawah BB upper (bounce)
|
||
if(close1 > bb_upper[1]) return false;
|
||
|
||
// Kondisi 3: RSI cepat di area overbought
|
||
if(scalp_rsi_val[1] < Scalp_RSI_OB) return false;
|
||
|
||
// Kondisi 4: Candle bounce bearish
|
||
if(close1 >= iOpen(_Symbol, _Period, 1)) return false;
|
||
|
||
// Kondisi 5: Harga di atas BB middle
|
||
if(close1 < bb_mid[0]) return false;
|
||
|
||
// Kondisi 6: Tidak melawan trend kuat
|
||
if(adx_val[0] > 30.0 && GetTrend() == +1) return false;
|
||
|
||
return true;
|
||
}
|
||
|
||
//============================================================
|
||
// MANAGE SWING POSITIONS
|
||
//============================================================
|
||
void ManageSwing()
|
||
{
|
||
double atrNow[];
|
||
ArraySetAsSeries(atrNow, true);
|
||
if(CopyBuffer(atr_handle, 0, 0, 1, atrNow) < 1) return;
|
||
double atr = atrNow[0];
|
||
if(atr <= 0) return;
|
||
|
||
for(int i = PositionsTotal()-1; i >= 0; i--)
|
||
{
|
||
ulong ticket = PositionGetTicket(i);
|
||
if(!PositionSelectByTicket(ticket)) continue;
|
||
if(PositionGetString(POSITION_SYMBOL) != _Symbol) continue;
|
||
if(PositionGetInteger(POSITION_MAGIC) != MagicSwing) continue;
|
||
|
||
double openPrice = PositionGetDouble(POSITION_PRICE_OPEN);
|
||
double sl = PositionGetDouble(POSITION_SL);
|
||
double tp = PositionGetDouble(POSITION_TP);
|
||
double volume = PositionGetDouble(POSITION_VOLUME);
|
||
int type = (int)PositionGetInteger(POSITION_TYPE);
|
||
|
||
double price = (type==POSITION_TYPE_BUY) ?
|
||
SymbolInfoDouble(_Symbol,SYMBOL_BID) :
|
||
SymbolInfoDouble(_Symbol,SYMBOL_ASK);
|
||
|
||
double profitDist = (type==POSITION_TYPE_BUY) ?
|
||
(price-openPrice) : (openPrice-price);
|
||
double slDist = (type==POSITION_TYPE_BUY) ?
|
||
(openPrice-sl) : (sl-openPrice);
|
||
|
||
// Partial Close
|
||
if(UsePartialClose && slDist > 0 && profitDist >= slDist * PartialCloseRR)
|
||
{
|
||
string gvP = "HUP5_SwP_" + IntegerToString(ticket);
|
||
if(!GlobalVariableCheck(gvP))
|
||
{
|
||
double lotStep = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_STEP);
|
||
if(lotStep <= 0) lotStep = 0.01;
|
||
double closeLot = MathFloor((volume * PartialPercent / 100.0) / lotStep) * lotStep;
|
||
closeLot = NormalizeDouble(closeLot, 2);
|
||
double minLot = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MIN);
|
||
if(closeLot >= minLot && (volume - closeLot) >= minLot)
|
||
{
|
||
trade.SetExpertMagicNumber(MagicSwing);
|
||
if(trade.PositionClosePartial(ticket, closeLot))
|
||
GlobalVariableSet(gvP, 1.0);
|
||
}
|
||
}
|
||
}
|
||
|
||
// Breakeven
|
||
if(profitDist >= atr * BE_ATR_Multi)
|
||
{
|
||
double lock = atr * 0.2;
|
||
if(type==POSITION_TYPE_BUY)
|
||
{
|
||
double nSL = NormalizePrice(openPrice + lock);
|
||
if(sl < nSL)
|
||
{
|
||
trade.SetExpertMagicNumber(MagicSwing);
|
||
trade.PositionModify(ticket, nSL, tp);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
double nSL = NormalizePrice(openPrice - lock);
|
||
if(sl > nSL || sl == 0)
|
||
{
|
||
trade.SetExpertMagicNumber(MagicSwing);
|
||
trade.PositionModify(ticket, nSL, tp);
|
||
}
|
||
}
|
||
}
|
||
|
||
// Progressive Trailing + Dynamic TP Extension
|
||
if(profitDist >= atr * Trail_ATR_Multi)
|
||
{
|
||
double baseDist = atr * Trail_Step_ATR;
|
||
double profATR = profitDist / atr;
|
||
double tightF = MathMax(0.4, 1.0 - (profATR - Trail_ATR_Multi) * 0.15);
|
||
double trailDist = baseDist * tightF;
|
||
|
||
// Dynamic TP: jika harga sudah > 80% jarak ke TP, extend TP 1 ATR
|
||
double tpDist = (type==POSITION_TYPE_BUY) ? (tp - openPrice) : (openPrice - tp);
|
||
double newTP = tp;
|
||
if(tp > 0 && tpDist > 0 && profitDist >= tpDist * 0.8)
|
||
{
|
||
if(type==POSITION_TYPE_BUY)
|
||
newTP = NormalizePrice(tp + atr);
|
||
else
|
||
newTP = NormalizePrice(tp - atr);
|
||
}
|
||
|
||
if(type==POSITION_TYPE_BUY)
|
||
{
|
||
double nSL = NormalizePrice(price - trailDist);
|
||
// Trailing step minimal 10% dari ATR untuk mencegah spamming order modifikasi ke broker
|
||
if((nSL - sl >= atr * 0.1 || sl == 0) && nSL > openPrice)
|
||
{
|
||
trade.SetExpertMagicNumber(MagicSwing);
|
||
trade.PositionModify(ticket, nSL, newTP);
|
||
}
|
||
else if(newTP != tp && newTP > tp)
|
||
{
|
||
trade.SetExpertMagicNumber(MagicSwing);
|
||
trade.PositionModify(ticket, sl, newTP);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
double nSL = NormalizePrice(price + trailDist);
|
||
// Trailing step minimal 10% dari ATR
|
||
if((sl - nSL >= atr * 0.1 || sl == 0) && nSL < openPrice)
|
||
{
|
||
trade.SetExpertMagicNumber(MagicSwing);
|
||
trade.PositionModify(ticket, nSL, newTP);
|
||
}
|
||
else if(newTP != tp && newTP < tp)
|
||
{
|
||
trade.SetExpertMagicNumber(MagicSwing);
|
||
trade.PositionModify(ticket, sl, newTP);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
//============================================================
|
||
// MANAGE SCALP POSITIONS (fast BE + quick trail)
|
||
//============================================================
|
||
void ManageScalp()
|
||
{
|
||
double atrNow[];
|
||
ArraySetAsSeries(atrNow, true);
|
||
if(CopyBuffer(atr_handle, 0, 0, 1, atrNow) < 1) return;
|
||
double atr = atrNow[0];
|
||
if(atr <= 0) return;
|
||
|
||
// BB mid untuk dynamic TP
|
||
double bbMid[];
|
||
ArraySetAsSeries(bbMid, true);
|
||
if(CopyBuffer(bb_handle, 0, 0, 1, bbMid) < 1) return;
|
||
|
||
double beTrigger = atr * Scalp_BE_ATR; // Adaptive BE trigger
|
||
double lockDist = atr * 0.05; // Lock ~5% ATR profit
|
||
double trailDist = atr * Scalp_Trail_ATR; // Adaptive trail distance
|
||
double trailStart = beTrigger * 1.5; // Trail mulai setelah 1.5x BE trigger
|
||
|
||
for(int i = PositionsTotal()-1; i >= 0; i--)
|
||
{
|
||
ulong ticket = PositionGetTicket(i);
|
||
if(!PositionSelectByTicket(ticket)) continue;
|
||
if(PositionGetString(POSITION_SYMBOL) != _Symbol) continue;
|
||
if(PositionGetInteger(POSITION_MAGIC) != MagicScalp) continue;
|
||
|
||
double openPrice = PositionGetDouble(POSITION_PRICE_OPEN);
|
||
double sl = PositionGetDouble(POSITION_SL);
|
||
double tp = PositionGetDouble(POSITION_TP);
|
||
int type = (int)PositionGetInteger(POSITION_TYPE);
|
||
|
||
double price = (type==POSITION_TYPE_BUY) ?
|
||
SymbolInfoDouble(_Symbol,SYMBOL_BID) :
|
||
SymbolInfoDouble(_Symbol,SYMBOL_ASK);
|
||
|
||
double profitDist = (type==POSITION_TYPE_BUY) ?
|
||
(price-openPrice) : (openPrice-price);
|
||
|
||
// Adaptive Breakeven
|
||
if(profitDist >= beTrigger)
|
||
{
|
||
if(type==POSITION_TYPE_BUY)
|
||
{
|
||
double nSL = NormalizePrice(openPrice + lockDist);
|
||
if(sl < nSL)
|
||
{
|
||
trade.SetExpertMagicNumber(MagicScalp);
|
||
trade.PositionModify(ticket, nSL, tp);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
double nSL = NormalizePrice(openPrice - lockDist);
|
||
if(sl > nSL || sl == 0)
|
||
{
|
||
trade.SetExpertMagicNumber(MagicScalp);
|
||
trade.PositionModify(ticket, nSL, tp);
|
||
}
|
||
}
|
||
}
|
||
|
||
// Adaptive Trailing + Dynamic TP toward BB mid
|
||
if(profitDist >= trailStart)
|
||
{
|
||
// Dynamic TP: geser ke BB mid secara dinamis mengikuti pergerakan band
|
||
double newTP = tp;
|
||
if(type==POSITION_TYPE_BUY && bbMid[0] > price)
|
||
newTP = NormalizePrice(bbMid[0]);
|
||
else if(type==POSITION_TYPE_SELL && bbMid[0] < price)
|
||
newTP = NormalizePrice(bbMid[0]);
|
||
|
||
// Hanya modifikasi jika perbedaan TP cukup signifikan untuk mencegah spamming order ke broker
|
||
bool updateTP = (newTP != tp && MathAbs(tp - newTP) >= atr * 0.1);
|
||
|
||
if(type==POSITION_TYPE_BUY)
|
||
{
|
||
double nSL = NormalizePrice(price - trailDist);
|
||
// Trailing step minimal 5% dari ATR untuk scalp
|
||
if((nSL - sl >= atr * 0.05 || sl == 0) && nSL > openPrice)
|
||
{
|
||
trade.SetExpertMagicNumber(MagicScalp);
|
||
trade.PositionModify(ticket, nSL, newTP);
|
||
}
|
||
else if(updateTP)
|
||
{
|
||
trade.SetExpertMagicNumber(MagicScalp);
|
||
trade.PositionModify(ticket, sl, newTP);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
double nSL = NormalizePrice(price + trailDist);
|
||
// Trailing step minimal 5% dari ATR untuk scalp
|
||
if((sl - nSL >= atr * 0.05 || sl == 0) && nSL < openPrice)
|
||
{
|
||
trade.SetExpertMagicNumber(MagicScalp);
|
||
trade.PositionModify(ticket, nSL, newTP);
|
||
}
|
||
else if(updateTP)
|
||
{
|
||
trade.SetExpertMagicNumber(MagicScalp);
|
||
trade.PositionModify(ticket, sl, newTP);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
//============================================================
|
||
// ON TRADE EVENT
|
||
//============================================================
|
||
void OnTrade()
|
||
{
|
||
datetime dayStart = iTime(_Symbol, PERIOD_D1, 0);
|
||
|
||
// Reset counter saat ganti hari (fix day-boundary bug)
|
||
if(dayStart != lastTradeDay)
|
||
{
|
||
lastDealsTotal = 0;
|
||
lastTradeDay = dayStart;
|
||
}
|
||
|
||
HistorySelect(dayStart, TimeCurrent());
|
||
int currentTotal = HistoryDealsTotal();
|
||
|
||
if(currentTotal > lastDealsTotal)
|
||
{
|
||
for(int i = lastDealsTotal; i < currentTotal; i++)
|
||
{
|
||
ulong ticket = HistoryDealGetTicket(i);
|
||
if(ticket == 0) continue;
|
||
long magic = (long)HistoryDealGetInteger(ticket, DEAL_MAGIC);
|
||
if(magic != MagicSwing && magic != MagicScalp) continue;
|
||
if(HistoryDealGetString(ticket, DEAL_SYMBOL) != _Symbol) continue;
|
||
if(HistoryDealGetInteger(ticket, DEAL_ENTRY) != DEAL_ENTRY_OUT) continue;
|
||
|
||
double profit = HistoryDealGetDouble(ticket, DEAL_PROFIT)
|
||
+ HistoryDealGetDouble(ticket, DEAL_SWAP)
|
||
+ HistoryDealGetDouble(ticket, DEAL_COMMISSION);
|
||
|
||
string mode = (magic == MagicScalp) ? "SCALP" : "SWING";
|
||
|
||
if(profit < 0)
|
||
{
|
||
consecLosses++;
|
||
lastLossTime = (datetime)HistoryDealGetInteger(ticket, DEAL_TIME);
|
||
Print(mode, " LOSS #", consecLosses, " net=", DoubleToString(profit,2));
|
||
}
|
||
else if(profit > 0)
|
||
{
|
||
if(consecLosses > 0)
|
||
Print(mode, " WIN +", DoubleToString(profit,2), " after ", consecLosses, " losses");
|
||
consecLosses = 0;
|
||
}
|
||
|
||
// Cleanup GlobalVariable partial close
|
||
ulong posId = (ulong)HistoryDealGetInteger(ticket, DEAL_POSITION_ID);
|
||
string gvP = "HUP5_SwP_" + IntegerToString(posId);
|
||
if(GlobalVariableCheck(gvP)) GlobalVariableDel(gvP);
|
||
}
|
||
}
|
||
lastDealsTotal = currentTotal;
|
||
}
|
||
|
||
//============================================================
|
||
// MAIN TICK
|
||
//============================================================
|
||
void OnTick()
|
||
{
|
||
// ===== Management setiap tick =====
|
||
ManageSwing();
|
||
ManageScalp();
|
||
|
||
// ===== Circuit breakers =====
|
||
if(!EquitySafe()) return;
|
||
CheckWeekendClose();
|
||
|
||
// ===== Bar baru check =====
|
||
datetime now = iTime(_Symbol, _Period, 0);
|
||
bool newBar = (now != lastSwingBar);
|
||
if(newBar) lastSwingBar = now;
|
||
|
||
if(!newBar) return; // Semua entry hanya di bar baru
|
||
|
||
// ===== Global filters =====
|
||
if(!DailySafe()) return;
|
||
if(!CooldownOK()) return;
|
||
if(DailyTargetReached()) return; // Sudah cukup profit hari ini
|
||
if(!MarginOK()) return; // Margin terlalu rendah
|
||
|
||
// ===== Load indicators =====
|
||
if(!LoadIndicators()) return;
|
||
|
||
double atr = atr_val[1];
|
||
if(atr < _Point * 10) return; // Proteksi batas spread dasar (sangat kecil)
|
||
if(!IsVolatilityOk()) return; // Filter volatilitas adaptif
|
||
|
||
double bid = SymbolInfoDouble(_Symbol, SYMBOL_BID);
|
||
double ask = SymbolInfoDouble(_Symbol, SYMBOL_ASK);
|
||
|
||
int totalPos = CountAllMyPositions();
|
||
|
||
// =========================================================
|
||
// ENGINE 1: SWING ENTRIES
|
||
// =========================================================
|
||
if(SpreadOK(MaxSpread) && SessionOK() && !IsNearNewsHour() && totalPos < MaxTotalPos)
|
||
{
|
||
int swingPos = CountPositions(MagicSwing);
|
||
|
||
// --- SWING BUY ---
|
||
if(SwingBuySignal() && swingPos < MaxSwingPos)
|
||
{
|
||
if(CloseOnOpposite) ClosePositions(MagicSwing, +1); // close sells
|
||
|
||
double slP = NormalizePrice(iLow(_Symbol,_Period,1) - atr * ATR_SL_Multi);
|
||
if(slP < ask)
|
||
{
|
||
double minD = atr * 0.5;
|
||
if((ask - slP) < minD) slP = NormalizePrice(ask - minD);
|
||
|
||
double tpP = NormalizePrice(ask + (ask - slP) * Swing_RR);
|
||
|
||
if(ValidateSLTP(ask, slP, tpP, +1))
|
||
{
|
||
double lot = LotCalc((ask - slP) / _Point, RiskPercent);
|
||
if(lot > 0)
|
||
{
|
||
trade.SetExpertMagicNumber(MagicSwing);
|
||
if(trade.Buy(lot, _Symbol, ask, slP, tpP, "SWING BUY"))
|
||
Print("SWING BUY: Lot=", lot, " SL=", slP, " TP=", tpP);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// --- SWING SELL ---
|
||
if(SwingSellSignal() && swingPos < MaxSwingPos)
|
||
{
|
||
if(CloseOnOpposite) ClosePositions(MagicSwing, -1); // close buys
|
||
|
||
double slP = NormalizePrice(iHigh(_Symbol,_Period,1) + atr * ATR_SL_Multi);
|
||
if(slP > bid)
|
||
{
|
||
double minD = atr * 0.5;
|
||
if((slP - bid) < minD) slP = NormalizePrice(bid + minD);
|
||
|
||
double tpP = NormalizePrice(bid - (slP - bid) * Swing_RR);
|
||
|
||
if(ValidateSLTP(bid, slP, tpP, -1))
|
||
{
|
||
double lot = LotCalc((slP - bid) / _Point, RiskPercent);
|
||
if(lot > 0)
|
||
{
|
||
trade.SetExpertMagicNumber(MagicSwing);
|
||
if(trade.Sell(lot, _Symbol, bid, slP, tpP, "SWING SELL"))
|
||
Print("SWING SELL: Lot=", lot, " SL=", slP, " TP=", tpP);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
totalPos = CountAllMyPositions(); // Refresh setelah swing mungkin buka posisi
|
||
|
||
// =========================================================
|
||
// ENGINE 2: SCALP ENTRIES
|
||
// =========================================================
|
||
if(EnableScalp && SpreadOK(Scalp_MaxSpread) && ScalpSessionOK() && !IsNearNewsHour() && totalPos < MaxTotalPos)
|
||
{
|
||
int scalpPos = CountPositions(MagicScalp);
|
||
|
||
// --- SCALP BUY (BB lower bounce) ---
|
||
if(ScalpBuySignal() && scalpPos < MaxScalpPos)
|
||
{
|
||
double slDist = atr * Scalp_SL_ATR;
|
||
double slP = NormalizePrice(ask - slDist);
|
||
double tpP = NormalizePrice(ask + slDist * Scalp_RR);
|
||
|
||
// TP tidak melewati BB mid (target realistis)
|
||
if(tpP > bb_mid[0])
|
||
tpP = NormalizePrice(bb_mid[0]);
|
||
|
||
// Pastikan masih ada ruang profit minimal 0.5x SL
|
||
if((tpP - ask) < slDist * 0.5) { /* skip, target terlalu kecil */ }
|
||
else if(ValidateSLTP(ask, slP, tpP, +1))
|
||
{
|
||
double lot = LotCalc(slDist / _Point, ScalpRiskPercent);
|
||
if(lot > 0)
|
||
{
|
||
trade.SetExpertMagicNumber(MagicScalp);
|
||
if(trade.Buy(lot, _Symbol, ask, slP, tpP, "SCALP BUY"))
|
||
Print("SCALP BUY: Lot=", lot, " SL=", slP, " TP=", tpP,
|
||
" BB_low=", DoubleToString(bb_lower[1],_Digits));
|
||
}
|
||
}
|
||
}
|
||
|
||
// --- SCALP SELL (BB upper bounce) ---
|
||
if(ScalpSellSignal() && scalpPos < MaxScalpPos)
|
||
{
|
||
double slDist = atr * Scalp_SL_ATR;
|
||
double slP = NormalizePrice(bid + slDist);
|
||
double tpP = NormalizePrice(bid - slDist * Scalp_RR);
|
||
|
||
// TP tidak melewati BB mid
|
||
if(tpP < bb_mid[0])
|
||
tpP = NormalizePrice(bb_mid[0]);
|
||
|
||
// Pastikan masih ada ruang profit minimal 0.5x SL
|
||
if((bid - tpP) < slDist * 0.5) { /* skip */ }
|
||
else if(ValidateSLTP(bid, slP, tpP, -1))
|
||
{
|
||
double lot = LotCalc(slDist / _Point, ScalpRiskPercent);
|
||
if(lot > 0)
|
||
{
|
||
trade.SetExpertMagicNumber(MagicScalp);
|
||
if(trade.Sell(lot, _Symbol, bid, slP, tpP, "SCALP SELL"))
|
||
Print("SCALP SELL: Lot=", lot, " SL=", slP, " TP=", tpP,
|
||
" BB_up=", DoubleToString(bb_upper[1],_Digits));
|
||
}
|
||
}
|
||
}
|
||
}
|
||
} |