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

[硬件驱动层]
   │
   ├─ 原始信号采集（触控点、按键码、手柄轴）
   │
[引擎抽象层]
   │
   ├─ 输入标准化（坐标转换、轴归一化）
   │
[逻辑处理层]
   │
   ├─ 输入映射（.input_binding 配置）
   │
[事件分发层]
   │
   └─ Lua 脚本响应（on_input 回调）

 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

InputBuffer = {
    buffer = {},
    max_size = 5,
    push = function(self, action)
        table.insert(self.buffer, 1, action)
        if #self.buffer > self.max_size then
            table.remove(self.buffer)
        end
    end,
    consume = function(self, action_id)
        for i=#self.buffer,1,-1 do
            if self.buffer[i].action_id == action_id then
                table.remove(self.buffer, i)
                return true
            end
        end
        return false
    end
}

-- 使用示例
function on_input(self, action_id, action)
    InputBuffer:push({ action_id = action_id, action = action })
end

function update(self)
    if InputBuffer:consume(hash("jump")) then
        self:perform_jump()
    end
end

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

local INPUT_PRIORITY = {
    [hash("pause")] = 100,   -- 最高优先级
    [hash("attack")] = 50,
    [hash("move")] = 30
}

function process_input(action)
    local current_priority = INPUT_PRIORITY[action.action_id] or 0
    if current_priority > self.current_priority then
        self:interrupt_current_action()
        self.current_priority = current_priority
        return true
    end
    return false
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

local COMBO_TIMEOUT = 0.3  -- 组合键间隔时间

ComboDetector = {
    sequence = {},
    last_input_time = 0,
    combos = {
        ["A+B"] = { hash("a"), hash("b") },
        ["→→A"] = { hash("right"), hash("right"), hash("a") }
    },
    check = function(self, action)
        local now = socket.gettime()
        if now - self.last_input_time > COMBO_TIMEOUT then
            self.sequence = {}
        end
        
        table.insert(self.sequence, action.action_id)
        self.last_input_time = now
        
        for name, pattern in pairs(self.combos) do
            if self:match_pattern(pattern) then
                msg.post("/combos#handler", "combo_achieved", { name = name })
                self.sequence = {}
                return true
            end
        end
        return false
    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

GestureRecognizer = {
    touch_start_pos = nil,
    tolerance = 20,  -- 像素容差
    gestures = {
        SWIPE_LEFT = { dx = -1, dy = 0 },
        SWIPE_RIGHT = { dx = 1, dy = 0 }
    },
    on_touch = function(self, action)
        if action.pressed then
            self.touch_start_pos = action.screen_pos
        elseif action.released and self.touch_start_pos then
            local delta = action.screen_pos - self.touch_start_pos
            local dir = vmath.normalize(delta)
            
            for name, gesture in pairs(self.gestures) do
                if math.abs(dir.x - gesture.dx) < 0.3 and
                   math.abs(dir.y - gesture.dy) < 0.3 then
                    msg.post("/player#controller", "gesture", { type = name })
                    break
                end
            end
        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

EventBus = {
    subscribers = {},
    subscribe = function(event, callback, priority)
        EventBus.subscribers[event] = EventBus.subscribers[event] or {}
        table.insert(EventBus.subscribers[event], {
            callback = callback,
            priority = priority or 50
        })
        table.sort(EventBus.subscribers[event], function(a,b)
            return a.priority > b.priority
        end)
    end,
    publish = function(event, data)
        local handlers = EventBus.subscribers[event] or {}
        for _, handler in ipairs(handlers) do
            if handler.callback(data) == "STOP" then
                break  -- 高优先级拦截后续处理
            end
        end
    end
}

-- 使用示例
EventBus.subscribe("player_damage", function(data)
    -- 更新UI血条
end, 30)

EventBus.publish("player_damage", { amount = 10 })

 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

EventPipeline = {
    middleware = {},
    use = function(self, fn)
        table.insert(self.middleware, fn)
    end,
    process = function(self, event)
        local index = 1
        local function next()
            local layer = self.middleware[index]
            if layer then
                index = index + 1
                layer(event, next)
            end
        end
        next()
    end
}

-- 日志中间件
EventPipeline:use(function(event, next)
    print("Event received:", event.type)
    next()
end)

-- 过滤中间件
EventPipeline:use(function(event, next)
    if event.source ~= "player" then
        return  -- 拦截非玩家事件
    end
    next()
end)

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

InputManager = {
    current_mode = "keyboard",
    modes = {
        keyboard = { sensitivity = 1.0 },
        gamepad = { sensitivity = 2.0 },
        touch = { sensitivity = 1.5 }
    },
    detect_mode = function(self)
        if input.get_gamepad() then
            self.current_mode = "gamepad"
        elseif input.get_touch() then
            self.current_mode = "touch"
        else
            self.current_mode = "keyboard"
        end
    end
}

function update(self)
    InputManager:detect_mode()
    local sensitivity = InputManager.modes[InputManager.current_mode].sensitivity
    -- 应用不同灵敏度
end

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

ControlPresets = {
    schemes = {
        default = {
            jump = { keys = {"space"}, buttons = {"A"} },
            attack = { keys = {"ctrl"}, buttons = {"X"} }
        },
        legacy = {
            jump = { keys = {"enter"}, buttons = {"B"} }
        }
    },
    load = function(self, scheme_name)
        local scheme = self.schemes[scheme_name]
        input.rebind(scheme)
    end
}

-- 游戏设置界面调用
ControlPresets:load("legacy")

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

local INPUT_FLAGS = {
    JUMP_PRESSED = 0x1,
    ATTACK_HELD = 0x2,
    MOVE_LEFT = 0x4
}

function on_input(self, action_id, action)
    local mask = 0
    if action_id == hash("jump") and action.pressed then
        mask = bit.bor(mask, INPUT_FLAGS.JUMP_PRESSED)
    end
    -- 其他状态更新...
    self.input_state = mask
end

function has_input(self, flag)
    return bit.band(self.input_state, flag) ~= 0
end

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

InputWorker = {
    queue = {},
    process = function(self)
        while #self.queue > 0 do
            local job = table.remove(self.queue, 1)
            pcall(job.fn, job.data)
        end
    end
}

function on_input(self, action_id, action)
    table.insert(InputWorker.queue, {
        fn = handle_input,
        data = { action_id = action_id, action = action }
    })
end

function handle_input(data)
    -- 耗时的输入处理逻辑
end

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

DebugInputViewer = {
    history = {},
    max_entries = 20,
    log = function(self, action)
        table.insert(self.history, 1, {
            time = os.time(),
            action = action
        })
        if #self.history > self.max_entries then
            table.remove(self.history)
        end
    end,
    draw = function(self)
        imgui.Begin("Input Debug")
        for _, entry in ipairs(self.history) do
            imgui.Text(string.format("[%s] %s", 
                os.date("%H:%M:%S", entry.time),
                hash_to_string(entry.action.action_id)))
        end
        imgui.End()
    end
}

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

InputProfiler = {
    timings = {},
    begin = function(self, name)
        self.timings[name] = socket.gettime()
    end,
    end = function(self, name)
        if self.timings[name] then
            local duration = (socket.gettime() - self.timings[name]) * 1000
            print(string.format("%s: %.2fms", name, duration))
        end
    end
}

function on_input(self, ...)
    InputProfiler:begin("input_processing")
    -- 处理逻辑...
    InputProfiler:end("input_processing")
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

ComboSystem = {
    current_sequence = {},
    combo_definitions = {
        ["Hadoken"] = {
            pattern = { "down", "forward", "punch" },
            timing = 0.5  -- 秒
        }
    },
    on_input = function(self, direction)
        table.insert(self.current_sequence, direction)
        self:check_combos()
        self:start_timeout()
    end,
    check_combos = function(self)
        for name, combo in pairs(self.combo_definitions) do
            if #self.current_sequence >= #combo.pattern then
                local match = true
                for i=1, #combo.pattern do
                    if self.current_sequence[#self.current_sequence - #combo.pattern + i] ~= combo.pattern[i] then
                        match = false
                        break
                    end
                end
                if match then
                    msg.post("/fighter#controller", "special_move", { move = name })
                    self.current_sequence = {}
                    return
                end
            end
        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

InputBufferWindow = {
    buffer = {},
    window = 0.15,  -- 150ms 缓冲窗口
    add = function(self, action)
        table.insert(self.buffer, {
            action = action,
            expire = socket.gettime() + self.window
        })
    end,
    process = function(self)
        local now = socket.gettime()
        for i=#self.buffer,1,-1 do
            if self.buffer[i].expire < now then
                table.remove(self.buffer, i)
            else
                -- 尝试消费缓冲输入
                if self:can_consume(self.buffer[i].action) then
                    table.remove(self.buffer, i)
                    return true
                end
            end
        end
        return false
    end
}