int orderType = OrderType();

//保有ポジションを一つ選択
if(OrderSelect(0, SELECT_BY_POS, MODE_TRADES))
   {

   //選択したポジションが、買いポジションなのかチェック
   if(OrderType() == OP_BUY)
   {

      //ここにポジションを決済するプログラムを書く

   }
   }

//保有ポジションを一つずつチェックしていく
for( int i = OrdersTotal() - 1; i >= 0; i--)
   {

    //保有ポジションを一つ選択
    if( OrderSelect( i, SELECT_BY_POS, MODE_TRADES))
        {

            //選択したポジションが、買いポジションなのかチェック
            if( OrderType() == OP_BUY)
            {

            //ここにポジションを決済するプログラムを書く

            }
        }
   }

//+------------------------------------------------------------------+
//| OrderType関数サンプル                                              |
//+------------------------------------------------------------------+
void OnTick()
{
   //保有ポジションを一つずつチェックしていく
   for( int i = OrdersTotal() - 1; i >= 0; i--)
   {
      //保有ポジションを一つ選択
      if( OrderSelect( i, SELECT_BY_POS, MODE_TRADES))
      {
         //選択したポジションが、買いポジションなのかチェック
         if( OrderType() == OP_BUY)
         {
            Print("買いポジションを検出しました。チケット番号: ", OrderTicket());

            //ここにポジションを決済するプログラムを書く
         }

         //選択したポジションが、売りポジションなのかチェック
         if( OrderType() == OP_SELL)
         {
            Print("売りポジションを検出しました。チケット番号: ", OrderTicket());

            //ここにポジションを決済するプログラムを書く
         }
      }
   }
}

double orderOpenPrice = OrderOpenPrice();

//保有ポジションを一つ選択
    if(OrderSelect(10, SELECT_BY_POS, MODE_TRADES))
       {

        //ポジションのエントリー価格を取得
        double orderOpenPrice = OrderOpenPrice();

        //変更注文を出す
        bool orderModify = OrderModify(OrderTicket(), orderOpenPrice, OrderStopLoss(), 110.000, OrderExpiration(), clrRed);
       }
   }

double orderClosePrice = OrderClosePrice();

//保有ポジションを一つ選択
if(OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
   {

      //決済価格を取得
      double orderClosePrice = OrderClosePrice();

      //ポジションを決済
      bool orderClose = OrderClose( OrderTicket(), OrderLots(), orderClosePrice, 10, clrNONE);

   }

bool orderModify = OrderModify( ①, ②, ③, ④, ⑤, ⑥);

bool orderModify = OrderModify(OrderTicket(), ②, ③, ④, ⑤, ⑥)

bool orderModify = OrderModify(OrderTicket(), OrderOpenPrice(), ③, ④, ⑤, ⑥)

bool orderModify = OrderModify(OrderTicket(), OrderOpenPrice(), OrderStopLoss(), ④, ⑤, ⑥)

bool orderModify = OrderModify(OrderTicket(), OrderOpenPrice(), OrderStopLoss(), 110.000, ⑤, ⑥)

datetime expiration = D'2021.09.22 00:00:00';

bool orderModify = OrderModify(OrderTicket(), OrderOpenPrice(), OrderStopLoss(), 110.000, OrderExpiration(), ⑥)

bool orderModify = OrderModify(OrderTicket(), OrderOpenPrice(), OrderStopLoss(), 110.000, OrderExpiration(), clrRed)

bool orderModify = OrderModify(OrderTicket(), OrderOpenPrice(), OrderStopLoss(), 110.000, OrderExpiration(), clrRed)

//+------------------------------------------------------------------+
//| トレーリングストップEA                                              |
//| 価格が有利に動いたら損切りラインを自動で追従させる                      |
//+------------------------------------------------------------------+
input int TrailingStopPips = 30;  // トレーリングストップ幅（pips）
input int TrailingStartPips = 20; // トレーリング開始条件（pips利益が出てから）

void OnTick()
{
   // ポイント値を取得（5桁ブローカー対応）
   double pip = Point;
   if(Digits == 3 || Digits == 5)
      pip = Point * 10;

   // 保有中の全ポジションをループ
   for(int i = OrdersTotal() - 1; i >= 0; i--)
   {
      // ポジションを選択
      if(!OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
         continue;

      // 自分のEAの通貨ペアが一致するか確認
      if(OrderSymbol() != Symbol())
         continue;

      // 買いポジションのトレーリングストップ
      if(OrderType() == OP_BUY)
      {
         // 現在の利益がトレーリング開始条件を超えているか
         double buyProfit = Bid - OrderOpenPrice();
         if(buyProfit >= TrailingStartPips * pip)
         {
            // 新しい損切り価格を計算
            double newSL = Bid - TrailingStopPips * pip;
            // 現在のSLより有利（高い）場合のみ変更
            if(newSL > OrderStopLoss() || OrderStopLoss() == 0)
            {
               bool result = OrderModify(
                  OrderTicket(),       // チケット番号
                  OrderOpenPrice(),    // 取得価格はそのまま
                  NormalizeDouble(newSL, Digits), // 新しい損切り価格
                  OrderTakeProfit(),   // 利確はそのまま
                  OrderExpiration(),   // 有効期限はそのまま
                  clrBlue             // 矢印の色（青）
               );
               if(result)
                  Print("買いトレーリングストップ更新: SL=", newSL);
               else
                  Print("トレーリングストップ更新失敗: エラー=", GetLastError());
            }
         }
      }

      // 売りポジションのトレーリングストップ
      if(OrderType() == OP_SELL)
      {
         // 現在の利益がトレーリング開始条件を超えているか
         double sellProfit = OrderOpenPrice() - Ask;
         if(sellProfit >= TrailingStartPips * pip)
         {
            // 新しい損切り価格を計算
            double newSL = Ask + TrailingStopPips * pip;
            // 現在のSLより有利（低い）場合のみ変更
            if(newSL < OrderStopLoss() || OrderStopLoss() == 0)
            {
               bool result = OrderModify(
                  OrderTicket(),       // チケット番号
                  OrderOpenPrice(),    // 取得価格はそのまま
                  NormalizeDouble(newSL, Digits), // 新しい損切り価格
                  OrderTakeProfit(),   // 利確はそのまま
                  OrderExpiration(),   // 有効期限はそのまま
                  clrRed              // 矢印の色（赤）
               );
               if(result)
                  Print("売りトレーリングストップ更新: SL=", newSL);
               else
                  Print("トレーリングストップ更新失敗: エラー=", GetLastError());
            }
         }
      }
   }
}

//+------------------------------------------------------------------+
//| 建値ストップ（ブレイクイーブン）の例                                  |
//| 一定利益が出たらSLをエントリー価格に移動                              |
//+------------------------------------------------------------------+
input int BreakevenPips = 20; // 建値ストップ発動条件（pips）

void SetBreakeven()
{
   double pip = Point;
   if(Digits == 3 || Digits == 5)
      pip = Point * 10;

   for(int i = OrdersTotal() - 1; i >= 0; i--)
   {
      if(!OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
         continue;

      if(OrderSymbol() != Symbol())
         continue;

      // 買いポジション
      if(OrderType() == OP_BUY)
      {
         // 条件を満たし、かつSLがまだエントリー価格以下の場合
         if(Bid - OrderOpenPrice() >= BreakevenPips * pip)
         {
            if(OrderStopLoss() < OrderOpenPrice() || OrderStopLoss() == 0)
            {
               bool result = OrderModify(
                  OrderTicket(),
                  OrderOpenPrice(),
                  OrderOpenPrice(),    // SLをエントリー価格に設定
                  OrderTakeProfit(),
                  OrderExpiration(),
                  clrGreen
               );
               if(result)
                  Print("建値ストップ設定完了: チケット=", OrderTicket());
            }
         }
      }

      // 売りポジション
      if(OrderType() == OP_SELL)
      {
         if(OrderOpenPrice() - Ask >= BreakevenPips * pip)
         {
            if(OrderStopLoss() > OrderOpenPrice() || OrderStopLoss() == 0)
            {
               bool result = OrderModify(
                  OrderTicket(),
                  OrderOpenPrice(),
                  OrderOpenPrice(),    // SLをエントリー価格に設定
                  OrderTakeProfit(),
                  OrderExpiration(),
                  clrGreen
               );
               if(result)
                  Print("建値ストップ設定完了: チケット=", OrderTicket());
            }
         }
      }
   }
}

//+------------------------------------------------------------------+
//| 利確価格を段階的に変更する例                                        |
//+------------------------------------------------------------------+
input int InitialTPPips = 50;   // 初期利確幅（pips）
input int ExtendedTPPips = 100; // 拡張利確幅（pips）
input int ExtendTriggerPips = 30; // 拡張トリガー（pips利益）

void AdjustTakeProfit()
{
   double pip = Point;
   if(Digits == 3 || Digits == 5)
      pip = Point * 10;

   for(int i = OrdersTotal() - 1; i >= 0; i--)
   {
      if(!OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
         continue;

      if(OrderSymbol() != Symbol())
         continue;

      // 買いポジションの利確拡張
      if(OrderType() == OP_BUY)
      {
         double currentProfit = Bid - OrderOpenPrice();
         double initialTP = OrderOpenPrice() + InitialTPPips * pip;
         double extendedTP = OrderOpenPrice() + ExtendedTPPips * pip;

         // トリガー条件を満たし、TPがまだ初期値の場合
         if(currentProfit >= ExtendTriggerPips * pip)
         {
            if(NormalizeDouble(OrderTakeProfit(), Digits) == NormalizeDouble(initialTP, Digits))
            {
               bool result = OrderModify(
                  OrderTicket(),
                  OrderOpenPrice(),
                  OrderStopLoss(),
                  NormalizeDouble(extendedTP, Digits), // 利確を拡張
                  OrderExpiration(),
                  clrYellow
               );
               if(result)
                  Print("利確拡張完了: 新TP=", extendedTP);
            }
         }
      }

      // 売りポジションの利確拡張
      if(OrderType() == OP_SELL)
      {
         double currentProfit = OrderOpenPrice() - Ask;
         double initialTP = OrderOpenPrice() - InitialTPPips * pip;
         double extendedTP = OrderOpenPrice() - ExtendedTPPips * pip;

         if(currentProfit >= ExtendTriggerPips * pip)
         {
            if(NormalizeDouble(OrderTakeProfit(), Digits) == NormalizeDouble(initialTP, Digits))
            {
               bool result = OrderModify(
                  OrderTicket(),
                  OrderOpenPrice(),
                  OrderStopLoss(),
                  NormalizeDouble(extendedTP, Digits), // 利確を拡張
                  OrderExpiration(),
                  clrYellow
               );
               if(result)
                  Print("利確拡張完了: 新TP=", extendedTP);
            }
         }
      }
   }
}

// 正しい例
double newSL = NormalizeDouble(Bid - 30 * Point, Digits);

// 間違いやすい例（正規化なし）
double newSL = Bid - 30 * Point; // 桁数がずれる可能性あり

// ストップレベルの取得
double stopLevel = MarketInfo(Symbol(), MODE_STOPLEVEL) * Point;
Print("ストップレベル: ", stopLevel);

double lots = OrderLots();

//保有ポジションを一つ選択
if(OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
   {

      //ロット数を取得
      double lots = OrderLots();

      //ポジションを決済
      bool orderClose = OrderClose( OrderTicket(), lots, OrderClosePrice(), 10, clrNONE);

   }

//+------------------------------------------------------------------+
//| 現在の通貨ペアの合計ロット数を計算する関数                         |
//+------------------------------------------------------------------+
double GetTotalLots(int magicNumber)
  {
   double totalLots = 0.0; // 合計ロット数を格納する変数

   // 全ポジションをループで確認
   for(int i = OrdersTotal() - 1; i >= 0; i--)
     {
      // ポジションを選択
      if(OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
        {
         // 通貨ペアとマジックナンバーが一致するか確認
         if(OrderSymbol() == Symbol() && OrderMagicNumber() == magicNumber)
           {
            // OrderLots関数でロット数を取得し、合計に加算
            totalLots += OrderLots();
           }
        }
     }

   return totalLots; // 合計ロット数を返す
  }

//+------------------------------------------------------------------+
//| 使用例：OnTick内で合計ロット数を確認                              |
//+------------------------------------------------------------------+
void OnTick()
  {
   int myMagic = 12345;

   // 合計ロット数を取得
   double total = GetTotalLots(myMagic);

   // 合計ロット数が上限を超えていたら新規注文を出さない
   double maxLots = 1.0; // 最大合計ロット数
   if(total >= maxLots)
     {
      Comment("合計ロット数が上限に達しています: ", DoubleToString(total, 2), " lots");
      return; // 新規注文を行わない
     }

   // ここに通常のエントリーロジックを記述
   Comment("現在の合計ロット数: ", DoubleToString(total, 2), " lots");
  }

#define MAGIC_NUMBER 12345 // マジックナンバーの定義

//+------------------------------------------------------------------+
//| 全ポジションを一括決済する関数                                     |
//+------------------------------------------------------------------+
void CloseAllPositions()
  {
   // ポジション数が0になるまで繰り返す（逆順ループ）
   for(int i = OrdersTotal() - 1; i >= 0; i--)
     {
      // ポジションを選択できるか確認
      if(!OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
         continue;

      // 自分のEAのポジションかつ、現在の通貨ペアか確認
      if(OrderSymbol() != Symbol() || OrderMagicNumber() != MAGIC_NUMBER)
         continue;

      // OrderLots関数でロット数を取得
      double lots = OrderLots();

      // 注文タイプに応じて決済価格を設定
      double closePrice = 0;
      if(OrderType() == OP_BUY)
         closePrice = Bid;  // 買いポジションはBidで決済
      else if(OrderType() == OP_SELL)
         closePrice = Ask;  // 売りポジションはAskで決済
      else
         continue; // 指値・逆指値注文はスキップ

      // ポジションを決済（取得したロット数を使用）
      bool result = OrderClose(OrderTicket(), lots, closePrice, 10, clrRed);

      // 決済結果をログに出力
      if(result)
         Print("決済成功 チケット:", OrderTicket(), " ロット:", DoubleToString(lots, 2));
      else
         Print("決済失敗 チケット:", OrderTicket(), " エラー:", GetLastError());
     }
  }

//+------------------------------------------------------------------+
//| OnTick - 利益が一定額を超えたら全決済する例                       |
//+------------------------------------------------------------------+
void OnTick()
  {
   double totalProfit = 0.0;

   // 全ポジションの損益を合計
   for(int i = OrdersTotal() - 1; i >= 0; i--)
     {
      if(OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
        {
         if(OrderSymbol() == Symbol() && OrderMagicNumber() == MAGIC_NUMBER)
           {
            totalProfit += OrderProfit() + OrderSwap() + OrderCommission();
           }
        }
     }

   // 利益が10,000円を超えたら全決済
   if(totalProfit >= 10000)
     {
      Print("利益目標達成！全ポジション決済開始 利益:", DoubleToString(totalProfit, 0), "円");
      CloseAllPositions();
     }

   Comment("現在の合計損益: ", DoubleToString(totalProfit, 0), "円");
  }

#define MAGIC_NUMBER 12345 // マジックナンバー
input double PartialCloseProfit = 50.0; // 部分決済を行う利益pips

//+------------------------------------------------------------------+
//| ポジションの半分を部分決済する関数                                 |
//+------------------------------------------------------------------+
bool PartialClose(int ticket)
  {
   // チケット番号でポジションを選択
   if(!OrderSelect(ticket, SELECT_BY_TICKET))
     {
      Print("ポジション選択失敗 チケット:", ticket);
      return false;
     }

   // OrderLots関数で現在のロット数を取得
   double currentLots = OrderLots();

   // 半分のロット数を計算（最小ロット数以上になるよう調整）
   double halfLots = NormalizeDouble(currentLots / 2.0, 2);
   double minLot   = MarketInfo(Symbol(), MODE_MINLOT); // 最小ロット数を取得

   // 半分のロット数が最小ロット未満なら部分決済できない
   if(halfLots < minLot)
     {
      Print("ロット数が小さすぎるため部分決済できません。現在:", 
            DoubleToString(currentLots, 2), " 半分:", DoubleToString(halfLots, 2));
      return false;
     }

   // 決済価格を注文タイプに応じて設定
   double closePrice = 0;
   if(OrderType() == OP_BUY)
      closePrice = MarketInfo(Symbol(), MODE_BID);
   else if(OrderType() == OP_SELL)
      closePrice = MarketInfo(Symbol(), MODE_ASK);
   else
      return false;

   // 半分のロット数だけ決済を実行
   bool result = OrderClose(ticket, halfLots, closePrice, 10, clrBlue);

   if(result)
      Print("部分決済成功 チケット:", ticket, 
            " 決済ロット:", DoubleToString(halfLots, 2),
            " 残りロット:", DoubleToString(currentLots - halfLots, 2));
   else
      Print("部分決済失敗 チケット:", ticket, " エラー:", GetLastError());

   return result;
  }

//+------------------------------------------------------------------+
//| OnTick - 利益が一定pipsを超えたら半分決済                         |
//+------------------------------------------------------------------+
void OnTick()
  {
   for(int i = OrdersTotal() - 1; i >= 0; i--)
     {
      if(!OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
         continue;

      // 自分のEAかつ現在の通貨ペアのポジションか確認
      if(OrderSymbol() != Symbol() || OrderMagicNumber() != MAGIC_NUMBER)
         continue;

      // 現在の利益pipsを計算
      double profitPips = 0;
      if(OrderType() == OP_BUY)
         profitPips = (Bid - OrderOpenPrice()) / Point / 10;
      else if(OrderType() == OP_SELL)
         profitPips = (OrderOpenPrice() - Ask) / Point / 10;

      // OrderLots関数でロット数を確認し、初期ロットから減っていなければ部分決済
      double initialLot = 0.10; // 初期エントリーロット数
      double currentLots = OrderLots();

      // 利益が目標に達し、かつまだ部分決済していない場合
      if(profitPips >= PartialCloseProfit && currentLots >= initialLot)
        {
         PartialClose(OrderTicket());
        }
     }
  }

//+------------------------------------------------------------------+
//| ポジション情報一覧表示インジケーター                               |
//+------------------------------------------------------------------+
#property indicator_chart_window // チャートウィンドウに表示

//+------------------------------------------------------------------+
//| カスタムインジケーター初期化関数                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
   // 表示更新用のタイマーを1秒ごとに設定
   EventSetTimer(1);
   return(INIT_SUCCEEDED);
  }

//+------------------------------------------------------------------+
//| カスタムインジケーター終了処理                                     |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
   // チャートのコメントをクリア
   Comment("");
   EventKillTimer();
  }

//+------------------------------------------------------------------+
//| タイマーイベントで定期的に情報を更新                               |
//+------------------------------------------------------------------+
void OnTimer()
  {
   DisplayPositionInfo();
  }

//+------------------------------------------------------------------+
//| メインの計算関数（インジケーター必須）                             |
//+------------------------------------------------------------------+
int OnCalculate(const int rates_total,
                const int prev_calculated,
                const datetime &time[],
                const double &open[],
                const double &high[],
                const double &low[],
                const double &close[],
                const long &tick_volume[],
                const long &volume[],
                const int &spread[])
  {
   return(rates_total);
  }

//+------------------------------------------------------------------+
//| ポジション情報をチャートに表示する関数                             |
//+------------------------------------------------------------------+
void DisplayPositionInfo()
  {
   string info = "===== ポジション情報一覧 =====\n"; // 表示用文字列
   double totalLots   = 0.0; // 合計ロット数
   double totalProfit = 0.0; // 合計損益
   int    posCount    = 0;   // ポジション数カウンター

   // 全ポジションをループ
   for(int i = 0; i < OrdersTotal(); i++)
     {
      // ポジションを選択
      if(!OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
         continue;

      // 現在の通貨ペアのポジションのみ対象
      if(OrderSymbol() != Symbol())
         continue;

      // 成行注文（BUYまたはSELL）のみ対象
      if(OrderType() != OP_BUY && OrderType() != OP_SELL)
         continue;

      posCount++; // ポジション数をカウント

      // OrderLots関数でロット数を取得
      double lots   = OrderLots();
      double profit = OrderProfit() + OrderSwap() + OrderCommission();

      // 注文タイプを文字列に変換
      string typeStr = (OrderType() == OP_BUY) ? "BUY" : "SELL";

      // 各ポジションの情報を1行ずつ追加
      info += StringFormat("#%d | %s | %.2f lots | 建値:%.5f | 損益:%.0f円 | Magic:%d\n",
                           OrderTicket(),           // チケット番号
                           typeStr,                  // 売買方向
                           lots,                     // ロット数（OrderLots関数）
                           OrderOpenPrice(),         // エントリー価格
                           profit,                   // 損益
                           OrderMagicNumber());      // マジックナンバー

      // 合計値を加算
      totalLots   += lots;
      totalProfit += profit;
     }

   // 合計情報を追加
   info += "==============================\n";
   info += StringFormat("ポジション数: %d\n", posCount);
   info += StringFormat("合計ロット数: %.2f lots\n", totalLots);
   info += StringFormat("合計損益: %.0f円\n", totalProfit);

   // チャートに表示
   Comment(info);
  }

#define MAGIC_NUMBER 99999 // マジックナンバー
input double BaseLot       = 0.01; // 基本ロット数
input double LotMultiplier = 2.0;  // ロット倍率（マーチンゲール係数）
input double MaxLot        = 1.0;  // 最大ロット数（安全上限）
input int    NanpinPips    = 30;   // ナンピン間隔（pips）

//+------------------------------------------------------------------+
//| 最新ポジションのロット数を取得する関数                             |
//+------------------------------------------------------------------+
double GetLastPositionLots()
  {
   datetime latestTime = 0; // 最新のオープン時間を保持
   double   lastLots   = 0; // 最新ポジションのロット数

   for(int i = OrdersTotal() - 1; i >= 0; i--)
     {
      if(!OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
         continue;

      // 自分のEAかつ現在の通貨ペアか確認
      if(OrderSymbol() != Symbol() || OrderMagicNumber() != MAGIC_NUMBER)
         continue;

      // 成行注文のみ対象
      if(OrderType() != OP_BUY && OrderType() != OP_SELL)
         continue;

      // より新しいポジションを見つけたら更新
      if(OrderOpenTime() > latestTime)
        {
         latestTime = OrderOpenTime();
         // OrderLots関数で最新ポジションのロット数を取得
         lastLots = OrderLots();
        }
     }

   return lastLots; // 最新ポジションのロット数を返す
  }

//+------------------------------------------------------------------+
//| 最新ポジションの建値を取得する関数                                 |
//+------------------------------------------------------------------+
double GetLastPositionPrice()
  {
   datetime latestTime  = 0;
   double   lastPrice   = 0;

   for(int i = OrdersTotal() - 1; i >= 0; i--)
     {
      if(!OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
         continue;

      if(OrderSymbol() != Symbol() || OrderMagicNumber() != MAGIC_NUMBER)
         continue;

      if(OrderType() != OP_BUY && OrderType() != OP_SELL)
         continue;

      if(OrderOpenTime() > latestTime)
        {
         latestTime = OrderOpenTime();
         lastPrice  = OrderOpenPrice();
        }
     }

   return lastPrice;
  }

//+------------------------------------------------------------------+
//| 保有ポジション数を取得する関数                                     |
//+------------------------------------------------------------------+
int CountPositions()
  {
   int count = 0;

   for(int i = OrdersTotal() - 1; i >= 0; i--)
     {
      if(!OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
         continue;

      if(OrderSymbol() == Symbol() && OrderMagicNumber() == MAGIC_NUMBER)
        {
         if(OrderType() == OP_BUY || OrderType() == OP_SELL)
            count++;
        }
     }

   return count;
  }

//+------------------------------------------------------------------+
//| OnTick - ナンピン買いのロジック例                                  |
//+------------------------------------------------------------------+
void OnTick()
  {
   int posCount = CountPositions();

   // ポジションが0のとき：基本ロットで初回エントリー
   if(posCount == 0)
     {
      // ここにエントリー条件を記述（例として常にBUY）
      int ticket = OrderSend(Symbol(), OP_BUY, BaseLot, Ask, 10, 0, 0,
                             "Nanpin EA", MAGIC_NUMBER, 0, clrBlue);
      if(ticket > 0)
         Print("初回エントリー成功 ロット:", DoubleToString(BaseLot, 2));
      return;
     }

   // ポジションが1つ以上あるとき：ナンピン条件を確認
   double lastPrice = GetLastPositionPrice();
   double lastLots  = GetLastPositionLots();

   // 最新ポジションからナンピン間隔分だけ逆行したか確認
   double nanpinDistance = NanpinPips * Point * 10;

   if(Ask <= lastPrice - nanpinDistance)
     {
      // OrderLots関数で取得した前回ロットに倍率をかける
      double nextLot = NormalizeDouble(lastLots * LotMultiplier, 2);

      // 最大ロット数を超えないよう制限
      if(nextLot > MaxLot)
         nextLot = MaxLot;

      // ナンピンエントリー
      int ticket = OrderSend(Symbol(), OP_BUY, nextLot, Ask, 10, 0, 0,
                             "Nanpin EA", MAGIC_NUMBER, 0, clrGreen);
      if(ticket > 0)
         Print("ナンピンエントリー成功 ロット:", DoubleToString(nextLot, 2),
               " 前回ロット:", DoubleToString(lastLots, 2));
     }

   // チャートに情報を表示
   Comment("ポジション数: ", posCount,
           "\n最新ロット: ", DoubleToString(lastLots, 2),
           "\n最新建値: ", DoubleToString(lastPrice, 5));
  }

int ticketNum = OrderTicket();

//保有ポジションを一つ選択
if(OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
   {

      //チケット番号を取得
      int ticketNum = OrderTicket();

      //ポジションを決済
      bool orderClose = OrderClose( ticketNum, OrderLots(), OrderClosePrice(), 10, clrNONE);

   }

//+------------------------------------------------------------------+
//| 自分のEAのポジションだけを全決済する関数                          |
//+------------------------------------------------------------------+
#define MAGIC_NUMBER 12345  // このEA固有のマジックナンバー

void CloseAllMyPositions()
{
   // ポジション数の後ろから順にループ（決済するとインデックスがずれるため）
   for(int i = OrdersTotal() - 1; i >= 0; i--)
   {
      // ポジションを選択
      if(!OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
         continue;

      // 自分のEAのマジックナンバーかチェック
      if(OrderMagicNumber() != MAGIC_NUMBER)
         continue;

      // 対象通貨ペアかチェック
      if(OrderSymbol() != Symbol())
         continue;

      // チケット番号を取得
      int ticket = OrderTicket();

      // 決済処理を実行
      bool result = OrderClose(ticket, OrderLots(), OrderClosePrice(), 10, clrNONE);

      if(result)
         Print("チケット番号 ", ticket, " の決済に成功しました");
      else
         Print("チケット番号 ", ticket, " の決済に失敗。エラー: ", GetLastError());
   }
}

//+------------------------------------------------------------------+
//| チケット番号を配列に保存して保有ポジションを管理する例            |
//+------------------------------------------------------------------+
#define MAGIC_NUMBER 12345

// チケット番号を格納する配列
int g_tickets[];

//+------------------------------------------------------------------+
//| 自分のEAの全チケット番号を配列に取得する関数                      |
//+------------------------------------------------------------------+
int GetMyTickets(int &tickets[])
{
   int count = 0;
   // まず配列を空にする
   ArrayResize(tickets, 0);

   for(int i = 0; i < OrdersTotal(); i++)
   {
      if(!OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
         continue;

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

      // 配列を1つ拡張してチケット番号を格納
      count++;
      ArrayResize(tickets, count);
      tickets[count - 1] = OrderTicket();
   }

   return count;  // 保有ポジション数を返す
}

//+------------------------------------------------------------------+
//| OnTick内での使用例                                                |
//+------------------------------------------------------------------+
void OnTick()
{
   // 全チケット番号を取得
   int posCount = GetMyTickets(g_tickets);

   // 合計損益を計算
   double totalProfit = 0;
   for(int i = 0; i < posCount; i++)
   {
      // チケット番号で直接ポジションを選択
      if(OrderSelect(g_tickets[i], SELECT_BY_TICKET))
      {
         totalProfit += OrderProfit() + OrderSwap() + OrderCommission();
      }
   }

   // 合計利益が一定額を超えたら全決済
   if(totalProfit > 5000)  // 5000円以上の利益で全決済
   {
      for(int i = posCount - 1; i >= 0; i--)
      {
         if(OrderSelect(g_tickets[i], SELECT_BY_TICKET))
         {
            OrderClose(g_tickets[i], OrderLots(), OrderClosePrice(), 10, clrNONE);
         }
      }
   }
}

//+------------------------------------------------------------------+
//| 新規注文後にチケット番号でSL/TPを変更するEA例                    |
//+------------------------------------------------------------------+
#define MAGIC_NUMBER 12345

//+------------------------------------------------------------------+
//| 自分のEAのポジション数をカウントする関数                          |
//+------------------------------------------------------------------+
int CountMyOrders()
{
   int count = 0;
   for(int i = 0; i < OrdersTotal(); i++)
   {
      if(!OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
         continue;
      if(OrderMagicNumber() == MAGIC_NUMBER && OrderSymbol() == Symbol())
         count++;
   }
   return count;
}

//+------------------------------------------------------------------+
//| メイン処理                                                        |
//+------------------------------------------------------------------+
void OnTick()
{
   // すでにポジションがあれば何もしない
   if(CountMyOrders() > 0) return;

   // 移動平均のゴールデンクロスでエントリー
   double maFast     = iMA(Symbol(), 0, 10, 0, MODE_SMA, PRICE_CLOSE, 1);
   double maSlow     = iMA(Symbol(), 0, 50, 0, MODE_SMA, PRICE_CLOSE, 1);
   double maFastPrev = iMA(Symbol(), 0, 10, 0, MODE_SMA, PRICE_CLOSE, 2);
   double maSlowPrev = iMA(Symbol(), 0, 50, 0, MODE_SMA, PRICE_CLOSE, 2);

   // ゴールデンクロス発生時に買い注文
   if(maFastPrev < maSlowPrev && maFast > maSlow)
   {
      // まずSL/TPなしで注文を送信
      int ticket = OrderSend(Symbol(), OP_BUY, 0.1, Ask, 10,
                             0, 0, "GoldenCross EA", MAGIC_NUMBER, 0, clrBlue);

      if(ticket > 0)
      {
         Print("注文成功！チケット番号: ", ticket);

         // チケット番号でポジションを選択してSL/TPを設定
         if(OrderSelect(ticket, SELECT_BY_TICKET))
         {
            double openPrice = OrderOpenPrice();
            double sl = openPrice - 500 * Point;  // 50pipsのストップロス
            double tp = openPrice + 1000 * Point;  // 100pipsのテイクプロフィット

            bool modified = OrderModify(ticket, openPrice, sl, tp, 0, clrBlue);

            if(modified)
               Print("チケット番号 ", ticket, " のSL/TP設定に成功");
            else
               Print("SL/TP設定に失敗。エラー: ", GetLastError());
         }
      }
      else
      {
         Print("注文失敗。エラー: ", GetLastError());
      }
   }
}

//+------------------------------------------------------------------+
//| 最も古いポジションだけを決済する関数                              |
//+------------------------------------------------------------------+
#define MAGIC_NUMBER 12345

bool CloseOldestPosition()
{
   int    oldestTicket = -1;        // 最も古いポジションのチケット番号
   datetime oldestTime = TimeCurrent(); // 比較用の時刻（現在時刻で初期化）

   // 全ポジションをループして最も古いものを探す
   for(int i = 0; i < OrdersTotal(); i++)
   {
      if(!OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
         continue;

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

      // オープン時刻が最も古いポジションを記録
      if(OrderOpenTime() < oldestTime)
      {
         oldestTime   = OrderOpenTime();
         oldestTicket = OrderTicket();  // チケット番号を保存
      }
   }

   // 対象ポジションが見つかった場合に決済
   if(oldestTicket > 0)
   {
      if(OrderSelect(oldestTicket, SELECT_BY_TICKET))
      {
         bool result = OrderClose(oldestTicket, OrderLots(), OrderClosePrice(), 10, clrRed);

         if(result)
         {
            Print("最も古いポジション（チケット番号: ", oldestTicket, "）を決済しました");
            return true;
         }
         else
         {
            Print("決済失敗。チケット番号: ", oldestTicket, " エラー: ", GetLastError());
         }
      }
   }

   return false;
}

//+------------------------------------------------------------------+
//| チケット番号を使ったトレーリングストップ処理                      |
//+------------------------------------------------------------------+
#define MAGIC_NUMBER 12345

input int TrailingStartPips = 30;  // トレーリング開始pips
input int TrailingStopPips  = 20;  // トレーリング幅pips

void TrailingStopByTicket()
{
   double trailingStart = TrailingStartPips * Point * 10; // pipsをポイントに変換（5桁対応）
   double trailingStop  = TrailingStopPips  * Point * 10;

   for(int i = 0; i < OrdersTotal(); i++)
   {
      if(!OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
         continue;

      // 自分のEAかつ対象通貨ペアかチェック
      if(OrderMagicNumber() != MAGIC_NUMBER) continue;
      if(OrderSymbol() != Symbol())          continue;

      // チケット番号を取得（ログ出力やデバッグに使用）
      int ticket = OrderTicket();

      // 買いポジションのトレーリングストップ
      if(OrderType() == OP_BUY)
      {
         // 現在の含み益がトレーリング開始条件を満たしているか
         double profit = Bid - OrderOpenPrice();
         if(profit >= trailingStart)
         {
            // 新しいSL = 現在のBid - トレーリング幅
            double newSL = NormalizeDouble(Bid - trailingStop, Digits);

            // 現在のSLより高い場合のみ更新（SLは上方向にのみ移動）
            if(newSL > OrderStopLoss() || OrderStopLoss() == 0)
            {
               bool modified = OrderModify(ticket, OrderOpenPrice(), newSL, OrderTakeProfit(), 0, clrBlue);
               if(modified)
                  Print("チケット ", ticket, " のSLを ", newSL, " に更新しました");
               else
                  Print("チケット ", ticket, " のSL更新失敗。エラー: ", GetLastError());
            }
         }
      }

      // 売りポジションのトレーリングストップ
      if(OrderType() == OP_SELL)
      {
         // 現在の含み益がトレーリング開始条件を満たしているか
         double profit = OrderOpenPrice() - Ask;
         if(profit >= trailingStart)
         {
            // 新しいSL = 現在のAsk + トレーリング幅
            double newSL = NormalizeDouble(Ask + trailingStop, Digits);

            // 現在のSLより低い場合のみ更新（SLは下方向にのみ移動）
            if(newSL < OrderStopLoss() || OrderStopLoss() == 0)
            {
               bool modified = OrderModify(ticket, OrderOpenPrice(), newSL, OrderTakeProfit(), 0, clrRed);
               if(modified)
                  Print("チケット ", ticket, " のSLを ", newSL, " に更新しました");
               else
                  Print("チケット ", ticket, " のSL更新失敗。エラー: ", GetLastError());
            }
         }
      }
   }
}

//+------------------------------------------------------------------+
//| 期限切れの待機注文をチケット番号で削除する関数                    |
//+------------------------------------------------------------------+
#define MAGIC_NUMBER 12345

input int PendingExpireMinutes = 60;  // 待機注文の有効期限（分）

void DeleteExpiredPendingOrders()
{
   // 有効期限の基準時刻を計算
   datetime expireTime = TimeCurrent() - PendingExpireMinutes * 60;

   // 後ろから順にループ（削除するとインデックスがずれるため）
   for(int i = OrdersTotal() - 1; i >= 0; i--)
   {
      if(!OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
         continue;

      // 自分のEAかつ対象通貨ペアかチェック
      if(OrderMagicNumber() != MAGIC_NUMBER) continue;
      if(OrderSymbol() != Symbol())          continue;

      // 待機注文かどうかを判定（OP_BUYLIMITからOP_SELLSTOPまで）
      int type = OrderType();
      if(type != OP_BUYLIMIT && type != OP_SELLLIMIT &&
         type != OP_BUYSTOP  && type != OP_SELLSTOP)
         continue;  // 成行ポジションはスキップ

      // 注文時刻が有効期限を過ぎているかチェック
      if(OrderOpenTime() < expireTime)
      {
         // チケット番号を取得して待機注文を削除
         int ticket = OrderTicket();
         bool result = OrderDelete(ticket, clrNONE);

         if(result)
            Print("期限切れの待機注文を削除。チケット番号: ", ticket,
                  " 注文時刻: ", TimeToStr(OrderOpenTime()));
         else
            Print("待機注文の削除に失敗。チケット番号: ", ticket,
                  " エラー: ", GetLastError());
      }
   }
}

//大域変数にマジックナンバーの数値を書く
int magicNumber = 10;

//エントリーするときに、マジックナンバーを設定する
//OrderSend関数の９番目の引数に設定
int ticketNum = OrderSend( NULL, OP_BUY, 0.1, Ask, 20, 105.000, 110.000, "自動売買の注文", magicNumber, 0, clrRed);

int orderMagicNumber = OrderMagicNumber();

//大域変数にマジックナンバーの数値を書く
int magicNumber = 10;

//保有ポジションを一つ選択
if(OrderSelect(0,SELECT_BY_POS,MODE_TRADES))
{
   //選択したポジションのマジックナンバーが
   //自動売買のマジックナンバーと同じかどうかチェック
   if(OrderMagicNumber() == magicNumber)
   {
      //ここにポジションを決済するプログラムを書く
   }
}

//大域変数にマジックナンバーの数値を書く
int magicNumber = 10;

void OnTick()
{
//---

   //エントリーするときに、マジックナンバーを設定する
   //OrderSend関数の９番目の引数に設定
   int ticketNum = OrderSend(NULL, OP_BUY, 0.1, Ask, 20, 105.000, 110.000, "自動売買の注文", magicNumber, 0, clrRed);

   //保有ポジションを一つずつチェックしていく
   for(int i = OrdersTotal() - 1; i >= 0; i--)
   {
      //保有ポジションを一つ選択
      if(OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
      {
         //選択したポジションが、実行されている通貨ペアと同じかどうかチェック
         if(OrderSymbol() == Symbol())
         {
            //選択したポジションが、この自動売買のマジックナンバーと同じかチェック
            if(OrderMagicNumber() == magicNumber)
            {
               //ここにポジションを決済するプログラムを書く
               //わかりやすいようにprintしておきます。
               Print("OrderSymbol : " + OrderSymbol());
               Print("Symbol : " + Symbol());
               Print("OrderMagicNumber : " + IntegerToString(OrderMagicNumber()));
            }
         }
      }
   }

}

// マジックナンバーの定義
int magicNumber = 12345;

//+------------------------------------------------------------------+
//| 自分のEAが保有しているポジション数をカウントする関数              |
//+------------------------------------------------------------------+
int CountMyPositions()
{
   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() != magicNumber)
         continue;

      // すべての条件を満たしたらカウントを増やす
      count++;
   }

   return count; // ポジション数を返す
}

//+------------------------------------------------------------------+
//| OnTick関数                                                        |
//+------------------------------------------------------------------+
void OnTick()
{
   // 自分のEAのポジション数を取得
   int myPositions = CountMyPositions();

   // ポジションが0個のときだけエントリーする
   if(myPositions == 0)
   {
      // ここにエントリー条件を書く
      // 例：買いエントリー
      int ticket = OrderSend(Symbol(), OP_BUY, 0.1, Ask, 20, 0, 0,
                             "MyEA", magicNumber, 0, clrBlue);

      if(ticket > 0)
         Print("エントリー成功！チケット番号: ", ticket);
      else
         Print("エントリー失敗。エラーコード: ", GetLastError());
   }
   else
   {
      Print("既にポジションを ", myPositions, " 個保有中です。");
   }
}

// マジックナンバーの定義
int magicNumber = 12345;

//+------------------------------------------------------------------+
//| 自分のEAのポジションを全決済する関数                              |
//+------------------------------------------------------------------+
void CloseAllMyPositions()
{
   // 後ろからループすることで、決済後のインデックスずれを防ぐ
   for(int i = OrdersTotal() - 1; i >= 0; i--)
   {
      // ポジションを選択
      if(!OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
         continue;

      // 通貨ペアが一致するかチェック
      if(OrderSymbol() != Symbol())
         continue;

      // マジックナンバーが一致するかチェック
      if(OrderMagicNumber() != magicNumber)
         continue;

      // ポジションの種類に応じて決済する
      bool result = false;

      if(OrderType() == OP_BUY)
      {
         // 買いポジションの決済（決済価格はBid）
         result = OrderClose(OrderTicket(), OrderLots(), Bid, 20, clrRed);
      }
      else if(OrderType() == OP_SELL)
      {
         // 売りポジションの決済（決済価格はAsk）
         result = OrderClose(OrderTicket(), OrderLots(), Ask, 20, clrBlue);
      }

      // 決済結果をログに出力
      if(result)
         Print("決済成功！チケット番号: ", OrderTicket());
      else
         Print("決済失敗。チケット番号: ", OrderTicket(),
               " エラーコード: ", GetLastError());
   }
}

//+------------------------------------------------------------------+
//| OnTick関数                                                        |
//+------------------------------------------------------------------+
void OnTick()
{
   // 例：合計損益が -10000円を下回ったら全決済する
   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() != magicNumber)
         continue;

      // そのポジションの損益を合計に加算
      totalProfit += OrderProfit() + OrderSwap() + OrderCommission();
   }

   // 合計損益が -10000 を下回ったら全決済
   if(totalProfit < -10000)
   {
      Print("合計損益が ", totalProfit, " 円のため、全決済を実行します。");
      CloseAllMyPositions();
   }
}

// 外部パラメータとしてマジックナンバーを定義
// EAをチャートに適用するときに、数値を変更できる
input int MagicNumber = 12345;

//+------------------------------------------------------------------+
//| OnTick関数                                                        |
//+------------------------------------------------------------------+
void OnTick()
{
   // 保有ポジションをチェック
   for(int i = OrdersTotal() - 1; i >= 0; i--)
   {
      if(!OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
         continue;

      if(OrderSymbol() != Symbol())
         continue;

      // 外部パラメータのマジックナンバーと比較
      if(OrderMagicNumber() != MagicNumber)
         continue;

      // マジックナンバーが一致するポジションの情報を表示
      Print("チケット番号: ", OrderTicket(),
            " マジックナンバー: ", OrderMagicNumber(),
            " 損益: ", OrderProfit());
   }
}

string orderSymbol = OrderSymbol();

//保有ポジションを一つ選択
if(OrderSelect(0,SELECT_BY_POS,MODE_TRADES))
   {

   //選択したポジションが、実行されている通貨ペアと同じかどうかチェック
   if(OrderSymbol() == Symbol())
   {

      //ここにポジションを決済するプログラムを書く

   }
}

//保有ポジションを一つずつチェックしていく
  for( int i = OrdersTotal() - 1; i >= 0; i--)
     {

      //保有ポジションを一つ選択
      if( OrderSelect( i, SELECT_BY_POS, MODE_TRADES))
          {

              //選択したポジションが、実行されている通貨ペアと同じかどうかチェック
              if( OrderSymbol() == Symbol())
              {

              //ここにポジションを決済するプログラムを書く

              }
          }
     }

//+------------------------------------------------------------------+
//| 自分の通貨ペアの買いポジションだけを全決済する関数               |
//+------------------------------------------------------------------+
void CloseAllBuyPositions()
{
   // 保有ポジションを後ろからループ（決済するとインデックスがずれるため）
   for(int i = OrdersTotal() - 1; i >= 0; i--)
   {
      // ポジションを選択
      if(OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
      {
         // 通貨ペアが一致しているかチェック
         if(OrderSymbol() == Symbol())
         {
            // 買いポジション（OP_BUY）かどうかチェック
            if(OrderType() == OP_BUY)
            {
               // 買いポジションを決済（Bid価格で決済する）
               bool result = OrderClose(OrderTicket(), OrderLots(), MarketInfo(OrderSymbol(), MODE_BID), 10, clrRed);

               // 決済結果をログに出力
               if(result)
                  Print("買いポジション決済成功: チケット=", OrderTicket());
               else
                  Print("買いポジション決済失敗: エラー=", GetLastError());
            }
         }
      }
   }
}

//+------------------------------------------------------------------+
//| OnTick関数での使用例                                              |
//+------------------------------------------------------------------+
void OnTick()
{
   // 例：RSIが70を超えたら買いポジションを全決済する
   double rsi = iRSI(Symbol(), 0, 14, PRICE_CLOSE, 0);

   if(rsi > 70)
   {
      CloseAllBuyPositions();
   }
}

//+------------------------------------------------------------------+
//| 自分の通貨ペアのポジション数をカウントする関数                   |
//| buyCount: 買いポジション数（参照渡しで返す）                     |
//| sellCount: 売りポジション数（参照渡しで返す）                    |
//+------------------------------------------------------------------+
void CountMyPositions(int &buyCount, int &sellCount)
{
   // カウンターを初期化
   buyCount  = 0;
   sellCount = 0;

   // 全ポジションをループしてチェック
   for(int i = OrdersTotal() - 1; i >= 0; i--)
   {
      // ポジションを選択
      if(OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
      {
         // 自分の通貨ペアかどうかチェック
         if(OrderSymbol() == Symbol())
         {
            // 買いポジションならbuyCountを加算
            if(OrderType() == OP_BUY)
               buyCount++;

            // 売りポジションならsellCountを加算
            if(OrderType() == OP_SELL)
               sellCount++;
         }
      }
   }
}

//+------------------------------------------------------------------+
//| OnTick関数での使用例                                              |
//+------------------------------------------------------------------+
void OnTick()
{
   int buyCount, sellCount;

   // 自分の通貨ペアのポジション数を取得
   CountMyPositions(buyCount, sellCount);

   // ポジション数をログに出力
   Print("買いポジション数=", buyCount, " 売りポジション数=", sellCount);

   // 例：買いポジションが0のときだけ新規エントリーする
   if(buyCount == 0)
   {
      // ここに新規注文のプログラムを書く
   }
}

//+------------------------------------------------------------------+
//| マジックナンバーの設定                                           |
//+------------------------------------------------------------------+
#define MAGIC_NUMBER 123456  // このEA専用のマジックナンバー

//+------------------------------------------------------------------+
//| 通貨ペア＋マジックナンバーで自分のポジションだけを全決済する関数 |
//+------------------------------------------------------------------+
void CloseMyAllPositions()
{
   // 保有ポジションを後ろからループ
   for(int i = OrdersTotal() - 1; i >= 0; i--)
   {
      // ポジションを選択
      if(OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
      {
         // 通貨ペアが一致しているかチェック
         if(OrderSymbol() != Symbol()) continue;

         // マジックナンバーが一致しているかチェック（自分のEAが建てたポジションか）
         if(OrderMagicNumber() != MAGIC_NUMBER) continue;

         // 決済価格を決定（買いならBid、売りならAsk）
         double closePrice = 0;
         if(OrderType() == OP_BUY)
            closePrice = MarketInfo(OrderSymbol(), MODE_BID);
         else if(OrderType() == OP_SELL)
            closePrice = MarketInfo(OrderSymbol(), MODE_ASK);
         else
            continue;  // 指値・逆指値注文はスキップ

         // ポジションを決済
         bool result = OrderClose(OrderTicket(), OrderLots(), closePrice, 10, clrYellow);

         // 決済結果をログに出力
         if(result)
            Print("決済成功: チケット=", OrderTicket(), " 通貨ペア=", OrderSymbol());
         else
            Print("決済失敗: チケット=", OrderTicket(), " エラー=", GetLastError());
      }
   }
}

//+------------------------------------------------------------------+
//| OnTick関数での使用例                                              |
//+------------------------------------------------------------------+
void OnTick()
{
   // 例：金曜日の22時を過ぎたら週末リスク回避のため全決済する
   if(DayOfWeek() == 5 && Hour() >= 22)
   {
      CloseMyAllPositions();
      return;  // 決済後は新規エントリーしない
   }

   // ここに通常のエントリーロジックを書く
}

//+------------------------------------------------------------------+
//| 自分の通貨ペアの合計損益をチャートに表示するインジケーター       |
//+------------------------------------------------------------------+
#property indicator_chart_window  // チャートウィンドウに表示

//+------------------------------------------------------------------+
//| 初期化関数                                                        |
//+------------------------------------------------------------------+
int OnInit()
{
   // タイマーを1秒間隔で設定（リアルタイム更新用）
   EventSetTimer(1);
   return(INIT_SUCCEEDED);
}

//+------------------------------------------------------------------+
//| 終了処理関数                                                      |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
   // タイマーを停止
   EventKillTimer();

   // 表示したオブジェクトを削除
   ObjectDelete(0, "ProfitLabel");
   ObjectDelete(0, "ProfitValue");
}

//+------------------------------------------------------------------+
//| 自分の通貨ペアの合計損益を計算する関数                           |
//+------------------------------------------------------------------+
double CalcMyProfit()
{
   double totalProfit = 0;

   // 全ポジションをループ
   for(int i = OrdersTotal() - 1; i >= 0; i--)
   {
      if(OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
      {
         // 自分の通貨ペアのポジションだけを合計する
         if(OrderSymbol() == Symbol())
         {
            // OrderProfit()で損益、OrderSwap()でスワップ、OrderCommission()で手数料を取得
            totalProfit += OrderProfit() + OrderSwap() + OrderCommission();
         }
      }
   }

   return(totalProfit);
}

//+------------------------------------------------------------------+
//| タイマーイベント（1秒ごとに実行）                                |
//+------------------------------------------------------------------+
void OnTimer()
{
   // 自分の通貨ペアの合計損益を計算
   double profit = CalcMyProfit();

   // 損益の文字列を作成
   string profitText = Symbol() + " 合計損益: " + DoubleToString(profit, 2) + " " + AccountCurrency();

   // 損益に応じて色を変える（プラスなら青、マイナスなら赤）
   color textColor = (profit >= 0) ? clrDodgerBlue : clrRed;

   // チャート左上にテキストを表示
   if(ObjectFind(0, "ProfitValue") < 0)
   {
      // オブジェクトが存在しない場合は新規作成
      ObjectCreate(0, "ProfitValue", OBJ_LABEL, 0, 0, 0);
      ObjectSetInteger(0, "ProfitValue", OBJPROP_CORNER, CORNER_LEFT_UPPER);
      ObjectSetInteger(0, "ProfitValue", OBJPROP_XDISTANCE, 20);
      ObjectSetInteger(0, "ProfitValue", OBJPROP_YDISTANCE, 30);
      ObjectSetInteger(0, "ProfitValue", OBJPROP_FONTSIZE, 14);
   }

   // テキストと色を更新
   ObjectSetString(0, "ProfitValue", OBJPROP_TEXT, profitText);
   ObjectSetInteger(0, "ProfitValue", OBJPROP_COLOR, textColor);

   // チャートを再描画
   ChartRedraw();
}

//+------------------------------------------------------------------+
//| OnCalculate関数（インジケーターに必須）                           |
//+------------------------------------------------------------------+
int OnCalculate(const int rates_total,
                const int prev_calculated,
                const datetime &time[],
                const double &open[],
                const double &high[],
                const double &low[],
                const double &close[],
                const long &tick_volume[],
                const long &volume[],
                const int &spread[])
{
   return(rates_total);
}

bool  OrderSelect( ①, ②, ③);

bool select = OrderSelect( 0, ②, ③);

bool select = OrderSelect( 0, SELECT_BY_POS, ③);

bool select = OrderSelect( 0, SELECT_BY_POS, MODE_TRADES);

//保有ポジションを一つずつチェックしていく
for( int i = OrdersTotal() - 1; i >= 0; i--)
{
   //保有ポジションを一つ選択
   if( OrderSelect( i, SELECT_BY_POS, MODE_TRADES))
   {
      //ここにポジションを操作するプログラムを書く
   }
}

// マジックナンバーの定義（EAごとに固有の番号を設定する）
#define MAGIC_NUMBER 12345

//+------------------------------------------------------------------+
//| 自分のEAが保有しているポジション数をカウントする関数             |
//+------------------------------------------------------------------+
int CountMyPositions()
{
   int count = 0; // カウント用の変数を初期化

   // 保有ポジションを後ろから順にチェックしていく
   for(int i = OrdersTotal() - 1; i >= 0; i--)
   {
      // ポジションを1つ選択する
      if(OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
      {
         // マジックナンバーが自分のEAのものかチェック
         if(OrderMagicNumber() != MAGIC_NUMBER) continue;

         // 通貨ペアが現在のチャートと一致しているかチェック
         if(OrderSymbol() != Symbol()) continue;

         // 両方一致した場合のみカウントを増やす
         count++;
      }
   }

   return count; // 自分のEAのポジション数を返す
}

//+------------------------------------------------------------------+
//| OnTick：ティックごとに呼ばれる関数                               |
//+------------------------------------------------------------------+
void OnTick()
{
   // 自分のEAのポジション数を取得
   int myPositions = CountMyPositions();

   // ログに出力して確認する
   Print("自分のEAの保有ポジション数: ", myPositions);

   // ポジションがなければ新規注文を検討する、など
   if(myPositions == 0)
   {
      // ここにエントリー条件を書く
   }
}

// マジックナンバーの定義
#define MAGIC_NUMBER 12345

//+------------------------------------------------------------------+
//| 自分のEAの保有ポジションをすべて決済する関数                     |
//+------------------------------------------------------------------+
void CloseAllMyPositions()
{
   // 後ろから順にループする（決済するとインデックスがずれるため）
   for(int i = OrdersTotal() - 1; i >= 0; i--)
   {
      // ポジションを1つ選択する
      if(!OrderSelect(i, SELECT_BY_POS, MODE_TRADES)) continue;

      // 自分のEAのマジックナンバーでなければスキップ
      if(OrderMagicNumber() != MAGIC_NUMBER) continue;

      // 現在のチャートの通貨ペアでなければスキップ
      if(OrderSymbol() != Symbol()) continue;

      // 注文種別を取得する
      int type = OrderType();

      // 買いポジション（OP_BUY）の場合
      if(type == OP_BUY)
      {
         // Bid価格で決済する
         bool result = OrderClose(
            OrderTicket(),   // チケット番号
            OrderLots(),     // ロット数
            MarketInfo(Symbol(), MODE_BID), // 現在のBid価格
            3,               // スリッページ（3ポイント）
            clrRed           // チャート上の矢印の色
         );

         // 決済結果をログに出力
         if(result)
            Print("買いポジション決済成功: チケット=", OrderTicket());
         else
            Print("買いポジション決済失敗: エラー=", GetLastError());
      }
      // 売りポジション（OP_SELL）の場合
      else if(type == OP_SELL)
      {
         // Ask価格で決済する
         bool result = OrderClose(
            OrderTicket(),   // チケット番号
            OrderLots(),     // ロット数
            MarketInfo(Symbol(), MODE_ASK), // 現在のAsk価格
            3,               // スリッページ（3ポイント）
            clrBlue          // チャート上の矢印の色
         );

         // 決済結果をログに出力
         if(result)
            Print("売りポジション決済成功: チケット=", OrderTicket());
         else
            Print("売りポジション決済失敗: エラー=", GetLastError());
      }
   }
}

//+------------------------------------------------------------------+
//| OnTick：ティックごとに呼ばれる関数                               |
//+------------------------------------------------------------------+
void OnTick()
{
   // 例：金曜日の22時以降になったら全決済する（週末持ち越し防止）
   if(DayOfWeek() == 5 && Hour() >= 22)
   {
      CloseAllMyPositions();
   }
}

// マジックナンバーの定義
#define MAGIC_NUMBER 12345

//+------------------------------------------------------------------+
//| 自分のEAの保有ポジション合計損益を取得する関数                   |
//| 戻り値：合計損益（通貨単位。例：ドル口座なら米ドル）             |
//+------------------------------------------------------------------+
double GetTotalProfit()
{
   double totalProfit = 0.0; // 合計損益を格納する変数

   // 保有ポジションを後ろから順にチェック
   for(int i = OrdersTotal() - 1; i >= 0; i--)
   {
      // ポジションを選択する
      if(!OrderSelect(i, SELECT_BY_POS, MODE_TRADES)) continue;

      // マジックナンバーが異なればスキップ
      if(OrderMagicNumber() != MAGIC_NUMBER) continue;

      // 通貨ペアが異なればスキップ
      if(OrderSymbol() != Symbol()) continue;

      // 買い or 売りポジションのみ対象（待機注文は除外する）
      if(OrderType() != OP_BUY && OrderType() != OP_SELL) continue;

      // OrderProfit()で含み損益、OrderSwap()でスワップ、
      // OrderCommission()で手数料を取得し、すべて合算する
      totalProfit += OrderProfit() + OrderSwap() + OrderCommission();
   }

   return totalProfit; // 合計損益を返す
}

//+------------------------------------------------------------------+
//| OnTick：ティックごとに呼ばれる関数                               |
//+------------------------------------------------------------------+
void OnTick()
{
   // 合計損益を取得
   double profit = GetTotalProfit();

   // チャート左上にコメントとして表示
   Comment("合計損益: ", DoubleToString(profit, 2), " ", AccountCurrency());

   // 例：合計利益が5000円以上になったら全決済
   if(profit >= 5000.0)
   {
      Print("目標利益に到達！全決済を実行します。合計損益=", profit);
      // ここで全決済関数（例２のCloseAllMyPositions）を呼び出す
      // CloseAllMyPositions();
   }

   // 例：合計損失が-3000円以下になったら損切り全決済
   if(profit <= -3000.0)
   {
      Print("損切りラインに到達！全決済を実行します。合計損益=", profit);
      // ここで全決済関数（例２のCloseAllMyPositions）を呼び出す
      // CloseAllMyPositions();
   }
}