castle-web-cli 0.4.129 → 0.4.131

package/kits/physics-3d/CLAUDE.md

@@ -0,0 +1,108 @@
+# physics-3d kit
+
+A 3D actor/behavior kit: three.js rendering with PBR lighting and rapier
+physics, built ON TOP of the `physics-2d` kit as an import. The actor /
+behavior / scene / blueprint model, deck file map, live reload, and the
+`.pxart` pixel-art pipeline (including its editor) all come from
+`imports/castle.physics-2d/` and work exactly as that kit's CLAUDE.md
+describes. This file covers what is different in 3D.
+
+## Quick reference
+
+<!-- Injected into Castle's create assistant every turn; keep this compact and factual. -->
+
+- 3D actor / behavior / scene framework: three.js + rapier, 1 unit = 1 meter,
+  y up. Scenes are `scenes/*.scene` (blueprints too, under `blueprints/`),
+  behaviors `behaviors/*.jsx` -- same JSON shapes as physics-2d, but the
+  component vocabulary is 3D (`Transform`, `Shape`, `Body`, `Solid`, ...).
+- Every actor needs a `Transform` (`x/y/z`, `rotationX/Y/Z` in degrees).
+  Every Transform actor gets a rapier body automatically -- fixed by default,
+  `Body { type: 'dynamic' }` to be simulated, `'kinematic'` to be unpushable
+  but follow Transform edits (doors, platforms).
+- Colliders come from `Shape` and are **sensors unless solid**: add a
+  `Solid {}` behavior (or `Shape.solid: true`) to block; leave it off for
+  pickups / trigger zones. Behaviors get `onCollisionEnter(actor, scene,
+other)` / `onCollisionExit` for both contacts and sensor overlaps.
+- `Shape`: `kind` `'box' | 'sphere' | 'capsule' | 'cylinder'` with
+  `width/height/depth` or `radius`, PBR knobs (`color`, `roughness`,
+  `metalness`, `clearcoat`, `emissive`, `emissiveIntensity`), and `art` -- a
+  `.pxart`/image path baked as a nearest-filtered albedo map. On boxes `art`
+  may be a per-face object `{ all, sides, front, back, left, right, top,
+bottom }`; any ref can pick a frame of a multi-frame pxart with
+  `path#<frame>`. A flat `color` with no art is a fine look.
+- Motion goes through `scene.physics3d`, never by writing a dynamic actor's
+  Transform: `setVelocity(actor, {x,y,z})`, `applyImpulse`, `getVelocity`,
+  `mass`, `castRay(origin, dir, maxToi, excludeActor)` (rays skip sensors).
+  Fixed/kinematic actors ARE moved by writing their Transform.
+- The scene has the lighting rig built in (hemisphere + ambient + one
+  shadow-casting sun, ground plane at y=0); meshes cast and receive shadows
+  automatically. Don't add your own lights for a normal scene.
+- Built-in gameplay behaviors: `Player` (WASD/arrows move, space jumps,
+  drag orbits the camera, faux-isometric follow cam), `Pickup` (sensor
+  collectible -> player score), `Door` (kinematic slide-up when the player is
+  near), `Lookable { text }` (hud caption when the player faces it nearby).
+- Hud: behaviors write `scene.hud = { score, look }`; the player behavior
+  already does.
+- Scene switching: set `scene.requestedScene = 'scenes/other.scene'` from any
+  behavior (applied
+  between frames; safer than calling `scene.loadFromFile` mid-callback). A
+  load rebuilds the physics world and resets the scene to its authored state;
+  `scene.persistent` survives loads -- the player's score, collected-pickup
+  memory, and camera angle live there, so they cross scenes.
+- A scene can dress the ground: `"ground": { "art": "drawings/floor.pxart",
+"tile": 2, "color": "#..." }` at the scene file's top level (`tile` = meters
+  per texture repeat). `Shape.artRepeat: [u, v]` tiles a texture across a
+  face so long walls don't stretch.
+- `.scene` files open in the kit's 3d scene editor (same chrome as the 2d
+  kit's): blueprint hotbar (tap to inspect/edit the template, drag onto the
+  stage to place), orbit camera (drag orbits, wheel zooms), click to select /
+  click again to cycle / shift to multi-select, move & rotate gizmos (keys
+  1/2/3 pick select/move/rotate), floating clone/delete toolbar on the
+  selection, behavior-panel inspector with instance-override tints, undo/redo
+  (cmd+z / cmd+shift+z), cmd+d duplicate, delete key removes. `.pxart` opens
+  in the imported pixel-art editor.
+- Blueprint thumbnails in the hotbar / inspector are live 3d corner-view
+  renders of each template (engine3d/thumbnails.js) -- no icon data needed on
+  the blueprint.
+- 3d models are `.pxmodel` files under `models/` -- part-based JSON (named
+  primitive parts with hierarchy, per-part material/art), spec in
+  docs/pxmodel-format.md. A `Model` behavior (`{ file, scale, yOffset }`)
+  renders one instead of the Shape mesh; part ids legL/legR/armL/armR/torso
+  walk-animate automatically from observed motion. `.pxmodel` opens in the
+  kit's model editor (parts list, gizmos, part inspector, walk preview);
+  `scenes/model-lab.scene` is an all-model scene for trying it.
+- Controls are tank-style: W/S (or up/down) walk forward/back along facing,
+  A/D (or left/right) turn; a pointer/touch drag is a virtual stick where the
+  drag angle blends walking and turning. Space jumps.
+- After any edit: `npm run restart`. After a coherent change: `npm run check`
+  (lint + duplicate gate + single-file bundle) must pass.
+
+## What lives where
+
+- `engine3d/` -- the renderer (`world3d.js`, vase-style rig: PCFSoft shadows,
+  EffectComposer RenderPass + OutputPass), `materials.js` (pxart -> albedo
+  textures, per-face box materials), `Scene3DPlayer.jsx` / `PlayOnly3D.jsx`
+  (the play mount). Internal; behaviors shouldn't import from here.
+- `systems/physics3d.js` -- the rapier system, auto-discovered by the imported
+  engine's `systems/*.js` seam. Fixed 1/60 step, body-per-actor reconcile,
+  collision/overlap events, `scene.physics3d` API.
+- `behaviors/` -- the 3D component vocabulary plus gameplay behaviors. Same
+  rules as physics-2d: `static behaviorName`, `defaultProps`, per-frame
+  instances (state on `actor.runtime`).
+- `imports/castle.physics-2d/` -- read-only. Its engine modules are imported
+  directly (scene runtime, files, live reload, pxart, art, behavior
+  registry); its 2D-only pieces (canvas ScenePlayer, matter physics, 2D
+  editors other than pxart) are present but unused here.
+
+## Known state / caveats
+
+- The 2D kit's behaviors (Layout, Sprite, Collider, RigidBody, ...) are still
+  in the behavior registry via the import's root-anchored globs, and its
+  matter-js system installs (idle) into every runtime. Harmless but present;
+  don't attach 2D components to 3D actors.
+- Transform is the source of truth: dynamic bodies write back position (and
+  rotation unless `lockRotations`), fixed/kinematic bodies follow Transform.
+  A locked-rotation dynamic actor (the player) keeps `rotationY` free for
+  facing.
+- Space is bound to jump in this kit (unlike physics-2d, where the editor
+  reserves it).

package/kits/physics-3d/behaviors/Body.jsx

@@ -0,0 +1,51 @@
+// Physics options. Every actor with a Transform gets a rapier body whether or
+// not it carries this behavior -- fixed by default. Add a Body to opt into
+// motion: 'dynamic' is simulated (gravity, pushes), 'kinematic' is unpushable
+// but follows Transform edits with proper contact resolution (moving doors,
+// platforms). `lockRotations` keeps a dynamic body upright (characters).
+import React from 'react';
+import { SelectField } from '@imports/castle.physics-2d/engine/ui';
+import { AutoFields, overrideProps } from '@imports/castle.physics-2d/engine/autoInspector';
+
+const TYPE_OPTIONS = [
+  { value: 'fixed', label: 'Fixed' },
+  { value: 'dynamic', label: 'Dynamic' },
+  { value: 'kinematic', label: 'Kinematic' },
+];
+
+function BodyInspector({ component, setComponent, override }) {
+  return (
+    <>
+      <SelectField
+        label="Type"
+        value={component.type}
+        options={TYPE_OPTIONS}
+        onChange={(type) => setComponent({ type })}
+        {...overrideProps(override, 'type')}
+      />
+      <AutoFields
+        defaultProps={Body.defaultProps}
+        component={component}
+        setComponent={setComponent}
+        exclude={['type']}
+        override={override}
+      />
+    </>
+  );
+}
+
+export class Body {
+  static Inspector = BodyInspector;
+  static behaviorName = 'Body';
+  static defaultProps = {
+    type: 'fixed', // 'fixed' | 'dynamic' | 'kinematic'
+    friction: 0.6,
+    restitution: 0,
+    gravityScale: 1,
+    lockRotations: false,
+  };
+
+  constructor(props) {
+    this.props = props;
+  }
+}

package/kits/physics-3d/behaviors/Door.jsx

@@ -0,0 +1,31 @@
+// A sliding door: solid, kinematic, and opens (slides up) while the player is
+// within range. Motion is written to the Transform; the physics system feeds
+// it to the kinematic body so contacts resolve properly.
+export class Door {
+  static behaviorName = 'Door';
+  static defaultProps = { range: 3, slide: 2.1, speed: 2.5 };
+
+  constructor(props) {
+    this.props = props;
+  }
+
+  update(actor, scene, dt) {
+    const player = scene.actorWith('Player');
+    const pt = player?.components.Transform;
+    const t = actor.components.Transform;
+    const rt = actor.runtime;
+    if (rt.openT === undefined) {
+      rt.openT = 0;
+      rt.baseY = t.y;
+    }
+    let target = 0;
+    if (pt) {
+      const dist = Math.hypot(pt.x - t.x, pt.z - t.z);
+      target = dist < this.props.range ? 1 : 0;
+    }
+    const delta = Math.sign(target - rt.openT) * this.props.speed * dt;
+    rt.openT = Math.max(0, Math.min(1, rt.openT + delta));
+    const eased = rt.openT * rt.openT * (3 - 2 * rt.openT);
+    t.y = rt.baseY + eased * this.props.slide;
+  }
+}

package/kits/physics-3d/behaviors/Lookable.jsx

@@ -0,0 +1,11 @@
+// Something the player can look at. When the player is near and facing this
+// actor, the hud shows `text`. Pure data -- the Player behavior does the
+// looking.
+export class Lookable {
+  static behaviorName = 'Lookable';
+  static defaultProps = { text: '', range: 4 };
+
+  constructor(props) {
+    this.props = props;
+  }
+}

package/kits/physics-3d/behaviors/Model.jsx

@@ -0,0 +1,14 @@
+// Render a `.pxmodel` (see docs/pxmodel-format.md) instead of the Shape mesh.
+// The Shape still provides the physics collider. `yOffset` places the model's
+// own origin relative to the actor's Transform -- e.g. -0.7 puts a
+// feet-at-zero model under a capsule whose center is the Transform. Models
+// with the walk part ids (legL/legR/armL/armR/torso) animate automatically
+// from how the actor actually moves.
+export class Model {
+  static behaviorName = 'Model';
+  static defaultProps = { file: '', scale: 1, yOffset: 0 };
+
+  constructor(props) {
+    this.props = props;
+  }
+}

package/kits/physics-3d/behaviors/Pickup.jsx

@@ -0,0 +1,39 @@
+// A collectible: bobs and spins in place, and despawns into the player's score
+// on touch. No Solid behavior, so its collider is a sensor -- it overlaps
+// instead of blocking, which is what fires onCollisionEnter here.
+//
+// Collection is remembered in the persistent store keyed by scene + actor id,
+// so re-entering a scene doesn't respawn (and double-count) shards
+// -- scene loads otherwise reset the world to its authored state.
+function pickupKey(scene, actor) {
+  return `${scene.currentScenePath ?? ''}:${actor.id}`;
+}
+
+export class Pickup {
+  static behaviorName = 'Pickup';
+  static defaultProps = { bob: 0.12, spin: 120 };
+
+  constructor(props) {
+    this.props = props;
+  }
+
+  update(actor, scene, dt) {
+    if (scene.persistent?.collected?.has(pickupKey(scene, actor))) {
+      scene.despawnActor(actor.id);
+      return;
+    }
+    const t = actor.components.Transform;
+    const rt = actor.runtime;
+    if (rt.baseY === undefined) rt.baseY = t.y;
+    t.y = rt.baseY + Math.sin(scene.time * 2.5) * this.props.bob;
+    t.rotationY += this.props.spin * dt;
+  }
+
+  onCollisionEnter(actor, scene, other) {
+    if (!other.components.Player) return;
+    const per = (scene.persistent ??= {});
+    per.score = (per.score ?? 0) + 1;
+    (per.collected ??= new Set()).add(pickupKey(scene, actor));
+    scene.despawnActor(actor.id);
+  }
+}

package/kits/physics-3d/behaviors/Player.jsx

@@ -0,0 +1,172 @@
+// The walkable player: a dynamic locked-rotation capsule driven by impulses
+// (the vase floating-capsule controller), a faux-isometric follow camera, and
+// the "look at things" reading of nearby Lookables into the hud.
+//
+// Controls: WASD / arrows move (camera-relative), Q / E orbit the camera.
+// State lives on `actor.runtime` -- behavior instances are per-frame.
+
+const DEG = Math.PI / 180;
+
+function keyDown(keys, ...codes) {
+  return codes.some((code) => keys.has(code));
+}
+
+// Tank-style drive input: `forward` (-1..1) walks along the facing direction,
+// `turn` (-1..1) steers it. W/S (and up/down arrows) drive, A/D (and
+// left/right) turn. The pointer-drag stick maps the same way -- drag up walks,
+// drag sideways turns, and the drag ANGLE blends the two, so a diagonal drag
+// walks a curve and a pure sideways drag turns in place.
+// Keys turn a bit harder than a full stick deflection -- discrete input wants
+// the snappier response.
+const KEY_TURN = 1.35;
+
+function readDrive(keys, stick) {
+  let forward = 0;
+  let turn = 0;
+  if (keyDown(keys, 'KeyW', 'ArrowUp')) forward += 1;
+  if (keyDown(keys, 'KeyS', 'ArrowDown')) forward -= 1;
+  if (keyDown(keys, 'KeyD', 'ArrowRight')) turn += KEY_TURN;
+  if (keyDown(keys, 'KeyA', 'ArrowLeft')) turn -= KEY_TURN;
+  if (forward === 0 && turn === 0 && stick?.active && Math.hypot(stick.x, stick.y) >= 0.15) {
+    forward = -stick.y;
+    turn = stick.x;
+  }
+  return {
+    forward: Math.max(-1, Math.min(1, forward)),
+    turn: Math.max(-KEY_TURN, Math.min(KEY_TURN, turn)),
+  };
+}
+
+// Spring-hover the capsule a touch above the ground (smooths steps and edges);
+// returns whether the player counts as grounded. The spring stays out of the
+// way while the player is on the way up from a jump.
+function applyHover(phys, actor, t, dims, dt) {
+  const hit = phys.castRay({ x: t.x, y: t.y, z: t.z }, { x: 0, y: -1, z: 0 }, dims.height, actor);
+  const hoverHeight = dims.height / 2 + 0.15;
+  const grounded = Boolean(hit && hit.distance < hoverHeight + 0.25);
+  const vel = phys.getVelocity(actor);
+  if (hit && hit.distance < hoverHeight + 0.4 && vel.y <= 1) {
+    const accel = 160 * (hoverHeight - hit.distance) - 18 * vel.y;
+    phys.applyImpulse(actor, { x: 0, y: accel * phys.mass(actor) * dt, z: 0 });
+  }
+  return grounded;
+}
+
+function applyMove(phys, actor, move, speed, grounded, dt) {
+  const mass = phys.mass(actor);
+  const vel = phys.getVelocity(actor);
+  if (move) {
+    const factor = Math.min(1, dt * 14) * (grounded ? 1 : 0.3);
+    phys.applyImpulse(actor, {
+      x: (move.x * speed - vel.x) * mass * factor,
+      y: 0,
+      z: (move.z * speed - vel.z) * mass * factor,
+    });
+  } else if (grounded) {
+    const factor = Math.min(1, dt * 12);
+    phys.applyImpulse(actor, { x: -vel.x * mass * factor, y: 0, z: -vel.z * mass * factor });
+  }
+}
+
+function updateCamera(scene, t, rt, props, dt) {
+  const cam = scene.three?.camera;
+  if (!cam) return;
+  const targetX = t.x - props.camDistance * Math.sin(rt.camAngle);
+  const targetY = t.y + props.camHeight;
+  const targetZ = t.z + props.camDistance * Math.cos(rt.camAngle);
+  // A scene switch teleports the player; snap instead of swooshing the
+  // camera across the whole map.
+  if (Math.hypot(targetX - cam.position.x, targetZ - cam.position.z) > 20) {
+    cam.position.set(targetX, targetY, targetZ);
+  } else {
+    const lerp = 1 - Math.exp(-12 * dt);
+    cam.position.x += (targetX - cam.position.x) * lerp;
+    cam.position.y += (targetY - cam.position.y) * lerp;
+    cam.position.z += (targetZ - cam.position.z) * lerp;
+  }
+  cam.lookAt(t.x, t.y + 0.5, t.z);
+}
+
+// The nearest Lookable the player is facing, within its range.
+function findLookText(scene, actor, t, facing) {
+  const fx = Math.sin(facing);
+  const fz = Math.cos(facing);
+  let bestText = '';
+  let bestDist = Infinity;
+  for (const other of scene.actorsWith('Lookable')) {
+    if (other.id === actor.id) continue;
+    const ot = other.components.Transform;
+    if (!ot) continue;
+    const dx = ot.x - t.x;
+    const dz = ot.z - t.z;
+    const dist = Math.hypot(dx, dz);
+    const range = other.components.Lookable.range ?? 4;
+    if (dist < 0.01 || dist > range || dist >= bestDist) continue;
+    if ((dx * fx + dz * fz) / dist < 0.7) continue;
+    bestText = other.components.Lookable.text ?? '';
+    bestDist = dist;
+  }
+  return bestText;
+}
+
+export class Player {
+  static behaviorName = 'Player';
+  static defaultProps = { speed: 6, turnSpeed: 2.4, jumpSpeed: 8, camDistance: 9, camHeight: 7 };
+
+  constructor(props) {
+    this.props = props;
+  }
+
+  update(actor, scene, dt) {
+    const phys = scene.physics3d;
+    if (!phys?.ready()) return;
+    const t = actor.components.Transform;
+    // Cross-scene state (camera angle, score) lives on the runtime's
+    // persistent store so it survives `loadFromFile`; actor.runtime is
+    // rebuilt on every scene load.
+    const per = (scene.persistent ??= {});
+    const rt = actor.runtime;
+    if (per.camAngle === undefined) per.camAngle = Math.PI / 4;
+    if (per.score === undefined) per.score = 0;
+
+    const shape = actor.components.Shape;
+    const dims = { radius: shape?.radius ?? 0.35, height: shape?.height ?? 1.4 };
+    const grounded = applyHover(phys, actor, t, dims, dt);
+    const drive = readDrive(scene.keys, scene.moveInput);
+    per.camAngle += drive.turn * this.props.turnSpeed * dt;
+    rt.facing = Math.PI - per.camAngle;
+    const move =
+      drive.forward !== 0
+        ? {
+            x: Math.sin(per.camAngle) * drive.forward,
+            z: -Math.cos(per.camAngle) * drive.forward,
+          }
+        : null;
+    applyMove(phys, actor, move, this.props.speed, grounded, dt);
+    t.rotationY = rt.facing / DEG;
+
+    // Jump: Space on keyboard, or a short tap anywhere on the canvas (which
+    // works while another finger drives the drag stick). A tap is buffered
+    // briefly so one made just before touchdown still fires.
+    if (scene.moveInput?.consumeJump?.()) rt.jumpBuffer = 0.18;
+    else rt.jumpBuffer = Math.max(0, (rt.jumpBuffer ?? 0) - dt);
+    if ((keyDown(scene.keys, 'Space') || rt.jumpBuffer > 0) && grounded) {
+      rt.jumpBuffer = 0;
+      const vel = phys.getVelocity(actor);
+      phys.setVelocity(actor, { x: vel.x, y: this.props.jumpSpeed, z: vel.z });
+    }
+    // Fall faster than the rise: extra downward pull past the jump apex kills
+    // the floaty arc.
+    if (!grounded) {
+      const vel = phys.getVelocity(actor);
+      if (vel.y < 1) phys.applyImpulse(actor, { x: 0, y: -14 * phys.mass(actor) * dt, z: 0 });
+    }
+
+    updateCamera(scene, t, per, this.props, dt);
+    const remaining = scene.actorsWith('Pickup').length;
+    const total = per.score + remaining;
+    const score =
+      total === 0 ? '' : remaining === 0 ? '◆ all shards found' : `◆ ${per.score}/${total}`;
+    scene.hud = { score, look: findLookText(scene, actor, t, rt.facing) };
+  }
+}

package/kits/physics-3d/behaviors/Shape.jsx

@@ -0,0 +1,75 @@
+// The actor's visual: a primitive mesh with a PBR material, and the source of
+// its collider dimensions. `art` names a `.pxart` (or image) file used as the
+// albedo map, nearest-filtered so pixels stay crisp; `color` tints (or is the
+// whole surface when there is no art -- a flat colour is a fine look here).
+// `solid: true` is one of the two ways to make the collider solid (the other is
+// a `Solid` behavior on the actor); without either the collider is a sensor
+// that reports overlaps but doesn't block.
+import React from 'react';
+import { SelectField, TextField } from '@imports/castle.physics-2d/engine/ui';
+import { AutoFields, overrideProps } from '@imports/castle.physics-2d/engine/autoInspector';
+
+const KIND_OPTIONS = [
+  { value: 'box', label: 'Box' },
+  { value: 'sphere', label: 'Sphere' },
+  { value: 'capsule', label: 'Capsule' },
+  { value: 'cylinder', label: 'Cylinder' },
+];
+
+function ShapeInspector({ component, setComponent, override }) {
+  const art = component.art;
+  return (
+    <>
+      <SelectField
+        label="Kind"
+        value={component.kind}
+        options={KIND_OPTIONS}
+        onChange={(kind) => setComponent({ kind })}
+        {...overrideProps(override, 'kind')}
+      />
+      {typeof art === 'object' && art !== null ? (
+        <TextField label="Art" value="(per-face art -- edit as JSON)" onChange={() => {}} />
+      ) : (
+        <TextField
+          label="Art"
+          value={art ?? ''}
+          onChange={(next) => setComponent({ art: next })}
+          {...overrideProps(override, 'art')}
+        />
+      )}
+      <AutoFields
+        defaultProps={Shape.defaultProps}
+        component={component}
+        setComponent={setComponent}
+        exclude={['kind', 'art', 'artRepeat']}
+        override={override}
+      />
+    </>
+  );
+}
+
+export class Shape {
+  static Inspector = ShapeInspector;
+  static behaviorName = 'Shape';
+  static defaultProps = {
+    kind: 'box', // 'box' | 'sphere' | 'capsule' | 'cylinder'
+    width: 1,
+    height: 1,
+    depth: 1,
+    radius: 0.5,
+    color: '#c7cfdd',
+    art: '',
+    artRepeat: null,
+    tint: '',
+    roughness: 0.7,
+    metalness: 0,
+    clearcoat: 0,
+    emissive: '#000000',
+    emissiveIntensity: 1,
+    solid: false,
+  };
+
+  constructor(props) {
+    this.props = props;
+  }
+}

package/kits/physics-3d/behaviors/Solid.jsx

@@ -0,0 +1,11 @@
+// Marker: this actor's collider blocks things. Without it (and without
+// `Shape.solid`), colliders are sensors -- they overlap and report it, which is
+// what pickups and trigger zones want.
+export class Solid {
+  static behaviorName = 'Solid';
+  static defaultProps = {};
+
+  constructor(props) {
+    this.props = props;
+  }
+}

package/kits/physics-3d/behaviors/Transform.jsx

@@ -0,0 +1,24 @@
+// Every 3d actor needs a Transform: position and rotation (degrees) in world
+// units, 1 unit = 1 meter. The physics system keeps it in sync with the actor's
+// rapier body -- dynamic bodies write simulated results back here, fixed and
+// kinematic bodies follow edits made here. The renderer reads it every frame,
+// so Transform is the source of truth for where an actor is.
+export class Transform {
+  static behaviorName = 'Transform';
+  static defaultProps = { x: 0, y: 0, z: 0, rotationX: 0, rotationY: 0, rotationZ: 0 };
+  // Position and rotation are always instance-local (like the 2d kit's Layout
+  // x/y): they never read as "overriding" a blueprint value in the inspector,
+  // and blueprint edits never move placed instances.
+  static propertyMeta = {
+    x: { inherit: false },
+    y: { inherit: false },
+    z: { inherit: false },
+    rotationX: { inherit: false },
+    rotationY: { inherit: false },
+    rotationZ: { inherit: false },
+  };
+
+  constructor(props) {
+    this.props = props;
+  }
+}

package/kits/physics-3d/blueprints/barrel.scene

@@ -0,0 +1,15 @@
+{
+  "name": "Barrel",
+  "actors": [
+    {
+      "components": {
+        "Transform": { "y": 0.45 },
+        "Shape": { "kind": "cylinder", "radius": 0.4, "height": 0.9 },
+        "Model": { "file": "models/barrel.pxmodel", "yOffset": -0.45 },
+        "Body": { "type": "dynamic", "friction": 0.7 },
+        "Solid": {},
+        "Lookable": { "text": "a barrel. push it around.", "range": 3 }
+      }
+    }
+  ]
+}

package/kits/physics-3d/blueprints/crate.scene

@@ -0,0 +1,29 @@
+{
+  "name": "Crate",
+  "actors": [
+    {
+      "components": {
+        "Transform": {
+          "y": 0.5
+        },
+        "Shape": {
+          "kind": "box",
+          "width": 1,
+          "height": 1,
+          "depth": 1,
+          "art": "drawings/crate.pxart",
+          "roughness": 0.85
+        },
+        "Body": {
+          "type": "dynamic",
+          "friction": 0.8
+        },
+        "Solid": {},
+        "Lookable": {
+          "text": "a crate. push it around.",
+          "range": 3
+        }
+      }
+    }
+  ]
+}

package/kits/physics-3d/blueprints/door.scene

@@ -0,0 +1,35 @@
+{
+  "name": "Door",
+  "actors": [
+    {
+      "components": {
+        "Transform": {
+          "y": 1.1
+        },
+        "Shape": {
+          "kind": "box",
+          "width": 2,
+          "height": 2.2,
+          "depth": 0.3,
+          "art": {
+            "front": "drawings/door.pxart",
+            "back": "drawings/door.pxart",
+            "sides": "drawings/door-edge.pxart",
+            "top": "drawings/door-edge.pxart"
+          },
+          "color": "#c9a17a",
+          "roughness": 0.8
+        },
+        "Body": {
+          "type": "kinematic"
+        },
+        "Solid": {},
+        "Door": {},
+        "Lookable": {
+          "text": "a door. it opens when someone comes close.",
+          "range": 5
+        }
+      }
+    }
+  ]
+}

package/kits/physics-3d/blueprints/gem.scene

@@ -0,0 +1,26 @@
+{
+  "name": "Gem",
+  "actors": [
+    {
+      "components": {
+        "Transform": {
+          "y": 0.7
+        },
+        "Shape": {
+          "kind": "sphere",
+          "radius": 0.28,
+          "color": "#0cf1ff",
+          "roughness": 0.25,
+          "metalness": 0.2,
+          "emissive": "#0cf1ff",
+          "emissiveIntensity": 0.5
+        },
+        "Pickup": {},
+        "Lookable": {
+          "text": "a shard. walk into it to collect it.",
+          "range": 3.5
+        }
+      }
+    }
+  ]
+}