《Cocos 游戏联机实战》2.1 确定性模拟与定点数

帧 N：玩家 0 按右，玩家 1 不按
      ↓ 服务端汇总广播
所有客户端都用「玩家0=右, 玩家1=不按」跑第 N 帧
      ↓
所有客户端得到同一份状态

// 同一段代码，不同引擎可能打印不同的最后几位
const y = Math.sin(0.123456789) * 1000;
console.log(y);

// assets/scripts/net/fixed.ts
export type Fixed = number;

export const FIXED_SHIFT = 16;
export const FIXED_ONE = 1 << FIXED_SHIFT; // 65536

export function fxFromInt(n: number): Fixed {
  return (n << FIXED_SHIFT) | 0;
}

export function fxFromFloat(x: number): Fixed {
  return Math.round(x * FIXED_ONE) | 0;
}

export function fxToFloat(a: Fixed): number {
  return a / FIXED_ONE;
}

export function fxAdd(a: Fixed, b: Fixed): Fixed {
  return (a + b) | 0;
}

export function fxSub(a: Fixed, b: Fixed): Fixed {
  return (a - b) | 0;
}

export function fxMul(a: Fixed, b: Fixed): Fixed {
  const aHi = a >> 16;        // 有符号整数部分
  const aLo = a & 0xffff;     // 无符号小数部分 [0, 65535]
  const bHi = b >> 16;
  const bLo = b & 0xffff;

  // (aHi + aLo/65536)(bHi + bLo/65536) * 65536
  //   = aHi*bHi*65536 + (aHi*bLo + aLo*bHi) + aLo*bLo/65536
  const hi = Math.imul(aHi, bHi);
  const cross = Math.imul(aHi, bLo) + Math.imul(aLo, bHi);
  const low = Math.floor((aLo * bLo) / FIXED_ONE);
  return (hi * FIXED_ONE + cross + low) | 0;
}

export function fxDiv(a: Fixed, b: Fixed): Fixed {
  if (b === 0) throw new Error('fixed divide by zero');
  return Math.floor((a * FIXED_ONE) / b) | 0;
}

// assets/scripts/net/determinism.ts
import { Fixed, fxAdd, fxFromFloat, fxMul } from './fixed';

export interface PlayerState {
  x: Fixed;    // 位置
  vx: Fixed;   // 速度
}

const ACCEL = fxFromFloat(0.25);
const FRICTION = fxFromFloat(0.9);

export function stepPlayer(s: PlayerState, keys: number): PlayerState {
  const ax = (keys & 1) === 1 ? ACCEL : 0;
  const vx = fxMul(fxAdd(s.vx, ax), FRICTION);
  return { x: fxAdd(s.x, vx), vx };
}

export function simulate(keysPerFrame: number[]): PlayerState {
  let s: PlayerState = { x: 0, vx: 0 };
  for (const keys of keysPerFrame) s = stepPlayer(s, keys);
  return s;
}

import { describe, expect, it } from 'vitest';
import { fxAdd, fxFromFloat, fxMul } from '../net/fixed';
import { simulate } from '../net/determinism';

describe('定点数确定性', () => {
  it('同一串输入两次运行得到逐位相同的状态', () => {
    const keys = [1, 1, 0, 1, 0, 0, 1, 1, 1, 0];
    const a = simulate(keys);
    const b = simulate(keys);
    expect(a.x).toBe(b.x);
    expect(a.vx).toBe(b.vx);
  });

  it('定点加法让 0.1 + 0.2 精确等于 0.3', () => {
    expect(fxAdd(fxFromFloat(0.1), fxFromFloat(0.2))).toBe(fxFromFloat(0.3));
  });

  it('乘法在整数域内闭合', () => {
    expect(fxMul(fxFromFloat(1.5), fxFromFloat(2.0))).toBe(fxFromFloat(3.0));
  });
});

import { _decorator, Component } from 'cc';

const { ccclass, property } = _decorator;

// 定点状态：Fixed 是 int32，Q16.16。这里内联一份最小实现，真实工程从 net/fixed 引入。
type Fixed = number;
const FX_ONE = 65536;
const fxToFloat = (a: Fixed): number => a / FX_ONE;
const fxAdd = (a: Fixed, b: Fixed): Fixed => (a + b) | 0;

@ccclass('DeterministicRunner')
export class DeterministicRunner extends Component {
  @property
  fixedStepPerSecond = 60;

  private x: Fixed = 0;
  private vx: Fixed = 0;
  private accumulator = 0;

  update(dt: number): void {
    this.accumulator += dt;
    const step = 1 / this.fixedStepPerSecond;
    while (this.accumulator >= step) {
      this.vx = fxAdd(this.vx, 16384);   // 0.25/帧 的加速度
      this.x = fxAdd(this.x, this.vx);
      this.accumulator -= step;
    }
    this.node.setPosition(fxToFloat(this.x), 0);
  }
}