@agent-os-lab/agent-game-sdk 0.1.1

package/src/core/office-building-layout.ts

@@ -0,0 +1,376 @@
+import { AgentGameError } from "./errors.js";
+import type { OfficeObjectAtlasDefinition } from "./office-layout.js";
+import type {
+  AgentGameAnchor,
+  AgentGameAnchorKind,
+  AgentGameDirection,
+  AgentGameSceneDefinition,
+} from "./scene.js";
+import { validateAgentGameScene } from "./scene.js";
+import { createTownOfficeRoomAnchors } from "./town-office-seat-layout.js";
+import { isTownOfficeRoomType, type TownOfficeRoomType } from "./town-office-assets.js";
+
+export type OfficeBuildingGridRect = {
+  x: number;
+  y: number;
+  w: number;
+  h: number;
+};
+
+export type OfficeBuildingRatio = {
+  width: number;
+  height: number;
+};
+
+export type OfficeBuildingRoomTheme = {
+  titleColor: string;
+  floorColor: string;
+  borderColor: string;
+  titleTextColor?: string;
+  gridColor?: string;
+};
+
+export type OfficeBuildingObjectDefinition = {
+  id: string;
+  frame: string;
+  x: number;
+  y: number;
+  scale?: number;
+  depth?: number;
+};
+
+export type OfficeBuildingAnchorDefinition = {
+  id: string;
+  kind: AgentGameAnchorKind;
+  x: number;
+  y: number;
+  direction?: AgentGameDirection;
+};
+
+export type OfficeBuildingRoomDefinition = {
+  id: string;
+  name: string;
+  type?: TownOfficeRoomType;
+  row?: number;
+  weight?: number;
+  rowHeight?: number;
+  grid: OfficeBuildingGridRect;
+  theme: OfficeBuildingRoomTheme;
+  objects: OfficeBuildingObjectDefinition[];
+  anchors: OfficeBuildingAnchorDefinition[];
+};
+
+export type OfficeBuildingLayout = {
+  id: string;
+  cellSize: number;
+  gap: number;
+  padding: number;
+  ratio?: OfficeBuildingRatio;
+  backgroundColor: string;
+  rooms: OfficeBuildingRoomDefinition[];
+};
+
+export type OfficeRoomBounds = {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+};
+
+export function validateOfficeBuildingLayout(
+  layout: OfficeBuildingLayout,
+  atlas: OfficeObjectAtlasDefinition,
+): OfficeBuildingLayout {
+  assertNonEmpty(layout.id, "office building layout id");
+  assertPositive(layout.cellSize, "office building cell size");
+  assertFiniteNumber(layout.gap, "office building gap");
+  assertFiniteNumber(layout.padding, "office building padding");
+  validateRatio(layout.ratio);
+  parseHexColor(layout.backgroundColor);
+
+  const roomIds = new Set<string>();
+  const anchorIds = new Set<string>();
+  for (const room of layout.rooms) {
+    assertNonEmpty(room.id, "office building room id");
+    assertNonEmpty(room.name, "office building room name");
+    if (roomIds.has(room.id)) {
+      throw new AgentGameError("invalid_asset_manifest", `Duplicate office building room id: ${room.id}`);
+    }
+    roomIds.add(room.id);
+    if (room.type && !isTownOfficeRoomType(room.type)) {
+      throw new AgentGameError("invalid_asset_manifest", `Unsupported office building room type: ${room.type}`);
+    }
+    validateRowLayoutHints(room);
+    assertGrid(room.grid, room.id);
+    validateTheme(room.theme);
+
+    for (const object of room.objects) {
+      assertNonEmpty(object.id, "office building object id");
+      assertNonEmpty(object.frame, "office building object frame");
+      if (!atlas.frames[object.frame]) {
+        throw new AgentGameError("invalid_asset_manifest", `Office building object references missing frame: ${object.frame}`);
+      }
+      assertFiniteNumber(object.x, `office building object ${object.id} x`);
+      assertFiniteNumber(object.y, `office building object ${object.id} y`);
+    }
+
+    for (const anchor of room.anchors) {
+      assertNonEmpty(anchor.id, "office building anchor id");
+      if (anchorIds.has(anchor.id)) {
+        throw new AgentGameError("invalid_asset_manifest", `Duplicate office building anchor id: ${anchor.id}`);
+      }
+      anchorIds.add(anchor.id);
+      assertFiniteNumber(anchor.x, `office building anchor ${anchor.id} x`);
+      assertFiniteNumber(anchor.y, `office building anchor ${anchor.id} y`);
+    }
+  }
+
+  return layout;
+}
+
+export function createOfficeBuildingSceneDefinition(layout: OfficeBuildingLayout): AgentGameSceneDefinition {
+  const normalizedLayout = normalizeOfficeBuildingLayoutForRatio(layout);
+  const anchors: AgentGameAnchor[] = [];
+  for (const room of normalizedLayout.rooms) {
+    const bounds = getOfficeRoomBounds(normalizedLayout, room);
+    const roomAnchors = room.anchors.length > 0 || !room.type
+      ? room.anchors
+      : createTownOfficeRoomAnchors({
+        roomId: room.id,
+        roomType: room.type,
+        width: bounds.width,
+        height: bounds.height,
+      });
+    for (const anchor of roomAnchors) {
+      anchors.push({
+        id: anchor.id,
+        kind: anchor.kind,
+        x: bounds.x + anchor.x,
+        y: bounds.y + anchor.y,
+        direction: anchor.direction,
+      });
+    }
+  }
+
+  return validateAgentGameScene({
+    id: layout.id,
+    map: {
+      key: layout.id,
+      url: `/assets/layouts/${layout.id}.json`,
+      tilesets: [],
+    },
+    anchors,
+  });
+}
+
+export function normalizeOfficeBuildingLayoutForRatio(layout: OfficeBuildingLayout): OfficeBuildingLayout {
+  if (!layout.ratio || layout.rooms.length === 0) {
+    return layout;
+  }
+
+  if (usesRowFillLayout(layout)) {
+    return normalizeRowFillOfficeBuildingLayout(layout);
+  }
+
+  const targetColumns = getTargetGridColumnCount(layout);
+  const rooms: OfficeBuildingRoomDefinition[] = [];
+  let cursorX = 0;
+  let cursorY = 0;
+  let rowHeight = 0;
+
+  for (const room of layout.rooms) {
+    if (cursorX > 0 && cursorX + room.grid.w > targetColumns) {
+      cursorX = 0;
+      cursorY += rowHeight;
+      rowHeight = 0;
+    }
+
+    rooms.push({
+      ...room,
+      grid: {
+        ...room.grid,
+        x: cursorX,
+        y: cursorY,
+      },
+    });
+    cursorX += room.grid.w;
+    rowHeight = Math.max(rowHeight, room.grid.h);
+  }
+
+  return {
+    ...layout,
+    rooms,
+  };
+}
+
+export function getOfficeRoomBounds(
+  layout: OfficeBuildingLayout,
+  room: OfficeBuildingRoomDefinition,
+): OfficeRoomBounds {
+  return {
+    x: layout.padding + room.grid.x * (layout.cellSize + layout.gap),
+    y: layout.padding + room.grid.y * (layout.cellSize + layout.gap),
+    width: room.grid.w * layout.cellSize + (room.grid.w - 1) * layout.gap,
+    height: room.grid.h * layout.cellSize + (room.grid.h - 1) * layout.gap,
+  };
+}
+
+export function measureOfficeBuildingLayoutSize(layout: OfficeBuildingLayout): { width: number; height: number } {
+  const measuredLayout = normalizeOfficeBuildingLayoutForRatio(layout);
+  let width = layout.padding * 2;
+  let height = layout.padding * 2;
+
+  for (const room of measuredLayout.rooms) {
+    const bounds = getOfficeRoomBounds(measuredLayout, room);
+    width = Math.max(width, bounds.x + bounds.width + measuredLayout.padding);
+    height = Math.max(height, bounds.y + bounds.height + measuredLayout.padding);
+  }
+
+  return { width, height };
+}
+
+export function parseHexColor(hex: string): number {
+  if (!/^#[0-9a-fA-F]{6}$/.test(hex)) {
+    throw new AgentGameError("invalid_asset_manifest", `Office building color must be a #rrggbb hex color: ${hex}`);
+  }
+  return Number.parseInt(hex.slice(1), 16);
+}
+
+function validateTheme(theme: OfficeBuildingRoomTheme): void {
+  parseHexColor(theme.titleColor);
+  parseHexColor(theme.floorColor);
+  parseHexColor(theme.borderColor);
+  if (theme.titleTextColor) {
+    parseHexColor(theme.titleTextColor);
+  }
+  if (theme.gridColor) {
+    parseHexColor(theme.gridColor);
+  }
+}
+
+function validateRatio(ratio: OfficeBuildingRatio | undefined): void {
+  if (!ratio) {
+    return;
+  }
+  assertPositive(ratio.width, "office building ratio width");
+  assertPositive(ratio.height, "office building ratio height");
+}
+
+function validateRowLayoutHints(room: OfficeBuildingRoomDefinition): void {
+  if (room.row !== undefined) {
+    assertFiniteNumber(room.row, `office building room ${room.id} row`);
+    if (!Number.isInteger(room.row) || room.row < 0) {
+      throw new AgentGameError("invalid_asset_manifest", `Office building room ${room.id} row must be a non-negative integer`);
+    }
+  }
+  if (room.weight !== undefined) {
+    assertPositive(room.weight, `office building room ${room.id} weight`);
+  }
+  if (room.rowHeight !== undefined) {
+    assertPositive(room.rowHeight, `office building room ${room.id} rowHeight`);
+  }
+}
+
+function usesRowFillLayout(layout: OfficeBuildingLayout): boolean {
+  return layout.rooms.some((room) => room.row !== undefined || room.weight !== undefined || room.rowHeight !== undefined);
+}
+
+function normalizeRowFillOfficeBuildingLayout(layout: OfficeBuildingLayout): OfficeBuildingLayout {
+  const rows = groupRoomsByRow(layout.rooms);
+  const totalGridHeight = rows.reduce((sum, row) => sum + row.height, 0);
+  const worldHeight = layout.padding * 2 + totalGridHeight * (layout.cellSize + layout.gap) - layout.gap;
+  const targetWorldWidth = worldHeight * (layout.ratio!.width / layout.ratio!.height);
+  const targetContentWidth = Math.max(layout.cellSize, targetWorldWidth - layout.padding * 2);
+  const targetGridWidth = (targetContentWidth + layout.gap) / (layout.cellSize + layout.gap);
+  const rooms: OfficeBuildingRoomDefinition[] = [];
+  let cursorY = 0;
+
+  for (const row of rows) {
+    const totalWeight = row.rooms.reduce((sum, room) => sum + getRoomLayoutWeight(room), 0);
+    let cursorX = 0;
+
+    row.rooms.forEach((room, index) => {
+      const isLast = index === row.rooms.length - 1;
+      const width = isLast
+        ? Math.max(0.01, targetGridWidth - cursorX)
+        : targetGridWidth * (getRoomLayoutWeight(room) / totalWeight);
+      rooms.push({
+        ...room,
+        grid: {
+          ...room.grid,
+          x: cursorX,
+          y: cursorY,
+          w: width,
+          h: row.height,
+        },
+      });
+      cursorX += width;
+    });
+
+    cursorY += row.height;
+  }
+
+  return {
+    ...layout,
+    rooms,
+  };
+}
+
+function groupRoomsByRow(rooms: OfficeBuildingRoomDefinition[]): Array<{ row: number; height: number; rooms: OfficeBuildingRoomDefinition[] }> {
+  const groups = new Map<number, OfficeBuildingRoomDefinition[]>();
+  rooms.forEach((room, index) => {
+    const row = room.row ?? room.grid.y ?? index;
+    const current = groups.get(row);
+    if (current) {
+      current.push(room);
+    } else {
+      groups.set(row, [room]);
+    }
+  });
+
+  return Array.from(groups.entries())
+    .sort(([a], [b]) => a - b)
+    .map(([row, rowRooms]) => ({
+      row,
+      rooms: rowRooms,
+      height: rowRooms.reduce((max, room) => Math.max(max, room.rowHeight ?? room.grid.h), 0),
+    }));
+}
+
+function getRoomLayoutWeight(room: OfficeBuildingRoomDefinition): number {
+  return room.weight ?? room.grid.w;
+}
+
+function getTargetGridColumnCount(layout: OfficeBuildingLayout): number {
+  const ratio = layout.ratio ? layout.ratio.width / layout.ratio.height : 1;
+  const area = layout.rooms.reduce((sum, room) => sum + room.grid.w * room.grid.h, 0);
+  const widestRoom = layout.rooms.reduce((max, room) => Math.max(max, room.grid.w), 1);
+
+  return Math.max(widestRoom, Math.ceil(Math.sqrt(area * ratio)));
+}
+
+function assertGrid(grid: OfficeBuildingGridRect, roomId: string): void {
+  assertFiniteNumber(grid.x, `office building room ${roomId} grid x`);
+  assertFiniteNumber(grid.y, `office building room ${roomId} grid y`);
+  assertPositive(grid.w, `office building room ${roomId} grid w`);
+  assertPositive(grid.h, `office building room ${roomId} grid h`);
+}
+
+function assertNonEmpty(value: string, field: string): void {
+  if (value.trim().length === 0) {
+    throw new AgentGameError("invalid_asset_manifest", `Agent game ${field} must not be empty`);
+  }
+}
+
+function assertPositive(value: number, field: string): void {
+  assertFiniteNumber(value, field);
+  if (value <= 0) {
+    throw new AgentGameError("invalid_asset_manifest", `Agent game ${field} must be positive`);
+  }
+}
+
+function assertFiniteNumber(value: number, field: string): void {
+  if (!Number.isFinite(value)) {
+    throw new AgentGameError("invalid_asset_manifest", `Agent game ${field} must be finite`);
+  }
+}

package/src/core/office-layout.ts

@@ -0,0 +1,152 @@
+import { AgentGameError } from "./errors.js";
+
+export type OfficeObjectAtlasFrame = {
+  frame: {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+  };
+};
+
+export type OfficeObjectAtlasDefinition = {
+  frames: Record<string, OfficeObjectAtlasFrame>;
+  meta: {
+    image: string;
+    size: {
+      w: number;
+      h: number;
+    };
+    scale: string;
+  };
+};
+
+export type OfficeLayoutFloorDefinition = {
+  frame: string;
+  visible?: boolean;
+  x?: number;
+  y?: number;
+  width?: number;
+  height?: number;
+};
+
+export type OfficeLayoutFloorFillDefinition = {
+  fillColor: number;
+  depth?: number;
+};
+
+export type OfficeLayoutWallDefinition = {
+  id: string;
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+  fillColor: number;
+  depth?: number;
+};
+
+export type OfficeLayoutObjectDefinition = {
+  id: string;
+  frame: string;
+  x: number;
+  y: number;
+  depth?: number;
+  scale?: number;
+};
+
+export type OfficeLayoutDefinition = {
+  width: number;
+  height: number;
+  tileSize: number;
+  floor: OfficeLayoutFloorDefinition;
+  floorFill?: OfficeLayoutFloorFillDefinition;
+  walls?: OfficeLayoutWallDefinition[];
+  objects: OfficeLayoutObjectDefinition[];
+};
+
+export function validateOfficeLayoutDefinition(
+  layout: OfficeLayoutDefinition,
+  atlas: OfficeObjectAtlasDefinition,
+): OfficeLayoutDefinition {
+  assertPositive(layout.width, "office layout width");
+  assertPositive(layout.height, "office layout height");
+  assertPositive(layout.tileSize, "office layout tile size");
+  assertNonEmpty(layout.floor.frame, "office layout floor frame");
+  assertOptionalFiniteNumber(layout.floor.x, "office layout floor x");
+  assertOptionalFiniteNumber(layout.floor.y, "office layout floor y");
+  assertOptionalPositive(layout.floor.width, "office layout floor width");
+  assertOptionalPositive(layout.floor.height, "office layout floor height");
+  if (layout.floorFill) {
+    assertFiniteNumber(layout.floorFill.fillColor, "office layout floor fill color");
+  }
+
+  const missingFrames = listMissingOfficeLayoutFrames(layout, atlas);
+  if (missingFrames.length > 0) {
+    throw new AgentGameError(
+      "invalid_asset_manifest",
+      `Office layout references missing object frame: ${missingFrames.join(", ")}`,
+    );
+  }
+
+  const objectIds = new Set<string>();
+  for (const wall of layout.walls ?? []) {
+    assertNonEmpty(wall.id, "office layout wall id");
+    assertFiniteNumber(wall.x, `office layout wall ${wall.id} x`);
+    assertFiniteNumber(wall.y, `office layout wall ${wall.id} y`);
+    assertPositive(wall.width, `office layout wall ${wall.id} width`);
+    assertPositive(wall.height, `office layout wall ${wall.id} height`);
+    assertFiniteNumber(wall.fillColor, `office layout wall ${wall.id} fill color`);
+  }
+
+  for (const object of layout.objects) {
+    assertNonEmpty(object.id, "office layout object id");
+    assertNonEmpty(object.frame, "office layout object frame");
+    assertFiniteNumber(object.x, `office layout object ${object.id} x`);
+    assertFiniteNumber(object.y, `office layout object ${object.id} y`);
+    if (objectIds.has(object.id)) {
+      throw new AgentGameError("invalid_asset_manifest", `Duplicate office layout object id: ${object.id}`);
+    }
+    objectIds.add(object.id);
+  }
+
+  return layout;
+}
+
+function assertOptionalPositive(value: number | undefined, field: string): void {
+  if (value !== undefined) {
+    assertPositive(value, field);
+  }
+}
+
+function assertOptionalFiniteNumber(value: number | undefined, field: string): void {
+  if (value !== undefined) {
+    assertFiniteNumber(value, field);
+  }
+}
+
+export function listMissingOfficeLayoutFrames(
+  layout: OfficeLayoutDefinition,
+  atlas: OfficeObjectAtlasDefinition,
+): string[] {
+  const frames = new Set<string>([layout.floor.frame, ...layout.objects.map((object) => object.frame)]);
+  return Array.from(frames).filter((frame) => !atlas.frames[frame]);
+}
+
+function assertNonEmpty(value: string, field: string): void {
+  if (value.trim().length === 0) {
+    throw new AgentGameError("invalid_asset_manifest", `Agent game ${field} must not be empty`);
+  }
+}
+
+function assertPositive(value: number, field: string): void {
+  assertFiniteNumber(value, field);
+  if (value <= 0) {
+    throw new AgentGameError("invalid_asset_manifest", `Agent game ${field} must be positive`);
+  }
+}
+
+function assertFiniteNumber(value: number, field: string): void {
+  if (!Number.isFinite(value)) {
+    throw new AgentGameError("invalid_asset_manifest", `Agent game ${field} must be finite`);
+  }
+}

package/src/core/pixel-character-avatar.ts

@@ -0,0 +1,87 @@
+import type { AgentAvatarDefinition } from "./assets.js";
+import type { PixelCharacterSprite } from "./pixel-character.js";
+
+export type PixelCharacterAvatarAtlas = {
+  frames: Record<string, { frame: { x: number; y: number; w: number; h: number } }>;
+  meta: {
+    app: string;
+    image: string;
+    format: "RGBA8888";
+    size: { w: number; h: number };
+    scale: "1";
+  };
+};
+
+export function createAgentAvatarFromPixelCharacter(sprite: PixelCharacterSprite): AgentAvatarDefinition {
+  const frameNames = Object.keys(sprite.frames);
+  const sheetWidth = sprite.frame.width * frameNames.length;
+  const sheetHeight = sprite.frame.height;
+  const svg = createPixelCharacterSpriteSheetSvg(sprite, frameNames, sheetWidth, sheetHeight);
+  const atlas = createPixelCharacterAtlas(sprite, frameNames, sheetWidth, sheetHeight);
+
+  return {
+    id: sprite.id,
+    imageUrl: `data:image/svg+xml;base64,${encodeBase64(svg)}`,
+    atlasUrl: `data:application/json;base64,${encodeBase64(JSON.stringify(atlas))}`,
+    animations: sprite.animations,
+  };
+}
+
+function createPixelCharacterSpriteSheetSvg(
+  sprite: PixelCharacterSprite,
+  frameNames: string[],
+  sheetWidth: number,
+  sheetHeight: number,
+): string {
+  const frames = frameNames.map((frameName, index) => {
+    const frameX = index * sprite.frame.width;
+    const rects = sprite.frames[frameName].layers.map((layer) =>
+      `<rect x="${frameX + layer.x}" y="${layer.y}" width="${layer.width}" height="${layer.height}" fill="${layer.fill}"/>`
+    ).join("");
+    return `<g id="${frameName}">${rects}</g>`;
+  }).join("");
+
+  return `<svg xmlns="http://www.w3.org/2000/svg" width="${sheetWidth}" height="${sheetHeight}" viewBox="0 0 ${sheetWidth} ${sheetHeight}" shape-rendering="crispEdges">${frames}</svg>`;
+}
+
+function createPixelCharacterAtlas(
+  sprite: PixelCharacterSprite,
+  frameNames: string[],
+  sheetWidth: number,
+  sheetHeight: number,
+): PixelCharacterAvatarAtlas {
+  const frames: PixelCharacterAvatarAtlas["frames"] = {};
+  frameNames.forEach((frameName, index) => {
+    frames[frameName] = {
+      frame: {
+        x: index * sprite.frame.width,
+        y: 0,
+        w: sprite.frame.width,
+        h: sprite.frame.height,
+      },
+    };
+  });
+
+  return {
+    frames,
+    meta: {
+      app: "agent-game-sdk/pixel-character-avatar",
+      image: `${sprite.id}.svg`,
+      format: "RGBA8888",
+      size: {
+        w: sheetWidth,
+        h: sheetHeight,
+      },
+      scale: "1",
+    },
+  };
+}
+
+function encodeBase64(value: string): string {
+  const bytes = new TextEncoder().encode(value);
+  let binary = "";
+  for (let index = 0; index < bytes.length; index++) {
+    binary += String.fromCharCode(bytes[index]);
+  }
+  return btoa(binary);
+}