graph-games-proto 0.3.1953__py3-none-any.whl → 0.3.1966__py3-none-any.whl

graph_games_proto/fns.py

@@ -2060,7 +2060,6 @@ class State(PClass):
     players = field(type=list)  # List[Player]
     player_idxs = field(type=list)  # List[int]
     decks = field(type=list)  # List[Deck]
-    game_config = field(type=GameConfig)
     rng = field(type=random.Random)
     last_to_play = field(type=(int, type(None)), initial=None)
     winners = field(type=list)  # List[int]
@@ -2086,7 +2085,6 @@ class State(PClass):
             "players": [player.__todict__() for player in self.players],
             "player_idxs": self.player_idxs,
             "decks": [deck.__todict__() for deck in self.decks],
-            "game_config": self.game_config.__todict__(),
             "rng": rng2json(self.rng),
             "last_to_play": self.last_to_play,
             "winners": self.winners,
@@ -2114,7 +2112,6 @@ class State(PClass):
             players=[Player.__fromdict__(p) for p in d["players"]],
             player_idxs=d["player_idxs"],
             decks=[Deck.__fromdict__(deck) for deck in d["decks"]],
-            game_config=GameConfig.__fromdict__(d["game_config"]),
             rng=json2rng(d["rng"]),
             last_to_play=d.get("last_to_play"),
             winners=d["winners"],
@@ -2567,7 +2564,7 @@ def getsettingvalue(f, setting_name):
 
 @dispatch(State, str)
 def getsettingvalue(s, setting_name):
-    return getsettingvalue(s.game_config.fig, setting_name)
+    return getsettingvalue(s.kernel.game_config.fig, setting_name)
 
 
 @dispatch(GameConfig)
@@ -2669,7 +2666,6 @@ def getinitialstate(game_config):
         players=[Player(idx=idx, pieces=[], cards=[], discard_tray=[]) for idx in range(game_config.num_players)],
         player_idxs=list(range(game_config.num_players)),
         decks=decks,
-        game_config=game_config,
         rng=rng,
         last_to_play=None,
         winners=[],
@@ -2679,7 +2675,7 @@ def getinitialstate(game_config):
     
     kernel = init_state_kernel(
         rng=rng,
-        game_config=state.game_config,
+        game_config=game_config,
         edges=state.edges,
         decks=state.decks,
         piles=state.piles,
@@ -2722,14 +2718,14 @@ def run_state_action_hooks(state, action, hooks, log=False):
     )
 
 
-def score_public_items(game, player_idx):
+def score_public_items(state, player_idx):
     items = []
-    for edge in game.edges:
+    for edge in state.edges:
         for path in edge.paths:
             if len(path.segments) > 0:
                 first_segment = path.segments[0]
                 if first_segment.pieces and len(first_segment.pieces) > 0:
-                    first_piece = game.pieceuuid2piece[first_segment.pieces[0]]
+                    first_piece = state.pieceuuid2piece[first_segment.pieces[0]]
                     if first_piece.player_idx == player_idx:
                         items.append(
                             ScoreItem2(
@@ -2742,9 +2738,9 @@ def score_public_items(game, player_idx):
                                 description="Player {} owns edge {}".format(player_idx, edge.uuid),
                             )
                         )
-    for bonus_status in game.bonus_statuses:
-        bonus_idx = game.bonusuuid2bonusidx.get(bonus_status.bonus_uuid)
-        bonus = game.game_config.fig.board_config.bonuses[bonus_idx] if bonus_idx is not None else None
+    for bonus_status in state.bonus_statuses:
+        bonus_idx = state.bonusuuid2bonusidx.get(bonus_status.bonus_uuid)
+        bonus = state.kernel.game_config.fig.board_config.bonuses[bonus_idx] if bonus_idx is not None else None
         if bonus:
             if player_idx in bonus_status.winners:
                 items.append(
@@ -2836,13 +2832,13 @@ def calc_bonus_status(game, bonus):
     return None
 
 
-def get_bonus_status_longest_trail(game, bonus):
+def get_bonus_status_longest_trail(state, bonus):
     longest_trail = 0
     winners = []
     player_longest_trail_lens = []
 
-    for player_idx in range(game.game_config.num_players):
-        trail_length = get_longest_path_length(game, player_idx)
+    for player_idx in range(state.kernel.game_config.num_players):
+        trail_length = get_longest_path_length(state, player_idx)
         player_longest_trail_lens.append(trail_length)
         if trail_length > longest_trail:
             longest_trail = trail_length
@@ -2868,14 +2864,14 @@ def get_bonus_status_longest_trail(game, bonus):
     )
 
 
-def handle_bonus_statuses(game):
+def handle_bonus_statuses(state):
     bonus_statuses = [
-        calc_bonus_status(game, bonus)
-        for bonus in game.game_config.fig.board_config.bonuses
+        calc_bonus_status(state, bonus)
+        for bonus in state.kernel.game_config.fig.board_config.bonuses
     ]
     # Remove all None bonus statuses
     bonus_statuses = [bs for bs in bonus_statuses if bs is not None]
-    return game.set(bonus_statuses=bonus_statuses)
+    return state.set(bonus_statuses=bonus_statuses)
 
 
 def default_handle_scoring(game):
@@ -3176,12 +3172,12 @@ def random_player_graph_walk(game, player_idx):
     return walk([random_start_node_idx], set([]))
 
 
-def find_player_with_longest_path(game):
+def find_player_with_longest_path(state):
     longest_path_player_idx = None
     longest_path_length = 0
 
-    for player_idx in range(game.game_config.num_players):
-        path_length = get_longest_path_length(game, player_idx)
+    for player_idx in range(state.kernel.game_config.num_players):
+        path_length = get_longest_path_length(state, player_idx)
         if path_length > longest_path_length:
             longest_path_length = path_length
             longest_path_player_idx = player_idx
@@ -3189,7 +3185,7 @@ def find_player_with_longest_path(game):
     if longest_path_player_idx is None:
         return None
     
-    return game.players[longest_path_player_idx]
+    return state.players[longest_path_player_idx]
 
 
 @dispatch(State, set)
@@ -3340,10 +3336,10 @@ def calc_player_graph(game, player_idx):
     )
 
 
-def calc_player_graphs(game):
-    game_config = game.game_config
+def calc_player_graphs(state):
+    game_config = state.kernel.game_config
     return [
-        calc_player_graph(game, player_idx) 
+        calc_player_graph(state, player_idx) 
         for player_idx in range(game_config.num_players)
     ]
 
@@ -4094,7 +4090,7 @@ def getnextstate2(s, a, log=False):
 
     state_kernel = init_state_kernel(
         rng=s.rng,
-        game_config=s.game_config,
+        game_config=s.kernel.game_config,
         edges=s.edges,
         decks=s.decks,
         piles=s.piles,
@@ -4140,7 +4136,7 @@ def getpublictoplay(s):
 def get_max_allotted_times(s):
     return [
         get_player_max_allotted_time(s, player_idx) 
-        for player_idx in range(s.game_config.num_players)
+        for player_idx in range(s.kernel.game_config.num_players)
     ]
 
 
@@ -4166,7 +4162,7 @@ def get_deadline(s, max_allotted_time):
     since_action_idx = max_allotted_time.since_action_idx
     if since_action_idx == -1:
         allotted_since = datetime.strptime(
-            s.game_config.started_at, 
+            s.kernel.game_config.started_at, 
             "%Y-%m-%d %H:%M:%S"
         )
     else:
@@ -4184,7 +4180,7 @@ def get_deadline(s, max_allotted_time):
 
 def get_deadlines(s):
     if isterminal(s):
-        return [None for _ in range(s.game_config.num_players)]
+        return [None for _ in range(s.kernel.game_config.num_players)]
     return [
         get_deadline(s, max_alloted_time)
         for max_alloted_time in get_max_allotted_times(s)
@@ -4268,7 +4264,7 @@ def isterminal(s):
 def getpublicstate(s):
     return PublicState(
         deadlines=get_deadlines(s),
-        game_started_at=s.game_config.started_at,
+        game_started_at=s.kernel.game_config.started_at,
         allotted_times=get_max_allotted_times(s),
         all_pieces=list(s.pieceuuid2piece.values()),
         to_play_2=getpublictoplay(s),
@@ -4306,10 +4302,10 @@ def getpublicdeck(s, d):
 
 @dispatch(State, Player)
 def getpublicplayer(s, p):
-    deck_counts = [0 for _ in s.game_config.fig.board_config.deks]
+    deck_counts = [0 for _ in s.kernel.game_config.fig.board_config.deks]
     for card in p.cards:
         deck_counts[s.kernel.carduuid2card[card].deck_idx] += 1
-    piece_template_counts = [0 for _ in s.game_config.fig.board_config.piece_templates]
+    piece_template_counts = [0 for _ in s.kernel.game_config.fig.board_config.piece_templates]
     for piece_uuid in p.pieces:
         piece_template_counts[s.pieceuuid2piece[piece_uuid].piece_template_idx] += 1
     return PublicPlayer(
@@ -4353,10 +4349,10 @@ def getpublicscore(s, player_idx):
         path_lens = getplayerpathlens(s, player_idx)
         if not path_lens:
             return 0
-        addends.append(sum(s.game_config.fig.path_scores[len] for len in path_lens))
+        addends.append(sum(s.kernel.game_config.fig.path_scores[len] for len in path_lens))
     
     if getsettingvalue(s, 'cluster_scoring'):
-        clusters = s.game_config.fig.board_config.clusters
+        clusters = s.kernel.game_config.fig.board_config.clusters
         uuid2cluster = {x.uuid: x for x in clusters}
         completed_clusters = s.player_hands[player_idx].completed_clusters
         cluster_scores = [uuid2cluster[cluster_uuid].score for cluster_uuid in completed_clusters]
@@ -4379,7 +4375,7 @@ def getplayerpathlens(s, player_idx):
 # Implementing the following Julia function:
 # getpathlens(s::State) = length.(getfield.(getfield.(s.fig.board_config.board_paths, :path), :segments))
 def getpathlens(s):
-    return [len(p.path.segments) for p in s.game_config.fig.board_config.board_paths]
+    return [len(p.path.segments) for p in s.kernel.game_config.fig.board_config.board_paths]
 
 # Implementing the following Julia function:
 # function getplayerpathidxs(s::State, player_idx::Int)
@@ -4419,7 +4415,7 @@ def getactiontype(action_name):
 
 
 # Function implements the following Julia function:
-# getlastplayeridxplus1(s) = mod1(getlastaction(s).player_idx + 1, s.game_config.num_players)
+# getlastplayeridxplus1(s) = mod1(getlastaction(s).player_idx + 1, s.kernel.game_config.num_players)
 def getlastplayeridxplus1(s):
     pass
 
@@ -4565,7 +4561,7 @@ def combinations(a, n=None):
 def getpotentialpathidxs(s, player_num):
     num_pieces = s.player_hands[player_num-1].num_pieces
     return list(
-        set(getpathidxs(s.game_config.fig, num_pieces)) - set(getunavailablepathidxs(s, player_num))
+        set(getpathidxs(s.kernel.game_config.fig, num_pieces)) - set(getunavailablepathidxs(s, player_num))
     )
     # return list(set(getpathidxs(s.fig, num_pieces)) - set(getunavailablepaths(s, player_num)))
 
@@ -4629,16 +4625,16 @@ def getunavailablepathidxs(s, player_idx):
     link2paths = {}
     path2link = {}
 
-    for board_path in s.game_config.fig.board_config.board_paths:
+    for board_path in s.kernel.game_config.fig.board_config.board_paths:
         link_idx = board_path.link_num - 1
         if link_idx not in link2paths:
             link2paths[link_idx] = []
         link2paths[link_idx].append(board_path.num-1)
         path2link[board_path.num-1] = link_idx
 
-    multipath_links = [(board_link.num-1) for board_link in getmultipathlinks(s.game_config.fig)]
+    multipath_links = [(board_link.num-1) for board_link in getmultipathlinks(s.kernel.game_config.fig)]
 
-    if s.game_config.num_players < 4:
+    if s.kernel.game_config.num_players < 4:
         blocking_hands = s.player_hands
     else:
         blocking_hands = [s.player_hands[player_idx]]
@@ -5144,7 +5140,7 @@ def getqproxy0(ps, a, td):
             return rewards
         v_proxies = [
             getvproxy0(getprivatestate(next_s, i))
-            for i in range(next_s.game_config.num_players)
+            for i in range(next_s.kernel.game_config.num_players)
         ]
         q_proxies = [
             r + v_proxies[i]

{graph_games_proto-0.3.1953.dist-info → graph_games_proto-0.3.1966.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: graph_games_proto
-Version: 0.3.1953
+Version: 0.3.1966
 Requires-Dist: multipledispatch==1.0.0
 Requires-Dist: pyrsistent==0.20.0
 Requires-Dist: numpy==2.2.4

{graph_games_proto-0.3.1953.dist-info → graph_games_proto-0.3.1966.dist-info}/RECORD

@@ -1,9 +1,9 @@
 graph_games_proto/__init__.py,sha256=_EVQR-51XehfH45XZlba1WPdx3omS3Gm1nTwrgGyn2Q,667
 graph_games_proto/all_types.py,sha256=IpbwftEcHS5Ewz-saFNk0lO9FvcbuHG36odRTayCXUk,54911
-graph_games_proto/fns.py,sha256=Y880m_lmU6FCvxx4zowDu9Lrgcco4pOdDYYYQXzrQNY,182121
+graph_games_proto/fns.py,sha256=XaDJPmMLioflSj00zzPXjdF1JfBh-hZB5dLO1OTn7lQ,182090
 graph_games_proto/main.py,sha256=fj2U7KcwrpZtuUhjOX5yVxY18LZvvsxDFYZ_S5mxe04,145
 graph_games_proto/state.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-graph_games_proto-0.3.1953.dist-info/METADATA,sha256=ZAxOkRoFWLDz0NzLq1q15j0-FWw_gYTHWiqVvOH_Is8,188
-graph_games_proto-0.3.1953.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-graph_games_proto-0.3.1953.dist-info/top_level.txt,sha256=-4QSrBMf_MM4BGsr2QXBpqDx8c8k_OPnzGyFjqjakes,18
-graph_games_proto-0.3.1953.dist-info/RECORD,,
+graph_games_proto-0.3.1966.dist-info/METADATA,sha256=4JWfsAdg8cjBPgPN1tFc6UuRWIMKSvKtceQmO5iRN4s,188
+graph_games_proto-0.3.1966.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+graph_games_proto-0.3.1966.dist-info/top_level.txt,sha256=-4QSrBMf_MM4BGsr2QXBpqDx8c8k_OPnzGyFjqjakes,18
+graph_games_proto-0.3.1966.dist-info/RECORD,,