Added more notes / todos

TODO.md

@@ -0,0 +1,2 @@
+# TODO
+- Add turn / round based systems

src/gameUtils/__init__.py

@@ -5,3 +5,5 @@ from .anim import AnimatedObject
 from .events import AnimStart
 from .events import AnimFinish
 from .events import Timeout
+from .turns import BaseTurnHandler
+from .turns import RoundTable

src/gameUtils/base.py

@@ -1,5 +1,6 @@
 from .events import Timeout
 from .anim import AnimatedObject
+import NoPELib
 import tomllib
 import time
 
@@ -12,15 +13,15 @@ class Game:
             surface (pygame.Surface): The surface the game devs draw on.
         """
 
-        self.surf = surface
-        self.size = self.surf.size
-        self.pm = None
-        # Holds all the timeouts that haven't been fired yet
-        self._timeouts = []
-
         with open('./game.toml', 'r') as f:
             self.cfg = tomllib.loads(f.read())
 
+        self.surf = surface
+        self.size = self.surf.size
+        self.pm = NoPELib.PlayersManager(self.cfg['name'], playersPath='../players.json')
+        # Holds all the timeouts that haven't been fired yet
+        self._timeouts = []
+
     def update(self):
         """
         Updates some core things in the background.
@@ -60,3 +61,21 @@ class Game:
         """
         
         self._timeouts.append(Timeout(id, time.perf_counter()+delay))
+    
+    def awaitingTimeout(self, id: str):
+        """
+        Tells you if a timeout ID is on the timeout stack.
+
+        Args:
+            id (str): The timeout ID.
+        
+        Returns:
+            bool: True if there is a timeout with that ID
+                  ID on the stack, False otherwise.
+        """
+
+        return any([timeout.timeoutID == id for timeout in self._timeouts])
+    
+    # TODO: Add popup method
+
+    # TODO: add punish(player, intensity)

src/gameUtils/turns.py

@@ -0,0 +1,69 @@
+# TODO: Add a variable for the game developers to see if pain is "avaialbe",
+#       I.E. has the shocker been passed to the next player.
+#       Also add a pop-up, probably using pygame-gui, to tell the player
+#       to pass the shocker to the next person.
+# NOTE: Each expansion is assigned multiple players, if an expansion has a tag
+#       such as "ONE_PERSON_ONLY", it means that when the game developer wants
+#       to go to the next player, it must self.notify() the players to pass the
+#       physical object around.
+# NOTE: That tag IS NOT a part of NoPE-Lib or PDO-Lib. It simply acts as an
+#       identifier for games to use.
+# TODO: Add player config editor.
+
+class BaseTurnHandler:
+    def __init__(self, playersManager):
+        """
+        The base turn handler metaclass, used to create round
+        handlers such as round table.
+        """
+        self._pm = playersManager
+        # The current turn number (0 based)
+        self.turn = 0
+        # The maximum number of turns
+        self.turns = len(self._pm)
+        # The current round number (0 based)
+        self.round = 0
+        # Which players are playing in this turn
+        self.playing = []
+    
+    def next(self):
+        raise NotImplementedError
+
+class RoundTable(BaseTurnHandler):
+    """
+    A simple "round table" round system.
+    """
+    # TODO: Add some kind of implementation with NoPE
+    # to determain if we actually need to re-assign PDOs.
+    def __init__(self, teamSize: int, *args, **kwargs):
+        """
+        
+        """
+        super().__init__(*args, **kwargs)
+
+        if teamSize > len(self._pm):
+            raise Exception('Too little players for specified team size.') # TODO: Custom exception
+
+        self.teamSize = teamSize
+        self.turns //= self.teamSize
+
+        self.turn -= 1
+        self.next()
+    
+    def next(self):
+        """
+        Oh god I hate it.
+        """
+
+        self.turn += 1
+        if self.turn >= self.turns:
+            self.turn -= self.turns
+            self.round += 1
+
+        self.playing = []
+        playerNames = list(self._pm.keys())
+
+        for i in range(self.teamSize):
+            self.playing.append(self._pm[playerNames[(i+self.turn)%len(playerNames)]])
+
+        return self.playing