《Cocos 游戏联机实战》7.2 机器人压测

// net/bot.ts —— 纯 TS，无任何 cc 依赖
export interface BotState {
  x: number;
  y: number;
  vy: number;
  grounded: boolean;
  collected: number;
}

export interface BotInput {
  jump: boolean;
  moveRight: boolean;
  collect: boolean;
}

export interface BotConfig {
  speed: number;
  gravity: number;
  jumpVelocity: number;
}

/** 一个无渲染的机器人客户端：只跑逻辑，不碰节点与引擎 */
export class Bot {
  readonly id: number;
  state: BotState;
  private readonly cfg: BotConfig;
  private tick = 0;

  constructor(id: number, cfg: BotConfig) {
    this.id = id;
    this.cfg = cfg;
    this.state = { x: 0, y: 0, vy: 0, grounded: true, collected: 0 };
  }

  /** 脚本化行为：每帧产出一个输入，由 id 与帧号决定，完全确定 */
  think(): BotInput {
    this.tick += 1;
    const phase = (this.tick + this.id * 7) % 90;
    return {
      jump: this.state.grounded && phase % 30 === 0,
      moveRight: true,
      collect: phase % 15 === 0,
    };
  }

  /** 本地应用输入，与真实客户端共用同一套逻辑 */
  step(input: BotInput, dt: number): void {
    if (input.jump && this.state.grounded) {
      this.state.vy = this.cfg.jumpVelocity;
      this.state.grounded = false;
    }
    this.state.vy += this.cfg.gravity * dt;
    this.state.y += this.state.vy * dt;
    if (this.state.y <= 0) {
      this.state.y = 0;
      this.state.vy = 0;
      this.state.grounded = true;
    }
    if (input.moveRight) this.state.x += this.cfg.speed * dt;
    if (input.collect) this.state.collected += 1;
  }
}

// net/bot-driver.ts
import type { Transport } from './transport';
import type { Bot } from './bot';

export interface BotFrameReport {
  bots: number;
  stepMs: number;            // 本帧驱动全部机器人的耗时
  handledMessages: number;   // 累计处理的消息数
}

export class BotDriver {
  private readonly bots: Bot[];
  private readonly dt: number;
  private readonly clock: () => number;
  private handledMessages = 0;

  constructor(bots: Bot[], transport: Transport, dt: number, clock: () => number) {
    this.bots = bots;
    this.dt = dt;
    this.clock = clock;
    // 消息处理也计入客户端开销，不能只算 step
    transport.onMessage(() => { this.handledMessages += 1; });
  }

  /** 单帧：每个机器人思考一次并前进一次 */
  tick(): BotFrameReport {
    const t0 = this.clock();
    for (const bot of this.bots) {
      bot.step(bot.think(), this.dt);
    }
    return { bots: this.bots.length, stepMs: this.clock() - t0, handledMessages: this.handledMessages };
  }
}

// net/fake-server.ts —— 测试替身，只回最小快照，不是服务端实现
import type { Transport } from './transport';

export class FakeSnapshotServer implements Transport {
  private listener: ((p: Uint8Array) => void) | null = null;
  private snapshots = 0;

  send(payload: Uint8Array): void {
    const ack = new Uint8Array(12);   // 1 字节类型 + 4 字节回显 + 1 字节序号 + 保留
    ack[0] = 0x01;                    // 0x01 = 快照
    ack.set(payload.subarray(0, 4), 4);
    ack[8] = this.snapshots++ & 0xff;
    this.listener?.(ack);
  }

  onMessage(cb: (p: Uint8Array) => void): void { this.listener = cb; }
  close(): void { this.listener = null; }
  get snapshotCount(): number { return this.snapshots; }
}

import { describe, expect, it } from 'vitest';
import { Bot } from './bot';
import { BotDriver } from './bot-driver';
import { FakeSnapshotServer } from './fake-server';

const cfg = { speed: 120, gravity: -900, jumpVelocity: 320 };

function makeBots(n: number): Bot[] {
  return Array.from({ length: n }, (_, i) => new Bot(i, cfg));
}

describe('BotDriver', () => {
  it('1000 个机器人单帧逻辑耗时远低于 60Hz 预算', () => {
    const driver = new BotDriver(makeBots(1000), new FakeSnapshotServer(), 1 / 60, () => performance.now());
    for (let i = 0; i < 20; i++) driver.tick();   // 预热，排除首次 JIT 抖动
    let worst = 0;
    for (let i = 0; i < 300; i++) worst = Math.max(worst, driver.tick().stepMs);
    expect(worst).toBeLessThan(8);
  });

  it('相同配置的机器人轨迹可复现', () => {
    const run = () => makeBots(50).map((b) => {
      for (let i = 0; i < 300; i++) b.step(b.think(), 1 / 60);
      return b.state;
    });
    expect(run()).toEqual(run());
  });
});

import { _decorator, Component, sys } from 'cc';
const { ccclass } = _decorator;

@ccclass('BotLoadTestGate')
export class BotLoadTestGate extends Component {
  onLoad(): void {
    const desktop =
      sys.platform === sys.Platform.DESKTOP_BROWSER ||
      sys.platform === sys.Platform.EDITOR_PAGE;
    if (!desktop) {
      console.log('[bot] skip load test on', sys.platform);
      this.enabled = false;
      return;
    }
    console.log('[bot] load test enabled on', sys.platform);
  }
}