@auraindustry/aurajs 0.1.3 → 0.1.5

package/templates/create/2d-adventure/prefabs/relic.prefab.js

@@ -6,28 +6,28 @@ const relicPrefab = {
     kind: 'pickup2d',
   },
   hooks: {},
-  notes: ['Treat relics as authored pickups first, then grow them into richer quest nouns later.'],
+  notes: ['Treat relics as tilemap-authored pickups first, then grow them into richer quest nouns later.'],
 };
 
 export function createRelicPrefab() {
   return relicPrefab;
 }
 
-export function drawAdventureRelics(relics, elapsed = 0) {
-  for (const relic of relics) {
-    if (relic.collected) continue;
-    const pulse = 0.88 + (Math.sin((elapsed * 3.4) + relic.x) * 0.12);
-    const size = relic.radius * pulse;
+export function drawAdventureRelics(interactables = [], elapsed = 0) {
+  for (const entry of interactables) {
+    if (!entry || entry.kind !== 'pickup' || entry.collected === true) continue;
+    const pulse = 0.88 + (Math.sin((elapsed * 3.4) + entry.x) * 0.12);
+    const size = Math.max(12, (Math.max(Number(entry.w) || 0, Number(entry.h) || 0) * 0.5) * pulse);
     aura.draw2d.rect(
-      relic.x - size,
-      relic.y - size,
+      entry.x + ((entry.w - (size * 2)) * 0.5),
+      entry.y + ((entry.h - (size * 2)) * 0.5),
       size * 2,
       size * 2,
       aura.rgb(0.98, 0.9, 0.42),
     );
     aura.draw2d.rect(
-      relic.x - (size * 0.42),
-      relic.y - (size * 0.42),
+      entry.x + ((entry.w - (size * 0.84)) * 0.5),
+      entry.y + ((entry.h - (size * 0.84)) * 0.5),
       size * 0.84,
       size * 0.84,
       aura.rgb(0.18, 0.12, 0.04),

package/templates/create/2d-adventure/prefabs/world.prefab.js

@@ -1,4 +1,12 @@
-import { BEACON_SITES, EXIT_GATE, WORLD_BOUNDS, WORLD_OBSTACLES } from '../content/gameplay/world.js';
+import {
+  createTilemapWorld2D,
+  drawTilemapWorld2D,
+  ensureTilemapWorldLoaded2D,
+  listTilemapWorldObjects2D,
+  moveActorThroughTilemapWorld2D,
+  resolveTilemapSpawn2D,
+} from '../src/starter-utils/index.js';
+import { WORLD_OBJECT_LAYERS, WORLD_ORIGIN, WORLD_TILEMAP } from '../content/gameplay/world.js';
 
 const worldPrefab = {
   id: 'world',
@@ -8,118 +16,163 @@ const worldPrefab = {
     kind: 'environment2d',
   },
   hooks: {},
-  notes: ['Keep authored room layout in content/ and world rendering or collision affordances here.'],
+  notes: ['Keep authored room layout in content/ and tilemap-backed world rendering or collision affordances here.'],
 };
 
-function centeredRect(x, y, size) {
+function worldBounds(world) {
+  const info = world?.info || null;
+  const width = Number(info?.width || 0) * Number(info?.tilewidth || 0);
+  const height = Number(info?.height || 0) * Number(info?.tileheight || 0);
   return {
-    x: x - (size * 0.5),
-    y: y - (size * 0.5),
-    w: size,
-    h: size,
+    x: Number(world?.offsetX || 0),
+    y: Number(world?.offsetY || 0),
+    width,
+    height,
   };
 }
 
-function rectsOverlap(left, right) {
-  return left.x < right.x + right.w
-    && left.x + left.w > right.x
-    && left.y < right.y + right.h
-    && left.y + left.h > right.y;
+function objectProperty(object, name, fallback = null) {
+  if (!object || typeof object !== 'object') return fallback;
+  const properties = object.properties;
+  if (Array.isArray(properties)) {
+    const entry = properties.find((candidate) => candidate && candidate.name === name) || null;
+    return entry && Object.prototype.hasOwnProperty.call(entry, 'value') ? entry.value : fallback;
+  }
+  if (properties && typeof properties === 'object' && Object.prototype.hasOwnProperty.call(properties, name)) {
+    return properties[name];
+  }
+  return fallback;
 }
 
-function clampActorRect(rect) {
-  rect.x = Math.max(WORLD_BOUNDS.x, Math.min(WORLD_BOUNDS.x + WORLD_BOUNDS.width - rect.w, rect.x));
-  rect.y = Math.max(WORLD_BOUNDS.y, Math.min(WORLD_BOUNDS.y + WORLD_BOUNDS.height - rect.h, rect.y));
-  return rect;
+function ensureScenery(world) {
+  if (!world || world.loaded !== true) return [];
+  if (!Array.isArray(world.sceneryObjects)) {
+    world.sceneryObjects = listTilemapWorldObjects2D(world, globalThis.aura, {
+      layer: WORLD_OBJECT_LAYERS.scenery,
+      includeHidden: true,
+    });
+  }
+  return world.sceneryObjects;
 }
 
-function collidesWithObstacle(rect) {
-  return WORLD_OBSTACLES.some((obstacle) => rectsOverlap(rect, obstacle));
+function interactablesByKind(interactables = [], kind) {
+  return interactables.filter((entry) => entry && entry.kind === kind);
 }
 
-function applyActorRect(actor, rect, size) {
-  actor.x = rect.x + (size * 0.5);
-  actor.y = rect.y + (size * 0.5);
+export function createAdventureWorldState() {
+  return createTilemapWorld2D({
+    mapSource: WORLD_TILEMAP,
+    offsetX: WORLD_ORIGIN.x,
+    offsetY: WORLD_ORIGIN.y,
+    cull: false,
+  });
 }
 
 export function createWorldPrefab() {
   return {
     ...worldPrefab,
-    obstacleCount: WORLD_OBSTACLES.length,
+    worldKind: 'tilemap-backed-adventure',
   };
 }
 
-export function moveActorThroughAdventureWorld(actor, deltaX, deltaY, size) {
-  const baseRect = centeredRect(actor.x, actor.y, size);
-
-  if (deltaX !== 0) {
-    const candidate = clampActorRect({
-      x: baseRect.x + deltaX,
-      y: baseRect.y,
-      w: baseRect.w,
-      h: baseRect.h,
+export function ensureAdventureWorldLoaded(world) {
+  const loaded = ensureTilemapWorldLoaded2D(world, globalThis.aura);
+  if (!loaded) return false;
+  if (!Array.isArray(world.sceneryObjects)) {
+    world.sceneryObjects = listTilemapWorldObjects2D(world, globalThis.aura, {
+      layer: WORLD_OBJECT_LAYERS.scenery,
+      includeHidden: true,
     });
-    if (!collidesWithObstacle(candidate)) {
-      baseRect.x = candidate.x;
-    }
   }
+  return true;
+}
 
-  if (deltaY !== 0) {
-    const candidate = clampActorRect({
-      x: baseRect.x,
-      y: baseRect.y + deltaY,
-      w: baseRect.w,
-      h: baseRect.h,
-    });
-    if (!collidesWithObstacle(candidate)) {
-      baseRect.y = candidate.y;
-    }
-  }
+export function resolveAdventurePlayerSpawn(world, markerName = 'player-start') {
+  ensureAdventureWorldLoaded(world);
+  return resolveTilemapSpawn2D(world, globalThis.aura, {
+    layer: WORLD_OBJECT_LAYERS.markers,
+    name: markerName,
+    centered: true,
+  }) || {
+    x: WORLD_ORIGIN.x + 96,
+    y: WORLD_ORIGIN.y + 96,
+  };
+}
 
-  applyActorRect(actor, baseRect, size);
+export function listAdventureWorldObjects(world, options = {}) {
+  ensureAdventureWorldLoaded(world);
+  return listTilemapWorldObjects2D(world, globalThis.aura, options);
 }
 
-export function drawAdventureWorld({ beacons = [], gateReady = false, elapsed = 0 }) {
+export function moveActorThroughAdventureWorld(world, actor, deltaX, deltaY, size) {
+  return moveActorThroughTilemapWorld2D(world, globalThis.aura, actor, deltaX, deltaY, size, size);
+}
+
+export function drawAdventureWorld({
+  world,
+  interactables = [],
+  elapsed = 0,
+  activeCheckpointId = null,
+  runComplete = false,
+}) {
+  ensureAdventureWorldLoaded(world);
+  const bounds = worldBounds(world);
+
   aura.draw2d.rect(
-    WORLD_BOUNDS.x - 24,
-    WORLD_BOUNDS.y - 24,
-    WORLD_BOUNDS.width + 48,
-    WORLD_BOUNDS.height + 48,
-    aura.rgb(0.06, 0.08, 0.11),
+    bounds.x - 24,
+    bounds.y - 24,
+    bounds.width + 48,
+    bounds.height + 48,
+    aura.rgb(0.05, 0.07, 0.1),
   );
   aura.draw2d.rect(
-    WORLD_BOUNDS.x,
-    WORLD_BOUNDS.y,
-    WORLD_BOUNDS.width,
-    WORLD_BOUNDS.height,
-    aura.rgb(0.12, 0.16, 0.12),
+    bounds.x,
+    bounds.y,
+    bounds.width,
+    bounds.height,
+    aura.rgb(0.1, 0.14, 0.11),
   );
+  drawTilemapWorld2D(world, globalThis.aura, { cull: false });
 
-  for (const obstacle of WORLD_OBSTACLES) {
-    aura.draw2d.rect(obstacle.x, obstacle.y, obstacle.w, obstacle.h, aura.rgb(0.22, 0.26, 0.24));
+  for (const object of ensureScenery(world)) {
+    const fill = String(objectProperty(object, 'fill', '#24322a'));
+    const border = String(objectProperty(object, 'border', '#45534b'));
+    aura.draw2d.rect(object.worldX, object.worldY, object.width, object.height, fill);
+    aura.draw2d.rect(object.worldX + 4, object.worldY + 4, Math.max(0, object.width - 8), Math.max(0, object.height - 8), border);
   }
 
-  const beaconById = new Map(beacons.map((beacon) => [beacon.id, beacon]));
-  for (const site of BEACON_SITES) {
-    const lit = beaconById.get(site.id)?.lit === true;
-    const pulse = lit ? 1.0 : 0.9 + (Math.sin((elapsed * 2.2) + site.x) * 0.1);
-    const size = site.size * pulse;
+  for (const checkpoint of interactablesByKind(interactables, 'checkpoint')) {
+    const active = checkpoint.checkpointId === activeCheckpointId || checkpoint.activated === true;
+    const pulse = 0.92 + (Math.sin((elapsed * 2.1) + checkpoint.x) * 0.08);
+    const size = Math.max(checkpoint.w, checkpoint.h) * pulse;
     aura.draw2d.rect(
-      site.x - (size * 0.5),
-      site.y - (size * 0.5),
+      checkpoint.x + ((checkpoint.w - size) * 0.5),
+      checkpoint.y + ((checkpoint.h - size) * 0.5),
       size,
       size,
-      lit ? aura.rgb(0.58, 1.0, 0.74) : aura.rgb(0.44, 0.58, 0.74),
+      active ? aura.rgb(0.58, 1.0, 0.74) : aura.rgb(0.46, 0.64, 0.8),
     );
   }
 
-  aura.draw2d.rect(
-    EXIT_GATE.x,
-    EXIT_GATE.y,
-    EXIT_GATE.w,
-    EXIT_GATE.h,
-    gateReady ? aura.rgb(0.62, 1.0, 0.76) : aura.rgb(0.2, 0.24, 0.28),
-  );
+  for (const prop of interactablesByKind(interactables, 'prop')) {
+    const active = prop.activated === true;
+    aura.draw2d.rect(prop.x, prop.y, prop.w, prop.h, active ? aura.rgb(0.72, 0.82, 0.94) : aura.rgb(0.36, 0.42, 0.5));
+  }
+
+  for (const gate of interactablesByKind(interactables, 'lock')) {
+    const pulse = gate.opened === true || runComplete === true
+      ? 1
+      : 0.92 + (Math.sin((elapsed * 2.4) + gate.x) * 0.08);
+    const width = gate.w * pulse;
+    const height = gate.h * pulse;
+    aura.draw2d.rect(
+      gate.x + ((gate.w - width) * 0.5),
+      gate.y + ((gate.h - height) * 0.5),
+      width,
+      height,
+      gate.opened === true || runComplete === true ? aura.rgb(0.64, 1.0, 0.78) : aura.rgb(0.24, 0.3, 0.36),
+    );
+  }
 }
 
 export default worldPrefab;