solanapolis 1.0.0

package/convex/aiTown/agentOperations.ts

@@ -0,0 +1,178 @@
+import { v } from 'convex/values';
+import { internalAction } from '../_generated/server';
+import { WorldMap, serializedWorldMap } from './worldMap';
+import { rememberConversation } from '../agent/memory';
+import { GameId, agentId, conversationId, playerId } from './ids';
+import {
+  continueConversationMessage,
+  leaveConversationMessage,
+  startConversationMessage,
+} from '../agent/conversation';
+import { assertNever } from '../util/assertNever';
+import { serializedAgent } from './agent';
+import { ACTIVITIES, ACTIVITY_COOLDOWN, CONVERSATION_COOLDOWN } from '../constants';
+import { api, internal } from '../_generated/api';
+import { sleep } from '../util/sleep';
+import { serializedPlayer } from './player';
+
+export const agentRememberConversation = internalAction({
+  args: {
+    worldId: v.id('worlds'),
+    playerId,
+    agentId,
+    conversationId,
+    operationId: v.string(),
+  },
+  handler: async (ctx, args) => {
+    await rememberConversation(
+      ctx,
+      args.worldId,
+      args.agentId as GameId<'agents'>,
+      args.playerId as GameId<'players'>,
+      args.conversationId as GameId<'conversations'>,
+    );
+    await sleep(Math.random() * 1000);
+    await ctx.runMutation(api.aiTown.main.sendInput, {
+      worldId: args.worldId,
+      name: 'finishRememberConversation',
+      args: {
+        agentId: args.agentId,
+        operationId: args.operationId,
+      },
+    });
+  },
+});
+
+export const agentGenerateMessage = internalAction({
+  args: {
+    worldId: v.id('worlds'),
+    playerId,
+    agentId,
+    conversationId,
+    otherPlayerId: playerId,
+    operationId: v.string(),
+    type: v.union(v.literal('start'), v.literal('continue'), v.literal('leave')),
+    messageUuid: v.string(),
+  },
+  handler: async (ctx, args) => {
+    let completionFn;
+    switch (args.type) {
+      case 'start':
+        completionFn = startConversationMessage;
+        break;
+      case 'continue':
+        completionFn = continueConversationMessage;
+        break;
+      case 'leave':
+        completionFn = leaveConversationMessage;
+        break;
+      default:
+        assertNever(args.type);
+    }
+    const text = await completionFn(
+      ctx,
+      args.worldId,
+      args.conversationId as GameId<'conversations'>,
+      args.playerId as GameId<'players'>,
+      args.otherPlayerId as GameId<'players'>,
+    );
+
+    await ctx.runMutation(internal.aiTown.agent.agentSendMessage, {
+      worldId: args.worldId,
+      conversationId: args.conversationId,
+      agentId: args.agentId,
+      playerId: args.playerId,
+      text,
+      messageUuid: args.messageUuid,
+      leaveConversation: args.type === 'leave',
+      operationId: args.operationId,
+    });
+  },
+});
+
+export const agentDoSomething = internalAction({
+  args: {
+    worldId: v.id('worlds'),
+    player: v.object(serializedPlayer),
+    agent: v.object(serializedAgent),
+    map: v.object(serializedWorldMap),
+    otherFreePlayers: v.array(v.object(serializedPlayer)),
+    operationId: v.string(),
+  },
+  handler: async (ctx, args) => {
+    const { player, agent } = args;
+    const map = new WorldMap(args.map);
+    const now = Date.now();
+    // Don't try to start a new conversation if we were just in one.
+    const justLeftConversation =
+      agent.lastConversation && now < agent.lastConversation + CONVERSATION_COOLDOWN;
+    // Don't try again if we recently tried to find someone to invite.
+    const recentlyAttemptedInvite =
+      agent.lastInviteAttempt && now < agent.lastInviteAttempt + CONVERSATION_COOLDOWN;
+    const recentActivity = player.activity && now < player.activity.until + ACTIVITY_COOLDOWN;
+    // Decide whether to do an activity or wander somewhere.
+    if (!player.pathfinding) {
+      if (recentActivity || justLeftConversation) {
+        await sleep(Math.random() * 1000);
+        await ctx.runMutation(api.aiTown.main.sendInput, {
+          worldId: args.worldId,
+          name: 'finishDoSomething',
+          args: {
+            operationId: args.operationId,
+            agentId: agent.id,
+            destination: wanderDestination(map),
+          },
+        });
+        return;
+      } else {
+        // TODO: have LLM choose the activity & emoji
+        const activity = ACTIVITIES[Math.floor(Math.random() * ACTIVITIES.length)];
+        await sleep(Math.random() * 1000);
+        await ctx.runMutation(api.aiTown.main.sendInput, {
+          worldId: args.worldId,
+          name: 'finishDoSomething',
+          args: {
+            operationId: args.operationId,
+            agentId: agent.id,
+            activity: {
+              description: activity.description,
+              emoji: activity.emoji,
+              until: Date.now() + activity.duration,
+            },
+          },
+        });
+        return;
+      }
+    }
+    const invitee =
+      justLeftConversation || recentlyAttemptedInvite
+        ? undefined
+        : await ctx.runQuery(internal.aiTown.agent.findConversationCandidate, {
+            now,
+            worldId: args.worldId,
+            player: args.player,
+            otherFreePlayers: args.otherFreePlayers,
+          });
+
+    // TODO: We hit a lot of OCC errors on sending inputs in this file. It's
+    // easy for them to get scheduled at the same time and line up in time.
+    await sleep(Math.random() * 1000);
+    await ctx.runMutation(api.aiTown.main.sendInput, {
+      worldId: args.worldId,
+      name: 'finishDoSomething',
+      args: {
+        operationId: args.operationId,
+        agentId: args.agent.id,
+        invitee,
+      },
+    });
+  },
+});
+
+function wanderDestination(worldMap: WorldMap) {
+  // Wander someonewhere at least one tile away from the edge.
+  return {
+    x: 1 + Math.floor(Math.random() * (worldMap.width - 2)),
+    y: 1 + Math.floor(Math.random() * (worldMap.height - 2)),
+  };
+}

package/convex/aiTown/conversation.ts

@@ -0,0 +1,395 @@
+import { ObjectType, v } from 'convex/values';
+import { GameId, parseGameId } from './ids';
+import { conversationId, playerId } from './ids';
+import { Player } from './player';
+import { inputHandler } from './inputHandler';
+
+import { TYPING_TIMEOUT, CONVERSATION_DISTANCE } from '../constants';
+import { distance, normalize, vector } from '../util/geometry';
+import { Point } from '../util/types';
+import { Game } from './game';
+import { stopPlayer, blocked, movePlayer } from './movement';
+import { ConversationMembership, serializedConversationMembership } from './conversationMembership';
+import { parseMap, serializeMap } from '../util/object';
+
+export class Conversation {
+  id: GameId<'conversations'>;
+  creator: GameId<'players'>;
+  created: number;
+  isTyping?: {
+    playerId: GameId<'players'>;
+    messageUuid: string;
+    since: number;
+  };
+  lastMessage?: {
+    author: GameId<'players'>;
+    timestamp: number;
+  };
+  numMessages: number;
+  participants: Map<GameId<'players'>, ConversationMembership>;
+
+  constructor(serialized: SerializedConversation) {
+    const { id, creator, created, isTyping, lastMessage, numMessages, participants } = serialized;
+    this.id = parseGameId('conversations', id);
+    this.creator = parseGameId('players', creator);
+    this.created = created;
+    this.isTyping = isTyping && {
+      playerId: parseGameId('players', isTyping.playerId),
+      messageUuid: isTyping.messageUuid,
+      since: isTyping.since,
+    };
+    this.lastMessage = lastMessage && {
+      author: parseGameId('players', lastMessage.author),
+      timestamp: lastMessage.timestamp,
+    };
+    this.numMessages = numMessages;
+    this.participants = parseMap(participants, ConversationMembership, (m) => m.playerId);
+  }
+
+  tick(game: Game, now: number) {
+    if (this.isTyping && this.isTyping.since + TYPING_TIMEOUT < now) {
+      delete this.isTyping;
+    }
+    if (this.participants.size !== 2) {
+      console.warn(`Conversation ${this.id} has ${this.participants.size} participants`);
+      return;
+    }
+    const [playerId1, playerId2] = [...this.participants.keys()];
+    const member1 = this.participants.get(playerId1)!;
+    const member2 = this.participants.get(playerId2)!;
+
+    const player1 = game.world.players.get(playerId1)!;
+    const player2 = game.world.players.get(playerId2)!;
+
+    const playerDistance = distance(player1?.position, player2?.position);
+
+    // If the players are both in the "walkingOver" state and they're sufficiently close, transition both
+    // of them to "participating" and stop their paths.
+    if (member1.status.kind === 'walkingOver' && member2.status.kind === 'walkingOver') {
+      if (playerDistance < CONVERSATION_DISTANCE) {
+        console.log(`Starting conversation between ${player1.id} and ${player2.id}`);
+
+        // First, stop the two players from moving.
+        stopPlayer(player1);
+        stopPlayer(player2);
+
+        member1.status = { kind: 'participating', started: now };
+        member2.status = { kind: 'participating', started: now };
+
+        // Try to move the first player to grid point nearest the other player.
+        const neighbors = (p: Point) => [
+          { x: p.x + 1, y: p.y },
+          { x: p.x - 1, y: p.y },
+          { x: p.x, y: p.y + 1 },
+          { x: p.x, y: p.y - 1 },
+        ];
+        const floorPos1 = { x: Math.floor(player1.position.x), y: Math.floor(player1.position.y) };
+        const p1Candidates = neighbors(floorPos1).filter((p) => !blocked(game, now, p, player1.id));
+        p1Candidates.sort((a, b) => distance(a, player2.position) - distance(b, player2.position));
+        if (p1Candidates.length > 0) {
+          const p1Candidate = p1Candidates[0];
+
+          // Try to move the second player to the grid point nearest the first player's
+          // destination.
+          const p2Candidates = neighbors(p1Candidate).filter(
+            (p) => !blocked(game, now, p, player2.id),
+          );
+          p2Candidates.sort(
+            (a, b) => distance(a, player2.position) - distance(b, player2.position),
+          );
+          if (p2Candidates.length > 0) {
+            const p2Candidate = p2Candidates[0];
+            movePlayer(game, now, player1, p1Candidate, true);
+            movePlayer(game, now, player2, p2Candidate, true);
+          }
+        }
+      }
+    }
+
+    // Orient the two players towards each other if they're not moving.
+    if (member1.status.kind === 'participating' && member2.status.kind === 'participating') {
+      const v = normalize(vector(player1.position, player2.position));
+      if (!player1.pathfinding && v) {
+        player1.facing = v;
+      }
+      if (!player2.pathfinding && v) {
+        player2.facing.dx = -v.dx;
+        player2.facing.dy = -v.dy;
+      }
+    }
+  }
+
+  static start(game: Game, now: number, player: Player, invitee: Player) {
+    if (player.id === invitee.id) {
+      throw new Error(`Can't invite yourself to a conversation`);
+    }
+    // Ensure the players still exist.
+    if ([...game.world.conversations.values()].find((c) => c.participants.has(player.id))) {
+      const reason = `Player ${player.id} is already in a conversation`;
+      console.log(reason);
+      return { error: reason };
+    }
+    if ([...game.world.conversations.values()].find((c) => c.participants.has(invitee.id))) {
+      const reason = `Player ${player.id} is already in a conversation`;
+      console.log(reason);
+      return { error: reason };
+    }
+    const conversationId = game.allocId('conversations');
+    console.log(`Creating conversation ${conversationId}`);
+    game.world.conversations.set(
+      conversationId,
+      new Conversation({
+        id: conversationId,
+        created: now,
+        creator: player.id,
+        numMessages: 0,
+        participants: [
+          { playerId: player.id, invited: now, status: { kind: 'walkingOver' } },
+          { playerId: invitee.id, invited: now, status: { kind: 'invited' } },
+        ],
+      }),
+    );
+    return { conversationId };
+  }
+
+  setIsTyping(now: number, player: Player, messageUuid: string) {
+    if (this.isTyping) {
+      if (this.isTyping.playerId !== player.id) {
+        throw new Error(`Player ${this.isTyping.playerId} is already typing in ${this.id}`);
+      }
+      return;
+    }
+    this.isTyping = { playerId: player.id, messageUuid, since: now };
+  }
+
+  acceptInvite(game: Game, player: Player) {
+    const member = this.participants.get(player.id);
+    if (!member) {
+      throw new Error(`Player ${player.id} not in conversation ${this.id}`);
+    }
+    if (member.status.kind !== 'invited') {
+      throw new Error(
+        `Invalid membership status for ${player.id}:${this.id}: ${JSON.stringify(member)}`,
+      );
+    }
+    member.status = { kind: 'walkingOver' };
+  }
+
+  rejectInvite(game: Game, now: number, player: Player) {
+    const member = this.participants.get(player.id);
+    if (!member) {
+      throw new Error(`Player ${player.id} not in conversation ${this.id}`);
+    }
+    if (member.status.kind !== 'invited') {
+      throw new Error(
+        `Rejecting invite in wrong membership state: ${this.id}:${player.id}: ${JSON.stringify(
+          member,
+        )}`,
+      );
+    }
+    this.stop(game, now);
+  }
+
+  stop(game: Game, now: number) {
+    delete this.isTyping;
+    for (const [playerId, member] of this.participants.entries()) {
+      const agent = [...game.world.agents.values()].find((a) => a.playerId === playerId);
+      if (agent) {
+        agent.lastConversation = now;
+        agent.toRemember = this.id;
+      }
+    }
+    game.world.conversations.delete(this.id);
+  }
+
+  leave(game: Game, now: number, player: Player) {
+    const member = this.participants.get(player.id);
+    if (!member) {
+      throw new Error(`Couldn't find membership for ${this.id}:${player.id}`);
+    }
+    this.stop(game, now);
+  }
+
+  serialize(): SerializedConversation {
+    const { id, creator, created, isTyping, lastMessage, numMessages } = this;
+    return {
+      id,
+      creator,
+      created,
+      isTyping,
+      lastMessage,
+      numMessages,
+      participants: serializeMap(this.participants),
+    };
+  }
+}
+
+export const serializedConversation = {
+  id: conversationId,
+  creator: playerId,
+  created: v.number(),
+  isTyping: v.optional(
+    v.object({
+      playerId,
+      messageUuid: v.string(),
+      since: v.number(),
+    }),
+  ),
+  lastMessage: v.optional(
+    v.object({
+      author: playerId,
+      timestamp: v.number(),
+    }),
+  ),
+  numMessages: v.number(),
+  participants: v.array(v.object(serializedConversationMembership)),
+};
+export type SerializedConversation = ObjectType<typeof serializedConversation>;
+
+export const conversationInputs = {
+  // Start a conversation, inviting the specified player.
+  // Conversations can only have two participants for now,
+  // so we don't have a separate "invite" input.
+  startConversation: inputHandler({
+    args: {
+      playerId,
+      invitee: playerId,
+    },
+    handler: (game: Game, now: number, args): GameId<'conversations'> => {
+      const playerId = parseGameId('players', args.playerId);
+      const player = game.world.players.get(playerId);
+      if (!player) {
+        throw new Error(`Invalid player ID: ${playerId}`);
+      }
+      const inviteeId = parseGameId('players', args.invitee);
+      const invitee = game.world.players.get(inviteeId);
+      if (!invitee) {
+        throw new Error(`Invalid player ID: ${inviteeId}`);
+      }
+      console.log(`Starting ${playerId} ${inviteeId}...`);
+      const { conversationId, error } = Conversation.start(game, now, player, invitee);
+      if (!conversationId) {
+        // TODO: pass it back to the client for them to show an error.
+        throw new Error(error);
+      }
+      return conversationId;
+    },
+  }),
+
+  startTyping: inputHandler({
+    args: {
+      playerId,
+      conversationId,
+      messageUuid: v.string(),
+    },
+    handler: (game: Game, now: number, args): null => {
+      const playerId = parseGameId('players', args.playerId);
+      const player = game.world.players.get(playerId);
+      if (!player) {
+        throw new Error(`Invalid player ID: ${playerId}`);
+      }
+      const conversationId = parseGameId('conversations', args.conversationId);
+      const conversation = game.world.conversations.get(conversationId);
+      if (!conversation) {
+        throw new Error(`Invalid conversation ID: ${conversationId}`);
+      }
+      if (conversation.isTyping && conversation.isTyping.playerId !== playerId) {
+        throw new Error(
+          `Player ${conversation.isTyping.playerId} is already typing in ${conversationId}`,
+        );
+      }
+      conversation.isTyping = { playerId, messageUuid: args.messageUuid, since: now };
+      return null;
+    },
+  }),
+
+  finishSendingMessage: inputHandler({
+    args: {
+      playerId,
+      conversationId,
+      timestamp: v.number(),
+    },
+    handler: (game: Game, now: number, args): null => {
+      const playerId = parseGameId('players', args.playerId);
+      const conversationId = parseGameId('conversations', args.conversationId);
+      const conversation = game.world.conversations.get(conversationId);
+      if (!conversation) {
+        throw new Error(`Invalid conversation ID: ${conversationId}`);
+      }
+      if (conversation.isTyping && conversation.isTyping.playerId === playerId) {
+        delete conversation.isTyping;
+      }
+      conversation.lastMessage = { author: playerId, timestamp: args.timestamp };
+      conversation.numMessages++;
+      return null;
+    },
+  }),
+
+  // Accept an invite to a conversation, which puts the
+  // player in the "walkingOver" state until they're close
+  // enough to the other participant.
+  acceptInvite: inputHandler({
+    args: {
+      playerId,
+      conversationId,
+    },
+    handler: (game: Game, now: number, args): null => {
+      const playerId = parseGameId('players', args.playerId);
+      const player = game.world.players.get(playerId);
+      if (!player) {
+        throw new Error(`Invalid player ID ${playerId}`);
+      }
+      const conversationId = parseGameId('conversations', args.conversationId);
+      const conversation = game.world.conversations.get(conversationId);
+      if (!conversation) {
+        throw new Error(`Invalid conversation ID ${conversationId}`);
+      }
+      conversation.acceptInvite(game, player);
+      return null;
+    },
+  }),
+
+  // Reject the invite. Eventually we might add a message
+  // that explains why!
+  rejectInvite: inputHandler({
+    args: {
+      playerId,
+      conversationId,
+    },
+    handler: (game: Game, now: number, args): null => {
+      const playerId = parseGameId('players', args.playerId);
+      const player = game.world.players.get(playerId);
+      if (!player) {
+        throw new Error(`Invalid player ID ${playerId}`);
+      }
+      const conversationId = parseGameId('conversations', args.conversationId);
+      const conversation = game.world.conversations.get(conversationId);
+      if (!conversation) {
+        throw new Error(`Invalid conversation ID ${conversationId}`);
+      }
+      conversation.rejectInvite(game, now, player);
+      return null;
+    },
+  }),
+  // Leave a conversation.
+  leaveConversation: inputHandler({
+    args: {
+      playerId,
+      conversationId,
+    },
+    handler: (game: Game, now: number, args): null => {
+      const playerId = parseGameId('players', args.playerId);
+      const player = game.world.players.get(playerId);
+      if (!player) {
+        throw new Error(`Invalid player ID ${playerId}`);
+      }
+      const conversationId = parseGameId('conversations', args.conversationId);
+      const conversation = game.world.conversations.get(conversationId);
+      if (!conversation) {
+        throw new Error(`Invalid conversation ID ${conversationId}`);
+      }
+      conversation.leave(game, now, player);
+      return null;
+    },
+  }),
+};

package/convex/aiTown/conversationMembership.ts

@@ -0,0 +1,38 @@
+import { ObjectType, v } from 'convex/values';
+import { GameId, parseGameId, playerId } from './ids';
+
+export const serializedConversationMembership = {
+  playerId,
+  invited: v.number(),
+  status: v.union(
+    v.object({ kind: v.literal('invited') }),
+    v.object({ kind: v.literal('walkingOver') }),
+    v.object({ kind: v.literal('participating'), started: v.number() }),
+  ),
+};
+export type SerializedConversationMembership = ObjectType<typeof serializedConversationMembership>;
+
+export class ConversationMembership {
+  playerId: GameId<'players'>;
+  invited: number;
+  status:
+    | { kind: 'invited' }
+    | { kind: 'walkingOver' }
+    | { kind: 'participating'; started: number };
+
+  constructor(serialized: SerializedConversationMembership) {
+    const { playerId, invited, status } = serialized;
+    this.playerId = parseGameId('players', playerId);
+    this.invited = invited;
+    this.status = status;
+  }
+
+  serialize(): SerializedConversationMembership {
+    const { playerId, invited, status } = this;
+    return {
+      playerId,
+      invited,
+      status,
+    };
+  }
+}