2023-04-09 05:35:35 +00:00
|
|
|
|
-- SPDX-License-Identifier: GPL-3.0-or-later
|
|
|
|
|
|
2022-03-30 08:33:56 +00:00
|
|
|
|
---@class ServerPlayer : Player
|
2023-03-26 09:32:45 +00:00
|
|
|
|
---@field public serverplayer fk.ServerPlayer
|
|
|
|
|
---@field public room Room
|
|
|
|
|
---@field public next ServerPlayer
|
|
|
|
|
---@field public request_data string
|
|
|
|
|
---@field public client_reply string
|
|
|
|
|
---@field public default_reply string
|
|
|
|
|
---@field public reply_ready boolean
|
|
|
|
|
---@field public reply_cancel boolean
|
|
|
|
|
---@field public phases Phase[]
|
|
|
|
|
---@field public skipped_phases Phase[]
|
|
|
|
|
---@field public phase_state table[]
|
|
|
|
|
---@field public phase_index integer
|
|
|
|
|
---@field public role_shown boolean
|
2023-08-09 14:25:15 +00:00
|
|
|
|
---@field private _fake_skills Skill[]
|
2023-09-06 14:16:09 +00:00
|
|
|
|
---@field private _manually_fake_skills Skill[]
|
2023-08-09 14:25:15 +00:00
|
|
|
|
---@field public prelighted_skills Skill[]
|
2023-08-02 13:40:00 +00:00
|
|
|
|
---@field private _timewaste_count integer
|
2023-03-26 09:32:45 +00:00
|
|
|
|
---@field public ai AI
|
|
|
|
|
---@field public ai_data any
|
2022-03-27 06:49:41 +00:00
|
|
|
|
local ServerPlayer = Player:subclass("ServerPlayer")
|
2022-03-25 04:28:07 +00:00
|
|
|
|
|
2022-03-27 06:49:41 +00:00
|
|
|
|
function ServerPlayer:initialize(_self)
|
2022-04-30 07:27:56 +00:00
|
|
|
|
Player.initialize(self)
|
2023-04-27 06:15:08 +00:00
|
|
|
|
self.serverplayer = _self -- 控制者
|
|
|
|
|
self._splayer = _self -- 真正在玩的玩家
|
|
|
|
|
self._observers = { _self } -- "旁观"中的玩家,然而不包括真正的旁观者
|
2022-04-30 07:27:56 +00:00
|
|
|
|
self.id = _self:getId()
|
|
|
|
|
self.room = nil
|
|
|
|
|
|
|
|
|
|
-- Below are for doBroadcastRequest
|
|
|
|
|
self.request_data = ""
|
|
|
|
|
self.client_reply = ""
|
|
|
|
|
self.default_reply = ""
|
|
|
|
|
self.reply_ready = false
|
2022-12-18 13:19:35 +00:00
|
|
|
|
self.reply_cancel = false
|
2022-04-30 07:27:56 +00:00
|
|
|
|
self.phases = {}
|
2022-12-20 10:40:17 +00:00
|
|
|
|
self.skipped_phases = {}
|
2023-08-09 14:25:15 +00:00
|
|
|
|
|
|
|
|
|
self._fake_skills = {}
|
2023-09-06 14:16:09 +00:00
|
|
|
|
self._manually_fake_skills = {}
|
2023-08-09 14:25:15 +00:00
|
|
|
|
self.prelighted_skills = {}
|
|
|
|
|
self._prelighted_skills = {}
|
|
|
|
|
|
2023-08-02 13:40:00 +00:00
|
|
|
|
self._timewaste_count = 0
|
2023-02-26 07:01:14 +00:00
|
|
|
|
self.ai = RandomAI:new(self)
|
2022-03-27 06:49:41 +00:00
|
|
|
|
end
|
|
|
|
|
|
2022-03-31 05:29:23 +00:00
|
|
|
|
---@param command string
|
|
|
|
|
---@param jsonData string
|
2022-03-28 14:24:30 +00:00
|
|
|
|
function ServerPlayer:doNotify(command, jsonData)
|
2023-04-27 06:15:08 +00:00
|
|
|
|
for _, p in ipairs(self._observers) do
|
|
|
|
|
p:doNotify(command, jsonData)
|
|
|
|
|
end
|
|
|
|
|
|
2023-02-15 11:54:35 +00:00
|
|
|
|
local room = self.room
|
|
|
|
|
for _, t in ipairs(room.observers) do
|
|
|
|
|
local id, p = table.unpack(t)
|
2023-07-12 12:35:05 +00:00
|
|
|
|
if id == self.id and room.room:hasObserver(p) then
|
2023-02-15 11:54:35 +00:00
|
|
|
|
p:doNotify(command, jsonData)
|
|
|
|
|
end
|
|
|
|
|
end
|
2022-03-28 14:24:30 +00:00
|
|
|
|
end
|
|
|
|
|
|
2022-03-31 05:29:23 +00:00
|
|
|
|
--- Send a request to client, and allow client to reply within *timeout* seconds.
|
|
|
|
|
---
|
|
|
|
|
--- *timeout* must not be negative. If nil, room.timeout is used.
|
|
|
|
|
---@param command string
|
|
|
|
|
---@param jsonData string
|
2023-12-03 11:35:14 +00:00
|
|
|
|
---@param timeout? integer
|
2022-03-28 14:24:30 +00:00
|
|
|
|
function ServerPlayer:doRequest(command, jsonData, timeout)
|
2022-04-30 07:27:56 +00:00
|
|
|
|
self.client_reply = ""
|
|
|
|
|
self.reply_ready = false
|
2022-12-18 13:19:35 +00:00
|
|
|
|
self.reply_cancel = false
|
2023-04-27 06:15:08 +00:00
|
|
|
|
|
|
|
|
|
if self.serverplayer:busy() then
|
|
|
|
|
self.room.request_queue[self.serverplayer] = self.room.request_queue[self.serverplayer] or {}
|
|
|
|
|
table.insert(self.room.request_queue[self.serverplayer], { self.id, command, jsonData, timeout })
|
|
|
|
|
return
|
|
|
|
|
end
|
|
|
|
|
|
|
|
|
|
self.room.request_self[self.serverplayer:getId()] = self.id
|
|
|
|
|
|
|
|
|
|
if not table.contains(self._observers, self.serverplayer) then
|
|
|
|
|
self.serverplayer:doNotify("StartChangeSelf", tostring(self.id))
|
|
|
|
|
end
|
|
|
|
|
|
|
|
|
|
timeout = timeout or self.room.timeout
|
|
|
|
|
self.serverplayer:setBusy(true)
|
2023-02-26 07:01:14 +00:00
|
|
|
|
self.ai_data = {
|
|
|
|
|
command = command,
|
|
|
|
|
jsonData = jsonData,
|
|
|
|
|
}
|
2022-04-30 07:27:56 +00:00
|
|
|
|
self.serverplayer:doRequest(command, jsonData, timeout)
|
2022-03-28 14:24:30 +00:00
|
|
|
|
end
|
|
|
|
|
|
2023-01-17 14:34:15 +00:00
|
|
|
|
local function _waitForReply(player, timeout)
|
|
|
|
|
local result
|
2023-02-21 05:44:24 +00:00
|
|
|
|
local start = os.getms()
|
2023-06-16 02:56:33 +00:00
|
|
|
|
local state = player.serverplayer:getState()
|
|
|
|
|
player.request_timeout = timeout
|
|
|
|
|
player.request_start = start
|
|
|
|
|
if state ~= fk.Player_Online then
|
2023-07-02 12:39:42 +00:00
|
|
|
|
if player.room.hasSurrendered then
|
|
|
|
|
return "__cancel"
|
|
|
|
|
end
|
|
|
|
|
|
2023-06-16 02:56:33 +00:00
|
|
|
|
if state ~= fk.Player_Robot then
|
|
|
|
|
player.room:checkNoHuman()
|
2023-06-04 11:31:44 +00:00
|
|
|
|
player.room:delay(500)
|
|
|
|
|
return "__cancel"
|
|
|
|
|
end
|
2023-02-26 07:01:14 +00:00
|
|
|
|
-- Let AI make reply. First handle request
|
2023-06-16 02:56:33 +00:00
|
|
|
|
-- coroutine.yield("__handleRequest", 0)
|
2023-02-26 07:01:14 +00:00
|
|
|
|
|
2023-06-16 02:56:33 +00:00
|
|
|
|
player.room:checkNoHuman()
|
2023-02-26 07:01:14 +00:00
|
|
|
|
player.ai:readRequestData()
|
|
|
|
|
local reply = player.ai:makeReply()
|
2023-08-27 12:21:37 +00:00
|
|
|
|
if reply == "" then reply = "__cancel" end
|
2023-02-26 07:01:14 +00:00
|
|
|
|
return reply
|
|
|
|
|
end
|
2023-01-17 14:34:15 +00:00
|
|
|
|
while true do
|
2023-06-16 02:56:33 +00:00
|
|
|
|
player.serverplayer:setThinking(true)
|
2023-01-17 14:34:15 +00:00
|
|
|
|
result = player.serverplayer:waitForReply(0)
|
|
|
|
|
if result ~= "__notready" then
|
2023-08-02 13:40:00 +00:00
|
|
|
|
player._timewaste_count = 0
|
2023-06-16 02:56:33 +00:00
|
|
|
|
player.serverplayer:setThinking(false)
|
2023-01-17 14:34:15 +00:00
|
|
|
|
return result
|
|
|
|
|
end
|
2023-02-26 07:01:14 +00:00
|
|
|
|
local rest = timeout * 1000 - (os.getms() - start) / 1000
|
|
|
|
|
if timeout and rest <= 0 then
|
2023-08-03 07:24:17 +00:00
|
|
|
|
if timeout >= 15 then
|
|
|
|
|
player._timewaste_count = player._timewaste_count + 1
|
|
|
|
|
end
|
2023-06-16 02:56:33 +00:00
|
|
|
|
player.serverplayer:setThinking(false)
|
2023-08-02 13:40:00 +00:00
|
|
|
|
|
|
|
|
|
if player._timewaste_count >= 3 then
|
2023-08-03 07:24:17 +00:00
|
|
|
|
player._timewaste_count = 0
|
2023-08-02 13:40:00 +00:00
|
|
|
|
player.serverplayer:emitKick()
|
|
|
|
|
end
|
|
|
|
|
|
2023-01-17 14:34:15 +00:00
|
|
|
|
return ""
|
|
|
|
|
end
|
2023-07-02 12:39:42 +00:00
|
|
|
|
|
|
|
|
|
if player.room.hasSurrendered then
|
|
|
|
|
player.serverplayer:setThinking(false)
|
|
|
|
|
return ""
|
|
|
|
|
end
|
|
|
|
|
|
2023-02-28 17:43:44 +00:00
|
|
|
|
coroutine.yield("__handleRequest", rest)
|
2023-01-17 14:34:15 +00:00
|
|
|
|
end
|
|
|
|
|
end
|
|
|
|
|
|
2022-03-31 05:29:23 +00:00
|
|
|
|
--- Wait for at most *timeout* seconds for reply from client.
|
|
|
|
|
---
|
|
|
|
|
--- If *timeout* is negative or **nil**, the function will wait forever until get reply.
|
2022-04-02 13:39:44 +00:00
|
|
|
|
---@param timeout integer @ seconds to wait
|
|
|
|
|
---@return string @ JSON data
|
2022-03-30 06:14:40 +00:00
|
|
|
|
function ServerPlayer:waitForReply(timeout)
|
2023-01-17 14:34:15 +00:00
|
|
|
|
local result = _waitForReply(self, timeout)
|
2023-04-27 06:15:08 +00:00
|
|
|
|
local sid = self.serverplayer:getId()
|
|
|
|
|
local id = self.id
|
|
|
|
|
if self.room.request_self[sid] ~= id then
|
|
|
|
|
result = ""
|
|
|
|
|
end
|
|
|
|
|
|
2022-04-30 07:27:56 +00:00
|
|
|
|
self.request_data = ""
|
|
|
|
|
self.client_reply = result
|
2022-12-18 13:19:35 +00:00
|
|
|
|
if result == "__cancel" then
|
|
|
|
|
result = ""
|
|
|
|
|
self.reply_cancel = true
|
2023-04-27 06:15:08 +00:00
|
|
|
|
self.serverplayer:setBusy(false)
|
2023-06-18 16:20:50 +00:00
|
|
|
|
self.serverplayer:setThinking(false)
|
2023-04-27 06:15:08 +00:00
|
|
|
|
end
|
|
|
|
|
if result ~= "" then
|
|
|
|
|
self.reply_ready = true
|
|
|
|
|
self.serverplayer:setBusy(false)
|
2023-06-18 16:20:50 +00:00
|
|
|
|
self.serverplayer:setThinking(false)
|
2022-12-18 13:19:35 +00:00
|
|
|
|
end
|
2023-04-27 06:15:08 +00:00
|
|
|
|
|
2023-10-18 13:46:11 +00:00
|
|
|
|
-- FIXME: 一控多求无懈
|
2023-04-27 06:15:08 +00:00
|
|
|
|
local queue = self.room.request_queue[self.serverplayer]
|
|
|
|
|
if queue and #queue > 0 and not self.serverplayer:busy() then
|
|
|
|
|
local i, c, j, t = table.unpack(table.remove(queue, 1))
|
|
|
|
|
self.room:getPlayerById(i):doRequest(c, j, t)
|
|
|
|
|
end
|
|
|
|
|
|
2022-04-30 07:27:56 +00:00
|
|
|
|
return result
|
2022-03-30 06:14:40 +00:00
|
|
|
|
end
|
|
|
|
|
|
2023-01-17 14:34:15 +00:00
|
|
|
|
---@param player ServerPlayer
|
2023-12-03 11:35:14 +00:00
|
|
|
|
---@param observe? boolean
|
2023-08-03 12:34:43 +00:00
|
|
|
|
function ServerPlayer:marshal(player, observe)
|
2023-01-17 14:34:15 +00:00
|
|
|
|
local room = self.room
|
2023-02-15 16:54:39 +00:00
|
|
|
|
if not room.game_started then
|
|
|
|
|
-- If game does not starts, that mean we are entering room that
|
|
|
|
|
-- all players are choosing their generals.
|
|
|
|
|
-- Note that when we are in this function, the main thread must be
|
|
|
|
|
-- calling delay() or waiting for reply.
|
|
|
|
|
if self.role_shown then
|
|
|
|
|
room:notifyProperty(player, self, "role")
|
|
|
|
|
end
|
|
|
|
|
return
|
|
|
|
|
end
|
|
|
|
|
|
2023-01-17 14:34:15 +00:00
|
|
|
|
room:notifyProperty(player, self, "maxHp")
|
|
|
|
|
room:notifyProperty(player, self, "hp")
|
2023-04-13 12:17:39 +00:00
|
|
|
|
room:notifyProperty(player, self, "shield")
|
2023-01-29 10:11:41 +00:00
|
|
|
|
room:notifyProperty(player, self, "gender")
|
2023-04-12 14:28:19 +00:00
|
|
|
|
room:notifyProperty(player, self, "kingdom")
|
2023-01-17 14:34:15 +00:00
|
|
|
|
|
|
|
|
|
if self.dead then
|
|
|
|
|
room:notifyProperty(player, self, "dead")
|
|
|
|
|
room:notifyProperty(player, self, "role")
|
|
|
|
|
else
|
|
|
|
|
room:notifyProperty(player, self, "seat")
|
|
|
|
|
room:notifyProperty(player, self, "phase")
|
|
|
|
|
end
|
|
|
|
|
|
|
|
|
|
if not self.faceup then
|
|
|
|
|
room:notifyProperty(player, self, "faceup")
|
|
|
|
|
end
|
|
|
|
|
|
|
|
|
|
if self.chained then
|
|
|
|
|
room:notifyProperty(player, self, "chained")
|
|
|
|
|
end
|
|
|
|
|
|
|
|
|
|
local card_moves = {}
|
|
|
|
|
if #self.player_cards[Player.Hand] ~= 0 then
|
|
|
|
|
local info = {}
|
|
|
|
|
for _, i in ipairs(self.player_cards[Player.Hand]) do
|
|
|
|
|
table.insert(info, { cardId = i, fromArea = Card.DrawPile })
|
|
|
|
|
end
|
|
|
|
|
local move = {
|
|
|
|
|
moveInfo = info,
|
|
|
|
|
to = self.id,
|
|
|
|
|
toArea = Card.PlayerHand
|
|
|
|
|
}
|
|
|
|
|
table.insert(card_moves, move)
|
|
|
|
|
end
|
|
|
|
|
if #self.player_cards[Player.Equip] ~= 0 then
|
|
|
|
|
local info = {}
|
|
|
|
|
for _, i in ipairs(self.player_cards[Player.Equip]) do
|
|
|
|
|
table.insert(info, { cardId = i, fromArea = Card.DrawPile })
|
|
|
|
|
end
|
|
|
|
|
local move = {
|
|
|
|
|
moveInfo = info,
|
|
|
|
|
to = self.id,
|
|
|
|
|
toArea = Card.PlayerEquip
|
|
|
|
|
}
|
|
|
|
|
table.insert(card_moves, move)
|
|
|
|
|
end
|
|
|
|
|
if #self.player_cards[Player.Judge] ~= 0 then
|
|
|
|
|
local info = {}
|
|
|
|
|
for _, i in ipairs(self.player_cards[Player.Judge]) do
|
|
|
|
|
table.insert(info, { cardId = i, fromArea = Card.DrawPile })
|
|
|
|
|
end
|
|
|
|
|
local move = {
|
|
|
|
|
moveInfo = info,
|
|
|
|
|
to = self.id,
|
|
|
|
|
toArea = Card.PlayerJudge
|
|
|
|
|
}
|
|
|
|
|
table.insert(card_moves, move)
|
|
|
|
|
end
|
2023-06-16 05:26:02 +00:00
|
|
|
|
|
|
|
|
|
for k, v in pairs(self.special_cards) do
|
|
|
|
|
local info = {}
|
|
|
|
|
for _, i in ipairs(v) do
|
|
|
|
|
table.insert(info, { cardId = i, fromArea = Card.DrawPile })
|
|
|
|
|
end
|
|
|
|
|
local move = {
|
|
|
|
|
moveInfo = info,
|
|
|
|
|
to = self.id,
|
|
|
|
|
toArea = Card.PlayerSpecial,
|
|
|
|
|
specialName = k,
|
|
|
|
|
specialVisible = self == player,
|
|
|
|
|
}
|
|
|
|
|
table.insert(card_moves, move)
|
|
|
|
|
end
|
|
|
|
|
|
2023-01-17 14:34:15 +00:00
|
|
|
|
if #card_moves > 0 then
|
2023-08-03 12:34:43 +00:00
|
|
|
|
room:notifyMoveCards({ player }, card_moves, observe and self.seat == 1)
|
2023-01-17 14:34:15 +00:00
|
|
|
|
end
|
|
|
|
|
|
2023-05-26 12:53:26 +00:00
|
|
|
|
for k, v in pairs(self.mark) do
|
|
|
|
|
player:doNotify("SetPlayerMark", json.encode{self.id, k, v})
|
|
|
|
|
end
|
2023-01-17 14:34:15 +00:00
|
|
|
|
|
|
|
|
|
for _, s in ipairs(self.player_skills) do
|
|
|
|
|
player:doNotify("AddSkill", json.encode{self.id, s.name})
|
|
|
|
|
end
|
|
|
|
|
|
|
|
|
|
for k, v in pairs(self.cardUsedHistory) do
|
2023-02-21 05:44:24 +00:00
|
|
|
|
if v[1] > 0 then
|
|
|
|
|
player:doNotify("AddCardUseHistory", json.encode{k, v[1]})
|
|
|
|
|
end
|
2023-01-17 14:34:15 +00:00
|
|
|
|
end
|
|
|
|
|
|
2023-06-04 11:31:44 +00:00
|
|
|
|
for k, v in pairs(self.skillUsedHistory) do
|
2023-06-16 05:26:02 +00:00
|
|
|
|
if v[4] > 0 then
|
|
|
|
|
player:doNotify("SetSkillUseHistory", json.encode{self.id, k, v[1], 1})
|
|
|
|
|
player:doNotify("SetSkillUseHistory", json.encode{self.id, k, v[2], 2})
|
|
|
|
|
player:doNotify("SetSkillUseHistory", json.encode{self.id, k, v[3], 3})
|
|
|
|
|
player:doNotify("SetSkillUseHistory", json.encode{self.id, k, v[4], 4})
|
2023-06-04 11:31:44 +00:00
|
|
|
|
end
|
|
|
|
|
end
|
|
|
|
|
|
2023-01-17 14:34:15 +00:00
|
|
|
|
if self.role_shown then
|
|
|
|
|
room:notifyProperty(player, self, "role")
|
|
|
|
|
end
|
2023-08-12 18:25:04 +00:00
|
|
|
|
|
|
|
|
|
if #self.sealedSlots > 0 then
|
|
|
|
|
room:notifyProperty(player, self, "sealedSlots")
|
|
|
|
|
end
|
2023-01-17 14:34:15 +00:00
|
|
|
|
end
|
|
|
|
|
|
|
|
|
|
function ServerPlayer:reconnect()
|
|
|
|
|
local room = self.room
|
2023-06-16 02:56:33 +00:00
|
|
|
|
self.serverplayer:setState(fk.Player_Online)
|
2023-01-17 14:34:15 +00:00
|
|
|
|
|
|
|
|
|
self:doNotify("Setup", json.encode{
|
|
|
|
|
self.id,
|
2023-06-30 20:12:19 +00:00
|
|
|
|
self._splayer:getScreenName(),
|
|
|
|
|
self._splayer:getAvatar(),
|
2023-01-17 14:34:15 +00:00
|
|
|
|
})
|
|
|
|
|
self:doNotify("EnterLobby", "")
|
|
|
|
|
self:doNotify("EnterRoom", json.encode{
|
2023-04-19 16:19:48 +00:00
|
|
|
|
#room.players, room.timeout, room.settings,
|
2023-01-17 14:34:15 +00:00
|
|
|
|
})
|
2023-05-19 08:23:24 +00:00
|
|
|
|
self:doNotify("StartGame", "")
|
2023-01-17 14:34:15 +00:00
|
|
|
|
room:notifyProperty(self, self, "role")
|
|
|
|
|
|
|
|
|
|
-- send player data
|
2023-07-04 10:20:52 +00:00
|
|
|
|
for _, p in ipairs(room:getOtherPlayers(self, false, true)) do
|
2023-01-17 14:34:15 +00:00
|
|
|
|
self:doNotify("AddPlayer", json.encode{
|
|
|
|
|
p.id,
|
2023-06-30 20:12:19 +00:00
|
|
|
|
p._splayer:getScreenName(),
|
|
|
|
|
p._splayer:getAvatar(),
|
2023-01-17 14:34:15 +00:00
|
|
|
|
})
|
|
|
|
|
end
|
2023-10-07 15:00:25 +00:00
|
|
|
|
self:doNotify("RoomOwner", json.encode{ room.room:getOwner():getId() })
|
2023-01-17 14:34:15 +00:00
|
|
|
|
|
|
|
|
|
local player_circle = {}
|
|
|
|
|
for i = 1, #room.players do
|
|
|
|
|
table.insert(player_circle, room.players[i].id)
|
|
|
|
|
end
|
|
|
|
|
self:doNotify("ArrangeSeats", json.encode(player_circle))
|
|
|
|
|
|
2023-09-06 14:16:09 +00:00
|
|
|
|
-- send printed_cards
|
|
|
|
|
for i = -2, -math.huge, -1 do
|
|
|
|
|
local c = Fk.printed_cards[i]
|
|
|
|
|
if not c then break end
|
|
|
|
|
self:doNotify("PrintCard", json.encode{ c.name, c.suit, c.number })
|
|
|
|
|
end
|
|
|
|
|
|
|
|
|
|
-- send card marks
|
|
|
|
|
for id, marks in pairs(room.card_marks) do
|
|
|
|
|
for k, v in pairs(marks) do
|
|
|
|
|
self:doNotify("SetCardMark", json.encode{ id, k, v })
|
|
|
|
|
end
|
|
|
|
|
end
|
|
|
|
|
|
2023-12-06 13:07:35 +00:00
|
|
|
|
-- send banners
|
|
|
|
|
for k, v in pairs(room.banners) do
|
|
|
|
|
self:doNotify("SetBanner", json.encode{ k, v })
|
|
|
|
|
end
|
|
|
|
|
|
2023-09-06 14:33:42 +00:00
|
|
|
|
for _, p in ipairs(room.players) do
|
|
|
|
|
room:notifyProperty(self, p, "general")
|
|
|
|
|
room:notifyProperty(self, p, "deputyGeneral")
|
|
|
|
|
p:marshal(self)
|
|
|
|
|
end
|
|
|
|
|
|
|
|
|
|
self:doNotify("UpdateDrawPile", #room.draw_pile)
|
|
|
|
|
self:doNotify("UpdateRoundNum", room:getTag("RoundCount") or 0)
|
|
|
|
|
|
2023-09-06 14:16:09 +00:00
|
|
|
|
-- send fake skills
|
|
|
|
|
for _, s in ipairs(self._manually_fake_skills) do
|
|
|
|
|
self:doNotify("AddSkill", json.encode{ self.id, s.name, true })
|
|
|
|
|
if table.contains(self.prelighted_skills, s) then
|
|
|
|
|
self:doNotify("PrelightSkill", json.encode{ s.name, true })
|
|
|
|
|
end
|
|
|
|
|
end
|
|
|
|
|
|
2023-01-17 14:34:15 +00:00
|
|
|
|
room:broadcastProperty(self, "state")
|
|
|
|
|
end
|
|
|
|
|
|
2022-04-01 12:51:01 +00:00
|
|
|
|
function ServerPlayer:isAlive()
|
2022-04-30 07:27:56 +00:00
|
|
|
|
return self.dead == false
|
2022-04-01 12:51:01 +00:00
|
|
|
|
end
|
|
|
|
|
|
2022-04-02 13:39:44 +00:00
|
|
|
|
function ServerPlayer:turnOver()
|
2023-05-28 10:45:54 +00:00
|
|
|
|
if self.room.logic:trigger(fk.BeforeTurnOver, self) then
|
|
|
|
|
return
|
|
|
|
|
end
|
|
|
|
|
|
2022-04-30 07:27:56 +00:00
|
|
|
|
self.faceup = not self.faceup
|
|
|
|
|
self.room:broadcastProperty(self, "faceup")
|
2022-04-02 13:39:44 +00:00
|
|
|
|
|
2022-12-18 04:52:52 +00:00
|
|
|
|
self.room:sendLog{
|
|
|
|
|
type = "#TurnOver",
|
|
|
|
|
from = self.id,
|
|
|
|
|
arg = self.faceup and "face_up" or "face_down",
|
|
|
|
|
}
|
2023-05-28 10:45:54 +00:00
|
|
|
|
|
2022-04-30 07:27:56 +00:00
|
|
|
|
self.room.logic:trigger(fk.TurnedOver, self)
|
2022-04-02 13:39:44 +00:00
|
|
|
|
end
|
|
|
|
|
|
2023-03-20 12:15:24 +00:00
|
|
|
|
function ServerPlayer:showCards(cards)
|
|
|
|
|
cards = Card:getIdList(cards)
|
2023-06-24 07:05:58 +00:00
|
|
|
|
for _, id in ipairs(cards) do
|
|
|
|
|
Fk:filterCard(id, self)
|
|
|
|
|
end
|
|
|
|
|
|
2023-03-20 12:15:24 +00:00
|
|
|
|
local room = self.room
|
|
|
|
|
room:sendLog{
|
|
|
|
|
type = "#ShowCard",
|
|
|
|
|
from = self.id,
|
|
|
|
|
card = cards,
|
|
|
|
|
}
|
|
|
|
|
room:doBroadcastNotify("ShowCard", json.encode{
|
|
|
|
|
from = self.id,
|
|
|
|
|
cards = cards,
|
|
|
|
|
})
|
2023-06-09 18:18:51 +00:00
|
|
|
|
room:sendFootnote(cards, {
|
|
|
|
|
type = "##ShowCard",
|
|
|
|
|
from = self.id,
|
|
|
|
|
})
|
2023-05-20 08:00:03 +00:00
|
|
|
|
|
|
|
|
|
room.logic:trigger(fk.CardShown, self, { cardIds = cards })
|
2023-03-20 12:15:24 +00:00
|
|
|
|
end
|
|
|
|
|
|
2023-06-08 17:10:16 +00:00
|
|
|
|
local phase_name_table = {
|
|
|
|
|
[Player.Judge] = "phase_judge",
|
|
|
|
|
[Player.Draw] = "phase_draw",
|
|
|
|
|
[Player.Play] = "phase_play",
|
|
|
|
|
[Player.Discard] = "phase_discard",
|
|
|
|
|
}
|
|
|
|
|
|
2022-04-04 11:04:55 +00:00
|
|
|
|
---@param from_phase Phase
|
|
|
|
|
---@param to_phase Phase
|
|
|
|
|
function ServerPlayer:changePhase(from_phase, to_phase)
|
2022-04-30 07:27:56 +00:00
|
|
|
|
local room = self.room
|
|
|
|
|
local logic = room.logic
|
|
|
|
|
self.phase = Player.PhaseNone
|
2022-04-04 11:04:55 +00:00
|
|
|
|
|
2022-04-30 07:27:56 +00:00
|
|
|
|
local phase_change = {
|
|
|
|
|
from = from_phase,
|
|
|
|
|
to = to_phase
|
|
|
|
|
}
|
2022-04-04 11:04:55 +00:00
|
|
|
|
|
2022-04-30 07:27:56 +00:00
|
|
|
|
local skip = logic:trigger(fk.EventPhaseChanging, self, phase_change)
|
|
|
|
|
if skip and to_phase ~= Player.NotActive then
|
|
|
|
|
self.phase = from_phase
|
|
|
|
|
return true
|
|
|
|
|
end
|
2022-04-04 11:04:55 +00:00
|
|
|
|
|
2022-04-30 07:27:56 +00:00
|
|
|
|
self.phase = to_phase
|
2023-07-16 07:32:16 +00:00
|
|
|
|
room:broadcastProperty(self, "phase")
|
2022-04-04 11:04:55 +00:00
|
|
|
|
|
2023-02-26 08:51:29 +00:00
|
|
|
|
if #self.phases > 0 then
|
2022-04-30 07:27:56 +00:00
|
|
|
|
table.remove(self.phases, 1)
|
|
|
|
|
end
|
2022-04-04 11:04:55 +00:00
|
|
|
|
|
2023-08-03 05:49:34 +00:00
|
|
|
|
GameEvent(GameEvent.Phase, self, self.phase):exec()
|
2022-04-30 07:27:56 +00:00
|
|
|
|
|
|
|
|
|
return false
|
2022-04-04 11:04:55 +00:00
|
|
|
|
end
|
|
|
|
|
|
2023-06-08 17:10:16 +00:00
|
|
|
|
function ServerPlayer:gainAnExtraPhase(phase, delay)
|
2023-04-22 07:52:26 +00:00
|
|
|
|
local room = self.room
|
2023-06-08 17:10:16 +00:00
|
|
|
|
delay = (delay == nil) and true or delay
|
|
|
|
|
if delay then
|
|
|
|
|
local logic = room.logic
|
|
|
|
|
local turn = logic:getCurrentEvent():findParent(GameEvent.Phase, true)
|
|
|
|
|
if turn then
|
2023-09-19 06:27:54 +00:00
|
|
|
|
turn:prependExitFunc(function() self:gainAnExtraPhase(phase, false) end)
|
2023-06-08 17:10:16 +00:00
|
|
|
|
return
|
|
|
|
|
end
|
|
|
|
|
end
|
|
|
|
|
|
2023-04-22 07:52:26 +00:00
|
|
|
|
local current = self.phase
|
|
|
|
|
self.phase = phase
|
2023-07-16 07:32:16 +00:00
|
|
|
|
room:broadcastProperty(self, "phase")
|
2023-04-22 07:52:26 +00:00
|
|
|
|
|
2023-06-08 17:10:16 +00:00
|
|
|
|
room:sendLog{
|
|
|
|
|
type = "#GainAnExtraPhase",
|
|
|
|
|
from = self.id,
|
|
|
|
|
arg = phase_name_table[phase],
|
|
|
|
|
}
|
|
|
|
|
|
2023-08-03 05:49:34 +00:00
|
|
|
|
GameEvent(GameEvent.Phase, self, self.phase):exec()
|
2023-04-22 07:52:26 +00:00
|
|
|
|
|
|
|
|
|
self.phase = current
|
2023-07-16 07:32:16 +00:00
|
|
|
|
room:broadcastProperty(self, "phase")
|
2023-04-22 07:52:26 +00:00
|
|
|
|
end
|
|
|
|
|
|
2023-12-03 11:35:14 +00:00
|
|
|
|
---@param phase_table? Phase[]
|
2022-04-04 11:04:55 +00:00
|
|
|
|
function ServerPlayer:play(phase_table)
|
2022-04-30 07:27:56 +00:00
|
|
|
|
phase_table = phase_table or {}
|
|
|
|
|
if #phase_table > 0 then
|
|
|
|
|
if not table.contains(phase_table, Player.NotActive) then
|
|
|
|
|
table.insert(phase_table, Player.NotActive)
|
2022-04-04 11:04:55 +00:00
|
|
|
|
end
|
2022-04-30 07:27:56 +00:00
|
|
|
|
else
|
|
|
|
|
phase_table = {
|
|
|
|
|
Player.RoundStart, Player.Start,
|
|
|
|
|
Player.Judge, Player.Draw, Player.Play, Player.Discard,
|
|
|
|
|
Player.Finish, Player.NotActive,
|
|
|
|
|
}
|
|
|
|
|
end
|
|
|
|
|
|
|
|
|
|
self.phases = phase_table
|
|
|
|
|
self.phase_state = {}
|
2022-04-04 11:04:55 +00:00
|
|
|
|
|
2022-04-30 07:27:56 +00:00
|
|
|
|
local phases = self.phases
|
|
|
|
|
local phase_state = self.phase_state
|
|
|
|
|
local room = self.room
|
2022-04-04 11:04:55 +00:00
|
|
|
|
|
2022-04-30 07:27:56 +00:00
|
|
|
|
for i = 1, #phases do
|
|
|
|
|
phase_state[i] = {
|
|
|
|
|
phase = phases[i],
|
2022-12-20 10:40:17 +00:00
|
|
|
|
skipped = self.skipped_phases[phases[i]] or false
|
2022-04-30 07:27:56 +00:00
|
|
|
|
}
|
|
|
|
|
end
|
2022-04-04 11:04:55 +00:00
|
|
|
|
|
2022-04-30 07:27:56 +00:00
|
|
|
|
for i = 1, #phases do
|
|
|
|
|
if self.dead then
|
|
|
|
|
self:changePhase(self.phase, Player.NotActive)
|
|
|
|
|
break
|
2022-04-04 11:04:55 +00:00
|
|
|
|
end
|
|
|
|
|
|
2022-04-30 07:27:56 +00:00
|
|
|
|
self.phase_index = i
|
|
|
|
|
local phase_change = {
|
|
|
|
|
from = self.phase,
|
|
|
|
|
to = phases[i]
|
|
|
|
|
}
|
2022-04-04 11:04:55 +00:00
|
|
|
|
|
2022-04-30 07:27:56 +00:00
|
|
|
|
local logic = self.room.logic
|
|
|
|
|
self.phase = Player.PhaseNone
|
2022-04-04 11:04:55 +00:00
|
|
|
|
|
2022-12-20 10:40:17 +00:00
|
|
|
|
local skip = phase_state[i].skipped
|
|
|
|
|
if not skip then
|
|
|
|
|
skip = logic:trigger(fk.EventPhaseChanging, self, phase_change)
|
|
|
|
|
end
|
2022-04-30 07:27:56 +00:00
|
|
|
|
phases[i] = phase_change.to
|
|
|
|
|
phase_state[i].phase = phases[i]
|
2022-04-04 11:04:55 +00:00
|
|
|
|
|
2022-04-30 07:27:56 +00:00
|
|
|
|
self.phase = phases[i]
|
2023-07-16 07:32:16 +00:00
|
|
|
|
room:broadcastProperty(self, "phase")
|
2022-04-04 11:04:55 +00:00
|
|
|
|
|
2022-04-30 07:27:56 +00:00
|
|
|
|
local cancel_skip = true
|
2022-12-20 10:40:17 +00:00
|
|
|
|
if phases[i] ~= Player.NotActive and (skip) then
|
2022-04-30 07:27:56 +00:00
|
|
|
|
cancel_skip = logic:trigger(fk.EventPhaseSkipping, self)
|
|
|
|
|
end
|
2022-04-04 11:04:55 +00:00
|
|
|
|
|
2022-04-30 07:27:56 +00:00
|
|
|
|
if (not skip) or (cancel_skip) then
|
2023-08-03 05:49:34 +00:00
|
|
|
|
GameEvent(GameEvent.Phase, self, self.phase):exec()
|
2022-12-20 10:40:17 +00:00
|
|
|
|
else
|
|
|
|
|
room:sendLog{
|
|
|
|
|
type = "#PhaseSkipped",
|
|
|
|
|
from = self.id,
|
|
|
|
|
arg = phase_name_table[self.phase],
|
|
|
|
|
}
|
|
|
|
|
end
|
|
|
|
|
end
|
|
|
|
|
end
|
|
|
|
|
|
|
|
|
|
---@param phase Phase
|
|
|
|
|
function ServerPlayer:skip(phase)
|
|
|
|
|
if not table.contains({
|
|
|
|
|
Player.Judge,
|
|
|
|
|
Player.Draw,
|
|
|
|
|
Player.Play,
|
|
|
|
|
Player.Discard
|
|
|
|
|
}, phase) then
|
|
|
|
|
return
|
|
|
|
|
end
|
|
|
|
|
self.skipped_phases[phase] = true
|
|
|
|
|
for _, t in ipairs(self.phase_state) do
|
|
|
|
|
if t.phase == phase then
|
|
|
|
|
t.skipped = true
|
2022-04-04 11:04:55 +00:00
|
|
|
|
end
|
2022-04-30 07:27:56 +00:00
|
|
|
|
end
|
2022-04-04 11:04:55 +00:00
|
|
|
|
end
|
|
|
|
|
|
2023-09-19 06:27:54 +00:00
|
|
|
|
--- 当进行到出牌阶段空闲点时,结束出牌阶段。
|
2023-08-11 16:50:17 +00:00
|
|
|
|
function ServerPlayer:endPlayPhase()
|
|
|
|
|
self._play_phase_end = true
|
|
|
|
|
-- TODO: send log
|
|
|
|
|
end
|
|
|
|
|
|
2023-06-08 17:10:16 +00:00
|
|
|
|
function ServerPlayer:gainAnExtraTurn(delay)
|
2023-03-13 12:51:12 +00:00
|
|
|
|
local room = self.room
|
2023-06-08 17:10:16 +00:00
|
|
|
|
delay = (delay == nil) and true or delay
|
|
|
|
|
if delay then
|
|
|
|
|
local logic = room.logic
|
|
|
|
|
local turn = logic:getCurrentEvent():findParent(GameEvent.Turn, true)
|
|
|
|
|
if turn then
|
2023-09-19 06:27:54 +00:00
|
|
|
|
turn:prependExitFunc(function() self:gainAnExtraTurn(false) end)
|
2023-06-08 17:10:16 +00:00
|
|
|
|
return
|
|
|
|
|
end
|
|
|
|
|
end
|
|
|
|
|
|
2023-03-13 12:51:12 +00:00
|
|
|
|
room:sendLog{
|
|
|
|
|
type = "#GainAnExtraTurn",
|
|
|
|
|
from = self.id
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
local current = room.current
|
|
|
|
|
room.current = self
|
2023-09-19 06:27:54 +00:00
|
|
|
|
|
|
|
|
|
self.tag["_extra_turn_count"] = self.tag["_extra_turn_count"] or {}
|
|
|
|
|
local ex_tag = self.tag["_extra_turn_count"]
|
|
|
|
|
local skillName = room.logic:getCurrentSkillName()
|
|
|
|
|
table.insert(ex_tag, skillName)
|
|
|
|
|
|
2023-08-03 05:49:34 +00:00
|
|
|
|
GameEvent(GameEvent.Turn, self):exec()
|
2023-09-19 06:27:54 +00:00
|
|
|
|
|
|
|
|
|
table.remove(ex_tag)
|
|
|
|
|
|
2023-03-13 12:51:12 +00:00
|
|
|
|
room.current = current
|
|
|
|
|
end
|
|
|
|
|
|
2023-09-19 06:27:54 +00:00
|
|
|
|
function ServerPlayer:insideExtraTurn()
|
|
|
|
|
return self.tag["_extra_turn_count"] and #self.tag["_extra_turn_count"] > 0
|
|
|
|
|
end
|
|
|
|
|
|
|
|
|
|
---@return string
|
|
|
|
|
function ServerPlayer:getCurrentExtraTurnReason()
|
|
|
|
|
local ex_tag = self.tag["_extra_turn_count"]
|
|
|
|
|
if (not ex_tag) or #ex_tag == 0 then
|
|
|
|
|
return "game_rule"
|
|
|
|
|
end
|
|
|
|
|
return ex_tag[#ex_tag]
|
|
|
|
|
end
|
|
|
|
|
|
2022-12-20 04:51:54 +00:00
|
|
|
|
function ServerPlayer:drawCards(num, skillName, fromPlace)
|
|
|
|
|
return self.room:drawCards(self, num, skillName, fromPlace)
|
|
|
|
|
end
|
|
|
|
|
|
2023-02-21 05:44:24 +00:00
|
|
|
|
---@param pile_name string
|
|
|
|
|
---@param card integer|Card
|
|
|
|
|
---@param visible boolean
|
2023-12-03 11:35:14 +00:00
|
|
|
|
---@param skillName? string
|
2023-02-21 05:44:24 +00:00
|
|
|
|
function ServerPlayer:addToPile(pile_name, card, visible, skillName)
|
|
|
|
|
local room = self.room
|
|
|
|
|
room:moveCardTo(card, Card.PlayerSpecial, self, fk.ReasonJustMove, skillName, pile_name, visible)
|
|
|
|
|
end
|
|
|
|
|
|
2022-12-20 04:51:54 +00:00
|
|
|
|
function ServerPlayer:bury()
|
2023-03-18 15:37:21 +00:00
|
|
|
|
self:setCardUseHistory("")
|
|
|
|
|
self:setSkillUseHistory("")
|
2022-12-20 04:51:54 +00:00
|
|
|
|
self:throwAllCards()
|
2023-03-18 15:37:21 +00:00
|
|
|
|
self:throwAllMarks()
|
|
|
|
|
self:clearPiles()
|
2023-07-11 15:16:46 +00:00
|
|
|
|
self:reset()
|
2022-12-20 04:51:54 +00:00
|
|
|
|
end
|
|
|
|
|
|
|
|
|
|
function ServerPlayer:throwAllCards(flag)
|
2023-08-03 07:26:52 +00:00
|
|
|
|
local cardIds = {}
|
2022-12-20 04:51:54 +00:00
|
|
|
|
flag = flag or "hej"
|
|
|
|
|
if string.find(flag, "h") then
|
2023-08-03 07:26:52 +00:00
|
|
|
|
table.insertTable(cardIds, self.player_cards[Player.Hand])
|
2022-12-20 04:51:54 +00:00
|
|
|
|
end
|
|
|
|
|
|
|
|
|
|
if string.find(flag, "e") then
|
2023-08-03 07:26:52 +00:00
|
|
|
|
table.insertTable(cardIds, self.player_cards[Player.Equip])
|
2022-12-20 04:51:54 +00:00
|
|
|
|
end
|
|
|
|
|
|
|
|
|
|
if string.find(flag, "j") then
|
2023-08-03 07:26:52 +00:00
|
|
|
|
table.insertTable(cardIds, self.player_cards[Player.Judge])
|
2022-12-20 04:51:54 +00:00
|
|
|
|
end
|
2023-08-03 07:26:52 +00:00
|
|
|
|
|
|
|
|
|
self.room:throwCard(cardIds, "", self)
|
2022-12-20 04:51:54 +00:00
|
|
|
|
end
|
|
|
|
|
|
2023-03-18 15:37:21 +00:00
|
|
|
|
function ServerPlayer:throwAllMarks()
|
|
|
|
|
for name, _ in pairs(self.mark) do
|
|
|
|
|
self.room:setPlayerMark(self, name, 0)
|
|
|
|
|
end
|
|
|
|
|
end
|
|
|
|
|
|
|
|
|
|
function ServerPlayer:clearPiles()
|
2023-08-03 07:26:52 +00:00
|
|
|
|
local cardIds = {}
|
2023-03-18 15:37:21 +00:00
|
|
|
|
for _, ids in pairs(self.special_cards) do
|
2023-08-03 07:26:52 +00:00
|
|
|
|
table.insertTable(cardIds, ids)
|
2023-03-18 15:37:21 +00:00
|
|
|
|
end
|
2023-08-03 07:26:52 +00:00
|
|
|
|
self.room:moveCardTo(cardIds, Card.DiscardPile, nil, fk.ReasonPutIntoDiscardPile, "", nil, true)
|
2023-03-18 15:37:21 +00:00
|
|
|
|
end
|
|
|
|
|
|
2023-01-29 10:11:41 +00:00
|
|
|
|
function ServerPlayer:addVirtualEquip(card)
|
|
|
|
|
Player.addVirtualEquip(self, card)
|
|
|
|
|
self.room:doBroadcastNotify("AddVirtualEquip", json.encode{
|
|
|
|
|
player = self.id,
|
|
|
|
|
name = card.name,
|
|
|
|
|
subcards = card.subcards,
|
|
|
|
|
})
|
|
|
|
|
end
|
|
|
|
|
|
|
|
|
|
function ServerPlayer:removeVirtualEquip(cid)
|
|
|
|
|
local ret = Player.removeVirtualEquip(self, cid)
|
|
|
|
|
self.room:doBroadcastNotify("RemoveVirtualEquip", json.encode{
|
|
|
|
|
player = self.id,
|
|
|
|
|
id = cid,
|
|
|
|
|
})
|
|
|
|
|
return ret
|
|
|
|
|
end
|
|
|
|
|
|
2022-12-20 04:51:54 +00:00
|
|
|
|
function ServerPlayer:addCardUseHistory(cardName, num)
|
|
|
|
|
Player.addCardUseHistory(self, cardName, num)
|
|
|
|
|
self:doNotify("AddCardUseHistory", json.encode{cardName, num})
|
|
|
|
|
end
|
|
|
|
|
|
2023-01-29 10:11:41 +00:00
|
|
|
|
function ServerPlayer:setCardUseHistory(cardName, num, scope)
|
|
|
|
|
Player.setCardUseHistory(self, cardName, num, scope)
|
|
|
|
|
self:doNotify("SetCardUseHistory", json.encode{cardName, num, scope})
|
|
|
|
|
end
|
|
|
|
|
|
|
|
|
|
function ServerPlayer:addSkillUseHistory(cardName, num)
|
|
|
|
|
Player.addSkillUseHistory(self, cardName, num)
|
2023-04-04 17:05:06 +00:00
|
|
|
|
self.room:doBroadcastNotify("AddSkillUseHistory", json.encode{self.id, cardName, num})
|
2023-01-29 10:11:41 +00:00
|
|
|
|
end
|
|
|
|
|
|
|
|
|
|
function ServerPlayer:setSkillUseHistory(cardName, num, scope)
|
|
|
|
|
Player.setSkillUseHistory(self, cardName, num, scope)
|
2023-04-04 17:05:06 +00:00
|
|
|
|
self.room:doBroadcastNotify("SetSkillUseHistory", json.encode{self.id, cardName, num, scope})
|
2022-12-20 04:51:54 +00:00
|
|
|
|
end
|
|
|
|
|
|
2023-03-09 04:19:16 +00:00
|
|
|
|
---@param chained boolean
|
|
|
|
|
function ServerPlayer:setChainState(chained)
|
2023-08-03 07:26:52 +00:00
|
|
|
|
local room = self.room
|
|
|
|
|
if room.logic:trigger(fk.BeforeChainStateChange, self) then
|
2023-05-28 10:45:54 +00:00
|
|
|
|
return
|
|
|
|
|
end
|
|
|
|
|
|
2023-03-09 04:19:16 +00:00
|
|
|
|
self.chained = chained
|
2023-08-03 07:26:52 +00:00
|
|
|
|
|
|
|
|
|
room:broadcastProperty(self, "chained")
|
|
|
|
|
room:sendLog{
|
2023-03-09 04:19:16 +00:00
|
|
|
|
type = "#ChainStateChange",
|
|
|
|
|
from = self.id,
|
2023-07-11 15:16:46 +00:00
|
|
|
|
arg = self.chained and "chained" or "un-chained"
|
2023-03-09 04:19:16 +00:00
|
|
|
|
}
|
2023-08-03 07:26:52 +00:00
|
|
|
|
room:delay(150)
|
|
|
|
|
room:broadcastPlaySound("./audio/system/chain")
|
|
|
|
|
room.logic:trigger(fk.ChainStateChanged, self)
|
2023-03-09 04:19:16 +00:00
|
|
|
|
end
|
|
|
|
|
|
2023-07-11 15:16:46 +00:00
|
|
|
|
function ServerPlayer:reset()
|
2023-09-27 13:02:22 +00:00
|
|
|
|
if self.faceup and not self.chained then return end
|
2023-07-11 15:16:46 +00:00
|
|
|
|
self.room:sendLog{
|
2023-08-01 18:19:51 +00:00
|
|
|
|
type = "#ChainStateChange",
|
2023-07-11 15:16:46 +00:00
|
|
|
|
from = self.id,
|
2023-08-01 18:19:51 +00:00
|
|
|
|
arg = "reset-general"
|
2023-07-11 15:16:46 +00:00
|
|
|
|
}
|
2023-09-06 14:16:09 +00:00
|
|
|
|
if self.chained then self:setChainState(false) end
|
2023-07-11 15:16:46 +00:00
|
|
|
|
if not self.faceup then self:turnOver() end
|
|
|
|
|
end
|
|
|
|
|
|
2023-09-06 14:16:09 +00:00
|
|
|
|
--- 进行拼点。
|
2023-03-14 12:48:08 +00:00
|
|
|
|
---@param tos ServerPlayer[]
|
|
|
|
|
---@param skillName string
|
2023-12-03 11:35:14 +00:00
|
|
|
|
---@param initialCard? Card
|
2023-03-14 12:48:08 +00:00
|
|
|
|
---@return PindianStruct
|
|
|
|
|
function ServerPlayer:pindian(tos, skillName, initialCard)
|
2023-04-30 10:55:59 +00:00
|
|
|
|
local pindianData = { from = self, tos = tos, reason = skillName, fromCard = initialCard, results = {} }
|
2023-03-14 12:48:08 +00:00
|
|
|
|
self.room:pindian(pindianData)
|
|
|
|
|
return pindianData
|
|
|
|
|
end
|
|
|
|
|
|
2023-08-24 13:37:24 +00:00
|
|
|
|
--- 播放技能的语音。
|
|
|
|
|
---@param skill_name string @ 技能名
|
2023-12-03 11:35:14 +00:00
|
|
|
|
---@param index? integer @ 语音编号,默认为-1(也就是随机播放)
|
2023-08-24 13:37:24 +00:00
|
|
|
|
function ServerPlayer:broadcastSkillInvoke(skill_name, index)
|
|
|
|
|
index = index or -1
|
|
|
|
|
self.room:sendLogEvent("PlaySkillSound", {
|
|
|
|
|
name = skill_name,
|
|
|
|
|
i = index,
|
|
|
|
|
general = self.general,
|
|
|
|
|
deputy = self.deputyGeneral,
|
|
|
|
|
})
|
|
|
|
|
end
|
|
|
|
|
|
2023-04-23 13:10:07 +00:00
|
|
|
|
-- Hegemony func
|
|
|
|
|
|
2023-08-09 14:25:15 +00:00
|
|
|
|
---@param skill Skill
|
|
|
|
|
function ServerPlayer:addFakeSkill(skill)
|
2023-08-24 13:37:06 +00:00
|
|
|
|
assert(type(skill) == "string" or skill:isInstanceOf(Skill))
|
|
|
|
|
if type(skill) == "string" then
|
|
|
|
|
skill = Fk.skills[skill]
|
|
|
|
|
end
|
2023-08-09 14:25:15 +00:00
|
|
|
|
if table.contains(self._fake_skills, skill) then return end
|
|
|
|
|
|
2023-09-06 14:16:09 +00:00
|
|
|
|
table.insertIfNeed(self._manually_fake_skills, skill)
|
|
|
|
|
|
2023-08-09 14:25:15 +00:00
|
|
|
|
table.insert(self._fake_skills, skill)
|
|
|
|
|
for _, s in ipairs(skill.related_skills) do
|
|
|
|
|
-- if s.main_skill == skill then -- TODO: need more detailed
|
|
|
|
|
table.insert(self._fake_skills, s)
|
|
|
|
|
-- end
|
|
|
|
|
end
|
|
|
|
|
|
|
|
|
|
-- TODO
|
|
|
|
|
self:doNotify("AddSkill", json.encode{ self.id, skill.name, true })
|
|
|
|
|
end
|
|
|
|
|
|
|
|
|
|
---@param skill Skill
|
|
|
|
|
function ServerPlayer:loseFakeSkill(skill)
|
2023-08-24 13:37:06 +00:00
|
|
|
|
assert(type(skill) == "string" or skill:isInstanceOf(Skill))
|
|
|
|
|
if type(skill) == "string" then
|
|
|
|
|
skill = Fk.skills[skill]
|
|
|
|
|
end
|
2023-08-09 14:25:15 +00:00
|
|
|
|
if not table.contains(self._fake_skills, skill) then return end
|
|
|
|
|
|
2023-09-06 14:16:09 +00:00
|
|
|
|
table.removeOne(self._manually_fake_skills, skill)
|
|
|
|
|
|
2023-08-09 14:25:15 +00:00
|
|
|
|
table.removeOne(self._fake_skills, skill)
|
|
|
|
|
for _, s in ipairs(skill.related_skills) do
|
|
|
|
|
table.removeOne(self._fake_skills, s)
|
|
|
|
|
end
|
|
|
|
|
|
|
|
|
|
-- TODO
|
|
|
|
|
self:doNotify("LoseSkill", json.encode{ self.id, skill.name, true })
|
|
|
|
|
end
|
|
|
|
|
|
|
|
|
|
function ServerPlayer:isFakeSkill(skill)
|
|
|
|
|
if type(skill) == "string" then skill = Fk.skills[skill] end
|
|
|
|
|
assert(skill:isInstanceOf(Skill))
|
|
|
|
|
return table.contains(self._fake_skills, skill)
|
|
|
|
|
end
|
|
|
|
|
|
|
|
|
|
---@param skill string | Skill
|
2023-12-03 11:35:14 +00:00
|
|
|
|
---@param isPrelight? boolean
|
2023-04-23 13:10:07 +00:00
|
|
|
|
function ServerPlayer:prelightSkill(skill, isPrelight)
|
2023-08-09 14:25:15 +00:00
|
|
|
|
if type(skill) == "string" then skill = Fk.skills[skill] end
|
|
|
|
|
assert(skill:isInstanceOf(Skill))
|
|
|
|
|
|
|
|
|
|
if not self._prelighted_skills[skill] and not self:hasSkill(skill) then
|
|
|
|
|
self._prelighted_skills[skill] = true
|
|
|
|
|
-- to attach skill to room
|
2023-04-23 13:10:07 +00:00
|
|
|
|
self:addSkill(skill)
|
|
|
|
|
self:loseSkill(skill)
|
|
|
|
|
end
|
2023-08-09 14:25:15 +00:00
|
|
|
|
|
|
|
|
|
if isPrelight then
|
|
|
|
|
-- self:addSkill(skill)
|
|
|
|
|
table.insert(self.prelighted_skills, skill)
|
|
|
|
|
for _, s in ipairs(skill.related_skills) do
|
|
|
|
|
table.insert(self.prelighted_skills, s)
|
|
|
|
|
end
|
|
|
|
|
else
|
|
|
|
|
-- self:loseSkill(skill)
|
|
|
|
|
table.removeOne(self.prelighted_skills, skill)
|
|
|
|
|
for _, s in ipairs(skill.related_skills) do
|
|
|
|
|
table.removeOne(self.prelighted_skills, s)
|
|
|
|
|
end
|
|
|
|
|
end
|
|
|
|
|
|
|
|
|
|
self:doNotify("PrelightSkill", json.encode{ skill.name, isPrelight })
|
2023-04-23 13:10:07 +00:00
|
|
|
|
end
|
|
|
|
|
|
2023-12-03 11:35:14 +00:00
|
|
|
|
---@param isDeputy? boolean
|
|
|
|
|
---@param no_trigger? boolean
|
2023-08-24 13:37:06 +00:00
|
|
|
|
function ServerPlayer:revealGeneral(isDeputy, no_trigger)
|
2023-04-23 13:10:07 +00:00
|
|
|
|
local room = self.room
|
|
|
|
|
local generalName
|
|
|
|
|
if isDeputy then
|
|
|
|
|
if self.deputyGeneral ~= "anjiang" then return end
|
|
|
|
|
generalName = self:getMark("__heg_deputy")
|
|
|
|
|
else
|
|
|
|
|
if self.general ~= "anjiang" then return end
|
|
|
|
|
generalName = self:getMark("__heg_general")
|
|
|
|
|
end
|
|
|
|
|
|
2023-08-25 09:14:43 +00:00
|
|
|
|
local general = Fk.generals[generalName] or Fk.generals["blank_shibing"]
|
2023-04-23 13:10:07 +00:00
|
|
|
|
for _, s in ipairs(general:getSkillNameList()) do
|
|
|
|
|
local skill = Fk.skills[s]
|
2023-08-09 14:25:15 +00:00
|
|
|
|
self:loseFakeSkill(skill)
|
2023-04-23 13:10:07 +00:00
|
|
|
|
end
|
|
|
|
|
|
2023-08-24 13:37:06 +00:00
|
|
|
|
local ret = true
|
|
|
|
|
if not ((isDeputy and self.general ~= "anjiang") or (not isDeputy and self.deputyGeneral ~= "anjiang")) then
|
2023-08-25 09:14:43 +00:00
|
|
|
|
local other = Fk.generals[self:getMark(isDeputy and "__heg_general" or "__heg_deputy")] or Fk.generals["blank_shibing"]
|
2023-08-24 13:37:06 +00:00
|
|
|
|
for _, sname in ipairs(other:getSkillNameList()) do
|
|
|
|
|
local s = Fk.skills[sname]
|
|
|
|
|
if s.frequency == Skill.Compulsory and s.relate_to_place ~= (isDeputy and "m" or "d") then
|
|
|
|
|
ret = false
|
|
|
|
|
break
|
|
|
|
|
end
|
|
|
|
|
end
|
|
|
|
|
end
|
|
|
|
|
if ret then
|
|
|
|
|
self:loseFakeSkill("reveal_skill")
|
|
|
|
|
end
|
|
|
|
|
|
2023-04-23 13:10:07 +00:00
|
|
|
|
local oldKingdom = self.kingdom
|
2023-09-30 03:51:17 +00:00
|
|
|
|
room:changeHero(self, generalName, false, isDeputy, false, false, false)
|
2023-08-25 09:14:43 +00:00
|
|
|
|
if oldKingdom ~= "wild" then
|
2023-09-30 03:51:17 +00:00
|
|
|
|
local kingdom = (self:getMark("__heg_wild") == 1 and not isDeputy) and "wild" or self:getMark("__heg_kingdom")
|
2023-08-25 09:14:43 +00:00
|
|
|
|
self.kingdom = kingdom
|
2023-09-30 03:51:17 +00:00
|
|
|
|
if oldKingdom == "unknown" and kingdom ~= "wild" and #table.filter(room:getOtherPlayers(self, false, true),
|
2023-08-25 09:14:43 +00:00
|
|
|
|
function(p)
|
|
|
|
|
return p.kingdom == kingdom
|
2023-09-30 03:51:17 +00:00
|
|
|
|
end) >= #room.players // 2 and table.every(room.alive_players, function(p) return p.kingdom ~= kingdom or not string.find(p.general, "lord") end) then
|
2023-08-25 09:14:43 +00:00
|
|
|
|
self.kingdom = "wild"
|
|
|
|
|
end
|
|
|
|
|
room:broadcastProperty(self, "kingdom")
|
|
|
|
|
else
|
|
|
|
|
room:setPlayerProperty(self, "kingdom", "wild")
|
|
|
|
|
end
|
2023-04-23 13:10:07 +00:00
|
|
|
|
|
2023-09-30 03:51:17 +00:00
|
|
|
|
if self.gender == General.Agender or self.gender ~= Fk.generals[self.general].gender then
|
|
|
|
|
room:setPlayerProperty(self, "gender", general.gender)
|
2023-04-23 13:10:07 +00:00
|
|
|
|
end
|
|
|
|
|
|
|
|
|
|
room:sendLog{
|
|
|
|
|
type = "#RevealGeneral",
|
|
|
|
|
from = self.id,
|
|
|
|
|
arg = isDeputy and "deputyGeneral" or "mainGeneral",
|
|
|
|
|
arg2 = generalName,
|
|
|
|
|
}
|
|
|
|
|
|
2023-08-24 13:37:06 +00:00
|
|
|
|
if not no_trigger then
|
2023-11-07 13:14:51 +00:00
|
|
|
|
local current_event = room.logic:getCurrentEvent()
|
|
|
|
|
if table.contains({GameEvent.Round, GameEvent.Turn, GameEvent.Phase}, current_event.event) then
|
|
|
|
|
room.logic:trigger(fk.GeneralRevealed, self, {[isDeputy and "d" or "m"] = generalName})
|
|
|
|
|
else
|
|
|
|
|
current_event:addExitFunc(function ()
|
|
|
|
|
room.logic:trigger(fk.GeneralRevealed, self, {[isDeputy and "d" or "m"] = generalName})
|
|
|
|
|
end)
|
|
|
|
|
end
|
|
|
|
|
end
|
|
|
|
|
end
|
|
|
|
|
|
|
|
|
|
function ServerPlayer:revealGenerals()
|
|
|
|
|
self:revealGeneral(false, true)
|
|
|
|
|
self:revealGeneral(true, true)
|
|
|
|
|
local room = self.room
|
|
|
|
|
local current_event = room.logic:getCurrentEvent()
|
|
|
|
|
if table.contains({GameEvent.Round, GameEvent.Turn, GameEvent.Phase}, current_event.event) then
|
|
|
|
|
room.logic:trigger(fk.GeneralRevealed, self, {["m"] = self:getMark("__heg_general"), ["d"] = self:getMark("__heg_deputy")})
|
|
|
|
|
else
|
|
|
|
|
current_event:addExitFunc(function ()
|
|
|
|
|
room.logic:trigger(fk.GeneralRevealed, self, {["m"] = self:getMark("__heg_general"), ["d"] = self:getMark("__heg_deputy")})
|
|
|
|
|
end)
|
2023-08-24 13:37:06 +00:00
|
|
|
|
end
|
2023-04-23 13:10:07 +00:00
|
|
|
|
end
|
|
|
|
|
|
|
|
|
|
function ServerPlayer:revealBySkillName(skill_name)
|
|
|
|
|
local main = self.general == "anjiang"
|
|
|
|
|
local deputy = self.deputyGeneral == "anjiang"
|
|
|
|
|
|
|
|
|
|
if main then
|
|
|
|
|
if table.contains(Fk.generals[self:getMark("__heg_general")]
|
|
|
|
|
:getSkillNameList(), skill_name) then
|
|
|
|
|
self:revealGeneral(false)
|
|
|
|
|
return
|
|
|
|
|
end
|
|
|
|
|
end
|
|
|
|
|
|
|
|
|
|
if deputy then
|
|
|
|
|
if table.contains(Fk.generals[self:getMark("__heg_deputy")]
|
|
|
|
|
:getSkillNameList(), skill_name) then
|
|
|
|
|
self:revealGeneral(true)
|
|
|
|
|
return
|
|
|
|
|
end
|
|
|
|
|
end
|
|
|
|
|
end
|
|
|
|
|
|
2023-08-24 13:37:06 +00:00
|
|
|
|
function ServerPlayer:hideGeneral(isDeputy)
|
|
|
|
|
local room = self.room
|
|
|
|
|
local generalName = isDeputy and self.deputyGeneral or self.general
|
|
|
|
|
local mark = isDeputy and "__heg_deputy" or "__heg_general"
|
|
|
|
|
|
|
|
|
|
self:setMark(mark, generalName)
|
|
|
|
|
self:doNotify("SetPlayerMark", json.encode{ self.id, mark, generalName})
|
|
|
|
|
|
|
|
|
|
if isDeputy then
|
|
|
|
|
room:setDeputyGeneral(self, "anjiang")
|
|
|
|
|
room:broadcastProperty(self, "deputyGeneral")
|
|
|
|
|
else
|
|
|
|
|
room:setPlayerGeneral(self, "anjiang", false)
|
|
|
|
|
room:broadcastProperty(self, "general")
|
|
|
|
|
end
|
|
|
|
|
|
|
|
|
|
local general = Fk.generals[generalName]
|
|
|
|
|
local skills = general.skills
|
|
|
|
|
local place = isDeputy and "m" or "d"
|
|
|
|
|
for _, s in ipairs(skills) do
|
|
|
|
|
room:handleAddLoseSkills(self, "-" .. s.name, nil, false, true)
|
|
|
|
|
if s.relate_to_place ~= place then
|
|
|
|
|
if s.frequency == Skill.Compulsory then
|
|
|
|
|
self:addFakeSkill("reveal_skill")
|
|
|
|
|
end
|
|
|
|
|
self:addFakeSkill(s)
|
|
|
|
|
end
|
|
|
|
|
end
|
|
|
|
|
for _, sname in ipairs(general.other_skills) do
|
|
|
|
|
room:handleAddLoseSkills(self, "-" .. sname, nil, false, true)
|
|
|
|
|
local s = Fk.skills[sname]
|
|
|
|
|
if s.relate_to_place ~= place then
|
|
|
|
|
if s.frequency == Skill.Compulsory then
|
|
|
|
|
self:addFakeSkill("reveal_skill")
|
|
|
|
|
end
|
|
|
|
|
self:addFakeSkill(s)
|
|
|
|
|
end
|
|
|
|
|
end
|
|
|
|
|
|
2023-09-30 03:51:17 +00:00
|
|
|
|
self.gender = General.Agender
|
|
|
|
|
if Fk.generals[self.general].gender ~= General.Agender then
|
|
|
|
|
self.gender = Fk.generals[self.general].gender
|
|
|
|
|
elseif self.deputyGeneral and Fk.generals[self.deputyGeneral].gender ~= General.Agender then
|
|
|
|
|
self.gender = Fk.generals[self.deputyGeneral].gender
|
|
|
|
|
end
|
|
|
|
|
room:broadcastProperty(self, "gender")
|
|
|
|
|
|
|
|
|
|
room.logic:trigger(fk.GeneralHidden, self, generalName)
|
2023-08-24 13:37:06 +00:00
|
|
|
|
end
|
2023-09-30 03:51:17 +00:00
|
|
|
|
|
2023-04-27 06:15:08 +00:00
|
|
|
|
-- 神貂蝉
|
|
|
|
|
|
2023-07-14 15:12:46 +00:00
|
|
|
|
---@param p ServerPlayer
|
2023-04-27 06:15:08 +00:00
|
|
|
|
function ServerPlayer:control(p)
|
|
|
|
|
if self == p then
|
|
|
|
|
self.room:setPlayerMark(p, "@ControledBy", 0)
|
|
|
|
|
else
|
|
|
|
|
self.room:setPlayerMark(p, "@ControledBy", "seat#" .. self.seat)
|
|
|
|
|
end
|
|
|
|
|
p.serverplayer = self._splayer
|
|
|
|
|
end
|
|
|
|
|
|
2023-08-11 16:50:17 +00:00
|
|
|
|
-- 22
|
|
|
|
|
|
|
|
|
|
function ServerPlayer:addBuddy(other)
|
|
|
|
|
if type(other) == "number" then
|
|
|
|
|
other = self.room:getPlayerById(other)
|
|
|
|
|
end
|
|
|
|
|
Player.addBuddy(self, other)
|
|
|
|
|
self:doNotify("AddBuddy", json.encode{ other.id, other.player_cards[Player.Hand] })
|
|
|
|
|
end
|
|
|
|
|
|
|
|
|
|
function ServerPlayer:removeBuddy(other)
|
|
|
|
|
if type(other) == "number" then
|
|
|
|
|
other = self.room:getPlayerById(other)
|
|
|
|
|
end
|
|
|
|
|
Player.removeBuddy(self, other)
|
|
|
|
|
self:doNotify("RmBuddy", tostring(other.id))
|
|
|
|
|
end
|
|
|
|
|
|
2022-03-27 06:49:41 +00:00
|
|
|
|
return ServerPlayer
|