@netforge/engine-sim API reference

import { initSim, createPhysics } from "@netforge/engine-sim";

function addKart(w: KartWorld, id: number, opts?: { bot?: boolean; frozen?: boolean; slot?: number; }): Kart;

function addPlatformPlayer(w: PlatformWorld, id: number, opts?: { bot?: boolean; frozen?: boolean; }): PlatformPlayer;

function addPlayer(world: SimWorld, playerId: PlayerId, spawn?: Vec3): NetId;

function applyBeamHit(world: SimWorld, shot: BeamShot, target: NetId): void;

function applyKart(w: KartWorld, s: KartWire): Kart;

function applyPlatformPlayer(w: PlatformWorld, s: PlatformPlayerWire): PlatformPlayer;

function applyState(world: SimWorld, state: SimState): void;

function arenaHitboxes(world: SimWorld): ArenaHitbox[];

function arenaSpawn(world: SimWorld, playerId: PlayerId): [number, number];

function beamRange(config: ResolvedSimConfig, x: number, z: number, dx: number, dz: number, range: number): number;

function beamShot(world: SimWorld, playerId: PlayerId, cmd: InputCommand): BeamShot | null;

function buildKartTrack(def: KartTrackDef): KartTrack;

function captureKart(w: KartWorld, k: Kart): KartWire;

function capturePlatformPlayer(w: PlatformWorld, p: PlatformPlayer): PlatformPlayerWire;

function captureState(world: SimWorld, include?: (e: EntityState) => boolean): SimState;

function collisionGroups(layer: number, mask: number): number;

function createKartWorld(cfg: KartConfig): KartWorld;

function createPhysics(opts?: PhysicsOptions): PhysicsWorld;

function createPlatformWorld(cfg: PlatformConfig): PlatformWorld;

function createWorld(config?: SimConfig): SimWorld;

function critRoll(tick: number, netId: number): number;

function decodeChoices(choices: number): { offers: [number, number, number]; pending: number; };

function decodeInput(bytes: Uint8Array, offset?: number): InputCommand;

function decodeInputs(bytes: Uint8Array): InputCommand[];

function decodeSnapshot(bytes: Uint8Array, baseline?: SimState): SimState;

function decodeTelegraph(word: number): { kind: number; progress: number; angle: number; radius: number; };

function destroyWorld(world: SimWorld): void;

function edgeSpawnPoint(world: SimWorld, playerId: PlayerId | undefined, opts?: EdgeSpawnOptions): [number, number] | null;

function encodeInput(cmd: InputCommand, out?: Uint8Array, offset?: number): Uint8Array;

function encodeInputs(cmds: readonly InputCommand[]): Uint8Array;

function encodeSnapshot(state: SimState, baseline?: SimState): Uint8Array;

function enemyCount(world: SimWorld, type?: number): number;

function enemyMaxHealth(world: SimWorld, netId: NetId): number | undefined;

function enemyTypeOf(world: SimWorld, netId: NetId): number;

function entityHeadroom(world: SimWorld): number;

function entityHealth(world: SimWorld, netId: NetId): number | undefined;

function entityPosition(world: SimWorld, netId: NetId): [number, number] | undefined;

function grantKartStat(w: KartWorld, id: number, stat: KartStat): boolean;

function grantLevels(world: SimWorld, playerId: PlayerId, levels: number): number;

function grantPlatformStat(w: PlatformWorld, id: number, stat: PlatStat): boolean;

function grantUpgrade(world: SimWorld, playerId: PlayerId, index: number): boolean;

function grantXp(world: SimWorld, playerId: PlayerId, amount: number): boolean;

function initSim(): Promise<void>;

function inWall(walls: readonly WallBox[], x: number, z: number, r: number): boolean;

function isOnScreen(world: SimWorld, x: number, z: number): boolean;

function kartCoinCount(k: { coinsLo: number; coinsHi: number; }): number;

function kartCoinTaken(k: { coinsLo: number; coinsHi: number; }, i: number): boolean;

function kartProgress(w: KartWorld, k: Kart): number;

function kartStatLevel(k: { stats: number; }, stat: KartStat): number;

function kartStep(w: KartWorld, inputs: ReadonlyMap<number, InputCommand>): KartEvent[];

function keeperButtons(index: number): number;

function lastProcessedSeq(world: SimWorld, playerId: PlayerId): number;

function lateralOffset(t: KartTrack, seg: number, x: number, z: number): number;

function layerMask(...layers: readonly (LayerName | number)[]): number;

function layersCollide(layerA: number, maskA: number, layerB: number, maskB: number): boolean;

function listPickups(world: SimWorld): { x: number; z: number; value: number; }[];

function listPlayers(world: SimWorld): PlayerSummary[];

function maxHealthFor(config: ResolvedSimConfig, stats: number): number;

function metaBonusOf(world: SimWorld, playerId: PlayerId): MetaBonus;

function moverBox(m: PlatformMover, tick: number): PlatBox;

function nearestSample(t: KartTrack, x: number, z: number, from?: number, reach?: number): number;

function onFloor(floors: readonly WallBox[], x: number, z: number, r: number): boolean;

function orbitAngle(tick: number, tickRate: number, speed: number, i: number, n: number): number;

function pendingCards(world: SimWorld, playerId: PlayerId): number;

function platBox(x0: number, y0: number, x1: number, y1: number): PlatBox;

function platformCoinCount(p: { coinsLo: number; coinsHi: number; }): number;

function platformCoinTaken(p: { coinsLo: number; coinsHi: number; }, i: number): boolean;

function platformProgress(w: PlatformWorld, p: { x: number; flags: number; }): number;

function platformRespawnPoint(w: PlatformWorld, cp: number): readonly [number, number];

function platformStep(w: PlatformWorld, inputs: ReadonlyMap<number, InputCommand>): PlatformEvent[];

function platStatLevel(p: { stats: number; }, stat: PlatStat): number;

function playerBuild(world: SimWorld, playerId: PlayerId): PlayerBuild | null;

function playerNetId(world: SimWorld, playerId: PlayerId): NetId | undefined;

function pushOutOfWalls(walls: readonly WallBox[], x: number, z: number, r: number): [x: number, z: number, nx: number, nz: number];

function quantizeInput(cmd: InputCommand): InputCommand;

function recycleEnemies(world: SimWorld, periodTicks: number, afterTicks: number, margin: number): { moved: number; removed: number; };

function removeEnemies(world: SimWorld, type: number): number;

function removeKart(w: KartWorld, id: number): boolean;

function removePlatformPlayer(w: PlatformWorld, id: number): boolean;

function removePlayer(world: SimWorld, playerId: PlayerId): void;

function renderView(world: SimWorld): RenderView;

function resetKart(w: KartWorld, k: Kart, frozen: boolean): void;

function resetPlatformPlayer(w: PlatformWorld, p: PlatformPlayer, frozen: boolean): void;

function resetRun(world: SimWorld): void;

function resolveCharacter(d: CharacterDesc): ResolvedCharacterDesc;

function resolveConfig(config?: SimConfig): ResolvedSimConfig;

function respawnDead(world: SimWorld): PlayerId[];

function restorePhysics(bytes: Uint8Array): PhysicsWorld;

function revivePlayer(world: SimWorld, playerId: PlayerId): boolean;

function ringSpawnPoint(world: SimWorld, cx: number, cz: number, radius: number, enemyRadius?: number): [number, number] | null;

function scaledWeapon(def: WeaponDef, level: number, mods: WeaponMods): Scaled;

function scatterEnemies(world: SimWorld, type: number, count: number): number;

function segmentWalls(walls: readonly WallBox[], x0: number, z0: number, dx: number, dz: number, r: number): number;

function selectedSlot(choices: number): number;

function setCosmetic(world: SimWorld, playerId: PlayerId, cosmetic: number): void;

function setEnemySpeed(world: SimWorld, k: number): void;

function setKartsFrozen(w: KartWorld, frozen: boolean): void;

function setKartTrack(w: KartWorld, index: number): void;

function setMetaBonus(world: SimWorld, playerId: PlayerId, bonus: Partial<MetaBonus>): void;

function setPlatformFrozen(w: PlatformWorld, frozen: boolean): void;

function setPlatformLevel(w: PlatformWorld, index: number): void;

function setXpBoost(world: SimWorld, multiplier: number): void;

function simPaused(world: SimWorld): boolean;

function simRandom(world: SimWorld): number;

function slotLevel(weapons: number, slot: number): number;

function slotWeapon(weapons: number, slot: number): number;

function snapshotBaseTick(bytes: Uint8Array): number | null;

function spawnEnemy(world: SimWorld, type: number, x: number, z: number): NetId;

function spawnEnemyScaled(world: SimWorld, type: number, x: number, z: number, scale: SpawnScale): NetId;

function spawnPickupAt(world: SimWorld, index: number, x: number, z: number): NetId;

function spawnRingPoint(world: SimWorld, radius: number): [number, number];

function statLevel(stats: number, i: number): number;

function step(world: SimWorld, inputs: TickInputs): StepResult;

function teleWord(kind: number, progress: number, angleOrRadius: number, isRadius?: boolean): number;

function viewEdge(world: SimWorld, heading: number): number;

function weaponModsFor(config: ResolvedSimConfig, stats: number): { might: number; haste: number; area: number; amount: number; };

function xpForLevel(config: ResolvedSimConfig, level: number): number;

class FixedStepper {
  constructor(tickRate: number, maxTicksPerAdvance?: number);
  readonly tickRate: number;
  readonly tickMs: number;
  readonly maxTicksPerAdvance: number;
  advance(elapsedMs: number): StepperAdvance;
  reset(): void;
}

class PhysicsWorld {
  constructor(raw: RapierWorld, tickRate: number, gravity: Vec3);
  readonly dt: number;
  get tick(): number;
  get bodyCount(): number;
  addBody(desc: BodyDesc): BodyId;
  addStaticBox(halfExtents: Vec3, position: Vec3, opts?: Omit<BodyDesc, "type" | "shape" | "position">): BodyId;
  addTrigger(shape: ShapeDesc, position: Vec3, opts?: Omit<BodyDesc, "type" | "shape" | "position" | "sensor">): BodyId;
  removeBody(id: BodyId): void;
  has(id: BodyId): boolean;
  userData(id: BodyId): number;
  bodyType(id: BodyId): BodyType;
  bodyIds(): BodyId[];
  position(id: BodyId): Vec3;
  rotation(id: BodyId): Quat;
  velocity(id: BodyId): Vec3;
  angularVelocity(id: BodyId): Vec3;
  mass(id: BodyId): number;
  setPosition(id: BodyId, p: Vec3): void;
  setRotation(id: BodyId, q: Quat): void;
  setLinearVelocity(id: BodyId, v: Vec3): void;
  setAngularVelocity(id: BodyId, v: Vec3): void;
  applyImpulse(id: BodyId, impulse: Vec3): void;
  applyForce(id: BodyId, force: Vec3): void;
  applyKnockback(id: BodyId, from: Vec3, strength: number, opts?: KnockbackOptions): void;
  setKinematicTarget(id: BodyId, p: Vec3, q?: Quat): void;
  wake(id: BodyId): void;
  sleep(id: BodyId): void;
  isSleeping(id: BodyId): boolean;
  addJoint(desc: JointDesc): JointId;
  removeJoint(id: JointId): void;
  addCharacter(desc: CharacterDesc): BodyId;
  characterState(id: BodyId): CharacterState;
  setCharacterState(id: BodyId, s: CharacterState): void;
  isCharacter(id: BodyId): boolean;
  step(inputs?: ReadonlyMap<BodyId, CharacterInput>): PhysicsStepResult;
  raycast(origin: Vec3, dir: Vec3, maxDist: number, opts?: QueryOptions): RayHit | null;
  raycastAll(origin: Vec3, dir: Vec3, maxDist: number, opts?: QueryOptions): RayHit[];
  shapeCast(shape: ShapeDesc, from: Vec3, dir: Vec3, maxDist: number, opts?: QueryOptions & { rotation?: Quat; }): ShapeHit | null;
  overlap(shape: ShapeDesc, position: Vec3, opts?: QueryOptions & { rotation?: Quat; }): BodyId[];
  // ... 5 more lines in the source

const ALL_LAYERS: 65535;

const ARENA_BOLT_RADIUS: 0.2;

const ARENA_HITBOX_PAD: 0.2;

const ARENA_SPAWN_CLEAR: 12;

const BOT_PLAYER_BASE: 65280;

const Button: { readonly Jump: number; readonly Fire: number; readonly Alt: number; readonly Use: number; readonly Sprint: number; readonly Choice1: number; readonly Choice2: number; readonly Choice3: number; readonly Reroll: number; readonly Skip: number; readonly Ready: number; };

const DEFAULT_ARENA: ArenaConfig;

const DEFAULT_ARENA_RULES: ArenaRules;

const DEFAULT_COOP: CoopRules;

const DEFAULT_ENEMIES: EnemyRules;

const DEFAULT_KART_TUNING: KartTuning;

const DEFAULT_PLATFORM_TUNING: PlatformTuning;

const DEFAULT_PLAYER: PlayerRules;

const DEFAULT_PROGRESSION: ProgressionRules;

const DEFAULT_TICK_RATE: 30;

const DEFAULT_VIEW: ViewRules;

const EntityFlag: { readonly Grounded: number; readonly Dead: number; readonly Downed: number; readonly Dashing: number; readonly Solo: number; readonly Shielded: number; readonly Elite: number; readonly Hostile: number; };

const EntityKind: { readonly Player: 1; readonly Enemy: 2; readonly Projectile: 3; readonly Pickup: 4; };

const INPUT_BYTES: 15;

const KART_COIN_CAP: 10;

const KART_COIN_SPEED: 0.01;

const KART_MAX_COINS: 62;

const KART_RADIUS: 0.9;

const KART_STAT_DOC: Readonly<Record<"magnet" | "speed" | "armor" | "might" | "haste", string>>;

const KART_STATS: readonly ["speed", "haste", "might", "armor", "magnet"];

const KartFlag: { readonly Drifting: number; readonly DriftRight: number; readonly OnGrass: number; readonly Finished: number; readonly Frozen: number; readonly Bot: number; readonly Bumped: number; readonly Boosting: number; };

const KEEPER_MASK: number;

const KEEPER_SHIFT: 11;

const Layer: { readonly Level: number; readonly Player: number; readonly Enemy: number; readonly Projectile: number; readonly Pickup: number; readonly Prop: number; readonly Trigger: number; readonly Debris: number; readonly User1: number; readonly User2: number; readonly User3: number; readonly User4: number; readonly User5: number; readonly User6: number; readonly User7: number; readonly User8: number; };

const META_MAX_PER_STAT: 0.15;

const META_MAX_TOTAL: 0.3;

const METEOR_FALL_SECONDS: 0.6;

const ORBIT_BLADE_RADIUS: 0.45;

const ORBIT_HIT_EVERY: 8;

const PICKUP_SPECIAL: 16;

const PLAT_HALF_W: 0.34;

const PLAT_HEIGHT: 1.4;

const PLAT_MAX_COINS: 62;

const PLAT_STAT_DOC: Readonly<Record<"magnet" | "speed" | "amount" | "maxHealth" | "haste", string>>;

const PLAT_STATS: readonly ["speed", "amount", "magnet", "maxHealth", "haste"];

const PlatFlag: { readonly Grounded: number; readonly FacingLeft: number; readonly Rising: number; readonly Dead: number; readonly Finished: number; readonly Frozen: number; readonly DashReady: number; readonly Bot: number; readonly OnMover: number; };

const POSITION_SCALE: 1024;

const ROLE_DEFAULTS: { readonly runner: { readonly lead: 0.5; }; readonly charger: { readonly range: 6; readonly windup: 0.55; readonly act: 0.6; readonly recover: 1; readonly cooldown: 2.5; readonly speed: 3.4; }; readonly ranged: { readonly range: 10; readonly windup: 0.3; readonly cooldown: 2.6; readonly speed: 7; }; readonly bomber: { readonly range: 1.8; readonly windup: 1; readonly radius: 2.5; readonly damage: 1.4; }; readonly shielder: { readonly cooldown: 6; readonly windup: 0.8; readonly radius: 8; readonly count: 6; readonly share: 0.35; readonly seconds: 8; }; readonly healer: { readonly cooldown: 3.5; /* ... */;

const SNAPSHOT_VERSION: 2;

const Telegraph: { readonly None: 0; readonly Circle: 1; readonly Lane: 2; readonly Aura: 3; };

const VELOCITY_SCALE: 1024;

const YAW_UNITS: 65536;

interface ArenaConfig {
  readonly halfExtent: number;
  readonly wallHeight: number;
  readonly pillars: readonly Pillar[];
  readonly walls?: readonly WallBox[];
  readonly floors?: readonly WallBox[];
  readonly spawn: Vec3;
}

interface ArenaHitbox {
  readonly netId: NetId;
  readonly owner: PlayerId;
  readonly x: number;
  readonly z: number;
  readonly r: number;
}

interface ArenaRules {
  readonly enabled: boolean;
  readonly authority: boolean;
  readonly externalHitscan: boolean;
  readonly respawnTicks: number;
  readonly spawnIframeTicks: number;
  readonly spawns: readonly (readonly [number, number])[];
  readonly dropHeal: number;
  readonly pickupTicks: number;
}

interface BeamShot {
  readonly shooter: PlayerId;
  readonly x: number;
  readonly z: number;
  readonly dx: number;
  readonly dz: number;
  readonly range: number;
  readonly damage: number;
  readonly knockback: number;
}

interface BodyDesc {
  readonly type: BodyType;
  readonly shape: ShapeDesc;
  readonly position?: Vec3;
  readonly rotation?: Quat;
  readonly mass?: number;
  readonly density?: number;
  readonly friction?: number;
  readonly restitution?: number;
  readonly linearDamping?: number;
  readonly angularDamping?: number;
  readonly gravityScale?: number;
  readonly layer?: number;
  readonly mask?: number;
  readonly sensor?: boolean;
  readonly ccd?: boolean;
  readonly lockRotations?: boolean;
  readonly linearVelocity?: Vec3;
  readonly angularVelocity?: Vec3;
  readonly userData?: number;
}

type BodyId = number;

type BodyType = "dynamic" | "kinematic" | "static";

type BossAttack = "slam" | "dash" | "leap" | "rain" | "ring" | "fan" | "summon";

interface BossPattern {
  readonly attacks: readonly BossAttack[];
  readonly enrageAt: number;
  readonly summon?: number;
  readonly mini?: boolean;
}

type ButtonBit = (typeof Button)[keyof typeof Button];

interface CharacterDef {
  readonly weapon: number;
  readonly stat: number;
}

interface CharacterDesc {
  readonly position: Vec3;
  readonly radius?: number;
  readonly halfHeight?: number;
  readonly layer?: number;
  readonly mask?: number;
  readonly offset?: number;
  readonly maxSlopeClimb?: number;
  readonly minSlopeSlide?: number;
  readonly stepHeight?: number;
  readonly stepWidth?: number;
  readonly stepOverDynamic?: boolean;
  readonly snapToGround?: number;
  readonly maxSpeed?: number;
  readonly groundAccel?: number;
  readonly groundDecel?: number;
  readonly airAccel?: number;
  readonly airDecel?: number;
  readonly jumpVelocity?: number;
  readonly jumpCut?: number;
  readonly gravityScale?: number;
  readonly terminalVelocity?: number;
  readonly coyoteTicks?: number;
  readonly jumpBufferTicks?: number;
  readonly dashTicks?: number;
  readonly dashSpeed?: number;
  readonly dashCooldownTicks?: number;
  readonly dashBufferTicks?: number;
  readonly dashInvulnerable?: boolean;
  readonly pushBodies?: boolean;
  readonly mass?: number;
  readonly userData?: number;
}

interface CharacterInput {
  readonly moveX: number;
  readonly moveZ: number;
  readonly jump?: boolean;
  readonly dash?: boolean;
}

interface CharacterReport {
  readonly id: BodyId;
  readonly grounded: boolean;
  readonly landed: boolean;
  readonly jumped: boolean;
  readonly dashed: boolean;
  readonly hitCeiling: boolean;
  readonly groundNormal: Vec3;
}

interface CharacterState {
  x: number;
  y: number;
  z: number;
  vx: number;
  vy: number;
  vz: number;
  grounded: boolean;
  coyote: number;
  jumpBuffer: number;
  jumping: boolean;
  dashTicks: number;
  dashCooldown: number;
  dashBuffer: number;
  dashX: number;
  dashZ: number;
  facingX: number;
  facingZ: number;
  invulnerable: boolean;
  buttons: number;
  groundNormalX: number;
  groundNormalY: number;
  groundNormalZ: number;
}

interface ContentConfig {
  readonly enemyTypes?: readonly EnemyTypeDef[];
  readonly weapons?: readonly WeaponDef[];
  readonly stats?: readonly StatDef[];
  readonly progression?: Partial<ProgressionRules>;
  readonly coop?: Partial<CoopRules>;
  readonly arena?: Partial<ArenaRules>;
  readonly view?: ViewRules;
  readonly pickups?: readonly PickupTypeDef[];
  readonly loot?: { readonly chest: number; readonly heal: number; readonly vacuum: number; readonly bossChest?: number };
  readonly mergeGemsAbove?: number;
  readonly characters?: readonly CharacterDef[];
}

interface CoopRules {
  readonly downedTicks: number;
  readonly reviveTicks: number;
  readonly reviveRadius: number;
  readonly reviveHealth: number;
  readonly iframeTicks: number;
  readonly corpseTicks: number;
  readonly dashTicks: number;
  readonly dashSpeed: number;
  readonly dashCooldownTicks: number;
  readonly dashBufferTicks: number;
  readonly hitIframeTicks: number;
  readonly pauseSolo: boolean;
  readonly soloFromFlag: boolean;
  readonly choicePulseRadius: number;
  readonly choicePulseIframeTicks: number;
  readonly reviveBuffTicks: number;
  readonly reviveBuffMight: number;
  readonly reviveBuffSpeed: number;
  readonly crawlSpeed: number;
  readonly selfRevives: number;
  readonly selfReviveDelayTicks: number;
  readonly respawnTicks: number;
  readonly risePulseRadius: number;
}

interface EdgeSpawnOptions {
  readonly heading?: number;
  readonly spread?: number;
  readonly margin?: number;
  readonly radius?: number;
  readonly relative?: "ahead" | "behind";
}

type EnemyAi =
  | "chase"
  | "idle"
  | "runner"
  | "charger"
  | "ranged"
  | "bomber"
  | "shielder"
  | "healer"
  | "summoner"
  | "flee"
  | "wander";

interface EnemyAttack {
  readonly damage?: number;
  readonly range?: number;
  readonly windupTicks?: number;
  readonly cooldownTicks?: number;
  readonly speed?: number;
  readonly radius?: number;
  readonly summon?: number;
  readonly count?: number;
}

interface EnemyRules {
  readonly target: number;
  readonly spawnPerTick: number;
  readonly spawnRadius: number;
  readonly speed: number;
  readonly radius: number;
  readonly maxHealth: number;
  readonly contactDamage: number;
  readonly contactCooldownTicks: number;
}

interface EnemyTypeDef {
  readonly health: number;
  readonly speed: number;
  readonly radius: number;
  readonly damage: number;
  readonly xp: number;
  readonly boss?: boolean;
  readonly mass?: number;
  readonly ai?: EnemyAi;
  readonly attack?: EnemyAttack;
  readonly split?: { readonly type: number; readonly count: number };
  readonly pattern?: BossPattern;
  readonly drops?: readonly { readonly pickup: number; readonly chance: number }[];
  readonly prop?: boolean;
}

type EntityKindId = (typeof EntityKind)[keyof typeof EntityKind];

interface EntityState {
  netId: NetId;
  kind: EntityKindId;
  owner: PlayerId;
  px: number;
  py: number;
  pz: number;
  vx: number;
  vy: number;
  vz: number;
  yaw: number;
  health: number;
  flags: number;
  ack: number;
  cooldown: number;
  buttons: number;
  timers: number;
  type: number;
  value: number;
  level: number;
  xp: number;
  weapons: number;
  wcd: number;
  stats: number;
  choices: number;
  bleed: number;
  revive: number;
  iframes: number;
  dash: number;
}

type HitSource = "contact" | "charge" | "blast" | "projectile" | "slam" | "hazard";

interface InputCommand {
  seq: number;
  tick: number;
  moveX: number;
  moveZ: number;
  yaw: number;
  buttons: number;
}

interface JointDesc {
  readonly kind: JointKind;
  readonly a: BodyId;
  readonly b: BodyId;
  readonly anchorA?: Vec3;
  readonly anchorB?: Vec3;
  readonly axis?: Vec3;
}

type JointId = number;

type JointKind = "fixed" | "ball" | "hinge" | "slider";

interface Kart {
  readonly id: number;
  x: number;
  z: number;
  yaw: number;
  vx: number;
  vz: number;
  flags: number;
  charge: number;
  boost: number;
  seg: number;
  lap: number;
  cps: number;
  coinsLo: number;
  coinsHi: number;
  finishTick: number;
  stats: number;
  cosmetic: number;
  slot: number;
  ack: number;
  held: number;
}

interface KartConfig {
  readonly tickRate: number;
  readonly tracks: readonly KartTrackDef[];
  readonly tuning?: Partial<KartTuning>;
  readonly statSteps?: readonly number[];
  readonly authority?: boolean;
}

type KartEvent =
  | { readonly type: "coin"; readonly kart: number; readonly index: number }
  | { readonly type: "lap"; readonly kart: number; readonly lap: number }
  | { readonly type: "finish"; readonly kart: number; readonly tick: number }
  | { readonly type: "turbo"; readonly kart: number; readonly tier: number }
  | { readonly type: "pad"; readonly kart: number }
  | { readonly type: "wall"; readonly kart: number; readonly speed: number }
  | { readonly type: "bump"; readonly kart: number; readonly other: number };

type KartStat = (typeof KART_STATS)[number];

interface KartTrack {
  readonly def: KartTrackDef;
  readonly x: Float64Array;
  readonly z: Float64Array;
  readonly tx: Float64Array;
  readonly tz: Float64Array;
  readonly dist: Float64Array;
  readonly length: number;
  readonly count: number;
  readonly half: number;
  readonly wall: number;
  readonly pads: readonly { readonly x: number; readonly z: number; readonly tx: number; readonly tz: number }[];
  readonly coinAt: readonly (readonly [number, number])[];
  readonly grid: readonly (readonly [number, number, number])[];
}

interface KartTrackDef {
  readonly points: readonly (readonly [number, number])[];
  readonly width: number;
  readonly laps: number;
  readonly boosts: readonly (readonly [number, number])[];
  readonly coins: readonly (readonly [number, number])[];
  readonly verge?: number;
}

interface KartTuning {
  readonly topSpeed: number;
  readonly accel: number;
  readonly brake: number;
  readonly drag: number;
  readonly turn: number;
  readonly grip: number;
  readonly driftGrip: number;
  readonly grass: number;
  readonly boostSpeed: number;
  readonly turbo: readonly [number, number, number];
  readonly turboAt: readonly [number, number, number];
  readonly padSeconds: number;
  readonly coinRadius: number;
}

interface KartWire {
  readonly id: number;
  readonly x: number;
  readonly z: number;
  readonly yaw: number;
  readonly vx: number;
  readonly vz: number;
  readonly flags: number;
  readonly timers: number;
  readonly track: number;
  readonly coinsLo: number;
  readonly coinsHi: number;
  readonly finishTick: number;
  readonly stats: number;
  readonly cosmetic: number;
  readonly clock: number;
}

interface KartWorld {
  readonly tickRate: number;
  readonly dt: number;
  readonly tracks: readonly KartTrack[];
  track: KartTrack;
  trackIndex: number;
  readonly tuning: KartTuning;
  readonly statSteps: readonly number[];
  readonly authority: boolean;
  tick: number;
  readonly karts: Map<number, Kart>;
}

interface KnockbackOptions {
  readonly lift?: number;
  readonly byMass?: boolean;
}

type LayerBit = (typeof Layer)[LayerName];

type LayerName = keyof typeof Layer;

interface MetaBonus {
  speed: number;
  maxHealth: number;
  magnet: number;
  might: number;
  haste: number;
  area: number;
}

type NetId = number;

interface PhysicsEvent {
  readonly type: PhysicsEventType;
  readonly a: BodyId;
  readonly b: BodyId;
}

type PhysicsEventType = "contact.start" | "contact.end" | "trigger.enter" | "trigger.exit";

interface PhysicsOptions {
  readonly gravity?: Vec3;
  readonly tickRate?: number;
}

interface PhysicsStepResult {
  readonly tick: number;
  readonly events: readonly PhysicsEvent[];
  readonly characters: readonly CharacterReport[];
}

type PickupEffect = "heal" | "vacuum" | "bomb" | "chest";

interface PickupTypeDef {
  readonly effect: PickupEffect;
  readonly amount: number;
  readonly evolve?: boolean;
}

interface Pillar {
  readonly x: number;
  readonly z: number;
  readonly radius: number;
  readonly height: number;
}

type PlatBox = readonly [number, number, number, number];

interface PlatformConfig {
  readonly tickRate: number;
  readonly levels: readonly PlatformLevel[];
  readonly tuning?: Partial<PlatformTuning>;
  readonly statSteps?: readonly number[];
}