《Cocos 游戏联机实战》9.3 延迟补偿与体验权衡

// assets/scripts/net/sync/SoftCorrection.ts
import { _decorator, Component, Node, Vec3 } from 'cc';

const { ccclass, property } = _decorator;

@ccclass('SoftCorrection')
export class SoftCorrection extends Component {
  @property(Node)
  target: Node | null = null;

  @property
  smoothSpeed = 12;

  @property
  snapDist = 32;

  private readonly desired = new Vec3();
  private readonly tmp = new Vec3();

  /** 服务端和解后调用，把节点朝权威位置平滑吸附。 */
  correctTo(x: number, y: number): void {
    this.desired.set(x, y, 0);
  }

  update(dt: number): void {
    if (!this.target) return;
    const cur = this.target.getPosition(this.tmp);
    const dist = Vec3.distance(cur, this.desired);
    if (dist > this.snapDist) {
      this.target.setPosition(this.desired);
      return;
    }
    const k = Math.min(1, this.smoothSpeed * dt);
    Vec3.lerp(this.tmp, cur, this.desired, k);
    this.target.setPosition(this.tmp);
  }
}

// sync/lag-compensation.ts —— 纯 TS，延迟补偿策略
export type RaceMode = 'pure-time' | 'interference';

export interface CompInput {
  localRttMs: number; // 本地往返延迟（已平滑）
  remoteRttMs: number; // 对手延迟估计
  baseMs: number; // 基础补偿量
}

export interface CompResult {
  compMs: number; // 实际施加的补偿量
  capped: boolean; // 是否被上限截断
}

export const MAX_COMP_MS = 150; // 补偿上限：再高就等于给高延迟玩家开挂
export const DEADZONE_MS = 60; // 死区：低于此延迟差不补偿

/** 纯计时竞速不需要补偿；只有会互相干扰的赛道才需要。 */
export function needsCompensation(mode: RaceMode): boolean {
  return mode === 'interference';
}

/** 根据双方延迟估计给出补偿量。只补劣势，不惩罚低延迟玩家。 */
export function computeCompensation(input: CompInput): CompResult {
  const { localRttMs, remoteRttMs, baseMs } = input;
  const disadvantage = localRttMs - remoteRttMs;
  if (disadvantage <= DEADZONE_MS) return { compMs: 0, capped: false };
  const raw = baseMs + (disadvantage - DEADZONE_MS) * 0.5;
  const compMs = Math.min(raw, MAX_COMP_MS);
  return { compMs, capped: compMs < raw };
}

import { describe, expect, it } from 'vitest';
import {
  computeCompensation,
  needsCompensation,
  MAX_COMP_MS,
  type CompInput,
} from './lag-compensation';

const input = (localRttMs: number, remoteRttMs: number, baseMs = 20): CompInput =>
  ({ localRttMs, remoteRttMs, baseMs });

describe('computeCompensation', () => {
  it('低延迟玩家不被惩罚：本地更快时补偿为 0', () => {
    expect(computeCompensation(input(40, 200)).compMs).toBe(0);
  });

  it('延迟差在死区内不补偿', () => {
    expect(computeCompensation(input(100, 60)).compMs).toBe(0); // 差 40 < 60
  });

  it('延迟差超出死区后给出正补偿', () => {
    // 差 170，raw = 20 + (170 - 60) * 0.5 = 75
    expect(computeCompensation(input(200, 30)).compMs).toBeCloseTo(75);
  });

  it('补偿量有硬上限', () => {
    const r = computeCompensation(input(1000, 0));
    expect(r.compMs).toBe(MAX_COMP_MS);
    expect(r.capped).toBe(true);
  });

  it('补偿量随劣势单调不减，且封顶', () => {
    const a = computeCompensation(input(150, 30)).compMs;
    const b = computeCompensation(input(300, 30)).compMs;
    const c = computeCompensation(input(900, 30)).compMs;
    expect(a).toBeLessThanOrEqual(b);
    expect(b).toBeLessThanOrEqual(c);
    expect(c).toBe(MAX_COMP_MS);
  });
});

describe('needsCompensation', () => {
  it('纯计时竞速不需要补偿，干扰赛道才需要', () => {
    expect(needsCompensation('pure-time')).toBe(false);
    expect(needsCompensation('interference')).toBe(true);
  });
});