| +
|
| //| StochasticScalper.mq5 |
|
| //| Copyright 2024, VerttaxxFX Organization |
|
| //| https://verttaxfx.com |
|
| //+------------------------------------------------------------------+
|
| #property copyright "Copyright 2024, VerttaxxFX"
|
| #property link "https://verttaxfx.com"
|
| #property version "1.01" // RECTIFIED: Version updated to reflect changes.
|
| // RECTIFIED: #property strict is obsolete in MQL5 and has been removed.
|
|
|
| //+------------------------------------------------------------------+
|
| //| Input parameters for the Kanban system |
|
| //+------------------------------------------------------------------+
|
| input ulong Inp_MagicNumber = 202409; // Unique Magic Number for this EA
|
| input int Inp_MaxOpenTickets = 1; // Max open trades (The Kanban limit)
|
| input double Inp_RiskPerTrade = 1.0; // Risk % per trade
|
| input bool Inp_UseEquityForRisk = false; // Use Equity? (False uses Balance)
|
|
|
| //+------------------------------------------------------------------+
|
| //| Input parameters for the Stochastic strategy |
|
| //+------------------------------------------------------------------+
|
| input int Inp_KPeriod = 14; // Stochastic K Period
|
| input int Inp_DPeriod = 3; // Stochastic D Period
|
| input int Inp_Slowing = 3; // Stochastic Slowing
|
| input int Inp_OverboughtLevel = 80; // Overbought Level
|
| input int Inp_OversoldLevel = 20; // Oversold Level
|
|
|
| //+------------------------------------------------------------------+
|
| //| Input parameters for trade management |
|
| //+------------------------------------------------------------------+
|
| input int Inp_StopLoss = 50; // Stop Loss (in pips) // RECTIFIED: Comment changed to 'pips' for clarity.
|
| input int Inp_TakeProfit = 75; // Take Profit (in pips) // RECTIFIED: Comment changed to 'pips' for clarity.
|
|
|
| //+------------------------------------------------------------------+
|
| //| Global variables |
|
| //+------------------------------------------------------------------+
|
| // RECTIFIED: The indicator handle is now a global variable.
|
| // This is created once in OnInit() for efficiency, instead of on every tick.
|
| int stoch_handle = INVALID_HANDLE;
|
|
|
| //+------------------------------------------------------------------+
|
| //| Expert initialization function |
|
| //+------------------------------------------------------------------+
|
| int OnInit()
|
| {
|
| // RECTIFIED: Create the indicator handle once when the EA starts.
|
| // This is vastly more efficient than creating it on every tick.
|
| stoch_handle = iStochastic(_Symbol, _Period, Inp_KPeriod, Inp_DPeriod, Inp_Slowing, MODE_SMA, STO_LOWHIGH);
|
|
|
| if(stoch_handle == INVALID_HANDLE)
|
| {
|
| Print("Failed to create Stochastic indicator handle. Error: ", GetLastError());
|
| return(INIT_FAILED);
|
| }
|
|
|
| // RECTIFIED: The old 'MyPoint' calculation was removed. MQL5's predefined
|
| // '_Point' variable and '_Digits' handle this automatically and more reliably.
|
| return(INIT_SUCCEEDED);
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Expert deinitialization function |
|
| //+------------------------------------------------------------------+
|
| void OnDeinit(const int reason)
|
| {
|
| // RECTIFIED: Release the indicator handle when the EA is removed or the chart is closed.
|
| // This frees up terminal resources and is good practice.
|
| if(stoch_handle != INVALID_HANDLE)
|
| {
|
| IndicatorRelease(stoch_handle);
|
| }
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Expert tick function |
|
| //+------------------------------------------------------------------+
|
| void OnTick()
|
| {
|
| // 1. Check Kanban first! If limit is reached, do nothing.
|
| if(!CheckKanban())
|
| return;
|
|
|
| // 2. Get Stochastic values
|
| double stoch_main0, stoch_signal0;
|
| if(!GetStochastic(0, stoch_main0, stoch_signal0)) return; // Current bar
|
|
|
| double stoch_main1, stoch_signal1;
|
| if(!GetStochastic(1, stoch_main1, stoch_signal1)) return; // Previous bar
|
|
|
| // 3. Check for BUY signal: Cross above oversold level
|
| if(stoch_main1 < Inp_OversoldLevel && stoch_main0 > Inp_OversoldLevel && stoch_main0 > stoch_signal0)
|
| {
|
| if(OpenOrder(ORDER_TYPE_BUY))
|
| Print("Buy order opened successfully.");
|
| }
|
|
|
| // 4. Check for SELL signal: Cross below overbought level
|
| if(stoch_main1 > Inp_OverboughtLevel && stoch_main0 < Inp_OverboughtLevel && stoch_main0 < stoch_signal0)
|
| {
|
| if(OpenOrder(ORDER_TYPE_SELL))
|
| Print("Sell order opened successfully.");
|
| }
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Kanban Function - Checks max open tickets |
|
| //+------------------------------------------------------------------+
|
| bool CheckKanban()
|
| {
|
| int current_tickets = 0;
|
|
|
| // Iterate through all open positions
|
| for(int i = PositionsTotal() - 1; i >= 0; i--)
|
| {
|
| // RECTIFIED: You must select a position by its index before you can get its properties.
|
| // The original code was missing this crucial step.
|
| if(PositionSelect(i))
|
| {
|
| if(PositionGetInteger(POSITION_MAGIC) == Inp_MagicNumber &&
|
| PositionGetString(POSITION_SYMBOL) == _Symbol)
|
| {
|
| current_tickets++;
|
| }
|
| }
|
| }
|
|
|
| // Also check pending orders
|
| for(int i = OrdersTotal() - 1; i >= 0; i--)
|
| {
|
| // RECTIFIED: OrderGetTicket(i) correctly gets the ticket number for the order at the specified index.
|
| ulong ord_ticket = OrderGetTicket(i);
|
|
|
| // RECTIFIED: The original functions OrderGetInteger(ORDER_MAGIC) were incorrect.
|
| // You must provide the ticket number to the function to specify which order you are querying.
|
| if(OrderGetInteger(ord_ticket, ORDER_MAGIC) == Inp_MagicNumber &&
|
| OrderGetString(ord_ticket, ORDER_SYMBOL) == _Symbol)
|
| {
|
| current_tickets++;
|
| }
|
| }
|
|
|
| // The Kanban rule: If current tickets >= max allowed, return false.
|
| if(current_tickets >= Inp_MaxOpenTickets)
|
| {
|
| Comment("Kanban Limit Reached. Current Trades: ", current_tickets);
|
| return false;
|
| }
|
| else
|
| {
|
| Comment("Kanban Status: OK. Current Trades: ", current_tickets);
|
| return true;
|
| }
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Function to get Stochastic values |
|
| //+------------------------------------------------------------------+
|
| // RECTIFIED: Function now returns a boolean to indicate success or failure.
|
| bool GetStochastic(int shift, double &main, double &signal)
|
| {
|
| // RECTIFIED: Check if the global handle is valid before using it.
|
| if(stoch_handle == INVALID_HANDLE) return false;
|
|
|
| double k[1];
|
| double d[1];
|
|
|
| // RECTIFIED: ArraySetAsSeries is not needed when copying only one element.
|
|
|
| // RECTIFIED: Use the globally created handle. Do not create or release it here.
|
| if(CopyBuffer(stoch_handle, 0, shift, 1, k) < 1 || CopyBuffer(stoch_handle, 1, shift, 1, d) < 1)
|
| {
|
| Print("Failed to copy stochastic buffers. Error ", GetLastError());
|
| return false;
|
| }
|
|
|
| main = k[0];
|
| signal = d[0];
|
| return true;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Function to calculate lot size based on risk |
|
| //+------------------------------------------------------------------+
|
| double CalculateLotSize(double risk_percent, bool use_equity)
|
| {
|
| double account_balance;
|
| if(use_equity) account_balance = AccountInfoDouble(ACCOUNT_EQUITY);
|
| else account_balance = AccountInfoDouble(ACCOUNT_BALANCE);
|
|
|
| double risk_amount = account_balance * (risk_percent / 100.0);
|
|
|
| // RECTIFIED: This logic is more robust for calculating the price distance of the stop loss
|
| // based on the input pips. It correctly handles both 3/5 and 2/4 digit brokers.
|
| double point_value = _Point * (_Digits == 3 || _Digits == 5 ? 10 : 1);
|
| double stop_loss_in_price = Inp_StopLoss * point_value;
|
|
|
| if(stop_loss_in_price == 0) return 0.01;
|
|
|
| // RECTIFIED: Using SymbolInfoDouble directly for clarity and correctness.
|
| double tick_value = SymbolInfoDouble(_Symbol, SYMBOL_TRADE_TICK_VALUE);
|
| double tick_size = SymbolInfoDouble(_Symbol, SYMBOL_TRADE_TICK_SIZE);
|
|
|
| if(tick_size == 0 || tick_value == 0) return 0.01;
|
|
|
| double loss_per_lot = (stop_loss_in_price / tick_size) * tick_value;
|
|
|
| if(loss_per_lot == 0) return 0.01;
|
|
|
| double lot_size = risk_amount / loss_per_lot;
|
|
|
| // Normalize and validate lot size
|
| double vol_step = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_STEP);
|
| lot_size = MathRound(lot_size / vol_step) * vol_step;
|
|
|
| double min_vol = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MIN);
|
| double max_vol = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MAX);
|
|
|
| if(lot_size < min_vol) lot_size = min_vol;
|
| if(lot_size > max_vol) lot_size = max_vol;
|
|
|
| return lot_size;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Function to open a new order |
|
| //+------------------------------------------------------------------+
|
| bool OpenOrder(ENUM_ORDER_TYPE order_type)
|
| {
|
| double bid_price = SymbolInfoDouble(_Symbol, SYMBOL_BID);
|
| double ask_price = SymbolInfoDouble(_Symbol, SYMBOL_ASK);
|
| double sl_price = 0, tp_price = 0;
|
| double open_price = 0;
|
|
|
| // RECTIFIED: More robust calculation for SL/TP in price units.
|
| double stop_loss_distance = Inp_StopLoss * _Point * (_Digits == 3 || _Digits == 5 ? 10 : 1);
|
| double take_profit_distance = Inp_TakeProfit * _Point * (_Digits == 3 || _Digits == 5 ? 10 : 1);
|
|
|
| MqlTradeRequest request;
|
| MqlTradeResult result;
|
| ZeroMemory(request);
|
| ZeroMemory(result);
|
|
|
| // Calculate lot size
|
| double lot_size = CalculateLotSize(Inp_RiskPerTrade, Inp_UseEquityForRisk);
|
| if(lot_size <= 0) return false;
|
|
|
| // Set order type and price
|
| if(order_type == ORDER_TYPE_BUY)
|
| {
|
| open_price = ask_price;
|
| sl_price = open_price - stop_loss_distance;
|
| tp_price = open_price + take_profit_distance;
|
| }
|
| else if(order_type == ORDER_TYPE_SELL)
|
| {
|
| open_price = bid_price;
|
| sl_price = open_price + stop_loss_distance;
|
| tp_price = open_price - take_profit_distance;
|
| }
|
|
|
| // Fill in the trade request structure
|
| request.action = TRADE_ACTION_DEAL;
|
| request.symbol = _Symbol;
|
| request.volume = lot_size;
|
| request.type = order_type;
|
| request.price = NormalizeDouble(open_price, _Digits);
|
| request.sl = NormalizeDouble(sl_price, _Digits);
|
| request.tp = NormalizeDouble(tp_price, _Digits);
|
| request.magic = Inp_MagicNumber;
|
| request.comment = "Stochastic Scalper EA";
|
| request.deviation = 10;
|
|
|
| // Send the order
|
| bool success = OrderSend(request, result);
|
| if(!success)
|
| {
|
| Print("OrderSend failed. Error code: ", result.retcode, " - ", result.comment);
|
| return false;
|
| }
|
|
|
| return true;
|
| }
|
|
|
| // RECTIFIED: The custom Point() function was redundant as MQL5 has a built-in _Point variable.
|
| // It has been removed.
|
| //+------------------------------------------------------------------+ |
