从“上帝类”到“事件驱动”：Lua回合制卡牌对战游戏架构重构实战

一、痛点：当“主流程”变成“万能处理器”

• 代码量爆炸：单文件超过 2000 行，每次新增卡牌都要修改核心文件。
• 变更风险高：修改一个技能可能意外影响其他逻辑。
• 测试困难：技能与流程深度耦合，无法单独验证。
• 协作冲突：多人开发时频繁合并冲突。

lua
-- 处理士气为0
GameLogic.ProcessMoraleZero(game, playerIdx)
-- 张良光环
for _, card in ipairs(player.field) do
    if card.template.abilityFn == "zhangliang_aura" then
        player.provisions = player.provisions + 1
        break
    end
end
-- 鲁肃光环
for _, card in ipairs(player.field) do
    if card.template.abilityFn == "lusu_aura" then
        GameLogic.DrawCard(game, playerIdx)
        break
    end
end
-- 墓碑递减...
-- 摸牌...

二、药方：观察者模式 + 事件系统

1. 事件系统的实现（Lua）

lua
-- EventSystem.lua
local EventSystem = {}
EventSystem.__index = EventSystem

function EventSystem:new()
    local instance = setmetatable({}, EventSystem)
    instance._listeners = {}  -- event -> {func, priority, target, id}
    instance._id_counter = 0
    return instance
end

function EventSystem:on(event, func, params)
    params = params or {}
    local priority = params.priority or 0
    local target = params.target
    self._id_counter = self._id_counter + 1
    local listener = { func = func, target = target, priority = priority, id = self._id_counter }
    self._listeners[event] = self._listeners[event] or {}
    table.insert(self._listeners[event], listener)
    table.sort(self._listeners[event], function(a, b)
        if a.priority == b.priority then return a.id < b.id end
        return a.priority > b.priority
    end)
end

function EventSystem:emit(event, data)
    local listeners = self._listeners[event]
    if not listeners then return end
    -- 快照防止回调中修改列表
    for _, cb in ipairs(listeners) do
        local ok, err = pcall(cb.func, cb.target, data)
        if not ok then
            print(string.format("[Event Error] %s: %s", event, err))
            if data and data.game and data.game.AddLog then
                data.game:AddLog("⚠️ 技能执行异常: " .. tostring(err))
            end
        end
    end
end

return EventSystem

2. 定义事件节点

三、重构实战：从硬编码到模块化

1. 主流程精简

lua
function GameLogic.StartTurn(game, playerIdx)
    -- 基础状态重置
    game.currentPlayer = playerIdx
    game.turnNumber = game.turnNumber + 1
    -- 重置攻击状态、粮草等...

    -- 派发回合开始事件（所有光环、效果在此处理）
    local eventData = { game = game, playerIdx = playerIdx, turnNumber = game.turnNumber }
    globalEventSystem:emit("ROUND_START", eventData)

    -- 统一摸牌（也可以作为事件的一部分）
    GameLogic.DrawCard(game, playerIdx)

    -- 生成专属技（可事件化）
    GameLogic.GenerateExclusiveSkills(game, playerIdx)

    -- 胜负判定...
    if GameLogic.CheckDefeat(game, playerIdx) then return end
    if game.onStateChange then game.onStateChange() end
end

2. 卡牌效果独立为监听器

lua
-- abilities/auras/zhangliang.lua
local GameLogic = require("GameLogic")

local M = {}

function M.onRoundStart(data)
    local game = data.game
    local player = game.players[data.playerIdx]
    for _, card in ipairs(player.field) do
        if card.template.abilityFn == "zhangliang_aura" then
            player.provisions = math.min(player.provisions + 1, GameLogic.MAX_PROVISIONS)
            GameLogic.AddLog(game, "🧠 张良光环：粮草+1")
            break
        end
    end
end

-- 注册监听，优先级80（高于默认）
globalEventSystem:on("ROUND_START", M.onRoundStart, { priority = 80 })

return M

3. 攻击流程的细化控制

lua
function GameLogic.Attack(game, playerIdx, attIdx, tgtIdx)
    local attacker = player.field[attIdx]
    local target = getTarget(...)
    local data = { game = game, attacker = attacker, target = target, damage = 0, cancelled = false }

    -- 1. 攻击前（可取消）
    globalEventSystem:emit("BEFORE_ATTACK", data)
    if data.cancelled then return false, "攻击被取消" end

    -- 2. 计算基础伤害
    data.damage = GameLogic.CalcBaseDamage(attacker, target)

    -- 3. 伤害修正（增伤/减伤/免疫）
    globalEventSystem:emit("CALCULATE_DAMAGE", data)

    -- 4. 执行伤害
    applyDamage(target, data.damage)

    -- 5. 攻击后（触发各种被动）
    globalEventSystem:emit("AFTER_ATTACK", data)

    -- 6. 死亡检查及亡语
    if target.troops <= 0 then
        globalEventSystem:emit("BEFORE_DEATH", { game = game, card = target })
        removeFromField(target)
        globalEventSystem:emit("DEATHRATTLE", { game = game, card = target })
    end
end

• 彭越（免反击） 监听 CALCULATE_DAMAGE，将反击伤害设为0。
• 陈汤（虽远必诛） 监听 AFTER_ATTACK，在攻击后额外反击。
• 霍去病（封狼居胥） 监听 BEFORE_DEATH，生成墓碑。
• 樊哙（排闼直入） 监听 AFTER_ATTACK，为我方其他卡牌加士气。

4. 执行顺序如何保证？

• 优先级数字：定义全局常量，如 PRIORITY_AURA = 100、PRIORITY_BUFF = 80、PRIORITY_DEBUFF = 60。
• 相同优先级：按注册顺序执行（通过 id 排序）。
• 阶段拆分：将强依赖的逻辑放入不同事件（如 BEFORE_ATTACK 先于 AFTER_ATTACK），从机制上保证顺序。

5. 日志的可视化

lua
GameLogic.AddLog(game, "=== 开始回合结算 ===")
globalEventSystem:emit("ROUND_START", data)
GameLogic.AddLog(game, "=== 回合结算完毕 ===")

四、收益与注意事项

收获

• 主流程代码量减少 60%，只保留规则骨架。
• 新增卡牌零侵入：只需在 abilities/ 目录下新增文件并注册监听，无需修改核心文件。
• 测试友好：可单独模拟事件，独立测试技能逻辑。
• 协作便利：不同技能由不同开发者维护，冲突大大减少。

注意事项

• 避免循环事件：回调中不要再 emit 同一事件，可用计数器防护。
• 数据传递一致：所有事件数据必须包含 game 引用，以便操作共享状态。
• 错误隔离：用 pcall 包裹回调，防止单个技能崩溃阻塞全部。
• 不要过度拆分：事件粒度以“流程阶段”为准，不要为每个细微动作都定义事件。

五、总结