solanapolis 1.0.0

package/convex/aiTown/game.ts

@@ -0,0 +1,371 @@
+import { Infer, v } from 'convex/values';
+import { Doc, Id } from '../_generated/dataModel';
+import {
+  ActionCtx,
+  DatabaseReader,
+  MutationCtx,
+  internalMutation,
+  internalQuery,
+} from '../_generated/server';
+import { World, serializedWorld } from './world';
+import { WorldMap, serializedWorldMap } from './worldMap';
+import { PlayerDescription, serializedPlayerDescription } from './playerDescription';
+import { Location, locationFields, playerLocation } from './location';
+import { runAgentOperation } from './agent';
+import { GameId, IdTypes, allocGameId } from './ids';
+import { InputArgs, InputNames, inputs } from './inputs';
+import {
+  AbstractGame,
+  EngineUpdate,
+  applyEngineUpdate,
+  engineUpdate,
+  loadEngine,
+} from '../engine/abstractGame';
+import { internal } from '../_generated/api';
+import { HistoricalObject } from '../engine/historicalObject';
+import { AgentDescription, serializedAgentDescription } from './agentDescription';
+import { parseMap, serializeMap } from '../util/object';
+
+const gameState = v.object({
+  world: v.object(serializedWorld),
+  playerDescriptions: v.array(v.object(serializedPlayerDescription)),
+  agentDescriptions: v.array(v.object(serializedAgentDescription)),
+  worldMap: v.object(serializedWorldMap),
+});
+type GameState = Infer<typeof gameState>;
+
+const gameStateDiff = v.object({
+  world: v.object(serializedWorld),
+  playerDescriptions: v.optional(v.array(v.object(serializedPlayerDescription))),
+  agentDescriptions: v.optional(v.array(v.object(serializedAgentDescription))),
+  worldMap: v.optional(v.object(serializedWorldMap)),
+  agentOperations: v.array(v.object({ name: v.string(), args: v.any() })),
+});
+type GameStateDiff = Infer<typeof gameStateDiff>;
+
+export class Game extends AbstractGame {
+  tickDuration = 16;
+  stepDuration = 1000;
+  maxTicksPerStep = 600;
+  maxInputsPerStep = 32;
+
+  world: World;
+
+  historicalLocations: Map<GameId<'players'>, HistoricalObject<Location>>;
+
+  descriptionsModified: boolean;
+  worldMap: WorldMap;
+  playerDescriptions: Map<GameId<'players'>, PlayerDescription>;
+  agentDescriptions: Map<GameId<'agents'>, AgentDescription>;
+
+  pendingOperations: Array<{ name: string; args: any }> = [];
+
+  numPathfinds: number;
+
+  constructor(
+    engine: Doc<'engines'>,
+    public worldId: Id<'worlds'>,
+    state: GameState,
+  ) {
+    super(engine);
+
+    this.world = new World(state.world);
+    delete this.world.historicalLocations;
+
+    this.descriptionsModified = false;
+    this.worldMap = new WorldMap(state.worldMap);
+    this.agentDescriptions = parseMap(state.agentDescriptions, AgentDescription, (a) => a.agentId);
+    this.playerDescriptions = parseMap(
+      state.playerDescriptions,
+      PlayerDescription,
+      (p) => p.playerId,
+    );
+
+    this.historicalLocations = new Map();
+
+    this.numPathfinds = 0;
+  }
+
+  static async load(
+    db: DatabaseReader,
+    worldId: Id<'worlds'>,
+    generationNumber: number,
+  ): Promise<{ engine: Doc<'engines'>; gameState: GameState }> {
+    const worldDoc = await db.get(worldId);
+    if (!worldDoc) {
+      throw new Error(`No world found with id ${worldId}`);
+    }
+    const worldStatus = await db
+      .query('worldStatus')
+      .withIndex('worldId', (q) => q.eq('worldId', worldId))
+      .unique();
+    if (!worldStatus) {
+      throw new Error(`No engine found for world ${worldId}`);
+    }
+    const engine = await loadEngine(db, worldStatus.engineId, generationNumber);
+    const playerDescriptionsDocs = await db
+      .query('playerDescriptions')
+      .withIndex('worldId', (q) => q.eq('worldId', worldId))
+      .collect();
+    const agentDescriptionsDocs = await db
+      .query('agentDescriptions')
+      .withIndex('worldId', (q) => q.eq('worldId', worldId))
+      .collect();
+    const worldMapDoc = await db
+      .query('maps')
+      .withIndex('worldId', (q) => q.eq('worldId', worldId))
+      .unique();
+    if (!worldMapDoc) {
+      throw new Error(`No map found for world ${worldId}`);
+    }
+    // Discard the system fields and historicalLocations from the world state.
+    const { _id, _creationTime, historicalLocations: _, ...world } = worldDoc;
+    const playerDescriptions = playerDescriptionsDocs
+      // Discard player descriptions for players that no longer exist.
+      .filter((d) => !!world.players.find((p) => p.id === d.playerId))
+      .map(({ _id, _creationTime, worldId: _, ...doc }) => doc);
+    const agentDescriptions = agentDescriptionsDocs
+      .filter((a) => !!world.agents.find((p) => p.id === a.agentId))
+      .map(({ _id, _creationTime, worldId: _, ...doc }) => doc);
+    const {
+      _id: _mapId,
+      _creationTime: _mapCreationTime,
+      worldId: _mapWorldId,
+      ...worldMap
+    } = worldMapDoc;
+    return {
+      engine,
+      gameState: {
+        world,
+        playerDescriptions,
+        agentDescriptions,
+        worldMap,
+      },
+    };
+  }
+
+  allocId<T extends IdTypes>(idType: T): GameId<T> {
+    const id = allocGameId(idType, this.world.nextId);
+    this.world.nextId += 1;
+    return id;
+  }
+
+  scheduleOperation(name: string, args: unknown) {
+    this.pendingOperations.push({ name, args });
+  }
+
+  handleInput<Name extends InputNames>(now: number, name: Name, args: InputArgs<Name>) {
+    const handler = inputs[name]?.handler;
+    if (!handler) {
+      throw new Error(`Invalid input: ${name}`);
+    }
+    return handler(this, now, args as any);
+  }
+
+  beginStep(_now: number) {
+    // Store the current location of all players in the history tracking buffer.
+    this.historicalLocations.clear();
+    for (const player of this.world.players.values()) {
+      this.historicalLocations.set(
+        player.id,
+        new HistoricalObject(locationFields, playerLocation(player)),
+      );
+    }
+    this.numPathfinds = 0;
+  }
+
+  tick(now: number) {
+    for (const player of this.world.players.values()) {
+      player.tick(this, now);
+    }
+    for (const player of this.world.players.values()) {
+      player.tickPathfinding(this, now);
+    }
+    for (const player of this.world.players.values()) {
+      player.tickPosition(this, now);
+    }
+    for (const conversation of this.world.conversations.values()) {
+      conversation.tick(this, now);
+    }
+    for (const agent of this.world.agents.values()) {
+      agent.tick(this, now);
+    }
+
+    // Save each player's location into the history buffer at the end of
+    // each tick.
+    for (const player of this.world.players.values()) {
+      let historicalObject = this.historicalLocations.get(player.id);
+      if (!historicalObject) {
+        historicalObject = new HistoricalObject(locationFields, playerLocation(player));
+        this.historicalLocations.set(player.id, historicalObject);
+      }
+      historicalObject.update(now, playerLocation(player));
+    }
+  }
+
+  async saveStep(ctx: ActionCtx, engineUpdate: EngineUpdate): Promise<void> {
+    const diff = this.takeDiff();
+    await ctx.runMutation(internal.aiTown.game.saveWorld, {
+      engineId: this.engine._id,
+      engineUpdate,
+      worldId: this.worldId,
+      worldDiff: diff,
+    });
+  }
+
+  takeDiff(): GameStateDiff {
+    const historicalLocations = [];
+    let bufferSize = 0;
+    for (const [id, historicalObject] of this.historicalLocations.entries()) {
+      const buffer = historicalObject.pack();
+      if (!buffer) {
+        continue;
+      }
+      historicalLocations.push({ playerId: id, location: buffer });
+      bufferSize += buffer.byteLength;
+    }
+    if (bufferSize > 0) {
+      console.debug(
+        `Packed ${Object.entries(historicalLocations).length} history buffers in ${(
+          bufferSize / 1024
+        ).toFixed(2)}KiB.`,
+      );
+    }
+    this.historicalLocations.clear();
+
+    const result: GameStateDiff = {
+      world: { ...this.world.serialize(), historicalLocations },
+      agentOperations: this.pendingOperations,
+    };
+    this.pendingOperations = [];
+    if (this.descriptionsModified) {
+      result.playerDescriptions = serializeMap(this.playerDescriptions);
+      result.agentDescriptions = serializeMap(this.agentDescriptions);
+      result.worldMap = this.worldMap.serialize();
+      this.descriptionsModified = false;
+    }
+    return result;
+  }
+
+  static async saveDiff(ctx: MutationCtx, worldId: Id<'worlds'>, diff: GameStateDiff) {
+    const existingWorld = await ctx.db.get(worldId);
+    if (!existingWorld) {
+      throw new Error(`No world found with id ${worldId}`);
+    }
+    const newWorld = diff.world;
+    // Archive newly deleted players, conversations, and agents.
+    for (const player of existingWorld.players) {
+      if (!newWorld.players.some((p) => p.id === player.id)) {
+        await ctx.db.insert('archivedPlayers', { worldId, ...player });
+      }
+    }
+    for (const conversation of existingWorld.conversations) {
+      if (!newWorld.conversations.some((c) => c.id === conversation.id)) {
+        const participants = conversation.participants.map((p) => p.playerId);
+        const archivedConversation = {
+          worldId,
+          id: conversation.id,
+          created: conversation.created,
+          creator: conversation.creator,
+          ended: Date.now(),
+          lastMessage: conversation.lastMessage,
+          numMessages: conversation.numMessages,
+          participants,
+        };
+        await ctx.db.insert('archivedConversations', archivedConversation);
+        for (let i = 0; i < participants.length; i++) {
+          for (let j = 0; j < participants.length; j++) {
+            if (i == j) {
+              continue;
+            }
+            const player1 = participants[i];
+            const player2 = participants[j];
+            await ctx.db.insert('participatedTogether', {
+              worldId,
+              conversationId: conversation.id,
+              player1,
+              player2,
+              ended: Date.now(),
+            });
+          }
+        }
+      }
+    }
+    for (const conversation of existingWorld.agents) {
+      if (!newWorld.agents.some((a) => a.id === conversation.id)) {
+        await ctx.db.insert('archivedAgents', { worldId, ...conversation });
+      }
+    }
+    // Update the world state.
+    await ctx.db.replace(worldId, newWorld);
+
+    // Update the larger description tables if they changed.
+    const { playerDescriptions, agentDescriptions, worldMap } = diff;
+    if (playerDescriptions) {
+      for (const description of playerDescriptions) {
+        const existing = await ctx.db
+          .query('playerDescriptions')
+          .withIndex('worldId', (q) =>
+            q.eq('worldId', worldId).eq('playerId', description.playerId),
+          )
+          .unique();
+        if (existing) {
+          await ctx.db.replace(existing._id, { worldId, ...description });
+        } else {
+          await ctx.db.insert('playerDescriptions', { worldId, ...description });
+        }
+      }
+    }
+    if (agentDescriptions) {
+      for (const description of agentDescriptions) {
+        const existing = await ctx.db
+          .query('agentDescriptions')
+          .withIndex('worldId', (q) => q.eq('worldId', worldId).eq('agentId', description.agentId))
+          .unique();
+        if (existing) {
+          await ctx.db.replace(existing._id, { worldId, ...description });
+        } else {
+          await ctx.db.insert('agentDescriptions', { worldId, ...description });
+        }
+      }
+    }
+    if (worldMap) {
+      const existing = await ctx.db
+        .query('maps')
+        .withIndex('worldId', (q) => q.eq('worldId', worldId))
+        .unique();
+      if (existing) {
+        await ctx.db.replace(existing._id, { worldId, ...worldMap });
+      } else {
+        await ctx.db.insert('maps', { worldId, ...worldMap });
+      }
+    }
+    // Start the desired agent operations.
+    for (const operation of diff.agentOperations) {
+      await runAgentOperation(ctx, operation.name, operation.args);
+    }
+  }
+}
+
+export const loadWorld = internalQuery({
+  args: {
+    worldId: v.id('worlds'),
+    generationNumber: v.number(),
+  },
+  handler: async (ctx, args) => {
+    return await Game.load(ctx.db, args.worldId, args.generationNumber);
+  },
+});
+
+export const saveWorld = internalMutation({
+  args: {
+    engineId: v.id('engines'),
+    engineUpdate,
+    worldId: v.id('worlds'),
+    worldDiff: gameStateDiff,
+  },
+  handler: async (ctx, args) => {
+    await applyEngineUpdate(ctx, args.engineId, args.engineUpdate);
+    await Game.saveDiff(ctx, args.worldId, args.worldDiff);
+  },
+});

package/convex/aiTown/ids.ts

@@ -0,0 +1,32 @@
+import { v } from 'convex/values';
+
+const IdShortCodes = { agents: 'a', conversations: 'c', players: 'p', operations: 'o' };
+export type IdTypes = keyof typeof IdShortCodes;
+
+export type GameId<T extends IdTypes> = string & { __type: T };
+
+export function parseGameId<T extends IdTypes>(idType: T, gameId: string): GameId<T> {
+  const type = gameId[0];
+  const match = Object.entries(IdShortCodes).find(([_, value]) => value === type);
+  if (!match || match[0] !== idType) {
+    throw new Error(`Invalid game ID type: ${type}`);
+  }
+  const number = parseInt(gameId.slice(2), 10);
+  if (isNaN(number) || !Number.isInteger(number) || number < 0) {
+    throw new Error(`Invalid game ID number: ${gameId}`);
+  }
+  return gameId as GameId<T>;
+}
+
+export function allocGameId<T extends IdTypes>(idType: T, idNumber: number): GameId<T> {
+  const type = IdShortCodes[idType];
+  if (!type) {
+    throw new Error(`Invalid game ID type: ${idType}`);
+  }
+  return `${type}:${idNumber}` as GameId<T>;
+}
+
+export const conversationId = v.string();
+export const playerId = v.string();
+export const agentId = v.string();
+export const operationId = v.string();

package/convex/aiTown/inputHandler.ts

@@ -0,0 +1,9 @@
+import { ObjectType, PropertyValidators, Value } from 'convex/values';
+import type { Game } from './game';
+
+export function inputHandler<ArgsValidator extends PropertyValidators, Return extends Value>(def: {
+  args: ArgsValidator;
+  handler: (game: Game, now: number, args: ObjectType<ArgsValidator>) => Return;
+}) {
+  return def;
+}

package/convex/aiTown/inputs.ts

@@ -0,0 +1,25 @@
+import { ObjectType } from 'convex/values';
+import { playerInputs } from './player';
+import { conversationInputs } from './conversation';
+import { agentInputs } from './agentInputs';
+
+// It's easy to hit circular dependencies with these imports,
+// so assert at module scope so we hit errors when analyzing.
+if (playerInputs === undefined || conversationInputs === undefined || agentInputs === undefined) {
+  throw new Error("Input map is undefined, check if there's a circular import.");
+}
+export const inputs = {
+  ...playerInputs,
+  // Inputs for the messaging layer.
+  ...conversationInputs,
+  // Inputs for the agent layer.
+  ...agentInputs,
+};
+export type Inputs = typeof inputs;
+export type InputNames = keyof Inputs;
+export type InputArgs<Name extends InputNames> = ObjectType<Inputs[Name]['args']>;
+export type InputReturnValue<Name extends InputNames> = ReturnType<
+  Inputs[Name]['handler']
+> extends Promise<infer T>
+  ? T
+  : never;

package/convex/aiTown/insertInput.ts

@@ -0,0 +1,20 @@
+import { MutationCtx } from '../_generated/server';
+import { Id } from '../_generated/dataModel';
+import { engineInsertInput } from '../engine/abstractGame';
+import { InputNames, InputArgs } from './inputs';
+
+export async function insertInput<Name extends InputNames>(
+  ctx: MutationCtx,
+  worldId: Id<'worlds'>,
+  name: Name,
+  args: InputArgs<Name>,
+): Promise<Id<'inputs'>> {
+  const worldStatus = await ctx.db
+    .query('worldStatus')
+    .withIndex('worldId', (q) => q.eq('worldId', worldId))
+    .unique();
+  if (!worldStatus) {
+    throw new Error(`World for engine ${worldId} not found`);
+  }
+  return await engineInsertInput(ctx, worldStatus.engineId, name, args);
+}

package/convex/aiTown/location.ts

@@ -0,0 +1,32 @@
+import { FieldConfig } from '../engine/historicalObject';
+import { Player } from './player';
+
+export type Location = {
+  // Unpacked player position.
+  x: number;
+  y: number;
+
+  // Normalized facing vector.
+  dx: number;
+  dy: number;
+
+  speed: number;
+};
+
+export const locationFields: FieldConfig = [
+  { name: 'x', precision: 8 },
+  { name: 'y', precision: 8 },
+  { name: 'dx', precision: 8 },
+  { name: 'dy', precision: 8 },
+  { name: 'speed', precision: 16 },
+];
+
+export function playerLocation(player: Player): Location {
+  return {
+    x: player.position.x,
+    y: player.position.y,
+    dx: player.facing.dx,
+    dy: player.facing.dy,
+    speed: player.speed,
+  };
+}

package/convex/aiTown/main.ts

@@ -0,0 +1,154 @@
+import { ConvexError, v } from 'convex/values';
+import { DatabaseReader, MutationCtx, internalAction, mutation, query } from '../_generated/server';
+import { insertInput } from './insertInput';
+import { Game } from './game';
+import { internal } from '../_generated/api';
+import { sleep } from '../util/sleep';
+import { Id } from '../_generated/dataModel';
+import { ENGINE_ACTION_DURATION } from '../constants';
+
+export async function createEngine(ctx: MutationCtx) {
+  const now = Date.now();
+  const engineId = await ctx.db.insert('engines', {
+    currentTime: now,
+    generationNumber: 0,
+    running: true,
+  });
+  return engineId;
+}
+
+async function loadWorldStatus(db: DatabaseReader, worldId: Id<'worlds'>) {
+  const worldStatus = await db
+    .query('worldStatus')
+    .withIndex('worldId', (q) => q.eq('worldId', worldId))
+    .unique();
+  if (!worldStatus) {
+    throw new Error(`No engine found for world ${worldId}`);
+  }
+  return worldStatus;
+}
+
+export async function startEngine(ctx: MutationCtx, worldId: Id<'worlds'>) {
+  const { engineId } = await loadWorldStatus(ctx.db, worldId);
+  const engine = await ctx.db.get(engineId);
+  if (!engine) {
+    throw new Error(`Invalid engine ID: ${engineId}`);
+  }
+  if (engine.running) {
+    throw new Error(`Engine ${engineId} isn't currently stopped`);
+  }
+  const now = Date.now();
+  const generationNumber = engine.generationNumber + 1;
+  await ctx.db.patch(engineId, {
+    // Forcibly advance time to the present. This does mean we'll skip
+    // simulating the time the engine was stopped, but we don't want
+    // to have to simulate a potentially large stopped window and send
+    // it down to clients.
+    lastStepTs: engine.currentTime,
+    currentTime: now,
+    running: true,
+    generationNumber,
+  });
+  await ctx.scheduler.runAfter(0, internal.aiTown.main.runStep, {
+    worldId: worldId,
+    generationNumber,
+    maxDuration: ENGINE_ACTION_DURATION,
+  });
+}
+
+export async function kickEngine(ctx: MutationCtx, worldId: Id<'worlds'>) {
+  const { engineId } = await loadWorldStatus(ctx.db, worldId);
+  const engine = await ctx.db.get(engineId);
+  if (!engine) {
+    throw new Error(`Invalid engine ID: ${engineId}`);
+  }
+  if (!engine.running) {
+    throw new Error(`Engine ${engineId} isn't currently running`);
+  }
+  const generationNumber = engine.generationNumber + 1;
+  await ctx.db.patch(engineId, { generationNumber });
+  await ctx.scheduler.runAfter(0, internal.aiTown.main.runStep, {
+    worldId: worldId,
+    generationNumber,
+    maxDuration: ENGINE_ACTION_DURATION,
+  });
+}
+
+export async function stopEngine(ctx: MutationCtx, worldId: Id<'worlds'>) {
+  const { engineId } = await loadWorldStatus(ctx.db, worldId);
+  const engine = await ctx.db.get(engineId);
+  if (!engine) {
+    throw new Error(`Invalid engine ID: ${engineId}`);
+  }
+  if (!engine.running) {
+    throw new Error(`Engine ${engineId} isn't currently running`);
+  }
+  await ctx.db.patch(engineId, { running: false });
+}
+
+export const runStep = internalAction({
+  args: {
+    worldId: v.id('worlds'),
+    generationNumber: v.number(),
+    maxDuration: v.number(),
+  },
+  handler: async (ctx, args) => {
+    try {
+      const { engine, gameState } = await ctx.runQuery(internal.aiTown.game.loadWorld, {
+        worldId: args.worldId,
+        generationNumber: args.generationNumber,
+      });
+      const game = new Game(engine, args.worldId, gameState);
+
+      let now = Date.now();
+      const deadline = now + args.maxDuration;
+      while (now < deadline) {
+        await game.runStep(ctx, now);
+        const sleepUntil = Math.min(now + game.stepDuration, deadline);
+        await sleep(sleepUntil - now);
+        now = Date.now();
+      }
+      await ctx.scheduler.runAfter(0, internal.aiTown.main.runStep, {
+        worldId: args.worldId,
+        generationNumber: game.engine.generationNumber,
+        maxDuration: args.maxDuration,
+      });
+    } catch (e: unknown) {
+      if (e instanceof ConvexError) {
+        if (e.data.kind === 'engineNotRunning') {
+          console.debug(`Engine is not running: ${e.message}`);
+          return;
+        }
+        if (e.data.kind === 'generationNumber') {
+          console.debug(`Generation number mismatch: ${e.message}`);
+          return;
+        }
+      }
+      throw e;
+    }
+  },
+});
+
+export const sendInput = mutation({
+  args: {
+    worldId: v.id('worlds'),
+    name: v.string(),
+    args: v.any(),
+  },
+  handler: async (ctx, args) => {
+    return await insertInput(ctx, args.worldId, args.name as any, args.args);
+  },
+});
+
+export const inputStatus = query({
+  args: {
+    inputId: v.id('inputs'),
+  },
+  handler: async (ctx, args) => {
+    const input = await ctx.db.get(args.inputId);
+    if (!input) {
+      throw new Error(`Invalid input ID: ${args.inputId}`);
+    }
+    return input.returnValue ?? null;
+  },
+});