local extension = Package:new("majiang_huanhun")
extension.extensionName = "MahjongSoul"
extension.game_modes_blacklist = { "as_StonehengEarena_mode" }
Fk:loadTranslationTable {
  ["majiang_huanhun"] = "雀魂-幻魂",
  ["huan"] = "幻",
}
local U = require "packages/utility/utility"
local xuncai = General(extension, "sw__xuncai", "huan", 3, 3, General.Female)
local sw_panshii = fk.CreateTriggerSkill {
  name = "sw_panshii",
  events = { fk.EventPhaseStart, fk.AfterCardsMove },
  frequency = Skill.Compulsory,
  can_trigger = function(self, event, target, player, data)
    if not player:hasSkill(self) then return false end
    if event == fk.EventPhaseStart then
      return player:hasSkill(self.name) and not player:isKongcheng() and target.phase == target.Start
    else
      if player:getHandcardNum() < player:getMark("@sw_panshii-turn") and player:getMark("@sw_panshii-turn") > 0 and not player:isKongcheng() then
        for _, move in ipairs(data) do
          if move.to == player.id and move.toArea == Card.PlayerHand then
            return true
          elseif move.from == player.id then
            for _, info in ipairs(move.moveInfo) do
              if info.fromArea == Card.PlayerHand then
                return true
              end
            end
          end
        end
      end
    end
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    if event == fk.EventPhaseStart then
      local n = player:getHandcardNum()
      room:setPlayerMark(player, "@sw_panshii-turn", n)
    else
      player:drawCards(1, self.name)
      room:removePlayerMark(player, "@sw_panshii-turn", 1)
    end
  end,
}
xuncai:addSkill(sw_panshii)
Fk:loadTranslationTable {
  ["sw__xuncai"] = "荀彩",
  ["sw_panshii"] = "磐誓",
  [":sw_panshii"] = "锁定技，每当你的手牌数小于回合开始时的手牌数时，你将手牌补至该值；你因此技能摸牌时，该数值－1",
  ["@sw_panshii-turn"] = "磐誓",
}
local sw_migui = fk.CreateTriggerSkill {
  name = "sw_migui",
  events = { fk.EventPhaseEnd, fk.GameStart },
  frequency = Skill.Compulsory,
  can_trigger = function(self, event, target, player, data)
    if player:hasSkill(self.name) then
      if event == fk.EventPhaseEnd then
        return target.phase == Player.Finish
      else
        return true
      end
    end
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    if event == fk.EventPhaseEnd then
      local n = player:getMark("@migui")
      player:drawCards(n - player:getHandcardNum(), self.name)
    else
      room:setPlayerMark(player, "@migui", 3)
    end
  end,
}
local sw_migui_tar = fk.CreateTriggerSkill {
  name = "#sw_migui_tar",
  events = { fk.EventPhaseStart, fk.CardUseFinished },
  frequency = Skill.Compulsory,
  mute = true,
  can_trigger = function(self, event, target, player, data)
    if player:hasSkill(self.name) then
      if event == fk.EventPhaseStart then
        return player:getMark("@migui") < 6 and player:getMark("@migui") > 0 and
            player:getMark("migui_jiben-turn") == 0 and target.phase == Player.Finish
      else
        return player:getMark("migui_jiben-turn") == 0 and target == player and
            data.card.type == Card.TypeBasic
      end
    end
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    if event == fk.EventPhaseStart then
      room:addPlayerMark(player, "@migui", 1)
    else
      room:setPlayerMark(player, "migui_jiben-turn", 1)
    end
  end,
}
sw_migui:addRelatedSkill(sw_migui_tar)
xuncai:addSkill(sw_migui)
Fk:loadTranslationTable {
  ["sw_migui"] = "觅归",
  [":sw_migui"] = "锁定技，每名角色的回合结束时，你将手牌摸至【3】张，若你本回合未使用过基本牌，此数字+1，至多为6。",
  ["@migui"] = "觅归",
}
local jisi = General(extension, "sw__jisi", "huan", 3, 3, General.Female)
local sw_nizhuan = fk.CreateTriggerSkill {
  name = "sw_nizhuan",
  events = { fk.GameStart, fk.TurnEnd, fk.CardUsing },
  frequency = Skill.Compulsory,
  mute = true,
  can_trigger = function(self, event, target, player, data)
    if player:hasSkill(self.name) then
      if event == fk.GameStart then
        return true
      else
        return target == player
      end
    end
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    if event == fk.GameStart then
      room:throwCard(player.player_cards[Player.Hand], self.name, player)
      local allCardIds = table.map(room.draw_pile, function(id0) return id0 end) --player.player_cards[Player.Hand]
      local allCardOfNumber = {}
      for _, id in ipairs(allCardIds) do
        local card = Fk:getCardById(id)
        local number = card.number
        allCardOfNumber[number] = allCardOfNumber[number] or {}
        table.insert(allCardOfNumber[number], id)
      end
      local cards = {}
      for _, numberCards in ipairs(allCardOfNumber) do
        if #numberCards > 0 then
          local draw_num = math.random(1, #numberCards)
          table.insert(cards, numberCards[draw_num])
          table.remove(numberCards, draw_num)
        end
      end
      room:moveCardTo(cards, Card.PlayerHand, player, fk.ReasonJustMove, self.name, nil, true)
    else
      local allCardIds = table.map(player.player_cards[Player.Hand], function(id0) return id0 end) --player.player_cards[Player.Hand]
      local allCardOfNumber = {}
      for _, id in ipairs(allCardIds) do
        local card = Fk:getCardById(id)
        local number = card.number
        allCardOfNumber[number] = allCardOfNumber[number] or {}
        table.insert(allCardOfNumber[number], id)
      end
      for i, numberCards in pairs(allCardOfNumber) do
        local n = #numberCards - 1
        if n > 0 then
          room:askForDiscard(player, n, n, false, self.name, false, ".|" .. i,
            "#sw_nizhuan-invoke:::" .. n .. ":" .. i)
        end
      end
    end
  end,
}
jisi:addSkill(sw_nizhuan)
Fk:loadTranslationTable {
  ["sw__jisi"] = "祭祀",
  ["sw_nizhuan"] = "逆转",
  ["#sw_nizhuan-invoke"] = "请弃置 %arg 张点数为 %arg2 的牌",
  [":sw_nizhuan"] = "锁定技，游戏开始时，你弃置所有手牌，然后随机获得13张点数各不相同的牌；结束阶段或当你使用牌时，若你手牌中有相同点数的牌，将其弃至仅剩一张<br>",
}
local sw_huanying = fk.CreateActiveSkill {
  name = "sw_huanying",
  anim_type = "drawcard",
  card_num = 0,
  target_num = 0,
  card_filter = Util.FalseFunc,
  can_use = function(self, player)
    return player:getMark("sw_huanyig-turn") == 0
  end,
  on_use = function(self, room, effect)
    local player = room:getPlayerById(effect.from)
    local cards = room:getNCards(3)
    U.viewCards(player, cards, self.name)
    local names = {}
    for _, id in ipairs(cards) do
      local card = Fk:getCardById(id)
      if card.type == Card.TypeTrick and player:canUse(card) then
        table.insertIfNeed(names, card.name)
      end
    end
    if #names > 0 then
      room:setPlayerMark(player, "sw_huanying_names", names)
      local success, dat = room:askForUseViewAsSkill(player, "sw_huanying_viewas", "#sw_huanying-viewascard",
        true, nil, true)
      if success and dat then
        local num = Fk:getCardById(dat.cards[1]).number
        local numbers = U.getMark(player, "sw_huanying_number-turn")
        table.insert(numbers, num)
        room:setPlayerMark(player, "sw_huanying_number-turn", numbers)
        local card = Fk.skills["sw_huanying_viewas"]:viewAs(dat.cards)
        room:useCard {
          from = player.id,
          tos = table.map(dat.targets, function(p) return { p } end),
          card = card,
          extraUse = true,
        }
        local ids = room:getCardsFromPileByRule(".|" .. num)
        if #ids > 0 then
          room:moveCards({
            ids = ids,
            to = player.id,
            toArea = Card.PlayerHand,
            moveReason = fk.ReasonJustMove,
            proposer = player.id,
            skillName = self.name,
          })
        end
      else
        room:moveCards({
          ids = cards,
          toArea = Card.DiscardPile,
          moveReason = fk.ReasonJustMove,
          skillName = self.name,
        })
        player:drawCards(3, self.name)
        room:addPlayerMark(player, "sw_huanyig-turn", 1)
      end
    else
      room:moveCards({
        ids = cards,
        toArea = Card.DiscardPile,
        moveReason = fk.ReasonJustMove,
        skillName = self.name,
      })
      player:drawCards(3, self.name)
      room:addPlayerMark(player, "sw_huanyig-turn", 1)
    end
  end,
}

local sw_huanying_viewas = fk.CreateViewAsSkill {
  name = "sw_huanying_viewas",
  interaction = function()
    return UI.ComboBox { choices = U.getMark(Self, "sw_huanying_names") }
  end,
  card_filter = function(self, to_select, selected)
    if self.interaction.data and #selected == 0 then
      local numbers = U.getMark(Self, "sw_huanying_number-turn")
      local card = Fk:cloneCard(self.interaction.data)
      card:addSubcard(to_select)
      return not table.contains(numbers, Fk:getCardById(to_select).number) and not Self:prohibitUse(card)
    end
  end,
  view_as = function(self, cards)
    if #cards ~= 1 or not self.interaction.data then return end
    local card = Fk:cloneCard(self.interaction.data)
    card:addSubcard(cards[1])
    card.skillName = "sw_huanying"
    return card
  end,
}
Fk:addSkill(sw_huanying_viewas)
jisi:addSkill(sw_huanying)
Fk:loadTranslationTable {
  ["sw_huanying"] = "幻影",
  ["sw_huanying_viewas"] = "幻影",
  ["@sw_huanyig-turn"] = "幻影",
  ["#sw_huanying-viewascard"] = "是否使用其中一张可用的牌",
  [":sw_huanying"] = "出牌阶段，你可以观看牌堆顶三张牌，然后可以将一张你的本回合未以此法使用过的点数的牌当其中一张锦囊牌使用并随机获得一张与其点数相等的牌，然后弃置这些牌；若你没有使用或其中没有锦囊牌，摸等量的牌，该技能本回合失效",
}
local lingyan = General(extension, "sw__lingyan", "huan", 4, 4)
local sw_yujin = fk.CreateActiveSkill {
  name = "sw_yujin",
  anim_type = "offensive",
  target_num = 1,
  frequency = Skill.Limited,
  can_use = function(self, player)
    return player:usedSkillTimes(self.name, Player.HistoryGame) == 0 and
        (#player:getAvailableEquipSlots() > 0 or not table.contains(player.sealedSlots, Player.JudgeSlot))
  end,
  card_filter = Util.FalseFunc,
  target_filter = function(self, to_select, selected, selected_cards)
    return Self.id ~= to_select
  end,
  on_use = function(self, room, effect)
    local to = room:getPlayerById(effect.tos[1])
    local player = room:getPlayerById(effect.from)
    local eqipSlots = player:getAvailableEquipSlots()
    if not table.contains(player.sealedSlots, Player.JudgeSlot) then
      table.insert(eqipSlots, Player.JudgeSlot)
    end
    room:abortPlayerArea(player, eqipSlots)
    room:addPlayerMark(to, "yujin_target-turn")
    local targetRecorded = type(player:getMark("@@yujin_kill")) == "table" and
        player:getMark("@@yujin_kill") or {}
    table.insertIfNeed(targetRecorded, to.id)
    room:setPlayerMark(player, "@@yujin_kill", targetRecorded)
  end,
}
local sw_yujin_prohibit = fk.CreateProhibitSkill {
  name = "#sw_yujin_prohibit",
  prohibit_use = function(self, player, card)
    if player:getMark("yujin_target-turn") > 0 then
      local subcards = card:isVirtual() and card.subcards or { card.id }
      return #subcards > 0 and table.every(subcards, function(id)
        return table.contains(player:getCardIds(Player.Hand), id)
      end)
    end
  end,
  prohibit_response = function(self, player, card)
    if player:getMark("yujin_target-turn") > 0 then
      local subcards = card:isVirtual() and card.subcards or { card.id }
      return #subcards > 0 and table.every(subcards, function(id)
        return table.contains(player:getCardIds(Player.Hand), id)
      end)
    end
  end,
}
local sw_yujin_targetmod = fk.CreateTargetModSkill {
  name = "#sw_yujin_targetmod",
  bypass_times = function(self, player, skill, scope, card, to)
    if card and to then
      local targetRecorded = player:getMark("@@yujin_kill")
      return type(targetRecorded) == "table" and table.contains(targetRecorded, to.id)
    end
  end,
  bypass_distances = function(self, player, skill, card, to)
    if card and to then
      local targetRecorded = player:getMark("@@yujin_kill")
      return type(targetRecorded) == "table" and table.contains(targetRecorded, to.id)
    end
  end,
}
local sw_yujin_kill = fk.CreateTriggerSkill {
  name = "#sw_yujin_kill",
  anim_type = "offensive",
  events = { fk.EventPhaseStart },
  frequency = Skill.Compulsory,
  can_trigger = function(self, event, target, player, data)
    return target == player and player:hasSkill(self.name) and player.phase == player.Finish and
        player:usedSkillTimes("sw_yujin", Player.HistoryGame) > 0
  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.id ~= player.id and p.id
    end), 1, 1, "#yujin_kill-chos", self.name, true)
    if #to > 0 then
      local tar = room:getPlayerById(to[1])
      local chs = { "yujin1", "yujin2" }
      local chc = room:askForChoice(player, chs, self.name)
      if chc == "yujin1" then
        room:handleAddLoseSkills(tar, "sw_ranhui&", nil)
      else
        room:handleAddLoseSkills(tar, "sw_yanzang&", nil)
      end
    end
    room:killPlayer({ who = player.id })
  end,
}
sw_yujin:addRelatedSkill(sw_yujin_kill)
sw_yujin:addRelatedSkill(sw_yujin_targetmod)
sw_yujin:addRelatedSkill(sw_yujin_prohibit)
lingyan:addSkill(sw_yujin)
Fk:loadTranslationTable {
  ["sw_yujin"] = "余烬",
  ["#sw_yujin_kill"] = "余烬",
  [":sw_yujin"] = "限定技，出牌阶段，你令一名其他角色无法使用和打出牌直到回合结束，本回合你对其使用牌无距离和次数限制，若如此做，结束阶段，你选择一名其他角色，令其获得〖燃辉〗或〖焰葬〗，然后你死亡。",
  ["@@yujin_kill"] = "余烬",

  ["yujin1"] = "〖燃辉〗：【杀】造成伤害可以无限出杀",
  ["yujin2"] = "〖焰葬〗：【杀】指定目标可以转化手牌",
  ["#yujin_kill-chos"] = "余烬：请选择一名角色，令其获得〖燃辉〗或〖焰葬〗",
}
local sw_ranhui = fk.CreateTriggerSkill {
  name = "sw_ranhui&",
  frequency = Skill.Compulsory,
  events = { fk.DamageCaused },
  can_trigger = function(self, event, target, player, data)
    return target == player and player:hasSkill(self.name) and data.card and data.card.trueName == "slash"
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    room:notifySkillInvoked(player, self.name, "offensive")
    data.damage = data.damage - data.damage
    room:addPlayerMark(player, MarkEnum.SlashResidue .. "-phase", 1)
    room:damage {
      from = player,
      to = data.to,
      damage = 1,
      damageType = fk.FireDamage,
      skillName = self.name,
    }
  end,
}
Fk:addSkill(sw_ranhui)
Fk:loadTranslationTable {
  ["sw_ranhui&"] = "燃辉",
  [":sw_ranhui&"] = "锁定技，当你使用非虚拟【杀】造成伤害时，令此【杀】伤害降至0，然后对目标造成一点火焰伤害并令本阶段可使用的【杀】次数+1",
}
local sw_yanzang = fk.CreateTriggerSkill {
  name = "sw_yanzang&",
  switch_skill_name = "sw_yanzang&",
  frequency = Skill.Compulsory,
  events = { fk.TargetSpecified },
  can_trigger = function(self, event, target, player, data)
    return player:hasSkill(self.name) and data.card and #AimGroup:getAllTargets(data.tos) == 1 and
        data.to ~= player.id and player.phase == Player.Play
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    local to = player.room:getPlayerById(data.to)
    room:notifySkillInvoked(player, self.name, "switch")
    local n = math.min(player:usedSkillTimes(self.name, Player.HistoryPhase), player:getHandcardNum())
    local n2 = math.min(player:usedSkillTimes(self.name, Player.HistoryPhase), to:getHandcardNum())
    if player:getSwitchSkillState("sw_yanzang&", true) == fk.SwitchYang then
      local id1 = room:askForCard(player, n, n, false, self.name, false, ".", "yanzang-chos1:::" .. n)
      player:showCards(id1)
      room:delay(800)
      for _, id in ipairs(id1) do
        room:setCardMark(Fk:getCardById(id), "@@yanzang-turn", 1)
      end
    else
      local id2 = room:askForCard(to, n2, n2, false, self.name, false, ".", "yanzang-chos2:::" .. n2)
      player:showCards(id2)
      room:delay(800)
      for _, id in ipairs(id2) do
        room:setCardMark(Fk:getCardById(id), "@@yanzang-turn", 1)
      end
    end
  end,
}
local yanzang_skill_file = fk.CreateFilterSkill {
  name = "#yanzang_skill_file",
  mute = true,
  frequency = Skill.Compulsory,
  card_filter = function(self, card, player)
    return card:getMark("@@yanzang-turn") > 0
  end,
  view_as = function(self, card)
    local card = Fk:cloneCard("fire__slash", Card.NoSuit, card.number)
    card.skillName = self.name
    return card
  end,
}
sw_yanzang:addRelatedSkill(yanzang_skill_file)
Fk:addSkill(sw_yanzang)
Fk:loadTranslationTable {
  ["sw_yanzang&"] = "焰葬",
  ["#yanzang_skill_file"] = "焰葬",
  ["yanzang-chos1"] = "焰葬：选择%arg张牌，回合结束前视为火杀",
  ["yanzang-chos2"] = "焰葬：选择%arg张牌，回合结束前视为火杀",
  [":sw_yanzang&"] = "转换技，锁定技，出牌阶段内，当你使用牌指定除你外的唯一目标后，阳：你展示x张牌，阴：其展示x张牌；展示的牌于回合结束前视为无色的火【杀】且无距离限制（x为本回合技能的发动次数且至多不超过展示者的手牌数）",
  ["@@yanzang-turn"] = "焰葬",
}
local sw_mingshu = fk.CreateTriggerSkill {
  name = "sw_mingshu",
  frequency = Skill.Compulsory,
  events = { fk.GameStart },
  can_trigger = function(self, event, target, player, data)
    return player:hasSkill(self.name)
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    local chs = { "yujin1", "yujin2" }
    local chc = room:askForChoice(player, chs, self.name)
    if chc == "yujin1" then
      room:handleAddLoseSkills(player, "sw_ranhui&", nil)
    else
      room:handleAddLoseSkills(player, "sw_yanzang&", nil)
    end
  end,
}
lingyan:addSkill(sw_mingshu)
Fk:loadTranslationTable {
  ["sw__lingyan"] = "凌炎",
  ["sw_mingshu"] = "命数",
  [":sw_mingshu"] = "锁定技，游戏开始时，你选择〖燃辉〗或〖焰葬〗获得",
}
local caohuacaoxian = General(extension, "sw__caohuacaoxian", "huan", 4, 4, General.Female)
Fk:loadTranslationTable {
  ["sw__caohuacaoxian"] = "曹华曹宪",
}
local sw_huamu = fk.CreateTriggerSkill {
  name = "sw_huamu",
  mute = true,
  events = { fk.AfterCardsMove },
  frequency = Skill.Compulsory,
  can_trigger = function(self, event, target, player, data)
    if player:hasSkill(self) then
      for _, move in ipairs(data) do
        if move.toArea == Card.PlayerSpecial then
          for _, info in ipairs(move.moveInfo) do
            if info.fromArea ~= Card.PlayerSpecial then
              return table.find(player.room.alive_players, function(p)
                return (#p:getCardIds(Player.Hand) + #p:getCardIds(Player.Equip)) > 0 and
                    p.id ~= player.id
              end)
            end
          end
        end
        if move.toArea == Card.PlayerHand then
          for _, info in ipairs(move.moveInfo) do
            if info.fromArea == Card.PlayerSpecial then
              return table.find(player.room.alive_players, function(p)
                return (#p:getCardIds(Player.Hand) + #p:getCardIds(Player.Equip)) > 0 and
                    p.id ~= player.id
              end)
            end
          end
        end
      end
    end
  end,
  on_trigger = function(self, event, target, player, data)
    local dat = ""
    for _, move in ipairs(data) do
      if move.toArea == Card.PlayerSpecial then
        for _, info in ipairs(move.moveInfo) do
          if info.fromArea ~= Card.PlayerSpecial then
            dat = "chufa"
          end
        end
      end
      if move.toArea ~= Card.PlayerSpecial then
        for _, info in ipairs(move.moveInfo) do
          if info.fromArea == Card.PlayerSpecial then
            dat = "chufa"
          end
        end
      end
    end
    if dat ~= "" then
      self:doCost(event, target, player, dat)
    end
  end,
  on_cost = function(self, event, target, player, data)
    local room = player.room
    local targets
    if data == "chufa" then
      targets = table.map(table.filter(room.alive_players, function(p)
        return (#p:getCardIds(Player.Hand) + #p:getCardIds(Player.Equip)) > 0 and p.id ~= player.id
      end), Util.IdMapper)
    end
    local to = room:askForChoosePlayers(player, targets, 1, 1, "#sw_huamu-" .. data, self.name, true)
    if #to > 0 then
      self.cost_data = to[1]
      return true
    end
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    local to = room:getPlayerById(self.cost_data)
    if data == "chufa" then
      local chs = { "sw_huamu1", "sw_huamu2" }
      local chc = room:askForChoice(player, chs, self.name)
      if chc == "sw_huamu1" then
        room:notifySkillInvoked(player, self.name, "support")
        player:broadcastSkillInvoke(self.name)
        room:loseHp(player, 1, self.name)
        local cards1 = room:askForDiscard(to, 1, 2, true, self.name, false, ".", "#sw_huamu-discard")
        local draw1 = #cards1
        local equipC = table.filter(cards1, function(id)
          return Fk:getCardById(id).type == Card.TypeEquip
        end)
        if #equipC > 0 then
          draw1 = #cards1 + 1
        end
        to:drawCards(draw1)
        if #cards1 > 0 then
          local dummy = Fk:cloneCard("dilu")
          dummy:addSubcards(cards1)
          room:obtainCard(player, dummy, false, fk.ReasonPrey)
        end
        local tag = room:askForChoosePlayers(player, table.map(player.room.alive_players, function(p)
          return (#p:getCardIds(Player.Hand) + #p:getCardIds(Player.Equip)) > 0 and p.id
        end), 1, 1, "#sw_huamu-tagask", self.name, true)
        local targ = room:getPlayerById(tag[1])
        if #tag > 0 then
          local cards2 = room:askForDiscard(targ, 1, 2, true, self.name, false, ".", "#sw_huamu-discard")
          local draw2 = #cards2
          local equipC2 = table.filter(cards2, function(id)
            return Fk:getCardById(id).type == Card.TypeEquip
          end)
          if #equipC2 > 0 then
            draw2 = #cards2 + 1
          end
          targ:drawCards(draw2)
        end
      else
        room:notifySkillInvoked(player, self.name, "support")
        player:broadcastSkillInvoke(self.name)
        room:recover {
          who = player,
          num = 1,
          recoverBy = player,
          skillName = self.name
        }
        local chos = { "sw_huamu3" }
        if #to:getCardIds(Player.Equip) > 0 then
          table.insert(chos, "sw_huamu4")
        end
        local choc = room:askForChoice(to, chos, self.name)
        if choc == "sw_huamu4" then
          local cids = to:getCardIds("e")
          to:throwAllCards("e")
          if #cids > 0 then
            local dummy = Fk:cloneCard("dilu")
            dummy:addSubcards(cids)
            room:obtainCard(player, dummy, false, fk.ReasonPrey)
          end
        else
          room:damage({
            from = nil,
            to = to,
            damage = 1,
            damageType = fk.ThunderDamage,
            skillName = self.name
          })
        end
        local chosplayer = { "sw_huamu3" }
        if #player:getCardIds(Player.Equip) > 0 then
          table.insert(chosplayer, "sw_huamu4")
        end
        local chocplayer = room:askForChoice(player, chosplayer, self.name)
        if chocplayer == "sw_huamu4" then
          player:throwAllCards("e")
        else
          room:damage({
            from = nil,
            to = player,
            damage = 1,
            damageType = fk.ThunderDamage,
            skillName = self.name
          })
        end
      end
    end
  end,
}
caohuacaoxian:addSkill(sw_huamu)
Fk:loadTranslationTable {
  ["sw_huamu"] = "化木",
  [":sw_huamu"] = "锁定技，当有牌移入或移除游戏时，你选择一项：<br>" ..
      "①失去一点体力，依次选择对两名角色执行【树上开花】效果<br>" ..
      "②回复一点体力，对一名其他角色和你执行【水淹七军】效果<br>" ..
      "因此技能弃置且不由你弃置的牌由你获得",
  ["#sw_huamu-chufa"] = "化木：请选择一名角色，令其执行化木的效果",
  ["sw_huamu1"] = "失去一点体力，依次选择对两名角色执行【树上开花】效果",
  ["sw_huamu2"] = "回复一点体力，对一名其他角色和你执行【水淹七军】效果",
  ["#sw_huamu-discard"] = "树上开花：弃置至多两张牌，摸等量的牌，若包含装备牌，则额外摸一张牌",
  ["#sw_huamu-tagask"] = "请再选择一名角色，令其执行【树上开花】效果",
  ["sw_huamu3"] = "受到一点雷电伤害",
  ["sw_huamu4"] = "弃置所有装备区的牌",
}
local sw_liangyuan = fk.CreateTriggerSkill {
  name = "sw_liangyuan",
  anim_type = "drawcard",
  frequency = Skill.Compulsory,
  events = { fk.EventPhaseEnd },
  can_trigger = function(self, event, target, player, data)
    local red = #table.filter(player:getPile("sw_liangyuan_p&"),
      function(id) return Fk:getCardById(id, true).color == Card.Red end)
    local black = #player:getPile("sw_liangyuan_p&") - red
    if player:hasSkill(self) and target == player and player.phase == Player.Start then
      return player.hp > 1 and #player:getPile("sw_liangyuan_p&") < 6
    elseif player:hasSkill(self) and target == player and player.phase == Player.Play then
      return player:getMark("sw_liangyuan-turn") and
          ((#player:getPile("sw_liangyuan_p&") > 0 and red == black) or #player:getPile("sw_liangyuan_p&") == 0)
    end
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    if player.phase == Player.Start then
      local pile = 6 - #player:getPile("sw_liangyuan_p&")
      local n = math.min(player.hp - 1, pile)
      room:loseHp(player, n, self.name)
      local card = room:getNCards(n, "bottom")
      player:addToPile("sw_liangyuan_p&", card, true, self.name)
      room:setPlayerMark(player, "sw_liangyuan-turn", 1)
    elseif player.phase == Player.Play then
      if player:isWounded() then
        room:recover {
          who = player,
          num = player.maxHp - player.hp,
          recoverBy = player,
          skillName = self.name
        }
      end
    end
  end,
}
caohuacaoxian:addSkill(sw_liangyuan)
Fk:loadTranslationTable {
  ["sw_liangyuan"] = "良缘",
  ["sw_liangyuan_p&"] = "缘",
  [":sw_liangyuan"] = "准备阶段，若你的“缘”小于6，你失去X点体力，然后将牌堆底等量的牌置于武将牌上，称为“缘”(X为6减体力值且至多扣减至1血)；你可以将“缘”如手牌般使用或打出；出牌阶段结束时，若你本回合发动过该技能，且“缘”的黑色牌与红色牌数量相等，你回复体力至上限",
}
local sw_jisi = fk.CreateTriggerSkill {
  name = "sw_jisi",
  events = { fk.EnterDying },
  frequency = Skill.Limited,
  can_trigger = function(self, event, target, player, data)
    return player:hasSkill(self.name) and target == player and player.dying and
        player:usedSkillTimes(self.name, Player.HistoryGame) == 0
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    local cardIds = player:getPile("sw_liangyuan_p&")
    room:moveCards({
      from = player.id,
      ids = cardIds,
      toArea = Card.DiscardPile,
      moveReason = fk.ReasonPutIntoDiscardPile,
      skillName = self.name,
    })
    local chc = { "sw_jisi1", "sw_jisi2" }
    local chs = room:askForChoice(player, chc, self.name)
    if chs == "sw_jisi1" then
      room:changeHero(player, "sw__caohua", false, false, true)
    else
      room:changeHero(player, "sw__caoxian", false, false, Treasure)
    end
    room:recover {
      who = player,
      num = 1 - player.hp,
      recoverBy = player,
      skillName = self.name
    }
    if player:getMark("sw_jisi_kill") > 0 and (not player:hasSkill("sw_huamu") or not player:hasSkill("sw_liangyuan")) then
      local chcc = {}
      if not player:hasSkill("sw_huamu") then
        table.insert(chcc, "sw_huamu_give")
      end
      if not player:hasSkill("sw_liangyuan") then
        table.insert(chcc, "sw_liangyuan_give")
      end
      local chss = room:askForChoice(player, chcc, self.name)
      if chss == "sw_huamu_give" then
        room:handleAddLoseSkills(player, "sw_huamu")
      else
        room:handleAddLoseSkills(player, "sw_liangyuan")
      end
    end
  end,
}
local sw_jisi_death = fk.CreateTriggerSkill {
  name = "#sw_jisi_death",
  events = { fk.Death },
  frequency = Skill.Compulsory,
  mute = true,
  can_trigger = function(self, event, target, player, data)
    return player:hasSkill(self.name) and data.damage and data.damage.from == player
  end,
  on_use = function(self, event, target, player, data)
    player.room:setPlayerMark(player, "sw_jisi_kill", 1)
  end,
}
sw_jisi:addRelatedSkill(sw_jisi_death)
caohuacaoxian:addSkill(sw_jisi)
Fk:loadTranslationTable {
  ["sw_jisi"] = "羁肆",
  ["sw_jisi1"] = "曹华",
  ["sw_jisi2"] = "曹宪",
  ["sw_huamu_give"] = "获得【化木】",
  ["sw_liangyuan_give"] = "获得【良缘】",
  [":sw_jisi"] = "限定技，当你进入濒死状态时，你可以将武将变更为【曹华】或【曹宪】，然后回复体力至1点；若你此前击杀过其他角色，你可以选择保留【化木】或【良缘】",

  ["$sw_jisi1"] = "",
  ["$sw_jisi2"] = "",
}
local caohua = General(extension, "sw__caohua", "huan", 3, 3, General.Female)
Fk:loadTranslationTable {
  ["sw__caohua"] = "曹华",
}
local sw_caiyi = fk.CreateActiveSkill {
  name = "sw_caiyi",
  card_num = 0,
  target_num = 0,
  can_use = function(self, player)
    local red = #table.filter(player:getCardIds("h"), function(id) return Fk:getCardById(id).color == Card.Red end)
    local black = #table.filter(player:getCardIds("h"),
      function(id) return Fk:getCardById(id).color == Card.Black end)
    return player:usedSkillTimes(self.name, Player.HistoryPhase) == 0 and red ~= black
  end,
  card_filter = Util.FalseFunc,
  on_use = function(self, room, effect)
    local player = room:getPlayerById(effect.from)
    local num = 1 + player:getMark("@caiyi_shengji")
    local red = #table.filter(player:getCardIds("h"), function(id) return Fk:getCardById(id).color == Card.Red end)
    local black = #table.filter(player:getCardIds("h"),
      function(id) return Fk:getCardById(id).color == Card.Black end)
    local discard
    if red > black then
      local card1 = room:askForDiscard(player, red - black, red - black, false, self.name, false,
        ".|.|heart,diamond", "#sw_caiyi-red:::" .. red - black)
      if #card1 > 0 then
        if player:getMark("caiyi_shengji_no") > 0 then
          num = player:getMark("@caiyi_shengji") + 1
        else
          num = num + #card1
        end
        discard = num
      end
    else
      local card2 = room:askForDiscard(player, black - red, black - red, false, self.name, false, ".|.|spade,club",
        "#sw_caiyi-black:::" .. black - red)
      if #card2 > 0 then
        if player:getMark("caiyi_shengji_no") > 0 then
          num = player:getMark("@caiyi_shengji") + 1
        else
          num = num + #card2
        end
        discard = num
      end
    end
    if discard then
      if num > 0 then
        if player:getMark("@caiyi_shengji") < 3 and player:getMark("caiyi_shengji_no") == 0 then
          room:addPlayerMark(player, "@caiyi_shengji", 1)
        end
      end
      if num > 1 then
        local to = room:askForChoosePlayers(player, table.map(player.room.alive_players, function(p)
          return p.id
        end), 1, 1, "#sw_caiyi-tagask", self.name, true)
        local targ = room:getPlayerById(to[1])
        if #to > 0 then
          local n = targ:getHandcardNum() - targ.maxHp
          if n > 0 then
            room:askForDiscard(targ, n, n, false, self.name, false)
          else
            targ:drawCards(-n, self.name)
          end
        end
      end
      if num > 2 then
        room:setPlayerMark(player, "@@sw_caiyi_tar-turn", 1)
        local card = player:getCardIds("h")
        for _, id in ipairs(card) do
          room:setCardMark(Fk:getCardById(id), "@@sw_caiyi_tar-turn", 1)
        end
      end
      if num > 3 then
        -- local targets = {}
        -- local n = 0
        -- for _, p in ipairs(room:getOtherPlayers(player)) do
        --     if p.hp > n then
        --         n = p.hp
        --     end
        -- end
        -- for _, p in ipairs(room:getOtherPlayers(player)) do
        --     if p.hp == n then
        --         table.insert(targets, p.id)
        --     end
        -- end
        local targets = table.map(room.alive_players, Util.IdMapper)
        local to = room:askForChoosePlayers(player, targets, 1, 1, "#sw_caiyi-damage", self.name, true)
        if #to > 0 then
          room:loseHp(room:getPlayerById(to[1]), 1, self.name)
        end
      end
    end
  end,
}
local sw_caiyi_red = fk.CreateFilterSkill {
  name = "#sw_caiyi_red",
  mute = true,
  card_filter = function(self, card, player)
    return card.color == Card.Red and player:getMark("@@sw_caiyi_tar-turn") > 0
  end,
  view_as = function(self, card)
    return Fk:cloneCard("slash", Card.Heart, card.number)
  end,
}
local sw_caiyi_black = fk.CreateFilterSkill {
  name = "#sw_caiyi_black",
  mute = true,
  card_filter = function(self, card, player)
    return card.color == Card.Black and player:getMark("@@sw_caiyi_tar-turn") > 0
  end,
  view_as = function(self, card)
    return Fk:cloneCard("duel", Card.Spade, card.number)
  end,
}
local sw_caiyi_tar = fk.CreateTargetModSkill {
  name = "#sw_caiyi_tar",
  bypass_times = function(self, player, skill, scope, card)
    return player:hasSkill(sw_caiyi.name) and card and card:getMark("@@sw_caiyi_tar-turn") > 0
  end,
}
sw_caiyi:addRelatedSkill(sw_caiyi_tar)
sw_caiyi:addRelatedSkill(sw_caiyi_red)
sw_caiyi:addRelatedSkill(sw_caiyi_black)
caohua:addSkill(sw_caiyi)
Fk:loadTranslationTable {
  ["sw_caiyi"] = "彩翼",
  ["#sw_caiyi_red"] = "彩翼",
  ["#sw_caiyi_black"] = "彩翼",
  ["#sw_caiyi-red"] = "弃置 %arg 张红色牌",
  ["#sw_caiyi-black"] = "弃置 %arg 张黑色牌",
  ["#sw_caiyi-tagask"] = "选择一名角色，令其将手牌调整至体力上限",
  ["@@sw_caiyi_tar-turn"] = "彩翼",
  ["@caiyi_shengji"] = "彩翼升级",
  ["#sw_caiyi-damage"] = "选择一名角色，令其失去一点体力",
  [":sw_caiyi"] = "出牌阶段限一次，你可以将手牌中黑色和红色的牌弃至相同，然后依次执行1+X项(X为你弃置的牌数)：<br>" ..
      "①升级该技能，每次升级依次获得以下一项<br>" ..
      "②令一名角色将手牌调整至体力上限<br>" ..
      "③本回合黑色/红色牌视为不限次数的【决斗】/【杀】<br>" ..
      "④令一名其他角色失去一点体力<br>" ..
      "若通过【归离】获得，则无法升级",
}
local sw_guili = fk.CreateTriggerSkill {
  name = "sw_guili",
  anim_type = "negative",
  events = { fk.EnterDying },
  frequency = Skill.Limited,
  can_trigger = function(self, event, target, player, data)
    return target == player and player:hasSkill(self.name) and player:getMark("@caiyi_shengji") > 0 and
        player:usedSkillTimes(self.name, Player.HistoryGame) == 0
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    local targets = table.map(table.filter(room:getAlivePlayers(), function(p)
      return not p:hasSkill("sw_caiyi")
    end), function(p) return p.id end)
    if #targets == 0 then return end
    local to = room:askForChoosePlayers(player, targets, 1, 1, "#sw_guili-askchos", self.name, true)
    if #to > 0 then
      local tar = room:getPlayerById(to[1])
      local n = player:getMark("@caiyi_shengji")
      room:handleAddLoseSkills(tar, "sw_caiyi", nil, true, false)
      room:setPlayerMark(tar, "@caiyi_shengji", n)
      room:setPlayerMark(tar, "caiyi_shengji_no", 1)
    end
  end,
}
caohua:addSkill(sw_guili)
Fk:loadTranslationTable {
  ["sw_guili"] = "归离",
  ["#sw_guili-askchos"] = "归离：请选择一名存活的角色，令其获得【彩翼】",
  [":sw_guili"] = "限定技，你进入濒死状态时，若你的【彩翼】已升级，你可以选择一名存活的角色，令其获得当前升级状态的【彩翼】",

  ["$sw_guili1"] = "",
  ["$sw_guili2"] = "",
}
local caoxian = General(extension, "sw__caoxian", "huan", 3, 3, General.Female)
local sw_lingxit = fk.CreateTriggerSkill {
  name = "sw_lingxit",
  mute = true,
  frequency = Skill.Compulsory,
  events = { fk.TurnStart, fk.TurnEnd, fk.AfterCardsMove, fk.GameStart },
  can_trigger = function(self, event, target, player, data)
    if not player:hasSkill(self) then return false end
    if event == fk.AfterCardsMove then
      for _, move in ipairs(data) do
        if move.from == player.id then
          for _, info in ipairs(move.moveInfo) do
            if info.fromSpecialName == "sw_lingxi_wing" then
              return true
            end
          end
        end
      end
      for _, move in ipairs(data) do
        if move.to == player.id and move.toArea == Card.PlayerSpecial and move.specialName == "sw_lingxi_wing" then
          return true
        end
      end
    elseif event == fk.GameStart then
      return not player:isNude() and #player:getPile("sw_lingxi_wing") < 4
    else
      return target == player and not player:isNude() and #player:getPile("sw_lingxi_wing") < 4
    end
  end,
  on_cost = function(self, event, target, player, data)
    if event == fk.AfterCardsMove then return true end
    local room = player.room
    local card = room:askForCard(player, 1, 4 - #player:getPile("sw_lingxi_wing"), true, self.name, true, ".",
      "#sw_lingxit-put")
    if #card > 0 then
      self.cost_data = card
      return true
    end
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    player:broadcastSkillInvoke(self.name)
    if event == fk.AfterCardsMove then
      local suits = {}
      for _, id in ipairs(player:getPile("sw_lingxi_wing")) do
        local suit = Fk:getCardById(id).suit
        table.insertIfNeed(suits, suit)
      end
      local x = (2 * #suits) - player:getHandcardNum()
      if x == 0 then return false end
      if x > 0 then
        room:notifySkillInvoked(player, self.name, "drawcard")
        player:drawCards(x, self.name)
      else
        room:notifySkillInvoked(player, self.name, "negative")
        room:askForDiscard(player, -x, -x, false, self.name, false)
      end
    else
      room:notifySkillInvoked(player, self.name, "special")
      player:drawCards(1)
      local dummy = Fk:cloneCard("dilu")
      dummy:addSubcards(self.cost_data)
      player:addToPile("sw_lingxi_wing", dummy, true, self.name)
    end
  end,
}
caoxian:addSkill(sw_lingxit)
Fk:loadTranslationTable {
  ["sw_lingxit"] = "灵犀",
  [":sw_lingxit"] = "锁定技，游戏开始时，出牌阶段开始时或结束时，你可以将至少一张牌置于你的武将牌上，称为“翼”(至多四张)。当你的“翼”改变后，你将手牌调整至“翼”包含的花色数的两倍。",
  ["#sw_lingxit-put"] = "灵犀：将至少一张张牌置入“翼”",
  ["sw_lingxi_wing"] = "翼",
}
local sw_zhifou = fk.CreateTriggerSkill {
  name = "sw_zhifou",
  anim_type = "drawcard",
  events = { fk.CardUsing },
  can_trigger = function(self, event, target, player, data)
    local suits = {}
    for _, id in ipairs(player:getPile("sw_lingxi_wing")) do
      local suit = Fk:getCardById(id).suit
      table.insertIfNeed(suits, suit)
    end
    return target == player and player:hasSkill(self) and
        player.phase < Player.PhaseNone and self.can_sw_zhifou and
        player:usedSkillTimes(self.name, Player.HistoryTurn) < #suits and #player:getPile("sw_lingxi_wing") > 0
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    local card = room:askForCard(player, 1, 1, false, self.name, true, ".|.|.|sw_lingxi_wing",
      "#sw_zhifou-dis", "sw_lingxi_wing")
    if #card > 0 then
      room:moveCardTo(card, Card.DiscardPile, nil, fk.ReasonPutIntoDiscardPile, self.name, "sw_lingxi_wing")
      local cards = {}
      for _, t in ipairs(room.alive_players) do
        table.insertTable(cards, t.player_cards[Player.Equip])
        table.insertTable(cards, t.player_cards[Player.Judge])
      end
      if #cards > 0 then
        room:fillAG(player, cards)
        local id = room:askForAG(player, cards, true, self.name)
        room:closeAG(player)
        if id > 0 then
          room:obtainCard(player, id, false)
          local cid = Fk:getCardById(id)
          room:setCardMark(cid, "@@sw_zhifou-turn", 1)
          if cid.color == Card.Red then
            local success, dat = room:askForUseViewAsSkill(target, "sw_zhifou_viewas1", "#sw_zhifou-fire",
              true)
            if success then
              local cardA = Fk.skills["sw_zhifou_viewas1"]:viewAs(dat.cards)
              room:useCard {
                from = target.id,
                tos = table.map(dat.targets, function(p) return { p } end),
                card = cardA,
                extraUse = true,
              }
            else
              for _, cds in ipairs(player.player_cards[Player.Hand]) do
                if Fk:getCardById(cds):getMark("@@sw_zhifou-turn") > 0 then
                  room:throwCard(cds, self.name, player, player)
                end
              end
            end
          else
            local success, dat = room:askForUseViewAsSkill(target, "sw_zhifou_viewas2", "#sw_zhifou-chai",
              true)
            if success then
              local cardB = Fk.skills["sw_zhifou_viewas2"]:viewAs(dat.cards)
              room:useCard {
                from = target.id,
                tos = table.map(dat.targets, function(p) return { p } end),
                card = cardB,
                extraUse = true,
              }
            else
              for _, cds in ipairs(player.player_cards[Player.Hand]) do
                if Fk:getCardById(cds):getMark("@@sw_zhifou-turn") > 0 then
                  room:throwCard(cds, self.name, player, player)
                end
              end
            end
          end
        end
      else
        player:drawCards(1)
      end
    end
  end,

  refresh_events = { fk.CardUsing, fk.EventPhaseStart },
  can_refresh = function(self, event, target, player, data)
    if not (target == player and player:hasSkill(self)) then return end
    if event == fk.EventPhaseStart then
      return player.phase == Player.NotActive
    else
      return player.phase < Player.PhaseNone -- FIXME: this is a bug of FK 0.0.2!!
    end
  end,
  on_refresh = function(self, event, target, player, data)
    local room = player.room
    if event == fk.EventPhaseStart then
      room:setPlayerMark(player, self.name, 0)
      room:setPlayerMark(player, "@" .. self.name, 0)
    else
      self.can_sw_zhifou = data.card.color ~= player:getMark(self.name) and player:getMark(self.name) ~= 0
      room:setPlayerMark(player, self.name, data.card.color)
      room:setPlayerMark(player, "@" .. self.name, data.card:getColorString())
    end
  end,
}
local sw_zhifou_viewas1 = fk.CreateViewAsSkill {
  name = "sw_zhifou_viewas1",
  pattern = "fire_attack",
  card_filter = function(self, to_select, selected)
    return #selected == 0 and Fk:getCardById(to_select):getMark("@@sw_zhifou-turn") > 0
  end,
  view_as = function(self, cards)
    if #cards ~= 1 then return end
    local card = Fk:cloneCard("fire_attack")
    card:addSubcard(cards[1])
    card.skillName = "sw_zhifou"
    return card
  end,
}
local sw_zhifou_viewas2 = fk.CreateViewAsSkill {
  name = "sw_zhifou_viewas2",
  pattern = "dismantlement",
  card_filter = function(self, to_select, selected)
    return #selected == 0 and Fk:getCardById(to_select):getMark("@@sw_zhifou-turn") > 0
  end,
  view_as = function(self, cards)
    if #cards ~= 1 then return end
    local card = Fk:cloneCard("dismantlement")
    card:addSubcard(cards[1])
    card.skillName = "sw_zhifou"
    return card
  end,
}
Fk:addSkill(sw_zhifou_viewas1)
Fk:addSkill(sw_zhifou_viewas2)
caoxian:addSkill(sw_zhifou)
Fk:loadTranslationTable {
  ["sw_zhifou"] = "知否",
  ["sw_zhifou_viewas1"] = "知否",
  ["sw_zhifou_viewas2"] = "知否",
  ["@sw_zhifou"] = "",
  ["@@sw_zhifou-turn"] = "知否",
  ["sw_lingxi_wing"] = "翼",
  ["#sw_zhifou-fire"] = "使用【火攻】？",
  ["#sw_zhifou-chai"] = "使用【过河拆桥】？",
  ["#sw_zhifou-dis"] = "你可以移去一张翼，将场上一张黑牌当过河拆桥或一张红色牌火攻使用",
  [":sw_zhifou"] = "每回合限X次，若你有“翼”，当你使用与上一张颜色不同的牌时，你可以移去一枚“翼”，然后执行：<br>" ..
      "①将场上一张红色牌当火攻使用；<br>" ..
      "②将场上一张黑色牌当过河拆桥使用；<br>" ..
      "若场上没有牌，你摸一张牌；若你于回合外使用了牌，则记录颜色持续至你的回合结束(X为翼中的花色数)",
}
Fk:loadTranslationTable {
  ["sw__caoxian"] = "曹宪",
}

local sw_xieyi = General(extension, "sw__xieyi", "huan", 4, 4, General.Female)
local sw_lingye = fk.CreateTriggerSkill {
  name = "sw_lingye",
  anim_type = "offensive",
  frequency = Skill.Compulsory,
  events = { fk.DamageCaused },
  can_trigger = function(self, event, target, player, data)
    return target == player and player:hasSkill(self) and data.skillName ~= self.name
  end,
  on_cost = function(self, event, target, player, data)
    return player.room:askForSkillInvoke(player, self.name, nil, "lingye-ask:" .. data.to.id)
  end,
  on_use = function(self, event, target, player, data)
    if data.damageType ~= 4 then
      data.damageType = 4
    end
    if not data.to:isNude() and data.damageType == 4 then
      player.room:loseHp(player, 1, self.name)
      player.room:broadcastPlaySound("./packages/standard_cards/audio/card/ice_sword")
      player.room:setEmotion(player, "./packages/standard_cards/image/anim/ice_sword")
      for i = 1, 2, 1 do
        if player.dead or data.to.dead or data.to:isNude() then
          break
        end
        local card = player.room:askForCardsChosen(player, data.to, 1, 1, "he", self.name)
        if #card > 0 then
          player.room:throwCard(card, self.name, data.to, player)
        end
      end
      player.room:damage {
        from = player,
        to = data.to,
        damage = data.damage,
        damageType = fk.IceDamage,
        skillName = self.name,
      }
      return true
    end
  end,
}
sw_xieyi:addSkill(sw_lingye)
Fk:loadTranslationTable {
  ["sw_lingye"] = "零叶",
  ["sw__xieyi"] = "谢仪",
  ["lingye-ask"] = "是否对 %src 发动零叶",
  [":sw_lingye"] = "当你造成伤害时，你可以失去一点体力，对其发动寒冰剑，然后将此伤害转为冰冻伤害",
}
local sw_xifeng = fk.CreateTriggerSkill {
  name = "sw_xifeng",
  anim_type = "switch",
  switch_skill_name = "sw_xifeng",
  events = { fk.Damaged, fk.AfterCardsMove },
  can_trigger = function(self, event, target, player, data)
    if not player:hasSkill(self) then return end
    if event == fk.Damaged then
      return player:getSwitchSkillState("sw_xifeng") == fk.SwitchYang and target == player
    elseif event == fk.AfterCardsMove then
      if player:getSwitchSkillState("sw_xifeng") == fk.SwitchYin then
        for _, move in ipairs(data) do
          if move.from == player.id and move.moveReason == fk.ReasonDiscard and move.toArea == Card.DiscardPile then
            for _, info in ipairs(move.moveInfo) do
              if info.fromArea == Card.PlayerHand or info.fromArea == Card.PlayerEquip then
                return true
              end
            end
          end
        end
      end
    end
  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.id
    end), 1, 1, "#sw_xifeng-chose", self.name, true)
    if #to > 0 then
      local use1 = {
        from = player.id,
        tos = { { to[1] } },
        card = Fk:cloneCard("slash"),
        extraUse = true,
      }
      use1.card.skillName = self.name
      room:useCard(use1)
    end
  end,
}
sw_xieyi:addSkill(sw_xifeng)
Fk:loadTranslationTable {
  ["sw_xifeng"] = "汐锋",
  ["#sw_xifeng-chose"] = "汐锋：请选择使用【杀】的目标",
  [":sw_xifeng"] = "转换技，阳：当你受到伤害后；阴：当你的牌因弃置而进入弃牌堆时，你可以视为使用一张无视距离且不计次数的【杀】",
}

local sw_xuyuan = General(extension, "sw__xuyuan", "huan", 4, 4, General.Male)
local sw_xingchui = fk.CreateTriggerSkill {
  name = "sw_xingchui",
  anim_type = "offensive",
  events = { fk.Damage, fk.Damaged },
  can_trigger = function(self, event, target, player, data)
    if not player:hasSkill(self) then return false end
    if event == fk.Damage then
      return target == player and not data.to.dead and not player.dead and data.to ~= player
    else
      return target == player and not data.from.dead and not player.dead and data.from ~= player
    end
  end,
  on_cost = function(self, event, target, player, data)
    local tar
    if event == fk.Damage then
      tar = data.to.id
    elseif event == fk.Damaged then
      tar = data.from.id
    end
    return player.room:askForSkillInvoke(player, self.name, nil, "sw_xingchui-ask:" .. tar)
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    local tar
    if event == fk.Damage then
      tar = data.to
    elseif event == fk.Damaged then
      tar = data.from
    end
    local cards = tar:drawCards(2, self.name)
    tar:showCards(cards)
    room:delay(800)
    if Fk:getCardById(cards[1]).type ~= Fk:getCardById(cards[2]).type and not tar:isKongcheng() then
      local chc = room:askForChoice(tar, { "sw_xingchuifeng", "sw_xingchuigei:" .. player.id }, self.name)
      if chc == "sw_xingchuifeng" then
        room:setPlayerMark(tar, "@@sw_xingchui", 1)
      else
        local chostypecard
        local typecard = {}
        local basic = table.filter(tar:getCardIds("h"),
          function(id) return Fk:getCardById(id).type == Card.TypeBasic end)
        if #basic > 0 then
          table.insertIfNeed(typecard, "basic")
        end
        local trick = table.filter(tar:getCardIds("h"),
          function(id) return Fk:getCardById(id).type == Card.TypeTrick end)
        if #trick > 0 then
          table.insertIfNeed(typecard, "trick")
        end
        local equip = table.filter(tar:getCardIds("h"),
          function(id) return Fk:getCardById(id).type == Card.TypeEquip end)
        if #equip > 0 then
          table.insertIfNeed(typecard, "equip")
        end
        local chstype = room:askForChoice(tar, typecard, self.name,
          "#sw_xingchui-ask:" .. player.id)
        if chstype == "basic" then
          chostypecard = Card.TypeBasic
        elseif chstype == "trick" then
          chostypecard = Card.TypeTrick
        elseif chstype == "equip" then
          chostypecard = Card.TypeEquip
        end
        local ids = table.filter(tar:getCardIds("h"),
          function(id) return Fk:getCardById(id).type == chostypecard end)
        if #ids > 0 then
          local dummy = Fk:cloneCard("dilu")
          dummy:addSubcards(ids)
          room:moveCardTo(dummy, Card.PlayerHand, player, fk.ReasonGive, self.name, nil, true, player.id)
        end
      end
    end
  end,

  refresh_events = { fk.TurnStart },
  can_refresh = function(self, event, target, player, data)
    return target == player and player:getMark("@@sw_xingchui") ~= 0
  end,
  on_refresh = function(self, event, target, player, data)
    player.room:setPlayerMark(player, "@@sw_xingchui", 0)
  end,
}
local sw_xingchui_prohibit = fk.CreateProhibitSkill {
  name = "#sw_xingchui_prohibit",
  prohibit_use = function(self, player, card)
    return player:getMark("@@sw_xingchui") > 0
  end,
  prohibit_response = function(self, player, card)
    return player:getMark("@@sw_xingchui") > 0
  end,
}
sw_xingchui:addRelatedSkill(sw_xingchui_prohibit)
sw_xuyuan:addSkill(sw_xingchui)
Fk:loadTranslationTable {
  ["sw__xuyuan"] = "许愿",
  ["designer:sw__xuyuan"] = "许愿",
  ["sw_xingchui"] = "星垂",
  [":sw_xingchui"] = "当你造成/受到伤害后，你可令目标/来源摸两张牌并展示，若类别不同，其需交给你一种类别的所有手牌或不能使用或打出牌直至其回合开始。",

  ["sw_xingchui-ask"] = "星垂：是否令 %src 摸两张牌？",
  ["sw_xingchuifeng"] = "无法使用或打出手牌",
  ["sw_xingchuigei"] = "交给 %src 一种牌",
  ["#sw_xingchui-ask"] = "星垂：请选择要交给 %src 的卡牌类别",
  ["@@sw_xingchui"] = "星垂",
}
local sw_yewang = fk.CreateTriggerSkill {
  name = "sw_yewang",
  events = { fk.RoundStart },
  frequency = Skill.Compulsory,
  can_trigger = function(self, event, target, player, data)
    if player:hasSkill(self) then
      return true
    end
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    local n = #player:getCardIds("h")
    local targets = table.filter(room.alive_players,
      function(p) return p ~= player and p:getHandcardNum() ~= player:getHandcardNum() end)
    for _, p in ipairs(targets) do
      if #p:getCardIds("h") > n then
        local cards = room:askForDiscard(p, #p:getCardIds("h") - n, #p:getCardIds("h") - n, false,
          self.name,
          false, nil, "#sw_yewang-discards:::" .. #p:getCardIds("h") - n)
        local douse = false
        if #cards > 0 then
          local ids = {}
          for _, id in ipairs(cards) do
            local card = Fk:getCardById(id)
            if card.trueName ~= "jink" and card.trueName ~= "nullification" then
              if room:getCardArea(card) == Card.DiscardPile then
                table.insertIfNeed(ids, card:getEffectiveId())
              end
            end
          end
          if #ids == 0 then return false end
          if #p:getCardIds("h") == 0 or table.find(ids, function(id)
                return Fk:getCardById(id).is_damage_card
              end) then
            douse = true
          end
          if douse == true then
            local use = U.askForUseRealCard(room, p, ids, ".", self.name, "#sw_yewang-use", { expand_pile = ids })
            if use then
              player:drawCards(1, self.name)
            end
          end
        end
      elseif #p:getCardIds("h") < n then
        p:drawCards(n - #p:getCardIds("h"), self.name)
        if not p.dead and not player.dead then
          local chc = room:askForChoice(p, { "yewang_give:" .. player.id, "yewang_damage:" .. player.id }, self.name,
            "#yewang-ask:" .. player.id)
          if chc == "yewang_damage:" .. player.id then
            room:damage {
              from = player,
              to = p,
              damage = 1,
              skillName = self.name,
            }
          else
            local ids
            if #p:getCardIds("h") > 2 then
              ids = room:askForCard(p, 2, 2, false, self.name, true, nil, "#yewang_givecard:" .. player.id)
            else
              ids = p:getCardIds("h")
            end
            local dummy = Fk:cloneCard("dilu")
            dummy:addSubcards(ids)
            room:moveCardTo(dummy, Card.PlayerHand, player, fk.ReasonGive, self.name, nil, true, player.id)
          end
        end
      end
    end
  end,

  refresh_events = { fk.EventLoseSkill },
  can_refresh = function(self, event, target, player, data)
    return player == target and data == self
  end,
  on_refresh = function(self, event, target, player, data)
    player.room:handleAddLoseSkills(player, "sw_yewang", nil, true, false)
  end,
}
sw_yewang.permanent_skill = true
sw_xuyuan:addSkill(sw_yewang)
Fk:loadTranslationTable {
  ["sw_yewang"] = "烨望",
  [":sw_yewang"] = "法则技，每轮开始时，所有其他角色需将手牌调整至与你相同，因此弃置了伤害牌或弃置了所有手牌的角色，其可以使用其中一张牌并令你摸一张牌，因此摸牌的角色需受到你造成的一点伤害或交给你两张牌。" ..
      "<br><font color='grey'>#法则技：该技能不会因任何原因被无效或失去",

  ["#sw_yewang-discards"] = "烨望：你需弃置 %arg 张牌",
  ["#sw_yewang-use"] = "烨望：请选择你要使用的牌",

  ["yewang_give"] = "交给 %src 两张牌",
  ["#yewang_givecard"] = "烨望：请选择交给 %src 的两张牌",
  ["#yewang-ask"] = "%src对你发动了烨望，请选择一项",
  ["yewang_damage"] = "受到%src造成的一点伤害",
}
local sw_yingxuan = fk.CreateTriggerSkill {
  name = "sw_yingxuan$",
  anim_type = "drawcard",
  events = { fk.EventPhaseStart },
  can_trigger = function(self, event, target, player, data)
    return target ~= player and player:hasSkill(self) and target.kingdom == "huan" and not target:isNude() and
        target.phase == Player.Start
  end,
  on_cost = function(self, event, target, player, data)
    return player.room:askForSkillInvoke(target, self.name, nil, "#sw_yingxuan-invoke:" .. player.id)
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    local card = room:askForCard(target, 1, 1, false, self.name, true, nil, "#sw_yingxuanchos:" .. player.id)
    room:moveCardTo(card, Player.Hand, player, fk.ReasonGive, self.name, nil, false, player.id)
    room:setPlayerMark(player, "sw_yingxuan-turn", Fk:getCardById(card[1]).name)
    local chc = { "Yyewang:" .. player.id }
    if Fk:getCardById(card[1]):isCommonTrick() or (Fk:getCardById(card[1]).trueName ~= "jink" and Fk:getCardById(card[1]).trueName ~= "nullification") then
      table.insertIfNeed(chc, "Yusecard:" .. player.id)
    end
    local chs = room:askForChoice(target, chc, self.name,
      "#sw_yingxuan-ask:" .. player.id)
    if chs == "Yyewang:" .. player.id then
      sw_yewang:trigger(fk.RoundStart, player, player, nil)
    else
      local success, data = room:askForUseActiveSkill(player, "xuyuan_viewas", "#sw_yingxuan-choice", true)
      if success then
        local ids = Fk.skills["xuyuan_viewas"]:viewAs(data.cards)
        local use = {
          from = player.id,
          tos = table.map(data.targets, function(id) return { id } end),
          card = ids,
          extraUse = true,
        }
        room:useCard(use)
      end
    end
  end,
}
local xuyuan_viewas = fk.CreateViewAsSkill {
  name = "xuyuan_viewas",
  interaction = function()
    local name = {}
    local card = Self:getMark("sw_yingxuan-turn")
    table.insert(name, card)
    if #name == 0 then return false end
    return UI.ComboBox { choices = name }
  end,
  card_filter = Util.FalseFunc,
  view_as = function(self, cards)
    if not self.interaction.data then return end
    local card = Fk:cloneCard(self.interaction.data)
    card.skillName = "sw_yingxuan"
    return card
  end,
}
Fk:addSkill(xuyuan_viewas)
sw_xuyuan:addSkill(sw_yingxuan)
Fk:loadTranslationTable {
  ["sw_yingxuan"] = "荧悬",
  [":sw_yingxuan"] = "主公技，其他幻势力角色的准备阶段，其可以交给你一张牌，令你发动〖烨望〗或视为使用此牌(仅普通锦囊牌和基本牌)。",

  ["#sw_yingxuan-invoke"] = "荧悬：是否交给 %src 一张牌",
  ["#sw_yingxuanchos"] = "荧悬：请选择要交个 %src 的牌",
  ["#sw_yingxuan-ask"] = "荧悬：请选择令 %src 执行的效果",
  ["#sw_yingxuan-choice"] = "荧悬：请选择要使用的牌和目标",
  ["Yusecard"] = "令%src使用此牌",
  ["Yyewang"] = "令%src发动烨望",
  ["xuyuan_viewas"] = "荧悬",
}
return extension