Fixing mistakes one by one

Author: Tesla2000

agent/train_agent.py

@@ -7,7 +7,6 @@
 
 from Config import Config
 from src.Game import Game
-from src.entities.Player import Player
 from .Agent import Agent
 
 
@@ -39,13 +38,10 @@ def search(
     visited: set,
     P: defaultdict,
     Q: defaultdict,
-    evaluated_player: Player = None,
 ):
-    if evaluated_player is None:
-        evaluated_player = game.current_player
     state = game.get_state()
     if game.is_terminal():
-        return game.get_results()[evaluated_player]
+        return game.get_results()[game.current_player]
     if state not in visited:
         visited.add(state)
         move_scores, v = agent(Tensor([state]))
@@ -62,7 +58,7 @@ def search(
     )
 
     next_game_state = game.perform(action)
-    v = search(next_game_state, agent, c, N, visited, P, Q, evaluated_player)
+    v = search(next_game_state, agent, c, N, visited, P, Q)
 
     Q[state][action] = (N[state][action] * Q[state].get(action, 1) + v) / (
         N[state][action] + 1

src/Game.py

@@ -1,14 +1,17 @@
-from dataclasses import fields, asdict, dataclass, field
+from dataclasses import fields, dataclass, field
 from itertools import combinations, starmap, product
 from typing import Self, Type
 
-from dacite import from_dict
-
-from hashabledict import hashabledict
 from .StateExtractor import StateExtractor
+from .entities.AllResources import AllResources
 from .entities.BasicResources import BasicResources
 from .entities.Board import Board
 from .entities.Player import Player
+from .entities.Tier import Tier
+from .entities.extended_lists.Aristocrats import Aristocrats
+from .entities.extended_lists.PlayerAristocrats import PlayerAristocrats
+from .entities.extended_lists.PlayerCards import PlayerCards
+from .entities.extended_lists.PlayerReserve import PlayerReserve
 from .moves import (
     Move,
     GrabThreeResource,
@@ -34,14 +37,15 @@ class Game:
     _state_extractor: Type[StateExtractor] = StateExtractor
 
     def __post_init__(self):
-        if not self.board or not self.players:
+        if not self.players:
             self.players = tuple(Player() for _ in range(self.n_players))
+        if not self.board:
             self.board = Board(self.n_players)
+        if not self._performed_the_last_move:
             self._performed_the_last_move = dict(
                 (player, False) for player in self.players
             )
             self.is_blocked = dict((player, False) for player in self.players)
-            self._last_turn = False
         self.current_player = self.players[0]
 
     def perform(self, action: Move) -> Self:
@@ -60,7 +64,6 @@ def next_turn(self) -> None:
             self._last_turn = True
         self._performed_the_last_move[self.current_player] = self._last_turn
         self.current_player = self.players[0]
-        self._turn_counter += 1
 
     def is_terminal(self) -> bool:
         return all(self._performed_the_last_move.values()) or (
@@ -85,8 +88,38 @@ def get_state(self) -> tuple:
         return self._state_extractor.get_state(self)
 
     def copy(self) -> Self:
-        dict_repr = asdict(self, dict_factory=hashabledict)
-        game = from_dict(Game, dict_repr)
+        game = Game(
+            players=tuple(
+                Player(
+                    resources=AllResources(
+                        (resources := player.resources).red,
+                        resources.green,
+                        resources.blue,
+                        resources.black,
+                        resources.white,
+                        resources.gold,
+                    ),
+                    cards=PlayerCards(tuple(player.cards)),
+                    reserve=PlayerReserve(tuple(player.reserve)),
+                    aristocrats=PlayerAristocrats(tuple(player.aristocrats)),
+                )
+                for player in self.players
+            ),
+            board=Board(
+                n_players=(board := self.board).n_players,
+                tiers=list(Tier(tier.hidden, tier.visible) for tier in board.tiers),
+                aristocrats=Aristocrats(board.aristocrats),
+                resources=AllResources(
+                    board.resources.red,
+                    board.resources.green,
+                    board.resources.blue,
+                    board.resources.black,
+                    board.resources.white,
+                    board.resources.gold,
+                ),
+            ),
+            n_players=self.n_players,
+        )
         game.current_player = game.players[0]
         for player in game.players:
             game.is_blocked[player] = next(

src/entities/AllResources.py

@@ -46,3 +46,6 @@ def __rsub__(self, other: BasicResources) -> Self:
 
     def lacks(self) -> bool:
         return self.gold < 0
+
+if __name__ == '__main__':
+    (AllResources(red=0, green=0, blue=0, black=4, white=4, gold=5) - BasicResources(red=1, green=1, blue=0, black=0, white=1))

src/moves/GrabResource.py

@@ -1,8 +1,13 @@
 from abc import ABC
-from dataclasses import dataclass
+from dataclasses import dataclass, astuple
+from typing import TYPE_CHECKING
 
 from src.entities.BasicResources import BasicResources
 from .Move import Move
+from ..entities.AllResources import AllResources
+
+if TYPE_CHECKING:
+    from src.Game import Game
 
 
 @dataclass(slots=True, frozen=True)
@@ -11,3 +16,17 @@ class GrabResource(Move, ABC):
 
     def __repr__(self):
         return self.resources.__repr__()
+
+    def is_valid(self, game: "Game") -> bool:
+        if (
+            sum(astuple(game.current_player.resources)) + sum(astuple(self.resources))
+            > 10
+        ):
+            return False
+        return not (AllResources(
+            game.board.resources.red,
+            game.board.resources.green,
+            game.board.resources.blue,
+            game.board.resources.black,
+            game.board.resources.white,
+        ) - self.resources).lacks()

src/moves/GrabThreeResource.py

@@ -1,12 +1,11 @@
 from dataclasses import astuple
-
 from typing import TYPE_CHECKING
 
+from .GrabResource import GrabResource
 from .Move import Move
 
 if TYPE_CHECKING:
     from src.Game import Game
-from .GrabResource import GrabResource
 
 
 class GrabThreeResource(GrabResource):
@@ -17,11 +16,3 @@ def perform(self, game: "Game") -> "Game":
         if sum(astuple(game.current_player.resources)) > 10:
             raise ValueError
         return game
-
-    def is_valid(self, game: "Game") -> bool:
-        if (
-            sum(astuple(game.current_player.resources)) + sum(astuple(self.resources))
-            > 10
-        ):
-            return False
-        return not (game.board.resources - self.resources).lacks()

src/moves/GrabTwoResource.py

@@ -20,10 +20,7 @@ def perform(self, game: "Game") -> "Game":
         return game
 
     def is_valid(self, game: "Game") -> bool:
-        tuple_resources = astuple(self.resources)
-        if sum(astuple(game.current_player.resources)) + sum(tuple_resources) > 10:
-            return False
-        resource = next(compress(asdict(self.resources).keys(), tuple_resources))
+        resource = next(compress(asdict(self.resources).keys(), astuple(self.resources)))
         if getattr(game.board.resources, resource) < 4:
             return False
-        return not (game.board.resources - self.resources).lacks()
+        return super().is_valid(game)

src/moves/Reserve.py

@@ -1,11 +1,9 @@
 from abc import ABC
-from dataclasses import dataclass, fields
-
-from src.entities.Card import Card
+from dataclasses import dataclass
 from typing import TYPE_CHECKING
 
+from src.entities.Card import Card
 from ..entities.AllResources import AllResources
-from ..entities.BasicResources import BasicResources
 
 if TYPE_CHECKING:
     from src.Game import Game
@@ -21,16 +19,18 @@ def reserve_card(self, game: "Game", card: Card):
         current_player.reserve.append(card)
         if game.board.resources.gold:
             game.board.resources = AllResources(
-                **dict(
-                    (field.name, getattr(game.board.resources, field.name))
-                    for field in fields(BasicResources)
-                ),
-                gold=game.board.resources.gold - 1
+                game.board.resources.red,
+                game.board.resources.green,
+                game.board.resources.blue,
+                game.board.resources.black,
+                game.board.resources.white,
+                game.board.resources.gold - 1
             )
             current_player.resources = AllResources(
-                **dict(
-                    (field.name, getattr(game.board.resources, field.name))
-                    for field in fields(BasicResources)
-                ),
-                gold=game.board.resources.gold + 1
+                current_player.resources.red,
+                current_player.resources.green,
+                current_player.resources.blue,
+                current_player.resources.black,
+                current_player.resources.white,
+                current_player.resources.gold + 1
             )