local extension = Package:new("sw_zhu")
extension.extensionName = "MahjongSoul"
extension.game_modes_blacklist = { "as_StonehengEarena_mode" }
Fk:loadTranslationTable {
  ["sw_zhu"] = "神武-协力",
  ["sww"] = "神武",
  ["jyex"] = "神武",
  ["swex"] = "神武",
}
local U = require "packages/utility/utility"
local zhoufei = General(extension, "sww__zhoufei", "wu", 3, 3, General.Female)
local sw_lingkong = fk.CreateTriggerSkill {
  name = "sw_lingkong",
  anim_type = "drawcard",
  frequency = Skill.Compulsory,
  events = { fk.AfterDrawInitialCards, fk.AfterCardsMove },
  can_trigger = function(self, event, target, player, data)
    if not player:hasSkill(self) then return false end
    if event == fk.AfterDrawInitialCards then
      return player:getHandcardNum() > 0 and target == player
    else
      if player:getHandcardNum() > 3 or player:getMark("sw_lingkong-turn") > 0 then return false end
      for _, move in ipairs(data) do
        if 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,
  on_use = function(self, event, target, player, data)
    local room = player.room
    if event == fk.AfterCardsMove then
      room:addPlayerMark(player, "sw_lingkong-turn")
      local cards = player:drawCards(4 - player:getHandcardNum(), self.name)
      for _, id in ipairs(cards) do
        if table.contains(player:getCardIds("h"), id) then
          room:setCardMark(Fk:getCardById(id), "@@sw_lingkong-inhand", 1)
        end
      end
    else
      for _, id in ipairs(player:getCardIds("h")) do
        room:setCardMark(Fk:getCardById(id), "@@sw_lingkong-inhand", 1)
      end
    end
  end,
}
local sw_lingkong_maxcards = fk.CreateMaxCardsSkill {
  name = "#sw_lingkong_maxcards",
  exclude_from = function(self, player, card)
    return card:getMark("@@sw_lingkong-inhand") > 0
  end,
}
sw_lingkong:addRelatedSkill(sw_lingkong_maxcards)
zhoufei:addSkill(sw_lingkong)

local sw_qilu = fk.CreateActiveSkill {
  name = "sw_qilu",
  mute = true,
  target_num = 1,
  can_use = function(self, player)
    return player:getMark("sw_qilu_recover-phase") == 0 or player:getMark("sw_qilu_losehp-phase") == 0
  end,
  interaction = function()
    local choices = {}
    for _, s in ipairs({ "sw_qilu_recover", "sw_qilu_losehp" }) do
      if Self:getMark(s .. "-phase") == 0 then
        table.insert(choices, s)
      end
    end
    return UI.ComboBox { choices = choices }
  end,
  card_filter = function(self, to_select, selected)
    local card = Fk:getCardById(to_select)
    return not Self:prohibitDiscard(card) and card:getMark("@@sw_lingkong-inhand") > 0
  end,
  target_filter = function(self, to_select, selected, cards)
    local to = Fk:currentRoom():getPlayerById(to_select)
    if #selected == 0 then
      if self.interaction.data == "sw_qilu_recover" then
        return #cards == to:getLostHp() and to:isWounded()
      else
        return #cards == to.hp
      end
    end
  end,
  on_use = function(self, room, effect)
    local player = room:getPlayerById(effect.from)
    local to = room:getPlayerById(effect.tos[1])
    room:addPlayerMark(player, self.interaction.data .. "-phase")
    local cards = effect.cards
    if #cards > 0 then
      room:throwCard(cards, self.name, player, player)
    end
    if self.interaction.data == "sw_qilu_recover" then
      room:notifySkillInvoked(player, self.name, "support")
      player:broadcastSkillInvoke(self.name, 1)
      if not to.dead and to:isWounded() then
        room:recover { num = 1, skillName = self.name, who = to, recoverBy = player }
      end
    else
      room:notifySkillInvoked(player, self.name, "offensive")
      player:broadcastSkillInvoke(self.name, 2)
      room:loseHp(to, 1, self.name)
    end
  end,
}

zhoufei:addSkill(sw_qilu)

Fk:loadTranslationTable {
  ["sww__zhoufei"] = "周妃",

  ["sw_lingkong"] = "灵箜",
  [":sw_lingkong"] = "锁定技，你的初始手牌标记为“箜篌”；“箜篌”不计入你的手牌上限；每回合限一次，当你失去手牌时，若手牌小于四张，摸至四张，以此法摸的牌标记为“箜篌”。",
  ["@@sw_lingkong-inhand"] = "箜篌",

  ["sw_qilu"] = "泣露",
  [":sw_qilu"] = "出牌阶段每项限一次，你可以：1.弃置X张“箜篌”令一名角色回复一点体力（X为其已损失体力值）；2.弃置Y张“箜篌”令一名角色失去一点体力（Y为其当前体力值）。",
  ["sw_qilu_recover"] = "回复体力",
  ["sw_qilu_losehp"] = "失去体力",

  ["$sw_lingkong1"] = "灵箜有意解相思，夕照独倚楼外楼。",
  ["$sw_lingkong2"] = "青山不解秋心意，绿衣落华秋色收。",
  ["$sw_qilu1"] = "凭此箜篌引，思君为我心。",
  ["$sw_qilu2"] = "一曲新月白，数曲暮山青。",
  ["~sww__zhoufei"] = "为谁丹青画黛眉........",
}

local himiko = General(extension, "sww__himiko", "qun", 3, 3, General.Female)
local sw_zongkui = fk.CreateTriggerSkill {
  name = "sw_zongkui",
  anim_type = "control",
  frequency = Skill.Compulsory,
  events = { fk.Damage, fk.RoundStart },
  can_trigger = function(self, event, target, player, data)
    if event == fk.Damage then
      return player:hasSkill(self) and player == target and data.to ~= player and not data.to.dead
    else
      return player:hasSkill(self)
    end
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    if event == fk.Damage then
      room:addPlayerMark(data.to, "@sw__puppet")
    else
      local min_num = 999
      for _, p in ipairs(room:getOtherPlayers(player)) do
        min_num = math.min(min_num, p:getMark("@sw__puppet"))
      end
      local tos = {}
      for _, p in ipairs(room:getOtherPlayers(player)) do
        if p:getMark("@sw__puppet") == min_num then
          table.insert(tos, p)
        end
      end
      if #tos == 0 then return end
      room:addPlayerMark(table.random(tos), "@sw__puppet")
    end
  end,
}

himiko:addSkill(sw_zongkui)

local sw_guju = fk.CreateTriggerSkill {
  name = "sw_guju",
  anim_type = "drawcard",
  events = { fk.DamageInflicted, fk.Death },
  frequency = Skill.Compulsory,
  can_trigger = function(self, event, target, player, data)
    return target:getMark("@sw__puppet") > 0 and player:hasSkill(self)
  end,
  on_use = function(self, event, target, player, data)
    player:drawCards(event == fk.Death and target:getMark("@sw__puppet") or 1, self.name)
  end,
}
himiko:addSkill(sw_guju)

local sw_baijia = fk.CreateActiveSkill {
  name = "sw_baijia",
  frequency = Skill.Limited,
  anim_type = "control",
  card_num = 0,
  card_filter = function() return false end,
  target_num = 0,
  can_use = function(self, player)
    return player:usedSkillTimes(self.name, Player.HistoryGame) == 0 and
        table.every(Fk:currentRoom().alive_players,
          function(p) return p == player or p:getMark("@sw__puppet") > 0 end)
  end,
  on_use = function(self, room, effect)
    local player = room:getPlayerById(effect.from)
    room:changeMaxHp(player, 1)
    room:recover { num = 1, skillName = self.name, who = player, recoverBy = player }
    player:skip(Player.Discard)
    for _, p in ipairs(room:getOtherPlayers(player)) do
      if player.dead then break end
      if not p:isKongcheng() then
        local give = room:askForCard(p, 1, 1, false, self.name, false, ".", "#sw_baijia-give:" .. player.id)
        if #give > 0 then
          room:obtainCard(player, give[1], false, fk.ReasonGive)
        end
      end
    end
  end,
}

himiko:addSkill(sw_baijia)

local sw_canshi = fk.CreateTriggerSkill {
  name = "sw_canshi",
  mute = true,
  events = { fk.TargetConfirming, fk.AfterCardTargetDeclared },
  can_trigger = function(self, event, target, player, data)
    if target == player and player:hasSkill(self) and (data.card.type == Card.TypeBasic or data.card:isCommonTrick()) then
      if event == fk.TargetConfirming then
        return player.room:getPlayerById(data.from):getMark("@sw__puppet") > 0
      else
        return data.tos
      end
    end
  end,
  on_cost = function(self, event, target, player, data)
    if event == fk.TargetConfirming then
      return player.room:askForSkillInvoke(player, self.name, data,
        "#sw_canshi::" .. data.from .. ":" .. data.card.name)
    else
      local targets = table.filter(player.room.alive_players, function(p)
        return p:getMark("@sw__puppet") > 0 and not table.contains(TargetGroup:getRealTargets(data.tos), p.id)
            and not player:isProhibited(p, data.card)
      end)
      if #targets == 0 then return false end
      local tos = player.room:askForChoosePlayers(player, table.map(targets, Util.IdMapper), 1, #targets,
        "#sw_canshi-targets", self.name, true)
      if #tos > 0 then
        self.cost_data = tos
        return true
      end
    end
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    if event == fk.TargetConfirming then
      player:broadcastSkillInvoke(self.name, 1)
      room:notifySkillInvoked(player, self.name, "defensive")
      AimGroup:cancelTarget(data, data.to)
      room:removePlayerMark(room:getPlayerById(data.from), "@sw__puppet")
    else
      player:broadcastSkillInvoke(self.name, 2)
      room:notifySkillInvoked(player, self.name, "control")
      local tos = self.cost_data
      room:doIndicate(player.id, tos)
      for _, pid in ipairs(tos) do
        table.insert(data.tos, { pid })
        room:removePlayerMark(room:getPlayerById(pid), "@sw__puppet")
      end
      room:sendLog {
        type = "#AddTargetsBySkill",
        from = player.id,
        to = tos,
        arg = self.name,
        arg2 = data.card:toLogString()
      }
    end
  end,
}


himiko:addSkill(sw_canshi)

Fk:loadTranslationTable {
  ["sww__himiko"] = "卑弥呼",
  ["sw_zongkui"] = "纵傀",
  [":sw_zongkui"] = "锁定技，①每当你对一名其他角色造成伤害后，你令其获得1枚“傀”。②每轮开始时，拥有“傀”最少的随机一名其他角色获得1枚“傀”。",

  ["sw_guju"] = "骨疽",
  [":sw_guju"] = "锁定技，有“傀”的角色受到伤害时，你摸一张牌。有“傀”的角色死亡时，你摸等于其“傀”数的牌。",

  ["sw_baijia"] = "拜假",
  [":sw_baijia"] = "限定技，出牌阶段，若所有其他角色均有“傀”，你可以增加一点体力上限并回复一点体力，令所有其他角色依次交给你一张手牌，然后跳过本回合的弃牌阶段。",
  ["#sw_baijia-give"] = "拜假：交给 %src 一张手牌",

  ["sw_canshi"] = "蚕食",
  [":sw_canshi"] = "①每当你成为有“傀”的角色使用的基本牌或普通锦囊牌的目标时，你可以令其失去1枚“傀”，取消之；②你使用基本牌或普通锦囊牌选择目标时，你可以令任意名有“傀”的角色失去1枚“傀”并成为额外目标。",
  ["#AddTargetsBySkill"] = "用于 %arg 的效果，%from 使用的 %arg2 增加了目标 %to",

  ["@sw__puppet"] = "傀",
  ["#sw_canshi"] = "蚕食：你可取消【%arg】的目标，然后 %dest 弃“傀”",
  ["#sw_canshi-targets"] = "蚕食：你可令任意名有“傀”的角色也成为目标，然后这些角色弃“傀”",

  ["$sw_zongkui1"] = "你，是我的人吗？",
  ["$sw_zongkui2"] = "向你的女王低头！",
  ["$sw_guju1"] = "这份诅咒，你如何摆脱。",
  ["$sw_guju2"] = "附骨之疽，便是这般痛苦。",
  ["$sw_baijia1"] = "我拜受天神之恩，所言便是真理。",
  ["$sw_baijia2"] = "所有人都要在这一刻臣服于我。",
  ["$sw_canshi1"] = "此患不足为惧，可蚕食而尽。",
  ["$sw_canshi2"] = "小则蚕食，大则溃坝。",
  ["~sww__himiko"] = "相信我，你会后悔的。",
}

local tangji = General(extension, "sww__tangji", "qun", 3, 3, General.Female)
local sw_kangge = fk.CreateTriggerSkill {
  name = "sw_kangge",
  anim_type = "support",
  events = { fk.AfterCardTargetDeclared, fk.EnterDying },
  can_trigger = function(self, event, target, player, data)
    if event == fk.AfterCardTargetDeclared then
      return player:hasSkill(self) and player == target and player:getMark("sw_kangge-turn") > 0
          and data.card.type == Card.TypeBasic and data.tos
    else
      return player:hasSkill(self) and player ~= target and player:getMark("tj_jl_yf-round") == 0
    end
  end,
  on_cost = function(self, event, target, player, data)
    local room = player.room
    if event == fk.AfterCardTargetDeclared then
      local targets = {}
      local current_targets = TargetGroup:getRealTargets(data.tos)
      for _, p in ipairs(room:getOtherPlayers(player)) do
        if not table.contains(current_targets, p.id) and not player:isProhibited(p, data.card)
            and data.card.skill:modTargetFilter(p.id, current_targets, data.from, data.card, false) then
          table.insert(targets, p.id)
        end
      end
      if #targets == 0 then return false end
      local tos = room:askForChoosePlayers(player, targets, 1, 999, "#sw_kangge-add:::" .. data.card.name,
        self.name, true)
      if #tos > 0 then
        self.cost_data = tos
        return true
      end
    else
      return room:askForSkillInvoke(player, self.name, nil, "#sw_kangge-save:" .. target.id)
    end
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    if event == fk.AfterCardTargetDeclared then
      room:setPlayerMark(player, "sw_kangge-turn", 1)
      local n = 0
      for _, pid in ipairs(self.cost_data) do
        table.insert(data.tos, { pid })
        local p = room:getPlayerById(pid)
        if p:getHandcardNum() < player:getHandcardNum() then
          n = n + 1
        end
      end
      for _ = 1, n do
        if player.dead then break end
        room:loseHp(player, 1, self.name)
      end
    else
      room:setPlayerMark(player, "tj_jl_yf-round", 1)
      room:recover { num = 1, skillName = self.name, who = target, recoverBy = player }
      if player.dead then return end
      room:loseHp(player, 1, self.name)
      local x = target:getHandcardNum() - player:getHandcardNum()
      if not player.dead and x > 0 then
        player:drawCards(x, self.name)
      end
    end
  end,
}

tangji:addSkill(sw_kangge)

local sw_jielie = fk.CreateTriggerSkill {
  name = "sw_jielie",
  anim_type = "masochism",
  events = { fk.HpLost },
  on_cost = function(self, event, target, player, data)
    local room = player.room
    local tos = room:askForChoosePlayers(player, table.map(room.alive_players, Util.IdMapper), 1, 1,
      "#sw_jielie-choose", self.name, true)
    if #tos > 0 then
      self.cost_data = tos[1]
      return true
    end
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    local to = room:getPlayerById(self.cost_data)
    to:drawCards(1, self.name)
    if not to.dead and not to:isKongcheng() then
      local id = room:askForCardChosen(player, to, { card_data = { { "$Hand", to:getCardIds("h") } } }, self.name,
        "#sw_jielie-card")
      local card = Fk:getCardById(id)
      local cards = room:getCardsFromPileByRule(".|.|" .. card:getSuitString())
      if #cards > 0 then
        room:obtainCard(to, cards[1], false, fk.ReasonPrey)
      end
      if not to.dead and to:getMark(self.name) == 0 then
        room:setPlayerMark(to, self.name, 1)
        local get = room:getCardsFromPileByRule(card.name)
        if #get > 0 then
          room:obtainCard(to, get[1], false, fk.ReasonPrey)
        end
      end
    end
    if to.dead then return end
    room:setPlayerMark(to, "@@sw_jielie", 1)
  end,
}

local sw_jielie_delay = fk.CreateTriggerSkill {
  name = "#sw_jielie_delay",
  mute = true,
  events = { fk.EventPhaseStart },
  can_trigger = function(self, event, target, player, data)
    return target == player and player:getMark("@@sw_jielie") > 0 and player.phase == Player.RoundStart
  end,
  on_cost = Util.TrueFunc,
  on_use = function(self, event, target, player, data)
    player.room:setPlayerMark(player, "@@sw_jielie", 0)
    player:skip(Player.Judge)
    player:skip(Player.Discard)
  end,
}
sw_jielie:addRelatedSkill(sw_jielie_delay)

local sw_jielie_lose = fk.CreateTriggerSkill {
  name = "#sw_jielie_lose",
  mute = true,
  main_skill = sw_jielie,
  frequency = Skill.Compulsory,
  events = { fk.DamageInflicted },
  on_use = function(self, event, target, player, data)
    player:broadcastSkillInvoke(sw_jielie.name)
    player.room:loseHp(player, data.damage, sw_jielie.name)
    return true
  end,
}
sw_jielie:addRelatedSkill(sw_jielie_lose)

tangji:addSkill(sw_jielie)


Fk:loadTranslationTable {
  ["sww__tangji"] = "唐姬",

  ["sw_kangge"] = "抗歌",
  [":sw_kangge"] = "①每回合限一次，你使用基本牌选择目标后，你可以选择任意名其他角色成为额外目标，其中每有一个角色手牌数小于你，你失去一点体力；<br>②每轮限一次，一名其他角色进入濒死状态时，你可以令其回复一点体力，然后你失去一点体力，若你存活，将手牌摸至与其相同。",
  ["#sw_kangge-add"] = "抗歌：选择任意名其他角色成为 %arg 的额外目标，每有一个手牌数小于你，你失去一点体力",
  ["#sw_kangge-save"] = "抗歌：可令 %src 回复一点体力，然后你失去一点体力并将手牌摸至与其相同",

  ["sw_jielie"] = "节烈",
  [":sw_jielie"] = "①每当你失去体力后，你可以令一名角色摸一张牌，观看其手牌并选择一张，其摸一张同花色牌，若第一次对其发动，其摸一张同名牌。然后其跳过下回合的判定和弃牌阶段；②锁定技，每当你受到伤害时，防止之并失去等量点体力。",
  ["@@sw_jielie"] = "节烈",
  ["#sw_jielie-choose"] = "节烈：令一名角色摸一张牌，观看其手牌并选择一张，其摸一张同花色牌，若第一次对其发动，其摸一张同名牌",
  ["#sw_jielie-card"] = "节烈：选择一张",
  ["#sw_jielie_lose"] = "节烈",

  ["$sw_kangge1"] = "悲歌击筑，歌以咏志。",
  ["$sw_kangge2"] = "抗袖而歌，泣下鸣咽。",
  ["$sw_jielie1"] = "外清内白，如玉之素。",
  ["$sw_jielie2"] = "贞淑而有志节，刚烈表性。",
  ["~sww__tangji"] = "死生异路兮从此乖。",
}

local chengong = General(extension, "sww__chengong", "qun", 3)
local sw_shence = fk.CreateTriggerSkill {
  name = "sw_shence",
  anim_type = "drawcard",
  events = { fk.EventPhaseStart },
  can_trigger = function(self, event, target, player, data)
    if player:usedSkillTimes(self.name, Player.HistoryRound) == 2 then return false end
    if event == fk.EventPhaseStart then
      return target.phase == Player.Start and player:hasSkill(self)
    end
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    if event == fk.EventPhaseStart then
      local cards = {}
      local pile = (room.draw_pile or room.discard_pile)
      for _, id in ipairs(pile) do
        if Fk:getCardById(id).is_damage_card then
          table.insertIfNeed(cards, id)
        end
      end
      if #cards > 0 then
        local card = table.random(cards)
        room:moveCards({
          ids = { card },
          to = target.id,
          toArea = Card.PlayerHand,
          moveReason = fk.ReasonJustMove,
          proposer = player.id,
          skillName = self.name,
        })
        room:setCardMark(Fk:getCardById(card), "@@sw_shece_ce-turn", 1)
      end
      room:setPlayerMark(target, "@@sw_shece-turn", 1)
    end
  end,
}
local sw_shence_dlc = fk.CreateTriggerSkill {
  name = "#sw_shence_dlc",
  anim_type = "drawcard",
  frequency = Skill.Compulsory,
  mute = true,
  events = { fk.CardUsing, fk.Damage },
  can_trigger = function(self, event, target, player, data)
    if event == fk.CardUsing then
      return player:hasSkill(sw_shence.name) and table.find(Card:getIdList(data.card), function(id)
            return Fk:getCardById(id):getMark("@@sw_shece_ce-turn") > 0
          end) and
          not (table.contains({ "aaa_role_mode", "aab_role_mode", "vanished_dragon" }, player.room.settings.gameMode))
    else
      return player:hasSkill(sw_shence.name) and data.card and table.find(Card:getIdList(data.card), function(id)
        return Fk:getCardById(id):getMark("@@sw_shece_ce-turn") > 0
      end) and player:getMark("shence_dely-turn") == 0
    end
  end,
  on_use = function(self, event, target, player, data)
    if event == fk.CardUsing then
      player.room:notifySkillInvoked(player, sw_shence.name)
      player:broadcastSkillInvoke(sw_shence.name)
      player:drawCards(1)
    else
      player.room:notifySkillInvoked(player, sw_shence.name)
      player:broadcastSkillInvoke(sw_shence.name)
      player.room:setPlayerMark(player, "shence_dely-turn", 1)
      player:drawCards(1)
      target:drawCards(2)
    end
  end,
}

local sw_shence_tar = fk.CreateTargetModSkill {
  name = "#sw_shence_tar",
  residue_func = function(self, player, skill, scope, card)
    if skill.trueName == "slash_skill" and scope == Player.HistoryPhase and player:getMark("@@sw_shece-turn") > 0 then
      return 1
    end
  end,
}
local sw_shence_attackrange = fk.CreateAttackRangeSkill {
  name = "#sw_shence_attackrange",
  correct_func = function(self, from, to)
    if from:getMark("@@sw_shece-turn") > 0 then
      return 1
    end
  end,
}
sw_shence:addRelatedSkill(sw_shence_dlc)
sw_shence:addRelatedSkill(sw_shence_tar)
sw_shence:addRelatedSkill(sw_shence_attackrange)
chengong:addSkill(sw_shence)
Fk:loadTranslationTable {
  ["sww__chengong"] = "陈宫",
  ["sw_shence"] = "神策",
  ["#sw_shence_dlc"] = "神策",
  ["@@sw_shece_ce-turn"] = "策",
  ["@@sw_shece-turn"] = "神策",
  [":sw_shence"] = "每轮限两次，一名角色的准备阶段，你可以令其获得一张伤害牌并标记为“策”，其本回合攻击范围和使用【杀】次数+1；本回合“策”牌首次造成伤害后，你摸一张牌，使用者摸两张牌(若不为身份模式，其使用策牌时，你摸一张牌)",
}
local sw_zhimou = fk.CreateTriggerSkill {
  name = "sw_zhimou",
  anim_type = "defensive",
  events = { fk.EventPhaseStart },
  can_trigger = function(self, event, target, player, data)
    return target == player and player:hasSkill(self) and player.phase == Player.Play and
        table.find(player.room.alive_players,
          function(p) return not p.role_shown end) and player:getMark("zhimou_huan") == 0
  end,
  on_cost = function(self, event, target, player, data)
    local to = player.room:askForChoosePlayers(player, table.map(player.room.alive_players, function(p)
      return not p.role_shown and p:getMark("zhimou_pass") == 0 and p.id
    end), 1, 1, "#sw_zhimou-chos", self.name, true, 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)
    local chs = { "lord", "loyalist", "rebel", "renegade", }
    local chc = room:askForChoice(player, chs, self.name)
    local cards = room:getCardsFromPileByRule(".|.|.|.|.|trick,equip", 2)
    if to.role == chc then
      room:setPlayerMark(to, "zhimou_pass", 1)
      room:addPlayerMark(player, "@zhimou_true", 1)
      room:setPlayerMark(player, "@zhimou_false", 0)
    else
      room:setPlayerMark(player, "@zhimou_true", 0)
      room:addPlayerMark(player, "@zhimou_false", 1)
    end
    if player:getMark("@zhimou_true") > 0 then
      if #cards > 0 then
        room:moveCards({
          ids = cards,
          to = player.id,
          toArea = Card.PlayerHand,
          moveReason = fk.ReasonJustMove,
          proposer = player.id,
          skillName = self.name,
        })
      end
    end
    if player:getMark("@zhimou_false") == 2 then
      room:loseHp(player, 1, self.name)
      room:notifySkillInvoked(player, self.name)
      player:broadcastSkillInvoke(self.name)
      room:handleAddLoseSkills(player, "zhichi", nil, true, false)
      room:handleAddLoseSkills(player, "-sw_zhimou", nil, true, false)
    end
    if player:getMark("@zhimou_true") == 3 then
      room:notifySkillInvoked(player, self.name)
      player:broadcastSkillInvoke(self.name)
      room:handleAddLoseSkills(player, "mobile__god_huishi", nil, true, false)
    end
    if player:getMark("@zhimou_true") == #player.room.alive_players - 1 then
      local to1 = room:askForChoosePlayers(player, table.map(room.alive_players, function(p)
        return p.role ~= "lord" and p.id ~= player.id and p.id
      end), 1, 1, "#sw_zhimou-chose", self.name, true, true)
      if #to1 > 0 then
        local tar = room:getPlayerById(to1[1])
        local temp = player.role
        player.role = "unknown"
        room:broadcastProperty(player, "role")
        player.role = tar.role
        tar.role = temp
        room:notifyProperty(player, player, "role")
        room:notifyProperty(tar, tar, "role")
        if tar.role == "lord" or player.role == "lord" then
          room:broadcastProperty(tar, "role")
        end
        room:setPlayerMark(player, "zhimou_huan", 1)
      end
    end
  end,
}
chengong:addRelatedSkill("zhichi")
chengong:addRelatedSkill("mobile__god_huishi")
chengong:addSkill(sw_zhimou)
Fk:loadTranslationTable {
  ["sw_zhimou"] = "智谋",
  ["@zhimou_false"] = "猜错",
  ["@zhimou_true"] = "猜对",
  ["#sw_zhimou-chos"] = "智谋：选择一名其他角色，猜测其身份",
  ["#sw_zhimou-chose"] = "智谋：选择一名其他角色，与其交换身份",
  [":sw_zhimou"] = "出牌阶段开始时，你可以秘密选择一名未展示身份牌且未以此法选择过的角色并猜测其身份，若你猜对，你随机获得两张非基本牌；" ..
      "若你连续猜错两次，失去一点体力，失去该技能并获得“智迟”；若你连续猜对三次，你获得“慧识”；若你猜对了所有角色的身份，你可以选择一个名除主公外的其他角色，与其秘密交换身份牌",
}

local yangyi = General(extension, "sww__yangyi", "shu", 3)
local sw_dingcuo = fk.CreateTriggerSkill {
  name = "sw_dingcuo",
  anim_type = "drawcard",
  events = { fk.Damage, fk.DamageInflicted },
  can_trigger = function(self, event, target, player, data)
    return target == player and player:hasSkill(self.name) and
        player:usedSkillTimes(self.name, Player.HistoryTurn) < 2
  end,
  on_use = function(self, event, target, player, data)
    local cards = player:drawCards(2, self.name)
    if Fk:getCardById(cards[1]).color ~= Fk:getCardById(cards[2]).color and not player:isKongcheng() then
      player.room:askForDiscard(player, 1, 1, true, self.name, false, ".")
    end
  end
}
local sw_juanxia = fk.CreateTriggerSkill {
  name = "sw_juanxia",
  anim_type = "defensive",
  events = { fk.EventPhaseStart },
  can_trigger = function(self, event, target, player, data)
    return target == player and player:hasSkill(self) and player.phase == Player.Finish
  end,
  on_cost = function(self, event, target, player, data)
    local to = player.room:askForChoosePlayers(player, table.map(player.room:getOtherPlayers(player), Util.IdMapper),
      1, 1, "#sw_juanxia-chos", self.name, true, true)
    if #to > 0 then
      self.cost_data = to[1]
      return true
    end
  end,
  on_use = function(self, event, target, player, data)
    player.room:setPlayerMark(player, self.name, self.cost_data)
  end,

  refresh_events = { fk.TurnStart },
  can_refresh = function(self, event, target, player, data)
    return target == player and player:getMark("sw_juanxia") ~= 0
  end,
  on_refresh = function(self, event, target, player, data)
    player.room:setPlayerMark(player, "sw_juanxia", 0)
  end,
}
local sw_juanxia_trigger = fk.CreateTriggerSkill {
  name = "#sw_juanxia_trigger",
  mute = true,
  events = { fk.CardUseFinished },
  can_trigger = function(self, event, target, player, data)
    return player:getMark("sw_juanxia") == target.id and data.card and data.card.is_damage_card
  end,
  on_cost = Util.TrueFunc,
  on_use = function(self, event, target, player, data)
    local room = player.room
    player:broadcastSkillInvoke("sw_juanxia")
    room:notifySkillInvoked(player, "sw_juanxia", "defensive")
    room:setPlayerMark(player, "sw_juanxia", 0)
    room:setPlayerMark(target, "sw_juanxia", 1)
  end,
}
local sw_juanxia_viewas = fk.CreateViewAsSkill {
  name = "sw_juanxia_viewas",
  interaction = function()
    local names = {}
    for _, id in ipairs(Fk:getAllCardIds()) do
      local card = Fk:getCardById(id)
      if card:isCommonTrick() and not card.is_derived and card.skill.target_num == 1 then
        table.insertIfNeed(names, card.name)
      end
    end
    if #names == 0 then return end
    return UI.ComboBox { choices = names }
  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_juanxia"
    return card
  end,
}
local sw_juanxia_active = fk.CreateActiveSkill {
  name = "sw_juanxia_active",
  interaction = function()
    local names = {}
    local mark = Self:getMark("sw_juanxia-phase")
    for _, id in ipairs(Fk:getAllCardIds()) do
      local card = Fk:getCardById(id)
      if card.name ~= mark[1] then
        if card:isCommonTrick() and card.skill.target_num == 1 and not card.is_derived and
            card.skill:targetFilter(mark[2], {}, {}, card) and
            not Self:isProhibited(Fk:currentRoom():getPlayerById(mark[2]), card) then
          table.insertIfNeed(names, card.name)
        end
      end
    end
    if #names == 0 then return end
    return UI.ComboBox { choices = names }
  end,
  card_filter = Util.FalseFunc,
}
local sw_juanxia_mod = fk.CreateTriggerSkill {
  name = "#sw_juanxia_mod",
  anim_type = "offensive",
  events = { fk.EventPhaseEnd },
  can_trigger = function(self, event, target, player, data)
    return player:hasSkill(self) and target.phase == Player.Finish and target:getMark("sw_juanxia") == 1
  end,
  on_cost = function(self, event, target, player, data)
    local success, dat = player.room:askForUseActiveSkill(player, "sw_juanxia_viewas", "#sw_juanxia-choose", true)
    if success then
      self.cost_data = dat
      return true
    end
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    local n = 1
    local card = Fk.skills["sw_juanxia_viewas"]:viewAs(self.cost_data.cards)
    room:useCard {
      from = player.id,
      tos = table.map(self.cost_data.targets, function(id) return { id } end),
      card = card,
    }
    local to = room:getPlayerById(self.cost_data.targets[1])
    if to.dead or player.dead then return end
    room:setPlayerMark(player, "sw_juanxia-phase", { card.name, to.id })
    local command = "AskForUseActiveSkill"
    room:notifyMoveFocus(player, "sw_juanxia_active")
    local data = { "sw_juanxia_active", "#sw_juanxia-invoke::" .. to.id, true, {} }
    local result = room:doRequest(player, command, json.encode(data))
    if result ~= "" then
      data = json.decode(result)
      room:useVirtualCard(data.interaction_data, nil, player, to, self.name)
      n = 2
    end
    if to.dead or player.dead then return end
    room:setPlayerMark(to, "sw_juanxia", 0)
  end,
}
Fk:addSkill(sw_juanxia_viewas)
Fk:addSkill(sw_juanxia_active)
sw_juanxia:addRelatedSkill(sw_juanxia_trigger)
sw_juanxia:addRelatedSkill(sw_juanxia_mod)
yangyi:addSkill(sw_juanxia)
yangyi:addSkill(sw_dingcuo)
Fk:loadTranslationTable {
  ["sww__yangyi"] = "杨仪",
  ["sw_juanxia"] = "狷狭",
  ["#sw_juanxia_mod"] = "狷狭",
  [":sw_juanxia"] = "结束阶段，可以秘密选择一名其他角色，若其下个回合内使用了伤害类卡牌，其回合结束时，你可以视为依次使用两张仅指定单一目标的普通锦囊牌",
  ["sw_dingcuo"] = "定措",
  [":sw_dingcuo"] = "每回合限两次，当你造成伤害后或受到伤害时，你可以摸两张牌，若这两张牌颜色不同，你弃置一张牌。",
  ["#sw_juanxia-choose"] = "狷狭：是否依次视为对其使用至多两张仅指定唯一目标的普通锦囊牌",
  ["#sw_juanxia-invoke"] = "狷狭：你可以视为对 %dest 再使用一张锦囊",
  ["#sw_juanxia-chos"] = "狷狭：标记一名角色",
  ["sw_juanxia_viewas"] = "狷狭",
  ["sw_juanxia_active"] = "狷狭",

  ["$sw_juanxia1"] = "放之海内，知我者少、同我者无，可谓高处胜寒",
  ["$sw_juanxia2"] = "满堂朱紫，能文者不武，为将者少谋，唯吾兼备",
  ["$sw_dingcuo1"] = "奋笔墨为锄，茁大汉以壮、慷国士以慨。",
  ["$sw_dingcuo2"] = "执金戈为尺，定国之方圆、立人之规矩。",
  ["~sww__yangyi"] = "幼主昏聩，群臣无谋，国将亡。",
}

local wangyi = General(extension, "sww__wangyi", "wei", 4, 4, General.Female)

local sw_zhenlie = fk.CreateTriggerSkill {
  name = "sw_zhenlie",
  anim_type = "defensive",
  frequency = Skill.Compulsory,
  events = { fk.BeforeCardEffect },
  can_trigger = function(self, event, target, player, data)
    if target == player and player:hasSkill(self) then
      local mark = type(player:getMark("@sw_zhenlie")) == "string" and player:getMark("@sw_zhenlie") or "slash"
      return (mark == "slash" and data.card.trueName == "slash") or
          (mark == "mj_damage_trick" and data.card.type == Card.TypeTrick and data.card.is_damage_card) or
          (mark == "mj_delayed_trick" and data.card.sub_type == Card.SubtypeDelayedTrick)
    end
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    room:loseHp(player, 1, self.name)
    local targets = table.filter(room:getOtherPlayers(player), function(p) return not p:isNude() end)
    if #targets > 0 then
      local promot = player.dead and "#sw_zhenlie-throwall" or "#sw_zhenlie-throw"
      local tos = room:askForChoosePlayers(player, table.map(targets, Util.IdMapper), 1, 1, promot, self.name,
        false)
      if #tos > 0 then
        local to = room:getPlayerById(tos[1])
        if player.dead then
          to:throwAllCards("he")
        else
          local cid = room:askForCardChosen(player, to, "he", self.name)
          room:throwCard({ cid }, self.name, to, player)
        end
      end
    end
    return true
  end,
  refresh_events = { fk.EventLoseSkill, fk.EventAcquireSkill },
  can_refresh = function(self, event, target, player, data)
    return data == self and target == player
  end,
  on_refresh = function(self, event, target, player, data)
    player.room:setPlayerMark(player, "@sw_zhenlie", event == fk.EventLoseSkill or 0 and "slash")
  end,
}
wangyi:addSkill(sw_zhenlie)

local sw_miji = fk.CreateTriggerSkill {
  name = "sw_miji",
  anim_type = "control",
  events = { fk.TurnEnd, fk.AskForRetrial },
  can_trigger = function(self, event, target, player, data)
    if event == fk.TurnEnd then
      if player:hasSkill(self) and (target == player or player:usedSkillTimes(sw_zhenlie.name, Player.HistoryTurn) > 0) then
        return player:isWounded()
      end
    else
      return player:hasSkill(self) and
          table.find(player:getCardIds("h"),
            function(id) return Fk:getCardById(id):getMark("@@sw_miji-inhand") > 0 end)
    end
  end,
  on_cost = function(self, event, target, player, data)
    if event == fk.TurnEnd then
      local tos = player.room:askForChoosePlayers(player, table.map(player.room.alive_players, Util.IdMapper), 1, 1,
        "#sw_miji-draw:::" .. player:getLostHp(), self.name, true)
      if #tos > 0 then
        self.cost_data = tos[1]
        return true
      end
    else
      local ids = table.filter(player:getCardIds("h"),
        function(id) return Fk:getCardById(id):getMark("@@sw_miji-inhand") > 0 end)
      local card = player.room:askForResponse(player, self.name, ".|.|.|hand|.|.|" .. table.concat(ids, ","),
        "#sw_miji-retrial::" .. target.id .. ":" .. data.reason .. ":" .. data.card:toLogString(), true)
      if card then
        self.cost_data = card
        return true
      end
    end
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    if event == fk.TurnEnd then
      local to = room:getPlayerById(self.cost_data)
      local draw = to:drawCards(player:getLostHp(), self.name)
      if to == player then
        for _, id in ipairs(draw) do
          if table.contains(player:getCardIds("h"), id) then
            room:setCardMark(Fk:getCardById(id), "@@sw_miji-inhand", 1)
          end
        end
      end
      if to ~= player and player:hasSkill(sw_zhenlie, true) then
        local choice = room:askForChoice(player, { "slash", "mj_damage_trick", "mj_delayed_trick" }, self.name,
          "#sw_miji-choice")
        room:setPlayerMark(player, "@sw_zhenlie", choice)
      end
    else
      room:retrial(self.cost_data, player, data, self.name, true)
    end
  end,
}
local sw_miji_max = fk.CreateMaxCardsSkill {
  name = "#sw_miji_max",
  exclude_from = function(self, player, card)
    return player:hasSkill(self) and card and card:getMark("@@sw_miji-inhand") > 0
  end,
}
sw_miji:addRelatedSkill(sw_miji_max)
wangyi:addSkill(sw_miji)

Fk:loadTranslationTable {
  ["sww__wangyi"] = "王异",

  ["sw_zhenlie"] = "贞烈",
  [":sw_zhenlie"] = "锁定技，每当【杀】对你生效时，你令之无效并失去一点体力，然后你弃置一名其他角色一张牌，若你已死亡，改为令其弃置所有牌。",
  ["#sw_zhenlie-throw"] = "贞烈：你弃置一名其他角色一张牌",
  ["#sw_zhenlie-throwall"] = "贞烈：令一名其他角色弃置所有牌",
  ["@sw_zhenlie"] = "贞烈",

  ["sw_miji"] = "秘计",
  [":sw_miji"] = "你的回合或你发动〖贞烈〗的回合结束时，你可以令一名角色摸X张牌（X为你已损失体力值），若不为你，你将〖贞烈〗描述中对你生效的牌修改为【杀】/伤害锦囊/延时锦囊。你以此法摸的牌不计入手牌上限，一名角色的判定牌生效前，你可以打出其中一张牌替换之。",
  ["mj_damage_trick"] = "伤害锦囊",
  ["mj_delayed_trick"] = "延时锦囊",
  ["#sw_miji-retrial"] = "秘计：打出一张“秘计”牌替换 %dest 进行“%arg”判定的判定牌 %arg2",
  ["#sw_miji-choice"] = "秘计：修改〖贞烈〗描述中对你生效的牌",
  ["#sw_miji-draw"] = "秘计：令一名角色摸%arg张牌",
  ["@@sw_miji-inhand"] = "秘计",

  ["$sw_zhenlie1"] = "秉忠持义，纵死犹归。",
  ["$sw_zhenlie2"] = "守义死节，不为苟生。",
  ["$sw_miji1"] = "密谋筹策，奇计制敌。",
  ["$sw_miji2"] = "奇谋九策，共御强敌。",
  ["~sww__wangyi"] = "为雪君父之耻，死而不惜！",
}
local wuxian = General(extension, "sww__wuxian", "shu", 3, 3, General.Female)

local sw_guixiang = fk.CreateTriggerSkill {
  name = "sw_guixiang",
  events = { fk.EventPhaseEnd },
  anim_type = "support",
  can_trigger = function(self, event, target, player, data)
    if not player:hasSkill(self) or target.phase ~= Player.Play or target.dead then return false end
    local n = 0
    player.room.logic:getEventsOfScope(GameEvent.UseCard, 1, function(e)
      local use = e.data[1]
      if use and use.from == target.id then
        n = n + 1
      end
      return false
    end, Player.HistoryPhase)
    n = math.min(5, n)
    if n > target:getHandcardNum() then
      self.cost_data = n
      return true
    end
  end,
  on_cost = function(self, event, target, player, data)
    local n = self.cost_data
    return player.room:askForSkillInvoke(player, self.name, nil, "#sw_guixiang-invoke::" .. target.id .. ":" .. n)
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    local n = self.cost_data
    room:setPlayerMark(target, "@@sw_guixiang", 1)
    target:skip(Player.Discard)
    target:drawCards(n - target:getHandcardNum(), self.name)
  end,
  refresh_events = { fk.EventPhaseChanging },
  can_refresh = function(self, event, target, player, data)
    return target:getMark("@@sw_guixiang") > 0 and data.to == Player.Draw
  end,
  on_refresh = function(self, event, target, player, data)
    player.room:setPlayerMark(target, "@@sw_guixiang", 0)
    data.to = Player.Play
  end,
}
wuxian:addSkill(sw_guixiang)


local sw_fumian = fk.CreateTriggerSkill {
  name = "sw_fumian",
  events = { fk.CardUseFinished },
  can_trigger = function(self, event, target, player, data)
    return player:hasSkill(self) and player == target and data.card.color == Card.Red and
        data.card.type ~= Card.TypeEquip and not player:isNude()
  end,
  on_cost = function(self, event, target, player, data)
    local card = player.room:askForDiscard(player, 1, 1, true, self.name, true, ".", "#sw_fumian", true)
    if #card > 0 then
      self.cost_data = card
      return true
    end
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    room:throwCard(self.cost_data, self.name, player, player)
    if player.dead then return end
    local choices = {}
    local peach = Fk:cloneCard("peach")
    peach.skillName = self.name
    if player:isWounded() and not player:isProhibited(player, peach) and not player:prohibitUse(peach) then
      table.insert(choices, peach)
    end
    local ex = Fk:cloneCard("ex_nihilo")
    ex.skillName = self.name
    if not player:isProhibited(player, ex) and not player:prohibitUse(ex) then
      table.insert(choices, ex)
    end
    for _, id in ipairs(room.draw_pile) do
      local card = Fk:getCardById(id)
      if card.type == Card.TypeEquip and player:hasEmptyEquipSlot(card.sub_type) and not player:isProhibited(player, card) and not player:prohibitUse(card) then
        table.insert(choices, card)
        break
      end
    end
    if #choices == 0 then return end
    local card = table.random(choices)
    room:useCard({ from = player.id, tos = { { player.id } }, card = card })
  end,
}
wuxian:addSkill(sw_fumian)


Fk:loadTranslationTable {
  ["sww__wuxian"] = "吴苋",

  ["sw_guixiang"] = "贵相",
  [":sw_guixiang"] = "一名角色出牌阶段结束时，你可以令其将手牌摸至X张（X为其本阶段使用牌数且至多为5），若如此做，其跳过弃牌阶段且下一个摸牌阶段改为出牌阶段。",
  ["#sw_guixiang-invoke"] = "贵相：你可令 %dest 将手牌摸至%arg张，跳过弃牌阶段，下一个摸牌阶段改为出牌阶段",
  ["@@sw_guixiang"] = "贵相",

  ["sw_fumian"] = "福绵",
  [":sw_fumian"] = "每当你使用一张红色非装备牌后，你可以弃置一张牌随机执行一项：1.视为使用【桃】2.视为使用【无中生有】3.使用牌堆一张未拥有副类别的装备牌。",
  ["#sw_fumian"] = "福绵：你可以弃置一张牌发动随机执行一项“福绵”的效果",

  ["$sw_guixiang1"] = "余常闻，橘枳分南北，妻于夫亦当如是。",
  ["$sw_guixiang2"] = "命中之女，如剑分双刃，或为所用，或为所伤。",
  ["$sw_fumian1"] = "天长地久有时尽，福佑绵绵无绝期。",
  ["$sw_fumian2"] = "愿以三尺微命，祈大汉福气长存。",
  ["~sww__wuxian"] = "太平本是玄德创，不见我夫享太平。",
}

local bulianshi = General(extension, "sww__bulianshi", "wu", 3, 3, General.Female)

local doAnxu = function(room, player, from, to)
  if from:isKongcheng() then return end
  local skillName = "sw_anxu"
  local get = table.random(from:getCardIds("h"))
  room:obtainCard(to, get, true, fk.ReasonPrey)
  to:showCards({ get })
  if Fk:getCardById(get).suit ~= Card.Spade then
    if not player.dead then
      player:drawCards(1, skillName)
    end
  elseif not player:isNude() then
    room:askForDiscard(player, 1, 1, true, skillName, false)
  end
end
local sw_anxu = fk.CreateActiveSkill {
  name = "sw_anxu",
  anim_type = "control",
  can_use = function(self, player)
    return player:usedSkillTimes(self.name, Player.HistoryPhase) == 0
  end,
  card_num = 0,
  card_filter = Util.FalseFunc,
  target_num = 2,
  target_filter = function(self, to_select, selected)
    if #selected > 1 then return false end
    if #selected == 0 then
      return true
    else
      return Fk:currentRoom():getPlayerById(to_select):getHandcardNum() ~=
          Fk:currentRoom():getPlayerById(selected[1]):getHandcardNum()
    end
  end,
  on_use = function(self, room, use)
    local player = room:getPlayerById(use.from)
    local target1 = room:getPlayerById(use.tos[1])
    local target2 = room:getPlayerById(use.tos[2])
    local from = target1:getHandcardNum() > target2:getHandcardNum() and target1 or target2
    local to = target1:getHandcardNum() < target2:getHandcardNum() and target1 or target2
    doAnxu(room, player, from, to)
  end,
}
local sw_anxu_trigger = fk.CreateTriggerSkill {
  name = "#sw_anxu_trigger",
  anim_type = "control",
  events = { fk.Damage },
  can_trigger = function(self, event, target, player, data)
    return target and player:hasSkill(self) and target:getHandcardNum() ~= data.to:getHandcardNum() and
        not target.dead and not data.to.dead and player:getMark("anxue_fd-turn") == 0
  end,
  on_cost = function(self, event, target, player, data)
    local from = target:getHandcardNum() > data.to:getHandcardNum() and target or data.to
    local to = target:getHandcardNum() < data.to:getHandcardNum() and target or data.to
    if player.room:askForSkillInvoke(player, self.name, nil, "#sw_anxu-invoke:" .. from.id .. ":" .. to.id) then
      self.cost_data = { from, to }
      return true
    end
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    player:broadcastSkillInvoke("sw_anxu")
    room:setPlayerMark(player, "anxue_fd-turn", 1)
    doAnxu(room, player, self.cost_data[1], self.cost_data[2])
  end,
}
sw_anxu:addRelatedSkill(sw_anxu_trigger)
bulianshi:addSkill(sw_anxu)

local sw_zhuiyi = fk.CreateTriggerSkill {
  name = "sw_zhuiyi",
  anim_type = "support",
  events = { fk.Death },
  can_trigger = function(self, event, target, player, data)
    return target == player and player:hasSkill(self, false, true)
  end,
  on_cost = function(self, event, target, player, data)
    local room = player.room
    local tos = room:askForChoosePlayers(player, table.map(room.alive_players, Util.IdMapper), 1, 1,
      "#sw_zhuiyi-choose", self.name, true)
    if #tos > 0 then
      self.cost_data = tos[1]
      return true
    end
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    local to = room:getPlayerById(self.cost_data)
    to:drawCards(3, self.name)
    if to:isWounded() and not to.dead then
      room:recover {
        who = to,
        num = 3 - to.hp,
        recoverBy = player,
        skillName = self.name
      }
    end
    to:reset()
    room:abortPlayerArea(to, Player.JudgeSlot)
  end,
}
bulianshi:addSkill(sw_zhuiyi)

Fk:loadTranslationTable {
  ["sww__bulianshi"] = "步练师",

  ["sw_anxu"] = "安恤",
  [":sw_anxu"] = "出牌阶段限一次，你可以选择两名手牌数不相等的角色，或当一名角色对与其手牌数不相等的另一名角色造成伤害后，若你未发动过该技能，你可以令其中手牌较少的角色获得另一名角色的随机一张手牌并展示之，若为不黑桃，你摸一张牌，若为黑桃，你须弃置一张牌。",
  ["#sw_anxu-invoke"] = "安恤：你可以令 %dest 获得 %src 随机一张手牌并展示",
  ["#sw_anxu_trigger"] = "安恤",
  ["#sw_anxu-recover"] = "安恤：你可以弃置两张牌令一名角色回复一点体力",

  ["sw_zhuiyi"] = "追忆",
  [":sw_zhuiyi"] = "当你死亡时，你可以令一名其他角色摸三张牌并回复体力至3点，复原武将牌并废除判定区。",
  ["#sw_zhuiyi-choose"] = "追忆：你可以令一名角色摸三张牌并回复体力至3点，复原武将牌并废除判定区",

  ["$sw_anxu1"] = "妾不长文武，欲解君愁，唯献歌阙。",
  ["$sw_anxu2"] = "君远役劳苦，今借春风秋月以慰之。",
  ["$sw_zhuiyi1"] = "我本岸汀一浮萍，幸君采之、此生殊荣。",
  ["$sw_zhuiyi2"] = "此间草木多颜色，经年忆之、可解相思。",
  ["~sww__bulianshi"] = "此生许君，愿生生亦如是。",
}

local sunshangxiang = General(extension, "sww__sunshangxiang", "wu", 4, 4, General.Female)

local sw_jiaoxiao = fk.CreateTriggerSkill {
  name = "sw_jiaoxiao",
  events = { fk.AfterCardsMove },
  anim_type = "drawcard",
  frequency = Skill.Compulsory,
  can_trigger = function(self, event, target, player, data)
    if player:hasSkill(self) then
      local infos = {}
      for _, move in ipairs(data) do
        if move.from == player.id then
          for _, info in ipairs(move.moveInfo) do
            local card = Fk:getCardById(info.cardId)
            if card.type == Card.TypeEquip and (info.fromArea == Card.PlayerHand or info.fromArea == Card.PlayerEquip) then
              local list = { info.cardId }
              if move.toArea == Card.DiscardPile then
                table.insert(list, "draw")
              end
              if move.toArea == Card.PlayerHand and move.to ~= player.id then
                table.insert(list, move.to)
              end
              table.insert(infos, list)
            end
          end
        end
      end
      if #infos > 0 then
        self.cost_data = infos
        return true
      end
    end
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    for _, info in ipairs(self.cost_data) do
      local card = Fk:getCardById(info[1])
      if card.sub_type == Card.SubtypeWeapon then
        room:addPlayerMark(player, "sw_jiaoxiao_targetmod")
      elseif card.sub_type == Card.SubtypeArmor or card.sub_type == Card.SubtypeTreasure then
        room:addPlayerMark(player, "sw_jiaoxiao_maxcards")
        room:broadcastProperty(player, "MaxCards")
      else
        room:addPlayerMark(player, "sw_jiaoxiao_distance")
      end
      local extra = info[2]
      if extra and type(extra) == "string" and not player.dead then
        player:drawCards(1, self.name)
      end
      if extra and type(extra) == "number" then
        local to = room:getPlayerById(extra)
        if to and not to.dead then
          room:damage { from = player, to = to, damage = 1, skillName = self.name }
        end
      end
    end
    room:delay(600)
  end,
}
local sw_jiaoxiao_targetmod = fk.CreateTargetModSkill {
  name = "#sw_jiaoxiao_targetmod",
  residue_func = function(self, player, skill, scope, card)
    if skill.trueName == "slash_skill" and scope == Player.HistoryPhase then
      return player:getMark("sw_jiaoxiao_targetmod")
    end
  end,
}
sw_jiaoxiao:addRelatedSkill(sw_jiaoxiao_targetmod)

local sw_jiaoxiao_maxcards = fk.CreateMaxCardsSkill {
  name = "#sw_jiaoxiao_maxcards",
  correct_func = function(self, player)
    return player:getMark("sw_jiaoxiao_maxcards")
  end,
}
sw_jiaoxiao:addRelatedSkill(sw_jiaoxiao_maxcards)

local sw_jiaoxiao_distance = fk.CreateDistanceSkill {
  name = "#sw_jiaoxiao_distance",
  correct_func = function(self, from, to)
    return -from:getMark("sw_jiaoxiao_distance")
  end,
}
sw_jiaoxiao:addRelatedSkill(sw_jiaoxiao_distance)

sunshangxiang:addSkill(sw_jiaoxiao)



local sw_guiyong = fk.CreateTriggerSkill {
  name = "sw_guiyong",
  frequency = Skill.Wake,
  events = { fk.DamageCaused },
  anim_type = "offensive",
  can_trigger = function(self, event, target, player, data)
    return player:usedSkillTimes(self.name, Player.HistoryGame) == 0 and player:hasSkill(self) and target == player
  end,
  can_wake = function(self, event, target, player, data)
    return data.to:getHandcardNum() < player:getHandcardNum() and data.to.gender == General.Male
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    room:changeMaxHp(player, -1)
    data.damage = data.damage + 1
    room:handleAddLoseSkills(player, "sw_gongyao", nil)
  end,
}
sunshangxiang:addSkill(sw_guiyong)

local sw_gongyao = fk.CreateTriggerSkill {
  name = "sw_gongyao",
  events = { fk.Damage, fk.Damaged },
  anim_type = "control",
  can_trigger = function(self, event, target, player, data)
    return player:hasSkill(self) and target == player and
        table.find(player.room.alive_players, function(p) return #p:getCardIds("ej") > 0 end)
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    local ids = {}
    for _, p in ipairs(room.alive_players) do
      table.insertTable(ids, p:getCardIds("ej"))
    end
    local id = table.random(ids)
    local draw = table.contains(player:getCardIds("ej"), id)
    room:obtainCard(player, id, true, fk.ReasonPrey)
    if not player.dead and draw then
      player:drawCards(1, self.name)
    end
  end,
}
sunshangxiang:addRelatedSkill(sw_gongyao)


Fk:loadTranslationTable {
  ["sww__sunshangxiang"] = "孙尚香",

  ["sw_jiaoxiao"] = "骄枭",
  [":sw_jiaoxiao"] = "锁定技，每当你失去一张装备牌时，若为：武器牌，你使用【杀】次数上限+1；防具或宝具牌，你手牌上限+1；坐骑牌，你与其他角色距离-1。若此装备牌进入弃牌堆，你摸一张牌，若进入其他角色的手牌，对其造成一点伤害。",

  ["sw_guiyong"] = "闺勇",
  [":sw_guiyong"] = "觉醒技，当你对一名角色造成伤害时，若其手牌数小于你且为男性，你扣减一点体力上限，令此伤害+1，然后获得〖弓腰〗。",

  ["sw_gongyao"] = "弓腰",
  [":sw_gongyao"] = "每当你造成后，或你受到伤害后，你可以获得场上随机一张牌，若获得你区域内的牌，你摸一张牌。",

  ["$sw_jiaoxiao1"] = "佩干将莫邪之利器，擅龙泉秋水之嘉名。",
  ["$sw_jiaoxiao2"] = "本小姐有清歌妙舞，不妨与长铗一齐献上。",
  ["$sw_guiyong1"] = "统统给本小姐闪开！",
  ["$sw_guiyong2"] = "本小姐这身本事，可不是假的。",
  ["$sw_gongyao1"] = "花间矫捷，快步无影。",
  ["$sw_gongyao2"] = "弓腰舞美姬，巾帼不输君。",
  ["~sww__sunshangxiang"] = "哥哥，妹妹我想家了……",
}
local huaman = General(extension, "sww__huaman", "shu", 3, 3, General.Female)
local sw_mansi = fk.CreateTriggerSkill { ---.....这技能真的是写的又臭又长
  name = "sw_mansi",
  mute = true,
  frequency = Skill.Compulsory,
  events = { fk.TargetConfirmed, fk.EventPhaseChanging },
  can_trigger = function(self, event, target, player, data)
    if target == player and player:hasSkill(self) then
      if event == fk.TargetConfirmed then
        return data.card.trueName == "savage_assault" or
            data.card.trueName ==
            "archery_attack" -- 这里的无效其实是取消了目标而已
      else
        return data.to == player.Start
      end
    end
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    if event == fk.TargetConfirmed then
      player.room:notifySkillInvoked(player, self.name, "defensive")
      player:broadcastSkillInvoke(self.name, 3)
      table.insertIfNeed(data.nullifiedTargets, player.id) --向不可成为目标的列表添加角色
    else
      room:doIndicate(player.id, table.map(room:getOtherPlayers(player), Util.IdMapper))
      local targets = table.filter(room:getOtherPlayers(player), function(p) return not p:isKongcheng() end) --获取所有符合目标的角色，可以在p定义是什么条件，这里定义的非空城
      local extraData = {                                                                                    --这是让所有人选一张牌的意思，照着抄就行了，如果可选装备，就填true
        num = 1,
        min_num = 1,
        include_equip = false,
        pattern = ".",
        reason = self.name,
      }
      for _, p in ipairs(targets) do
        p.request_data = json.encode({ "choose_cards_skill", "#sw_mansi-card", true, extraData }) --获取所有已经被展示的牌，然后让玩家来选择
      end
      room:notifyMoveFocus(room:getOtherPlayers(player), self.name)                               --告诉出除了角色外的其他角色
      room:doBroadcastRequest("AskForUseActiveSkill", targets)                                    --发送请求信息，就是询问选择了
      for _, p in ipairs(targets) do
        local id
        if p.reply_ready then
          local replyCard = json.decode(p.client_reply).card
          id = json.decode(replyCard).subcards[1] --这里是，如果目标展示了牌，那么获取这张展示的牌的信息
        else
          id = table.random(p:getCardIds("h"))    --如果烧条到头他还不展示，那就从手牌里随机展示一张
        end
        room:setPlayerMark(p, "sw_mansi-tmp", id) --把卡牌信息贴到这个人头上
      end

      local cards = {}               --表，空的
      for _, p in ipairs(targets) do --开始遍历这些人头上的标记信息，把这些信息记录到cards里
        if not p.dead then
          local id = p:getMark("sw_mansi-tmp")
          p:showCards({ id })
          if room:getCardOwner(id) == p and room:getCardArea(id) == Card.PlayerHand then
            table.insertIfNeed(cards, id)
          end
        end
      end
      if player.dead or #cards == 0 then return end                                                     --如果没有或者玩家死了，告终
      local red = table.filter(cards, function(id) return Fk:getCardById(id).color == Card.Red end)     --寻找cards里的红色牌
      local black = table.filter(cards, function(id) return Fk:getCardById(id).color == Card.Black end) --同上但是黑色
      if #red > #black or #black == 0 then                                                              --红大于黑或者没黑的话xxx
        player:broadcastSkillInvoke(self.name, 1)
        player.room:notifySkillInvoked(player, self.name, "defensive")
        room:useVirtualCard("archery_attack", nil, player, room:getOtherPlayers(player, true), self.name, true) --视为一张万箭齐发，目标指向除玩家外的所有人，其实也可以是所有人，因为不吃这张牌，会被自动排除
      elseif #red < #black or #red == 0 then
        player:broadcastSkillInvoke(self.name, 2)
        player.room:notifySkillInvoked(player, self.name, "defensive")
        room:useVirtualCard("savage_assault", nil, player, room:getOtherPlayers(player, true), self.name, true) --同↑↑↑↑，但是南蛮入侵
      end
      if #red == #black then                                                                                    --如果数量相等
        player:broadcastSkillInvoke(self.name, 3)
        player.room:notifySkillInvoked(player, self.name, "defensive")
        local color = { "red", "black" } --询问玩家选择什么颜色的牌，就获得那些个颜色的所有牌
        local choscolor = room:askForChoice(player, color, self.name)
        if choscolor == "red" then
          local dummy = Fk:cloneCard("dilu")
          dummy:addSubcards(red)
          room:obtainCard(player.id, dummy, true, fk.ReasonPrey)
        else
          local dummy = Fk:cloneCard("dilu")
          dummy:addSubcards(black)
          room:obtainCard(player.id, dummy, true, fk.ReasonPrey)
        end
      end
      for _, p in ipairs(targets) do
        if not p.dead and p:getMark("sw_mansi-tmp") ~= 0 then
          local id = p:getMark("sw_mansi-tmp")
          if room:getCardOwner(id) == p and room:getCardArea(id) == Card.PlayerHand then
            room:setPlayerMark(p, "sw_mansi-tmp", 0)     --最后设置标记归零，别忘了这种机制
            room:throwCard({ id }, self.name, p, player) --最后，把所有没选的扔了
          end
        end
      end
    end
  end,
}
huaman:addSkill(sw_mansi)
Fk:loadTranslationTable {
  ["sww__huaman"] = "花鬘",
  ["sw_mansi"] = "蛮嗣",
  [":sw_mansi"] = "锁定技，【南蛮入侵】和【万箭齐发】对你无效；准备阶段，你令其他所有角色同时选择并展示一张手牌，这些牌于技能效果执行后弃置，若展示的牌中：" ..
      "黑色多于红色，你视为使用一张【万箭齐发】；红色多于黑色，你视为使用一张【南蛮入侵】；相等，你选择一种颜色的所有牌获得",

  ["#sw_mansi-card"] = "蛮嗣：请展示一张手牌",
}
local sw_xiangxi = fk.CreateActiveSkill {
  name = "sw_xiangxi",
  anim_type = "control",
  mute = true,
  can_use = function(self, player)
    return player:usedSkillTimes(self.name, Player.HistoryPhase) < 1
  end,
  card_num = 0,
  card_filter = function() return false end,
  target_num = 1,
  target_filter = function(self, to_select, selected)
    return #selected == 0 and to_select ~= Self.id
  end,
  on_use = function(self, room, effect)
    local player = room:getPlayerById(effect.from)
    local to = room:getPlayerById(effect.tos[1])
    room:notifySkillInvoked(player, self.name)
    player:broadcastSkillInvoke(self.name, 1)
    local choices = U.doStrategy(room, player, to, { "sw_xiangxi-xiangxi", "sw_xiangxi-yanggong" }, --谋弈技能，需要俩人一起选
      { "sw_xiangxi-shouwei", "sw_xiangxi-fanji" }, self.name, 1)
    if choices[1] == "sw_xiangxi-xiangxi" and choices[2] ~= "sw_xiangxi-shouwei" then               --谋弈会存在四种情况，但是只需要写两种就够了
      player:broadcastSkillInvoke(self.name, 1)
      local targets = table.map(room:getOtherPlayers(player), Util.IdMapper)                        --谋弈成功，视为一张南蛮入侵，tos能把我难为死
      local use = {
        from = player.id,
        tos = table.map(targets, function(p) return { p } end),
        card = Fk:cloneCard("savage_assault"),
        extraUse = true,
      }
      use.card.skillName = self.name
      room:useCard(use)
      if use.damageDealt then
        for _, p in ipairs(room.players) do
          if use.damageDealt[p.id] then --锁定每个受到伤害的角色
            room:askForDiscard(p, 1, 1, true, self.name, false, nil, "#sw_xiangxi-discards")
          end
        end
      end
    elseif choices[1] == "sw_xiangxi-yanggong" and choices[2] ~= "sw_xiangxi-fanji" then
      player:broadcastSkillInvoke(self.name, 2)
      if (#to:getCardIds(player.Hand) + #to:getCardIds(player.Equip)) > 1 then
        local cards = room:askForCardsChosen(player, to, 2, 2, "he", self.name, "#sw_xiangxi-choscard")
        local dummy = Fk:cloneCard("dilu")
        dummy:addSubcards(cards) --第二种情况，谋弈成功，但是这里是拿他牌的，然后对其使用杀
        room:obtainCard(player.id, dummy, true, fk.ReasonPrey)
      else
        local dummy = Fk:cloneCard("dilu")
        dummy:addSubcards(to:getCardIds("he"))
        room:obtainCard(player.id, dummy, true, fk.ReasonPrey)
      end
      room:useVirtualCard("wd_poison__slash", nil, player, to, self.name, true) --毒杀真长吧
    else
      room:useVirtualCard("slash", nil, to, player, self.name, true)
      player:drawCards(1)
      player:broadcastSkillInvoke(self.name, 3) --如果失败，挨打
    end
  end,
}
huaman:addSkill(sw_xiangxi)
Fk:loadTranslationTable {
  ["sw_xiangxi"] = "象袭",
  [":sw_xiangxi"] = "出牌阶段限一次，你可以与一名其他角色进行谋弈，若你赢且你选择了：<br>" ..
      "“南蛮凶袭”，你视为使用一张【南蛮入侵】，受到此牌伤害的角色需弃置一张牌；<br>" ..
      "“佯攻探敌”，你获得其两张牌并视为对其使用一张毒【杀】；<br>" ..
      "若你没赢，你摸一张牌，其视为对你使用一张【杀】",

  ["#sw_xiangxi-discards"] = "遭到了南蛮侵袭，南蛮凶猛!(弃置一张牌)", --我只能说，谋弈技能翻译表就是多 他妈的
  ["#sw_xiangxi-choscard"] = "汉人不过如此，拿来吧!(选择获得其两张牌)",
  ["sw_xiangxi-xiangxi"] = "南蛮凶袭",
  ["sw_xiangxi-yanggong"] = "佯攻探敌",
  ["sw_xiangxi-shouwei"] = "竭力御敌",
  ["sw_xiangxi-fanji"] = "起兵伐蛮",
  [":sw_xiangxi-xiangxi"] = "谋奕成功后，视为使用【南蛮入侵】",
  [":sw_xiangxi-yanggong"] = "谋奕成功后，获得其两张牌并视为对其使用毒【杀】",
  [":sw_xiangxi-shouwei"] = "用于防御“南蛮来袭”(防止其使用【南蛮入侵】)，若成功，对对其使用【杀】",
  [":sw_xiangxi-fanji"] = "用于防御“佯攻探敌”(防止其获得你的牌)，若成功，对对其使用【杀】",
}

local sw_niyuan = fk.CreateTriggerSkill {
  name = "sw_niyuan",
  anim_type = "masochism",
  events = { fk.Damaged },
  can_trigger = function(self, event, target, player, data)
    return target == player and player:hasSkill(self)
  end,
  on_cost = function(self, event, target, player, data)
    local room = player.room
    local targets = table.map(room:getOtherPlayers(player), Util.IdMapper)
    local tos = room:askForChoosePlayers(player, targets, 1, 1, "#sw_niyuan-choose", self.name)
    if #tos > 0 then
      self.cost_data = tos[1]
      return true --在on_cost里处理完选人信息，传给use
    end
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    local to = room:getPlayerById(self.cost_data)
    if not player:isNude() then
      local card = room:askForCard(player, 1, 1, true, self.name, true, nil, "#sw_niyuan-chocard:" .. to.id) --选完人了，这里选牌递给他
      if #card > 0 then
        room:setCardMark(Fk:getCardById(card[1]), "sw_niyuan-turn", 1)
        local dummy = Fk:cloneCard("dilu")
        dummy:addSubcards(card)
        room:obtainCard(to.id, dummy, false, fk.ReasonGive) --加id加id加id
        local cardIds = {}
        for _, cid in ipairs(to:getCardIds("h")) do
          local cards = Fk:getCardById(cid)
          if to:canUse(cards) then table.insert(cardIds, cid) end --这里是遍历他手中，当前可用的牌，自动屏蔽不可用的牌
        end
        if #cardIds > 0 then
          local use = U.askForUseRealCard(room, to, cardIds, nil, self.name, "#AskForUseHandCard", --询问他使用，这张牌有特殊数据，不计次数，不限距离
            { bypass_distances = true, bypass_times = true })                                      --这里就是特殊数据
          if use then                                                                              --if
            if use.card:getMark("sw_niyuan-turn") > 0 then
              player:drawCards(1)
              to:drawCards(1) --如果这张牌带有标记，一起摸一张
            end
            local phc = {}
            for _, cid in ipairs(player:getCardIds("h")) do
              local cards = Fk:getCardById(cid)
              if player:canUse(cards) then table.insert(phc, cid) end --如果他用了，那你也能用，同上，遍历自己的手牌筛选出能用的d
            end
            if #phc > 0 then
              U.askForUseRealCard(room, player, phc, nil, self.name, "#AskForUseHandCard",
                { bypass_distances = true, bypass_times = true }) --一样的
            end
          end
        end
      end
    else
      player:drawCards(2)
    end
  end,
}
huaman:addSkill(sw_niyuan)
Fk:loadTranslationTable {
  ["sw_niyuan"] = "逆缘",
  [":sw_niyuan"] = "当你受到伤害后，你可以选择一名其他角色，交给其一张牌，其可以使用一张手牌，若其使用了牌，你也可以使用一张手牌(无次数和距离限制)，若其使用的是你交出的牌，" ..
      "则你与其各摸一张牌；若你没有手牌，你摸两张牌",

  ["#sw_niyuan-choose"] = "逆缘：选择要交给其一张牌的角色",
  ["#sw_niyuan-chocard"] = "逆缘：选择要交给 %src 的牌",
}
local dongbai = General(extension, "sww__dongbai", "qun", 3, 3, General.Female)
local sw_lianzhu = fk.CreateActiveSkill {
  name = "sw_lianzhu",
  mute = true,
  can_use = function(self, player)
    return not player:isKongcheng() and player:usedSkillTimes(self.name, Player.HistoryPhase) == 0
  end,
  min_card_num = 1,
  card_filter = function(self, to_select, selected)
    return Fk:getCardById(to_select).color == Card.Black and not Self:prohibitDiscard(Fk:getCardById(to_select))
  end,
  min_target_num = 1,
  target_filter = function(self, to_select, selected, cards)
    if Self.id == to_select or #selected == #cards then return false end
    return #selected == 0 or
        Fk:currentRoom():getPlayerById(to_select).hp == Fk:currentRoom():getPlayerById(selected[1]).hp
  end,
  feasible = function(self, selected, selected_cards)
    return #selected > 0 and #selected == #selected_cards
  end,
  on_use = function(self, room, effect)
    local player = room:getPlayerById(effect.from)
    player:broadcastSkillInvoke(self.name)
    room:notifySkillInvoked(player, self.name, "control")
    room:throwCard(effect.cards, self.name, player, player)
    local tos = table.map(effect.tos, Util.Id2PlayerMapper)
    for _, p in ipairs(tos) do
      room:addPlayerMark(p, "@sw_lianzhu-round")
    end
  end,
}
local sw_lianzhu_prohibit = fk.CreateProhibitSkill {
  name = "#sw_lianzhu_prohibit",
  prohibit_use = function(self, player, card)
    if player:getMark("@sw_lianzhu-round") > 0 then
      return card.color == Card.Black
    end
  end,
  prohibit_response = function(self, player, card)
    if player:getMark("@sw_lianzhu-round") > 0 then
      return card.color == Card.Black
    end
  end,
  prohibit_discard = function(self, player, card)
    if player:getMark("@sw_lianzhu-round") > 0 then
      return card.color == Card.Black
    end
  end,
}
local sw_lianzhu_trigger = fk.CreateTriggerSkill {
  name = "#sw_lianzhu_trigger",
  mute = true,
  main_skill = sw_lianzhu,
  events = { fk.Damaged, fk.DamageInflicted },
  can_trigger = function(self, event, target, player, data)
    if event == fk.Damaged then
      return player:hasSkill(self) and target == player and not player:isNude()
    else
      return target == player and player:getMark("@sw_lianzhu-round") > 0
    end
  end,
  on_cost = function(self, event, target, player, data)
    return true
  end,
  on_use = function(self, event, target, player, data)
    if event == fk.Damaged then
      player.room:askForUseActiveSkill(player, "sw_lianzhu", "#sw_lianzhu")
    else
      data.damage = data.damage + player:getMark("@sw_lianzhu-round")
    end
  end,
}
sw_lianzhu:addRelatedSkill(sw_lianzhu_prohibit)
sw_lianzhu:addRelatedSkill(sw_lianzhu_trigger)
dongbai:addSkill(sw_lianzhu)

local sw_shichongg = fk.CreateTriggerSkill {
  name = "sw_shichongg",
  anim_type = "drawcard",
  events = { fk.Damage },
  can_trigger = function(self, event, target, player, data)
    return player:hasSkill(self) and target and data.damage > 1
  end,
  on_use = function(self, event, target, player, data)
    player:drawCards(1, self.name)
    if target.hp > player.hp and not player.dead and player:isWounded() then
      player.room:recover { num = 1, skillName = self.name, who = player, recoverBy = player }
    end
  end,
}
local sw_shichongg_maxcards = fk.CreateMaxCardsSkill {
  name = "#sw_shichongg_maxcards",
  exclude_from = function(self, player, card)
    return player:hasSkill(self) and card.color == Card.Black
  end,
}
sw_shichongg:addRelatedSkill(sw_shichongg_maxcards)
dongbai:addSkill(sw_shichongg)
Fk:loadTranslationTable {
  ["sww__dongbai"] = "董白",

  ["sw_lianzhu"] = "连诛",
  [":sw_lianzhu"] = "每当你受到伤害后，或出牌阶段限一次，你可以弃置任意张黑色牌，令体力值相同的等量其他角色无法使用、打出或弃置黑色牌，且受到伤害+1直到本轮结束。",
  ["#sw_lianzhu"] = "连诛：弃置任意张黑色牌，令体力值相同的等量其他角色无法使用、打出或弃置黑色牌，且受到伤害+1直到本轮结束",
  ["#sw_lianzhu_prohibit"] = "连诛",
  ["#sw_lianzhu_trigger"] = "连诛",
  ["@sw_lianzhu-round"] = "连诛",

  ["sw_shichongg"] = "恃宠",
  [":sw_shichongg"] = "①当一名角色造成大于1点伤害后，你可以摸一张牌，若其体力值大于你，你回复一点体力。②你的黑色牌不占用手牌上限。",

  ["$sw_lianzhu1"] = "诛汝九族，以泄我心头之恨！",
  ["$sw_lianzhu2"] = "汝身犯连诛之罪，本小姐岂可轻饶？",
  ["$sw_shichongg1"] = "坐上这华盖车，可真威风啊。",
  ["$sw_shichongg2"] = "跟着我爷爷，还有什么好怕的？",
  ["~sww__dongbai"] = "我还没有……享尽荣华…",
}
local guanqiujian = General(extension, "sww__guanqiujian", "wei", 4)
local sw_zhengrong = fk.CreateTriggerSkill {
  name = "sw_zhengrong",
  anim_type = "offensive",
  events = { fk.TargetSpecified, fk.TurnEnd, fk.TurnStart },
  can_trigger = function(self, event, target, player, data)
    if event == fk.TargetSpecified then
      return target == player and player:hasSkill(self.name) and player.phase == Player.Play and data.firstTarget and
          table.find(TargetGroup:getRealTargets(data.tos), function(pid) return pid ~= player.id end)
    else
      return player == target and not player:isKongcheng() and #player:getPile("sw_rong") > 0
    end
  end,
  on_cost = function(self, event, target, player, data)
    if event == fk.TargetSpecified then
      local targets = table.filter(AimGroup:getAllTargets(data.tos), function(id)
        return not player.room:getPlayerById(id).dead and not player.room:getPlayerById(id):isNude()
      end)
      if #targets == 0 then return end
      local to = player.room:askForChoosePlayers(player, targets, 1, 1,
        "#sw_zhengrong-chose", self.name, true)
      if #to > 0 then
        self.cost_data = to[1]
        return true
      end
    else
      return player.room:askForSkillInvoke(player, self.name, nil, "征荣：是否使用等量的手牌替换等量的荣")
    end
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    if event == fk.TargetSpecified then
      local tar = room:getPlayerById(self.cost_data)
      local card = room:askForCardChosen(player, tar, "he", self.name)
      player:addToPile("sw_rong", card, false, self.name)
    else
      local cids = room:askForArrangeCards(player, self.name,
        { player:getPile("sw_rong"), player:getCardIds(Player.Hand), "sw_rong", "$Hand" }, "征荣：请选择要替换的牌", true)
      U.swapCardsWithPile(player, cids[1], cids[2], self.name, "sw_rong")
    end
  end,
}
guanqiujian:addSkill(sw_zhengrong)
Fk:loadTranslationTable {
  ["sww__guanqiujian"] = "毌丘俭",
  ["sw_zhengrong"] = "征荣",
  ["sw_rong"] = "荣",
  ["#sw_zhengrong-chose"] = "征荣：选择一名角色，将其一张牌置于你的武将牌上",
  [":sw_zhengrong"] = "当你使用非装备牌指定目标后，若目标不包含你，你可以将其中一个目标的一张牌置于你的武将牌上，称为“荣”，你的回合开始或结束时，你可以使用任意张手牌交换“荣”。",
}
local sw_hongju = fk.CreateTriggerSkill {
  name = "sw_hongju",
  frequency = Skill.Wake,
  events = { fk.EventPhaseStart },
  can_trigger = function(self, event, target, player, data)
    return target == player and player:hasSkill(self.name) and player.phase == Player.Start and
        player:usedSkillTimes(self.name, Player.HistoryGame) == 0
  end,
  can_wake = function(self, event, target, player, data)
    return #player:getPile("sw_rong") > 2
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    player:broadcastSkillInvoke("sw_hongju")
    local n = #player:getPile("sw_rong")
    player:drawCards(n, self.name)
    room:handleAddLoseSkills(player, "sw_qingce", nil, true, false)
  end,
}
guanqiujian:addSkill(sw_hongju)
Fk:loadTranslationTable {
  ["sw_hongju"] = "鸿举",
  [":sw_hongju"] = "觉醒技，准备阶段，若你的“荣”大于等于3，你摸X张牌并获得清侧(X为荣的数量)。",
}

local sw_qingce = fk.CreateActiveSkill {
  name = "sw_qingce",
  anim_type = "control",
  target_num = 0,
  card_num = 1,
  expand_pile = "sw_rong",
  prompt = "#sw_qingce",
  target_filter = Util.FalseFunc,
  card_filter = function(self, to_select, selected)
    return #selected == 0 and Self:getPileNameOfId(to_select) == "sw_rong"
  end,
  on_use = function(self, room, use)
    local player = room:getPlayerById(use.from)
    room:moveCardTo(use.cards, Card.DiscardPile, nil, fk.ReasonPutIntoDiscardPile, self.name, "sw_rong")
    local chc = { "qingce_qizhi", "qingce_yidong" }
    local chs = room:askForChoice(player, chc, self.name)
    if chs == "qingce_qizhi" then
      local to = room:askForChoosePlayers(player, table.map(player.room.alive_players, function(p)
        return #p:getCardIds { Player.Hand, Player.Equip, Player.Judge } > 0 and p.id
      end), 1, 1, "#qingce_qizhi", self.name, false)
      local cards = room:askForCardsChosen(player, room:getPlayerById(to[1]), 1, 1, "hej", self.name)
      room:throwCard(cards, self.name, room:getPlayerById(to[1]), player)
    else
      local to = room:askForChooseToMoveCardInBoard(player, "#qingce_yidong-choose", self.name, true)
      if #to == 2 then
        room:askForMoveCardInBoard(player, room:getPlayerById(to[1]), room:getPlayerById(to[2]), self.name)
      end
    end
  end,
}
guanqiujian:addRelatedSkill(sw_qingce)
Fk:loadTranslationTable {
  ["sw_qingce"] = "清侧",
  [":sw_qingce"] = "出牌阶段，可以弃置一枚“荣”，然后选择一项：1.弃置一名角色区域内的一张牌；2.移动场上的一张牌",

  ["#sw_qingce"] = "清侧：你可以移去一张“荣”，然后执行效果",
  ["#sw_qingce-phase"] = "清侧：是否发动清侧",
  ["qingce_qizhi"] = "弃置一名角色区域内的一张牌",
  ["qingce_yidong"] = "移动一名角色区域内的一张牌",
  ["#qingce_qizhi"] = "清侧：弃置一名角色区域内的一张牌",
  ["#qingce_yidong-choose"] = "清侧：你可以移动场上的一张牌",

}
local zoushi = General(extension, "sww__zoushi", "qun", 3, 3, General.Female)
local sw_huoshui = fk.CreateActiveSkill {
  name = "sw_huoshui",
  mute = true,
  card_num = 1,
  target_num = 1,
  can_use = function(self, player)
    return not player:isNude()
  end,
  card_filter = function(self, to_select, selected)
    return #selected == 0 and Fk:getCardById(to_select).type == Card.TypeEquip
  end,
  target_filter = function(self, to_select, selected, selected_cards)
    return #selected == 0 and #selected_cards == 1
        and U.canMoveCardIntoEquip(Fk:currentRoom():getPlayerById(to_select), selected_cards[1], true)
  end,
  on_use = function(self, room, effect)
    local player = room:getPlayerById(effect.from)
    room:notifySkillInvoked(player, self.name, "control")
    player:broadcastSkillInvoke(self.name, math.random(2))
    local to = room:getPlayerById(effect.tos[1])
    room:addPlayerMark(to, MarkEnum.UncompulsoryInvalidity .. "-turn")
    room:addPlayerMark(to, "@@sw_huoshui-turn")
    U.moveCardIntoEquip(room, to, effect.cards[1], self.name, true, player)
    if to:isWounded() then
      room:recover { num = 1, skillName = self.name, who = to, recoverBy = player }
      if player.dead or to.dead then return end
      if room:askForSkillInvoke(player, self.name, nil, "#sw_huoshui-turnover:" .. to.id) then
        player:broadcastSkillInvoke(self.name, math.random(3, 4))
        to:turnOver()
      end
    else
      room:loseHp(to, 1, self.name)
    end
  end,
}

zoushi:addSkill(sw_huoshui)

local sw_qingcheng = fk.CreateTriggerSkill {
  name = "sw_qingcheng",
  anim_type = "control",
  frequency = Skill.Compulsory,
  events = { fk.CardUsing, fk.CardResponding },
  can_trigger = function(self, event, target, player, data)
    return player:hasSkill(self) and target == player and data.card.name == "jink" and
        #player:getEquipments(Card.SubtypeArmor) == 0
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    for _, p in ipairs(room:getOtherPlayers(player)) do
      if player.dead then break end
      if p.gender == General.Male and not p:isNude() then
        local card = room:askForCard(p, 1, 1, true, self.name, false, ".", "#sw_qingcheng-give:" .. player.id)
        room:obtainCard(player, card[1], false, fk.ReasonGive)
      end
    end
  end,
}

local sw_qingcheng_maxcards = fk.CreateMaxCardsSkill {
  name = "#sw_qingcheng_maxcards",
  frequency = Skill.Compulsory,
  correct_func = function(self, player)
    if player:hasSkill(self) and #player:getEquipments(Card.SubtypeWeapon) == 0 then
      local n = 0
      for _, p in ipairs(Fk:currentRoom().alive_players) do
        if p.gender == General.Male then n = n + 1 end
      end
      return n
    end
  end,
}
sw_qingcheng:addRelatedSkill(sw_qingcheng_maxcards)

local sw_qingcheng_distance = fk.CreateDistanceSkill {
  name = "#sw_qingcheng_distance",
  frequency = Skill.Compulsory,
  correct_func = function() return 0 end,
  fixed_func = function(self, from, to)
    if from:hasSkill(self) and #from:getEquipments(Card.SubtypeDefensiveRide) == 0 and #from:getEquipments(Card.SubtypeOffensiveRide) == 0 and to.gender == General.Male then
      return 1
    end
    if to:hasSkill(self) and #to:getEquipments(Card.SubtypeDefensiveRide) == 0 and #to:getEquipments(Card.SubtypeOffensiveRide) == 0 and from.gender == General.Male then
      return 1
    end
  end,
}
sw_qingcheng:addRelatedSkill(sw_qingcheng_distance)

zoushi:addSkill(sw_qingcheng)

Fk:loadTranslationTable {
  ["sww__zoushi"] = "邹氏",

  ["sw_huoshui"] = "祸水",
  [":sw_huoshui"] = "出牌阶段，你可以将一张装备牌置入一名其他角色的装备区（替换原装备）并令其非锁定技失效至回合结束，若其未受伤，其失去一点体力；若已受伤，其回复一点体力，且你可令其翻面。",
  ["#sw_huoshui-turnover"] = "祸水：你可以令 %src 翻面",
  ["@@sw_huoshui-turn"] = "祸水",

  ["sw_qingcheng"] = "倾城",
  [":sw_qingcheng"] = "锁定技，若你未装备：防具，每当你使用或打出【闪】时，所有其他男性角色交给须你一张牌；武器，你的手牌上限+X（X为存活男性角色数）；坐骑，你与男性角色，男性角色与你的距离为1。",
  ["#sw_qingcheng-give"] = "倾城：你须交给 %src 一张牌",

  ["$sw_huoshui1"] = "薄酒岂真醉，君心非我心。",
  ["$sw_huoshui2"] = "君爱一时欢，烽烟作良辰。",
  ["$sw_huoshui3"] = "红颜催人醉，你就别醒了吧~",
  ["$sw_huoshui4"] = "妾身害怕，你转过去嘛~",
  ["$sw_qingcheng1"] = "佳人倾城又倾国，何怨幽王戏诸侯？",
  ["$sw_qingcheng2"] = "武夫以力破阵，佳人凭貌倾城。",
  ["~sww__zoushi"] = "世间的成败得失，都要怪红颜祸水么…",
}

local fazheng = General(extension, "sww__fazheng", "shu", 3)

local sw_enyuan = fk.CreateTriggerSkill {
  name = "sw_enyuan",
  mute = true,
  frequency = Skill.Compulsory,
  events = { fk.AfterCardsMove, fk.Damaged },
  can_trigger = function(self, event, target, player, data)
    if player:hasSkill(self) then
      if event == fk.AfterCardsMove then
        for _, move in ipairs(data) do
          if move.from and move.from ~= player.id and move.to == player.id and move.toArea == Card.PlayerHand and #move.moveInfo > 1 then
            return true
          end
        end
      else
        return target == player and data.from and data.from ~= player and not data.from.dead
      end
    end
  end,
  on_trigger = function(self, event, target, player, data)
    if event == fk.AfterCardsMove then
      local tos = {}
      for _, move in ipairs(data) do
        if move.from and move.from ~= player.id and move.to == player.id and move.toArea == Card.PlayerHand and #move.moveInfo > 1 then
          table.insertIfNeed(tos, move.from)
        end
      end
      for _, pid in ipairs(tos) do
        if player:hasSkill(self) and not player.room:getPlayerById(pid).dead then
          self:doCost(event, target, player, { pid })
        end
      end
    else
      self:doCost(event, target, player, data)
    end
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    if event == fk.AfterCardsMove then
      player:broadcastSkillInvoke(self.name, math.random(2))
      room:notifySkillInvoked(player, self.name, "support")
      room:doIndicate(player.id, { data[1] })
      room:getPlayerById(data[1]):drawCards(1, self.name)
    else
      player:broadcastSkillInvoke(self.name, math.random(3, 4))
      room:notifySkillInvoked(player, self.name, "masochism")
      room:doIndicate(player.id, { data.from.id })
      room:addPlayerMark(data.from, "@sw_enyuan", data.damage)
    end
  end,
}

local sw_enyuan_delay = fk.CreateTriggerSkill {
  name = "#sw_enyuan_delay",
  mute = true,
  main_skill = sw_enyuan,
  frequency = Skill.Compulsory,
  events = { fk.EventPhaseEnd },
  can_trigger = function(self, event, target, player, data)
    return target ~= player and player:hasSkill(self) and target:getMark("@sw_enyuan") > 0 and
        not target:isKongcheng() and target.phase == Player.Play
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    room:doIndicate(player.id, { target.id })
    local n = math.min(target:getMark("@sw_enyuan"), #target:getCardIds("h"))
    room:notifySkillInvoked(player, sw_enyuan.name, "control")
    if n == 1 then player:broadcastSkillInvoke(sw_enyuan.name, math.random(3, 4)) end
    local card = room:askForCard(target, n, n, false, sw_enyuan.name, false, ".|.|.|hand",
      "#sw_enyuan-give::" .. player.id .. ":" .. n)
    if #card > 0 then
      local dummy = Fk:cloneCard("dilu")
      dummy:addSubcards(card)
      room:obtainCard(player, dummy, false, fk.ReasonGive)
    end
  end,
}
sw_enyuan:addRelatedSkill(sw_enyuan_delay)

fazheng:addSkill(sw_enyuan)

local sw_xuanhuo = fk.CreateActiveSkill {
  name = "sw_xuanhuo",
  can_use = function(self, player)
    return not player:isNude() and player:usedSkillTimes(self.name, Player.HistoryPhase) == 0
  end,
  card_num = 2,
  card_filter = function(self, to_select, selected)
    return #selected < 2
  end,
  target_num = 1,
  target_filter = function(self, to_select, selected)
    return #selected == 0 and to_select ~= Self.id and
        Fk:currentRoom():getPlayerById(to_select):getMark("sw_xuanhuo-phase") == 0
  end,
  on_use = function(self, room, effect)
    local player = room:getPlayerById(effect.from)
    local to = room:getPlayerById(effect.tos[1])
    local dummy = Fk:cloneCard("dilu")
    dummy:addSubcards(effect.cards)
    room:obtainCard(to, dummy, false, fk.ReasonGive)
    if player.dead then return end
    local get = to:isNude() and {} or room:askForCardsChosen(player, to, 0, 2, "he", self.name)
    if #get > 0 then
      local dilu = Fk:cloneCard("dilu")
      dilu:addSubcards(get)
      room:obtainCard(player, dilu, false, fk.ReasonPrey)
    end
    if player.dead then return end
    local n = 0
    for _, id in ipairs(get) do
      if table.contains(effect.cards, id) then
        n = n + 1
      end
    end
    if n == 0 then
      if not to:isKongcheng() then
        local card = room:askForCardChosen(player, to,
          { card_data = { { "$Hand", to:getCardIds(Player.Hand) } } }, self.name)
        room:obtainCard(player, card, false, fk.ReasonPrey)
      end
    elseif n == 1 then
      local card = Fk:cloneCard("slash")
      if to:prohibitUse(card) then return end
      local targets = {}
      for _, p in ipairs(room.alive_players) do
        if to:inMyAttackRange(p) and not to:isProhibited(p, card) then
          table.insert(targets, p.id)
        end
      end
      if #targets == 0 then return end
      local tos = room:askForChoosePlayers(player, targets, 1, 1, "#sw_xuanhuo-slash::" .. to.id, self.name, false,
        true)
      room:useVirtualCard("slash", nil, to, room:getPlayerById(tos[1]), self.name, true)
    else
      room:setPlayerMark(to, "sw_xuanhuo-phase", 1)
      player:setSkillUseHistory(self.name, 0, Player.HistoryPhase)
    end
  end,
}

fazheng:addSkill(sw_xuanhuo)
Fk:loadTranslationTable {
  ["sww__fazheng"] = "法正",

  ["sw_enyuan"] = "恩怨",
  [":sw_enyuan"] = "锁定技，①每当你受到其他角色造成的1点伤害后，令其获得1个“宿怨”标记，其每个出牌阶段结束时须交给你等同于“宿怨”标记数的手牌。②每当你获得其他角色至少两张牌时，你令其摸一张牌。",
  ["@sw_enyuan"] = "宿怨",
  ["#sw_enyuan-give"] = "恩怨：你须交给 %dest %arg 张手牌",
  ["#sw_enyuan_delay"] = "恩怨",

  ["sw_xuanhuo"] = "眩惑",
  [":sw_xuanhuo"] = "出牌阶段限一次，你可以交给一名其他角色两张牌，然后获得其至多两张牌，若你以此法获得和交出的牌中相同的牌数为：0，你观看其手牌并获得一张，1，视为其对其攻击范围内你选择的一名角色使用一张【杀】；2，视为未发动〖眩惑〗且本阶段无法对其发动。",
  ["#sw_xuanhuo-slash"] = "眩惑：选择一名角色，视为 %dest 对其使用【杀】",

  ["$sw_enyuan1"] = "承君之恩，正定思报。",
  ["$sw_enyuan2"] = "一餐之德，孝直当珍馐相报！",
  ["$sw_enyuan3"] = "毁伤吾者，锱铢必较！",
  ["$sw_enyuan4"] = "睚眦之怨，叫汝血肉来偿！",
  ["$sw_xuanhuo1"] = "欲先取之，必先予之",
  ["$sw_xuanhuo2"] = "重许靖之虚，揽才俊之实，望主公纳之。",
}

local yangxiu = General(extension, "sww__yangxiu", "wei", 3)
local sw_danlao = fk.CreateTriggerSkill {
  name = "sw_danlao",
  anim_type = "defensive",
  events = { fk.TargetSpecifying },
  can_trigger = function(self, event, target, player, data)
    return player:hasSkill(self) and data.firstTarget and player.hp > 0 and
        (data.card.type == Card.TypeTrick or data.card.trueName == "slash") and #AimGroup:getAllTargets(data.tos) > 1
  end,
  on_cost = function(self, event, target, player, data)
    return player.room:askForSkillInvoke(player, self.name, nil, "#sw_danlao-invoke:::" .. data.card:toLogString())
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    player:drawCards(1, self.name)
    local tos = player.room:askForChoosePlayers(player, AimGroup:getAllTargets(data.tos), 1, 1,
      "#sw_danlao-choose:::" .. data.card:toLogString(), self.name, true)
    if #tos > 0 then
      player.room:sortPlayersByAction(tos)
      local pid = room:getPlayerById(tos[1])
      table.insertIfNeed(data.nullifiedTargets, pid.id)
      AimGroup:cancelTarget(data, pid)
      pid:drawCards(1, self.name)
    end
    -- table.insertIfNeed(data.nullifiedTargets, player.id)
  end,
}
yangxiu:addSkill(sw_danlao)
Fk:loadTranslationTable {
  ["sww__yangxiu"] = "杨修",
  ["~sww__yangxiu"] = "自作聪明，作茧自缚，悔之晚矣……",
  ["sw_danlao"] = "啖酪",
  ["#sw_danlao-invoke"] = "啖酪：你可以摸一张牌",
  ["#sw_danlao-choose"] = "啖酪：选择一名角色，令其摸一张牌并令 %arg 对其无效",
  [":sw_danlao"] = "当有【杀】或锦囊牌指定多于一个目标时，你可以摸一张牌，然后令一名此牌的目标角色摸一张牌，令此牌对其无效。",

  ["$sw_danlao1"] = "此酪味美，诸君何不与我共食之？",
  ["$sw_danlao2"] = "来来来，丞相美意，不可辜负啊。",
}
local sw_jilei = fk.CreateTriggerSkill {
  name = "sw_jilei",
  anim_type = "masochism",
  events = { fk.Damaged },
  can_trigger = function(self, event, target, player, data)
    return target == player and player:hasSkill(self) and data.from and not data.from.dead
  end,
  on_cost = function(self, event, target, player, data)
    local room = player.room
    if room:askForSkillInvoke(player, self.name, nil, "#ty__jilei-invoke::" .. data.from.id) then
      room:doIndicate(player.id, { data.from.id })
      return true
    end
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    local typechose
    local choice = room:askForChoice(player, { "basic", "trick", "equip" }, self.name)
    if choice == "basic" then
      typechose = Card.TypeBasic
    elseif choice == "trick" then
      typechose = Card.TypeTrick
    elseif choice == "equip" then
      typechose = Card.TypeEquip
    end
    local mark = U.getMark(data.from, "@sw_jilei")
    local chc = { "sw_jileiproint", "sw_jileigive" }
    -- local ids = table.filter(data.from:getCardIds("h"), function(id) return Fk:getCardById(id).type == typechose end)
    -- if #ids > 0 then
    --   table.insertIfNeed(chc, "sw_jileigive")
    -- end
    local chs = room:askForChoice(player, chc, self.name)
    if chs == "sw_jileiproint" then
      if table.insertIfNeed(mark, choice .. "_char") then
        room:setPlayerMark(data.from, "@sw_jilei", mark)
      end
    else
      local ids = table.filter(data.from:getCardIds("h"), function(id) return Fk:getCardById(id).type == typechose 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
      data.from:drawCards(1, self.name)
    end
  end,

  refresh_events = { fk.TurnStart },
  can_refresh = function(self, event, target, player, data)
    return target == player and player:getMark("@sw_jilei") ~= 0
  end,
  on_refresh = function(self, event, target, player, data)
    player.room:setPlayerMark(player, "@sw_jilei", 0)
  end,
}
local sw_jilei_prohibit = fk.CreateProhibitSkill {
  name = "#sw_jilei_prohibit",
  prohibit_use = function(self, player, card)
    if table.contains(U.getMark(player, "@sw_jilei"), card:getTypeString() .. "_char") 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 table.contains(U.getMark(player, "@sw_jilei"), card:getTypeString() .. "_char") 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_discard = function(self, player, card)
    return table.contains(U.getMark(player, "@sw_jilei"), card:getTypeString() .. "_char")
  end,
}
sw_jilei:addRelatedSkill(sw_jilei_prohibit)
yangxiu:addSkill(sw_jilei)
Fk:loadTranslationTable {
  ["sw_jilei"] = "鸡肋",
  ["#sw_jilei_prohibit"] = "鸡肋",
  [":sw_jilei"] = "当你受到伤害后，你选择一种类型的牌并选择：<br>①：令伤害来源无法使用，打出或弃置此类型的牌直到其下个回合开始；<br>②：获得伤害来源此类型的所有手牌，然后其摸一张牌",

  ["@sw_jilei"] = "鸡肋",
  ["sw_jileiproint"] = "令其封锁其此类型的手牌",
  ["sw_jileigive"] = "获得其此类型的手牌",

  ["$sw_jilei1"] = "今进退两难，势若鸡肋，魏王必当罢兵而还。",
  ["$sw_jilei2"] = "汝可令士卒收拾行装，魏王明日必定退兵。",
}
local zhangsong = General(extension, "sww__zhangsong", "shu", 3)
local sw_xiantu = fk.CreateTriggerSkill {
  name = "sw_xiantu",
  mute = true,
  anim_type = "drawcard",
  events = { fk.EventPhaseStart, fk.TurnEnd },
  can_trigger = function(self, event, target, player, data)
    if event == fk.EventPhaseStart then
      return player:hasSkill(self) and target.phase == Player.Start and not target.dead
    else
      local n = 0
      if player:usedSkillTimes("sw_xiantu", Player.HistoryTurn) > 0 and not player.dead then
        player.room.logic:getEventsOfScope(GameEvent.ChangeHp, 1, function(e)
          local damage = e.data[5]
          if damage and target == damage.from then
            n = n + damage.damage
          end
        end, Player.HistoryTurn)
        self.cost_data = n
        return n < player:getMark("sw_xiantu-turn")
      end
    end
  end,
  on_cost = function(self, event, target, player, data)
    if event == fk.EventPhaseStart then
      return player.room:askForSkillInvoke(player, self.name, data,
        "#sw_xiantu-invoke:" .. target.id .. "::" .. player.hp)
    else
      return true
    end
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    if event == fk.EventPhaseStart then
      player:broadcastSkillInvoke(self.name)
      room:notifySkillInvoked(player, self.name)
      local choices = {}
      local i1 = 1
      for i = i1, player.hp, 1 do
        table.insert(choices, tostring(i))
      end
      local choice = room:askForChoice(player, choices, self.name, "#sw_xiantu-choice")
      if choice ~= "0" then
        player:drawCards(tonumber(choice) * 1, self.name)
      end
      if player:isNude() then return end
      local cards
      if target ~= player then
        if #player:getCardIds("he") <= tonumber(choice) * 1 then
          cards = player:getCardIds("he")
        else
          cards = room:askForCard(player, tonumber(choice) * 1, tonumber(choice) * 1, true, self.name, false, ".",
            "#sw_xiantu-give:" .. target.id)
        end
        if #target:getCardIds(Player.Judge) > 0 then
          local card = room:askForCardChosen(player, target, "j", self.name)
          room:throwCard({ card }, self.name, target, player)
        end
        room:obtainCard(target.id, cards, false, fk.ReasonGive, player.id)
      end
      room:setPlayerMark(player, "sw_xiantu-turn", tonumber(choice) * 1)
    else
      player:broadcastSkillInvoke("sw_xiantu")
      room:notifySkillInvoked(player, "sw_xiantu", "negative")
      room:loseHp(player, player:getMark("sw_xiantu-turn") - self.cost_data, "sw_xiantu")
    end
  end,
}
zhangsong:addSkill(sw_xiantu)
Fk:loadTranslationTable {
  ["sww__zhangsong"] = "张松",
  ["~sww__zhangsong"] = "松之言并无虚谬，皇叔何故迟迟不发？",
  ["sw_xiantu"] = "献图",
  ["#sw_xiantu_trigger"] = "献图",
  [":sw_xiantu"] = "一名角色的准备阶段，你可以摸至多X张牌并交给其等量的牌，若如此做，你可以弃置其判定区的一张牌，其回合结束时，若其本回合造成的伤害不足X，你失去不足部分的体力(X为你以此法交出的牌数)。",

  ["#sw_xiantu-invoke"] = "献图：是否摸至多 %arg 张牌，然后交给 %src 等量的牌",
  ["#sw_xiantu-choice"] = "献图：选择要摸的牌数",
  ["#sw_xiantu-give"] = "献图：选择要交给 %src 的牌",

  ["$sw_xiantu1"] = "此乃战国无名氏所作，何谓新书？",
  ["$sw_xiantu2"] = "不过是拾前人牙惠，何足道哉？",
}
local sw_qiangzhi = fk.CreateTriggerSkill {
  name = "sw_qiangzhi",
  mute = true,
  events = { fk.RoundStart, fk.CardUsing, fk.CardResponding },
  can_trigger = function(self, event, target, player, data)
    if event == fk.RoundStart then
      return player:hasSkill(self) and
          table.find(player.room:getOtherPlayers(player), function(p) return p:getHandcardNum() > 0 end)
    else
      local mark = player:getMark("@sw_qiangzhi-round")
      local type = data.card:getTypeString()
      local suit = data.card:getSuitString(true)
      local num = data.card.number
      return target == player and mark ~= 0 and
          (type .. "_char" == mark[1] or suit == mark[2] or num == mark[3])
    end
  end,
  on_cost = function(self, event, target, player, data)
    local room = player.room
    if event == fk.RoundStart then
      local targets = table.map(table.filter(room:getOtherPlayers(player), function(p)
        return not p:isKongcheng()
      end), Util.IdMapper)
      local to = room:askForChoosePlayers(player, targets, 1, 1, "#sw_qiangzhi-choose", self.name, true)
      if #to > 0 then
        self.cost_data = to[1]
        return true
      end
    else
      return true
    end
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    if event == fk.RoundStart then
      player:broadcastSkillInvoke(self.name)
      room:notifySkillInvoked(player, self.name, "control")
      local to = room:getPlayerById(self.cost_data)
      room:doIndicate(player.id, { self.cost_data })
      local card = Fk:getCardById(room:askForCardChosen(player, to, "h", self.name))
      to:showCards(card)
      local type = card:getTypeString()
      local suit = card:getSuitString(true)
      local num = card.number
      if type ~= "notype" then
        room:setPlayerMark(player, "@sw_qiangzhi-round", { type .. "_char", suit, num })
      end
    else
      -- local n = 0
      local mark = player:getMark("@sw_qiangzhi-round")
      local type = data.card:getTypeString()
      local suit = data.card:getSuitString(true)
      local num = data.card.number
      if type .. "_char" == mark[1] or suit == mark[2] or num == mark[3] then
        --   n = n + 1
        -- end
        -- if suit == mark[2] then
        --   n = n + 1
        -- end
        -- if num == mark[3] then
        --   n = n + 1
        -- end
        player:broadcastSkillInvoke(self.name)
        room:notifySkillInvoked(player, self.name, "drawcard")
        player:drawCards(1, self.name)
      end
    end
  end,
}
zhangsong:addSkill(sw_qiangzhi)
Fk:loadTranslationTable {
  ["sw_qiangzhi"] = "强识",
  [":sw_qiangzhi"] = "每轮开始时，你展示一名其他角色一张牌，本轮你使用、打出牌的花色，点数，类型中，任意一项与此牌相等，你摸一张牌。",

  ["@sw_qiangzhi-round"] = "",
  ["#sw_qiangzhi-choose"] = "强识：你可以展示一名其他角色一张牌",

  ["$sw_qiangzhi1"] = "蜀道艰难，松有一图，可助阁下成事",
  ["$sw_qiangzhi2"] = "川中险要，皆在此图之中，还请将军切莫踟蹰",
}

local wangtao = General(extension, "sww__wangtao", "shu", 3, 3, General.Female)
Fk:loadTranslationTable {
  ["sww__wangtao"] = "王桃",
  ["~sww__wangtao"] = "人间芳菲尽，花落水长流...",
}
local sw_huguanwt = fk.CreateTriggerSkill {
  name = "sw_huguanwt",
  anim_type = "support",
  events = { fk.TurnEnd },
  can_trigger = function(self, event, target, player, data)
    if player:hasSkill(self) and not target.dead then
      local black = 0
      local red = 0
      player.room.logic:getEventsOfScope(GameEvent.UseCard, 1, function(e)
        local use = e.data[1]
        if use and use.from == target.id and use.card.color == Card.Black or use.card.color == Card.Red then
          if use.card.color == Card.Black then
            black = black + 1
          elseif use.card.color == Card.Red then
            red = red + 1
          end
        end
      end, Player.HistoryTurn)
      self.cost_data = { red, black }
      return (black > 0 or red > 0)
    end
  end,
  on_cost = function(self, event, target, player, data)
    return player.room:askForSkillInvoke(player, self.name, nil,
      "#sw_huguanwt:" .. target.id .. "::" .. math.min(self.cost_data[1], 5) .. ":" .. self.cost_data[2])
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    if self.cost_data[1] > 0 then
      target:drawCards(math.min(self.cost_data[1], 5), self.name)
    end
    if self.cost_data[2] > 0 then
      room:askForDiscard(target, self.cost_data[2], self.cost_data[2], true, self.name, false, nil,
        "#sw_huguanwt_dis:::" .. self.cost_data[2])
    end
    if self.cost_data[1] == 0 or self.cost_data[2] == 0 then
      local targets = table.filter(room:getOtherPlayers(player),
        function(p) return p:getHandcardNum() > player:getHandcardNum() end)
      if #targets == 0 then return end
      local tos = player.room:askForChoosePlayers(player, table.map(targets, Util.IdMapper), 1, 1, "#sw_huguanwt_draw",
        self.name, true)
      if #tos > 0 then
        local n = #room:getPlayerById(tos[1]):getCardIds(Player.Hand) - #player:getCardIds(Player.Hand)
        player:drawCards(math.min(n, 5), self.name)
      end
    end
  end,
}
wangtao:addSkill(sw_huguanwt)
Fk:loadTranslationTable {
  ["sw_huguanwt"] = "护关",
  [":sw_huguanwt"] = "一名角色的结束阶段，你可以令其摸等同于其本回合使用的红色牌数量的牌，然后弃置等同于" ..
      "其本回合使用黑色牌数量的牌，若其没有弃牌或没有摸牌，你可以将手牌调整至与任意角色相同(此技能摸牌的数量至多为五张)。",

  ["#sw_huguanwt"] = "护关：你可以令%src摸 %arg 张牌，然后弃置 %arg2 张牌",
  ["#sw_huguanwt_dis"] = "护关：你需要弃置 %arg 张牌",
  ["#sw_huguanwt_draw"] = "护关：请选择手牌大于你的一名其他角色",

  ["$sw_huguanwt1"] = "我夫乃关氏之俊杰，谁敢侮之",
  ["$sw_huguanwt2"] = "长刀系红缨，身伴千军万马、情随万水千山",
}
local sw_yaopei = fk.CreateActiveSkill {
  name = "sw_yaopei",
  anim_type = "offensive",
  prompt = "#sw_yaipei-inovk",
  interaction = function(self)
    local choiceList = {}
    local cards = Self.player_cards[Player.Hand]
    for _, id in ipairs(cards) do
      table.insertIfNeed(choiceList, Fk:getCardById(id):getSuitString(true))
    end
    if #choiceList == 0 then return false end
    return UI.ComboBox { choices = choiceList, all_choices = { "log_spade", "log_heart", "log_club", "log_diamond" } }
  end,
  can_use = function(self, player)
    return player:usedSkillTimes(self.name, Player.HistoryPhase) == 0 and player:getHandcardNum() > 0
  end,
  card_filter = Util.TrueFunc,
  target_filter = Util.FalseFunc,
  on_use = function(self, room, effect)
    local player = room:getPlayerById(effect.from)
    local suit = self.interaction.data
    local x
    local cid = player.player_cards[Player.Hand]
    local handsuits = table.filter(cid, function(id)
      return Fk:getCardById(id):getSuitString(true) == suit
    end)
    for _, id in ipairs(handsuits) do
      room:setCardMark(Fk:getCardById(id), "sw_yaopei", 1)
    end
    if #handsuits > 0 then
      table.shuffle(handsuits)
      x = #handsuits
      local positions = {}
      local y = #room.draw_pile
      for _ = 1, x, 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, x, 1 do
        table.insert(moveInfos, {
          ids = { handsuits[i] },
          from = player.id,
          toArea = Card.DrawPile,
          moveReason = fk.ReasonJustMove,
          skillName = self.name,
          drawPilePosition = positions[i],
        })
      end
      room:moveCards(table.unpack(moveInfos))
      local to = room:askForChoosePlayers(player, table.map(player.room.alive_players, function(p)
        return p.id
      end), 1, 1, "#sw_yaopei-draw:::" .. #handsuits, self.name, true)
      if #to > 0 then
        room:getPlayerById(to[1]):drawCards(#handsuits, self.name)
      end
    end
  end,
}
local sw_yaopei_dlc = fk.CreateTriggerSkill {
  name = "#sw_yaopei_dlc",
  events = { fk.Damaged },
  can_trigger = function(self, event, target, player, data)
    return target == player and player:hasSkill(sw_yaopei.name) and not player:isKongcheng()
  end,
  on_cost = function(self, event, target, player, data)
    return player.room:askForSkillInvoke(player, "sw_yaopei", nil, "#sw_yaopei-invoke")
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    local skill = sw_yaopei.name
    player:broadcastSkillInvoke("sw_yaopei")
    room:notifySkillInvoked(player, "sw_yaopei", "support")
    room:askForUseActiveSkill(target, skill, skill.prompt, true)
  end
}
local sw_yaopei_trigger = fk.CreateTriggerSkill {
  name = "#sw_yaopei_trigger",
  anim_type = "drawcard",
  events = { fk.CardUsing, fk.CardResponding },
  can_trigger = function(self, event, target, player, data)
    return player:hasSkill(sw_yaopei.name) and table.find(Card:getIdList(data.card), function(id)
      return Fk:getCardById(id):getMark("sw_yaopei") > 0
    end)
  end,
  on_cost = function(self, event, target, player, data)
    return player.room:askForSkillInvoke(player, self.name, nil, "#sw_yaopei-askto:" .. target.id)
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    local c = room:askForChoice(player,
      { "sw_yaopei-drawcard:" .. target.id, "sw_yaopei-discrad:" .. target.id, "Cancel" })
    if c == "sw_yaopei-drawcard:" .. target.id then
      target:drawCards(2, self.name)
    elseif c == "sw_yaopei-discrad:" .. target.id then
      local ids = table.random(target:getCardIds { Player.Hand, Player.Equip }, 2)
      room:throwCard(ids, self.name, target, player)
    end
    if target == player then
      if player:isWounded() then
        room:recover({
          who = player,
          num = 1,
          recoverBy = player,
          skillName = self.name
        })
      end
    end
  end,
}
sw_yaopei:addRelatedSkill(sw_yaopei_dlc)
sw_yaopei:addRelatedSkill(sw_yaopei_trigger)
wangtao:addSkill(sw_yaopei)
Fk:loadTranslationTable {
  ["sw_yaopei"] = "摇佩",
  [":sw_yaopei"] = "出牌阶段限一次或当你受到伤害后，你可以将一种花色的所有手牌洗入牌堆，然后令一名角色摸等量的牌，" ..
      "有角色使用或打出这些牌时，你可以令其摸两张牌或随机弃置两张牌，若该角色为你，你回复一点体力。",

  ["#sw_yaipei-inovk"] = "摇佩：你可以将任意花色的所有牌洗入牌堆",
  ["#sw_yaopei-draw"] = "摇佩：令一名角色摸 %arg 张牌",
  ["#sw_yaopei_trigger"] = "摇佩",
  ["sw_yaopei-drawcard"] = "令%src摸两张牌",
  ["sw_yaopei-discrad"] = "令%src弃两张牌",
  ["#sw_yaopei_dlc"] = "摇佩",
  ["#sw_yaopei-askto"] = "摇佩：是否令%src摸牌或弃牌",
  ["#sw_yaopei-invoke"] = "摇佩：你可以将任意花色的所有牌洗入牌堆",

  ["$sw_yaopei1"] = "金铃系玉瑶，步步鸣思君之环佩",
  ["$sw_yaopei2"] = "赠我琼瑶之君子，当携一世之窈窕",
}
local wangyue = General(extension, "sww__wangyue", "shu", 3, 3, General.Female)
Fk:loadTranslationTable {
  ["sww__wangyue"] = "王悦",
  ["~sww__wangyue"] = "姐姐，此景桃花似汝颜...",
}
local sw_huguanwy = fk.CreateTriggerSkill {
  name = "sw_huguanwy",
  anim_type = "support",
  events = { fk.TurnEnd },
  can_trigger = function(self, event, target, player, data)
    if player:hasSkill(self) and not target.dead then
      local black = 0
      local red = 0
      player.room.logic:getEventsOfScope(GameEvent.UseCard, 1, function(e)
        local use = e.data[1]
        if use and use.from == target.id and use.card.color == Card.Black or use.card.color == Card.Red then
          if use.card.color == Card.Black then
            black = black + 1
          elseif use.card.color == Card.Red then
            red = red + 1
          end
        end
      end, Player.HistoryTurn)
      self.cost_data = { red, black }
      return (black > 0 or red > 0)
    end
  end,
  on_cost = function(self, event, target, player, data)
    return player.room:askForSkillInvoke(player, self.name, nil,
      "#sw_huguanwy:" .. target.id .. "::" .. math.min(self.cost_data[2], 5) .. ":" .. self.cost_data[1])
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    if self.cost_data[2] > 0 then
      target:drawCards(math.min(self.cost_data[2], 5), self.name)
    end
    if self.cost_data[1] > 0 then
      room:askForDiscard(target, self.cost_data[1], self.cost_data[1], true, self.name, false, nil,
        "#sw_huguanwy_dis:::" .. self.cost_data[1])
    end
    if self.cost_data[1] == 0 or self.cost_data[2] == 0 then
      local targets = table.filter(room:getOtherPlayers(player),
        function(p) return p:getHandcardNum() > player:getHandcardNum() end)
      if #targets == 0 then return end
      local tos = player.room:askForChoosePlayers(player, table.map(targets, Util.IdMapper), 1, 1, "#sw_huguanwy_draw",
        self.name, true)
      if #tos > 0 then
        local n = #room:getPlayerById(tos[1]):getCardIds(Player.Hand) - #player:getCardIds(Player.Hand)
        player:drawCards(math.min(n, 5), self.name)
      end
    end
  end,
}
wangyue:addSkill(sw_huguanwy)
Fk:loadTranslationTable {
  ["sw_huguanwy"] = "护关",
  [":sw_huguanwy"] = "一名角色的结束阶段，你可以令其摸等同于其本回合使用的黑色牌数量的牌，然后弃置等同于" ..
      "其本回合使用红色牌数量的牌，若其没有弃牌或没有摸牌，你可以将手牌调整至与任意角色相同(此技能摸牌的数量至多为五张)。",

  ["#sw_huguanwy"] = "护关：你可以令%src摸 %arg 张牌，然后弃置 %arg2 张牌",
  ["#sw_huguanwy_dis"] = "护关：你需要弃置 %arg 张牌",
  ["#sw_huguanwy_draw"] = "护关：请选择手牌大于你的一名其他角色",

  ["$sw_huguanwy1"] = "同心守边土，蜀汉山河安",
  ["$sw_huguanwy2"] = "与君共进退，何处皆可栖",
}
local sw_mingluan = fk.CreateTriggerSkill {
  name = "sw_mingluan",
  anim_type = "support",
  events = { fk.EventPhaseStart },
  can_trigger = function(self, event, target, player, data)
    local hpup = table.map(table.filter(player.room:getOtherPlayers(player), function(p)
      return p.hp > 1
    end), Util.IdMapper)
    return player:hasSkill(self) and target == player and player.phase == Player.Play and #hpup > 0
  end,
  on_cost = function(self, event, target, player, data)
    local room = player.room
    local to = room:askForChoosePlayers(player, table.map(table.filter(room.alive_players, function(p)
      return p.hp > 1
    end), function(p) return p.id end), 1, 1, "#sw_mingluan-choose", 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)
    room:setPlayerMark(to, "sw_mingluan_trigger-turn", to.hp - 1)
    room:changeHp(to, -(to.hp - 1))
  end,
}
local sw_mingluan_trigger = fk.CreateTriggerSkill {
  name = "#sw_mingluan_trigger",
  anim_type = "offensive",
  mute = true,
  frequency = Skill.Compulsory,
  events = { fk.EnterDying, fk.EventPhaseStart },
  can_trigger = function(self, event, target, player, data)
    if event == fk.EnterDying then
      return target:getMark("sw_mingluan_trigger-turn") > 0
    else
      local mark = table.map(table.filter(player.room:getAlivePlayers(), function(p)
        return p:getMark("sw_mingluan_trigger-turn") > 0
      end), Util.IdMapper)
      return player.phase == Player.Finish and #mark > 0
    end
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    local n = target:getMark("sw_mingluan_trigger-turn")
    player:broadcastSkillInvoke("sw_mingluan")
    room:notifySkillInvoked(player, "sw_mingluan", "offensive")
    if event == fk.EnterDying then
      local cards = target:drawCards(n, self.name)
      room:recover {
        who = target,
        num = n,
        recoverBy = player,
        skillName = self.name
      }
      room:setPlayerMark(target, "sw_mingluan_trigger-turn", 0)
      if #cards > 2 then
        local to = room:askForChoosePlayers(target, table.map(player.room.alive_players, function(p)
          return p.id ~= player.id and p.id
        end), 1, 1, "#sw_mingluan-ask", self.name, true)
        if #to > 0 then
          room:damage {
            from = target,
            to = room:getPlayerById(to[1]),
            damage = 1,
            skillName = self.name,
          }
        end
      end
    else
      for _, p in ipairs(room:getAlivePlayers()) do
        if p:getMark("sw_mingluan_trigger-turn") > 0 then
          room:changeHp(p, p:getMark("sw_mingluan_trigger-turn"))
          room:setPlayerMark(p, "sw_mingluan_trigger-turn", 0)
          if p == player then
            p:drawCards(n, self.name)
          end
        end
      end
    end
  end,
}
sw_mingluan:addRelatedSkill(sw_mingluan_trigger)
wangyue:addSkill(sw_mingluan)
Fk:loadTranslationTable {
  ["sw_mingluan"] = "鸣鸾",
  [":sw_mingluan"] = "出牌阶段开始时，你可以令一名其他角色将体力调整为1，其本回合进入濒死状态时，其摸X张牌，然后将体力恢复至X，" ..
      "若其因此获得的牌大于两张，其可以对一名角色造成一点伤害；结束阶段，若你没有对其造成过伤害，其恢复X点体力，若为你，你摸X张牌(X为其因此失去的体力值)。",

  ["#sw_mingluan_trigger"] = "鸣鸾",
  ["#sw_mingluan-ask"] = "鸣鸾：请选择要造成伤害的目标",
  ["#sw_mingluan-choose"] = "鸣鸾：请选择一名角色，令其将体力调整至1",

  ["$sw_mingluan1"] = "比翼双飞鸾，连理缠绵枝。",
  ["$sw_mingluan2"] = "凤鸣鸾歌林间起，心悦君情相思暖。",
}

local xiahoushi = General(extension, "sww__xiahoushi", "shu", 3, 3, General.Female)
Fk:loadTranslationTable {
  ["sww__xiahoushi"] = "夏侯氏",
  ["~sww__xiahoushi"] = "柴木潮湿，不可拾取...",
}
local sw_qiaoshi = fk.CreateTriggerSkill {
  name = "sw_qiaoshi",
  anim_type = "drawcard",
  events = { fk.EventPhaseChanging },
  can_trigger = function(self, event, target, player, data)
    return player:hasSkill(self) and target == player and data.to == Player.Start and
        table.find(player.room.alive_players, function(p) return p:getHandcardNum() ~= player:getHandcardNum() end)
  end,
  on_cost = function(self, event, target, player, data)
    local room = player.room
    if player.room:askForSkillInvoke(player, self.name, nil, "#sw_qiaoshi-invoke") then
      local targets = table.map(table.filter(room:getOtherPlayers(player), function(p)
        return (p:getHandcardNum() ~= player:getHandcardNum())
      end), function(p) return p.id end)
      if #targets > 0 then
        local to = room:askForChoosePlayers(player, targets, 1, 1, "#sw_qiaoshi-choose", self.name, true)
        self.cost_data = to[1]
        if #to > 0 then
          return true
        end
      end
    end
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    local to = room:getPlayerById(self.cost_data)
    local cards
    if to:getHandcardNum() < player:getHandcardNum() then
      cards = to:drawCards(math.min(3, player:getHandcardNum() - to:getHandcardNum()), self.name)
    else
      cards = player:drawCards(math.min(3, to:getHandcardNum() - player:getHandcardNum()), self.name)
    end
    to:showCards(cards)
    room:delay(600)
    local damagecards = table.filter(cards, function(cid) return Fk:getCardById(cid).is_damage_card end)
    if #damagecards > 0 then
      local ids = room:askForChoosePlayers(player, table.map(player.room.alive_players, function(p)
        return p.id
      end), 1, 1, "#sw_qiaoshi_damage-ask", self.name, true)
      if #ids > 0 then
        if not room:getPlayerById(ids[1]).dead then
          room:damage {
            from = to,
            to = room:getPlayerById(ids[1]),
            damage = 1,
            skillName = self.name,
          }
        end
      end
    end
  end,
}
xiahoushi:addSkill(sw_qiaoshi)
Fk:loadTranslationTable {
  ["sw_qiaoshi"] = "樵拾",
  [":sw_qiaoshi"] = "准备阶段，你可以选择一名手牌数与你不同的其他角色，手牌较少的一方将手牌调整至与对方相同，若因此获得的牌中有伤害牌，你可以令其对一名角色造成一点伤害(至多因此摸3张牌)。",

  ["#sw_qiaoshi-invoke"] = "樵拾：是否选择一名角色，将你与其手牌数调整至较多的一方",
  ["#sw_qiaoshi-choose"] = "樵拾：请选择一名角色，将你与其手牌数调整至较多的一方",
  ["#sw_qiaoshi_damage-ask"] = "樵拾：你可以对一名角色造成一点伤害",

  ["$sw_qiaoshi1"] = "樵烟亮亮升，待君归来时",
  ["$sw_qiaoshi2"] = "青翠枝繁茂，采拾心欢喜",
}
local sw_yanyu = fk.CreateActiveSkill {
  name = "sw_yanyu",
  anim_type = "drawcard",
  min_card_num = 1,
  target_num = 0,
  can_use = function(self, player)
    return not player:isKongcheng() and player:usedSkillTimes(self.name, Player.HistoryPhase) < 2
  end,
  card_filter = function(self, to_select, selected)
    return Fk:currentRoom():getCardArea(to_select) ~= Card.PlayerEquip and
        Fk:getCardById(to_select).type == Card.TypeBasic
  end,
  on_use = function(self, room, effect)
    local player = room:getPlayerById(effect.from)
    room:recastCard(effect.cards, player, self.name)
    local mark = U.getMark(player, "@sw_yanyu-turn")
    for _, ids in ipairs(effect.cards) do
      local card = Fk:getCardById(ids)
      if not table.contains(mark, card.trueName) then
        table.insert(mark, card.trueName)
        room:setPlayerMark(player, "@sw_yanyu-turn", #mark > 0 and mark or 0)
      end
    end
  end,
}
local sw_yanyu_trigger = fk.CreateTriggerSkill {
  name = "#sw_yanyu_trigger",
  anim_type = "control",
  events = { fk.EventPhaseStart },
  can_trigger = function(self, event, target, player, data)
    return target == player and player:hasSkill(sw_yanyu) and player:getMark("@sw_yanyu-turn") ~= 0 and
        player.phase == Player.Discard
  end,
  on_cost = function(self, event, target, player, data)
    local room = player.room
    local n = #player:getMark("@sw_yanyu-turn")
    local targets = room:getAlivePlayers()
    if #targets == 0 then return end
    local to = room:askForChoosePlayers(player, table.map(targets, Util.IdMapper), 1, 1, "#sw_yanyu-choose:::" .. n,
      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)
    local n = #player:getMark("@sw_yanyu-turn")
    if to ~= player then
      player:drawCards(n, self.name)
    end
    if n > 0 then
      to:reset()
      to:drawCards(n, self.name)
    end
    if n > 1 then
      if to:isWounded() then
        room:recover {
          who = to,
          num = 1,
          recoverBy = player,
          skillName = self.name
        }
      end
    end
    if n > 2 then
      if to.dead then return end
      local generals, same_g = {}, {}
      for _, general_name in ipairs(room.general_pile) do
        same_g = Fk:getSameGenerals(general_name)
        table.insert(same_g, general_name)
        same_g = table.filter(same_g, function(g_name)
          local general = Fk.generals[g_name]
          return (general.kingdom == "shu" or general.subkingdom == "shu") and general.gender == General.Male
        end)
        if #same_g > 0 then
          table.insert(generals, table.random(same_g))
        end
      end
      if #generals == 0 then return false end
      generals = table.random(generals, math.min(n, #generals))

      local skills = {}
      local choices = {}
      for _, general_name in ipairs(generals) do
        local general = Fk.generals[general_name]
        local g_skills = {}
        --加载技能
        for _, skill in ipairs(general.skills) do
          if not (table.contains({ Skill.Limited, Skill.Wake, Skill.Quest }, skill.frequency) or skill.lordSkill) and
              (#skill.attachedKingdom == 0 or (table.contains(skill.attachedKingdom, "shu") and player.kingdom == "shu")) then
            table.insertIfNeed(g_skills, skill.name)
          end
        end
        for _, s_name in ipairs(general.other_skills) do
          local skill = Fk.skills[s_name]
          if not (table.contains({ Skill.Limited, Skill.Wake, Skill.Quest }, skill.frequency) or skill.lordSkill) and
              (#skill.attachedKingdom == 0 or (table.contains(skill.attachedKingdom, "shu") and player.kingdom == "shu")) then
            table.insertIfNeed(g_skills, skill.name)
          end
        end
        table.insertIfNeed(skills, g_skills)
        if #choices == 0 and #g_skills > 0 then
          choices = { g_skills[1] }
        end
      end
      if #choices > 0 then
        local result = player.room:askForCustomDialog(to, self.name,
          "packages/tenyear/qml/ChooseGeneralSkillsBox.qml", {
            generals, skills, 1, 1, "燕语：请选择一个要获得的技能", false
          })
        if result ~= "" then
          choices = json.decode(result)
        end
        room:handleAddLoseSkills(to, table.concat(choices, "|"), nil)
        room:setPlayerMark(to, "@sw_yanyu_skill", choices)
      end
    end
    if n > 3 then
      room:changeMaxHp(to, 1)
    end
  end,

  refresh_events = { fk.EventPhaseEnd },
  can_refresh = function(self, event, target, player, data)
    return target == player and player:hasSkill(self) and player.phase == Player.Play
  end,
  on_refresh = function(self, event, target, player, data)
    local room = player.room
    for _, p in ipairs(room:getAlivePlayers()) do
      if p:getMark("@sw_yanyu_skill") ~= 0 then
        local skills = p:getMark("@sw_yanyu_skill")
        room:setPlayerMark(p, "@sw_yanyu_skill", 0)
        room:handleAddLoseSkills(p, "-" .. table.concat(skills, "|-"), nil, true, false)
      end
    end
  end,

}
sw_yanyu:addRelatedSkill(sw_yanyu_trigger)
xiahoushi:addSkill(sw_yanyu)
Fk:loadTranslationTable {
  ["sw_yanyu"] = "燕语",
  [":sw_yanyu"] = "出牌阶段限两次，你可以重铸任意张基本牌，棋牌阶段开始时，你可以令一名其他角色依次执行前X项，若不为你，你摸X张牌：" ..
      "<br>1.摸X张牌并重置武将牌；<br>2.回复一点体力；<br>3.令其从X个随机的男性蜀势力武将中选择一个技能于你的下个出牌阶段结束前获得；<br>4.增加一点体力上限(X为你重铸不同牌名的数量)。",

  ["@sw_yanyu-turn"] = "燕语",
  ["#sw_yanyu_trigger"] = "燕语",
  ["#sw_yanyu-choose"] = "燕语：你可以选择一名角色，令其执行〖燕语〗的前 %arg 项",

  ["$sw_yanyu1"] = "画堂欢燕飞，情许鸳鸯合",
  ["$sw_yanyu2"] = "欢娱在今夕，燕婉及良时",
  ["@sw_yanyu_skill"] = "燕语",
}

local sp_xiangxiang = General(extension, "swex__sunshangxiang", "shu", 4, 4, General.Female)
Fk:loadTranslationTable {
  ["swex__sunshangxiang"] = "孙尚香",
  ["~swex__sunshangxiang"] = "莫道江水不复返，轻舟过岸再难停...",
}
local sw_liangzhu = fk.CreateTriggerSkill {
  name = "sw_liangzhu",
  anim_type = "drawcard",
  events = { fk.HpRecover },
  can_trigger = function(self, event, target, player, data)
    return player:hasSkill(self)
  end,
  on_cost = function(self, event, target, player, data)
    return player.room:askForSkillInvoke(player, self.name, nil, "#sw_liangzhu-invoke::" .. target.id)
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    local chs = { "sw_liangzhu_d+hp::" .. player.id, "sw_liangzhu_d" }
    if target:getHandcardNum() == 0 or target:getMark("liangzhu_hx-turn") > 0 then
      table.removeOne(chs, "sw_liangzhu_d+hp::" .. player.id)
    end
    local choice = room:askForChoice(target, chs, self.name)
    if choice == "sw_liangzhu_d+hp::" .. player.id then
      room:setPlayerMark(target, "liangzhu_hx-turn", 1)
      local card = room:askForDiscard(target, 1, 1, true, self.name, true, nil, "#sw_liangzhudisc-ask:" .. player.id)
      if #card > 0 then
        if player:isWounded() then
          room:recover {
            who = player,
            num = 1,
            recoverBy = target,
            skillName = self.name
          }
        end
      end
      if not player:isWounded() or not target:isWounded() then
        if room:askForSkillInvoke(player, self.name, nil, "良助：达成条件，是否摸两张牌") then
          player:drawCards(2, self.name)
        end
      end
    else
      room:doIndicate(player.id, { target.id })
      target:drawCards(2, self.name)
      if target:getMark("liangzhu_hx-turn") == 0 then
        room:setPlayerMark(target, "liangzhu_hx-turn", 1)
        if not player:isWounded() or not target:isWounded() then
          if player:getHandcardNum() > 0 then
            local card = room:askForDiscard(player, 1, 1, true, self.name, true, nil,
              "#sw_liangzhudisc-ask:" .. player.id)
            if #card > 0 then
              if target:isWounded() then
                room:recover {
                  who = player,
                  num = 1,
                  recoverBy = player,
                  skillName = self.name
                }
              end
            end
          end
        end
      end
    end
    if target ~= player then
      local mark = U.getMark(player, "sw_liangzhu")
      table.insert(mark, target.id)
      room:setPlayerMark(player, "sw_liangzhu", #mark > 0 and mark or 0)
    end
  end,
}
sp_xiangxiang:addSkill(sw_liangzhu)
Fk:loadTranslationTable {
  ["sw_liangzhu"] = "良助",
  [":sw_liangzhu"] = "当有角色回复体力后，你可以令其选择一项：1.弃置一张牌，令对方回复一点体力；2.摸两张牌。若你或其体力值为满，你可以执行另一项，若本回合已执行过选项一，移去此项。",

  ["#sw_liangzhudisc-ask"] = "良助：你可以弃置一张牌，令 %src 回复一点体力",
  ["#sw_liangzhu-invoke"] = "良助：是否令 %dest 执行良助",
  ["sw_liangzhu_d+hp"] = "弃一张牌，令 %dest 回复一点体力",
  ["sw_liangzhu_d"] = "摸两张牌",

  ["$sw_liangzhu1"] = "花暖照心花，月白知有意",
  ["$sw_liangzhu2"] = "借问春江水，君情与妾心",
}
local sw_xiaoji = fk.CreateTriggerSkill {
  name = "sw_xiaoji",
  anim_type = "support",
  events = { fk.PreHpRecover },
  can_trigger = function(self, event, target, player, data)
    return target == player and player:hasSkill(self) and data.recoverBy and data.recoverBy ~= player
  end,
  on_cost = function(self, event, target, player, data)
    local room = player.room
    local targets = room:getOtherPlayers(player)
    if #targets == 0 then return end
    local to = room:askForChoosePlayers(data.recoverBy, table.map(targets, Util.IdMapper), 1, 1,
      "#sw_xiaoji-askdamage:" .. data.recoverBy.id, self.name)
    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)
    room:doIndicate(data.recoverBy.id, to)
    room:damage {
      from = data.recoverBy,
      to = to,
      damage = 1,
      skillName = self.name,
    }
  end,
}
local sw_xiaoji_trigger = fk.CreateTriggerSkill {
  name = "#sw_xiaoji_trigger",
  anim_type = "drawcard",
  events = { fk.AfterCardsMove },
  can_trigger = function(self, event, target, player, data)
    if not player:hasSkill(self) then return end
    for _, move in ipairs(data) do
      if move.from == player.id then
        for _, info in ipairs(move.moveInfo) do
          if info.fromArea == Card.PlayerEquip then
            return true
          end
        end
      end
    end
  end,
  on_trigger = function(self, event, target, player, data)
    local i = 0
    for _, move in ipairs(data) do
      if move.from == player.id then
        for _, info in ipairs(move.moveInfo) do
          if info.fromArea == Card.PlayerEquip then
            i = i + 1
          end
        end
      end
    end
    self.cancel_cost = false
    for _ = 1, i do
      if self.cancel_cost or not player:hasSkill(self) then break end
      self:doCost(event, target, player, data)
    end
  end,
  on_cost = function(self, event, target, player, data)
    local room = player.room
    local to = room:askForChoosePlayers(player, table.map(
      table.filter(room:getOtherPlayers(player), function(p) return not p:isNude() end),
      Util.IdMapper), 1, 1, "#sw_xiaoji-choose", self.name)
    if #to > 0 then
      self.cost_data = to[1]
      return true
    elseif #to == 0 then
      return true
    end
    self.cancel_cost = true
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    player:broadcastSkillInvoke("sw_xiaoji")
    if self.cost_data then
      local to = room:getPlayerById(self.cost_data)
      local cid = room:askForCardChosen(player, to, "he", self.name)
      room:moveCardTo(cid, Player.Hand, player, fk.ReasonPrey, self.name, nil, false, player.id)
      -- player:drawCards(1, self.name)
    else
      player:drawCards(2, self.name)
    end
  end,
}
sw_xiaoji:addRelatedSkill(sw_xiaoji_trigger)
sp_xiangxiang:addSkill(sw_xiaoji)
Fk:loadTranslationTable {
  ["sw_xiaoji"] = "枭姬",
  ["#sw_xiaoji_trigger"] = "枭姬",
  [":sw_xiaoji"] = "当其他角色令你回复体力后，其可以对一名其他角色造成一点伤害；每当失去一张装备区的牌后，你可以获得其他角色的一张牌，若你没有获得其他角色的牌，改为摸两张。",

  ["#sw_xiaoji-choose"] = "枭姬：选择要拿牌的角色",
  ["#sw_xiaoji-askdamage"] = "枭姬：选择令 %src 造成伤害的角色",

  ["$sw_xiaoji1"] = "林间箭飞速，倩影枝头走",
  ["$sw_xiaoji2"] = "轻弓俏丽，花剑武美",
}
local sw_sijuns = fk.CreateActiveSkill {
  name = "sw_sijuns",
  anim_type = "control",
  prompt = "#sw_sijuns",
  can_use = function(self, player)
    return player:usedSkillTimes(self.name, Player.HistoryPhase) == 0 and #player:getCardIds(Player.Equip) > 0
  end,
  card_num = 1,
  card_filter = function(self, to_select, selected, selected_targets)
    return #selected == 0 and Fk:currentRoom():getCardArea(to_select) == Player.Equip
  end,
  target_filter = Util.FalseFunc,
  on_use = function(self, room, effect)
    local player = room:getPlayerById(effect.from)
    local cid = effect.cards[1]
    room:throwCard(cid, self.name, player, player)
    U.askForUseVirtualCard(room, player, U.getAllCardNames("b"), nil, self.name, "#sw_sijuns-ask", true, true, true,
      true)
  end,
}
sp_xiangxiang:addRelatedSkill(sw_sijuns)
Fk:loadTranslationTable {
  ["sw_sijuns"] = "思君",
  ["#sw_sijuns"] = "思君：是否弃置一张装备区的牌，视为使用一张基本牌",
  [":sw_sijuns"] = "出牌阶段限一次，你可以弃置一张装备区的牌，视为使用一张不计次数和距离限制的基本牌",

  ["#sw_sijuns-ask"] = "思君：请选择要使用的基本牌",
  ["$sw_sijuns1"] = "赤帢缠头锦束腰，阵前不弱霍嫖姚",
  ["$sw_sijuns2"] = "英姿飒爽扬袖舞，娉婷昂扬曲身轻",
}
local sw_fanxiang = fk.CreateTriggerSkill {
  name = "sw_fanxiang",
  anim_type = "defensive",
  frequency = Skill.Limited,
  events = { fk.EnterDying },
  can_trigger = function(self, event, target, player, data)
    return target == player and player:hasSkill(self) and player:getMark("sw_liangzhu") ~= 0 and
        player:usedSkillTimes(self.name, Player.HistoryGame) == 0
  end,
  on_cost = function(self, event, target, player, data)
    local room = player.room
    local targets = {}
    local mark = U.getMark(player, "sw_liangzhu")
    for _, p in ipairs(mark) do
      local to = room:getPlayerById(p)
      if table.contains(mark, to.id) then
        table.insert(targets, to.id)
      end
    end
    if #targets == 0 then return end
    local to = room:askForChoosePlayers(player, targets, 1, 1, "#sw_fanxiang-choose", self
      .name)
    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)
    local chc = { "helpplayer:" .. player.id, "Cancel" }
    local chos = room:askForChoice(to, chc, self.name)
    if chos == "helpplayer:" .. player.id then
      local chs = {}
      local i1 = 1
      for i = i1, to.hp, 1 do
        table.insert(chs, tostring(i))
      end
      local chs2 = room:askForChoice(to, chs, self.name, "#sw_fanxiang-losehp")
      room:loseHp(to, tonumber(chs2) * 1, self.name)
      room:recover {
        who = player,
        num = tonumber(chs2) * 1,
        recoverBy = to,
        skillName = self.name
      }
      if not player.dead then
        room:changeMaxHp(player, -1)
        room:changeKingdom(player, "wu", true)
        room:handleAddLoseSkills(target, "-sw_liangzhu", nil)
        room:handleAddLoseSkills(target, "sw_sijuns", nil)
      end
    end
  end,
}

sp_xiangxiang:addSkill(sw_fanxiang)
Fk:loadTranslationTable {
  ["sw_fanxiang"] = "返乡",
  [":sw_fanxiang"] = "限定技，当你进入濒死状态后且，若你发动过〖良助〗，你可以令你对其发动过〖良助〗的一名其他角色选择是否将任意点体力值转移至你，若你因此脱离了濒死状态，你失去一点体力上限，将势力改为吴，失去〖良助〗获得〖思君〗。",

  ["helpplayer"] = "令 %src 回复体力",
  ["#sw_fanxiang-choose"] = "返乡：请选择一名角色，其可以令你回复体力",
  ["#sw_fanxiang-losehp"] = "返乡：请选择要转移的体力值",

  ["$sw_fanxiang1"] = "日暮归乡迟，道长且艰辛",
  ["$sw_fanxiang2"] = "与君离别意，兄命自难违",
}

return extension