@agent-os-lab/agent-game-sdk 0.1.9 → 0.1.11

package/src/office/renderers/three/mount.ts

@@ -8,12 +8,20 @@ import type {
   AgentGameOfficeResolvedOptions,
   AgentGameOfficeSceneState,
   AgentGameOfficeSnapshot,
+  AgentNavigationError,
 } from "../../core/types";
 import type { ResolvedOfficeLayout } from "../../layout";
 import { applyAgentPose, updateAgentMotion } from "./agent-animation";
 import { createAgentBodyInstancedLayer } from "./agent-body-instancing";
 import { createAgentEffectInstancedLayer } from "./agent-effect-instancing";
-import { resolveAgentFacingTarget, resolveAgentPosition } from "./agent-layout";
+import { resolveAgentFacingTarget } from "./agent-layout";
+import {
+  advanceAgentRouteState,
+  createAgentRouteState,
+  resolveAgentRouteFloorId,
+  resolveRouteTargetPosition,
+  type RenderAgentLocationState,
+} from "./agent-route";
 import {
   type AgentLabelRecord,
   createAgentLabel,
@@ -22,7 +30,13 @@ import {
   updateAgentLabelPosition,
 } from "./agent-label";
 import { type AgentMeshParts, createAgentMesh } from "./agent-mesh";
-import { addLights, buildOfficeScene, disposeObject } from "./scene";
+import {
+  OFFICE_FLOOR_FOCUS_DIM_OPACITY,
+  addLights,
+  applyOfficeFloorFocus,
+  buildOfficeScene,
+  disposeObject,
+} from "./scene";
 
 type AgentMeshRecord = {
   id: string;
@@ -31,18 +45,20 @@ type AgentMeshRecord = {
   mesh: AgentMeshParts;
   label: AgentLabelRecord;
   target: THREE.Vector3;
+  routeState: RenderAgentLocationState;
 };
 
 export const THREE_RENDERER_PIXEL_RATIO_LIMIT = 1.5;
 export const THREE_RENDERER_TARGET_FPS = 30;
 export const THREE_RENDERER_MIN_CAMERA_DISTANCE = 8;
-export const THREE_RENDERER_MAX_CAMERA_DISTANCE = 150;
-export const THREE_RENDERER_INITIAL_CAMERA_ROTATION = { x: -0.93, y: -0.23, z: -0.29 } as const;
+export const THREE_RENDERER_MAX_CAMERA_DISTANCE = 180;
+export const THREE_RENDERER_INITIAL_CAMERA_ROTATION = { x: -0.57, y: 0.52, z: 0.31 } as const;
+export const THREE_RENDERER_INITIAL_CAMERA_POSITION = { x: 130.17, y: 100.75, z: 123.18 } as const;
 const THREE_RENDERER_CAMERA_PADDING = 1.16;
-const OFFICE_CAMERA_BOUNDS_HEIGHT = 3.2;
+const OFFICE_CAMERA_MIN_BOUNDS_HEIGHT = 3.2;
 const WORKING_FOLLOW_RESET_DELAY_MS = 30_000;
 const WORK_EXIT_WAIT_MS = 30_000;
-const WORKING_FOLLOW_CAMERA_OFFSET = new THREE.Vector3(9, 12, 12);
+const WORKING_FOLLOW_CAMERA_OFFSET = new THREE.Vector3(14, 18, 20);
 const OFFICE_CAMERA_TRANSITION_DURATION_MS = 600;
 const OFFICE_CAMERA_UP = new THREE.Vector3(0, 1, 0);
 
@@ -238,6 +254,8 @@ export function mountThreeAgentGameOffice(
   let previousFrameTime = performance.now();
   let previousRenderTime = previousFrameTime;
   let cameraTransition: OfficeCameraTransition | null = null;
+  let focusedFloorId = normalizeFocusedFloorId(_options.officeLayout, _options.focusedFloorId ?? null);
+  setFocusedFloor(focusedFloorId, false);
 
   function update(snapshot: AgentGameOfficeSnapshot) {
     latestSourceAgents = snapshot.agents;
@@ -262,11 +280,14 @@ export function mountThreeAgentGameOffice(
     latestAgents.forEach((agent, index) => {
       const record = agents.get(agent.id) ?? createAgentRecord(agent, index);
       agents.set(agent.id, record);
-      const target = resolveAgentPosition(agent, index, latestAgents.length, _options.officeLayout);
+      record.routeState = createAgentRouteState(_options.officeLayout, agent, record.routeState);
+      const target = vectorFromLike(resolveRouteTargetPosition(record.routeState));
       record.agent = agent;
       record.renderIndex = index;
       record.target.copy(target);
       record.mesh.group.visible = agent.sceneState !== "offline";
+      record.mesh.group.userData.officeFloorId = resolveAgentRouteFloorId(_options.officeLayout, record.routeState);
+      record.label.root.style.opacity = String(resolveFocusedAgentOpacity(record));
       updateAgentLabel(record.label, agent);
       updateAgentLabelPosition(record.label, record.mesh.group.position, camera, renderer.domElement);
     });
@@ -274,13 +295,16 @@ export function mountThreeAgentGameOffice(
 
   function createAgentRecord(agent: AgentGameOfficeAgent, index: number): AgentMeshRecord {
     const mesh = createAgentMesh(agent, index);
-    const position = resolveAgentPosition(agent, index, initialSnapshot.agents.length, _options.officeLayout);
+    void index;
+    const routeState = createAgentRouteState(_options.officeLayout, agent, undefined);
+    const position = vectorFromLike(routeState.currentPosition);
     mesh.group.position.copy(position);
     scene.add(mesh.group);
 
     const label = createAgentLabel(overlay);
+    label.root.style.opacity = String(resolveFocusedAgentOpacity({ routeState } as AgentMeshRecord));
 
-    return { id: agent.id, agent, renderIndex: index, mesh, label, target: position.clone() };
+    return { id: agent.id, agent, renderIndex: index, mesh, label, target: position.clone(), routeState };
   }
 
   function animate() {
@@ -312,7 +336,17 @@ export function mountThreeAgentGameOffice(
         elapsedSeconds,
         deltaSeconds,
       });
+      record.routeState = {
+        ...record.routeState,
+        currentPosition: vectorToLike(record.mesh.group.position),
+      };
+      if (!moving && record.routeState.activeRoute) {
+        record.routeState = advanceAgentRouteState(record.routeState, vectorToLike(record.mesh.group.position));
+        record.target.copy(vectorFromLike(resolveRouteTargetPosition(record.routeState)));
+      }
       record.mesh.group.visible = record.agent.sceneState !== "offline";
+      record.mesh.group.userData.officeFloorId = resolveAgentRouteFloorId(_options.officeLayout, record.routeState);
+      record.label.root.style.opacity = String(resolveFocusedAgentOpacity(record));
       applyAgentPose(record.mesh, record.agent, moving, elapsedSeconds);
       if (moving || shouldUpdateLabels) {
         updateAgentLabelPosition(record.label, record.mesh.group.position, camera, renderer.domElement);
@@ -324,10 +358,12 @@ export function mountThreeAgentGameOffice(
       mesh: record.mesh,
       renderIndex: record.renderIndex,
       visible: record.agent.sceneState !== "offline",
+      opacity: resolveFocusedAgentOpacity(record),
     })));
     agentEffectLayer.update(Array.from(agents.values()).map((record) => ({
       mesh: record.mesh,
       visible: record.agent.sceneState !== "offline",
+      opacity: resolveFocusedAgentOpacity(record),
     })));
     renderer.render(scene, camera);
     labelsDirty = false;
@@ -351,6 +387,16 @@ export function mountThreeAgentGameOffice(
 
   return {
     update,
+    resetCamera() {
+      workingFollowState = {
+        ...workingFollowState,
+        selectedAgentId: null,
+        resetAtMs: null,
+      };
+      camera.zoom = 1;
+      camera.updateProjectionMatrix();
+      transitionOfficeCameraTo(createInitialOfficeCameraView(_options.officeLayout, camera.aspect, camera.fov));
+    },
     focusAgent(agentId) {
       if (!agentId) {
         transitionOfficeCameraTo(createInitialOfficeCameraView(_options.officeLayout, camera.aspect, camera.fov));
@@ -361,6 +407,16 @@ export function mountThreeAgentGameOffice(
         return;
       }
       transitionOfficeCameraTo(createFollowOfficeCameraView(record.mesh.group.position));
+      setFocusedFloor(resolveAgentRouteFloorId(_options.officeLayout, record.routeState));
+    },
+    focusFloor(floorId) {
+      setFocusedFloor(floorId);
+    },
+    getFocusedFloor() {
+      return focusedFloorId;
+    },
+    getNavigationErrors() {
+      return getCurrentNavigationErrors();
     },
     destroy() {
       disposed = true;
@@ -387,6 +443,30 @@ export function mountThreeAgentGameOffice(
     _options.onCameraChange?.(createOfficeCameraState(camera, controls));
   }
 
+  function getCurrentNavigationErrors(): AgentNavigationError[] {
+    return Array.from(agents.values())
+      .map((record) => record.routeState.error)
+      .filter((error): error is AgentNavigationError => Boolean(error));
+  }
+
+  function resolveFocusedAgentOpacity(record: Pick<AgentMeshRecord, "routeState">): number {
+    if (!focusedFloorId) {
+      return 1;
+    }
+    const agentFloorId = resolveAgentRouteFloorId(_options.officeLayout, record.routeState);
+    return agentFloorId === focusedFloorId ? 1 : OFFICE_FLOOR_FOCUS_DIM_OPACITY;
+  }
+
+  function setFocusedFloor(floorId: string | null, emit = true) {
+    const nextFloorId = normalizeFocusedFloorId(_options.officeLayout, floorId);
+    focusedFloorId = nextFloorId;
+    applyOfficeFloorFocus(scene, _options.officeLayout, focusedFloorId);
+    labelsDirty = true;
+    if (emit) {
+      _options.onFocusedFloorChange?.(focusedFloorId);
+    }
+  }
+
   function syncWorkingFollowState(nowMs: number) {
     const previousSelectedAgentId = workingFollowState.selectedAgentId;
     workingFollowState = updateWorkingAgentFollowState(workingFollowState, latestAgents, nowMs);
@@ -432,6 +512,21 @@ export function mountThreeAgentGameOffice(
   }
 }
 
+function vectorFromLike(value: { x: number; y: number; z: number }): THREE.Vector3 {
+  return new THREE.Vector3(value.x, value.y, value.z);
+}
+
+function vectorToLike(value: THREE.Vector3): { x: number; y: number; z: number } {
+  return { x: value.x, y: value.y, z: value.z };
+}
+
+function normalizeFocusedFloorId(layout: ResolvedOfficeLayout, floorId: string | null): string | null {
+  if (!floorId) {
+    return null;
+  }
+  return layout.building.floors.some((floor) => floor.id === floorId) ? floorId : null;
+}
+
 export type OfficeCameraView = {
   position: THREE.Vector3;
   rotation: THREE.Euler;
@@ -496,21 +591,19 @@ export function createInitialOfficeCameraView(
   aspect: number,
   fovDegrees: number,
 ): OfficeCameraView {
-  const rotation = new THREE.Euler(
-    THREE_RENDERER_INITIAL_CAMERA_ROTATION.x,
-    THREE_RENDERER_INITIAL_CAMERA_ROTATION.y,
-    THREE_RENDERER_INITIAL_CAMERA_ROTATION.z,
+  const boundsHeight = resolveOfficeCameraBoundsHeight(layout);
+  const target = new THREE.Vector3(layout.scene.center.x, boundsHeight / 2, layout.scene.center.z);
+  const position = new THREE.Vector3(
+    THREE_RENDERER_INITIAL_CAMERA_POSITION.x,
+    THREE_RENDERER_INITIAL_CAMERA_POSITION.y,
+    THREE_RENDERER_INITIAL_CAMERA_POSITION.z,
   );
-  const quaternion = new THREE.Quaternion().setFromEuler(rotation);
-  const forward = new THREE.Vector3(0, 0, -1).applyQuaternion(quaternion).normalize();
-  const target = new THREE.Vector3(layout.scene.center.x, OFFICE_CAMERA_BOUNDS_HEIGHT / 2, layout.scene.center.z);
-  const preliminaryPosition = target.clone().sub(forward.clone());
   const orbitRotation = new THREE.Euler();
-  const matrix = new THREE.Matrix4().lookAt(preliminaryPosition, target, OFFICE_CAMERA_UP);
+  const matrix = new THREE.Matrix4().lookAt(position, target, OFFICE_CAMERA_UP);
   orbitRotation.setFromRotationMatrix(matrix);
   const orbitQuaternion = new THREE.Quaternion().setFromEuler(orbitRotation);
-  const distance = resolveOfficeCameraDistance(layout, target, orbitQuaternion, aspect, fovDegrees);
-  const position = target.clone().sub(forward.multiplyScalar(distance));
+  const fittedDistance = resolveOfficeCameraDistance(layout, target, orbitQuaternion, aspect, fovDegrees);
+  const distance = Math.max(position.distanceTo(target), fittedDistance);
 
   return {
     position,
@@ -587,7 +680,7 @@ function resolveOfficeCameraDistance(
   const corners: THREE.Vector3[] = [];
 
   for (const x of [layout.scene.center.x - halfWidth, layout.scene.center.x + halfWidth]) {
-    for (const y of [0, OFFICE_CAMERA_BOUNDS_HEIGHT]) {
+    for (const y of [0, resolveOfficeCameraBoundsHeight(layout)]) {
       for (const z of [layout.scene.center.z - halfDepth, layout.scene.center.z + halfDepth]) {
         corners.push(new THREE.Vector3(x, y, z));
       }
@@ -610,6 +703,10 @@ function resolveOfficeCameraDistance(
   );
 }
 
+function resolveOfficeCameraBoundsHeight(layout: ResolvedOfficeLayout): number {
+  return Math.max(OFFICE_CAMERA_MIN_BOUNDS_HEIGHT, layout.scene.height);
+}
+
 export function createOfficeCameraState(
   camera: THREE.PerspectiveCamera,
   controls: OrbitControls,