Defold 消息传递架构：message.post 与解耦设计

URL 结构： [socket:]<path>[#fragment]
  socket    集合代理（Proxy）的 socket 名，跨集合时用
  path      游戏对象 id，"." 表示「自己」
  fragment  组件 id，如 "#sprite"、"#script"

-- 发送方：给玩家对象发一个「受伤」消息
msg.post("/player", "apply_damage", { amount = 25, source = "trap" })

-- 接收方（player.script）：在 on_message 里消费
function on_message(self, message_id, message, sender)
    if message_id == hash("apply_damage") then
        self.hp = self.hp - message.amount
        -- sender 是发送方的 URL，可用于回信
        msg.post(sender, "damage_applied", { hp = self.hp })
    end
end

1. message_id 是 hash（整数），比较用 == 而非字符串
2. 消息体（message）是 Lua table，按值传递引用，不要塞大数组
3. sender 参数是 URL，请求-响应模式靠它回信

-- 好：只带事件必需的数据，接收方自行决定怎么用
msg.post("/player", "apply_damage", { amount = 25, source = "trap" })

-- 坏：把整个对象状态塞进去，接收方和发送方再次耦合
msg.post("/ui", "refresh", { player = self.player_obj, world = self.world })

消息体三条纪律：
  ✓ 只放「标量 + 小表」：数字、字符串、hash、短数组
  ✗ 不放 userdata（如 go.get 拿到的 vector 可以，但别放引用）
  ✗ 不放「以后会变」的对象引用——那是共享状态，不是消息

① 同帧内多次 post 同一消息 → 全部按序派发（不是覆盖）
② 给自己 post（"."）→ 下一帧才收到，可用来「延迟一帧」解循环依赖

帧内顺序：
  1. 所有脚本的 update(self, dt) 执行
  2. 收集本帧产生的消息
  3. 按「post 顺序」逐条派发到 on_message

function on_message(self, message_id, message, sender)
    -- 用 if/elseif 链分发；消息多时改用 table 映射
    if message_id == hash("enable") then
        self.active = true
    elseif message_id == hash("disable") then
        self.active = false
    elseif message_id == hash("animation_done") then
        self:on_anim_done(message.animation_id)
    end
end

-- 把 handler 存进 table，避免超长 if 链
local handlers = {}

handlers[hash("enable")]  = function(self, msg) self.active = true end
handlers[hash("disable")] = function(self, msg) self.active = false end
handlers[hash("respawn")] = function(self, msg) self:respawn(msg.pos) end

function on_message(self, message_id, message, sender)
    local h = handlers[message_id]
    if h then h(self, message) end
end

main.collection
├── player.go
├── level.collection        ← 子集合
│   ├── enemy.go
│   └── tilemap.go
└── ui.collection（作为 Proxy 加载）

-- 在 enemy.script 里，向「同集合的 player」发消息
msg.post("/player", "spotted")     -- 先找本集合，找不到再向上冒泡

-- 主集合里的 loader.script 加载 UI 代理
msg.post("#ui_proxy", "load")        -- 异步加载 ui.collection

-- 加载完成后，跨集合给 UI 发消息
msg.post("ui:/hud#gui", "set_hp", { hp = 80 })
--         socket ↑   ↑对象  ↑组件

1. 跨集合通信必须经 Proxy，直接写 "/ui/hud" 是错的
2. load 是异步的：加载完成前 post 会被丢弃，需等 proxy_loaded 消息
3. 卸载用 msg.post("#ui_proxy", "unload")，卸载后地址失效

-- 等代理加载完成再通信
function on_message(self, message_id, message, sender)
    if message_id == hash("proxy_loaded") then
        msg.post(sender, "enable")               -- 启用代理
        msg.post("ui:/hud#gui", "set_hp", { hp = 100 })
    end
end

load → proxy_loaded → enable → [正常通信] → disable → unload → proxy_unloaded
         ↑ 此后地址才可用         ↑ 期间消息可达

常见坑：
  1. 在 init 里直接 post 跨集合消息 → 代理还没加载，消息被静默丢弃
  2. 卸载代理后继续 post → 地址失效，同样是静默丢弃
  3. 同一集合被多个 Proxy 引用 → 每个实例独立，socket 名不能重

-- bus.script：全局事件总线
function init(self)
    self.listeners = {}     -- event_id -> { url1, url2, ... }
end

function on_message(self, message_id, message, sender)
    if message_id == hash("subscribe") then
        local list = self.listeners[message.topic] or {}
        table.insert(list, sender)
        self.listeners[message.topic] = list
    elseif message_id == hash("publish") then
        local list = self.listeners[message.topic]
        if list then
            for _, url in ipairs(list) do
                msg.post(url, message.topic, message.payload)
            end
        end
    end
end

-- 订阅方：只发 subscribe，不知道谁在发
msg.post("/bus", "subscribe", { topic = hash("player_died") })

-- 发布方：只发 publish，不知道谁在收
msg.post("/bus", "publish", { topic = hash("player_died"), payload = { id = 1 } })

-- manager.script：集中路由
function on_message(self, message_id, message, sender)
    if message_id == hash("game_event") then
        if message.type == "level_complete" then
            self:on_level_complete(message.level)
        elseif message.type == "player_died" then
            self:on_player_died()
        end
    end
end

msg.post 的隐含成本：
  1. URL 字符串 → 哈希查找
  2. 消息入队（分配）
  3. 帧末派发时按 URL 定位脚本

用消息：  跨对象、跨集合、事件通知、需要解耦、生命周期不确定
用直调：  同一脚本内部、每帧热路径（如更新 1000 个粒子的位置）
用 go.set：同对象组件属性同步（位置/缩放/染色）

-- 反例：每帧给 500 个子弹对象各 post 一次「更新位置」
-- 正例：子弹自己在 update 里读共享数据，只在「命中」时 post 一次事件
function update(self, dt)
    self.pos = self.pos + self.vel * dt
    go.set_position(self.pos)                -- 直接设置，不走消息
    -- 只有命中这种「离散事件」才 post
end

-- 请求方
self.req_id = (self.req_id or 0) + 1
msg.post("/inventory", "query_item", { id = "potion", req_id = self.req_id })

function on_message(self, message_id, message, sender)
    if message_id == hash("query_result") then
        if message.req_id == self.req_id then     -- 只认最新请求
            self.potion_count = message.count
        end
    end
end

msg.post("/bus", "subscribe_once", { topic = hash("level_loaded") })

function on_message(self, message_id, message, sender)
    if message_id == hash("level_loaded") then
        -- 处理一次后不再关心
        msg.post("/bus", "unsubscribe", { topic = hash("level_loaded") })
        self:start_gameplay()
    end
end

1. 事件里带 source，收到自己的事件直接丢弃
2. 加「正在处理」标志位，处理期间不再发布同类事件
3. 总线侧做去重：同一 tick 内相同 topic+payload 只转发一次

-- 丢弃自产事件，防循环
function on_message(self, message_id, message, sender)
    if sender == msg.url() then return end      -- 自己发的不处理
    -- ...
end

function init(self)
    self.pending = {}     -- req_id -> { deadline = t }
end

function update(self, dt)
    local now = os.time()
    for req_id, p in pairs(self.pending) do
        if now > p.deadline then
            self.pending[req_id] = nil
            self:on_request_timeout(req_id)     -- 走降级分支
        end
    end
end