jianyu/jianyu.lua

2559 lines
95 KiB
Lua
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

local extension = Package:new("jianyu_standard")
extension.extensionName = "jianyu"
local U = require "packages/utility/utility"
Fk:loadTranslationTable {
["jianyu"] = [[简浴]],
["jianyu_standard"] = [[简浴]],
["jy"] = "简浴",
}
-- 简自豪
local jy__jianzihao = General(extension, "jy__jianzihao", "qun", 8)
-- 红温
local jy_hongwen = fk.CreateFilterSkill {
name = "jy_hongwen",
card_filter = function(self, to_select, player)
return player:hasSkill(self) and to_select.suit ~= Card.Heart
end,
view_as = function(self, to_select)
return Fk:cloneCard(to_select.name, Card.Heart, to_select.number)
end,
}
-- 走位
local jy_zouwei = fk.CreateDistanceSkill {
name = "jy_zouwei",
correct_func = function(self, from, to)
-- 有装备时视为-1
if from:hasSkill(self) and #from:getCardIds(Player.Equip) ~= 0 then
return -1
end
-- 没装备时视为+1
if to:hasSkill(self) and #to:getCardIds(Player.Equip) == 0 then
return 1
end
return 0
end,
}
-- TODO写一个语音触发游戏开始时、装备时、没有装备时
-- 圣弩
-- 参考自formation包的君刘备
local jy_shengnu = fk.CreateTriggerSkill {
name = "jy_shengnu",
anim_type = 'drawcard',
events = { fk.AfterCardsMove },
frequency = Skill.Limited,
can_trigger = function(self, event, target, player, data)
if not player:hasSkill(self) then return false end
if player:usedSkillTimes(self.name, Player.HistoryGame) ~= 0 then return false end
for _, move in ipairs(data) do
if move.to ~= player.id and (move.toArea == Card.PlayerEquip or move.toArea == Card.DiscardPile) then
for _, info in ipairs(move.moveInfo) do
if Fk:getCardById(info.cardId).name == "crossbow" then
return true
end
end
end
end
end,
on_use = function(self, event, target, player, data)
local ids = {}
for _, move in ipairs(data) do
if move.to ~= player.id and (move.toArea == Card.PlayerEquip or move.toArea == Card.DiscardPile) then
for _, info in ipairs(move.moveInfo) do
if Fk:getCardById(info.cardId).name == "crossbow" then
table.insert(ids, info.cardId)
end
end
end
end
local dummy = Fk:cloneCard("dilu")
dummy:addSubcards(ids)
player.room:obtainCard(player, dummy, true, fk.ReasonPrey)
end,
}
-- 洗澡
local jy_xizao = fk.CreateTriggerSkill {
name = "jy_xizao",
anim_type = "defensive",
frequency = Skill.Limited,
events = { fk.AskForPeaches },
can_trigger = function(self, event, target, player, data)
return target == player and player:hasSkill(self) and player.dying and
player:usedSkillTimes(self.name, Player.HistoryGame) == 0
end,
on_use = function(self, event, target, player, data)
local room = player.room
if player.dead then return end
-- player:reset()
player:drawCards(3, self.name)
if player.dead or not player:isWounded() then return end
room:recover({
who = player,
num = math.min(#room:getAlivePlayers(), player.maxHp) - player.hp,
recoverBy = player,
skillName = self.name,
})
player:turnOver()
end,
}
-- 开局
-- 参考forest包贾诩 刘备 god包神曹操
local jy_kaiju = fk.CreateTriggerSkill {
name = "jy_kaiju", -- jy_kaiju$是主公技
anim_type = "masochism",
frequency = Skill.Compulsory,
events = { fk.EventPhaseStart },
can_trigger = function(self, event, target, player, data)
return target == player and player:hasSkill(self) and player.phase == Player.Start
end,
on_use = function(self, event, target, player, data)
local room = player.room
for _, p in ipairs(room:getOtherPlayers(player, true)) do
if not p:isAllNude() and not player.dead then -- 如果我自己死了,那就不要继续了
local id = room:askForCard(p, 1, 1, true, self.name, false, nil, "#jy_kaiju-choose")
if #id ~= 0 then
room:moveCardTo(id, Card.PlayerHand, player, fk.ReasonJustMove, self.name, nil, false, nil)
room:useVirtualCard("slash", nil, p, player, self.name, true) -- 杀
end
end
end
end,
}
-- local id = room:askForCardChosen(player, p, "hej", self.name) -- 我选他一张牌
jy__jianzihao:addSkill(jy_kaiju)
jy__jianzihao:addSkill(jy_hongwen)
jy__jianzihao:addSkill(jy_zouwei)
jy__jianzihao:addSkill(jy_shengnu)
jy__jianzihao:addSkill(jy_xizao)
Fk:loadTranslationTable {
["jy__jianzihao"] = "简自豪",
["#jy__jianzihao"] = "澡子哥",
["designer:jy__jianzihao"] = "导演片子怎么样了 & 考公专家",
["cv:jy__jianzihao"] = "简自豪",
["illustrator:jy__jianzihao"] = "简自豪",
["jy_kaiju"] = "开局",
[":jy_kaiju"] = [[锁定技,准备阶段,其他角色需交给你一张牌,视为对你使用一张【杀】。<br>
<font color="grey"><i>“从未如此美妙的开局!”</i></font>]],
["$jy_kaiju1"] = "不是啊我炸一对鬼的时候我在打什么打一对10。一对10他四个9炸我我不输了吗",
["$jy_kaiju2"] = "怎么赢啊?你别瞎说啊!",
["$jy_kaiju3"] = "打这牌怎么打?兄弟们快教我,我看着头晕!",
["$jy_kaiju4"] = "好亏呀,我每一波都。",
["$jy_kaiju5"] = "被秀了,操。",
["$jy_kaiju6"] = "从未如此美妙的开局请为我欢呼为我喝喝彩OK",
["$jy_kaiju7"] = "如此美妙的开局,这是我近两天来第一次啊!",
["$jy_kaiju8"] = "Oh my God我要珍惜这段时光我要好好地将它珍惜",
["#jy_kaiju-choose"] = "开局:交给简自豪一张牌,视为对他使用一张【杀】",
["jy_hongwen"] = "红温",
[":jy_hongwen"] = "锁定技,你的非<font color='red'>♥</font>牌视为<font color='red'>♥</font>牌。",
["$jy_hongwen1"] = "唉,不该出水银的。",
["$jy_hongwen2"] = "哎,兄弟我为什么不打四带两对儿啊,兄弟?",
["$jy_hongwen3"] = "好难受啊!",
["$jy_hongwen4"] = "操,可惜!",
["$jy_hongwen5"] = "这是咋想的呀?",
["jy_zouwei"] = "走位",
[":jy_zouwei"] = "锁定技,当你的装备区没有牌时,其他角色计算与你的距离+1当你的装备区有牌时你计算与其他角色的距离-1。",
["$jy_zouwei1"] = "玩一下,不然我是不是一张牌没有出啊兄弟?",
["$jy_zouwei2"] = "完了呀!",
["jy_shengnu"] = "圣弩",
[":jy_shengnu"] = "限定技,当【诸葛连弩】移至弃牌堆或其他角色的装备区时,你可以获得之。",
["$jy_shengnu1"] = "哎兄弟们我这个牌不能拆吧?",
["$jy_shengnu2"] = "补刀瞬间回来了!",
["$jy_shengnu3"] = "恶心我,我也恶心你啊,互恶心呗!",
["jy_xizao"] = "洗澡",
[":jy_xizao"] = "限定技你处于濒死状态时可以将体力恢复至X点、摸三张牌并翻面X为存活角色数。",
["$jy_xizao1"] = "呃啊啊啊啊啊啊啊!!",
["$jy_xizao2"] = "也不是稳赢吧,我觉得赢了!",
["$jy_xizao3"] = "真的我是真玩不了,这跟变态没关系,我好他妈的气!",
["~jy__jianzihao"] = "好像又要倒下了……",
}
-- 第二代简自豪
local jy__jianzihao = General(extension, "jy__new__jianzihao", "god", 3)
local jy_sanjian = fk.CreateTriggerSkill {
name = "jy_sanjian",
anim_type = "drawcard",
frequency = Skill.Compulsory,
events = { fk.EventPhaseStart }, -- 事件开始时
can_trigger = function(self, event, target, player, data)
return target == player and player:hasSkill(self) -- 如果是我这名角色如果是有这个技能的角色如果是出牌阶段如果这名角色的装备数是3
and player.phase == Player.Play and #player:getCardIds(Player.Equip) >= 3
end,
on_use = function(self, event, target, player, data)
local room = player.room
room:useVirtualCard("analeptic", nil, player, player, self.name, false)
room:useVirtualCard("ex_nihilo", nil, player, player, self.name, false)
end,
}
local jy_kaiju_2 = fk.CreateActiveSkill {
name = "jy_kaiju_2",
anim_type = "offensive",
can_use = function(self, player)
return player:usedSkillTimes(self.name, Player.HistoryPhase) == 0
end,
card_filter = function(self, card)
return false
end,
card_num = 0,
target_filter = function(self, to_select, selected)
-- 判断目标是否不能成为【顺手牵羊】的目标
local s = Fk:currentRoom():getPlayerById(to_select)
local snatch = Fk:cloneCard("snatch")
if Self:isProhibited(s, snatch) then -- 前面的是自己,后面的是别人!
return false
end
return to_select ~= Self.id and -- 如果目标不是自己
not s:isAllNude() and -- 而且不是啥也没有,那就可以对他用这个技能
#selected < 2
end,
min_target_num = 1,
max_target_num = 2,
on_use = function(self, room, use)
local player = room:getPlayerById(use.from)
-- TODOsort use.tos
for _, to in ipairs(use.tos) do
local p = room:getPlayerById(to)
if not player.dead then
room:useVirtualCard("snatch", nil, player, p, self.name, true) -- 顺
end
end
end,
}
jy__jianzihao:addSkill(jy_kaiju_2)
jy__jianzihao:addSkill(jy_sanjian)
jy__jianzihao:addSkill("jy_shengnu")
jy__jianzihao:addSkill("jy_xizao")
Fk:loadTranslationTable {
["jy__new__jianzihao"] = "简自豪",
["#jy__new__jianzihao"] = "无冕之王",
["designer:jy__new__jianzihao"] = "考公专家",
["cv:jy__new__jianzihao"] = "简自豪",
["illustrator:jy__new__jianzihao"] = "简自豪",
["jy_kaiju_2"] = "开局",
[":jy_kaiju_2"] = "出牌阶段限一次你可以指定至多2名角色视为你对其使用一张【顺手牵羊】无距离限制",
["$jy_kaiju_21"] = "不是啊我炸一对鬼的时候我在打什么打一对10。一对10他四个9炸我我不输了吗",
["$jy_kaiju_22"] = "怎么赢啊?你别瞎说啊!",
["$jy_kaiju_23"] = "打这牌怎么打?兄弟们快教我,我看着头晕!",
["$jy_kaiju_24"] = "好亏呀,我每一波都。",
["$jy_kaiju_25"] = "被秀了,操。",
["$jy_kaiju_26"] = "从未如此美妙的开局请为我欢呼为我喝喝彩OK",
["$jy_kaiju_27"] = "如此美妙的开局,这是我近两天来第一次啊!",
["$jy_kaiju_28"] = "Oh my God我要珍惜这段时光我要好好地将它珍惜",
["jy_sanjian"] = "三件",
[":jy_sanjian"] = [[锁定技,出牌阶段开始时,若你的装备区有至少三张牌,你视为使用一张【酒】和一张【无中生有】。]],
["$jy_sanjian1"] = "也不是稳赢吧,我觉得赢了!",
["~jy__jianzihao"] = "好像又要倒下了……",
}
-- 李元浩
local jy__liyuanhao = General(extension, "jy__liyuanhao", "qun", 4)
local jy_huxiao = fk.CreateViewAsSkill {
name = "jy_huxiao",
mute = true,
pattern = "jink,analeptic",
expand_pile = "jy__liyuanhao_xiao",
enabled_at_play = function(self, player)
return #player:getPile("jy__liyuanhao_xiao") ~= 0
end,
enabled_at_response = function(self, player, response)
return #player:getPile("jy__liyuanhao_xiao") ~= 0
end,
interaction = function()
local names = {}
for _, name in ipairs({ "jink", "analeptic" }) do
local c = Fk:cloneCard(name)
if (Fk.currentResponsePattern == nil and c.skill:canUse(Self, c)) or
(Fk.currentResponsePattern and Exppattern:Parse(Fk.currentResponsePattern):match(c)) then
table.insertIfNeed(names, name)
end
end
return UI.ComboBox { choices = names }
end,
card_filter = function(self, to_select, selected)
if #selected == 1 then return false end
if #Self:getPile("jy__liyuanhao_xiao") == 0 then return false end
if Self:getPileNameOfId(to_select) ~= "jy__liyuanhao_xiao" then return false end
return true
end,
view_as = function(self, cards)
if not self.interaction.data then return nil end
if #cards ~= 1 then
return nil
end
local card = Fk:cloneCard(self.interaction.data)
card.skillName = self.name
card:addSubcards(cards)
return card
end,
}
local jy_huxiao_xiao = fk.CreateTriggerSkill {
name = "#jy_huxiao_xiao",
mute = true,
events = { fk.CardResponding, fk.CardUsing }, -- 包括了使用和打出
can_trigger = function(self, event, target, player, data)
if player:hasSkill(self) and data.card and data.card.trueName == "slash" then
return target == player
end
end,
on_cost = function(self, event, target, player, data)
return player.room:askForSkillInvoke(player, "jy_huxiao")
end,
on_use = function(self, event, target, player, data)
local room = player.room
player:broadcastSkillInvoke("jy_huxiao")
room:notifySkillInvoked(player, "jy_huxiao", "drawcard")
local dummy = Fk:cloneCard("dilu")
dummy:addSubcards(room:getNCards(1))
player:addToPile("jy__liyuanhao_xiao", dummy, true, self.name)
end,
}
-- 界二段
local jy_erduanxiao = fk.CreateTriggerSkill {
name = "#jy_erduanxiao",
anim_type = "support",
mute = true,
refresh_events = { fk.BeforeCardsMove }, -- 理论上来说每次牌的移动只有同一个方向的
frequency = Skill.Compulsory,
-- 测试通过。1-23-2都可以顺利触发。
-- 我猜想原因是1-2的时候可能有多张牌进出而3-2的时候只会有一张牌出去。但我搞不懂这个数据结构
-- 不知道为什么有一个是两层循环,有一个是一层循环。
can_refresh = function(self, event, target, player, data)
if not player:hasSkill(self) then return end -- 如果我自己没有这个技能,那就算了
local xiaos = player:getPile("jy__liyuanhao_xiao")
player.is_xiao_changing = nil -- TODO建议改成data.is_xiao_changing
-- 判断是否有牌出去
for _, move in ipairs(data) do -- 第一层循环,不知道为啥
if move.from then -- 照着抄的,牌离开
-- print("有牌正打算离开")
if move.from == player.id then
-- print("有牌正打算从你家离开")
if #xiaos == 3 then
-- print("啸是3")
for _, info in ipairs(move.moveInfo) do -- 还有第二层循环。我自己的代码里没有第二层
if info.fromArea == Card.PlayerSpecial then -- 出去的时候不需要判断specialName因为去的是弃牌堆
-- print("有牌正打算从你家特殊区离开")
return true
end
end
end
end
end
end
-- 判断是否有牌进来
if #xiaos == 1 then -- 如果啸是1
for _, move in ipairs(data) do
if move.to == player.id and move.toArea == Card.PlayerSpecial and
move.specialName == "jy__liyuanhao_xiao" then
return true
end
end
end
end,
on_refresh = function(self, event, target, player, data)
local xiaos = player:getPile("jy__liyuanhao_xiao")
player.is_xiao_changing = #xiaos
end,
events = { fk.AfterCardsMove },
can_trigger = function(self, event, target, player, data)
local xiaos = player:getPile("jy__liyuanhao_xiao")
if #xiaos == player.is_xiao_changing then return false end
return player:hasSkill(self) and -- 如果是有二段啸的角色
#player:getPile("jy__liyuanhao_xiao") == 2 -- 如果啸为2
end,
on_cost = function(self, event, target, player, data)
return true
end,
on_use = function(self, event, target, player, data)
local xiaos = player:getPile("jy__liyuanhao_xiao")
local room = player.room
player:broadcastSkillInvoke("jy_huxiao")
room:notifySkillInvoked(player, "jy_huxiao", "drawcard")
-- 将所有“啸”纳入自己的手牌
room:moveCardTo(xiaos, Card.PlayerHand, player, fk.ReasonJustMove, self.name, "jy__liyuanhao_xiao", true,
player.id)
room:recover({
who = player,
num = 1,
recoverBy = player,
skillName = self.name,
})
end,
}
jy_huxiao:addRelatedSkill(jy_erduanxiao)
jy_huxiao:addRelatedSkill(jy_huxiao_xiao)
jy__liyuanhao:addSkill(jy_huxiao)
Fk:loadTranslationTable {
["jy__liyuanhao"] = "李元浩",
["#jy__liyuanhao"] = "虎大将军",
["designer:jy__liyuanhao"] = "拂却心尘 & 考公专家",
["cv:jy__liyuanhao"] = "暂无",
["illustrator:jy__liyuanhao"] = "李元浩",
["jy__liyuanhao_xiao"] = "",
["jy_huxiao"] = "虎啸",
[":jy_huxiao"] = [[当你使用或打出一张【杀】时可以将牌堆顶的一张牌置于武将牌上称为“啸”你可以将“啸”当【酒】或【闪】使用或打出。每当你的“啸”数为2时你将所有“啸”收入手牌并恢复一点体力。<br><font color="grey"><i>“我希望我的后辈们能够记住,在你踏上职业道路的这一刻开始,你的目标就只有,冠军。”</i></font>]],
}
-- 高天亮
local jy__gaotianliang = General(extension, "jy__gaotianliang", "shu", 4)
local jy_yuyu = fk.CreateTriggerSkill {
name = "jy_yuyu",
anim_type = "masochism",
events = { fk.Damaged },
on_trigger = function(self, event, target, player, data)
local room = player.room
self.this_time_slash = false
if data.card and data.from and data.card.trueName == "slash" then -- 如果是杀
if data.from:getMark("@jy_yuyu_enemy") == 0 then -- 如果他不是敌人
self.this_time_slash = true -- 如果他是因为这次伤害变成了天敌那么写在this_time_slash里
room:setPlayerMark(data.from, "@jy_yuyu_enemy", "") -- 空字符串也是true
end
end
if self.this_time_slash or data.from:getMark("@jy_yuyu_enemy") == 0 then -- 如果他不是敌人
self:doCost(event, target, player, data)
end
end,
on_cost = function(self, event, target, player, data)
local room = player.room
local cost = room:askForSkillInvoke(player, self.name, data)
if cost then
local choices = { "#jy_yuyu_draw3", "#jy_yuyu_draw4turnover" }
self.choice = room:askForChoice(player, choices, self.name, "#jy_yuyu_ask_which") -- 如果玩家确定使用,询问用哪个
end
return cost
end,
on_use = function(self, event, target, player, data)
if self.choice == "#jy_yuyu_draw3" then
player:drawCards(3, self.name)
else
player:drawCards(4, self.name)
player:turnOver()
Fk:currentRoom():damage({
from = player,
to = player,
damage = 1,
damageType = fk.NormalDamage,
skillName = self.name,
})
end
self.this_time_slash = false
end,
}
local jy_yuyu_trigger = fk.CreateTriggerSkill {
name = "#jy_yuyu_trigger",
mute = true,
events = { fk.DamageCaused },
can_trigger = function(self, event, target, player, data)
return player:hasSkill(self) and target == player and data.to:getMark("@jy_yuyu_enemy") ~= 0 and
not data.chain
end,
on_cost = Util.TrueFunc,
on_use = function(self, event, target, player, data)
local room = player.room
player:broadcastSkillInvoke("jy_yuyu")
room:notifySkillInvoked(player, "jy_yuyu")
data.damage = data.damage + 1
end,
}
jy_yuyu:addRelatedSkill(jy_yuyu_trigger)
jy__gaotianliang:addSkill(jy_yuyu)
Fk:loadTranslationTable {
["jy__gaotianliang"] = "高天亮",
["#jy__gaotianliang"] = "沉默寡言",
["designer:jy__gaotianliang"] = "导演片子怎么样了 & 考公专家",
["cv:jy__gaotianliang"] = "高天亮",
["illustrator:jy__gaotianliang"] = "高天亮",
["jy_yuyu"] = "玉玉",
[":jy_yuyu"] = [[当有角色对你使用【杀】造成了伤害时其获得“致郁”。受到没有“致郁”的角色或因本次伤害而获得“致郁”的角色造成的伤害时你可以选择一项摸3张牌摸4张牌并翻面然后对自己造成1点伤害。你对持有“致郁”的角色造成的非传导伤害+1。]],
["@jy_yuyu_enemy"] = "致郁",
["#jy_yuyu_ask_which"] = "玉玉:请选择你要触发的效果",
["#jy_yuyu_draw3"] = "摸3张牌",
["#jy_yuyu_draw4turnover"] = "摸4张牌并翻面然后对自己造成1点伤害",
["$jy_yuyu1"] = "我……我真的很想听到你们说话……",
["$jy_yuyu2"] = "我天天被队霸欺负,他们天天骂我。",
["$jy_yuyu3"] = "有什么话是真的不能讲的……为什么一定……每次都是……一个人在讲……",
["~jy__gaotianliang"] = "顶不住啦!我每天都活在水深火热里面。",
}
-- 阿威罗
local jy__aweiluo = General(extension, "jy__aweiluo", "qun", 3)
-- 游龙
local jy_youlong = fk.CreateTriggerSkill {
name = "jy_youlong",
anim_type = "support",
frequency = Skill.Compulsory,
events = { fk.EventPhaseStart },
can_trigger = function(self, event, target, player, data)
return target == player and player:hasSkill(self)
and player.phase == Player.Start
end,
on_use = function(self, event, target, player, data)
local room = player.room
for _, p in ipairs(room:getAlivePlayers(player, true)) do
-- getAlivePlayers 只需要一个参数。这里为什么两个也行?
if not p:isKongcheng() then -- 如果他有手牌
local id = room:askForCard(p, 1, 1, false, self.name, false, nil, "#jy_youlong-choose")
assert(id)
local next = p.next -- 下家
while next.dead do -- 一直找,直到找到一个活的下家
next = next.next
end
room:moveCardTo(id, Card.PlayerHand, next, fk.ReasonJustMove, self.name, nil, false, player.id)
end
end
end,
}
-- 核爆
local jy_hebao = fk.CreateTriggerSkill {
name = "jy_hebao",
anim_type = "special",
events = { fk.EventPhaseProceeding },
can_trigger = function(self, event, target, player, data)
return target == player and player:hasSkill(self) and player.phase == Player.Start
end,
on_cost = function(self, event, target, player, data)
local room = player.room
local id = room:askForCard(player, 1, 1, false, self.name, true, nil, "#jy_hebao-choose")
player:addToPile("jy_aweiluo_dian", id, true, self.name)
end,
}
-- 跳水
local jy_tiaoshui = fk.CreateTriggerSkill {
name = "jy_tiaoshui",
anim_type = "special",
events = { fk.Damaged },
can_trigger = function(self, event, target, player, data)
local dians = player:getPile("jy_aweiluo_dian")
return target == player and target:hasSkill(self.name) and
#dians ~= 0
end,
on_use = function(self, event, target, player, data)
local room = player.room
-- local dians = player:getPile("jy_aweiluo_dian")
-- 以后“选择一张特殊区的牌并且弃置”这个要求就这么写。
local id = room:askForCard(player, 1, 1, false, self.name, true, ".|.|.|jy_aweiluo_dian|.|.|.", "#jy_tiaoshui",
"jy_aweiluo_dian", true)
room:throwCard(id, self.id, player, player)
-- askForDiscard 函数是不能对特殊区的牌生效的
-- local id = room:askForDiscard(player, 1, 1, false, self.name, true, ".|.|.|jy_aweiluo_dian|.|.|.", "#jy_tiaoshui", false, true)
end,
}
-- 罗绞
-- 这个技能难以实现。目前好像还没看到其他的武将是“特殊区牌量变化时执行效果”的,一般都是某个特定的时机触发,
-- 如邓艾,在准备阶段才判断有几张。所以我注释写详细一点,方便其他开发者参考。
-- 其实前面的两个李元浩也是这样。不过这个技能比那两个更复杂,解释这个会比较好。
--
-- 新月杀现有的函数无法判断一张牌移动时,如果是离开特殊区,离开的是否是某特定的特殊区(在这个技能里,是“点”)。我们作如下设计:
-- 罗绞主技能监视“卡牌移动前”事件,将卡牌移动前的“点”数量记录,并传给另一个关联技能,其监视“卡牌移动后”事件,也记录一次移动后“点”的数量。
-- 如果卡牌移动之后“点”数没有变化,那么不要触发。
-- 这样就能防止当其他人给我挂上或丢掉其他特殊区的牌时,也触发我们的技能。
-- TODO可以参考曹植落英把这个技能写得更简洁上面的技能也是。但是能跑就行
local jy_luojiao = fk.CreateTriggerSkill {
name = "jy_luojiao",
anim_type = "offensive",
refresh_events = { fk.BeforeCardsMove }, -- 在每次牌移动之前
mute = true, -- 不声明使用了这个技能
can_refresh = function(self, event, target, player, data) -- 使用refresh而不是trigger是因为这个技能不需要询问玩家是否触发
if not player:hasSkill(self) then return end -- 如果我自己没有这个技能,那就不触发了
-- 先清理自家变量
player.is_luojiao_archery_attack_may_be_triggered = false
player.is_dian_may_changing = nil
local dians = player:getPile("jy_aweiluo_dian") -- dians是“点”的牌
-- 判断是否有牌进出特殊区
-- 为什么不用data传参数因为这里是BeforeCardsMove后面是AfterCardsMove两个不是同一个事件data不一样。用player
-- 判断是否有牌出去
for _, move in ipairs(data) do
if move.from then
if move.from == player.id then
for _, info in ipairs(move.moveInfo) do
if info.fromArea == Card.PlayerSpecial then -- 出去的时候不需要判断,因为去的是弃牌堆
-- 如果点是5那么有可能可以触发万箭齐发
if #dians == 5 then player.is_luojiao_archery_attack_may_be_triggered = true end
return true
end
end
end
end
end
-- 判断是否有牌进来
for _, move in ipairs(data) do
if move.to == player.id and move.toArea == Card.PlayerSpecial and move.specialName == "jy_aweiluo_dian" then
-- 如果点是3那么有可能可以触发万箭齐发
if #dians == 3 then player.is_luojiao_archery_attack_may_be_triggered = true end
return true
end
end
end,
on_refresh = function(self, event, target, player, data)
-- 触发之后,设置变量,告诉下一个函数有没有可能在发生变化
local dians = player:getPile("jy_aweiluo_dian")
player.is_dian_may_changing = #dians
-- 必须使用player来储存该变量因为后面的事件使用的是另一个函数jy_luojiao_after如果你用self那个函数是看不到的
end,
}
-- 使用同一个函数来判断是否触发了南蛮和万箭
local jy_luojiao_after = fk.CreateTriggerSkill {
name = "#jy_luojiao_after", -- 这个技能的名字
events = { fk.AfterCardsMove }, -- 卡牌移动之后如果can_trigger返回真那就可以发动这个技能
-- can_trigger是用来判断是否能触发这个技能的返回真就能触发返回假就不能触发
can_trigger = function(self, event, target, player, data)
if not player:hasSkill(self) then return false end
if not player.is_dian_may_changing then return false end -- 如果“点”有可能在变化
local dians = player:getPile("jy_aweiluo_dian")
-- 如果卡牌移动前和移动后“点”相同那就证明是其他的特殊区的牌直接return
if player.is_dian_may_changing == #dians then return false end
-- 判断是否有两张同样花色的“点”若有返回false若没有返回true
if #dians == 0 then return false end -- 设计者说1张也可以发动南蛮
local dict = {}
local is_luojiao_suit_satisfied = true
for _, c in ipairs(dians) do
local suit = Fk:getCardById(c).suit
if dict[suit] then
-- 有相同的花色,不执行
is_luojiao_suit_satisfied = false
break
else
dict[suit] = true
end
end
-- 万箭需要满足的条件点数为4且之前已经告诉我有可能触发
player.is_archery_attack =
player.is_luojiao_archery_attack_may_be_triggered and
#player:getPile("jy_aweiluo_dian") == 4
-- 南蛮需要满足的条件:花色全部不同
-- 且本回合未使用过(目前已删除)
player.is_savage_assault = is_luojiao_suit_satisfied
-- and player:usedSkillTimes(self.name) == 0
-- 万箭或南蛮满足,返回真
return player.is_archery_attack or player.is_savage_assault
end,
-- on_cost代表执行该技能时要做什么事情
on_cost = function(self, event, target, player, data)
local room = player.room
self.first = nil -- 如果两个条件都满足,这个变量存储谁是第一个使用的牌
-- 如果两个条件都满足
if player.is_archery_attack and player.is_savage_assault then
if room:askForSkillInvoke(player, self.name, nil, "#jy_luojiao_both_ask") then -- 都触发了,询问是否要使用罗绞
local choices = { "archery_attack", "savage_assault" }
self.first = room:askForChoice(player, choices, self.name, "#jy_luojiao_ask_which") -- 如果玩家确定使用,询问先用哪张牌
return true
end
end
-- 因为南蛮触发的比万箭多,所以把南蛮放到前面提高效率
-- 如果南蛮的条件满足
if player.is_savage_assault then
if room:askForSkillInvoke(player, self.name, nil, "#jy_luojiao_savage_assault_ask") then -- 那么问是否要发动
self.do_savage_assault = true
return true
end
end
-- 如果万箭的条件满足
if player.is_archery_attack then
if room:askForSkillInvoke(player, self.name, nil, "#jy_luojiao_archery_attack_ask") then -- 那么问是否要发动
self.do_archery_attack = true
return true
end
end
-- 如果玩家选择不触发,那擦屁股,这次“点”结算完成了
self.do_archery_attack = false
self.do_savage_assault = false
self.first = nil
player.is_dian_may_changing = false
player.is_archery_attack = false
player.is_savage_assault = false
return false
end,
on_use = function(self, event, target, player, data)
local room = player.room
if self.first then -- 如果self.first这个值有那就代表两个条件同时满足
local cards
local skill_names
-- 这样写方便以后扩展,也可以更好地移植到别的代码里去
if self.first == "archery_attack" then -- 如果玩家选择先用万箭
cards = { "archery_attack", "savage_assault" }
skill_names = { "#jy_luojiao_archery_attack", "#jy_luojiao_savage_assault" }
else
cards = { "savage_assault", "archery_attack" }
skill_names = { "#jy_luojiao_savage_assault", "#jy_luojiao_archery_attack" }
end
-- assert(#cards == #skill_names)
-- 对于
for i = 1, #cards do
if room:askForSkillInvoke(player, skill_names[i]) then -- 如果同意发动这个技能
room:notifySkillInvoked(player, skill_names[i], "offensive") -- 在武将上显示这个技能的名字
player:broadcastSkillInvoke("jy_luojiao") -- 播放这个技能的语音
room:useVirtualCard(cards[i], nil, player, room:getOtherPlayers(player, true), self.name, true)
end
end
else -- 如果没有两个条件同时满足,那满足谁就执行谁
-- 满足万箭,执行万箭
if self.do_archery_attack then
room:notifySkillInvoked(player, "jy_luojiao", "offensive")
player:broadcastSkillInvoke("jy_luojiao")
room:useVirtualCard("archery_attack", nil, player, room:getOtherPlayers(player, true), self.name, true)
end
-- 满足南蛮,执行南蛮
if self.do_savage_assault then
room:notifySkillInvoked(player, "jy_luojiao", "offensive")
player:broadcastSkillInvoke("jy_luojiao")
room:useVirtualCard("savage_assault", nil, player, room:getOtherPlayers(player, true), self.name, true)
end
end
-- 一次“点”的变化结算完成,把所有变量都设为初始
self.do_archery_attack = false
self.do_savage_assault = false
self.first = nil
player.is_dian_may_changing = false
player.is_archery_attack = false
player.is_savage_assault = false
end
}
jy_luojiao:addRelatedSkill(jy_luojiao_after)
-- 玉玊
local jy_yusu = fk.CreateTriggerSkill {
name = "jy_yusu",
anim_type = "special",
refresh_events = { fk.EventPhaseEnd },
can_refresh = function(self, event, target, player, data)
return target == player and player:hasSkill(self)
and player.phase == Player.Play
end,
on_refresh = function(self, event, target, player, data)
local room = player.room
room:setPlayerMark(player, "@jy_yusu_basic_count", 0)
end,
events = { fk.CardResponding, fk.CardUsing },
can_trigger = function(self, event, target, player, data)
if not player:hasSkill(self) then return false end
if type(player:getMark("@jy_yusu_basic_count")) ~= "number" then return false end
if player.phase ~= Player.NotActive and data.card and
data.card.type == Card.TypeBasic and target == player then
return true
end
end,
on_cost = function(self, event, target, player, data)
local room = player.room
room:addPlayerMark(player, "@jy_yusu_basic_count")
local basic_count = player:getMark("@jy_yusu_basic_count")
if basic_count == 2 then -- 第二张基本牌
return room:askForSkillInvoke(player, self.name)
end
end,
on_use = function(self, event, target, player, data)
local room = player.room
local id = data.card
player:addToPile("jy_aweiluo_dian", id, true, self.name)
room:setPlayerMark(player, "@jy_yusu_basic_count", "#jy_yusu_triggered")
end,
}
jy__aweiluo:addSkill(jy_youlong)
jy__aweiluo:addSkill(jy_hebao)
jy__aweiluo:addSkill(jy_tiaoshui)
jy__aweiluo:addSkill(jy_yusu)
jy__aweiluo:addSkill(jy_luojiao)
Fk:loadTranslationTable {
["jy__aweiluo"] = "阿威罗",
["#jy__aweiluo"] = "绝代双骄",
["designer:jy__aweiluo"] = "导演片子怎么样了 & 考公专家",
["cv:jy__aweiluo"] = "克里斯蒂亚诺·罗纳尔多·多斯·桑托斯·阿威罗 & 刘嘉远",
["illustrator:jy__aweiluo"] = "《时代》封面",
["jy_aweiluo_dian"] = "",
["jy_youlong"] = "游龙",
["#jy_youlong-choose"] = "游龙:选择一张手牌交给下家",
[":jy_youlong"] = "锁定技,准备阶段,有手牌的角色依次将一张手牌交给下家。",
["$jy_youlong1"] = "翩若惊鸿!婉若游龙!",
["jy_hebao"] = "核爆",
[":jy_hebao"] = "准备阶段,你可以将一张手牌作为“点”置于武将牌上。",
["#jy_hebao-choose"] = "核爆:选择一张手牌成为“点”",
["$jy_hebao1"] = "Siu~",
["jy_tiaoshui"] = "跳水",
[":jy_tiaoshui"] = "你受到伤害时,可以弃置一张“点”。",
["#jy_tiaoshui"] = "弃置一张“点”",
["$jy_tiaoshui1"] = "Siu, hahahaha!",
["jy_luojiao"] = "罗绞",
[":jy_luojiao"] = [[每当你的武将牌上的“点”的数量变化后若你有“点”且任意2张“点”的花色都不相同你可以视为使用一张【南蛮入侵】若你有4张“点”你可以视为使用一张【万箭齐发】。]],
["$jy_luojiao1"] = "Muchas gracias afición, esto es para vosotros, Siuuu!!",
["#jy_luojiao_after"] = "罗绞",
["#jy_luojiao_archery_attack"] = "罗绞·万箭",
["#jy_luojiao_savage_assault"] = "罗绞·南蛮",
["#jy_luojiao_archery_attack_ask"] = "“点”数量为4是否发动 罗绞·万箭",
["#jy_luojiao_savage_assault_ask"] = "“点”花色不同,是否发动 罗绞·南蛮",
["#jy_luojiao_both_ask"] = "罗绞 两个条件同时达成,是否发动",
["#jy_luojiao_ask_which"] = "罗绞 两个条件同时达成并发动,请选择要先视为使用的牌",
["jy_yusu"] = "玉玊",
[":jy_yusu"] = "你的回合内,你使用或打出第二张基本牌时,可以将其作为“点”置于武将牌上。",
["@jy_yusu_basic_count"] = "玉玊",
["$jy_yusu1"] = "Siu...",
["#jy_yusu_triggered"] = "已触发",
["~jy__aweiluo"] = "Messi, Messi, Messi, Messi...",
}
-- 水晶哥
-- 失去技能原创之魂2017薛综
-- 觉醒技:山包邓艾
-- 受到伤害一将2013曹冲
-- 没有次数距离限制:星火燎原刘焉
-- 无法被响应tenyear_huicui1 #gonghu_delay
-- 使用一张牌:诸葛恪,借刀
local jy__yangfan = General(extension, "jy__yangfan", "qun", 4)
-- 四吃3的选牌规则
Fk:addPoxiMethod {
name = "jy_sichi_3",
card_filter = function(to_select, selected)
-- 三张同类型的牌或两张不同类型的牌
-- 如果已选择卡牌数小于等于1直接返回真因为还不知道到底要选的是相同的还是不同的类型
if #selected <= 1 then return true end
-- 如果已选择卡牌数大于等于3直接返回假因为不可能再通过多选一张满足条件了
if #selected >= 3 then return false end
-- 如果已选择卡牌数为2检查它们的类型是否相同
if #selected == 2 then
local type = Fk:getCardById(to_select).type
local type1 = Fk:getCardById(selected[1]).type
local type2 = Fk:getCardById(selected[2]).type
-- 如果两张卡牌类型相同,那么对和它们类型相同的牌返回真,因为只能这样满足条件了
if type1 == type2 then
return type == type1
-- 如果两张卡牌类型不同,那么已经满足要求了,返回假
else
return false
end
end
-- 如果以上条件都不满足,返回真
return true
end,
feasible = function(selected)
if #selected <= 1 then
return false
elseif #selected == 2 then
return Fk:getCardById(selected[1]).type ~= Fk:getCardById(selected[2]).type
elseif #selected == 3 then
return Fk:getCardById(selected[1]).type == Fk:getCardById(selected[2]).type and
Fk:getCardById(selected[2]).type == Fk:getCardById(selected[3]).type
end
end,
prompt = function()
return Fk:translate("#jy_sichi_3")
end
}
-- 四吃
local jy_sichi = fk.CreateTriggerSkill {
name = "jy_sichi",
anim_type = "masochism",
events = { fk.Damaged },
on_use = function(self, event, target, player, data)
local room = player.room
-- 亮出四张牌
local card_ids = room:getNCards(4)
-- 放到过程区
room:moveCards({
ids = card_ids,
toArea = Card.Processing,
moveReason = fk.ReasonPut,
})
-- player:showCards(card_ids) -- 这个和上面的是一个效果,区别在于这个可以在牌上显示是自己展示的
-- 看花色有多少种,测试通过
local dict = { false, false, false, false }
local suit_count = 0
for _, c in ipairs(card_ids) do
local suit = Fk:getCardById(c).suit
if not dict[suit] then
dict[suit] = true
suit_count = suit_count + 1
end
end
assert(suit_count <= 4 and suit_count >= 1)
-- TODO:其实主要是担心如果用..它不会翻译成中文。有空可以试一下
local msg
if suit_count == 1 then
msg = "#jy_sichi_suits_1"
elseif suit_count == 2 then
msg = "#jy_sichi_suits_2"
elseif suit_count == 3 then
msg = "#jy_sichi_suits_3"
elseif suit_count == 4 then
msg = "#jy_sichi_suits_4"
end
room:doBroadcastNotify("ShowToast", Fk:translate(msg))
-- 一种花色:全部给一个人,测试通过
if suit_count == 1 then
-- 不能直接用room:getOtherPlayers(player)因为这个函数返回的是player而askForChoosePlayers需要的是idinteger
-- 无法让这些展示的牌在结算完成之前保留在屏幕上,火攻也不行
local targets = table.map(room:getAlivePlayers(), Util.IdMapper)
local result = room:askForChoosePlayers(player, targets, 1, 1, "#jy_sichi_1", self.name, true, false) -- 这玩意返回的是id列表
if #result ~= 0 then -- 点击取消,就给自己
room:moveCardTo(card_ids, Player.Hand, room:getPlayerById(result[1]), fk.ReasonGive, self.name, nil, false,
player.id)
else
room:moveCardTo(card_ids, Player.Hand, player, fk.ReasonGive, self.name, nil, false, player.id)
end
-- 2种花色判断是否有可以使用的牌。如果有选择其中一张可以使用的牌然后选择目标并使用如果没有弃置一张牌
-- 因为我们只选一张所以用addSubcard就可以了。如果你要移植这个函数到别的地方去那就记得改单复数
elseif suit_count == 2 then
-- 1. 先判断是否全都无法使用,如果全都无法使用,直接让他弃牌,把这几张牌都丢到弃牌堆去,结束这个技能
local is_any_card_usable = false
for _, c in ipairs(card_ids) do
if U.canUseCard(room, player, Fk:getCardById(c), true) then
is_any_card_usable = true
break
end
end
-- is_any_card_usable = false -- 测试用的,记得改回来
if not is_any_card_usable then
room:doBroadcastNotify("ShowToast", Fk:translate("#jy_sichi_2_failed_toast"))
room:askForDiscard(player, 1, 1, true, self.name, false, ".", "#jy_sichi_2_failed", false)
room:moveCards({
ids = card_ids,
toArea = Card.DiscardPile,
moveReason = fk.ReasonPutIntoDiscardPile,
})
-- 在此处已经把垃圾丢完了所以可以放心return
return false
end
-- 2. 如果有可以使用的牌,用五谷丰登(神吕蒙)的方式把牌展示出来,其中不可使用的牌变灰,让他选择一张没有变灰的牌
table.forEach(room.players, function(p)
room:fillAG(p, card_ids) -- 让每个人都能看到AG
end)
for i = 1, #card_ids do -- 对于所有的牌
local id = card_ids[i]
if not U.canUseCard(room, player, Fk:getCardById(id), true) then -- 如果这张牌无法使用
room:takeAG(player, id) -- 把这张牌标记为被拿了(也就是变灰)
-- table.removeOne(card_ids, id) -- 把这张牌从所有的牌中移除。此时不需要。
end
end
local card_id = room:askForAG(player, card_ids, false, self.name) -- 要求你拿一张
room:takeAG(player, card_id)
table.removeOne(card_ids, card_id) -- 将这张牌从card_ids移除因为最后要把所有的card_ids都弃掉
room:closeAG()
-- card_id 即为被选的牌
local dummy = Fk:cloneCard("dilu")
-- 3. 选择完毕后,放入他的手牌,并要求他为这张牌指定目标
dummy:addSubcard(card_id)
room:obtainCard(player.id, dummy, true, fk.ReasonPrey)
local card = Fk:getCardById(card_id)
-- TODO这个肯定有更好的方式
local name = card.trueName
local number
local suit
if card.number == 11 then
number = "J"
elseif card.number == 12 then
number = "Q"
elseif card.number == 13 then
number = "K"
elseif card.number == 1 then
number = "A"
else
number = tostring(card.number)
end
if card.suit == Card.Spade then
suit = "spade"
elseif card.suit == Card.Heart then
suit = "heart"
elseif card.suit == Card.Club then
suit = "club"
elseif card.suit == Card.Diamond then
suit = "diamond"
end
-- 牌名|点数|花色 -- 这个exppattern.lua里用例子给的写法可以匹配到
local pattern = name .. "|" .. number .. "|" .. suit
-- 雷杀火杀的匹配用truename即可反正花色和点数会限制别的牌
local use = room:askForUseCard(player, card.name, pattern, "#jy_sichi_2_use", false) -- 这里填false也没用反正是可以取消的
-- useCard
if use then room:useCard(use) end
-- 3种花色选牌然后所有人各摸一张
elseif suit_count == 3 then
local get = room:askForPoxi(player, "jy_sichi_3", {
{ self.name, card_ids },
}, nil, true)
if #get > 0 then
local dummy = Fk:cloneCard("dilu")
dummy:addSubcards(get)
room:obtainCard(player.id, dummy, true, fk.ReasonPrey)
end
-- 所有其他人各摸一张
for _, p in ipairs(room:getOtherPlayers(player)) do
if not p.dead then
p:drawCards(1, self.name)
end
end
-- 4种花色选择至多3名角色你和他们各失去一点体力
elseif suit_count == 4 then
-- 业炎
-- 这里只能选择除了自己以外的角色,因为自己肯定是要掉血的
local targets = table.map(table.filter(room:getOtherPlayers(player), function(p)
return true
end), Util.IdMapper)
local result = room:askForChoosePlayers(player, targets, 0, 3, "#jy_sichi_4", self.name) -- 这玩意返回的是id列表
room:loseHp(player, 1, self.name)
for _, p in ipairs(result) do
local p_player = room:getPlayerById(p)
if not p_player.dead then room:loseHp(p_player, 1, self.name) end
end
end
-- 移动到弃牌堆,最后一起丢,前面的不用丢
card_ids = table.filter(card_ids, function(id) return room:getCardArea(id) == Card.Processing end)
if #card_ids > 0 then
room:moveCards({
ids = card_ids,
toArea = Card.DiscardPile,
moveReason = fk.ReasonPutIntoDiscardPile,
})
end
end,
}
-- ol_sp1 sheyan
local jy_huapen = fk.CreateTriggerSkill {
name = "jy_huapen",
anim_type = "control",
events = { fk.TargetConfirming },
frequency = Skill.Compulsory,
can_trigger = function(self, event, target, player, data)
if player:hasSkill(self) and data.from ~= player.id and data.card and
data.card.suit == Card.Club and
(data.card:isCommonTrick() or data.card.type == Card.TypeBasic) then
local previous_targets = AimGroup:getAllTargets(data.tos)
if #AimGroup:getAllTargets(data.tos) ~= 1 then return false end -- 如果目标不是一个,那就不用管了
-- 借刀杀人也被判定为单体卡牌
-- 如果目标里面已经有我自己了,那就不要判定了
for _, v in pairs(previous_targets) do
if v == player.id then
return false
end
end
return true
end
end,
on_use = function(self, event, target, player, data)
local room = player.room
local targets = {}
local judge = {
who = player,
reason = self.name,
pattern = ".|.|heart",
}
room:judge(judge)
if judge.card.suit == Card.Heart then
room:doIndicate(data.from, { player.id }) -- 播放指示线
-- TODO这里写的不对吧targets根本就没用上
if #AimGroup:getAllTargets(data.tos) == 1 then -- 如果只有一个人,那么把我也加进去
table.insertTable(targets, AimGroup:getAllTargets(data.tos))
end
TargetGroup:pushTargets(data.targetGroup, player.id)
end
end,
}
local jy_boshi = fk.CreateTriggerSkill {
name = "jy_boshi",
frequency = Skill.Wake,
events = { fk.EventPhaseStart },
can_trigger = function(self, event, target, player, data)
return target == player and player:hasSkill(self) and
player:usedSkillTimes(self.name, Player.HistoryGame) == 0 and
player.phase == Player.Start
end,
can_wake = function(self, event, target, player, data)
return player:getMark("@jy_boshi_judge_count") >= #player.room:getAlivePlayers()
end,
on_use = function(self, event, target, player, data)
local room = player.room
room:changeMaxHp(player, 1)
room:setPlayerMark(player, "@jy_boshi_judge_count", 0) -- 清空标记
room:handleAddLoseSkills(player, "-jy_huapen")
room:handleAddLoseSkills(player, "jy_jiangbei")
end,
refresh_events = { fk.AskForRetrial },
can_refresh = function(self, event, target, player, data)
return target == player and player:hasSkill(self) and
player:usedSkillTimes("jy_boshi", Player.HistoryGame) == 0 -- 如果觉醒技未发动过,可以更新数值(发动过了就不更新了)
end,
on_refresh = function(self, event, target, player, data)
local room = player.room
room:addPlayerMark(player, "@jy_boshi_judge_count")
end,
}
-- TODO: 重写这个技能,把它们放到一起
-- ♥无法被响应
local jy_jiangbei = fk.CreateTriggerSkill {
name = "jy_jiangbei",
frequency = Skill.Compulsory,
events = { fk.CardUsing },
can_trigger = function(self, event, target, player, data)
if not player:hasSkill(self) then return false end
if target == player and data.card.suit == Card.Heart then
return data.card.type == Card.TypeBasic or data.card.type == Card.TypeTrick
end
end,
on_use = function(self, event, target, player, data)
local room = player.room
player:broadcastSkillInvoke(self.name)
data.disresponsiveList = table.map(room.alive_players, Util.IdMapper)
end,
}
-- ♣没有距离次数限制
local jy_jiangbei_club = fk.CreateTargetModSkill {
name = "#jy_jiangbei_club",
bypass_times = function(self, player, skill, scope, card, to)
return player:hasSkill(self) and card.suit == Card.Club and to
end,
bypass_distances = function(self, player, skill, card, to)
return player:hasSkill(self) and card.suit == Card.Club and to
end,
}
-- ♣无视防具
-- 注意targetSpecified事件只有一个data.to因为是对每个target做一次。
local jy_jiangbei_club_2 = fk.CreateTriggerSkill {
name = "#jy_jiangbei_club_2",
frequency = Skill.Compulsory,
events = { fk.TargetSpecified },
can_trigger = function(self, event, target, player, data)
if not player:hasSkill(self) then return false end
if target == player and data.card and data.card.suit == Card.Club then
return data.card.type == Card.TypeBasic or data.card.type == Card.TypeTrick
end
end,
on_use = function(self, event, target, player, data)
local room = player.room
local to = room:getPlayerById(data.to)
local use_event = room.logic:getCurrentEvent():findParent(GameEvent.UseCard, true)
if use_event == nil then return end
room:addPlayerMark(to, fk.MarkArmorNullified)
use_event:addCleaner(function()
room:removePlayerMark(to, fk.MarkArmorNullified)
end)
end,
}
-- 计算出牌阶段使用打出了多少张红桃梅花。一旦使用打出了别的牌,就变为字符串。
-- TargetSpecified对每个目标都会执行一次所以改成CardUsing。前面的虎啸也一并改了已经。
local jy_jiangbei_draw_count = fk.CreateTriggerSkill {
name = "#jy_jiangbei_draw_count",
mute = true,
frequency = Skill.Compulsory,
refresh_events = { fk.CardResponding, fk.CardUsing }, -- 包括了使用和打出
can_refresh = function(self, event, target, player, data)
if player:hasSkill(self) and data.card and player.phase == Player.Play then
return target == player
end
end,
on_refresh = function(self, event, target, player, data)
local room = player.room
-- 如果是红桃和梅花
if (data.card.suit == Card.Club or data.card.suit == Card.Heart) and
type(player:getMark("@jy_jiangbei_draw")) == "number" then -- 并且没有使用打出过别的花色
room:addPlayerMark(player, "@jy_jiangbei_draw")
-- else
-- room:setPlayerMark(player, "@jy_jiangbei_draw", "#jy_jiangbei_no") -- 如果设置成字符串了,代表不允许摸牌了
end
end,
}
-- 出牌阶段结束时摸等量的牌
local jy_jiangbei_draw = fk.CreateTriggerSkill {
name = "#jy_jiangbei_draw",
anim_type = "special",
-- 出牌阶段开始时把已使用打出的红桃梅花数设置成0
refresh_events = { fk.EventPhaseStart },
can_refresh = function(self, event, target, player, data)
return player:hasSkill(self) and target == player and
player.phase == Player.Play -- 在我的出牌阶段
end,
on_refresh = function(self, event, target, player, data)
player.room:setPlayerMark(player, "@jy_jiangbei_draw", 0)
end,
events = { fk.EventPhaseEnd }, -- 包括了使用和打出
can_trigger = function(self, event, target, player, data)
return target == player and player:hasSkill(self)
and player.phase == Player.Play
end,
on_cost = function(self, event, target, player, data)
local room = player.room
-- if type(player:getMark("@jy_jiangbei_draw")) == "number" then -- 只有是数字的时候,代表可以摸牌
player:drawCards(player:getMark("@jy_jiangbei_draw"), self.name)
-- end
room:setPlayerMark(player, "@jy_jiangbei_draw", 0) -- 无论能不能摸牌,都要清理掉这个标记
end,
}
jy_jiangbei:addRelatedSkill(jy_jiangbei_heart)
jy_jiangbei:addRelatedSkill(jy_jiangbei_club)
jy_jiangbei:addRelatedSkill(jy_jiangbei_club_2)
jy_jiangbei:addRelatedSkill(jy_jiangbei_draw_count)
jy_jiangbei:addRelatedSkill(jy_jiangbei_draw)
jy__yangfan:addSkill(jy_sichi)
jy__yangfan:addSkill(jy_huapen)
jy__yangfan:addSkill(jy_boshi)
jy__yangfan:addRelatedSkill(jy_jiangbei)
Fk:loadTranslationTable {
["jy__yangfan"] = "杨藩",
["#jy__yangfan"] = "一鱼四吃",
["designer:jy__yangfan"] = "敏敏伊人梦中卿 & 考公专家",
["cv:jy__yangfan"] = "暂无",
["illustrator:jy__yangfan"] = "杨藩",
["jy_sichi"] = "四吃",
[":jy_sichi"] = [[你受到伤害后可以展示牌堆顶的4张牌根据其花色数1令一名角色获得之2获得其中一张可以使用的牌并可以使用之若都无法使用你弃一张牌3获得3/2张同类型/不同类型的牌然后其他角色摸一张牌4你与至多3名角色各失去一点体力。]],
["#jy_sichi_suits_1"] = "四吃1种花色选择一名角色获得这些牌",
["#jy_sichi_suits_2"] = "四吃2种花色获得一张可使用的牌并可以使用",
["#jy_sichi_suits_3"] = "四吃3种花色获得3张同类型或2张不同类型的牌然后其他角色各摸一张牌",
["#jy_sichi_suits_4"] = "四吃4种花色选择至多3名角色一起失去1点体力",
["#jy_sichi_1"] = "四吃:选择一名角色获得所有牌,点击取消选择自己",
["#jy_sichi_2"] = "四吃:获得其中一张牌并可以使用",
["#jy_sichi_2_use"] = "四吃:你可以使用这张牌",
["#jy_sichi_2_failed_toast"] = "四吃2种花色没有可使用的牌弃一张牌",
["#jy_sichi_2_failed"] = "四吃:没有可使用的牌,弃一张牌",
["jy_sichi_3"] = "四吃",
["#jy_sichi_3"] = "四吃选择其中3张同类型的牌或2张不同类型的牌获得然后除你以外的角色各摸一张牌",
["#jy_sichi_4"] = "四吃选择至多3名角色你和他们各失去一点体力",
["jy_huapen"] = "花盆",
[":jy_huapen"] = [[锁定技,其他角色使用♣普通锦囊牌或基本牌指定了有且仅有一个不为你的目标时,你判定,若为<font color="red">♥</font>,额外指定你为目标。]],
["jy_boshi"] = "搏时",
[":jy_boshi"] = [[觉醒技准备阶段若你已判定过至少X次你增加一点体力上限、失去〖花盆〗然后获得〖奖杯〗X等于存活角色数。]],
["@jy_boshi_judge_count"] = "搏时",
["jy_jiangbei"] = "奖杯",
[":jy_jiangbei"] = [[锁定技,你的基本牌和锦囊牌花色若为:♣,无视距离、次数限制和防具;<font color="red">♥</font>不可响应出牌阶段结束时你摸X张牌X为你出牌阶段使用或打出的♣和<font color="red">♥</font>牌数)。]],
["#jy_jiangbei_heart"] = "奖杯",
["#jy_jiangbei_club"] = "奖杯",
["#jy_jiangbei_club_2"] = "奖杯",
["@jy_jiangbei_draw"] = "奖杯",
["#jy_jiangbei_no"] = "不可摸牌",
-- TODO改一下这里按照sp公孙瓒义从改只提示触发了义从。
}
-- 参考:廖化,英姿,蛊惑,血裔
local jy__mou__gaotianliang = General(extension, "jy__mou__gaotianliang", "god", 4)
local jy_tianling = fk.CreateViewAsSkill {
name = "jy_tianling",
anim_type = "special",
pattern = ".",
interaction = function()
local names = {}
for _, id in ipairs(Fk:getAllCardIds()) do
local card = Fk:getCardById(id)
if card:isCommonTrick()
-- and card.trueName ~= "ex_nihilo" and card.trueName ~= "snatch" and card.trueName ~= "amazing_grace"
and not card.is_derived and
((Fk.currentResponsePattern == nil and Self:canUse(card)) or
(Fk.currentResponsePattern and Exppattern:Parse(Fk.currentResponsePattern):match(card))) then
table.insertIfNeed(names, card.name)
end
end
if #names == 0 then return false end
return UI.ComboBox { choices = names }
end,
card_filter = function(self, to_select, selected)
return #selected == 0 and Fk:currentRoom():getCardArea(to_select) ~= Card.PlayerEquip
end,
view_as = function(self, cards)
if #cards ~= 1 or not self.interaction.data then return end
local card = Fk:cloneCard(self.interaction.data)
self.cost_data = cards
card.skillName = self.name
return card
end,
before_use = function(self, player, use)
local cards = self.cost_data
local card_id = cards[1]
use.card:addSubcard(card_id)
end,
enabled_at_play = function(self, player)
return player:getMark("@jy_tianling") ~= 0 and not player:isKongcheng() and player.phase ~= Player.NotActive and
player:usedSkillTimes(self.name, Player.HistoryTurn) < 5
end,
enabled_at_response = function(self, player, response)
return player:getMark("@jy_tianling") ~= 0 and player.phase ~= Player.NotActive and not response and
not player:isKongcheng() and player:usedSkillTimes(self.name, Player.HistoryTurn) < 5
end,
}
local jy_tianling_yuyu = fk.CreateTriggerSkill {
name = "#jy_tianling_yuyu",
anim_type = "masochism",
refresh_events = { fk.EventPhaseEnd },
can_refresh = function(self, event, target, player, data)
return player:hasSkill(self) and target == player and
target.phase == Player.Judge and
player:getMark("@jy_tianling") ~= 0
end,
on_refresh = function(self, event, target, player, data)
player.room:setPlayerMark(player, "@jy_tianling", 0)
end,
events = { fk.EventPhaseStart },
can_trigger = function(self, event, target, player, data)
return player:hasSkill(self) and player == target and player.phase == Player.Discard
end,
on_use = function(self, event, target, player, data)
local room = player.room
local choices = { "#jy_tianling_1hp", "#jy_tianling_2cards" }
local choice
-- 检测他是否没有两张牌可以弃了,如果是,就黑掉弃两张牌那个按钮
if #player:getCardIds { Player.Hand, Player.Equip } < 2 then
choice = room:askForChoice(player, { "#jy_tianling_1hp" }, self.name, nil, nil, choices)
-- 如果可以做选择,就让他做选择
else
choice = room:askForChoice(player, choices, self.name)
end
if choice == "#jy_tianling_1hp" then
room:loseHp(player, 1, self.name)
else
room:askForDiscard(player, 2, 2, true, self.name, false)
end
room:setPlayerMark(player, "@jy_tianling", "")
end,
}
local jy_tianling_dangxian = fk.CreateTriggerSkill {
name = "#jy_tianling_dangxian",
anim_type = "offensive",
frequency = Skill.Compulsory,
events = { fk.EventPhaseChanging },
can_trigger = function(self, event, target, player, data)
return target == player and player:hasSkill(self) and
data.to == Player.Start and player:getMark("@jy_tianling") ~= 0
end,
on_use = function(self, event, target, player, data)
player:gainAnExtraPhase(Player.Play, true)
end,
}
jy_tianling:addRelatedSkill(jy_tianling_yuyu)
jy_tianling:addRelatedSkill(jy_tianling_dangxian)
local jy_yali = fk.CreateTriggerSkill {
name = "jy_yali",
anim_type = "drawcard",
frequency = Skill.Compulsory,
events = { fk.DrawNCards },
on_cost = Util.TrueFunc,
on_use = function(self, event, target, player, data)
data.n = math.max(player.hp - #player:getCardIds(Player.Hand), 1)
end,
}
local jy_yali_maxcards = fk.CreateMaxCardsSkill {
name = "#jy_yali_maxcards",
fixed_func = function(self, player)
if player:hasSkill(self) then
return player.maxHp
end
end,
}
jy_yali:addRelatedSkill(jy_yali_maxcards)
jy__mou__gaotianliang:addSkill(jy_yali)
jy__mou__gaotianliang:addSkill(jy_tianling)
Fk:loadTranslationTable {
["jy__mou__gaotianliang"] = "高天亮",
["#jy__mou__gaotianliang"] = "凤鸣九天",
["designer:jy__mou__gaotianliang"] = "拂却心尘 & 考公专家",
["cv:jy__mou__gaotianliang"] = "暂无",
["illustrator:jy__mou__gaotianliang"] = "高天亮",
["jy_tianling"] = "天灵",
[":jy_tianling"] = [[弃牌阶段开始时你可以弃两张牌或失去一点体力。若如此做你的下一个回合准备阶段后执行一个额外的出牌阶段判定阶段结束前你的手牌可当作所有锦囊牌使用至多5次。]],
["@jy_tianling"] = "天灵",
["#jy_tianling_1hp"] = "失去一点体力",
["#jy_tianling_2cards"] = "弃置2张牌",
["#jy_tianling_dangxian"] = "天灵",
["#jy_tianling_yuyu"] = "天灵",
["jy_yali"] = "压力",
[":jy_yali"] = [[锁定技你的摸牌阶段改为摸X张牌X为你的体力值与手牌数之差且至少为1你的手牌上限等于你的体力上限。]],
}
local jy__raiden = General(extension, "jy__raiden", "god", 4, 4, General.Female)
local jy_leiyan = fk.CreateActiveSkill {
name = "jy_leiyan",
anim_type = "support",
can_use = function(self, player)
-- local room = player.room
-- 如果所有人都有雷眼,那么就不能发动
local all_players = true
-- 在这里写room:getAlivePlayers不行
-- Fk:currentRoom():getAlivePlayer也不行。因为这里用的是客户端Room。
-- 这几个函数定义在服务端Room里
for _, p in ipairs(Fk:currentRoom().alive_players) do
if p:getMark("@jy_raiden_leiyan") == 0 then
all_players = false
break
end
end
return not all_players and
player:usedSkillTimes(self.name, Player.HistoryPhase) == 0
end,
card_filter = function(self, card)
return false
end,
card_num = 0,
target_filter = function(self, to_select, selected)
return Fk:currentRoom():getPlayerById(to_select):getMark("@jy_raiden_leiyan") == 0
end,
min_target_num = 1,
on_use = function(self, room, use)
for _, to in ipairs(use.tos) do
local p = room:getPlayerById(to)
room:setPlayerMark(p, "@jy_raiden_leiyan", "")
end
end,
}
local jy_leiyan_trigger = fk.CreateTriggerSkill {
name = "#jy_leiyan_trigger",
mute = true,
anim_type = "support",
frequency = Skill.Compulsory,
events = { fk.Damage },
can_trigger = function(self, event, target, player, data)
if not data.from then return false end -- 如果这次伤害没有伤害来源,就不用看了
local from = data.from
return from:getMark("@jy_raiden_leiyan") ~= 0 and player:hasSkill(self)
and not data.is_leiyan
end,
on_use = function(self, event, target, player, data)
local room = player.room
local from = data.from
local to = data.to
if not target.dead then
local judge = {
who = player,
reason = self.name,
pattern = ".|.|club,spade",
}
room:judge(judge)
if judge.card.color == Card.Black then
player:broadcastSkillInvoke("jy_leiyan")
room:doIndicate(player.id, { to.id }) -- 播放指示线
room:damage({
from = player,
to = to,
damage = 1,
damageType = fk.ThunderDamage,
skillName = "jy_leiyan",
is_leiyan = true,
})
end
end
end,
}
jy_leiyan:addRelatedSkill(jy_leiyan_trigger)
local jy_zhenshuo = fk.CreateActiveSkill {
name = "jy_zhenshuo",
anim_type = "offensive",
can_use = function(self, player)
return player:usedSkillTimes(self.name, Player.HistoryPhase) == 0
end,
card_filter = function(self, to_select, selected, selected_targets)
return #selected ~= 3 and not Self:prohibitDiscard(Fk:getCardById(to_select))
end,
card_num = 3,
target_filter = function(self, to_select, selected)
return to_select ~= Self.id and Self:inMyAttackRange(Fk:currentRoom():getPlayerById(to_select))
end,
target_num = 1,
on_use = function(self, room, use)
local player = room:getPlayerById(use.from)
local to = room:getPlayerById(use.tos[1])
room:throwCard(use.cards, self.name, player, player)
room:delay(900)
room:damage({
from = player,
to = to,
damage = 1,
damageType = fk.ThunderDamage,
skillName = self.name,
})
end,
}
jy__raiden:addSkill(jy_leiyan)
jy__raiden:addSkill(jy_zhenshuo)
Fk:loadTranslationTable {
["jy__raiden"] = [[雷电将军]],
["#jy__raiden"] = "一心净土",
["designer:jy__raiden"] = "考公专家",
["cv:jy__raiden"] = "菊花花",
["illustrator:jy__raiden"] = "米哈游",
["~jy__raiden"] = "浮世一梦……",
["jy_leiyan"] = "雷眼",
[":jy_leiyan"] = [[出牌阶段限一次,你可以令至少一名角色获得<font color="Fuchsia">雷眼</font>;持有<font color="Fuchsia">雷眼</font>的角色造成伤害后若目标未死亡你判定若为黑色你对目标造成1点雷电伤害不会触发〖雷眼〗。]],
["@jy_raiden_leiyan"] = [[<font color="Fuchsia">雷眼</font>]],
["#jy_leiyan_trigger"] = "雷眼",
["$jy_leiyan1"] = "泡影看破!",
["$jy_leiyan2"] = "无处遁逃!",
["$jy_leiyan3"] = "威光无赦!",
["jy_zhenshuo"] = "真说",
[":jy_zhenshuo"] = [[出牌阶段限一次,你可以弃三张牌对一名攻击范围内的角色造成一点雷电伤害。]],
["$jy_zhenshuo1"] = "此刻,寂灭之时!",
["$jy_zhenshuo2"] = "稻光,亦是永恒!",
["$jy_zhenshuo3"] = "无念,断绝!",
}
local jy__ayato = General(extension, "jy__ayato", "qun", 4)
local jy_jinghua = fk.CreateTriggerSkill {
name = "jy_jinghua",
anim_type = "offensive",
events = { fk.CardRespondFinished, fk.CardUseFinished },
can_trigger = function(self, event, target, player, data)
return player:hasSkill(self) and data.card and data.card.type == Card.TypeBasic and
target == player and player:usedSkillTimes(self.name, Player.HistoryTurn) == 0
end,
on_cost = function(self, event, target, player, data)
local extraData = { bypass_times = true } -- 加上这个,就可以让它就算之前使用过杀,也可以再使用了
self.jinghua_use = player.room:askForUseCard(player, "slash", "slash|.|.", "#jy_jinghua_use", true, extraData) -- 这里填false也没用反正是可以取消的
return self.jinghua_use
end,
on_use = function(self, event, target, player, data)
local room = player.room
local disresponsiveList = table.map(room.alive_players, Util.IdMapper)
self.jinghua_use.extraUse = true -- 加上这个,就可以让它不计入次数了,也就是说还可以再使用一张杀
self.jinghua_use.disresponsiveList = disresponsiveList
room:useCard(self.jinghua_use)
end,
}
local jy_jianying = fk.CreateTriggerSkill {
frequency = Skill.Compulsory,
name = "jy_jianying",
anim_type = "defensive",
events = { fk.EventPhaseProceeding },
can_trigger = function(self, event, target, player, data)
return player:hasSkill(self) and
target.phase == Player.Finish and
#player:getCardIds(Player.Hand) < 2
end,
on_use = function(self, event, target, player, data)
player:drawCards(1, self.name)
end,
}
jy__ayato:addSkill(jy_jinghua)
jy__ayato:addSkill(jy_jianying)
--[[
获取原神配音方法:去下面网站找到你的角色的页面,然后查看源文件,搜索配音即可。
https://bbs.mihoyo.com/ys/obc/channel/map/189/25?bbs_presentation_style=no_header
]]
Fk:loadTranslationTable {
["jy__ayato"] = [[神里绫人]],
["#jy__ayato"] = "磐祭叶守",
["designer:jy__ayato"] = "考公专家",
["cv:jy__ayato"] = "赵路",
["illustrator:jy__ayato"] = "米哈游",
["~jy__ayato"] = "世事无常……",
["jy_jinghua"] = "镜花",
[":jy_jinghua"] = [[每回合限一次,你使用或打出一张基本牌后,可以使用一张无次数限制且不可被响应的【杀】。]],
["$jy_jinghua1"] = "苍流水影。",
["$jy_jinghua2"] = "剑影。",
["#jy_jinghua_use"] = "镜花:你可以使用一张无次数限制且不可响应的【杀】",
["jy_jianying"] = "渐盈",
[":jy_jianying"] = [[锁定技每名角色的结束阶段若你的手牌数小于2你摸一张牌。]],
["$jy_jianying1"] = "冒进是大忌。",
["$jy_jianying2"] = "呵……余兴节目。",
}
local jy__liuxian = General(extension, "jy__liuxian", "god", 3, 3, General.Female)
local jy_jieyin = fk.CreateActiveSkill {
frequency = Skill.Limited,
name = "jy_jieyin",
anim_type = "support",
can_use = function(self, player)
return player:usedSkillTimes(self.name, Player.HistoryGame) == 0
end,
card_filter = function(self, card)
return false
end,
card_num = 0,
target_filter = function(self, to_select, selected)
local s = Fk:currentRoom():getPlayerById(to_select)
return to_select ~= Self.id and -- 如果目标不是自己
s.gender == General.Male and -- 而且是男的
s.maxHp ~= s.hp and -- 而且受了伤
#selected < 1 -- 而且只选了一个
end,
target_num = 1,
on_use = function(self, room, use)
local player = room:getPlayerById(use.from)
for _, to in ipairs(use.tos) do
local p = room:getPlayerById(to)
-- 治疗其
room:recover({
who = p,
num = 1,
recoverBy = player,
skillName = self.name,
})
-- 治疗自己
room:recover({
who = player,
num = 1,
recoverBy = player,
skillName = self.name,
})
-- 获得其所有牌
if not p:isNude() then
local cards_id = p:getCardIds { Player.Hand, Player.Equip, Player.Judge }
local dummy = Fk:cloneCard 'slash'
dummy:addSubcards(cards_id)
room:obtainCard(player.id, dummy, false, fk.ReasonPrey)
end
-- 获得其所有技能
local skills = {}
for _, s in ipairs(p.player_skills) do
if not (s.attached_equip or s.name[#s.name] == "&") then
table.insertIfNeed(skills, s.name)
end
end
if #skills > 0 then
room:handleAddLoseSkills(player, table.concat(skills, "|"), nil, true, false)
end
room:setPlayerMark(p, "jy_jieyin-phase", true)
end
end,
}
local jieyin_prohibit = fk.CreateProhibitSkill {
name = "#jy_jieyin_prohibit",
is_prohibited = function(self, from, to, card)
return from:hasSkill(self) and to:getMark("jy_jieyin-phase") ~= 0
end,
}
jy_jieyin:addRelatedSkill(jieyin_prohibit)
jy__liuxian:addSkill(jy_jieyin)
Fk:loadTranslationTable {
["jy__liuxian"] = [[刘仙]],
["#jy__liuxian"] = "人中龙凤",
["designer:jy__liuxian"] = "考公专家",
["cv:jy__liuxian"] = "暂无",
["illustrator:jy__liuxian"] = "意间AI",
["jy_jieyin"] = "结姻",
[":jy_jieyin"] = [[限定技出牌阶段你可以令一名已受伤的男性角色与你各回复1点体力、你获得其所有牌并视为拥有其所有技能、其不是你本阶段使用牌的合法目标。]],
["$jy_jieyin1"] = [[夫君,身体要紧。]],
["$jy_jieyin2"] = [[他好,我也好。]],
}
local jy__huohuo = General(extension, "jy__huohuo", "wu", 3, 3, General.Female)
-- TODO可以不写这个
local jy_bazhen = fk.CreateTriggerSkill {
name = "jy_bazhen",
events = { fk.AskForCardUse, fk.AskForCardResponse },
frequency = Skill.Compulsory,
anim_type = "defensive",
can_trigger = function(self, event, target, player, data)
return target == player and player:hasSkill(self) and not player:isFakeSkill(self) and
(data.cardName == "jink" or (data.pattern and Exppattern:Parse(data.pattern):matchExp("jink|0|nosuit|none"))) and
not player:getEquipment(Card.SubtypeArmor) and player:getMark(fk.MarkArmorNullified) == 0
end,
on_cost = function(self, event, target, player, data)
return player.room:askForSkillInvoke(player, self.name, data)
end,
on_use = function(self, event, target, player, data)
local room = player.room
local judgeData = {
who = player,
reason = "eight_diagram",
pattern = ".|.|heart,diamond",
}
room:judge(judgeData)
if judgeData.card.color == Card.Red then
if event == fk.AskForCardUse then
data.result = {
from = player.id,
card = Fk:cloneCard('jink'),
}
data.result.card.skillName = "eight_diagram"
data.result.card.skillName = "bazhen"
if data.eventData then
data.result.toCard = data.eventData.toCard
data.result.responseToEvent = data.eventData.responseToEvent
end
else
data.result = Fk:cloneCard('jink')
data.result.skillName = "eight_diagram"
data.result.skillName = "bazhen"
end
return true
end
end
}
local jy_lingfu = fk.CreateActiveSkill {
name = "jy_lingfu",
anim_type = "offensive",
min_target_num = 1,
max_target_num = 3,
min_card_num = 3,
max_card_num = 5,
can_use = function(self, player)
return #player:getCardIds { Player.Hand, Player.Equip } >= 3 and player:usedSkillTimes(self.name) == 0
end,
card_filter = function(self, to_select, selected)
if Self:prohibitDiscard(Fk:getCardById(to_select)) then return end
return #selected < 5
end,
target_filter = function(self, to_select, selected, selected_cards)
local to = Fk:currentRoom():getPlayerById(to_select)
return #selected < #selected_cards - 2 -- and to.hp ~= to.maxHp
end,
feasible = function(self, selected, selected_cards)
return #selected + 2 == #selected_cards
end,
on_use = function(self, room, effect)
local player = room:getPlayerById(effect.from)
room:throwCard(effect.cards, self.name, player, player)
room:delay(600)
for _, id in ipairs(effect.tos) do
local to = room:getPlayerById(id)
room:recover({
who = to,
num = 1,
recoverBy = player,
skillName = self.name,
})
to:drawCards(2, self.name)
if not to.faceup then
to:turnOver()
end
if to.chained then
to:setChainState(false)
end
if #to:getCardIds(Player.Judge) ~= 0 then
local cards_id = to:getCardIds(Player.Judge)
local dummy = Fk:cloneCard 'slash'
dummy:addSubcards(cards_id)
room:obtainCard(player.id, dummy, false, fk.ReasonPrey)
end
end
end,
}
jy__huohuo:addSkill(jy_bazhen)
jy__huohuo:addSkill(jy_lingfu)
Fk:loadTranslationTable {
["jy__huohuo"] = [[藿藿]],
["#jy__huohuo"] = "令奉贞凶",
["designer:jy__huohuo"] = "考公专家",
["cv:jy__huohuo"] = "葛子瑞 & 刘北辰",
["illustrator:jy__huohuo"] = "米哈游",
["~jy__huohuo"] = [[投……投降……]],
["jy_bazhen"] = "八阵",
[":jy_bazhen"] = [[锁定技,若你没有装备防具,视为你装备着【八卦阵】。]],
["$jy_bazhen1"] = "尾巴:走你。 藿藿:啊啊啊——",
["$jy_bazhen2"] = "不要啊救命啊——",
["$jy_bazhen3"] = "怎么还没结束……",
["$jy_bazhen4"] = "说不定我也能做到……",
["jy_lingfu"] = "灵符",
[":jy_lingfu"] = [[出牌阶段限一次你可以弃置X+2张牌并令XX由你选择X不小于1且不大于3名角色回复一点体力、摸两张牌、重置武将牌然后你获得其判定区的牌。]],
["$jy_lingfu1"] = [[驱邪……缚魅……]],
["$jy_lingfu2"] = [[灵符……保命……]],
}
local argenti = General(extension, "jy__argenti", "qun", 4)
local chunmei = fk.CreateTriggerSkill {
frequency = Skill.Compulsory,
name = "jy_chunmei",
anim_type = "defensive",
events = { fk.Damage },
can_trigger = function(self, event, target, player, data)
return player:hasSkill(self) and (data.from == player or data.to == player)
end,
on_use = function(self, event, target, player, data)
local room = player.room
local judge = {
who = player,
reason = self.name,
pattern = ".|.|heart,diamond",
}
room:judge(judge)
if judge.card.color == Card.Red and not player.dead then
room:obtainCard(player.id, judge.card)
end
end
}
local zhuhua = fk.CreateActiveSkill {
name = "jy_zhuhua",
anim_type = "offensive",
min_card_num = 3,
max_card_num = 4,
can_use = function(self, player)
-- return #player:getCardIds(Player.Hand) >= 3
return true
end,
card_filter = function(self, to_select, selected)
if Self:prohibitDiscard(Fk:getCardById(to_select)) then return false end
-- if not table.contains(Self:getHandlyIds(true), to_select) then return false end
if #selected == 4 then return false end
if #selected == 0 then
return true
else
return Fk:getCardById(to_select).suit == Fk:getCardById(selected[1]).suit
end
end,
feasible = function(self, selected, selected_cards)
return #selected_cards == 3 or #selected_cards == 4
end,
on_use = function(self, room, effect)
local player = room:getPlayerById(effect.from)
room:throwCard(effect.cards, self.name, player, player)
if #effect.cards == 3 then
room:useVirtualCard("archery_attack", nil, player, room:getOtherPlayers(player, true), self.name, true)
else
room:doIndicate(player.id, table.map(room.alive_players, Util.IdMapper))
room:delay(1000)
for _, p in ipairs(room:getOtherPlayers(player, true)) do
if not player.dead then -- 如果我自己死了(因为各种乱七八糟的技能弹反),那就不要继续了
room:damage({
from = player,
to = p,
damage = 1,
damageType = fk.NormalDamage,
})
end
end
end
end,
}
argenti:addSkill(chunmei)
argenti:addSkill(zhuhua)
Fk:loadTranslationTable {
["jy__argenti"] = [[银枝]],
["#jy__argenti"] = "荆冠芳勋",
["designer:jy__argenti"] = "考公专家",
["cv:jy__argenti"] = "梁达伟",
["illustrator:jy__argenti"] = "米哈游",
["~jy__argenti"] = [[没找到……「祂」……]],
["jy_chunmei"] = "纯美",
[":jy_chunmei"] = [[锁定技,你造成或受到伤害时进行判定,若为红色,你获得该判定牌。]],
["jy_zhuhua"] = "驻花",
[":jy_zhuhua"] = [[出牌阶段,你可以弃三张或四张相同花色的牌。若为三张,你视为使用一张【万箭齐发】;若为四张,你对其他所有角色造成一点伤害。]],
["$jy_zhuhua1"] = [[再次见到那道光芒之前……]],
["$jy_zhuhua2"] = [[银河中的一切美丽,我将捍卫至最后一刻!]],
["$jy_zhuhua3"] = [[……献给伊德莉拉。]],
}
-- 因为下面几个都属于高手系列差不多,所以都放到一起写了,降低耦合度
-- 下面的这一堆函数是用于判断“这个玩家是否是满足某一属性的玩家”,有可能是它的名字符合,也有可能是它的势力符合,或者还有别的判断标准。总之不是特定的针对某个势力的,不要误以为是。
-- 以武将名为判定是否为原神角色的标准。按照bwiki排序截止2024.3.21
-- 也要收录私服有人写了的怪物,丘丘人什么的,看到一个收一个
-- 使用哈希表,时间复杂度低
local genshin_names = {
["凯亚"] = true,
["重云"] = true,
["诺艾尔"] = true,
["凝光"] = true,
["行秋"] = true,
["芭芭拉"] = true,
["班尼特"] = true,
["安柏"] = true,
["香菱"] = true,
["丽莎"] = true,
["菲谢尔"] = true,
["雷泽"] = true,
["北斗"] = true,
["砂糖"] = true,
["迪奥娜"] = true,
["辛焱"] = true,
["罗莎莉亚"] = true,
["烟绯"] = true,
["早柚"] = true,
["九条裟罗"] = true,
["托马"] = true,
["五郎"] = true,
["云堇"] = true,
["久岐忍"] = true,
["鹿野院平藏"] = true,
["柯莱"] = true,
["多莉"] = true,
["坎蒂丝"] = true,
["莱依拉"] = true,
["珐露珊"] = true,
["瑶瑶"] = true,
["米卡"] = true,
["卡维"] = true,
["绮良良"] = true,
["琳妮特"] = true,
["菲米尼"] = true,
["夏洛蒂"] = true,
["夏沃蕾"] = true,
["嘉明"] = true,
["七七"] = true,
["旅行者"] = true,
["原神"] = true,
["派蒙"] = true,
["莫娜"] = true,
["迪卢克"] = true,
["刻晴"] = true,
[""] = true,
["温迪"] = true,
["可莉"] = true,
["达达利亚"] = true,
["钟离"] = true,
["阿贝多"] = true,
["甘雨"] = true,
[""] = true,
["胡桃"] = true,
["优菈"] = true,
["枫原万叶"] = true,
["神里绫华"] = true,
["宵宫"] = true,
["雷电将军"] = true,
["埃洛伊"] = true,
["珊瑚宫心海"] = true,
["荒泷一斗"] = true,
["申鹤"] = true,
["八重神子"] = true,
["神里绫人"] = true,
["夜兰"] = true,
["提纳里"] = true,
["赛诺"] = true,
["妮露"] = true,
["纳西妲"] = true,
["流浪者"] = true,
["艾尔海森"] = true,
["迪希雅"] = true,
["白术"] = true,
["林尼"] = true,
["那维莱特"] = true,
["莱欧斯利"] = true,
["芙宁娜"] = true,
["娜维娅"] = true,
["闲云"] = true,
["千织"] = true,
["阿蕾奇诺"] = true,
-- 以下是已知的怪物
["兽境猎犬"] = true,
["深渊咏者"] = true,
["海乱鬼"] = true,
}
local function is_genshin(player)
return genshin_names[Fk:translate(player.general)] or
genshin_names[Fk:translate(player.deputyGeneral)]
end
local function is_majsoul(player)
return player.kingdom == "que"
end
local function is_moe(player)
return player.kingdom == "moe"
end
local lol_names = {
["亚托克斯"] = true,
["阿狸"] = true,
["阿卡丽"] = true,
["阿克尚"] = true,
["阿利斯塔"] = true,
["阿木木"] = true,
["艾尼维亚"] = true,
["安妮"] = true,
["厄斐琉斯"] = true,
["艾希"] = true,
["奥瑞利安·索尔"] = true,
["奥瑞利安索尔"] = true,
["阿兹尔"] = true,
["巴德"] = true,
["卑尔维斯"] = true,
["布里茨"] = true,
["布兰德"] = true,
["布隆"] = true,
["贝蕾亚"] = true,
["凯特琳"] = true,
["卡蜜尔"] = true,
["卡西奥佩娅"] = true,
["科加斯"] = true,
["库奇"] = true,
["德莱厄斯"] = true,
["黛安娜"] = true,
["德莱文"] = true,
["蒙多医生"] = true,
["蒙多"] = true,
["艾克"] = true,
["伊莉丝"] = true,
["伊芙琳"] = true,
["伊泽瑞尔"] = true,
["费德提克"] = true,
["菲奥娜"] = true,
["菲兹"] = true,
["加里奥"] = true,
["普朗克"] = true,
["盖伦"] = true,
["纳尔"] = true,
["古拉加斯"] = true,
["格雷福斯"] = true,
["格温"] = true,
["赫卡里姆"] = true,
["黑默丁格"] = true,
[""] = true,
["俄洛伊"] = true,
["艾瑞莉娅"] = true,
["艾翁"] = true,
["迦娜"] = true,
["嘉文四世"] = true,
["贾克斯"] = true,
["杰斯"] = true,
[""] = true,
["金克丝"] = true,
["卡莎"] = true,
["卡莉丝塔"] = true,
["卡尔玛"] = true,
["卡尔萨斯"] = true,
["卡萨丁"] = true,
["卡特琳娜"] = true,
["凯尔"] = true,
["凯隐"] = true,
["凯南"] = true,
["卡兹克"] = true,
["千珏"] = true,
["克烈"] = true,
["克格莫"] = true,
["奎桑提"] = true,
["乐芙兰"] = true,
["李青"] = true,
["蕾欧娜"] = true,
["莉莉娅"] = true,
["丽桑卓"] = true,
["卢锡安"] = true,
["璐璐"] = true,
["拉克丝"] = true,
["墨菲特"] = true,
["玛尔扎哈"] = true,
["茂凯"] = true,
[""] = true,
["易大师"] = true,
["米利欧"] = true,
["厄运小姐"] = true,
["好运小姐"] = true,
["孙悟空"] = true,
["悟空"] = true,
["莫德凯撒"] = true,
["莫甘娜"] = true,
["纳亚菲利"] = true,
["娜美"] = true,
["内瑟斯"] = true,
["诺提勒斯"] = true,
["妮蔻"] = true,
["奈德丽"] = true,
["尼菈"] = true,
["魔腾"] = true,
["努努和威朗普"] = true,
["奥拉夫"] = true,
["奥莉安娜"] = true,
["奥恩"] = true,
["潘森"] = true,
["波比"] = true,
["派克"] = true,
["奇亚娜"] = true,
["奎因"] = true,
[""] = true,
["拉莫斯"] = true,
["雷克塞"] = true,
["芮尔"] = true,
["烈娜塔·戈拉斯克"] = true,
["烈娜塔"] = true,
["雷克顿"] = true,
["雷恩加尔"] = true,
["锐雯"] = true,
["兰博"] = true,
["瑞兹"] = true,
["莎弥拉"] = true,
["瑟庄妮"] = true,
["赛娜"] = true,
["萨勒芬妮"] = true,
["瑟提"] = true,
["萨科"] = true,
[""] = true,
["希瓦娜"] = true,
["辛吉德"] = true,
["赛恩"] = true,
["希维尔"] = true,
["斯卡纳"] = true,
["斯莫德"] = true,
["娑娜"] = true,
["索拉卡"] = true,
["斯维因"] = true,
["塞拉斯"] = true,
["辛德拉"] = true,
["塔姆"] = true,
["塔莉垭"] = true,
["泰隆"] = true,
["塔里克"] = true,
["提莫"] = true,
["锤石"] = true,
["崔丝塔娜"] = true,
["特朗德尔"] = true,
["泰达米尔"] = true,
["崔斯特"] = true,
["图奇"] = true,
["乌迪尔"] = true,
["厄加特"] = true,
["韦鲁斯"] = true,
["薇恩"] = true,
["维迦"] = true,
["维克兹"] = true,
["薇古丝"] = true,
[""] = true,
["佛耶戈"] = true,
["维克托"] = true,
["弗拉基米尔"] = true,
["沃利贝尔"] = true,
["沃里克"] = true,
[""] = true,
["泽拉斯"] = true,
["赵信"] = true,
["亚索"] = true,
["永恩"] = true,
["约里克"] = true,
["悠米"] = true,
["扎克"] = true,
[""] = true,
["泽丽"] = true,
["吉格斯"] = true,
["基兰"] = true,
["佐伊"] = true,
["婕拉"] = true,
}
local function is_lol(player)
return lol_names[Fk:translate(player.general)] or
lol_names[Fk:translate(player.deputyGeneral)]
end
-- 下面这一堆函数是用来快速制作高手系列的。
local master_events = { fk.EventPhaseProceeding, fk.TargetConfirming, fk.Damage }
local function master_can_trigger(is_fun, property)
return function(self, event, target, player, data)
if not player:hasSkill(self) then return false end
if event == fk.EventPhaseProceeding then
if not (target == player and (player.phase == Player.Start or player.phase == Player.Finish)) then return false end
local room = player.room
local is_exist = false
for _, p in ipairs(room:getOtherPlayers(player)) do
if is_fun(p) then
is_exist = true
break
end
end
if is_exist then return false end
-- 确认自己有没有哪个武将牌有这个技能
local generals
if player.deputyGeneral == "" then
generals = { player.general }
else
generals = { player.general, player.deputyGeneral }
end
for _, g in ipairs(generals) do
if table.contains(Fk.generals[g].skills, self) then
self.general = g
return true
end
end
elseif event == fk.TargetConfirming then
if data.from == player.id and
(data.card:isCommonTrick() or data.card.type == Card.TypeBasic) and
player:getMark("jy_master_" .. property) == 0 then
-- 检查是否所有的目标角色已经被选中。只要有一个没被选中那就return true
local targets = AimGroup:getAllTargets(data.tos)
for _, p in ipairs(player.room:getOtherPlayers(player)) do
if is_fun(p) and not table.contains(targets, p.id) and not Self:isProhibited(p, data.card) then
return true
end
end
end
elseif event == fk.Damage then
return target and is_fun(target) and target ~= player
end
end
end
local function master_on_cost(property)
return function(self, event, target, player, data)
if event == fk.EventPhaseProceeding then
return true
elseif event == fk.TargetConfirming then
player.room:setPlayerMark(player, "jy_master_" .. property, true)
return player.room:askForSkillInvoke(player, self.name)
else
return true
end
end
end
local function master_on_use(is_fun)
return function(self, event, target, player, data)
local room = player.room
if event == fk.EventPhaseProceeding then
-- local generals = Fk.packages["jianyu_standard"] -- TODO:自动检索所有简浴,但是先懒得写了
local generals = { "jy__genshin__master", "jy__que__master",
"jy__moe__master", "jy__lol__master", "jy__liuxian", "jy__huohuo",
"jy__kgdxs", "jy__kgds", }
-- 不能选择场上已有的武将
table.removeOne(generals, self.general)
for _, p in ipairs(room:getAlivePlayers()) do
table.removeOne(generals, p.general)
table.removeOne(generals, p.deputyGeneral)
end
generals = table.connect(generals, room:getNGenerals(14 - #generals))
local general = room:askForGeneral(player, generals, 1, true) -- true 才是禁止替换
room:changeHero(player, general, false, self.general == player.deputyGeneral, true)
room:recover({
who = player,
num = 1,
recoverBy = player,
skillName = self.name,
})
elseif event == fk.TargetConfirming then
local indicate_players = {} -- 用来画指示线的
local targets = AimGroup:getAllTargets(data.tos)
for _, p in ipairs(room:getOtherPlayers(player)) do
if is_fun(p) and not table.contains(targets, p.id) and not Self:isProhibited(p, data.card) then -- 抄的room.lua142行
AimGroup:addTargets(player.room, data, p.id)
table.insert(indicate_players, p.id)
end
end
if #indicate_players ~= 0 then
room:notifySkillInvoked(player, self.name, "offensive")
room:doIndicate(data.from, indicate_players)
end
else
player:drawCards(1, self.name)
end
end
end
local master_refresh_events = { fk.CardUseFinished }
local function master_can_refresh(property)
return function(self, event, target, player, data)
return player:hasSkill(self) and
player:getMark("jy_master_" .. property) ~= 0
end
end
local function master_on_refresh(property)
return function(self, event, target, player, data) player.room:setPlayerMark(player, "jy_master_" .. property, 0) end
end
-- 生成一个对应的技能。
local function master_createTriggerSkill(is_fun, property)
return fk.CreateTriggerSkill {
name = "jy_master_" .. property,
events = master_events,
can_trigger = master_can_trigger(is_fun, property),
on_cost = master_on_cost(property),
on_use = master_on_use(is_fun),
refresh_events = master_refresh_events,
can_refresh = master_can_refresh(property),
on_refresh = master_on_refresh(property)
}
end
local ysgs = General(extension, "jy__genshin__master", "qun", 4, 4, General.Female)
ysgs:addSkill(master_createTriggerSkill(is_genshin, "genshin"))
local qhgs = General(extension, "jy__que__master", "que", 4, 4, General.Female)
qhgs:addSkill(master_createTriggerSkill(is_majsoul, "majsoul"))
local mgs = General(extension, "jy__moe__master", "moe", 4, 4, General.Female)
mgs:addSkill(master_createTriggerSkill(is_moe, "moe"))
local lmgs = General(extension, "jy__lol__master", "qun", 4, 4, General.Female)
lmgs:addSkill(master_createTriggerSkill(is_lol, "lol"))
local function master_des(property)
return [[你使用普通锦囊牌和基本牌可以额外指定除你以外所有]] ..
property ..
[[角色为目标。除你以外的]] ..
property ..
[[角色造成伤害后,你摸一张牌。准备阶段或结束阶段,若场上除你以外没有存活的]] ..
property ..
[[角色且你武将牌上有该技能,你变更该武将并回复一点体力。]]
end
Fk:loadTranslationTable {
["jy__genshin__master"] = "原神高手",
["#jy__genshin__master"] = "考公专家",
["designer:jy__genshin__master"] = "考公专家",
["cv:jy__genshin__master"] = "AI德丽莎",
["illustrator:jy__genshin__master"] = "德丽莎",
["~jy__genshin__master"] = "不玩了!再也不玩了!",
["jy_master_genshin"] = "原神",
[":jy_master_genshin"] = master_des("原神"),
["$jy_master_genshin1"] = [[玩原神玩的!]],
["$jy_master_genshin2"] = [[不玩原神导致的!]],
["$jy_master_genshin3"] = [[原神,启动!]],
["jy__que__master"] = "雀魂高手",
["#jy__que__master"] = "",
["designer:jy__que__master"] = "考公专家",
["cv:jy__que__master"] = "AI德丽莎",
["illustrator:jy__que__master"] = "德丽莎",
["~jy__que__master"] = "不玩了!再也不玩了!",
["jy_master_majsoul"] = "雀神",
[":jy_master_majsoul"] = master_des("雀势力"),
["$jy_master_majsoul1"] = [[玩雀魂玩的!]],
["$jy_master_majsoul2"] = [[不玩雀魂导致的!]],
["$jy_master_majsoul3"] = [[雀魂,启动!]],
["jy__moe__master"] = "萌包高手",
["#jy__moe__master"] = "emo公主",
["designer:jy__moe__master"] = "考公专家",
["cv:jy__moe__master"] = "AI德丽莎",
["illustrator:jy__moe__master"] = "德丽莎",
["~jy__moe__master"] = "不玩了!再也不玩了!",
["jy_master_moe"] = "萌神",
[":jy_master_moe"] = master_des("萌势力"),
["$jy_master_moe1"] = [[玩萌包玩的!]],
["$jy_master_moe2"] = [[不玩萌包导致的!]],
["$jy_master_moe3"] = [[萌包,启动!]],
["jy__lol__master"] = "联盟高手",
["#jy__lol__master"] = "考公专家",
["designer:jy__lol__master"] = "考公专家",
["cv:jy__lol__master"] = "AI德丽莎",
["illustrator:jy__lol__master"] = "德丽莎",
["~jy__lol__master"] = "不玩了!再也不玩了!",
["jy_master_lol"] = "盟神",
[":jy_master_lol"] = master_des("英雄联盟"),
["$jy_master_lol1"] = [[玩英雄联盟玩的!]],
["$jy_master_lol2"] = [[不玩英雄联盟导致的!]],
["$jy_master_lol3"] = [[英雄联盟,启动!]],
}
--- masters end here
local guiyi = fk.CreateTriggerSkill {
name = "jy_guiyi",
anim_type = "offensive",
events = { fk.EventPhaseProceeding },
can_trigger = function(self, event, target, player, data)
return player:hasSkill(self) and
target.phase == Player.Finish and not player:isNude()
end,
on_use = function(self, event, target, player, data)
local room = player.room
local success, dat = room:askForUseActiveSkill(player, "#jy_guiyi_viewas", "#jy_guiyi-use", true,
{ bypass_distances = true })
if success then
local card = Fk:cloneCard("duel")
card:addSubcards(dat.cards)
card.skillName = self.name
local use = {
from = player.id,
tos = table.map(dat.targets, function(p) return { p } end),
card = card,
extraData = { bypass_distances = true },
}
room:useCard(use)
if use.damageDealt and use.damageDealt[player.id] then
room:killPlayer({ who = player.id })
end
end
end,
}
local guiyi_viewas = fk.CreateViewAsSkill {
name = "#jy_guiyi_viewas",
anim_type = "offensive",
pattern = "duel",
card_filter = function(self, to_select, selected)
if #selected == 1 then return false end
return true
end,
view_as = function(self, cards)
if #cards ~= 1 then
return nil
end
local c = Fk:cloneCard("duel")
c.skillName = self.name
c:addSubcard(cards[1])
return c
end,
}
guiyi:addRelatedSkill(guiyi_viewas)
Fk:loadTranslationTable {
["jy__gambler"] = [[赌徒]], -- TODOchange this
["#jy__gambler"] = "游刃有余",
["designer:jy__gambler"] = "考公专家",
["cv:jy__gambler"] = "暂无",
["illustrator:jy__gambler"] = "米哈游",
["jy_guiyi"] = [[命弈]],
[":jy_guiyi"] = [[每名角色的结束阶段,你可以将一张牌当【决斗】使用。若此【决斗】对你造成伤害,你死亡。]],
["#jy_guiyi_viewas"] = [[命弈]],
["#jy_guiyi-use"] = [[命弈:将一张牌当【决斗】使用,若其对你造成伤害则你死亡]],
}
local gambler = General(extension, "jy__gambler", "qun", 6)
gambler:addSkill(guiyi)
return extension