graph-games-proto 0.3.2031__py3-none-any.whl → 0.3.2036__py3-none-any.whl

graph_games_proto/fns.py

@@ -2090,10 +2090,6 @@ class State(PClass):
     player_scores_3 = field(type=list)  # List[PlayerScore2]
     winners = field(type=list)  # List[int]
 
-    player_graphs = field(type=list)  # List[PlayerGraph]
-    player_scores = field(type=list)  # List[PlayerScore2]
-    bonus_statuses = field(type=list)  # List[BonusStatus]
-
     def __todict__(self):
         return {
             "kernel": self.kernel.__todict__(),
@@ -2562,24 +2558,15 @@ def getsettingvalue(s, setting_name):
 
 @dispatch(GameConfig)
 def getinitialstate(game_config):
-    fig = game_config.fig
     rng = getrng(game_config.seed)
-    unit_deck = shuffledeck(gettotaldeckcards(fig), rng)
-    route_deck_idx, unit_deck_idx = 0, 0
-    unit_deck_idx += 5
-    board_config = fig.board_config
-    deck_0_rng = getrng(1234321)
-    deck_1_rng = getrng(8738758)
+    board_config = game_config.fig.board_config
     nodes = get_nodes(board_config)
 
-    pieceuuid2piece = {}
     piles = []
     for piece_template in board_config.piece_templates:
         if piece_template.has_player:
             for player_idx in range(game_config.num_players):
                 pieces = generate_pieces(piece_template, player_idx)
-                for piece in pieces:
-                    pieceuuid2piece[piece.uuid] = piece
                 pile = Pile(
                     player_idx=player_idx,
                     num_pieces=piece_template.quantity,
@@ -2600,25 +2587,22 @@ def getinitialstate(game_config):
         )
         decks.append(deck_obj)
 
-    nodeuuid2idx = {node.uuid: idx for idx, node in enumerate(board_config.points)}
-    edges = get_edges(rng, board_config, nodeuuid2idx)
-
-    bonuses = game_config.fig.board_config.bonuses
-    bonus_statuses = [
-        BonusStatus(
-            bonus_uuid=bonus.uuid, 
-            winners=[],
-            player_statuses=[
-                BonusPlayerStatus(
-                    player_idx=player_idx,
-                    score=0,
-                    longest_trail=None,
-                )
-                for player_idx in range(game_config.num_players)
-            ]
-        ) 
-        for bonus in bonuses
-    ]
+    # bonuses = game_config.fig.board_config.bonuses
+    # bonus_statuses = [
+    #     BonusStatus(
+    #         bonus_uuid=bonus.uuid, 
+    #         winners=[],
+    #         player_statuses=[
+    #             BonusPlayerStatus(
+    #                 player_idx=player_idx,
+    #                 score=0,
+    #                 longest_trail=None,
+    #             )
+    #             for player_idx in range(game_config.num_players)
+    #         ]
+    #     ) 
+    #     for bonus in bonuses
+    # ]
 
     # state = State(
     #     bonus_statuses=bonus_statuses,
@@ -2642,6 +2626,9 @@ def getinitialstate(game_config):
     #     last_to_play=None,
     #     winners=[],
     # )
+
+    nodeuuid2idx = {node.uuid: idx for idx, node in enumerate(board_config.points)}
+    edges = get_edges(rng, board_config, nodeuuid2idx)
     
     kernel = init_state_kernel(
         rng=rng,
@@ -2661,15 +2648,23 @@ def getinitialstate(game_config):
 
     kernel = run_kernel_hooks(kernel, INITIALIZATION_HOOKS, True)
 
+    return init_memoized_state(kernel)
+
+
+@dispatch(StateKernel)
+def init_memoized_state(kernel):
     state = State(
         kernel=kernel,
         legal_actions_3=calc_legal_actions3(kernel),
         bonus_statuses_3=calc_bonus_statuses3(kernel),
     )
-    
+    return memoize_state(state)
+
+
+@dispatch(State)
+def memoize_state(state):
     state = state.set(player_scores_3=calc_player_scores3(state))
     state = state.set(winners=calc_winners_3(state))
-
     return state
 
 
@@ -2864,16 +2859,17 @@ def handle_last_to_play(game):
         for player in game.players:
             if len(player.pieces) < 3:
                 return game.set(last_to_play=player.idx)
-    elif game.last_to_play == game.history[-1].legal_action.player_idx:
+    elif game.last_to_play == game.kernel.history[-1].legal_action.player_idx:
         if not game.legal_actions_3:
             return game.set(terminal=True)
     return game
 
 
-def getfinalscores(game):
+@dispatch(State)
+def getfinalscores(state):
     return [
-        getpublicplayerscore(game, game.player_scores[player_idx]).total
-        for player_idx in range(len(game.players))
+        getpublicplayerscore(state, state.player_scores_3[player_idx]).total
+        for player_idx in range(len(state.kernel.players))
     ]
 
 
@@ -3170,14 +3166,15 @@ def handle_draw_discard_action(kernel, action):
     )
 
 
-def get_follow_up_draw_legal_actions(game, action):
+@dispatch(State, Action2)
+def get_follow_up_draw_legal_actions(state, action):
     to_return = []
     legal_action = action.legal_action
-    if len(game.history) >= 2:
-        last_action = game.history[-2]
+    if len(state.kernel.history) >= 2:
+        last_action = state.kernel.history[-2]
         if (last_action.legal_action.player_idx != legal_action.player_idx) or last_action.legal_action.name == "INITIAL-GOAL-KEEP":
             
-            if len(game.decks[0].facedown_stack) >= 1:
+            if len(state.kernel.decks[0].facedown_stack) >= 1:
                 to_return.append(
                     LegalAction(
                         auto_preferred=True,
@@ -3185,7 +3182,7 @@ def get_follow_up_draw_legal_actions(game, action):
                         name="DRAW",
                         instruction="draw a unit",
                         allotted_seconds=DEFAULT_ALLOTTED_SECONDS,
-                        allotted_since_action_idx=(len(game.history) - 1),
+                        allotted_since_action_idx=(len(state.kernel.history) - 1),
                         draw=LegalActionDraw(
                             deck_idx=0,
                             quantity=1,
@@ -3193,16 +3190,16 @@ def get_follow_up_draw_legal_actions(game, action):
                     )
                 )
             
-            for card_uuid in game.decks[0].faceup_spots:
+            for card_uuid in state.kernel.decks[0].faceup_spots:
                 if card_uuid:
-                    if not game.carduuid2card[card_uuid].is_wild:
+                    if not state.kernel.carduuid2card[card_uuid].is_wild:
                         to_return.append(
                             LegalAction(
                                 player_idx=legal_action.player_idx,
                                 name="FACEUP-DRAW",
                                 instruction="draw a faceup unit",
                                 allotted_seconds=DEFAULT_ALLOTTED_SECONDS,
-                                allotted_since_action_idx=(len(game.history) - 1),
+                                allotted_since_action_idx=(len(state.kernel.history) - 1),
                                 faceup_draw=LegalActionFaceupDraw(
                                     deck_idx=0,
                                     card_uuid=card_uuid,
@@ -4374,46 +4371,14 @@ def get_next_player_shuffled_idx(state_kernel, last_action):
     return next_player_shuffled_idx
 
 
-def init_state(kernel):
-
-    legal_actions_3 = calc_legal_actions3(kernel)
-
-    return State(
-        kernel=kernel,
-        rng=kernel.rng,
-        game_config=kernel.game_config,
-        edges=kernel.edges,
-        decks=kernel.decks,
-        piles=kernel.piles,
-        players=kernel.players,
-        player_idxs=kernel.player_idxs,
-        history=kernel.history,
-        player_scores=kernel.player_scores,
-        is_terminal=False,
-        idx2path=kernel.idx2path,
-        carduuid2card=kernel.carduuid2card,
-        legal_actions_3=legal_actions_3,
-    )
-
-
 def getnextstate2(s, a, log=False):
     is_legal, reason = isactionlegal2(s, a)
     if not is_legal:
         raise ValueError(f"Action is not legal: {a}. Reason: {reason}")
-    
     kernel = s.kernel
     kernel = run_state_action_hooks(kernel, a, AFTER_ACCEPT_ACTION_HOOKS, log)
     kernel = run_state_action_hooks(kernel, a, HANDLE_ACTION_HOOKS, log)
-
-    state = State(
-        kernel=kernel,
-        legal_actions_3=calc_legal_actions3(kernel),
-        bonus_statuses_3=calc_bonus_statuses3(kernel),
-    )
-    state = state.set(player_scores_3=calc_player_scores3(state))
-    state = state.set(winners=calc_winners_3(state))
-
-    return state
+    return init_memoized_state(kernel)
 
 
 def getpublicplayerscore(s, player_score):
@@ -4468,6 +4433,7 @@ def get_player_max_allotted_time(s, player_idx):
     return None
 
 
+@dispatch(State, AllottedTime)
 def get_deadline(s, max_allotted_time):
     if not max_allotted_time:
         return None
@@ -4478,7 +4444,7 @@ def get_deadline(s, max_allotted_time):
             "%Y-%m-%d %H:%M:%S"
         )
     else:
-        since_action = s.history[since_action_idx]
+        since_action = s.kernel.history[since_action_idx]
         submitted_at = since_action.submitted_at
         allotted_since = datetime.strptime(submitted_at, "%Y-%m-%d %H:%M:%S")
     deadline = allotted_since + timedelta(seconds=max_allotted_time.seconds)
@@ -4500,7 +4466,7 @@ def get_deadlines(s):
 
 
 def get_public_player_scores(s):
-    return [getpublicplayerscore(s, player_score) for player_score in s.player_scores]
+    return [getpublicplayerscore(s, player_score) for player_score in s.player_scores_3]
 
 
 # deadlines = field(type=list)  # List[RemainingAllottedTime|None]
@@ -4532,8 +4498,9 @@ def get_public_player_scores(s):
 # goal_completions = field(type=list, initial=[])  # List[GoalCompletion]
 
 
+@dispatch(State)
 def get_public_history(s):
-    return [action.get_public(s) for action in s.history]
+    return [action.get_public(s) for action in s.kernel.history]
 
 
 def imagine_history(public_state, private_state):
@@ -4553,19 +4520,23 @@ def imagine_decks(public_state, private_state):
 
 
 def imagine_state(public_state, private_state):
+    game_config = public_state.game_config
     imagined_kernel = init_state_kernel(
         rng=random.Random(),
-        game_config=public_state.game_config,
-        player_idxs=public_state.player_idxs,
-        piles=public_state.piles,
+        game_config=game_config,
         edges=public_state.edges,
         nodes=public_state.nodes,
+        piles=public_state.piles,
         decks=imagine_decks(public_state, private_state),
         players=imagine_players(public_state, private_state),
+        player_idxs=public_state.player_idxs,
         history=imagine_history(public_state, private_state),
         player_scores=imagine_player_scores(public_state, private_state),
+        starting_decks=[Deck.__fromdict__(x.__todict__()) for x in decks],
+        starting_piles=[Pile.__fromdict__(x.__todict__()) for x in public_state.piles],
+        goals=game_config.fig.board_config.goals,
     )
-    return init_state(imagined_kernel) 
+    return init_memoized_state(imagined_kernel)
 
 
 def isterminal(s):
@@ -5265,9 +5236,9 @@ def json2rng(json_str):
 @dispatch(State, int)
 def getprivatestate(s, player_idx):
     return PrivateState(
-        my_history=[a for a in s.history if a.legal_action.player_idx == player_idx],
-        player_score=getprivateplayerscore(s, s.player_scores[player_idx]),
-        player=s.players[player_idx],
+        my_history=[a for a in s.kernel.history if a.legal_action.player_idx == player_idx],
+        player_score=getprivateplayerscore(s, s.player_scores_3[player_idx]),
+        player=s.kernel.players[player_idx],
         legal_actions_3 = get_legal_actions3(s, player_idx),
         goal_completions=get_goal_completions(s, player_idx),
     )

{graph_games_proto-0.3.2031.dist-info → graph_games_proto-0.3.2036.dist-info}/METADATA

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

{graph_games_proto-0.3.2031.dist-info → graph_games_proto-0.3.2036.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=f3K8SmCxm0KTxHcsfOPI0o-JlRJv67COHyrIY1BC_FM,194428
+graph_games_proto/fns.py,sha256=rWENIi9bL6YymSD7-1Z6VRl2E_nkvRR8cWDv7lQFaw0,193756
 graph_games_proto/main.py,sha256=fj2U7KcwrpZtuUhjOX5yVxY18LZvvsxDFYZ_S5mxe04,145
 graph_games_proto/state.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-graph_games_proto-0.3.2031.dist-info/METADATA,sha256=d1I2BAoSsTLpv8cuwnU4tKlzPnvkLv5Fh0cce13XV4E,188
-graph_games_proto-0.3.2031.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-graph_games_proto-0.3.2031.dist-info/top_level.txt,sha256=-4QSrBMf_MM4BGsr2QXBpqDx8c8k_OPnzGyFjqjakes,18
-graph_games_proto-0.3.2031.dist-info/RECORD,,
+graph_games_proto-0.3.2036.dist-info/METADATA,sha256=YVBvzZp03PYPkKCWT2cQ3K81aTFN5U48ueJvHFuZ4jg,188
+graph_games_proto-0.3.2036.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+graph_games_proto-0.3.2036.dist-info/top_level.txt,sha256=-4QSrBMf_MM4BGsr2QXBpqDx8c8k_OPnzGyFjqjakes,18
+graph_games_proto-0.3.2036.dist-info/RECORD,,