local extension = Package:new("MahjongSoul_token", Package.CardPack)
extension.extensionName = "MahjongSoul"
extension.game_modes_whitelist = { "tenyear_1v2", "m_2v2_mode", "vanished_dragon", "sfvanished_dragon", "chaos_mode",
  "aaa_role_mode", "oddfight_mode", "jbs_2v2_mode", "m_1v2_mode" }
Fk:loadTranslationTable {
  ["MahjongSoul_token"] = "神武卡牌包",
}
local U = require "packages/utility/utility"
local zlCards = {}
local function addzlCard(c)
  extension:addCard(c)
  table.insert(zlCards, c)
end
-- 游戏开始时移除部分装备
local swcard__modify_skill = fk.CreateTriggerSkill {
  name = "#swcard__modify_skill",
  global = true,
  refresh_events = { fk.GamePrepared },
  can_refresh = function(self, event, target, player, data)
    return not table.contains(player.room.disabled_packs, "MahjongSoul_token")
  end,
  on_refresh = function(self, event, target, player, data)
    for _, id in ipairs(player.room.draw_pile) do
      if Fk:getCardById(id).name == "qinggang_sword" or Fk:getCardById(id).name == "axe" or
          Fk:getCardById(id).name == "halberd" or Fk:getCardById(id).name == "ice_sword" or Fk:getCardById(id).name == "kylin_bow" then
        table.insertIfNeed(player.room.void, id)
        player.room:setCardArea(id, Card.Void, nil)
        table.removeOne(player.room.draw_pile, id)
      end
    end
  end
}
table.insertTable(AuxSkills, {
  swcard__modify_skill
})

local jgfuc__Skill = fk.CreateTriggerSkill {
  name = "#jgfuc__Skill",
  attached_equip = "sw_fmjgc",
  priority = 0,
  frequency = Skill.Compulsory,
  events = { fk.DamageCaused, fk.TargetSpecified },
  can_trigger = function(self, event, target, player, data)
    if event == fk.DamageCaused then
      return target == player and player:hasSkill(self.name) and data.to:getEquipment(Card.SubtypeArmor) and data.card and
          data.card.trueName == "slash"
    else
      return target == player and player:hasSkill(self) and data.card and data.card.trueName == "slash"
    end
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    room:broadcastPlaySound("./packages/standard_cards/audio/card/qinggang_sword")
    room:setEmotion(player, "./packages/standard_cards/image/anim/qinggang_sword")
    if event == fk.DamageCaused then
      data.damage = data.damage + 1
    else
      local to = room:getPlayerById(data.to)
      local use_event = room.logic:getCurrentEvent():findParent(GameEvent.UseCard, true)
      if use_event == nil then return end
      room:addPlayerMark(to, fk.MarkArmorNullified)
      use_event:addCleaner(function()
        room:removePlayerMark(to, fk.MarkArmorNullified)
      end)
    end
  end
}
Fk:addSkill(jgfuc__Skill)

local sw_fmjgc = fk.CreateWeapon {
  name = "sw_fmjgc",
  suit = Card.Spade,
  number = 3,
  attack_range = 3,
  equip_skill = jgfuc__Skill,
}
extension:addCard(sw_fmjgc)
Fk:loadTranslationTable {
  ["sw_fmjgc"] = "伏魔金刚杵",
  [":sw_fmjgc"] = "装备牌·武器<br /><b>攻击范围</b>：3<br /><b>武器技能</b>：锁定技，你使用【杀】无视防具，对有防具的目标造成的伤害+1。",
  ["#jgfuc__Skill"] = "伏魔金刚杵",
}
local sw_psfskill = fk.CreateTriggerSkill {
  name = "#sw_psfskill",
  attached_equip = "sw_psf",
  events = { fk.CardEffectCancelledOut },
  can_trigger = function(self, event, target, player, data)
    return player:hasSkill(self) and data.from == player.id and data.card.trueName == "slash" and
        not player.room:getPlayerById(data.to).dead
  end,
  on_cost = function(self, event, target, player, data)
    local room = player.room
    local pattern
    if player:getEquipment(Card.SubtypeWeapon) then
      pattern = ".|.|.|.|.|.|^" .. tostring(player:getEquipment(Card.SubtypeWeapon))
    else
      pattern = "."
    end
    local cards = room:askForDiscard(player, 2, 2, true, self.name, true, pattern, "#sw_psf-invoke::" .. data.to, true)
    if #cards > 0 then
      self.cost_data = cards
      return true
    end
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    if #self.cost_data > 0 then
      local equipC = table.filter(self.cost_data, function(id)
        return Fk:getCardById(id).type == Card.TypeEquip
      end)
      local drawtrick = table.filter(self.cost_data, function(id)
        return Fk:getCardById(id).type == Card.TypeTrick
      end)
      if #drawtrick > 0 or #equipC > 0 then
        player:drawCards(1, self.name)
      end
    end
    room:broadcastPlaySound("./packages/standard_cards/audio/card/axe")
    room:setEmotion(player, "./packages/standard_cards/image/anim/axe")
    room:throwCard(self.cost_data, "sw_psf", player, player)
    return true
  end,
}
Fk:addSkill(sw_psfskill)
local sw_psf = fk.CreateWeapon {
  name = "sw_psf",
  suit = Card.Diamond,
  number = 5,
  attack_range = 3,
  equip_skill = sw_psfskill,
}

extension:addCards({
  sw_psf,
})
Fk:loadTranslationTable {
  ["sw_psf"] = "劈山斧",
  [":sw_psf"] = "装备牌·武器<br /><b>攻击范围</b>：３<br /><b>武器技能</b>：当你使用的【杀】被【闪】抵消后，你可以弃置两张牌，则此【杀】继续造成伤害，若你弃置的牌包含非基本牌，你摸一张牌。",
  ["#sw_psfskill"] = "劈山斧",
  ["#psf_skill_tarmod"] = "劈山斧",
  ["#sw_psf-invoke"] = "劈山斧：你可以弃置两张牌，令你对 %dest 使用的【杀】依然生效",
}
local sw_sxzbskill = fk.CreateViewAsSkill {
  name = "sw_sxzbskill",
  prompt = "#sw_sxzbskill",
  attached_equip = "sw_sxzb",
  pattern = "slash",
  card_filter = function(self, to_select, selected)
    if #selected == 2 then return false end
    return table.contains(Self:getHandlyIds(true), to_select)
  end,
  view_as = function(self, cards)
    local n = math.min(Self:usedSkillTimes(self.name, Player.HistoryTurn), 2)
    if #cards ~= n then
      return nil
    end
    local c = Fk:cloneCard("slash")
    c.skillName = "sw_sxzb"
    c:addSubcards(cards)
    return c
  end,
  before_use = function(self, player, use)
    player.room:broadcastPlaySound("./packages/standard_cards/audio/card/spear")
    player.room:setEmotion(player, "./packages/standard_cards/image/anim/spear")
  end,
}
Fk:addSkill(sw_sxzbskill)
local sw_sxzb = fk.CreateWeapon {
  name = "sw_sxzb",
  suit = Card.Spade,
  number = 12,
  attack_range = 3,
  equip_skill = sw_sxzbskill,
}

extension:addCards({
  sw_sxzb,
})
Fk:loadTranslationTable {
  ["sw_sxzb"] = "神啸丈八",
  [":sw_sxzb"] = "装备牌·武器<br /><b>攻击范围</b>：３<br /><b>武器技能</b>：你可以将X张手牌当【杀】使用或打出(X为你本回合使用该装备的次数，至多为2)。",
  ["sw_sxzbskill"] = "丈八",
  [":sw_sxzbskill"] = "你可以将X张手牌当【杀】使用或打出(X为你本回合使用该装备的次数，至多为2)",
  ["#sw_sxzbskill"] = "神啸：请选择要打出或使用的牌",
}
local sw_hlyyskill = fk.CreateTriggerSkill {
  name = "#sw_hlyyskill",
  attached_equip = "sw_hlyy",
  events = { fk.CardEffectCancelledOut },
  can_trigger = function(self, event, target, player, data)
    return player:hasSkill(self) and data.from == player.id and data.card.trueName == "slash" and
        not player.room:getPlayerById(data.to).dead and
        table.find(player.player_cards[Player.Hand],
          function(id) return Fk:getCardById(id).trueName == "slash" end)
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    local tar = room:getPlayerById(data.to)
    local type
    room:broadcastPlaySound("./packages/standard_cards/audio/card/blade")
    room:setEmotion(player, "./packages/standard_cards/image/anim/blade")
    local card = room:askForDiscard(player, 1, 1, true, self.name, true, "slash", "#sw_hlyyskill-discard:" .. data.to)
    if Fk:getCardById(card[1]).name == "fire__slash" then
      type = fk.FireDamage
    elseif Fk:getCardById(card[1]).name == "thunder__slash" then
      type = fk.ThunderDamage
    elseif Fk:getCardById(card[1]).name == "ice__slash" then
      type = fk.IceDamage
    elseif Fk:getCardById(card[1]).name == "wd_poison__slash" then
      type = 555
    else
      type = fk.NormalDamage
    end
    if #card == 0 then return end
    if #card > 0 then
      room:damage({
        from = player,
        to = tar,
        damage = 1,
        damageType = type,
        skillName = self.name,
      })
    end
  end,
}
Fk:addSkill(sw_hlyyskill)
local sw_hlyy = fk.CreateWeapon {
  name = "sw_hlyy",
  suit = Card.Spade,
  number = 5,
  attack_range = 3,
  equip_skill = sw_hlyyskill,
}

extension:addCards({
  sw_hlyy,
})
Fk:loadTranslationTable {
  ["sw_hlyy"] = "煌龙焱月",
  [":sw_hlyy"] = "装备牌·武器<br /><b>攻击范围</b>：3<br /><b>武器技能</b>：当你使用的【杀】被【闪】抵消后，你可以弃置一张【杀】对该角色造成一点伤害，此伤害属性等于你弃置【杀】的属性。",
  ["#sw_hlyyskill"] = "煌龙焱月",
  ["#sw_hlyyskill-discard"] = "煌龙焱月：你可以弃置一张【杀】，对 %src 造成一点伤害，此伤害属性等于你弃置【杀】的属性",
}

local sw_xsnhskill = fk.CreateTriggerSkill {
  name = "#sw_xsnhskill",
  attached_equip = "sw_xsnh",
  events = { fk.DamageCaused },
  can_trigger = function(self, event, target, player, data)
    return target == player and player:hasSkill(self) and (not data.chain) and
        data.card and data.card.trueName == "slash" and
        table.find(player:getEquipments(Card.SubtypeWeapon), function(id)
          return Fk:getCardById(id).name == "sw_xsnh"
        end)
  end,
  on_cost = function(self, event, target, player, data)
    local room = player.room
    local tar = data.to
    if #tar:getCardIds { Player.Hand, Player.Equip, Player.Judge } > 0 then
      return room:askForSkillInvoke(player, self.name, nil, "#xuanshuang-discards:" .. tar.id)
    else
      return room:askForSkillInvoke(player, self.name, nil, "#xuanshuang-losemaxhp:" .. tar.id)
    end
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    local tar = data.to
    room:broadcastPlaySound("./packages/standard_cards/audio/card/ice_sword")
    room:setEmotion(player, "./packages/standard_cards/image/anim/ice_sword")
    if #tar:getCardIds { Player.Hand, Player.Equip, Player.Judge } > 0 then
      if not tar:isNude() then
        for i = 1, 2, 1 do
          if room:askForSkillInvoke(player, self.name, nil, "#xuanshuang-dis:" .. tar.id.."::"..i) then
            local card = room:askForCardChosen(player, tar, "hej", self.name)
            room:throwCard({ card }, self.name, tar, player)
            if tar:isNude() then
              break
            end
          end
        end
      end
    else
      if tar:isNude() then
        room:changeMaxHp(tar, -1)
        local weapon = table.find(player:getEquipments(Card.SubtypeWeapon),
          function(id) return Fk:getCardById(id).name == "sw_xsnh" end)
        if weapon then
          room:throwCard({ weapon }, self.name, player, player)
        end
      end
    end
    return true
  end
}
Fk:addSkill(sw_xsnhskill)

local sw_xsnh = fk.CreateWeapon {
  name = "sw_xsnh",
  suit = Card.Spade,
  number = 2,
  attack_range = 2,
  equip_skill = sw_xsnhskill,
}
extension:addCards({
  sw_xsnh,
})
Fk:loadTranslationTable {
  ["sw_xsnh"] = "玄霜凝魂",
  [":sw_xsnh"] = "装备牌·武器<br /><b>攻击范围</b>：2<br /><b>武器技能</b>：当你使用【杀】对目标角色造成伤害时，若你的武器区有此牌，你可以防止此伤害，然后你可以弃置其一张区域内的牌(可执行两次)，若其区域内没有牌，你弃置此武器牌，令其减去一点体力上限",
  ["#sw_xsnhskill"] = "玄霜凝魂",

  ["#xuanshuang-discards"] = "玄霜凝魂：你可以弃置%src至多两张牌",
  ["#xuanshuang-losemaxhp"] = "玄霜凝魂：你可以弃置玄霜凝魂，令%src减去一点体力上限",

  ["#xuanshuang-dis"] = "玄霜凝魂：请选择弃置%src一张牌(第 %arg 张，共计 2 张)",
}
local sw_zyskill = fk.CreateTriggerSkill {
  name = "#sw_zyskill",
  attached_equip = "sw_zy",
  events = { fk.DamageCaused },
  can_trigger = function(self, event, target, player, data)
    local ret = target == player and player:hasSkill(self) and
        data.card and data.card.trueName == "slash" and (not data.chain)
    if ret then
      ---@type ServerPlayer
      local to = data.to
      return table.find(to:getCardIds(Player.Equip), function(id)
        local card = Fk:getCardById(id)
        return card.sub_type == Card.SubtypeDefensiveRide or card.sub_type == Card.SubtypeOffensiveRide
      end)
    end
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    local to = data.to
    local ride_tab = table.filter(to:getCardIds(Player.Equip), function(id)
      local card = Fk:getCardById(id)
      return card.sub_type == Card.SubtypeDefensiveRide or card.sub_type == Card.SubtypeOffensiveRide
    end)
    if #ride_tab == 0 then return end
    local id = room:askForCardChosen(player, to, {
      card_data = {
        { "equip_horse", ride_tab }
      }
    }, self.name)
    room:throwCard({ id }, self.name, to, player)
    -- room:broadcastPlaySound("./packages/standard_cards/audio/card/kylin_bow")
    -- room:setEmotion(player, "./packages/standard_cards/image/anim/kylin_bow")
    -- room:throwCard({ id }, self.name, to, player)
    -- room:abortPlayerArea(to, Util.convertSubtypeAndEquipSlot(Fk:getCardById(id).sub_type))
  end
}
local sw_zyskill_tar = fk.CreateTriggerSkill {
  name = "#sw_zyskill_tar",
  anim_type = "offensive",
  events = { fk.TargetSpecified },
  can_trigger = function(self, event, target, player, data)
    local tar = player.room:getPlayerById(data.to)
    return target == player and player:hasSkill(self) and data.card.trueName == "slash" and
        tar:getEquipment(Card.SubtypeOffensiveRide) == nil and
        tar:getEquipment(Card.SubtypeDefensiveRide) == nil and player:usedSkillTimes(self.name, Player.HistoryPhase) == 0
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    local tar = player.room:getPlayerById(data.to)
    room:broadcastPlaySound("./packages/standard_cards/audio/card/kylin_bow")
    room:setEmotion(player, "./packages/standard_cards/image/anim/kylin_bow")
    local card = room:askForDiscard(tar, 1, 1, false, self.name, true, ".", "#sw_zyskill_tar-ask")
    if #card < 1 then
      data.disresponsiveList = data.disresponsiveList or {}
      for _, target in ipairs(player.room.alive_players) do
        table.insertIfNeed(data.disresponsiveList, target.id)
      end
    end
  end,
}
sw_zyskill:addRelatedSkill(sw_zyskill_tar)
Fk:addSkill(sw_zyskill)
local sw_zy = fk.CreateWeapon {
  name = "sw_zy",
  suit = Card.Heart,
  number = 5,
  attack_range = 5,
  equip_skill = sw_zyskill,
}

extension:addCards({
  sw_zy,
})
Fk:loadTranslationTable {
  ["sw_zy"] = "坠月",
  ["#sw_zyskill_tar"] = "坠月",
  ["#sw_zyskill_tar-ask"] = "坠月：弃置一手张牌，否则无法响应此【杀】",
  [":sw_zy"] = "装备牌·武器<br /><b>攻击范围</b>：５<br /><b>武器技能</b>：每阶段限一次，当你使用【杀】指定目标后，若其没有坐骑，其需弃置一手张牌，否则无法响应此【杀】；当你使用【杀】对其他角色造成伤害时，若其有坐骑，你可以弃置其装备区里的一张坐骑牌",
  ["#sw_zyskill"] = "坠月",
}

local sw_hhznskill = fk.CreateTargetModSkill {
  name = "#sw_hhznskill",
  attached_equip = "sw_hhzn",
  residue_func = function(self, player, skill, scope, card)
    if card and player:hasSkill(self.name) and card.trueName == "slash" and scope == Player.HistoryPhase then
      return 2
    end
  end
}
local sw_hhznskill_tar = fk.CreateTriggerSkill {
  name = "#sw_hhznskill_tar",
  attached_equip = "sw_hhzn",
  frequency = Skill.Compulsory,
  events = { fk.DamageCaused },
  can_trigger = function(self, event, target, player, data)
    return target == player and player:hasSkill(self) and data.card
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    local tar = data.to
    local mark = tar:getMark("@haihuang_silie-turn")
    if tar.hp > 3 then
      room:addPlayerMark(tar, "@haihuang_silie-turn", 1)
    end
    data.damage = data.damage + mark
  end,
}
local sw_hhznskill_sk = fk.CreateTriggerSkill {
  name = "#sw_hhznskill_sk",
  refresh_events = { fk.CardUsing },
  can_refresh = function(self, event, target, player, data)
    return target == player and player:hasSkill(self) and player.phase == Player.Play and
        data.card.trueName == "slash" and player:usedCardTimes("slash", Player.HistoryPhase) > 1
  end,
  on_refresh = function(self, event, target, player, data)
    local room = player.room
    room:broadcastPlaySound("./packages/standard_cards/audio/card/crossbow")
    room:setEmotion(player, "./packages/standard_cards/image/anim/crossbow")
    room:sendLog {
      type = "#InvokeSkill",
      from = player.id,
      arg = "crossbow",
    }
  end,
}
sw_hhznskill:addRelatedSkill(sw_hhznskill_sk)
sw_hhznskill:addRelatedSkill(sw_hhznskill_tar)
Fk:addSkill(sw_hhznskill)
local sw_hhzn = fk.CreateWeapon {
  name = "sw_hhzn",
  suit = Card.Club,
  number = 1,
  attack_range = 1,
  equip_skill = sw_hhznskill,
}
addzlCard(sw_hhzn)
Fk:loadTranslationTable {
  ["sw_hhzn"] = "海皇之怒",
  ["#sw_hhznskill"] = "海皇之怒",
  [":sw_hhzn"] = "装备牌·武器<br /><b>攻击范围</b>：1<br /><b>武器技能</b>：锁定技，出牌阶段，你可以额外使用两张【杀】；当你使用牌对体力值大于3的目标造成伤害时，你本回合对其造成的伤害+X(X为本回对其造成的伤害次数)",
  ["@haihuang_silie-turn"] = "撕裂",
  ["#sw_hhznskill_tar"] = "撕裂",
  ["#sw_hhznskill_sk"] = "海皇之怒",
}
local swfjj_skill = fk.CreateTriggerSkill {
  name = "#swfjj_skill",
  attached_equip = "sw_swfjj",
  -- anim_type = "offensive",
  priority = 0,
  events = { fk.TargetSpecified },
  can_trigger = function(self, event, target, player, data)
    return target == player and player:hasSkill(self.name) and data.card and data.card.trueName == "slash" and
        player:usedSkillTimes(self.name, Player.HistoryPhase) == 0
  end,
  on_cost = Util.TrueFunc,
  on_use = function(self, event, target, player, data)
    local room = player.room
    local to = room:getPlayerById(data.to)
    if room:askForSkillInvoke(player, self.name, nil, "神威：你可以失去一点体力，令其失去一点体力") then
      -- local pattern
      -- if player:getEquipment(Card.SubtypeWeapon) then
      --   pattern = ".|.|.|.|.|.|^" .. tostring(player:getEquipment(Card.SubtypeWeapon))
      -- else
      --   pattern = "."
      -- end
      -- local card = room:askForDiscard(player, 1, 1, true, self.name, true, pattern, "#swfjj_skill-ask")
      -- if #card == 0 then return end
      -- if #card > 0 then
      room:notifySkillInvoked(player, self.name, "drawcard")
      room:loseHp(player, 1, self.name)
      room:loseHp(to, 1, self.name)
    end
  end,
}
Fk:addSkill(swfjj_skill)

local sw_swfjj = fk.CreateWeapon {
  name = "sw_swfjj",
  suit = Card.Spade,
  number = 9,
  attack_range = 2,
  equip_skill = swfjj_skill,
}

extension:addCards({
  sw_swfjj,
})
Fk:loadTranslationTable {
  ["sw_swfjj"] = "神威飞将剑",
  ["#swfjj_skill-ask"] = "神威:你可以弃置一张牌，令其失去一点体力",
  [":sw_swfjj"] = "装备牌·武器<br /><b>攻击范围</b>：２<br /><b>武器技能</b>：每阶段限一次，当你使用【杀】指定目标后，你可以失去一点体力，令其失去一点体力。",
  ["#swfjj_skill"] = "神威飞将剑",
}

--蛇腹剑
local sfj_skill = fk.CreateTriggerSkill {
  name = "#sfj_skill",
  attached_equip = "sw_sfj",
  events = { fk.CardUsing },
  can_trigger = function(self, event, target, player, data)
    if event == fk.CardUsing and target == player and player:hasSkill(self.name) and player:usedSkillTimes(self.name, Player.HistoryPhase) == 0 then
      return data.card:isCommonTrick() and data.tos and #data.tos == 1
    end
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    if event == fk.CardUsing then
      local targets = table.map(room.alive_players, function(p) return p.id end)
      if #targets == 0 then return false end
      local tos = room:askForChoosePlayers(player, targets, 1, 1, "#shefujian-choose", self.name, true)
      if #tos > 0 then
        table.forEach(tos, function(id)
          table.insert(data.tos, { id })
        end)
      end
    end
  end
}
Fk:addSkill(sfj_skill)

local sw_sfj = fk.CreateWeapon {
  name = "sw_sfj",
  suit = Card.Heart,
  number = 9,
  attack_range = 3,
  equip_skill = sfj_skill,
}

extension:addCards({
  sw_sfj,
})
Fk:loadTranslationTable {
  ["sw_sfj"] = "蛇腹剑",
  [":sw_sfj"] = "武器牌·武器<br /><b>攻击范围</b>：3<br /><b>武器技能</b>：每阶段限一次，当你使用仅指定一个目标的普通锦囊牌时，你可以额外选择任意一名角色成为目标。",
  ["#sfj_skill"] = "蛇腹剑",
  ["#shefujian-choose"] = "蛇腹剑：是否为此牌添加一个目标"
}


local hlzjg_skill = fk.CreateTriggerSkill {
  name = "#hlzjg_skill",
  attached_equip = "sw_hlzjg",
  -- anim_type = "offensive",
  priority = 0,
  frequency = Skill.Compulsory,
  events = { fk.EventPhaseStart },
  can_trigger = function(self, event, target, player, data)
    return target == player and player:hasSkill(self.name) and player.phase == Player.Start
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    local to = room:askForChoosePlayers(player, table.map(player.room.alive_players, function(p)
      return #p:getCardIds { Player.Equip, Player.Judge, Player.Hand } > 0 and p.id
    end), 1, 1, "#sw_hlzjg-choose", self.name, true)
    if #to > 0 then
      local id = room:askForCardChosen(player, room:getPlayerById(to[1]), "hej", self.name)
      room:throwCard({ id }, self.name, room:getPlayerById(to[1]), player)
    end
  end
}

Fk:addSkill(hlzjg_skill)
local sw_hlzjg = fk.CreateTreasure {
  name = "sw_hlzjg",
  suit = Card.Heart,
  number = 6,
  equip_skill = hlzjg_skill,
}
extension:addCard(sw_hlzjg)

Fk:loadTranslationTable {
  ["sw_hlzjg"] = "红莲紫金冠",
  ["#hlzjg_skill"] = "红莲冠",
  [":sw_hlzjg"] = "装备牌·宝物<br /><b>宝物技能</b>：准备阶段，你可以弃置一名角色区域内的一张牌。",
  ["#sw_hlzjg"] = "红莲紫金冠",
  ["#sw_hlzjg-choose"] = "红莲紫金冠：请选择一名角色，弃置其区域内的一张牌",
}

--血影刀
local xyd_skill = fk.CreateTriggerSkill {
  name = "#xyd_skill",
  attached_equip = "sw_xyd",
  events = { fk.Damage, fk.Damaged },
  can_trigger = function(self, event, target, player, data)
    return player == target and player:hasSkill(self.name) and
        table.find(player:getEquipments(Card.SubtypeWeapon), function(id)
          return Fk:getCardById(id).name == "sw_xyd"
        end)
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    if player:isWounded() then
      room:recover({
        who = player,
        num = 1,
        recoverBy = player,
        skillName = self.name
      })
    end
    local card = room:getCardsFromPileByRule(".|.|.|.", 1, "discardPile")
    if #card > 0 then
      room:moveCards({
        ids = card,
        to = player.id,
        toArea = Card.PlayerHand,
        moveReason = fk.ReasonJustMove,
        proposer = player.id,
        skillName = self.name,
      })
    end
    local toThrow = table.find(
      player:getEquipments(Card.SubtypeWeapon), function(id) return Fk:getCardById(id).name == "sw_xyd" end)
    if toThrow then
      room:throwCard({ toThrow }, self.name, player, player)
    end
    room:notifySkillInvoked(player, self.name, "defensive")
  end,
}
Fk:addSkill(xyd_skill)
local sw_xyd = fk.CreateWeapon {
  name = "sw_xyd",
  suit = Card.Club,
  number = 1,
  attack_range = 2,
  equip_skill = xyd_skill,
}
extension:addCards({
  sw_xyd,
})
Fk:loadTranslationTable {
  ["sw_xyd"] = "血影刀",
  [":sw_xyd"] = "武器牌·武器<br /><b>攻击范围</b>：2<br /><b>武器技能</b>：当你受到或造成伤害后，若你的武器区有此牌，你可以回复一点体力，从弃牌堆获得一张牌，然后弃置此牌。",
  ["#xyd_skill_tarmod"] = "血影刀",
  ["#xyd_skill"] = "血影刀",
}

--涯角枪
local yjq_skill = fk.CreateTriggerSkill {
  name = "#yjq_skill",
  attached_equip = "sw_yjq",
  -- anim_type = "offensive",
  events = { fk.CardUseFinished },
  can_trigger = function(self, event, target, player, data)
    -- dbg()
    return player == target and target:hasSkill(self.name) and data.card and target.phase == Player.NotActive and
        data.card.color == Card.Black and player:usedSkillTimes(self.name, Player.HistoryTurn) == 0
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    room:obtainCard(target, data.card.id, true, fk.ReasonGive)
    room:notifySkillInvoked(player, self.name, "defensive")
  end,
}
Fk:addSkill(yjq_skill)

local sw_yjq = fk.CreateWeapon {
  name = "sw_yjq",
  suit = Card.Diamond,
  number = 5,
  attack_range = 3,
  equip_skill = yjq_skill,
}
extension:addCards({
  sw_yjq,
})
Fk:loadTranslationTable {
  ["sw_yjq"] = "涯角枪",
  [":sw_yjq"] = "武器牌·武器<br /><b>攻击范围</b>：3<br /><b>武器技能</b>：每回合限一次，当你于回合外使用黑色牌后，你收回此牌",
  ["#yjq_skill"] = "涯角枪",
}

--女装
local nz_nvzhuang_skill = fk.CreateTriggerSkill {
  name = "#nz_nvzhuang_skill",
  attached_equip = "nz_nvzhuang",
}
Fk:addSkill(nz_nvzhuang_skill)

local nz_nvzhuang = fk.CreateArmor {
  name = "nz_nvzhuang",
  suit = Card.Diamond,
  number = 1,
  equip_skill = nz_nvzhuang_skill,
  on_install = function(self, room, player)
    -- dbg()
    if player:isAlive() and self.equip_skill:isEffectable(player) and player.gender == General.Male then
      room:askForDiscard(player, 1, 1, true, self.name, false, "^nz_nvzhuang", "#nz_nvzhuang-discard")
    end
  end,
  on_uninstall = function(self, room, player)
    -- dbg()
    if player:isAlive() and self.equip_skill:isEffectable(player) and player.gender == General.Male then
      room:askForDiscard(player, 1, 1, true, self.name, false, nil, "#nz_nvzhuang-discard")
    end
  end,
}
addzlCard(nz_nvzhuang)
Fk:loadTranslationTable {
  ["nz_nvzhuang"] = "女装",
  [":nz_nvzhuang"] = "装备牌·防具<br /><b>防具技能</b>：该装备进入或离开一名角色的装备区时,若其性别为男，其需弃置一张牌",
  ["#nz_nvzhuang_skill"] = "女装",
  ["#nz_nvzhuang-discard"] = "女装：你须弃置一张【女装】以外的牌",
}

--驽马
local nm_numa_skill = fk.CreateTriggerSkill {
  name = "#nm_numa_skill",
  attached_equip = "nm_numa",
}
Fk:addSkill(nm_numa_skill)

local nm_numa = fk.CreateOffensiveRide {
  name = "nm_numa",
  suit = Card.Heart,
  number = 5,
  equip_skill = nm_numa_skill,
  on_install = function(self, room, player)
    -- dbg()
    if player:isAlive() and self.equip_skill:isEffectable(player) then
      -- player:throwAllCards("e")
      local equips = {}
      for key, eid in pairs(player.player_cards[Player.Equip]) do
        if Fk:getCardById(eid).sub_type ~= Card.SubtypeOffensiveRide then
          table.insert(equips, eid)
        end
      end
      room:throwCard(equips, self.name, player, player)
    end
  end,
}
addzlCard(nm_numa)
Fk:loadTranslationTable {
  ["nm_numa"] = "驽马",
  [":nm_numa"] = "装备牌·进攻马<br /><b>技能</b>：该装备进入装备区后，弃置其他所有装备，该装备不提供进攻距离。",
  ["#nm_numa_skill"] = "驽马",
}

--引蜂甲
local yfj_yinfengjia_skill = fk.CreateTriggerSkill {
  name = "#yfj_yinfengjia_skill",
  attached_equip = "yfj_yinfengjia",
  events = { fk.DamageCaused },
  can_trigger = function(self, event, target, player, data)
    if player:hasSkill(self.name) and data.card and data.card.type == Card.TypeTrick and data.to == player then
      return true
    end
  end,
  on_cost = function(self, event, target, player, data)
    return true
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    data.damage = data.damage + 1
    room:notifySkillInvoked(player, self.name, "offensive")
  end,
}
Fk:addSkill(yfj_yinfengjia_skill)

local yfj_yinfengjia = fk.CreateArmor {
  name = "yfj_yinfengjia",
  suit = Card.Diamond,
  number = 9,
  equip_skill = yfj_yinfengjia_skill,
}
addzlCard(yfj_yinfengjia)
Fk:loadTranslationTable {
  ["yfj_yinfengjia"] = "引蜂甲",
  [":yfj_yinfengjia"] = "装备牌·防具<br /><b>防具技能</b>：锁定技，你受到来自锦囊牌的伤害+1",
  ["#yfj_yinfengjia_skill"] = "引蜂甲",
}

--锦盒
local jh_jinhe_skill = fk.CreateTriggerSkill {
  name = "#jh_jinhe_skill",
  attached_equip = "jh_jinhe",
}
Fk:addSkill(jh_jinhe_skill)

local sw_jh_skill = fk.CreateActiveSkill {
  name = "sw_jh_skill&",
  prompt = "#sw_jh_skill-active",
  card_num = 0,
  target_num = 0,
  can_use = function(self, player)
    return player:usedSkillTimes(self.name, Player.HistoryPhase) == 0
  end,
  card_filter = Util.FalseFunc,
  on_use = function(self, room, effect)
    local player = room:getPlayerById(effect.from)
    room:fillAG(player, player:getPile("#zl_jinhe"))
    local ids = room:askForAG(player, player:getPile("#zl_jinhe"), false, self.name)
    room:closeAG(player)
    local suit = Fk:getCardById(ids).suit
    local discards = table.filter(player:getCardIds(Player.Hand), function(id)
      return Fk:getCardById(id).suit == suit and not player:prohibitDiscard(Fk:getCardById(id))
    end)
    if #discards > 0 then
      room:throwCard(discards, self.name, player, player)
    end
    if #player:getPile("#zl_jinhe") ~= 0 then
      room:moveCards({
        from = player.id,
        ids = player:getPile("#zl_jinhe"),
        toArea = Card.DiscardPile,
        moveReason = fk.ReasonPutIntoDiscardPile,
        skillName = self.name,
      })
    end
    if player:getEquipment(Card.SubtypeTreasure) and Fk:getCardById(player:getEquipment(Card.SubtypeTreasure)).name == "jh_jinhe" then
      room:throwCard({ player:getEquipment(Card.SubtypeTreasure) }, self.name, player, player)
    end
  end,
}
Fk:addSkill(sw_jh_skill)
Fk:loadTranslationTable {
  ["sw_jh_skill&"] = "锦盒",
  [":sw_jh_skill&"] = "出牌阶段，你可以查看锦盒内的牌，选择其中一张，弃置所有与此牌花色相同的手牌",
  ["#sw_jh_skill-active"] = "开盒？",
  ["zl_jinhe"] = "锦",
}
local jh_jinhe = fk.CreateTreasure {
  name = "jh_jinhe",
  suit = Card.Club,
  number = 10,
  equip_skill = jh_jinhe_skill,
  on_install = function(self, room, player)
    if player:isAlive() and self.equip_skill:isEffectable(player) then
      player:addToPile("#zl_jinhe", room:getNCards(2), false, self.name, nil, {}) --不可见的置入
      room:handleAddLoseSkills(player, "sw_jh_skill&", nil, true, false)
    end
  end,
  on_uninstall = function(self, room, player)
    if player:isAlive() and self.equip_skill:isEffectable(player) then
      if #player:getPile("#zl_jinhe") ~= 0 then
        room:moveCards({
          from = player.id,
          ids = player:getPile("#zl_jinhe"),
          toArea = Card.DiscardPile,
          moveReason = fk.ReasonPutIntoDiscardPile,
          skillName = self.name,
          moveVisible = true,
        })
      end
    end
    if player:hasSkill("sw_jh_skill&", true) then
      room:handleAddLoseSkills(player, "-sw_jh_skill&", nil, true, false)
    end
  end,
}
local jh_trigger = fk.CreateTriggerSkill {
  name = "jh_trigger",
  mute = true,
  global = true,
  priority = 0,
  events = { fk.AfterCardsMove },
  can_trigger = function(self, event, target, player, data)
    for _, move in ipairs(data) do
      if move.toArea == Card.DiscardPile then
        for _, info in ipairs(move.moveInfo) do
          if Fk:getCardById(info.cardId).name == "jh_jinhe" and
              move.skillName ~= "sw_jh_skill&" and info.fromArea == Card.PlayerEquip then
            return true
          end
        end
      end
    end
  end,
  on_cost = function(self, event, target, player, data)
    return true
  end,
  on_use = function(self, event, target, player, data)
    for _, move in ipairs(data) do
      if move.toArea == Card.DiscardPile then
        for _, info in ipairs(move.moveInfo) do
          if Fk:getCardById(info.cardId).name == "jh_jinhe" and
              move.skillName ~= "sw_jh_skill&" and info.fromArea == Card.PlayerEquip then
            local room = player.room
            if room:getCardArea(info.cardId) == Card.DiscardPile then
              room:getPlayerById(move.from):throwAllCards("h")
              room:handleAddLoseSkills(room:getPlayerById(move.from), "-sw_jh_skill&", nil, true, false)
              if #room:getPlayerById(move.from):getPile("#zl_jinhe") ~= 0 then
                room:moveCards({
                  from = room:getPlayerById(move.from).id,
                  ids = room:getPlayerById(move.from):getPile("#zl_jinhe"),
                  toArea = Card.DiscardPile,
                  moveReason = fk.ReasonPutIntoDiscardPile,
                  skillName = self.name,
                })
              end
              return
            end
          end
        end
      end
    end
  end,
}
Fk:addSkill(jh_trigger)
addzlCard(jh_jinhe)
Fk:loadTranslationTable {
  ["jh_jinhe"] = "锦盒",
  ["jh_trigger"] = "锦盒",
  [":jh_jinhe"] = "装备牌·宝物<br /><b>技能</b>：此牌进入目标装备区后，将两张牌置于其武将牌上，此牌离开装备区后，弃置武将牌上的锦盒牌；持有者出牌阶段可以选择其中一张，弃置与此牌花色相同的所有手牌，然后弃置锦盒，若锦盒不因此法从装备区进入弃牌堆，持有者弃置所有手牌。",
  ["#jh_jinhe_skill"] = "锦盒",
}

--折戟
local zj_zheji_skill = fk.CreateTriggerSkill {
  name = "#zj_zheji_skill",
  attached_equip = "zj_zheji",
}
Fk:addSkill(zj_zheji_skill)

local zj_zheji = fk.CreateWeapon {
  name = "zj_zheji",
  suit = Card.Club,
  number = 4,
  attack_range = 0,
  equip_skill = zj_zheji_skill,
}
addzlCard(zj_zheji)
Fk:loadTranslationTable {
  ["zj_zheji"] = "折戟",
  [":zj_zheji"] = "武器牌·武器<br /><b>武器技能</b>：这似乎是一把损坏的武器...",
  ["#zj_zheji_skill"] = "折戟",
}

--幽魂摄火令
local yh_shehuo_skill = fk.CreateTriggerSkill {
  name = "#yh_shehuo_skill",
  attached_equip = "sw_yhshl",
  events = { fk.DamageInflicted },
  can_trigger = function(self, event, target, player, data)
    return target == player and data.from and data.form ~= player and player:hasSkill(self.name) and data.damage > 1 and
        table.find(player:getEquipments(Card.SubtypeTreasure), function(id)
          return Fk:getCardById(id).name == "sw_yhshl"
        end)
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    data.damage = 0
    room:loseHp(player, 1, self.name)
    local card = Fk:getCardById(player:getEquipment(Card.SubtypeTreasure), true)
    room:sendLog {
      type = "#destructDerivedCard",
      arg = card:toLogString(),
    }
    room:notifySkillInvoked(player, self.name, "defensive")
    if player.dead or data.from.dead then return false end
    if #data.from:getCardIds("he") > 0 then
      local cards = room:askForCard(data.from, 1, 1, true, self.name, false, ".", "youhunling-chos::" .. player.id)
      local dummy = Fk:cloneCard("snatch")
      dummy:addSubcards(cards)
      room:obtainCard(player, dummy, false, fk.ReasonPrey)
    end
    room:moveCardTo(card, Card.Void, nil, fk.ReasonJustMove, "", "", true)
  end,
}
Fk:addSkill(yh_shehuo_skill)
local sw_yhshl = fk.CreateTreasure {
  name = "sw_yhshl",
  suit = Card.Heart,
  number = 9,
  equip_skill = yh_shehuo_skill,
}

extension:addCards({
  sw_yhshl,
})

Fk:loadTranslationTable {
  ["sw_yhshl"] = "幽魂摄火令",
  [":sw_yhshl"] = "装备牌·宝物<br /><b>技能</b>：效果：当你受到其他角色造成的大于1点的伤害时，你可以防止此伤害，失去一点体力并销毁该装备，若来源有牌，令伤害来源交给你一张牌",
  ["youhunling-chos"] = "交给%dest一张牌",
  ["#yh_shehuo_skill"] = "幽魂摄火令",
}

--七星点钢枪
local qxdg_qixingdiangang_skill = fk.CreateTriggerSkill {
  name = "#qxdg_qixingdiangang_skill",
  attached_equip = "sw_qxdgq",
  -- anim_type = "offensive",
  events = { fk.TargetSpecified },
  can_trigger = function(self, event, target, player, data)
    local tar = player.room:getPlayerById(data.to)
    return player:hasSkill(self) and target == player and data.card.trueName == "slash" and
        tar:getHandcardNum() > player:getHandcardNum() and
        not tar:isKongcheng() and player:usedCardTimes("slash", Player.HistoryTurn) == 1
  end,
  on_cost = function(self, event, target, player, data)
    return player.room:askForSkillInvoke(player, self.name, nil, "#qixing-ask:" .. player.room:getPlayerById(data.to).id)
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    local tar = room:getPlayerById(data.to)
    local id = table.random(tar:getCardIds { Player.Hand })
    room:notifySkillInvoked(player, self.name, "switch")
    room:throwCard({ id }, self.name, tar, player)
  end,
}
Fk:addSkill(qxdg_qixingdiangang_skill)

local sw_qxdgq = fk.CreateWeapon {
  name = "sw_qxdgq",
  suit = Card.Spade,
  number = 9,
  attack_range = 4,
  equip_skill = qxdg_qixingdiangang_skill,
}
extension:addCards({
  sw_qxdgq,
})
Fk:loadTranslationTable {
  ["sw_qxdgq"] = "七星点钢枪",
  [":sw_qxdgq"] = "武器牌·武器<br /><b>攻击范围</b>：4<br /><b>武器技能</b>：当你每回合首次使用【杀】指定手牌数大于你的目标后，若其有手牌，你随机弃置其一张手牌。",
  ["#qxdg_qixingdiangang_skill"] = "七星点钢枪",

  ["#qixing-ask"] = "七星点钢枪：是否令%src随机弃置一张手牌",
}

--红棉百花袍
local hmbhp_skill = fk.CreateTriggerSkill {
  name = "#hmbhp_skill",
  attached_equip = "sw_hmbhp",
  events = { fk.DamageInflicted },
  can_trigger = function(self, event, target, player, data)
    -- dbg()
    if player == target and player:hasSkill(self.name) then
      return true
    end
  end,
  on_cost = function(self, event, target, player, data)
    return true
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    if data.damageType == 1 then
      data.damage = data.damage + 1
    else
      data.damage = 0
    end
    room:notifySkillInvoked(target, self.name, "control")
  end,
}
Fk:addSkill(hmbhp_skill)

local sw_hmbhp = fk.CreateArmor {
  name = "sw_hmbhp",
  suit = Card.Heart,
  number = 1,
  equip_skill = hmbhp_skill,
}

addzlCard(sw_hmbhp)
Fk:loadTranslationTable {
  ["sw_hmbhp"] = "红棉百花袍",
  [":sw_hmbhp"] = "装备牌·防具<br /><b>防具技能</b>：防止你受到的属性伤害，你受到的普通伤害+1",
  ["#hmbhp_skill"] = "红棉百花袍",
}

--炼狱修罗戟
local wsxlj_skill = fk.CreateTriggerSkill {
  name = "#wsxlj_skill",
  attached_equip = "sw_wsxlj",
}
Fk:addSkill(wsxlj_skill)

local sw_wsxlj = fk.CreateWeapon {
  name = "sw_wsxlj",
  suit = Card.Diamond,
  number = 12,
  attack_range = 4,
  equip_skill = wsxlj_skill,
  on_install = function(self, room, player)
    if player:isAlive() and self.equip_skill:isEffectable(player) then
      room:changeMaxHp(player, -1)
      local chc = { "pf_wushuang", "pf_shenji" }
      local chs = room:askForChoice(player, chc, self.name)
      room:setPlayerMark(player, "wsxlj", chs)
      room:handleAddLoseSkills(player, chs, nil, true, false)
    end
  end,
  on_uninstall = function(self, room, player)
    if player:isAlive() and self.equip_skill:isEffectable(player) and player:getMark("wsxlj") ~= 0 then
      room:changeMaxHp(player, 1)
      room:handleAddLoseSkills(player, "-" .. player:getMark("wsxlj"), nil, true, false)
      room:setPlayerMark(player, "wsxlj", 0)
    end
  end,
}

extension:addCards({
  sw_wsxlj,
})
Fk:loadTranslationTable {
  ["sw_wsxlj"] = "无双修罗戟",
  [":sw_wsxlj"] = "武器牌·武器<br /><b>攻击范围</b>：4<br /><b>武器技能</b>：该装备进入装备区时，你减去一点体力上限选择获得〖无双〗/〖修罗〗；通过常规方式离开装备区后，你增加一点体力上限，失去因此获得的技能。",
  ["#wsxlj_skill"] = "无双修罗戟",
  ["#sw_wsxlj-tip"] = "无双修罗戟：是否移除该武器，获得无双",
}

--锚
local m_skill = fk.CreateTriggerSkill {
  name = "#m_skill",
  attached_equip = "sw_mao",
  events = { fk.EventPhaseStart },
  can_trigger = function(self, event, target, player, data)
    return player == target and player:hasSkill(self.name) and player.phase == Player.Play and
        table.find(player:getEquipments(Card.SubtypeWeapon), function(id)
          return Fk:getCardById(id).name == "sw_mao"
        end)
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    player.room:notifySkillInvoked(player, self.name, "offensive")
    local to = room:askForChoosePlayers(player, table.map(player.room.alive_players, function(p)
      return p.id
    end), 1, 1, "#m_skill-ips", self.name, true)
    if #to > 0 then
      room:changeMaxHp(player, -1)
      room:swapSeat(player, room:getPlayerById(to[1]))
    end
    if player:getEquipment(Card.SubtypeWeapon) and Fk:getCardById(player:getEquipment(Card.SubtypeWeapon)).name == "sw_mao" then
      room:throwCard({ player:getEquipment(Card.SubtypeWeapon) }, self.name, player, player)
      player:drawCards(1, self.name)
    end
  end,
}
Fk:addSkill(m_skill)

local sw_mao = fk.CreateWeapon {
  name = "sw_mao",
  suit = Card.Spade,
  number = 7,
  attack_range = 1,
  equip_skill = m_skill,
}
extension:addCards({
  sw_mao,
})
Fk:loadTranslationTable {
  ["sw_mao"] = "锚",
  [":sw_mao"] = "武器牌·武器<br /><b>攻击范围</b>：1<br /><b>起锚</b>：出牌阶段开始时，若你的武器区有此牌，你可以选择一名存活的其他角色，失去一点体力上限，与其交换座位，然后重铸该武器",
  ["#m_skill-ips"] = "选择一名其他角色，与其交换位置",
  ["#m_skill"] = "锚",
}


--玲珑狮蛮带
local sw_llsmd_skill = fk.CreateTriggerSkill {
  name = "#sw_llsmd_skill",
  attached_equip = "sw_llsmd",
  events = { fk.TargetConfirmed },
  can_trigger = function(self, event, target, player, data)
    if target == player and player:hasSkill(self.name) and data.from ~= player.id and player:usedSkillTimes(self.name, Player.HistoryRound) < 1 then
      return (data.card.type == Card.TypeBasic or data.card.type == Card.TypeTrick)
    end
  end,
  on_cost = function(self, event, target, player, data)
    local room = target.room
    if room:askForSkillInvoke(target, self.name, data) then
      return true
    end
  end,
  on_use = function(self, event, target, player, data)
    player.room:notifySkillInvoked(player, self.name, "offensive")
    AimGroup:cancelTarget(data, player.id)
    player:drawCards(1, self.name)
  end,
}
Fk:addSkill(sw_llsmd_skill)

local sw_llsmd = fk.CreateArmor {
  name = "sw_llsmd",
  suit = Card.Club,
  number = 1,
  equip_skill = sw_llsmd_skill,
}

extension:addCards({
  sw_llsmd,
})
Fk:loadTranslationTable {
  ["sw_llsmd"] = "玲珑狮蛮带",
  [":sw_llsmd"] = "装备牌·防具<br /><b>防具技能</b>：每轮限一次，当你成为其他角色使用牌的目标时，你可以摸一张牌，然后令此牌对你无效",
  ["#sw_llsmd_skill"] = "玲珑狮蛮带",
}
local tujiSkill = fk.CreateActiveSkill {
  name = "tuji_Skill",
  prompt = "#tuji_Skill",
  min_target_num = 1,
  max_target_num = 2,
  mod_target_filter = function(self, to_select, selected, user, card)
    return user ~= to_select
  end,
  target_filter = function(self, to_select, selected, _, card)
    if #selected < self:getMaxTargetNum(Self, card) and to_select ~= Self.id and
        Self:inMyAttackRange(Fk:currentRoom():getPlayerById(to_select)) then
      -- local player = Fk:currentRoom():getPlayerById(to_select)
      return true
    end
  end,
  on_effect = function(self, room, effect)
    local target = room:getPlayerById(effect.to)
    local player = room:getPlayerById(effect.from)
    if target.dead then return end
    local ids = room:askForDiscard(player, 1, 1, true, self.name, true, ".|.|.|.|.|trick,equip", "#tuji-discard::" ..
      target.id)
    if #ids > 0 then
      room:damage({
        from = player,
        to = target,
        card = effect.card,
        damage = 1,
        damageType = fk.NormalDamage,
        skillName = self.name
      })
    else
      room:loseHp(player, 1, self.name)
    end
  end
}
Fk:addSkill(tujiSkill)

local tuji = fk.CreateTrickCard {
  name = "tuji",
  skill = tujiSkill,
  is_damage_card = true,
}

extension:addCards({
  tuji:clone(Card.Heart, 6),
  tuji:clone(Card.Diamond, 6),
})
Fk:loadTranslationTable {
  ["tuji"] = "突击",
  ["tuji_Skill"] = "突击",
  ["#tuji_Skill"] = "选择攻击范围内的至多两名其他角色，弃置一张非基本牌，<br>对其造成一点伤害，若你没有弃牌，你失去一点体力",
  ["#tuji-discard"] = "弃置一张锦囊牌对 %dest 造成一点伤害，否则失去一点体力",
  [":tuji"] = "锦囊牌<br /><b>时机</b>：出牌阶段<br /><b>目标</b>：攻击范围内至多两名其他角色<br /><b>效果</b>：弃置一张非基本牌，对其造成一点伤害，若你没有弃牌，你失去一点体力",
}

--兵临城下
local binglinchengxia_Skill = fk.CreateActiveSkill {
  name = "binglinchengxia_skill",
  prompt = "#binglinchengxia_skill",
  mod_target_filter = function(self, to_select, selected, user, card, distance_limited)
    return user ~= to_select
  end,
  target_filter = function(self, to_select, selected, _, card)
    return #selected == 0 and self:modTargetFilter(to_select, selected, Self.id, card, true)
  end,
  target_num = 1,
  on_effect = function(self, room, effect)
    local to = room:getPlayerById(effect.to)
    local judge = {
      who = to,
      reason = "binglinchengxia",
      pattern = ".|.|^diamond",
    }
    room:judge(judge)
    local result = judge.card
    if result.suit ~= Card.Diamond then
      local chc = { "losehp" }
      if #to.player_cards[Player.Equip] > 0 then
        table.insert(chc, "throw_equips")
      end
      local chs = room:askForChoice(to, chc, self.name)
      if chs == "throw_equips" then
        to:throwAllCards("e")
      else
        -- room:loseHp(to,1,self.name)
        room:damage({
          from = nil,
          to = to,
          -- card = effect.card,
          damage = 1,
          damageType = fk.FireDamage,
          skillName = self.name
        })
      end
    else
      if effect.card:isVirtual() then
        to:addVirtualEquip(effect.card)
      end
      -- room:moveCards{
      -- ids = room:getSubcardsByRule(effect.card, { Card.Processing }),
      -- to = effect.to,
      -- toArea = Card.PlayerJudge,
      -- moveReason = fk.ReasonPut }
    end
    self:onNullified(room, effect)
  end,
  on_nullified = function(self, room, effect)
    room:moveCards {
      ids = room:getSubcardsByRule(effect.card, { Card.Processing }),
      toArea = Card.DiscardPile,
      moveReason = fk.ReasonUse
    }
  end,
}
local binglinchengxia = fk.CreateDelayedTrickCard {
  name = "binglinchengxia",
  suit = Card.Diamond,
  number = 1,
  skill = binglinchengxia_Skill,
}

extension:addCards({
  binglinchengxia,
  binglinchengxia:clone(Card.Spade, 1),
})

Fk:loadTranslationTable {
  ["binglinchengxia"] = "兵临城下",
  ["binglinchengxia_skill"] = "兵临城下",
  ["#binglinchengxia_skill"] = "将此牌置入目标的判定区，其判定阶段进行判定：<br>若不为♦，其选择弃置所有装备或受到一点火属性伤害",
  ["throw_equips"] = "失去所有装备",
  ["losehp"] = "受到1点火属性伤害",
  [":binglinchengxia"] = "延时锦囊牌<br /><b>时机</b>：出牌阶段<br /><b>目标</b>：一名其他角色<br /><b>效果</b>：将此牌置入目标的判定区，其判定阶段进行判定，若不为方片，其选择弃置所有装备或受到一点火属性伤害(无装备直接受伤)，然后将此牌置入弃牌堆",
}

--截辎断粮
local jieziduanliang_Skill = fk.CreateActiveSkill {
  name = "jieziduanliang_skill",
  prompt = "#jieziduanliang_skill",
  distance_limit = 1,
  mod_target_filter = function(self, to_select, _, user, card, distance_limited)
    local player = Fk:currentRoom():getPlayerById(to_select)
    local from = Fk:currentRoom():getPlayerById(user)
    return from ~= player and not (distance_limited and not self:withinDistanceLimit(from, false, card, player))
  end,
  target_filter = function(self, to_select, selected, _, card)
    return #selected == 0 and self:modTargetFilter(to_select, selected, Self.id, card, true)
  end,
  target_num = 1,
  on_effect = function(self, room, effect)
    local to = room:getPlayerById(effect.to)
    local player = to
    local judge = {
      who = to,
      reason = "jieziduanliang",
      pattern = ".|2~12|.",
    }
    room:judge(judge)
    local result = judge.card
    if result.number == 1 or result.number == 13 then
      self:onNullified(room, effect)
      return
    end
    if result.color == Card.Red then
      room:loseHp(player, 1, self.name)
    else
      if not player:isAllNude() then
        room:askForDiscard(player, 2, 2, true, self.name, false)
      end
    end
    self:onNullified(room, effect)
  end,
  on_nullified = function(self, room, effect)
    room:moveCards {
      ids = room:getSubcardsByRule(effect.card, { Card.Processing }),
      toArea = Card.DiscardPile,
      moveReason = fk.ReasonUse
    }
  end,
}
local jieziduanliang = fk.CreateDelayedTrickCard {
  name = "jieziduanliang",
  suit = Card.Spade,
  number = 9,
  skill = jieziduanliang_Skill,
}

extension:addCards({
  jieziduanliang,
  jieziduanliang:clone(Card.Diamond, 7),
})

Fk:loadTranslationTable {
  ["jieziduanliang"] = "截辎断粮",
  ["jieziduanliang_skill"] = "截辎断粮",
  ["#jieziduanliang_skill"] = "将此牌置入距离为1的目标判定区，其判定阶段判定：<br>若为黑色，其弃置两张牌，若为红色，其失去一点体力，<br>若为A或K，此牌失效",
  [":jieziduanliang"] = "延时锦囊牌<br /><b>时机</b>：出牌阶段<br /><b>目标</b>：距离1以内的一名其他角色<br /><b>效果</b>：将此牌置入目标的判定区，其判定阶段进行判定，若为黑色，其弃置两张牌，若为红色，其失去一点体力，若判定点数为A或K，则失效，然后将此牌置入弃牌堆",
}

local s_niepanSkill = fk.CreateActiveSkill {
  name = "s_niepan_skill",
  prompt = "#s_niepan_skill",
  mod_target_filter = function(self, to_select, selected, user, card, distance_limited)
    return true
  end,
  can_use = function(self, player, card)
    return not player:isProhibited(player, card) and player:getMark("niepan_fd-turn") == 0
  end,
  on_use = function(self, room, cardUseEvent)
    if not cardUseEvent.tos or #TargetGroup:getRealTargets(cardUseEvent.tos) == 0 then
      cardUseEvent.tos = { { cardUseEvent.from } }
    end
  end,
  on_effect = function(self, room, effect)
    local target = room:getPlayerById(effect.to)
    if target.dead then return end
    room:setPlayerMark(target, "niepan_fd-turn", 1)
    room:damage({
      from = target,
      to = target,
      card = effect.card,
      damage = 1,
      damageType = fk.FireDamage,
      skillName = self.name
    })
  end
}
Fk:addSkill(s_niepanSkill)

local s_niepanSkill_tri = fk.CreateTriggerSkill {
  name = "#s_niepanSkill_tri",
  global = true,
  mute = true,
  priority = 0.1,
  events = { fk.EnterDying },
  can_trigger = function(self, event, target, player, data)
    return target == player and data.damage and data.damage.card and data.damage.card.name == "s_niepan"
  end,
  on_cost = function(self, event, target, player, data)
    return true
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    if event == fk.EnterDying then
      local chc = { "playermaxHP" }
      if #player.player_cards[Player.Hand] < 100 then
        table.insert(chc, "playerdrawcards")
      end
      local chs = room:askForChoice(player, chc, self.name)
      if chs == "playerdrawcards" then
        player:drawCards(player.maxHp, self.name)
      else
        player.room:recover {
          who = target,
          num = 1 - target.hp,
          recoverBy = player,
          skillName = self.name
        }
      end
      room:notifySkillInvoked(player, self.name, "drawcard")
    end
  end
}
Fk:addSkill(s_niepanSkill_tri)

local s_niepan = fk.CreateTrickCard {
  name = "s_niepan",
  skill = s_niepanSkill,
  is_damage_card = true,
}
addzlCard(s_niepan:clone(Card.Heart, 6))

Fk:loadTranslationTable {
  ["s_niepan"] = "涅槃",
  ["s_niepan_skill"] = "涅槃",
  ["#s_niepan_skill"] = "受到1点火属性伤害，若你因此进入濒死状态，<br>则你可以选择摸X张牌或将体力恢复至1(X为体力上限)",
  [":s_niepan"] = "锦囊牌<br/><b>时机</b>：出牌阶段<br/><b>目标</b>：对自己<br /><b>效果</b>：每回合限一次，受到1点火属性伤害，若你因此进入濒死状态，则你可以选择摸X张牌或将体力恢复至1(X为体力上限)",
  ["#s_niepanSkill_tri"] = "涅槃",
  ["playermaxHP"] = "体力恢复至1",
  ["playerdrawcards"] = "摸体力上限的牌"
}

--休养生息
local xiuyangshengxi_Skill = fk.CreateActiveSkill {
  name = "xiuyangshengxi_skill",
  prompt = "#xiuyangshengxi_skill",
  mod_target_filter = function(self, to_select, selected, user, card, distance_limited)
    return true
  end,
  can_use = function(self, player, card)
    return not player:isProhibited(player, card)
  end,
  on_use = function(self, room, cardUseEvent)
    if not cardUseEvent.tos or #TargetGroup:getRealTargets(cardUseEvent.tos) == 0 then
      cardUseEvent.tos = { { cardUseEvent.from } }
    end
  end,
  on_effect = function(self, room, effect)
    local to = room:getPlayerById(effect.to)
    local player = to
    local judge = {
      who = to,
      reason = "xiuyangshengxi",
      pattern = ".|.|diamond,heart",
    }
    room:judge(judge)
    local result = judge.card
    if result.color == Card.Red then
      if player:isWounded() then
        room:recover({
          who = player,
          num = 1,
          card = effect.card,
          recoverBy = player,
          skillName = self.name
        })
      end
      room:drawCards(player, 1, self.name)
      player:skip(Player.Discard)
    end
    self:onNullified(room, effect)
  end,
  on_nullified = function(self, room, effect)
    room:moveCards {
      ids = room:getSubcardsByRule(effect.card, { Card.Processing }),
      toArea = Card.DiscardPile,
      moveReason = fk.ReasonUse
    }
  end,
}
local xiuyangshengxi = fk.CreateDelayedTrickCard {
  name = "xiuyangshengxi",
  suit = Card.Heart,
  number = 9,
  skill = xiuyangshengxi_Skill,
}
addzlCard(xiuyangshengxi)
extension:addCards({
  xiuyangshengxi:clone(Card.Diamond, 12),
})

Fk:loadTranslationTable {
  ["xiuyangshengxi"] = "休养生息",
  ["xiuyangshengxi_skill"] = "休养生息",
  ["#xiuyangshengxi_skill"] = "对自己使用，置于自己的判定区，判定阶段进行判定：<br>若为红色，恢复1点体力并摸1张牌，跳过弃牌阶段",
  [":xiuyangshengxi"] = "延时锦囊牌<br /><b>时机</b>：出牌阶段<br /><b>目标</b>：对自己使用<br /><b>效果</b>：置于自己的判定区，判定阶段进行判定，若为红色，恢复1点体力并摸1张牌，跳过弃牌阶段",
}
-----基本，锦囊牌
addzlCard(Fk:cloneCard("lightning", Card.Heart, 12))
-- addzlCard(Fk:cloneCard("lightning", Card.Spade, 12))

addzlCard(Fk:cloneCard("jink", Card.Club, 3))
addzlCard(Fk:cloneCard("jink", Card.Spade, 12))

extension:addCard(Fk:cloneCard("jink", Card.Heart, 6))
extension:addCard(Fk:cloneCard("jink", Card.Diamond, 1))
extension:addCard(Fk:cloneCard("jink", Card.Club, 7))
extension:addCard(Fk:cloneCard("jink", Card.Spade, 9))
extension:addCard(Fk:cloneCard("jink", Card.Diamond, 10))


addzlCard(Fk:cloneCard("slash", Card.Spade, 7))
addzlCard(Fk:cloneCard("slash", Card.Diamond, 2))
-- addzlCard(Fk:cloneCard("slash", Card.Heart, 8))
-- addzlCard(Fk:cloneCard("slash", Card.Club, 13))

extension:addCard(Fk:cloneCard("slash", Card.Heart, 6))
extension:addCard(Fk:cloneCard("slash", Card.Club, 13))
extension:addCard(Fk:cloneCard("slash", Card.Spade, 10))
extension:addCard(Fk:cloneCard("slash", Card.Heart, 7))
extension:addCard(Fk:cloneCard("slash", Card.Diamond, 3))
extension:addCard(Fk:cloneCard("slash", Card.Club, 5))
extension:addCard(Fk:cloneCard("slash", Card.Heart, 8))

-- addzlCard(Fk:cloneCard("fire__slash", Card.Spade, 4))
-- addzlCard(Fk:cloneCard("fire__slash", Card.Club, 7))
addzlCard(Fk:cloneCard("fire__slash", Card.Club, 1))

extension:addCard(Fk:cloneCard("fire__slash", Card.Heart, 9))
extension:addCard(Fk:cloneCard("fire__slash", Card.Spade, 1))
extension:addCard(Fk:cloneCard("fire__slash", Card.Diamond, 12))

-- addzlCard(Fk:cloneCard("peach", Card.Spade, 3))
addzlCard(Fk:cloneCard("peach", Card.Club, 4))
addzlCard(Fk:cloneCard("peach", Card.Spade, 13))

extension:addCard(Fk:cloneCard("peach", Card.Heart, 7))
extension:addCard(Fk:cloneCard("peach", Card.Diamond, 11))
extension:addCard(Fk:cloneCard("peach", Card.Heart, 11))

addzlCard(Fk:cloneCard("thunder__slash", Card.Heart, 13))
-- addzlCard(Fk:cloneCard("thunder__slash", Card.Diamond, 9))
-- addzlCard(Fk:cloneCard("thunder__slash", Card.Diamond, 8))

extension:addCard(Fk:cloneCard("thunder__slash", Card.Heart, 9))
extension:addCard(Fk:cloneCard("thunder__slash", Card.Spade, 13))

extension:addCard(Fk:cloneCard("nullification", Card.Diamond, 8))
extension:addCard(Fk:cloneCard("nullification", Card.Heart, 1))
extension:addCard(Fk:cloneCard("nullification", Card.Spade, 13))
-- extension:addCard(Fk:cloneCard("nullification", Card.Spade, 7))
-- extension:addCard(Fk:cloneCard("nullification", Card.Club, 5))

--火上浇油
local huoshangjiaoyouSkill = fk.CreateActiveSkill {
  name = "huoshangjiaoyou_skill",
  prompt = "#huoshangjiaoyou_skill",
  target_num = 1,
  mod_target_filter = function(self, to_select, selected, user, card)
    return user ~= to_select
  end,
  target_filter = function(self, to_select, selected, _, card)
    if #selected < self:getMaxTargetNum(Self, card) and
        Self:inMyAttackRange(Fk:currentRoom():getPlayerById(to_select)) then
      -- local player = Fk:currentRoom():getPlayerById(to_select)
      return true
    end
  end,
  on_effect = function(self, room, effect)
    local target = room:getPlayerById(effect.to)
    local player = room:getPlayerById(effect.from)
    if target.dead then return end
    -- data.Fk:currentRoom()
    if target.hp > 1 then
      room:damage({
        from = player,
        to = target,
        card = effect.card,
        damage = 1,
        damageType = fk.FireDamage,
        skillName = self.name
      })
    else
      room:drawCards(target, 5, self.name)
      room:damage({
        from = player,
        to = target,
        card = effect.card,
        damage = 2,
        damageType = fk.FireDamage,
        skillName = self.name
      })
    end
  end
}
Fk:addSkill(huoshangjiaoyouSkill)

local huoshangjiaoyou = fk.CreateTrickCard {
  name = "huoshangjiaoyou",
  skill = huoshangjiaoyouSkill,
  is_damage_card = true,
  -- special_skills = { "xiancetrick" },
}

extension:addCards({
  huoshangjiaoyou:clone(Card.Heart, 12),
  -- huoshangjiaoyou:clone(Card.Diamond, 12),
})
Fk:loadTranslationTable {
  ["huoshangjiaoyou"] = "火上浇油",
  ["huoshangjiaoyou_skill"] = "火上浇油",
  ["#huoshangjiaoyou_skill"] = "对攻击范围内的一名其他角色使用，若其体力值大于1，受到1点火焰伤害，<br>否则摸5张牌并受到两点火焰伤害",
  [":huoshangjiaoyou"] = "锦囊牌<br/><b>时机</b>：出牌阶段<br/><b>目标</b>：攻击范围内的一名角色<br /><b>效果</b>：若其体力值大于1，受到1点火焰伤害，否则摸5张牌并受到两点火焰伤害",
}
--逐鹿天下
local zhulutianxia_skill = fk.CreateActiveSkill {
  name = "zhulutianxia_skill",
  prompt = "#zhulutianxia_skill",
  can_use = Util.GlobalCanUse,
  on_use = Util.GlobalOnUse,
  mod_target_filter = Util.TrueFunc,
  on_action = function(self, room, use, finished)
    if not finished then
      local toDisplay = {}
      local pile = (room.draw_pile or room.discard_pile)
      for index, eid in ipairs(pile) do
        if Fk:getCardById(eid).type == Card.TypeEquip then
          if #toDisplay < #TargetGroup:getRealTargets(use.tos) then
            table.insert(toDisplay, eid)
          else
            break
          end
        end
      end
      room:moveCards({
        ids = toDisplay,
        toArea = Card.Processing,
        moveReason = fk.ReasonPut,
        proposer = use.from,
      })

      table.forEach(room.players, function(p)
        room:fillAG(p, toDisplay)
      end)

      use.extra_data = use.extra_data or {}
      use.extra_data.AGFilled = toDisplay
    else
      if use.extra_data and use.extra_data.AGFilled then
        table.forEach(room.players, function(p)
          room:closeAG(p)
        end)

        local toDiscard = table.filter(use.extra_data.AGFilled, function(id)
          return room:getCardArea(id) == Card.Processing
        end)

        if #toDiscard > 0 then
          room:moveCards({
            ids = toDiscard,
            toArea = Card.DiscardPile,
            moveReason = fk.ReasonPutIntoDiscardPile,
          })
        end
      end

      use.extra_data.AGFilled = nil
    end
  end,
  on_effect = function(self, room, effect)
    local to = room:getPlayerById(effect.to)
    if not (effect.extra_data and effect.extra_data.AGFilled) then
      return
    end

    local chosen = room:askForAG(to, effect.extra_data.AGFilled, false, self.name)
    room:takeAG(to, chosen, room.players)
    U.moveCardIntoEquip(room, to, chosen, self.name, true, to)
    table.removeOne(effect.extra_data.AGFilled, chosen)
  end
}
Fk:addSkill(zhulutianxia_skill)

local zhulutianxia = fk.CreateTrickCard {
  name = "zhulutianxia",
  skill = zhulutianxia_skill,
  multiple_targets = true,
}

extension:addCards({
  zhulutianxia:clone(Card.Heart, 13),
})
Fk:loadTranslationTable {
  ["zhulutianxia"] = "逐鹿天下",
  ["zhulutianxia_skill"] = "逐鹿天下",
  ["#zhulutianxia_skill"] = "对所有角色使用，随机从牌堆和弃牌堆展示X张装备，从使用者开始，<br>依次将其中一张置入自己的装备区并替换原有装备（X为存活玩家数），请勿将此牌用于额外结算",
  ["zhulutianxiaAction"] = "逐鹿天下",
  [":zhulutianxia"] = "锦囊牌<br/><b>时机</b>：出牌阶段<br/><b>目标</b>：所有角色<br /><b>效果</b>：对所有存活角色使用，随机从牌堆和弃牌堆展示X张装备，从使用者开始，依次将其中一张置入自己的装备区并替换原有装备（X为存活玩家数）",
}

--以缓制急
local yihuanzhijiSkill = fk.CreateActiveSkill {
  name = "yihuanzhiji_skill",
  prompt = "#yihuanzhiji_skill",
  target_num = 1,
  mod_target_filter = function(self, to_select, selected, user, card, distance_limited)
    return user ~= to_select
  end,
  target_filter = function(self, to_select, selected, _, card)
    if #selected < self:getMaxTargetNum(Self, card) then
      local player = Fk:currentRoom():getPlayerById(to_select)
      return Self ~= player and self:modTargetFilter(to_select, selected, Self.id, card, true)
    end
  end,

  on_effect = function(self, room, effect)
    local target = room:getPlayerById(effect.to)
    local player = room:getPlayerById(effect.from)
    if not player:isAllNude() then
      local cids = room:askForCard(player, 1, 1, true, self.name, true, "", "#yihuanzhiji_skill-tip")
      if #cids > 0 then
        room:obtainCard(target, cids[1], false, fk.ReasonJustMove)
        local use = room:askForUseCard(target, "slash", "slash", "#yihuanzhiji_skill-useslash-tip:::" .. player.general,
          true, { must_targets = { effect.from }, bypass_times = true, bypass_distances = true })
        if use then
          room:useCard(use)
        else
          room:loseHp(target, 1, self.name)
        end
      end
    end
  end
}
Fk:addSkill(yihuanzhijiSkill)

local yihuanzhiji = fk.CreateTrickCard {
  name = "yihuanzhiji",
  skill = yihuanzhijiSkill,
}

extension:addCards({
  yihuanzhiji:clone(Card.Club, 11),
  yihuanzhiji:clone(Card.Spade, 11),
})
Fk:loadTranslationTable {
  ["yihuanzhiji"] = "以缓制急",
  ["yihuanzhiji_skill"] = "以缓制急",
  ["#yihuanzhiji_skill"] = "对一名其他角色使用，交给其一张牌，其需对你使用一张【杀】，否则失去1点体力",
  ["#yihuanzhiji_skill-tip"] = "以缓制急：对一名其他角色使用，交给其一张牌",
  ["#yihuanzhiji_skill-useslash-tip"] = "以缓制急：是否对 %arg 使用一张【杀】，否则失去一点体力",
  [":yihuanzhiji"] = "锦囊牌<br/><b>时机</b>：出牌阶段<br/><b>目标</b>：一名其他角色<br /><b>效果</b>：交给其一张牌，令其选择对你使用一张【杀】，否则失去1点体力",
}

--解甲归田
local jiejiaguitianSkill = fk.CreateActiveSkill {
  name = "jiejiaguitian_skill",
  prompt = "#jiejiaguitian_skill",
  target_num = 1,
  mod_target_filter = function(self, to_select, selected, user, card, distance_limited)
    local player = Fk:currentRoom():getPlayerById(to_select)
    return #player.player_cards[Player.Equip] > 0
  end,
  target_filter = function(self, to_select, selected, _, card)
    if #selected < self:getMaxTargetNum(Self, card) then
      local player = Fk:currentRoom():getPlayerById(to_select)
      -- return #player.player_cards[Player.Equip] > 0
      return #selected == 0 and self:modTargetFilter(to_select, selected, Self.id, card, true)
    end
  end,

  on_effect = function(self, room, effect)
    local target = room:getPlayerById(effect.to)
    local player = room:getPlayerById(effect.from)
    local clonetb = table.clone(target.player_cards[Player.Equip])
    room:moveCards({
      ids = clonetb,
      from = target.id,
      fromArea = Card.PlayerEquip,
      to = target.id,
      toArea = Card.PlayerHand,
      moveReason = fk.ReasonJustMove,
      proposer = player.id,
      skillName = self.name,
    })
  end
}
Fk:addSkill(jiejiaguitianSkill)

local jiejiaguitian = fk.CreateTrickCard {
  name = "jiejiaguitian",
  skill = jiejiaguitianSkill,
}

extension:addCards({
  jiejiaguitian:clone(Card.Diamond, 7),
  jiejiaguitian:clone(Card.Diamond, 13),
  jiejiaguitian:clone(Card.Diamond, 8),
})
Fk:loadTranslationTable {
  ["jiejiaguitian"] = "解甲归田",
  ["jiejiaguitian_skill"] = "解甲归田",
  ["#jiejiaguitian_skill"] = "令一名角色将装备牌收回手中",
  [":jiejiaguitian"] = "锦囊牌<br/><b>时机</b>：出牌阶段<br/><b>目标</b>：一名其他角色<br /><b>效果</b>：对一名角色使用，令其将所有装备收回手牌中",
}
Fk:addPoxiMethod {
  name = "sslj_chosecard",
  card_filter = function(to_select, selected, data)
    return #selected == 0
  end,
  feasible = function(selected)
    return #selected == 1
  end,
  prompt = function()
    return "三十六计：选择其中一张牌"
  end
}
local sw_sslj_skill = fk.CreateActiveSkill {
  name = "sw_sslj_skill",
  prompt = "#sw_sslj_skill",
  mod_target_filter = Util.TrueFunc,
  can_use = function(self, player, card)
    return not player:isProhibited(player, card)
  end,
  on_use = function(self, room, cardUseEvent)
    if not cardUseEvent.tos or #TargetGroup:getRealTargets(cardUseEvent.tos) == 0 then
      cardUseEvent.tos = { { cardUseEvent.from } }
    end
  end,
  on_effect = function(self, room, effect)
    local target = room:getPlayerById(effect.to)
    if target.dead then return end
    local ids = room:getCardsFromPileByRule(".|.|.|.|.|trick", 3)
    room:moveCards({
      ids = ids,
      toArea = Card.Processing,
      moveReason = fk.ReasonPut,
    })
    local get = room:askForPoxi(target, "sslj_chosecard", {
      { self.name, ids },
    }, nil, true)
    if #get > 0 then
      local dummy = Fk:cloneCard("dilu")
      dummy:addSubcards(get)
      room:obtainCard(target.id, dummy, true, fk.ReasonPrey)
    end
    ids = table.filter(ids, function(id) return room:getCardArea(id) == Card.Processing end)
    if #ids > 0 then
      table.shuffle(ids)
      local positions = {}
      local y = #room.draw_pile
      for _ = 1, #ids, 1 do
        table.insert(positions, math.random(y + 1))
      end
      table.sort(positions, function(a, b)
        return a > b
      end)
      local moveInfos = {}
      for i = 1, #ids, 1 do
        table.insert(moveInfos, {
          ids = { ids[i] },
          from = target.id,
          toArea = Card.DrawPile,
          moveReason = fk.ReasonJustMove,
          skillName = self.name,
          drawPilePosition = positions[i],
        })
      end
      room:moveCards(table.unpack(moveInfos))
    end
  end
}
local sw_sslj = fk.CreateTrickCard {
  name = "sw_sslj",
  skill = sw_sslj_skill,
}
extension:addCards({
  sw_sslj:clone(Card.Diamond, 6),
  sw_sslj:clone(Card.Heart, 2),
})
Fk:loadTranslationTable {
  ["sw_sslj"] = "三十六计",
  ["sw_sslj_skill"] = "三十六计",
  ["sslj_chosecard"] = "三十六计",
  ["#sw_sslj_skill"] = "锦囊牌三选一",
  [":sw_sslj"] = "锦囊牌<br/><b>时机</b>：出牌阶段<br/><b>目标</b>：自己<br /><b>效果</b>：从随机三张锦囊牌中选择一张，然后将剩余的牌洗入牌堆",
}
Fk:addPoxiMethod {
  name = "sbtj_chosecard",
  card_filter = function(to_select, selected, data)
    return #selected == 0
  end,
  feasible = function(selected)
    return #selected == 1
  end,
  prompt = function()
    return "神兵天降：选择其中一张牌"
  end
}
local sw_sbtj_skill = fk.CreateActiveSkill {
  name = "sw_sbtj_skill",
  prompt = "#sw_sbtj_skill",
  mod_target_filter = Util.TrueFunc,
  can_use = function(self, player, card)
    return not player:isProhibited(player, card)
  end,
  on_use = function(self, room, cardUseEvent)
    if not cardUseEvent.tos or #TargetGroup:getRealTargets(cardUseEvent.tos) == 0 then
      cardUseEvent.tos = { { cardUseEvent.from } }
    end
  end,
  on_effect = function(self, room, effect)
    local target = room:getPlayerById(effect.to)
    if target.dead then return end
    local ids = room:getCardsFromPileByRule(".|.|.|.|.|weapon", 3)
    room:moveCards({
      ids = ids,
      toArea = Card.Processing,
      moveReason = fk.ReasonPut,
    })
    local get = room:askForPoxi(target, "sbtj_chosecard", {
      { self.name, ids },
    }, nil, true)
    if #get > 0 then
      local dummy = Fk:cloneCard("dilu")
      dummy:addSubcards(get)
      room:obtainCard(target.id, dummy, true, fk.ReasonPrey)
    end
    ids = table.filter(ids, function(id) return room:getCardArea(id) == Card.Processing end)
    if #ids > 0 then
      table.shuffle(ids)
      local positions = {}
      local y = #room.draw_pile
      for _ = 1, #ids, 1 do
        table.insert(positions, math.random(y + 1))
      end
      table.sort(positions, function(a, b)
        return a > b
      end)
      local moveInfos = {}
      for i = 1, #ids, 1 do
        table.insert(moveInfos, {
          ids = { ids[i] },
          from = target.id,
          toArea = Card.DrawPile,
          moveReason = fk.ReasonJustMove,
          skillName = self.name,
          drawPilePosition = positions[i],
        })
      end
      room:moveCards(table.unpack(moveInfos))
    end
  end
}
local sw_sbtj = fk.CreateTrickCard {
  name = "sw_sbtj",
  skill = sw_sbtj_skill,
}
extension:addCards({
  sw_sbtj:clone(Card.Club, 2),
  -- sw_sbtj:clone(Card.Spade, 6),
})
Fk:loadTranslationTable {
  ["sw_sbtj"] = "神兵天降",
  ["sw_sbtj_skill"] = "神兵天降",
  ["sbtj_chosecard"] = "神兵天降",
  ["#sw_sbtj_skill"] = "武器牌三选一",
  [":sw_sbtj"] = "锦囊牌<br/><b>时机</b>：出牌阶段<br/><b>目标</b>：自己<br /><b>效果</b>：从随机三张武器牌中选择一张，然后将剩余两张洗入牌堆。",
}
local sw_fkwz_trigger = fk.CreateTriggerSkill {
  name = "sw_fkwz_trigger",
  global = true,
  mute = true,
  priority = 0,
  events = { fk.TargetConfirmed },
  can_trigger = function(self, event, target, player, data)
    return target == player and (data.card.trueName == "slash" or data.card:isCommonTrick()) and
        #AimGroup:getAllTargets(data.tos) == 1 and data.from ~= player.id and
        table.find(player:getCardIds("h"), function(id) return Fk:getCardById(id).trueName == "sw_fkwz" end)
  end,
  on_cost = function(self, event, target, player, data)
    local prompt = ""
    if data.from then
      prompt = "#sw_fkwz-use:" .. data.from .. "::" .. data.card:toLogString()
    end
    local use = player.room:askForUseCard(player, "sw_fkwz", nil, prompt, true, nil, data)
    if use then
      self.cost_data = use
      return true
    end
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    for _, p in ipairs(room.alive_players) do
      room:setPlayerMark(p, "sw_fnke_to-turn", 0)
    end

    room:setPlayerMark(player, "sw_fanke_card-turn", data.card.name)
    room:setPlayerMark(player.room:getPlayerById(data.from), "sw_fnke_to-turn", 1)
    local use = self.cost_data
    use.toCard = data.card
    use.responseToEvent = data
    room:useCard(use)
    -- player.room:useCard(use)
    -- local cardname = data.card.trueName
    -- if not table.contains(use.nullifiedTargets, player.id) then
    --   table.insertIfNeed(data.nullifiedTargets, player.id)
    -- end
    -- player.room:useVirtualCard(cardname, nil, player, player.room:getPlayerById(data.from), self.name, true)
  end,
}
Fk:addSkill(sw_fkwz_trigger)
local sw_fkwz_skill = fk.CreateActiveSkill {
  name = "sw_fkwz_skill",
  can_use = function()
    return false
  end,
  on_effect = function(self, room, effect)
    local player = room:getPlayerById(effect.from)
    if effect.responseToEvent then
      table.insertIfNeed(effect.responseToEvent.nullifiedTargets, player.id)
    end
    local to
    for _, p in ipairs(room.alive_players) do
      if p:getMark("sw_fnke_to-turn") > 0 then
        to = p
      end
    end
    room:useVirtualCard(player:getMark("sw_fanke_card-turn"), nil, player, to, self.name, true)
    room:setPlayerMark(player, "sw_fanke_card-turn", 0)
    room:setPlayerMark(to, "sw_fnke_to-turn", 0)
  end,
}
local sw_fkwz = fk.CreateTrickCard {
  name = "sw_fkwz",
  skill = sw_fkwz_skill,
}
extension:addCards {
  sw_fkwz:clone(Card.Spade, 1),
  -- sw_fkwz:clone(Card.Heart, 13),
  -- sw_fkwz:clone(Card.Club, 6),
}
Fk:loadTranslationTable {
  ["sw_fkwz"] = "反客为主",
  ["sw_fkwz_skill"] = "反客为主",
  [":sw_fkwz"] = "锦囊牌<br/><b>时机</b>：成为唯一目标的【杀】和普通锦囊牌的目标后<br/><b>目标</b>：你<br/><b>效果</b>：若你可以响应此牌，调转此牌的目标，改为你对其使用此牌。",
  ["#sw_fkwz-use"] = "%src 对你使用%arg，你可以使用【反客为主】调转此牌的目标",
}
-- local sw_jshh_skill = fk.CreateActiveSkill {
--   name = "sw_jshh_skill",
--   prompt = "#sw_jshh_skill",
--   mod_target_filter = Util.TrueFunc,
--   can_use = function(self, player, card)
--     local dead_players = table.filter(Fk:currentRoom().players, function(p) return p.dead end)
--     return not player:isProhibited(player, card) and #dead_players > 0
--   end,
--   on_use = function(self, room, cardUseEvent)
--     if not cardUseEvent.tos or #TargetGroup:getRealTargets(cardUseEvent.tos) == 0 then
--       cardUseEvent.tos = { { cardUseEvent.from } }
--     end
--   end,
--   on_effect = function(self, room, effect)
--     local target = room:getPlayerById(effect.to)
--     if target:getMark("jshh_fd") == 0 then
--       room:setPlayerMark(target, "jshh_fd", 1)
--       local targets = table.map(table.filter(room.players, function(p) return p.dead end),
--         function(p) return p.general end)
--       if #targets > 0 then
--         targets = room:askForChoice(target, targets, self.name, "#sw_jshh-phase")
--         if #targets > 0 then
--           for _, p in ipairs(room.players) do
--             if p.general == targets then
--               room:revivePlayer(p, true)
--               room:changeMaxHp(p, -(p.maxHp - 1))
--               room:drawCards(p, 2, self.name)
--               room:setPlayerMark(p, "jshh_kill", 1)
--               local temp = target.role
--               p.role = temp
--               room:notifyProperty(p, p, "role")
--               room:broadcastProperty(p, "role")
--             end
--           end
--         end
--       end
--     else
--       return false
--     end
--   end
-- }
-- local sw_jshh = fk.CreateTrickCard {
--   name = "sw_jshh",
--   skill = sw_jshh_skill,
-- }
-- extension:addCards {
--   sw_jshh:clone(Card.Spade, 1),
-- }
-- Fk:loadTranslationTable {
--   ["sw_jshh"] = "借尸还魂",
--   ["sw_jshh_skill"] = "借尸还魂",
--   ["#sw_jshh-phase"] = "借尸还魂：请选择复活的角色",
--   ["#sw_jshh_skill"] = "借尸还魂：令一名死亡的角色复活为你的队友，回复1点体力上限摸两张牌，其回合结束时，其死亡",
--   [":sw_jshh"] = "锦囊牌<br/><b>时机</b>：出牌阶段且存在死亡角色<br/><b>目标</b>：自己<br/><b>效果</b>：每名角色限一次，令一名死亡的角色复活为你的队友，回复1点体力上限摸两张牌，其回合结束时，其死亡(即身份相同)。",
-- }
local sw_chdj_trigger = fk.CreateTriggerSkill {
  name = "sw_chdj_trigger",
  global = true,
  mute = true,
  priority = 0,
  events = { fk.Damaged },
  can_trigger = function(self, event, target, player, data)
    return player:inMyAttackRange(target) and target ~= player and data.card and
        table.find(player:getCardIds("h"), function(id) return Fk:getCardById(id).trueName == "sw_chdj" end)
  end,
  on_cost = function(self, event, target, player, data)
    local prompt = ""
    if target then
      prompt = "#sw_chdj-use:" .. data.to.id
    end
    local use = player.room:askForUseCard(player, "sw_chdj", nil, prompt, true, nil, data)
    if use then
      self.cost_data = use
      return true
    end
  end,
  on_use = function(self, event, target, player, data)
    player.room:setPlayerMark(data.to, "sw_chdj_s", 1)
    local use = self.cost_data
    use.toCard = data.card
    use.responseToEvent = data
    player.room:useCard(use)
    if use.responseToEvent.isCancellOut then
      return true
    end
    -- player.room:useCard(use)
    -- local cid = player.room:askForCardChosen(player, target, "hej", self.name)
    -- player.room:obtainCard(player.id, cid, false, fk.ReasonPrey)
  end,
}
Fk:addSkill(sw_chdj_trigger)
local sw_chdj_skill = fk.CreateActiveSkill {
  name = "sw_chdj_skill",
  can_use = function()
    return false
  end,
  on_effect = function(self, room, effect)
    if effect.responseToEvent then
      effect.responseToEvent.isCancellOut = true
      local player = room:getPlayerById(effect.from)
      for _, p in ipairs(room.alive_players) do
        if p:getMark("sw_chdj_s") > 0 then
          if not p or p.dead then return end
          if #p:getCardIds { Player.Hand, Player.Equip, Player.Judge } > 0 then
            local cid = player.room:askForCardChosen(player, p, "hej", self.name)
            room:obtainCard(player.id, cid, false, fk.ReasonPrey)
          else
            room:damage {
              from = player,
              to = p,
              damage = 1,
              skillName = self.name,
            }
          end
          player.room:setPlayerMark(p, "sw_chdj_s", 0)
        end
      end
    end
  end
}
local sw_chdj = fk.CreateTrickCard {
  name = "sw_chdj",
  skill = sw_chdj_skill,
  is_damage_card = true,
}
extension:addCards {
  sw_chdj:clone(Card.Heart, 7),
  sw_chdj:clone(Card.Diamond, 12),
}
Fk:loadTranslationTable {
  ["sw_chdj"] = "趁火打劫",
  ["sw_chdj_skill"] = "趁火打劫",
  ["sw_chdj_trigger"] = "趁火打劫",
  [":sw_chdj"] = "锦囊牌<br/><b>时机</b>：你攻击范围内的其他角色受到牌造成的伤害后<br/><b>目标</b>：受伤的角色<br/><b>效果</b>：你可以获得其区域内的一张牌，若其没有牌，你对其造成一点伤害",
  ["#sw_chdj-use"] = "你可以获得 %src 区以内的一张牌",
}
local sw_sskh_skill = fk.CreateActiveSkill {
  name = "sw_sskh_skill",
  mod_target_filter = Util.TrueFunc,
  can_use = function(self, player, card)
    return not player:isProhibited(player, card)
  end,
  on_use = function(self, room, cardUseEvent)
    if not cardUseEvent.tos or #TargetGroup:getRealTargets(cardUseEvent.tos) == 0 then
      cardUseEvent.tos = { { cardUseEvent.from } }
    end
  end,
  on_effect = function(self, room, effect)
    local target = room:getPlayerById(effect.to)
    if target.dead or target:isNude() then return end
    local cards = room:askForDiscard(target, 1, 2, true, "sw_sskh", false, ".", "#sw_sskh-discard", true)
    if #cards == 0 then return end
    local n = #cards
    if table.find(cards, function(id) return Fk:getCardById(id).type == Card.TypeEquip end) then
      n = n + 1
    end
    room:throwCard(cards, "sw_sskh", target, target)
    if not target.dead then
      target:drawCards(n, "sw_sskh")
    end
  end
}
local sw_sskh = fk.CreateTrickCard {
  name = "sw_sskh",
  skill = sw_sskh_skill,
}
extension:addCards {
  sw_sskh:clone(Card.Heart, 5),
  sw_sskh:clone(Card.Diamond, 5),
}
Fk:loadTranslationTable {
  ["sw_sskh"] = "树上开花",
  ["sw_sskh_skill"] = "树上开花",
  [":sw_sskh"] = "锦囊牌<br/><b>时机</b>：出牌阶段<br/><b>目标</b>：你<br/><b>效果</b>：目标角色弃置至多两张牌，然后摸等量的牌；" ..
      "若弃置了装备牌，则多摸一张牌。",
  ["#sw_sskh-discard"] = "树上开花：弃置一至两张牌，摸等量的牌，若弃置了装备牌则多摸一张",
}
local zl_skill = fk.CreateActiveSkill {
  name = "zl_skill&",
  prompt = "#zl_skill&",
  anim_type = "support",
  interaction = function()
    return UI.ComboBox { choices = { "zl_use", "zl_zhiru" } }
  end,
  card_num = 1,
  target_num = 1,
  can_use = function(self, player)
    return table.find(player:getCardIds("h"),
      function(id) return Fk:getCardById(id):getMark("@@sw_zlsun") > 0 or Fk:getCardById(id):getMark("@@sw_zlli") > 0 end)
  end,
  card_filter = function(self, to_select, selected)
    if self.interaction.data == "zl_use" then
      return #selected == 0 and Fk:getCardById(to_select):getMark("@@sw_zlli") > 0 and
          table.contains(Self:getCardIds("h"), to_select) and Fk:getCardById(to_select).type ~= Card.TypeEquip
    else
      return #selected == 0 and Fk:getCardById(to_select):getMark("@@sw_zlsun") > 0 and
          table.contains(Self:getCardIds("h"), to_select) and Fk:getCardById(to_select).type == Card.TypeEquip
    end
  end,
  target_filter = function(self, to_select, selected, selected_cards)
    return #selected == 0 and to_select ~= Self.id
  end,
  on_use = function(self, room, effect)
    local player = room:getPlayerById(effect.from)
    local target = room:getPlayerById(effect.tos[1])
    if self.interaction.data == "zl_zhiru" then
      U.presentCard(player, target, Fk:getCardById(effect.cards[1]))
    else
      local cards = effect.cards
      room:moveCardTo(cards, Player.Hand, target, fk.ReasonGive, self.name, nil, false, player.id)
      U.askForUseRealCard(room, target, cards, nil, self.name, "#zl_usecard")
    end
  end,
}
local zl_rule = fk.CreateTriggerSkill {
  name = "#zl_rule",
  priority = 0.001,
  global = true,

  refresh_events = { fk.GamePrepared },
  can_refresh = function(self, event, target, player, data)
    return not table.contains(player.room.disabled_packs, "MahjongSoul_token")
  end,
  on_refresh = function(self, event, target, player, data)
    local room = player.room
    for _, p in ipairs(room.alive_players) do
      room:handleAddLoseSkills(p, "zl_skill&", nil, false, true)
    end
    for _, card in ipairs(Fk.packages["MahjongSoul_token"].cards) do
      if table.contains(zlCards, card) then
        if card.type == Card.TypeEquip then
          room:setCardMark(card, "@@sw_zlsun", 1)
        else
          room:setCardMark(card, "@@sw_zlli", 1)
        end
      end
    end
  end,
}
Fk:addSkill(zl_skill)
Fk:addSkill(zl_rule)
Fk:loadTranslationTable {
  ["zl_skill&"] = "利损",
  [":zl_skill&"] = "出牌阶段，你可以选择一张有『利』标记的牌交给一名其他角色，其可以使用之(无次数限制)，或选择一张有『损』标记的牌，置入一名其他角色的装备区并替换原有装备",
  ["#zl_skill&"] = "选择一张有『利』或『损』的牌并选择一名其他角色",
  ["@@sw_zlli"] = "<font color='yellow'>利</font>",
  ["@@sw_zlsun"] = "<font color='red'>损</font>",
  ["#zl_usecard"] = "礼：是否使用此 %arg",

  ["zl_use"] = "给他用",
  ["zl_zhiru"] = "给他穿",
}

return extension