《太阳神三国杀》Lua武将自制：柯南包

龙一野

已于 2024-04-07 08:46:41 修改

阅读量60

点赞数

分类专栏： Lua 文章标签： lua

于 2022-11-21 22:05:53 首次发布

本文链接：https://blog.csdn.net/qq_49322638/article/details/127973594

版权

Lua 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

---@diagnostic disable: deprecated, lowercase-global, undefined-global
--创建武将包：柯南包
module("extensions.kenan", package.seeall)
extension = sgs.Package("kenan")

--创建武将：毛利兰
--（武将包，武将名称，国家，体力上限，性别）
maolilan = sgs.General(extension, "maolilan", "god", "3", false)

--距离技
--创建技能：影武
--技能描述：锁定技，你计算到其他角色的距离始终-1，其他角色计算到你的距离始终+1。
LuaYingwu = sgs.CreateDistanceSkill{
    name = "LuaYingwu",
    correct_func = function(self, from, to)
        if from:hasSkill("LuaYingwu") then
            return -1
        end
        if to:hasSkill("LuaYingwu") then
            return 1
        end
    end,
}

--手牌上限技
--创建技能：隐忍
--技能描述：锁定技，你的手牌上限为当前体力值的2倍。
LuaYinren = sgs.CreateMaxCardsSkill{
    name = "LuaYinren",
    extra_func = function(self, target)
        if target:hasSkill("LuaYinren") then
            local hp = target:getHp()
            return hp
        end
    end,
}

--禁止技
--创建技能：忍术
--技能描述：锁定技，你不能使用属性杀指定其他角色为目标，你不能成为无属性杀的目标。
LuaRenshu = sgs.CreateProhibitSkill{
    name = "LuaRenshu",
    is_prohibited = function(self, from, to, card)
        if from:hasSkill("LuaRenshu") and card:isKindOf("NatureSlash") then
            return true
        elseif to:hasSkill("LuaRenshu") and (card:isKindOf("Slash") and not card:isKindOf("NatureSlash")) then
            return true
        else
            return false
        end
    end,
}

--添加技能
maolilan:addSkill(LuaYingwu)
maolilan:addSkill(LuaYinren)
maolilan:addSkill(LuaRenshu)

--翻译语句
sgs.LoadTranslationTable{
    ["kenan"] = "柯南包",  --武将包名称
    ["maolilan"] = "毛利兰",  --武将名称
    ["LuaYingwu"] = "影武",  --技能名称
    [":LuaYingwu"] = "锁定技，你计算到其他角色的距离始终-1，其他角色计算到你的距离始终+1。",  --技能描述
    ["LuaYinren"] = "隐忍",
    [":LuaYinren"] = "锁定技，你的手牌上限为当前体力值的2倍。",
    ["LuaRenshu"] = "忍术",
    [":LuaRenshu"] = "锁定技，你不能使用属性杀指定其他角色为目标，你不能成为无属性杀的目标。",
}

--创建武将：朗姆
--（武将包，武将名称，国家，体力上限，性别）
langmu = sgs.General(extension, "langmu", "god", "4", true)

--触发技
--创建技能：膨胀
--技能描述：锁定技，当你造成伤害时，你失去1点体力。
LuaPengzhang = sgs.CreateTriggerSkill{
    name = "LuaPengzhang",
    frequency = sgs.Skill_Compulsory,
    events = {sgs.Damage},
    on_trigger = function(self, event, player, data)
        local room = player:getRoom()
        room:loseHp(player)
    end,
}

--触发技
--创建技能：毁灭
--技能描述：锁定技，当你受到伤害时，你可以选择失去2点体力，令伤害来源弃置所有手牌和装备牌并翻面，同时其失去2点体力上限。
LuaHuimie = sgs.CreateTriggerSkill{
    name = "LuaHuimie",
    frequency = sgs.Skill_NotFrequent,
    events = {sgs.Damaged},
    on_trigger = function(self, event, player, data)
        local room = player:getRoom()
        if room:askForSkillInvoke(player, self:objectName(), data) then
            room:loseHp(player, 2)
            local damage = data:toDamage()
            local attacker = damage.from
            attacker:throwAllHandCardsAndEquips()
            attacker:turnOver()
            room:loseMaxHp(attacker, 2)

        end
    end,
}

--添加技能
langmu:addSkill(LuaPengzhang)
langmu:addSkill(LuaHuimie)

--翻译语句
sgs.LoadTranslationTable{
    ["langmu"] = "朗姆",  --武将名称
    ["LuaPengzhang"] = "膨胀",  --技能名称
    [":LuaPengzhang"] = "锁定技，当你造成伤害时，你失去1点体力。",  --技能描述
    ["LuaHuimie"] = "毁灭",
    [":LuaHuimie"] = "当你受到伤害时，你可以选择失去2点体力，令伤害来源弃置所有手牌和装备牌并翻面，同时其失去2点体力上限。",
}

--创建武将：灰原哀
--（武将包，武将名称，国家，体力上限，性别）
huiyuanai = sgs.General(extension, "huiyuanai", "god", "3", false)

--触发技
--创建技能：风魔
--技能描述：回合开始阶段，你可以选择1名其他角色，对其造成1点雷属性伤害，然后自己增加1点体力上限并回复1点体力。
LuaFengmo = sgs.CreateTriggerSkill{
    name = "LuaFengmo",
    frequency = sgs.Skill_NotFrequent,
    events = {sgs.EventPhaseStart},
    on_trigger = function(self, event, player, data)
        local room = player:getRoom()
        if player:getPhase() == sgs.Player_Start and room:askForSkillInvoke(player, self:objectName(), data) then
            local plist = room:getOtherPlayers(player)
            local victim = room:askForPlayerChosen(player, plist, self:objectName())
            local damage = sgs.DamageStruct()  --伤害结构体
            damage.from = player
            damage.to = victim
            damage.damage = 1
            damage.nature = sgs.DamageStruct_Thunder
            room:damage(damage)
            local count = player:getMaxHp()  --增加体力上限
            local mhp = sgs.QVariant()
            mhp:setValue(count+1)
            room:setPlayerProperty(player, "maxhp", mhp)
            local rec = sgs.RecoverStruct()  --回复结构体
            rec.who = player
            rec.recover = 1
            room:recover(player, rec)
        end
    end,
}

--触发技
--创建技能：备弹
--技能描述：摸牌阶段，你少摸1张牌。
LuaBeidan = sgs.CreateTriggerSkill{
    name = "LuaBeidan",
    frequency = sgs.Skill_Frequent,
    events = {sgs.DrawNCards},
    on_trigger = function(self, event, player, data)
        local room = player:getRoom()
        if room:askForSkillInvoke(player, self:objectName(), data) then
            local count = data:toInt()-1
            data:setValue(count)
        end
    end,
}

--添加技能
huiyuanai:addSkill(LuaFengmo)
huiyuanai:addSkill(LuaBeidan)

--翻译语句
sgs.LoadTranslationTable{
    ["huiyuanai"] = "灰原哀",  --武将名称
    ["LuaFengmo"] = "风魔",  --技能名称
    [":LuaFengmo"] = "回合开始阶段，你可以选择1名其他角色，对其造成1点雷属性伤害，然后自己增加1点体力上限并回复1点体力。",  --技能描述
    ["LuaBeidan"] = "备弹",
    [":LuaBeidan"] = "摸牌阶段，你少摸1张牌。",
}

--创建武将：世良真纯
--（武将包，武将名称，国家，体力上限，性别）
shiliangzc = sgs.General(extension, "shiliangzc", "god", "3", true)

--触发技
--创建技能：眩晕
--技能描述：任意角色出牌阶段开始前，你可以失去1点体力令其跳过出牌阶段。
LuaXuanyun = sgs.CreateTriggerSkill{
    name = "LuaXuanyun",
    frequency = sgs.Skill_NotFrequent,
    events = {sgs.EventPhaseChanging},
    on_trigger = function(self, event, player, data)
        local room = player:getRoom()
        local change = data:toPhaseChange()
        local phase = change.to
        local attacker = room:findPlayerBySkillName(self:objectName())  --技能发动者
        if player:objectName() == attacker:objectName() then return end  --自己伤害自己无效
        if phase == sgs.Player_Play and room:askForSkillInvoke(attacker, self:objectName(), data) then
            room:loseHp(attacker)
            player:skip(phase)  --技能承受者
        end
    end,
    can_trigger = function(self, target)
        return target:isAlive() and not target:isSkipped(sgs.Player_Play)  --技能发动要求
    end,
}

--触发技
--创建技能：维和
--技能描述：弃牌阶段结束后，你可以弃1张牌，进行1个额外出牌阶段。
LuaWeihe = sgs.CreateTriggerSkill{
    name = "LuaWeihe",
    frequency = sgs.Skill_NotFrequent,
    events = {sgs.EventPhaseChanging},
    on_trigger = function(self, event, player, data)
        local room = player:getRoom()
        local change = data:toPhaseChange()
        local lastphase = change.from
        if lastphase == sgs.Player_Discard and room:askForSkillInvoke(player, self:objectName(), data) then
            change.to = sgs.Player_Play
            data:setValue(change)
            room:sendCompulsoryTriggerLog(player, self:objectName())
            if not room:askForDiscard(player, self:objectName(), 1, 1, false, true, "@Wuren_card") then
                local cards = player:getCards("he")
                local c = cards:at(math.random(0, cards:length() - 1))
                room:throwCard(c, player)
            end
            player:insertPhase(sgs.Player_Play)
        end
    end,
}

--触发技
--创建技能：和维
--技能描述：回合结束时，若你没有手牌，则可以进行1个额外的回合。
LuaHewei = sgs.CreateTriggerSkill{
    name = "LuaHewei",
    frequency = sgs.Skill_NotFrequent,
    events = {sgs.EventPhaseEnd},
    on_trigger = function(self, event, player, data)
        local room = player:getRoom()
        local change = data:toPhaseChange()
        if player:getPhase() == sgs.Player_Finish and player:isKongcheng()
            and room:askForSkillInvoke(player, self:objectName(), data) then
                player:gainAnExtraTurn()
        end
    end,
}

--添加技能
shiliangzc:addSkill(LuaXuanyun)
shiliangzc:addSkill(LuaWeihe)
shiliangzc:addSkill(LuaHewei)

--翻译语句
sgs.LoadTranslationTable{
    ["shiliangzc"] = "世良真纯",  --武将名称
    ["LuaXuanyun"] = "眩晕",  --技能名称
    [":LuaXuanyun"] = "任意角色出牌阶段开始前，你可以失去1点体力令其跳过出牌阶段。",  --技能描述
    ["LuaWeihe"] = "维和",
    [":LuaWeihe"] = "弃牌阶段结束后，你可以弃1张牌，进行1个额外出牌阶段。",
    ["LuaHewei"] = "和维",
    [":LuaHewei"] = "回合结束时，若你没有手牌，则可以进行1个额外的回合。",
}

--创建武将：降谷零
--（武将包，武将名称，国家，体力上限，性别）
jiangguling = sgs.General(extension, "jiangguling", "god", "4", true)

--触发技
--创建技能：聚合
--技能描述：当你对其他角色造成伤害时，你可以获得其1张牌；当你受到其他角色伤害时，你可以弃置其1张牌。
LuaJuhe = sgs.CreateTriggerSkill{
    name = "LuaJuhe",
    frequency = sgs.Skill_NotFrequent,
    events = {sgs.Damage, sgs.Damaged},
    on_trigger = function(self, event, player, data)
        local room = player:getRoom()
        if event == sgs.Damage then
            local damage = data:toDamage()
            local attacker = damage.to
            if player:objectName() == attacker:objectName() then return end  --自己伤害自己无效
            if room:askForSkillInvoke(player, "LuaJuhe1", data) and not attacker:isNude() then
                local id = room:askForCardChosen(player, attacker, "he", self:objectName())  --h:手牌，e：装备牌，j判定区
                room:obtainCard(player, id, true)
            end
        end
        if event == sgs.Damaged then
            local damage = data:toDamage()
            local attacker = damage.from
            if player:objectName() == attacker:objectName() then return end  --自己伤害自己无效
            if room:askForSkillInvoke(player, "LuaJuhe2", data) and not attacker:isNude() then
                local id = room:askForCardChosen(player, attacker, "he", self:objectName())  --h:手牌，e：装备牌，j判定区
                room:throwCard(id, attacker, player)  --（牌，被害人，凶手）
            end
        end
    end,
}

--触发技
--创建技能：武装
--技能描述：回合开始阶段，如果你的装备区没有牌，则你可以选择场上任意1名其他角色，选择其装备区内的1张牌置入你的装备区。
LuaWuzhuang = sgs.CreateTriggerSkill{
    name = "LuaWuzhuang",
    frequency = sgs.Skill_NotFrequent,
    events = {sgs.EventPhaseStart},
    on_trigger = function(self, event, player, data)
        local room = player:getRoom()
        if player:getPhase() == sgs.Player_Start and not player:hasEquip()
        and room:askForSkillInvoke(player, self:objectName(), data) then
            local plist = room:getOtherPlayers(player)
            local victim = room:askForPlayerChosen(player, plist, self:objectName())
            local id = room:askForCardChosen(player, victim, "e", self:objectName())
            local card = sgs.Sanguosha:getCard(id)
            room:moveCardTo(card, player, sgs.Player_PlaceEquip)
        end
    end,
}

--添加技能
jiangguling:addSkill(LuaJuhe)
jiangguling:addSkill(LuaWuzhuang)

--翻译语句
sgs.LoadTranslationTable{
    ["jiangguling"] = "降谷零",  --武将名称
    ["LuaJuhe"] = "聚合",  --技能名称
    ["LuaJuhe1"] = "聚合（造成伤害）",
    ["LuaJuhe2"] = "聚合（受到伤害）",
    [":LuaJuhe"] = "当你对其他角色造成伤害时，你可以获得其1张牌；当你受到其他角色伤害时，你可以弃置其1张牌。",  --技能描述
    ["LuaWuzhuang"] = "武装",
    [":LuaWuzhuang"] = "回合开始阶段，如果你的装备区没有牌，则你可以选择场上任意1名角色，选择其装备区内的1张牌置入你的装备区。"
}

--创建武将：贝尔摩德
--（武将包，武将名称，国家，体力上限，性别）
beiermd = sgs.General(extension, "beiermd", "god", "3", true)

--主动视为技
--创建技能：神偷
--技能描述：出牌阶段，你可以将你的♣手牌当作【顺手牵羊】使用。
LuaShentou = sgs.CreateViewAsSkill{
    name = "LuaShentou",
    n = 1,  --手牌数量
    view_filter = function(self, selected, to_select)
        return to_select:getSuit() == sgs.Card_Club and not to_select:isEquipped()  --梅花且非装备牌
    end,
    view_as = function(self, cards)
        if #cards == 0 then return
        elseif #cards == 1 then
            local card = cards[1]
            local suit = card:getSuit()
            local point = card:getNumber()
            local id = card:getId()
            local vs_card = sgs.Sanguosha:cloneCard("snatch", suit, point)  --创建虚拟卡牌:顺手牵羊
            vs_card:addSubcard(id)
            vs_card:setSkillName(self:objectName())
            return vs_card
        end
    end,
}

--单牌视为技（特殊）
--创建技能：神拆
--技能描述：出牌阶段，你可以将你的♠2-9手牌当作【过河拆桥】使用。
LuaShenchai = sgs.CreateOneCardViewAsSkill{
    name = "LuaShenchai",
    filter_pattern = ".|spade|2~9|hand",  --牌名|花色|点数|牌类型
    view_as = function(self, originalCard)
        local suit = originalCard:getSuit()
        local point = originalCard:getNumber()
        local id = originalCard:getId()
        local vs_card = sgs.Sanguosha:cloneCard("dismantlement", suit, point)  --创建虚拟卡牌:过河拆桥
        vs_card:addSubcard(id)
        vs_card:setSkillName(self:objectName())
        return vs_card
    end,
}

--被动视为技
--创建技能：消散
--技能描述：出牌阶段，你可以将1张手牌当作【闪】使用。
LuaXiaosan = sgs.CreateViewAsSkill{
    name = "LuaXiaosan",
    n = 1,  --手牌数量
    view_filter = function(self, selected, to_select)
        return not to_select:isEquipped()
    end,
    view_as = function(self, cards)
        if #cards == 0 then return
        elseif #cards == 1 then
            local card = cards[1]
            local suit = card:getSuit()
            local point = card:getNumber()
            local id = card:getId()
            local vs_card = sgs.Sanguosha:cloneCard("jink", suit, point)  --创建虚拟卡牌:闪
            vs_card:addSubcard(id)
            vs_card:setSkillName(self:objectName())
            return vs_card
        end
    end,
    enabled_at_play = function(self, player)  --出牌阶段不可发动
        return false
    end,
    enabled_at_response = function(self, player, pattern)  --回合外阶段可被响应
        return pattern == "jink"
    end,
}

--锁定视为技
--创建技能：弥散
--技能描述：锁定技，你的♥手牌均视为【桃】。
LuaMisan = sgs.CreateFilterSkill{
    name = "LuaMisan",
    view_filter = function(self, to_select)
        return to_select:getSuit() == sgs.Card_Heart  --红桃
    end,
    view_as = function(self, card)
        local suit = card:getSuit()
        local point = card:getNumber()
        local id = card:getId()
        local peach = sgs.Sanguosha:cloneCard("peach", suit, point)  --创建虚拟卡牌:桃
        peach:setSkillName(self:objectName())
        local vs_card = sgs.Sanguosha:getWrappedCard(id)  --覆盖原始卡牌
        vs_card:takeOver(peach)
        return vs_card
    end,
}

--添加技能
beiermd:addSkill(LuaShentou)
beiermd:addSkill(LuaShenchai)
beiermd:addSkill(LuaXiaosan)
beiermd:addSkill(LuaMisan)

--翻译语句
sgs.LoadTranslationTable{
    ["beiermd"] = "贝尔摩德",  --武将名称
    ["LuaShentou"] = "神偷",  --技能名称
    [":LuaShentou"] = "出牌阶段，你可以将你的♣手牌当作【顺手牵羊】使用。",  --技能描述
    ["LuaShenchai"] = "神拆",
    [":LuaShenchai"] = "出牌阶段，你可以将你的♠2-9手牌当作【过河拆桥】使用。",
    ["LuaXiaosan"] = "消散",
    [":LuaXiaosan"] = "出牌阶段，你可以将1张手牌当作【闪】使用。",
    ["LuaMisan"] = "弥散",
    [":LuaMisan"] = "锁定技，你的♥手牌均视为【桃】。",
}

--创建武将：赤井秀一
--（武将包，武将名称，国家，体力上限，性别）
chijingxy = sgs.General(extension, "chijingxy", "god", "4", true)

--主动技能卡牌
--创建技能：血染
--技能描述：出牌阶段，你可以弃置1张装备牌，并选择1名角色，对其造成1点伤害，然后你摸1张牌。
--实体卡牌--视为技，（角色对象，技能效果）--技能卡牌
CCXueran = sgs.CreateSkillCard{
    name = "LuaXueran",
    target_fixed = false,  --指定的目标不固定
    filter = function(self, targets, to_select)  --过滤角色
        if #targets == 1 then return false  --限制可选目标数量为1
        else return true
        end
    end,
    on_use = function(self, room, source, targets)
        local dest = targets[1]
        local damage = sgs.DamageStruct()
        damage.from = source
        damage.to = dest
        damage.damage = 1
        damage.nature = sgs.DamageStruct_Normal
        room:damage(damage)
        room:drawCards(source, 1)
    end,
}

LuaXueran = sgs.CreateViewAsSkill{
    name = "LuaXueran",
    n = 1,  --手牌数量
    view_filter = function(self, selected, to_select)  --过滤卡牌
        return to_select:getTypeId() == sgs.Card_TypeEquip --指定为装备牌
    end,
    view_as = function(self, cards)
        if #cards == 0 then return end
        local vs_card = CCXueran:clone()  --创建虚拟技能卡牌
        vs_card:addSubcard(cards[1])
        return vs_card
    end,
}

--主动技能卡牌（限制次数）
--创建技能：冲锋
--技能描述：出牌阶段限一次，你可以对场上任意1名角色造成1点伤害。
CCChongfeng = sgs.CreateSkillCard{
    name = "LuaChongfeng",
    target_fixed = false,  --指定的目标不固定
    filter = function(self, targets, to_select)  --过滤角色
        return #targets == 0
    end,
    on_use = function(self, room, source, targets)
        local damage = sgs.DamageStruct()
        damage.from = source
        damage.to = targets[1]
        damage.damage = 1
        damage.nature = sgs.DamageStruct_Normal
        room:damage(damage)
        room:setPlayerFlag(source, "Chongfeng_used")  -- 次数限制标记
    end,
}

--0牌视为技（特殊）
LuaChongfeng = sgs.CreateZeroCardViewAsSkill{
    name = "LuaChongfeng",
    view_as = function(self, cards)
        return CCChongfeng:clone()
    end,
    enabled_at_play = function(self, target)
        return not target:hasFlag("Chongfeng_used")
    end,
}

--被动技能卡牌（触发视为技）
--创建技能：血栓
--技能描述：出牌阶段结束时，你可以弃置2张黑色手牌，若如此做，你可以令至多2名角色翻面。
--触发时机--触发技，实体卡牌--视为技，（角色对象，技能效果）--技能卡牌
CCXueshuan = sgs.CreateSkillCard{
    name = "LuaXueshuan",
    target_fixed = false,  --指定的目标不固定
    filter = function(self, targets, to_select)  --过滤角色
        if #targets == 2 then return false  --限制可选目标数量为2
        else return true
        end
    end,
    on_use = function(self, room, source, targets)
        for _, dest in pairs(targets) do  --遍历目标，每有1个角色就令其翻面
            dest:turnOver()
        end
    end,
}

VSXueshuan = sgs.CreateViewAsSkill{
    name = "LuaXueshuan",
    n = 2,  --手牌数量
    view_filter = function(self, selected, to_select)  --过滤卡牌
        return to_select:isBlack() and not to_select:isEquipped()
    end,
    view_as = function(self, cards)
        if #cards == 0 or #cards == 1 then return end
        local vs_card = CCXueshuan:clone()  --创建虚拟技能卡牌
        vs_card:addSubcard(cards[1])
        vs_card:addSubcard(cards[2])
        return vs_card
    end,
    response_pattern = "@@LuaXueshuan",  --触发响应
}

LuaXueshuan = sgs.CreateTriggerSkill{
    name = "LuaXueshuan",
    events = {sgs.EventPhaseEnd},
    view_as_skill = VSXueshuan,  --触发视为技联动
    on_trigger = function(self, event, player, data)
        local room = player:getRoom()
        if player:getPhase() == sgs.Player_Play and room:askForSkillInvoke(player, self:objectName(), data) then
            room:askForUseCard(player, "@@LuaXueshuan", "@LuaXueshuan_card")  --触发响应，提示信息
        end
    end,
}

--添加技能
chijingxy:addSkill(LuaXueran)
chijingxy:addSkill(LuaChongfeng)
chijingxy:addSkill(LuaXueshuan)

--翻译语句
sgs.LoadTranslationTable{
    ["chijingxy"] = "赤井秀一",  --武将名称
    ["LuaXueran"] = "血染",  --技能名称
    [":LuaXueran"] = "出牌阶段，你可以弃置1张装备牌，并选择1名角色，对其造成1点伤害，然后你摸1张牌。",  --技能描述
    ["LuaChongfeng"] = "冲锋",
    [":LuaChongfeng"] = "出牌阶段限一次，你可以对场上任意1名角色造成1点伤害。",
    ["LuaXueshuan"] = "血栓",
    [":LuaXueshuan"] = "出牌阶段结束时，你可以弃置2张黑色手牌，若如此做，你可以令至多2名角色翻面。",
    ["@LuaXueshuan_card"] = "请选择2张黑色手牌，并指定至多2名角色。"
}

--创建武将：服部平次
--（武将包，武将名称，国家，体力上限，性别）
fubupc = sgs.General(extension, "fubupc", "god", "4", true)

--触发技（主动判定）
--创建技能：洞察
--技能描述：当你将要受到有伤害来源的伤害时，你可以进行1次判定，若为红桃花色，则此次的伤害来源与伤害目标交换，同时对方摸1张牌。
LuaDongcha = sgs.CreateTriggerSkill{
    name = "LuaDongcha",
    events = {sgs.DamageForseen},
    on_trigger = function(self, event, player, data)
        local room = player:getRoom()
        local DCdamage = data:toDamage()
        if DCdamage.from and room:askForSkillInvoke(player, self:objectName(), data) then
            local DCjudge = sgs.JudgeStruct()  --判定结构体
            DCjudge.good = true  --加入判定生效列表
            DCjudge.who = player  --进行判定的角色
            DCjudge.pattern = ".|heart|."  --牌名|花色|点数
            DCjudge.reason = self:objectName()
            room:judge(DCjudge)
            if DCjudge:isGood() then
                local victim = DCdamage.from  --创建临时变量进行交换目标
                DCdamage.from = DCdamage.to
                DCdamage.to = victim
                data:setValue(DCdamage)
                room:drawCards(victim, 1)
            end
        end
    end,
}

--触发技（被动判定）
--创建技能：敏锐
--技能描述：当你的判定牌生效时，你可以获得之。
LuaMinrui = sgs.CreateTriggerSkill{
    name = "LuaMinrui",
    events = {sgs.FinishJudge},
    on_trigger = function(self, event, player, data)
        local room = player:getRoom()
        local judge = data:toJudge()
        local card = judge.card
        if room:askForSkillInvoke(player, self:objectName(), data) then
            player:obtainCard(card)
        end
    end,
}

--触发技（改变判定）
--创建技能：逆天
--技能描述：当有角色进行判定时，你可以打出1张手牌替代之，若如此做，你需要弃置1张牌。
CCNitian = sgs.CreateSkillCard{
    name = "LuaNitian",
    target_fixed = true,  --指定的目标固定
    will_throw = false,  --不需要丢弃该牌
    on_effect = function(self, effect)
        return
    end,
}

VSNitian = sgs.CreateViewAsSkill{
    name = "LuaNitian",
    n = 1,  --手牌数量
    view_filter = function(self, selected, to_select)  --过滤卡牌
        return not to_select:isEquipped()
    end,
    view_as = function(self, cards)
        if #cards == 0 then return end
        local vs_card = CCNitian:clone()  --创建虚拟技能卡牌
        vs_card:addSubcard(cards[1])
        return vs_card
    end,
    response_pattern = "@@LuaNitian",  --触发响应
}

LuaNitian = sgs.CreateTriggerSkill{
    name = "LuaNitian",
    events = {sgs.AskForRetrial},
    view_as_skill = VSNitian,
    on_trigger = function(self, event, player, data)
        local room = player:getRoom()
        if room:askForSkillInvoke(player, self:objectName(), data) then
            local judge = data:toJudge()
            local card = room:askForCard(player, "@@LuaNitian", "@LuaNitian_card", data, sgs.AskForRetrial)
            room:retrial(card, player, judge, self:objectName())
            room:sendCompulsoryTriggerLog(player, self:objectName())
            if not room:askForDiscard(player, self:objectName(), 1, 1, false, true, "@Wuren_card") then
                local cards = player:getCards("he")
                local c = cards:at(math.random(0, cards:length() - 1))
                room:throwCard(c, player)
            end
        end
    end,
}

--添加技能
fubupc:addSkill(LuaDongcha)
fubupc:addSkill(LuaMinrui)
fubupc:addSkill(LuaNitian)

--翻译语句
sgs.LoadTranslationTable{
    ["fubupc"] = "服部平次",  --武将名称
    ["LuaDongcha"] = "洞察",  --技能名称
    [":LuaDongcha"] = "当你将要受到有伤害来源的伤害时，你可以进行1次判定，若为红桃花色，则此次的伤害来源与伤害目标交换，同时对方摸1张牌。",  --技能描述
    ["LuaMinrui"] = "敏锐",
    [":LuaMinrui"] = "当你的判定牌生效时，你可以获得之。",
    ["LuaNitian"] = "逆天",
    [":LuaNitian"] = "当有角色进行判定时，你可以打出1张手牌替代之，若如此做，你需要弃置1张牌。",
    ["@LuaNitian_card"] = "请选择1张手牌进行改判。",
}

--创建武将：怪盗基德
--（武将包，武将名称，国家，体力上限，性别）
guaidaojd = sgs.General(extension, "guaidaojd", "god", "4", true)

--触发技(标记)
--创建技能：积累
--技能描述：锁定技，在判定阶段开始时，你获得1个龙标记。
LuaJilei = sgs.CreateTriggerSkill{
    name = "LuaJilei",
    frequency = sgs.Skill_Compulsory,
    events = {sgs.EventPhaseStart},
    on_trigger = function(self, event, player, data)
        local room = player:getRoom()
        local phase = player:getPhase()
        if phase == sgs.Player_Judge then
            player:gainMark("@dragon_test")
        end
    end,
}

--隐藏技
--技能描述：你每拥有1个龙标记，你的手牌上限+1。
LuaJileiCardnum = sgs.CreateMaxCardsSkill{
    name = "#LuaJilei",
    extra_func = function(self, target)
        if target:hasSkill("#LuaJilei") then
            return target:getMark("@dragon_test")
        end
    end,
}

--主动技能卡牌
--创建技能：消耗
--技能描述：出牌阶段，你可以弃置所有龙标记，并指定1名角色对其造成标记数量一半的火焰伤害（向上取整），
         --若以此法造成的伤害数量不少于3点，你需要失去2点体力并弃置所有手牌。
--实体卡牌--视为技，（角色对象，技能效果）--技能卡牌
CCXiaohao = sgs.CreateSkillCard{
    name = "LuaXiaohao",
    target_fixed = false,  --指定的目标不固定
    filter = function(self, targets, to_select)  --过滤角色
        return #targets == 0  --指定1名角色
    end,
    on_use = function(self, room, source, targets)
        local num = (source:getMark("@dragon_test")+1)/2  --标记数量的一半，向上取整
        local damage = sgs.DamageStruct()
        damage.from = source
        damage.to = targets[1]
        damage.damage = num
        damage.nature = sgs.DamageStruct_Fire
        room:damage(damage)
        if num >= 3 then
            room:loseHp(source, 2)
            source:throwAllHandCards()
        end
        source:loseAllMarks("@dragon_test")
    end,
}

LuaXiaohao = sgs.CreateViewAsSkill{
    name = "LuaXiaohao",
    n = 0,  --手牌数量
    view_as = function(self, cards)
        return CCXiaohao:clone()  --创建虚拟技能卡牌
    end,
    enabled_at_play = function(self, player)  --判断是否有标记
        return player:getMark("@dragon_test") >= 1
    end
}

--添加技能
guaidaojd:addSkill(LuaJilei)
guaidaojd:addSkill(LuaJileiCardnum)
guaidaojd:addSkill(LuaXiaohao)


--翻译语句
sgs.LoadTranslationTable{
    ["guaidaojd"] = "怪盗基德",  --武将名称
    ["LuaJilei"] = "积累",  --技能名称
    [":LuaJilei"] = "锁定技，在判定阶段开始时，你获得1个龙标记，你每拥有1个龙标记，你的手牌上限+1。",  --技能描述
    ["LuaXiaohao"] = "消耗",
    [":LuaXiaohao"] = "出牌阶段，你可以弃置所有龙标记，并指定1名角色对其造成标记数量一半的火焰伤害（向上取整），若以此法造成的伤害数量不少于3点，你需要失去2点体力并弃置所有手牌。",
    ["@dragon_test"] = "龙",
}

--创建武将：工藤新一
--（武将包，武将名称，国家，体力上限，性别）
gongtengxy = sgs.General(extension, "gongtengxy", "god", "4", true)

--触发技(跨阶段)
--创建技能：任重
--技能描述：摸牌阶段，你可以放弃摸牌并判定，若如此做，你在回合结束阶段摸与判定点数一半数量的牌（向上取整）。
LuaRenzhong = sgs.CreateTriggerSkill{
	name = "LuaRenzhong",
	events = {sgs.DrawNCards, sgs.EventPhaseEnd},
	on_trigger = function(self, event, player, data)
		local room = player:getRoom()
		if event == sgs.DrawNCards and room:askForSkillInvoke(player, "LuaRenzhong", data) then
			local count = data:toInt()
			data:setValue(count-2)
			local judge = sgs.JudgeStruct()  --判定结构体
			judge.good = true
			judge.pattern = ".|.|."
			judge.who = player
			judge.reason = self:objectName()
			room:judge(judge)
			local card = judge.card
			local point = card:getNumber()
			room:setTag("Renzhong_point", sgs.QVariant(point))  --保留判定点数
		end
		if event == sgs.EventPhaseEnd and player:getPhase()==sgs.Player_Finish then
			local num = room:getTag("Renzhong_point"):toInt()
			room:drawCards(player, (num+1)/2)
			room:removeTag("Renzhong_point")  --移除标签
		end
	end,
}

--触发技(濒死)
--创建技能：护盾
--技能描述：任意其他角色进入濒死状态时，你可以选择弃置所有手牌，然后令该角色回复X点体力。（X为以此法弃置的手牌数量）
LuaHudun = sgs.CreateTriggerSkill{
    name = "LuaHudun",
    events = {sgs.Dying},
    on_trigger = function(self, event, player, data)
        local room = player:getRoom()
        local dying = data:toDying()
        local target = dying.who
        if target:objectName() ~= player:objectName() and room:askForSkillInvoke(player, self:objectName(), data) then
            local num = player:getHandcardNum()
            local rec = sgs.RecoverStruct()
            rec.who = player
            rec.recover = num
            room:recover(target, rec)
            player:throwAllHandCards()
        end
    end,
}

--添加技能
gongtengxy:addSkill(LuaRenzhong)
gongtengxy:addSkill(LuaHudun)

--翻译语句
sgs.LoadTranslationTable{
    ["gongtengxy"] = "工藤新一",  --武将名称
    ["LuaRenzhong"] = "任重",  --技能名称
    [":LuaRenzhong"] = "摸牌阶段，你可以放弃摸牌并判定，若如此做，你在回合结束阶段摸与判定点数一半数量的牌（向上取整）。",  --技能描述
    ["LuaHudun"] = "护盾",
    [":LuaHudun"] = "任意其他角色进入濒死状态时，你可以选择弃置所有手牌，然后令该角色回复X点体力。（X为以此法弃置的手牌数量）",
}

--创建武将：乌丸莲耶
--（武将包，武将名称，国家，体力上限，性别）
wuwanly = sgs.General(extension, "wuwanly", "god", "4", true)

--触发技（私家牌堆）
--创建技能：坚毅
--技能描述：锁定技，当你受到伤害时，你可以翻开牌堆顶的X张牌作为龙置于你的武将牌上（X为你受到伤害的数值）。
LuaJianyi = sgs.CreateTriggerSkill{
    name = "LuaJianyi",
    frequency = sgs.Skill_Compulsory,
    events = {sgs.Damaged},
    on_trigger = function(self, event, player, data)
        local room = player:getRoom()
        local damage = data:toDamage()
        local ids = room:getNCards(damage.damage)
        player:addToPile("LuaJianyi_pile", ids)  --定义牌堆
    end,
}

--隐藏技
--技能描述：每当你拥有1张龙，你计算到其他角色的距离-1。
LuaJianyiDistance = sgs.CreateDistanceSkill{
    name = "#LuaJianyi",
    correct_func = function(self, from, to)
        if from:hasSkill("#LuaJianyi") then
            local pile = from:getPile("LuaJianyi_pile")
            return -pile:length()
        end
    end,
}

--主动技能卡牌（限制次数）
--创建技能：猛击
--技能描述：出牌阶段限一次，你可以弃置1张龙并选择1项：1.指定1名其他角色，对其造成1点伤害；
         --2.获得这张牌，并额外从摸牌堆中摸1张牌。
CCMengji = sgs.CreateSkillCard{
    name = "LuaMengji",
    target_fixed = true,  --指定的目标固定
    on_use = function(self, room, source, targets)
        local choice = room:askForChoice(source, "LuaMengji", "Damage+Draw")
        if choice == "Damage" then  --指定1名其他角色，对其造成1点伤害
            local plist = room:getOtherPlayers(source)
            local victim = room:askForPlayerChosen(source, plist, self:objectName())
            local damage = sgs.DamageStruct()
            damage.from = source
            damage.to = victim
            damage.damage = 1
            damage.nature = sgs.DamageStruct_Normal
            room:damage(damage)
        elseif choice == "Draw" then  --获得这张牌，并额外从摸牌堆中摸1张牌
            room:obtainCard(source, self)
            room:drawCards(source, 1)
        end
        room:setPlayerFlag(source, "Mengji_used")  -- 次数限制标记
    end,
}

--单牌视为技（特殊）
LuaMengji = sgs.CreateOneCardViewAsSkill{
    name = "LuaMengji",
    filter_pattern = ".|.|.|LuaJianyi_pile",  --牌名|花色|点数|牌类型
    expand_pile = "LuaJianyi_pile",  --私家牌堆
    view_as = function(self, originalCard)
        local vs_card = CCMengji:clone()
        vs_card:addSubcard(originalCard:getId())
        return vs_card
    end,
    enabled_at_play = function(self, target)
        return not target:hasFlag("Mengji_used") and target:getPile("LuaJianyi_pile"):length() >= 1
    end,
}

--觉醒技
--创建技能：荣耀
--技能描述：觉醒技，回合开始阶段，当你拥有4张或以上的龙，你失去1点体力上限并摸3张牌，同时获得技能"无双"。
LuaRongyao = sgs.CreateTriggerSkill{
	name = "LuaRongyao",
	frequency = sgs.Skill_Wake,
	events = {sgs.EventPhaseStart},
	on_trigger = function(self, event, player, data)
		local room = player:getRoom()
		room:doLightbox("$LuaRongyao_effect")  --全屏特效
		room:loseMaxHp(player, 1)
		room:drawCards(player, 3)
		if not player:hasSkill("wushuang") then
			room:acquireSkill(player, "wushuang")
		end
		player:gainMark("@waked")  --觉醒标记
	end,
	can_trigger = function(self, target)
		return target:isAlive() and target:hasSkill("LuaRongyao") and target:getPhase() == sgs.Player_Start
		and target:getMark("@waked") == 0 and target:getPile("LuaJianyi_pile"):length()>=4
	end,
}

--限定技
--创建技能：绝刃
--技能描述：限定技，你可以选择弃置6张龙并选择1名其他角色，将这6张龙交给他，然后你摸3张牌，并且你与其回复满体力值，
         --然后除你俩之外的其他所有角色选择1项：1.弃置所有手牌和装备牌；2.受到你造成的2点火焰伤害。（若没有牌强制选第2项）
CCJueren = sgs.CreateSkillCard{
	name = "LuaJueren",
	target_fixed = false,
	will_throw = false,
	filter = function(self, targets, to_select)
		return #targets == 0 and not to_select:hasSkill("LuaJueren")  --指定其他角色
	end,
	on_use = function(self, room, source, targets)
		room:doLightbox("$LuaJueren_effect")
		source:loseAllMarks("@burn_test")  --限定标记
		room:obtainCard(targets[1], self)
		room:drawCards(source, 3)
		local rec = sgs.RecoverStruct()  --回复结构体
		rec.who = source
		rec.recover = source:getMaxHp()
		room:recover(source, rec)  --我回复体力值
		rec.recover = targets[1]:getMaxHp()
		room:recover(targets[1], rec)  --他回复体力值
		local plist = room:getAlivePlayers()  --获得所有角色列表
		for _, dest in sgs.qlist(plist) do
			if dest:objectName() ~= source:objectName() and dest:objectName() ~= targets[1]:objectName() then  --所选角色不是我也不是他
				local damage = sgs.DamageStruct()
				damage.from = source
				damage.to = dest
				damage.damage = 2
				damage.nature = sgs.DamageStruct_Fire
				if dest:isNude() then  --若没有牌必须受到伤害
					room:damage(damage)
				else
					local choice = room:askForChoice(dest, self:objectName(), "Discard+Getdamage")
					if choice == "Discard" then
						dest:throwAllHandCardsAndEquips()
					elseif choice == "Getdamage" then
						room:damage(damage)
					end
				end
			end
		end
	end,
}

VSJueren = sgs.CreateViewAsSkill{
	name = "LuaJueren",
	n = 6,
	expand_pile = "LuaJianyi_pile",
	view_filter = function(self, selected, to_select)
		return #selected <=5 and sgs.Self:getPile("LuaJianyi_pile"):contains(to_select:getId())
	end,
	view_as = function(self, cards)
		if #cards < 6 then return end
		local vs_card = CCJueren:clone()
		for _,card in pairs(cards) do
			vs_card:addSubcard(card)
		end
		return vs_card
	end,
	enabled_at_play = function (self,player)
		return player:getMark("@burn_test")>=1 and player:getPile("LuaJianyi_pile"):length()>=6
	end,
}

LuaJueren = sgs.CreateTriggerSkill{
	name = "LuaJueren",
	frequency = sgs.Skill_Limited,
	view_as_skill = VSJueren,
	limit_mark = "@burn_test",
	on_trigger = function(self, event, player, data)
	end,
}

--添加技能
wuwanly:addSkill(LuaJianyi)
wuwanly:addSkill(LuaJianyiDistance)
wuwanly:addSkill(LuaMengji)
wuwanly:addSkill(LuaRongyao)
wuwanly:addSkill(LuaJueren)

--翻译语句
sgs.LoadTranslationTable{
    ["wuwanly"] = "乌丸莲耶",  --武将名称
    ["LuaJianyi"] = "坚毅",  --技能名称
    [":LuaJianyi"] = "锁定技，当你受到伤害时，你可以翻开牌堆顶的X张牌作为龙置于你的武将牌上（X为你受到伤害的数值），每当你拥有1张龙，你计算到其他角色的距离-1。",  --技能描述
    ["LuaJianyi_pile"] = "龙", --私家牌堆名称
    ["LuaMengji"] = "猛击",
    [":LuaMengji"] = "出牌阶段限一次，你可以弃置1张龙并选择1项:1.指定1名其他角色，对其造成1点伤害；2.获得这张牌，并额外从摸牌堆中摸1张牌。",
    ["Damage"] = "1.指定1名其他角色，对其造成1点伤害",
    ["Draw"] = "2.获得这张牌，并额外从摸牌堆中摸1张牌",
    ["LuaRongyao"] = "荣耀",
    [":LuaRongyao"] = "觉醒技，回合开始阶段，当你拥有4张或以上的龙，你失去1点体力上限并摸3张牌，同时获得技能“无双”。",
    ["$LuaRongyao_effect"] = "我受到了召唤，我必须回应，一如既往！",  --觉醒技特效
    ["LuaJueren"] = "绝刃",
    [":LuaJueren"] = "限定技，你可以选择弃置6张龙并选择1名其他角色，将这6张龙交给他，然后你摸3张牌，并且你与其回复满体力值，然后除你俩之外的其他所有角色选择1项:1.弃置所有手牌和装备牌；2.受到你造成的2点火焰伤害。（若没有牌强制选第2项）",
    ["$LuaJueren_effect"] = "大展宏图，就在今日！",  --限定技特效
    ["Discard"] = "1.弃置所有手牌和装备牌",
    ["Getdamage"] = "2.受到你造成的2点火焰伤害",
}