code.lua

--[[ Lua code. See documentation: https://api.tabletopsimulator.com/ --]]
--TTS开发守则
--1.给ai以需求
--2.能拿则拿
--3.注意拼写！！！
--4.通读API文档

--[[ The onLoad event is called after the game save finishes loading. --]]
function onLoad(save_state)
  WebRequest.get("http://www.justgan.cn/datas/cards.csv", function(request)
          data = processCSVData(request)
        end
  )
  canAddButton = false
  cardInstances = {}
  tokenInstances = {}
  gameInfo = {
    stage = "",
    redealA = 3,
    redealB = 2,
    meleeA = {},
    rangeA = {},
    meleeB = {},
    rangeB = {},
    deckA = nil,
    deckB = nil,
    originalDeckA = nil,
    originalDeckB = nil,
    round = 0,
    turn = 0,
    allTurn = 0,
    stopA = false,
    stopB = false,
    jumpA = false,
    jumpB = false,
    playedA = false,
    playedB = false,
    pointA = 0,
    pointB = 0,
    board = nil
  }
  count = 0
  countCards = 0
  countAdjust = 0
  globalButtons = {}
  clipBoards = {}
  scale = 2
  size_card = {9.25, 0, 12} -- 假设这是单张卡牌的尺寸（宽、无意义、高）
  Turns.enable = true
  Turns.pass_turns = true
  flagODA = false
  flagODB = false
  choosing = false
  chosenCard = nil
  chooseCards = {} -- 存储选择的卡牌GUID列表
  chooseNum = 0 -- 需要选择的卡牌数量
  chooseUIObjects = {} -- 存储UI对象引用，用于清理
  objectUI = {}
  objectAsset = {}
  
  -- FollowCursor相关变量
  followCursorData = {} -- 存储每个玩家的追踪数据 {playerColor = {cardObj, isTracking}}
  
  -- 出牌区列表（FollowCursor功能使用）
  PLAY_ZONES = {
    "zoneMeleeA",
    "zoneMeleeB", 
    "zoneRangeA",
    "zoneRangeB"
  }
  
  -- 旋转检测相关变量
  cardRotated = {} -- 存储卡牌是否被旋转过 {cardGuid = true/false}
  
  -- =========================================================
  -- 指令系统：Order 按钮状态追踪与目标选择模式
  -- =========================================================
  -- 追踪每张卡牌的指令按钮状态
  -- {cardGuid -> {turnEntered=N, isDormant=true/false, filter="...", selectType="..."}}
  orderButtonState = {}
  
  -- target_field 交互模式的选择状态
  targetSelectMode = false   -- 是否处于目标选择模式
  targetSelectData = {       -- 当前目标选择的配置和进度
    filter       = nil,      -- 筛选范围 ("allyRows"/"enemyRows"/"battleGround")
    min          = 1,        -- 最少选择数量
    max          = 1,        -- 最多选择数量
    orderCardGuid = nil,     -- 发起 Order 的卡牌 GUID（可用于排除自身）
    selected     = {}        -- 已选中的目标 GUID 列表
  }
end

function deepCopyItable(t)
    local newTable = {}
    if t then
      for k, v in pairs(t) do
          if type(v) == 'table' then
              newTable[k] = deepCopyItable(v) -- 递归复制子表
          else
              newTable[k] = v -- 直接复制非表类型的数据
          end
      end
    end
    return newTable
end

-- 处理单个牌组的通用函数
function processDeck(deck)
  if deck then
    local tempDeck = {}
    for _, object in ipairs(deck.getObjects()) do
      local instance = getGUIDInstance(object.guid)
      local instanceCopy = deepCopyItable(instance) -- 创建 instance 的深拷贝
      instanceCopy.inGameObj = instanceCopy.inGameObjGUID -- 修改拷贝，不影响原始对象
      instanceCopy.owner = nil
      instanceCopy.buttonDisplay = nil
      table.insert(tempDeck, instanceCopy)
    end
    return tempDeck
  end
  return nil
end

function processDeckWithOutGetObjects(deck)
  if deck then
    local tempDeck = {}
    for _, object in ipairs(deck) do
      local instance = getGUIDInstance(object.guid)
      local instanceCopy = deepCopyItable(instance) -- 创建 instance 的深拷贝
      instanceCopy.inGameObj = nil -- 修改拷贝，不影响原始对象
      instanceCopy.owner = nil
      instanceCopy.buttonDisplay = nil
      table.insert(tempDeck, instanceCopy)
    end
    return tempDeck
  end
  return nil
end

function processCards(cardListName, processedGameInfo)
  local temp = {}
  for _, card in ipairs(processedGameInfo[cardListName]) do
    local instance = getObjectInstance(card)
    if instance then
      -- 清理 userdata 字段，只保留可序列化的数据
      local safeInstance = deepCopyItable(instance)
      safeInstance.inGameObj = nil
      safeInstance.inGameObjGuid = instance.inGameObjGuid
      safeInstance.owner = instance.owner and instance.owner.color or nil
      safeInstance.buttonDisplay = nil
      
      -- 清理 statuses 中的 userdata
      if safeInstance.statuses then
        local safeStatuses = {}
        for _, status in ipairs(safeInstance.statuses) do
          if type(status) == "table" then
            table.insert(safeStatuses, {
              inGameObjGuid = status.inGameObjGuid,
              type = status.type,
              charge = status.charge
            })
          else
            table.insert(safeStatuses, tostring(status))
          end
        end
        safeInstance.statuses = safeStatuses
      end
      
      table.insert(temp, safeInstance)
    end
  end
  processedGameInfo[cardListName] = temp
end

-- 修改后的 emit 函数
function emit(event)
  local url = "http://www.justgan.cn/server"
  
  -- 不使用 deepCopyItable(gameInfo)，因为它会复制 TTS userdata（Deck/Card 对象）导致 JSON 报错
  -- 手动构建一个完全可序列化的 gameInfo 表
  local processedGameInfo = {
    stage = gameInfo.stage or "",
    redealA = gameInfo.redealA or 3,
    redealB = gameInfo.redealB or 2,
    round = gameInfo.round or 0,
    turn = gameInfo.turn or 0,
    allTurn = gameInfo.allTurn or 0,
    stopA = gameInfo.stopA or false,
    stopB = gameInfo.stopB or false,
    jumpA = gameInfo.jumpA or false,
    jumpB = gameInfo.jumpB or false,
    playedA = gameInfo.playedA or false,
    playedB = gameInfo.playedB or false,
    pointA = gameInfo.pointA or 0,
    pointB = gameInfo.pointB or 0,
    originalDeckA = nil,
    originalDeckB = nil
  }
  
  -- 安全处理牌库（deckA/deckB 是 TTS userdata，不能直接序列化）
  -- 注意：这里发送的是当前牌库中的完整卡牌信息，用于服务器实时判定
  local function processCurrentDeck(deckRef, fieldName)
    if not deckRef then
      processedGameInfo[fieldName] = {}
      return
    end
    local temp = {}
    -- 获取牌库中的所有卡牌对象
    local deckObjects = deckRef.getObjects and deckRef.getObjects() or {}
    for _, cardObj in ipairs(deckObjects) do
      if cardObj and cardObj.guid then
        local instance = getGUIDInstance(cardObj.guid)
        if instance then
          -- 使用白名单方式，只提取基本类型数据，避免任何 userdata 泄露
          local safeInstance = {
            dataId = tostring(instance.dataId or ""),
            power = tonumber(instance.power) or 0,
            basePower = tonumber(instance.basePower) or 0,
            armor = tonumber(instance.armor) or 0,
            provision = tonumber(instance.provision) or 0,
            guid = instance.guid or cardObj.guid,
            inGameObjGuid = instance.guid or cardObj.guid,
            owner = instance.owner and instance.owner.color or nil,
            statuses = {}
          }
          
          -- 安全地处理 statuses，只保留基本字段
          if instance.statuses then
            for _, status in ipairs(instance.statuses) do
              if type(status) == "table" then
                table.insert(safeInstance.statuses, {
                  inGameObjGuid = tostring(status.inGameObjGuid or ""),
                  type = tostring(status.type or ""),
                  charge = tonumber(status.charge) or 0
                })
              end
            end
          end
          
          table.insert(temp, safeInstance)
        else
          -- 如果找不到实例，至少保留 guid 和 dataId
          table.insert(temp, {guid = cardObj.guid, dataId = "", inGameObjGuid = cardObj.guid})
        end
      end
    end
    processedGameInfo[fieldName] = temp
  end
  
  processCurrentDeck(gameInfo.deckA, "deckA")
  processCurrentDeck(gameInfo.deckB, "deckB")
  
  -- board 只保留 GUID
  if gameInfo.board then
    processedGameInfo.board = {
      zones = {
        meleeA = gameInfo.board.zones.meleeA.getGUID(),
        meleeB = gameInfo.board.zones.meleeB.getGUID(),
        rangeA = gameInfo.board.zones.rangeA.getGUID(),
        rangeB = gameInfo.board.zones.rangeB.getGUID(),
        deckA  = gameInfo.board.zones.deckA.getGUID(),
        deckB  = gameInfo.board.zones.deckB.getGUID(),
        graveA = gameInfo.board.zones.graveA.getGUID(),
        graveB = gameInfo.board.zones.graveB.getGUID()
      }
    }
  else
    processedGameInfo.board = {zones = {}}
  end
  
  -- 处理战场上的卡牌列表：发送完整的卡牌实例数据
  local function processFieldCards(fieldName)
    local cards = gameInfo[fieldName] or {}
    local temp = {}
    for _, card in ipairs(cards) do
      if card then
        local guid = ""
        if type(card) == "userdata" and card.guid then
          guid = card.guid
        elseif type(card) == "table" and card.inGameObjGuid then
          guid = card.inGameObjGuid
        else
          guid = tostring(card)
        end
        
        -- 获取完整的卡牌实例数据
        local instance = getGUIDInstance(guid)
        if instance then
          -- 使用白名单方式，只提取基本类型数据，避免任何 userdata 泄露
          local safeInstance = {
            dataId = tostring(instance.dataId or ""),
            power = tonumber(instance.power) or 0,
            basePower = tonumber(instance.basePower) or 0,
            armor = tonumber(instance.armor) or 0,
            provision = tonumber(instance.provision) or 0,
            guid = instance.guid or guid,
            inGameObjGuid = instance.guid or guid,
            owner = instance.owner and instance.owner.color or nil,
            statuses = {}
          }
          
          -- 安全地处理 statuses，只保留基本字段
          if instance.statuses then
            for _, status in ipairs(instance.statuses) do
              if type(status) == "table" then
                table.insert(safeInstance.statuses, {
                  inGameObjGuid = tostring(status.inGameObjGuid or ""),
                  type = tostring(status.type or ""),
                  charge = tonumber(status.charge) or 0
                })
              end
            end
          end
          
          table.insert(temp, safeInstance)
        else
          -- 如果找不到实例，至少保留 GUID
          table.insert(temp, {inGameObjGuid = guid, dataId = ""})
        end
      end
    end
    processedGameInfo[fieldName] = temp
  end
  
  processFieldCards("meleeA")
  processFieldCards("rangeA")
  processFieldCards("meleeB")
  processFieldCards("rangeB")
  
  -- 处理墓场中的卡牌列表：发送完整的卡牌实例数据
  local function processGraveCards(fieldName)
    local graveZone = gameInfo.board and gameInfo.board.zones and gameInfo.board.zones[fieldName]
    if not graveZone then
      processedGameInfo[fieldName] = {}
      return
    end
    
    local temp = {}
    -- 获取墓场区域中的所有对象
    local graveObjects = graveZone.getObjects and graveZone.getObjects() or {}
    for _, cardObj in ipairs(graveObjects) do
      if cardObj and cardObj.guid then
        -- 获取完整的卡牌实例数据
        local instance = getGUIDInstance(cardObj.guid)
        if instance then
          -- 使用白名单方式，只提取基本类型数据，避免任何 userdata 泄露
          local safeInstance = {
            dataId = tostring(instance.dataId or ""),
            power = tonumber(instance.power) or 0,
            basePower = tonumber(instance.basePower) or 0,
            armor = tonumber(instance.armor) or 0,
            provision = tonumber(instance.provision) or 0,
            guid = instance.guid or cardObj.guid,
            inGameObjGuid = instance.guid or cardObj.guid,
            owner = instance.owner and instance.owner.color or nil,
            statuses = {}
          }
          
          -- 安全地处理 statuses，只保留基本字段
          if instance.statuses then
            for _, status in ipairs(instance.statuses) do
              if type(status) == "table" then
                table.insert(safeInstance.statuses, {
                  inGameObjGuid = tostring(status.inGameObjGuid or ""),
                  type = tostring(status.type or ""),
                  charge = tonumber(status.charge) or 0
                })
              end
            end
          end
          
          table.insert(temp, safeInstance)
        else
          -- 如果找不到实例，至少保留 GUID
          table.insert(temp, {inGameObjGuid = cardObj.guid, dataId = ""})
        end
      end
    end
    processedGameInfo[fieldName] = temp
  end
  
  processGraveCards("graveA")
  processGraveCards("graveB")
  
  -- 处理 originalDeckA/B：只在 game_start 事件时发送完整的初始卡组信息
  -- originalDeck 是游戏开始时的快照，不需要随时更新状态
  local function processOriginalDeck(originalDeckRef, fieldName)
    if not originalDeckRef then
      processedGameInfo[fieldName] = {}
      return
    end
    local temp = {}
    for _, cardObj in ipairs(originalDeckRef) do
      if cardObj and cardObj.guid then
        local instance = getGUIDInstance(cardObj.guid)
        if instance then
          -- 使用白名单方式，只提取基本类型数据，避免任何 userdata 泄露
          local safeInstance = {
            dataId = tostring(instance.dataId or ""),
            power = tonumber(instance.power) or 0,
            basePower = tonumber(instance.basePower) or 0,
            armor = tonumber(instance.armor) or 0,
            provision = tonumber(instance.provision) or 0,
            guid = instance.guid or cardObj.guid,
            inGameObjGuid = instance.guid or cardObj.guid,
            owner = instance.owner and instance.owner.color or nil,
            statuses = {}
          }
          
          -- 安全地处理 statuses，只保留基本字段
          if instance.statuses then
            for _, status in ipairs(instance.statuses) do
              if type(status) == "table" then
                table.insert(safeInstance.statuses, {
                  inGameObjGuid = tostring(status.inGameObjGuid or ""),
                  type = tostring(status.type or ""),
                  charge = tonumber(status.charge) or 0
                })
              end
            end
          end
          
          table.insert(temp, safeInstance)
        else
          -- 如果找不到实例，至少保留 guid 和 dataId
          table.insert(temp, {guid = cardObj.guid, dataId = "", inGameObjGuid = cardObj.guid})
        end
      end
    end
    processedGameInfo[fieldName] = temp
  end
  
  processOriginalDeck(gameInfo.originalDeckA, "originalDeckA")
  processOriginalDeck(gameInfo.originalDeckB, "originalDeckB")
  
  -- 白名单处理 event 参数中的 card 字段，避免 userdata 泄露
  local safeEvent = {
    type = event.type or "",
    color = event.color or "",
    round = event.round or nil,
    row = event.row or nil,
    index = event.index or nil,
    args = event.args or nil
  }
  
  -- 如果 event 包含 card 字段，使用白名单方式安全处理
  if event.card then
    local cardData = event.card
    if type(cardData) == "userdata" then
      -- cardData 本身就是 TTS userdata，尝试获取 GUID
      safeEvent.card = {
        inGameObjGuid = cardData.guid or "",
        dataId = ""
      }
    elseif type(cardData) == "table" then
      -- cardData 是卡牌实例表，使用白名单提取安全字段
      safeEvent.card = {
        dataId = tostring(cardData.dataId or ""),
        power = tonumber(cardData.power) or 0,
        basePower = tonumber(cardData.basePower) or 0,
        armor = tonumber(cardData.armor) or 0,
        provision = tonumber(cardData.provision) or 0,
        guid = cardData.guid or cardData.inGameObjGuid or "",
        inGameObjGuid = cardData.guid or cardData.inGameObjGuid or "",
        owner = cardData.owner and cardData.owner.color or nil,
        faction = cardData.faction or "",
        color = cardData.color or "",
        cardType = cardData.type or "",
        rarity = cardData.rarity or "",
        placed = cardData.placed or false,
        charge = cardData.charge or 0,
        statuses = {}
      }
      
      -- 安全处理 statuses
      if cardData.statuses then
        for _, status in ipairs(cardData.statuses) do
          if type(status) == "table" then
            table.insert(safeEvent.card.statuses, {
              inGameObjGuid = tostring(status.inGameObjGuid or ""),
              type = tostring(status.type or ""),
              charge = tonumber(status.charge) or 0
            })
          else
            table.insert(safeEvent.card.statuses, tostring(status))
          end
        end
      end
    end
  end
  
  local body = {
    gameInfo = JSON.encode(processedGameInfo),
    event = safeEvent
  }
  local headers = {
    ["Content-Type"]="application/x-www-form-urlencoded"
  }
  WebRequest.custom(url, "POST", true, JSON.encode(body), headers, handleResponse)
end

function handleResponse(request)
  if request.is_error then
      print(request.error)
    else
      print(request.text)
      local actions = JSON.decode(request.text)
      if type(actions) ~= "table" then
        print("handleResponse: invalid or nil actions from server, skipping.")
        return
      end
      for i, action in ipairs(actions) do
        if action["action"] == "power" then
          card = getGUIDInstance(action["guid"])
          if card then
            card.power = card.power + action["args"][1]
          end
        elseif action["action"] == "jumpTo" then
          card = getObjectFromGUID(action["guid"])
          to = action["args"][1]
          index = action["args"][2]
          if card then
            for _, zone in ipairs(card.getZones()) do
              if zone == gameInfo.board.zones.meleeA or zone == gameInfo.board.zones.meleeB or zone == gameInfo.board.zones.rangeA or zone == gameInfo.board.zones.rangeB then
                insertCard(card, to, index)
                break
              elseif zone == gameInfo.board.zones.deckA then
                for _, c  in ipairs(gameInfo.deckA.getObjects()) do
                  if c.guid == card.guid then
                    _card = gameInfo.board.zones.deckA.takeObject({
                      index = c.index
                    })
                    insertCard(_card, to, index)
                    break
                  end
                end
              elseif zone == gameInfo.board.zones.deckB then
                for _, c  in ipairs(gameInfo.deckB.getObjects()) do
                  if c.guid == card.guid then
                    _card = gameInfo.board.zones.deckB.takeObject({
                      index = c.index
                    })
                    insertCard(_card, to, index)
                    break
                  end
                end
              elseif zone == gameInfo.board.zones.graveA then
                objsInDeck = {}
                deck = nil
                for _, c in ipairs(gameInfo.board.zones.graveA.getObjects()) do
                  if c.type == "Deck" then
                    objsIndeck = c.getObjects()
                    deck = c
                    break
                  elseif c.type == "Card" then
                    objsInDeck[#objsInDeck + 1] = c
                  end
                end
                for _, c in ipairs(objsInDeck) do
                  print(c.guid, card.guid)
                  if c.guid == card.guid then
                    if deck then
                      _card = deck.takeObject({
                        index = c.index
                      })
                    else
                      _card = objsInDeck[1]
                    end

                    insertCard(_card, to, index)
                    break
                  end
                end
                print("graveA")
              elseif zone == gameInfo.board.zones.graveB then
                for _, c in ipairs(gameInfo.board.zones.graveB.getObjects()) do
                  if c.guid == card.guid then
                    _card = gameInfo.board.zones.graveB.takeObject({
                      index = c.index
                    })
                    insertCard(_card, to, index)
                    break
                  end
                end
              end
            end
            card = getObjectInstance(card)
          end
        elseif action["action"] == "Choose" then
          choosing = true
          Wait.condition(function()
            local url = "http://www.justgan.cn/choose"
            -- 白名单处理chosenCard
            local safeCard = {
              dataId = tostring(chosenCard.dataId or ""),
              power = tonumber(chosenCard.power) or 0,
              basePower = tonumber(chosenCard.basePower) or 0,
              armor = tonumber(chosenCard.armor) or 0,
              provision = tonumber(chosenCard.provision) or 0,
              inGameObjGuid = tostring(chosenCard.guid or chosenCard.inGameObjGuid or ""),
              owner = chosenCard.owner and chosenCard.owner.color or nil,
              faction = tostring(chosenCard.faction or ""),
              cardType = tostring(chosenCard.type or ""),
              rarity = tostring(chosenCard.rarity or ""),
              placed = chosenCard.placed or false,
              charge = tonumber(chosenCard.charge) or 0,
              statuses = {}
            }
            if chosenCard.statuses then
              for _, status in ipairs(chosenCard.statuses) do
                if type(status) == "table" then
                  table.insert(safeCard.statuses, {
                    inGameObjGuid = tostring(status.inGameObjGuid or ""),
                    type = tostring(status.type or ""),
                    charge = tonumber(status.charge) or 0
                  })
                else
                  table.insert(safeCard.statuses, tostring(status))
                end
              end
            end
            
            event = {
              type = "ChooseEnd",
              args = {
                card = safeCard
              }
            }
            local body = {
              gameInfo = nil,
              event = event
            }
            local headers = {
              ["Content-Type"]="application/x-www-form-urlencoded"
            }
            WebRequest.custom(url, "POST", true, JSON.encode(body), headers, handleResponse)
          end, function()
            return not choosing
          end)
        elseif action["action"] == "showChooseUI" then
          -- 显示新的选择UI
          chooseNum = action["num"] or 1
          chooseCards = {}
          local cards = action["cards"] or {}
          
          print("[DEBUG-ChooseUI] 收到showChooseUI请求")
          print("[DEBUG-ChooseUI] 需要选择数量: " .. chooseNum)
          print("[DEBUG-ChooseUI] 卡牌数量: " .. #cards)
          
          -- 检查cards是否为空
          if #cards == 0 then
            print("[ERROR-ChooseUI] 卡牌列表为空！")
            UI.setAttribute("GlobalUI", "active", false)
            return
          end
          
          -- 为每张卡牌创建缩略图按钮（带战力、护甲、人口显示）
          local gridXML = ""
          for i, cardData in ipairs(cards) do
            local imageUrl = string.format("http://www.justgan.cn/images/card_image_%s.png", cardData.dataId)
            local descUrl = string.format("http://www.justgan.cn/images/card_description_%s.png", cardData.dataId)
            
            -- 计算战力颜色
            local powerColor = "#FFFFFF"
            if cardData.power < cardData.basePower then
              powerColor = "#FF0000"
            elseif cardData.power > cardData.basePower then
              powerColor = "#00FF00"
            end
            
            -- 放大到200%：从140,190变为280,380
            gridXML = gridXML .. [[
              <Button id="card_]] .. cardData.guid .. [["
                      onClick="onChooseCardClick"
                      onHover="onChooseCardHover"
                      tooltip="]] .. cardData.name .. [[  战力: ]] .. cardData.power .. [[/]] .. cardData.basePower .. [[  护甲: ]] .. (cardData.armor or 0) .. [[  人口: ]] .. (cardData.provision or 0) .. [[\n]] .. (cardData.description or "") .. [["
                      image="]] .. imageUrl .. [["
                      width="280"
                      height="380"
                      data-guid="]] .. cardData.guid .. [["
                      data-desc="]] .. descUrl .. [["
                      data-name="]] .. cardData.name .. [["
                      data-description="]] .. (cardData.description or "") .. [["
                      data-power="]] .. cardData.power .. [["
                      data-basePower="]] .. cardData.basePower .. [["
                      data-armor="]] .. (cardData.armor or 0) .. [["
                      color="#FFFFFF">
                  <Panel>
                  <!-- 🔴 左上角：战力 -->
                  <Text text="]] .. cardData.power .. [["
                        fontSize="42"
                        color="]] .. powerColor .. [["
                        offsetXY="-100,150"
                        fontStyle="Bold"
                        textOutline="#000000"
                        textOutlineSize="2" />

                  <!-- 🟡 右上角：护甲 -->
                  <Text text="]] .. (cardData.armor or 0) .. [["
                        fontSize="42"
                        active="]] .. ((cardData.armor or 0) > 0 and "true" or "false") .. [["
                        color="#FFD700"
                        offsetXY="100,150"
                        fontStyle="Bold"
                        textOutline="#000000"
                        textOutlineSize="2" />

                  <!-- 🔵 右下角：人口 -->
                  <Text text="]] .. (cardData.provision or 0) .. [["
                        fontSize="42"
                        color="#FFD700"
                        offsetXY="100,-150"
                        fontStyle="Bold"
                        textOutline="#000000"
                        textOutlineSize="2" />
                  </Panel>
              </Button>
            ]]
          end
          
          print("[DEBUG-ChooseUI] 已生成gridXML，长度: " .. string.len(gridXML))
          
          -- 使用GridLayout配合固定尺寸，确保卡牌正确排列
          -- ScrollView使用固定高度而非百分比
          local fullXML = [[
            <VerticalLayout width="100%" height="100%" color="#CC000000" padding="20" spacing="10" Id="choosePanel">
              <Text text="请选择 ]] .. chooseNum .. [[ 张卡" fontSize="40" color="#FFFFFF" alignment="MiddleCenter" height="60" />
              <VerticalScrollView width="100%" height="700" scrollbarBackgroundColor="#404040">
                <GridLayout width="100%" cellSize="280,380" spacing="10 10" padding="10" color="#00000000">
                  ]] .. gridXML .. [[
                </GridLayout>
              </VerticalScrollView>
              <HorizontalLayout width="100%" height="80" color="#00000000">
                <Button id="confirmBtn" text="确定 (0/]] .. chooseNum .. [[)" onClick="confirmChoose" width="200" height="60" fontSize="42" color="#404040" activeColor="#4CAF50" />
             </HorizontalLayout>
            </VerticalLayout>
          ]]
          
--           UI.setAttribute("GlobalUI", "active", true)
          UI.setXml(fullXML)
          
          print("[DEBUG-ChooseUI] UI已设置完成")
          
          -- 初始化按钮状态
          updateConfirmButton()
        elseif action["action"] == "addButton" then
          -- 动态给卡牌添加 Order 按钮（支持图标和筛选条件）
          -- BUG修复：原代码在有 icon 时调用一次 createButton，无 icon 时调用两次，现已统一。
          -- 设计变更：首次加入战场时始终添加"休眠指令"按钮（不可用），
          -- 回合推进后由 updateOrderButtons() 自动切换为可用指令按钮。
          local card = getObjectFromGUID(action["card"])
          if card then
            local buttonType = action["args"][1]  -- "Order", "Deploy", "Charge" 等
            if buttonType == "Order" then
              local filter     = action["filter"] or "allyRows"  -- 目标筛选范围
              local selectType = action["type"]   or "unit"      -- 目标类型
              local cardGuid   = action["card"]
              
              -- 清理已有的 Order 相关按钮，防止重复添加（例如卡牌被 jumpTo 后重新触发 Deploy）
              for _, button in ipairs(card.getButtons() or {}) do
                if button.click_function == "clickOrderButton" or
                   button.click_function == "clickDormantOrderButton" then
                  card.removeButton(button.index)
                end
              end
              
              -- 添加"休眠指令"按钮（第一回合不可用，灰色样式）
              local dormantParams = {
                click_function = "clickDormantOrderButton",
                function_owner = self,
                label          = "Order",
                position       = {0, 0.1, 0},
                rotation       = {0, 0, 0},
                width          = 400,
                height         = 200,
                font_size      = 200,
                color          = {0.5, 0.5, 0.5},   -- 灰色：不可用
                font_color     = {0.8, 0.8, 0.8},
                tooltip        = "休眠指令\n本回合无法使用，下一回合起可激活。\n筛选: " .. filter
              }
              card.createButton(dormantParams)
              
              -- 设置休眠图标贴花（休眠指令图标）
              card.setDecals({{
                name     = "order_dormant",
                url      = "http://www.justgan.cn/icons/休眠指令",
                position = {0, 0.05, -0.5},
                rotation = {90, 0, 0},
                scale    = {0.15, 0.15, 1}
              }})
              
              -- 记录该卡牌的指令按钮状态，供 updateOrderButtons() 使用
              orderButtonState[cardGuid] = {
                turnEntered = gameInfo.turn,   -- 入场回合数
                isDormant   = true,            -- 当前为休眠状态
                filter      = filter,
                selectType  = selectType
              }
              
              print("[AddButton] 添加休眠指令按钮: card=" .. cardGuid
                    .. "，入场回合=" .. gameInfo.turn
                    .. "，筛选=" .. filter)
            end
          end
        elseif action["action"] == "removeButton" then
          -- 移除卡牌上的按钮，并清理对应的指令状态追踪
          local card = getObjectFromGUID(action["guid"])
          if card then
            local buttonLabel = action["args"][1]  -- 要移除的按钮标签
            for _, button in ipairs(card.getButtons()) do
              if button.label == buttonLabel then
                card.removeButton(button.index)
                print("Removed button '" .. buttonLabel .. "' from card: " .. action["guid"])
                break
              end
            end
          end
          -- 移除该卡牌的指令状态追踪（防止残留状态影响其他逻辑）
          orderButtonState[action["guid"]] = nil
          
        elseif action["action"] == "awaitTarget" then
          -- target_field 交互模式：进入目标选择状态
          -- 服务端指示 Lua 端让玩家在战场上点选卡牌，选完后通过 /choose 提交
          local filter     = action["filter"]   or "allyRows"
          local minCount   = action["min"]      or 1
          local maxCount   = action["max"]      or 1
          local orderGuid  = action["cardGuid"] -- 发起 Order 的卡牌 GUID
          
          print("[AwaitTarget] 进入目标选择模式: filter=" .. filter
                .. " min=" .. minCount .. " max=" .. maxCount
                .. " orderCard=" .. tostring(orderGuid))
          enterTargetSelectMode(filter, minCount, maxCount, orderGuid)
        elseif action["action"] == "followCursor" then
          -- 让卡牌跟随玩家光标
          local cardGuid = action["guid"]
          local playerColor = action["args"][1]
          
          -- 🔴 关键修复：getGUIDInstance 返回的是 cardInstance 表，需要获取其中的 inGameObj
          local cardInstance = getGUIDInstance(cardGuid)
          local cardObj = nil
          
          if cardInstance and cardInstance.inGameObj then
            -- cardInstance 是包含 inGameObj 字段的表，提取实际对象
            cardObj = cardInstance.inGameObj
            print("[FollowCursor] 从 cardInstance 提取卡牌对象: " .. cardGuid)
          end
          
          if not cardObj then
            -- 如果找不到卡牌实例，说明可能在卡组中，直接从 TTS 获取
            print("[FollowCursor] 警告: 未找到卡牌实例 " .. cardGuid .. "，尝试直接从 TTS 获取")
            cardObj = getObjectFromGUID(cardGuid)
            
            if not cardObj then
              print("[FollowCursor] 错误: 无法从 TTS 找到卡牌 " .. cardGuid)
              return
            end
          end
          
          -- 🔴 关键修复：如果卡牌在卡组中，必须先取出才能操作
          print("[FollowCursor] 尝试取出卡牌: " .. cardGuid)
          local unpackedCard = ensureCardIsUnpacked(cardObj, cardGuid)
          if unpackedCard == nil then
            print("[FollowCursor] 错误: 无法从卡组中取出卡牌 " .. cardGuid)
            return
          end
          print(unpackedCard)
          print("[FollowCursor] 开始追踪卡牌: " .. unpackedCard.guid .. " 玩家: " .. playerColor)
          startFollowCursor(unpackedCard, playerColor)
        elseif action["action"] == "spawnCard" then
          -- 生成一张新卡并可选地跟随光标
          local dataId = action["dataId"]
          local playerColor = action["args"][1]  -- 如果提供，则跟随该玩家光标
          
          print("[SpawnCard] 生成卡牌: " .. dataId)
          
          -- 查找卡牌数据
          local cardData = nil
          for _, card in ipairs(data) do
            if card.id == dataId then
              cardData = card
              break
            end
          end
          
          if not cardData then
            print("[SpawnCard] 错误: 找不到卡牌数据 " .. dataId)
            return
          end
          
          -- 确定生成位置
          local spawnPos
          if playerColor then
            -- 如果有playerColor，生成在该玩家手牌附近
            spawnPos = (playerColor == "Purple") and {50, 2, -26} or {48, 2, 21}
          else
            -- 否则默认生成在紫方手牌区
            spawnPos = {50, 2, -26}
          end
          
          -- 生成卡牌对象
          local obj = spawnObject({
            type = "CardCustom",
            position = spawnPos,
            scale = {2*scale, 1, 2*scale},
            sound = false,
          })
          
          -- 设置卡牌图片
          local image = string.format("http://www.justgan.cn/images/card_image_%s.png", dataId)
          local desc = string.format("http://www.justgan.cn/images/card_description_%s.png", dataId)
          obj.setCustomObject({
            face = image,
            back = desc
          })
          
          obj.addTag("GwentCard")
          
          -- 创建卡牌实例
          local player = Player[playerColor or "Purple"]
          createCardInstance(obj, cardData, player)
          
          print("[SpawnCard] 卡牌生成成功: " .. obj.guid)
          
          -- 如果指定了playerColor，让卡牌跟随光标
          if playerColor then
            Wait.frames(function()
              print("[SpawnCard] 启动跟随效果")
              startFollowCursor(obj, playerColor)
            end, 3)  -- 等待几帧确保卡牌完全生成
          end
        end
        if action["guid"] then
          -- 重新获取 card 变量，避免使用过期的引用
          local cardObj = getObjectFromGUID(action["guid"])
          local displayCard = cardObj and getGUIDInstance(cardObj.guid)
          local displayObj = cardObj
          
          if displayCard and displayObj then
            updateDisplay(displayCard, displayObj)
          end
        end
      end
  end
end

function insertCard(card, to, index)
  if to == "MeleeA" then
    table.insert(gameInfo.meleeA, index+1, card) -- 插入到位置+1（lua的index...）
    print("inserted")
    print(index)
    print(gameInfo.meleeA[index+1])
    adjustCardsPlace(gameInfo.meleeA, gameInfo.board.zones.meleeA)
  elseif to == "RangeA" then
    table.insert(gameInfo.rangeA, index+1, card)
    print(table[index+1])
    adjustCardsPlace(gameInfo.rangeA, gameInfo.board.zones.rangeA)
  elseif to == "MeleeB" then
    table.insert(gameInfo.meleeB, index+1, card)
    adjustCardsPlace(gameInfo.meleeB, gameInfo.board.zones.meleeB)
  elseif to == "RangeB" then
    table.insert(gameInfo.rangeB, index+1, card)
    adjustCardsPlace(gameInfo.rangeB, gameInfo.board.zones.rangeB)
  end
end

-- 用于打印表格的辅助函数
function printTable(t, indent)
  indent = indent or 0
  for k, v in pairs(t) do
    if type(v) == 'table' then
      print(string.rep(' ', indent) .. k .. ':')
      printTable(v, indent + 2)
    else
      print(string.rep(' ', indent) .. k .. ': ' .. tostring(v))
    end
  end
end

function loadCardDeck(link, player)
  WebRequest.get(link, function(request)
      if request.is_error then
          print(request.error)
      else
          count = count+1
          print('Deck fetched successfully')
          local str = request.text local card_ids = {}
          for line in str:gmatch("%S+") do -- 修改正则表达式以匹配非空白字符序列
            table.insert(card_ids, line)
          end
          local cards = data
          -- 创建一个从ID到卡片信息的映射表
          idToCard = {}
          for _, card in ipairs(cards) do
              idToCard[card.id] = card
          end

          -- 遍历 card_ids，只处理那些存在于 cards 中的卡牌
          for index, id in ipairs(card_ids) do
              if idToCard[id] then
                  local card = idToCard[id]
                  local pos = (player.color == "Purple") and {50, 2, -26} or {48, 2, 21}
                  if card.type == "ability" then
                    pos[2] = 1
                  end
                  if card.type == "stratagem" then
                    pos[2] = 1.5
                  end
                  local obj = spawnObject({
                      type = "CardCustom",
                      position = pos,
                      scale = {2*scale, 1, 2*scale},
                      sound = false,
                  })

                  local image = string.format("http://www.justgan.cn/images/card_image_%s.png", card.id)
                  local desc = string.format("http://www.justgan.cn/images/card_description_%s.png", card.id)
                  local params = {
                      face = image,
                      back = desc
                  }
                  obj.setCustomObject(params)
                  -- print(obj.guid, obj.getGUID(), getObjectFromGUID(obj.guid))
                  --obj = obj.reload()
                  -- print(obj.guid, obj.getGUID(), getObjectFromGUID(obj.guid))
                  obj.addTag("GwentCard")
                  obj.addTag(tostring(count))
                  -- 创建 CardInstance 表
                  print("loaddeck ", card.type)
                  createCardInstance(obj, card, player)
                  print(obj.UI.getXml())
              else
                print(id)
              end
          end
          canAddButton = true
      end
  end)
  return cardInstances
end

function createCardInstance(obj, card, player)
  print("instance ", obj.guid)
  -- 创建 CardInstance 表
  local cardInstance = {
      dataId = card.id,
      inGameObj = obj,
      inGameObjGuid = obj.guid,
      basePower = card.power,
      power = card.power,
      provision = card.provision,
      armor = card.armor,
      faction = card.faction,
      color = card.color,
      type = card.type,
      rarity = card.rarity,
      powerButton = false,
      buttonDisplay = nil,
      buttonProvision = nil,
      indexBUp = nil,
      indexBDown = nil,
      owner = player,
      placed = false,
      charge = 1 and card.type == 'unit' or 0,
      statuses = {}
  }

  -- 将新创建的 cardInstance 添加到全局的 cardInstances 列表中
  table.insert(cardInstances, cardInstance)
  -- 返回新创建的 cardInstance
  return cardInstance
end

function createTokenInstance(obj, player, type)
  local tokenInstance = {
      charge = 0,
      inGameObj = obj,
      inGameObjGuid = obj.guid,
      owner = player,
      type = type,
      adjustButton = false,
      buttonDisplay = nil,
  }
  obj.addTag("GwentToken")
  table.insert(tokenInstances, tokenInstance)

  return tokenInstance
end

function buttonClicked(obj, color, alt_click)
  print(111)
end

function clickbutton(obj, color, alt_click)
  cardInstance = getObjectInstance(obj)
  cardInstance.powerButton = not cardInstance.powerButton

  if cardInstance.powerButton then
    -- Create buttons and store their indices in the globalButtons list
    cardInstance.indexBUp = createPowerButton(obj, "+", "add_button")
    cardInstance.indexBDown = createPowerButton(obj, "-", "minus_button")

  elseif not cardInstance.powerButton then
    -- Remove buttons and update globalButtons list
      local indexs = {}
      for _, button in ipairs(obj.getButtons()) do
        --print(button.click_function)
        if button.click_function == "add_button" or button.click_function == "minus_button" then
          obj.removeButton(button.index)
        end
      end
    -- Remove the button from the object

    cardInstance.indexBUp = nil
    cardInstance.indexBDown = nil
  end
end

function clicktokenbutton(obj, color, alt_click)
  TokenInstance = getObjectInstance(obj)
  TokenInstance.adjustButton = not TokenInstance.adjustButton

  if TokenInstance.adjustButton then
    -- Create buttons and store their indices in the globalButtons list
    createPowerButton(obj, "+", "add_token")
    createPowerButton(obj, "-", "minus_token")

  elseif not TokenInstance.adjustButton then
    -- Remove buttons and update globalButtons list
      local indexs = {}
      for _, button in ipairs(obj.getButtons()) do
          indexs[#indexs+1] = button.index
      end
      for i, index in ipairs(table.sort(indexs)) do
          if i > 1 then
              obj.removeButton(index)
          end
      end
  end
end

function clickOrderButton(obj, color, alt_click)
  -- Order 按钮点击处理：触发 Order 事件，让服务器执行 Order 函数
  -- BUG修复：原代码通过手动 WebRequest 发送 {gameInfo = nil, event = event}，
  -- 导致服务器收不到完整游戏状态（gameInfo 为 null），可能引发服务端解析错误。
  -- 修复：改为调用 emit(event)，它会构建完整的可序列化 processedGameInfo 一并发送。
  print("[OrderButton] Order 按钮点击: card=" .. obj.guid)
  
  local cardInstance = getObjectInstance(obj)
  if not cardInstance then
    print("[OrderButton] 错误: 找不到卡牌实例 GUID=" .. obj.guid)
    return
  end
  
  -- 使用后移除/禁用 Order 按钮，防止重复触发
  for _, button in ipairs(obj.getButtons() or {}) do
    if button.click_function == "clickOrderButton" then
      obj.removeButton(button.index)
      break
    end
  end
  -- 清除指令状态追踪
  orderButtonState[obj.guid] = nil
  
  -- 构建 Order 事件（字段命名与服务端 Event 类型对齐）
  local event = {
    type  = "Order",
    color = tostring(cardInstance.owner and cardInstance.owner.color or color or ""),
    card  = {
      dataId        = tostring(cardInstance.dataId        or ""),
      inGameObjGuid = tostring(obj.guid                  or ""),
      power         = tonumber(cardInstance.power)        or 0,
      basePower     = tonumber(cardInstance.basePower)    or 0,
      armor         = tonumber(cardInstance.armor)        or 0,
      provision     = tonumber(cardInstance.provision)    or 0,
      faction       = tostring(cardInstance.faction       or ""),
      color         = tostring(cardInstance.color         or ""),
      cardType      = tostring(cardInstance.type          or ""),
      rarity        = tostring(cardInstance.rarity        or ""),
      placed        = cardInstance.placed                 or false,
      charge        = tonumber(cardInstance.charge)       or 0,
      statuses      = {}
    }
  }
  
  -- 使用 emit() 携带完整 gameInfo 发送请求，handleResponse 负责处理服务器返回
  print("[OrderButton] 发送 Order 事件 → emit()")
  emit(event)
end

-- 休眠指令按钮点击处理：第一回合不可使用，点击时给玩家提示
function clickDormantOrderButton(obj, color, alt_click)
  print("[DormantOrderButton] 点击了休眠指令按钮: card=" .. obj.guid)
  -- 向点击者显示提示（broadcastToColor 只有该玩家可见；broadcastToAll 所有人可见）
  broadcastToColor("此卡本回合刚刚入场，指令处于休眠状态。\n下一回合起即可使用指令。", color, {1, 0.8, 0})
end

-- Helper function to create a button and adjust globalButtons list
function createPowerButton(obj, label, function_name)
  local buttonIndex = #globalButtons + 1
  local params = {
    click_function = function_name,
    function_owner = self,
    label          = label,
    position       = calculatePosition(label, function_name),
    rotation       = {0, 0, 0},
    width          = 200,
    height         = 200,
    font_size      = 260,
    color          = {0.5, 0.5, 0.5},
    font_color     = label == "+" and {0, 1, 0} or {1, 0, 0},
    tooltip        = label == "+" and "增加" or "降低",
    scale = string.find(function_name, "token") and {2, 1, 2} or {1, 1, 1}
  }

  obj.createButton(params)

  return buttonIndex
end


function calculatePosition(label, function_name)
  if string.find(function_name, "token") then
    if label == "+" then
      return {0.2*scale*0.5, 0.1, 0*scale*0.5-1}
    elseif label == "-" then
      return {0.2*scale*0.5, 0.1, 0*scale*0.5+1}
    end
  else
    if label == "+" then
      return {-0.7*scale*0.5, 0.1, -1.15*scale*0.5-0.5}
    elseif label == "-" then
      return {-0.7*scale*0.5, 0.1, -1.15*scale*0.5+0.5}
    end
  end

end

function add_button(obj, color, alt_click)
  cardInstance = getObjectInstance(obj)
  if alt_click then
    cardInstance.power = cardInstance.power + 5
  else
    cardInstance.power = cardInstance.power + 1
  end
  updateDisplay(cardInstance, obj)
end

function minus_button(obj, color, alt_click)
  cardInstance = getObjectInstance(obj)
  if alt_click then
    cardInstance.power = cardInstance.power - 5
  else
    cardInstance.power = cardInstance.power - 1
  end
  updateDisplay(cardInstance, obj)
end

function add_token(obj, color, alt_click)
  TokenInstance = getObjectInstance(obj)
  if alt_click then
    TokenInstance.charge = TokenInstance.charge + 5
  else
    TokenInstance.charge = TokenInstance.charge + 1
  end
  updateTokenDisplay(TokenInstance, obj)
end

function minus_token(obj, color, alt_click)
  TokenInstance = getObjectInstance(obj)
  if alt_click then
    TokenInstance.charge = TokenInstance.charge - 5
  else
    TokenInstance.charge = TokenInstance.charge - 1
  end
  updateTokenDisplay(TokenInstance, obj)
end

function processCSVData(request)
    if request.is_error then
        print("Error: " .. request.error)
        return nil
    end

    if request.is_done then
        local csvData = request.text
        local lines = {}

        -- 分割每一行
        for line in csvData:gmatch("[^\r\n]+") do
            local fields = {}
            for field in line:gmatch('([^,]+)') do
                table.insert(fields, field)
            end
            -- 创建以字段值为值的table
            local card = {
                artid = fields[1],
                id = fields[2],
                power = tonumber(fields[3]),
                armor = tonumber(fields[4]),
                provision = tonumber(fields[5]),
                faction = fields[6],
                color = fields[7],
                type = fields[8],
                rarity = fields[9]
            }
            table.insert(lines, card)
        end
        return lines
    end
    return nil
end

function spawnBoard()
  board = spawnObject({
      type = "Custom_Board",
      position = {0, 0.1, 0},
      scale = {2, 1, 3.6},
      sound = false,
      rotation = {0, 180, 0}
  })
  local params = {
      image = "http://www.justgan.cn/datas/Lairia.png",
  }
  board.setCustomObject(params)
  board.scale({x=1.26, y=1, z=0.7})
  local meleeRangeA = {
    X = {-48, 37.33},
    Y = {0, 0.1},
    Z = {0, -5}
  }
  local centerX = (meleeRangeA.X[1] + meleeRangeA.X[2]) / 2
  local centerY = (meleeRangeA.Y[1] + meleeRangeA.Y[2]) / 2
  local centerZ = (meleeRangeA.Z[1] + meleeRangeA.Z[2]) / 2
  local width = math.abs(meleeRangeA.X[1] - meleeRangeA.X[2])
  local height = math.abs(meleeRangeA.Y[1] - meleeRangeA.Y[2])
  local depth = math.abs(meleeRangeA.Z[1] - meleeRangeA.Z[2])

  zoneMeleeA = spawnObject({
      type = "ScriptingTrigger",
      position = {centerX, centerY, centerZ},
      scale = {width, 5, depth},
  })
  zoneMeleeB = spawnObject({
      type = "ScriptingTrigger",
      position = {centerX, centerY, centerZ+(meleeRangeA.Z[1] - meleeRangeA.Z[2] + 7)},
      scale = {width, 5, depth},
  })
  zoneRangeB = spawnObject({
      type = "ScriptingTrigger",
      position = {centerX, centerY, centerZ+(meleeRangeA.Z[1] - meleeRangeA.Z[2] + 7)*2},
      scale = {width, 5, depth},
  })
  zoneRangeA = spawnObject({
      type = "ScriptingTrigger",
      position = {centerX, centerY, centerZ-(meleeRangeA.Z[1] - meleeRangeA.Z[2] + 7)},
      scale = {width, 5, depth},
  })
  zoneDeckA = spawnObject({
      type = "ScriptingTrigger",
      position = {50, 1, -26},
      scale = {12, 5, 16},
  })
  zoneDeckB = spawnObject({
      type = "ScriptingTrigger",
      position = {50, 1, 21},
      scale = {12, 5, 16},
  })
  zoneGraveA = spawnObject({
      type = "ScriptingTrigger",
      position = {-52, 1, -22},
      scale = {12, 5, 16},
  })
  zoneGraveB = spawnObject({
      type = "ScriptingTrigger",
      position = {-52, 1, 22},
      scale = {12, 5, 16},
  })
  zoneMeleeA.addTag("zoneMeleeA")
  zoneMeleeA.addTag("GwentCard")
  zoneMeleeB.addTag("zoneMeleeB")
  zoneMeleeB.addTag("GwentCard")
  zoneRangeA.addTag("zoneRangeA")
  zoneRangeA.addTag("GwentCard")
  zoneRangeB.addTag("zoneRangeB")
  zoneRangeB.addTag("GwentCard")
  zoneDeckA.addTag("zoneHandA")
  zoneDeckA.addTag("GwentCard")
  zoneDeckB.addTag("zoneHandB")
  zoneDeckB.addTag("GwentCard")
  zoneGraveA.addTag("zoneGraveA")
  zoneGraveA.addTag("GwentCard")
  zoneGraveB.addTag("zoneGraveB")
  zoneGraveB.addTag("GwentCard")
  boardInstance = {
    inGameObj = board,
    zones = {
      meleeA = zoneMeleeA,
      meleeB = zoneMeleeB,
      rangeA = zoneRangeA,
      rangeB = zoneRangeB,
      deckA  = zoneDeckA,
      deckB  = zoneDeckB,
      graveA = zoneGraveA,
      graveB = zoneGraveB,
    }
  }
  gameInfo.board = boardInstance
end

--在编辑完文本框时调用
function onNameInputFinished(player, value, id)
link = string.format("http://www.justgan.cn/decks/%s.txt", value)
print(loadCardDeck(link, player), cardInstances)
end

function onCardNameInputFinished(player, value, id)
link = string.format("https://www.justgan.cn/datas/nametoid/%s", value)
print(getNameIdAndSummonCard(link, player))
end

function start()
  -- 确保 gameInfo 被初始化
  if not gameInfo or not gameInfo.deckA or not gameInfo.deckB then
    error("gameInfo or its decks are not initialized.")
  end

  gameInfo.stage = "redealPrepare"
  gameInfo.round = 1
  gameInfo.turn = 1
  if gameInfo.deckA.getObjects then
    print("here", gameInfo.deckA)
    local objs = gameInfo.originalDeckA
    print("herevvv")
    print(objs[0])
    for i=#objs, 1, -1 do
      local card = objs[i]
      print("Card:", card)
      if card and card.type ~= "" then
        local cardInstance = getObjectInstance(card)
        -- print("Card Instance Type:", card.index, " ", cardInstance.type)
        if cardInstance and cardInstance.type == "stratagem" then
          local _card = gameInfo.deckA.takeObject({
            index = card.index
          })
          if _card then
            _card.setPosition({ 0, 1, 0})
            _card.setRotation({ 0, 180, 0})
            table.insert(gameInfo.meleeA, _card)
            adjustCardsPlace(gameInfo.meleeA, gameInfo.board.zones.meleeA)
          else
            error("Card is nil after getObjectFromGUID.")
          end
        elseif cardInstance and cardInstance.type == "ability" then
          local _card = gameInfo.deckA.takeObject({
            index = card.index
          })
          if _card then
            local abilityInstance = getObjectInstance(_card)
            print(abilityInstance and abilityInstance.type or "unknown")
            _card.setPosition({-54, 1, -7})
            _card.setRotation({0, 180, 0})
          end
        end
      else
        error("Card is nil in the loop.")
      end
    end
  else
    error("deckA.getObjects is not a function.")
  end
  if gameInfo.deckB.getObjects then
    local objs = gameInfo.originalDeckB
    for i=#objs, 1, -1 do
      local card = objs[i]
      if card then
        local cardInstance = getObjectInstance(card)
        if cardInstance and cardInstance.type == "stratagem" then
          local _card = gameInfo.deckB.takeObject({
            index = card.index
          })
          destroyObject(_card)
        elseif cardInstance and cardInstance.type == "ability" then
          local _card = gameInfo.deckB.takeObject({
            index = card.index
          })
          _card.setPosition({ -54, 1, 6})
          _card.setRotation({ 0, 180, 0})
        end

      else
        error("Card is nil in the loop.")
      end
    end
  else
    error("deckB.getObjects is not a function.")
  end
  gameInfo.deckA.deal(10, "Purple")
  gameInfo.deckB.deal(10, "Yellow")
  local event = {
    type = "game_start"
  }
  emit(event)
  -- 其他操作
end


function stop(player)
  -- 在调度阶段，点击停止按钮直接结束调度（将剩余调度次数设为0）
  if gameInfo.stage == "redeal" then
    if player.color == "Purple" then
      gameInfo.redealA = 0
      print("Purple player ended redeal phase")
    elseif player.color == "Yellow" then
      gameInfo.redealB = 0
      print("Yellow player ended redeal phase")
    end
    return
  end
  
  -- 正常游戏阶段的停止逻辑
  if player.color == "Purple" then
    gameInfo.stopA = true
  elseif player.color == "Yellow" then
    gameInfo.stopB = true
  end
end

function jump(player)
  if player.color == "Purple" then
    gameInfo.jumpA = true
  elseif player.color == "Yellow" then
    gameInfo.jumpB = true
  end
end

function onTokenNameInputFinished(player, value, id)
  local iconDict = {
    ['坚韧'] = 'Tough',
    ['护盾'] = 'Shield',
    ['锁定'] = 'Lockdown',
    ['重伤'] = 'Injury',
    ['活力'] = 'Vitality',
    ['中毒'] = 'Poisoning',
    ['潜伏'] = 'Lurking',
    ['免疫'] = 'Immunity',
    ['佚亡'] = 'Oblivion',
    ['卫士'] = 'Guardian',
    ['破裂'] = 'Shattering',
    ['遮蔽'] = 'Obscuring',
    ['赏金'] = 'Bounty',
    ['灌注'] = 'Infusion',
    ['近战'] = 'Melee',
    ['远程'] = 'Ranged',
    ['护甲'] = 'Armor',
    ['可用指令'] = 'Available Command',
    ['可充能指令可用'] = 'Chargeable Command Available',
    ['可充能指令不可使用'] = 'Chargeable Command Unavailable',
    ['可充能指令不可使用睡眠'] = 'Chargeable Command Unavailable (Sleep)',
    ['冷却'] = 'Cooldown',
    ['指令不可使用'] = 'Command Unavailable',
    ['能力被锁定'] = 'Ability Locked',
    ['钱袋'] = 'Money Bag',
    ['休眠指令'] = 'Hibernating Command',
    ['倒数'] = 'Countdown',
    ['新可用指令'] = 'New Available Command'
  }
  originalValue = value
  value = iconDict[value] or value
  local link = string.format("http://www.justgan.cn/icons/%s", value)
  if isInArray({"可充能指令可用", "可充能指令不可使用", "冷却", "钱袋", "倒数", "重伤", "活力", "护甲"}, originalValue) then
    local obj = spawnObject({
      type = "Custom_Token",
      position = {50, 1, -26},
      scale = {0.5*scale, 1, 0.5*scale},
      sound = false,
    })
    local params = {
      image = link,
      merge_distance = 5
    }
    obj.addTag("GwentToken")
    obj.setCustomObject(params)
    --obj = obj.reload()
    createTokenInstance(obj, player, originalValue)
    addTokenButton(obj)
  else
    local obj = spawnObject({
      type = "Custom_Tile",
      position = {50, 1, -26},
      scale = {0.5*scale, 1, 0.5*scale},
      sound = false,
    })
    local params = {
      image = link,
      type = 2,
    }
    obj.addTag("GwentToken")
    if value == "休眠指令" then
      params.image_bottom = "http://www.justgan.cn/icons/新可用指令"
    elseif value == "可用指令" then
      params.image_bottom = "http://www.justgan.cn/icons/休眠指令"
    elseif value == "新可用指令" then
      params.image_bottom = "http://www.justgan.cn/icons/休眠指令"
    end
    obj.setCustomObject(params)
    --obj = obj.reload()
    createTokenInstance(obj, player, value)
    addTokenButton(obj)
  end

end

function getNameIdAndSummonCard(link, player)
  --get链接内容，然后根据返回的Json获取卡牌id并生成
  local request = WebRequest.get(link, function(request)
    if request.is_error then
      print("Error: " .. request.error)
      return nil
    end
    if request.is_done then
      local json = JSON.decode(request.text)
      if json.cardIds then
        for _, cardId in ipairs(json.cardIds) do
          local id = cardId
          --print(id, json)
          local card = idToCard[id]

          local obj = spawnObject({
              type = "CardCustom",
              position = {0, 1, 0},
              scale = {2*scale, 1, 2*scale},
              sound = false,
          })

          local image = string.format("http://www.justgan.cn/images/card_image_%s.png", card.id)
          local desc = string.format("http://www.justgan.cn/images/card_description_%s.png", card.id)
          local params = {
              face = image,
              back = desc
          }
          obj.setCustomObject(params)
          -- print(obj.guid, obj.getGUID(), getObjectFromGUID(obj.guid))
          --obj = obj.reload()
          -- print(obj.guid, obj.getGUID(), getObjectFromGUID(obj.guid))
          obj.addTag("GwentCard")
          obj.addTag(tostring(count))

          local cardInstance = createCardInstance(obj, card, player)
          if cardInstance.type == "unit" then
            addDisplayButton(obj)
          end
        end
      else
        print("Invalid JSON format")
      end
    end
  end)
end

function onUpdate()
  -- 🔵 新增：FollowCursor 追踪逻辑
  for playerColor, fcData in pairs(followCursorData) do
    if fcData.isTracking and fcData.cardObj then
      if fcData.cardObj.isDestroyed() then
        print("[FollowCursor] 卡牌已被销毁，停止追踪: " .. playerColor)
        stopFollowCursor(playerColor)
      else
        local player = Player[playerColor]
        if player then
          local pos = player.getPointerPosition()
          pos.y = pos.y + 2
          fcData.cardObj.setPosition(pos)
        end
      end
    end
  end

  -- 以下保持原有逻辑不变 
  purplePower = 0
  yellowPower = 0
  for _, card in ipairs(gameInfo.meleeA) do
    purplePower = purplePower + getObjectInstance(card).power
  end
  for _, card in ipairs(gameInfo.meleeB) do
    yellowPower = purplePower + getObjectInstance(card).power
  end
  for _, card in ipairs(gameInfo.rangeA) do
    purplePower = purplePower + getObjectInstance(card).power
  end
  for _, card in ipairs(gameInfo.rangeB) do
    yellowPower = yellowPower + getObjectInstance(card).power
  end
  UI.setAttribute("purple", "text", "紫方战力: " .. purplePower)
  UI.setAttribute("yellow", "text", "黄方战力: " ..yellowPower)

  if gameInfo.stopA and gameInfo.stopB and gameInfo.stage ~= "settling" then
      print("第 " .. gameInfo.round .. " 轮结束")
      
      -- 触发RoundEnd事件，让卡牌能在回合结束前执行效果
      local roundEndEvent = {
        type = "RoundEnd",
        round = gameInfo.round
      }
      emit(roundEndEvent)
      
      gameInfo.stage = "settling"
      gameInfo.jumpA = false
      gameInfo.jumpB = false
      gameInfo.turn = 0
      if purplePower > yellowPower then
        gameInfo.pointA = gameInfo.pointA + 1
        gameInfo.redealA = 3
        gameInfo.redealB = 2
      elseif purplePower < yellowPower then
        gameInfo.pointB = gameInfo.pointB + 1
        gameInfo.redealA = 2
        gameInfo.redealB = 3
      else
        gameInfo.pointA = gameInfo.pointA + 1
        gameInfo.pointB = gameInfo.pointB + 1
        gameInfo.redealA = 2
        gameInfo.redealB = 2
      end
      if gameInfo.pointA == 2 then
        print("紫色获胜")
        gameInfo.stage = "finish"
      end
      if gameInfo.pointB == 2 then
        print("黄色获胜")
        gameInfo.stage = "finish"
      end
      gameInfo.round = gameInfo.round + 1
      gameInfo.stopA = false
      gameInfo.stopB = false
      
      -- 将战场牌移位到墓场区域
      for _, row in pairs({gameInfo.meleeA, gameInfo.rangeA}) do
        for _, card in pairs(row) do
          cardInstance = getObjectInstance(card)
          cardInstance.power = cardInstance.basePower
          card.setPositionSmooth(gameInfo.board.zones.graveA.getPosition())
        end
      end
      for _, row in pairs({gameInfo.meleeB, gameInfo.rangeB}) do
        for _, card in pairs(row) do
          cardInstance = getObjectInstance(card)
          cardInstance.power = cardInstance.basePower
          card.setPositionSmooth(gameInfo.board.zones.graveB.getPosition())
        end
      end
      
      -- 卡牌移入墓场后，可以再次触发RoundEnd事件（如果需要）
      -- 或者触发一个新的事件如CardsMovedToGrave
      
      print("第 " .. gameInfo.round .. " 轮开始")
      gameInfo.stage = "redealPrepare"

  end
  if gameInfo.jumpA and gameInfo.jumpB then
    gameInfo.jumpA = false
    gameInfo.jumpB = false
    gameInfo.playedA = false
    gameInfo.playedB = false
    gameInfo.turn = gameInfo.turn + 1
    gameInfo.allTurn = gameInfo.allTurn + 1
    UI.setAttribute("stopA", "color", "#FFFFFF")
    UI.setAttribute("stopB", "color", "#FFFFFF")
    UI.setAttribute("stopA", "active", true)
    UI.setAttribute("stopB", "active", true)
    print("第 " .. gameInfo.turn .. " 回合开始")
    -- 回合递增后同步更新所有休眠指令按钮状态
    -- （此处调用 updateOrderButtons，将上一回合入场的卡牌指令切换为可用）
    updateOrderButtons()
  end
  if gameInfo.playedA then
    UI.setAttribute("stopA", "color", "#CCCCCC")
    UI.setAttribute("stopA", "active", false)
    UI.setAttribute("jumpA", "active", true)
  else
    UI.setAttribute("jumpA", "color", "#CCCCCC")
    UI.setAttribute("jumpA", "active", false)
    UI.setAttribute("stopA", "active", true)
  end
  if gameInfo.playedB then
    UI.setAttribute("stopB", "color", "#CCCCCC")
    UI.setAttribute("stopB", "active", false)
    UI.setAttribute("jumpB", "active", true)
  else
    UI.setAttribute("jumpB", "color", "#CCCCCC")
    UI.setAttribute("jumpB", "active", false)
    UI.setAttribute("stopB", "active", true)
  end
  if gameInfo.stopB then
    UI.setAttribute("stopA", "active", true)
    UI.setAttribute("jumpA", "active", false)
  end
  if gameInfo.stage == "redealPrepare" then
    addRedealButtonsToAllCards()
    gameInfo.stage = "redeal"
  end
  if gameInfo.stage == "redeal" and gameInfo.redealA <= 0 and gameInfo.redealB <= 0 then
    gameInfo.stage = "playing"
    removeAllRedealButtons()
    gameInfo.deckA.shuffle()
    gameInfo.deckB.shuffle()
  end
end

-- 添加重新调度按钮到所有卡牌
function addRedealButtonsToAllCards()
  local params = {
      click_function = "redeal",
      function_owner = self,
      label = "调度此卡",
      position = { 0, 0.1,  0.4 * scale * 0.5 },
      rotation = { 0, 0, 0 },
      width = 600,
      height = 200,
      font_size = 64,
      color = { 0.8, 0.5, 0.5 },
      font_color = { 0, 0, 0 },
      tooltip = "点击以调度此卡"
  }
  for _, card in ipairs(getObjectsWithTag("GwentCard")) do
    if getObjectInstance(card) and not isInArray({"stratagem", "ability"}, getObjectInstance(card).type) then
      print("addbutton")
      card.createButton(params)
    end
  end
end

-- 从所有卡牌中移除重新调度按钮
function removeAllRedealButtons()
  for _, card in ipairs(getObjectsWithTag("GwentCard")) do
    buttons = card.getButtons()
    print(buttons)
    print(card.type)
    if buttons then
      for _, button in ipairs(buttons) do
        print(button.index)
        if button.click_function == "redeal" then
          print(card.removeButton(button.index))
        end
      end
    end
  end
end

-- 为指定玩家刷新重新调度按钮
function refreshRedealButtonsForPlayer(player)
  -- 直接复用代码，删除再添加
    removeAllRedealButtons()
    addRedealButtonsToAllCards()
end

function redeal(obj, color, alt_click)
  if color == "Purple" then
    if gameInfo.redealA <= 0 then
      print("Purple player has no more redeals available")
    else
      gameInfo.redealA = gameInfo.redealA - 1
      local pos = gameInfo.board.zones.deckA.getPosition()
      local poscard = obj.getPosition()
      poscard[1] = poscard[1] + 1
      obj.use_hands = false
      obj.setPosition(poscard)
      poscard[1] = poscard[1] - 1
      obj.setPosition(poscard)
      obj.setPositionSmooth(pos, false, true)
      gameInfo.deckA.deal(1, "Purple")
    end
  elseif color == "Yellow" then
    if gameInfo.redealB <= 0 then
      print("Yellow player has no more redeals available")
    else
      gameInfo.redealB = gameInfo.redealB - 1
      local pos = gameInfo.board.zones.deckB.getPosition()
      local poscard = obj.getPosition()
      poscard[1] = poscard[1] + 1
      obj.use_hands = false
      obj.setPosition(poscard)
      poscard[1] = poscard[1] - 1
      obj.setPosition(poscard)
      obj.setPositionSmooth(pos, false, true)
      gameInfo.deckB.deal(1, "Yellow")
    end
  end

  -- 为两个玩家的手牌刷新重新调度按钮
  Wait.time(function()
    if gameInfo.stage == "redeal" then
      -- 获取所有玩家
      local players = Player.getPlayers()

      -- 遍历每个玩家
      for _, player in ipairs(players) do
        -- 只处理紫方和黄方玩家
        if player.color == "Purple" or player.color == "Yellow" then
          refreshRedealButtonsForPlayer(player)
        end
      end
    end
  end, 0.5)
end

function getObjectInstance(object)
  for _, card in ipairs(cardInstances) do
    if card.inGameObjGuid == object.guid then
      return card
    end
  end
  for _, token in ipairs(tokenInstances) do
    if token.inGameObjGuid == object.guid then
      return token
    end
  end
end

function getGUIDInstance(guid)
  for _, card in ipairs(cardInstances) do
    if card.inGameObjGuid == guid then
      return card
    end
  end
  for _, token in ipairs(tokenInstances) do
    if token.inGameObjGuid == guid then
      return token
    end
  end
end
-- Function to handle when an object leaves a container
function onObjectLeaveContainer(container, object)
  print("Object " .. object.guid .. " left container " .. container.guid .. " Type " .. object.type)
  if object.hasTag("GwentCard") then
    local cardInstance = getObjectInstance(object)
    if not cardInstance then return end

    -- Remove power buttons and main button
    if cardInstance.powerButton then
      local indexs = {}
      for _, button in ipairs(object.getButtons()) do
          indexs[#indexs+1] = button.index
      end
      for i, index in ipairs(table.sort(indexs)) do
          obj.removeButton(index)
      end

      cardInstance.indexBUp = nil
      cardInstance.indexBDown = nil
      cardInstance.powerButton = false
    end

    cardInstance.placed = false
  end
end

function onObjectSpawn(object)
    if object.hasTag("GwentCard") then
      addDisplayButton(object)
    end
    if object.hasTag("GwentToken") then
      addTokenButton(object)
    end
end

function addDisplayButton(object)
  local fColor
  cardInstance = getObjectInstance(object)
  if not cardInstance then
    return false
  end
  if cardInstance.power == cardInstance.basePower then
    fColor = {1, 1, 1}
  elseif cardInstance.power < cardInstance.basePower then
    fColor = {1, 0, 0}
  else
    fColor = {0, 1, 0}
  end
  local params = {
      click_function = "clickbutton",
      function_owner = self,
      label          = cardInstance.power,
      position       = {-0.7*scale*0.5, 0.1, -1.15*scale*0.5},
      rotation       = {0, 0, 0},
      width          = 200,
      height         = 200,
      font_size      = 260,
      color          = {0.5, 0.5, 0.5},
      font_color     = fColor,
      tooltip        = "点击以修改战力"
  }
  local params1 = {
      click_function = "nullButton",
      function_owner = self,
      label          = cardInstance.provision,
      position       = {0.8*scale*0.5, 0.1, 1.25*scale*0.5},
      rotation       = {0, 0, 0},
      width          = 0,
      height         = 0,
      font_size      = 260,
      color          = {0.5, 0.5, 0.5},
      font_color     = {1, 0.7568, 0.145},
      tooltip        = "人口...？？"
  }
  local params2 = {
      click_function = "nullButton",
      function_owner = self,
      label          = cardInstance.armor,
      position       = {0.775*scale*0.5, 0.1, -1.15*scale*0.5},
      rotation       = {0, 0, 0},
      width          = 0,
      height         = 0,
      font_size      = 260,
      color          = {0.5, 0.5, 0.5},
      font_color     = {1, 1, 1},
      tooltip        = "护甲...？？"
  }
  if cardInstance.type == "unit" then
    object.createButton(params)
  end
  if cardInstance.provision ~= 0 and cardInstance.type ~= "stragem" then
    object.createButton(params1)
  end
  if cardInstance.armor ~= 0 and cardInstance.type ~= "stragem" then
    object.createButton(params2)
  end
  cardInstance.buttonDisplay = params
  cardInstance.buttonProvision = params1
  if cardInstance.armor > 0 then
    print("create token")
    -- 使用贴花和CustomUI替代3D模型标记
    object.setDecals({
        {
            name     = "armor_bg",
            url      = "http://www.justgan.cn/icons/Armor",
            position = {0.775*scale*0.5, 0.05, -1.15*scale*0.5},   -- 略低于按钮
            rotation = {90, 0, 0},
            scale    = {0.12, 0.12, 1}
        }
    })

    object.createButton({
        click_function = "dummy",
        function_owner = self,
        label          = cardInstance.armor,
        position       = {0.775*scale*0.5, 0.15, -1.15*scale*0.5}, -- 比贴花略高
        rotation       = {0, 0, 0},
        width          = 0,       -- 0 不画按钮背景，只留文字
        height         = 0,
        font_size      = 200,
        font_color     = {1,1,1}, -- 白色
        color          = {0,0,0,0}
    })
  end
end

function nullButton()

end

function isInArray(t, val)
	for _, v in ipairs(t) do
		if v == val then
			return true
		end
	end
	return false
end


function addTokenButton(obj)
  local tokenInstance = getObjectInstance(obj)
  if not tokenInstance then return end
  local params = {
    click_function = "clicktokenbutton",
    function_owner = self,
    label          = tokenInstance.charge,
    position       = {0.1*scale, 0.1, 0},
    rotation       = {0, 0, 0},
    width          = 500,
    height         = 500,
    font_size      = 600,
    color          = {0, 0, 0},
    font_color     = {1, 1, 1},
    tooltip        = "点击以修改数量"
  }
  if isInArray({"倒数", "可充能指令", "可充能指令不可使用", "冷却"}, tokenInstance.type) then
    obj.createButton(params)
    tokenInstance.buttonDisplay = params
  elseif tokenInstance.type == "钱袋" then
    params.font_color = {0.7568, 1, 0.145}
    obj.createButton(params)
    tokenInstance.buttonDisplay = params
  elseif isInArray({"重伤", "活力"}, tokenInstance.type) then
    params.position = {0, 0.1, 0.5*scale}
    obj.createButton(params)
    tokenInstance.buttonDisplay = params
  elseif tokenInstance.type == "护甲" then
    params.position = {0, 0.1, 0}
    params.font_size = 1000
    obj.createButton(params)
    tokenInstance.buttonDisplay = params
  end
end

function onPlayerAction(player, action, targets)
    if action == Player.Action.Paste then
      if clipBoards[player.color][1].hasTag("GwentCard") then
        registerHousehold(targets[1], clipBoards[player.color][1])
        --addDisplayButton(targets[1])
      end
    elseif action == Player.Action.Copy then
      clipBoards[player.color] = targets
    end
    return true
end

function registerHousehold(child, parent)
  parentInstance = getObjectInstance(parent)
--  为child创建一个实例信息并插入CardInstances列表中
  cardInstance = {
    dataId = parentInstance.dataId,
    inGameObj = child,
    owner = parentInstance.owner,
    type = parentInstance.type,
    power = parentInstance.power,
    basePower = parentInstance.basePower,
    placed = false,
    powerButton = false,
    indexBUp = nil,
    indexBDown = nil,
    buttonDisplay = nil
  }
  cardInstances[#cardInstances+1] = cardInstance
end

function updateDisplay(instance, obj)
  -- 添加参数校验
  if not instance or not obj then
    print("[updateDisplay] 警告: instance或obj为nil")
    return
  end
  
  print("here vvv")
  print(instance)
  
  -- 检查必要的字段是否存在
  if not instance.buttonDisplay then
    print("[updateDisplay] 警告: instance.buttonDisplay不存在")
    return
  end
  
  for _, button in ipairs(obj.getButtons()) do
    if button.click_function == "clickbutton" then
      instance.buttonDisplay.label = instance.power
      local fColor = {}
      if instance.power == instance.basePower then
        fColor = {1, 1, 1, 1}
      elseif instance.power < instance.basePower then
        fColor = {1, 0, 0, 1}
      else
        fColor = {0, 1, 0, 1}
      end
      local params = instance.buttonDisplay
      params.index = button.index
      params.font_color = fColor
      obj.editButton(params)
      if button.click_function == "nullButton" then
        fColor = {1, 1, 0, 1}
        params = instance.buttonProvision
        if params then  -- 添加nil检查
          params.index = button.index
          params.font_color = fColor
          obj.editButton(params)
        end
        if instance.buttonDisplay then  -- 添加nil检查
          instance.buttonDisplay.font_color = fColor
        end
      end
    end
  end
  --params.index = 1
  --obj.editButton(params)
end

function updateTokenDisplay(instance, obj)
  instance.buttonDisplay.label = instance.charge
  obj.editButton(instance.buttonDisplay)
end
function onObjectPickUp(colorName, object)
    -- print(colorName .. " picked up " .. object.getName())
end

function onObjectEnterZone(zoneEntered, object)
    --print("Object " .. object.guid .. " entered zone " .. zoneEntered.guid)
    if gameInfo.board and object.hasTag("GwentCard") then
      for _, zone in pairs(gameInfo.board.zones) do
        if zoneEntered == zone then
            if zoneEntered.hasTag("zoneMeleeA") then
                object.addTag("InZoneMeleeA")
            elseif zoneEntered.hasTag("zoneMeleeB") then
                object.addTag("InZoneMeleeB")
            elseif zoneEntered.hasTag("zoneRangeA") then
                object.addTag("InZoneRangeA")
            elseif zoneEntered.hasTag("zoneRangeB") then
                object.addTag("InZoneRangeB")
            end
        end
      end
    end
  if gameInfo.board and object.type == "Deck" then
    if zoneEntered == gameInfo.board.zones.deckA then
      flagODA = true
      gameInfo.deckA = object
      gameInfo.originalDeckA = object.getObjects()
      print("deckA: ", gameInfo.deckA, object)
    elseif zoneEntered == gameInfo.board.zones.deckB then
      flagODB = true
      gameInfo.deckB = object
      gameInfo.originalDeckB = object.getObjects()
    end
  end
  
  -- 🔵 新增：FollowCursor 出牌区检测
  if not zoneEntered or not object then return end
  
  -- 检查是否有卡牌正在被跟随并进入出牌区
  local cardGuid = object.guid
  local targetedPlayerColor = nil
  
  for playerColor, fcData in pairs(followCursorData) do
    if fcData.isTracking and fcData.cardObj and fcData.cardObj.guid == cardGuid then
      targetedPlayerColor = playerColor
      break
    end
  end
  
  -- 如果有卡牌正在被跟随且进入了出牌区
  if targetedPlayerColor then
    -- 🔴 关键检查：只有当卡牌被旋转过才允许打出
    if cardRotated[cardGuid] == true then
      print("[FollowCursor] 卡牌 " .. cardGuid .. " 被旋转过，允许打出到 " .. tagName)
      stopFollowCursor(targetedPlayerColor)
      return
    else
      -- 没有旋转，禁止打出
      print("[FollowCursor] 警告: 卡牌 " .. cardGuid .. " 没有被旋转，禁止打出！")
      
      -- 将卡牌移回光标位置（取消打出操作）
      Wait.frames(function()
        local player = Player[targetedPlayerColor]
        if player and followCursorData[targetedPlayerColor] 
           and followCursorData[targetedPlayerColor].cardObj
           and not followCursorData[targetedPlayerColor].cardObj.isDestroyed() then
          local pos = player.getPointerPosition()
          pos.y = pos.y + 2
          followCursorData[targetedPlayerColor].cardObj.setPositionSmooth(pos, false, false)
          followCursorData[targetedPlayerColor].isTracking = true
          print("[FollowCursor] 卡牌已移回光标位置")
        end
      end, 1)
      
      return
    end
  end
  
  -- 正常的出牌区检测（针对非跟随状态的卡牌）
  for _, tagName in ipairs(zoneEntered.getTags()) do
    if table.contains(PLAY_ZONES, tagName) then
      for playerColor, fcData in pairs(followCursorData) do
        if fcData.isTracking and fcData.cardObj and object.guid == fcData.cardObj.guid then
          print("[FollowCursor] " .. playerColor .. " 打出了卡牌到 " .. tagName .. "！")
          stopFollowCursor(playerColor)
          return
        end
      end
    end
  end
end

function onObjectLeaveZone(zoneEntered, object)
    --print("Object " .. object.guid .. " left zone " .. zoneEntered.guid)
    if gameInfo.board and object.hasTag("GwentCard") then
        -- 移除对象的区域标签，并从游戏信息的对应列表中移除该对象
        if zoneEntered.hasTag("zoneMeleeA") then
            object.removeTag("InZoneMeleeA")
            removeObjectFromList(gameInfo.meleeA, object)
        elseif zoneEntered.hasTag("zoneMeleeB") then
            object.removeTag("InZoneMeleeB")
            removeObjectFromList(gameInfo.meleeB, object)
        elseif zoneEntered.hasTag("zoneRangeA") then
            object.removeTag("InZoneRangeA")
            removeObjectFromList(gameInfo.rangeA, object)
        elseif zoneEntered.hasTag("zoneRangeB") then
            object.removeTag("InZoneRangeB")
            removeObjectFromList(gameInfo.rangeB, object)
        end
        
        -- 卡牌离开战场时，清理其指令按钮状态追踪
        -- 防止卡牌移出战场后 orderButtonState 中存在残留记录，
        -- 导致下次该卡牌上场时 turnEntered 判断错误（仍用旧的值）
        if orderButtonState[object.guid] then
            orderButtonState[object.guid] = nil
            print("[OrderButton] 卡牌离场，清除指令状态: " .. object.guid)
        end
        
        -- 若卡牌离场时正处于目标选择模式，将其从已选中列表中移除（避免选中的目标失效）
        if targetSelectMode then
            for i, guid in ipairs(targetSelectData.selected) do
                if guid == object.guid then
                    table.remove(targetSelectData.selected, i)
                    print("[TargetSelect] 目标卡牌离场，已从选中列表移除: " .. object.guid)
                    break
                end
            end
        end
    end
end

-- 辅助函数，从列表中移除特定对象
function removeObjectFromList(list, object)
    for i, obj in ipairs(list) do
        if obj == object then
            table.remove(list, i)
            break
        end
    end
end

function onObjectDrop(colorName, object)
    if gameInfo.board and object.hasTag("GwentCard") and object.type == "Card" then
      local instance = getObjectInstance(object)
      local tagMatch = objectHasOneInAllTags(object, {"InZoneMeleeA", "InZoneMeleeB", "InZoneRangeA", "InZoneRangeB"})
      if tagMatch then
        print(colorName .. " 打出了 " .. instance.dataId)
        if colorName == "Purple" then
          gameInfo.playedA = true
        elseif colorName == "Yellow" then
          gameInfo.playedB = true
        end
        --只有单位可以被放在排里
        if isInArray({"unit", "stratagem", "artifact"}, instance.type) then
        -- 根据卡牌的位置计算插入索引
        -- 删除meleeACards里所有为空的元素
        local function removeEmptyEntries(cardList)
            local filteredList = {}
            for _, card in ipairs(cardList) do
                if card ~= nil then
                    table.insert(filteredList, card)
                end
            end
            return filteredList
        end

        local function getInsertIndex(cardList, newCardPos)
            for i, card in ipairs(cardList) do
                local cardPos = card.getPosition()
                if cardPos.x > newCardPos.x then return i end
            end
            return #cardList + 1 -- 插入到最后
        end

        local cardPos = object.getPosition()
        gameInfo.meleeA = removeEmptyEntries(gameInfo.meleeA) -- 在调用获取索引之前删除所有为空的元素
        local meleeACards = gameInfo.meleeA

          local zone = ""
          local insertIndex = 0
          if tagMatch == "InZoneMeleeA" and not isInArray(meleeACards, object) then
              zone = "MeleeA"
              insertIndex = getInsertIndex(meleeACards, cardPos)
              print("here>>> ", object)
              table.insert(meleeACards, insertIndex, object)
              print(meleeACards)
              adjustCardsPlace(meleeACards, gameInfo.board.zones.meleeA)
              print("adjusted")
          end
          local meleeBCards = gameInfo.meleeB
          if tagMatch == "InZoneMeleeB" and not isInArray(meleeBCards, object) then
            zone = "MeleeB"
            insertIndex = getInsertIndex(meleeBCards, cardPos)
            table.insert(meleeBCards, insertIndex, object)
            adjustCardsPlace(meleeBCards, gameInfo.board.zones.meleeB)
          end

          local rangeACards = gameInfo.rangeA
          if tagMatch == "InZoneRangeA" and not isInArray(rangeACards, object) then
            zone = "RangeA"
            insertIndex = getInsertIndex(rangeACards, cardPos)
            table.insert(rangeACards, insertIndex, object)
            adjustCardsPlace(rangeACards, gameInfo.board.zones.rangeA)
          end

          local rangeBCards = gameInfo.rangeB
          if tagMatch == "InZoneRangeB" and not isInArray(rangeBCards, object) then
            zone = "RangeB"
            insertIndex = getInsertIndex(rangeBCards, cardPos)
            table.insert(rangeBCards, insertIndex, object)
            adjustCardsPlace(rangeBCards, gameInfo.board.zones.rangeB)
          end
          print("zone" .. zone)
          print("Placed card " .. instance.dataId .. " in " .. zone)
          instance.placed = true
          --卡牌打出时，传递事件
          local event = {
            type = "Deploy",
            color = colorName,
            card = instance,
            row = zone,
            index = insertIndex,
          }
          emit(event)
          print(111)
        end
      else

      end
    end
  card = oncard(object)
  print(object)
  if object.hasTag("GwentToken") and card then
    print(object.type)
    if isInArray({'坚韧', '护盾', '锁定', '重伤', '活力', '中毒', '潜伏', '免疫', '佚亡', '卫士', '破裂', '遮蔽', '赏金', '灌注',}, object.type) then
      print(object.type)
      table.insert(card.statuses, object)
    end
  end
  
  -- 🔵 新增：FollowCursor 放下后重新拾起
  if not object then return end
  local fcData = followCursorData[colorName]
  if fcData and fcData.isTracking and fcData.cardObj and object.guid == fcData.cardObj.guid then
    print("[FollowCursor] " .. colorName .. " 放下了卡牌，重新拾起！")
    
    -- 检查卡牌是否被旋转过
    if cardRotated[object.guid] ~= true then
      print("[FollowCursor] 警告: 卡牌没有被旋转，强制标记为已旋转以允许后续打出")
      cardRotated[object.guid] = true
    end
    
    Wait.frames(function()
      if followCursorData[colorName] and followCursorData[colorName].cardObj
         and not followCursorData[colorName].cardObj.isDestroyed() then
        local pos = Player[colorName].getPointerPosition()
        pos.y = pos.y + 2
        followCursorData[colorName].cardObj.setPositionSmooth(pos, false, false)
        followCursorData[colorName].isTracking = true
      end
    end, 2)
  end
end

function oncard(obj)
  local cards = {}
  for i = 1, #gameInfo.meleeA do
    cards[#cards + i] = gameInfo.meleeA[i]
  end
  for i = 1, #gameInfo.meleeB do
    cards[#cards + i] = gameInfo.meleeB[i]
  end
  for i = 1, #gameInfo.rangeA do
    cards[#cards + i] = gameInfo.rangeA[i]
  end
  for i = 1, #gameInfo.rangeB do
    cards[#cards + i] = gameInfo.rangeB[i]
  end
  local half_size_card = {size_card[1] / 2, size_card[3] / 2}

  for _, card in ipairs(cards) do
      local card_position = card.getPosition()
      local obj_position = obj.getPosition()

      -- 判断 obj 的中心位置是否在 card 的范围内
      if math.abs(obj_position.x - card_position.x) <= half_size_card[1] and
         math.abs(obj_position.z - card_position.z) <= half_size_card[2] then
          return card
      end
  end
  return nil
end

-- 计算基于区域旋转的卡牌位置调整量
function calculateAdjustment_deparated(zoneRotate, cardSize)
  local rx, ry, rz = zoneRotate[1], zoneRotate[2], zoneRotate[3]
  local dx, dz = 0, 0

  dx = cardSize[1] * math.cos(math.rad(rz)) - cardSize[3] * math.sin(math.rad(rz))
  dz = cardSize[1] * math.sin(math.rad(rz)) + cardSize[3] * math.cos(math.rad(rz))

  return {dx, 0, dz}
end

function calculateAdjustment(zoneRotate, cardSize)
  local rx, ry, rz = zoneRotate[1], zoneRotate[2], zoneRotate[3]
  local dx, dz = 0, 0
  dx = dx + cardSize[1]
  return {dx, 0, dz}
end

function adjustCardsPlace(cards, zone)
  local zonePosition = zone.getPosition()
  local totalWidth = (#cards - 1) * size_card[1] / 2 -- 卡牌总宽度的一半

  -- 因为我们希望卡片中心对齐，所以首先计算中间点的x坐标偏移
  local centerXOffset = -totalWidth -- 这会使得第一张卡片的左侧正好位于区域中心左侧
  print("wait to adjust")
  for index, card in ipairs(cards) do
    print(index)
    print(card)
    local posX = zonePosition[1] + centerXOffset + (index - 1) * size_card[1]
    local posZ = zonePosition[3] -- 保持原有Z轴位置逻辑不变，假设高度没有变化处理

    -- 设置卡牌位置
    local newPos = {posX, 1.5, posZ} -- Y轴固定在1.5
    card.setPositionSmooth(newPos, false, false)
  end
end

function objectHasOneInAllTags(object, tags)
  for _, tag in ipairs(tags) do
    if object.hasTag(tag) then
      return tag
    end
  end
  return nil
end

function addXML(object, xml)
  if objectUI[object.guid] then
    table.insert(objectUI[object.guid], xml)
  else
    objectUI[object.guid] = {xml}
  end
  print(xml)
  updateXML(object)
end

function removeXML(object, xml)
  if objectUI[object.guid] then
    for i, _xml in ipairs(objectUI[object.guid]) do
      if _xml == xml then
        table.remove(objectUI[object.guid], i)
        break
      end
    end
    print(xml)
    updateXML(object)
  end
end

function updateXML(object)
  allXML = ""
  for _, xml in ipairs(objectUI[object.guid]) do
    allXML = allXML .. xml
  end
  object.UI.setXml(allXML)
end

function onObjectHover(player_color, object)
    local target = object and object.guid or "Nothing"
    print(player_color .. " hovered over " .. target)
    if object then
        local card = getObjectInstance(object)
      if object.type == "Card" and card then
        object.addTag("Hovered")
        local descUrl = string.format("http://www.justgan.cn/images/card_description_%s.png", card.dataId)
        -- 先移除可能已存在的相同XML（如果有的话）
        local xmlToRemove = string.format([[
            <Panel id="wrapper" position="0 0 -51" rotation="0 0 180">
              <HorizontalLayout height="320" width="240" color="rgba(255,204,0,0)" position="0 0 10">
                <Image image="%s" height="320" width="240" position="0 0 10"></Image>
              </HorizontalLayout>
            </Panel>
            <HorizontalLayout height="320" width="230" color="#78F0FFAA" position="0 0 0">
            </HorizontalLayout>
            ]], descUrl)
        --removeXML(object, xmlToRemove)

        addXML(object, xmlToRemove)
        print(object.guid)
      end
    end
    for _, targetHovered in ipairs(getObjectsWithTag("Hovered")) do
        if targetHovered ~= object and targetHovered.type == "Card" then
          local card = getObjectInstance(targetHovered)
          print(card, targetHovered)
          local descUrl = string.format("http://www.justgan.cn/images/card_description_%s.png", card.dataId)
          targetHovered.removeTag("Hovered")
          removeXML(targetHovered, string.format([[
            <Panel id="wrapper" position="0 0 -51" rotation="0 0 180">
              <HorizontalLayout height="320" width="240" color="rgba(255,204,0,0)" position="0 0 10">
                <Image image="%s" height="320" width="240" position="0 0 10"></Image>
              </HorizontalLayout>
            </Panel>
            <HorizontalLayout height="320" width="230" color="#78F0FFAA" position="0 0 0">
            </HorizontalLayout>
            ]], descUrl))

          -- 恢复卡牌正面为原来的立绘图片
          --local originalCard = getObjectInstance(targetHovered)
          --if originalCard then
          --  local originalUrl = string.format("http://www.justgan.cn/images/card_image_%s.png", originalCard.dataId)
          --  local descUrl = string.format("http://www.justgan.cn/images/card_description_%s.png", originalCard.dataId)
          --  targetHovered.setCustomObject({face = originalUrl, back = descUrl})
          --end
          --updateDisplay(getObjectInstance(targetHovered), targetHovered)
          --targetHovered.removeTag("Hovered")
        end
      end
end


function chooseButton(player, guid)
  print(player.color, guid)
  chosenCard = getGUIDInstance(guid)
  choosing = false
end

-- Choose UI相关函数
function onChooseCardClick(player, value, id)
  print("[DEBUG-ChooseUI] onChooseCardClick被调用")
  print("[DEBUG-ChooseUI] player: " .. tostring(player))
  print("[DEBUG-ChooseUI] value: " .. tostring(value))
  print("[DEBUG-ChooseUI] id: " .. tostring(id))
  
  -- 右键点击显示描述（value=2表示右键）
  if value == 2 then
    showCardDescription(id)
    return
  end
  
  -- 从id中提取guid (格式: "card_348cec")
  local guid = string.sub(id, 6) -- 去掉"card_"前缀
  print("[DEBUG-ChooseUI] 提取的guid: " .. guid)
  
  -- 检查是否已经选择
  local alreadySelected = false
  for i, selectedGuid in ipairs(chooseCards) do
    if selectedGuid == guid then
      table.remove(chooseCards, i)
      alreadySelected = true
      break
    end
  end
  
  if not alreadySelected then
    -- 如果未达到选择上限，添加选择
    if #chooseCards < chooseNum then
      table.insert(chooseCards, guid)
      print("[DEBUG-ChooseUI] 添加选择: " .. guid .. ", 当前已选: " .. #chooseCards)
    else
      -- 已达到上限，提示玩家
      print("[DEBUG-ChooseUI] 已选择" .. chooseNum .. "张卡，请先取消其他选择")
      return
    end
  else
    print("[DEBUG-ChooseUI] 取消选择: " .. guid)
  end
  
  -- 更新卡牌高亮状态
  updateCardHighlight(id, not alreadySelected)
  -- 更新确定按钮状态
  updateConfirmButton()
end

function showCardDescription(buttonId)
  -- 获取卡牌数据
  local guid = UI.getAttribute(buttonId, "data-guid")
  local name = UI.getAttribute(buttonId, "data-name")
  local descUrl = UI.getAttribute(buttonId, "data-desc")
  
  print("[DEBUG-ChooseUI] 显示卡牌描述: " .. tostring(name))
  
  -- 隐藏描述面板（如果已显示）
  local currentActive = UI.getAttribute("DescTooltip", "active")
  if currentActive == "true" then
    UI.setAttribute("DescTooltip", "active", false)
    return
  end
  
  -- 显示自定义描述面板
  local descXML = [[
    <VerticalLayout id="DescTooltip" width="350" height="450" color="#EE1a1a1a" padding="10">
      <Text text="]] .. name .. [[" fontSize="18" color="#FFFFFF" alignment="UpperCenter" fontStyle="Bold" />
      <Image url="]] .. descUrl .. [[" width="330" height="400" offsetXY="0,-30" />
    </VerticalLayout>
  ]]
  
  UI.setXml(descXML)
  UI.setAttribute("DescTooltip", "active", true)
end

function onChooseCardHover(player, isHovering, id)
  print("[DEBUG-ChooseUI] onChooseCardHover被调用, id: " .. tostring(id) .. ", isHovering: " .. tostring(isHovering))
  
  if isHovering then
    -- 获取卡牌数据
    local guid = UI.getAttribute(id, "data-guid")
    local name = UI.getAttribute(id, "data-name")
    local power = UI.getAttribute(id, "data-power")
    local basePower = UI.getAttribute(id, "data-basePower")
    local armor = UI.getAttribute(id, "data-armor")
    local descUrl = UI.getAttribute(id, "data-desc")
    
    print("[DEBUG-ChooseUI] Hover卡牌: " .. tostring(name))
    
    -- 计算战力颜色
    local powerColor = "#FFFFFF"
    if tonumber(power) < tonumber(basePower) then
      powerColor = "#FF0000"
    elseif tonumber(power) > tonumber(basePower) then
      powerColor = "#00FF00"
    end
    
    -- 显示自定义tooltip面板（使用description图片）
    local tooltipXML = [[
      <VerticalLayout id="CardTooltip" width="300" height="400" color="#DD1a1a1a" padding="10">
        <Text text="]] .. name .. [[" fontSize="20" color="#FFFFFF" alignment="UpperCenter" fontStyle="Bold" />
        <Image url="]] .. descUrl .. [[" width="280" height="350" offsetXY="0,-20" />
      </VerticalLayout>
    ]]
    
    UI.setXml(tooltipXML)
    UI.setAttribute("CardTooltip", "active", true)
  else
    -- 隐藏tooltip
    UI.setAttribute("CardTooltip", "active", false)
  end
end

function updateCardHighlight(buttonId, isSelected)
  -- 为选中的卡牌添加金色边框效果
  if isSelected then
    UI.setAttribute(buttonId, "color", "#FFD700")
    print("[DEBUG-ChooseUI] 高亮: " .. buttonId)
  else
    UI.setAttribute(buttonId, "color", "#FFFFFF")
    print("[DEBUG-ChooseUI] 取消高亮: " .. buttonId)
  end
end

function updateConfirmButton()
  -- 根据选择的卡牌数量更新确定按钮状态和标签
  if #chooseCards == chooseNum then
    UI.setAttribute("confirmBtn", "interactable", true)
    UI.setAttribute("confirmBtn", "color", "#4CAF50")
    UI.setAttribute("confirmBtn", "label", "确定 (" .. #chooseCards .. "/" .. chooseNum .. ")")
    print("[DEBUG-ChooseUI] 确定按钮已启用")
  else
    UI.setAttribute("confirmBtn", "interactable", false)
    UI.setAttribute("confirmBtn", "color", "#404040")
    UI.setAttribute("confirmBtn", "label", "确定 (" .. #chooseCards .. "/" .. chooseNum .. ")")
    print("[DEBUG-ChooseUI] 确定按钮已禁用")
  end
end

function confirmChoose(player, value, id)
  print("[DEBUG-ChooseUI] confirmChoose被调用")
  if #chooseCards ~= chooseNum then
    print("[DEBUG-ChooseUI] 请选择" .. chooseNum .. "张卡，当前已选: " .. #chooseCards)
    return
  end
  
  -- 构建选中的卡牌信息列表
  local selectedCardsData = {}
  for _, guid in ipairs(chooseCards) do
    local cardInstance = getGUIDInstance(guid)
    if cardInstance then
      -- 使用 inGameObjGuid（完整 GUID）而不是 guid
      table.insert(selectedCardsData, {
        dataId = tostring(cardInstance.dataId or ""),
        power = tonumber(cardInstance.power) or 0,
        basePower = tonumber(cardInstance.basePower) or 0,
        armor = tonumber(cardInstance.armor) or 0,
        provision = tonumber(cardInstance.provision) or 0,
        inGameObjGuid = tostring(cardInstance.inGameObjGuid or guid), -- 优先使用 inGameObjGuid
        owner = cardInstance.owner and cardInstance.owner.color or nil,
        faction = cardInstance.faction or "",
        cardType = cardInstance.type or "",
        rarity = cardInstance.rarity or "",
        placed = cardInstance.placed or false,
        charge = cardInstance.charge or 0,
        statuses = cardInstance.statuses or {},
        powerButton = cardInstance.powerButton or false
      })
    else
      -- 如果找不到卡牌实例，尝试直接从TTS获取
      print("[DEBUG-ChooseUI] 警告: 未找到卡牌实例 " .. guid .. "，尝试直接从TTS获取")
      local cardObj = getObjectFromGUID(guid)
      if cardObj then
        local fullGuid = cardObj.guid
        if fullGuid and string.len(tostring(fullGuid)) == 8 then
          print("[DEBUG-ChooseUI] 使用TTS返回的完整GUID: " .. fullGuid)
        end
        
        table.insert(selectedCardsData, {
          dataId = "",
          power = 0,
          basePower = 0,
          armor = 0,
          provision = 0,
          inGameObjGuid = tostring(fullGuid or guid),
          owner = nil,
          faction = "",
          cardType = "",
          rarity = "",
          placed = false,
          charge = 0,
          statuses = {},
          powerButton = false
        })
      end
    end
  end
  
  -- 发送选择结果到服务器
  local url = "http://www.justgan.cn/choose"
  local event = {
    type = "ChooseEnd",
    args = {
      cards = selectedCardsData
    }
  }
  local body = {
    gameInfo = nil,
    event = event
  }
  local headers = {
    ["Content-Type"]="application/x-www-form-urlencoded"
  }
  
  -- 隐藏UI
  UI.setAttribute("choosePanel", "active", false)
  WebRequest.custom(url, "POST", true, JSON.encode(body), headers, handleResponse)
end

-- ============================================================
-- FollowCursor 功能：让卡牌持续跟随玩家光标，直到被打出
-- ============================================================

-- 注意：PLAY_ZONES 已在 onLoad() 中声明为全局变量，此处不再重复声明

-- 辅助函数：从卡组中取出卡牌（如果卡牌在卡组中）
-- 返回：取出的卡牌对象（如果已在外部或取出成功）或 nil（如果卡牌不存在）
function ensureCardIsUnpacked(cardObj, cardGuid)
  if cardObj == nil then
    print("[ensureCardIsUnpacked] 警告: cardObj为nil，尝试通过cardGuid在卡组中查找")
    
    -- 如果没有 cardObj，尝试通过 cardGuid 在卡组中查找并取出
    if cardGuid then
      -- 遍历 gameInfo.deckA 和 gameInfo.deckB（真正的卡组对象）
      local decks = {gameInfo.deckA, gameInfo.deckB}
      
      for _, deck in ipairs(decks) do
        if deck and deck.getObjects then
          print("[ensureCardIsUnpacked] 检查卡组: " .. tostring(deck) .. " GUID: " .. (deck.guid or "unknown"))
          
          -- 获取卡组中的所有卡牌
          local cardsInDeck = deck.getObjects()
          for _, card in ipairs(cardsInDeck) do
            if card and card.guid then
              print("[ensureCardIsUnpacked]  卡组中的卡牌 GUID: " .. card.guid .. " vs 目标 GUID: " .. cardGuid)
              
              -- 检查 GUID 是否匹配（处理不同格式的 GUID）
              local cardGuidStr = tostring(card.guid)
              local targetGuidStr = tostring(cardGuid)
              
              -- 如果 GUID 的后8位匹配（TTS 短 GUID 格式）
              if cardGuidStr == targetGuidStr then
                print("[ensureCardIsUnpacked] ✓ 找到匹配的卡牌，从卡组 " .. tostring(deck) .. " 中取出")
                
                local takenCard = deck.takeObject({
                  index = card.index
                })
                
                if takenCard then
                  print("[ensureCardIsUnpacked] ✓ 成功取出卡牌，新 GUID: " .. takenCard.guid)
                  return takenCard
                else
                  print("[ensureCardIsUnpacked] ✗ 警告: 无法从卡组中取出卡牌")
                  return nil
                end
              end
            end
          end
        else
          print("[ensureCardIsUnpacked] 跳过无效的卡组引用")
        end
      end
      
      print("[ensureCardIsUnpacked] ✗ 未找到 GUID 匹配的卡牌: " .. cardGuid)
      return nil
    end
    
    print("[ensureCardIsUnpacked] 错误: cardObj为空且没有提供cardGuid")
    return nil
  end
  
  -- 检查卡牌是否在卡组中
  local cardZones = cardObj.getZones and cardObj.getZones() or {}
  local inDeck = false
  local sourceDeck = nil
  
  for _, zone in ipairs(cardZones) do
    -- 修复：TTS API 中 zone 对象没有 type 字段
    -- 正确的方法是检查 zone 是否是 Deck 类型对象（通过 zone.getName() 或 zone.tag）
    local zoneName = zone.getName and zone.getName() or ""
    if string.match(zoneName, "Deck") or (zone.tag and zone.tag == "Deck") then
      inDeck = true
      sourceDeck = zone
      print("[ensureCardIsUnpacked] 卡牌在卡组 " .. zoneName .. " 中")
      break
    end
  end
  
  -- 如果卡牌在卡组中，先将其取出
  if inDeck and sourceDeck then
    print("[ensureCardIsUnpacked] 正在从卡组 " .. sourceDeck.getName() .. " 中取出卡牌...")
    
    local takenCard = sourceDeck.takeObject({
      index = cardObj.index
    })
    
    if takenCard then
      print("[ensureCardIsUnpacked] ✓ 成功从卡组中取出卡牌，新GUID: " .. takenCard.guid)
      return takenCard
    else
      print("[ensureCardIsUnpacked] ✗ 警告: 无法从卡组中取出卡牌")
      return nil
    end
  end
  
  -- 卡牌不在卡组中，直接返回原对象
  return cardObj
end

-- 启动卡牌跟随光标
function startFollowCursor(cardObj, playerColor)
  if cardObj == nil then
    print("[FollowCursor] 错误: cardObj为空")
    return
  end
  
  -- 初始化该玩家的追踪数据
  followCursorData[playerColor] = {
    cardObj = cardObj,
    isTracking = true,
    cardGuid = cardObj.guid
  }
  
  -- 初始化旋转状态为false
  cardRotated[cardObj.guid] = false
  
  print("[FollowCursor] 开始追踪: " .. playerColor .. " 的卡牌 " .. cardObj.guid)
  
  -- 将卡牌移动到玩家光标位置（初始位置）
  local player = Player[playerColor]
  if player then
    local pos = player.getPointerPosition()
    pos.y = pos.y + 2  -- 稍微抬高，避免插进桌面
    cardObj.setPositionSmooth(pos, false, false)
    cardObj.setLock(false)
    print("[FollowCursor] 卡牌已移动到光标位置")
  else
    print("[FollowCursor] 错误: 找不到玩家 " .. playerColor)
  end
end

-- 停止卡牌跟随
function stopFollowCursor(playerColor)
  if followCursorData[playerColor] then
    local cardGuid = followCursorData[playerColor].cardGuid
    
    print("[FollowCursor] 停止追踪: " .. playerColor)
    
    -- 清理旋转状态
    if cardGuid and cardRotated[cardGuid] ~= nil then
      cardRotated[cardGuid] = nil
    end
    
    followCursorData[playerColor] = nil
  end
end

-- 辅助函数：检查table是否包含某个值
function table.contains(tbl, value)
  for _, v in ipairs(tbl) do
    if v == value then
      return true
    end
  end
  return false
end

-- 显示Order选择UI
function showOrderChooseUI()
  local cards = clickOrderButton.chooseCardsData or {}
  local num = clickOrderButton.chooseNum or 1
  
  print("[DEBUG-showOrderChooseUI] 显示Order选择UI，需要选择" .. num .. "张卡，卡牌数量: " .. #cards)
  
  -- 检查cards是否为空
  if #cards == 0 then
    print("[ERROR-showOrderChooseUI] 卡牌列表为空！")
    return
  end
  
  -- 为每张卡牌创建缩略图按钮
  local gridXML = ""
  for i, cardData in ipairs(cards) do
    local imageUrl = string.format("http://www.justgan.cn/images/card_image_%s.png", cardData.dataId)
    local descUrl = string.format("http://www.justgan.cn/images/card_description_%s.png", cardData.dataId)
    
    -- 计算战力颜色
    local powerColor = "#FFFFFF"
    if cardData.power and cardData.power < cardData.basePower then
      powerColor = "#FF0000"
    elseif cardData.power and cardData.power > cardData.basePower then
      powerColor = "#00FF00"
    end
    
    -- 放大到200%：从140,190变为280,380
    gridXML = gridXML .. [[
      <Button id="card_]] .. cardData.guid .. [["
              onClick="onOrderChooseCardClick"
              onHover="onOrderChooseCardHover"
              tooltip="]] .. (cardData.name or "Unknown") .. [[  战力: ]] .. (cardData.power or 0) .. [[/]] .. (cardData.basePower or 0) .. [[  护甲: ]] .. (cardData.armor or 0) .. [[  人口: ]] .. (cardData.provision or 0) .. [[\n]] .. (cardData.description or "") .. [["
              image="]] .. imageUrl .. [["
              width="280"
              height="380"
              data-guid="]] .. cardData.guid .. [["
              data-desc="]] .. descUrl .. [["
              data-name="]] .. (cardData.name or "") .. [["
              data-description="]] .. (cardData.description or "") .. [["
              data-power="]] .. (cardData.power or 0) .. [["
              data-basePower="]] .. (cardData.basePower or 0) .. [["
              data-armor="]] .. (cardData.armor or 0) .. [["
              color="#FFFFFF">
          <Panel>
          <!-- 🔴 左上角：战力 -->
          <Text text="]] .. (cardData.power or 0) .. [["
                fontSize="42"
                color="]] .. powerColor .. [["
                offsetXY="-100,150"
                fontStyle="Bold"
                textOutline="#000000"
                textOutlineSize="2" />

          <!-- 🟡 右上角：护甲 -->
          <Text text="]] .. (cardData.armor or 0) .. [["
                fontSize="42"
                active="]] .. ((cardData.armor or 0) > 0 and "true" or "false") .. [["
                color="#FFD700"
                offsetXY="100,150"
                fontStyle="Bold"
                textOutline="#000000"
                textOutlineSize="2" />

          <!-- 🔵 右下角：人口 -->
          <Text text="]] .. (cardData.provision or 0) .. [["
                fontSize="42"
                color="#FFD700"
                offsetXY="100,-150"
                fontStyle="Bold"
                textOutline="#000000"
                textOutlineSize="2" />
          </Panel>
      </Button>
    ]]
  end
  
  print("[DEBUG-showOrderChooseUI] 已生成gridXML")
  
  -- 使用VerticalScrollView配合GridLayout
  local fullXML = [[
    <VerticalLayout width="100%" height="100%" color="#CC000000" padding="20" spacing="10" Id="orderChoosePanel">
      <Text text="请选择 ]] .. num .. [[ 张卡" fontSize="40" color="#FFFFFF" alignment="MiddleCenter" height="60" />
      <VerticalScrollView width="100%" height="700" scrollbarBackgroundColor="#404040">
        <GridLayout width="100%" cellSize="280,380" spacing="10 10" padding="10" color="#00000000">
          ]] .. gridXML .. [[
        </GridLayout>
      </VerticalScrollView>
      <HorizontalLayout width="100%" height="80" color="#00000000">
        <Button id="confirmOrderBtn" text="确定 (0/]] .. num .. [[)" onClick="confirmOrderChoose" width="200" height="60" fontSize="42" color="#404040" activeColor="#4CAF50" />
       </HorizontalLayout>
    </VerticalLayout>
  ]]
  
  UI.setXml(fullXML)
  print("[DEBUG-showOrderChooseUI] UI已设置完成")
end

-- Order选择UI：点击卡牌
function onOrderChooseCardClick(el)
  print("[DEBUG-onOrderChooseCardClick] 点击卡牌: " .. el.id)
  
  -- 获取卡牌GUID
  local guid = el:getAttribute("data-guid")
  if not guid then
    print("[ERROR-onOrderChooseCardClick] 未找到卡牌GUID")
    return
  end
  
  -- 标记卡牌为选中状态（添加边框）
  local currentColor = el:getAttribute("color")
  if currentColor == "#FFFF00" then
    -- 取消选中
    el:setAttribute("color", "#FFFFFF")
    -- 从选中列表中移除
    for i, selectedGuid in ipairs(clickOrderButton.selectedGuids or {}) do
      if selectedGuid == guid then
        table.remove(clickOrderButton.selectedGuids, i)
        break
      end
    end
  else
    -- 选中
    el:setAttribute("color", "#FFFF00")
    -- 添加到选中列表
    if not clickOrderButton.selectedGuids then
      clickOrderButton.selectedGuids = {}
    end
    table.insert(clickOrderButton.selectedGuids, guid)
  end
  
  -- 更新确认按钮文本
  updateOrderConfirmButton()
end

-- Order选择UI：更新确认按钮状态
function updateOrderConfirmButton()
  local btn = UI.getObject("confirmOrderBtn")
  if btn then
    local selected = clickOrderButton.selectedGuids or {}
    local num = clickOrderButton.chooseNum or 1
    btn:setAttribute("text", "确定 (" .. #selected .. "/" .. num .. ")")
    
    -- 根据选中数量设置按钮是否激活
    if #selected == num then
      btn:setAttribute("active", "true")
      btn:setAttribute("color", "#4CAF50")
    else
      btn:setAttribute("active", "false")
      btn:setAttribute("color", "#404040")
    end
  end
end

-- Order选择UI：确认选择
function confirmOrderChoose()
  local selected = clickOrderButton.selectedGuids or {}
  local num = clickOrderButton.chooseNum or 1
  
  if #selected ~= num then
    print("[ERROR-confirmOrderChoose] 选中数量不匹配，需要" .. num .. "张，实际选中" .. #selected .. "张")
    return
  end
  
  print("[DEBUG-confirmOrderChoose] 确认选择" .. #selected .. "张卡")
  
  -- 构建选中卡牌的数据列表
  local selectedCardsData = {}
  for i, guid in ipairs(selected) do
    -- 从chooseCardsData中查找对应的卡牌数据
    for j, cardData in ipairs(clickOrderButton.chooseCardsData or {}) do
      if cardData.guid == guid then
        table.insert(selectedCardsData, cardData)
        break
      end
    end
  end
  
  -- 清理UI
  UI.setAttribute("orderChoosePanel", "active", false)
  
  -- 发送选中卡牌到Python后端
  sendOrderChooseResult(selectedCardsData)
end

-- 发送Order选择结果到Python后端
function sendOrderChooseResult(selectedCards)
  print("[DEBUG-sendOrderChooseResult] 发送Order选择结果，选中卡牌数量: " .. #selectedCards)
  
  -- 构建事件
  local event = {
    type = "OrderChooseEnd",
    args = {
      cards = selectedCards  -- 发送多张卡牌
    }
  }
  
  -- 发送到 /choose 接口
  local url = "http://www.justgan.cn/choose"
  local body = {
    gameInfo = nil,
    event = event
  }
  local headers = {
    ["Content-Type"]="application/x-www-form-urlencoded"
  }
  
  print("Sending Order choose result to server...")
  WebRequest.custom(url, "POST", true, JSON.encode(body), headers, function(request)
    if request.is_error then
      print("Error sending Order choose result: " .. request.error)
    else
      print("Order choose result response: " .. request.text)
      local actions = JSON.decode(request.text)
      if actions and type(actions) == "table" then
        -- 处理返回的actions
        for i, action in ipairs(actions) do
          print("Processing action: " .. action.action)
          -- 这里可以处理其他action，目前只关注选择结果
        end
      end
    end
  end)
end

-- 旋转检测函数：监控卡牌旋转状态
function onObjectRotate(object, spin, flip, player_color, old_spin, old_flip)
  -- 只处理昆特牌
  if not object.hasTag("GwentCard") then
    return
  end
  
  local cardGuid = object.guid
  
  -- 检查该卡牌是否正在被跟随
  for pColor, fcData in pairs(followCursorData) do
    if fcData.isTracking and fcData.cardObj and fcData.cardObj.guid == cardGuid then
      -- 检测到旋转（spin或flip发生变化）
      if spin ~= old_spin or flip ~= old_flip then
        cardRotated[cardGuid] = true
        print("[FollowCursor] 检测到卡牌 " .. cardGuid .. " 被旋转 (spin: " .. old_spin .. "→" .. spin .. ", flip: " .. old_flip .. "→" .. flip .. ")，玩家: " .. player_color)
      end
      break
    end
  end
  
  -- 默认的旋转打印（用于其他情况）
  if spin ~= old_spin then
    print(player_color .. " spun " .. tostring(object) .. " from " .. old_spin .. " degrees to " .. spin .. " degrees")
  end

  if flip ~= old_flip then
    print(player_color .. " flipped " .. tostring(object) .. " from " .. old_flip .. " degrees to " .. flip .. " degrees")
  end
end
-- =============================================================================
-- 指令系统（Order System）辅助函数
-- =============================================================================

-- --------------------------------------------------------------------------
-- updateOrderButtons()
-- 在每个回合开始时调用（由 onUpdate 的回合递增逻辑触发），
-- 遍历 orderButtonState，将入场早于当前回合（即上一回合或更早入场）的
-- 休眠按钮切换为可用指令按钮。
-- --------------------------------------------------------------------------
function updateOrderButtons()
  local currentTurn = gameInfo.turn
  print("[OrderButton] updateOrderButtons 执行，当前回合=" .. currentTurn)
  
  for cardGuid, state in pairs(orderButtonState) do
    -- 只处理仍处于休眠状态、且入场回合严格早于当前回合的卡牌
    if state.isDormant and currentTurn > state.turnEntered then
      local card = getObjectFromGUID(cardGuid)
      if card then
        -- 移除休眠按钮
        for _, button in ipairs(card.getButtons() or {}) do
          if button.click_function == "clickDormantOrderButton" then
            card.removeButton(button.index)
            break
          end
        end
        
        -- 添加可用指令按钮（蓝色，可点击）
        local activeParams = {
          click_function = "clickOrderButton",
          function_owner = self,
          label          = "Order",
          position       = {0, 0.1, 0},
          rotation       = {0, 0, 0},
          width          = 400,
          height         = 200,
          font_size      = 200,
          color          = {0.2, 0.5, 1.0},   -- 蓝色：可用
          font_color     = {1, 1, 1},
          tooltip        = "点击使用指令\n筛选: " .. (state.filter or "allyRows")
        }
        card.createButton(activeParams)
        
        -- 切换为可用指令图标贴花
        card.setDecals({{
          name     = "order_active",
          url      = "http://www.justgan.cn/icons/新可用指令",
          position = {0, 0.05, -0.5},
          rotation = {90, 0, 0},
          scale    = {0.15, 0.15, 1}
        }})
        
        -- 更新状态为已激活（非休眠）
        state.isDormant = false
        
        print("[OrderButton] 卡牌指令激活: card=" .. cardGuid
              .. "，入场回合=" .. state.turnEntered
              .. "，当前回合=" .. currentTurn)
      else
        -- 卡牌对象已不存在（例如被销毁），清理残留状态
        orderButtonState[cardGuid] = nil
        print("[OrderButton] 卡牌已不存在，清理状态: " .. cardGuid)
      end
    end
  end
end

-- --------------------------------------------------------------------------
-- enterTargetSelectMode(filter, minCount, maxCount, orderCardGuid)
-- 进入 target_field 目标选择模式。
-- 在符合 filter 条件的战场卡牌上添加临时选择按钮并高亮，
-- 玩家点击后记录到 targetSelectData.selected；达到 maxCount 时自动确认。
-- --------------------------------------------------------------------------
function enterTargetSelectMode(filter, minCount, maxCount, orderCardGuid)
  -- 如果已经在选择模式中，先清理
  if targetSelectMode then
    clearTargetSelectMode()
  end
  
  targetSelectMode = true
  targetSelectData = {
    filter        = filter,
    min           = minCount  or 1,
    max           = maxCount  or 1,
    orderCardGuid = orderCardGuid,
    selected      = {}
  }
  
  print("[TargetSelect] 进入目标选择模式: filter=" .. tostring(filter)
        .. " min=" .. tostring(minCount) .. " max=" .. tostring(maxCount))
  
  -- 获取所有有效目标并高亮
  local validTargets = getValidTargets(filter, orderCardGuid)
  if #validTargets == 0 then
    print("[TargetSelect] 没有找到有效目标，自动取消选择模式")
    clearTargetSelectMode()
    return
  end
  
  for _, cardObj in ipairs(validTargets) do
    -- 高亮目标卡牌（绿色）
    cardObj.highlightOn({0, 1, 0})
    
    -- 在目标卡牌上添加选择按钮
    local params = {
      click_function = "onTargetCardClick",
      function_owner = self,
      label          = "选择",
      position       = {0, 0.2, 0.4},
      rotation       = {0, 0, 0},
      width          = 350,
      height         = 200,
      font_size      = 180,
      color          = {0.1, 0.7, 0.2},    -- 绿色：可选
      font_color     = {1, 1, 1},
      tooltip        = "点击选择此卡牌为目标"
    }
    cardObj.createButton(params)
  end
  
  -- 如果需要最少超过1张，显示确认按钮（当选择数量不足时玩家需手动确认）
  -- 目前先依赖 onTargetCardClick 中的自动确认（达到 max 时自动提交）
  broadcastToAll("[指令] 请在战场上点击选择目标卡牌（最多选 " .. tostring(maxCount) .. " 张）", {0.5, 0.8, 1})
end

-- --------------------------------------------------------------------------
-- getValidTargets(filter, excludeGuid)
-- 根据 filter 字符串返回符合条件的战场卡牌对象列表。
-- excludeGuid：可选，排除指定 GUID 的卡牌（通常为发起指令的卡牌本身）。
-- 支持的 filter：
--   "allyRows"     - 所有友方战场卡牌
--   "enemyRows"    - 所有敌方战场卡牌
--   "battleGround" - 所有战场卡牌
-- --------------------------------------------------------------------------
function getValidTargets(filter, excludeGuid)
  local targets = {}
  
  -- 确定要遍历的行列表
  local rowsToCheck = {}
  if filter == "allyRows" then
    rowsToCheck = {gameInfo.meleeA, gameInfo.rangeA}
  elseif filter == "enemyRows" then
    rowsToCheck = {gameInfo.meleeB, gameInfo.rangeB}
  else
    -- 默认或 "battleGround"：包含所有战场行
    rowsToCheck = {gameInfo.meleeA, gameInfo.rangeA, gameInfo.meleeB, gameInfo.rangeB}
  end
  
  for _, row in ipairs(rowsToCheck) do
    if row then
      for _, cardObj in ipairs(row) do
        -- 排除指定 GUID（通常为发起 Order 的卡牌自身）
        local skip = (excludeGuid and cardObj.guid == excludeGuid)
        if not skip and cardObj.hasTag and cardObj.hasTag("GwentCard") then
          table.insert(targets, cardObj)
        end
      end
    end
  end
  
  print("[TargetSelect] 有效目标数量: " .. #targets .. " (filter=" .. tostring(filter) .. ")")
  return targets
end

-- --------------------------------------------------------------------------
-- onTargetCardClick(obj, color, alt_click)
-- 目标选择按钮的回调函数，玩家点击目标卡牌上的"选择"按钮时触发。
-- --------------------------------------------------------------------------
function onTargetCardClick(obj, color, alt_click)
  if not targetSelectMode then
    print("[TargetSelect] 警告: 非目标选择模式下触发了 onTargetCardClick")
    return
  end
  
  local cardGuid = obj.guid
  
  -- 检查是否已选择该卡牌（避免重复选择）
  for _, guid in ipairs(targetSelectData.selected) do
    if guid == cardGuid then
      broadcastToColor("该卡牌已选中，请选择其他目标。", color, {1, 0.6, 0})
      return
    end
  end
  
  -- 记录选择，并将该卡牌高亮改为黄色（已选中）
  table.insert(targetSelectData.selected, cardGuid)
  obj.highlightOn({1, 1, 0})   -- 黄色：已选中
  print("[TargetSelect] 选择目标: " .. cardGuid .. "（已选 " .. #targetSelectData.selected .. "/" .. targetSelectData.max .. "）")
  
  -- 达到最大选择数时自动确认提交
  if #targetSelectData.selected >= targetSelectData.max then
    print("[TargetSelect] 已达到最大选择数，自动确认")
    confirmTargetSelect()
  end
end

-- --------------------------------------------------------------------------
-- confirmTargetSelect()
-- 玩家完成目标选择后，构建选中卡牌数据并 POST 到 /choose。
-- 服务端 GameContext.set_choice_result() 会解析此数据并继续 Order 协程。
-- --------------------------------------------------------------------------
function confirmTargetSelect()
  if not targetSelectMode then
    print("[TargetSelect] 错误: 非目标选择模式下调用了 confirmTargetSelect")
    return
  end
  
  -- 检查是否满足最少选择数量
  if #targetSelectData.selected < targetSelectData.min then
    broadcastToAll("[指令] 请至少选择 " .. targetSelectData.min .. " 个目标", {1, 0.5, 0.5})
    return
  end
  
  print("[TargetSelect] 确认选择，已选目标数: " .. #targetSelectData.selected)
  
  -- 构建 /choose 请求体
  -- 与 showChooseUI 的 ChooseEnd 事件格式保持一致，以便 Python 端统一处理
  local selectedCards = {}
  for _, guid in ipairs(targetSelectData.selected) do
    local cardObj = getObjectFromGUID(guid)
    local instance = cardObj and getObjectInstance(cardObj)
    if instance then
      table.insert(selectedCards, {
        guid          = guid,
        dataId        = tostring(instance.dataId    or ""),
        power         = tonumber(instance.power)    or 0,
        basePower     = tonumber(instance.basePower) or 0,
        armor         = tonumber(instance.armor)    or 0,
        inGameObjGuid = guid
      })
    else
      -- 即使找不到实例，也传 GUID 以防服务端需要
      table.insert(selectedCards, {guid = guid, inGameObjGuid = guid})
    end
  end
  
  -- 清除选择模式（先清理 UI，再提交，避免回调在提交途中被重复触发）
  clearTargetSelectMode()
  
  -- 发送到 /choose
  local url  = "http://www.justgan.cn/choose"
  local body = {
    -- 与 showChooseUI 的 ChooseEnd 格式保持一致：cards 放在 event.args.cards 中，
    -- Python /choose 端通过 args.get("cards", []) 读取。
    -- type 使用 "TargetSelectEnd" 便于日志区分（Python 端对 type 不做限制）。
    event = {
      type = "TargetSelectEnd",
      args = {
        cards = selectedCards
      }
    }
  }
  local headers = { ["Content-Type"] = "application/x-www-form-urlencoded" }
  
  print("[TargetSelect] 发送目标选择结果到 /choose，卡牌数: " .. #selectedCards)
  WebRequest.custom(url, "POST", true, JSON.encode(body), headers, handleResponse)
end

-- --------------------------------------------------------------------------
-- clearTargetSelectMode()
-- 退出目标选择模式，移除所有高亮和临时选择按钮。
-- --------------------------------------------------------------------------
function clearTargetSelectMode()
  if not targetSelectMode then
    return
  end
  
  print("[TargetSelect] 清理目标选择模式")
  
  -- 遍历所有战场行，移除高亮和选择按钮
  local allRows = {
    gameInfo.meleeA, gameInfo.rangeA,
    gameInfo.meleeB, gameInfo.rangeB
  }
  for _, row in ipairs(allRows) do
    if row then
      for _, cardObj in ipairs(row) do
        -- 取消高亮
        -- 取消高亮（TTS 的 isHighlighted 是方法，需直接调用）
        if cardObj.isHighlighted() then
          cardObj.highlightOff()
        end
        -- 移除"选择"按钮
        for _, button in ipairs(cardObj.getButtons() or {}) do
          if button.click_function == "onTargetCardClick" then
            cardObj.removeButton(button.index)
            break
          end
        end
      end
    end
  end
  
  -- 重置目标选择状态
  targetSelectMode = false
  targetSelectData = {
    filter        = nil,
    min           = 1,
    max           = 1,
    orderCardGuid = nil,
    selected      = {}
  }
end