Develop

example.py

@@ -1,6 +1,9 @@
 from rps import Game, FixedActionPlayer, RandomActionPlayer
 from collections import deque
 from rps.utils import get_player_action_info
+import logging
+
+logging.basicConfig(level=logging.INFO)
 
 if __name__ == "__main__":
     game_action_size = 3  # classic rock-paper-scissors

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "rock-paper-scissors-py"
-version = "0.1.3.1"
+version = "0.1.4"
 description = "Multi-player and multi-action Rock, Paper, Scissors game client"
 readme = "README.md"
 requires-python = ">=3.12"

rps/game.py

@@ -13,15 +13,15 @@ def __init__(self, players, action_count: int) -> None:
         if action_count < 0:
             raise ValueError(f"Action count must be greater than or equal to 3")
 
-        if not players or len(players) < 2:
-            raise ValueError(f"Must have at least two players")
+        # if not players or len(players) < 2:
+        #     raise ValueError(f"Must have at least two players")
 
         self._players = players
         self._original_players = players.copy() # for resetting game
         self._action_count = action_count
         self._beats = {}
-        self.round_num = 0
-        self.game_num = 1
+        self._round_num = 1
+        self._game_num = 1
 
         # set beats/game rules created by https://www.umop.com/rps.htm
         if 3 <= action_count <= 15 and action_count % 2 != 0 and action_count != 13:
@@ -39,6 +39,26 @@ def beats(self):
     @property
     def players(self):
         return self._players
+
+    @players.setter
+    def players(self, players):
+        self._players = players
+
+    @property
+    def round_num(self):
+        return self._round_num
+
+    @round_num.setter
+    def round_num(self, round_num):
+        self._round_num = round_num
+
+    @property
+    def game_num(self):
+        return self._game_num
+
+    @game_num.setter
+    def game_num(self, game_num):
+        self._game_num = game_num
 
     def generate_beats(self):
         """generate beats dictionary for games with action size 17 or greater"""
@@ -91,7 +111,7 @@ def eliminate(self, actions: list[int]) -> list[int]:
                 if i == n:
                     result.append(p)
 
-        log.info(f"eliminated players: {[(p.name, p.action) for p in result]}")
+        log.info(f"eliminated players: {[(p.name) for p in result]}")
 
         return eliminated
 
@@ -116,15 +136,15 @@ def play_round(self):
 
     def reset(self):
         self._players = self._original_players.copy()
-        self.round_num = 0
-        self.game_num += 1
+        self._round_num = 1
+        self._game_num += 1
+        log.info("game has been reset")
 
     def play(self):
-        self.round_num += 1
         while len(self._players) > 1:
-            log.info(f"Round {round}")
+            log.info(f"Round {self._round_num}")
             self.play_round()
-            self.round_num += 1
+            self._round_num += 1
             log.info(" ")
 
         log.info(f"Winner is {self._players[0].name}")

rps/player.py

@@ -2,6 +2,10 @@
 from abc import ABC, abstractmethod
 from collections import deque
 
+import logging
+
+log = logging.getLogger(__name__)
+
 
 class Player(ABC):
     def __init__(self, name: str, action=None) -> None:
@@ -39,13 +43,16 @@ def __init__(
     def choose_action(self, action_count: int) -> int:
         if self.action_queue is not None:
             if self.action_queue:
+                log.info(f"{self.name} played: {self.action_queue[0]}")
                 return self.action_queue.popleft()
             elif self.is_cycle and self.original_queue:  # reset
                 self.action_queue = self.original_queue.copy()
+                log.info(f"{self.name} played: {self.action_queue[0]}")
                 return self.action_queue.popleft()
             else:
                 raise ValueError("Action queue is empty")
         else:
+            log.info(f"{self.name} played: {self.action}")
             return self.action
 
 
@@ -57,4 +64,5 @@ def __init__(self, name: str) -> None:
 
     def choose_action(self, action_count: int) -> int:
         self.action = random.randrange(0, action_count)
+        log.info(f"{self.name} played: {self.action}")
         return self.action