Lua 设计模式落地：用 table 与元表实现经典模式

-- Lua 里最常见的「模式载体」：一个返回 table 的工厂函数
local function make_counter()
    local n = 0                     -- upvalue 私有状态
    return {
        inc = function() n = n + 1; return n end,
        get = function() return n end,
    }
end

-- config.lua：require 缓存即单例
local Config = {
    temperature = 0.75,
    max_retries = 3,
}

function Config.set(name, value)
    Config[name] = value
end

return Config

-- 任意多处 require，拿到的都是同一个 table
local a = require("config")
local b = require("config")
print(a == b)      -- true

local Database = {}
Database.__index = Database
local instance

function Database.get()
    if not instance then
        instance = setmetatable({}, Database)
        instance.connected = false
    end
    return instance
end

function Database:connect(url)
    self.url = url
    self.connected = true
end

-- 使用：全局唯一连接
local db = Database.get()
db:connect("postgres://127.0.0.1:5432/app")

-- 注册表工厂
local Registry = {}

function Registry.register(kind, factory)
    Registry[kind] = factory
end

function Registry.create(kind, ...)
    local factory = Registry[kind]
    if not factory then
        error("未知类型: " .. tostring(kind))
    end
    return factory(...)
end

-- 注册几种实体
Registry.register("player", function(id)
    return { kind = "player", id = id, hp = 100 }
end)

Registry.register("npc", function(id, talk)
    return { kind = "npc", id = id, talk = talk or "你好" }
end)

-- 使用：调用方只认 kind，不关心实现细节
local e1 = Registry.create("player", 1001)
local e2 = Registry.create("npc", 2001)

local EventBus = {}
EventBus.__index = EventBus

function EventBus.new()
    return setmetatable({ handlers = {} }, EventBus)
end

function EventBus:on(event, handler)
    local list = self.handlers[event]
    if not list then
        list = {}
        self.handlers[event] = list
    end
    table.insert(list, handler)
end

function EventBus:off(event, handler)
    local list = self.handlers[event]
    if not list then return end
    for i = #list, 1, -1 do
        if list[i] == handler then
            table.remove(list, i)
        end
    end
end

function EventBus:emit(event, ...)
    local list = self.handlers[event]
    if not list then return end
    -- 拷贝一份再遍历，允许处理器在回调里退订
    local snapshot = {}
    for i = 1, #list do snapshot[i] = list[i] end
    for _, handler in ipairs(snapshot) do
        handler(...)
    end
end

-- 使用
local bus = EventBus.new()
local function on_player_dead(uid, killer)
    print(string.format("%d 被 %d 击杀", uid, killer))
end
bus:on("player_dead", on_player_dead)
bus:emit("player_dead", 1001, 2002)

local FSM = {}
FSM.__index = FSM

function FSM.new(init_state)
    return setmetatable({ state = init_state, handlers = {} }, FSM)
end

function FSM:on(state, handlers)
    -- handlers: { enter = fn, update = fn, leave = fn }
    self.handlers[state] = handlers
end

function FSM:transition(next_state, ...)
    local cur = self.handlers[self.state]
    local nxt = self.handlers[next_state]
    if not nxt then
        error("未知状态: " .. tostring(next_state))
    end
    if cur and cur.leave then cur.leave(self) end
    self.state = next_state
    if nxt and nxt.enter then nxt.enter(self, ...) end
end

function FSM:update(dt)
    local h = self.handlers[self.state]
    if h and h.update then
        h.update(self, dt)
    end
end

-- 连接状态机：connecting -> connected -> closed
local conn = FSM.new("connecting")

conn:on("connecting", {
    enter = function(self)
        print("开始连接...")
        self:transition("connected")     -- 模拟连接成功
    end,
})
conn:on("connected", {
    enter = function(self) print("已连接") end,
    update = function(self, dt) print("心跳 dt=" .. dt) end,
})
conn:on("closed", {
    enter = function(self) print("已关闭") end,
})

conn:transition("closed")
conn:update(0.1)

local CommandStack = {}
CommandStack.__index = CommandStack

function CommandStack.new()
    return setmetatable({ undo_stack = {}, redo_stack = {} }, CommandStack)
end

function CommandStack:execute(cmd)
    cmd:run()
    table.insert(self.undo_stack, cmd)
    self.redo_stack = {}
end

function CommandStack:undo()
    local cmd = self.undo_stack[#self.undo_stack]
    if not cmd then return end
    table.remove(self.undo_stack)
    cmd:undo()
    table.insert(self.redo_stack, cmd)
end

function CommandStack:redo()
    local cmd = self.redo_stack[#self.redo_stack]
    if not cmd then return end
    table.remove(self.redo_stack)
    cmd:run()
    table.insert(self.undo_stack, cmd)
end

-- 具体命令：用闭包捕获旧值，实现可撤销
local function make_move_cmd(unit, from, to)
    return {
        run = function()
            unit.x, unit.y = to.x, to.y
        end,
        undo = function()
            unit.x, unit.y = from.x, from.y
        end,
    }
end

local stack = CommandStack.new()
local unit = { x = 0, y = 0 }
stack:execute(make_move_cmd(unit, {x=0,y=0}, {x=3,y=4}))
stack:undo()      -- 回到 (0,0)
stack:redo()      -- 回到 (3,4)