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

package/native/kinetix-fixed1000-physics.hpp

@@ -0,0 +1,28 @@
+// C++20 transliteration of the syncplay deterministic 3D physics slice used by
+// by the installed fixed-1000 profile: dynamic spheres plus static boxes, one TGS-Soft
+// step (dt=1, gravity 0, velocityIterations 3, substeps 6), no materials, no
+// orientation, no joints, no warm cache, no CCD.
+//
+// Source of truth: venus packages/syncplay/src/physics3d{,-solver,-shared}.ts.
+// Every arithmetic expression is ported verbatim (same IEEE-754 operation
+// order); compile with -ffp-contract=off and doubles throughout.
+#pragma once
+
+#include <string>
+#include <vector>
+
+struct PhysBody {
+  std::string id;
+  bool dynamic;
+  double x, y, z, vx, vy, vz;
+  bool isSphere;
+  double radius;
+  double halfX, halfY, halfZ;
+  int layer;
+  unsigned mask;
+};
+
+// Sorts `bodies` by id lexicographically (canonical body order), runs one
+// deterministic rigid step, and writes back quantized positions + velocities
+// to dynamic bodies (statics untouched, apart from the sort).
+void stepPhysicsSlice(std::vector<PhysBody>& bodies);

package/native/kinetix-installed-f64-renderer.cpp

@@ -0,0 +1,344 @@
+// C++ transliteration of parity-renderer-f64.mjs. Mirrors the JS renderer
+// exactly: same draw order, same loop bounds (Math.floor/ceil on doubles),
+// same pixel-center math (x + 0.5), same comparison operators, same colors,
+// same integer (a + b) >> 1 mix. Frames must be byte-identical to the Node
+// reference dump.
+//
+// The runtime's entity model lives in an anonymous namespace inside
+// the installed runtime source; renaming its sole external-linkage symbol lets
+// this TU include the runtime source verbatim (bit-identical sim, no
+// duplicate symbol) and read Runtime/Entity/Component directly.
+#define runReplayF64 runReplayF64RendererCopyUnused
+#define RUNDOT_F64RT_OMIT_SIM_STEPPER
+#include "kinetix-installed-f64-runtime.cpp"
+#undef RUNDOT_F64RT_OMIT_SIM_STEPPER
+#undef runReplayF64
+
+#include <algorithm>
+#include <cstdio>
+#include <fstream>
+
+#include "kinetix-installed-f64-renderer.hpp"
+
+namespace rundot::f64rt {
+namespace {
+
+constexpr int FRAME_WIDTH = kFrameWidth;
+constexpr int FRAME_HEIGHT = kFrameHeight;
+
+struct Rgb {
+  std::uint8_t r = 0;
+  std::uint8_t g = 0;
+  std::uint8_t b = 0;
+};
+
+constexpr Rgb kBackground{10, 10, 18};
+constexpr Rgb kGrid{20, 20, 40};
+constexpr Rgb kBorder{42, 42, 85};
+constexpr Rgb kShip{102, 255, 238};
+constexpr Rgb kShipShield{220, 240, 255};
+constexpr Rgb kBulletCore{255, 243, 199};
+constexpr Rgb kBulletGlow{138, 122, 64};
+constexpr Rgb kWanderer{176, 64, 255};
+constexpr Rgb kShard{207, 122, 255};
+constexpr Rgb kGrunt{170, 255, 51};
+constexpr Rgb kTelegraph{90, 90, 140};
+constexpr Rgb kScoreBar{255, 216, 77};
+constexpr Rgb kDeathPip{255, 80, 80};
+
+void putPixel(std::uint8_t* frame, int x, int y, const Rgb& color) {
+  if (x < 0 || y < 0 || x >= FRAME_WIDTH || y >= FRAME_HEIGHT) return;
+  const std::size_t offset = (static_cast<std::size_t>(y) * FRAME_WIDTH + static_cast<std::size_t>(x)) * 3;
+  frame[offset] = color.r;
+  frame[offset + 1] = color.g;
+  frame[offset + 2] = color.b;
+}
+
+void mixPixel(std::uint8_t* frame, int x, int y, const Rgb& color) {
+  if (x < 0 || y < 0 || x >= FRAME_WIDTH || y >= FRAME_HEIGHT) return;
+  const std::size_t offset = (static_cast<std::size_t>(y) * FRAME_WIDTH + static_cast<std::size_t>(x)) * 3;
+  frame[offset] = static_cast<std::uint8_t>((frame[offset] + color.r) >> 1);
+  frame[offset + 1] = static_cast<std::uint8_t>((frame[offset + 1] + color.g) >> 1);
+  frame[offset + 2] = static_cast<std::uint8_t>((frame[offset + 2] + color.b) >> 1);
+}
+
+void fillCircle(std::uint8_t* frame, double cx, double cy, double radius, const Rgb& color) {
+  const int x0 = static_cast<int>(std::max(0.0, std::floor(cx - radius)));
+  const int x1 = static_cast<int>(std::min(static_cast<double>(FRAME_WIDTH - 1), std::ceil(cx + radius)));
+  const int y0 = static_cast<int>(std::max(0.0, std::floor(cy - radius)));
+  const int y1 = static_cast<int>(std::min(static_cast<double>(FRAME_HEIGHT - 1), std::ceil(cy + radius)));
+  const double r2 = radius * radius;
+  for (int y = y0; y <= y1; y += 1) {
+    for (int x = x0; x <= x1; x += 1) {
+      const double dx = x + 0.5 - cx;
+      const double dy = y + 0.5 - cy;
+      if (dx * dx + dy * dy <= r2) putPixel(frame, x, y, color);
+    }
+  }
+}
+
+void ring(std::uint8_t* frame, double cx, double cy, double innerRadius, double outerRadius, const Rgb& color) {
+  const int x0 = static_cast<int>(std::max(0.0, std::floor(cx - outerRadius)));
+  const int x1 = static_cast<int>(std::min(static_cast<double>(FRAME_WIDTH - 1), std::ceil(cx + outerRadius)));
+  const int y0 = static_cast<int>(std::max(0.0, std::floor(cy - outerRadius)));
+  const int y1 = static_cast<int>(std::min(static_cast<double>(FRAME_HEIGHT - 1), std::ceil(cy + outerRadius)));
+  const double inner2 = innerRadius * innerRadius;
+  const double outer2 = outerRadius * outerRadius;
+  for (int y = y0; y <= y1; y += 1) {
+    for (int x = x0; x <= x1; x += 1) {
+      const double dx = x + 0.5 - cx;
+      const double dy = y + 0.5 - cy;
+      const double d2 = dx * dx + dy * dy;
+      if (d2 >= inner2 && d2 <= outer2) putPixel(frame, x, y, color);
+    }
+  }
+}
+
+void fillDiamond(std::uint8_t* frame, double cx, double cy, double size, const Rgb& color) {
+  const int x0 = static_cast<int>(std::max(0.0, std::floor(cx - size)));
+  const int x1 = static_cast<int>(std::min(static_cast<double>(FRAME_WIDTH - 1), std::ceil(cx + size)));
+  const int y0 = static_cast<int>(std::max(0.0, std::floor(cy - size)));
+  const int y1 = static_cast<int>(std::min(static_cast<double>(FRAME_HEIGHT - 1), std::ceil(cy + size)));
+  for (int y = y0; y <= y1; y += 1) {
+    for (int x = x0; x <= x1; x += 1) {
+      const double dx = x + 0.5 - cx;
+      const double dy = y + 0.5 - cy;
+      const double adx = dx < 0 ? -dx : dx;
+      const double ady = dy < 0 ? -dy : dy;
+      if (adx + ady <= size) putPixel(frame, x, y, color);
+    }
+  }
+}
+
+double edge(double ax, double ay, double bx, double by, double px, double py) {
+  return (bx - ax) * (py - ay) - (by - ay) * (px - ax);
+}
+
+void fillTriangle(std::uint8_t* frame, double ax, double ay, double bx, double by, double cx, double cy, const Rgb& color) {
+  const int minX = static_cast<int>(std::max(0.0, std::floor(std::min(std::min(ax, bx), cx))));
+  const int maxX = static_cast<int>(std::min(static_cast<double>(FRAME_WIDTH - 1), std::ceil(std::max(std::max(ax, bx), cx))));
+  const int minY = static_cast<int>(std::max(0.0, std::floor(std::min(std::min(ay, by), cy))));
+  const int maxY = static_cast<int>(std::min(static_cast<double>(FRAME_HEIGHT - 1), std::ceil(std::max(std::max(ay, by), cy))));
+  const double area = edge(ax, ay, bx, by, cx, cy);
+  if (area == 0) return;
+  for (int y = minY; y <= maxY; y += 1) {
+    for (int x = minX; x <= maxX; x += 1) {
+      const double px = x + 0.5;
+      const double py = y + 0.5;
+      const double w0 = edge(ax, ay, bx, by, px, py);
+      const double w1 = edge(bx, by, cx, cy, px, py);
+      const double w2 = edge(cx, cy, ax, ay, px, py);
+      if (area > 0 ? w0 >= 0 && w1 >= 0 && w2 >= 0 : w0 <= 0 && w1 <= 0 && w2 <= 0) {
+        putPixel(frame, x, y, color);
+      }
+    }
+  }
+}
+
+const Component* componentOf(const Entity& entity, Kind kind) {
+  const int index = entity.byKind[static_cast<std::size_t>(kind)];
+  return index < 0 ? nullptr : &entity.components[static_cast<std::size_t>(index)];
+}
+
+// orderedEntities(): statics in pack order (alive only) then alive pooled
+// sorted by ascending spawnId — a filtered copy, sim state untouched.
+std::vector<const Entity*> orderedEntities(const Runtime& runtime) {
+  std::vector<const Entity*> ordered;
+  ordered.reserve(runtime.statics.size() + runtime.pooled.size());
+  for (const Entity& entity : runtime.statics) {
+    if (entity.alive) ordered.push_back(&entity);
+  }
+  std::vector<const Entity*> pooledAlive;
+  pooledAlive.reserve(runtime.pooled.size());
+  for (const Entity& entity : runtime.pooled) {
+    if (entity.alive) pooledAlive.push_back(&entity);
+  }
+  std::sort(pooledAlive.begin(), pooledAlive.end(),
+            [](const Entity* a, const Entity* b) { return a->spawnId < b->spawnId; });
+  ordered.insert(ordered.end(), pooledAlive.begin(), pooledAlive.end());
+  return ordered;
+}
+
+void renderF64Frame(const Runtime& runtime, std::uint8_t* frame) {
+  // background
+  const std::size_t frameBytes = static_cast<std::size_t>(FRAME_WIDTH) * FRAME_HEIGHT * 3;
+  for (std::size_t offset = 0; offset < frameBytes; offset += 3) {
+    frame[offset] = kBackground.r;
+    frame[offset + 1] = kBackground.g;
+    frame[offset + 2] = kBackground.b;
+  }
+  // grid every 80 px
+  for (int x = 0; x < FRAME_WIDTH; x += 80) {
+    for (int y = 0; y < FRAME_HEIGHT; y += 1) putPixel(frame, x, y, kGrid);
+  }
+  for (int y = 0; y < FRAME_HEIGHT; y += 80) {
+    for (int x = 0; x < FRAME_WIDTH; x += 1) putPixel(frame, x, y, kGrid);
+  }
+  // arena border (2 px)
+  for (int x = 0; x < FRAME_WIDTH; x += 1) {
+    putPixel(frame, x, 0, kBorder);
+    putPixel(frame, x, 1, kBorder);
+    putPixel(frame, x, FRAME_HEIGHT - 2, kBorder);
+    putPixel(frame, x, FRAME_HEIGHT - 1, kBorder);
+  }
+  for (int y = 0; y < FRAME_HEIGHT; y += 1) {
+    putPixel(frame, 0, y, kBorder);
+    putPixel(frame, 1, y, kBorder);
+    putPixel(frame, FRAME_WIDTH - 2, y, kBorder);
+    putPixel(frame, FRAME_WIDTH - 1, y, kBorder);
+  }
+
+  const std::vector<const Entity*> entities = orderedEntities(runtime);
+
+  // telegraph rings (behind bodies)
+  for (const Entity* entity : entities) {
+    const Component* telegraph = componentOf(*entity, Kind::Telegraph);
+    if (telegraph == nullptr || telegraph->remaining <= 0) continue;
+    const Component* transform = componentOf(*entity, Kind::Transform2D);
+    const Component* circle = componentOf(*entity, Kind::CollisionCircle);
+    const double base = circle != nullptr ? circle->radius : 8;
+    const double radius = base * (1.5 + telegraph->remaining);
+    ring(frame, transform->position.x, transform->position.y, radius - 1.5, radius, kTelegraph);
+  }
+
+  // enemies + bullets + ship
+  for (const Entity* entity : entities) {
+    const Component* transform = componentOf(*entity, Kind::Transform2D);
+    if (transform == nullptr) continue;
+    const Component* telegraph = componentOf(*entity, Kind::Telegraph);
+    const bool telegraphing = telegraph != nullptr && telegraph->remaining > 0;
+
+    if (componentOf(*entity, Kind::WanderMover) != nullptr) {
+      if (!telegraphing) {
+        fillCircle(frame, transform->position.x, transform->position.y, 12, kWanderer);
+      }
+      continue;
+    }
+    if (componentOf(*entity, Kind::SeekMover) != nullptr) {
+      if (!telegraphing) {
+        fillDiamond(frame, transform->position.x, transform->position.y, 11, kGrunt);
+      }
+      continue;
+    }
+    if (entity->ref == "shard") {
+      fillCircle(frame, transform->position.x, transform->position.y, 7.5, kShard);
+      continue;
+    }
+    if (entity->ref == "bullet") {
+      ring(frame, transform->position.x, transform->position.y, 4, 7, kBulletGlow);
+      fillCircle(frame, transform->position.x, transform->position.y, 4, kBulletCore);
+      continue;
+    }
+    if (componentOf(*entity, Kind::AxisDriveMover) != nullptr) {
+      const double heading = transform->heading;
+      const double cos = rundot::detmath::det_cos(heading);
+      const double sin = rundot::detmath::det_sin(heading);
+      const double size = 14;
+      const double noseX = transform->position.x + cos * size;
+      const double noseY = transform->position.y + sin * size;
+      const double leftX = transform->position.x + (-cos * 0.7 - sin * 0.6) * size;
+      const double leftY = transform->position.y + (-sin * 0.7 + cos * 0.6) * size;
+      const double rightX = transform->position.x + (-cos * 0.7 + sin * 0.6) * size;
+      const double rightY = transform->position.y + (-sin * 0.7 - cos * 0.6) * size;
+      fillTriangle(frame, noseX, noseY, leftX, leftY, rightX, rightY, kShip);
+      const Component* shield = componentOf(*entity, Kind::SpawnShield);
+      if (shield != nullptr && shield->remaining > 0) {
+        ring(frame, transform->position.x, transform->position.y, 16, 18, kShipShield);
+      }
+    }
+  }
+
+  // HUD: score bar + death pips (mix 50% over background for a HUD feel).
+  // JS uses staticEntities.find() here — NOT filtered by alive.
+  const Entity* game = nullptr;
+  for (const Entity& entity : runtime.statics) {
+    if (componentOf(entity, Kind::ResourceCounter) != nullptr) {
+      game = &entity;
+      break;
+    }
+  }
+  if (game != nullptr) {
+    const Component* counter = componentOf(*game, Kind::ResourceCounter);
+    const double score = static_cast<double>(counter->score);
+    const int barWidth = static_cast<int>(std::floor(std::min(score, 2000.0) * 0.15));
+    for (int y = 12; y < 22; y += 1) {
+      for (int x = 16; x < 16 + barWidth; x += 1) mixPixel(frame, x, y, kScoreBar);
+    }
+    const std::int64_t deaths = counter->deaths;
+    const std::int64_t pipCount = deaths < 10 ? deaths : 10;  // Math.min(deaths, 10)
+    for (std::int64_t pip = 0; pip < pipCount; pip += 1) {
+      const int pipBase = 16 + static_cast<int>(pip) * 12;
+      for (int y = 26; y < 34; y += 1) {
+        for (int x = pipBase; x < pipBase + 8; x += 1) putPixel(frame, x, y, kDeathPip);
+      }
+    }
+  }
+}
+
+void writeFrameFile(const std::string& framesDir, std::int64_t frameIndex, const std::vector<std::uint8_t>& frame) {
+  char name[32];
+  std::snprintf(name, sizeof(name), "frame-%03lld.rgb", static_cast<long long>(frameIndex));
+  const std::string path = framesDir + "/" + name;
+  std::ofstream out(path, std::ios::binary);
+  if (!out) fail("cannot write frame " + path);
+  out.write(reinterpret_cast<const char*>(frame.data()), static_cast<std::streamsize>(frame.size()));
+  if (!out) fail("failed writing frame " + path);
+}
+
+}  // namespace
+
+F64FrameDumpResult runReplayF64WithFrames(const PackDef& pack,
+                                          const ReplayDef& replay,
+                                          bool hashEveryTick,
+                                          const std::string& framesDir) {
+  Runtime runtime = createRuntime(pack);
+  std::map<std::int64_t, const std::vector<SlotInputDef>*> inputsByTick;
+  for (const InputFrameDef& frame : replay.inputFrames) {
+    inputsByTick[frame.tick] = &frame.slots;
+  }
+  std::vector<SlotInputDef> currentInputs(static_cast<std::size_t>(pack.inputSlots));
+
+  F64FrameDumpResult out;
+  F64RunResult& result = out.run;
+  std::string streamAccum;
+  std::vector<std::uint8_t> frameBuffer(static_cast<std::size_t>(kFrameWidth) * kFrameHeight * 3);
+  std::int64_t frameIndex = 0;
+  for (std::int64_t tick = 0; tick < replay.tickCount; tick += 1) {
+    const auto frame = inputsByTick.find(tick);
+    if (frame != inputsByTick.end()) currentInputs = *frame->second;
+    tickRuntime(runtime, currentInputs);
+    if (tick % 2 == 1) {
+      renderF64Frame(runtime, frameBuffer.data());
+      writeFrameFile(framesDir, frameIndex, frameBuffer);
+      out.frameHashes.push_back(rundot::sha256Hex(frameBuffer.data(), frameBuffer.size()));
+      frameIndex += 1;
+    }
+    if (hashEveryTick || tick == replay.tickCount - 1) {
+      const std::string tickHash = canonicalTickHash(runtime);
+      if (hashEveryTick) {
+        result.tickHashes.push_back(tickHash);
+      } else {
+        result.tickHashes.assign(1, tickHash);
+      }
+      streamAccum += tickHash;
+    }
+  }
+  result.finalDigest = rundot::sha256Hex(reinterpret_cast<const std::uint8_t*>(streamAccum.data()), streamAccum.size());
+  result.completedTicks = replay.tickCount;
+  std::int64_t alivePooled = 0;
+  for (const Entity& entity : runtime.pooled) {
+    if (entity.alive) alivePooled += 1;
+  }
+  result.liveEntitiesAtEnd = static_cast<std::int64_t>(runtime.statics.size()) + alivePooled;
+  for (Entity& entity : runtime.statics) {
+    Component* counter = findComponent(entity, Kind::ResourceCounter);
+    if (counter != nullptr) {
+      result.finalScore = counter->score;
+      result.shipDeaths = counter->deaths;
+      break;
+    }
+  }
+  return out;
+}
+
+}  // namespace rundot::f64rt

package/native/kinetix-installed-f64-renderer.hpp

@@ -0,0 +1,35 @@
+// Deterministic parity renderer for the installed f64 runtime: C++
+// transliteration of parity-renderer-f64.mjs. Pure function of sim state ->
+// 1280x720 RGB24 frame; the only transcendentals are detmath det_cos/det_sin
+// for the ship heading triangle. The renderer never mutates runtime state.
+//
+// The runtime's entity model is TU-private (anonymous namespace inside
+// the installed runtime source), so the public entrypoint here is a replay
+// runner that mirrors runReplayF64 exactly and additionally renders after
+// every tick with tick % 2 == 1 (0-based), matching render-frames-node.mjs.
+#pragma once
+
+#include <cstdint>
+#include <string>
+#include <vector>
+
+#include "kinetix-installed-f64-runtime.hpp"
+
+namespace rundot::f64rt {
+
+inline constexpr int kFrameWidth = 1280;
+inline constexpr int kFrameHeight = 720;
+
+struct F64FrameDumpResult {
+  F64RunResult run;
+  std::vector<std::string> frameHashes;  // sha256 hex of each raw RGB24 frame
+};
+
+// Runs the replay bit-identically to runReplayF64 (same tick-hash outputs)
+// while writing framesDir/frame-%03d.rgb after each odd tick.
+F64FrameDumpResult runReplayF64WithFrames(const PackDef& pack,
+                                          const ReplayDef& replay,
+                                          bool hashEveryTick,
+                                          const std::string& framesDir);
+
+}  // namespace rundot::f64rt