1
2
3
4
5
6

-- 低效写法
if message_id == "take_damage" then ... end

-- 高效写法
local DAMAGE_HASH = hash("take_damage")
if message_id == DAMAGE_HASH then ... end

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

[对象实例化]
    │
    ├─ init()            # 初始化组件
    ├─ on_reload()       # 热重载时触发
    ├─ on_enable()       # 组件启用
    │
    │  [游戏运行]
    │
    ├─ update()          # 每帧更新
    ├─ late_update()     # 后处理更新
    ├─ on_input()        # 输入事件处理
    ├─ on_message()      # 消息接收
    │
    │  [对象销毁]
    │
    └─ final()           # 组件销毁

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

function on_input(self, action_id, action)
    -- 统一处理键盘和触控输入
    local is_touch = action.touch
    local pos = is_touch and action.screen_pos or nil

    if action_id == hash("jump") then
        if action.pressed then
            self:start_jump()
        elseif action.released then
            self:cancel_jump()
        end
    end
end

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

local INPUT_BUFFER = 0.2  -- 200ms 输入缓冲

function update(self, dt)
    -- 处理缓冲输入
    if self.buffered_jump and self.buffered_jump_timer > 0 then
        self.buffered_jump_timer = self.buffered_jump_timer - dt
        if self.is_grounded then
            self:perform_jump()
            self.buffered_jump = false
        end
    end
end

function on_input(self, action_id, action)
    if action_id == hash("jump") and action.pressed then
        self.buffered_jump = true
        self.buffered_jump_timer = INPUT_BUFFER
    end
end

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

local StateMachine = {
    current = nil,
    states = {},
    change = function(self, new_state)
        if self.current and self.states[self.current].exit then
            self.states[self.current].exit()
        end
        self.current = new_state
        if self.states[self.current].enter then
            self.states[self.current].enter()
        end
    end
}

-- 定义状态行为
StateMachine.states.idle = {
    enter = function() go.animate("sprite", "ease", go.PLAYBACK_LOOP_PINGPONG, 1.0) end,
    exit = function() go.cancel_animations("sprite") end
}

StateMachine.states.run = {
    update = function(dt)
        -- 运行动画逻辑
    end
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

local CHARACTER_CONFIG = {
    warrior = {
        speed = 200,
        jump_force = 800,
        states = { "idle", "run", "attack" }
    },
    mage = {
        speed = 150,
        jump_force = 600,
        states = { "idle", "cast", "teleport" }
    }
}

function init(self)
    local config = CHARACTER_CONFIG[self.character_class]
    self.move_speed = config.speed
    -- 初始化状态机
    StateMachine:init(config.states)
end

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

-- util/math.lua
local M = {}

function M.lerp(a, b, t)
    return a + (b - a) * math.min(math.max(t, 0), 1)
end

return M

-- 使用模块
local math_util = require("util.math")
local pos = math_util.lerp(start_pos, target_pos, 0.5)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

-- 统一管理所有敌人数据
EnemyManager = {
    entities = {},
    add = function(self, enemy)
        table.insert(self.entities, {
            id = enemy.id,
            health = enemy.health,
            position = vmath.vector3()
        })
    end,
    update_all = function(self, dt)
        for _, e in ipairs(self.entities) do
            -- 批量处理逻辑
        end
    end
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

local JUMP_BUFFER = 0.15
local COYOTE_TIME = 0.1

function init(self)
    self.velocity = vmath.vector3()
    self.jump_buffer = 0
    self.coyote_timer = 0
    self.gravity = -9.8 * 1000
end

function update(self, dt)
    -- 土狼时间处理
    if self.is_grounded then
        self.coyote_timer = COYOTE_TIME
    else
        self.coyote_timer = math.max(self.coyote_timer - dt, 0)
    end

    -- 输入缓冲处理
    self.jump_buffer = math.max(self.jump_buffer - dt, 0)
    
    -- 跳跃条件判断
    if self.jump_buffer > 0 and (self.is_grounded or self.coyote_timer > 0) then
        self.velocity.y = JUMP_FORCE
        self.is_grounded = false
        self.jump_buffer = 0
    end

    -- 应用运动
    self.velocity.y = self.velocity.y + self.gravity * dt
    local pos = go.get_position()
    pos = pos + self.velocity * dt
    go.set_position(pos)
end

function on_input(self, action_id, action)
    if action_id == hash("jump") and action.pressed then
        self.jump_buffer = JUMP_BUFFER
    end
end

function on_message(self, message_id, message)
    if message_id == hash("contact_point_response") then
        -- 地面检测逻辑
    end
end