@agent-os-lab/agent-game-sdk 0.1.3 → 0.1.5

package/src/office/layout/resolver.ts

@@ -0,0 +1,978 @@
+import type { AgentGameOfficeAgent, AgentGameOfficeZoneId } from "../core/types";
+import {
+  type AgentGameOfficeConfig,
+  type AgentGameOfficeRoomType,
+  normalizeOfficeConfig,
+} from "./config";
+
+const OFFICE_LAYOUT_SCALE = 1.2;
+const OFFICE_FLOOR_CENTER_X = 16;
+const OFFICE_FLOOR_WIDTH = 68 * OFFICE_LAYOUT_SCALE;
+const OFFICE_FLOOR_DEPTH = 24 * OFFICE_LAYOUT_SCALE;
+const OFFICE_FLOOR_TILE_SIZE = 3;
+const DEFAULT_ROOM_DEPTH = 34.25;
+const LARGE_MEETING_Z = 0;
+const LARGE_MEETING_CHAIRS_PER_SIDE = 8;
+const LARGE_MEETING_CHAIR_SPACING_X = 1.55 * OFFICE_LAYOUT_SCALE;
+const LARGE_MEETING_CHAIR_DISTANCE_Z = 2.55 * OFFICE_LAYOUT_SCALE;
+const ROOMS_PER_ROW = 3;
+const ROOM_ROW_GAP = 0;
+
+export type OfficeComponentKind =
+  | "desk"
+  | "officeChair"
+  | "monitor"
+  | "meetingTable"
+  | "meetingGlassRoom"
+  | "largeMeetingTable"
+  | "tableCup"
+  | "glassWall"
+  | "glassDoor"
+  | "dividerGlass"
+  | "wallWhiteboard"
+  | "wallWindow"
+  | "stickyNoteBoard"
+  | "wallClock"
+  | "sofa"
+  | "loungeSideTable"
+  | "bookcase"
+  | "teaCounter"
+  | "waterDispenser"
+  | "presentationBoard"
+  | "mobileDisplayStand"
+  | "treadmill"
+  | "stationaryBike"
+  | "dumbbellRack"
+  | "weightBench"
+  | "yogaMat"
+  | "gymMirror";
+
+export type ResolvedOfficeComponentInstance = {
+  id: string;
+  kind: OfficeComponentKind;
+  roomId: string | null;
+  position: { x: number; y?: number; z: number };
+  rotation?: number;
+  scale?: number;
+  props?: {
+    width?: number;
+    depth?: number;
+    height?: number;
+    color?: number;
+    topColor?: number;
+    legColor?: number;
+    screenColor?: number;
+    opacity?: number;
+    faceDirection?: -1 | 1;
+    variant?: string;
+    roomIndex?: number;
+    wallSide?: "north" | "south";
+    omitGlassSide?: "north" | "south";
+    whiteboardSide?: "north" | "south";
+  };
+};
+
+export type ResolvedOfficeRoom = {
+  id: string;
+  type: AgentGameOfficeRoomType;
+  bounds: { x: number; z: number; width: number; depth: number };
+  capacity: number;
+};
+
+export type ResolvedFloorTile = {
+  id: string;
+  color: number;
+  x: number;
+  z: number;
+  width: number;
+  depth: number;
+};
+
+export type ResolvedWallSide = "north" | "south" | "west" | "east";
+
+export type ResolvedWall = {
+  id: string;
+  roomId: string;
+  side: ResolvedWallSide;
+  x: number;
+  z: number;
+  width: number;
+  depth: number;
+  height: number;
+  color: number;
+};
+
+export type ResolvedLight = {
+  id: string;
+  kind: "ambient" | "directional";
+  color: number;
+  intensity: number;
+  position?: { x: number; y: number; z: number };
+};
+
+export type ResolvedSeatAnchor = {
+  id: string;
+  roomId: string;
+  zoneId: AgentGameOfficeZoneId;
+  position: { x: number; z: number };
+  facing?: { x: number; z: number };
+  capacityWeight?: number;
+};
+
+export type ResolvedZoneAnchor = ResolvedSeatAnchor;
+
+export type ResolvedWallAnchor = {
+  id: string;
+  roomId: string;
+  position: { x: number; z: number };
+  rotation?: number;
+  faceDirection: -1 | 1;
+};
+
+export type ResolvedOfficeLayout = {
+  scene: {
+    width: number;
+    depth: number;
+    center: { x: number; z: number };
+    floorTileSize: number;
+    floorTiles: ResolvedFloorTile[];
+    walls: ResolvedWall[];
+    lights: ResolvedLight[];
+  };
+  rooms: ResolvedOfficeRoom[];
+  components: ResolvedOfficeComponentInstance[];
+  anchors: {
+    seats: ResolvedSeatAnchor[];
+    zones: ResolvedZoneAnchor[];
+    wallDecorations: ResolvedWallAnchor[];
+    offstage: ResolvedSeatAnchor;
+  };
+};
+
+type MutableResolvedLayout = ResolvedOfficeLayout & {
+  components: ResolvedOfficeComponentInstance[];
+  anchors: ResolvedOfficeLayout["anchors"] & {
+    seats: ResolvedSeatAnchor[];
+    zones: ResolvedZoneAnchor[];
+    wallDecorations: ResolvedWallAnchor[];
+  };
+};
+
+const DESK_TEMPLATE = [
+  { seat: { x: scaleOfficeX(-12), z: scaleOfficeZ(-6.2) }, rotation: Math.PI, desk: { x: scaleOfficeX(-12), z: scaleOfficeZ(-8) } },
+  { seat: { x: scaleOfficeX(-7), z: scaleOfficeZ(-6.2) }, rotation: Math.PI, desk: { x: scaleOfficeX(-7), z: scaleOfficeZ(-8) } },
+  { seat: { x: scaleOfficeX(-2), z: scaleOfficeZ(-6.2) }, rotation: Math.PI, desk: { x: scaleOfficeX(-2), z: scaleOfficeZ(-8) } },
+  { seat: { x: scaleOfficeX(3), z: scaleOfficeZ(-6.2) }, rotation: Math.PI, desk: { x: scaleOfficeX(3), z: scaleOfficeZ(-8) } },
+  { seat: { x: scaleOfficeX(-12), z: scaleOfficeZ(-1.2) }, rotation: Math.PI, desk: { x: scaleOfficeX(-12), z: scaleOfficeZ(-3) } },
+  { seat: { x: scaleOfficeX(-7), z: scaleOfficeZ(-1.2) }, rotation: Math.PI, desk: { x: scaleOfficeX(-7), z: scaleOfficeZ(-3) } },
+  { seat: { x: scaleOfficeX(-2), z: scaleOfficeZ(-1.2) }, rotation: Math.PI, desk: { x: scaleOfficeX(-2), z: scaleOfficeZ(-3) } },
+  { seat: { x: scaleOfficeX(3), z: scaleOfficeZ(-1.2) }, rotation: Math.PI, desk: { x: scaleOfficeX(3), z: scaleOfficeZ(-3) } },
+  { seat: { x: scaleOfficeX(-12), z: scaleOfficeZ(3.8) }, rotation: Math.PI, desk: { x: scaleOfficeX(-12), z: scaleOfficeZ(2) } },
+  { seat: { x: scaleOfficeX(-7), z: scaleOfficeZ(3.8) }, rotation: Math.PI, desk: { x: scaleOfficeX(-7), z: scaleOfficeZ(2) } },
+  { seat: { x: scaleOfficeX(-2), z: scaleOfficeZ(3.8) }, rotation: Math.PI, desk: { x: scaleOfficeX(-2), z: scaleOfficeZ(2) } },
+  { seat: { x: scaleOfficeX(3), z: scaleOfficeZ(3.8) }, rotation: Math.PI, desk: { x: scaleOfficeX(3), z: scaleOfficeZ(2) } },
+] as const;
+
+const MEETING_ROOMS = [
+  {
+    center: { x: scaleOfficeX(16.5), z: scaleOfficeZ(3.6) },
+    seats: [
+      { x: scaleOfficeX(13.7), z: scaleOfficeZ(1.4), rotation: Math.PI / 2 },
+      { x: scaleOfficeX(13.7), z: scaleOfficeZ(2.8), rotation: Math.PI / 2 },
+      { x: scaleOfficeX(13.7), z: scaleOfficeZ(4.4), rotation: Math.PI / 2 },
+      { x: scaleOfficeX(13.7), z: scaleOfficeZ(5.8), rotation: Math.PI / 2 },
+      { x: scaleOfficeX(19.3), z: scaleOfficeZ(1.4), rotation: -Math.PI / 2 },
+      { x: scaleOfficeX(19.3), z: scaleOfficeZ(2.8), rotation: -Math.PI / 2 },
+      { x: scaleOfficeX(19.3), z: scaleOfficeZ(4.4), rotation: -Math.PI / 2 },
+      { x: scaleOfficeX(19.3), z: scaleOfficeZ(5.8), rotation: -Math.PI / 2 },
+    ],
+    signColor: 0x3498db,
+    topColor: 0xb8860b,
+    legColor: 0x8b6914,
+    tableDepth: 6.4,
+    roomDepth: 9.6 * OFFICE_LAYOUT_SCALE,
+    wallSide: undefined,
+    omitGlassSide: "north",
+    whiteboardSide: "north",
+  },
+  {
+    center: { x: scaleOfficeX(16.5), z: scaleOfficeZ(-7.25) },
+    seats: [
+      { x: scaleOfficeX(13.7), z: scaleOfficeZ(-8.25), rotation: Math.PI / 2 },
+      { x: scaleOfficeX(13.7), z: scaleOfficeZ(-6.25), rotation: Math.PI / 2 },
+      { x: scaleOfficeX(19.3), z: scaleOfficeZ(-8.25), rotation: -Math.PI / 2 },
+      { x: scaleOfficeX(19.3), z: scaleOfficeZ(-6.25), rotation: -Math.PI / 2 },
+    ],
+    signColor: 0xe67e22,
+    topColor: 0xa0522d,
+    legColor: 0x8b4513,
+    tableDepth: 3,
+    roomDepth: 7.8 * OFFICE_LAYOUT_SCALE,
+    wallSide: "north",
+    omitGlassSide: "north",
+    whiteboardSide: "north",
+  },
+] as const;
+
+const LARGE_MEETING_X = (scaleOfficeX(24) + (OFFICE_FLOOR_CENTER_X + OFFICE_FLOOR_WIDTH / 2)) / 2;
+const LOUNGE_CENTER = { x: scaleOfficeX(4.8), z: scaleOfficeZ(8.2) } as const;
+
+export function resolveOfficeLayout(config?: AgentGameOfficeConfig): ResolvedOfficeLayout {
+  const normalized = normalizeOfficeConfig(config);
+  const offstage = createAnchor("offstage", "offstage-1", "offstage", "offstage", scaleOfficeX(-13), scaleOfficeZ(8), {
+    x: scaleOfficeX(-13),
+    z: scaleOfficeZ(8),
+  });
+  const layout: MutableResolvedLayout = {
+    scene: {
+      width: OFFICE_FLOOR_WIDTH,
+      depth: OFFICE_FLOOR_DEPTH,
+      center: { x: OFFICE_FLOOR_CENTER_X, z: 0 },
+      floorTileSize: OFFICE_FLOOR_TILE_SIZE,
+      floorTiles: [],
+      walls: [],
+      lights: [
+        { id: "ambient", kind: "ambient", color: 0xffffff, intensity: 0.7 },
+        { id: "directional", kind: "directional", color: 0xffffff, intensity: 1.2, position: { x: 10, y: 18, z: 8 } },
+      ],
+    },
+    rooms: normalized.rooms.map((room, index) => createRoom(room.id, room.type, room.capacity, index)),
+    components: [],
+    anchors: {
+      seats: [],
+      zones: [],
+      wallDecorations: [],
+      offstage,
+    },
+  };
+
+  for (const room of layout.rooms) {
+    if (room.type === "office") {
+      addOfficePreset(layout, room);
+    } else if (room.type === "auditorium") {
+      addAuditoriumPreset(layout, room);
+    } else {
+      addGymPreset(layout, room);
+    }
+  }
+
+  applyAdaptiveSceneBounds(layout);
+  layout.anchors.seats.push(offstage);
+  layout.anchors.zones.push(offstage);
+  return layout;
+}
+
+export function resolveOfficeAgentAnchor(
+  layout: ResolvedOfficeLayout,
+  agent: AgentGameOfficeAgent,
+): ResolvedSeatAnchor {
+  const candidates = sortPreferredAnchors(layout, layout.anchors.seats
+    .filter((anchor) => anchor.zoneId === agent.zoneId)
+    .sort(compareAnchorId), agent.zoneId);
+  if (candidates.length > 0) {
+    return candidates[stableHash(agent.id) % candidates.length]!;
+  }
+
+  const available = layout.anchors.seats
+    .filter((anchor) => anchor.zoneId !== "offstage")
+    .sort(compareAnchorId);
+  if (available.length > 0) {
+    return available[stableHash(agent.id) % available.length]!;
+  }
+
+  return layout.anchors.offstage;
+}
+
+function sortPreferredAnchors(
+  layout: ResolvedOfficeLayout,
+  anchors: ResolvedSeatAnchor[],
+  zoneId: AgentGameOfficeZoneId,
+): ResolvedSeatAnchor[] {
+  if (zoneId !== "meeting-room") {
+    return anchors;
+  }
+  const roomTypes = new Map(layout.rooms.map((room) => [room.id, room.type]));
+  const auditoriumAnchors = anchors.filter((anchor) => roomTypes.get(anchor.roomId) === "auditorium");
+  return auditoriumAnchors.length > 0 ? auditoriumAnchors : anchors;
+}
+
+function addOfficePreset(layout: MutableResolvedLayout, room: ResolvedOfficeRoom) {
+  const northWallFaceZ = -OFFICE_FLOOR_DEPTH / 2 + 0.28;
+  addWallDecoration(layout, room, "wallWhiteboard", "office-whiteboard", scaleOfficeX(3.8), northWallFaceZ, 0, 1);
+  addWallDecoration(layout, room, "stickyNoteBoard", "sticky-notes", scaleOfficeX(-11.5), northWallFaceZ, 0, 1);
+  addWallDecoration(layout, room, "wallClock", "wall-clock", scaleOfficeX(-2.2), northWallFaceZ, 0, 1);
+
+  DESK_TEMPLATE.forEach((slot, index) => {
+    addComponent(layout, room.id, "desk", `desk-${index + 1}`, slot.desk.x, slot.desk.z);
+    addComponent(layout, room.id, "officeChair", `desk-chair-${index + 1}`, slot.seat.x, slot.seat.z, { rotation: slot.rotation });
+    addComponent(layout, room.id, "monitor", `monitor-${index + 1}`, slot.desk.x, slot.desk.z - 0.4);
+    addSeat(layout, room.id, `desk-${index + 1}`, "desk", slot.seat.x, slot.seat.z, { x: scaleOfficeX(-7), z: scaleOfficeZ(-5) });
+  });
+
+  MEETING_ROOMS.forEach((meetingRoom, roomIndex) => {
+    addComponent(layout, room.id, "meetingGlassRoom", `meeting-glass-room-${roomIndex + 1}`, meetingRoom.center.x, meetingRoom.center.z, {
+      props: {
+        roomIndex,
+        depth: meetingRoom.roomDepth,
+        wallSide: meetingRoom.wallSide,
+        omitGlassSide: meetingRoom.omitGlassSide,
+        whiteboardSide: meetingRoom.whiteboardSide,
+      },
+    });
+    addComponent(layout, room.id, "meetingTable", `meeting-table-${roomIndex + 1}`, meetingRoom.center.x, meetingRoom.center.z, {
+      props: {
+        topColor: meetingRoom.topColor,
+        legColor: meetingRoom.legColor,
+        depth: meetingRoom.tableDepth,
+      },
+    });
+    meetingRoom.seats.forEach((seat, seatIndex) => {
+      addComponent(layout, room.id, "officeChair", `meeting-chair-${roomIndex + 1}-${seatIndex + 1}`, seat.x, seat.z, {
+        rotation: seat.rotation,
+      });
+      addSeat(layout, room.id, `meeting-${roomIndex + 1}-${seatIndex + 1}`, "meeting-room", seat.x, seat.z, {
+        x: meetingRoom.center.x,
+        z: meetingRoom.center.z,
+      });
+    });
+  });
+  addComponent(layout, room.id, "sofa", "lounge-sofa", LOUNGE_CENTER.x, LOUNGE_CENTER.z);
+  addComponent(layout, room.id, "loungeSideTable", "lounge-side-table", LOUNGE_CENTER.x - 3.05, LOUNGE_CENTER.z - 0.05);
+  addComponent(layout, room.id, "bookcase", "lounge-bookcase", LOUNGE_CENTER.x + 3.25, LOUNGE_CENTER.z + 0.15);
+  for (let index = 0; index < Math.max(4, Math.min(room.capacity, 12)); index += 1) {
+    addSeat(
+      layout,
+      room.id,
+      `lounge-${index + 1}`,
+      "lounge",
+      LOUNGE_CENTER.x - 1.7 * OFFICE_LAYOUT_SCALE + (index % 4) * 1.15 * OFFICE_LAYOUT_SCALE,
+      LOUNGE_CENTER.z - 0.8 * OFFICE_LAYOUT_SCALE + Math.floor(index / 4) * 0.95 * OFFICE_LAYOUT_SCALE,
+      { x: LOUNGE_CENTER.x, z: LOUNGE_CENTER.z },
+    );
+  }
+
+  addComponent(layout, room.id, "teaCounter", "tea-counter", scaleOfficeX(-14.8), scaleOfficeZ(10.4));
+  addComponent(layout, room.id, "waterDispenser", "water-dispenser", scaleOfficeX(-16.9), scaleOfficeZ(10.4));
+  addSeat(layout, room.id, "pantry-1", "pantry", scaleOfficeX(-9.2), scaleOfficeZ(5.2), {
+    x: scaleOfficeX(-9.2),
+    z: scaleOfficeZ(5.2),
+  });
+  addSeat(layout, room.id, "review-1", "review-area", scaleOfficeX(0.5) + 2.2 * OFFICE_LAYOUT_SCALE, scaleOfficeZ(4), {
+    x: scaleOfficeX(0.5),
+    z: scaleOfficeZ(3.05),
+  });
+}
+
+function addAuditoriumPreset(layout: MutableResolvedLayout, room: ResolvedOfficeRoom) {
+  addComponent(layout, room.id, "largeMeetingTable", "large-meeting-table", LARGE_MEETING_X, LARGE_MEETING_Z);
+  for (let index = 0; index < LARGE_MEETING_CHAIRS_PER_SIDE * 2; index += 1) {
+    const side = index < LARGE_MEETING_CHAIRS_PER_SIDE ? -1 : 1;
+    const offset = (index % LARGE_MEETING_CHAIRS_PER_SIDE) - (LARGE_MEETING_CHAIRS_PER_SIDE - 1) / 2;
+    const x = LARGE_MEETING_X + offset * LARGE_MEETING_CHAIR_SPACING_X;
+    const z = LARGE_MEETING_Z + side * LARGE_MEETING_CHAIR_DISTANCE_Z;
+    addComponent(layout, room.id, "officeChair", `auditorium-chair-${index + 1}`, x, z, {
+      rotation: side === -1 ? 0 : Math.PI,
+    });
+    addComponent(layout, room.id, "tableCup", `auditorium-cup-${index + 1}`, x, LARGE_MEETING_Z + side * 1.75);
+    addSeat(layout, room.id, `auditorium-${index + 1}`, "meeting-room", x, z, {
+      x: LARGE_MEETING_X,
+      z: LARGE_MEETING_Z,
+    });
+  }
+  addComponent(layout, room.id, "officeChair", "auditorium-host-chair", LARGE_MEETING_X - 9.1, LARGE_MEETING_Z, {
+    rotation: Math.PI / 2,
+  });
+  addComponent(layout, room.id, "tableCup", "auditorium-host-cup", LARGE_MEETING_X - 7.6, LARGE_MEETING_Z);
+  addComponent(layout, room.id, "mobileDisplayStand", "auditorium-mobile-display", LARGE_MEETING_X + 9.3, LARGE_MEETING_Z, {
+    rotation: -Math.PI / 2,
+  });
+  addSeat(layout, room.id, "auditorium-host", "meeting-room", LARGE_MEETING_X - 9.1, LARGE_MEETING_Z, {
+    x: LARGE_MEETING_X,
+    z: LARGE_MEETING_Z,
+  });
+}
+
+function addGymPreset(layout: MutableResolvedLayout, room: ResolvedOfficeRoom) {
+  const baseX = scaleOfficeX(72);
+  addComponent(layout, room.id, "treadmill", "treadmill-1", baseX - 5, scaleOfficeZ(-5));
+  addComponent(layout, room.id, "treadmill", "treadmill-2", baseX - 1.8, scaleOfficeZ(-5));
+  addComponent(layout, room.id, "stationaryBike", "bike-1", baseX + 2.2, scaleOfficeZ(-5));
+  addComponent(layout, room.id, "dumbbellRack", "dumbbell-rack", baseX - 4.2, scaleOfficeZ(4.8));
+  addComponent(layout, room.id, "weightBench", "weight-bench", baseX - 0.6, scaleOfficeZ(4));
+  addComponent(layout, room.id, "yogaMat", "yoga-mat-1", baseX + 3.2, scaleOfficeZ(2.6), {
+    rotation: Math.PI / 2,
+  });
+  addComponent(layout, room.id, "yogaMat", "yoga-mat-2", baseX + 3.2, scaleOfficeZ(5.1), {
+    rotation: Math.PI / 2,
+  });
+  addComponent(layout, room.id, "gymMirror", "mirror-wall", baseX, scaleOfficeZ(-8), {
+    props: { width: 7.2, faceDirection: 1 },
+  });
+
+  const fixedAnchors = [
+    { id: "treadmill-1", x: baseX - 5, z: scaleOfficeZ(-2.5), facing: { x: baseX - 5, z: scaleOfficeZ(-5) } },
+    { id: "treadmill-2", x: baseX - 1.8, z: scaleOfficeZ(-2.5), facing: { x: baseX - 1.8, z: scaleOfficeZ(-5) } },
+    { id: "bike-1", x: baseX + 2.2, z: scaleOfficeZ(-2.8), facing: { x: baseX + 2.2, z: scaleOfficeZ(-5) } },
+    { id: "yoga-1", x: baseX + 3.2, z: scaleOfficeZ(2.6), facing: { x: baseX + 3.2, z: scaleOfficeZ(2.6) } },
+    { id: "yoga-2", x: baseX + 3.2, z: scaleOfficeZ(5.1), facing: { x: baseX + 3.2, z: scaleOfficeZ(5.1) } },
+    { id: "weights-1", x: baseX - 2.2, z: scaleOfficeZ(4.4), facing: { x: baseX - 4.2, z: scaleOfficeZ(4.8) } },
+  ];
+
+  fixedAnchors.forEach((anchor) => {
+    addSeat(layout, room.id, anchor.id, "lounge", anchor.x, anchor.z, anchor.facing);
+  });
+
+  const extraCount = Math.max(0, Math.min(room.capacity, 12) - fixedAnchors.length);
+  for (let index = 0; index < extraCount; index += 1) {
+    addSeat(
+      layout,
+      room.id,
+      `open-${index + 1}`,
+      "lounge",
+      baseX - 3 + index * 1.15,
+      scaleOfficeZ(0.2),
+      { x: baseX, z: scaleOfficeZ(0.2) },
+    );
+  }
+}
+
+function createRoom(
+  id: string,
+  type: AgentGameOfficeRoomType,
+  capacity: number,
+  index: number,
+): ResolvedOfficeRoom {
+  const floorMinX = OFFICE_FLOOR_CENTER_X - OFFICE_FLOOR_WIDTH / 2;
+  const splitX = scaleOfficeX(24);
+  const floorMaxX = OFFICE_FLOOR_CENTER_X + OFFICE_FLOOR_WIDTH / 2;
+  const isOffice = type === "office";
+  return {
+    id,
+    type,
+    capacity,
+    bounds: {
+      x: isOffice ? (floorMinX + splitX) / 2 : (splitX + floorMaxX) / 2 + index * OFFICE_FLOOR_WIDTH,
+      z: 0,
+      width: isOffice ? splitX - floorMinX : floorMaxX - splitX,
+      depth: OFFICE_FLOOR_DEPTH,
+    },
+  };
+}
+
+function applyAdaptiveSceneBounds(layout: MutableResolvedLayout) {
+  const roomBounds = new Map<string, { minX: number; maxX: number; minZ: number; maxZ: number }>();
+  const allBounds = createEmptyBounds();
+
+  for (const component of layout.components) {
+    if (!component.roomId) {
+      continue;
+    }
+    const extent = getComponentFootprint(component);
+    const bounds = roomBounds.get(component.roomId) ?? createEmptyBounds();
+    includeBounds(bounds, component.position.x - extent.width / 2, component.position.z - extent.depth / 2);
+    includeBounds(bounds, component.position.x + extent.width / 2, component.position.z + extent.depth / 2);
+    includeBounds(allBounds, component.position.x - extent.width / 2, component.position.z - extent.depth / 2);
+    includeBounds(allBounds, component.position.x + extent.width / 2, component.position.z + extent.depth / 2);
+    roomBounds.set(component.roomId, bounds);
+  }
+
+  const padding = 3 * OFFICE_LAYOUT_SCALE;
+  const sceneMinX = allBounds.minX - padding;
+  const sceneMaxX = allBounds.maxX + padding;
+  const sceneMinZ = allBounds.minZ - padding;
+  const sceneMaxZ = allBounds.maxZ + padding;
+  const width = Math.max(12 * OFFICE_LAYOUT_SCALE, sceneMaxX - sceneMinX);
+  const depth = Math.max(DEFAULT_ROOM_DEPTH, sceneMaxZ - sceneMinZ);
+  const center = { x: (sceneMinX + sceneMaxX) / 2, z: (sceneMinZ + sceneMaxZ) / 2 };
+
+  layout.scene.width = width;
+  layout.scene.depth = depth;
+  layout.scene.center = center;
+  layout.scene.floorTiles = layout.rooms.map((room) => {
+    const bounds = roomBounds.get(room.id);
+    if (!bounds) {
+      return {
+        id: `floor-${room.id}`,
+        color: getRoomFloorColor(room.type),
+        x: center.x,
+        z: center.z,
+        width,
+        depth,
+      };
+    }
+
+    const roomMinX = bounds.minX - padding;
+    const roomMaxX = bounds.maxX + padding;
+    const roomMinZ = bounds.minZ - padding;
+    const roomMaxZ = bounds.maxZ + padding;
+    room.bounds = {
+      x: (roomMinX + roomMaxX) / 2,
+      z: (roomMinZ + roomMaxZ) / 2,
+      width: Math.max(12 * OFFICE_LAYOUT_SCALE, roomMaxX - roomMinX),
+      depth: Math.max(DEFAULT_ROOM_DEPTH, roomMaxZ - roomMinZ),
+    };
+    return {
+      id: `floor-${room.id}`,
+      color: getRoomFloorColor(room.type),
+      x: room.bounds.x,
+      z: room.bounds.z,
+      width: room.bounds.width,
+      depth: room.bounds.depth,
+    };
+  });
+  packRoomBounds(layout);
+  attachMeetingRoomsToOfficeWalls(layout);
+  attachWallDecorationsToRoomWalls(layout);
+  layout.scene.walls = createRoomWalls(layout.rooms);
+  addRoomWindows(layout);
+  updateSceneBoundsFromRooms(layout);
+}
+
+function getRoomFloorColor(type: AgentGameOfficeRoomType): number {
+  switch (type) {
+    case "office":
+      return 0xe5e7eb;
+    case "auditorium":
+      return 0xdbe4ec;
+    case "gym":
+      return 0xd7e3d2;
+  }
+}
+
+function packRoomBounds(layout: MutableResolvedLayout) {
+  const floorTilesById = new Map(layout.scene.floorTiles.map((tile) => [tile.id, tile]));
+  const rows: ResolvedOfficeRoom[][] = [];
+  layout.rooms.forEach((room, index) => {
+    const row = Math.floor(index / ROOMS_PER_ROW);
+    rows[row] ??= [];
+    rows[row]!.push(room);
+  });
+
+  let nextRowMinZ = 0;
+  for (const row of rows) {
+    const rowDepth = Math.max(...row.map((room) => room.bounds.depth));
+    const rowCenterZ = nextRowMinZ + rowDepth / 2;
+    let nextMinX = 0;
+    for (const room of row) {
+      const previousBounds = room.bounds;
+      const nextCenterX = nextMinX + previousBounds.width / 2;
+      const deltaX = nextCenterX - previousBounds.x;
+      const deltaZ = rowCenterZ - previousBounds.z;
+      room.bounds = {
+        ...previousBounds,
+        x: nextCenterX,
+        z: rowCenterZ,
+        depth: rowDepth,
+      };
+      moveRoomContents(layout, room.id, deltaX, deltaZ);
+
+      const tile = floorTilesById.get(`floor-${room.id}`);
+      if (tile) {
+        tile.x = room.bounds.x;
+        tile.z = room.bounds.z;
+        tile.width = room.bounds.width;
+        tile.depth = room.bounds.depth;
+      }
+      nextMinX += previousBounds.width;
+    }
+    nextRowMinZ += rowDepth + ROOM_ROW_GAP;
+  }
+}
+
+function moveRoomContents(layout: MutableResolvedLayout, roomId: string, deltaX: number, deltaZ: number) {
+  if (nearlyEqual(deltaX, 0) && nearlyEqual(deltaZ, 0)) {
+    return;
+  }
+  for (const component of layout.components) {
+    if (component.roomId !== roomId) {
+      continue;
+    }
+    component.position = {
+      ...component.position,
+      x: component.position.x + deltaX,
+      z: component.position.z + deltaZ,
+    };
+  }
+
+  const anchors = new Set([...layout.anchors.seats, ...layout.anchors.zones, ...layout.anchors.wallDecorations]);
+  for (const anchor of anchors) {
+    if (anchor.roomId !== roomId) {
+      continue;
+    }
+    anchor.position = {
+      x: anchor.position.x + deltaX,
+      z: anchor.position.z + deltaZ,
+    };
+    if ("facing" in anchor && anchor.facing) {
+      anchor.facing = {
+        x: anchor.facing.x + deltaX,
+        z: anchor.facing.z + deltaZ,
+      };
+    }
+  }
+}
+
+function updateSceneBoundsFromRooms(layout: MutableResolvedLayout) {
+  const bounds = createEmptyBounds();
+  for (const room of layout.rooms) {
+    const edges = getRoomEdges(room);
+    includeBounds(bounds, edges.minX, edges.minZ);
+    includeBounds(bounds, edges.maxX, edges.maxZ);
+  }
+  layout.scene.width = bounds.maxX - bounds.minX;
+  layout.scene.depth = bounds.maxZ - bounds.minZ;
+  layout.scene.center = {
+    x: (bounds.minX + bounds.maxX) / 2,
+    z: (bounds.minZ + bounds.maxZ) / 2,
+  };
+}
+
+function attachMeetingRoomsToOfficeWalls(layout: MutableResolvedLayout) {
+  const officeRooms = layout.rooms.filter((room) => room.type === "office");
+  for (const room of officeRooms) {
+    const roomEdges = getRoomEdges(room);
+    MEETING_ROOMS.forEach((meetingRoom, index) => {
+      const glassRoom = layout.components.find((component) => component.id === `${room.id}:meeting-glass-room-${index + 1}`);
+      const currentCenter = glassRoom?.position ?? meetingRoom.center;
+      const northMeetingDepth = MEETING_ROOMS[1]!.roomDepth;
+      const targetCenterZ = index === 0
+        ? roomEdges.minZ + northMeetingDepth + meetingRoom.roomDepth / 2
+        : roomEdges.minZ + meetingRoom.roomDepth / 2;
+      const targetCenterX = roomEdges.maxX - (11.7 * OFFICE_LAYOUT_SCALE) / 2;
+      const deltaX = targetCenterX - currentCenter.x;
+      const deltaZ = targetCenterZ - currentCenter.z;
+      moveComponent(layout, room.id, `meeting-glass-room-${index + 1}`, deltaX, deltaZ);
+      moveComponent(layout, room.id, `meeting-table-${index + 1}`, deltaX, deltaZ);
+      moveAnchor(layout, room.id, `meeting-${index + 1}`, deltaX, deltaZ);
+
+      const seatCount = meetingRoom.seats.length;
+      for (let seatIndex = 0; seatIndex < seatCount; seatIndex += 1) {
+        moveComponent(layout, room.id, `meeting-chair-${index + 1}-${seatIndex + 1}`, deltaX, deltaZ);
+        moveAnchor(layout, room.id, `meeting-${index + 1}-${seatIndex + 1}`, deltaX, deltaZ);
+      }
+    });
+  }
+}
+
+function moveComponent(layout: MutableResolvedLayout, roomId: string, componentId: string, deltaX: number, deltaZ: number) {
+  const fullId = `${roomId}:${componentId}`;
+  const component = layout.components.find((item) => item.id === fullId);
+  if (!component) {
+    return;
+  }
+  component.position = {
+    ...component.position,
+    x: component.position.x + deltaX,
+    z: component.position.z + deltaZ,
+  };
+}
+
+function moveAnchor(layout: MutableResolvedLayout, roomId: string, anchorId: string, deltaX: number, deltaZ: number) {
+  const fullId = `${roomId}:${anchorId}`;
+  const anchors = new Set([...layout.anchors.seats, ...layout.anchors.zones]);
+  for (const anchor of anchors) {
+    if (anchor.id !== fullId) {
+      continue;
+    }
+    anchor.position = {
+      x: anchor.position.x + deltaX,
+      z: anchor.position.z + deltaZ,
+    };
+    if (anchor.facing) {
+      anchor.facing = {
+        x: anchor.facing.x + deltaX,
+        z: anchor.facing.z + deltaZ,
+      };
+    }
+  }
+}
+
+function attachWallDecorationsToRoomWalls(layout: MutableResolvedLayout) {
+  const roomsById = new Map(layout.rooms.map((room) => [room.id, room]));
+  const wallDecorationIds = new Set<string>();
+  for (const anchor of layout.anchors.wallDecorations) {
+    const room = roomsById.get(anchor.roomId);
+    if (!room) {
+      continue;
+    }
+    const northWallFaceZ = getRoomEdges(room).minZ + 0.28;
+    anchor.position = {
+      ...anchor.position,
+      z: northWallFaceZ,
+    };
+    wallDecorationIds.add(anchor.id);
+  }
+
+  for (const component of layout.components) {
+    if (!wallDecorationIds.has(component.id)) {
+      continue;
+    }
+    const room = component.roomId ? roomsById.get(component.roomId) : undefined;
+    if (!room) {
+      continue;
+    }
+    component.position = {
+      ...component.position,
+      z: getRoomEdges(room).minZ + 0.28,
+    };
+  }
+}
+
+function addRoomWindows(layout: MutableResolvedLayout) {
+  for (const room of layout.rooms) {
+    const edges = getRoomEdges(room);
+    const southWallZ = edges.maxZ - 0.28;
+    const offsets = room.bounds.width > 24 ? [-room.bounds.width * 0.25, room.bounds.width * 0.25] : [0];
+    offsets.forEach((offset, index) => {
+      addComponent(layout, room.id, "wallWindow", `south-window-${index + 1}`, room.bounds.x + offset, southWallZ, {
+        props: {
+          width: 3.1,
+          height: 1.25,
+          faceDirection: -1,
+        },
+      });
+    });
+  }
+}
+
+function createRoomWalls(rooms: ResolvedOfficeRoom[]): ResolvedWall[] {
+  const walls: ResolvedWall[] = [];
+  for (const room of rooms) {
+    const bounds = getRoomEdges(room);
+    (["north", "south", "west", "east"] as const).forEach((side) => {
+      if (hasAdjacentRoomWall(rooms, room, side)) {
+        return;
+      }
+      walls.push(createRoomWall(room, bounds, side));
+    });
+  }
+  return walls;
+}
+
+function createRoomWall(
+  room: ResolvedOfficeRoom,
+  bounds: ReturnType<typeof getRoomEdges>,
+  side: ResolvedWallSide,
+): ResolvedWall {
+  const isHorizontal = side === "north" || side === "south";
+  return {
+    id: `${room.id}:${side}-wall`,
+    roomId: room.id,
+    side,
+    color: 0xe8e0d0,
+    width: isHorizontal ? room.bounds.width : 0.5,
+    height: 2.5,
+    depth: isHorizontal ? 0.5 : room.bounds.depth,
+    x: side === "west" ? bounds.minX : side === "east" ? bounds.maxX : room.bounds.x,
+    z: side === "north" ? bounds.minZ : side === "south" ? bounds.maxZ : room.bounds.z,
+  };
+}
+
+function hasAdjacentRoomWall(
+  rooms: ResolvedOfficeRoom[],
+  room: ResolvedOfficeRoom,
+  side: ResolvedWallSide,
+): boolean {
+  const current = getRoomEdges(room);
+  return rooms.some((other) => {
+    if (other.id === room.id) {
+      return false;
+    }
+
+    const next = getRoomEdges(other);
+    switch (side) {
+      case "north":
+        return nearlyEqual(current.minZ, next.maxZ) && nearlyEqual(current.minX, next.minX) && nearlyEqual(current.maxX, next.maxX);
+      case "south":
+        return nearlyEqual(current.maxZ, next.minZ) && nearlyEqual(current.minX, next.minX) && nearlyEqual(current.maxX, next.maxX);
+      case "west":
+        return nearlyEqual(current.minX, next.maxX) && nearlyEqual(current.minZ, next.minZ) && nearlyEqual(current.maxZ, next.maxZ);
+      case "east":
+        return nearlyEqual(current.maxX, next.minX) && nearlyEqual(current.minZ, next.minZ) && nearlyEqual(current.maxZ, next.maxZ);
+    }
+  });
+}
+
+function getRoomEdges(room: ResolvedOfficeRoom) {
+  return {
+    minX: room.bounds.x - room.bounds.width / 2,
+    maxX: room.bounds.x + room.bounds.width / 2,
+    minZ: room.bounds.z - room.bounds.depth / 2,
+    maxZ: room.bounds.z + room.bounds.depth / 2,
+  };
+}
+
+function nearlyEqual(left: number, right: number): boolean {
+  return Math.abs(left - right) < 0.001;
+}
+
+function createEmptyBounds() {
+  return {
+    minX: Number.POSITIVE_INFINITY,
+    maxX: Number.NEGATIVE_INFINITY,
+    minZ: Number.POSITIVE_INFINITY,
+    maxZ: Number.NEGATIVE_INFINITY,
+  };
+}
+
+function includeBounds(bounds: ReturnType<typeof createEmptyBounds>, x: number, z: number) {
+  bounds.minX = Math.min(bounds.minX, x);
+  bounds.maxX = Math.max(bounds.maxX, x);
+  bounds.minZ = Math.min(bounds.minZ, z);
+  bounds.maxZ = Math.max(bounds.maxZ, z);
+}
+
+function getComponentFootprint(component: ResolvedOfficeComponentInstance): { width: number; depth: number } {
+  switch (component.kind) {
+    case "desk":
+      return { width: 3, depth: 1.8 };
+    case "officeChair":
+      return { width: 0.9, depth: 0.9 };
+    case "monitor":
+      return { width: 1.4, depth: 0.4 };
+    case "meetingTable":
+      return { width: 5, depth: component.props?.depth ?? 3 };
+    case "meetingGlassRoom":
+      return { width: 11.7 * OFFICE_LAYOUT_SCALE, depth: component.props?.depth ?? 8 * OFFICE_LAYOUT_SCALE };
+    case "largeMeetingTable":
+      return { width: 16.4, depth: 4.5 };
+    case "tableCup":
+      return { width: 0.2, depth: 0.2 };
+    case "dividerGlass":
+      return { width: 0.08, depth: 19 * OFFICE_LAYOUT_SCALE };
+    case "wallWhiteboard":
+      return { width: 3.2, depth: 0.2 };
+    case "wallWindow":
+      return { width: component.props?.width ?? 3.1, depth: 0.2 };
+    case "stickyNoteBoard":
+      return { width: 3, depth: 0.2 };
+    case "wallClock":
+      return { width: 0.9, depth: 0.2 };
+    case "sofa":
+      return { width: 4.6, depth: 1.3 };
+    case "loungeSideTable":
+      return { width: 1, depth: 0.8 };
+    case "bookcase":
+      return { width: 1.2, depth: 0.4 };
+    case "teaCounter":
+      return { width: 2.35, depth: 0.7 };
+    case "waterDispenser":
+      return { width: 0.75, depth: 0.45 };
+    case "presentationBoard":
+      return { width: 2.2, depth: 0.4 };
+    case "mobileDisplayStand":
+      return { width: 4.2, depth: 0.8 };
+    case "treadmill":
+      return { width: 2.4, depth: 4.2 };
+    case "stationaryBike":
+      return { width: 1.5, depth: 2.1 };
+    case "dumbbellRack":
+      return { width: 3.2, depth: 0.8 };
+    case "weightBench":
+      return { width: 2.2, depth: 1.1 };
+    case "yogaMat":
+      return { width: 1.4, depth: 3.2 };
+    case "gymMirror":
+      return { width: component.props?.width ?? 5.2, depth: 0.2 };
+    case "glassWall":
+    case "glassDoor":
+      return { width: component.props?.width ?? 1, depth: component.props?.depth ?? 1 };
+  }
+}
+
+function addComponent(
+  layout: MutableResolvedLayout,
+  roomId: string,
+  kind: OfficeComponentKind,
+  id: string,
+  x: number,
+  z: number,
+  options: {
+    y?: number;
+    rotation?: number;
+    scale?: number;
+    props?: ResolvedOfficeComponentInstance["props"];
+  } = {},
+) {
+  layout.components.push({
+    id: `${roomId}:${id}`,
+    kind,
+    roomId,
+    position: { x, y: options.y, z },
+    rotation: options.rotation,
+    scale: options.scale,
+    props: options.props,
+  });
+}
+
+function addWallDecoration(
+  layout: MutableResolvedLayout,
+  room: ResolvedOfficeRoom,
+  kind: Extract<OfficeComponentKind, "wallWhiteboard" | "stickyNoteBoard" | "wallClock">,
+  id: string,
+  x: number,
+  z: number,
+  rotation: number,
+  faceDirection: -1 | 1,
+) {
+  addComponent(layout, room.id, kind, id, x, z, { rotation, props: { faceDirection } });
+  layout.anchors.wallDecorations.push({
+    id: `${room.id}:${id}`,
+    roomId: room.id,
+    position: { x, z },
+    rotation,
+    faceDirection,
+  });
+}
+
+function addSeat(
+  layout: MutableResolvedLayout,
+  roomId: string,
+  id: string,
+  zoneId: AgentGameOfficeZoneId,
+  x: number,
+  z: number,
+  facing: { x: number; z: number },
+) {
+  const anchor = createAnchor(roomId, id, zoneId, roomId, x, z, facing);
+  layout.anchors.seats.push(anchor);
+  layout.anchors.zones.push(anchor);
+}
+
+function createAnchor(
+  roomId: string,
+  id: string,
+  zoneId: AgentGameOfficeZoneId,
+  anchorRoomId: string,
+  x: number,
+  z: number,
+  facing: { x: number; z: number },
+): ResolvedSeatAnchor {
+  return {
+    id: `${roomId}:${id}`,
+    roomId: anchorRoomId,
+    zoneId,
+    position: { x, z },
+    facing,
+  };
+}
+
+function compareAnchorId(left: ResolvedSeatAnchor, right: ResolvedSeatAnchor): number {
+  return left.id.localeCompare(right.id);
+}
+
+function stableHash(value: string): number {
+  let hash = 0;
+  for (let index = 0; index < value.length; index += 1) {
+    hash = (hash * 31 + value.charCodeAt(index)) >>> 0;
+  }
+  return hash;
+}
+
+function scaleOfficeX(x: number): number {
+  return OFFICE_FLOOR_CENTER_X + (x - OFFICE_FLOOR_CENTER_X) * OFFICE_LAYOUT_SCALE;
+}
+
+function scaleOfficeZ(z: number): number {
+  return z * OFFICE_LAYOUT_SCALE;
+}