MQL4 取引関数リファレンス｜OrderSend・OrderClose・OrderModify・ポジション管理ループ

int OrderSend(
   string   symbol,           // 通貨ペア
   int      cmd,              // 注文タイプ（OP_BUY等）
   double   volume,           // ロット数
   double   price,            // 注文価格
   int      slippage,         // 許容スリッページ（ポイント）
   double   stoploss,         // ストップロス価格
   double   takeprofit,       // テイクプロフィット価格
   string   comment = NULL,   // コメント（任意）
   int      magic = 0,        // マジックナンバー（任意）
   datetime expiration = 0,   // 有効期限（任意、指値注文用）
   color    arrow_color = clrNONE  // チャート上の矢印色（任意）
);
// 戻り値: 成功時はチケット番号、失敗時は-1

int BuyOrder(double lots, int slPoints, int tpPoints)
  {
   double ask = Ask;  // またはMarketInfo(Symbol(), MODE_ASK)
   double sl  = NormalizeDouble(ask - slPoints * Point, Digits);
   double tp  = NormalizeDouble(ask + tpPoints * Point, Digits);

   int ticket = OrderSend(Symbol(), OP_BUY, lots, ask, 3, sl, tp,"Buy Order", 12345, 0, clrBlue);

   if(ticket < 0)
     {
      Print("買い注文失敗:", GetLastError());
      return -1;
     }

   Print("買い注文成功: ticket=", ticket);
   return ticket;
  }

int SellOrder(double lots, int slPoints, int tpPoints)
  {
   double bid = Bid;
   double sl  = NormalizeDouble(bid + slPoints * Point, Digits);
   double tp  = NormalizeDouble(bid - tpPoints * Point, Digits);

   int ticket = OrderSend(Symbol(), OP_SELL, lots, bid, 3, sl, tp,"Sell Order", 12345, 0, clrRed);

   if(ticket < 0)
     {
      Print("売り注文失敗:", GetLastError());
      return -1;
     }

   Print("売り注文成功: ticket=", ticket);
   return ticket;
  }

// Buy Limit: 現在値より下で買い待機
int BuyLimitOrder(double lots, double entryPrice, int slPoints, int tpPoints)
  {
   double sl = NormalizeDouble(entryPrice - slPoints * Point, Digits);
   double tp = NormalizeDouble(entryPrice + tpPoints * Point, Digits);

   int ticket = OrderSend(Symbol(), OP_BUYLIMIT, lots,
                           NormalizeDouble(entryPrice, Digits),
                           3, sl, tp,"BuyLimit", 12345, 0, clrBlue);
   if(ticket < 0)
      Print("BuyLimit失敗:", GetLastError());
   return ticket;
  }

// Sell Limit: 現在値より上で売り待機
int SellLimitOrder(double lots, double entryPrice, int slPoints, int tpPoints)
  {
   double sl = NormalizeDouble(entryPrice + slPoints * Point, Digits);
   double tp = NormalizeDouble(entryPrice - tpPoints * Point, Digits);

   int ticket = OrderSend(Symbol(), OP_SELLLIMIT, lots,
                           NormalizeDouble(entryPrice, Digits),
                           3, sl, tp,"SellLimit", 12345, 0, clrRed);
   if(ticket < 0)
      Print("SellLimit失敗:", GetLastError());
   return ticket;
  }

// Buy Stop: 現在値より上で買い待機（ブレイクアウト狙い）
int BuyStopOrder(double lots, double entryPrice, int slPoints, int tpPoints)
  {
   double sl = NormalizeDouble(entryPrice - slPoints * Point, Digits);
   double tp = NormalizeDouble(entryPrice + tpPoints * Point, Digits);

   int ticket = OrderSend(Symbol(), OP_BUYSTOP, lots,
                           NormalizeDouble(entryPrice, Digits),
                           3, sl, tp,"BuyStop", 12345, 0, clrBlue);
   if(ticket < 0)
      Print("BuyStop失敗:", GetLastError());
   return ticket;
  }

// Sell Stop: 現在値より下で売り待機（ブレイクダウン狙い）
int SellStopOrder(double lots, double entryPrice, int slPoints, int tpPoints)
  {
   double sl = NormalizeDouble(entryPrice + slPoints * Point, Digits);
   double tp = NormalizeDouble(entryPrice - tpPoints * Point, Digits);

   int ticket = OrderSend(Symbol(), OP_SELLSTOP, lots,
                           NormalizeDouble(entryPrice, Digits),
                           3, sl, tp,"SellStop", 12345, 0, clrRed);
   if(ticket < 0)
      Print("SellStop失敗:", GetLastError());
   return ticket;
  }

bool OrderClose(
   int      ticket,      // 注文チケット番号
   double   lots,         // 決済ロット数
   double   price,        // 決済価格
   int      slippage,     // 許容スリッページ
   color    arrow_color = clrNONE  // 矢印色
);
// 戻り値: 成功=true, 失敗=false

// 買いポジションの決済
bool CloseBuyOrder(int ticket)
  {
   if(!OrderSelect(ticket, SELECT_BY_TICKET))
     {
      Print("チケット選択失敗:", ticket);
      return false;
     }

   // 買いポジションはBidで決済
   bool result = OrderClose(ticket, OrderLots(), Bid, 3, clrBlue);

   if(!result)
      Print("決済失敗:", GetLastError());
   else
      Print("決済成功: ticket=", ticket);

   return result;
  }

// 売りポジションの決済
bool CloseSellOrder(int ticket)
  {
   if(!OrderSelect(ticket, SELECT_BY_TICKET))
      return false;

   // 売りポジションはAskで決済
   return OrderClose(ticket, OrderLots(), Ask, 3, clrRed);
  }

bool OrderCloseBy(
   int   ticket,       // 決済する注文チケット
   int   opposite,     // 反対ポジションのチケット
   color arrow_color = clrNONE
);
// 同じ通貨ペアの反対ポジション同士を相殺決済する

bool OrderModify(
   int      ticket,       // チケット番号
   double   price,        // 新しい注文価格（成行ポジションの場合はOrderOpenPrice()）
   double   stoploss,     // 新しいSL
   double   takeprofit,   // 新しいTP
   datetime expiration,   // 新しい有効期限（0=変更なし）
   color    arrow_color = clrNONE
);
// 戻り値: 成功=true, 失敗=false

// 成行ポジションのSL/TPを変更
bool ModifySLTP(int ticket, double newSL, double newTP)
  {
   if(!OrderSelect(ticket, SELECT_BY_TICKET))
      return false;

   // 成行ポジションではpriceにOrderOpenPrice()を渡す
   bool result = OrderModify(ticket, OrderOpenPrice(),
                              NormalizeDouble(newSL, Digits),
                              NormalizeDouble(newTP, Digits),
                              0, clrYellow);
   if(!result)
      Print("SL/TP変更失敗:", GetLastError());

   return result;
  }

// 待機注文の価格を変更
bool ModifyPendingPrice(int ticket, double newPrice, double newSL, double newTP)
  {
   if(!OrderSelect(ticket, SELECT_BY_TICKET))
      return false;

   return OrderModify(ticket, NormalizeDouble(newPrice, Digits),
                       NormalizeDouble(newSL, Digits),
                       NormalizeDouble(newTP, Digits),
                       0, clrYellow);
  }

bool OrderDelete(
   int   ticket,          // チケット番号
   color arrow_color = clrNONE
);
// 待機注文（Limit/Stop）を削除する。成行ポジションには使用不可

void DeleteAllPendingOrders(int magic)
  {
   for(int i = OrdersTotal() - 1; i >= 0; i--)
     {
      if(!OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
         continue;
      if(OrderSymbol() != Symbol() || OrderMagicNumber() != magic)
         continue;
      if(OrderType() > OP_SELL)  // 2以上=待機注文
        {
         if(!OrderDelete(OrderTicket()))
            Print("待機注文削除失敗:", GetLastError());
        }
     }
  }

bool OrderSelect(
   int    index,            // インデックスまたはチケット番号
   int    select,           // SELECT_BY_POS または SELECT_BY_TICKET
   int    pool = MODE_TRADES  // MODE_TRADES（保有中）またはMODE_HISTORY（履歴）
);
// OrderSelect成功後に各種Order情報関数が使用可能になる

void ScanOpenOrders(int magic)
  {
   int buyCount = 0, sellCount = 0;
   double totalProfit = 0;

   // 逆順ループ（決済時にインデックスがずれるのを防ぐ）
   for(int i = OrdersTotal() - 1; i >= 0; i--)
     {
      if(!OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
         continue;

      // 通貨ペアとマジックナンバーでフィルタ
      if(OrderSymbol() != Symbol())
         continue;
      if(OrderMagicNumber() != magic)
         continue;

      // ポジション情報を取得
      int    type   = OrderType();
      int    ticket = OrderTicket();
      double lots   = OrderLots();
      double profit = OrderProfit() + OrderSwap() + OrderCommission();
      double openPrice = OrderOpenPrice();

      totalProfit += profit;

      if(type == OP_BUY)
        {
         buyCount++;
         Print("BUY: ticket=", ticket," lots=", lots," profit=", profit);
        }
      else if(type == OP_SELL)
        {
         sellCount++;
         Print("SELL: ticket=", ticket," lots=", lots," profit=", profit);
        }
     }

   Print("合計: Buy=", buyCount," Sell=", sellCount," Profit=", totalProfit);
  }

void AnalyzeHistory(int magic, datetime fromDate)
  {
   int    wins = 0, losses = 0;
   double totalWin = 0, totalLoss = 0;

   for(int i = OrdersHistoryTotal() - 1; i >= 0; i--)
     {
      if(!OrderSelect(i, SELECT_BY_POS, MODE_HISTORY))
         continue;
      if(OrderSymbol() != Symbol() || OrderMagicNumber() != magic)
         continue;
      if(OrderType() > OP_SELL)  // 待機注文は除外
         continue;
      if(OrderCloseTime() < fromDate)  // 期間フィルタ
         continue;

      double profit = OrderProfit() + OrderSwap() + OrderCommission();

      if(profit >= 0)
        {
         wins++;
         totalWin += profit;
        }
      else
        {
         losses++;
         totalLoss += MathAbs(profit);
        }
     }

   int total = wins + losses;
   if(total > 0)
     {
      double winRate = (double)wins / total * 100.0;
      double pf = (totalLoss > 0) ? totalWin / totalLoss : 0;
      Print("勝率:", DoubleToStr(winRate, 1),"% (",
            wins,"勝", losses,"敗) PF=", DoubleToStr(pf, 2));
     }
  }

double CalcLotSize(double riskPercent, int slPoints)
  {
   double balance    = AccountBalance();
   double riskAmount = balance * riskPercent / 100.0;
   double tickValue  = MarketInfo(Symbol(), MODE_TICKVALUE);
   double tickSize   = MarketInfo(Symbol(), MODE_TICKSIZE);
   double minLot     = MarketInfo(Symbol(), MODE_MINLOT);
   double maxLot     = MarketInfo(Symbol(), MODE_MAXLOT);
   double lotStep    = MarketInfo(Symbol(), MODE_LOTSTEP);

   if(tickValue == 0 || slPoints == 0)
      return minLot;

   // 1ロットあたりのSL損失額を計算
   double slMoney = slPoints * Point / tickSize * tickValue;

   // リスク額からロット数を逆算
   double lots = riskAmount / slMoney;

   // ロットステップに丸める
   lots = MathFloor(lots / lotStep) * lotStep;

   // 範囲制限
   if(lots < minLot) lots = minLot;
   if(lots > maxLot) lots = maxLot;

   return NormalizeDouble(lots, 2);
  }

void TrailingStop(int magic, int trailPoints, int trailStart)
  {
   for(int i = OrdersTotal() - 1; i >= 0; i--)
     {
      if(!OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
         continue;
      if(OrderSymbol() != Symbol() || OrderMagicNumber() != magic)
         continue;

      double newSL;
      double currentSL = OrderStopLoss();
      int    stopLevel = (int)MarketInfo(Symbol(), MODE_STOPLEVEL);
      double minDist   = stopLevel * Point;

      if(OrderType() == OP_BUY)
        {
         // 含み益がtrailStart以上あるときだけ発動
         if(Bid - OrderOpenPrice() < trailStart * Point)
            continue;

         newSL = NormalizeDouble(Bid - trailPoints * Point, Digits);

         // 現在のSLより上にある場合のみ更新
         if(newSL > currentSL + Point && Bid - newSL > minDist)
           {
            if(!OrderModify(OrderTicket(), OrderOpenPrice(), newSL,
                             OrderTakeProfit(), 0, clrBlue))
               Print("トレーリング失敗:", GetLastError());
           }
        }
      else if(OrderType() == OP_SELL)
        {
         if(OrderOpenPrice() - Ask < trailStart * Point)
            continue;

         newSL = NormalizeDouble(Ask + trailPoints * Point, Digits);

         if((currentSL == 0 || newSL < currentSL - Point) && newSL - Ask > minDist)
           {
            if(!OrderModify(OrderTicket(), OrderOpenPrice(), newSL,
                             OrderTakeProfit(), 0, clrRed))
               Print("トレーリング失敗:", GetLastError());
           }
        }
     }
  }

bool PartialClose(int ticket, double closePercent)
  {
   if(!OrderSelect(ticket, SELECT_BY_TICKET))
      return false;

   double totalLots = OrderLots();
   double closeLots = NormalizeDouble(totalLots * closePercent / 100.0, 2);
   double minLot    = MarketInfo(Symbol(), MODE_MINLOT);
   double lotStep   = MarketInfo(Symbol(), MODE_LOTSTEP);

   // ロットステップに丸める
   closeLots = MathFloor(closeLots / lotStep) * lotStep;

   // 最小ロット未満なら全決済
   if(closeLots < minLot)
      closeLots = totalLots;

   double price = (OrderType() == OP_BUY) ? Bid : Ask;

   bool result = OrderClose(ticket, closeLots, price, 3, clrYellow);
   if(!result)
      Print("部分決済失敗:", GetLastError());
   else
      Print("部分決済成功:", closeLots," /", totalLots," lots");

   return result;
  }

#define MAGIC_LOGIC_A  100001  // ロジックA
#define MAGIC_LOGIC_B  100002  // ロジックB
#define MAGIC_LOGIC_C  100003  // ロジックC
#define MAX_POSITIONS  3       // 全体の最大ポジション数

// 指定マジックナンバーのポジション数をカウント
int CountPositions(int magic)
  {
   int count = 0;
   for(int i = OrdersTotal() - 1; i >= 0; i--)
     {
      if(!OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
         continue;
      if(OrderSymbol() != Symbol())
         continue;
      if(OrderMagicNumber() != magic)
         continue;
      if(OrderType() <= OP_SELL)
         count++;
     }
   return count;
  }

// 全ロジックの合計ポジション数
int CountAllPositions()
  {
   return CountPositions(MAGIC_LOGIC_A)
        + CountPositions(MAGIC_LOGIC_B)
        + CountPositions(MAGIC_LOGIC_C);
  }

void OnTick()
  {
   // 最大ポジション数チェック
   if(CountAllPositions() >= MAX_POSITIONS)
      return;

   // ロジックA: 条件チェック & エントリー
   if(CountPositions(MAGIC_LOGIC_A) == 0 && LogicA_Signal())
     {
      OrderSend(Symbol(), OP_BUY, 0.1, Ask, 3, 0, 0,"LogicA", MAGIC_LOGIC_A, 0, clrBlue);
     }

   // ロジックB: 条件チェック & エントリー
   if(CountPositions(MAGIC_LOGIC_B) == 0 && LogicB_Signal())
     {
      OrderSend(Symbol(), OP_SELL, 0.1, Bid, 3, 0, 0,"LogicB", MAGIC_LOGIC_B, 0, clrRed);
     }

   // ロジックC: 条件チェック & エントリー
   if(CountPositions(MAGIC_LOGIC_C) == 0 && LogicC_Signal())
     {
      OrderSend(Symbol(), OP_BUY, 0.1, Ask, 3, 0, 0,"LogicC", MAGIC_LOGIC_C, 0, clrGreen);
     }
  }

int BuyOrderECN(double lots, int slPoints, int tpPoints, int magic)
  {
   // Step 1: SL/TPなしで発注
   int ticket = OrderSend(Symbol(), OP_BUY, lots, Ask, 3,
                            0, 0,"ECN Buy", magic, 0, clrBlue);

   if(ticket < 0)
     {
      Print("発注失敗:", GetLastError());
      return -1;
     }

   // Step 2: SL/TPを後から設定
   if(slPoints > 0 || tpPoints > 0)
     {
      if(!OrderSelect(ticket, SELECT_BY_TICKET))
         return ticket;

      double openPrice = OrderOpenPrice();
      double sl = (slPoints > 0) ? NormalizeDouble(openPrice - slPoints * Point, Digits) : 0;
      double tp = (tpPoints > 0) ? NormalizeDouble(openPrice + tpPoints * Point, Digits) : 0;

      // リトライ付きでSL/TP設定
      for(int retry = 0; retry < 3; retry++)
        {
         if(OrderModify(ticket, openPrice, sl, tp, 0, clrBlue))
            break;
         Print("SL/TP設定リトライ:", GetLastError());
         Sleep(500);
        }
     }

   return ticket;
  }