local extension = Package:new("majiang_lol_aony")
extension.extensionName = "MahjongSoul"
Fk:loadTranslationTable {
  ["majiang_lol_aony"] = "英雄联盟-艾欧尼亚",
}
extension.game_modes_blacklist = { "as_StonehengEarena_mode" }
local U = require "packages/utility/utility"

local seti = General(extension, "sw__seti", "aony", 4, 4)
local sw_guanzhi = fk.CreateActiveSkill {
  name = "sw_guanzhi",
  anim_type = "control",
  card_num = 0,
  target_num = 2,
  frequency = Skill.Limited,
  target_filter = function(self, to_select, selected)
    return #selected < 2 and to_select ~= Self.id
  end,
  can_use = function(self, player)
    return player:usedSkillTimes(self.name, Player.HistoryGame) == 0
  end,
  on_use = function(self, room, effect)
    local player = room:getPlayerById(effect.from)
    local n = math.max(2, (room:getPlayerById(effect.tos[1]).maxHp - room:getPlayerById(effect.tos[1]).hp))
    local from, to = room:getPlayerById(effect.tos[1]), room:getPlayerById(effect.tos[2])
    room:swapSeat(from, to)
    room:damage {
      from = player,
      to = room:getPlayerById(effect.tos[1]),
      damage = n,
      skillName = self.name,
    }
    for _, p in ipairs(room.alive_players) do
      if room:getPlayerById(effect.tos[1]):getNextAlive() == p or p:getNextAlive() == room:getPlayerById(effect.tos[1]) then
        room:damage {
          from = player,
          to = p,
          damage = n // 2,
          skillName = self.name,
        }
      end
    end
  end,
}
Fk:loadTranslationTable {
  ["sw_guanzhi"] = "观止",
  [":sw_guanzhi"] = "限定技，出牌阶段，你选择一名其他角色，然后将其投掷至两名角色之间并对其造成x点伤害，其被投掷后，与其相邻的角色受到该值一半的伤害（x为其体力上限减去体力值且至少为2）",
  ["$sw_guanzhi1"] = "起飞咯！",
  ["$sw_guanzhi2"] = "终结技来辣！"
}
seti:addSkill(sw_guanzhi)

local sw_lielu = fk.CreateTriggerSkill {
  name = "sw_lielu",
  anim_type = "offensive",
  frequency = Skill.Compulsory,
  events = { fk.CardUsing },
  can_trigger = function(self, event, target, player, data)
    return target == player and player:hasSkill(self) and data.card.trueName == "slash" and
        player:usedCardTimes("slash", Player.HistoryPhase) == 2 and
        player.phase == Player.Play
  end,
  on_use = function(self, event, target, player, data)
    local num = player:usedCardTimes("slash", Player.HistoryPhase)
    if num == 2 then
      data.additionalDamage = (data.additionalDamage or 0) + 1
      data.disresponsiveList = data.disresponsiveList or {}
      for _, target in ipairs(player.room.alive_players) do
        table.insertIfNeed(data.disresponsiveList, target.id)
      end
    end
  end,
}
local sw_lielu_targetmod = fk.CreateTargetModSkill {
  name = "#sw_lielu_targetmod",
  residue_func = function(self, player, skill, scope, card)
    if card and player:hasSkill("sw_lielu") and card.trueName == "slash" and scope == Player.HistoryPhase then
      return 1
    end
  end,
}
sw_lielu:addRelatedSkill(sw_lielu_targetmod)
seti:addSkill(sw_lielu)
Fk:loadTranslationTable {
  ["sw_lielu"] = "裂颅",
  [":sw_lielu"] = "锁定技，你于出牌阶段可使用【杀】的次数+1；你于出牌阶段使用的第二张【杀】不可响应且伤害+1",
}
local sw_hongquan = fk.CreateTriggerSkill {
  name = "sw_hongquan",
  anim_type = "drawcard",
  events = { fk.CardUsing },
  can_trigger = function(self, event, target, player, data)
    return target == player and player:hasSkill(self) and data.card.trueName == "slash" and player.shield > 0 and
        player:usedSkillTimes(self.name, Player.HistoryTurn) == 0
  end,
  on_use = function(self, event, target, player, data)
    local n = player.shield
    data.additionalDamage = (data.additionalDamage or 0) + n
    player.room:changeShield(player, -n)
  end,
}
local sw_hongquan_tar = fk.CreateTriggerSkill {
  name = "#sw_hongquan_tar",
  anim_type = "drawcard",
  events = { fk.HpChanged },
  frequency = Skill.Compulsory,
  can_trigger = function(self, event, target, player, data)
    return target == player and player:hasSkill(self) and player:usedSkillTimes(self.name, Player.HistoryTurn) == 0 and
        player.shield == 0
  end,
  on_use = function(self, event, target, player, data)
    player.room:changeShield(player, 1)
  end,
}
sw_hongquan:addRelatedSkill(sw_hongquan_tar)
seti:addSkill(sw_hongquan)
Fk:loadTranslationTable {
  ["sw__seti"] = "瑟提",
  ["sw_hongquan"] = "轰拳",
  ["#sw_hongquan_tar"] = "轰拳",
  [":sw_hongquan"] = "每项每回合限一次，①当你使用杀时，若你有护甲，你可以移去全部护甲，令此杀的伤害额外加该值<br>" ..
      "②当你的体力值发生变化时，若你没有护甲，你获得1点护甲",
}

local Masteryi = General(extension, "sw__Masteryi", "aony", 4, 4)
Fk:loadTranslationTable {
  ["sw__Masteryi"] = "易",
}
local sw_shuangren = fk.CreateTriggerSkill {
  name = "sw_shuangren",
  anim_type = "offensive",
  frequency = Skill.Compulsory,
  events = { fk.CardUsing },
  can_trigger = function(self, event, target, player, data)
    return target == player and player:hasSkill(self) and data.card.trueName == "slash" and
        player.phase == Player.Play
  end,
  on_use = function(self, event, target, player, data)
    player.room:addPlayerMark(player, "@sw_shuangren", 1)
    local num = player:getMark("@sw_shuangren")
    if num > 3 then
      data.extra_data = data.extra_data or {}
      data.extra_data.sw_shuangren = data.extra_data.sw_shuangren or true
      player.room:setPlayerMark(player, "@sw_shuangren", 0)
    end
  end,

  refresh_events = { fk.CardUseFinished },
  can_refresh = function(self, event, target, player, data)
    return data.extra_data and data.extra_data.sw_shuangren
  end,
  on_refresh = function(self, event, target, player, data)
    player.room:doCardUseEffect(data)
    data.extra_data.sw_shuangren = false
  end,
}
Masteryi:addSkill(sw_shuangren)
Fk:loadTranslationTable {
  ["sw_shuangren"] = "双刃",
  ["@sw_shuangren"] = "双重打击",
  [":sw_shuangren"] = "锁定技，每当你使用第四张杀时，该杀结算两次",
}
local sw_zhanxi = fk.CreateActiveSkill {
  name = "sw_zhanxi",
  prompt = "#sw_zhanxi-active",
  card_num = 0,
  target_num = 0,
  can_use = function(self, player)
    return player:usedSkillTimes(self.name, Player.HistoryPhase) == 0
  end,
  card_filter = Util.FalseFunc,
  on_use = function(self, room, effect)
    local player = room:getPlayerById(effect.from)
    player.room:addPlayerMark(player, "@sw_shuangren", 1)
    local card = room:getCardsFromPileByRule(".")
    if #card > 0 then
      room:moveCards({
        ids = card,
        to = player.id,
        toArea = Card.PlayerHand,
        moveReason = fk.ReasonJustMove,
        proposer = player.id,
        skillName = self.name,
      })
    end
    local cid = room:askForCardChosen(player, player, { card_data = { { "$Hand", player:getCardIds(Player.Hand) } } },
      self.name)
    room:setCardMark(Fk:getCardById(cid), "@@wuji-turn", 1)
    return true
  end,
}

local sw_zhanxi_file = fk.CreateFilterSkill {
  name = "#sw_zhanxi_file",
  mute = true,
  frequency = Skill.Compulsory,
  card_filter = function(self, card, player)
    return player:hasSkill(self) and card:getMark("@@wuji-turn") > 0
  end,
  view_as = function(self, card)
    local card = Fk:cloneCard("slash", Card.NoSuit, card.number)
    card.skillName = self.name
    return card
  end,
}
local sw_zhanxi_targetmod = fk.CreateTargetModSkill {
  name = "#sw_zhanxi_targetmod",
  bypass_times = function(self, player, skill, scope, card)
    return player:hasSkill(sw_zhanxi.name) and card and card.color == Card.NoColor
  end,
  bypass_distances = function(self, player, skill, card)
    return player:hasSkill(sw_zhanxi.name) and card and card.color == Card.NoColor
  end,
}
sw_zhanxi:addRelatedSkill(sw_zhanxi_file)
sw_zhanxi:addRelatedSkill(sw_zhanxi_targetmod)
Masteryi:addSkill(sw_zhanxi)
Fk:loadTranslationTable {
  ["sw_zhanxi"] = "冥想",
  ["@@wuji-turn"] = "冥想",
  ["#sw_zhanxi_file"] = "冥想",
  ["#sw_zhanxi-active"] = "冥想：随机获得一张牌并标记一张牌？",
  [":sw_zhanxi"] = "出牌阶段限一次，你令“双刃”的计数+1并随机获得牌堆或弃牌堆的一张牌，随后选择一张手牌，该牌视为无色的【杀】；此牌无次数和距离限制",
}
local sw_xuetong = fk.CreateActiveSkill {
  name = "sw_xuetong",
  prompt = "#sw_xuetong-active",
  card_num = 0,
  target_num = 0,
  frequency = Skill.Limited,
  can_use = function(self, player)
    return player:usedSkillTimes(self.name, Player.HistoryGame) == 0
  end,
  card_filter = Util.FalseFunc,
  on_use = function(self, room, effect)
    room:setPlayerMark(room:getPlayerById(effect.from), "@sw_shuangren", 4)
    room:getPlayerById(effect.from):setCardUseHistory("slash", 0, Player.HistoryPhase)
    room:setPlayerMark(room:getPlayerById(effect.from), "sw_xuetong", 1)
  end,
}
local sw_xuetong_targetmod = fk.CreateTargetModSkill {
  name = "#sw_xuetong_targetmod",
  residue_func = function(self, player, skill, scope, card)
    if card and player:hasSkill(self) and card.trueName == "slash" and scope == Player.HistoryPhase and player:getMark("sw_xuetong") > 0 then
      return 2
    end
  end,
}
local sw_xuetong_tar = fk.CreateTriggerSkill {
  name = "#sw_xuetong_tar",
  anim_type = "drawcard",
  frequency = Skill.Compulsory,
  events = { fk.Deathed },
  can_trigger = function(self, event, target, player, data)
    return player:hasSkill(self) and data.damage and data.damage.from == player
  end,
  on_use = function(self, event, target, player, data)
    player:setSkillUseHistory("sw_xuetong", 0, Player.HistoryGame)
    player:setSkillUseHistory("sw_zhanxi", 0, Player.HistoryPhase)
    player:drawCards(2, self.name)
  end,
}
Masteryi:addSkill(sw_xuetong)
sw_xuetong:addRelatedSkill(sw_xuetong_targetmod)
sw_xuetong:addRelatedSkill(sw_xuetong_tar)
Fk:loadTranslationTable {
  ["sw_xuetong"] = "血统",
  ["#sw_xuetong_tar"] = "血统",
  ["#sw_xuetong-active"] = "高原血统：是否令本回合可使用的杀次数+3",
  [":sw_xuetong"] = "限定技，出牌阶段，你重置本回合使用【杀】的次数，额外增加两次可用次数并将“双刃”的计数设置为4，；当你杀死其他角色后，你摸两张牌并重置“冥想”和“血统”",
  ["$sw_xuetong1"] = "真正的大师，永远都怀着一颗学徒的心",
  ["$sw_xuetong2"] = "集中起来的意志，可以击穿顽石"
}

local yasuo = General(extension, "sw__yasuo", "aony", 3, 3)
yasuo.shield = 1
Fk:loadTranslationTable {
  ["sw__yasuo"] = "亚索",
}
local sw_zhangang = fk.CreateTriggerSkill {
  name = "sw_zhangang",
  anim_type = "offensive",
  events = { fk.CardUsing },
  frequency = Skill.Compulsory,
  can_trigger = function(self, event, target, player, data)
    return target == player and player:hasSkill(self) and
        data.card.trueName == "slash" and
        player:getMark("@sw_zhangang") > 2
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    local targets = U.getUseExtraTargets(room, data)
    if #targets == 0 then return false end
    local tos = room:askForChoosePlayers(player, targets, 1, 1,
      "#sw_zhangang-invoke", self.name, true)
    player:broadcastSkillInvoke("sw_zhangang", 4)
    if #tos > 0 then
      table.forEach(tos, function(id)
        table.insert(data.tos, { id })
      end)
    end
    room:setPlayerMark(player, "@sw_zhangang", 0)
  end,
}
local sw_zhangang_tar = fk.CreateTriggerSkill {
  name = "#sw_zhangang_tar",
  anim_type = "offensive",
  frequency = Skill.Compulsory,
  events = { fk.CardUsing },
  can_trigger = function(self, event, target, player, data)
    return target == player and player:hasSkill(self) and data.card.trueName == "slash"
  end,
  on_use = function(self, event, target, player, data)
    player:broadcastSkillInvoke("sw_zhangang", math.random(1, 3))
    player.room:addPlayerMark(player, "@sw_zhangang", 1)
  end,
}
yasuo:addSkill(sw_zhangang)
sw_zhangang:addRelatedSkill(sw_zhangang_tar)
Fk:loadTranslationTable {
  ["sw_zhangang"] = "斩钢",
  ["@sw_zhangang"] = "斩钢闪",
  ["#sw_zhangang_tar"] = "斩钢",
  ["#sw_zhangang-invoke"] = "斩钢：是否为%arg增加一个额外的目标",
  [":sw_zhangang"] = "当你使用【杀】时，你获得一层“斩钢闪”，若你至少拥有两层“斩钢闪”，你可以令下一张【杀】额外增加一个目标（无距离限制）",
}
local sw_tazhan = fk.CreateActiveSkill {
  name = "sw_tazhan",
  anim_type = "offensive",
  card_num = 0,
  target_num = 1,
  can_use = function(self, player)
    return not player:isKongcheng() and player:getMark("@sw_tazhan-turn") < 1
  end,
  card_filter = Util.FalseFunc,
  target_filter = function(self, to_select, selected, selected_cards)
    return #selected == 0 and to_select ~= Self.id and not Fk:currentRoom():getPlayerById(to_select):isKongcheng()
  end,
  on_use = function(self, room, effect)
    local player = room:getPlayerById(effect.from)
    local target = room:getPlayerById(effect.tos[1])
    local pindian = player:pindian({ target }, self.name)
    if pindian.results[target.id].winner == player then
      room:useVirtualCard("slash", nil, player, target, self.name, true)
      local card = room:getCardsFromPileByRule("jink")
      if #card > 0 then
        room:moveCards({
          ids = card,
          to = player.id,
          toArea = Card.PlayerHand,
          moveReason = fk.ReasonJustMove,
          proposer = player.id,
          skillName = self.name,
        })
      end
    else
      room:loseHp(player, 1, self.name)
      room:addPlayerMark(player, "@sw_tazhan-turn", 1)
    end
  end,
}
yasuo:addSkill(sw_tazhan)
Fk:loadTranslationTable {
  ["sw_tazhan"] = "踏斩",
  ["@sw_tazhan-turn"] = "踏斩失效",
  [":sw_tazhan"] = "出牌阶段，你可以与一名其他角色拼点，若你赢，你视为对其使用一张【杀】并从牌堆中获得一张【闪】；若你没赢，你失去一点体力且本回合无法发动此技能",
}

local sw_fengqiang = fk.CreateTriggerSkill {
  name = "sw_fengqiang",
  anim_type = "masochism",
  events = { fk.DamageInflicted },
  can_trigger = function(self, event, target, player, data)
    return target == player and player:hasSkill(self) and data.from and player:distanceTo(data.from) > 1 and
        player:getMark("@sw_zhangang") > 0 and
        player:usedSkillTimes(self.name, Player.HistoryTurn) == 0
  end,
  on_cost = function(self, event, target, player, data)
    return player.room:askForSkillInvoke(player, self.name, nil, "#sw_fengqiang-invoke")
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    room:removePlayerMark(player, "@sw_zhangang", 1)
    return true
  end,
}
yasuo:addSkill(sw_fengqiang)
Fk:loadTranslationTable {
  ["sw_fengqiang"] = "风墙",
  ["#sw_fengqiang-invoke"] = "是否移去一层“斩钢闪”，防止此伤害",
  [":sw_fengqiang"] = "每回合限一次，当你受到伤害时，若有来源且来源至你的距离大于1，你可以移去一层“斩钢闪”，防止之",
}
local sw_juexi = fk.CreateTriggerSkill {
  name = "sw_juexi",
  anim_type = "offensive",
  frequency = Skill.Limited,
  events = { fk.Damaged },
  can_trigger = function(self, event, target, player, data)
    return not target.dead and target ~= player and data.card and data.card.trueName == "slash" and
        player:hasSkill(self) and player:usedSkillTimes(self.name, Player.HistoryGame) == 0 and
        not player:isKongcheng()
  end,
  on_cost = function(self, event, target, player, data)
    return player.room:askForSkillInvoke(player, self.name, nil, "#sw_juexi-chos:" .. target.id)
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    local n = player:getHandcardNum()
    player:throwAllCards("h")
    for _ = 1, n do
      room:useVirtualCard("slash", nil, player, target, self.name, true)
    end
  end,
}
yasuo:addSkill(sw_juexi)
Fk:loadTranslationTable {
  ["sw_juexi"] = "绝息",
  ["#sw_juexi-chos"] = "是否发动狂风绝息斩，对其%src使用等量手牌的【杀】",
  [":sw_juexi"] = "限定技，当一名其他角色受到【杀】造成的伤害后，你可以弃置所有手牌，视为对其使用等量的【杀】",

  ["$sw_juexi1"] = "索里亚给痛！",
  ["$sw_juexi2"] = "哈撒给!"
}

local ali = General(extension, "sw__ali", "aony", 3, 3, General.Female)
Fk:loadTranslationTable {
  ["sw__ali"] = "阿狸",
  ["~sw__ali"] = "所以..我也会被遗忘了吗...",
}

local ShePoAsk = function(player)
  local room = player.room
  local SkillName = "sw_shepo"
  if player:getMark("sw_shehun-hun") > player:getMark("sw_shehun-po") then
    room:setPlayerMark(player, "@sw_shehun", 0)
    room:setPlayerMark(player, "sw_shehun-hun", 0)
    room:setPlayerMark(player, "sw_shehun-po", 0)
    if player:isWounded() then
      room:recover {
        who = player,
        num = 1,
        recoverBy = player,
        skillName = SkillName
      }
      player:drawCards(2, SkillName)
    else
      player:drawCards(3, SkillName)
    end
  elseif player:getMark("sw_shehun-hun") < player:getMark("sw_shehun-po") then
    room:setPlayerMark(player, "@sw_shehun", 0)
    room:setPlayerMark(player, "sw_shehun-hun", 0)
    room:setPlayerMark(player, "sw_shehun-po", 0)
    local to = room:askForChoosePlayers(player, table.map(player.room.alive_players, function(p)
      return p.id ~= player.id and p.id
    end), 1, 1, "摄魄：你可以对一名角色造成一点伤害，然后令其随机弃置一张牌", SkillName, true)
    if #to > 0 then
      local p = room:getPlayerById(to[1])
      if not p:isNude() and not p.dead then
        local id = table.random(p:getCardIds { Player.Hand, Player.Equip })
        room:throwCard({ id }, SkillName, p, player)
      end
      if not p.dead then
        room:damage {
          from = player,
          to = p,
          damage = 1,
          skillName = SkillName
        }
      end
    end
  elseif player:getMark("sw_shehun-hun") == player:getMark("sw_shehun-po") then
    room:setPlayerMark(player, "@sw_shehun", 0)
    room:setPlayerMark(player, "sw_shehun-hun", 0)
    room:setPlayerMark(player, "sw_shehun-po", 0)
    room:addPlayerMark(player, "sw_yaohuo_usetime")
  end
end
local sw_shepo = fk.CreateTriggerSkill {
  name = "sw_shepo",
  anim_type = "special",
  frequency = Skill.Compulsory,
  events = { fk.Damage },
  can_trigger = function(self, event, target, player, data)
    return player:hasSkill(self) and (data.from or not data.from) and data.to
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    if data.from then
      local point = "po"
      if table.contains({ "lord", "loyalist", "renegade" }, player.role) and table.contains({ "lord", "loyalist", "renegade" }, target.role) or (player.role == target.role) then
        point = "hun"
      end
      room:addPlayerMark(player, "sw_shehun-" .. point, data.damage)
      room:setPlayerMark(player, "@sw_shehun", player:getMark("sw_shehun-hun") + player:getMark("sw_shehun-po"))
    else
      room:addPlayerMark(player, "sw_shehun-po", data.damage)
      room:addPlayerMark(player, "sw_shehun-hun", data.damage)
      room:setPlayerMark(player, "@sw_shehun", player:getMark("sw_shehun-hun") + player:getMark("sw_shehun-po"))
    end
    if #room.alive_players > 4 then
      if player:getMark("@sw_shehun") >= 8 then
        ShePoAsk(player)
      end
    else
      if player:getMark("@sw_shehun") >= 4 then
        ShePoAsk(player)
      end
    end
  end
}
ali:addSkill(sw_shepo)
Fk:loadTranslationTable {
  ["sw_shepo"] = "摄魄",
  [":sw_shepo"] = "锁定技，当有角色造成伤害后，你获得伤害值的魂魄；每当你的魂魄不小于8时(存活角色小于5时改为4)，移去所有魂魄，根据魂魄的数量：<br>" ..
      "若相等：令〖妖火〗可选择的角色数+1；<br>" ..
      "魄较多：对一名角色造成一点伤害，再令其随机弃置一张牌，。<br>" ..
      "魂较多：你回复一点体力，摸两张牌，若你未受伤，改为摸三张；<br>" ..
      "<font color='red'>(伤害来源与你阵营相同时获得“魂”，否则获得“魄”，内奸视为主忠阵营，若无来源则同时获得“魂”和“魄”，标记不可见，只计算总数)。",

  ["@sw_shehun"] = "摄魄",

  ["$sw_shepo1"] = "以心，换心",
  ["$sw_shepo2"] = "逮到你了",
}
local sw_yaohuo = fk.CreateActiveSkill {
  name = "sw_yaohuo",
  anim_type = "offensive",
  prompt = function(self, selected_cards, selected_targets)
    local mark = 2 + Self:getMark("sw_yaohuo_usetime")
    return "#sw_yaohuo-active:::" .. mark
  end,
  card_num = 0,
  mim_target_num = 1,
  max_target_num = function(self)
    local mark = 2 + Self:getMark("sw_yaohuo_usetime")
    return mark
  end,
  can_use = function(self, player)
    return player:usedSkillTimes(self.name, Player.HistoryPhase) == 0
  end,
  card_filter = Util.FalseFunc,
  target_filter = function(self, to_select, selected, cards)
    local mark = 2 + Self:getMark("sw_yaohuo_usetime")
    return #selected < mark and to_select ~= Self.id
  end,
  on_use = function(self, room, effect)
    local player = room:getPlayerById(effect.from)
    local n = 0
    local mark = 2 + player:getMark("sw_yaohuo_usetime")
    if #effect.tos < mark then
      n = n + mark - #effect.tos
    end
    for _, id in ipairs(effect.tos) do
      local to = room:getPlayerById(id)
      room:sortPlayersByAction(to)
      if not to.dead then
        room:damage {
          from = player,
          to = to,
          damage = math.random(0, math.min(n, 2)),
          skillName = self.name
        }
      end
    end
  end,
}
ali:addSkill(sw_yaohuo)
Fk:loadTranslationTable {
  ["sw_yaohuo"] = "妖火",
  [":sw_yaohuo"] = "出牌阶段，你可以选择至多3名其他角色，对这些角色随机造成0~0点伤害，每少选择一个角色，伤害值上限便+1，至多增加至2。",

  ["#sw_yaohuo-active"] = "妖火：你可以选择至多 %arg 名角色造成随机伤害。",

  ["$sw_yaohuo1"] = "你是我的猎物",
  ["$sw_yaohuo2"] = "天性使然，但我仍有分寸",
  ["$sw_yaohuo3"] = "专门给你的~",
}
local sw_meihuo = fk.CreateActiveSkill {
  name = "sw_meihuo",
  anim_type = "offensive",
  prompt = "#sw_meihuo",
  min_card_num = 2,
  max_card_num = 5,
  target_num = 1,
  can_use = function(self, player)
    return player:usedSkillTimes(self.name, Player.HistoryPhase) == 0
  end,
  card_filter = function(self, to_select, selected)
    return #selected < 5 and not Self:prohibitDiscard(Fk:getCardById(to_select))
  end,
  target_filter = function(self, to_select, selected, cards)
    return #selected == 0
  end,
  on_use = function(self, room, effect)
    local player = room:getPlayerById(effect.from)
    local target = room:getPlayerById(effect.tos[1])
    room:throwCard(effect.cards, self.name, player, player)
    local phast_name = {
      [2] = "phase_judge",
      [3] = "phase_draw",
      [4] = "phase_play",
      [5] = "phase_discard",
    }
    room:setPlayerMark(target, "@sw_meihuo", phast_name[#effect.cards])
  end,
}
local sw_meihuo_trigger = fk.CreateTriggerSkill {
  name = "#sw_meihuo_trigger",
  mute = true,
  events = { fk.EventPhaseStart },
  frequency = Skill.Compulsory,
  anim_type = "masochism",
  can_trigger = function(self, event, target, player, data)
    return player == target and player:getMark("@sw_meihuo") ~= 0
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    player:broadcastSkillInvoke(sw_meihuo.name)
    room:notifySkillInvoked(player, sw_meihuo.name, "masochism")
    local mark = player:getMark("@sw_meihuo")
    local skip
    local phast_name = {
      [2] = "phase_judge",
      [3] = "phase_draw",
      [4] = "phase_play",
      [5] = "phase_discard",
    }
    if mark == phast_name[2] then
      skip = Player.Judge
    elseif mark == phast_name[3] then
      skip = Player.Draw
    elseif mark == phast_name[4] then
      skip = Player.Play
    elseif mark == phast_name[5] then
      skip = Player.Discard
    end
    player:skip(skip)
    room:setPlayerMark(player, "@sw_meihuo", 0)
  end,
}
sw_meihuo:addRelatedSkill(sw_meihuo_trigger)
ali:addSkill(sw_meihuo)
Fk:loadTranslationTable {
  ["sw_meihuo"] = "魅惑",
  [":sw_meihuo"] = "出牌阶段，你可以选择一名角色并弃置至少两张牌，令其跳过下回合的第X的阶段(X为你弃置的牌数)。",

  ["#sw_meihuo_trigger"] = "魅惑",
  ["#sw_meihuo"] = "魅惑：你可以弃置至少两张牌，令一名角色跳过弃牌数相等的对应阶段",

  ["@sw_meihuo"] = "魅惑",
  ["$sw_meihuo1"] = "我不咬人，真的~",
  ["$sw_meihuo2"] = "诶~别跑远了~",
}

local yongen = General(extension, "sw__yongen", "aony", 3, 3)
yongen.shield = 1
Fk:loadTranslationTable {
  ["sw__yongen"] = "永恩",
  ["~sw__yongen"] = "没有..休息...没有..安息.....",
}
local sw_jianhun = fk.CreateTriggerSkill {
  name = "sw_jianhun",
  frequency = Skill.Compulsory,
  anim_type = "switch",
  switch_skill_name = "sw_jianhun",
  events = { fk.TargetSpecified },
  can_trigger = function(self, event, target, player, data)
    return player == target and player:hasSkill(self) and data.card and data.card.is_damage_card and data.firstTarget and
        data.to ~= player.id --指定后，已经有目标的，所以直接data.to
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    local to = player.room:getPlayerById(data.to)
    if player:getSwitchSkillState(self.name, true) == fk.SwitchYang then
      player:drawCards(1, self.name)
      data.additionalDamage = (data.additionalDamage or 0) + 1
    else
      if #to:getCardIds(player.Hand) > 0 then
        local id = table.random(to:getCardIds { Player.Hand })
        room:throwCard({ id }, self.name, to, player)
      end
      data.extra_data = data.extra_data or {}
      data.extra_data.sw_jianhun_user = true --向data中传入数据，用于触发附属技能
    end
  end,
}
local sw_jianhun_SwitchYin = fk.CreateTriggerSkill {
  name = "#sw_jianhun_SwitchYin",
  mute = true,
  frequency = Skill.Compulsory,
  events = { fk.PreDamage },
  can_trigger = function(self, event, target, player, data)
    if target == player and player:hasSkill(self) and data.card and data.to ~= player then
      local e = player.room.logic:getCurrentEvent():findParent(GameEvent.CardEffect) --可以通过父事件来查找信息，暂时不太明白原理，不过知道是记录器，先记下
      if e then
        local use = e.data[1]
        return (use.extra_data or {}).sw_jianhun_user == true --对应主技能的data.extra_data.sw_jianhun_user
      end
    end
  end,
  on_use = function(self, event, target, player, data)
    player.room:loseHp(data.to, data.damage, self.name)
    return true
  end,
}
sw_jianhun:addRelatedSkill(sw_jianhun_SwitchYin)
yongen:addSkill(sw_jianhun)
Fk:loadTranslationTable {
  ["sw_jianhun"] = "剑魂",
  ["#sw_jianhun_SwitchYin"] = "剑魂",
  ["@@jianhun-turn"] = "剑魂",
  [":sw_jianhun"] = "锁定技，转换技，当你使用伤害类牌指定其他角色为目标后，阳：你摸一张牌，令此牌伤害+1，阴：其随机弃置一张手牌，将此牌造成的伤害改为体力流失，每张牌仅可触发一次。",

  ["$sw_jianhun1"] = "锐利阵风！",
  ["$sw_jianhun2"] = "剑刃狂澜！",
  ["$sw_jianhun3"] = "钢铁烈风！",
  ["$sw_jianhun4"] = "斩去谗言！",
}
local sw_linshen = fk.CreateActiveSkill {
  name = "sw_linshen",
  anim_type = "offensive",
  prompt = "#sw_linshen-active",
  card_num = 0,
  min_target_num = 1,
  can_use = function(self, player)
    return player:usedSkillTimes(self.name, Player.HistoryPhase) == 0
  end,
  card_filter = function(self, to_select, selected)
    return false
  end,
  target_filter = function(self, to_select, selected, selected_cards)
    local target = Fk:currentRoom():getPlayerById(to_select)
    return #selected < Self:getAttackRange() and to_select ~= Self.id and
        not Self:isProhibited(target, Fk:cloneCard("slash")) and Self:inMyAttackRange(target)
  end,
  on_use = function(self, room, effect)
    local player = room:getPlayerById(effect.from)
    for _, id in ipairs(effect.tos) do
      room:useVirtualCard("slash", nil, player, room:getPlayerById(id), self.name, true)
    end
  end,
}
local sw_linshen_tar = fk.CreateTriggerSkill {
  name = "#sw_linshen_tar",
  events = { fk.DamageCaused },
  frequency = Skill.Compulsory,
  can_trigger = function(self, event, target, player, data)
    return target == player and player:hasSkill("sw_linshen") and data.card and data.card.trueName == "slash" and
        table.contains(data.card.skillNames, "sw_linshen") and player.shield == 0
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    room:changeShield(player, 1)
    data.damage = 1
  end,
}
sw_linshen:addRelatedSkill(sw_linshen_tar)
yongen:addSkill(sw_linshen)
Fk:loadTranslationTable {
  ["sw_linshen"] = "凛神",
  ["#sw_linshen_tar"] = "凛神",
  [":sw_linshen"] = "出牌阶段限一次，你可以视为对攻击范围内至多X名角色使用一张不计入次数限制且伤害值固定为1的【杀】，若此【杀】造成伤害，若你没有护甲，你增加一点护甲(X为你的攻击范围)。",

  ["#sw_linshen-active"] = "你可以视为对攻击范围内至多X名角色使用一张不计入次数限制且伤害值固定为1的【杀】，若此【杀】造成伤害，你增加一点护甲",
  ["$sw_linshen1"] = "卸下你的负担！",
  ["$sw_linshen2"] = "他们的命运，由我亲手封印！",
  ["$sw_linshen3"] = "可惜你充耳不闻！",
  ["$sw_linshen4"] = "悔恨会让你停滞不前！",
}
local sw_juenian = fk.CreateActiveSkill {
  name = "sw_juenian",
  anim_type = "offensive",
  prompt = "#sw_juenian-active",
  card_num = 0,
  target_num = 1,
  can_use = function(self, player)
    return player:getMark("@@fengchenjuenianzhan") > 0
  end,
  card_filter = Util.FalseFunc,
  target_filter = function(self, to_select, selected, selected_cards)
    local target = Fk:currentRoom():getPlayerById(to_select)
    return #selected == 0 and to_select ~= Self.id and Self:inMyAttackRange(target)
  end,
  on_use = function(self, room, effect)
    local player = room:getPlayerById(effect.from)
    local target = room:getPlayerById(effect.tos[1])
    local to = target:getNextAlive()
    room:swapSeat(player, to)
    local next = to:getNextAlive()
    room:setPlayerMark(player, "zuowei-turn", to.id)
    room:setPlayerMark(player, "@sw_pozhang-turn", 5)
    room:setPlayerMark(player, "sw_juenian-turn", 1)
    room:removePlayerMark(player, "@@fengchenjuenianzhan", 1)
    while true do
      if next ~= player or next ~= to then
        if not next.dead then
          room:damage({
            to = next,
            damage = 1,
            damageType = fk.NormalDamage,
            skillName = self.name,
          })
          next = next:getNextAlive()
        end
      end
      if next == player or next == to or player.dead then
        break
      end
    end
  end,
}
local sw_juenian_tar = fk.CreateTriggerSkill {
  name = "#sw_juenian_tar",
  refresh_events = { fk.GameStart, fk.RoundEnd },
  can_refresh = function(self, event, target, player, data)
    if not player:hasSkill("sw_juenian") then return false end
    if event == fk.GameStart then
      return true
    else
      return true
    end
  end,
  on_refresh = function(self, event, target, player, data)
    local room = player.room
    if event == fk.GameStart then
      room:setPlayerMark(player, "@@fengchenjuenianzhan", 1)
    else
      if player:getMark("fc_chongneng") < 1 then
        room:addPlayerMark(player, "fc_chongneng", 1)
      elseif player:getMark("fc_chongneng") == 1 then
        room:addPlayerMark(player, "@@fengchenjuenianzhan", 1)
        room:setPlayerMark(player, "fc_chongneng", 0)
      end
    end
  end,
}
local sw_juenian_pofeng = fk.CreateTriggerSkill {
  name = "#sw_juenian_pofeng",
  anim_type = "offensive",
  events = { fk.CardUsing, fk.CardUseFinished, fk.EventPhaseEnd },
  frequency = Skill.Compulsory,
  mute = true,
  can_trigger = function(self, event, target, player, data)
    if not player:hasSkill("sw_juenian") then return false end
    if event == fk.CardUsing then
      return target == player and player:getMark("zuowei-turn") ~= 0 and player:getMark("@sw_pozhang-turn") > 0
    elseif event == fk.CardUseFinished then
      return target == player and player:getMark("zuowei-turn") ~= 0 and player:getMark("@sw_pozhang-turn") == 0
    else
      return target == player and player.phase == Player.Play and player:getMark("zuowei-turn") ~= 0
    end
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    local tar = room:getPlayerById(player:getMark("zuowei-turn"))
    if event == fk.CardUsing then
      room:removePlayerMark(player, "@sw_pozhang-turn", 1)
    elseif event == fk.CardUseFinished then
      room:swapSeat(player, tar)
      room:setPlayerMark(player, "zuowei-turn", 0)
    else
      room:swapSeat(player, tar)
      room:setPlayerMark(player, "zuowei-turn", 0)
    end
  end,
}
sw_juenian:addRelatedSkill(sw_juenian_pofeng)
sw_juenian:addRelatedSkill(sw_juenian_tar)
yongen:addSkill(sw_juenian)
Fk:loadTranslationTable {
  ["sw_juenian"] = "绝念",
  [":sw_juenian"] = "每两轮充能一次，游戏开始时获得一次，出牌阶段，你选择一名攻击范围内的其他角色，移动至其上家，对逆时针经过的所有角色造成一点伤害，若如此做，你使用五张牌或回合结束时，你返回原位",

  ["#sw_juenian_pofeng"] = "破锋",
  ["@sw_pozhang-turn"] = "破锋",
  ["@@fengchenjuenianzhan"] = "封尘绝念斩",
  ["#sw_juenian_tar"] = "绝念",
  ["#sw_juenian-active"] = "封尘绝念斩：选择一名攻击范围内的其他角色，移动至其上家，对逆时针经过的所有角色造成一点伤害",

  ["$sw_juenian1"] = "我要将你从你自身中拯救出来！",
  ["$sw_juenian2"] = "我并非为你而来！",
  ["$sw_juenian3"] = "一剑追悔，一剑..开门",
  ["$sw_juenian4"] = "虚张声势，却愚弄不了任何人！",
}
local yingliuzhilia = General(extension, "sw__yingliuzhilia", "aony", 3, 3)
local sw_shuangying_qt = fk.CreateTriggerSkill {
  name = "sw_shuangying_qt",
  events = { fk.Deathed, fk.RoundEnd, fk.EnterDying },
  frequency = Skill.Quest,
  anim_type = "offensive",
  mute = true,
  can_trigger = function(self, event, target, player, data)
    if player:hasSkill(self) and player:usedSkillTimes(self.name, Player.HistoryGame) == 0 then
      if event == fk.Deathed then
        return data.damage and data.damage.from == player
      elseif event == fk.RoundEnd then
        return player.room:getTag("RoundCount") == 1
      elseif event == fk.EnterDying then
        return target == player
      end
    end
  end,
  on_cost = function()
    return true
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    room:notifySkillInvoked(player, self.name, "big")
    if event == fk.Deathed then
      room:updateQuestSkillState(player, self.name)
      player:broadcastSkillInvoke("sw_shuangying_qt", 1)
      room:changeHero(player, "sw__kaiyin", true, false, true, true)
      player:drawCards(2, self.name)
    elseif event == fk.RoundEnd then
      player:broadcastSkillInvoke("sw_shuangying_qt", 1)
      room:updateQuestSkillState(player, self.name)
      room:changeHero(player, "sw__kaiyin", true, false, true, true)
      player:gainAnExtraTurn()
    elseif event == fk.EnterDying then
      player:broadcastSkillInvoke("sw_shuangying_qt", 2)
      room:updateQuestSkillState(player, self.name, true)
      room:changeHero(player, "sw__layasite", true, false, true, true)
    end
    room:handleAddLoseSkills(player, "-sw_shuangying_qt", nil, true, false)
  end,
}
local sw_fanshi = fk.CreateActiveSkill {
  name = "sw_fanshi",
  anim_type = "control",
  card_num = 2,
  target_num = 1,
  can_use = function(self, player)
    return player:usedSkillTimes(self.name, Player.HistoryGame) == 0 and not player:isNude()
  end,
  card_filter = Util.TrueFunc,
  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 target = room:getPlayerById(effect.tos[1])
    room:moveCards({
      ids = effect.cards,
      from = player.id,
      to = target.id,
      toArea = Card.PlayerHand,
      moveReason = fk.ReasonGive,
      proposer = player.id,
      skillName = self.name,
    })
    room:loseHp(player, player.hp, self.name)
  end,
}
yingliuzhilia:addSkill(sw_fanshi)
yingliuzhilia:addSkill(sw_shuangying_qt)
Fk:loadTranslationTable {
  ["sw__yingliuzhilia"] = "影流之镰",
  ["sw_shuangying_qt"] = "双影",
  [":sw_shuangying_qt"] = "使命技：生存，死亡或厮杀！<br><strong>成功</strong>：杀死一名角色或存活至第一轮结束，你变身为凯隐，获得技能“纵贯”，“裂舍”并摸两张牌，若因存活而变身，则改为由你首先行动。<br>" ..
      "<strong>失败</strong>：第一轮结束前进入濒死状态，你变身为拉亚斯特，获得技能“横扫”，“裂舍”并将体力恢复至上限。",
  ["$sw_shuangying_qt1"] = "",
  ["$sw_shuangying_qt2"] = "",

  ["sw_fanshi"] = "反噬",
  [":sw_fanshi"] = "出牌阶段，你可以交给一名其他角色两张牌，然后失去全部体力",
}

local kaiyin = General(extension, "sw__kaiyin", "aony", 3, 3)
kaiyin.total_hidden = true
Fk:loadTranslationTable {
  ["sw__kaiyin"] = "凯隐",
}
local sw_zongguan = fk.CreateActiveSkill {
  name = "sw_zongguan",
  anim_type = "offensive",
  card_num = 0,
  target_num = 1,
  can_use = function(self, player)
    return player:usedSkillTimes(self.name, Player.HistoryPhase) == 0
  end,
  card_filter = function(self, to_select, selected)
    return false
  end,
  target_filter = function(self, to_select, selected, selected_cards)
    local target = Fk:currentRoom():getPlayerById(to_select)
    return #selected == 0 and not Self:isProhibited(target, Fk:cloneCard("stab__slash"))
  end,
  on_use = function(self, room, effect)
    local player = room:getPlayerById(effect.from)
    local target = room:getPlayerById(effect.tos[1])
    room:useVirtualCard("stab__slash", nil, player, target, self.name, true)
  end,
}
local sw_zongguan_tar = fk.CreateTriggerSkill {
  name = "#sw_zongguan_tar",
  anim_type = "offensive",
  events = { fk.PreDamage },
  can_trigger = function(self, event, target, player, data)
    return target == player and player:hasSkill(self) and data.card and data.card.trueName == "slash" and
        table.contains(data.card.skillNames, "sw_zongguan")
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    room:addPlayerMark(player, "hengsao_sha-phase", 1)
    for _, p in ipairs(room.alive_players) do
      if p.id ~= player.id and (data.to:getNextAlive() == p or p:getNextAlive() == data.to) then
        room:damage {
          from = player,
          to = p,
          damage = 1,
          skillName = self.name,
        }
      end
    end
  end,
}
local sw_zongguan_slash = fk.CreateTriggerSkill {
  name = "#sw_zongguan_slash",
  anim_type = "offensive",
  events = { fk.Damage },
  frequency = Skill.Compulsory,
  can_trigger = function(self, event, target, player, data)
    return target == player and player:hasSkill(self) and data.card
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    player:drawCards(1, self.name)
    room:addPlayerMark(player, "hengsao_sha-phase", 1)
  end,
}
local sw_zongguan_mod = fk.CreateTargetModSkill {
  name = "#sw_zongguan_mod",
  residue_func = function(self, player, skill, scope, card)
    if card and player:hasSkill(self.name) and card.trueName == "slash" and scope == Player.HistoryPhase then
      return player:getMark("hengsao_sha-phase")
    else
      return 0
    end
  end
}
sw_zongguan:addRelatedSkill(sw_zongguan_slash)
sw_zongguan:addRelatedSkill(sw_zongguan_mod)
sw_zongguan:addRelatedSkill(sw_zongguan_tar)
kaiyin:addSkill(sw_zongguan)
Fk:loadTranslationTable {
  ["sw_zongguan"] = "纵贯",
  ["#sw_zongguan_tar"] = "纵贯",
  ["#sw_zongguan_slash"] = "纵贯",
  [":sw_zongguan"] = "出牌阶段限一次，你视为对使用一张不计入次数的刺【杀】，此刺【杀】造成伤害时，你可以对其相邻的角色造成一点伤害；当你使用牌或因该技能使用的刺【杀】造成伤害后，你摸一张牌并令本阶段可使用【杀】的次数+1",
}
local sw_lieshe_lan = fk.CreateActiveSkill {
  name = "sw_lieshe_lan",
  anim_type = "control",
  card_num = 0,
  target_num = 1,
  frequency = Skill.Limited,
  target_filter = function(self, to_select, selected)
    local target = Fk:currentRoom():getPlayerById(to_select)
    return #selected < 1 and to_select ~= Self.id and target:isWounded()
  end,
  can_use = function(self, player)
    return player:usedSkillTimes(self.name, Player.HistoryGame) == 0
  end,
  on_use = function(self, room, effect)
    local player = room:getPlayerById(effect.from)
    local target = room:getPlayerById(effect.tos[1])
    local x = 1 + (target:getLostHp() // 2)
    room:damage {
      from = player,
      to = target,
      damage = x,
      skillName = self.name,
    }
  end,
}
local sw_lieshe_lan_trigger = fk.CreateTriggerSkill {
  name = "#sw_lieshe_lan_trigger",
  mute = true,
  events = { fk.EnterDying },
  can_trigger = function(self, event, target, player, data)
    return data.damage and data.damage.skillName == "sw_lieshe_lan" and data.damage.from and
        data.damage.from == player and not player.dead
  end,
  on_cost = Util.TrueFunc,
  on_use = function(self, event, target, player, data)
    player.room:addPlayerMark(data.damage.to, "@@lieshe_lan-turn", 1)
  end,
}
local sw_lieshe_lan_prohib = fk.CreateProhibitSkill {
  name = "#sw_lieshe_lan_prohib",
  prohibit_use = function(self, player, card)
    return player:getMark("@@lieshe_lan-turn") > 0 and (card.name == "peach" or card.name == "analeptic")
  end,
}
local sw_lieshe_lan_invalidity = fk.CreateInvaliditySkill {
  name = "#sw_lieshe_lan_invalidity",
  invalidity_func = function(self, from, skill)
    return from:getMark("@@lieshe_lan-turn") > 0 and not skill:isEquipmentSkill(from) and not skill.name:endsWith("&") 
  end
}

local sw_lieshe_lan_kill = fk.CreateTriggerSkill {
  name = "#sw_lieshe_lan_kill",
  anim_type = "drawcard",
  frequency = Skill.Compulsory,
  events = { fk.Deathed },
  can_trigger = function(self, event, target, player, data)
    return player:hasSkill(self) and data.damage and data.damage.from == player and
        data.damage.skillName == "sw_lieshe_lan"
  end,
  on_use = function(self, event, target, player, data)
    player:drawCards(3, self.name)
    player:setSkillUseHistory("sw_lieshe_lan", 0, Player.HistoryGame)
  end,
}
sw_lieshe_lan:addRelatedSkill(sw_lieshe_lan_kill)
sw_lieshe_lan:addRelatedSkill(sw_lieshe_lan_prohib)
sw_lieshe_lan:addRelatedSkill(sw_lieshe_lan_invalidity)
sw_lieshe_lan:addRelatedSkill(sw_lieshe_lan_trigger)
kaiyin:addSkill(sw_lieshe_lan)
Fk:loadTranslationTable {
  ["sw_lieshe_lan"] = "裂舍",
  ["@@lieshe_chongzhi"] = "收割成功",
  ["@@lieshe_lan-turn"] = "灵魂撕裂",
  ["#sw_lieshe_lan_kill"] = "裂舍",
  ["#sw_lieshe_lan_trigger"] = "裂舍",
  [":sw_lieshe_lan"] = "限定技，出牌阶段，你选择一名受伤的其他角色，对其造成X点伤害，若其因此进入濒死状态，其本回合不能使用【桃】/【酒】且所有技能失效（X为1+其已损失体力向下取整的一半），若其因此死亡，你摸三张牌并立刻重置〖裂舍〗",

  ["$sw_lieshe_lan1"] = "在我面前臣服吧！",
  ["$sw_lieshe_lan2"] = "我的力量将持敌永恒！没有人能够挑战我！",
}
local layasite = General(extension, "sw__layasite", "nkss", 4, 4)
layasite.total_hidden = true
local sw_lueying = fk.CreateTriggerSkill {
  name = "sw_lueying",
  anim_type = "control",
  events = { fk.TargetSpecifying },
  can_trigger = function(self, event, target, player, data)
    return target == player and player:hasSkill(self.name) and data.firstTarget and
        #AimGroup:getAllTargets(data.tos) == 1 and (data.card.trueName == "slash" or
          data.card:isCommonTrick()) and data.to ~= player.id
  end,
  on_cost = function(self, event, target, player, data)
    local room = player.room
    room:askForSkillInvoke(player, self.name, data, "#sw_lueying-jiaohuan::" .. data.to)
    return true
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    local tid = table.contains(U.getUseExtraTargets(room, data), player:getNextAlive().id) and
        player:getNextAlive().id
    AimGroup:addTargets(room, data, tid)
  end,
}
local sw_lueying_xixue = fk.CreateTriggerSkill {
  name = "#sw_lueying_xixue",
  anim_type = "offensive",
  events = { fk.DamageCaused },
  frequency = Skill.Compulsory,
  can_trigger = function(self, event, target, player, data)
    return target == player and player:hasSkill(self.name)
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    local n = data.to.hp // 3
    data.damage = data.damage + n
    if player:isWounded() then
      room:recover {
        who = player,
        num = 1,
        recoverBy = player,
        skillName = self.name
      }
    end
    local cards1 = {}
    for _, id in ipairs(room.draw_pile) do
      if not Fk:getCardById(id).is_damage_card then
        table.insertIfNeed(cards1, id)
      end
    end
    if #cards1 > 0 then
      local card = table.random(cards1)
      room:moveCards({
        ids = { card },
        to = player.id,
        toArea = Card.PlayerHand,
        moveReason = fk.ReasonJustMove,
        proposer = player.id,
        skillName = self.name,
      })
    end
  end,
}

sw_lueying:addRelatedSkill(sw_lueying_xixue)
layasite:addSkill(sw_lueying)
Fk:loadTranslationTable {
  ["sw_lueying"] = "掠影",
  ["#sw_lueying-jiaohuan"] = "掠影：是否移动至%dest的下家然后指定移动后的下家成为额外目标",
  ["@@lueying_jiaohuan-phase"] = "掠影",
  ["#sw_lueying_xixue"] = "掠影",
  ["#sw_lueying_ask"] = "掠影：是否指定%dest成为额外目标",
  [":sw_lueying"] = "当你于回合内使用仅指定单一目标的【杀】或普通锦囊时，可以令此牌额外指定你的下家为目标；当你造成伤害时，此伤害额外加x，然后你回复1点体力并随机获得一张非伤害牌(x为当前体力的1/3)",
}
local sw_lieshe_hong = fk.CreateActiveSkill {
  name = "sw_lieshe_hong",
  anim_type = "control",
  card_num = 0,
  target_num = 1,
  frequency = Skill.Limited,
  target_filter = function(self, to_select, selected)
    return #selected < 1 and to_select ~= Self.id
  end,
  can_use = function(self, player)
    return player:usedSkillTimes(self.name, Player.HistoryGame) == 0
  end,
  on_use = function(self, room, effect)
    local player = room:getPlayerById(effect.from)
    local target = room:getPlayerById(effect.tos[1])
    room:damage {
      from = player,
      to = target,
      damage = 1,
      skillName = self.name,
    }
  end,
}
local sw_lieshe_hong_trigger = fk.CreateTriggerSkill {
  name = "#sw_lieshe_hong_trigger",
  mute = true,
  events = { fk.EnterDying },
  can_trigger = function(self, event, target, player, data)
    return data.damage and data.damage.skillName == "sw_lieshe_hong" and data.damage.from and
        data.damage.from == player and not player.dead
  end,
  on_cost = Util.TrueFunc,
  on_use = function(self, event, target, player, data)
    player.room:abortPlayerArea(data.damage.to, Player.ArmorSlot)
    player.room:abortPlayerArea(data.damage.to, Player.TreasureSlot)
    player.room:addPlayerMark(data.damage.to, "@@hong_pojia", 1)
  end,
}
local sw_lieshe_hong_skill = fk.CreateTriggerSkill {
  name = "#sw_lieshe_hong_skill",
  anim_type = "drawcard",
  frequency = Skill.Compulsory,
  events = { fk.Death },
  can_trigger = function(self, event, target, player, data)
    return player:hasSkill(self) and player:hasSkill(self) and data.damage and data.damage.from == player and
        data.damage.skillName == "sw_lieshe_hong"
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    local cards_id = data.damage.to:getCardIds { Player.Hand, Player.Equip }
    local dummy = Fk:cloneCard 'slash'
    dummy:addSubcards(cards_id)
    room:obtainCard(player.id, dummy, false, fk.ReasonPrey)
    room:changeMaxHp(player, data.damage.to.maxHp)
    if player:isWounded() then
      room:recover {
        who = player,
        num = 1,
        recoverBy = player,
        skillName = self.name
      }
    end
  end,
}
sw_lieshe_hong:addRelatedSkill(sw_lieshe_hong_skill)
sw_lieshe_hong:addRelatedSkill(sw_lieshe_hong_trigger)
layasite:addSkill(sw_lieshe_hong)
Fk:loadTranslationTable {
  ["sw_lieshe_hong"] = "裂舍",
  ["@@hong_pojia"] = "破甲",
  [":sw_lieshe_hong"] = "限定技，出牌阶段，你选择一名角色，对其造成1点伤害，若其因此进入濒死状态，令其“破甲”，若其死亡，你获得其体力上限和所有手牌并回复2点体力<br>" ..
      '<br /><font color="black">w=破甲：其废除防具和宝物栏</font>',

  ["#sw_lieshe_hong_skill"] = "裂舍",
  ["#sw_lieshe_hong_trigger"] = "裂舍",

  ["$sw_lieshe_hong1"] = "如此欢娱的屠戮！",
  ["$sw_lieshe_hong2"] = "他们从来就不该打开那扇门！哈哈哈哈哈",
}
Fk:loadTranslationTable {
  ["sw__layasite"] = "拉亚斯特",
}

local suona = General(extension, "sw__suona", "aony", 3, 3, General.Female)
Fk:loadTranslationTable {
  ["sw__suona"] = "娑娜",
}
local sw_hexian = fk.CreateActiveSkill {
  name = "sw_hexian",
  anim_type = "control",
  prompt = function(self)
    if self.interaction.data == "hexian_zansong" then
      return "#hexian_zansong"
    end
    if self.interaction.data == "hexian_yongtan" then
      return "#hexian_yongtan"
    end
    if self.interaction.data == "hexian_xunzou" then
      return "#hexian_xunzou"
    end
    return ""
  end,
  interaction = function(self)
    local choiceList = {}
    if Self:getMark("hexian_zansong-turn") == 0 then
      table.insert(choiceList, "hexian_zansong")
    end
    if Self:getMark("hexian_yongtan-turn") == 0 then
      table.insert(choiceList, "hexian_yongtan")
    end
    if Self:getMark("hexian_xunzou-turn") == 0 then
      table.insert(choiceList, "hexian_xunzou")
    end
    return UI.ComboBox { choices = choiceList }
  end,
  can_use = function(self, player)
    return (player:getMark("hexian_zansong-turn") == 0 or player:getMark("hexian_yongtan-turn") == 0 or player:getMark("hexian_xunzou-turn") == 0) and
        player:usedSkillTimes(self.name, Player.HistoryRound) < 3
  end,
  on_use = function(self, room, effect)
    local player = room:getPlayerById(effect.from)
    room:setPlayerMark(player, self.interaction.data .. "-turn", 1)
    if self.interaction.data == "hexian_zansong" then
      player:broadcastSkillInvoke("sw_hexian", 1)
      local tos = player.room:askForChoosePlayers(player, table.map(player.room.alive_players,
          function(p)
            return (#p:getCardIds(player.Hand) + #p:getCardIds(player.Equip)) > 0 and
                #p:getPile("sw_zansong") < 1 and p.id
          end), 1, 1, "#hexian_zansong-chos",
        self.name,
        true)
      if #tos > 0 then
        local id = room:getPlayerById(tos[1])
        local card = room:askForCard(id, 1, 1, true, self.name, false)
        id:addToPile("sw_zansong", card, true, self.name)
      end
    end
    if self.interaction.data == "hexian_yongtan" then
      player:broadcastSkillInvoke("sw_hexian", 6)
      local tos = player.room:askForChoosePlayers(player, table.map(player.room.alive_players,
          function(p)
            return (#p:getCardIds(player.Hand) + #p:getCardIds(player.Equip)) > 0 and
                #p:getPile("sw_yongtan") < 1 and p.id
          end), 1, 1, "#hexian_yongtan-chos",
        self.name,
        true)
      if #tos > 0 then
        local id = room:getPlayerById(tos[1])
        local card = room:askForCard(id, 1, 1, true, self.name, false)
        id:addToPile("sw_yongtan", card, true, self.name)
      end
    end
    if self.interaction.data == "hexian_xunzou" then
      player:broadcastSkillInvoke("sw_hexian", 2)
      local tos = player.room:askForChoosePlayers(player, table.map(player.room.alive_players,
          function(p)
            return (#p:getCardIds(player.Hand) + #p:getCardIds(player.Equip)) > 0 and
                #p:getPile("sw_xunzou") < 1 and p.id
          end), 1, 1, "#hexian_xunzou-chos", self.name,
        true)
      if #tos > 0 then
        local id = room:getPlayerById(tos[1])
        local card = room:askForCard(id, 1, 1, true, self.name, false)
        id:addToPile("sw_xunzou", card, true, self.name)
      end
    end
  end,
}
local sw_hexian_zansong = fk.CreateTriggerSkill {
  name = "#sw_hexian_zansong",
  events = { fk.DamageCaused },
  anim_type = "negative",
  can_trigger = function(self, event, target, player, data)
    return target == player and player.phase == player.Play and #player:getPile("sw_zansong") > 0
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    player:broadcastSkillInvoke("sw_hexian", 3)
    room:fillAG(player, player:getPile("sw_zansong"))
    local ids = room:askForAG(player, player:getPile("sw_zansong"), false, self.name)
    room:closeAG(player)
    room:moveCards({
      from = player.id,
      ids = { ids },
      toArea = Card.DiscardPile,
      moveReason = fk.ReasonPutIntoDiscardPile,
      skillName = self.name,
    })
    data.damage = data.damage + 1
  end
}
local sw_hexian_yongtan = fk.CreateTriggerSkill {
  name = "#sw_hexian_yongtan",
  events = { fk.EventPhaseStart, fk.Damaged },
  anim_type = "negative",
  can_trigger = function(self, event, target, player, data)
    if #player:getPile("sw_yongtan") > 0 and not player.dead then
      if event == fk.EventPhaseStart then
        return target == player and player.phase == Player.Start
      else
        return target == player
      end
    end
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    player:broadcastSkillInvoke("sw_hexian", 4)
    room:fillAG(player, player:getPile("sw_yongtan"))
    local ids = room:askForAG(player, player:getPile("sw_yongtan"), false, self.name)
    room:closeAG(player)
    room:moveCards({
      from = player.id,
      ids = { ids },
      toArea = Card.DiscardPile,
      moveReason = fk.ReasonPutIntoDiscardPile,
      skillName = self.name,
    })
    if player:isWounded() then
      room:recover({
        who = player,
        num = 1,
        recoverBy = player,
        skillName = self.name
      })
    end
    player:drawCards(2, self.name)
  end
}
local sw_hexian_xunzou = fk.CreateTriggerSkill {
  name = "#sw_hexian_xunzou",
  events = { fk.CardUsing },
  anim_type = "negative",
  can_trigger = function(self, event, target, player, data)
    return target == player and #player:getPile("sw_xunzou") > 0 and (data.card.type == Card.TypeBasic or
      data.card:isCommonTrick())
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    player:broadcastSkillInvoke("sw_hexian", 5)
    room:fillAG(player, player:getPile("sw_xunzou"))
    local ids = room:askForAG(player, player:getPile("sw_xunzou"), false, self.name)
    room:closeAG(player)
    room:moveCards({
      from = player.id,
      ids = { ids },
      toArea = Card.DiscardPile,
      moveReason = fk.ReasonPutIntoDiscardPile,
      skillName = self.name,
    })
    data.disresponsiveList = data.disresponsiveList or {}
    for _, p in ipairs(player.room.alive_players) do
      table.insertIfNeed(data.disresponsiveList, p.id)
    end
    if not data.card.is_damage_card then
      data.additionalEffect = 1
    end
  end,

}
sw_hexian:addRelatedSkill(sw_hexian_zansong)
sw_hexian:addRelatedSkill(sw_hexian_yongtan)
sw_hexian:addRelatedSkill(sw_hexian_xunzou)
suona:addSkill(sw_hexian)
Fk:loadTranslationTable {
  ["sw_hexian"] = "和弦",
  [":sw_hexian"] = "出牌阶段每项限一次，你令一名角色将一张牌置于武将牌上，称为：<br>" ..
      "赞颂：出牌阶段造成伤害时，其可以移去“赞颂”，令此次伤害+1并摸一张牌；<br>" ..
      "咏叹：准备阶段或受到伤害时，其可以移去“咏叹”，回复一点体力并摸两张牌；<br>" ..
      "迅奏：当其使用牌时，其可以移去“迅奏”，令此牌不可被响应，若为非伤害牌，则额外结算一次",

  ["hexian_zansong"] = "赞颂",
  ["#sw_hexian_zansong"] = "赞颂",
  ["hexian_yongtan"] = "咏叹",
  ["#sw_hexian_yongtan"] = "咏叹",
  ["hexian_xunzou"] = "迅奏",
  ["#sw_hexian_xunzou"] = "迅奏",

  ["#hexian_zansong-chos"] = "和弦：选择一名玩家，令其获得“赞颂”",
  ["#hexian_yongtan-chos"] = "和弦：选择一名玩家，令其获得“咏叹”",
  ["#hexian_xunzou-chos"] = "和弦：选择一名玩家，令其获得“迅奏”",

  ["sw_zansong"] = "和弦",
  ["sw_yongtan"] = "咏叹",
  ["sw_xunzou"] = "迅奏",
  ["#hexian_zansong"] = "赞颂：出牌阶段造成伤害时，其可以移去“赞颂”，令此次伤害+1并摸一张牌",
  ["#hexian_yongtan"] = "咏叹：准备阶段或受到伤害时，其可以移去“咏叹”，回复一点体力并摸两张牌",
  ["#hexian_xunzou"] = "迅奏：当其使用牌时，其可以移去“迅奏”，令此牌不可被响应，若为非伤害牌，则额外结算一次",
}
local sw_jiwu = fk.CreateTriggerSkill {
  name = "sw_jiwu",
  anim_type = "offensive",
  frequency = Skill.Limited,
  events = { fk.EventPhaseStart },
  can_trigger = function(self, event, target, player, data)
    return player == target and player:hasSkill(self.name) and player.phase == Player.Discard and
        player:usedSkillTimes(self.name, Player.HistoryGame) == 0 and #player:getCardIds(Player.Hand) > 3
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    if player:getHandcardNum() > 3 then
      local cards = room:askForDiscard(player, 4, 4, false, self.name, false, ".", "sw_jiwu-chos")
      local to = room:askForChoosePlayers(player, table.map(player.room.alive_players, function(p)
        return p.id ~= player.id and p.id
      end), 1, #cards, "#sw_jiwu-ips:::" .. tostring(#cards), self.name, true)
      local n = (1 + #cards) - #to
      if #to > 0 then
        for _, id in ipairs(to) do
          local p = room:getPlayerById(id)
          if not p.dead then
            local total = #p:getCardIds { Player.Hand, Player.Equip }
            if total < n then
              p:turnOver()
            else
              local card = room:askForDiscard(p, n, n, true, self.name, true, ".",
                "#sw_mingyun-discard:::" .. tostring(n))
              if #card == 0 then
                p:turnOver()
              end
            end
          end
        end
      end
    end
  end,
}
suona:addSkill(sw_jiwu)
Fk:loadTranslationTable {
  ["sw_jiwu"] = "激舞",
  ["#sw_jiwu-ips"] = "激舞：选择至多%arg名其他角色，令这些角色弃置%arg张牌",
  ["#sw_mingyun-discard"] = "弃置%arg张牌或点击取消翻面",
  ["sw_jiwu-chos"] = "请选择四张牌，然后令至多等量的角色选择弃牌或翻面",
  [":sw_jiwu"] = "限定技，弃牌阶段开始时，你可以弃置4张手牌，然后选择至多4名其他角色，令这些角色弃置至少4张牌，每多选一名角色，便少弃一张，若其不弃，其翻面",

  ["$sw_jiwu1"] = "",
  ["$sw_jiwu2"] = ""
}

local jie = General(extension, "sw__jie", "aony", 3, 5)
Fk:loadTranslationTable {
  ["sw__jie"] = "劫",
}
local sw_yingren = fk.CreateTriggerSkill {
  name = "sw_yingren",
  anim_type = "offensive",
  events = { fk.TurnEnd, fk.TurnStart },
  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 to = room:askForChoosePlayers(player, table.map(table.filter(room:getOtherPlayers(player), function(p)
      return p:getMark("@@jie_ying") < 1
    end), function(p) return p.id end), 1, 1, "#sw_yingren-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)
    for _, p in ipairs(room.alive_players) do
      room:setPlayerMark(p, "@@jie_ying", 0)
    end
    room:setPlayerMark(to, "@@jie_ying", 1)
  end,
}
local sw_yingren_tar = fk.CreateTriggerSkill {
  name = "#sw_yingren_tar",
  anim_type = "offensive",
  events = { fk.DamageInflicted },
  can_trigger = function(self, event, target, player, data)
    return target == player and player:hasSkill(self) and
        table.find(player.room.alive_players, function(p) return p:getMark("@@jie_ying") ~= 0 end)
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    local to = player.room:askForChoosePlayers(player, table.map(player.room.alive_players,
      function(p) return p:getMark("@@jie_ying") > 0 and p.id end), 1, 1, "#sw_yingren-chose", self.name, true)
    if #to > 0 then
      room:changeMaxHp(player, -1)
      room:getPlayerById(to[1]):drawCards(1, self.name)
      room:setPlayerMark(room:getPlayerById(to[1]), "@@jie_ying", 0)
      room:swapSeat(player, room:getPlayerById(to[1]))
      local dat = table.simpleClone(data)
      dat.to = room:getPlayerById(to[1])
      room:damage(dat)
      return true
    end
  end,
}
sw_yingren:addRelatedSkill(sw_yingren_tar)
jie:addSkill(sw_yingren)
Fk:loadTranslationTable {
  ["sw_yingren"] = "影忍",
  ["@@jie_ying"] = "影",
  ["#sw_yingren_tar"] = "影忍",
  ["#sw_yingren-chose"] = "影忍：是否与“影”交换位置并转移该伤害",
  ["#sw_yingren-choose"] = "影忍：选择一个目标成为你的“影”",
  [":sw_yingren"] = "准备阶段或结束阶段，你可以选择一名其他角色，其视为你的“影”(只能存在一个“影”)；当你受到伤害时，你可以失去一点体力上限，与“影”交换位置并将伤害转移至“影”，其摸一张牌并不再视为你的“影”"
}

local sw_zhuren = fk.CreateTriggerSkill {
  name = "sw_zhuren",
  anim_type = "offensive",
  events = { fk.CardUsing },
  can_trigger = function(self, event, target, player, data)
    local room = player.room
    if player:hasSkill(self.name) and player == target and data.tos and data.card.is_damage_card and player:usedSkillTimes(self.name, Player.HistoryTurn) == 0 then
      local user = table.find(room.alive_players, function(p) return p:getMark("@@jie_ying") > 0 end)
      if user then
        local tos = TargetGroup:getRealTargets(data.tos)
        local card = Fk:cloneCard(data.card.name, data.card.suit, data.card.number)
        return table.find(tos, function(pid)
          return not user:isProhibited(room:getPlayerById(pid), card)
        end)
      end
    end
  end,
  on_cost = function(self, event, target, player, data)
    local room = player.room
    local user = table.find(room.alive_players, function(p) return p:getMark("@@jie_ying") > 0 end)
    return user and room:askForSkillInvoke(user, self.name, nil, "#zhuren_chos")
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    local user = table.find(room.alive_players, function(p) return p:getMark("@@jie_ying") > 0 end)
    if not user then return end
    local card = Fk:cloneCard(data.card.name, data.card.suit, data.card.number)
    local tos = {}
    for _, pid in ipairs(TargetGroup:getRealTargets(data.tos)) do
      local p = room:getPlayerById(pid)
      if not user:isProhibited(p, card) then
        table.insert(tos, p)
      end
    end
    if #tos == 0 then return end
    local use = { from = user.id, tos = table.map(tos, function(p) return { p.id } end), card = card, extraUse = true }
    room:useCard(use)
    room:setPlayerMark(user, "@@jie_ying", 0)
    if use.damageDealt then
      if player:getMark("@sw_linghun") < 5 then
        room:addPlayerMark(player, "@sw_linghun")
      end
    end
  end,
}
jie:addSkill(sw_zhuren)
Fk:loadTranslationTable {
  ["sw_zhuren"] = "诛刃",
  ["@sw_linghun"] = "灵魂",
  ["#zhuren_chos"] = "诛刃：是否视为对相同的角色使用一张相同的牌",
  [":sw_zhuren"] = "当你使用伤害牌时，“影”可以视为对相同目标使用此牌，然后其不再视为你的“影”，若其因此造成伤害，你收割其一层灵魂(至多5层)"
}
local sw_yingsha = fk.CreateActiveSkill {
  name = "sw_yingsha",
  anim_type = "offensive",
  card_num = 0,
  target_num = 0,
  frequency = Skill.Limited,
  can_use = function(self, player)
    return player:getMark("@sw_linghun") > 0 and player:usedSkillTimes(self.name, Player.HistoryGame) == 0
  end,
  card_filter = Util.FalseFunc,
  on_use = function(self, room, effect)
    local player = room:getPlayerById(effect.from)
    local n = math.min(player:getMark("@sw_linghun"), 5)
    local to = player.room:askForChoosePlayers(player, table.map(player.room.alive_players,
      function(p) return p.id ~= player.id and p.id end), 1, 1, "#sw_yingsha-chose:::" .. n, self.name, true)
    if #to > 0 then
      for i = 1, n, 1 do
        local card = Fk:cloneCard("slash")
        local use = {
          from = player.id,
          tos = { { to[1] } },
          card = card,
          extraUse = true,
        }
        card.skillName = self.name
        room:useCard(use)
        if use.damageDealt then
          room:addPlayerMark(room:getPlayerById(to[1]), "@sw_yingsha_lose")
        end
      end
    end
  end,
}
local sw_yingsha_targetmod = fk.CreateTargetModSkill {
  name = "#sw_yingsha_targetmod",
  bypass_times = function(self, player, skill, scope, card)
    return card and table.contains(card.skillNames, sw_yingsha.name)
  end,
}
local sw_yingsha_lieying = fk.CreateTriggerSkill {
  name = "#sw_yingsha_lieying",
  anim_type = "offensive",
  frequency = Skill.Compulsory,
  events = { fk.EventPhaseStart },
  can_trigger = function(self, event, target, player, data)
    return target == player and player.phase == Player.Start and player:getMark("@sw_yingsha_lose") > 0
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    local n = player:getMark("@sw_yingsha_lose")
    for i = 1, n, 1 do
      room:damage {
        to = target,
        damage = 1,
        skillName = self.name,
      }
      room:removePlayerMark(player, "@sw_yingsha_lose", 1)
    end
  end,
}
sw_yingsha:addRelatedSkill(sw_yingsha_targetmod)
sw_yingsha:addRelatedSkill(sw_yingsha_lieying)
jie:addSkill(sw_yingsha)
Fk:loadTranslationTable {
  ["sw_yingsha"] = "影杀",
  ["@sw_yingsha_lose"] = "裂影",
  ["#sw_yingsha_lieying"] = "裂影",
  ["#sw_yingsha-chose"] = "影杀：选择一名角色，视为对其使用%arg张杀",
  [":sw_yingsha"] = "限定技，出牌阶段，你可以选择一名其他角色，视为对其使用x张杀，其每因此受到一次伤害，其下个准备阶段便受到一点无来源的伤害(x为你收割的灵魂)",

  ["$sw_yingsha1"] = "",
  ["$sw_yingsha2"] = "",
}
local jin = General(extension, "sw__jin", "aony", 3, 3)
Fk:loadTranslationTable {
  ["sw__jin"] = "烬",
  ["aony"] = "艾欧尼亚",
  ["~sw__jin"] = "(语气)....",
}
local sw_diyu = fk.CreateTargetModSkill {
  name = "sw_diyu",
  bypass_distances = function(self, player, skill)
    return player:hasSkill(self) and player.phase ~= Player.NotActive
  end,
}
jin:addSkill(sw_diyu)
Fk:loadTranslationTable {
  ["sw_diyu"] = "低语",
  [":sw_diyu"] = "锁定技，你于出牌阶段内使用牌无距离限制",

  ["$sw_diyu1"] = "我喜欢你死的样子",
  ["$sw_diyu2"] = "成为我的作品，你将得以超脱",
}
local sw_huacai = fk.CreateTriggerSkill {
  name = "sw_huacai",
  anim_type = "offensive",
  frequency = Skill.Compulsory,
  events = { fk.CardUsing },
  mute = true,
  can_trigger = function(self, event, target, player, data)
    return target == player and (data.card.type == Card.TypeBasic or data.card:isCommonTrick()) and
        player:hasSkill(self.name) and
        player.phase == Player.Play
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    room:addPlayerMark(player, "huacai_js-turn", 1)
    if player:getMark("huacai_js-turn") == 4 then
      room:setPlayerMark(player, "@@diyu_zhuangdan-turn", 1)
    end
  end,
}
local sw_huacai_tar = fk.CreateTriggerSkill {
  name = "#sw_huacai_tar",
  anim_type = "offensive",
  frequency = Skill.Compulsory,
  mute = true,
  events = { fk.TargetSpecified },
  can_trigger = function(self, event, target, player, data)
    return target == player and (data.card.type == Card.TypeBasic or data.card:isCommonTrick()) and
        player:hasSkill(self.name) and
        player.phase == Player.Play
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    if player:getMark("huacai_js-turn") == 1 then
      player:broadcastSkillInvoke("sw_huacai")
      data.disresponsiveList = data.disresponsiveList or {}
      for _, p in ipairs(player.room.alive_players) do
        table.insertIfNeed(data.disresponsiveList, p.id)
      end
    elseif player:getMark("huacai_js-turn") == 2 then
      player:broadcastSkillInvoke("sw_huacai")
      player:drawCards(4, self.name)
    end
  end,
}

local sw_huacai_ewai = fk.CreateTriggerSkill {
  name = "#sw_huacai_ewai",
  anim_type = "offensive",
  events = { fk.CardUsing },
  frequency = Skill.Compulsory,
  can_trigger = function(self, event, target, player, data)
    return target == player and (data.card.type == Card.TypeBasic or data.card:isCommonTrick()) and
        player:hasSkill(self.name) and player:usedSkillTimes(self.name, Player.HistoryTurn) < 1 and
        player.phase == Player.Play and player:getMark("huacai_js-turn") == 3
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    local targets = U.getUseExtraTargets(room, data)
    if #targets == 0 then return false end
    player:broadcastSkillInvoke("sw_huacai")
    local tos = room:askForChoosePlayers(player, targets, 1, 3,
      "#huacai_basic-choose", self.name, true)
    if #tos > 0 then
      table.forEach(tos, function(id)
        table.insert(data.tos, { id })
      end)
    end
  end,
}

local sw_huacai_damage = fk.CreateTriggerSkill {
  name = "#sw_huacai_damage",
  anim_type = "offensive",
  frequency = Skill.Compulsory,
  events = { fk.DamageCaused },
  can_trigger = function(self, event, target, player, data)
    return target == player and player:hasSkill(self.name) and player:getMark("huacai_js-turn") == 4 and
        data.card.is_damage_card
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    player:broadcastSkillInvoke("sw_huacai")
    data.damage = data.damage * 2
  end,
}
local sw_huacai_prohibit = fk.CreateProhibitSkill {
  name = "#sw_huacai_prohibit",
  prohibit_use = function(self, player, card)
    return player:getMark("@@diyu_zhuangdan-turn") > 0
  end,
}

local sw_huacai_maxcards = fk.CreateMaxCardsSkill {
  name = "#sw_huacai_maxcards",
  correct_func = function(self, player)
    if player:hasSkill(self.name) and player:getMark("huacai_js-turn") == 5 then
      return 4
    else
      return 0
    end
  end,
}
local sw_huacai_tar1 = fk.CreateTriggerSkill {
  name = "#sw_huacai_tar1",
  anim_type = "offensive",
  frequency = Skill.Compulsory,
  events = { fk.EventPhaseEnd },
  mute = true,
  can_trigger = function(self, event, target, player, data)
    return target == player and
        player:hasSkill(self.name) and
        player.phase == Player.Play
  end,
  on_use = function(self, event, target, player, data)
    if player:getMark("huacai_js-turn") == 4 then
      player.room:addPlayerMark(player, "huacai_js-turn", 1)
    end
  end,
}
local sw_huacai_slash = fk.CreateTargetModSkill {
  name = "#sw_huacai_slash",
  residue_func = function(self, player, skill, scope)
    if player:hasSkill(self) and skill.trueName == "slash_skill"
        and scope == Player.HistoryPhase then
      return 999
    end
  end,
}
sw_huacai:addRelatedSkill(sw_huacai_slash)
sw_huacai:addRelatedSkill(sw_huacai_tar1)
sw_huacai:addRelatedSkill(sw_huacai_maxcards)
sw_huacai:addRelatedSkill(sw_huacai_ewai)
sw_huacai:addRelatedSkill(sw_huacai_damage)
sw_huacai:addRelatedSkill(sw_huacai_prohibit)
sw_huacai:addRelatedSkill(sw_huacai_tar)
jin:addSkill(sw_huacai)
Fk:loadTranslationTable {
  ["sw_huacai"] = "华彩",
  ["#huacai_basic-choose"] = "卓越：请选择至多三名其他角色",
  ["@@diyu_zhuangdan-turn"] = "需重新装填",
  ["#sw_huacai_ewai"] = "卓越",
  ["#sw_huacai_damage"] = "非凡",
  [":sw_huacai"] = "低语至多装填四发弹药，因此烬的出牌阶段，除装备牌和延时锦囊外，只能使用四张牌且【杀】无次数限制，根据使用顺序附带以下效果<br>" ..
      "精彩：无法被响应<br>" ..
      "绝妙：摸目标数*4张牌<br>" ..
      "卓越：若为单体牌，可以选择至多4个目标<br>" ..
      "非凡：造成的伤害翻倍<br>" ..
      "出牌阶段结束时，若你使用了所有子弹，本回合手牌上限+4",

  ["$sw_huacai1"] = "每粒子弹，都将翩翩起舞",
  ["$sw_huacai2"] = "子弹出膛前的瞬间，非常痛苦",
  ["$sw_huacai3"] = "你，将饱含诗意",
  ["$sw_huacai4"] = "看我的傀儡，跳舞吧",
  ["$sw_huacai5"] = "每颗子弹都是我的一缕灵魂，每道枪火都是我的一丝生命",
  ["$sw_huacai6"] = "杀戮，是多么甜蜜的哀伤",
}
local sw_xiemu = fk.CreateTriggerSkill {
  name = "sw_xiemu",
  anim_type = "offensive",
  frequency = Skill.Limited,
  events = { fk.EventPhaseStart },
  can_trigger = function(self, event, target, player, data)
    return player == target and player:hasSkill(self.name) and player.phase == Player.Finish and
        player:getMark("huacai_js-turn") == 5 and
        player:usedSkillTimes(self.name, Player.HistoryGame) == 0
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    room:setPlayerMark(player, "huacai_js-turn", 0)
    local to = room:askForChoosePlayers(player, table.map(player.room.alive_players, function(p)
      return p.id ~= player.id and p.id
    end), 1, 4, "#sw_xiemu-ips", self.name, true)
    if #to > 0 then
      for _, id in ipairs(to) do
        local targets = room:getPlayerById(id)
        if targets.hp > 1 then
          room:damage {
            from = player,
            to = targets,
            damage = 1,
            skillName = self.name,
          }
        else
          room:damage {
            from = player,
            to = targets,
            damage = 2,
            skillName = self.name,
          }
        end
      end
    end
  end,
}
jin:addSkill(sw_xiemu)
Fk:loadTranslationTable {
  ["sw_xiemu"] = "落幕",
  ["#sw_xiemu-ips"] = "落幕：你可以选择至多四名其他角色",
  [":sw_xiemu"] = "限定技，结束阶段，若你本回合成功击发了低语的四颗弹药，你可以进行装填，然后选择至多四名其他角色，对其造成一点伤害，若其体力值不大于1，则视为对其发动“非凡”",

  ["$sw_xiemu1"] = "我从污秽和淤泥中复苏，我是灼热的青莲，我是..独一的美",
  ["$sw_xiemu2"] = "我于杀戮之中盛放，亦如，黎明中的花朵",
}



return extension