@blkc-code/render-canvas 0.1.0 → 0.6.0

package/src/world.ts

@@ -3,57 +3,32 @@
  * heading. Nothing in here touches a canvas, so all of it can be tested.
  */
 
-import type { AgentState, FloorStyle, FurnitureType, OfficeAgent, OfficeDoor, OfficeFurniture, OfficeRoom, OfficeScene, OfficeTask, TaskState } from "./types.js";
+import { registerWorld, worldData, type ItemSpec, type WorldData } from "./pack.js";
+import { OFFICE, OFFICE_ITEMS, OFFICE_LAYOUT } from "./worlds/office-data.js";
+import type { LinkRoute } from "./links.js";
+import type { AgentState, FloorStyle, FurnitureType, OfficeAgent, OfficeDoor, OfficeFurniture, OfficeLayout, OfficeRoom, OfficeScene, OfficeTask, TaskState } from "./types.js";
 
 export const MAX_COLS = 64;
 export const MAX_ROWS = 40;
 const MAX_AGENTS = 40;
 const MAX_FURNITURE = 300;
 const MAX_TASKS = 60;
-export const WALK_SPEED = 3.2; // tiles a second
-
-/** Footprint in tiles, and where someone stands to use it, relative to its corner. */
-export const FURNITURE: Record<FurnitureType, { w: number; h: number; solid?: boolean; spot?: { x: number; y: number } }> = {
-  desk: { w: 3, h: 2, spot: { x: 1, y: 2 } },
-  coffee: { w: 2, h: 1, spot: { x: 0, y: 1 } },
-  water: { w: 1, h: 1, spot: { x: 0, y: 1 } },
-  sofa: { w: 3, h: 1, spot: { x: 1, y: 1 } },
-  plant: { w: 1, h: 1 },
-  board: { w: 4, h: 1, spot: { x: 1, y: 1 } },
-  shelf: { w: 2, h: 1, spot: { x: 0, y: 1 } },
-  server: { w: 1, h: 1 },
-  table: { w: 3, h: 2, spot: { x: 1, y: 2 } },
-  rug: { w: 4, h: 3, solid: false },
-};
+export const WALK_SPEED = 4.5; // tiles a second
+
+/** Footprints and uses, for the office. Other worlds bring their own. */
+export const FURNITURE = OFFICE_ITEMS;
 
 const AGENT_STATES: readonly string[] = ["working", "thinking", "blocked", "reviewing", "idle", "done", "away"];
 const TASK_STATES: readonly string[] = ["todo", "doing", "done"];
-const FLOORS: readonly string[] = ["wood", "carpet", "tile"];
-
-export const DEFAULT_LAYOUT = {
-  cols: 26,
-  rows: 17,
-  rooms: [
-    { id: "studio", name: "Studio", x: 1, y: 3, w: 15, h: 13, floor: "wood" },
-    { id: "lounge", name: "Lounge", x: 17, y: 3, w: 8, h: 6, floor: "carpet" },
-    { id: "quests", name: "Quests", x: 17, y: 10, w: 8, h: 6, floor: "tile" },
-  ] as OfficeRoom[],
-  doors: [{ x: 16, y: 6 }, { x: 16, y: 13 }, { x: 23, y: 9 }] as OfficeDoor[],
-  furniture: [
-    { type: "desk", x: 2, y: 4 }, { type: "desk", x: 7, y: 4 }, { type: "desk", x: 12, y: 4 },
-    { type: "desk", x: 2, y: 10 }, { type: "desk", x: 7, y: 10 }, { type: "desk", x: 12, y: 10 },
-    { type: "plant", x: 1, y: 8 }, { type: "plant", x: 15, y: 8 }, { type: "server", x: 15, y: 15 }, { type: "server", x: 14, y: 15 },
-    { type: "shelf", x: 1, y: 15 },
-    { type: "coffee", x: 19, y: 3 }, { type: "water", x: 21, y: 3 }, { type: "sofa", x: 22, y: 3 }, { type: "rug", x: 20, y: 5 }, { type: "plant", x: 24, y: 8 },
-    { type: "board", x: 19, y: 10 }, { type: "table", x: 19, y: 13 }, { type: "plant", x: 24, y: 15 },
-  ] as OfficeFurniture[],
-};
+const FLOORS: readonly string[] = ["wood", "carpet", "tile", "stone", "concrete", "grass", "hall"];
+
+export const DEFAULT_LAYOUT = OFFICE_LAYOUT;
 
 const int = (value: unknown, fallback: number): number => (typeof value === "number" && Number.isFinite(value) ? Math.floor(value) : fallback);
 const str = (value: unknown, max = 120): string => (typeof value === "string" ? value.slice(0, max) : "");
 const list = <T>(value: unknown, max: number): T[] => (Array.isArray(value) ? (value.slice(0, max) as T[]) : []);
 
-export interface Room { name: string; x: number; y: number; w: number; h: number; floor: FloorStyle }
+export interface Room { id: string; name: string; x: number; y: number; w: number; h: number; floor: FloorStyle; paths: string[] }
 export interface Item { type: FurnitureType; x: number; y: number }
 export interface Task { title: string; state: TaskState; agent: string }
 
@@ -63,6 +38,9 @@ export interface Agent {
   role: string;
   state: AgentState;
   task: string;
+  area: string;
+  /** Seconds of celebration left after finishing something. */
+  party: number;
   hair: string;
   skin: string;
   shirt: string;
@@ -79,6 +57,12 @@ export interface Agent {
 }
 
 export interface World {
+  /** What this world is made of. */
+  pack: WorldData;
+  links: { from: string; to: string }[];
+  /** Worked out when first drawn, and again when the building changes. */
+  routes?: LinkRoute[];
+  showLinks: boolean;
   cols: number;
   rows: number;
   rooms: Room[];
@@ -88,6 +72,7 @@ export interface World {
   tasks: Task[];
   walkable: boolean[];
   spots: { lounge: { x: number; y: number }[]; board: { x: number; y: number }[] };
+  seats: { x: number; y: number }[];
 }
 
 export function hash(text: string): number {
@@ -152,6 +137,8 @@ function toAgent(raw: OfficeAgent, index: number): Agent {
     role: str(raw?.role, 40),
     state,
     task: str(raw?.task, 120),
+    area: str(raw?.area, 60),
+    party: 0,
     hair: colour(raw?.hair, HAIR[seed % HAIR.length] as string),
     skin: colour(raw?.skin, SKIN[(seed >>> 4) % SKIN.length] as string),
     shirt: colour(raw?.shirt, SHIRT[(seed >>> 8) % SHIRT.length] as string),
@@ -169,25 +156,31 @@ function toTask(raw: OfficeTask): Task {
   return { title: str(raw?.title, 80), state: TASK_STATES.includes(raw?.state as string) ? (raw.state as TaskState) : "todo", agent: str(raw?.agent, 60) };
 }
 
-/** Build a world from a scene. Bad values are dropped or clamped, so it never throws. */
-export function createWorld(scene: OfficeScene = {}): World {
+registerWorld(OFFICE);
+
+/** A piece of furniture's spec. Only items in the world's list get into a World. */
+export const specOf = (world: Pick<World, "pack">, item: Item): ItemSpec => world.pack.items[item.type] as ItemSpec;
+
+function buildLayout(scene: OfficeLayout, pack: WorldData): Pick<World, "links" | "cols" | "rows" | "rooms" | "doors" | "furniture" | "walkable" | "spots" | "seats"> {
   const custom = Array.isArray(scene?.rooms) && scene.rooms.length > 0;
-  const cols = Math.min(Math.max(int(scene?.cols, custom ? 20 : DEFAULT_LAYOUT.cols), 6), MAX_COLS);
-  const rows = Math.min(Math.max(int(scene?.rows, custom ? 14 : DEFAULT_LAYOUT.rows), 6), MAX_ROWS);
-  const rawRooms = custom ? list<OfficeRoom>(scene.rooms, 40) : DEFAULT_LAYOUT.rooms;
-  const rawDoors = custom ? list<OfficeDoor>(scene.doors, 60) : DEFAULT_LAYOUT.doors;
-  const rawItems = Array.isArray(scene?.furniture) ? list<OfficeFurniture>(scene.furniture, MAX_FURNITURE) : custom ? [] : DEFAULT_LAYOUT.furniture;
+  const cols = Math.min(Math.max(int(scene?.cols, custom ? 20 : pack.layout.cols), 6), MAX_COLS);
+  const rows = Math.min(Math.max(int(scene?.rows, custom ? 14 : pack.layout.rows), 6), MAX_ROWS);
+  const rawRooms = custom ? list<OfficeRoom>(scene.rooms, 40) : pack.layout.rooms;
+  const rawDoors = custom ? list<OfficeDoor>(scene.doors, 60) : pack.layout.doors;
+  const rawItems = Array.isArray(scene?.furniture) ? list<OfficeFurniture>(scene.furniture, MAX_FURNITURE) : custom ? [] : pack.layout.furniture;
 
   // Clamped to the grid: everything later loops over these, so a huge room must not hang the page.
-  const rooms: Room[] = rawRooms.map((room) => {
+  const rooms: Room[] = rawRooms.map((room, index) => {
     const x = Math.min(Math.max(int(room?.x, 0), 0), cols);
     const y = Math.min(Math.max(int(room?.y, 0), 0), rows);
     return {
+      id: str(room?.id, 60) || `room-${index + 1}`,
       name: str(room?.name, 24),
       x, y,
       w: Math.min(Math.max(int(room?.w, 0), 0), cols - x),
       h: Math.min(Math.max(int(room?.h, 0), 0), rows - y),
       floor: FLOORS.includes(room?.floor as string) ? (room.floor as FloorStyle) : "wood",
+      paths: list<string>(room?.paths, 20).filter((p) => typeof p === "string").map((p) => p.slice(0, 200)),
     };
   });
   const walkable = new Array<boolean>(cols * rows).fill(false);
@@ -201,56 +194,131 @@ export function createWorld(scene: OfficeScene = {}): World {
   for (const door of doors) mark(door.x, door.y, true);
 
   const furniture: Item[] = rawItems
-    .filter((item) => item && Object.hasOwn(FURNITURE, item.type))
+    .filter((item) => item && Object.hasOwn(pack.items, item.type))
     .map((item) => ({ type: item.type, x: int(item.x, -99), y: int(item.y, -99) }));
   for (const item of furniture) {
-    const spec = FURNITURE[item.type];
+    const spec = pack.items[item.type] as ItemSpec;
     if (spec.solid === false) continue;
     for (let y = item.y; y < item.y + spec.h; y++) for (let x = item.x; x < item.x + spec.w; x++) mark(x, y, false);
   }
 
-  const world: World = {
-    cols, rows, rooms, doors, furniture, walkable,
-    agents: list<OfficeAgent>(scene?.agents, MAX_AGENTS).map(toAgent),
-    tasks: list<OfficeTask>(scene?.tasks, MAX_TASKS).map(toTask),
-    spots: { lounge: [], board: [] },
-  };
-
+  const open = (x: number, y: number): boolean => x >= 0 && y >= 0 && x < cols && y < rows && walkable[y * cols + x] === true;
   const spot = (item: Item): { x: number; y: number } | undefined => {
-    const offset = FURNITURE[item.type].spot;
+    const offset = (pack.items[item.type] as ItemSpec).spot;
     if (!offset) return undefined;
     const point = { x: item.x + offset.x, y: item.y + offset.y };
-    return isWalkable(world, point.x, point.y) ? point : undefined;
+    return open(point.x, point.y) ? point : undefined;
   };
-  const seats = furniture.filter((item) => item.type === "desk").map(spot).filter((p): p is { x: number; y: number } => Boolean(p));
+  const seats = furniture.filter((item) => (pack.items[item.type] as ItemSpec).use === "seat").map(spot).filter((p): p is { x: number; y: number } => Boolean(p));
+  const spots: World["spots"] = { lounge: [], board: [] };
   for (const item of furniture) {
     const point = spot(item);
     if (!point) continue;
-    if (item.type === "coffee" || item.type === "sofa" || item.type === "water" || item.type === "shelf") world.spots.lounge.push(point);
-    if (item.type === "board" || item.type === "table") world.spots.board.push(point);
+    const use = (pack.items[item.type] as ItemSpec).use;
+    if (use === "lounge") spots.lounge.push(point);
+    if (use === "board") spots.board.push(point);
   }
+  const links = list<{ from: string; to: string }>(scene?.links, 60)
+    .map((link) => ({ from: str(link?.from, 60), to: str(link?.to, 60) }))
+    .filter((link) => link.from && link.to);
+  return { cols, rows, rooms, doors, furniture, walkable, seats, spots, links };
+}
 
-  world.agents.forEach((agent, index) => {
-    agent.seat = seats[index];
-    placeAgent(world, agent);
-  });
+/** Build a world from a scene. Bad values are dropped or clamped, so it never throws. */
+export function createWorld(scene: OfficeScene = {}): World {
+  const pack = worldData(scene?.world, OFFICE);
+  const world: World = {
+    pack,
+    showLinks: true,
+    ...buildLayout(scene, pack),
+    agents: list<OfficeAgent>(scene?.agents, MAX_AGENTS).map(toAgent),
+    tasks: list<OfficeTask>(scene?.tasks, MAX_TASKS).map(toTask),
+  };
+  for (const agent of world.agents) placeAgent(world, agent);
   return world;
 }
 
+/** Change the building while everyone is in it. Anyone left inside a wall or a desk moves. */
+export function applyLayout(world: World, layout: OfficeLayout): void {
+  Object.assign(world, buildLayout(layout, world.pack), { routes: undefined });
+  for (const agent of world.agents) {
+    agent.seat = undefined;
+    agent.path = [];
+    agent.x = Math.round(agent.x);
+    agent.y = Math.round(agent.y);
+    if (!isWalkable(world, agent.x, agent.y)) {
+      placeAgent(world, agent);
+    } else {
+      updateSeat(world, agent);
+      routeTo(world, agent, goalFor(world, agent));
+    }
+  }
+}
+
 function firstWalkable(world: World): { x: number; y: number } {
   for (let y = 0; y < world.rows; y++) for (let x = 0; x < world.cols; x++) if (isWalkable(world, x, y)) return { x, y };
   return { x: 0, y: 0 };
 }
 
-/** Where this agent's current state wants them to be. */
+const NEEDS_DESK: readonly AgentState[] = ["working", "thinking", "blocked"];
+
+/** Desks belong to whoever is working at one: claimed when an agent starts, freed when it stops. */
+function updateSeat(world: World, agent: Agent): void {
+  if (!NEEDS_DESK.includes(agent.state)) {
+    agent.seat = undefined;
+    return;
+  }
+  const room = world.rooms.find((candidate) => candidate.id === agent.area);
+  const inRoom = (seat: { x: number; y: number }): boolean =>
+    Boolean(room) && seat.x >= (room as Room).x && seat.x < (room as Room).x + (room as Room).w && seat.y >= (room as Room).y && seat.y < (room as Room).y + (room as Room).h;
+  // Moved to another room: this desk is no longer the right one.
+  if (agent.seat && (!room || inRoom(agent.seat))) return;
+  agent.seat = undefined;
+  const taken = new Set(world.agents.filter((other) => other !== agent && other.seat).map((other) => `${other.seat?.x},${other.seat?.y}`));
+  const free = world.seats.filter((seat) => !taken.has(`${seat.x},${seat.y}`));
+  agent.seat = room ? free.find(inRoom) : free[0];
+}
+
+/** Where an agent is standing, or heading to if it is walking. */
+function standing(agent: Agent): { x: number; y: number } {
+  const end = agent.path[agent.path.length - 1];
+  return end ?? { x: Math.round(agent.x), y: Math.round(agent.y) };
+}
+
+/** The closest tile to a spot that no other agent is on, so they don't stand inside each other. */
+function freeTileNear(world: World, agent: Agent, spot: { x: number; y: number }): { x: number; y: number } {
+  const others = new Set(world.agents.filter((other) => other !== agent && other.state !== "away").map((other) => {
+    const at = standing(other);
+    return `${at.x},${at.y}`;
+  }));
+  for (let radius = 0; radius <= 4; radius++) {
+    for (let dy = -radius; dy <= radius; dy++) {
+      for (let dx = -radius; dx <= radius; dx++) {
+        if (Math.abs(dx) + Math.abs(dy) !== radius) continue;
+        const tile = { x: spot.x + dx, y: spot.y + dy };
+        if (isWalkable(world, tile.x, tile.y) && !others.has(`${tile.x},${tile.y}`) && findPath(world, spot, tile)) return tile;
+      }
+    }
+  }
+  return spot;
+}
+
+/** Where this agent's current state wants it to be. */
 export function goalFor(world: World, agent: Agent): { x: number; y: number } | undefined {
-  const pick = (spots: { x: number; y: number }[]): { x: number; y: number } | undefined =>
-    spots.length > 0 ? spots[(agent.seed + Math.floor(agent.rest * 1000)) % spots.length] : undefined;
+  const pick = (spots: { x: number; y: number }[]): { x: number; y: number } | undefined => {
+    const spot = spots.length > 0 ? spots[(agent.seed + Math.floor(agent.rest * 1000)) % spots.length] : undefined;
+    return spot && freeTileNear(world, agent, spot);
+  };
   switch (agent.state) {
     case "working":
     case "thinking":
-    case "blocked":
-      return agent.seat ?? pick(world.spots.lounge);
+    case "blocked": {
+      if (agent.seat) return agent.seat;
+      // No free desk in the room they are working in: they stand in it anyway.
+      const room = world.rooms.find((candidate) => candidate.id === agent.area);
+      if (room && room.w > 0 && room.h > 0) return freeTileNear(world, agent, { x: room.x + (room.w >> 1), y: room.y + (room.h >> 1) });
+      return pick(world.spots.lounge);
+    }
     case "reviewing":
       return pick(world.spots.board) ?? agent.seat;
     case "idle":
@@ -262,6 +330,7 @@ export function goalFor(world: World, agent: Agent): { x: number; y: number } |
 }
 
 function placeAgent(world: World, agent: Agent): void {
+  updateSeat(world, agent);
   const goal = goalFor(world, agent) ?? agent.seat ?? firstWalkable(world);
   agent.x = goal.x;
   agent.y = goal.y;
@@ -307,6 +376,7 @@ export function step(world: World, dt: number): void {
     }
 
     agent.walking = false;
+    if (agent.party > 0) agent.party = Math.max(0, agent.party - dt);
     if (agent.state === "idle") {
       agent.rest -= dt;
       if (agent.rest <= 0) {
@@ -324,25 +394,39 @@ export function applyUpdate(world: World, scene: Pick<OfficeScene, "agents" | "t
   if (Array.isArray(scene.tasks)) world.tasks = list<OfficeTask>(scene.tasks, MAX_TASKS).map(toTask);
   if (!Array.isArray(scene.agents)) return;
   const existing = new Map(world.agents.map((agent) => [agent.id, agent]));
-  const seats = world.furniture
-    .filter((item) => item.type === "desk")
-    .map((item) => ({ x: item.x + 1, y: item.y + 2 }))
-    .filter((point) => isWalkable(world, point.x, point.y));
-  world.agents = list<OfficeAgent>(scene.agents, MAX_AGENTS).map((raw, index) => {
-    const next = toAgent(raw, index);
+  const incoming = list<OfficeAgent>(scene.agents, MAX_AGENTS).map(toAgent);
+  world.agents = incoming.map((next) => existing.get(next.id)).filter((agent): agent is Agent => Boolean(agent));
+  const updated = incoming.map((next) => {
     const current = existing.get(next.id);
-    next.seat = seats[index];
     if (!current) {
       placeAgent(world, next);
+      world.agents = [...world.agents, next];
+      // New arrivals come in through a door and walk to where they are going.
+      const door = world.doors[0];
+      const goal = { x: next.x, y: next.y };
+      if (door && next.state !== "away") {
+        next.x = door.x;
+        next.y = door.y;
+        routeTo(world, next, goal);
+      }
       return next;
     }
-    Object.assign(current, { name: next.name, role: next.role, task: next.task, hair: next.hair, skin: next.skin, shirt: next.shirt, seat: next.seat });
-    if (current.state !== next.state) {
+    Object.assign(current, { name: next.name, role: next.role, task: next.task, hair: next.hair, skin: next.skin, shirt: next.shirt });
+    const moved = current.area !== next.area;
+    current.area = next.area;
+    if (current.state !== next.state || moved) {
+      if (next.state === "done" && current.state !== "done") current.party = 3;
       current.state = next.state;
+      updateSeat(world, current);
       if (next.state !== "away") routeTo(world, current, goalFor(world, current));
+    } else if (NEEDS_DESK.includes(current.state) && !current.seat) {
+      // No desk was free before. One may be now.
+      updateSeat(world, current);
+      if (current.seat) routeTo(world, current, current.seat);
     }
     return current;
   });
+  world.agents = updated;
 }
 
 /** Agent under a point given in tiles, nearest first. */

package/src/worlds/office-data.ts

@@ -0,0 +1,57 @@
+/** The office as data: what furniture exists, how big it is, what it's for, and what things are called. */
+
+import type { WorldData } from "../pack.js";
+import type { OfficeDoor, OfficeFurniture, OfficeRoom } from "../types.js";
+
+/** Footprint in tiles, and where someone stands to use it, relative to its corner. */
+export const OFFICE_ITEMS: WorldData["items"] = {
+  desk: { w: 3, h: 2, spot: { x: 1, y: 2 }, use: "seat" },
+  coffee: { w: 2, h: 1, spot: { x: 0, y: 1 }, use: "lounge" },
+  water: { w: 1, h: 1, spot: { x: 0, y: 1 }, use: "lounge" },
+  sofa: { w: 3, h: 1, spot: { x: 1, y: 1 }, use: "lounge" },
+  plant: { w: 1, h: 1 },
+  fern: { w: 1, h: 1 },
+  board: { w: 4, h: 1, spot: { x: 1, y: 1 }, use: "board" },
+  whiteboard: { w: 3, h: 1, spot: { x: 1, y: 1 }, use: "board" },
+  shelf: { w: 2, h: 1, spot: { x: 0, y: 1 }, use: "lounge" },
+  server: { w: 1, h: 1 },
+  table: { w: 3, h: 2, spot: { x: 1, y: 2 }, use: "board" },
+  rug: { w: 4, h: 3, solid: false },
+  arcade: { w: 1, h: 1, spot: { x: 0, y: 1 }, use: "lounge" },
+  fridge: { w: 1, h: 1, spot: { x: 0, y: 1 }, use: "lounge" },
+  printer: { w: 1, h: 1, spot: { x: 0, y: 1 } },
+  lamp: { w: 1, h: 1 },
+  beanbag: { w: 1, h: 1, spot: { x: 0, y: 1 }, use: "lounge" },
+  tv: { w: 3, h: 1, spot: { x: 1, y: 2 }, use: "lounge" },
+  vending: { w: 1, h: 1, spot: { x: 0, y: 1 }, use: "lounge" },
+  trophy: { w: 1, h: 1 },
+  clock: { w: 1, h: 1, solid: false, wall: true },
+  poster: { w: 1, h: 1, solid: false, wall: true },
+};
+
+export const OFFICE_LAYOUT = {
+  cols: 26,
+  rows: 17,
+  rooms: [
+    { id: "studio", name: "Studio", x: 1, y: 3, w: 15, h: 13, floor: "wood" },
+    { id: "lounge", name: "Lounge", x: 17, y: 3, w: 8, h: 6, floor: "carpet" },
+    { id: "quests", name: "Quests", x: 17, y: 10, w: 8, h: 6, floor: "tile" },
+  ] as OfficeRoom[],
+  doors: [{ x: 16, y: 6 }, { x: 16, y: 13 }, { x: 23, y: 9 }] as OfficeDoor[],
+  furniture: [
+    { type: "desk", x: 2, y: 4 }, { type: "desk", x: 7, y: 4 }, { type: "desk", x: 12, y: 4 },
+    { type: "desk", x: 2, y: 10 }, { type: "desk", x: 7, y: 10 }, { type: "desk", x: 12, y: 10 },
+    { type: "plant", x: 1, y: 8 }, { type: "plant", x: 15, y: 8 }, { type: "server", x: 15, y: 15 }, { type: "server", x: 14, y: 15 },
+    { type: "shelf", x: 1, y: 15 },
+    { type: "coffee", x: 19, y: 3 }, { type: "water", x: 21, y: 3 }, { type: "sofa", x: 22, y: 3 }, { type: "rug", x: 20, y: 5 }, { type: "plant", x: 24, y: 8 },
+    { type: "board", x: 19, y: 10 }, { type: "table", x: 19, y: 13 }, { type: "plant", x: 24, y: 15 },
+  ] as OfficeFurniture[],
+};
+
+export const OFFICE: WorldData = {
+  id: "office",
+  name: "Pixel Office",
+  words: { quests: "QUESTS" },
+  items: OFFICE_ITEMS,
+  layout: OFFICE_LAYOUT,
+};