Multiplayer with HF

Dockerfile

@@ -22,6 +22,7 @@ RUN git clone https://github.com/a16z-infra/ai-town.git . && \
     git checkout f005c46d1759b47bb3ade8d41952a713c4faf331 
 
 RUN npm install --include=dev @huggingface/inference
+RUN npm install --include=dev @huggingface/hub
 
 RUN curl -L -O https://github.com/get-convex/convex-backend/releases/download/precompiled-2024-05-07-13337fd/convex-local-backend-x86_64-unknown-linux-gnu.zip && \
     unzip convex-local-backend-x86_64-unknown-linux-gnu.zip 
@@ -30,9 +31,17 @@ COPY ./patches/llm.ts ./convex/util/
 COPY ./patches/vite.config.ts ./
 COPY ./patches/constants.ts ./patches/music.ts ./convex/
 COPY ./patches/characters.ts ./patches/gentle.js ./data/
+COPY ./patches/PixiGame.tsx ./src/components/PixiGame.tsx
 COPY ./patches/PixiStaticMap.tsx ./src/components/
 COPY ./patches/Button.tsx ./src/components/buttons/Button.tsx
+COPY ./patches/InteractButton.tsx ./src/components/buttons/InteractButton.tsx
+COPY ./patches/OAuthLogin.tsx ./src/components/buttons/OAuthLogin.tsx
 COPY ./patches/App.tsx ./src/App.tsx
+COPY ./patches/world.ts ./convex/world.ts
+COPY ./patches/PlayerDetails.tsx ./src/components/PlayerDetails.tsx
+
+COPY ./patches/hf.svg ./assets/hf.svg
+
 COPY ./patches/run.sh ./
 
 CMD ["./run.sh"]

README.md

@@ -9,6 +9,7 @@ pinned: false
 disable_embedding: true
 # header: mini
 short_description: AI Town on HuggingFace
+hf_oauth: true
 ---
 
 # AI Town 🏠💻💌 on Hugging Face 🤗

patches/App.tsx

@@ -16,6 +16,7 @@ import InteractButton from './components/buttons/InteractButton.tsx';
 import FreezeButton from './components/FreezeButton.tsx';
 import { MAX_HUMAN_PLAYERS } from '../convex/constants.ts';
 import PoweredByConvex from './components/PoweredByConvex.tsx';
+import OAuthLogin from './components/buttons/OAuthLogin.tsx';
 
 export default function Home() {
   const [helpModalOpen, setHelpModalOpen] = useState(false);
@@ -90,7 +91,10 @@ export default function Home() {
 
         <footer className="justify-end bottom-0 left-0 w-full flex items-center mt-4 gap-3 p-6 flex-wrap pointer-events-none">
           <div className="flex gap-4 flex-grow pointer-events-none">
-            <FreezeButton />
+                  {/*
+          Users shall not be able freeze in multiplayer
+          <FreezeButton />
+     */}
             <MusicButton />
             <Button href="https://github.com/a16z-infra/ai-town" imgUrl={starImg}>
               Star
@@ -99,6 +103,7 @@ export default function Home() {
             <Button imgUrl={helpImg} onClick={() => setHelpModalOpen(true)}>
               Help
             </Button>
+            <OAuthLogin />
           </div>
           <a href="https://a16z.com" target="_blank">
             <img className="w-8 h-8 pointer-events-auto" src={a16zImg} alt="a16z" />

patches/InteractButton.tsx

@@ -0,0 +1,88 @@
+import Button from './Button';
+import { toast } from 'react-toastify';
+import interactImg from '../../../assets/interact.svg';
+import { useConvex, useMutation, useQuery } from 'convex/react';
+import { api } from '../../../convex/_generated/api';
+// import { SignInButton } from '@clerk/clerk-react';
+import { ConvexError } from 'convex/values';
+import { Id } from '../../../convex/_generated/dataModel';
+import { useCallback } from 'react';
+import { waitForInput } from '../../hooks/sendInput';
+import { useServerGame } from '../../hooks/serverGame';
+
+export default function InteractButton() {
+  // const { isAuthenticated } = useConvexAuth();
+  const worldStatus = useQuery(api.world.defaultWorldStatus);
+  const worldId = worldStatus?.worldId;
+  const game = useServerGame(worldId);
+  const oauth = JSON.parse(localStorage.getItem('oauth'));
+  const oauthToken = oauth ? oauth.userInfo.fullname : undefined;
+  console.log(oauthToken)
+  const humanTokenIdentifier = useQuery(api.world.userStatus, worldId ? { worldId, oauthToken } : 'skip');
+  const userPlayerId =
+    game && [...game.world.players.values()].find((p) => p.human === humanTokenIdentifier)?.id;
+  const join = useMutation(api.world.joinWorld);
+  const leave = useMutation(api.world.leaveWorld);
+  const isPlaying = !!userPlayerId;
+
+  const convex = useConvex();
+  const joinInput = useCallback(
+    async (worldId: Id<'worlds'>) => {
+      let inputId;
+      try {
+        inputId = await join({ worldId, oauthToken });
+      } catch (e: any) {
+        if (e instanceof ConvexError) {
+          toast.error(e.data);
+          return;
+        }
+        throw e;
+      }
+      try {
+        await waitForInput(convex, inputId);
+      } catch (e: any) {
+        toast.error(e.message);
+      }
+    },
+    [convex, join, oauthToken],
+  );
+
+
+  const joinOrLeaveGame = () => {
+    if (
+      !worldId ||
+      // || !isAuthenticated
+      game === undefined
+    ) {
+      return;
+    }
+    if (isPlaying) {
+      console.log(`Leaving game for player ${userPlayerId}`);
+      void leave({ worldId , oauthToken});
+    } else {
+      console.log(`Joining game`);
+      void joinInput(worldId);
+    }
+  };
+  // if (!isAuthenticated || game === undefined) {
+  //   return (
+  //     <SignInButton>
+  //       <button className="button text-white shadow-solid text-2xl pointer-events-auto">
+  //         <div className="inline-block bg-clay-700">
+  //           <span>
+  //             <div className="inline-flex h-full items-center gap-4">
+  //               <img className="w-4 h-4 sm:w-[30px] sm:h-[30px]" src={interactImg} />
+  //               Interact
+  //             </div>
+  //           </span>
+  //         </div>
+  //       </button>
+  //     </SignInButton>
+  //   );
+  // }
+  return (
+    <Button imgUrl={interactImg} onClick={joinOrLeaveGame}>
+      {isPlaying ? 'Leave' : 'Interact'}
+    </Button>
+  );
+}

patches/OAuthLogin.tsx

@@ -0,0 +1,57 @@
+import { useState, useEffect } from 'react';
+import Button from './Button';
+import hf from '../../../assets/hf.svg';
+import { oauthLoginUrl, oauthHandleRedirectIfPresent } from '@huggingface/hub';
+
+const OAuthLogin = () => {
+  const [isSignedIn, setIsSignedIn] = useState(false);
+
+  useEffect(() => {
+    const checkAuthStatus = async () => {
+      let oauthResult = localStorage.getItem('oauth');
+      if (oauthResult) {
+        try {
+          oauthResult = JSON.parse(oauthResult);
+        } catch {
+          oauthResult = null;
+        }
+      }
+
+      if (!oauthResult) {
+        oauthResult = await oauthHandleRedirectIfPresent();
+        if (oauthResult) {
+          localStorage.setItem('oauth', JSON.stringify(oauthResult));
+        }
+      }
+
+      setIsSignedIn(!!oauthResult);
+    };
+
+    checkAuthStatus();
+  }, []);
+
+  const handleSignIn = async () => {
+    let clientId = import.meta.env.VITE_OAUTH_CLIENT_ID;
+    window.location.href = await oauthLoginUrl({ clientId });
+  };
+
+  const handleSignOut = () => {
+    localStorage.removeItem('oauth');
+    window.location.href = window.location.href.replace(/\?.*$/, '');
+    setIsSignedIn(false);
+  };
+
+  return (
+    <>
+      {isSignedIn ? (
+          <Button id="signout" imgUrl={hf} onClick={handleSignOut}>Sign out</Button>
+      ) : (
+        <Button id="signin" imgUrl={hf} onClick={handleSignIn}>
+          Sign in with Hugging Face
+        </Button>
+      )}
+      </>
+  );
+};
+
+export default OAuthLogin;

patches/PixiGame.tsx

@@ -0,0 +1,132 @@
+import * as PIXI from 'pixi.js';
+import { useApp } from '@pixi/react';
+import { Player, SelectElement } from './Player.tsx';
+import { useEffect, useRef, useState } from 'react';
+import { PixiStaticMap } from './PixiStaticMap.tsx';
+import PixiViewport from './PixiViewport.tsx';
+import { Viewport } from 'pixi-viewport';
+import { Id } from '../../convex/_generated/dataModel';
+import { useQuery } from 'convex/react';
+import { api } from '../../convex/_generated/api.js';
+import { useSendInput } from '../hooks/sendInput.ts';
+import { toastOnError } from '../toasts.ts';
+import { DebugPath } from './DebugPath.tsx';
+import { PositionIndicator } from './PositionIndicator.tsx';
+import { SHOW_DEBUG_UI } from './Game.tsx';
+import { ServerGame } from '../hooks/serverGame.ts';
+
+export const PixiGame = (props: {
+  worldId: Id<'worlds'>;
+  engineId: Id<'engines'>;
+  game: ServerGame;
+  historicalTime: number | undefined;
+  width: number;
+  height: number;
+  setSelectedElement: SelectElement;
+}) => {
+  // PIXI setup.
+  const pixiApp = useApp();
+  const viewportRef = useRef<Viewport | undefined>();
+  const oauth = JSON.parse(localStorage.getItem('oauth'));
+  const oauthToken = oauth ? oauth.userInfo.fullname : undefined;
+  const humanTokenIdentifier = useQuery(api.world.userStatus, { worldId: props.worldId, oauthToken }) ?? null;
+  const humanPlayerId = [...props.game.world.players.values()].find(
+    (p) => p.human === humanTokenIdentifier,
+  )?.id;
+
+  const moveTo = useSendInput(props.engineId, 'moveTo');
+
+  // Interaction for clicking on the world to navigate.
+  const dragStart = useRef<{ screenX: number; screenY: number } | null>(null);
+  const onMapPointerDown = (e: any) => {
+    // https://pixijs.download/dev/docs/PIXI.FederatedPointerEvent.html
+    dragStart.current = { screenX: e.screenX, screenY: e.screenY };
+  };
+
+  const [lastDestination, setLastDestination] = useState<{
+    x: number;
+    y: number;
+    t: number;
+  } | null>(null);
+  const onMapPointerUp = async (e: any) => {
+    if (dragStart.current) {
+      const { screenX, screenY } = dragStart.current;
+      dragStart.current = null;
+      const [dx, dy] = [screenX - e.screenX, screenY - e.screenY];
+      const dist = Math.sqrt(dx * dx + dy * dy);
+      if (dist > 10) {
+        console.log(`Skipping navigation on drag event (${dist}px)`);
+        return;
+      }
+    }
+    if (!humanPlayerId) {
+      return;
+    }
+    const viewport = viewportRef.current;
+    if (!viewport) {
+      return;
+    }
+    const gameSpacePx = viewport.toWorld(e.screenX, e.screenY);
+    const tileDim = props.game.worldMap.tileDim;
+    const gameSpaceTiles = {
+      x: gameSpacePx.x / tileDim,
+      y: gameSpacePx.y / tileDim,
+    };
+    setLastDestination({ t: Date.now(), ...gameSpaceTiles });
+    const roundedTiles = {
+      x: Math.floor(gameSpaceTiles.x),
+      y: Math.floor(gameSpaceTiles.y),
+    };
+    console.log(`Moving to ${JSON.stringify(roundedTiles)}`);
+    await toastOnError(moveTo({ playerId: humanPlayerId, destination: roundedTiles }));
+  };
+  const { width, height, tileDim } = props.game.worldMap;
+  const players = [...props.game.world.players.values()];
+
+  // Zoom on the user’s avatar when it is created
+  useEffect(() => {
+    if (!viewportRef.current || humanPlayerId === undefined) return;
+
+    const humanPlayer = props.game.world.players.get(humanPlayerId)!;
+    viewportRef.current.animate({
+      position: new PIXI.Point(humanPlayer.position.x * tileDim, humanPlayer.position.y * tileDim),
+      scale: 1.5,
+    });
+  }, [humanPlayerId]);
+
+  return (
+    <PixiViewport
+      app={pixiApp}
+      screenWidth={props.width}
+      screenHeight={props.height}
+      worldWidth={width * tileDim}
+      worldHeight={height * tileDim}
+      viewportRef={viewportRef}
+    >
+      <PixiStaticMap
+        map={props.game.worldMap}
+        onpointerup={onMapPointerUp}
+        onpointerdown={onMapPointerDown}
+      />
+      {players.map(
+        (p) =>
+          // Only show the path for the human player in non-debug mode.
+          (SHOW_DEBUG_UI || p.id === humanPlayerId) && (
+            <DebugPath key={`path-${p.id}`} player={p} tileDim={tileDim} />
+          ),
+      )}
+      {lastDestination && <PositionIndicator destination={lastDestination} tileDim={tileDim} />}
+      {players.map((p) => (
+        <Player
+          key={`player-${p.id}`}
+          game={props.game}
+          player={p}
+          isViewer={p.id === humanPlayerId}
+          onClick={props.setSelectedElement}
+          historicalTime={props.historicalTime}
+        />
+      ))}
+    </PixiViewport>
+  );
+};
+export default PixiGame;

patches/PlayerDetails.tsx

@@ -0,0 +1,265 @@
+import { useQuery } from 'convex/react';
+import { api } from '../../convex/_generated/api';
+import { Id } from '../../convex/_generated/dataModel';
+import closeImg from '../../assets/close.svg';
+import { SelectElement } from './Player';
+import { Messages } from './Messages';
+import { toastOnError } from '../toasts';
+import { useSendInput } from '../hooks/sendInput';
+import { Player } from '../../convex/aiTown/player';
+import { GameId } from '../../convex/aiTown/ids';
+import { ServerGame } from '../hooks/serverGame';
+
+export default function PlayerDetails({
+  worldId,
+  engineId,
+  game,
+  playerId,
+  setSelectedElement,
+  scrollViewRef,
+}: {
+  worldId: Id<'worlds'>;
+  engineId: Id<'engines'>;
+  game: ServerGame;
+  playerId?: GameId<'players'>;
+  setSelectedElement: SelectElement;
+  scrollViewRef: React.RefObject<HTMLDivElement>;
+}) {
+  const oauth = JSON.parse(localStorage.getItem('oauth'));
+  const oauthToken = oauth ? oauth.userInfo.fullname : undefined;
+  const humanTokenIdentifier = useQuery(api.world.userStatus, { worldId, oauthToken });  
+
+  const players = [...game.world.players.values()];
+  const humanPlayer = players.find((p) => p.human === humanTokenIdentifier);
+  const humanConversation = humanPlayer ? game.world.playerConversation(humanPlayer) : undefined;
+  // Always select the other player if we're in a conversation with them.
+  if (humanPlayer && humanConversation) {
+    const otherPlayerIds = [...humanConversation.participants.keys()].filter(
+      (p) => p !== humanPlayer.id,
+    );
+    playerId = otherPlayerIds[0];
+  }
+
+  const player = playerId && game.world.players.get(playerId);
+  const playerConversation = player && game.world.playerConversation(player);
+
+  const previousConversation = useQuery(
+    api.world.previousConversation,
+    playerId ? { worldId, playerId } : 'skip',
+  );
+
+  const playerDescription = playerId && game.playerDescriptions.get(playerId);
+
+  const startConversation = useSendInput(engineId, 'startConversation');
+  const acceptInvite = useSendInput(engineId, 'acceptInvite');
+  const rejectInvite = useSendInput(engineId, 'rejectInvite');
+  const leaveConversation = useSendInput(engineId, 'leaveConversation');
+
+  if (!playerId) {
+    return (
+      <div className="h-full text-xl flex text-center items-center p-4">
+        Click on an agent on the map to see chat history.
+      </div>
+    );
+  }
+  if (!player) {
+    return null;
+  }
+  const isMe = humanPlayer && player.id === humanPlayer.id;
+  const canInvite = !isMe && !playerConversation && humanPlayer && !humanConversation;
+  const sameConversation =
+    !isMe &&
+    humanPlayer &&
+    humanConversation &&
+    playerConversation &&
+    humanConversation.id === playerConversation.id;
+
+  const humanStatus =
+    humanPlayer && humanConversation && humanConversation.participants.get(humanPlayer.id)?.status;
+  const playerStatus = playerConversation && playerConversation.participants.get(playerId)?.status;
+
+  const haveInvite = sameConversation && humanStatus?.kind === 'invited';
+  const waitingForAccept =
+    sameConversation && playerConversation.participants.get(playerId)?.status.kind === 'invited';
+  const waitingForNearby =
+    sameConversation && playerStatus?.kind === 'walkingOver' && humanStatus?.kind === 'walkingOver';
+
+  const inConversationWithMe =
+    sameConversation &&
+    playerStatus?.kind === 'participating' &&
+    humanStatus?.kind === 'participating';
+
+  const onStartConversation = async () => {
+    if (!humanPlayer || !playerId) {
+      return;
+    }
+    console.log(`Starting conversation`);
+    await toastOnError(startConversation({ playerId: humanPlayer.id, invitee: playerId }));
+  };
+  const onAcceptInvite = async () => {
+    if (!humanPlayer || !humanConversation || !playerId) {
+      return;
+    }
+    await toastOnError(
+      acceptInvite({
+        playerId: humanPlayer.id,
+        conversationId: humanConversation.id,
+      }),
+    );
+  };
+  const onRejectInvite = async () => {
+    if (!humanPlayer || !humanConversation) {
+      return;
+    }
+    await toastOnError(
+      rejectInvite({
+        playerId: humanPlayer.id,
+        conversationId: humanConversation.id,
+      }),
+    );
+  };
+  const onLeaveConversation = async () => {
+    if (!humanPlayer || !inConversationWithMe || !humanConversation) {
+      return;
+    }
+    await toastOnError(
+      leaveConversation({
+        playerId: humanPlayer.id,
+        conversationId: humanConversation.id,
+      }),
+    );
+  };
+  // const pendingSuffix = (inputName: string) =>
+  //   [...inflightInputs.values()].find((i) => i.name === inputName) ? ' opacity-50' : '';
+
+  const pendingSuffix = (s: string) => '';
+  return (
+    <>
+      <div className="flex gap-4">
+        <div className="box w-3/4 sm:w-full mr-auto">
+          <h2 className="bg-brown-700 p-2 font-display text-2xl sm:text-4xl tracking-wider shadow-solid text-center">
+            {playerDescription?.name}
+          </h2>
+        </div>
+        <a
+          className="button text-white shadow-solid text-2xl cursor-pointer pointer-events-auto"
+          onClick={() => setSelectedElement(undefined)}
+        >
+          <h2 className="h-full bg-clay-700">
+            <img className="w-4 h-4 sm:w-5 sm:h-5" src={closeImg} />
+          </h2>
+        </a>
+      </div>
+      {canInvite && (
+        <a
+          className={
+            'mt-6 button text-white shadow-solid text-xl cursor-pointer pointer-events-auto' +
+            pendingSuffix('startConversation')
+          }
+          onClick={onStartConversation}
+        >
+          <div className="h-full bg-clay-700 text-center">
+            <span>Start conversation</span>
+          </div>
+        </a>
+      )}
+      {waitingForAccept && (
+        <a className="mt-6 button text-white shadow-solid text-xl cursor-pointer pointer-events-auto opacity-50">
+          <div className="h-full bg-clay-700 text-center">
+            <span>Waiting for accept...</span>
+          </div>
+        </a>
+      )}
+      {waitingForNearby && (
+        <a className="mt-6 button text-white shadow-solid text-xl cursor-pointer pointer-events-auto opacity-50">
+          <div className="h-full bg-clay-700 text-center">
+            <span>Walking over...</span>
+          </div>
+        </a>
+      )}
+      {inConversationWithMe && (
+        <a
+          className={
+            'mt-6 button text-white shadow-solid text-xl cursor-pointer pointer-events-auto' +
+            pendingSuffix('leaveConversation')
+          }
+          onClick={onLeaveConversation}
+        >
+          <div className="h-full bg-clay-700 text-center">
+            <span>Leave conversation</span>
+          </div>
+        </a>
+      )}
+      {haveInvite && (
+        <>
+          <a
+            className={
+              'mt-6 button text-white shadow-solid text-xl cursor-pointer pointer-events-auto' +
+              pendingSuffix('acceptInvite')
+            }
+            onClick={onAcceptInvite}
+          >
+            <div className="h-full bg-clay-700 text-center">
+              <span>Accept</span>
+            </div>
+          </a>
+          <a
+            className={
+              'mt-6 button text-white shadow-solid text-xl cursor-pointer pointer-events-auto' +
+              pendingSuffix('rejectInvite')
+            }
+            onClick={onRejectInvite}
+          >
+            <div className="h-full bg-clay-700 text-center">
+              <span>Reject</span>
+            </div>
+          </a>
+        </>
+      )}
+      {!playerConversation && player.activity && player.activity.until > Date.now() && (
+        <div className="box flex-grow mt-6">
+          <h2 className="bg-brown-700 text-base sm:text-lg text-center">
+            {player.activity.description}
+          </h2>
+        </div>
+      )}
+      <div className="desc my-6">
+        <p className="leading-tight -m-4 bg-brown-700 text-base sm:text-sm">
+          {!isMe && playerDescription?.description}
+          {isMe && <i>This is you!</i>}
+          {!isMe && inConversationWithMe && (
+            <>
+              <br />
+              <br />(<i>Conversing with you!</i>)
+            </>
+          )}
+        </p>
+      </div>
+      {!isMe && playerConversation && playerStatus?.kind === 'participating' && (
+        <Messages
+          worldId={worldId}
+          engineId={engineId}
+          inConversationWithMe={inConversationWithMe ?? false}
+          conversation={{ kind: 'active', doc: playerConversation }}
+          humanPlayer={humanPlayer}
+          scrollViewRef={scrollViewRef}
+        />
+      )}
+      {!playerConversation && previousConversation && (
+        <>
+          <div className="box flex-grow">
+            <h2 className="bg-brown-700 text-lg text-center">Previous conversation</h2>
+          </div>
+          <Messages
+            worldId={worldId}
+            engineId={engineId}
+            inConversationWithMe={false}
+            conversation={{ kind: 'archived', doc: previousConversation }}
+            humanPlayer={humanPlayer}
+            scrollViewRef={scrollViewRef}
+          />
+        </>
+      )}
+    </>
+  );
+}

patches/run.sh

@@ -17,5 +17,11 @@ else
     export VITE_CONVEX_URL=https://$SPACE_HOST/backend.convex.cloud
 fi
 
+export VITE_OAUTH_CLIENT_ID=$OAUTH_CLIENT_ID
+# Unsure if the following are necessary
+# export OAUTH_CLIENT_SECRET=$OAUTH_CLIENT_SECRET
+# export OAUTH_SCOPES=$OAUTH_SCOPES
+# export OPENID_PROVIDER_URL=$OPENID_PROVIDER_URL
+
 npm run dev:frontend -- --host 0.0.0.0 &
 run_convex_command dev

patches/world.ts

@@ -0,0 +1,273 @@
+import { ConvexError, v } from 'convex/values';
+import { internalMutation, mutation, query } from './_generated/server';
+import { characters } from '../data/characters';
+import { Descriptions } from '../data/characters';
+import { insertInput } from './aiTown/insertInput';
+import {
+  DEFAULT_NAME,
+  ENGINE_ACTION_DURATION,
+  IDLE_WORLD_TIMEOUT,
+  WORLD_HEARTBEAT_INTERVAL,
+} from './constants';
+import { playerId } from './aiTown/ids';
+import { kickEngine, startEngine, stopEngine } from './aiTown/main';
+import { engineInsertInput } from './engine/abstractGame';
+
+export const defaultWorldStatus = query({
+  handler: async (ctx) => {
+    const worldStatus = await ctx.db
+      .query('worldStatus')
+      .filter((q) => q.eq(q.field('isDefault'), true))
+      .first();
+    return worldStatus;
+  },
+});
+
+export const heartbeatWorld = mutation({
+  args: {
+    worldId: v.id('worlds'),
+  },
+  handler: async (ctx, args) => {
+    const worldStatus = await ctx.db
+      .query('worldStatus')
+      .withIndex('worldId', (q) => q.eq('worldId', args.worldId))
+      .first();
+    if (!worldStatus) {
+      throw new Error(`Invalid world ID: ${args.worldId}`);
+    }
+    const now = Date.now();
+
+    // Skip the update (and then potentially make the transaction readonly)
+    // if it's been viewed sufficiently recently..
+    if (!worldStatus.lastViewed || worldStatus.lastViewed < now - WORLD_HEARTBEAT_INTERVAL / 2) {
+      await ctx.db.patch(worldStatus._id, {
+        lastViewed: Math.max(worldStatus.lastViewed ?? now, now),
+      });
+    }
+
+    // Restart inactive worlds, but leave worlds explicitly stopped by the developer alone.
+    if (worldStatus.status === 'stoppedByDeveloper') {
+      console.debug(`World ${worldStatus._id} is stopped by developer, not restarting.`);
+    }
+    if (worldStatus.status === 'inactive') {
+      console.log(`Restarting inactive world ${worldStatus._id}...`);
+      await ctx.db.patch(worldStatus._id, { status: 'running' });
+      await startEngine(ctx, worldStatus.worldId);
+    }
+  },
+});
+
+export const stopInactiveWorlds = internalMutation({
+  handler: async (ctx) => {
+    const cutoff = Date.now() - IDLE_WORLD_TIMEOUT;
+    const worlds = await ctx.db.query('worldStatus').collect();
+    for (const worldStatus of worlds) {
+      if (cutoff < worldStatus.lastViewed || worldStatus.status !== 'running') {
+        continue;
+      }
+      console.log(`Stopping inactive world ${worldStatus._id}`);
+      await ctx.db.patch(worldStatus._id, { status: 'inactive' });
+      await stopEngine(ctx, worldStatus.worldId);
+    }
+  },
+});
+
+export const restartDeadWorlds = internalMutation({
+  handler: async (ctx) => {
+    const now = Date.now();
+
+    // Restart an engine if it hasn't run for 2x its action duration.
+    const engineTimeout = now - ENGINE_ACTION_DURATION * 2;
+    const worlds = await ctx.db.query('worldStatus').collect();
+    for (const worldStatus of worlds) {
+      if (worldStatus.status !== 'running') {
+        continue;
+      }
+      const engine = await ctx.db.get(worldStatus.engineId);
+      if (!engine) {
+        throw new Error(`Invalid engine ID: ${worldStatus.engineId}`);
+      }
+      if (engine.currentTime && engine.currentTime < engineTimeout) {
+        console.warn(`Restarting dead engine ${engine._id}...`);
+        await kickEngine(ctx, worldStatus.worldId);
+      }
+    }
+  },
+});
+
+export const userStatus = query({
+  args: {
+    worldId: v.id('worlds'),
+    oauthToken: v.optional(v.string()),
+
+  },
+  handler: async (ctx, args) => {
+    const { worldId, oauthToken } = args;
+    
+    if (!oauthToken) {
+     return null;
+    }
+    console.log("oauthToken", oauthToken)
+    return oauthToken;
+  },
+});
+
+export const joinWorld = mutation({
+  args: {
+    worldId: v.id('worlds'),
+    oauthToken: v.optional(v.string()),
+
+  },
+  handler: async (ctx, args) => {
+    const { worldId, oauthToken } = args;
+    
+    if (!oauthToken) {
+      throw new ConvexError(`Not logged in`);
+    }
+    // if (!identity) {
+    //   throw new ConvexError(`Not logged in`);
+    // }
+    // const name =
+    //   identity.givenName || identity.nickname || (identity.email && identity.email.split('@')[0]);
+    const name = oauthToken;
+
+    // if (!name) {
+    //   throw new ConvexError(`Missing name on ${JSON.stringify(identity)}`);
+    // }
+    const world = await ctx.db.get(args.worldId);
+    if (!world) {
+      throw new ConvexError(`Invalid world ID: ${args.worldId}`);
+    }
+    // Select a random character description
+      const randomCharacter = Descriptions[Math.floor(Math.random() * Descriptions.length)];
+
+      return await insertInput(ctx, world._id, 'join', {
+        name: oauthToken,
+        character: randomCharacter.character,
+        description: "This is you !",
+        tokenIdentifier: oauthToken,
+      });
+    },
+  });
+
+
+export const leaveWorld = mutation({
+  args: {
+    worldId: v.id('worlds'),
+    oauthToken: v.optional(v.string()),
+  },
+  handler: async (ctx, args) => {
+    const { worldId, oauthToken } = args;
+    
+    
+    console.log('OAuth Name:', oauthToken);
+    if (!oauthToken) {
+      throw new ConvexError(`Not logged in`);
+    }
+
+    const world = await ctx.db.get(args.worldId);
+    if (!world) {
+      throw new Error(`Invalid world ID: ${args.worldId}`);
+    }
+    // const existingPlayer = world.players.find((p) => p.human === tokenIdentifier);
+    const existingPlayer = world.players.find((p) => p.human === oauthToken);
+    if (!existingPlayer) {
+      return;
+    }
+    await insertInput(ctx, world._id, 'leave', {
+      playerId: existingPlayer.id,
+    });
+  },
+});
+
+export const sendWorldInput = mutation({
+  args: {
+    engineId: v.id('engines'),
+    name: v.string(),
+    args: v.any(),
+  },
+  handler: async (ctx, args) => {
+    // const identity = await ctx.auth.getUserIdentity();
+    // if (!identity) {
+    //   throw new Error(`Not logged in`);
+    // }
+    return await engineInsertInput(ctx, args.engineId, args.name as any, args.args);
+  },
+});
+
+export const worldState = query({
+  args: {
+    worldId: v.id('worlds'),
+  },
+  handler: async (ctx, args) => {
+    const world = await ctx.db.get(args.worldId);
+    if (!world) {
+      throw new Error(`Invalid world ID: ${args.worldId}`);
+    }
+    const worldStatus = await ctx.db
+      .query('worldStatus')
+      .withIndex('worldId', (q) => q.eq('worldId', world._id))
+      .unique();
+    if (!worldStatus) {
+      throw new Error(`Invalid world status ID: ${world._id}`);
+    }
+    const engine = await ctx.db.get(worldStatus.engineId);
+    if (!engine) {
+      throw new Error(`Invalid engine ID: ${worldStatus.engineId}`);
+    }
+    return { world, engine };
+  },
+});
+
+export const gameDescriptions = query({
+  args: {
+    worldId: v.id('worlds'),
+  },
+  handler: async (ctx, args) => {
+    const playerDescriptions = await ctx.db
+      .query('playerDescriptions')
+      .withIndex('worldId', (q) => q.eq('worldId', args.worldId))
+      .collect();
+    const agentDescriptions = await ctx.db
+      .query('agentDescriptions')
+      .withIndex('worldId', (q) => q.eq('worldId', args.worldId))
+      .collect();
+    const worldMap = await ctx.db
+      .query('maps')
+      .withIndex('worldId', (q) => q.eq('worldId', args.worldId))
+      .first();
+    if (!worldMap) {
+      throw new Error(`No map for world: ${args.worldId}`);
+    }
+    return { worldMap, playerDescriptions, agentDescriptions };
+  },
+});
+
+export const previousConversation = query({
+  args: {
+    worldId: v.id('worlds'),
+    playerId,
+  },
+  handler: async (ctx, args) => {
+    // Walk the player's history in descending order, looking for a nonempty
+    // conversation.
+    const members = ctx.db
+      .query('participatedTogether')
+      .withIndex('playerHistory', (q) => q.eq('worldId', args.worldId).eq('player1', args.playerId))
+      .order('desc');
+
+    for await (const member of members) {
+      const conversation = await ctx.db
+        .query('archivedConversations')
+        .withIndex('worldId', (q) => q.eq('worldId', args.worldId).eq('id', member.conversationId))
+        .unique();
+      if (!conversation) {
+        throw new Error(`Invalid conversation ID: ${member.conversationId}`);
+      }
+      if (conversation.numMessages > 0) {
+        return conversation;
+      }
+    }
+    return null;
+  },
+});