《Cocos 游戏联机实战》2.2 输入广播与帧对齐

export const KEY_RIGHT = 1 << 0;  // bit0
export const KEY_JUMP  = 1 << 1;  // bit1
export const KEY_DASH  = 1 << 2;  // bit2

// 一帧的输入就是一个位掩码
const keys = KEY_RIGHT | KEY_JUMP;  // 同时按右和跳

{ "type": "input-batch", "frame": 120, "inputs": [
  { "playerId": 0, "keys": 1, "seq": 118 },
  { "playerId": 1, "keys": 0, "seq": 121 } ] }

inputDelay 帧数 ≈ ceil( (单程延迟 + 抖动) / 每帧时长 ) + 1

// assets/scripts/net/protocol.ts
export interface NetMessage {
  readonly type: string;
  readonly payload: unknown;
}

export interface Transport {
  send(msg: NetMessage): void;
  onMessage(handler: (msg: NetMessage) => void): void;
  close(): void;
}

// assets/scripts/net/transport.ts
import { NetMessage, Transport } from './protocol';

export class FakeTransport implements Transport {
  readonly sent: NetMessage[] = [];
  private handler: ((msg: NetMessage) => void) | null = null;
  private readonly lossRate: number;
  private rngState: number;

  constructor(options: { lossRate?: number; seed?: number } = {}) {
    this.lossRate = options.lossRate ?? 0;
    this.rngState = options.seed ?? 1;
  }

  send(msg: NetMessage): void {
    if (this.lossRate > 0 && this.nextRand() < this.lossRate) return; // 丢包
    this.sent.push(msg);
  }

  onMessage(handler: (msg: NetMessage) => void): void {
    this.handler = handler;
  }

  close(): void {
    this.handler = null;
  }

  // 测试驱动：手动投递一条消息，可乱序、可重复、可延迟到任意时刻
  deliver(msg: NetMessage): void {
    this.handler?.(msg);
  }

  private nextRand(): number {
    this.rngState = (Math.imul(this.rngState, 1664525) + 1013904223) | 0;
    return (this.rngState >>> 0) / 4294967296;
  }
}

// assets/scripts/net/input-sync.ts
export type PlayerId = number;

export interface InputFrame {
  frame: number;
  player: PlayerId;
  keys: number;
  seq: number;
}

export const INPUT_MESSAGE = 'input';

export class InputBuffer {
  private readonly players: PlayerId[];
  private readonly byFrame = new Map<number, Map<PlayerId, InputFrame>>();

  constructor(players: PlayerId[]) {
    this.players = players.slice().sort((a, b) => a - b);
  }

  // 返回 true 表示是新输入；false 表示同帧重复（丢弃）
  push(input: InputFrame): boolean {
    let byPlayer = this.byFrame.get(input.frame);
    if (!byPlayer) {
      byPlayer = new Map();
      this.byFrame.set(input.frame, byPlayer);
    }
    if (byPlayer.has(input.player)) return false;
    byPlayer.set(input.player, input);
    return true;
  }

  isReady(frame: number): boolean {
    const byPlayer = this.byFrame.get(frame);
    if (!byPlayer) return false;
    return this.players.every((p) => byPlayer.has(p));
  }

  take(frame: number): InputFrame[] | null {
    if (!this.isReady(frame)) return null;
    const byPlayer = this.byFrame.get(frame)!;
    const ordered = this.players.map((p) => byPlayer.get(p)!);
    this.byFrame.delete(frame);
    return ordered;
  }
}

export class FrameAdvancer {
  private frame = 0;
  private readonly buffer: InputBuffer;

  constructor(buffer: InputBuffer) {
    this.buffer = buffer;
  }

  current(): number {
    return this.frame;
  }

  tryAdvance(): InputFrame[] | null {
    const inputs = this.buffer.take(this.frame);
    if (inputs === null) return null; // 输入不齐，本帧等待
    this.frame += 1;
    return inputs;
  }
}

import { describe, expect, it } from 'vitest';
import { FakeTransport } from '../net/transport';
import { FrameAdvancer, InputBuffer, InputFrame, INPUT_MESSAGE } from '../net/input-sync';

const inputMsg = (frame: number, player: number, keys: number, seq: number) => ({
  type: INPUT_MESSAGE,
  payload: { frame, player, keys, seq },
});

describe('输入广播与帧对齐', () => {
  it('两人输入乱序到达，仍按帧号对齐推进', () => {
    const transport = new FakeTransport();
    const buffer = new InputBuffer([0, 1]);
    transport.onMessage((msg) => {
      if (msg.type === INPUT_MESSAGE) buffer.push(msg.payload as InputFrame);
    });
    const advancer = new FrameAdvancer(buffer);

    // 本地（玩家 0）输入直接进缓冲
    buffer.push({ frame: 0, player: 0, keys: 1, seq: 0 });
    buffer.push({ frame: 1, player: 0, keys: 0, seq: 1 });

    // 玩家 1 的输入经网络乱序到达：先到帧 1，再到帧 0
    transport.deliver(inputMsg(1, 1, 1, 1));
    transport.deliver(inputMsg(0, 1, 0, 0));

    // 两帧都齐，按 0、1 顺序推进
    expect(advancer.tryAdvance()).not.toBeNull();
    expect(advancer.tryAdvance()).not.toBeNull();
    expect(advancer.current()).toBe(2);
  });

  it('缺一个玩家的输入时不推进，重复输入被去重', () => {
    const buffer = new InputBuffer([0, 1]);
    const advancer = new FrameAdvancer(buffer);
    expect(buffer.push({ frame: 0, player: 0, keys: 1, seq: 0 })).toBe(true);
    expect(buffer.push({ frame: 0, player: 0, keys: 1, seq: 0 })).toBe(false); // 去重
    expect(advancer.tryAdvance()).toBeNull(); // 玩家 1 没到，原地等
  });
});

import { _decorator, Component, EventKeyboard, Input, input, KeyCode } from 'cc';

const { ccclass } = _decorator;

const KEY_RIGHT = 1 << 0;
const KEY_JUMP = 1 << 1;

@ccclass('InputCapture')
export class InputCapture extends Component {
  private keys = 0;

  onEnable(): void {
    input.on(Input.EventType.KEY_DOWN, this.onKeyDown, this);
    input.on(Input.EventType.KEY_UP, this.onKeyUp, this);
  }

  onDisable(): void {
    input.off(Input.EventType.KEY_DOWN, this.onKeyDown, this);
    input.off(Input.EventType.KEY_UP, this.onKeyUp, this);
  }

  private onKeyDown(e: EventKeyboard): void {
    if (e.keyCode === KeyCode.ARROW_RIGHT) this.keys |= KEY_RIGHT;
    if (e.keyCode === KeyCode.SPACE) this.keys |= KEY_JUMP;
  }

  private onKeyUp(e: EventKeyboard): void {
    if (e.keyCode === KeyCode.ARROW_RIGHT) this.keys &= ~KEY_RIGHT;
    if (e.keyCode === KeyCode.SPACE) this.keys &= ~KEY_JUMP;
  }

  consume(): number {
    return this.keys;
  }
}