local extension = Package:new("majiang_lol_xk")
extension.extensionName = "MahjongSoul"
Fk:loadTranslationTable {
    ["majiang_lol_xk"] = "英雄联盟-虚空",
    ["xk"] = "虚空",
}
extension.game_modes_blacklist = { "as_StonehengEarena_mode" }
local U = require "packages/utility/utility"
local kasha = General(extension, "sw__kasha", "xk", 3, 3, General.Female)
Fk:loadTranslationTable {
    ["sw__kasha"] = "卡莎",
}
local sw_jinhua = fk.CreateTriggerSkill {
    name = "sw_jinhua",
    anim_type = "offensive",
    frequency = Skill.Compulsory,
    events = { fk.Damage, fk.Damaged },
    can_trigger = function(self, event, target, player, data)
        if target == player and player:hasSkill(self) then
            if event == fk.Damage and player:getMark("jinhua") < 3 then
                return true
            else
                return player:getMark("jinhua") < 3
            end
        end
    end,
    on_use = function(self, event, target, player, data)
        local room = player.room
        room:addPlayerMark(player, "@jinhua", data.damage)
    end,
}
local sw_jinhua_tar = fk.CreateTriggerSkill {
    name = "#sw_jinhua_tar",
    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:hasSkill(self) and
            player:getMark("@jinhua") > 2 and
            (player:getMark("UPSkill1+") < 1 or player:getMark("UPSkill2+") < 1 or player:getMark("UPSkill3+") < 1)
    end,
    on_use = function(self, event, target, player, data)
        local room = player.room
        local chc = {}
        if player:getMark("UPSkill1+") < 1 then
            table.insert(chc, "UPSkill1")
        end
        if player:getMark("UPSkill2+") < 1 then
            table.insert(chc, "UPSkill2")
        end
        if player:getMark("UPSkill3+") < 1 then
            table.insert(chc, "UPSkill3")
        end
        local chs = room:askForChoice(player, chc, self.name)
        if chs == "UPSkill1" then
            room:addPlayerMark(player, "jinhua", 1)
            room:setPlayerMark(player, "UPSkill1+", 1)
            room:removePlayerMark(player, "@jinhua", 3)
        elseif chs == "UPSkill2" then
            room:addPlayerMark(player, "jinhua", 1)
            room:setPlayerMark(player, "UPSkill2+", 1)
            room:removePlayerMark(player, "@jinhua", 3)
        elseif chs == "UPSkill3" then
            room:addPlayerMark(player, "jinhua", 1)
            room:setPlayerMark(player, "UPSkill3+", 1)
            room:removePlayerMark(player, "@jinhua", 3)
        end
        if player:getMark("UPSkill1+") > 0 and player:getMark("UPSkill2+") > 0 and player:getMark("UPSkill3+") > 0 then
            local mark = player:getMark("@jinhua")
            player:drawCards(mark)
            room:setPlayerMark(player, "@jinhua", 0)
        end
    end,
}
sw_jinhua:addRelatedSkill(sw_jinhua_tar)
kasha:addSkill(sw_jinhua)
Fk:loadTranslationTable {
    ["sw_jinhua"] = "进化",
    ["#sw_jinhua_tar"] = "进化",
    ["UPSkill1"] = "进化〖察危〗",
    ["UPSkill2"] = "进化〖索敌〗",
    ["UPSkill3"] = "进化〖超限〗",
    ["@jinhua"] = "进化点:",
    [":sw_jinhua"] = "锁定技，当你造成或受到伤害后，你获得伤害值相等的进化点数；准备阶段，若你至少拥有3个进化点，你可以失去3点进化点数进化一个技能，若技能均已进化，你摸额外点数的牌。<br>" ..
        "<font color='red'>【进化】你选择一项：<br>1.删除〖察危〗选项中的失去体力且改为摸两张牌；<br>2.删除〖索敌〗的次数限制，且可以指定任意目标；<br>3.修改〖超限〗为每轮一次"
}
local sw_chawei = fk.CreateTriggerSkill {
    name = "sw_chawei",
    anim_type = "offensive",
    events = { fk.DrawNCards },
    can_trigger = function(self, event, target, player, data)
        return target ~= player and target:distanceTo(player) == 1 and player:hasSkill(self.name)
    end,
    on_use = function(self, event, target, player, data)
        local room = player.room
        local chc = {}
        if player:getMark("UPSkill1+") == 0 then
            table.insertIfNeed(chc, "chawei1:" .. player.id)
            table.insertIfNeed(chc, "chawei2:" .. player.id)
        else
            table.insertIfNeed(chc, "chawei3:" .. player.id)
            table.insertIfNeed(chc, "chawei4:" .. player.id)
        end
        local chs = room:askForChoice(target, chc, self.name)
        if chs == "chawei1:" .. player.id or chs == "chawei3:" .. player.id then
            data.n = data.n - 1
            if player:getMark("UPSkill1+") == 1 then
                player:drawCards(2, self.name)
            else
                room:loseHp(player, 1, self.name)
                player:drawCards(1, self.name)
            end
        elseif chs == "chawei2:" .. player.id or chs == "chawei4:" .. player.id then
            data.n = data.n + 1
            local to = room:askForChoosePlayers(player, table.map(player.room.alive_players, function(p)
                return p.id ~= player.id and p.id
            end), 1, 1, "#chawei2-chos", self.name, true)
            if #to > 0 then
                local use2 = {
                    from = player.id,
                    tos = { { to[1] } },
                    card = Fk:cloneCard("stab__slash"),
                    extraUse = true,
                }
                use2.card.skillName = self.name
                room:useCard(use2)
            end
        end
    end,
}
kasha:addSkill(sw_chawei)
Fk:loadTranslationTable {
    ["sw_chawei"] = "察危",
    ["#sw_chawei_jinhua"] = "察危",
    ["chawei1"] = "少摸一张牌，令%src失去一点体力并摸一张牌",
    ["chawei2"] = "多摸一张牌，%src视为使用一张刺【杀】",
    ["chawei3"] = "少摸一张牌，令%src摸两张牌",
    ["chawei4"] = "多摸一张牌，%src视为使用一张刺【杀】",


    ["#chawei2-chos"] = "选择一名其他角色，视为对其使用【刺杀】",
    [":sw_chawei"] = "与你距离为1的其他角色摸牌阶段，你令其选择：1.少摸一张牌，令你失去一点体力并摸一张牌；2.多摸一张牌，你视为使用一张无视距离的刺【杀】",
}
local sw_suodi = fk.CreateTriggerSkill {
    name = "sw_suodi",
    anim_type = "offensive",
    events = { fk.DamageCaused },
    can_trigger = function(self, event, target, player, data)
        if target == player and player:distanceTo(data.to) > 1 and player:hasSkill(self.name) then
            if player:getMark("UPSkill2+") == 0 then
                return player:usedSkillTimes(self.name, Player.HistoryTurn) < 1
            else
                return player:usedSkillTimes(self.name, Player.HistoryTurn) < 999
            end
        end
    end,
    on_use = function(self, event, target, player, data)
        local room = player.room
        player:broadcastSkillInvoke("sw_suodi")
        data.damage = data.damage + 1
    end,

    refresh_events = { fk.CardUsing },
    can_refresh = function(self, event, target, player, data)
        if event == fk.CardUsing and target == player and player:hasSkill(self) then
            return (data.card.type == Card.TypeBasic or
                data.card:isCommonTrick()) and data.tos and #data.tos == 1
        end
    end,
    on_refresh = function(self, event, target, player, data)
        local room = player.room
        local targets = U.getUseExtraTargets(room, data)
        if #targets == 0 then return false end
        if player:getMark("UPSkill2+") == 1 then
            local tos = room:askForChoosePlayers(player, targets, 1, 99,
                "#sw_suodi_jinhua-choose", self.name, true)
            if #tos > 0 then
                player:broadcastSkillInvoke("sw_suodi")
                table.forEach(tos, function(id)
                    table.insert(data.tos, { id })
                end)
            end
        else
            local tos = room:askForChoosePlayers(player, targets, 1, 1,
                "#sw_suodi-choose", self.name, true)
            if #tos > 0 then
                player:broadcastSkillInvoke("sw_suodi")
                table.forEach(tos, function(id)
                    table.insert(data.tos, { id })
                end)
            end
        end
    end
}
kasha:addSkill(sw_suodi)
Fk:loadTranslationTable {
    ["sw_suodi"] = "索敌",
    ["#sw_suodi_jinhua"] = "索敌",
    ["#sw_suodi-choose"] = "索敌：请选择一名其他角色成为目标",
    ["#sw_suodi_jinhua-choose"] = "索敌：请选择任意名其他角色成为目标",
    [":sw_suodi"] = "当你使用基本牌或普通锦囊牌时，你可以额外选择一个目标（目标需合法）；每回合限一次，当你对与你距离大于1的其他角色造成伤害时，你可以令伤害值+1",
}
local sw_chaoxian = fk.CreateTriggerSkill {
    name = "sw_chaoxian",
    events = { fk.TurnEnd },
    anim_type = "control",
    can_trigger = function(self, event, target, player, data)
        if player:hasSkill(self) and target:getNextAlive() ~= player and target ~= player and
            not table.find(player.room.alive_players, function(p) return p:getHandcardNum() > target:getHandcardNum() end) then
            if player:getMark("UPSkill3+") == 0 then
                return player:usedSkillTimes(self.name, Player.HistoryGame) < 1
            else
                return player:usedSkillTimes(self.name, Player.HistoryRound) < 1
            end
        end
    end,
    on_use = function(self, event, target, player, data)
        local room = player.room
        local to = target:getNextAlive()
        room:swapSeat(player, to)
        room:changeShield(player, 1)
    end,
}

kasha:addSkill(sw_chaoxian)
Fk:loadTranslationTable {
    ["sw_chaoxian"] = "超限",
    ["#sw_chaoxian_jinhua"] = "超限",
    [":sw_chaoxian"] = "每局游戏限一次，手牌数最多的其他角色回合结束时，你可以与其下家交换座位并获得1点护甲",
}
local dabei_ = General(extension, "sw__dabeiex", "xk", 3, 3, General.Female)
dabei_.total_hidden = true
local dabei = General(extension, "sw__dabei", "xk", 4, 4, General.Female)
Fk:loadTranslationTable {
    ["sw__dabei"] = "卑尔维斯",
    ["sw__dabeiex"] = "卑尔维斯",
}
local sw_shiyun = fk.CreateTriggerSkill {
    name = "sw_shiyun",
    anim_type = "offensive",
    frequency = Skill.Compulsory,
    events = { fk.Damage, fk.DamageCaused, fk.Death },
    can_trigger = function(self, event, target, player, data)
        if not player:hasSkill(self) then return false end
        if event == fk.Damage then
            return target == player and data.card and data.card.trueName == "slash"
        elseif event == fk.DamageCaused then
            return target == player and data.to ~= player and
                not table.contains(U.getMark(player, "sw_shiyun_mark"), data.to.id)
        else
            return table.contains(U.getMark(player, "sw_shiyun_mark"), target.id)
        end
    end,
    on_use = function(self, event, target, player, data)
        local room = player.room
        local mark = U.getMark(player, "sw_shiyun_mark")
        if event == fk.Damage then
            room:addPlayerMark(player, "@db_rzhz", 1)
        elseif event == fk.DamageCaused then
            table.insert(mark, data.to.id)
            room:setPlayerMark(player, "sw_shiyun_mark", #mark > 0 and mark or 0)
        else
            room:addPlayerMark(player, "@db_rzhz", 1)
            player:drawCards(player:getMark("@db_rzhz"), self.name)
            table.removeOne(mark, target.id)
            room:setPlayerMark(player, "sw_shiyun_mark", #mark > 0 and mark or 0)
        end
    end,
}
local sw_shiyun_sk = fk.CreateTargetModSkill {
    name = "#sw_shiyun_sk",
    residue_func = function(self, player, skill, scope, card)
        if card and player:hasSkill("sw_shiyun") and card.trueName == "slash" and scope == Player.HistoryPhase then
            return player:getMark("@db_rzhz")
        end
    end
}
local sw_shiyun_maxcards = fk.CreateMaxCardsSkill {
    name = "#sw_shiyun_maxcards",
    correct_func = function(self, player)
        if player:hasSkill(self.name) then
            return player:getMark("@db_rzhz")
        else
            return 0
        end
    end,
}
sw_shiyun:addRelatedSkill(sw_shiyun_maxcards)
sw_shiyun:addRelatedSkill(sw_shiyun_sk)
dabei:addSkill(sw_shiyun)
Fk:loadTranslationTable {
    ["sw_shiyun"] = "时运",
    [":sw_shiyun"] = "锁定技，①当你的【杀】造成伤害后，获得一层『熔烛化紫』；" ..
        "<br>②当你参与击杀后，获得一层『熔烛化紫』，摸X张牌" ..
        "<br>③你出牌阶段可使用【杀】的次数和手牌上限+X(X为『熔烛化紫』的层数)；",

    ["@db_rzhz"] = "熔烛化紫",
    ["$sw_shiyun1"] = "当虚空初次触碰实在，一切便从此改变",
    ["$sw_shiyun2"] = "自我降生那刻，我们的胜利就已注定",
    ["$sw_shiyun3"] = "我的符文之地，将成为至美",
    ["$sw_shiyun4"] = "时间尽头，只有一片淡紫色的汪洋",
}
local sw_jiliu = fk.CreateActiveSkill {
    name = "sw_jiliu",
    anim_type = "offensive",
    card_num = 0,
    target_num = 1,
    can_use = function(self, player)
        local x = math.min(player:getMark("@db_rzhz"), 3)
        return player:usedSkillTimes(self.name, Player.HistoryPhase) < 1 + x
    end,
    card_filter = function(self, to_select, selected)
        return false
    end,
    target_filter = function(self, to_select, selected, _)
        local target = Fk:currentRoom():getPlayerById(to_select)
        return target:getMark("jiliufix-turn") == 0 and Self:distanceTo(target) == 1
    end,
    on_use = function(self, room, effect)
        local target = room:getPlayerById(effect.tos[1])
        room:damage({
            from = room:getPlayerById(effect.from),
            to = target,
            damage = 1,
            damageType = fk.NormalDamage,
            skillName = self.name,
        })
        room:setPlayerMark(target, "jiliufix-turn", 1)
    end,
}
local sw_jiliu_trigger = fk.CreateTriggerSkill {
    name = "#sw_jiliu_trigger",
    anim_type = "offensive",
    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 target:getMark("jiliufix-turn") > 1
    end,
    on_use = function(self, event, target, player, data)
        local room = player.room
        room:addPlayerMark(target, "@sw_jiliu_buff-turn", 1)
        if target:getMark("@sw_jiliu_buff-turn") == 3 then
            room:setPlayerMark(target, "@sw_jiliu_buff-turn", 0)
            target:turnOver()
        end
    end,
}
sw_jiliu:addRelatedSkill(sw_jiliu_trigger)
dabei:addSkill(sw_jiliu)
Fk:loadTranslationTable {
    ["sw_jiliu"] = "激流",
    [":sw_jiliu"] = "出牌阶段限X次，你可以选择与你距离为1且未以此法选择过的角色，对其造成一点伤害并<u>贯穿</u>(X为1+『熔烛化紫』的层数且至多为4)" ..
        "<br/><font color='grey'>#\"<b>贯穿</b>\"：被贯穿的角色本回合使用或打出【闪】的次数大于2时，其翻面。",

    ["#sw_jiliu_trigger"] = "激流",
    ["@sw_jiliu_buff-turn"] = "激流",

    ["$sw_jiliu1"] = "你无处躲藏",
    ["$sw_jiliu2"] = "我已超越你的存在",
    ["$sw_jiliu3"] = "你引起了我的兴趣",
    ["$sw_jiliu4"] = "露出你的本性吧",
}
local sw_haoyan = fk.CreateTriggerSkill {
    name = "sw_haoyan",
    anim_type = "drawcard",
    frequency = Skill.Wake,
    events = { fk.Deathed },
    can_trigger = function(self, event, target, player, data)
        return player:hasSkill(self) and data.damage and data.damage.from == player and
            player:usedSkillTimes(self.name, Player.HistoryGame) == 0
    end,
    can_wake = function(self, event, target, player, data)
        return player:getMark("@db_rzhz") ~= 0
    end,
    on_use = function(self, event, target, player, data)
        local room = player.room
        player.general = "sw__dabeiex"
        room:broadcastProperty(player, "general")
        room:changeMaxHp(player, 1)
        room:recover {
            who = player,
            num = 1,
            recoverBy = player,
            skillName = self.name
        }
        room:handleAddLoseSkills(player, "sw_jianyuan", nil, true, false)
    end,
}
dabei:addSkill(sw_haoyan)
Fk:loadTranslationTable {
    ["sw_haoyan"] = "豪筵",
    [":sw_haoyan"] = "觉醒技，当你杀死一名角色后，若你至少拥有一层『熔烛化紫』，变身为真实形态，增加一点体力上限，回复一点体力，获得〖觐渊〗",

    ["$sw_haoyan1"] = "我是，轰鸣的寂静。",
    ["$sw_haoyan2"] = "我们终会降临",
}
local sw_jianyuan = fk.CreateActiveSkill {
    name = "sw_jianyuan",
    card_num = 0,
    target_num = 0,
    interaction = function()
        local choices = {}
        for _, p in ipairs(Fk:currentRoom().players) do
            if p.dead and p.rest == 0 and p ~= Self and p.general ~= "sw__xky" then
                table.insert(choices, "#sw_jianyuan_revive:::seat#" .. p.seat .. ":" .. p.general)
            end
        end
        if #choices == 0 then return end
        return UI.ComboBox { choices = choices }
    end,
    card_filter = Util.FalseFunc,
    can_use = function(self, player)
        return table.find(Fk:currentRoom().players, function(p)
            return p.dead and p.general ~= "sw__xky" and p.rest == 0 and p ~= player
        end)
    end,
    on_use = function(self, room, effect)
        local player = room:getPlayerById(effect.from)
        local seat = tonumber(string.sub(self.interaction.data:split(":")[4], 6))
        local p = table.find(room.players, function(p) return p.seat == seat end)
        if not p then return end
        room:doIndicate(player.id, { p.id })
        room:changeHero(p, "", false, true, false)
        room:changeHero(p, "sw__xky", false, false, true)
        room:revivePlayer(p, true, self.name)
        p.role = "unknown"
        room:notifyProperty(p, p, "role")
        room:broadcastProperty(p, "role")
        p:drawCards(2, self.name)
    end,
}
dabei:addRelatedSkill(sw_jianyuan)
Fk:loadTranslationTable {
    ["sw_jianyuan"] = "觐渊",
    [":sw_jianyuan"] = "出牌阶段，你可以将一名未以此法复活且已死亡的角色复活为虚空鱼" ..
        "<br/><font color='grey'>#\"<b>虚空鱼</b>\"：拥有两点体力和上限，摸两张牌，死亡时，为卑尔维斯提供一层『熔烛化紫』并令其摸两张牌",

    ["#sw_jianyuan_revive"] = "复活 %arg(%arg2)",

    ["$sw_jianyuan1"] = "在我们之下，一座磅礴的城市正在滋生，那是我的城市",
    ["$sw_jianyuan2"] = "我们将吞噬你，再成为你",
}
local xky = General(extension, "sw__xky", "xk", 2, 2)
xky.total_hidden = true
local sw_haoling = fk.CreateTriggerSkill {
    name = "sw_haoling",
    anim_type = "offensive",
    frequency = Skill.Compulsory,
    events = { fk.DamageCaused, fk.Death, fk.BuryVictim },
    can_trigger = function(self, event, target, player, data)
        if event == fk.DamageCaused then
            return target == player and player:hasSkill(self) and
                (data.to.general == "sw__dabei" or data.to.deputyGeneral == "sw__dabei" or data.to.general == "sw__dabeiex" or data.to.deputyGeneral == "sw__dabeiex")
        elseif event == fk.Death then
            return target == player and player:hasSkill(self.name, false, true)
        else
            return player:hasSkill(self, false, true) and not player.room:getTag("SkipNormalDeathProcess")
        end
    end,
    on_use = function(self, event, target, player, data)
        local room = player.room
        if event == fk.DamageCaused then
            return true
        elseif event == fk.Death then
            for _, p in ipairs(room.alive_players) do
                if (string.find(p.general, "sw__dabei") or string.find(p.general, "sw__dabeiex") or string.find(p.deputyGeneral, "sw__dabei") or string.find(p.deputyGeneral, "sw__dabeiex")) and not p.dead then
                    p:drawCards(2)
                    room:addPlayerMark(p, "@db_rzhz", 1)
                end
            end
        else
            player.room:setTag("SkipNormalDeathProcess", true)
            player.room:setTag(self.name, true)
        end
    end,

    refresh_events = { fk.Deathed },
    can_refresh = function(self, event, target, player, data)
        return target == player and player.room:getTag(self.name)
    end,
    on_refresh = function(self, event, target, player, data)
        player.room:setTag("SkipNormalDeathProcess", false)
        player.room:setTag(self.name, false)
    end,
}

xky:addSkill(sw_haoling)
Fk:loadTranslationTable {
    ["sw__xky"] = "虚空鱼",
    ["sw_haoling"] = "号令",
    [":sw_haoling"] = "锁定技，你无法对卑尔维斯造成伤害；你死亡时，令卑尔维斯增加一层『熔烛化紫』并摸两张牌；杀死你的角色，不执行身份奖惩",
}

local kazike = General(extension, "sw__kazike", "xk", 3, 3)
kazike.shield = 1
Fk:loadTranslationTable {
    ["sw__kazike"] = "卡兹克",
}
local doLieShi = function(player)
    local room = player.room
    local SkillName = "sw_lieshi"
    local chc = { "lieshi_qxjuli", "lieshi_czyueji", "lieshi_shanghai+", "lieshi_wxguli" }
    for name, _ in pairs(player.mark) do
        if table.contains(chc, name) then
            table.removeOne(chc, name)
        end
    end
    if #chc > 0 then
        player:broadcastSkillInvoke("sw_lieshi", math.random(1, 2))
        room:notifySkillInvoked(player, "sw_lieshi", "offensive")
        local chs = room:askForChoice(player, chc, SkillName)
        if chs == "lieshi_czyueji" or chs == "lieshi_qxjuli" then
            player:setSkillUseHistory("sw_yuejit", 0, Player.HistoryPhase)
        end
        table.removeOne(chc, chs)
        room:setPlayerMark(player, chs, 1)
    else
        player:drawCards(2, SkillName)
    end
end
local sw_yuejit = fk.CreateActiveSkill {
    name = "sw_yuejit",
    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 = Util.FalseFunc,
    target_filter = function(self, to_select, selected)
        if Self:getMark("lieshi_qxjuli") == 0 then
            local target = Fk:currentRoom():getPlayerById(to_select)
            return #selected == 0 and Self:inMyAttackRange(target)
        else
            return #selected == 0 and to_select ~= Self.id
        end
    end,
    on_use = function(self, room, effect)
        local player = room:getPlayerById(effect.from)
        local target = room:getPlayerById(effect.tos[1])
        for _, p in ipairs(room.alive_players) do
            if p.id ~= player.id and target:getNextAlive() == p then
                room:setPlayerMark(p, "sw_yuejit-phase", 1)
                room:swapSeat(player, p)
            end
        end
        if player:getMark("lieshi_czyueji") == 0 then
            room:useVirtualCard("slash", nil, player, target, self.name, true)
        else
            room:useVirtualCard("stab__slash", nil, player, target, self.name, true)
        end
    end,
}
local sw_yuejit_tar = fk.CreateTriggerSkill {
    name = "#sw_yuejit_tar",
    mute = true,
    events = { fk.EventPhaseEnd, fk.Deathed },
    frequency = Skill.Compulsory,
    can_trigger = function(self, event, target, player, data)
        if event == fk.EventPhaseEnd then
            return target == player and player:hasSkill(self.name) and player.phase == Player.Play and
                table.find(player.room.alive_players, function(p)
                    return p:getMark("sw_yuejit-phase") > 0
                end)
        else
            return player:hasSkill(self) and data.damage and data.damage.from == player and
                player:getMark("lieshi_czyueji") > 0
        end
    end,
    on_use = function(self, event, target, player, data)
        local room = player.room
        local mark = U.getMark(player, "sw_lieshi_mark")
        if event == fk.EventPhaseEnd then
            for _, p in ipairs(room.alive_players) do
                if p:getMark("sw_yuejit-phase") > 0 then
                    room:swapSeat(player, p)
                    room:setPlayerMark(p, "sw_yuejit-phase", 0)
                end
            end
        else
            player:setSkillUseHistory("sw_yuejit", 0, Player.HistoryPhase)
        end
    end,
}
sw_yuejit:addRelatedSkill(sw_yuejit_tar)
kazike:addSkill(sw_yuejit)
Fk:loadTranslationTable {
    ["sw_yuejit"] = "跃击",
    ["#sw_yuejit_tar"] = "跃击",
    ["#sw_yueji_jh"] = "跃击",
    [":sw_yuejit"] = "出牌阶段限一次，你可以选择攻击范围内的一名其他角色，跳跃至其下家并视为对其使用一张【杀】，当你选择选择进化〖跃击〗时，立刻重置使用次数；出牌阶段结束时，若与你交换位置的角色存活，你回到原位。",
}
local sw_qinxi = fk.CreateTriggerSkill {
    name = "sw_qinxi",
    anim_type = "control",
    frequency = Skill.Compulsory,
    events = { fk.TargetSpecifying, fk.DamageCaused },
    can_trigger = function(self, event, target, player, data)
        local room = player.room
        if not player:hasSkill(self) then return false end
        if event == fk.TargetSpecifying then
            local to = room:getPlayerById(data.tos[1][1])
            if target == player and #AimGroup:getAllTargets(data.tos) == 1 and data.to ~= player.id and to:getMark("@@guliwuyuan-turn") == 0 then
                if player:getMark("lieshi_wxguli") == 0 then
                    local n = 0
                    for _, p in ipairs(room.alive_players) do
                        if p:getNextAlive() == to then
                            if p.kingdom ~= to.kingdom then
                                n = n + 1
                                for _, p2 in ipairs(room.alive_players) do
                                    if to:getNextAlive() == p2 then
                                        if p2.kingdom ~= to.kingdom then
                                            n = n + 1
                                        end
                                    end
                                end
                            end
                        end
                    end
                    return n == 2
                else
                    return true
                end
            end
        else
            return target == player and player:getMark("lieshi_shanghai+") > 0 and
                data.to:getMark("@@guliwuyuan-turn") > 0
        end
    end,
    on_use = function(self, event, target, player, data)
        local room = player.room
        if event == fk.TargetSpecifying then
            local to = room:getPlayerById(data.tos[1][1])
            room:addPlayerMark(to, MarkEnum.UncompulsoryInvalidity .. "-turn")
            room:setPlayerMark(to, "@@guliwuyuan-turn", 1)
        else
            data.damage = data.damage + 1
        end
    end,
}
local sw_qinxi_prohibit = fk.CreateProhibitSkill {
    name = "#sw_qinxi_prohibit",
    prohibit_use = function(self, player, card)
        return player:getMark("@@guliwuyuan-turn") > 0
    end,
    prohibit_response = function(self, player, card)
        return player:getMark("@@guliwuyuan-turn") > 0
    end,
}
sw_qinxi:addRelatedSkill(sw_qinxi_prohibit)
kazike:addSkill(sw_qinxi)
Fk:loadTranslationTable {
    ["sw_qinxi"] = "侵袭",
    ["@@guliwuyuan-turn"] = "孤立无援",
    [":sw_qinxi"] = "锁定技，当你使用牌指定唯一其他目标时，若其上家与下家的势力与其均不相同，其进入『孤立无援』状态。<br>" ..
        "<font color='red'>『孤立无援』：其无法使用或打出手牌且非锁定技失效直到回合结束",
}

local sw_lieshi = fk.CreateTriggerSkill {
    name = "sw_lieshi",
    mute = true,
    anim_type = "offensive",
    frequency = Skill.Compulsory,
    events = { fk.Damage, fk.Death, fk.Deathed },
    can_trigger = function(self, event, target, player, data)
        if not player:hasSkill(self) then return false end
        if event == fk.Damage then
            return target == player and data.to ~= player and
                not table.contains(U.getMark(player, "sw_lieshi_mark"), data.to.id)
        elseif event == fk.Death then
            return table.contains(U.getMark(player, "sw_lieshi_mark"), target.id) and
                (not data.damage or (data.damage and data.damage.from ~= player))
        else
            return data.damage and data.damage.from == player
        end
    end,
    on_use = function(self, event, target, player, data)
        local room = player.room
        local mark = U.getMark(player, "sw_lieshi_mark")
        if event == fk.Damage then
            table.insert(mark, data.to.id)
            room:setPlayerMark(player, "sw_lieshi_mark", #mark > 0 and mark or 0)
        else
            table.removeOne(mark, target.id)
            room:setPlayerMark(player, "sw_lieshi_mark", #mark > 0 and mark or 0)
            doLieShi(player)
        end
    end,
}

kazike:addSkill(sw_lieshi)
Fk:loadTranslationTable {
    ["sw_lieshi"] = "猎食",
    [":sw_lieshi"] = "锁定技，当你参与击杀或击杀一名角色后，你可以〖进化〗一次技能，每次进化为你的技能添加额外效果，若均已进化，你摸两张牌。<br>" ..
        "<font color='red'>【进化】你选择一项：<br>1.取消〖跃击〗的距离限制；<br>2.发动〖跃击〗后使用刺【杀】且击杀重置；<br>3.你对『孤立无援』目标造成的伤害+1；<br>4.取消〖侵袭〗的条件限制",

    ["lieshi_qxjuli"] = "取消〖跃击〗的距离限制",
    ["lieshi_czyueji"] = "发动〖跃击〗后使用刺【杀】且击杀重置",
    ["lieshi_shanghai+"] = "你对『孤立无援』目标造成的伤害+1",
    ["lieshi_wxguli"] = "取消〖侵袭〗的条件限制",
}
local jiakesi = General(extension, "sw__jiakesi", "xk", 4, 4)
Fk:loadTranslationTable {
    ["sw__jiakesi"] = "贾克斯",
    ["~sw__jiakesi"] = "(语气)....",
}
local sw_tiaozhan = fk.CreateActiveSkill {
    name = "sw_tiaozhan",
    anim_type = "offensive",
    card_num = 0,
    target_num = 1,
    prompt = "#sw_tiaozhan-choose",
    can_use = function(self, player)
        local room = Fk:currentRoom()
        local n = 0
        for _, p in ipairs(room.alive_players) do
            if p.kingdom == "xk" then
                n = n + 1
            end
        end
        return player:usedSkillTimes(self.name, Player.HistoryPhase) < n
    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 to_select ~= Self.id and
            not Self:isProhibited(target, Fk:cloneCard("slash")) and
            (Self:inMyAttackRange(target) or target.kingdom == "xk")
    end,
    on_use = function(self, room, effect)
        local player = room:getPlayerById(effect.from)
        local target = room:getPlayerById(effect.tos[1])
        local slash = Fk:cloneCard("slash")
        slash.skillName = self.name
        local use = { from = player.id, tos = { { target.id } }, card = slash, extraUse = true }
        room:useCard(use)
        if use.damageDealt then
            local tricks = table.filter(player:getCardIds(Player.Hand),
                function(cid)
                    return (Fk:getCardById(cid):isCommonTrick() or Fk:getCardById(cid).type == Card.TypeBasic or
                        Fk:getCardById(cid).type == Card.TypeEquip) and not Fk:getCardById(cid).multiple_targets
                end)
            U.askForUseRealCard(room, player, tricks, nil, self.name, "#sw_tiaozhan-use:" .. target.id,
                { exclusive_targets = { target.id }, bypass_distances = true, bypass_times = true })
        end
    end,
}
jiakesi:addSkill(sw_tiaozhan)
Fk:loadTranslationTable {
    ["sw_tiaozhan"] = "跳斩",
    [":sw_tiaozhan"] = "出牌阶段限X次，你可以视为对一名虚空势力角色或你攻击范围内的一名角色使用一张【杀】，若此【杀】造成伤害，你可以使用一张目标仅为你或该角色的非延时牌，此牌无次数限制(X为存活的虚空势力数)",

    ["#sw_tiaozhan-choose"] = "跳斩：请选择一名虚空势力角色，或攻击范围内的一名角色",
    ["#sw_tiaozhan-use"] = "跳斩：是否对 %src 使用一张牌",
    ["$sw_tiaozhan1"] = "我不管你从哪来到哪去，我只问你，你能打吗？",
    ["$sw_tiaozhan2"] = "管你是什么东西，都不在话下！",
    ["$sw_tiaozhan3"] = "喂，就用这盏灯，点亮你的火种",
}
local sw_fanji = fk.CreateTriggerSkill {
    name = "sw_fanji",
    anim_type = "offensive",
    events = { fk.EventPhaseEnd, fk.EventPhaseStart },
    can_trigger = function(self, event, target, player, data)
        if not player:hasSkill(self) then return false end
        if event == fk.EventPhaseEnd then
            return target == player and player.phase == Player.Finish and not player:isKongcheng()
        elseif player.phase == Player.Start then
            return target == player and player.phase == Player.Start and player:getMark("@@sw_fanji") > 0
        end
    end,
    on_cost = function(self, event, target, player, data)
        if event == fk.EventPhaseEnd then
            return player.room:askForSkillInvoke(player, self.name, nil, "#fanji_dsicard-ask")
        else
            return true
        end
    end,
    on_use = function(self, event, target, player, data)
        local room = player.room
        if event == fk.EventPhaseEnd then
            local cid = player.player_cards[Player.Hand]
            local discard = table.filter(table.map(cid, Util.Id2CardMapper), function(id)
                return id.is_damage_card
            end)
            player:showCards(discard)
            for _, id in ipairs(discard) do
                room:setCardMark(id, "@@sw_fanji", 1)
            end
            room:throwCard(table.map(discard, Util.IdMapper), self.name, player, player)
            room:setPlayerMark(player, "@@sw_fanji", 1)
        else
            room:setPlayerMark(player, "@@sw_fanji", 0)
            local cards = table.filter(room.discard_pile, function(id)
                return Fk:getCardById(id):getMark("@@sw_fanji") ~= 0
            end)
            if #cards > 0 then
                if player:getMark("fanji_true") == 0 then
                    room:moveCardTo(cards, Card.PlayerHand, player, fk.ReasonPrey, self.name, nil, true, player.id)
                    for _, id in ipairs(cards) do
                        room:setCardMark(Fk:getCardById(id), "@@sw_fanji", 0)
                    end
                else
                    for _, id in ipairs(cards) do
                        room:setCardMark(Fk:getCardById(id), "@@sw_fanji", 0)
                    end
                end
                room:setPlayerMark(player, "fanji_true", 0)
            end
        end
    end,
}
local sw_fanji_trigger = fk.CreateTriggerSkill {
    name = "#sw_fanji_trigger",
    anim_type = "drawcard",
    events = { fk.TargetConfirmed },
    can_trigger = function(self, event, target, player, data)
        return target == player and player:getMark("@@sw_fanji") > 0 and player.room:getPlayerById(data.from) ~= player and
            player:usedSkillTimes(self.name, Player.HistoryTurn) == 0
    end,
    on_cost = function(self, event, target, player, data)
        local from = player.room:getPlayerById(data.from)
        return player.room:askForSkillInvoke(player, self.name, nil, "#fanji_dule-ask:" .. from.id)
    end,
    on_use = function(self, event, target, player, data)
        local room = player.room
        local from = player.room:getPlayerById(data.from)
        room:useVirtualCard("slash", nil, player, from, self.name, true)
        room:setPlayerMark(player, "fanji_true", 1)
    end,
}
sw_fanji:addRelatedSkill(sw_fanji_trigger)
jiakesi:addSkill(sw_fanji)
Fk:loadTranslationTable {
    ["sw_fanji"] = "反击",
    ["#sw_fanji_trigger"] = "反击",
    [":sw_fanji"] = "结束阶段，若你有牌，你可以弃置所有伤害牌，激活『反击风暴』；准备阶段，若你未触发过反击，你从弃牌堆回收上回合因此技能弃置的所有牌" ..
        "<br/><font color='grey'>#\"<b>反击风暴</b>\"：每回合限一次，当你成为其他角色使用牌的目标后，你可以视为对其使用一张【杀】",

    ["@@sw_fanji"] = "反击风暴",
    ["#fanji_dule-ask"] = "反击：是否对 %src 使用一张【杀】",
    ["#fanji_dsicard-ask"] = "反击：是否弃置所有伤害牌，激活『反击风暴』",

    ["$sw_fanji1"] = "不错，差点就能抓伤我了",
    ["$sw_fanji2"] = "你就这点本事？",
    ["$sw_fanji3"] = "就没人敢管我么？嗯？",
}
local sw_zongshi = fk.CreateActiveSkill {
    name = "sw_zongshi",
    prompt = "#sw_zongshi-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)
        local player = room:getPlayerById(effect.from)
        room:changeShield(player, 1)
        room:recover {
            who = player,
            num = 1,
            recoverBy = player,
            skillName = self.name
        }
        room:setPlayerMark(player, "@@sw_zongshi-round", 1)
    end,
}
local sw_zongshi_trigger = fk.CreateTriggerSkill {
    name = "#sw_zongshi_trigger",
    mute = true,
    frequency = Skill.Compulsory,
    events = { fk.CardUsing },
    can_trigger = function(self, event, target, player, data)
        return target == player and player:hasSkill("sw_zongshi")
    end,
    on_use = function(self, event, target, player, data)
        local room = player.room
        room:addPlayerMark(player, "@sw_zongshi")
        local trigger
        if player:getMark("@@sw_zongshi-round") == 0 then
            if player:getMark("@sw_zongshi") > 2 then
                trigger = 1
            end
        else
            if player:getMark("@sw_zongshi") > 1 then
                trigger = 1
            end
        end
        if trigger == 1 then
            player:broadcastSkillInvoke("sw_zongshi", -1)
            room:notifySkillInvoked(player, "sw_zongshi", "support")
            if data.card.is_damage_card then
                data.additionalDamage = (data.additionalDamage or 0) + 1
            elseif data.card.name == "peach" or (data.card.name == "analeptic" and data.extra_data and data.extra_data.analepticRecover) then
                data.additionalRecover = (data.additionalRecover or 0) + 1
            end
            if data.card.trueName == "slash" and data.extra_data and data.extra_data.drankBuff then
                data.additionalDamage = (data.additionalDamage or 0) + data.extra_data.drankBuff
            end
            room:setPlayerMark(player, "@sw_zongshi", 0)
        end
    end,
}
local sw_zongshiMax = fk.CreateMaxCardsSkill {
    name = "#sw_zongshiMax",
    exclude_from = function(self, player, card)
        return player:hasSkill("sw_zongshi") and card.is_damage_card
    end,
}
sw_zongshi:addRelatedSkill(sw_zongshi_trigger)
sw_zongshi:addRelatedSkill(sw_zongshiMax)
jiakesi:addSkill(sw_zongshi)
Fk:loadTranslationTable {
    ["sw_zongshi"] = "宗师",
    ["#sw_zongshi_trigger"] = "宗师",
    [":sw_zongshi"] = "限定技，出牌阶段，获得一点护甲，回复一点体力，本回合将此技能的被动改为每两张；锁定技，你的伤害类卡牌不计入手牌上限，你每使用或打出的第三张牌，此牌伤害或回复值+1",

    ["@sw_zongshi"] = "宗师",
    ["@@sw_zongshi-round"] = "宗师之威",
    ["#sw_zongshi-active"] = "宗师：是否获得一点护甲，回复一点体力，本回合将此技能的被动改为每两张",

    ["$sw_zongshi1"] = "常胜不败！",
    ["$sw_zongshi2"] = "把全部本事都拿出来！",
    ["$sw_zongshi3"] = "站起来！打到底！",
}
local leikesai = General(extension, "sw__leikesai", "xk", 2, 4, General.Female)
leikesai.shield = 3
Fk:loadTranslationTable {
    ["sw__leikesai"] = "雷克塞",
}
local sw_zhennu = fk.CreateTriggerSkill {
    name = "sw_zhennu",
    events = { fk.CardUsing },
    frequency = Skill.Compulsory,
    anim_type = "offensive",
    can_trigger = function(self, event, target, player, data)
        if player:hasSkill(self.name) and data.card.trueName == "slash" and player:getMark("@sw_zhennu") < 100 then
            return data.card and ((target ~= player and target:inMyAttackRange(player)) or target == player)
        end
    end,
    on_use = function(self, event, target, player, data)
        local room = player.room
        if player:getMark("@sw_zhennu") < 100 then
            room:addPlayerMark(player, "@sw_zhennu", 10)
        end
    end,

    refresh_events = { fk.Damage },
    can_refresh = function(self, event, target, player, data)
        return player:hasSkill(self) and target == player and (data.card or not data.card) and
            data.skillName ~= "sw_shiyao"
    end,
    on_refresh = function(self, event, target, player, data)
        local room = player.room
        room:setPlayerMark(data.to, "@@sw_xunlies-turn", 1)
        if data.card and data.card.trueName == "slash" then
            room:addPlayerMark(player, "sw_xunlie_slash", 1)
            if player:getMark("@sw_zhennu") < 100 then
                room:addPlayerMark(player, "@sw_zhennu", math.min(30, 100 - player:getMark("@sw_zhennu")))
            end
        elseif (data.card or not data.card) then
            if player:getMark("@sw_zhennu") < 100 then
                room:addPlayerMark(player, "@sw_zhennu", math.min(20, 100 - player:getMark("@sw_zhennu")))
            end
        end
    end,
}
local sw_zhennu_maxcards = fk.CreateMaxCardsSkill {
    name = "#sw_zhennu_maxcards",
    frequency = Skill.Compulsory,
    fixed_func = function(self, player)
        if player:hasSkill(self) then
            return player.maxHp
        end
    end
}
sw_zhennu:addRelatedSkill(sw_zhennu_maxcards)
leikesai:addSkill(sw_zhennu)
Fk:loadTranslationTable {
    ["sw_zhennu"] = "震怒",
    [":sw_zhennu"] = "锁定技<br>①当你或攻击范围内含有你的角色使用【杀】时，你获得10点『怒气』；<br>②当你不因〖噬咬〗造成伤害后，" ..
        "你获得20点『怒气』，若造成伤害的牌是【杀】，额外获得10点(怒气上限100点)；<br>③你的手牌上限等于体力上限。<br>",

    ["@sw_zhennu"] = "怒气",
}
local sw_shiyao = fk.CreateActiveSkill {
    name = "sw_shiyao",
    anim_type = "offensive",
    card_num = 0,
    target_num = 1,
    prompt = "#sw_shiyao-choose",
    can_use = function(self, player)
        return player:getMark("@sw_zhennu") >= 50
    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])
        if player:getMark("@sw_zhennu") < 100 then
            room:damage({
                from = player,
                to = target,
                damage = 1,
                damageType = fk.NormalDamage,
                skillName = self.name,
            })
            room:removePlayerMark(player, "@sw_zhennu", 50)
        elseif player:getMark("@sw_zhennu") == 100 then
            room:damage({
                from = player,
                to = target,
                damage = 1 + target:getLostHp(),
                damageType = fk.NormalDamage,
                skillName = self.name,
            })
            room:removePlayerMark(player, "@sw_zhennu", 100)
        end
    end
}
leikesai:addSkill(sw_shiyao)
Fk:loadTranslationTable {
    ["sw_shiyao"] = "噬咬",
    [":sw_shiyao"] = "出牌阶段，若你拥有至少50点『怒气』，你可以消耗50点『怒气』对一名攻击范围内的角色造成一点伤害，" ..
        "若你拥有100点『怒气』，本次伤害额外追加目标已损失体力值的伤害，然后失去所有『怒气』。<br>",

    ["#sw_shiyao-choose"] = "噬咬：选择一名其他角色，根据怒气值，你可以对其造成伤害",
}
local sw_qiandun = fk.CreateTriggerSkill {
    name = "sw_qiandun",
    events = { fk.TurnEnd, fk.EventPhaseChanging },
    anim_type = "offensive",
    can_trigger = function(self, event, target, player, data)
        if event == fk.TurnEnd then
            if player:hasSkill(self.name) and player:getMark("@sw_zhennu") >= 20 then
                return target == player and player:isWounded()
            end
        else
            return player:hasSkill(self.name) and player:getMark("@@sw_qiandun") ~= 0 and data.to == Player.Start
        end
    end,
    on_cost = function(self, event, target, player, data)
        if event == fk.TurnEnd then
            return player.room:askForSkillInvoke(player, self.name, nil, "潜遁：是否进入遁地状态")
        else
            return true
        end
    end,
    on_use = function(self, event, target, player, data)
        local room = player.room
        if event == fk.TurnEnd then
            room:setPlayerMark(player, "@@sw_qiandun", 1)
        else
            room:removePlayerMark(player, "@sw_zhennu", 20)
            room:recover({
                who = player,
                num = 1,
                recoverBy = player,
                skillName = self.name
            })
            if not player:isWounded() or player:getMark("@sw_zhennu") < 20 then
                room:setPlayerMark(player, "@@sw_qiandun", 0)
            end
        end
    end,

    refresh_events = { fk.TurnStart },
    can_refresh = function(self, event, target, player, data)
        return target == player and player:getMark("@@sw_qiandun") ~= 0
    end,
    on_refresh = function(self, event, target, player, data)
        player.room:setPlayerMark(player, "@@sw_qiandun", 0)
    end,
}
local sw_qiandun_prohibit = fk.CreateProhibitSkill {
    name = "#sw_qiandun_prohibit",
    prohibit_use = function(self, player, card)
        return player:getMark("@@sw_qiandun") > 0
    end,
}
sw_qiandun:addRelatedSkill(sw_qiandun_prohibit)
leikesai:addSkill(sw_qiandun)
Fk:loadTranslationTable {
    ["sw_qiandun"] = "潜遁",
    [":sw_qiandun"] = "你的回合结束时，若你至少拥有20点『怒气』，你可以进入遁地状态，此状态下无法使用牌，" ..
        "每回合开始时消耗20点『怒气』回复一点体力(『怒气』不足20，体力值回复至上限或准备阶段，移去此状态)。<br>",

    ["@@sw_qiandun"] = "遁地",
}
local sw_xunlies = fk.CreateActiveSkill {
    name = "sw_xunlies",
    anim_type = "offensive",
    card_num = 0,
    target_num = 1,
    frequency = Skill.Limited,
    can_use = function(self, player)
        return player:usedSkillTimes(self.name, Player.HistoryGame) == 0 and player:getMark("sw_xunlie_slash") > 0
    end,
    card_filter = Util.FalseFunc,
    target_filter = function(self, to_select, selected)
        local target = Fk:currentRoom():getPlayerById(to_select)
        return #selected == 0 and target:getMark("@@sw_xunlies-turn") > 0
    end,
    on_use = function(self, room, effect)
        local player = room:getPlayerById(effect.from)
        local target = room:getPlayerById(effect.tos[1])
        for _, p in ipairs(room.alive_players) do
            if p.id ~= player.id and target:getNextAlive() == p then
                room:setPlayerMark(p, "sw_xunlies-phase", 1)
                room:swapSeat(player, p)
            end
        end
        room:delay(500)
        room:damage({
            from = player,
            to = target,
            damage = math.min(player:getMark("sw_xunlie_slash"), target.maxHp),
            damageType = fk.NormalDamage,
            skillName = self.name,
        })
        room:delay(500)
        for _, p in ipairs(room.alive_players) do
            if p:getMark("sw_xunlies-phase") > 0 then
                room:swapSeat(player, p)
                room:setPlayerMark(p, "sw_xunlies-phase", 0)
            end
        end
    end,
}
leikesai:addSkill(sw_xunlies)
Fk:loadTranslationTable {
    ["sw_xunlies"] = "巡猎",
    [":sw_xunlies"] = "限定技，你可以选择一名本回合对其造成过伤害的其他角色，移动至其上家，对其造成X点伤害(X为你本局使用【杀】造成过的伤害总数，至多为其体力上限)，然后回到原位。<br>",

    ["@@sw_xunlies-turn"] = "可巡猎",

    ["$sw_xunlies1"] = "",
    ["$sw_xunlies2"] = "",
}
return extension