@series-inc/rundot-kinetix 0.0.0-bootstrap.0

package/native/kinetix-fixed1000-native-profile.cpp

@@ -0,0 +1,777 @@
+#include "kinetix-installed-fixed1000-data.hpp"
+#include "kinetix-fixed1000-native-profile.hpp"
+#include "component_runtime.hpp"
+// The render configuration consumes a render-records encoder and a camera-follow
+// core that the CORE does not own — the host supplies them on its include path.
+// This package builds only the simulation configuration, where the macro below is
+// defined and these are compiled out; a host that wants the render configuration
+// (today: the console lab's Metal player) must -I the directory holding them.
+#ifndef KINETIX_FIXED1000_SIM_ONLY
+#include "actor_follow_core.hpp"
+#include "render_records_encoder.hpp"
+#endif
+#include "kinetix-fixed1000-physics.hpp"
+
+#include <algorithm>
+#include <array>
+#include <cmath>
+#include <cstdint>
+#include <cstdio>
+#include <cstdlib>
+#include <fstream>
+#include <limits>
+#include <map>
+#include <memory>
+#include <mutex>
+#include <sstream>
+#include <string>
+#include <utility>
+#include <vector>
+
+namespace {
+using namespace rundot::kinetix::fixed1000_data;
+using I = std::int64_t;
+constexpr int kLobby = 0;
+constexpr int kCountdown = 1;
+constexpr int kActive = 2;
+constexpr int kFinished = 3;
+
+std::uint32_t readU32(std::istream& input) {
+  std::uint32_t value = 0;
+  for (int shift = 0; shift < 32; shift += 8) {
+    const int byte = input.get();
+    if (byte == EOF) std::abort();
+    value |= static_cast<std::uint32_t>(static_cast<std::uint8_t>(byte)) << shift;
+  }
+  return value;
+}
+
+I readI64(std::istream& input) {
+  std::uint64_t value = 0;
+  for (int shift = 0; shift < 64; shift += 8) {
+    const int byte = input.get();
+    if (byte == EOF) std::abort();
+    value |= static_cast<std::uint64_t>(static_cast<std::uint8_t>(byte)) << shift;
+  }
+  return static_cast<I>(value);
+}
+
+std::string readString(std::istream& input) {
+  const std::uint32_t length = readU32(input);
+  std::string value(length, '\0');
+  input.read(value.data(), static_cast<std::streamsize>(length));
+  if (!input) std::abort();
+  return value;
+}
+
+std::vector<I> readI64Vector(std::istream& input) {
+  std::vector<I> values(readU32(input));
+  for (I& value : values) value = readI64(input);
+  return values;
+}
+
+void loadInstalledProfileData(std::istream& input) {
+  std::array<char, 8> magic{};
+  input.read(magic.data(), static_cast<std::streamsize>(magic.size()));
+  if (std::string(magic.data(), magic.size()) != "KFXDATA1") std::abort();
+  kTrack = readString(input);
+  const std::array<I*, 57> scalars = {
+    &kScale, &kSlotCount, &kHumanCount, &kInitialPhase,
+    &kCellRaw, &kGridScale, &kFinishTypeId,
+    &kMaxSpeed, &kAccelRate, &kBrakeRate, &kMaxReverse, &kTurnPerTick,
+    &kGripMin, &kSlipSpeed, &kTractionSlow, &kTractionFast, &kDriftSteer, &kStopDeadband,
+    &kWallHalfThick, &kWallLateral, &kWallY, &kWallHalfHeightRaw, &kHalfPiFixed,
+    &kTwoPiFixed, &kOuterArcSegments, &kInnerArcSegments, &kColliderLayer, &kColliderMask,
+    &kArenaHalfUnits, &kArenaWallThick, &kArenaWallHalfHeight, &kArenaWallY,
+    &kArenaCenterX, &kArenaCenterZ, &kScatterCols, &kScatterSpacing,
+    &kGridSpawnLateral, &kGridSpawnRowBack, &kGridSpawnMinSlots, &kGridSpawnMaxSlots,
+    &kWaypointLookahead, &kWaypointSteerGain, &kWaypointSharpTurnThrottle,
+    &kTotalLaps, &kMaxRaceFrames, &kNoTeleport, &kMaxRequiredBits,
+    &kLobbyInitialFrames, &kLobbyExtendFrames, &kLobbyMaxFrames, &kCountdownFrames,
+    &kResultsHoldFrames, &kMaxSlotsAutoStart, &kBodyRadius, &kBodyY, &kBodyLayer, &kBodyMask,
+  };
+  for (I* scalar : scalars) *scalar = readI64(input);
+  kCells.resize(readU32(input));
+  for (Cell& cell : kCells) cell = {readI64(input), readI64(input), readI64(input), readI64(input)};
+  kCornerTypeIds = readI64Vector(input);
+  kPassThroughTypeIds = readI64Vector(input);
+  kWallBodyPrefix = readString(input);
+  kCarBodyPrefix = readString(input);
+  if (readU32(input) != kArenaBodyIds.size()) std::abort();
+  for (std::string& id : kArenaBodyIds) id = readString(input);
+  if (input.get() != EOF || kScale <= 0 || kSlotCount < 1
+    || static_cast<std::size_t>(kSlotCount) > kMaxSlots) std::abort();
+}
+
+std::string readKinetixProductsProfile(const std::string& path) {
+  std::ifstream input(path, std::ios::binary);
+  if (!input) std::abort();
+  std::array<char, 8> magic{};
+  input.read(magic.data(), static_cast<std::streamsize>(magic.size()));
+  if (std::string(magic.data(), magic.size()) != "KNATIVE1") std::abort();
+  const std::string sourceDigest = readString(input);
+  const std::string simulationDigest = readString(input);
+  if (sourceDigest.size() != 64 || simulationDigest.size() != 64) std::abort();
+  const std::array<std::string, 5> ids = {
+    "slot-input-resolution", "vehicle-drive-body-build", "vehicle-physics-step",
+    "vehicle-lap-finish", "match-phase-transition",
+  };
+  const std::array<std::string, 5> phases = {
+    "fixed-simulation", "fixed-simulation", "fixed-simulation",
+    "fixed-simulation", "post-simulation",
+  };
+  const std::array<I, 5> phaseIndices = {1, 1, 1, 1, 2};
+  const std::array<I, 5> orders = {100, 200, 300, 400, 500};
+  if (readU32(input) != ids.size()) std::abort();
+  for (std::size_t index = 0; index < ids.size(); index += 1) {
+    if (readString(input) != ids[index] || readString(input) != phases[index]
+      || readI64(input) != phaseIndices[index] || readI64(input) != orders[index]) std::abort();
+  }
+  const std::string profileDigest = readString(input);
+  const std::uint32_t profileLength = readU32(input);
+  std::string profile(profileLength, '\0');
+  input.read(profile.data(), static_cast<std::streamsize>(profile.size()));
+  if (!input || input.get() != EOF || profileDigest.size() != 64
+    || rundot::sha256Hex(reinterpret_cast<const std::uint8_t*>(profile.data()), profile.size()) != profileDigest) std::abort();
+  return profile;
+}
+
+void activateInstalledProfile(const std::string& profile) {
+  std::istringstream profileInput(profile, std::ios::binary);
+  loadInstalledProfileData(profileInput);
+}
+
+std::mutex kInstalledProfileMutex;
+
+void loadKinetixProducts(const std::string& path) {
+  const std::string profile = readKinetixProductsProfile(path);
+  std::scoped_lock lock(kInstalledProfileMutex);
+  activateInstalledProfile(profile);
+}
+
+I mul(I a, I b) { return (a * b) / kScale; }
+I divFixed(I a, I b) { return b == 0 ? 0 : (a * kScale) / b; }
+I clamp(I value, I low, I high) { return value < low ? low : value > high ? high : value; }
+I absFixed(I value) { return value < 0 ? -value : value; }
+I signFixed(I value) { return value > 0 ? 1 : value < 0 ? -1 : 0; }
+I lerp(I a, I b, I t) { return a + mul(b - a, t); }
+
+I sinQuarter(I x) {
+  const I u = divFixed(x, kScale / 4);
+  const I u2 = mul(u, u);
+  const I u3 = mul(u2, u);
+  const I u5 = mul(u3, u2);
+  return mul(1571, u) + mul(-646, u3) + mul(80, u5);
+}
+
+I fsin(I turns) {
+  const I t = ((turns % kScale) + kScale) % kScale;
+  if (t < kScale / 4) return clamp(sinQuarter(t), -kScale, kScale);
+  if (t < kScale / 2) return clamp(sinQuarter(kScale / 2 - t), -kScale, kScale);
+  if (t < 3 * kScale / 4) return clamp(-sinQuarter(t - kScale / 2), -kScale, kScale);
+  return clamp(-sinQuarter(kScale - t), -kScale, kScale);
+}
+
+I fcos(I turns) { return fsin(turns + kScale / 4); }
+I orientTurns(I orientation) { return std::array<I, 4>{0, kScale / 4, kScale / 2, 3 * kScale / 4}[orientation]; }
+
+struct Pose { I x, z, yaw; };
+struct BodyFixed {
+  std::string id;
+  bool dynamic;
+  I x, y, z, vx, vy, vz;
+  bool sphere;
+  I radius, halfX, halfY, halfZ;
+  int layer;
+  unsigned mask;
+};
+
+bool contains(const std::vector<I>& values, I target) {
+  return std::find(std::begin(values), std::end(values), target) != std::end(values);
+}
+
+std::vector<BodyFixed> cookTrackWalls() {
+  const I cellHalf = kCellRaw / 2;
+  const I halfThick = mul(kWallHalfThick, kGridScale);
+  const I halfHeight = mul(kWallHalfHeightRaw, kGridScale);
+  const I halfLength = mul(cellHalf, kGridScale);
+  const I arcSpan = -(kScale / 4);
+  const I outerRadius = 2 * cellHalf - kWallHalfThick;
+  const I outerHalfLength = mul((mul(outerRadius, kHalfPiFixed) / (kOuterArcSegments * 2)), kGridScale);
+  const I innerRadius = kWallHalfThick;
+  const I innerHalfLength = mul((mul(innerRadius, kHalfPiFixed) / (kInnerArcSegments * 2)), kGridScale);
+  std::vector<BodyFixed> bodies;
+  int nextId = 0;
+  auto box = [&](I x, I z, I hx, I hz) {
+    bodies.push_back({std::string(kWallBodyPrefix) + std::to_string(nextId++), false,
+      x, kWallY, z, 0, 0, 0, false, 0, hx, halfHeight, hz,
+      static_cast<int>(kColliderLayer), static_cast<unsigned>(kColliderMask)});
+  };
+  auto arc = [&](I centerX, I centerZ, I start, I radius, I segments, I segmentHalfLength) {
+    for (I index = 0; index < segments; index += 1) {
+      const I fraction = ((2 * index + 1) * kScale) / (2 * segments);
+      const I mid = start + mul(fraction, arcSpan);
+      box(centerX + mul(mul(radius, fcos(mid)), kGridScale),
+          centerZ + mul(mul(radius, fsin(mid)), kGridScale), halfThick, segmentHalfLength);
+    }
+  };
+  for (const Cell& cell : kCells) {
+    if (contains(kPassThroughTypeIds, cell.typeId)) continue;
+    const I cx = mul((2 * cell.gridX + 1) * cellHalf, kGridScale);
+    const I cz = mul((2 * cell.gridZ + 1) * cellHalf, kGridScale);
+    const I turns = orientTurns(cell.orientation);
+    const I cosine = fcos(turns);
+    const I sine = fsin(turns);
+    if (contains(kCornerTypeIds, cell.typeId)) {
+      const I centerX = cx + mul(mul(-cellHalf, cosine) + mul(cellHalf, sine), kGridScale);
+      const I centerZ = cz + mul(mul(cellHalf, sine) + mul(cellHalf, cosine), kGridScale);
+      arc(centerX, centerZ, -turns, outerRadius, kOuterArcSegments, outerHalfLength);
+      arc(centerX, centerZ, -turns, innerRadius, kInnerArcSegments, innerHalfLength);
+    } else {
+      for (I side : {-1, 1}) {
+        const I lateral = side * kWallLateral;
+        box(cx + mul(mul(lateral, cosine), kGridScale),
+            cz + mul(mul(-lateral, sine), kGridScale), halfThick, halfLength);
+      }
+    }
+  }
+  return bodies;
+}
+
+std::vector<BodyFixed> cookArenaWalls() {
+  const I half = kArenaHalfUnits * kScale;
+  const I span = half + kArenaWallThick;
+  auto wall = [&](int id, I x, I z, I hx, I hz) {
+    return BodyFixed{std::string(kArenaBodyIds[id]), false, x, kArenaWallY, z, 0, 0, 0,
+      false, 0, hx, kArenaWallHalfHeight, hz, static_cast<int>(kColliderLayer), static_cast<unsigned>(kColliderMask)};
+  };
+  return {
+    wall(0, kArenaCenterX, kArenaCenterZ - half, span, kArenaWallThick),
+    wall(1, kArenaCenterX, kArenaCenterZ + half, span, kArenaWallThick),
+    wall(2, kArenaCenterX - half, kArenaCenterZ, kArenaWallThick, span),
+    wall(3, kArenaCenterX + half, kArenaCenterZ, kArenaWallThick, span),
+  };
+}
+
+const Cell* finishCell() {
+  for (const Cell& cell : kCells) if (cell.typeId == kFinishTypeId) return &cell;
+  return nullptr;
+}
+
+std::array<Pose, kMaxSlots> gridSpawns() {
+  const Cell* finish = finishCell();
+  if (!finish) std::abort();
+  const I half = kCellRaw / 2;
+  const I baseX = mul((2 * finish->gridX + 1) * half, kGridScale);
+  const I baseZ = mul((2 * finish->gridZ + 1) * half, kGridScale);
+  const I turns = orientTurns(finish->orientation);
+  const I cosine = fcos(turns);
+  const I sine = fsin(turns);
+  std::array<Pose, kMaxSlots> poses{};
+  for (I slot = 0; slot < kSlotCount; slot += 1) {
+    const I lateral = (slot % 2 == 0 ? -1 : 1) * kGridSpawnLateral;
+    const I back = -(slot / 2) * kGridSpawnRowBack;
+    poses[slot] = {baseX + mul(lateral, cosine) - mul(back, sine),
+      baseZ + mul(lateral, sine) + mul(back, cosine), turns};
+  }
+  return poses;
+}
+
+std::array<Pose, kMaxSlots> scatterSpawns() {
+  std::array<Pose, kMaxSlots> poses{};
+  for (I slot = 0; slot < kSlotCount; slot += 1) {
+    const I columnNumerator = 2 * (slot % kScatterCols) - (kScatterCols - 1);
+    poses[slot] = {kArenaCenterX + columnNumerator * kScatterSpacing / 2,
+      kArenaCenterZ + (slot / kScatterCols - 1) * kScatterSpacing, 0};
+  }
+  return poses;
+}
+
+struct WaypointRing { std::vector<I> x, z; };
+I upperHalf(I x, I z) { return z < 0 || (z == 0 && x < 0) ? 1 : 0; }
+
+WaypointRing buildWaypointRing() {
+  struct Point { I x, z; };
+  std::vector<Point> points;
+  I sumX = 0;
+  I sumZ = 0;
+  for (const Cell& cell : kCells) {
+    const I x = mul((2 * cell.gridX + 1) * (kCellRaw / 2), kGridScale);
+    const I z = mul((2 * cell.gridZ + 1) * (kCellRaw / 2), kGridScale);
+    points.push_back({x, z});
+    sumX += x;
+    sumZ += z;
+  }
+  const I centerX = sumX / static_cast<I>(points.size());
+  const I centerZ = sumZ / static_cast<I>(points.size());
+  for (Point& point : points) { point.x -= centerX; point.z -= centerZ; }
+  std::stable_sort(points.begin(), points.end(), [](const Point& a, const Point& b) {
+    const I halfA = upperHalf(a.x, a.z);
+    const I halfB = upperHalf(b.x, b.z);
+    if (halfA != halfB) return halfA < halfB;
+    const I cross = a.x * b.z - a.z * b.x;
+    if (cross != 0) return cross > 0;
+    return a.x * a.x + a.z * a.z < b.x * b.x + b.z * b.z;
+  });
+  WaypointRing ring;
+  for (const Point& point : points) { ring.x.push_back(point.x + centerX); ring.z.push_back(point.z + centerZ); }
+  return ring;
+}
+
+I approximateMagnitude(I x, I z) {
+  const I ax = absFixed(x);
+  const I az = absFixed(z);
+  const I high = std::max(ax, az);
+  const I low = std::min(ax, az);
+  return high + low / 2;
+}
+
+struct Drive { I steer, throttle; };
+Drive waypointDrive(const WaypointRing& ring, I x, I z, I yaw) {
+  std::size_t nearest = 0;
+  I best = std::numeric_limits<I>::max();
+  for (std::size_t index = 0; index < ring.x.size(); index += 1) {
+    const I dx = ring.x[index] - x;
+    const I dz = ring.z[index] - z;
+    const I distance = dx * dx + dz * dz;
+    if (distance < best) { best = distance; nearest = index; }
+  }
+  const std::size_t target = (nearest + static_cast<std::size_t>(kWaypointLookahead)) % ring.x.size();
+  const I dx = ring.x[target] - x;
+  const I dz = ring.z[target] - z;
+  const I forwardX = fsin(yaw);
+  const I forwardZ = fcos(yaw);
+  const I magnitude = approximateMagnitude(dx, dz);
+  if (magnitude == 0) return {0, kScale};
+  const I lateral = divFixed(mul(forwardZ, dx) - mul(forwardX, dz), magnitude);
+  const I forward = divFixed(mul(forwardX, dx) + mul(forwardZ, dz), magnitude);
+  return {clamp(mul(kWaypointSteerGain, lateral), -kScale, kScale), forward > 0 ? kScale : kWaypointSharpTurnThrottle};
+}
+
+struct LapInfo {
+  bool enabled = false;
+  I centerX = 0, centerZ = 0, forwardX = 0, forwardZ = 0, rightX = 0, rightZ = 0;
+  std::map<std::pair<I, I>, int> bits;
+  I mask = 0;
+};
+
+LapInfo buildLapInfo() {
+  const Cell* finish = finishCell();
+  LapInfo info;
+  if (!finish) return info;
+  info.enabled = true;
+  info.centerX = mul((2 * finish->gridX + 1) * (kCellRaw / 2), kGridScale);
+  info.centerZ = mul((2 * finish->gridZ + 1) * (kCellRaw / 2), kGridScale);
+  const I turns = orientTurns(finish->orientation);
+  info.forwardX = fsin(turns);
+  info.forwardZ = fcos(turns);
+  info.rightX = info.forwardZ;
+  info.rightZ = -info.forwardX;
+  std::vector<Cell> required;
+  for (const Cell& cell : kCells) if (cell.typeId != kFinishTypeId) required.push_back(cell);
+  std::sort(required.begin(), required.end(), [](const Cell& a, const Cell& b) {
+    return a.gridX != b.gridX ? a.gridX < b.gridX : a.gridZ < b.gridZ;
+  });
+  int bit = 0;
+  for (const Cell& cell : required) {
+    if (bit >= kMaxRequiredBits) break;
+    info.bits[{cell.gridX, cell.gridZ}] = bit++;
+  }
+  info.mask = bit == 0 ? 0 : bit >= 31 ? 0x7fffffff : (I{1} << bit) - 1;
+  return info;
+}
+
+struct State {
+  I frame = 0;
+  I phase = 0;
+  I phaseStart = 0;
+  I lobbyDeadline = 0;
+  std::array<I, kMaxSlots> x{}, z{}, vx{}, vz{}, speed{}, yaw{}, lap{}, visited{}, lapProjection{}, finishFrame{};
+  std::array<bool, kMaxSlots> drifting{}, isBot{};
+};
+
+struct SlotInput { bool present = false; I steer = 0; I throttle = 0; bool handbrake = false; };
+using TickInputs = std::array<SlotInput, kMaxSlots>;
+
+struct Runtime {
+  State state;
+  std::vector<BodyFixed> trackWalls = cookTrackWalls();
+  std::vector<BodyFixed> arenaWalls = cookArenaWalls();
+  WaypointRing ring = buildWaypointRing();
+  LapInfo lapInfo = buildLapInfo();
+};
+
+Runtime createRuntime(I initialPhase = kInitialPhase, I humanCount = kHumanCount) {
+  Runtime runtime;
+  runtime.state.phase = initialPhase;
+  runtime.state.lobbyDeadline = initialPhase == kLobby ? kLobbyInitialFrames : 0;
+  const auto poses = initialPhase == kLobby ? scatterSpawns() : gridSpawns();
+  for (I slot = 0; slot < kSlotCount; slot += 1) {
+    runtime.state.x[slot] = poses[slot].x;
+    runtime.state.z[slot] = poses[slot].z;
+    runtime.state.yaw[slot] = poses[slot].yaw;
+    runtime.state.finishFrame[slot] = -1;
+    runtime.state.isBot[slot] = slot >= humanCount;
+  }
+  return runtime;
+}
+
+void freeze(State& state, std::size_t slot) {
+  state.speed[slot] = 0;
+  state.vx[slot] = 0;
+  state.vz[slot] = 0;
+  state.drifting[slot] = false;
+}
+
+void stepVehicle(State& state, std::size_t slot, I steerInput, I throttleInput) {
+  const I steer = clamp(steerInput, -kScale, kScale);
+  const I throttle = clamp(throttleInput, -kScale, kScale);
+  const I target = throttle >= 0 ? mul(throttle, kMaxSpeed) : mul(throttle, kMaxReverse);
+  const bool braking = throttle < 0 && state.speed[slot] > 0;
+  I speed = lerp(state.speed[slot], target, braking ? kBrakeRate : kAccelRate);
+  if (absFixed(speed) < kStopDeadband) speed = 0;
+  const I grip = clamp(divFixed(absFixed(speed), kMaxSpeed), kGripMin, kScale);
+  const I direction = speed == 0 ? 0 : signFixed(speed);
+  const I yawDelta = mul(mul(steer, kTurnPerTick), grip) * direction;
+  I yaw = (state.yaw[slot] + yawDelta) % kScale;
+  if (yaw < 0) yaw += kScale;
+  const I desiredVX = mul(fsin(yaw), speed);
+  const I desiredVZ = mul(fcos(yaw), speed);
+  const I traction = absFixed(speed) > kSlipSpeed ? kTractionFast : kTractionSlow;
+  state.yaw[slot] = yaw;
+  state.speed[slot] = speed;
+  state.drifting[slot] = absFixed(speed) > kSlipSpeed && absFixed(steer) > kDriftSteer;
+  state.vx[slot] = lerp(state.vx[slot], desiredVX, traction);
+  state.vz[slot] = lerp(state.vz[slot], desiredVZ, traction);
+}
+
+PhysBody physicsBody(const BodyFixed& body) {
+  return {body.id, body.dynamic,
+    static_cast<double>(body.x) / kScale, static_cast<double>(body.y) / kScale, static_cast<double>(body.z) / kScale,
+    static_cast<double>(body.vx) / kScale, static_cast<double>(body.vy) / kScale, static_cast<double>(body.vz) / kScale,
+    body.sphere, static_cast<double>(body.radius) / kScale,
+    static_cast<double>(body.halfX) / kScale, static_cast<double>(body.halfY) / kScale, static_cast<double>(body.halfZ) / kScale,
+    body.layer, body.mask};
+}
+
+I jsRound(double value) { return static_cast<I>(std::floor(value + 0.5)); }
+
+void stepLap(State& state, const LapInfo& info, std::size_t slot, I frame) {
+  if (!info.enabled || state.finishFrame[slot] >= 0) return;
+  const I cellWorld = mul(kCellRaw, kGridScale);
+  const I gridX = static_cast<I>(std::floor(static_cast<double>(state.x[slot]) / cellWorld));
+  const I gridZ = static_cast<I>(std::floor(static_cast<double>(state.z[slot]) / cellWorld));
+  const auto bit = info.bits.find({gridX, gridZ});
+  if (bit != info.bits.end()) state.visited[slot] |= I{1} << bit->second;
+  const I relativeX = state.x[slot] - info.centerX;
+  const I relativeZ = state.z[slot] - info.centerZ;
+  const I forward = mul(relativeX, info.forwardX) + mul(relativeZ, info.forwardZ);
+  const I lateral = absFixed(mul(relativeX, info.rightX) + mul(relativeZ, info.rightZ));
+  const bool onLine = lateral <= cellWorld / 2;
+  const bool noTeleport = absFixed(forward - state.lapProjection[slot]) < kNoTeleport;
+  const bool crossed = state.lapProjection[slot] < 0 && forward >= 0;
+  if (onLine && noTeleport && crossed) {
+    if (state.visited[slot] == info.mask && info.mask > 0) {
+      state.lap[slot] += 1;
+      state.visited[slot] = 0;
+      if (state.lap[slot] >= kTotalLaps) state.finishFrame[slot] = frame;
+    } else {
+      state.visited[slot] = 0;
+    }
+  }
+  state.lapProjection[slot] = forward;
+}
+
+void tick(Runtime& runtime, const TickInputs& inputs = {}) {
+  State next = runtime.state;
+  const I frame = runtime.state.frame;
+  bool joined = false;
+  I humans = 0;
+  for (std::size_t slot = 0; slot < kSlotCount; slot += 1) {
+    const bool bot = !inputs[slot].present;
+    if (runtime.state.isBot[slot] && !bot) joined = true;
+    next.isBot[slot] = bot;
+    if (!bot) humans += 1;
+  }
+  const bool activeAtStart = next.phase == kActive;
+  const bool inArena = next.phase == kLobby;
+  std::vector<BodyFixed> dynamicBodies;
+  for (std::size_t slot = 0; slot < kSlotCount; slot += 1) {
+    const bool finished = next.finishFrame[slot] >= 0;
+    bool drive = (next.phase == kLobby && !next.isBot[slot]) || (next.phase == kActive && !finished);
+    I steer = 0;
+    I throttle = 0;
+    if (drive) {
+      if (next.isBot[slot]) {
+        const Drive command = waypointDrive(runtime.ring, next.x[slot], next.z[slot], next.yaw[slot]);
+        steer = command.steer;
+        throttle = command.throttle;
+      } else {
+        steer = inputs[slot].steer;
+        throttle = inputs[slot].throttle;
+      }
+      stepVehicle(next, slot, steer, throttle);
+    } else {
+      freeze(next, slot);
+    }
+    dynamicBodies.push_back({std::string(kCarBodyPrefix) + std::to_string(slot), true,
+      next.x[slot], kBodyY, next.z[slot], next.vx[slot], 0, next.vz[slot], true,
+      kBodyRadius, 0, 0, 0, static_cast<int>(kBodyLayer), static_cast<unsigned>(kBodyMask)});
+  }
+  std::vector<PhysBody> bodies;
+  for (const BodyFixed& body : inArena ? runtime.arenaWalls : runtime.trackWalls) bodies.push_back(physicsBody(body));
+  for (const BodyFixed& body : dynamicBodies) bodies.push_back(physicsBody(body));
+  stepPhysicsSlice(bodies);
+  for (std::size_t slot = 0; slot < kSlotCount; slot += 1) {
+    const std::string id = std::string(kCarBodyPrefix) + std::to_string(slot);
+    const auto body = std::find_if(bodies.begin(), bodies.end(), [&](const PhysBody& candidate) { return candidate.id == id; });
+    if (body != bodies.end()) {
+      next.x[slot] = jsRound(body->x * kScale);
+      next.z[slot] = jsRound(body->z * kScale);
+      next.vx[slot] = jsRound(body->vx * kScale);
+      next.vz[slot] = jsRound(body->vz * kScale);
+    }
+  }
+  if (activeAtStart) for (std::size_t slot = 0; slot < kSlotCount; slot += 1) stepLap(next, runtime.lapInfo, slot, frame);
+  if (next.phase == kLobby) {
+    if (joined) next.lobbyDeadline = std::min(next.lobbyDeadline + kLobbyExtendFrames, next.phaseStart + kLobbyMaxFrames);
+    if (humans >= kMaxSlotsAutoStart || frame >= next.lobbyDeadline) {
+      const auto poses = gridSpawns();
+      for (std::size_t slot = 0; slot < kSlotCount; slot += 1) {
+        next.x[slot] = poses[slot].x; next.z[slot] = poses[slot].z; next.yaw[slot] = poses[slot].yaw;
+        freeze(next, slot); next.lap[slot] = 0; next.visited[slot] = 0; next.lapProjection[slot] = 0; next.finishFrame[slot] = -1;
+      }
+      next.phase = kCountdown; next.phaseStart = frame;
+    }
+  } else if (next.phase == kCountdown) {
+    if (frame - next.phaseStart >= kCountdownFrames) { next.phase = kActive; next.phaseStart = frame; }
+  } else if (next.phase == kActive) {
+    const bool everyoneDone = std::all_of(
+      next.finishFrame.begin(), next.finishFrame.begin() + kSlotCount,
+      [](I value) { return value >= 0; });
+    if (everyoneDone || frame - next.phaseStart >= kMaxRaceFrames) { next.phase = kFinished; next.phaseStart = frame; }
+  } else if (next.phase == kFinished && frame - next.phaseStart >= kResultsHoldFrames) {
+    const auto poses = scatterSpawns();
+    for (std::size_t slot = 0; slot < kSlotCount; slot += 1) {
+      next.x[slot] = poses[slot].x; next.z[slot] = poses[slot].z; next.yaw[slot] = poses[slot].yaw;
+      freeze(next, slot); next.lap[slot] = 0; next.visited[slot] = 0; next.lapProjection[slot] = 0; next.finishFrame[slot] = -1;
+    }
+    next.phase = kLobby; next.phaseStart = frame; next.lobbyDeadline = frame + kLobbyInitialFrames;
+  }
+  next.frame = frame + 1;
+  runtime.state = next;
+}
+
+std::vector<TickInputs> readInputs(const std::string& path, int ticks) {
+  std::vector<TickInputs> frames(static_cast<std::size_t>(ticks));
+  if (path.empty()) return frames;
+  std::ifstream input(path, std::ios::binary);
+  if (!input) std::abort();
+  for (TickInputs& frame : frames) {
+    for (I index = 0; index < kSlotCount; index += 1) {
+      SlotInput& slot = frame[static_cast<std::size_t>(index)];
+      slot.present = input.get() == 1;
+      slot.steer = readI64(input);
+      slot.throttle = readI64(input);
+      slot.handbrake = input.get() == 1;
+    }
+  }
+  if (input.get() != EOF) std::abort();
+  return frames;
+}
+
+void appendU64(std::vector<std::uint8_t>& bytes, std::uint64_t value) {
+  for (int shift = 0; shift < 64; shift += 8) bytes.push_back(static_cast<std::uint8_t>(value >> shift));
+}
+void appendI64(std::vector<std::uint8_t>& bytes, I value) { appendU64(bytes, static_cast<std::uint64_t>(value)); }
+
+std::vector<std::uint8_t> canonical(const State& state) {
+  std::vector<std::uint8_t> bytes;
+  appendU64(bytes, static_cast<std::uint64_t>(state.frame));
+  const std::string& track = kTrack;
+  const std::uint32_t length = static_cast<std::uint32_t>(track.size());
+  for (int shift = 0; shift < 32; shift += 8) bytes.push_back(static_cast<std::uint8_t>(length >> shift));
+  bytes.insert(bytes.end(), track.begin(), track.end());
+  appendI64(bytes, state.phase); appendI64(bytes, state.phaseStart); appendI64(bytes, state.lobbyDeadline);
+  for (const auto* field : {&state.x, &state.z, &state.vx, &state.vz, &state.speed, &state.yaw})
+    for (I slot = 0; slot < kSlotCount; slot += 1) appendI64(bytes, (*field)[static_cast<std::size_t>(slot)]);
+  for (I slot = 0; slot < kSlotCount; slot += 1) bytes.push_back(state.drifting[static_cast<std::size_t>(slot)] ? 1 : 0);
+  for (const auto* field : {&state.lap, &state.visited, &state.lapProjection, &state.finishFrame})
+    for (I slot = 0; slot < kSlotCount; slot += 1) appendI64(bytes, (*field)[static_cast<std::size_t>(slot)]);
+  for (I slot = 0; slot < kSlotCount; slot += 1) bytes.push_back(state.isBot[static_cast<std::size_t>(slot)] ? 1 : 0);
+  return bytes;
+}
+}
+
+struct rundot::kinetix::Fixed1000Session::Impl {
+  std::string profile;
+  Runtime runtime;
+  Fixed1000Command currentCommand{0, 0, false};
+  Fixed1000Command commandForNextTick{0, 0, false};
+  bool hasCommandForNextTick = false;
+};
+
+rundot::kinetix::Fixed1000Session::Fixed1000Session(std::unique_ptr<Impl> impl)
+  : impl_(std::move(impl)) {}
+
+rundot::kinetix::Fixed1000Session::~Fixed1000Session() = default;
+
+std::unique_ptr<rundot::kinetix::Fixed1000Session>
+rundot::kinetix::Fixed1000Session::Load(
+  const std::string& productPath,
+  std::int64_t initialPhase,
+  std::int64_t humanCount
+) {
+  std::string profile = readKinetixProductsProfile(productPath);
+  std::scoped_lock lock(kInstalledProfileMutex);
+  activateInstalledProfile(profile);
+  auto impl = std::make_unique<Impl>();
+  impl->profile = std::move(profile);
+  impl->runtime = createRuntime(initialPhase, humanCount);
+  return std::unique_ptr<Fixed1000Session>(new Fixed1000Session(std::move(impl)));
+}
+
+bool rundot::kinetix::Fixed1000Session::SetCommandForNextTick(
+  const Fixed1000Command& command,
+  std::string& error
+) {
+  if (command.steerX < -1000 || command.steerX > 1000
+      || command.throttle < -1000 || command.throttle > 1000) {
+    error = "KINETIX_COMMAND_AXIS_OUT_OF_RANGE";
+    return false;
+  }
+  impl_->commandForNextTick = command;
+  impl_->hasCommandForNextTick = true;
+  error.clear();
+  return true;
+}
+
+void rundot::kinetix::Fixed1000Session::Tick() {
+  std::scoped_lock lock(kInstalledProfileMutex);
+  activateInstalledProfile(impl_->profile);
+  if (impl_->hasCommandForNextTick) {
+    impl_->currentCommand = impl_->commandForNextTick;
+    impl_->hasCommandForNextTick = false;
+  }
+  TickInputs inputs{};
+  inputs[0] = {
+    true,
+    impl_->currentCommand.steerX,
+    impl_->currentCommand.throttle,
+    impl_->currentCommand.handbrake,
+  };
+  tick(impl_->runtime, inputs);
+}
+
+rundot::kinetix::Fixed1000Presentation
+rundot::kinetix::Fixed1000Session::Presentation() const {
+  std::scoped_lock lock(kInstalledProfileMutex);
+  activateInstalledProfile(impl_->profile);
+  const State& state = impl_->runtime.state;
+  const std::array<std::string, 4> phases = {"lobby", "countdown", "active", "finished"};
+  Fixed1000Presentation presentation{
+    state.frame,
+    phases.at(static_cast<std::size_t>(state.phase)),
+    state.frame * 1000 / 30,
+    std::max<I>(1, state.lap[0] + 1),
+    kTotalLaps,
+    1,
+    {},
+  };
+  for (I slot = 1; slot < kSlotCount; slot += 1) {
+    if (state.finishFrame[slot] >= 0 && state.finishFrame[0] < 0) {
+      presentation.position += 1;
+    } else if (state.lap[slot] > state.lap[0]) {
+      presentation.position += 1;
+    } else if (state.lap[slot] == state.lap[0] && state.visited[slot] > state.visited[0]) {
+      presentation.position += 1;
+    }
+  }
+  for (I slot = 0; slot < kSlotCount; slot += 1) {
+    presentation.cars.push_back({
+      slot,
+      static_cast<double>(state.x[slot]) / kScale,
+      static_cast<double>(state.z[slot]) / kScale,
+      static_cast<double>(state.yaw[slot]) / kScale,
+    });
+  }
+  return presentation;
+}
+
+std::vector<std::uint8_t> rundot::kinetix::Fixed1000Session::CanonicalState() const {
+  std::scoped_lock lock(kInstalledProfileMutex);
+  activateInstalledProfile(impl_->profile);
+  return canonical(impl_->runtime.state);
+}
+
+std::string rundot::kinetix::Fixed1000Session::CanonicalChecksum() const {
+  const auto bytes = CanonicalState();
+  return rundot::sha256Hex(bytes.data(), bytes.size());
+}
+
+int rundot::kinetix::RunFixed1000Profile(int argc, char** argv) {
+#ifndef KINETIX_FIXED1000_SIM_ONLY
+  if (argc == 7 && std::string(argv[1]) == "--records") {
+    const int warmup = std::atoi(argv[2]);
+    const int capture = std::atoi(argv[3]);
+    const std::string packDir = argv[4];
+    const std::string output = argv[5];
+    const int expectedTicks = std::atoi(argv[6]);
+    Runtime runtime = createRuntime();
+    rundot::actorfollow::ActorFollowCore core(rundot::actorfollow::makeActorFollowData());
+    rundot::renderrec::StreamRec stream;
+    const auto renderData = rundot::actorfollow::makeActorFollowData();
+    stream.viewportWidth = renderData.viewportWidth;
+    stream.viewportHeight = renderData.viewportHeight;
+    double accumulatedMs = 0;
+    int ticks = 0;
+    for (int renderFrame = 0; renderFrame < warmup + capture; renderFrame += 1) {
+      accumulatedMs += 1000.0 / 60.0;
+      const int framesToStep = std::max(0, static_cast<int>(std::floor((accumulatedMs * 30.0 + 1e-9) / 1000.0)));
+      for (int stepIndex = 0; stepIndex < framesToStep; stepIndex += 1) { tick(runtime); ticks += 1; }
+      accumulatedMs = std::max(0.0, accumulatedMs - framesToStep * (1000.0 / 30.0));
+      std::vector<rundot::actorfollow::CarView> cars;
+      for (int slot = 0; slot < kSlotCount; slot += 1) cars.push_back({slot,
+        static_cast<double>(runtime.state.x[slot]) / kScale,
+        static_cast<double>(runtime.state.z[slot]) / kScale,
+        static_cast<double>(runtime.state.yaw[slot]) / kScale});
+      auto frame = core.frame(cars);
+      if (renderFrame >= warmup) {
+        frame.frameIndex = static_cast<std::uint32_t>(renderFrame - warmup);
+        if (frame.frameIndex == 0) {
+          auto uploads = core.textureUploads(packDir);
+          frame.commands.insert(frame.commands.begin(), uploads.begin(), uploads.end());
+        }
+        stream.frames.push_back(std::move(frame));
+      }
+    }
+    if (ticks != expectedTicks) { std::fprintf(stderr, "unexpected tick count %d != %d\n", ticks, expectedTicks); return 2; }
+    const auto encoded = rundot::renderrec::encodeRenderRecordStream(stream);
+    std::ofstream out(output, std::ios::binary);
+    out.write(reinterpret_cast<const char*>(encoded.data()), static_cast<std::streamsize>(encoded.size()));
+    std::printf("KINETIX_FIXED1000_RECORDS_OK ticks=%d frames=%zu bytes=%zu\n", ticks, stream.frames.size(), encoded.size());
+    return 0;
+  }
+#endif
+  if (argc < 4 || argc > 7) {
+    std::fprintf(stderr, "usage: kinetix-fixed1000 <profile.bin> <ticks> <out.bin> [inputs.bin] [initialPhase] [humanCount]\n");
+    return 2;
+  }
+  loadKinetixProducts(argv[1]);
+  const int ticks = std::atoi(argv[2]);
+  const auto inputs = readInputs(argc >= 5 ? argv[4] : "", ticks);
+  std::ofstream out(argv[3], std::ios::binary);
+  if (!out) return 2;
+  const I initialPhase = argc >= 6 ? std::atoll(argv[5]) : kInitialPhase;
+  const I humanCount = argc >= 7 ? std::atoll(argv[6]) : kHumanCount;
+  Runtime runtime = createRuntime(initialPhase, humanCount);
+  for (int index = -1; index < ticks; index += 1) {
+    const std::vector<std::uint8_t> bytes = canonical(runtime.state);
+    const std::uint32_t length = static_cast<std::uint32_t>(bytes.size());
+    out.write(reinterpret_cast<const char*>(&length), sizeof(length));
+    out.write(reinterpret_cast<const char*>(bytes.data()), static_cast<std::streamsize>(bytes.size()));
+    if (index + 1 < ticks) tick(runtime, inputs[static_cast<std::size_t>(index + 1)]);
+  }
+  std::printf("KINETIX_FIXED1000_SIM_OK ticks=%d frames=%d\n", ticks, ticks + 1);
+  return 0;
+}