Defold ECS 与代码架构

player (Game Object)
  ├── sprite          → 显示角色贴图
  ├── collisionobject → 参与物理碰撞
  ├── script          → 处理输入与状态
  └── sound           → 播放音效

function init(self)
    -- 组件创建时调用一次，适合初始化状态
    self.hp = 100
end

function update(self, dt)
    -- 每帧调用，dt 是距上一帧的秒数
    self.hp = self.hp - dt * 0.1
end

function on_message(self, message_id, message, sender)
    -- 收到消息时调用
    if message_id == hash("damage") then
        self.hp = self.hp - message.amount
    end
end

function final(self)
    -- 对象销毁时调用，适合清理
end

-- 同 Collection 内可以直接用 # 简写
msg.post("#sprite", "play_animation", { id = hash("run") })

-- 跨 Collection 必须写全路径
msg.post("/enemies/enemy_1#script", "damage", { amount = 10 })

-- 每个实体脚本在 init 时向世界注册自己
function init(self)
    self.eid = go.get_id()
    world.register(self.eid)
end

-- components/health.lua
local M = {}

function M.new(hp, max_hp)
    return {
        hp = hp,
        max_hp = max_hp or hp,
        invuln = 0,
    }
end

function M.damage(comp, amount)
    if comp.invuln > 0 then return false end
    comp.hp = comp.hp - amount
    return comp.hp <= 0
end

return M

-- world.lua
local M = {
    entities = {},   -- eid -> { components }
    systems  = {},   -- 有序系统列表
}

function M.register(eid)
    M.entities[eid] = M.entities[eid] or {}
end

function M.unregister(eid)
    M.entities[eid] = nil
end

function M.add(eid, name, comp)
    local e = M.entities[eid]
    if not e then return end
    e[name] = comp
end

function M.get(eid, name)
    local e = M.entities[eid]
    return e and e[name]
end

return M

-- 不推荐：组件里带了引擎调用
local comp = {
    hp = 100,
    on_death = function(self)
        go.delete()          -- 组件依赖引擎，无法单元测试
    end,
}

-- 查询同时拥有 health 和 transform 的实体
local function query_entities(world, names)
    local result = {}
    for eid, comps in pairs(world.entities) do
        local ok = true
        for _, n in ipairs(names) do
            if not comps[n] then ok = false break end
        end
        if ok then table.insert(result, eid) end
    end
    return result
end

go.property("max_hp", 100)
go.property("move_speed", 200.0)

function init(self)
    world.add(self.eid, "health", health.new(self.max_hp))
    world.add(self.eid, "move", move.new(self.move_speed))
end

-- systems/movement.lua
local world = require("world")

local M = {}

function M.update(dt)
    for eid, comps in pairs(world.entities) do
        local m = comps.move
        if m then
            local p = go.get_position(eid)
            go.set_position(p + m.dir * m.speed * dt, eid)
        end
    end
end

return M

-- main.script 中统一调度
local movement = require("systems.movement")
local combat   = require("systems.combat")
local death    = require("systems.death")

function update(self, dt)
    movement.update(dt)   -- 1. 位置先更新
    combat.update(dt)     -- 2. 再判定战斗
    death.update(dt)      -- 3. 最后处理死亡
end

-- 标记删除，延后处理
function M.update(dt)
    for eid, comps in pairs(world.entities) do
        if comps.health and comps.health.hp <= 0 then
            comps.dead = true
        end
    end
end

function M.cleanup()
    for eid, comps in pairs(world.entities) do
        if comps.dead then
            go.delete(eid)
            world.unregister(eid)
        end
    end
end

function update(self, dt)
    self.acc = (self.acc or 0) + dt
    if self.acc >= 0.2 then          -- 每 0.2 秒跑一次
        self.acc = 0
        ai.update(0.2)
    end
    movement.update(dt)              -- 移动仍然每帧跑
end

/main
  main.collection
/scripts
  main.script              ← 只负责调度
/core
  world.lua                ← 实体注册表
  event_bus.lua            ← 事件总线
/components
  health.lua
  move.lua
  inventory.lua
/systems
  movement.lua
  combat.lua
  spawn.lua
/data
  config.lua               ← 数值配置

main.script  →  systems  →  components  →  core

-- 直接调用：耦合强，A 必须知道 B 的存在
local audio = require("systems.audio")
audio.play("hit")

-- 消息：解耦，发送方不知道谁在听
msg.post("/audio#script", "play_sound", { id = hash("hit") })

-- core/event_bus.lua
local M = { listeners = {} }

function M.on(event, fn)
    M.listeners[event] = M.listeners[event] or {}
    table.insert(M.listeners[event], fn)
end

function M.off(event, fn)
    local list = M.listeners[event]
    if not list then return end
    for i = #list, 1, -1 do
        if list[i] == fn then table.remove(list, i) end
    end
end

function M.emit(event, payload)
    local list = M.listeners[event]
    if not list then return end
    -- 复制一份，避免回调中修改列表导致遍历错乱
    for _, fn in ipairs({ table.unpack(list) }) do
        fn(payload)
    end
end

return M

-- 组件收到引擎消息后，转发到事件总线
function on_message(self, message_id, message, sender)
    if message_id == hash("collision_response") then
        event_bus.emit("collision", { other = message.other_id, self = go.get_id() })
    end
end

1. 先把散落的全局变量收进一个 state 模块
2. 再把纯逻辑抽成 .lua 模块（可单元测试）
3. 然后引入 world 注册表统一管理实体
4. 最后按 System 拆分 update 逻辑

-- 纯函数：可单元测试
function M.apply_damage(health, amount, now)
    if health.invuln > now then return false end
    health.hp = health.hp - amount
    return true
end

-- 胶水层：调用纯函数并把结果同步到引擎
function on_message(self, message_id, message, sender)
    if message_id == hash("damage") then
        if M.apply_damage(self.health, message.amount, socket.gettime()) then
            update_health_bar(self)
        end
    end
end

-- ======================================
-- 完整示例：极简 ECS 世界（world.lua）
-- 放在 /core/world.lua，由 main.script 调度
-- ======================================

local M = {
    entities = {},
    systems  = {},
}

function M.register(eid)
    M.entities[eid] = M.entities[eid] or {}
    return M.entities[eid]
end

function M.unregister(eid)
    M.entities[eid] = nil
end

function M.add(eid, name, comp)
    local e = M.entities[eid]
    if not e then
        e = M.register(eid)
    end
    e[name] = comp
    return comp
end

function M.get(eid, name)
    local e = M.entities[eid]
    return e and e[name]
end

function M.add_system(name, sys)
    table.insert(M.systems, { name = name, fn = sys })
end

function M.update(dt)
    for _, s in ipairs(M.systems) do
        local ok, err = pcall(s.fn, dt)
        if not ok then
            print(string.format("[ECS] system %s error: %s", s.name, tostring(err)))
        end
    end
end

return M

-- ======================================
-- 完整示例：main.script 调度入口
-- ======================================

local world = require("core.world")

go.property("enemy_count", 20)

local function movement_system(dt)
    for _, eid in ipairs(world.query({ "move", "health" })) do
        local m = world.get(eid, "move")
        local p = go.get_position(eid)
        go.set_position(p + m.dir * m.speed * dt, eid)
    end
end

local function cleanup_system()
    for _, eid in ipairs(world.query({ "dead" })) do
        go.delete(eid)
        world.unregister(eid)
    end
end

function init(self)
    world.add_system("movement", movement_system)
    world.add_system("cleanup", cleanup_system)
    print("[init] ECS 世界已启动，预置敌人数量:", self.enemy_count)
end

function update(self, dt)
    world.update(dt)
end