Stoch EA-mm

Author: Mumsie

Profit factor:

1.22

This automated trading script is designed to manage and execute trades on the MetaTrader platform by analyzing a variety of technical indicators simultaneously. It functions as an autonomous "Expert Advisor," meaning it monitors the market data in real-time and makes decisions based on pre-defined mathematical conditions.

Core Trading Logic

The script operates by evaluating several different technical analysis tools to determine the best moment to enter or exit a trade. Rather than relying on a single indicator, it uses a multi-layered approach involving:

Stochastic Oscillators: It monitors price momentum across various timeframes (including the current chart and the 4-hour chart) to identify "overbought" or "oversold" conditions.
Moving Averages: The script checks the relationship between current prices and historical averages to determine the overall trend direction.
Williams Percent Range (WPR): It utilizes this indicator to gauge where the price is relative to its high-low range over a specific period.

Entry and Exit Conditions

The script follows a strict logical flow to decide when to take action:

Entry Signals: To open a "Buy" or "Sell" position, the script looks for specific combinations of these indicators hitting designated thresholds at the same time. For instance, it requires multiple conditions—such as certain oscillators being below specific values and others above them—to align before it authorizes a trade.
Exit Signals: The script also monitors specific "Close" conditions. If price momentum shifts significantly (monitored via the WPR indicator), the script can trigger an automatic exit to protect profits or limit losses before a manual stop is hit.
Trade Management: Once a trade is active, the script includes features for:
- Stop Loss & Take Profit: Automatically sets price limits to close a trade if it moves against you or reaches a target profit.
- Trailing Stop: A dynamic feature that adjusts your stop loss level in real-time as the market moves in your favor, "locking in" gains while keeping the trade open.

Automated Account Management

Beyond just opening and closing trades, the script includes intelligent risk management:

Dynamic Lot Sizing: It can automatically calculate how many units (lots) to trade based on your available account balance. This helps ensure that the trade size is proportional to the amount of capital you have available.
Margin Protection: Before opening any new position, the script checks your "Free Margin" to ensure you have enough funds to cover the trade. If the account is insufficient, it will skip the trade to prevent errors.
Notifications: The system can be configured to send email alerts whenever a trade is opened or closed, allowing you to monitor the bot's activity remotely.

Operational Modes

The script offers flexibility in how it "thinks":

Tick Mode: It can be set to check for new signals every time the price changes (every tick) or only when a new candle forms on the chart.
Execution Safety: It includes a "Slippage" buffer to ensure that orders are executed at acceptable prices even during fast-moving market conditions.

Price Data Components

Orders Execution

Indicators Used

Miscellaneous

10 Views

1 Downloads

0 Favorites

Stoch EA-mm

//+------------------------------------------------------------------+
//| This MQL is created by Mumsie                                    |
//|                                                                  |
//|                                                                  |
//|  In no event will author be liable for any damages whatsoever.   |
//|                      Use at your own risk.                       |
//|                                                                  |
//+------------------- DO NOT REMOVE THIS HEADER --------------------+

#define SIGNAL_NONE 0
#define SIGNAL_BUY   1
#define SIGNAL_SELL  2
#define SIGNAL_CLOSEBUY 3
#define SIGNAL_CLOSESELL 4
extern int mm=1; 
extern int reinv=10; 

extern int maxLots=50;
#property copyright "Mumsie"

extern int MagicNumber = 0;
extern bool SignalMail = False;
extern bool EachTickMode = True;
extern double Lots = 1;
extern int Slippage = 3;
extern bool UseStopLoss = False;
extern int StopLoss = 100;
extern bool UseTakeProfit = False;
extern int TakeProfit = 200;
extern bool UseTrailingStop = False;
extern int TrailingStop = 45;

int BarCount;
int Current;
bool TickCheck = False;
//+------------------------------------------------------------------+
//| expert initialization function                                   |
//+------------------------------------------------------------------+
int init() {
   BarCount = Bars;

   if (EachTickMode) Current = 0; else Current = 1;

   return(0);
}
//+------------------------------------------------------------------+
//| expert deinitialization function                                 |
//+------------------------------------------------------------------+
int deinit() {
   return(0);
}
//+------------------------------------------------------------------+
//| expert start function                                            |
//+------------------------------------------------------------------+
int start() {
   int Order = SIGNAL_NONE;
   int Total, Ticket;
   double StopLossLevel, TakeProfitLevel;



   if (EachTickMode && Bars != BarCount) TickCheck = False;
   Total = OrdersTotal();
   Order = SIGNAL_NONE;

   //+------------------------------------------------------------------+
   //| Variable Begin                                                   |
   //+------------------------------------------------------------------+


double Buy1_1 = iStochastic(NULL, 0, 8, 3, 3, MODE_SMA, 0, MODE_MAIN, Current + 1);
double Buy1_2 = 20;
double Buy2_1 = iStochastic(NULL, 0, 8, 3, 3, MODE_SMA, 0, MODE_MAIN, Current + 2);
double Buy2_2 = 20;
double Buy3_1 = iStochastic(NULL, 0, 8, 3, 3, MODE_SMA, 0, MODE_SIGNAL, Current + 2);
double Buy3_2 = 0;
double Buy4_1 = iStochastic(NULL, 0, 8, 3, 3, MODE_SMA, 0, MODE_SIGNAL, Current + 1);
double Buy4_2 = 20;
double Buy5_1 = iStochastic(NULL, 0, 8, 3, 3, MODE_SMA, 0, MODE_MAIN, Current + 0);
double Buy5_2 = 20;
double Buy6_1 = iStochastic(NULL, 0, 8, 3, 3, MODE_SMA, 0, MODE_SIGNAL, Current + 0);
double Buy6_2 = 20;
double Buy7_1 = iStochastic(NULL, 0, 8, 3, 3, MODE_SMA, 0, MODE_MAIN, Current + 0);
double Buy7_2 = iStochastic(NULL, 0, 8, 3, 3, MODE_SMA, 0, MODE_SIGNAL, Current + 0);
double Buy8_1 = iMA(NULL, 0, 20, 0, MODE_SMMA, PRICE_CLOSE, Current + 0);
double Buy8_2 = iHigh(NULL, 0, Current + 1);
double Buy9_1 = iStochastic(NULL, PERIOD_H4, 8, 3, 3, MODE_SMA, 0, MODE_MAIN, Current + 0);
double Buy9_2 = iStochastic(NULL, PERIOD_H4, 8, 3, 3, MODE_SMA, 0, MODE_SIGNAL, Current + 0);
double Buy10_1 = iWPR(NULL, 0, 14, Current + 0);
double Buy10_2 = -20;

double Sell1_1 = iStochastic(NULL, 0, 8, 3, 3, MODE_SMA, 0, MODE_MAIN, Current + 1);
double Sell1_2 = 80;
double Sell2_1 = iStochastic(NULL, 0, 8, 3, 3, MODE_SMA, 0, MODE_MAIN, Current + 2);
double Sell2_2 = 80;
double Sell3_1 = iStochastic(NULL, 0, 8, 3, 3, MODE_SMA, 0, MODE_SIGNAL, Current + 2);
double Sell3_2 = 80;
double Sell4_1 = iStochastic(NULL, 0, 8, 3, 3, MODE_SMA, 0, MODE_SIGNAL, Current + 1);
double Sell4_2 = 80;
double Sell5_1 = iStochastic(NULL, 0, 8, 3, 3, MODE_SMA, 0, MODE_MAIN, Current + 0);
double Sell5_2 = 80;
double Sell6_1 = iStochastic(NULL, 0, 8, 3, 3, MODE_SMA, 0, MODE_SIGNAL, Current + 0);
double Sell6_2 = 80;
double Sell7_1 = iStochastic(NULL, 0, 8, 3, 3, MODE_SMA, 0, MODE_MAIN, Current + 0);
double Sell7_2 = iStochastic(NULL, 0, 8, 3, 3, MODE_SMA, 0, MODE_SIGNAL, Current + 0);
double Sell8_1 = iStochastic(NULL, PERIOD_H4, 8, 3, 3, MODE_SMA, 0, MODE_MAIN, Current + 0);
double Sell8_2 = iStochastic(NULL, PERIOD_H4, 8, 3, 3, MODE_SMA, 0, MODE_SIGNAL, Current + 0);
double Sell9_1 = iMA(NULL, 0, 20, 0, MODE_SMMA, PRICE_CLOSE, Current + 0);
double Sell9_2 = iLow(NULL, 0, Current + 0);
double Sell10_1 = iWPR(NULL, 0, 14, Current + 0);
double Sell10_2 = -80;

double CloseBuy1_1 = iWPR(NULL, 0, 14, Current + 1);
double CloseBuy1_2 = -3;

double CloseSell1_1 = iWPR(NULL, 0, 14, Current + 1);
double CloseSell1_2 = -95;

   
   //+------------------------------------------------------------------+
   //| Variable End                                                     |
   //+------------------------------------------------------------------+

   //Check position
   bool IsTrade = False;

   for (int i = 0; i < Total; i ++) {
      OrderSelect(i, SELECT_BY_POS, MODE_TRADES);
      if(OrderType() <= OP_SELL &&  OrderSymbol() == Symbol()) {
         IsTrade = True;
         if(OrderType() == OP_BUY) {
            //Close

            //+------------------------------------------------------------------+
            //| Signal Begin(Exit Buy)                                           |
            //+------------------------------------------------------------------+

                     if (CloseBuy1_1 > CloseBuy1_2) Order = SIGNAL_CLOSEBUY;


            //+------------------------------------------------------------------+
            //| Signal End(Exit Buy)                                             |
            //+------------------------------------------------------------------+

            if (Order == SIGNAL_CLOSEBUY && ((EachTickMode && !TickCheck) || (!EachTickMode && (Bars != BarCount)))) {
               OrderClose(OrderTicket(), OrderLots(), Bid, Slippage, MediumSeaGreen);
               if (SignalMail) SendMail("[Signal Alert]", "[" + Symbol() + "] " + DoubleToStr(Bid, Digits) + " Close Buy");
               if (!EachTickMode) BarCount = Bars;
               IsTrade = False;
               continue;
            }
            //Trailing stop
            if(UseTrailingStop && TrailingStop > 0) {                 
               if(Bid - OrderOpenPrice() > Point * TrailingStop) {
                  if(OrderStopLoss() < Bid - Point * TrailingStop) {
                     OrderModify(OrderTicket(), OrderOpenPrice(), Bid - Point * TrailingStop, OrderTakeProfit(), 0, MediumSeaGreen);
                     if (!EachTickMode) BarCount = Bars;
                     continue;
                  }
               }
            }
         } else {
            //Close

            //+------------------------------------------------------------------+
            //| Signal Begin(Exit Sell)                                          |
            //+------------------------------------------------------------------+

                     if (CloseSell1_1 < CloseSell1_2) Order = SIGNAL_CLOSESELL;


            //+------------------------------------------------------------------+
            //| Signal End(Exit Sell)                                            |
            //+------------------------------------------------------------------+

            if (Order == SIGNAL_CLOSESELL && ((EachTickMode && !TickCheck) || (!EachTickMode && (Bars != BarCount)))) {
               OrderClose(OrderTicket(), OrderLots(), Ask, Slippage, DarkOrange);
               if (SignalMail) SendMail("[Signal Alert]", "[" + Symbol() + "] " + DoubleToStr(Ask, Digits) + " Close Sell");
               if (!EachTickMode) BarCount = Bars;
               IsTrade = False;
               continue;
            }
            //Trailing stop
            if(UseTrailingStop && TrailingStop > 0) {                 
               if((OrderOpenPrice() - Ask) > (Point * TrailingStop)) {
                  if((OrderStopLoss() > (Ask + Point * TrailingStop)) || (OrderStopLoss() == 0)) {
                     OrderModify(OrderTicket(), OrderOpenPrice(), Ask + Point * TrailingStop, OrderTakeProfit(), 0, DarkOrange);
                     if (!EachTickMode) BarCount = Bars;
                     continue;
                  }
               }
            }
         }
      }
   }

   //+------------------------------------------------------------------+
   //| Signal Begin(Entry)                                              |
   //+------------------------------------------------------------------+

   if (Buy1_1 < Buy1_2 || Buy2_1 < Buy2_2 && Buy3_1 < Buy3_2 || Buy4_1 < Buy4_2 && Buy5_1 > Buy5_2 && Buy6_1 > Buy6_2 && Buy7_1 > Buy7_2 && Buy8_1 < Buy8_2 && Buy9_1 > Buy9_2 && Buy10_1 < Buy10_2) Order = SIGNAL_BUY;

   if (Sell1_1 > Sell1_2 || Sell2_1 > Sell2_2 && Sell3_1 > Sell3_2 || Sell4_1 > Sell4_2 && Sell5_1 < Sell5_2 && Sell6_1 < Sell6_2 && Sell7_1 < Sell7_2 && Sell8_1 < Sell8_2 && Sell9_1 > Sell9_2 && Sell10_1 > Sell10_2) Order = SIGNAL_SELL;


   //+------------------------------------------------------------------+
   //| Signal End                                                       |
   //+------------------------------------------------------------------+
if (mm==1) 
{ 
if(Lots<(MathCeil((AccountFreeMargin()/1000)*reinv)/10)){Lots=(MathCeil((AccountFreeMargin()/10000)*reinv)/10);if(Lots>maxLots){Lots=maxLots;}} 
} 
   //Buy
   if (Order == SIGNAL_BUY && ((EachTickMode && !TickCheck) || (!EachTickMode && (Bars != BarCount)))) {
      if(!IsTrade) {
         //Check free margin
         if (AccountFreeMargin() < (1000 * Lots)) {
            Print("We have no money. Free Margin = ", AccountFreeMargin());
            return(0);
         }

         if (UseStopLoss) StopLossLevel = Ask - StopLoss * Point; else StopLossLevel = 0.0;
         if (UseTakeProfit) TakeProfitLevel = Ask + TakeProfit * Point; else TakeProfitLevel = 0.0;

         Ticket = OrderSend(Symbol(), OP_BUY, Lots, Ask, Slippage, StopLossLevel, TakeProfitLevel, "Buy(#" + MagicNumber + ")", MagicNumber, 0, DodgerBlue);
         if(Ticket > 0) {
            if (OrderSelect(Ticket, SELECT_BY_TICKET, MODE_TRADES)) {
				Print("BUY order opened : ", OrderOpenPrice());
                if (SignalMail) SendMail("[Signal Alert]", "[" + Symbol() + "] " + DoubleToStr(Ask, Digits) + " Open Buy");
			} else {
				Print("Error opening BUY order : ", GetLastError());
			}
         }
         if (EachTickMode) TickCheck = True;
         if (!EachTickMode) BarCount = Bars;
         return(0);
      }
   }

   //Sell
   if (Order == SIGNAL_SELL && ((EachTickMode && !TickCheck) || (!EachTickMode && (Bars != BarCount)))) {
      if(!IsTrade) {
         //Check free margin
         if (AccountFreeMargin() < (1000 * Lots)) {
            Print("We have no money. Free Margin = ", AccountFreeMargin());
            return(0);
         }

         if (UseStopLoss) StopLossLevel = Bid + StopLoss * Point; else StopLossLevel = 0.0;
         if (UseTakeProfit) TakeProfitLevel = Bid - TakeProfit * Point; else TakeProfitLevel = 0.0;

         Ticket = OrderSend(Symbol(), OP_SELL, Lots, Bid, Slippage, StopLossLevel, TakeProfitLevel, "Sell(#" + MagicNumber + ")", MagicNumber, 0, DeepPink);
         if(Ticket > 0) {
            if (OrderSelect(Ticket, SELECT_BY_TICKET, MODE_TRADES)) {
				Print("SELL order opened : ", OrderOpenPrice());
                if (SignalMail) SendMail("[Signal Alert]", "[" + Symbol() + "] " + DoubleToStr(Bid, Digits) + " Open Sell");
			} else {
				Print("Error opening SELL order : ", GetLastError());
			}
         }
         if (EachTickMode) TickCheck = True;
         if (!EachTickMode) BarCount = Bars;
         return(0);
      }
   }

   if (!EachTickMode) BarCount = Bars;

   return(0);
}
//+------------------------------------------------------------------+

Profitability Reports

PERFORMANCE BY SYMBOL

Expected payoff

Average expected payoff across the available backtests for each symbol.

Positive Negative

EUR/USD Jul 2025 - Sep 2025

7.19

Total Trades 8

Won Trades 6

Lost trades 2

Win Rate 75.00 %

Expected payoff 183.80

Gross Profit 1708.00

Gross Loss -237.60

Total Net Profit 1470.40

-100%

-50%

50%

100%

Stoch EA-mm

Core Trading Logic

Entry and Exit Conditions

Automated Account Management

Operational Modes

Profitability Reports

Expected payoff

Similar scripts

Comments

Privacy Settings

Customize Cookie Preferences

Essential Cookies Required

Analytics & Performance

Advertising & Personalization

User Data Collection