SmartCandleEA

//+-------------------------------------------------------------------------------------+
//|                                                                   SmartCandleEA.mq5 |
//|                                                       https://pastebin.com/cRhQ7rYz |
//+-------------------------------------------------------------------------------------+
#property copyright "ChatGPT"
#property version   "1.01"
#property strict
#define ColorAqua clrAqua
#define ColorRed clrRed

input double Lots       = 0.01;
input double SL_Points  = 890;    // stop loss in points
input double TP_Points  = 910;    // take profit in points
input double TrailStart = 690;     // trailing start in points
input double TrailStep  = 900;     // trailing step in points

//--- simbolul curent
string symbol;

//--- handle-uri pentru timeframe-uri
ENUM_TIMEFRAMES tfH1 = PERIOD_H1;
ENUM_TIMEFRAMES tfH4 = PERIOD_H4;
ENUM_TIMEFRAMES tfD1 = PERIOD_D1;
ENUM_TIMEFRAMES tfW1 = PERIOD_W1;

//--- nume obiecte grafice
string objNameH1 = "H1";
string objNameH4 = "H4";
string objNameD1 = "D1";
string objNameW1 = "W1";

// stochastic
double Karray[],Darray[];
//defining the stochastic indicator
int StochDef = iStochastic(_Symbol,_Period,14,3,3,MODE_SMA,STO_LOWHIGH);

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
   symbol = _Symbol;
   //ChartSetInteger(0, CHART_SHOW_PERIOD_SEPARATORS, false); // ascunde liniile perioadelor pentru claritate

   // curata obiecte vechi
   ObjectDelete(0,objNameH1);
   ObjectDelete(0,objNameH4);
   ObjectDelete(0,objNameD1);
   ObjectDelete(0,objNameW1);

   return(INIT_SUCCEEDED);
  }

//+------------------------------------------------------------------+
//| Functie pentru obtinerea valorilor OHLC pentru o anumita TF      |
//+------------------------------------------------------------------+
bool GetOHLC(ENUM_TIMEFRAMES tf, datetime &time_open, double &open, double &high, double &low, double &close)
  {
   MqlRates rates[];
   if(CopyRates(symbol, tf, 0, 1, rates) != 1)
     return(false);

   time_open = rates[0].time;
   open  = rates[0].open;
   high  = rates[0].high;
   low   = rates[0].low;
   close = rates[0].close;
   return(true);
  }

//+------------------------------------------------------------------+
//| Functie desenare candela suprapusa pe M1                         |
//+------------------------------------------------------------------+
void DrawCandleOverlay(string name, datetime time_open, double open, double high, double low, double close, color col)
  {
   // Șterge obiectul vechi daca exista
   ObjectDelete(0,name);

   // Creaza un obiect rectangle pe grafic cu următoarele coordonate:
   // pe orizontala, de la time_open pana la timpul curent (acum)
   // pe verticala, intre low si high

   datetime time_now = TimeCurrent();

   // creeaza rectangle
   if(!ObjectCreate(0, name, OBJ_RECTANGLE, 0, time_open, high, time_now, low))
     {
      Print("Eroare la crearea obiectului ", name);
      return;
     }

   // setari vizuale
   ObjectSetInteger(0, name, OBJPROP_COLOR, col);
   ObjectSetInteger(0, name, OBJPROP_BACK, true);      // sa fie in spate
   ObjectSetInteger(0, name, OBJPROP_STYLE, STYLE_SOLID);
   ObjectSetInteger(0, name, OBJPROP_WIDTH, 2);

   // Opacitate in functie de close > open
   if(close > open)
      ObjectSetInteger(0, name, OBJPROP_BGCOLOR, ColorToARGB(ColorAqua, 60));
   else
      ObjectSetInteger(0, name, OBJPROP_BGCOLOR, ColorToARGB(ColorRed, 60));
  }

//+-----------------------------------------------------------------+
//| Functie pentru conversia culorii cu opacitate                   |
//+-----------------------------------------------------------------+
ulong ColorToARGBAlpha(color c, uchar alpha)
  {
   return(((ulong)alpha << 24) | ((ulong)c & 0xFFFFFF));
  }

//+------------------------------------------------------------------+
//| Verifica regula simpla de intrare                                 |
//+------------------------------------------------------------------+
int CheckTradeSignal()
  {
   datetime t_open;
   double open, high, low, close;

   // Preluam OHLC pentru fiecare timeframe
   if(!GetOHLC(tfH1, t_open, open, high, low, close)) return 0;
   bool h1Buy  = (close > open);
   bool h1Sell = (close < open);

   if(!GetOHLC(tfH4, t_open, open, high, low, close)) return 0;
   bool h4Buy  = (close > open);
   bool h4Sell = (close < open);

   if(!GetOHLC(tfD1, t_open, open, high, low, close)) return 0;
   bool d1Buy  = (close > open);
   bool d1Sell = (close < open);

   if(!GetOHLC(tfW1, t_open, open, high, low, close)) return 0;
   bool w1Buy  = (close > open);
   bool w1Sell = (close < open);

// stochastic
//sorting arrays from the current data
   ArraySetAsSeries(Karray, true);
   ArraySetAsSeries(Darray, true);
//filling arrays with price data
   CopyBuffer(StochDef,0,0,3,Karray);
   CopyBuffer(StochDef,1,0,3,Darray);
//calculating value of %K and %D line of cuurent data
   double KValue0 = Karray[0];
   double DValue0 = Darray[0];
   double KValue1 = Karray[1];
   double DValue1 = Darray[1];

   // Conditii pentru BUY: toate in sus
   if(h1Buy && h4Buy && d1Buy && w1Buy &&  KValue0 < 20 && DValue0 < 20 && KValue0 > DValue0 && KValue1 < DValue1) return 1;

   // Conditii pentru SELL: toate in jos
   if(h1Sell && h4Sell && d1Sell && w1Sell && KValue0 > 80 && DValue0 > 80 && KValue0 < DValue0 && KValue1 > DValue1) return -1;

   return 0; // fara semnal clar
  }

//+------------------------------------------------------------------+
//| Functie executie ordine BUY                                       |
//+------------------------------------------------------------------+
bool OpenBuy()
  {
   double price = SymbolInfoDouble(symbol, SYMBOL_ASK);
   double sl    = price - SL_Points * _Point;
   double tp    = price + TP_Points * _Point;

   MqlTradeRequest request;
   MqlTradeResult  result;
   ZeroMemory(request);
   ZeroMemory(result);

   request.action   = TRADE_ACTION_DEAL;
   request.symbol   = symbol;
   request.volume   = Lots;
   request.type     = ORDER_TYPE_BUY;
   request.price    = price;
   request.sl       = sl;
   request.tp       = tp;
   request.deviation= 10;
   request.magic    = 123456;
   request.comment  = "SmartCandleEA_Buy";

   if(!OrderSend(request, result))
     {
      Print("Eroare la deschiderea BUY: ", GetLastError());
      return false;
     }
   Print("Buy deschis la ", price);
   return true;
  }

//+------------------------------------------------------------------+
//| Functie executie ordine SELL                                      |
//+------------------------------------------------------------------+
bool OpenSell()
  {
   double price = SymbolInfoDouble(symbol, SYMBOL_BID);
   double sl    = price + SL_Points * _Point;
   double tp    = price - TP_Points * _Point;

   MqlTradeRequest request;
   MqlTradeResult  result;
   ZeroMemory(request);
   ZeroMemory(result);

   request.action   = TRADE_ACTION_DEAL;
   request.symbol   = symbol;
   request.volume   = Lots;
   request.type     = ORDER_TYPE_SELL;
   request.price    = price;
   request.sl       = sl;
   request.tp       = tp;
   request.deviation= 10;
   request.magic    = 154326;
   request.comment  = "SmartCandleEA_Sell";

   if(!OrderSend(request, result))
     {
      Print("Eroare la deschiderea SELL: ", GetLastError());
      return false;
     }
   Print("Sell deschis la ", price);
   return true;
  }

//+------------------------------------------------------------------+
//| Functie de gestionare a trailing stop                            |
//+------------------------------------------------------------------+
void ManageTrailingStop()
  {
   ulong magic = 123456;
   for(int i=PositionsTotal()-1; i>=0; i--)
     {
      ulong ticket = PositionGetTicket(i);
      if(PositionGetInteger(POSITION_MAGIC) != magic) continue;
      if(PositionGetString(POSITION_SYMBOL) != symbol) continue;

      double open_price = PositionGetDouble(POSITION_PRICE_OPEN);
      double current_price = SymbolInfoDouble(symbol, (PositionGetInteger(POSITION_TYPE)==POSITION_TYPE_BUY) ? SYMBOL_BID : SYMBOL_ASK);
      double sl = PositionGetDouble(POSITION_SL);
      ENUM_POSITION_TYPE pos_type = (ENUM_POSITION_TYPE)PositionGetInteger(POSITION_TYPE);

      // Calculate profit in points
      double profit_points = (pos_type==POSITION_TYPE_BUY) ? (current_price - open_price)/_Point : (open_price - current_price)/_Point;

      if(profit_points > TrailStart)
        {
         double new_sl;
         if(pos_type==POSITION_TYPE_BUY)
           {
            new_sl = current_price - TrailStep * _Point;
            if(new_sl > sl)
              {
               // modifica SL in trailing
               ModifyPositionSL(ticket, new_sl);
              }
           }
         else
           {
            new_sl = current_price + TrailStep * _Point;
            if(new_sl < sl || sl==0)
              {
               ModifyPositionSL(ticket, new_sl);
              }
           }
        }
     }
  }

//+------------------------------------------------------------------+
//| Modificare SL pozitie                                            |
//+------------------------------------------------------------------+
void ModifyPositionSL(ulong ticket, double new_sl)
  {
   MqlTradeRequest request;
   MqlTradeResult  result;
   ZeroMemory(request);
   ZeroMemory(result);

   request.action   = TRADE_ACTION_SLTP;
   request.position = ticket;
   request.sl       = new_sl;
   request.tp       = PositionGetDouble(POSITION_TP);

   if(!OrderSend(request, result))
     {
      Print("Eroare la modificarea SL: ", GetLastError());
     }
   else
      Print("SL modificat la ", DoubleToString(new_sl, _Digits));
  }

//+------------------------------------------------------------------+
//| Functia principala OnTick                                        |
//+------------------------------------------------------------------+
void OnTick()
  {
   // 1. Afisare candela suprapusa pe fiecare timeframe
   datetime t_open; double open, high, low, close;
   if(GetOHLC(tfH1, t_open, open, high, low, close))
      DrawCandleOverlay(objNameH1, t_open, open, high, low, close, (close>open) ? clrAqua : clrRed);

   if(GetOHLC(tfH4, t_open, open, high, low, close))
      DrawCandleOverlay(objNameH4, t_open, open, high, low, close, (close>open) ? clrAqua : clrRed);

   if(GetOHLC(tfD1, t_open, open, high, low, close))
      DrawCandleOverlay(objNameD1, t_open, open, high, low, close, (close>open) ? clrAqua : clrRed);

   if(GetOHLC(tfW1, t_open, open, high, low, close))
      DrawCandleOverlay(objNameW1, t_open, open, high, low, close, (close>open) ? clrAqua : clrRed);

//+-------------------------------------------------------------------------+
//|1.1 blocheaza deschiderea de pozitii noi cand corpul candelei e prea mic |
//+-------------------------------------------------------------------------+
if(!CandleHasBody(_Symbol, PERIOD_H1) ||
   !CandleHasBody(_Symbol, PERIOD_H4) ||
   !CandleHasBody(_Symbol, PERIOD_D1) ||
   !CandleHasBody(_Symbol, PERIOD_W1))
{
   // Nu deschide ordine
   return;
}

   // 2. Verificam semnalul
   int signal = CheckTradeSignal();

   // 3. Managementul pozitiei
   ulong magic = 154326;
   bool hasPosition = false;
   ENUM_POSITION_TYPE pos_type = POSITION_TYPE_BUY;

   for(int i=PositionsTotal()-1; i>=0; i--)
     {
      if(PositionGetInteger(POSITION_MAGIC) != magic) continue;
      if(PositionGetString(POSITION_SYMBOL) != symbol) continue;

      hasPosition = true;
      pos_type = (ENUM_POSITION_TYPE)PositionGetInteger(POSITION_TYPE);
      break;
     }

   // 4. Executie ordine conform semnalului si pozitiei existente
   if(signal == 1)  // BUY
     {
      if(!hasPosition || pos_type == POSITION_TYPE_SELL)
        {
         // inchidem sell daca exista
         if(hasPosition && pos_type == POSITION_TYPE_SELL)
           ClosePosition(symbol, POSITION_TYPE_SELL);

         // deschidem BUY
         OpenBuy();
        }
     }
   else if(signal == -1) // SELL
     {
      if(!hasPosition || pos_type == POSITION_TYPE_BUY)
        {
         // inchidem buy daca exista
         if(hasPosition && pos_type == POSITION_TYPE_BUY)
           ClosePosition(symbol, POSITION_TYPE_BUY);

         // deschidem SELL
         OpenSell();
        }
     }
   else
     {
      // fara semnal inchidem toate pozitiile noastre
      if(hasPosition)
        CloseAllPositions(symbol, magic);
     }

   // 5. Management trailing stop
   ManageTrailingStop();
  }

//+------------------------------------------------------------------+
//| Inchide pozitie dupa tip                                          |
//+------------------------------------------------------------------+
void ClosePosition(string symb, ENUM_POSITION_TYPE type)
  {
   for(int i=PositionsTotal()-1; i>=0; i--)
     {
      if(PositionGetInteger(POSITION_MAGIC) != 154326) continue;
      if(PositionGetString(POSITION_SYMBOL) != symb) continue;
      if(PositionGetInteger(POSITION_TYPE) != type) continue;

      ulong ticket = PositionGetTicket(i);
      ClosePositionByTicket(ticket);
     }
  }

//+------------------------------------------------------------------+
//| Inchide toate pozitiile pentru simbol si magic                   |
//+------------------------------------------------------------------+
void CloseAllPositions(string symb, ulong magic)
  {
   for(int i=PositionsTotal()-1; i>=0; i--)
     {
      if(PositionGetInteger(POSITION_MAGIC) != magic) continue;
      if(PositionGetString(POSITION_SYMBOL) != symb) continue;

      ulong ticket = PositionGetTicket(i);
      ClosePositionByTicket(ticket);
     }
  }

//+------------------------------------------------------------------+
//| Inchide pozitia dupa ticket                                       |
//+------------------------------------------------------------------+
void ClosePositionByTicket(ulong ticket)
  {
   MqlTradeRequest request;
   MqlTradeResult  result;
   ZeroMemory(request);
   ZeroMemory(result);

   request.action = TRADE_ACTION_CLOSE_BY;
   request.position = ticket;

   if(!OrderSend(request,result))
     Print("Eroare inchidere pozitie: ", GetLastError());
   else
     Print("Pozitie inchisa, ticket: ", ticket);
  }

//+------------------------------------------------------------------+
//| blocheaza deschiderea de pozitii cand corpul candelei e prea mic |
//+------------------------------------------------------------------+
bool CandleHasBody(string usymbol, ENUM_TIMEFRAMES tf, int shift=0, double minBodyPoints=10)
{
   double open = iOpen(usymbol, tf, shift);
   double close = iClose(usymbol, tf, shift);
   return MathAbs(close - open) * MathPow(10, _Digits) >= minBodyPoints;
}