游戏客户端架构 / 系统课时

处理组合键与输入序列

处理组合键与输入序列

格斗游戏中的同时按键、方向指令和连续技能都需要识别多个输入事件。简单判断某个按键是否按下,容易产生误触发、前缀冲突和超时误判。本课使用有限状态和时间窗口实现可预测的输入序列识别,并验证不同事件顺序下的结果。

学习目标

  • 区分同时组合键与有序输入序列,理解各自的时间约束。
  • 使用有限状态识别序列,正确处理前缀冲突、超时和错误输入。
  • 实现可运行的识别器,并用确定性事件验证输出。

区分组合键和输入序列

假设游戏支持以下操作:

  • 同时按下 Ctrl 和 K:触发快捷操作。
  • 依次按下 A、B:触发普通技能。
  • 依次按下 A、B、C:触发强化技能。

第一种属于同时组合键,需要检查按键是否处于按住状态,以及按下时间是否满足容差。后两种属于输入序列,要求事件按指定顺序到达,并且相邻事件不能超过时间窗口。

不要将两个概念混为一谈。例如,玩家一直按住 A 再按 B,可能满足同时按键条件,但不一定满足要求两次独立按下事件的序列规则。

本课以离散的 KeyDown 事件识别有序序列;真实项目还需要在输入采集层维护 KeyUp 和当前按键集合,才能可靠地识别同时组合键。

用有限状态处理事件

以 A → B → C 为例,可以把已匹配的前缀作为识别器状态:初始状态、已收到 A、已收到 A B。每到达一个新事件,识别器根据当前状态、输入键和时间间隔决定继续、完成或回退。

输入序列有限状态转换图

这里存在一个重要冲突:A B 本身是合法技能,同时又是 A B C 的前缀。如果一收到 B 就执行普通技能,玩家将无法稳定触发强化技能。

解决方式是延迟确认:识别到 A B 时先保存候选结果;窗口内出现 C 就执行强化技能,否则在窗口结束后确认普通技能。

状态机还要明确三条规则:

  1. 相邻事件超过窗口时,结束旧序列,并尝试让当前事件成为新序列的起点。
  2. 收到不符合后续规则的事件时,先提交已有候选,再尝试重新匹配;不能无条件丢弃当前事件。
  3. 对存在多个匹配前缀的情况,优先保留可继续扩展的匹配路径,避免遗漏重叠序列。

实现带超时的序列识别器

下面使用 Python 标准库实现一个最小识别器。支持 AB、ABC 和 BC 三个动作,输入时间以整数毫秒表示,便于独立测试。为了让示例集中讨论前缀冲突,规则只使用固定序列,不包含通配符。

python
from dataclasses import dataclass


@dataclass(frozen=True)
class Rule:
    keys: tuple[str, ...]
    action: str


class SequenceRecognizer:
    def __init__(self, rules: list[Rule], window_ms: int = 200):
        if window_ms <= 0 or not rules:
            raise ValueError("窗口必须为正数,规则不能为空")
        if any(not rule.keys for rule in rules):
            raise ValueError("序列不能为空")
        if len({rule.keys for rule in rules}) != len(rules):
            raise ValueError("不能存在重复序列")
        self.rules = rules
        self.window_ms = window_ms
        self.events: list[tuple[str, int]] = []
        self.pending: Rule | None = None
        self.last_time: int | None = None

    def _matches(self):
        keys = tuple(key for key, _ in self.events)
        return [rule for rule in self.rules
                if rule.keys[:len(keys)] == keys]

    def _resolve(self):
        # 优先保留最长的已完成序列,避免短前缀抢先触发。
        matches = self._matches()
        complete = [rule for rule in matches
                    if len(rule.keys) == len(self.events)]
        if complete:
            self.pending = complete[0]
        if matches and any(len(rule.keys) > len(self.events)
                           for rule in matches):
            return []
        result = [self.pending.action] if self.pending else []
        self.events.clear()
        self.pending = None
        return result

    def flush(self, now_ms: int):
        if self.last_time is not None and now_ms < self.last_time:
            raise ValueError("时间不能倒退")
        if (self.events and now_ms - self.events[-1][1]
                > self.window_ms):
            result = [self.pending.action] if self.pending else []
            self.events.clear()
            self.pending = None
            return result
        return []

    def feed(self, key: str, time_ms: int):
        result = self.flush(time_ms)
        if self.last_time is not None and time_ms < self.last_time:
            raise ValueError("事件时间不能倒退")
        self.last_time = time_ms
        self.events.append((key, time_ms))
        if not self._matches():
            # 错误事件也可能是新序列的起点。
            if self.pending:
                result.append(self.pending.action)
            self.events = [(key, time_ms)]
            self.pending = None
            if not self._matches():
                self.events.clear()
                return result
        result.extend(self._resolve())
        return result


rules = [
    Rule(("A", "B"), "普通技能"),
    Rule(("A", "B", "C"), "强化技能"),
    Rule(("B", "C"), "反击技能"),
]

recognizer = SequenceRecognizer(rules)
print(recognizer.feed("A", 0))
print(recognizer.feed("B", 100))
print(recognizer.feed("C", 180))
print(recognizer.feed("A", 500))
print(recognizer.feed("B", 600))
print(recognizer.flush(801))

预期输出:

text
[]
[]
['强化技能']
[]
[]
['普通技能']

前两个空列表表示识别器仍在等待。第三个事件补全 ABC,直接产生强化技能。第二轮只有 AB,超过窗口后才提交普通技能。时间值由测试提供,不依赖真实帧率。

处理重叠前缀和取消策略

上述实现是便于理解的最小模型,并非支持任意重叠的完整匹配自动机。比如规则同时存在 A B A 和 B A 时,匹配失败后只保留当前按键,可能漏掉前面输入形成的有效后缀。

正式实现可以保存最近的事件窗口,在每次事件后重新匹配所有可能的后缀;或者构建 Trie 并结合失败转移,在出现重叠前缀时保留最长有效后缀。对于规则数量较少的游戏,重新扫描通常更容易维护。

同时必须明确取消策略:角色被击中、打开菜单或切换输入上下文时,是否清空未完成序列?通常应清空旧状态,防止暂停前的按键在恢复后意外触发技能。输入事件还应区分首次按下和操作系统自动重复产生的按下通知,否则长按可能被误判为连续操作。

验证边界与执行语义

至少需要覆盖完整匹配、短前缀超时、错误事件、新序列重新开始,以及恰好落在窗口边界的输入。测试应该直接注入时间戳,而不是使用 sleep 等待真实时间。

还要区分识别成功与玩法执行:识别器输出的是动作命令,角色能否执行仍由游戏状态决定。例如角色处于硬直期间,即使识别出强化技能,玩法层也可以拒绝执行。这样输入规则和技能冷却、资源消耗等业务规则不会相互污染。

当组合键数量很少时,按键集合加时间检查通常就够了;当序列包含前缀冲突、重叠匹配和多条分支时,再使用显式状态机或 Trie。关键不是算法复杂度,而是让每次超时、回退和命令提交都有明确、可测试的规则。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

处理组合键与输入序列

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通