quill/val Public Public: anyone can read this; nobody can change it.

/**

 * Where you are, drawn at the frame rate.

 *

 * Everybody else in a snapshot is smoothed toward the last position the

 * server sent, which is right for a body you only hear about fifteen times a

 * second. Doing it to your own body is what made the view skip: the camera

 * was always being dragged toward a position taken sixty-six milliseconds

 * ago, and against a wall the server kept correcting it besides.

 *

 * So your own body is run forward here instead, from your own keys, through

 * the same step-and-slide the server uses (`src/glide.ts` — one copy, or the

 * guess fights the answer at every wall). The server is still the only thing

 * that decides where you are: every snapshot leans the drawn body back

 * toward its answer, and a real disagreement is taken outright. This is a

 * drawing optimisation and nothing here is ever sent anywhere.

 */

import { circleBlocked, slideCircle } from "../../src/engine/glide.ts";

/** Past this much disagreement the server simply wins: a spawn, a teleport. */

export const SNAP = 40;

/** How fast the rest of a disagreement is leaned off, a second. */

export const PULL = 12;

/** How far ahead of a snapshot your own input is ever carried, in seconds. */

export const LEAD_MAX = 0.25;

/**

 * How long your own keys take to show in the server's answer: a send every

 * 50ms, a hop each way, a tick. The drawn body is allowed this much of a

 * lead over the answer without being called wrong, in seconds of running —

 * and a disagreement inside it is leaned off gently rather than at PULL,

 * because most of what is inside it is not a disagreement at all but the

 * lag itself, which a hard pull turns into a yank at every start and stop.

 */

export const LEAD_SLACK = 0.08;

export const SOFT_PULL = 2;

/**

 * `anchored` counts the times the server's word was taken outright: every one

 * is a jump. `still` is how long no key has been held, in seconds.

 */

export const makeLocal = () => ({ x: 0, y: 0, ready: false, gap: 0, anchored: 0, still: 0 });

/** Take the server's word for it outright. */

export function anchor(local, at) {

  local.x = at.x;

  local.y = at.y;

  local.ready = true;

  local.gap = 0;

  local.anchored += 1;

  return local;

}

/**

 * One frame of your own movement: a direction, the speed the server will

 * move you at, and the world to slide against — `{ solid, tile, r }`.

 */

export function advance(local, mx, my, speed, dt, world) {

  if (!local.ready) return local;

  const len = Math.hypot(mx, my);

  if (len > 1) {

    mx /= len;

    my /= len;

  }

  if (speed <= 0 || (mx === 0 && my === 0) || dt <= 0) return local;

  const to = slideCircle(local.x, local.y, mx * speed * dt, my * speed * dt, world.r, world.solid, world.tile);

  local.x = to.x;

  local.y = to.y;

  return local;

}

/**

 * Where the server's last answer has got to by now.

 *

 * A snapshot is a position from a moment ago, and the input you have held

 * since it was sent has not reached it yet. Rather than a sequence number

 * the server echoes back, the unacknowledged part of your own movement is

 * measured in time: the age of the snapshot, capped, walked through the

 * same slide. Hold nothing and this is the server's answer exactly, which

 * is the point — it is what the drawn body settles onto.

 */

export function project(at, mx, my, speed, age, world) {

  const len = Math.hypot(mx, my);

  if (len > 1) {

    mx /= len;

    my /= len;

  }

  const ahead = Math.min(LEAD_MAX, Math.max(0, age));

  if (speed <= 0 || ahead === 0 || (mx === 0 && my === 0)) return { x: at.x, y: at.y };

  return slideCircle(at.x, at.y, mx * speed * ahead, my * speed * ahead, world.r, world.solid, world.tile);

}

/**

 * Lean the drawn body toward the server's answer. A small disagreement —

 * the width of the guess, a shot of lag — is walked off over a moment; a

 * large one is not a disagreement but a different place, and is taken.

 *

 * With keys held (`mx, my`), the part of the gap along the way you are going

 * is the lag when the drawn body is ahead: the server has not heard the keys

 * yet. Inside `slack` that is left exactly alone — pulling it is what made

 * every start a yank and every stop a drift. Across the way you are going,

 * or with the server ahead, a gap is real and is leaned off at PULL. Having

 * just stopped, a gap inside the slack is the server still catching up to

 * where you stopped: held for the lag, then leaned off gently enough not to

 * show.

 */

export function reconcile(local, server, dt, mx = 0, my = 0, slack = 0) {

  if (!local.ready) return anchor(local, server);

  const dx = server.x - local.x;

  const dy = server.y - local.y;

  local.gap = Math.hypot(dx, dy);

  if (local.gap > SNAP) return anchor(local, server);

  const hard = 1 - Math.exp(-PULL * Math.max(0, dt));

  const len = Math.hypot(mx, my);

  if (len === 0) {

    if (local.gap <= slack && local.still < LEAD_SLACK) return local;

    const k = local.gap > slack ? hard : 1 - Math.exp(-SOFT_PULL * Math.max(0, dt));

    local.x += dx * k;

    local.y += dy * k;

    return local;

  }

  const ux = mx / len;

  const uy = my / len;

  const along = dx * ux + dy * uy; // positive: the server is ahead of the drawing

  const acrossX = dx - along * ux;

  const acrossY = dy - along * uy;

  local.x += acrossX * hard;

  local.y += acrossY * hard;

  if (along > 0 || -along > slack) {

    local.x += ux * along * hard;

    local.y += uy * along * hard;

  }

  return local;

}

/**

 * Never further past the answer than the lag. The guess may fill the gap to

 * where the server's word and your own held keys put you, plus `slack` —

 * the distance your keys travel before the server has heard them — and no

 * further: left to run, a guess that moves faster than its target is

 * corrected finds its own equilibrium somewhere beyond it, which is a claim

 * about a position rather than a drawing of one.

 */

export function holdBack(local, target, mx, my, slack = 0) {

  const len = Math.hypot(mx, my);

  if (len === 0) return local;

  const dx = mx / len;

  const dy = my / len;

  const over = (local.x - target.x) * dx + (local.y - target.y) * dy - slack;

  if (over > 0) {

    local.x -= dx * over;

    local.y -= dy * over;

  }

  return local;

}

/** A body drawn inside a wall is worse than a body drawn late. */

export const insideWall = (local, world) => circleBlocked(local.x, local.y, world.r, world.solid, world.tile);

/**

 * One frame of your own body, the whole of it: the server's answer `me`

 * carried `age` seconds forward by the keys `held`, the drawn body leaned

 * onto that, advanced a frame, and never drawn past it.

 *

 * A lean across a corner can put the drawn body inside a wall, and `refused`

 * is the caller's word for anywhere else the server would not let you stand

 * (the spawn pen in the buy phase). Both used to take the server's answer,

 * which is a jump: pressed against a wall and strafing, that fired most

 * frames and read as a stutter. Holding the last good place is invisible and

 * just as honest — the next snapshot corrects it anyway. Anchoring is kept

 * for the one case where holding still leaves the body in a wall.

 */

export function stepLocal(local, me, held, speed, age, dt, world, refused) {

  const target = project(me, held.mx, held.my, speed, age, world);

  const wasX = local.x;

  const wasY = local.y;

  const slack = speed * LEAD_SLACK;

  local.still = held.mx === 0 && held.my === 0 ? local.still + dt : 0;

  reconcile(local, target, dt, held.mx, held.my, slack);

  advance(local, held.mx, held.my, speed, dt, world);

  holdBack(local, target, held.mx, held.my, slack);

  if (insideWall(local, world) || (refused !== null && refused(local.x, local.y))) {

    local.x = wasX;

    local.y = wasY;

    // Holding is for a step the server would refuse, never for the server's

    // own answer: a barrier dropped on somebody standing still leaves them

    // inside it on the server too, and a hold that outranked that would keep

    // the drawn body wherever it last stood, a room away, for as long as the

    // barrier lasted. Past the snap distance, or in a wall, the answer wins.

    if (insideWall(local, world) || Math.hypot(local.x - me.x, local.y - me.y) > SNAP) anchor(local, me);

  }

  return local;

}