feat: allow players to control multiple avatars

Author: corruptedvyolet

base_client.py

@@ -15,7 +15,7 @@ def team_name(self):
         return 'Team 1'
 
     # This is where your AI will decide what to do
-    def take_turn(self, turn, actions, world, avatar):
+    def take_turn(self, turn, actions, world, avatars, avatar):
         """
         This is where your AI will decide what to do.
         :param turn:        The current turn of the game.

base_client_2.py

@@ -15,7 +15,7 @@ def team_name(self):
         return 'Team 2'
 
     # This is where your AI will decide what to do
-    def take_turn(self, turn, actions, world, avatar):
+    def take_turn(self, turn, actions, world, avatars, avatar):
         """
         This is where your AI will decide what to do.
         :param turn:        The current turn of the game.

game/client/user_client.py

@@ -17,5 +17,5 @@ def debug(self, *args):
     def team_name(self):
         return "No_Team_Name_Available"
 
-    def take_turn(self, turn, actions, world, avatar):
+    def take_turn(self, turn, actions, world, avatars, selected_avatar):
         raise NotImplementedError("Implement this in subclass")

game/common/avatar.py

@@ -160,10 +160,6 @@ def held_item(self) -> Item | None:
         self.__clean_inventory()
         return self.inventory[self.__held_index]
 
-    @property
-    def score(self) -> int:
-        return self.__score
-
     @property
     def position(self) -> Vector | None:
         return self.__position
@@ -194,14 +190,6 @@ def held_item(self, item: Item | None) -> None:
         # If the item is contained in the inventory, set the held_index to that item's index
         self.__held_index = self.inventory.index(item)
 
-    @score.setter
-    def score(self, score: int) -> None:
-        if score is None or not isinstance(score, int):
-            raise ValueError(
-                f'{self.__class__.__name__}.score must be an int. It is a(n) {score.__class__.__name__} and has the value of '
-                f'{score}')
-        self.__score: int = score
-
     @position.setter
     def position(self, position: Vector | None) -> None:
         if position is not None and not isinstance(position, Vector):

game/common/enums.py

@@ -59,7 +59,8 @@ class ActionType(Enum):
     PLACE_ITEM_DOWN = auto()
     PLACE_ITEM_LEFT = auto()
     PLACE_ITEM_RIGHT = auto()
+    SELECT_DEFAULT_AVATAR = auto()
     """
     These last 10 enums are for selecting a slot from the Avatar class' inventory.
     You can add/remove these as needed for the purposes of your game. 
-    """
+    """

game/common/map/occupiable.py

@@ -1,8 +1,7 @@
+from typing import Self
+
 from game.common.enums import ObjectType
 from game.common.game_object import GameObject
-from game.common.items.item import Item
-from typing import Self, Type
-from game.common.avatar import Avatar
 
 
 class Occupiable(GameObject):

game/common/player.py

@@ -1,8 +1,7 @@
-from game.common.action import Action
-from game.common.game_object import GameObject
+from game.client.user_client import UserClient
 from game.common.avatar import Avatar
 from game.common.enums import *
-from game.client.user_client import UserClient
+from game.common.game_object import GameObject
 
 
 class Player(GameObject):
@@ -18,17 +17,18 @@ class Player(GameObject):
     """
 
     def __init__(self, code: object | None = None, team_name: str | None = None, actions: list[ActionType] = [],
-                 avatar: Avatar | None = None):
+                 avatars: dict[ObjectType, Avatar] | None = None):
         super().__init__()
         self.object_type: ObjectType = ObjectType.PLAYER
         self.functional: bool = True
         self.error: str | None = None
         self.file_name: str | None = None
         self.team_name: str | None = team_name
         self.code: UserClient | None = code
-        # self.action: Action = action
         self.actions: list[ActionType] = actions
-        self.avatar: Avatar | None = avatar
+        self.avatars: dict[ObjectType, Avatar] | None = avatars
+        self.__selected_avatar_type: ObjectType = ObjectType.AVATAR
+        self.score: int = 0
 
     @property
     def error(self) -> str | None:
@@ -89,15 +89,41 @@ def file_name(self, file_name: str | None) -> None:
         self.__file_name = file_name
 
     @property
-    def avatar(self) -> Avatar:
-        return self.__avatar
+    def avatars(self) -> dict[ObjectType, Avatar]:
+        return self.__avatars
+
+    @avatars.setter
+    def avatars(self, avatars: dict[ObjectType, Avatar]) -> None:
+        if (avatars is not None and not (isinstance(avatars, dict)
+                and len(avatars) > 0
+                and all(map(lambda name_and_avatar: isinstance(name_and_avatar[0], ObjectType) and isinstance(name_and_avatar[1], Avatar), avatars.items())))):
+            raise ValueError(
+                f'{self.__class__.__name__}.avatars must be a dict with a key of ObjectType and a value of Avatar or None. It is a(n) {avatars.__class__.__name__} and has the value of {avatars}.')
+        self.__avatars = avatars
+
+    def select_avatar(self, avatar_type: ObjectType) -> None:
+        if avatar_type is None or not isinstance(avatar_type, ObjectType):
+            raise ValueError(
+                f'avatar_name must be a ObjectType. It is a(n) {avatar_type.__class__.__name__} and has the value of '
+                f'{avatar_type}'
+            )
+        self.__selected_avatar_type = avatar_type
+
+    @property
+    def avatar(self) -> Avatar | None:
+        return self.avatars.get(self.__selected_avatar_type, None) if self.avatars is not None else None
 
-    @avatar.setter
-    def avatar(self, avatar: Avatar) -> None:
-        if avatar is not None and not isinstance(avatar, Avatar):
+    @property
+    def score(self) -> int:
+        return self.__score
+
+    @score.setter
+    def score(self, score: int) -> None:
+        if score is None or not isinstance(score, int):
             raise ValueError(
-                f'{self.__class__.__name__}.avatar must be Avatar or None. It is a(n) {avatar.__class__.__name__} and has the value of {avatar}.')
-        self.__avatar = avatar
+                f'{self.__class__.__name__}.score must be an int. It is a(n) {score.__class__.__name__} and has the value of '
+                f'{score}')
+        self.__score: int = score
 
     @property
     def object_type(self) -> ObjectType:
@@ -118,7 +144,9 @@ def to_json(self):
         data['team_name'] = self.team_name
         data['file_name'] = self.file_name
         data['actions'] = [act.value for act in self.actions]
-        data['avatar'] = self.avatar.to_json() if self.avatar is not None else None
+        data['selected_avatar_type'] = self.__selected_avatar_type
+        data['avatars'] = { k: v.to_json() if v is not None else None for k, v in self.avatars} if self.avatars is not None else None
+        data['score'] = self.score
 
         return data
 
@@ -129,32 +157,15 @@ def from_json(self, data):
         self.error = data['error']
         self.team_name = data['team_name']
         self.file_name = data['file_name']
-
-        self.actions: list[ActionType] = [ObjectType(action) for action in data['actions']]
-        avatar: Avatar | None = data['avatar']
-        if avatar is None:
-            self.avatar = None
+        self.score = data['score']
+        self.actions: list[ActionType] = [ActionType(action) for action in data['actions']]
+        self.__selected_avatar_type = data['selected_avatar_type']
+        avatars: dict[str, Avatar] = data['avatars']
+        if avatars is None:
+            self.avatars = None
             return self
-        # match case for action
-        # match action['object_type']:
-        #     case ObjectType.ACTION:
-        #         self.action = Action().from_json(data['action'])
-        #     case None:
-        #         self.action = None
-        #     case _:  # checks if it is anything else
-        #         raise Exception(f'Could not parse action: {self.action}')
-
-        # match case for avatar
-        match ObjectType(avatar['object_type']):
-            case ObjectType.AVATAR:
-                self.avatar = Avatar().from_json(data['avatar'])
-            case None:
-                self.avatar = None
-            case _:
-                raise Exception(f'Could not parse avatar: {self.avatar}')
+        self.avatars = { k:Avatar().from_json(v) if v is not None else None for k, v in data['avatars']}
         return self
-        # self.action = Action().from_json(data['action']) if data['action'] is not None else None
-        # self.avatar = Avatar().from_json(data['avatar']) if data['avatar'] is not None else None
 
     # to String
     def __str__(self):

game/controllers/avatar_selection_controller.py

@@ -0,0 +1,26 @@
+from game.common.enums import ActionType, ObjectType
+from game.common.map.game_board import GameBoard
+from game.common.player import Player
+from game.controllers.controller import Controller
+
+
+class AvatarSelectionController(Controller):
+    def __init__(self):
+        super().__init__()
+
+    def handle_actions(self, action: ActionType, client: Player, world: GameBoard) -> None:
+        """
+           Given the ActionType for interacting in a direction, the Player's avatar will engage with the object.
+           :param action:
+           :param client:
+           :param world:
+           :return: None
+        """
+
+        match action:
+            case ActionType.SELECT_DEFAULT_AVATAR:
+                client.select_avatar(ObjectType.AVATAR)
+            case _:
+                return
+
+        return

game/controllers/controller.py

@@ -27,6 +27,6 @@ def handle_actions(self, action: ActionType, client: Player, world: GameBoard):
 
     def debug(self, *args):
         if self.debug and Debug.level >= self.debug_level:
-            logging.basicConfig(level=logging.DEBUGs)
+            logging.basicConfig(level=logging.DEBUG)
             for arg in args:
                 logging.debug(f'{self.__class__.__name__}: {arg}')

game/controllers/master_controller.py

@@ -6,6 +6,7 @@
 from game.common.enums import *
 from game.common.player import Player
 import game.config as config   # this is for turns
+from game.controllers.avatar_selection_controller import AvatarSelectionController
 from game.utils.thread import CommunicationThread
 from game.controllers.movement_controller import MovementController
 from game.controllers.controller import Controller
@@ -54,6 +55,7 @@ def __init__(self):
         self.current_world_data: dict = None
         self.movement_controller: MovementController = MovementController()
         self.interact_controller: InteractController = InteractController()
+        self.avatar_selection_controller: AvatarSelectionController = AvatarSelectionController()
 
     # Receives all clients for the purpose of giving them the objects they will control
     def give_clients_objects(self, clients: list[Player], world: dict):
@@ -62,7 +64,8 @@ def give_clients_objects(self, clients: list[Player], world: dict):
         avatars: list[tuple[Vector, list[Avatar]]] = gb.get_objects(ObjectType.AVATAR)
         for avatar, client in zip(avatars, clients):
             avatar[1][0].position = avatar[0]
-            client.avatar = avatar[1][0]
+            client.avatars = { ObjectType.AVATAR:avatar[1][0] }
+            client.select_avatar(ObjectType.AVATAR)
 
     # Generator function. Given a key:value pair where the key is the identifier for the current world and the value is
     # the state of the world, returns the key that will give the appropriate world information
@@ -95,17 +98,19 @@ def client_turn_arguments(self, client: Player, turn):
 
         # Create deep copies of all objects sent to the player
         current_world = deepcopy(self.current_world_data["game_board"])    # what is current world and copy avatar
+        copy_avatars = deepcopy(client.avatars)
         copy_avatar = deepcopy(client.avatar)
         # Obfuscate data in objects that that player should not be able to see
         # Currently world data isn't obfuscated at all
-        args = (self.turn, turn_actions, current_world, copy_avatar)
+        args = (self.turn, turn_actions, current_world, copy_avatars, copy_avatar)
         return args
 
     # Perform the main logic that happens per turn
     def turn_logic(self, clients: list[Player], turn):
         for client in clients:
             for i in range(MAX_NUMBER_OF_ACTIONS_PER_TURN):
                 try:
+                    self.avatar_selection_controller.handle_actions(client.actions[i], client, self.current_world_data["game_board"])
                     self.movement_controller.handle_actions(client.actions[i], client, self.current_world_data["game_board"])
                     self.interact_controller.handle_actions(client.actions[i], client, self.current_world_data["game_board"])
                 except IndexError: