@downdraft/cli 0.0.0 → 0.1.1

package/templates/physics/src/native-entry.ts.eta

@@ -0,0 +1,14 @@
+import { runNativeGameModule } from "@downdraft/platform-native";
+import { gameModule } from "./game-module";
+
+// Native entry — `draft dev`/`draft release` runtime (winit + wgpu under Bun, Node, or Deno).
+// Saves, MCP, display info, and screenshots work through the in-process
+// HostAPI bridge.
+
+await runNativeGameModule(gameModule, {
+  title: "<%= it.name %> — Native",
+  appId: "downdraft-<%= it.name %>",
+}).catch((e) => {
+  console.error("[native-entry] Fatal:", e);
+  process.exit(1);
+});

package/templates/physics/src/sim-host.ts.eta

@@ -0,0 +1,19 @@
+import { SimWorkerHost } from "@downdraft/engine";
+
+// Sim worker host — spawns sim-worker.ts on the main (renderer) thread and
+// exposes the sim SAB + event stream to startGame().
+export class SimHost extends SimWorkerHost {
+  constructor() {
+    // Replace with your game's sim-buffer allocation (see the SAB APIs in
+    // @downdraft/engine, e.g. defineRecordBuffer/allocateSimBuffer).
+    super(new SharedArrayBuffer(4096));
+  }
+
+  protected createWorker(): Worker {
+    return new Worker(new URL("./sim-worker.ts", import.meta.url), { type: "module" });
+  }
+
+  protected async onInit(): Promise<void> {
+    await this.getProxy()!.proxy.init(this.getSimBuffer());
+  }
+}

package/templates/physics/src/sim-worker.ts.eta

@@ -0,0 +1,155 @@
+import {
+  c,
+  Collider,
+  Component,
+  createBoxCollider,
+  createLogger,
+  createSimWorker,
+  createSphereCollider,
+  PhysicsTransform,
+  Query,
+  RigidBody,
+  spawn,
+  Stage,
+  system,
+  Velocity,
+  World,
+} from "@downdraft/engine";
+
+const log = createLogger();
+
+// Physics demo sim worker — an ECS World with gravity + integration systems
+// that spawns falling shapes. createSimWorker owns the tick loop, worker
+// protocol, and stats; this file provides onInit + onTick.
+
+type PhysicsBodyData = {
+  bodyType: "dynamic" | "static" | "kinematic";
+  mass: number;
+  restitution: number;
+  friction: number;
+};
+
+const PhysicsBody = Component.register<PhysicsBodyData>("PhysicsBody", {
+  bodyType: "dynamic",
+  mass: 1,
+  restitution: 0.4,
+  friction: 0.5,
+});
+
+type FallingShapeData = {
+  shape: "box" | "sphere";
+  size: number;
+  color: [number, number, number];
+};
+
+const FallingShape = Component.register<FallingShapeData>("FallingShape", {
+  shape: "box",
+  size: 1,
+  color: [1, 1, 1],
+});
+
+const gravityQuery = new Query([RigidBody.id, Velocity.id, PhysicsTransform.id]);
+
+let world: World;
+let spawnTimer = 0;
+
+createSimWorker({
+  fixedDt: 1 / 60,
+
+  onInit() {
+    world = new World();
+
+    // Ground entity — static body that shapes bounce on.
+    spawn(world,
+      c(PhysicsBody, { bodyType: "static", mass: 0, restitution: 0.3, friction: 0.8 }),
+      c(Collider, createBoxCollider([10, 0.5, 10])),
+      c(PhysicsTransform, { position: [0, -1, 0] }),
+      c(FallingShape, { shape: "box", size: 20, color: [0.3, 0.5, 0.3] }),
+    );
+
+    world.schedule.addSystem(system(
+      "physics-gravity", Stage.Update,
+      (ctx) => {
+        gravityQuery.iterate(ctx.tick, (_ent, comps) => {
+          const body = comps[0] as any;
+          const vel = comps[1] as any;
+          if (body && vel && body.bodyType === "dynamic") {
+            vel.linear[1] -= 9.81 * ctx.dt * (body.gravityScale as number);
+          }
+        });
+      },
+      { queries: [gravityQuery] },
+    ));
+
+    world.schedule.addSystem(system(
+      "physics-integrate", Stage.Update,
+      (ctx) => {
+        gravityQuery.iterate(ctx.tick, (ent, comps) => {
+          const body = comps[0] as any;
+          const vel = comps[1] as any;
+          const transform = comps[2] as any;
+          if (body && vel && transform && body.bodyType === "dynamic") {
+            const [vx, vy, vz] = vel.linear as [number, number, number];
+            const [px, py, pz] = transform.position as [number, number, number];
+            const newPy = py + vy * ctx.dt;
+            transform.position = [px + vx * ctx.dt, newPy, pz + vz * ctx.dt];
+
+            if (newPy < -10) {
+              world.despawn(ent);
+            }
+          }
+        });
+      },
+      { queries: [gravityQuery] },
+    ));
+
+    log.info("sim", "physics demo initialized — shapes will fall and bounce on the ground");
+  },
+
+  onTick(dt) {
+    spawnTimer += dt;
+    if (spawnTimer > 0.5) {
+      spawnTimer = 0;
+      spawnFallingShape();
+    }
+
+    world.step(dt);
+  },
+
+  onShutdown() {
+    log.info("sim", "sim worker shutdown");
+  },
+});
+
+function spawnFallingShape(): void {
+  const isBox = Math.random() > 0.5;
+  const size = 0.5 + Math.random() * 1.5;
+  const x = (Math.random() - 0.5) * 10;
+  const z = (Math.random() - 0.5) * 10;
+
+  spawn(world,
+    c(PhysicsBody, {
+      bodyType: "dynamic",
+      mass: size * size * size,
+      restitution: 0.3 + Math.random() * 0.4,
+      friction: 0.3 + Math.random() * 0.4,
+    }),
+    c(RigidBody, {
+      bodyType: "dynamic",
+      mass: size * size * size,
+      gravityScale: 1,
+    }),
+    c(Velocity, {
+      linear: [(Math.random() - 0.5) * 2, 0, (Math.random() - 0.5) * 2],
+    }),
+    c(PhysicsTransform, { position: [x, 15, z] }),
+    c(Collider, isBox
+      ? createBoxCollider([size / 2, size / 2, size / 2])
+      : createSphereCollider(size * 0.5)),
+    c(FallingShape, {
+      shape: isBox ? "box" : "sphere",
+      size: isBox ? size : size * 0.5,
+      color: [Math.random(), Math.random(), Math.random()],
+    }),
+  );
+}

package/templates/physics/tsconfig.json.eta

@@ -0,0 +1 @@
+<%~ include("_shared/partials/tsconfig", it) %>