Moving on to optimize copy

Author: Tesla2000

Config.py

@@ -9,6 +9,6 @@
 
 
 class Config:
-    n_simulations = 1000
+    n_simulations = 100
     n_games = 100
     n_players = 2

agent/train_agent.py

@@ -17,20 +17,17 @@ def train_agent():
     examples = []
     examples_per_game = []
     for i in range(Config.n_games):
-        N = defaultdict(lambda: defaultdict(int))
         game = Game(n_players=Config.n_players)
-        visited = set()
-        P = defaultdict(dict)
-        Q = defaultdict(dict)
         while True:
-            pi, action = policy(game, agent, 1, Config.n_simulations, N, visited, P, Q)
+            pi, action = policy(game, agent, 1, Config.n_simulations)
             examples_per_game.append((game, pi, 0))
             game = game.perform(action)
             if game.is_terminal():
                 for example in examples_per_game:
                     example[2] = game.get_state()
                 break
         examples += examples_per_game
+        break
     return examples
 
 
@@ -52,8 +49,10 @@ def search(
     if state not in visited:
         visited.add(state)
         move_scores, v = agent(Tensor([state]))
-        for index, move in enumerate(game.all_moves):
-            P[state][move] = move_scores[0, index]
+        tuple(
+            P[state].__setitem__(move, move_scores[0, index])
+            for index, move in enumerate(game.all_moves)
+        )
         return -v
 
     action = max(
@@ -77,11 +76,11 @@ def policy(
     agent: nn.Module,
     c: float,
     n_simulations: int,
-    N: defaultdict,
-    visited: set,
-    P: defaultdict,
-    Q: defaultdict,
 ):
+    N = defaultdict(lambda: defaultdict(int))
+    visited = set()
+    P = defaultdict(dict)
+    Q = defaultdict(dict)
     initial_state = game.get_state()
     all_moves = game.get_possible_actions()
     for _ in tqdm(range(n_simulations)):

src/StateExtractor.py

@@ -1,31 +1,42 @@
 from dataclasses import astuple
+from itertools import chain
 from typing import Iterable, Any, TYPE_CHECKING
 
-from .entities.Card import empty_card
-from .entities.Tier import Tier
-
 if TYPE_CHECKING:
     from .Game import Game
 
 
 class StateExtractor:
     @classmethod
     def get_state(cls, game: "Game") -> tuple:
-        tiers = game.board.tiers
-        game.board.tiers = list(Tier([], tier.visible) for tier in tiers)
-        state = cls._flatter_recursively(astuple(game.board))
-        game.board.tiers = tiers
-        for player in game.players:
-            state += astuple(player.resources, tuple_factory=list)
-            state += astuple(player.production, tuple_factory=list)
-            if player is not game.current_player:
-                state.append(sum(card != empty_card for card in player.reserve))
-            else:
-                state += cls._flatter_recursively(
-                    map(astuple, game.current_player.reserve)
+        return tuple(
+            chain.from_iterable(
+                (
+                    chain.from_iterable(
+                        (*astuple(card.cost), *astuple(card.production), card.points)
+                        for tier in game.board.tiers
+                        for card in tier.visible
+                    ),
+                    chain.from_iterable(
+                        (*astuple(card.cost), *astuple(card.production), card.points)
+                        for card in game.current_player.reserve
+                    ),
+                    chain.from_iterable(
+                        astuple(aristocrat.cost)
+                        for aristocrat in game.board.aristocrats
+                    ),
+                    chain.from_iterable(
+                        (
+                            *astuple(player.resources),
+                            *astuple(player.production),
+                            player.points,
+                        )
+                        for player in game.players
+                    ),
+                    (len(player.reserve) for player in game.players[1:]),
                 )
-            state.append(player.points)
-        return tuple(state)
+            )
+        )
 
     @classmethod
     def _flatter_recursively(

src/entities/AllResources.py

@@ -1,4 +1,4 @@
-from dataclasses import dataclass, asdict, fields, astuple
+from dataclasses import dataclass
 from typing import Self
 
 from .BasicResources import BasicResources
@@ -11,23 +11,35 @@ class AllResources(BasicResources):
     def __sub__(self, other: BasicResources) -> Self:
         if not isinstance(other, BasicResources):
             raise ValueError(f"Other element must be resource is {other.__class__}")
-        self_dict = asdict(self)
-        other_dict = asdict(other)
-        resources = AllResources(
-            **dict(
-                (key, value - other_dict.get(key, 0))
-                for key, value in self_dict.items()
-            )
-        )
-        resources = AllResources(
-            *tuple(max(0, resource) for resource in astuple(resources)[:-1]),
-            resources.gold
+        return AllResources(
+            max(0, self.red - other.red),
+            max(0, self.green - other.green),
+            max(0, self.blue - other.blue),
+            max(0, self.black - other.black),
+            max(0, self.white - other.white),
+            self.gold
             + sum(
-                min(0, getattr(resources, field.name))
-                for field in fields(BasicResources)
+                (
+                    min(0, self.red - other.red),
+                    min(0, self.green - other.green),
+                    min(0, self.blue - other.blue),
+                    min(0, self.black - other.black),
+                    min(0, self.white - other.white),
+                )
             ),
         )
-        return resources
+
+    def __add__(self, other: Self) -> Self:
+        if not isinstance(other, BasicResources):
+            raise ValueError(f"Other element must be resource is {other.__class__}")
+        return AllResources(
+            self.red + other.red,
+            self.green + other.green,
+            self.blue + other.blue,
+            self.black + other.black,
+            self.white + other.white,
+            self.gold + getattr(other, "gold", 0),
+        )
 
     def __rsub__(self, other: BasicResources) -> Self:
         return self.__sub__(other)

src/entities/BasicResources.py

@@ -13,11 +13,10 @@ class BasicResources:
     def __add__(self, other: Self) -> Self:
         if not isinstance(other, BasicResources):
             raise ValueError(f"Other element must be resource is {other.__class__}")
-        self_dict = asdict(self)
-        other_dict = asdict(other)
-        return type(self)(
-            **dict(
-                (key, value + other_dict.get(key, 0))
-                for key, value in self_dict.items()
-            )
+        return BasicResources(
+            self.red + other.red,
+            self.green + other.green,
+            self.blue + other.blue,
+            self.black + other.black,
+            self.white + other.white,
         )

src/entities/extended_lists/PlayerCards.py

@@ -1,15 +1,18 @@
-import operator
-from functools import reduce
-
-from ..BasicResources import BasicResources
 from .hashablelist import hashablelist
+from ..BasicResources import BasicResources
 
 
 class PlayerCards(hashablelist):
     @property
     def production(self) -> BasicResources:
-        return reduce(
-            operator.add, (card.production for card in self), BasicResources()
+        if not self:
+            return BasicResources()
+        return BasicResources(
+            sum(card.production.red for card in self),
+            sum(card.production.green for card in self),
+            sum(card.production.blue for card in self),
+            sum(card.production.black for card in self),
+            sum(card.production.white for card in self),
         )
 
     @property