@homie-rocks/studio 0.38.0 → 0.40.0

package/starters/ember-vale/tunables.json

@@ -1,13 +1,102 @@
 {
-  "strikeRange": { "value": 96, "min": 50, "max": 180, "step": 1, "unit": "px", "group": "Strike", "note": "How far a strike reaches (a slime's size adds to it)" },
-  "strikeMs": { "value": 380, "min": 150, "max": 900, "step": 10, "unit": "ms", "group": "Strike", "note": "The shortest time between two strikes" },
-  "flashMs": { "value": 200, "min": 60, "max": 500, "step": 10, "unit": "ms", "group": "Strike", "note": "How long a strike shows on every screen" },
-  "swingMs": { "value": 150, "min": 40, "max": 400, "step": 5, "unit": "ms", "group": "Strike", "note": "The swipe around the hero, and its smear as it carries through" },
-  "hitStopMs": { "value": 60, "min": 0, "max": 200, "step": 5, "unit": "ms", "group": "Hit", "note": "The hit lands: the slime freezes, white, before it is pushed" },
-  "slimePush": { "value": 14, "min": 0, "max": 80, "step": 1, "unit": "px", "group": "Hit", "note": "How far a strike pushes a slime back" },
-  "lunge": { "value": 14, "min": 0, "max": 40, "step": 1, "unit": "px", "group": "Strike", "note": "The hero steps into each strike (as far as the push, so a combo stays in reach)" },
-  "pushMs": { "value": 220, "min": 60, "max": 600, "step": 10, "unit": "ms", "group": "Hit", "note": "How long the push takes (it eases out)" },
-  "wobble": { "value": 0.3, "min": 0, "max": 0.7, "step": 0.01, "group": "Hit", "note": "How much a struck slime squashes and wobbles" },
-  "wobbleMs": { "value": 420, "min": 100, "max": 1000, "step": 10, "unit": "ms", "group": "Hit", "note": "How long the wobble takes to die away (overlap)" },
-  "shake": { "value": 4, "min": 0, "max": 16, "step": 0.5, "unit": "px", "group": "Hit", "note": "The camera's kick when your strike lands" }
+  "public": {
+    "strikeRange": {
+      "value": 1.92,
+      "min": 1.0,
+      "max": 3.6,
+      "step": 0.02,
+      "unit": "m",
+      "group": "Strike",
+      "note": "How far a strike reaches (a slime's size adds to it)"
+    },
+    "strikeMs": {
+      "value": 380,
+      "min": 150,
+      "max": 900,
+      "step": 10,
+      "unit": "ms",
+      "group": "Strike",
+      "note": "The shortest time between two strikes"
+    },
+    "flashMs": {
+      "value": 200,
+      "min": 60,
+      "max": 500,
+      "step": 10,
+      "unit": "ms",
+      "group": "Strike",
+      "note": "How long a strike shows on every screen"
+    },
+    "swingMs": {
+      "value": 150,
+      "min": 40,
+      "max": 400,
+      "step": 5,
+      "unit": "ms",
+      "group": "Strike",
+      "note": "The swipe around the hero, and its smear as it carries through"
+    },
+    "hitStopMs": {
+      "value": 60,
+      "min": 0,
+      "max": 200,
+      "step": 5,
+      "unit": "ms",
+      "group": "Hit",
+      "note": "The hit lands: the slime freezes, white, before it is pushed"
+    },
+    "slimePush": {
+      "value": 0.28,
+      "min": 0.0,
+      "max": 1.6,
+      "step": 0.02,
+      "unit": "m",
+      "group": "Hit",
+      "note": "How far a strike pushes a slime back"
+    },
+    "lunge": {
+      "value": 0.28,
+      "min": 0.0,
+      "max": 0.8,
+      "step": 0.02,
+      "unit": "m",
+      "group": "Strike",
+      "note": "The hero steps into each strike (as far as the push, so a combo stays in reach)"
+    },
+    "pushMs": {
+      "value": 220,
+      "min": 60,
+      "max": 600,
+      "step": 10,
+      "unit": "ms",
+      "group": "Hit",
+      "note": "How long the push takes (it eases out)"
+    },
+    "wobble": {
+      "value": 0.3,
+      "min": 0,
+      "max": 0.7,
+      "step": 0.01,
+      "group": "Hit",
+      "note": "How much a struck slime squashes and wobbles"
+    },
+    "wobbleMs": {
+      "value": 420,
+      "min": 100,
+      "max": 1000,
+      "step": 10,
+      "unit": "ms",
+      "group": "Hit",
+      "note": "How long the wobble takes to die away (overlap)"
+    },
+    "shake": {
+      "value": 4,
+      "min": 0,
+      "max": 16,
+      "step": 0.5,
+      "unit": "px",
+      "group": "Hit",
+      "note": "The camera's kick when your strike lands"
+    }
+  }
 }

package/starters/gem-rush/src/move.ts

@@ -18,6 +18,14 @@ export const move = defineMove({
     const keep = M.pow(1 - m.accel / 60, ctx.dt * 60);
     body.vel = M.add(want, M.scale(M.sub(body.vel, want), keep));
     if (M.len(body.vel) > 0.6) body.heading = M.norm(body.vel);
-    ctx.map.sweep(body, M.scale(body.vel, ctx.dt));
+    // Keep the tangential travel when a thumb points slightly into an arena wall.
+    // The original canvas starter clamped each axis independently.
+    const delta = M.scale(body.vel, ctx.dt), before = body.pos;
+    const hit = ctx.map.sweep(body, delta);
+    if (hit) {
+      const remaining = M.sub(delta, M.sub(body.pos, before));
+      const into = M.dot(remaining, hit.normal);
+      if (into < 0) ctx.map.sweep(body, M.sub(remaining, M.scale(hit.normal, into)));
+    }
   },
 });

package/starters/gem-rush/src/view.ts

@@ -420,7 +420,8 @@ function frame(t: number): void {
   const dt = lab.time.dt(t, 0.05);
   updateView();
   if (lab.on) labReport(dt);
-  draw(t); frames++; requestAnimationFrame(frame);
+  // updateView can deliver an effect newer than a delayed rAF timestamp.
+  draw(performance.now()); frames++; requestAnimationFrame(frame);
 }
 room.probe({ frames: () => frames, waves: () => wavesSeen, knocks: () => knocksSeen, zone: () => zone,
   camera: () => ({ ...cam, view: viewSeat() }),

package/starters/gem-rush-3d/game.json

@@ -2,11 +2,29 @@
   "id": "gem-rush-3d",
   "name": "Gem Rush 3D",
   "blurb": "Gem Rush in a meadow: animals grab gems and bump each other away. Sixty-second rounds that never stop, drawn in three.js with free CC0 models.",
-  "players": { "min": 1, "max": 8 },
+  "players": {
+    "min": 1,
+    "max": 8
+  },
   "roundSeconds": 60,
-  "entry": "src/main.ts",
-  "netplay": { "v": 1, "public": true, "movement": "owner" },
-  "needs": { "three": "0.185.1" },
+  "entry": "src/view.ts",
+  "netplay": {
+    "v": 1,
+    "public": true
+  },
+  "needs": {
+    "three": "0.185.1",
+    "@types/three": "0.185.1"
+  },
   "assets": "library",
-  "landing": { "pitch": "Grab the gems. Bump your rivals away.", "controls": { "phone": "Drag to move; a second finger bumps.", "computer": "WASD or arrows to move, Space to bump." } }
+  "landing": {
+    "pitch": "Grab the gems. Bump your rivals away.",
+    "controls": {
+      "phone": "Drag to move; a second finger bumps.",
+      "computer": "WASD or arrows to move, Space to bump."
+    }
+  },
+  "room": {
+    "host": "server"
+  }
 }

package/starters/gem-rush-3d/map/main.json

@@ -0,0 +1,153 @@
+{
+  "bounds": {
+    "min": [
+      0,
+      0,
+      0
+    ],
+    "max": [
+      26,
+      16,
+      8
+    ]
+  },
+  "circles": [
+    {
+      "at": [
+        13,
+        4,
+        0
+      ],
+      "r": 1.05
+    },
+    {
+      "at": [
+        4.6,
+        3.8,
+        0
+      ],
+      "r": 0.75
+    },
+    {
+      "at": [
+        21.4,
+        4.6,
+        0
+      ],
+      "r": 0.55
+    },
+    {
+      "at": [
+        6,
+        12.6,
+        0
+      ],
+      "r": 0.5
+    },
+    {
+      "at": [
+        20.2,
+        12.2,
+        0
+      ],
+      "r": 0.75
+    },
+    {
+      "at": [
+        9.6,
+        13.4,
+        0
+      ],
+      "r": 0.45
+    },
+    {
+      "at": [
+        23.6,
+        2,
+        0
+      ],
+      "r": 0.5
+    }
+  ],
+  "spots": {
+    "start": [
+      [
+        19.6,
+        8.0,
+        0
+      ],
+      [
+        17.66690475583121,
+        11.535533905932738,
+        0
+      ],
+      [
+        13.0,
+        13.0,
+        0
+      ],
+      [
+        8.333095244168787,
+        11.535533905932738,
+        0
+      ],
+      [
+        6.4,
+        8.0,
+        0
+      ],
+      [
+        8.333095244168785,
+        4.464466094067262,
+        0
+      ],
+      [
+        13,
+        2.509,
+        0
+      ],
+      [
+        17.66690475583121,
+        4.464466094067261,
+        0
+      ]
+    ],
+    "obstacles": [
+      [
+        13,
+        4,
+        1.05
+      ],
+      [
+        4.6,
+        3.8,
+        0.75
+      ],
+      [
+        21.4,
+        4.6,
+        0.55
+      ],
+      [
+        6,
+        12.6,
+        0.5
+      ],
+      [
+        20.2,
+        12.2,
+        0.75
+      ],
+      [
+        9.6,
+        13.4,
+        0.45
+      ],
+      [
+        23.6,
+        2,
+        0.5
+      ]
+    ]
+  }
+}

package/starters/gem-rush-3d/src/move.ts

@@ -0,0 +1,37 @@
+import { defineMove, type Vec3 } from '@homie-rocks/studio/rules';
+
+import type { MoveBody, MoveContext } from '@homie-rocks/studio/rules/types';
+
+function slide<M>(body: MoveBody<M>, delta: Vec3, ctx: MoveContext<unknown, M>) {
+  const before = body.pos, hit = ctx.map.sweep(body, delta);
+  if (!hit) return;
+  const M = ctx.math, remaining = M.sub(delta, M.sub(body.pos, before));
+  const into = M.dot(remaining, hit.normal);
+  if (into < 0) ctx.map.sweep(body, M.sub(remaining, M.scale(hit.normal, into)));
+}
+
+export const move = defineMove({
+  runner(body, input, ctx) {
+    const M = ctx.math, m = body.motion, T = ctx.tune;
+    if (m.knockAt > 0) {
+      const last = ctx.tick + 1 >= m.knockUntil;
+      const u = M.clamp((ctx.tick - m.knockAt) / (m.knockUntil - m.knockAt), 0, 1);
+      const ease = last ? 1 : 1 - M.pow(1 - u, T.knockEase);
+      // A wall consumes blocked travel. Chasing the absolute endpoint stores up
+      // that travel and releases it as a burst when the body slides clear.
+      const previous = M.clamp((ctx.tick - 1 - m.knockAt) / (m.knockUntil - m.knockAt), 0, 1);
+      const before = 1 - M.pow(1 - previous, T.knockEase);
+      const travel = M.scale(m.knockDir, T.knockDistance * (ease - before));
+      const delta = travel;
+      slide(body, delta, ctx);
+      body.vel = last ? { x: 0, y: 0, z: 0 } : M.scale(delta, 1 / ctx.dt);
+      if (last) m.knockAt = 0;
+      return;
+    }
+    const want = M.scale(M.clampLen({ x: input.ax / 127, y: input.ay / 127, z: 0 }, 1), m.speed);
+    const keep = M.pow(1 - m.accel / 60, ctx.dt * 60);
+    body.vel = M.add(want, M.scale(M.sub(body.vel, want), keep));
+    if (M.len(body.vel) > 0.6) body.heading = M.norm(body.vel);
+    slide(body, M.scale(body.vel, ctx.dt), ctx);
+  },
+});

package/starters/gem-rush-3d/src/rules.ts

@@ -0,0 +1,133 @@
+import { defineRules, f, type GameWorld } from '@homie-rocks/studio/rules';
+import { move } from './move';
+
+function gemPoint(world: Pick<GameWorld, 'random' | 'map' | 'math'>) {
+  let p = { x: 1.2 + world.random() * 23.6, y: 1.2 + world.random() * 13.6, z: 0 };
+  for (let i = 0; i < 12; i++) {
+    let blocked = false;
+    for (const o of world.map.spots('obstacles')) if (world.math.dist(p, { x: o.x, y: o.y, z: 0 }) < o.z + 0.7) blocked = true;
+    if (!blocked) break;
+    p = { x: 1.2 + world.random() * 23.6, y: 1.2 + world.random() * 13.6, z: 0 };
+  }
+  return p;
+}
+
+export default defineRules({
+  contract: 2, space: { dims: 3 }, move,
+  shapes: {
+    events: { hit: { from: f.vec3(), by: f.ref() }, take: { by: f.ref(), at: f.vec3() }, score: { value: f.u8() }, zone: {} },
+    effects: { wave: {}, knock: { dir: f.dir(), by: f.ref() } },
+  },
+  shared: { gemSeq: f.u32(), zone: f.vec3(), zoneN: f.u32(), zoneUntil: f.tick() },
+  entities: {
+    runner: {
+      player: { away: 'think', leave: 'bot' },
+      fields: { score: f.u16({ score: true }), pickups: f.u16(), target: f.vec3(), noticed: f.fix(), arrived: f.bit(), targetGem: f.ref() },
+      motion: { speed: f.fix({ init: 6.8 }), accel: f.fix({ init: 14 }), knockDir: f.dir(), knockFrom: f.vec3(), knockAt: f.fix(), knockUntil: f.fix() },
+      input: { ax: f.i8(), ay: f.i8(), wave: f.press() },
+      body: { shape: 'capsule', radius: 0.44, height: 1.2, maxSpeed: 6.8 },
+      tick(world, self) {
+        if (self.driver === 'person' && !self.away) { self.motion.speed = 6.8; self.motion.accel = 14; }
+        if (self.input.wave) {
+          world.emit('wave', self.id, {});
+          world.sendArea({ sphere: { at: self.pos, r: world.tune.knockRange } }, 'hit', { from: self.pos, by: self.id });
+        }
+        if (world.round.phase === 'live') for (const gem of world.near(self.pos, 0.7, 'gem')) world.send(gem.id, 'take', { by: self.id, at: self.pos });
+      },
+      think(world, self) {
+        const M = world.math;
+        self.motion.speed = 5; self.motion.accel = 5;
+        if (world.stage === 'dummy' || self.motion.knockAt > 0) return { ax: 0, ay: 0 };
+        const level = (world.kids ? Math.min(3, world.level) : world.level) - 1;
+        const reactions = [650, 420, 250, 170, 110];
+        const noise = [0.55, 0.3, 0.15, 0.07, 0.02];
+        const aggression = [0.1, 0.3, 0.5, 0.7, 0.9];
+        const positioning = [0.1, 0.35, 0.5, 0.75, 0.95];
+        if (self.noticed === 0 || world.tick - self.noticed >= reactions[level] / 1000 / world.dt) {
+          let best = self.pos, nearest = 10000;
+          self.targetGem = '';
+          const rivals = world.near(self.pos, 64, 'runner');
+          for (const gem of world.near(self.pos, 64, 'gem')) {
+            if (rivals.some(p => p.id !== self.id && p.noticed === world.tick && p.targetGem === gem.id)) continue;
+            const hot = M.dist(gem.pos, world.shared.zone) < 3;
+            const distance = M.dist(gem.pos, self.pos) * (hot ? 1.5 - positioning[level] : 1);
+            if (distance < nearest) { nearest = distance; best = gem.pos; self.targetGem = gem.id; }
+          }
+          self.target = { x: best.x + (world.random() - 0.5) * 4 * noise[level], y: best.y + (world.random() - 0.5) * 4 * noise[level], z: 0 };
+          self.noticed = world.tick; self.arrived = false;
+        }
+        const d = M.sub(self.target, self.pos), distance = M.len(d);
+        if (distance < 0.12 && !self.arrived) { self.arrived = true; self.noticed = world.tick; }
+        const v = distance < 0.12 ? { x: 0, y: 0, z: 0 } : M.norm(d);
+        let rival = false;
+        for (const p of world.near(self.pos, world.tune.knockRange, 'runner')) if (p.id !== self.id) rival = true;
+        return { ax: Math.round(v.x * 127), ay: Math.round(v.y * 127), wave: rival && world.round.phase === 'live' && world.random() < Math.min(world.kids ? 0.3 : 1, aggression[level]) * 0.8 * world.dt };
+      },
+      on: {
+        score(world, self, e) { self.score += e.value; self.pickups += 1; },
+        takeover(world, self) { self.motion.speed = 6.8; self.motion.accel = 14; self.motion.knockAt = 0; self.motion.knockUntil = 0; self.vel = { x: 0, y: 0, z: 0 }; },
+        arrive(world, self) {
+          if (world.stage === 'dummy') {
+            let index = 0;
+            for (const p of world.near(self.pos, 64, 'runner')) if (p.driver === 'bot' && p.seat < self.seat) index++;
+            world.place(self, self.driver === 'person' ? { x: 9.8, y: 8, z: 0 } : index === 0 ? { x: 11.64, y: 8, z: 0 } : { x: 22.4, y: 3 + (index - 1) * 10, z: 0 });
+          }
+        },
+        hit(world, self, e) {
+          if (e.by === self.id) return;
+          const M = world.math, m = self.motion, delta = M.sub(self.pos, e.from);
+          m.knockDir = M.len(delta) < 0.02 ? M.dir(world.random() * M.TAU) : M.norm(delta);
+          m.knockFrom = self.pos;
+          m.knockAt = world.tick + world.tune.hitStopMs / 1000 / world.dt;
+          m.knockUntil = m.knockAt + world.tune.knockMs / 1000 / world.dt;
+          world.emit('knock', self.id, { dir: m.knockDir, by: e.by });
+        },
+      },
+      onRoom: {
+        roundStart(world, self) {
+          self.score = 0; self.pickups = 0; self.noticed = 0;
+          self.motion.knockAt = 0; self.motion.knockUntil = 0;
+          const spots = world.map.spots('start');
+          if (world.stage !== 'dummy') world.place(self, spots[self.seat % spots.length]);
+          else {
+            let index = 0;
+            for (const p of world.near(self.pos, 64, 'runner')) if (p.driver === 'bot' && p.seat < self.seat) index++;
+            world.place(self, self.driver === 'person' ? { x: 9.8, y: 8, z: 0 } : index === 0 ? { x: 11.64, y: 8, z: 0 } : { x: 22.4, y: 3 + (index - 1) * 10, z: 0 });
+          }
+        },
+      },
+    },
+    gem: {
+      fields: { takenAt: f.tick(), serial: f.u32() },
+      on: {
+        take(world, self, e) {
+          if (self.takenAt === world.tick || world.math.dist(e.at, self.pos) >= 0.7) return;
+          self.takenAt = world.tick;
+          world.send(e.by, 'score', { value: world.math.dist(self.pos, world.shared.zone) < 3 ? 2 : 1 });
+          world.place(self, gemPoint(world));
+          self.serial += 14;
+        },
+      },
+      onRoom: { roundOver(world, self) { world.despawn(self); } },
+    },
+  },
+  room: {
+    rounds: { seconds: 60, breakSeconds: 7 }, bots: { keep: 3 },
+    join(ctx, player) { const spots = ctx.map.spots('start'); return { kind: 'runner', at: spots[player.seat % spots.length] }; },
+    on: {
+      roundStart(world) {
+        for (let i = 0; i < 14; i++) { world.shared.gemSeq += 1; world.spawn('gem', gemPoint(world), { serial: world.shared.gemSeq }); }
+        world.shared.zone = { x: 4.4 + world.random() * 17.2, y: 4 + world.random() * 8, z: 0 };
+        world.shared.zoneN += 1; world.shared.zoneUntil = world.tick + world.ticks(12);
+        world.after(world.ticks(12), 'zone', {});
+      },
+      zone(world) {
+        if (world.round.phase !== 'live') return;
+        world.shared.zone = { x: 4.4 + world.random() * 17.2, y: 4 + world.random() * 8, z: 0 };
+        world.shared.zoneN += 1; world.shared.zoneUntil = world.tick + world.ticks(12);
+        world.after(world.ticks(12), 'zone', {});
+      },
+    },
+  },
+  map: './map',
+});