MT5 데모 계좌에서 첫 EA 실행하기: 로그로 검증하는 MQL5 실습

//+------------------------------------------------------------------+
//|                                      Permact_First_Candle_EA.mq5 |
//|                                      Copyright 2026, Permact     |
//|                                             https://permact.com  |
//+------------------------------------------------------------------+
#property copyright "Copyright 2026, Permact"
#property link      "https://permact.com"
#property version   "1.10"

#include <Trade/Trade.mqh>

CTrade trade;

input double Lots             = 0.01;
input int    StopLossPoints   = 300;
input int    TakeProfitPoints = 600;
input int    MinStopBufferPoints = 50;
input ulong  MagicNumber      = 20260708;

datetime lastBarTime = 0;

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//---
   trade.SetExpertMagicNumber(MagicNumber);
   trade.SetAsyncMode(false);
   if (!trade.SetTypeFillingBySymbol(_Symbol))
     {
      Print("Initialization failed: unable to select the filling policy for ", _Symbol);
      return(INIT_FAILED);
     }
   Print("Permact first candle EA started");
//---
   return(INIT_SUCCEEDED);
  }

//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
//---
   Print("Permact first candle EA stopped. Reason: ", reason);
//---
  }

//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//---
   datetime currentBarTime = iTime(_Symbol, _Period, 0);
   if (currentBarTime == 0 || currentBarTime == lastBarTime)
      return;

   lastBarTime = currentBarTime;

   if (Bars(_Symbol, _Period) < 10)
      return;

   double previousOpen  = iOpen(_Symbol, _Period, 1);
   double previousClose = iClose(_Symbol, _Period, 1);

   if (previousOpen == 0 || previousClose == 0)
      return;

   if (previousClose > previousOpen)
     {
      CloseSellPosition();
      if (!PositionSelect(_Symbol))
         OpenBuy();
     }

   if (previousClose < previousOpen)
     {
      CloseBuyPosition();
      if (!PositionSelect(_Symbol))
         OpenSell();
     }
//---
  }

//+------------------------------------------------------------------+
//| Trade function                                                   |
//+------------------------------------------------------------------+
void OnTrade()
  {
//---
//---
  }

void OpenBuy()
  {
   double bid = SymbolInfoDouble(_Symbol, SYMBOL_BID);
   double ask = SymbolInfoDouble(_Symbol, SYMBOL_ASK);
   if (bid <= 0 || ask <= 0)
      return;

   int slPoints = EffectiveInitialStopPoints(StopLossPoints);
   int tpPoints = EffectiveInitialStopPoints(TakeProfitPoints);

   double sl = 0.0;
   double tp = 0.0;

   if (slPoints > 0)
      sl = AlignPriceDown(bid - slPoints * _Point);

   if (tpPoints > 0)
      tp = AlignPriceUp(ask + tpPoints * _Point);

   bool requestBuilt = trade.Buy(Lots, _Symbol, 0.0, sl, tp, "Permact candle buy");
   TradeRequestCompleted(requestBuilt, "Buy");
  }

void OpenSell()
  {
   double ask = SymbolInfoDouble(_Symbol, SYMBOL_ASK);
   double bid = SymbolInfoDouble(_Symbol, SYMBOL_BID);
   if (bid <= 0 || ask <= 0)
      return;

   int slPoints = EffectiveInitialStopPoints(StopLossPoints);
   int tpPoints = EffectiveInitialStopPoints(TakeProfitPoints);

   double sl = 0.0;
   double tp = 0.0;

   if (slPoints > 0)
      sl = AlignPriceUp(ask + slPoints * _Point);

   if (tpPoints > 0)
      tp = AlignPriceDown(bid - tpPoints * _Point);

   bool requestBuilt = trade.Sell(Lots, _Symbol, 0.0, sl, tp, "Permact candle sell");
   TradeRequestCompleted(requestBuilt, "Sell");
  }

int EffectiveInitialStopPoints(const int requestedPoints)
  {
   if (requestedPoints <= 0)
      return 0;

   int stopLevel = (int)SymbolInfoInteger(_Symbol, SYMBOL_TRADE_STOPS_LEVEL);
   int bufferPoints = MinStopBufferPoints > 0 ? MinStopBufferPoints : 0;
   int minimumPoints = stopLevel + bufferPoints;

   if (requestedPoints < minimumPoints)
      return minimumPoints;

   return requestedPoints;
  }

double AlignPriceDown(const double price)
  {
   double tickSize = SymbolInfoDouble(_Symbol, SYMBOL_TRADE_TICK_SIZE);
   if (tickSize <= 0.0)
      tickSize = _Point;

   return NormalizeDouble(MathFloor(price / tickSize) * tickSize, _Digits);
  }

double AlignPriceUp(const double price)
  {
   double tickSize = SymbolInfoDouble(_Symbol, SYMBOL_TRADE_TICK_SIZE);
   if (tickSize <= 0.0)
      tickSize = _Point;

   return NormalizeDouble(MathCeil(price / tickSize) * tickSize, _Digits);
  }

bool TradeRequestCompleted(const bool requestBuilt, const string action)
  {
   uint retcode = trade.ResultRetcode();
   ulong deal = trade.ResultDeal();
   ulong order = trade.ResultOrder();

   if (requestBuilt && retcode == TRADE_RETCODE_DONE && deal > 0)
      return true;

   if (retcode == TRADE_RETCODE_DONE_PARTIAL)
     {
      Print(action, " partially filled and requires reconciliation. Retcode: ", retcode, " ",
            trade.ResultRetcodeDescription(), ", deal: ", deal, ", order: ", order);
      return false;
     }

   if (retcode == TRADE_RETCODE_PLACED)
     {
      Print(action, " was placed but is not final; reconciliation is required. Retcode: ", retcode, " ",
            trade.ResultRetcodeDescription(), ", deal: ", deal, ", order: ", order);
      return false;
     }

   if (requestBuilt && retcode == TRADE_RETCODE_DONE && deal == 0)
     {
      Print(action, " returned DONE without a deal ticket; reconciliation is required. Order: ", order);
      return false;
     }

   Print(action, " failed. Retcode: ", retcode, " ", trade.ResultRetcodeDescription(),
         ", deal: ", deal, ", order: ", order);
   return false;
  }

void CloseBuyPosition()
  {
   if (!PositionSelect(_Symbol))
      return;

   long currentType = PositionGetInteger(POSITION_TYPE);
   long currentMagic = PositionGetInteger(POSITION_MAGIC);

   if (currentType != POSITION_TYPE_BUY)
      return;

   if (currentMagic != (long)MagicNumber)
     {
      Print("Skip close: buy position belongs to another strategy. Magic: ", currentMagic);
      return;
     }

   ulong ticket = (ulong)PositionGetInteger(POSITION_TICKET);
   bool requestBuilt = trade.PositionClose(ticket);
   if (TradeRequestCompleted(requestBuilt, "Close buy") && PositionSelectByTicket(ticket))
      Print("Close buy returned a deal but the position remains open; reconciliation is required. Ticket: ", ticket);
  }

void CloseSellPosition()
  {
   if (!PositionSelect(_Symbol))
      return;

   long currentType = PositionGetInteger(POSITION_TYPE);
   long currentMagic = PositionGetInteger(POSITION_MAGIC);

   if (currentType != POSITION_TYPE_SELL)
      return;

   if (currentMagic != (long)MagicNumber)
     {
      Print("Skip close: sell position belongs to another strategy. Magic: ", currentMagic);
      return;
     }

   ulong ticket = (ulong)PositionGetInteger(POSITION_TICKET);
   bool requestBuilt = trade.PositionClose(ticket);
   if (TradeRequestCompleted(requestBuilt, "Close sell") && PositionSelectByTicket(ticket))
      Print("Close sell returned a deal but the position remains open; reconciliation is required. Ticket: ", ticket);
  }
//+------------------------------------------------------------------+