游戏中的数学 15：从单机坐标到可同步世界

// $WORK_DIR/.tmp/game-math-lab/Program.cs
// CellPoint 与 GameMathLab.SplitCell
readonly record struct CellPoint(
    double World,
    long Cell,
    double Local);

static CellPoint SplitCell(double world, double size)
{
    var cell = (long)Math.Floor((world + size / 2) / size);
    var local = world - cell * size;
    return new(world, cell, local);
}

// Program.cs · Chapter15 分区样本与不变量
const double cellSize = 256;
var positions = new[] {
    -520.25, -128.0, 0.0,
    127.999, 300.5, 819.75
};

var encoded = positions
    .Select(x => SplitCell(x, cellSize))
    .ToArray();

var maxRebuild = encoded.Max(e =>
    Math.Abs(e.Cell * cellSize + e.Local - e.World));

Check(maxRebuild < Eps,
    "cell plus local reconstructs world coordinate");

// Program.cs · QuantizeSigned 与误差扫描
static double QuantizeSigned(
    double value, double extent, int bits)
{
    if (extent <= 0 || bits < 2 || bits > 30)
        throw new ArgumentOutOfRangeException();
    var levels = (1L << bits) - 1;
    var n = Math.Clamp(
        (value + extent) / (2 * extent), 0, 1);
    var q = Math.Round(n * levels);
    return q / levels * (2 * extent) - extent;
}

var qErrors = new List<double>();
for (var i = 0; i < 10_000; i++) {
    var x = -128 + 256.0 * i / 9999;
    qErrors.Add(Math.Abs(
        QuantizeSigned(x, 128, 16) - x));
}

Check(qErrors.Max() <= 256.0 / 65535 / 2 + 1e-9,
    "16-bit quantization respects half-step bound");

// Program.cs · 周期角度与实际快照字段
readonly record struct QuantizedSnapshot(
    int CellX, int CellY,
    ushort LocalX, ushort LocalY,
    ushort Yaw, uint Tick);

static ushort QuantizeAngle(double degrees, int bits)
{
    var wrapped = ((degrees % 360) + 360) % 360;
    var bins = 1 << bits;
    return (ushort)((long)Math.Round(
        wrapped / 360 * bins) % bins);
}

var snapshot = new QuantizedSnapshot(
    -2, 3,
    QuantizeToUInt16(-8.25, 128),
    QuantizeToUInt16(51.75, 128),
    QuantizeAngle(725, 16),
    42);

static byte[] EncodeSnapshot(QuantizedSnapshot s)
{
    var bytes = new byte[18];
    BinaryPrimitives.WriteInt32LittleEndian(bytes.AsSpan(0, 4), s.CellX);
    BinaryPrimitives.WriteInt32LittleEndian(bytes.AsSpan(4, 4), s.CellY);
    BinaryPrimitives.WriteUInt16LittleEndian(bytes.AsSpan(8, 2), s.LocalX);
    BinaryPrimitives.WriteUInt16LittleEndian(bytes.AsSpan(10, 2), s.LocalY);
    BinaryPrimitives.WriteUInt16LittleEndian(bytes.AsSpan(12, 2), s.Yaw);
    BinaryPrimitives.WriteUInt32LittleEndian(bytes.AsSpan(14, 4), s.Tick);
    return bytes;
}

var orientation = Quaternion.CreateFromAxisAngle(
    Vector3.UnitZ, (float)Math.Atan2(20, 100));
var velocity = Vector3.Transform(
    new Vector3((float)Math.Sqrt(10400), 0, 0), orientation);
var motion = MoveCircleAgainstWall(
    new(-1, 0), new(velocity.X, velocity.Y),
    1.0 / 60, .25, 0, .1);
var screen = Project(
    new(motion.Position.X, motion.Position.Y, -5),
    1920, 1080, 60, 1920.0 / 1080);
var cell = SplitCell(motion.Position.X + 512, 256);
var outgoing = new QuantizedSnapshot(
    (int)cell.Cell, 0, QuantizeToUInt16(cell.Local, 128),
    QuantizeToUInt16(motion.Position.Y, 128),
    QuantizeAngle(11.309932, 16), 43);
var wire = EncodeSnapshot(outgoing);
Check(motion.Hit && float.IsFinite(screen.X) &&
      wire.Length == 18 && DecodeSnapshot(wire) == outgoing,
    "one mover reaches collision, projection and snapshot");

// Program.cs · SimulateSnapshots 核心时序
const double duration = 12;
const double sendDt = .05;
const double renderDt = 1.0 / 60;
const double buffer = .1;

for (var t = 0.0; t <= duration; t += sendDt) {
    if ((t >= 5 && t < 5.5) ||
        random.NextDouble() < .1) {
        dropped++;
        continue;
    }
    var delay = .08 + (random.NextDouble() * 2 - 1) * .02;
    var truth = Truth(t);
    var quantized = new Vector2(
        (float)QuantizeSigned(truth.X, 128, 16),
        (float)QuantizeSigned(truth.Y, 128, 16));
    packets.Add(new(t, t + delay, quantized));
}

var target = now - buffer;
var before = received.LastOrDefault(p => p.Server <= target);
var after = received.FirstOrDefault(p => p.Server >= target);
if (before is null || target < 0) continue; // 仅跳过启动

Vector2 shown;
if (after is not null && after.Server > before.Server + 1e-9) {
    var f = (target - before.Server) /
            (after.Server - before.Server);
    shown = Vector2.Lerp(before.Position, after.Position, (float)f);
    interpolated++;
} else {
    shown = before.Position;
    held++;
}
var error = Vector2.Distance(shown, Truth(target));
sum2 += error * error;
samples++;

cd "$WORK_DIR"
/usr/bin/time -p dotnet run \
  --project .tmp/game-math-lab/GameMathLab.csproj \
  -- --out .tmp/game-math-lab/out

CH15 PASS crossings=6 rebuild=0.000E+000m qmax=0.001953m angle_max=0.002746deg bytes=18 integrated=pass received=210 dropped=30 samples=713 held=443 rmse=0.185576m outage_max=1.308509m recovery=150.0ms
TOTAL pass=15 fail=0 skip=0 chapters=15 elapsed_ms=112.8
exit_code=0

{
  "cell_size_m": 256,
  "max_rebuild_error_m": 0,
  "quantized_position_bits": 16,
  "quantization_max_error_m": 0.0019525687977477446,
  "quantized_angle_bits": 16,
  "angle_max_error_deg": 0.0027463073455464837,
  "sample_snapshot": {
    "CellX": -2, "CellY": 3,
    "LocalX": 30656, "LocalY": 46015,
    "Yaw": 910, "Tick": 42
  },
  "snapshot_bytes": 18,
  "integrated_mover": {
    "velocity_mps": {"x": 100, "y": 20},
    "collision_position_m": {"x": -0.25, "y": 0.3333333},
    "screen_px": {"x": 913.2346, "y": 477.64618},
    "cell_x": 2,
    "cell_y": 0,
    "rebuild_error_m": 0,
    "snapshot": {
      "CellX": 2, "CellY": 0,
      "LocalX": 32704, "LocalY": 32853,
      "Yaw": 2059, "Tick": 43
    },
    "wire_bytes": 18,
    "roundtrip": true
  },
  "network": {
    "Received": 210,
    "Dropped": 30,
    "Samples": 713,
    "InterpolatedSamples": 270,
    "HeldSamples": 443,
    "Rmse": 0.18557614338107617,
    "MaxError": 1.3987560272216797,
    "OutageMaxError": 1.3085088729858398,
    "RecoveryMs": 149.99999999998525
  }
}