Add order management and world tick functionality to DiscordInterface

- Implement order method to hold actions until the next tick
- Introduce tick method to resolve orders and update the world state
- Update main.py to initialize DiscordInterface with tick_seconds parameter
- Enhance tests to validate order behavior and tick resolution

Author: samclane

Discordia/Interface/DiscordInterface.py

@@ -1,8 +1,10 @@
 from __future__ import annotations
 
+import asyncio
 import logging
+import random
 import time
-from typing import Callable, List, Sequence, Tuple, cast
+from typing import Any, Callable, Dict, List, Sequence, Tuple, cast
 
 import discord
 from discord import app_commands
@@ -42,6 +44,10 @@
 
 NO_STORE = "There's no store here. Find a town that has one."
 
+SUPERSEDED = (
+    object()
+)  # what an order resolves to when the player replaces it before the tick
+
 
 def _character(interaction: discord.Interaction) -> Actors.PlayerCharacter:
     """The character behind an interaction. Checks only get the interaction, so dig the cog out of the command."""
@@ -106,6 +112,7 @@ def __init__(
         self,
         world_adapter: WorldAdapter,
         jobs: Sequence[Tuple[float, Callable[[], None], str]] = (),
+        tick_seconds: float = 5.0,
     ):
         """`jobs` are (seconds, action, name) triples run periodically alongside the commands."""
         self.bot: commands.Bot = commands.Bot(
@@ -115,9 +122,13 @@ def __init__(
         self.bot.setup_hook = self._setup_hook
         self.world_adapter: WorldAdapter = world_adapter
         self.jobs = jobs
+        self.tick_seconds = tick_seconds
         self._job_loops: List[tasks.Loop] = (
             []
         )  # kept alive; a Loop nobody holds gets collected
+        self._orders: Dict[
+            Actors.PlayerCharacter, Tuple[Callable[[], Any], asyncio.Future]
+        ] = {}
 
     def _start_job(self, seconds: float, action: Callable[[], None], name: str):
         """Run `action` every `seconds` on the bot's event loop: same thread as the commands, so no locking.
@@ -135,8 +146,36 @@ async def job():
         job.start()
         self._job_loops.append(job)
 
+    def order(
+        self, character: Actors.PlayerCharacter, action: Callable[[], Any]
+    ) -> asyncio.Future:
+        """Hold a world-changing action until the next tick, and hand back its eventual result.
+
+        One order per character: typing a second one before the tick replaces the first, whose command
+        gets SUPERSEDED back. Spamming a command therefore buys nothing but a change of mind.
+        """
+        _, previous = self._orders.pop(character, (None, None))
+        if previous is not None and not previous.done():
+            previous.set_result(SUPERSEDED)
+        future = asyncio.get_running_loop().create_future()
+        self._orders[character] = (action, future)
+        return future
+
+    def tick(self):
+        """Resolve everyone's orders, then let the world act. Same-tick orders resolve in random order."""
+        orders, self._orders = self._orders, {}
+        for action, future in random.sample(list(orders.values()), len(orders)):
+            if future.done():  # the command that asked for it went away
+                continue
+            try:
+                future.set_result(action())
+            except Exception as exc:
+                future.set_exception(exc)
+        self.world_adapter.world.tick()
+
     async def _setup_hook(self):
         await self.bot.add_cog(self)
+        self._start_job(self.tick_seconds, self.tick, "World tick")
         for seconds, action, name in self.jobs:
             self._start_job(seconds, action, name)
         synced = await self.bot.tree.sync()
@@ -237,12 +276,19 @@ async def look(self, interaction: discord.Interaction):
     async def move(
         self, interaction: discord.Interaction, direction: app_commands.Choice[str]
     ):
-        """Move your character one space in the given direction"""
+        """Move your character one space in the given direction, resolved on the next tick"""
         await interaction.response.defer()
         character = self._player(interaction)
-        results: List[PlayerActionResponse] = self.world_adapter.move_player(
-            character, DIRECTION_VECTORS[direction.value]
+        results = await self.order(
+            character,
+            lambda: self.world_adapter.move_player(
+                character, DIRECTION_VECTORS[direction.value]
+            ),
         )
+        if results is SUPERSEDED:
+            await interaction.followup.send("You change your mind before setting off.")
+            return
+        results = cast(List[PlayerActionResponse], results)
         msg = ""
         # If any Events happen, let the PC know step-by-step
         for r in results:
@@ -265,11 +311,19 @@ async def move(
     async def attack(
         self, interaction: discord.Interaction, direction: app_commands.Choice[str]
     ):
-        """Attack; give a direction for a ranged attack"""
+        """Attack, resolved on the next tick; give a direction for a ranged attack"""
+        await interaction.response.defer()
         character = self._player(interaction)
-        response: PlayerActionResponse = self.world_adapter.attack(
-            character, DIRECTION_VECTORS[direction.value]
+        response = await self.order(
+            character,
+            lambda: self.world_adapter.attack(
+                character, DIRECTION_VECTORS[direction.value]
+            ),
         )
+        if response is SUPERSEDED:
+            await interaction.followup.send("You hold your fire.")
+            return
+        response = cast(PlayerActionResponse, response)
         target_name = response.target.name if response.target else "nobody"
         await _send(
             interaction,

Discordia/test/test_discord_interface.py

@@ -5,8 +5,8 @@
 import pytest
 from discord import app_commands
 
-from Discordia.GameLogic import GameSpace
-from Discordia.Interface.DiscordInterface import DiscordInterface
+from Discordia.GameLogic import Actors, GameSpace
+from Discordia.Interface.DiscordInterface import SUPERSEDED, DiscordInterface
 from Discordia.Interface.WorldAdapter import (
     InvalidSpaceException,
     NotRegisteredException,
@@ -127,6 +127,72 @@ def test_space_check_passes_inside_a_town():
     assert run_checks(command, interaction)
 
 
+PLAYER = cast(Actors.PlayerCharacter, "a player")  # orders only ever key on identity
+
+
+def ticking_interface(on_world_tick=lambda: None) -> DiscordInterface:
+    """A cog whose world does nothing but record that it ticked."""
+    adapter = SimpleNamespace(world=SimpleNamespace(tick=on_world_tick))
+    return DiscordInterface(world_adapter=cast(WorldAdapter, adapter))
+
+
+def test_orders_wait_for_the_tick_instead_of_resolving_when_typed():
+    done = []
+    interface = ticking_interface()
+
+    async def scenario():
+        future = interface.order(PLAYER, lambda: done.append("moved") or "arrived")
+        assert not done, "the order ran before the tick"
+        interface.tick()
+        assert await future == "arrived"
+
+    asyncio.run(scenario())
+    assert done == ["moved"]
+
+
+def test_a_second_order_replaces_the_first_so_spamming_buys_nothing():
+    ran = []
+    interface = ticking_interface()
+
+    async def scenario():
+        first = interface.order(PLAYER, lambda: ran.append("north"))
+        second = interface.order(PLAYER, lambda: ran.append("south"))
+        interface.tick()
+        assert await first is SUPERSEDED
+        assert await second is None
+
+    asyncio.run(scenario())
+    assert ran == ["south"]
+
+
+def test_orders_resolve_before_the_world_acts():
+    sequence = []
+    interface = ticking_interface(on_world_tick=lambda: sequence.append("world"))
+
+    async def scenario():
+        future = interface.order(PLAYER, lambda: sequence.append("player"))
+        interface.tick()
+        await future
+
+    asyncio.run(scenario())
+    assert sequence == ["player", "world"]
+
+
+def test_a_rejected_order_raises_in_the_command_that_asked_for_it():
+    interface = ticking_interface()
+
+    async def scenario():
+        def blocked():
+            raise InvalidSpaceException("You can't go that way.")
+
+        future = interface.order(PLAYER, blocked)
+        interface.tick()
+        with pytest.raises(InvalidSpaceException):
+            await future
+
+    asyncio.run(scenario())
+
+
 def test_jobs_run_on_the_bots_event_loop():
     ticks = []
     interface = DiscordInterface(

main.py

@@ -39,12 +39,13 @@ def main():
     display = WindowRenderer(adapter)
 
     threading.Thread(target=update_display, args=(display, args.show_window), daemon=True).start()
-    # Both jobs run on the bot's event loop, in lockstep with the commands: no locking needed, and a
-    # crash loses at most AUTOSAVE_SECONDS of play.
-    discord_interface = DiscordInterface(adapter, jobs=[
-        (TICK_SECONDS, adapter.world.tick, "World tick"),
-        (AUTOSAVE_SECONDS, lambda: database.save(adapter), "Autosave"),
-    ])
+    # The tick and the autosave run on the bot's event loop, in lockstep with the commands: no locking
+    # needed, and a crash loses at most AUTOSAVE_SECONDS of play.
+    discord_interface = DiscordInterface(
+        adapter,
+        jobs=[(AUTOSAVE_SECONDS, lambda: database.save(adapter), "Autosave")],
+        tick_seconds=TICK_SECONDS,
+    )
     # discord_interface.bot.loop.create_task(update_display(display))
     # threading.Thread(target=discord_interface.bot.run, args=(ConfigParser.DISCORD_TOKEN,), daemon=True).start()
     LOG.info("Discordia Server has successfully started. Press Ctrl+C to quit.")