solanapolis 1.0.0

package/convex/aiTown/movement.ts

@@ -0,0 +1,189 @@
+import { movementSpeed } from '../../data/characters';
+import { COLLISION_THRESHOLD } from '../constants';
+import { compressPath, distance, manhattanDistance, pointsEqual } from '../util/geometry';
+import { MinHeap } from '../util/minheap';
+import { Point, Vector } from '../util/types';
+import { Game } from './game';
+import { GameId } from './ids';
+import { Player } from './player';
+import { WorldMap } from './worldMap';
+
+type PathCandidate = {
+  position: Point;
+  facing?: Vector;
+  t: number;
+  length: number;
+  cost: number;
+  prev?: PathCandidate;
+};
+
+export function stopPlayer(player: Player) {
+  delete player.pathfinding;
+  player.speed = 0;
+}
+
+export function movePlayer(
+  game: Game,
+  now: number,
+  player: Player,
+  destination: Point,
+  allowInConversation?: boolean,
+) {
+  if (Math.floor(destination.x) !== destination.x || Math.floor(destination.y) !== destination.y) {
+    throw new Error(`Non-integral destination: ${JSON.stringify(destination)}`);
+  }
+  const { position } = player;
+  // Close enough to current position or destination => no-op.
+  if (pointsEqual(position, destination)) {
+    return;
+  }
+  // Don't allow players in a conversation to move.
+  const inConversation = [...game.world.conversations.values()].some(
+    (c) => c.participants.get(player.id)?.status.kind === 'participating',
+  );
+  if (inConversation && !allowInConversation) {
+    throw new Error(`Can't move when in a conversation. Leave the conversation first!`);
+  }
+  player.pathfinding = {
+    destination: destination,
+    started: now,
+    state: {
+      kind: 'needsPath',
+    },
+  };
+  return;
+}
+
+export function findRoute(game: Game, now: number, player: Player, destination: Point) {
+  const minDistances: PathCandidate[][] = [];
+  const explore = (current: PathCandidate): Array<PathCandidate> => {
+    const { x, y } = current.position;
+    const neighbors = [];
+
+    // If we're not on a grid point, first try to move horizontally
+    // or vertically to a grid point. Note that this can create very small
+    // deltas between the current position and the nearest grid point so
+    // be careful to preserve the `facing` vectors rather than trying to
+    // derive them anew.
+    if (x !== Math.floor(x)) {
+      neighbors.push(
+        { position: { x: Math.floor(x), y }, facing: { dx: -1, dy: 0 } },
+        { position: { x: Math.floor(x) + 1, y }, facing: { dx: 1, dy: 0 } },
+      );
+    }
+    if (y !== Math.floor(y)) {
+      neighbors.push(
+        { position: { x, y: Math.floor(y) }, facing: { dx: 0, dy: -1 } },
+        { position: { x, y: Math.floor(y) + 1 }, facing: { dx: 0, dy: 1 } },
+      );
+    }
+    // Otherwise, just move to adjacent grid points.
+    if (x == Math.floor(x) && y == Math.floor(y)) {
+      neighbors.push(
+        { position: { x: x + 1, y }, facing: { dx: 1, dy: 0 } },
+        { position: { x: x - 1, y }, facing: { dx: -1, dy: 0 } },
+        { position: { x, y: y + 1 }, facing: { dx: 0, dy: 1 } },
+        { position: { x, y: y - 1 }, facing: { dx: 0, dy: -1 } },
+      );
+    }
+    const next = [];
+    for (const { position, facing } of neighbors) {
+      const segmentLength = distance(current.position, position);
+      const length = current.length + segmentLength;
+      if (blocked(game, now, position, player.id)) {
+        continue;
+      }
+      const remaining = manhattanDistance(position, destination);
+      const path = {
+        position,
+        facing,
+        // Movement speed is in tiles per second.
+        t: current.t + (segmentLength / movementSpeed) * 1000,
+        length,
+        cost: length + remaining,
+        prev: current,
+      };
+      const existingMin = minDistances[position.y]?.[position.x];
+      if (existingMin && existingMin.cost <= path.cost) {
+        continue;
+      }
+      minDistances[position.y] ??= [];
+      minDistances[position.y][position.x] = path;
+      next.push(path);
+    }
+    return next;
+  };
+
+  const startingLocation = player.position;
+  const startingPosition = { x: startingLocation.x, y: startingLocation.y };
+  let current: PathCandidate | undefined = {
+    position: startingPosition,
+    facing: player.facing,
+    t: now,
+    length: 0,
+    cost: manhattanDistance(startingPosition, destination),
+    prev: undefined,
+  };
+  let bestCandidate = current;
+  const minheap = MinHeap<PathCandidate>((p0, p1) => p0.cost > p1.cost);
+  while (current) {
+    if (pointsEqual(current.position, destination)) {
+      break;
+    }
+    if (
+      manhattanDistance(current.position, destination) <
+      manhattanDistance(bestCandidate.position, destination)
+    ) {
+      bestCandidate = current;
+    }
+    for (const candidate of explore(current)) {
+      minheap.push(candidate);
+    }
+    current = minheap.pop();
+  }
+  let newDestination = null;
+  if (!current) {
+    if (bestCandidate.length === 0) {
+      return null;
+    }
+    current = bestCandidate;
+    newDestination = current.position;
+  }
+  const densePath = [];
+  let facing = current.facing!;
+  while (current) {
+    densePath.push({ position: current.position, t: current.t, facing });
+    facing = current.facing!;
+    current = current.prev;
+  }
+  densePath.reverse();
+
+  return { path: compressPath(densePath), newDestination };
+}
+
+export function blocked(game: Game, now: number, pos: Point, playerId?: GameId<'players'>) {
+  const otherPositions = [...game.world.players.values()]
+    .filter((p) => p.id !== playerId)
+    .map((p) => p.position);
+  return blockedWithPositions(pos, otherPositions, game.worldMap);
+}
+
+export function blockedWithPositions(position: Point, otherPositions: Point[], map: WorldMap) {
+  if (isNaN(position.x) || isNaN(position.y)) {
+    throw new Error(`NaN position in ${JSON.stringify(position)}`);
+  }
+  if (position.x < 0 || position.y < 0 || position.x >= map.width || position.y >= map.height) {
+    return 'out of bounds';
+  }
+  for (const layer of map.objectTiles) {
+    if (layer[Math.floor(position.x)][Math.floor(position.y)] !== -1) {
+      return 'world blocked';
+    }
+  }
+  for (const otherPosition of otherPositions) {
+    if (distance(otherPosition, position) < COLLISION_THRESHOLD) {
+      return 'player';
+    }
+  }
+  return null;
+}

package/convex/aiTown/player.ts

@@ -0,0 +1,310 @@
+import { Infer, ObjectType, v } from 'convex/values';
+import { Point, Vector, path, point, vector } from '../util/types';
+import { GameId, parseGameId } from './ids';
+import { playerId } from './ids';
+import {
+  PATHFINDING_TIMEOUT,
+  PATHFINDING_BACKOFF,
+  HUMAN_IDLE_TOO_LONG,
+  MAX_HUMAN_PLAYERS,
+  MAX_PATHFINDS_PER_STEP,
+} from '../constants';
+import { pointsEqual, pathPosition } from '../util/geometry';
+import { Game } from './game';
+import { stopPlayer, findRoute, blocked, movePlayer } from './movement';
+import { inputHandler } from './inputHandler';
+import { characters } from '../../data/characters';
+import { PlayerDescription } from './playerDescription';
+
+const pathfinding = v.object({
+  destination: point,
+  started: v.number(),
+  state: v.union(
+    v.object({
+      kind: v.literal('needsPath'),
+    }),
+    v.object({
+      kind: v.literal('waiting'),
+      until: v.number(),
+    }),
+    v.object({
+      kind: v.literal('moving'),
+      path,
+    }),
+  ),
+});
+export type Pathfinding = Infer<typeof pathfinding>;
+
+export const activity = v.object({
+  description: v.string(),
+  emoji: v.optional(v.string()),
+  until: v.number(),
+});
+export type Activity = Infer<typeof activity>;
+
+export const serializedPlayer = {
+  id: playerId,
+  human: v.optional(v.string()),
+  pathfinding: v.optional(pathfinding),
+  activity: v.optional(activity),
+
+  // The last time they did something.
+  lastInput: v.number(),
+
+  position: point,
+  facing: vector,
+  speed: v.number(),
+};
+export type SerializedPlayer = ObjectType<typeof serializedPlayer>;
+
+export class Player {
+  id: GameId<'players'>;
+  human?: string;
+  pathfinding?: Pathfinding;
+  activity?: Activity;
+
+  lastInput: number;
+
+  position: Point;
+  facing: Vector;
+  speed: number;
+
+  constructor(serialized: SerializedPlayer) {
+    const { id, human, pathfinding, activity, lastInput, position, facing, speed } = serialized;
+    this.id = parseGameId('players', id);
+    this.human = human;
+    this.pathfinding = pathfinding;
+    this.activity = activity;
+    this.lastInput = lastInput;
+    this.position = position;
+    this.facing = facing;
+    this.speed = speed;
+  }
+
+  tick(game: Game, now: number) {
+    if (this.human && this.lastInput < now - HUMAN_IDLE_TOO_LONG) {
+      this.leave(game, now);
+    }
+  }
+
+  tickPathfinding(game: Game, now: number) {
+    // There's nothing to do if we're not moving.
+    const { pathfinding, position } = this;
+    if (!pathfinding) {
+      return;
+    }
+
+    // Stop pathfinding if we've reached our destination.
+    if (pathfinding.state.kind === 'moving' && pointsEqual(pathfinding.destination, position)) {
+      stopPlayer(this);
+    }
+
+    // Stop pathfinding if we've timed out.
+    if (pathfinding.started + PATHFINDING_TIMEOUT < now) {
+      console.warn(`Timing out pathfinding for ${this.id}`);
+      stopPlayer(this);
+    }
+
+    // Transition from "waiting" to "needsPath" if we're past the deadline.
+    if (pathfinding.state.kind === 'waiting' && pathfinding.state.until < now) {
+      pathfinding.state = { kind: 'needsPath' };
+    }
+
+    // Perform pathfinding if needed.
+    if (pathfinding.state.kind === 'needsPath' && game.numPathfinds < MAX_PATHFINDS_PER_STEP) {
+      game.numPathfinds++;
+      if (game.numPathfinds === MAX_PATHFINDS_PER_STEP) {
+        console.warn(`Reached max pathfinds for this step`);
+      }
+      const route = findRoute(game, now, this, pathfinding.destination);
+      if (route === null) {
+        console.log(`Failed to route to ${JSON.stringify(pathfinding.destination)}`);
+        stopPlayer(this);
+      } else {
+        if (route.newDestination) {
+          console.warn(
+            `Updating destination from ${JSON.stringify(
+              pathfinding.destination,
+            )} to ${JSON.stringify(route.newDestination)}`,
+          );
+          pathfinding.destination = route.newDestination;
+        }
+        pathfinding.state = { kind: 'moving', path: route.path };
+      }
+    }
+  }
+
+  tickPosition(game: Game, now: number) {
+    // There's nothing to do if we're not moving.
+    if (!this.pathfinding || this.pathfinding.state.kind !== 'moving') {
+      this.speed = 0;
+      return;
+    }
+
+    // Compute a candidate new position and check if it collides
+    // with anything.
+    const candidate = pathPosition(this.pathfinding.state.path as any, now);
+    if (!candidate) {
+      console.warn(`Path out of range of ${now} for ${this.id}`);
+      return;
+    }
+    const { position, facing, velocity } = candidate;
+    const collisionReason = blocked(game, now, position, this.id);
+    if (collisionReason !== null) {
+      const backoff = Math.random() * PATHFINDING_BACKOFF;
+      console.warn(`Stopping path for ${this.id}, waiting for ${backoff}ms: ${collisionReason}`);
+      this.pathfinding.state = {
+        kind: 'waiting',
+        until: now + backoff,
+      };
+      return;
+    }
+    // Update the player's location.
+    this.position = position;
+    this.facing = facing;
+    this.speed = velocity;
+  }
+
+  static join(
+    game: Game,
+    now: number,
+    name: string,
+    character: string,
+    description: string,
+    tokenIdentifier?: string,
+  ) {
+    if (tokenIdentifier) {
+      let numHumans = 0;
+      for (const player of game.world.players.values()) {
+        if (player.human) {
+          numHumans++;
+        }
+        if (player.human === tokenIdentifier) {
+          throw new Error(`You are already in this game!`);
+        }
+      }
+      if (numHumans >= MAX_HUMAN_PLAYERS) {
+        throw new Error(`Only ${MAX_HUMAN_PLAYERS} human players allowed at once.`);
+      }
+    }
+    let position;
+    for (let attempt = 0; attempt < 10; attempt++) {
+      const candidate = {
+        x: Math.floor(Math.random() * game.worldMap.width),
+        y: Math.floor(Math.random() * game.worldMap.height),
+      };
+      if (blocked(game, now, candidate)) {
+        continue;
+      }
+      position = candidate;
+      break;
+    }
+    if (!position) {
+      throw new Error(`Failed to find a free position!`);
+    }
+    const facingOptions = [
+      { dx: 1, dy: 0 },
+      { dx: -1, dy: 0 },
+      { dx: 0, dy: 1 },
+      { dx: 0, dy: -1 },
+    ];
+    const facing = facingOptions[Math.floor(Math.random() * facingOptions.length)];
+    if (!characters.find((c) => c.name === character)) {
+      throw new Error(`Invalid character: ${character}`);
+    }
+    const playerId = game.allocId('players');
+    game.world.players.set(
+      playerId,
+      new Player({
+        id: playerId,
+        human: tokenIdentifier,
+        lastInput: now,
+        position,
+        facing,
+        speed: 0,
+      }),
+    );
+    game.playerDescriptions.set(
+      playerId,
+      new PlayerDescription({
+        playerId,
+        character,
+        description,
+        name,
+      }),
+    );
+    game.descriptionsModified = true;
+    return playerId;
+  }
+
+  leave(game: Game, now: number) {
+    // Stop our conversation if we're leaving the game.
+    const conversation = [...game.world.conversations.values()].find((c) =>
+      c.participants.has(this.id),
+    );
+    if (conversation) {
+      conversation.stop(game, now);
+    }
+    game.world.players.delete(this.id);
+  }
+
+  serialize(): SerializedPlayer {
+    const { id, human, pathfinding, activity, lastInput, position, facing, speed } = this;
+    return {
+      id,
+      human,
+      pathfinding,
+      activity,
+      lastInput,
+      position,
+      facing,
+      speed,
+    };
+  }
+}
+
+export const playerInputs = {
+  join: inputHandler({
+    args: {
+      name: v.string(),
+      character: v.string(),
+      description: v.string(),
+      tokenIdentifier: v.optional(v.string()),
+    },
+    handler: (game, now, args) => {
+      Player.join(game, now, args.name, args.character, args.description, args.tokenIdentifier);
+      return null;
+    },
+  }),
+  leave: inputHandler({
+    args: { playerId },
+    handler: (game, now, args) => {
+      const playerId = parseGameId('players', args.playerId);
+      const player = game.world.players.get(playerId);
+      if (!player) {
+        throw new Error(`Invalid player ID ${playerId}`);
+      }
+      player.leave(game, now);
+      return null;
+    },
+  }),
+  moveTo: inputHandler({
+    args: {
+      playerId,
+      destination: v.union(point, v.null()),
+    },
+    handler: (game, now, args) => {
+      const playerId = parseGameId('players', args.playerId);
+      const player = game.world.players.get(playerId);
+      if (!player) {
+        throw new Error(`Invalid player ID ${playerId}`);
+      }
+      if (args.destination) {
+        movePlayer(game, now, player, args.destination);
+      } else {
+        stopPlayer(player);
+      }
+      return null;
+    },
+  }),
+};

package/convex/aiTown/playerDescription.ts

@@ -0,0 +1,35 @@
+import { ObjectType, v } from 'convex/values';
+import { GameId, parseGameId, playerId } from './ids';
+
+export const serializedPlayerDescription = {
+  playerId,
+  name: v.string(),
+  description: v.string(),
+  character: v.string(),
+};
+export type SerializedPlayerDescription = ObjectType<typeof serializedPlayerDescription>;
+
+export class PlayerDescription {
+  playerId: GameId<'players'>;
+  name: string;
+  description: string;
+  character: string;
+
+  constructor(serialized: SerializedPlayerDescription) {
+    const { playerId, name, description, character } = serialized;
+    this.playerId = parseGameId('players', playerId);
+    this.name = name;
+    this.description = description;
+    this.character = character;
+  }
+
+  serialize(): SerializedPlayerDescription {
+    const { playerId, name, description, character } = this;
+    return {
+      playerId,
+      name,
+      description,
+      character,
+    };
+  }
+}

package/convex/aiTown/schema.ts

@@ -0,0 +1,79 @@
+import { v } from 'convex/values';
+import { defineTable } from 'convex/server';
+import { serializedPlayer } from './player';
+import { serializedPlayerDescription } from './playerDescription';
+import { serializedAgent } from './agent';
+import { serializedAgentDescription } from './agentDescription';
+import { serializedWorld } from './world';
+import { serializedWorldMap } from './worldMap';
+import { serializedConversation } from './conversation';
+import { conversationId, playerId } from './ids';
+
+export const aiTownTables = {
+  // This table has a single document that stores all players, conversations, and agents. This
+  // data is small and changes regularly over time.
+  worlds: defineTable({ ...serializedWorld }),
+
+  // Worlds can be started or stopped by the developer or paused for inactivity, and this
+  // infrequently changing document tracks this world state.
+  worldStatus: defineTable({
+    worldId: v.id('worlds'),
+    isDefault: v.boolean(),
+    engineId: v.id('engines'),
+    lastViewed: v.number(),
+    status: v.union(v.literal('running'), v.literal('stoppedByDeveloper'), v.literal('inactive')),
+  }).index('worldId', ['worldId']),
+
+  // This table contains the map data for a given world. Since it's a bit larger than the player
+  // state and infrequently changes, we store it in a separate table.
+  maps: defineTable({
+    worldId: v.id('worlds'),
+    ...serializedWorldMap,
+  }).index('worldId', ['worldId']),
+
+  // Human readable text describing players and agents that's stored in separate tables, just like `maps`.
+  playerDescriptions: defineTable({
+    worldId: v.id('worlds'),
+    ...serializedPlayerDescription,
+  }).index('worldId', ['worldId', 'playerId']),
+  agentDescriptions: defineTable({
+    worldId: v.id('worlds'),
+    ...serializedAgentDescription,
+  }).index('worldId', ['worldId', 'agentId']),
+
+  //The game engine doesn't want to track players that have left or conversations that are over, since
+  // it wants to keep its managed state small. However, we may want to look at old conversations in the
+  // UI or from the agent code. So, whenever we delete an entry from within the world's document, we
+  // "archive" it within these tables.
+  archivedPlayers: defineTable({ worldId: v.id('worlds'), ...serializedPlayer }).index('worldId', [
+    'worldId',
+    'id',
+  ]),
+  archivedConversations: defineTable({
+    worldId: v.id('worlds'),
+    id: conversationId,
+    creator: playerId,
+    created: v.number(),
+    ended: v.number(),
+    lastMessage: serializedConversation.lastMessage,
+    numMessages: serializedConversation.numMessages,
+    participants: v.array(playerId),
+  }).index('worldId', ['worldId', 'id']),
+  archivedAgents: defineTable({ worldId: v.id('worlds'), ...serializedAgent }).index('worldId', [
+    'worldId',
+    'id',
+  ]),
+
+  // The agent layer wants to know what the last (completed) conversation was between two players,
+  // so this table represents a labelled graph indicating which players have talked to each other.
+  participatedTogether: defineTable({
+    worldId: v.id('worlds'),
+    conversationId,
+    player1: playerId,
+    player2: playerId,
+    ended: v.number(),
+  })
+    .index('edge', ['worldId', 'player1', 'player2', 'ended'])
+    .index('conversation', ['worldId', 'player1', 'conversationId'])
+    .index('playerHistory', ['worldId', 'player1', 'ended']),
+};

package/convex/aiTown/world.ts

@@ -0,0 +1,65 @@
+import { ObjectType, v } from 'convex/values';
+import { Conversation, serializedConversation } from './conversation';
+import { Player, serializedPlayer } from './player';
+import { Agent, serializedAgent } from './agent';
+import { GameId, parseGameId, playerId } from './ids';
+import { parseMap } from '../util/object';
+
+export const historicalLocations = v.array(
+  v.object({
+    playerId,
+    location: v.bytes(),
+  }),
+);
+
+export const serializedWorld = {
+  nextId: v.number(),
+  conversations: v.array(v.object(serializedConversation)),
+  players: v.array(v.object(serializedPlayer)),
+  agents: v.array(v.object(serializedAgent)),
+  historicalLocations: v.optional(historicalLocations),
+};
+export type SerializedWorld = ObjectType<typeof serializedWorld>;
+
+export class World {
+  nextId: number;
+  conversations: Map<GameId<'conversations'>, Conversation>;
+  players: Map<GameId<'players'>, Player>;
+  agents: Map<GameId<'agents'>, Agent>;
+  historicalLocations?: Map<GameId<'players'>, ArrayBuffer>;
+
+  constructor(serialized: SerializedWorld) {
+    const { nextId, historicalLocations } = serialized;
+
+    this.nextId = nextId;
+    this.conversations = parseMap(serialized.conversations, Conversation, (c) => c.id);
+    this.players = parseMap(serialized.players, Player, (p) => p.id);
+    this.agents = parseMap(serialized.agents, Agent, (a) => a.id);
+
+    if (historicalLocations) {
+      this.historicalLocations = new Map();
+      for (const { playerId, location } of historicalLocations) {
+        this.historicalLocations.set(parseGameId('players', playerId), location);
+      }
+    }
+  }
+
+  playerConversation(player: Player): Conversation | undefined {
+    return [...this.conversations.values()].find((c) => c.participants.has(player.id));
+  }
+
+  serialize(): SerializedWorld {
+    return {
+      nextId: this.nextId,
+      conversations: [...this.conversations.values()].map((c) => c.serialize()),
+      players: [...this.players.values()].map((p) => p.serialize()),
+      agents: [...this.agents.values()].map((a) => a.serialize()),
+      historicalLocations:
+        this.historicalLocations &&
+        [...this.historicalLocations.entries()].map(([playerId, location]) => ({
+          playerId,
+          location,
+        })),
+    };
+  }
+}