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

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

--创建武将：杜威
duwei = sgs.General(extension, "duwei", "god", "3", true)

--创建技能：微辣
--技能描述：出牌阶段限一次，你可以将2张手牌交给1名其它角色，若如此做，该角色回复1点体力。
CCLuaWeila = sgs.CreateSkillCard{
	name = "CCLuaWeila",
	will_throw = false,
	handling_method = sgs.Card_MethodNone,
	filter = function(self, selected, to_select)
		return (#selected == 0) and (to_select:objectName() ~= sgs.Self:objectName())
	end,
	on_use = function(self, room, source, targets)
		local reason = sgs.CardMoveReason(sgs.CardMoveReason_S_REASON_GIVE, source:objectName(), targets[1]:objectName(), "LuaWeila", "")
		room:obtainCard(targets[1], self, reason, false)
		local old_value = source:getMark("LuaWeila")
		local new_value = old_value + self:getSubcards():length()
		room:setPlayerMark(source, "LuaWeila", new_value)
		if old_value < 2 and new_value >= 2 then  --指定的角色回复体力
            local target = targets[1] or source
            local effect = sgs.CardEffectStruct()
            effect.card = self
            effect.from = source
            effect.to = target
            room:cardEffect(effect)
		end
        room:setPlayerFlag(source, "Weila_used")  --次数限制标记
	end,
	on_effect = function(self, effect)
		local dest = effect.to
		local room = dest:getRoom()
		local recover = sgs.RecoverStruct()
		recover.card = self
		recover.who = effect.from
		room:recover(dest, recover)
	end
}

VSLuaWeila = sgs.CreateViewAsSkill{
	name = "LuaWeila",
	n = 2,
	view_filter = function(self, selected, to_select)
		return not to_select:isEquipped()
	end,
	view_as = function(self, cards)
		if #cards == 0 then return nil end
        if #cards == 1 then return nil end
		local rende_card = CCLuaWeila:clone()
		for _, c in ipairs(cards) do
			rende_card:addSubcard(c)
		end
		return rende_card
	end ,
	enabled_at_play = function(self, player)
		return (not player:isKongcheng()) and not player:hasFlag("Weila_used")
	end
}

LuaWeila = sgs.CreateTriggerSkill{
	name = "LuaWeila",
	events = {sgs.EventPhaseChanging},
	view_as_skill = VSLuaWeila,
	on_trigger = function(self, event, player, data)
		local change = data:toPhaseChange()
		if change.to ~= sgs.Player_NotActive then return false end
		player:getRoom():setPlayerMark(player, self:objectName(), 0)
		return false
	end ,
	can_trigger = function(self, target)
		return target and target:getMark(self:objectName()) > 0
	end
}

--创建技能：特辣
--技能描述：每当你受到1点伤害时，你可以弃置1张手牌并指定1名其他角色，对其造成1点伤害。
CCTela = sgs.CreateSkillCard{
    name = "LuaTela",
    target_fixed = false,  --指定的目标不固定
    filter = function(self, selected, to_select)  --过滤角色
        return (#selected == 0) and (to_select:objectName() ~= sgs.Self:objectName())
    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)
    end,
}

VSTela = sgs.CreateViewAsSkill{
    name = "LuaTela",
    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 = CCTela:clone()  --创建虚拟技能卡牌
        vs_card:addSubcard(cards[1])
        return vs_card
    end,
    response_pattern = "@@LuaTela",  --触发响应
}

LuaTela = sgs.CreateTriggerSkill{
    name = "LuaTela",
    events = {sgs.Damaged},
    view_as_skill = VSTela,  --触发视为技联动
    on_trigger = function(self, event, player, data)
        local damage = data:toDamage()
        local room = player:getRoom()
        for i = 0, damage.damage - 1, 1 do
            if room:askForSkillInvoke(player, self:objectName(), data) then
                room:askForUseCard(player, "@@LuaTela", "@LuaTela_card")  --触发响应，提示信息
            end
		end
	end,
}

duwei:addSkill(LuaWeila)
duwei:addSkill(LuaTela)

--翻译语句
sgs.LoadTranslationTable{
    ["theodore"] = "龙包",  --武将包名称
    ["duwei"] = "杜威",  --武将名称
    ["#duwei"] = "威武帝",  --武将称号
    ["LuaWeila"] = "微辣",
    ["ccluaweila"] = "微辣",
    [":LuaWeila"] = "出牌阶段限一次，你可以将2张手牌交给1名其它角色，若如此做，该角色回复1点体力。",
    ["LuaTela"] = "特辣",
    [":LuaTela"] = "每当你受到1点伤害时，你可以弃置1张手牌并指定1名其他角色，对其造成1点伤害。",
    ["@LuaTela_card"] = "请弃置1张手牌并指定1名其他角色，对其造成1点伤害。",
    ["designer:duwei"] = "龙一野",  --设计师
    ["cv:duwei"] = "龙一野",  --配音演员
    ["illustrator:duwei"] = "龙一野"  --插画
}

--创建武将：李明康
limingkang = sgs.General(extension, "limingkang", "god", "8", true)

--创建技能：卡罗
--技能描述：你对其他角色造成杀的伤害+1，其他角色对你造成杀的伤害+1。
LuaKaluo = sgs.CreateTriggerSkill{
	name = "LuaKaluo",
	frequency = sgs.Skill_Compulsory,
	events = {sgs.DamageCaused, sgs.DamageInflicted},
	on_trigger = function(self, event, player, data)
        if event == sgs.DamageCaused then
            local damage = data:toDamage()
            if damage.chain or damage.transfer or (not damage.by_user) then return false end
            local reason = damage.card
            if reason and (reason:isKindOf("Slash")) then
                damage.damage = damage.damage + 1
                data:setValue(damage)
            end
		end
        if event == sgs.DamageInflicted then
            local damaged = data:toDamage()
            if damaged.chain or damaged.transfer or (not damaged.by_user) then return false end
            local reason = damaged.card
            if reason and (reason:isKindOf("Slash")) then
                damaged.damage = damaged.damage + 1
                data:setValue(damaged)
            end
            return false
        end
		return false
	end,
}

--创建技能：卡特
--技能描述：觉醒技，回合结束阶段，当你的体力值为1点时，你将体力值与手牌数补至体力上限数，并获得技能“影武”。
LuaKate = sgs.CreateTriggerSkill{
	name = "LuaKate",
	frequency = sgs.Skill_Wake,
	events = {sgs.EventPhaseStart},
	on_trigger = function(self, event, player, data)
        if player:getHp() == 1 then
            local room = player:getRoom()
            room:doLightbox("$LuaKate_effect")  --全屏特效
            room:broadcastSkillInvoke("LuaKate")  --技能音效
            local rec = sgs.RecoverStruct()  --回复结构体
            rec.who = player
            rec.recover = 7
            room:recover(player, rec)
            player:drawCards(math.min(8, player:getMaxHp()) - player:getHandcardNum())
            if not player:hasSkill("LuaYingwu") then
                room:acquireSkill(player, "LuaYingwu")
            end
            player:gainMark("@waked")  --觉醒标记
        end
	end,
	can_trigger = function(self, target)
		return target:isAlive() and target:hasSkill("LuaKate") and target:getPhase() == sgs.Player_Finish
		and target:getMark("@waked") == 0
	end,
}

--创建技能：布玛
--技能描述：限定技，你可以让1名角色弃置所有手牌并受到2点火焰伤害，若如此做，你将武将牌翻面。
CCBuma = sgs.CreateSkillCard{
	name = "LuaBuma",
	target_fixed = false,
	will_throw = false,
	filter = function(self, targets, to_select)
		return #targets == 0 --指定其他角色
	end,
	on_use = function(self, room, source, targets)
		room:doLightbox("$LuaBuma_effect")
        local damage = sgs.DamageStruct()
        damage.from = source
        damage.to = targets[1]
        damage.damage = 2
        damage.nature = sgs.DamageStruct_Fire
        room:damage(damage)
        targets[1]:throwAllHandCards()
        source:turnOver()
        source:loseAllMarks("@burn_test")
    end,
}

VSBuma = sgs.CreateZeroCardViewAsSkill{
    name = "LuaBuma",
    view_as = function(self, cards)
        return CCBuma:clone()
    end,
    enabled_at_play = function(self, target)
        return target:getMark("@burn_test") >= 1
    end,
}

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

limingkang:addSkill(LuaKaluo)
limingkang:addSkill(LuaKate)
limingkang:addSkill(LuaBuma)

--翻译语句
sgs.LoadTranslationTable{
    ["limingkang"] = "李明康",  --武将名称
    ["#limingkang"] = "蕉太狼",  --武将称号
    ["LuaKaluo"] = "卡罗",
    [":LuaKaluo"] = "你对其他角色造成杀的伤害+1，其他角色对你造成杀的伤害+1。",
    ["LuaKate"] = "卡特",
    [":LuaKate"] = "觉醒技，回合结束阶段，当你的体力值为1点时，你将体力值与手牌数补至体力上限数，并获得技能“影武”。",
    ["$LuaKate_effect"] = "我受到了召唤，我必须回应，一如既往！",  --觉醒技特效
    ["LuaBuma"] = "布玛",
    ["luabuma"] = "布玛",
    [":LuaBuma"] = "限定技，你可以让1名角色弃置所有手牌并受到2点火焰伤害，若如此做，你将武将牌翻面。",
    ["$LuaBuma_effect"] = "我受到了召唤，我必须回应，一如既往！",  --限定技特效
}

--创建武将：张贤
zhangxian = sgs.General(extension, "zhangxian", "god", "3", true)

--创建技能：奔雷
--技能描述：当你使用或打出【闪】时，你可以摸1张牌并令1名角色进行判定，若结果为♠，则你对其造成2点雷电伤害。
LuaBenlei = sgs.CreateTriggerSkill{
	name = "LuaBenlei" ,
	events = {sgs.CardResponded} ,
	on_trigger = function(self, event, player, data)
		local card_star = data:toCardResponse().m_card
		local room = player:getRoom()
		if card_star:isKindOf("Jink") then
			local target = room:askForPlayerChosen(player, room:getAlivePlayers(), self:objectName(), "LuaBenlei_card", true, true)
			room:drawCards(player, 1)
            if target then
				local judge = sgs.JudgeStruct()
				judge.pattern = ".|spade"
				judge.good = false
				judge.negative = true
				judge.reason = self:objectName()
				judge.who = target
				room:judge(judge)
				if judge:isBad() then
					room:damage(sgs.DamageStruct(self:objectName(), player, target, 2, sgs.DamageStruct_Thunder))
				end
			end
		end
		return false
	end
}

--创建技能：神鬼
--技能描述：当1名角色的判定牌生效前，你可以打出1张牌替换之，若如此做，你失去1点体力。
LuaShengui = sgs.CreateTriggerSkill{
	name = "LuaShengui",
	events = {sgs.AskForRetrial},
	can_trigger = function(self, target)
		if not (target and target:isAlive() and target:hasSkill(self:objectName())) then return false end
		if target:isKongcheng() then
			local has_black = false
			for i = 0, 3, 1 do
				local equip = target:getEquip(i)
				if equip and equip:isBlack() then
					has_black = true
					break
				end
			end
			return has_black
		else
			return true
		end
	end,
	on_trigger = function(self, event, player, data)
		local room = player:getRoom()
		local judge = data:toJudge()
		local prompt_list = {
			"@Shengui-card",
			judge.who:objectName(),
			self:objectName(),
			judge.reason,
			tostring(judge.card:getEffectiveId())
		}
        if room:askForSkillInvoke(player, self:objectName(), data) then
		local prompt = table.concat(prompt_list, ":")
		local card = room:askForCard(player, ".|.", prompt, data, sgs.Card_MethodResponse, judge.who, true)
        room:loseHp(player)
            if card then
                room:retrial(card, player, judge, self:objectName(), true)
            end
        end
		return false
	end
}

--创建技能：电鸣
--技能描述：回合开始阶段，你可以让1名角色进行判定，若为黑色，则对该角色造成1点雷电伤害；若为红色，则你获得该判定牌。
LuaDianming = sgs.CreateTriggerSkill{
    name = "LuaDianming",
    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 target = room:askForPlayerChosen(player, room:getAlivePlayers(), self:objectName(), "LuaBenlei_card", true, true)
            local judge = sgs.JudgeStruct()
            judge.pattern = ".|black"
            judge.good = false
            judge.negative = true
            judge.reason = self:objectName()
            judge.who = player
            room:judge(judge)
            if judge:isBad() then
                room:damage(sgs.DamageStruct(self:objectName(), player, target, 1, sgs.DamageStruct_Thunder))
            else
                player:obtainCard(judge.card)
            end
        end
    end,
}

zhangxian:addSkill(LuaBenlei)
zhangxian:addSkill(LuaShengui)
zhangxian:addSkill(LuaDianming)

--翻译语句
sgs.LoadTranslationTable{
    ["zhangxian"] = "张贤",  --武将名称
    ["#zhangxian"] = "抠脚大汉",  --武将称号
    ["LuaBenlei"] = "奔雷",
    [":LuaBenlei"] = "当你使用或打出【闪】时，你可以摸1张牌并令1名角色进行判定，若结果为♠，则你对其造成2点雷电伤害。",
    ["LuaBenlei_card"] = "请指定1名角色进行判定。",
    ["LuaShengui"] = "神鬼",
    [":LuaShengui"] = "当1名角色的判定牌生效前，你可以打出1张牌替换之，若如此做，你失去1点体力。",
    ["@Shengui-card"] = "请选择1张牌进行替换。",
    ["LuaDianming"] = "电鸣",
    [":LuaDianming"] = "回合开始阶段，你可以让1名角色进行判定，若为黑色，则对该角色造成1点雷电伤害；若为红色，则你获得该判定牌。",
}

--创建武将：宁留洋
ningliuyang = sgs.General(extension, "ningliuyang", "god", "6", true)

--创建技能：涛涛
--技能描述：当其他角色对你造成1点伤害时，你可以弃置伤害来源1张牌。
LuaTaotao = sgs.CreateTriggerSkill{
    name = "LuaTaotao",
    frequency = sgs.Skill_NotFrequent,
    events = {sgs.Damaged},
    on_trigger = function(self, event, player, data)
        local room = player:getRoom()
        local damage = data:toDamage()
        local attacker = damage.from
        if player:objectName() == attacker:objectName() then return end  --自己伤害自己无效
        if room:askForSkillInvoke(player, "LuaTaotao", 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,
}

--创建技能：暖暖
--技能描述：出牌阶段，你可以失去1点体力令1名其他角色回复1点体力，若如此做，你摸1张牌。
CCNuannuan = sgs.CreateSkillCard{
	name = "LuaNuannuan",
	target_fixed = false,
    filter = function(self, selected, to_select)
		return (#selected == 0) and (to_select:objectName() ~= sgs.Self:objectName())
	end,
	on_use = function(self, room, source, targets)
        if source:objectName() == targets[1]:objectName() then return end
        local rec = sgs.RecoverStruct()  --回复结构体
        rec.who = targets[1]
        rec.recover = 1
        room:recover(targets[1], rec)
		room:loseHp(source)
		if source:isAlive() then
			room:drawCards(source, 1)
        end
	end,
}

LuaNuannuan = sgs.CreateZeroCardViewAsSkill{
	name = "LuaNuannuan",
	view_as = function()
		return CCNuannuan:clone()
	end
}

ningliuyang:addSkill(LuaTaotao)
ningliuyang:addSkill(LuaNuannuan)

--翻译语句
sgs.LoadTranslationTable{
    ["ningliuyang"] = "宁留洋",  --武将名称
    ["#ningliuyang"] = "暖洋洋",  --武将称号
    ["LuaTaotao"] = "涛涛",
    [":LuaTaotao"] = "当其他角色对你造成1点伤害时，你可以弃置伤害来源1张牌。",
    ["LuaNuannuan"] = "暖暖",
    ["luanuannuan"] = "暖暖",  --技能卡牌翻译
    [":LuaNuannuan"] = "出牌阶段，你可以失去1点体力令1名其他角色回复1点体力，若如此做，你摸1张牌。",
}

--创建武将：黄新超
huangxinchao = sgs.General(extension, "huangxinchao", "god", "4", true)

--创建技能：怒吼
--技能描述：出牌阶段限一次，你可以选择失去1点体力，若如此做，你摸3张牌并且本回合使用的杀无次数限制。
CCNuhou = sgs.CreateSkillCard{
	name = "CCNuhou",
	target_fixed = true,
	on_use = function(self, room, source, targets)
		room:loseHp(source)
		if source:isAlive() then
			room:drawCards(source, 3, "CCNuhou")
		end
        if not source:hasSkill("paoxiao") then
            room:acquireSkill(source, "paoxiao")
        end
        room:broadcastSkillInvoke ("LuaNuhou")  --技能卡牌音效
        room:setPlayerFlag(source, "Nuhou_used")  -- 次数限制标记
	end
}

LuaNuhou = sgs.CreateZeroCardViewAsSkill{
	name = "LuaNuhou",
	view_as = function()
		return CCNuhou:clone()
    end,
    enabled_at_play = function(self, target)
        return not target:hasFlag("Nuhou_used")
    end,
}

LuaNuhou_plus = sgs.CreateTriggerSkill{
    name = "#LuaNuhou_plus",
    frequency = sgs.Skill_Compulsory,
    events = {sgs.Player_Finish},
    on_trigger = function(self, event, player, data)
        local room = player:getRoom()
        if player:hasSkill("paoxiao") then
            room:detachSkillFromPlayer(player, "paoxiao")
        end
    end,
}

--创建技能：无人
--技能描述：锁定技，出牌阶段，每当你使用1张【杀】便进行判定：若为黑色则摸1张牌；若为红色则弃1张牌。
LuaWuren = sgs.CreateTriggerSkill{
	name = "LuaWuren" ,
	frequency = sgs.Skill_Compulsory,
	events = {sgs.CardUsed} ,
	on_trigger = function(self, event, player, data)
		local room = player:getRoom()
		local use = data:toCardUse()
		if use.card:isKindOf("Slash") then
            local judge = sgs.JudgeStruct()
            judge.pattern = ".|black"
            judge.good = false
            judge.negative = true
            judge.reason = self:objectName()
            judge.who = player
            room:judge(judge)
            if judge:isBad() then
                player:drawCards(1, self:objectName())
            else
                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
		return false
	end
}


huangxinchao:addSkill(LuaNuhou)
huangxinchao:addSkill(LuaNuhou_plus)
huangxinchao:addSkill(LuaWuren)

--翻译语句
sgs.LoadTranslationTable{
    ["huangxinchao"] = "黄新超",  --武将名称
    ["#huangxinchao"] = "照亮黑夜",  --武将称号
    ["LuaNuhou"] = "怒吼",
    ["ccnuhou"] = "怒吼",
    [":LuaNuhou"] = "出牌阶段限一次，你可以选择失去1点体力，若如此做，你摸3张牌并且本回合使用的杀无次数限制。",
    ["LuaWuren"] = "无人",
    [":LuaWuren"] = "锁定技，出牌阶段，每当你使用1张【杀】便进行判定：若为黑色则摸1张牌；若为红色则弃1张牌。",
    ["@Wuren_card"] = "请弃置1张牌。"
}

--创建武将：于佳星
yujiaxing = sgs.General(extension, "yujiaxing", "god", "3", true)

--创建技能：烟雾
--技能描述：锁定技，回合开始阶段，若你的体力值不为1点，则你失去1点体力，
         --你不能使用无属性【杀】指定其他角色为目标且你的手牌上限始终为你的体力上限。
LuaYanwu = sgs.CreateTriggerSkill{
    name = "LuaYanwu",
    frequency = sgs.Skill_Compulsory,
    events = {sgs.EventPhaseStart},
    on_trigger = function(self, event, player, data)
        local room = player:getRoom()
        if player:getPhase() == sgs.Player_Start and player:getHp() ~= 1 then
        room:loseHp(player)
        end
    end,
}

LuaYanwu_plus = sgs.CreateMaxCardsSkill{
    name = "#LuaYanwu_plus",
    extra_func = function(self, target)
        if target:hasSkill("LuaYanwu_plus") then
            local hp = target:getMaxHp() - target:getHp()
            return hp
        end
    end,
}

LuaYanwu_plus2 = sgs.CreateProhibitSkill{
    name = "#LuaYanwu_plus2",
    is_prohibited = function(self, from, to, card)
        if from:hasSkill("LuaYanwu_plus2") and card:isKindOf("Slash") and not card:isKindOf("NatureSlash") then
            return true
        else
            return false
        end
    end,
}

--创建技能：星火
--技能描述：摸牌阶段，你可以额外摸X张牌，X为你当前损失的体力值。
LuaXinghuo = sgs.CreateTriggerSkill{
    name = "LuaXinghuo",
    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()+player:getMaxHp()-player:getHp()
            data:setValue(count)
        end
    end,
}

--创建技能：维素
--技能描述：回合结束阶段，你可以弃置3张锦囊牌让自己回复1点体力。
CCWeisu = sgs.CreateSkillCard{
	name = "CCWeisu",
	target_fixed = false,
	will_throw = true,
	filter = function(self, targets, to_select)
		return (#targets == 0) and (to_select:objectName() == sgs.Self:objectName())
	end,
    on_use = function(self, room, source, targets)
        local rec = sgs.RecoverStruct()  --回复结构体
        rec.who = source
        rec.recover = 1
        room:recover(source, rec)
    end,
}

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

LuaWeisu = sgs.CreateTriggerSkill{
	name = "LuaWeisu",
	frequency = sgs.Skill_NotFrequent,
	events = {sgs.EventPhaseStart},
	view_as_skill = VSWeisu,
	on_trigger = function(self, event, player, data)
		local room = player:getRoom()
		if (player:getPhase() == sgs.Player_Finish) and player:canDiscard(player, "h")
        and room:askForSkillInvoke(player, self:objectName(), data) then
			room:askForUseCard(player, "@@LuaWeisu", "@LuaWeisu_card", -1, sgs.Card_MethodNone)
		end
		return false
	end
}

--创建技能：狂连
--技能描述：你每使用、弃置或打出手牌便可再摸1张牌。
LuaKuanglian = sgs.CreateTriggerSkill{
	name = "LuaKuanglian",
	frequency = sgs.Skill_Frequent,
	events = {sgs.CardsMoveOneTime},
	on_trigger = function(self, event, luxun, data)
		local room = luxun:getRoom()
		local move = data:toMoveOneTime()
        if move.from and move.from:objectName() == luxun:objectName() and move.from_places:contains(sgs.Player_PlaceHand) then
            if room:askForSkillInvoke(luxun, self:objectName(), data) then
                luxun:drawCards(1, self:objectName())
            end
        end
		return false
	end
}

yujiaxing:addSkill(LuaYanwu)
yujiaxing:addSkill(LuaYanwu_plus)
yujiaxing:addSkill(LuaYanwu_plus2)
yujiaxing:addSkill(LuaXinghuo)
yujiaxing:addSkill(LuaWeisu)
yujiaxing:addSkill(LuaKuanglian)

--翻译语句
sgs.LoadTranslationTable{
    ["yujiaxing"] = "于佳星",  --武将名称
    ["#yujiaxing"] = "曹阿瞒",  --武将称号
    ["LuaYanwu"] = "烟雾",
    [":LuaYanwu"] = "锁定技，回合开始阶段，你失去1点体力，你不能使用无属性【杀】指定其他角色为目标且你的手牌上限始终为你的体力上限。",
    ["LuaXinghuo"] = "星火",
    [":LuaXinghuo"] = "摸牌阶段，你可以额外摸X张牌，X为你当前损失的体力值。",
    ["LuaWeisu"] = "维素",
    [":LuaWeisu"] = "回合结束阶段，你可以弃置3张锦囊牌让自己回复1点体力。",
    ["@LuaWeisu_card"] = "请弃置3张锦囊牌。",
    ["LuaKuanglian"] = "狂连",
    [":LuaKuanglian"] = "你每使用、弃置或打出手牌便可再摸1张牌。",
}