太阳神三国杀lua教程

--大家好我是hypercross。

--从这个文件开始讲解DIY接口的用法。

--首先，这个文件说明DIY需要的文件及其结构。

--DIY是以module的形式存在的。每个Module即是一个UTF8格式的Lua文件（建议用notepad++编辑），包含如下格式的代码：

module("extensions.moligaloo", package.seeall)

-- 进入module。这里moligaloo这个词必须和文件名相同。

extension = sgs.Package("moligaloo")

-- 创建扩展包对象。变量名必须为extension。参数名为扩展包的objectName，也是通常会使用的扩展包标识

shiqian = sgs.General(extension, "shiqian", "qun")

-- 创建武将对象,这里我们的武将是时迁。关于武将属性的详细说明见reference文档。

shentou = sgs.CreateViewAsSkill{

--创建技能，技能种类为ViewAsSkill。这里的技能是“出牌阶段，你可以将任意一张梅花手牌当作顺手牵羊使用。”

name = "shentou",

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 == 1 then

local card = cards[1]

local new_card =sgs.Sanguosha:cloneCard("snatch", card:getSuit(), card:getNumber())

new_card:addSubcard(card:getId())

new_card:setSkillName(self:objectName())

return new_card

end

end

}--关于技能的说明将是几乎所有其他帮助文件的重点。此处省略。

sgs.LoadTranslationTable{

["shentou"] = "神偷",

[":shentou"] = "你可以将你的梅花手牌当做顺手牵羊使用。",

}

--此段为翻译，将技能名称与描述中文化，否则你将会看到拼音

shiqian:addSkill(shentou)

--将神偷技能赋予时迁

--你可以将本文件保存至extension目录下的moligaloo.lua并启动游戏。此时扩展包即已经被添加至游戏。

--为了完善DIY扩展包，需要将音频、图片以及翻译代码放到指定目录。这一点将在其他文档中说明。

--技能详解1：ViewAsSkill（视为技，也叫视作技）

--在太阳神三国杀中，常用的基本技能是两种：触发技和视为技。我们使用这两种基本技能的复合来完成大多数复杂的技能。

--此外，我们还有距离技，禁止技等特殊类型的技能，它们用于实现某些某种程度上“要求改变游戏系统” 的技能。

--触发技可以用来实现”在某个时机，满足发动条件时，执行某个效果（包括做出选择）这样的技能。

--触发技也可以用来改变游戏事件而不仅是单纯的产生效果。比如，放弃摸牌阶段并执行xx 这样的技能也可以用触发技实现。

--事实上，一个触发技就是一条游戏规则。如果某名武将具有某个触发技，这个触发技就会被在服务端“注册”成为这局游戏的一条规则。

--被注册的触发技，通常会根据玩家“是否存活”以及玩家的武将“是否具有该技能”来决定是否被执行。

--视为技可以用来实现“可将某牌作为某牌打出”这样的技能。

--视为技的定义对于AI而言是无效的。为了让AI使用视为技，你基本上需要在AI中重新写一遍技能的定义。

--这是因为视为技是在客户端运行的，而AI在服务器端运行；触发技也是在服务端运行。--如果某名玩家具有某个视作技，该技能通常就会被”注册“到该玩家的客户端。这个动作与其他玩家是不相干的。

--总之，视为技负责在客户端管理，有哪些牌可以选中，选中的牌又会被当成什么牌，这样的效果；

--但是视为技的运行本身不影响游戏进程；视为技做的事情是通过将特定的牌（甚至没有牌）“视为”特定的牌，

--来允许你使用那张本来不存在的牌。这也是大多数”主动技能“的实现方式。

--距离技和禁止技则分别用于实现“修改玩家间的距离”，以及“某人不能对某人使用某牌”这样的效果。

--与其他两种技能不同，距离技和禁止技不需要在某局游戏中注册：距离技是永远生效。

--也就是说，如果你写了一个距离技能叫”所有玩家间的距离-1“，那么无论场上有没有玩

家具有这个技能，

--所有玩家间的距离都会被减一。禁止技也类似。

--这类技能的定义比较新，也比较清楚明了，可能你不需要看文档也能明白。

--正片开始

--首先讲解视为技。

--视为技在Lua中的创建使用了sgs.CreateViewAsSkill方法

-- **程序细节，以下可跳过

--sgs.CreateViewAsSkill方法可以在lua\sgs_ex.lua中找到。

--该方法会创建一个LuaViewAsSkill对象（定义见cpp源码），然后将你定义的Lua函数用于其成员函数。

--注意，本游戏cpp源码部分使用了类的继承重载来实现不同的技能，而在lua的DIY技能里面我们都使用固定的类

--我们通过将会被用作技能成员函数的lua function，直接赋给技能的实例来实现不同的技能。

-- **程序细节部分结束

--视为技在创建时，需要以下方法|变量的定义：

--name, n, view_filter, view_as, enabled_at_play和enabled_at_response

--name：

--一个字符串即技能名称。

--该字段必须定义。（无默认值）

--n：

--整数值，每次发动技能所用牌数的最大值。绝大多数DIY用到的n可能都为1或2.

--默认值为0，即不需要选择自己的任何牌.

--view_filter：

--lua函数，返回一个布尔值，即某张卡是否可被选中以用作发动技能。

--发动技能时，将对所有手牌、装备进行遍历，并执行view_filter方法。返回了true的牌可以被选择用作技能发动。

--传入的参数为self(技能对象本身),selected(lua表，已经选择的所有牌), to_select(当前需判断是否可选中的牌)

--默认为"永远返回false"，即如果你没有定义，则这个技能的发动不允许你选择任何牌。

--view_as：

--lua函数，返回一个card对象，即被选中的牌应当被视为什么牌被打出或使用。

--这里的牌可以是游戏牌，也可以是技能牌。

--如果你的DIY主动技能的效果不是某张游戏牌的效果，那么你需要把该效果定义到一个技能牌当中

--然后在view_as方法中得到并返回一张你定义的技能牌。

--传入参数为self(技能对象本身),cards(lua表，已经选择的所有牌)

--默认为"返回空对象"，即如果你没有定义，那么这个技能的发动永远不允许你点确定。

--enabled_at_play

--lua函数，返回一个布尔值，即你在出牌阶段是否可以使用该技能。（该按钮是否可点）

--传入参数为self(技能对象本身)，player(玩家对象)

--默认为true，即如果你没有定义，你永远可以在出牌阶段使用本技能。

--enabled_at_response

--lua函数，返回一个布尔值，即你在需要用响应时，是否可以使用本技能进行响应。

--传入参数为self(技能对象本身)，player(玩家对象),pattern(要求响应的牌的匹配规则) --默认为false,即如果你没有定义，你永远不可以在响应时使用本技能。

--** 实例

--以下为“任意一张草花牌”的view_filter方法：

n=1,

view_filter = function(self, selected, to_select)

return to_select:getSuit()==sgs.Card_Club

end,

--getSuit()返回一张牌的花色的enum。

--如果to_select的花色为草花Club，则返回真（可被选择）。否则返回假（不可被选择）。

--以下为“任意两张同花色手牌“的view_filter方法：

n=2,

view_filter = function(self, selected, to_select)

if #selected<1 then return not to_select:isEquipped() end

return to_select:getSuit()==selected[1]:getSuit() and not to_select:isEquipped()

end,

--如果选中的牌数小于1，那么任何未被装备的牌（手牌）都可以被选择；

--否则，只有那些和已被选中的第一张牌花色相同的牌才能被选中。

--以下为”当成借刀杀人使用“的view_as方法部分：

n=1,

view_as = function(self, cards)

if #cards<1 then return nil end

--如果没有牌被选中，那么返回空对象

local suit,number

for _,card in ipairs(cards) do

if suit and (suit~=card:getSuit()) then suit=sgs.Card_NoSuit else suit=card:getSuit() end

if number and (number~=card:getNumber()) then number=-1 else number=card:getNumber() end

end

--如果所有被选中的牌的花色一样，那么被视为的借刀杀人的花色也为该花色。否则，该借刀杀人无花色。

--点数同理。

local view_as_card= sgs.Sanguosha:cloneCard("collateral", suit, number)

--生成一张借刀杀人

for _,card in ipairs(cards) do

view_as_card:addSubcard(card:getId())

end

--将被用作视为借刀杀人的牌都加入到借刀杀人的subcards里

view_as_card:setSkillName(self:objectName())

--标记该借刀杀人是由本技能生成的

return view_as_card

end,

--将使用到的牌加入生成的借刀杀人的子牌列表中这一步，通常是必须的。

--因为可能存在对牌进行互动的技能，比如发动奸雄会得到发动乱击用的两张牌。

--将技能的名字即self:objectName赋予该卡的技能名属性，还是用于标记方便。

--需要其他游戏牌时，改动collateral这个名字即可。需要根据不同种类、数量的牌得到不同游戏牌时，改动if #cards<1 then 这句即可。

--当技能的效果不能简单地描述为”视为你打出了xx牌“时，你需要使用技能牌定义技能的效果。

--也就是说，将你的技能转述为”你可以将你的xx牌作为xx牌打出，其中xx牌的效果为blahblah“。然后，在技能牌的定义中实现技能的效果。

--技能的效果用”技能牌“实现，技能的发动约束用”视为技“实现，技能的发动时机控制用”触发技“实现。

--以下是貂蝉离间技能的view_as方法：

view_as = function(self, cards)

if #cards<1 then return nil end

local view_as_card=lijian_Card:clone()

--lijian_Card的定义应该被包含在同一个module文件当中。我将在其他文档中讲解技能牌的定义。

for _,card in ipairs(cards) do

view_as_card:addSubcard(card:getId())

end

return view_as_card

end,

--以下是周瑜“反间”的enable_at_play方法：

enabled_at_play=function(self,player)

return not player:hasFlag("fanjian_used")

--反间只能每回合用一次。如果你已经使用过了，那么你不能再次使用。

end

--注意在lua中暂时不能使用player:hasUsed方法来判断是否用过你的某个LuaSkillCard --因为LuaSkillCard并不使用在cpp里面用的类继承机制

--请暂时在你的LuaSkillCard中执行类似于room:setPlayerFlag(effect.from,"fanjian_used")

--这样的语句，然后在enabled_at_play里面使用player:hasFlag。

--以下是大乔”流离“的enabled_at_response方法：

enabled_at_response=function()

return sgs.Self:getPattern()=="#liuli_effect"

--仅在询问流离时可以发动此技能

--这里的函数没有参数传入（我们不需要）

--我们直接调用了sgs.Self，这个对象就是本地的ClientPlayer对象。

--注意：只有在本地运行的代码（比如视作技）可以调用到sgs.Self。

end

--虽然看起来流离并不像是一个视作技

--但事实上我们把它分成了这样的三部分：

--1、你成为杀的目标时，你可以响应使用"流离牌"（技能牌）。用触发技实现。

--2、在且仅在你响应使用"流离牌"时，你可以将任意一张牌视为"流离牌"使用。用视为技实现。

--3、流离牌的效果为：流离牌的目标成为杀的目标，该杀跳过对你的结算。用技能牌实现。

--注意到正常情况下pattern永远不会自己就是"#liuli_effect"

--你需要在触发技当中使用room:askForUseCard(daqiao,"#liuli_target",prompt)

--这样，就可以创造出一个专门用于流离的响应来。

--技能详解3：TriggerSkill 触发技

--许多技能都有”在xx时机，如果xx条件满足，那么执行xx效果“这样的描述。

--由于游戏技时机繁多，许多技能也都是相互类似的，我们在游戏的cpp部分有种类繁多的触发技定义方式。

--而基本的（也是万能的）触发技定义在Lua中是使用sgs.CreateTriggerSkill方法，该方法可以在lua\sgs_ex.lua中找到。

--CreateTriggerSkill需要以下参数：

--name, frequency, events, on_trigger, can_trigger, priority

--name：

--技能名称字符串

--没有默认……技能就是要有名字才行

--frequency：

--Frequency枚举类型，技能的发动频率。

--执行askForSkillInvoke（询问技能发动）时，frequency会影响玩家做决定的方式。

--frequency也起到了技能分类以及用于增加技能提示显示的作用。

--frequency可能的值有：

--sgs.Skill_Frequent（频繁发动：该技能会有一个可以打钩的按钮，如果勾选上，askForSkillInvoke就不会弹出提示而是直接返回true）

--sgs.Skill_NotFrequent（不频繁发动：该技能的askForSkillInvoke总是会弹出提示询问玩家是否发动）

--sgs.Skill_Compulsory （锁定技：该技能的默认优先度为2而不是1；该技能会在显示上提示玩家这是一个锁定技能）

--sgs.Skill_Limited （限定技：该技能会在显示上提示玩家这是一个限定技能）

--ssg.Skill_Wake（觉醒技：该技能的默认优先度为2而不是1；该技能会在显示上提示玩家这是一个觉醒技）

--frequency的默认值为sgs.Skill_NotFrequent

--events：

--Event枚举类型，或者一个包含Event枚举类型的lua表。代表该技能的触发时机。

--可用的Event列表请参考游戏代码中的struct.h文件。

--无默认值。

--on_trigger:

--lua函数，无返回值，执行事件触发时的技能效果。

--如果需要区分不同的事件执行不同效果，请根据event参数使用条件语句。

--通常需要将事件数据(data)转为具体的游戏结构对象才能进行操作。你可以在源码的swig/qvariant.i文件中看到定义。

--on_trigger的传入参数为self(技能对象本身),event(当前触发的事件),player(事件触发者),data(事件数据)

--无默认值。

--can_trigger:

--lua函数，返回一个布尔值，即是否能触发该技能。

--传入参数为self(技能对象),target(事件触发者)

--默认条件为“具有本技能并且存活”

--在这里个人只建议写简单的条件，许多判断都放在on_trigger里面做return其实都是可以的

--priority:

--整数值，代表本技能的优先度。

--如果本技能与其他技能（或规则）在同一个时机都触发，那么优先度影响这些技能或规则的执行顺序。

--优先度更大的技能（或规则）优先执行。游戏规则的优先度为0，典型的技能优先度为1，而受到伤害发动的技能优先度通常为-1.

--锁定技和觉醒技的优先度默认为2，其他情况下默认为1

-- **实例：

--以下是曹操奸雄的实现：

jianxiong=sgs.CreateTriggerSkill{

frequency = sgs.Skill_NotFrequent,

name = "jianxiong",

events={sgs.Damaged}, --或者events=sgs.Damaged

on_trigger=function(self,event,player,data)

local room = player:getRoom()

local card = data:toDamage().card

--这两步通常是必要的。我们需要room对象来操作大多数的游戏要素，我们也需要将data对象转成对应的数据类型来得到相应的信息。

if not room:obtainable(card,player) then return end

if room:askForSkillInvoke(player,"jianxiong") then

room:playSkillEffect("jianxiong")

player:obtainCard(card)

end

end

}

--在on_trigger方法中，我们首先获取了room对象。

--对于影响整盘游戏的效果，我们必须需要获取room对象。大多数情况下，room对象都是必须获取的。

--on_trigger方法的data参数是一个QVariant，根据不同的事件我们需要用不同的方法得到它原本的数据类型。

--对于Damaged事件（你受到了伤害），data对象的类型是DamageStruct，我们使用toDamage()得到DamageStruct。

--询问技能发动时，需要使用room对象的askForSkillInvoke方法。

--playSkillEffect方法则可以播放技能的发动效果。（但是对技能发动效果本身没有影响）

--player:obtainCard(card) 即让player得到造成伤害的card。

--在”某个阶段可触发“的技能，或者”摸牌时改为xx“这样的技能，可以使用PhaseChange 事件来触发，并对event对象进行判断进行触发控制。

--对于在复数个时机发动的触发技，我们需要在on_trigger中使用条件语句。

--以下是袁术”庸肆“技能的实现：

yongsi=sgs.CreateTriggerSkill{

frequency = sgs.Skill_Compulsory, --锁定技

name = "yongsi",

events={sgs.DrawNCards,sgs.PhaseChange}, --两个触发时机

on_trigger=function(self,event,player,data)

local room=player:getRoom()

local getKingdoms=function() --可以在函数中定义函数，本函数返回存活势力的数目

local kingdoms={}

local kingdom_number=0

local players=room:getAlivePlayers()

for _,aplayer in sgs.qlist(players) do

if not kingdoms[aplayer:getKingdom()] then

kingdoms[aplayer:getKingdom()]=true

kingdom_number=kingdom_number+1

end

end

return kingdom_number

end

if event==sgs.DrawNCards then

--摸牌阶段，改变摸牌数

room:playSkillEffect("yongsi")

data:setValue(data:toInt()+getKingdoms())

--DrawNCards事件的data是一个int类型的QVariant即摸牌数，改变该QVariant对象会改变摸牌数

elseif (event==sgs.PhaseChange) and (player:getPhase()==sgs.Player_Discard) then

--进入弃牌阶段时，先执行庸肆弃牌，然后再执行常规弃牌

local x = getKingdoms()

local e = player:getEquips():length()+player:getHandcardNum()

if e>x then room:askForDiscard(player,"yongsi",x,false,true)

--要求玩家弃掉一些牌

-- 最后两个参数为”是否强制“以及”是否包含装备“

else

--如果玩家的牌未达到庸肆的弃牌数目，那么跳过询问全部弃掉

player:throwAllHandCards()

player:throwAllEquips()

end

end

end

}

--技能讲解2：技能牌SkillCard

--神杀中，技能的效果在很多时候都技能牌实现。即，把技能定义在一张没有实体的抽象“牌”当中，当你发动技能的时候，视为你使用了这张牌。

--对于指定对象发动的技能，对象的指定也算在牌的效果当中。

--很多游戏的技能发动都带有cost这个概念，即发动技能的代价。神杀中，cost只能是你的牌或装备；也就是说，

--cost只能靠ViewAsSkill来实现。如果想实现类似于“发动代价”这样的效果，请用“发动技能的负面效果”这样的概念来替换。

--由于技能牌的需要有多个实例存在（每次发动技能得到一个技能牌），

--我们在DIY module当中并不像ViewAsSkill和TriggerSkill当中使用构造函数来创建SkillCard。

--我们需要将SkillCard的参数在一个lua table当中定义好，然后在每次需要创建SkillCard的时候再调用sgs.CreateSkillCard获取SkillCard对象。

--或者，我们也可以先创建好一个SkillCard，然后在技能中复制它。

--sgs.CreateSkillCard需要以下参数定义：

--name,target_fixed,will_throw, filter,feasible,on_use,on_effect

--name:

--字符串，牌的名字。取个好听的名字~

--没有默认值。快去取名字……

--target_fixed：

--布尔值，使用该牌时是否需要玩家指定目标。

--默认为false，使用时你需要指定目标，然后点确定。

--will_throw:

--布尔值，该牌在使用后是否被弃置。还记得subCards吗？

--对于拼点技能，请将will_throw设为false，否则对方将看到你的牌之后再选择拼点牌。--也可以将will_throw设为false,然后使用room:throwCard(card)这个方法来灵活地控制如何将牌移动到弃牌区。

--默认值为true。

--filter：

--lua函数，返回一个布尔值，类似于ViewAsSkill中的view_filter，但filter方法的对象是玩家目标。

--你在使用牌时只能指定玩家为对象，不能直接指定玩家的某张牌为对象；

--比如过河拆桥，在神杀中，“选择对方的一张牌并弃置”是过河拆桥的效果，但过河拆桥的对象只有对方玩家。

--如果你确实需要“作为对象的牌”，请还是在了解游戏机制后自行发明解决方法……

--传入参数为self,targets(已经选择的玩家),to_select(需要判断是否能选择的玩家)

--默认条件为“一名其他玩家”。

--feasible：

--lua函数，返回一个布尔值，相当于viewasSkill的view_as方法是否应该返回nil。

--在viewAsSkill中，我们可以无数次选中牌，直到返回了有意义的view_as再点确定，

--所以view_as返回了无意义的Nil也无所谓；然而在SkillCard当中，点确定的机会只有一次，

--因此我们规定用feasible来排除无效使用的情况。

--只有在feasible返回了true时，你才可以点确定。

--传入参数为self,targets(已经选择的玩家)

--默认条件为"target_fixed为true(不需要指定目标)，或者选择了至少一名玩家为目标"

--on_use:

--lua函数，无返回值，类似于on_trigger，执行使用效果。

--传入参数为self,room(游戏房间对象),source(使用者),targets(牌的使用目标)

--无默认。

--on_effect：

--lua函数，无返回值，同样用于执行使用效果，但只定义对于某一个目标的效果。

--通常情况下你只需要写on_effect或者on_use当中的一个。

--如果是没有目标或者是目标特定的技能，使用on_use；

--如果是有几个目标执行相同或类似的效果，使用on_effect。

--如果是玩家指定的目标，还是使用on_effect。

--以下为“离间牌”的 feasible 以及filter方法：

filter=function(self,targets,to_select)

if (not to_select:getGeneral():isMale()) or #targets>1 then return false elseif to_select:hasSkill("kongcheng") and to_select:isKongcheng() and #targets==0 then return false

else return true end

--当已经选择了多于1名玩家时，不能选择其他玩家。

--空城诸葛不能选择。

end

feasible=function(self,targets)

return #targets==2

--只有选择了2名玩家时，才能使用牌

end

--on_use 和 on_effect 为牌的效果执行。他们的区别在于生效时机的不同。

--on_use在牌被使用时生效，而on_effect在牌在使用中对某一名目标进行结算时生效。

--因此，在不存在需要结算“一名玩家对另一名指定的玩家”的效果时，使用on_use实行效果即可；

--存在指定的目标时，则原则上应该使用on_effect。

--on_use和on_effect可以同时存在。牌效果进行结算时，先执行on_use，然后对每名目标

执行on_effect

--以下为“雷击牌”的on_effect方法：

on_effect=function(self,effect)

--effect 为一个CardEffectStruct，其from和to为player对象，代表谁使用的牌对谁结算

local from=effect.from

local to =effect.to

local room=to:getRoom()

--sefEmotion在玩家的头像上显示表情

room:setEmotion(to,"bad")

--进行判定时，首先创建“判定”对象。

--pattern为一个正则表达式，由冒号隔开的三段分别匹配牌名、花色和点数

--good的定义和之后的判定结果获取有关。

--原则上，之前的pattern与判定牌匹配时，如果这种情况下执行的效果对于判定者来说是“好”的，

--那么good应该是true。

local judge=sgs.JudgeStruct()

judge.pattern=sgs.QRegExp("(.*):(spade):(.*)")

judge.good=false

judge.reason="leiji"

judge.who=to

--然后，让room根据此判定对象进行判定。判定结果依然在judge里面。

room:judge(judge)

--如果判定结果是一个“坏”结果，那么造成伤害

if judge.isBad() then

--和判定一样，造成伤害时先创建伤害struct,然后交由room:damage执行

local damage=sgs.DamageStruct()

damage.card = nil

damage.damage = 2

damage.from = from

damage.to = to

damage.nature = sgs.DamageStruct_Thunder

room:damage(damage)

else

room:setEmotion(from,"bad")

end

end,

--以下为孙权“制衡”的on_use方法：

on_use=function(self,room,source,targets)

--self代表技能牌本身。由于是将“任意张牌当成制衡牌打出”，

--因此弃置制衡牌就等于弃置所有用来发动制衡的牌，也即被制衡掉的牌。

room:throwCard(self)

--摸取相当于被用来发动制衡的牌的数目的牌。

--可以用self:getSubcards()来获取这些牌的QList。

room:drawCards(source,self:getSubcards():length())

end,

--技能讲解4：基本技能类型的组合与复杂技能的实现

--大多数技能都不是单独使用ViewAsSkill或者TriggerSkill就可以实现的。复杂的技能往往需要结合多种基本技能。

--一个的技能的描述，往往可以分成3部分：发动的时机、发动代价、效果。

--对于发动时机的控制，是只有触发技可以实现的。触发技可以在任何“有定义的时机”时产生作用。然而，对于需要根据消耗牌来决定效果的那些技能，用触发技往往无法实现，也很难符合游戏流程。

--ViewAsSkill可以非常完美地实现技能的发动流程。只有VIewAsSkill可以细致地操纵玩家发动技能所付出的代价。然而，ViewAsSkill本身并没有技能效果的实现，只能使用游戏牌作为技能效果，或者借助SkillCard。

--SkillCard本身并不是一个技能，但是只有他可以把技能发动用牌和技能效果联系起来。它对于ViewAsSkill而言是必需的。

--1.结合基本技能的方法：

--我们把技能效果定义在一个技能牌skill_card当中，技能牌的定义可以不从属于任何技能。然后，由于时机判断是整个技能的发动最先进行的一步，我们将ViewAsSkill定义在TriggerSkill当中。最后，我们把TriggerSkill的发动效果设为“询问使用skill_card”，而ViewAsSkill的效果设为“你可以将特定牌作为skill_card使用或打出”。如此，即实现了“xxx时，你可以使用xx牌发动，执行xxx效果。”

--以下为大乔流离技能的实现：

liuli_card=sgs.CreateSkillCard{

name="liuli_effect",

target_fixed=false,

will_throw=true,

filter=function(self,targets,to_select)

if #targets>0 then return false end

if to_select:hasFlag("slash_source") then return false end

local card_id=self:getSubcards()[1]

if sgs.Self:getWeapon() and sgs.Self:getWeapon():getId()==card_id then return sgs.Self:distanceTo(to_select)<=1

end

return sgs.Self:canSlash(to_select,true)

end,

on_effect=function(self,effect)

effect.to:getRoom():setPlayerFlag(effect.to,"liuli_target")

end

}

liuli_viewAsSkill=sgs.CreateViewAsSkill{

name="liuli_viewAs",

n=1,

view_filter=function(self, selected, to_select)

return true

end,

view_as=function(self, cards)

if #cards==0 then return nil end

local aliuli_card=liuli_card:clone()

--使用之前创建的skillCard的clone方法来创建新的skillCard

aliuli_card:addSubcard(cards[1])

return aliuli_card

end,

enabled_at_play=function()

return false

end,

enabled_at_response=function()

return sgs.Self:getPattern()=="#liuli_effect"

--仅在询问流离时可以发动此技能

end

}

liuli_triggerSkill=sgs.CreateTriggerSkill{

name="liuli_main",

view_as_skill=liuli_viewAsSkill,

events={sgs.CardEffected},

on_trigger=function(self,event,player,data)

local room=player:getRoom()

local players=room:getOtherPlayers(player)

local effect=data:toCardEffect()

if effect.card:inherits("Slash") and (not player:isNude()) and room:alivePlayerCount()>2 then

local canInvoke

for _,aplayer in sgs.qlist(players) do

if player:canSlash(aplayer) then

canInvoke=true

end

end

if not canInvoke then return end

local prompt="#liuli_effect:"..effect.from:objectName()

room:setPlayerFlag(effect.from,"slash_source")

if room:askForUseCard(player,"#liuli_effect",prompt) then

room:output("ha?")

for _,aplayer in sgs.qlist(players) do

if aplayer:hasFlag("liuli_target") then

room:setPlayerFlag(effect.from,"-slash_source")

room:setPlayerFlag(aplayer,"-liuli_target")

effect.to=aplayer

room:cardEffect(effect)

return true

end

end

end

end

end,

}

sgs.LoadTranslationTable{

["liuli_main"] = "lua流离",

[":liuli_main"] = "和流离技能描述一摸一样",

["#liuli_effect"] = "和流离的询问字串一摸一样",

}

--翻译代码

--技能实现说明：

--此技能的实现分3个部分

--第一部分是流离牌，效果为“将目标标记为流离对象”

--第二部分是流离ViewAsSkill，“每当你需要打出一张流离牌时，你可以将任意一张牌当作流离牌打出”

--第三部分是流离TriggerSkill，“触发技，每当你成为杀的目标时，你可以打出一张流离牌，然后让具有流离标记的对象代你成为杀的目标”