solanapolis 1.0.0

package/convex/aiTown/worldMap.ts

@@ -0,0 +1,74 @@
+import { Infer, ObjectType, v } from 'convex/values';
+
+// `layer[position.x][position.y]` is the tileIndex or -1 if empty.
+const tileLayer = v.array(v.array(v.number()));
+export type TileLayer = Infer<typeof tileLayer>;
+
+const animatedSprite = {
+  x: v.number(),
+  y: v.number(),
+  w: v.number(),
+  h: v.number(),
+  layer: v.number(),
+  sheet: v.string(),
+  animation: v.string(),
+};
+export type AnimatedSprite = ObjectType<typeof animatedSprite>;
+
+export const serializedWorldMap = {
+  width: v.number(),
+  height: v.number(),
+
+  tileSetUrl: v.string(),
+  //  Width & height of tileset image, px.
+  tileSetDimX: v.number(),
+  tileSetDimY: v.number(),
+
+  // Tile size in pixels (assume square)
+  tileDim: v.number(),
+  bgTiles: v.array(v.array(v.array(v.number()))),
+  objectTiles: v.array(tileLayer),
+  animatedSprites: v.array(v.object(animatedSprite)),
+};
+export type SerializedWorldMap = ObjectType<typeof serializedWorldMap>;
+
+export class WorldMap {
+  width: number;
+  height: number;
+
+  tileSetUrl: string;
+  tileSetDimX: number;
+  tileSetDimY: number;
+
+  tileDim: number;
+
+  bgTiles: TileLayer[];
+  objectTiles: TileLayer[];
+  animatedSprites: AnimatedSprite[];
+
+  constructor(serialized: SerializedWorldMap) {
+    this.width = serialized.width;
+    this.height = serialized.height;
+    this.tileSetUrl = serialized.tileSetUrl;
+    this.tileSetDimX = serialized.tileSetDimX;
+    this.tileSetDimY = serialized.tileSetDimY;
+    this.tileDim = serialized.tileDim;
+    this.bgTiles = serialized.bgTiles;
+    this.objectTiles = serialized.objectTiles;
+    this.animatedSprites = serialized.animatedSprites;
+  }
+
+  serialize(): SerializedWorldMap {
+    return {
+      width: this.width,
+      height: this.height,
+      tileSetUrl: this.tileSetUrl,
+      tileSetDimX: this.tileSetDimX,
+      tileSetDimY: this.tileSetDimY,
+      tileDim: this.tileDim,
+      bgTiles: this.bgTiles,
+      objectTiles: this.objectTiles,
+      animatedSprites: this.animatedSprites,
+    };
+  }
+}

package/convex/chat.ts

@@ -0,0 +1,79 @@
+import { query, mutation, internalQuery } from "./_generated/server";
+import { StreamId } from "@convex-dev/persistent-text-streaming";
+import { v } from "convex/values";
+import { streamingComponent } from "./streaming";
+
+/** List the most recent 100 chat messages, oldest first */
+export const listMessages = query({
+  args: {},
+  handler: async (ctx) => {
+    const messages = await ctx.db
+      .query("chat_messages")
+      .order("desc")
+      .take(100);
+    return messages.reverse();
+  },
+});
+
+/** Send a player chat message + create an AI response placeholder */
+export const sendMessage = mutation({
+  args: {
+    wallet_address: v.string(),
+    display_name: v.optional(v.string()),
+    message: v.string(),
+  },
+  handler: async (ctx, args) => {
+    // Insert the player's message
+    await ctx.db.insert("chat_messages", {
+      wallet_address: args.wallet_address,
+      display_name: args.display_name,
+      message: args.message.slice(0, 280),
+    });
+
+    // Create a stream for the AI response
+    const streamId = await streamingComponent.createStream(ctx);
+
+    // Insert the AI response placeholder
+    const aiMsgId = await ctx.db.insert("chat_messages", {
+      wallet_address: "helios-ai",
+      display_name: "Helios AI",
+      message: "",
+      is_ai: true,
+      responseStreamId: streamId,
+    });
+
+    return { aiMsgId, streamId };
+  },
+});
+
+/** Get chat history for AI context */
+export const getHistory = internalQuery({
+  args: {},
+  handler: async (ctx) => {
+    const messages = await ctx.db
+      .query("chat_messages")
+      .order("desc")
+      .take(20);
+
+    const history: { role: "user" | "assistant"; content: string }[] = [];
+
+    for (const msg of messages.reverse()) {
+      if (msg.is_ai && msg.responseStreamId) {
+        const body = await streamingComponent.getStreamBody(
+          ctx,
+          msg.responseStreamId as StreamId,
+        );
+        if (body.text) {
+          history.push({ role: "assistant", content: body.text });
+        }
+      } else {
+        history.push({
+          role: "user",
+          content: `[${msg.display_name || msg.wallet_address}]: ${msg.message}`,
+        });
+      }
+    }
+
+    return history;
+  },
+});

package/convex/constants.ts

@@ -0,0 +1,78 @@
+export const ACTION_TIMEOUT = 120_000; // more time for local dev
+// export const ACTION_TIMEOUT = 60_000;// normally fine
+
+export const IDLE_WORLD_TIMEOUT = 5 * 60 * 1000;
+export const WORLD_HEARTBEAT_INTERVAL = 60 * 1000;
+
+export const MAX_STEP = 10 * 60 * 1000;
+export const TICK = 16;
+export const STEP_INTERVAL = 1000;
+
+export const PATHFINDING_TIMEOUT = 60 * 1000;
+export const PATHFINDING_BACKOFF = 1000;
+export const CONVERSATION_DISTANCE = 1.3;
+export const MIDPOINT_THRESHOLD = 4;
+export const TYPING_TIMEOUT = 15 * 1000;
+export const COLLISION_THRESHOLD = 0.75;
+
+// How many human players can be in a world at once.
+export const MAX_HUMAN_PLAYERS = 8;
+
+// Don't talk to anyone for 15s after having a conversation.
+export const CONVERSATION_COOLDOWN = 15000;
+
+// Don't do another activity for 10s after doing one.
+export const ACTIVITY_COOLDOWN = 10_000;
+
+// Don't talk to a player within 60s of talking to them.
+export const PLAYER_CONVERSATION_COOLDOWN = 60000;
+
+// Invite 80% of invites that come from other agents.
+export const INVITE_ACCEPT_PROBABILITY = 0.8;
+
+// Wait for 1m for invites to be accepted.
+export const INVITE_TIMEOUT = 60000;
+
+// Wait for another player to say something before jumping in.
+export const AWKWARD_CONVERSATION_TIMEOUT = 60_000; // more time locally
+// export const AWKWARD_CONVERSATION_TIMEOUT = 20_000;
+
+// Leave a conversation after participating too long.
+export const MAX_CONVERSATION_DURATION = 10 * 60_000; // more time locally
+// export const MAX_CONVERSATION_DURATION = 2 * 60_000;
+
+// Leave a conversation if it has more than 8 messages;
+export const MAX_CONVERSATION_MESSAGES = 8;
+
+// Wait for 1s after sending an input to the engine. We can remove this
+// once we can await on an input being processed.
+export const INPUT_DELAY = 1000;
+
+// How many memories to get from the agent's memory.
+// This is over-fetched by 10x so we can prioritize memories by more than relevance.
+export const NUM_MEMORIES_TO_SEARCH = 3;
+
+// Wait for at least two seconds before sending another message.
+export const MESSAGE_COOLDOWN = 2000;
+
+// Don't run a turn of the agent more than once a second.
+export const AGENT_WAKEUP_THRESHOLD = 1000;
+
+// How old we let memories be before we vacuum them
+export const VACUUM_MAX_AGE = 2 * 7 * 24 * 60 * 60 * 1000;
+export const DELETE_BATCH_SIZE = 64;
+
+export const HUMAN_IDLE_TOO_LONG = 5 * 60 * 1000;
+
+export const ACTIVITIES = [
+  { description: 'reading a book', emoji: '📖', duration: 60_000 },
+  { description: 'daydreaming', emoji: '🤔', duration: 60_000 },
+  { description: 'gardening', emoji: '🥕', duration: 60_000 },
+];
+
+export const ENGINE_ACTION_DURATION = 30000;
+
+// Bound the number of pathfinding searches we do per game step.
+export const MAX_PATHFINDS_PER_STEP = 16;
+
+export const DEFAULT_NAME = 'Me';

package/convex/convex.config.ts

@@ -0,0 +1,6 @@
+import { defineApp } from "convex/server";
+import persistentTextStreaming from "@convex-dev/persistent-text-streaming/convex.config";
+
+const app = defineApp();
+app.use(persistentTextStreaming);
+export default app;

package/convex/crons.ts

@@ -0,0 +1,89 @@
+import { cronJobs } from 'convex/server';
+import { DELETE_BATCH_SIZE, IDLE_WORLD_TIMEOUT, VACUUM_MAX_AGE } from './constants';
+import { internal } from './_generated/api';
+import { internalMutation } from './_generated/server';
+import { TableNames } from './_generated/dataModel';
+import { v } from 'convex/values';
+
+const crons = cronJobs();
+
+crons.interval(
+  'stop inactive worlds',
+  { seconds: IDLE_WORLD_TIMEOUT / 1000 },
+  internal.world.stopInactiveWorlds,
+);
+
+crons.interval('restart dead worlds', { seconds: 60 }, internal.world.restartDeadWorlds);
+
+crons.daily('vacuum old entries', { hourUTC: 4, minuteUTC: 20 }, internal.crons.vacuumOldEntries);
+
+export default crons;
+
+const TablesToVacuum: TableNames[] = [
+  // Un-comment this to also clean out old conversations.
+  // 'conversationMembers', 'conversations', 'messages',
+
+  // Inputs aren't useful unless you're trying to replay history.
+  // If you want to support that, you should add a snapshot table, so you can
+  // replay from a certain time period. Or stop vacuuming inputs and replay from
+  // the beginning of time
+  'inputs',
+
+  // We can keep memories without their embeddings for inspection, but we won't
+  // retrieve them when searching memories via vector search.
+  'memories',
+  // We can vacuum fewer tables without serious consequences, but the only
+  // one that will cause issues over time is having >>100k vectors.
+  'memoryEmbeddings',
+];
+
+export const vacuumOldEntries = internalMutation({
+  args: {},
+  handler: async (ctx, args) => {
+    const before = Date.now() - VACUUM_MAX_AGE;
+    for (const tableName of TablesToVacuum) {
+      console.log(`Checking ${tableName}...`);
+      const exists = await ctx.db
+        .query(tableName)
+        .withIndex('by_creation_time', (q) => q.lt('_creationTime', before))
+        .first();
+      if (exists) {
+        console.log(`Vacuuming ${tableName}...`);
+        await ctx.scheduler.runAfter(0, internal.crons.vacuumTable, {
+          tableName,
+          before,
+          cursor: null,
+          soFar: 0,
+        });
+      }
+    }
+  },
+});
+
+export const vacuumTable = internalMutation({
+  args: {
+    tableName: v.string(),
+    before: v.number(),
+    cursor: v.union(v.string(), v.null()),
+    soFar: v.number(),
+  },
+  handler: async (ctx, { tableName, before, cursor, soFar }) => {
+    const results = await ctx.db
+      .query(tableName as TableNames)
+      .withIndex('by_creation_time', (q) => q.lt('_creationTime', before))
+      .paginate({ cursor, numItems: DELETE_BATCH_SIZE });
+    for (const row of results.page) {
+      await ctx.db.delete(row._id);
+    }
+    if (!results.isDone) {
+      await ctx.scheduler.runAfter(0, internal.crons.vacuumTable, {
+        tableName,
+        before,
+        soFar: results.page.length + soFar,
+        cursor: results.continueCursor,
+      });
+    } else {
+      console.log(`Vacuumed ${soFar + results.page.length} entries from ${tableName}`);
+    }
+  },
+});

package/convex/engine/abstractGame.ts

@@ -0,0 +1,199 @@
+import { ConvexError, Infer, Value, v } from 'convex/values';
+import { Doc, Id } from '../_generated/dataModel';
+import { ActionCtx, DatabaseReader, MutationCtx, internalQuery } from '../_generated/server';
+import { engine } from '../engine/schema';
+import { internal } from '../_generated/api';
+
+export abstract class AbstractGame {
+  abstract tickDuration: number;
+  abstract stepDuration: number;
+  abstract maxTicksPerStep: number;
+  abstract maxInputsPerStep: number;
+
+  constructor(public engine: Doc<'engines'>) {}
+
+  abstract handleInput(now: number, name: string, args: object): Value;
+  abstract tick(now: number): void;
+
+  // Optional callback at the beginning of each step.
+  beginStep(now: number) {}
+  abstract saveStep(ctx: ActionCtx, engineUpdate: EngineUpdate): Promise<void>;
+
+  async runStep(ctx: ActionCtx, now: number) {
+    const inputs = await ctx.runQuery(internal.engine.abstractGame.loadInputs, {
+      engineId: this.engine._id,
+      processedInputNumber: this.engine.processedInputNumber,
+      max: this.maxInputsPerStep,
+    });
+
+    const lastStepTs = this.engine.currentTime;
+    const startTs = lastStepTs ? lastStepTs + this.tickDuration : now;
+    let currentTs = startTs;
+    let inputIndex = 0;
+    let numTicks = 0;
+    let processedInputNumber = this.engine.processedInputNumber;
+    const completedInputs = [];
+
+    this.beginStep(currentTs);
+
+    while (numTicks < this.maxTicksPerStep) {
+      numTicks += 1;
+
+      // Collect all of the inputs for this tick.
+      const tickInputs = [];
+      while (inputIndex < inputs.length) {
+        const input = inputs[inputIndex];
+        if (input.received > currentTs) {
+          break;
+        }
+        inputIndex += 1;
+        processedInputNumber = input.number;
+        tickInputs.push(input);
+      }
+
+      // Feed the inputs to the game.
+      for (const input of tickInputs) {
+        let returnValue;
+        try {
+          const value = this.handleInput(currentTs, input.name, input.args);
+          returnValue = { kind: 'ok' as const, value };
+        } catch (e: any) {
+          console.error(`Input ${input._id} failed: ${e.message}`);
+          returnValue = { kind: 'error' as const, message: e.message };
+        }
+        completedInputs.push({ inputId: input._id, returnValue });
+      }
+
+      // Simulate the game forward one tick.
+      this.tick(currentTs);
+
+      const candidateTs = currentTs + this.tickDuration;
+      if (now < candidateTs) {
+        break;
+      }
+      currentTs = candidateTs;
+    }
+
+    // Commit the step by moving time forward, consuming our inputs, and saving the game's state.
+    const expectedGenerationNumber = this.engine.generationNumber;
+    this.engine.currentTime = currentTs;
+    this.engine.lastStepTs = lastStepTs;
+    this.engine.generationNumber += 1;
+    this.engine.processedInputNumber = processedInputNumber;
+    const { _id, _creationTime, ...engine } = this.engine;
+    const engineUpdate = { engine, completedInputs, expectedGenerationNumber };
+    await this.saveStep(ctx, engineUpdate);
+
+    console.debug(`Simulated from ${startTs} to ${currentTs} (${currentTs - startTs}ms)`);
+  }
+}
+
+const completedInput = v.object({
+  inputId: v.id('inputs'),
+  returnValue: v.union(
+    v.object({
+      kind: v.literal('ok'),
+      value: v.any(),
+    }),
+    v.object({
+      kind: v.literal('error'),
+      message: v.string(),
+    }),
+  ),
+});
+
+export const engineUpdate = v.object({
+  engine,
+  expectedGenerationNumber: v.number(),
+  completedInputs: v.array(completedInput),
+});
+export type EngineUpdate = Infer<typeof engineUpdate>;
+
+export async function loadEngine(
+  db: DatabaseReader,
+  engineId: Id<'engines'>,
+  generationNumber: number,
+) {
+  const engine = await db.get(engineId);
+  if (!engine) {
+    throw new Error(`No engine found with id ${engineId}`);
+  }
+  if (!engine.running) {
+    throw new ConvexError({
+      kind: 'engineNotRunning',
+      message: `Engine ${engineId} is not running`,
+    });
+  }
+  if (engine.generationNumber !== generationNumber) {
+    throw new ConvexError({ kind: 'generationNumber', message: 'Generation number mismatch' });
+  }
+  return engine;
+}
+
+export async function engineInsertInput(
+  ctx: MutationCtx,
+  engineId: Id<'engines'>,
+  name: string,
+  args: any,
+): Promise<Id<'inputs'>> {
+  const now = Date.now();
+  const prevInput = await ctx.db
+    .query('inputs')
+    .withIndex('byInputNumber', (q) => q.eq('engineId', engineId))
+    .order('desc')
+    .first();
+  const number = prevInput ? prevInput.number + 1 : 0;
+  const inputId = await ctx.db.insert('inputs', {
+    engineId,
+    number,
+    name,
+    args,
+    received: now,
+  });
+  return inputId;
+}
+
+export const loadInputs = internalQuery({
+  args: {
+    engineId: v.id('engines'),
+    processedInputNumber: v.optional(v.number()),
+    max: v.number(),
+  },
+  handler: async (ctx, args) => {
+    return await ctx.db
+      .query('inputs')
+      .withIndex('byInputNumber', (q) =>
+        q.eq('engineId', args.engineId).gt('number', args.processedInputNumber ?? -1),
+      )
+      .order('asc')
+      .take(args.max);
+  },
+});
+
+export async function applyEngineUpdate(
+  ctx: MutationCtx,
+  engineId: Id<'engines'>,
+  update: EngineUpdate,
+) {
+  const engine = await loadEngine(ctx.db, engineId, update.expectedGenerationNumber);
+  if (
+    engine.currentTime &&
+    update.engine.currentTime &&
+    update.engine.currentTime < engine.currentTime
+  ) {
+    throw new Error('Time moving backwards');
+  }
+  await ctx.db.replace(engine._id, update.engine);
+
+  for (const completedInput of update.completedInputs) {
+    const input = await ctx.db.get(completedInput.inputId);
+    if (!input) {
+      throw new Error(`Input ${completedInput.inputId} not found`);
+    }
+    if (input.returnValue) {
+      throw new Error(`Input ${completedInput.inputId} already completed`);
+    }
+    input.returnValue = completedInput.returnValue;
+    await ctx.db.replace(input._id, input);
+  }
+}