graph-games-proto 0.3.2112__py3-none-any.whl → 0.3.2113__py3-none-any.whl

graph_games_proto/fns.py

@@ -14,6 +14,7 @@ import numpy as np
 from functools import cmp_to_key
 from itertools import combinations as itertools_combinations, chain
 from collections import deque
+import copy
 
 DEFAULT_ALLOTTED_SECONDS = 12
 INITIAL_ALLOTTED_SECONDS = 22
@@ -1025,12 +1026,14 @@ class PublicPlayer(PClass):
     idx = field(type=int)
     pieces = field(type=list)  # List[Piece]
     deck_counts = field(type=list)
+    discard_deck_counts = field(type=list)
     piece_template_counts = field(type=list)
     def __todict__(self):
         return {
             "idx": self.idx,
             "pieces": self.pieces,
             "deck_counts": list(self.deck_counts),
+            "discard_deck_counts": list(self.discard_deck_counts),
             "piece_template_counts": list(self.piece_template_counts),
         }
     @staticmethod
@@ -1039,6 +1042,7 @@ class PublicPlayer(PClass):
             idx=d["idx"],
             pieces=d["pieces"],
             deck_counts=list(d["deck_counts"]),
+            discard_deck_counts=list(d["discard_deck_counts"]),
             piece_template_counts=list(d["piece_template_counts"]),
         )
 
@@ -1065,16 +1069,6 @@ class Player(PClass):
         )
 
 
-@dispatch(PublicPlayer)
-def imagine_player(public_player) -> Player:
-    return Player(
-        idx=public_player.idx,
-        pieces=public_player.pieces,
-        cards=[],
-        discard_tray=[],
-    )
-
-
 class GoalCompletion(PClass):
     goal_uuid = field(type=str)
     complete = field(type=bool, initial=False)
@@ -1190,19 +1184,6 @@ class PublicDeck(PClass):
             discard_len=d["discard_len"],
             faceup_spots=d["faceup_spots"],
         )
-
-
-class ActionKeepOptional(PClass):
-    card_uuids = field(type=list)  # List[int]
-    def __todict__(self):
-        return {
-            "card_uuids": self.card_uuids,
-        }
-    @staticmethod
-    def __fromdict__(d):
-        return ActionKeepOptional(
-            card_uuids=d["card_uuids"]
-        )
     
 
 class LegalActionKeep(PClass):
@@ -1572,19 +1553,19 @@ class PublicActionDiscard(PClass):
 
 
 class ActionDiscard(PClass):
-    card_uuids = field(type=list)  # List[int]
+    discard_tray_idxs = field(type=list)  # List[int]
     def get_public(self, state):
         return PublicActionDiscard(
-            deck_idxs=[state.kernel.carduuid2deckidx[card_uuid] for card_uuid in self.card_uuids]
+            deck_idxs=[0 for card_idx in self.discard_tray_idxs] # TODO: fix this
         )
     def __todict__(self):
         return {
-            "card_uuids": self.card_uuids,
+            "discard_tray_idxs": self.discard_tray_idxs,
         }
     @staticmethod
     def __fromdict__(d):
         return ActionDiscard(
-            card_uuids=d["card_uuids"]
+            discard_tray_idxs=d["discard_tray_idxs"]
         )
 
 
@@ -1602,19 +1583,19 @@ class PublicActionKeep(PClass):
 
 
 class ActionKeep(PClass):
-    card_uuids = field(type=list)  # List[int])
+    discard_tray_idxs = field(type=list)  # List[int]
     def get_public(self, state):
         return PublicActionKeep(
-            deck_idxs=[state.kernel.carduuid2deckidx[card_uuid] for card_uuid in self.card_uuids]
+            deck_idxs=[0 for card_idx in self.discard_tray_idxs] # TODO: fix this
         )
     def __todict__(self):
         return {
-            "card_uuids": self.card_uuids,
+            "discard_tray_idxs": self.discard_tray_idxs,
         }
     @staticmethod
     def __fromdict__(d):
         return ActionKeep(
-            card_uuids=d["card_uuids"]
+            discard_tray_idxs=d["discard_tray_idxs"]
         )
 
 
@@ -1725,9 +1706,7 @@ class Deck(PClass):
     facedown_stack = field(type=(CardStack, type(None)), initial=None)
     facedown_spread = field(type=(CardSpread, type(None)), initial=None)
     discard_faceup_stack = field(type=(CardStack, type(None)), initial=None)
-    discard_faceup_spread = field(type=(CardSpread, type(None)), initial=None)
     discard_facedown_stack = field(type=(CardStack, type(None)), initial=None)
-    discard_facedown_spread = field(type=(CardSpread, type(None)), initial=None)
     def __todict__(self):
         return {
             "idx": self.idx,
@@ -1737,9 +1716,7 @@ class Deck(PClass):
             "facedown_stack": self.facedown_stack.__todict__() if self.facedown_stack else None,
             "facedown_spread": self.facedown_spread.__todict__() if self.facedown_spread else None,
             "discard_faceup_stack": self.discard_faceup_stack.__todict__() if self.discard_faceup_stack else None,
-            "discard_faceup_spread": self.discard_faceup_spread.__todict__() if self.discard_faceup_spread else None,
             "discard_facedown_stack": self.discard_facedown_stack.__todict__() if self.discard_facedown_stack else None,
-            "discard_facedown_spread": self.discard_facedown_spread.__todict__() if self.discard_facedown_spread else None,
         }
     @staticmethod
     def __fromdict__(d):
@@ -1751,9 +1728,7 @@ class Deck(PClass):
             facedown_stack=CardStack.__fromdict__(d["facedown_stack"]) if d.get("facedown_stack") else None,
             facedown_spread=CardSpread.__fromdict__(d["facedown_spread"]) if d.get("facedown_spread") else None,
             discard_faceup_stack=CardStack.__fromdict__(d["discard_faceup_stack"]) if d.get("discard_faceup_stack") else None,
-            discard_faceup_spread=CardSpread.__fromdict__(d["discard_faceup_spread"]) if d.get("discard_faceup_spread") else None,
             discard_facedown_stack=CardStack.__fromdict__(d["discard_facedown_stack"]) if d.get("discard_facedown_stack") else None,
-            discard_facedown_spread=CardSpread.__fromdict__(d["discard_facedown_spread"]) if d.get("discard_facedown_spread") else None,
         )
 
 
@@ -3797,11 +3772,15 @@ def handle_keep_action(kernel, action):
     player = kernel.players[action.legal_action.player_idx]
     if not player:
         return kernel
-
-    # Keep the specified cards in the discard tray
-    kept_cards = [card_uuid for card_uuid in player.discard_tray if card_uuid in action.keep.card_uuids]
-    non_kept_cards = [card_uuid for card_uuid in player.discard_tray if card_uuid not in action.keep.card_uuids]
-
+    
+    kept_cards = []
+    non_kept_cards = []
+    discard_tray_idxs = action.keep.discard_tray_idxs
+    for i, card_uuid in enumerate(player.discard_tray):
+        if i in discard_tray_idxs:
+            kept_cards.append(card_uuid)
+        else:
+            non_kept_cards.append(card_uuid)
 
     # Discard the non-kept cards to the deck's discard pile
     deck.discard_faceup_stack.cards.extend(non_kept_cards)
@@ -3838,9 +3817,14 @@ def handle_discard_action(kernel, action):
     if not player:
         return kernel
 
-    # Keep the specified cards in the discard tray
-    non_kept_cards = [card_uuid for card_uuid in player.discard_tray if card_uuid in action.discard.card_uuids]
-    kept_cards = [card_uuid for card_uuid in player.discard_tray if card_uuid not in action.discard.card_uuids]
+    non_kept_cards = []
+    kept_cards = []
+    discard_tray_idxs = action.discard.discard_tray_idxs
+    for i, card_uuid in enumerate(player.discard_tray):
+        if i in discard_tray_idxs:
+            non_kept_cards.append(card_uuid)
+        else:
+            kept_cards.append(card_uuid)
 
     print("****************************** handle_discard_action 5", kept_cards)
     print("****************************** handle_discard_action 6", non_kept_cards)
@@ -4670,24 +4654,97 @@ def get_public_player_scores(s):
 # goal_completions = field(type=list, initial=[])  # List[GoalCompletion]
 
 
-@dispatch(State)
-def get_public_history(s):
+def get_public_history(s: State):
     return [action.get_public(s) for action in s.kernel.history]
 
 
-@dispatch(PlayerState)
-def imagine_history(ps) -> list[Action2]:
+def get_candidate_decks(ps: PlayerState) -> List[CandidateDeck]:
     pass
 
 
-@dispatch(PlayerState)
-def imagine_players(ps) -> list[Player]:
-    pass
+def imagine_player(p_idx: int, ps: PlayerState, candidate_decks: List[CandidateDeck]) -> Player:
+    if ps.private.player.idx ===p_idx:
+        return ps.private.player
+    public_player = ps.public.players[p_idx]
+    cards = []
+    for deck_idx, count in enumerate(public_player.deck_counts):
+        candidate_deck = candidate_decks[deck_idx]
+        for _ in range(count):
+            cards.append(candidate_deck.candidates.pop())
+    discard_tray = []
+    for deck_idx, count in enumerate(public_player.discard_deck_counts):
+        candidate_deck = candidate_decks[deck_idx]
+        for _ in range(count):
+            discard_tray.append(candidate_deck.candidates.pop())
+    return Player(
+        idx=p_idx,
+        pieces=copy.deepcopy(public_player.pieces),
+        cards=cards,
+        discard_tray=discard_tray,
+    )
 
 
-@dispatch(PlayerState)
-def imagine_decks(ps) -> list[Deck]:
-    pass
+def imagine_players(ps: PlayerState, candidate_decks: List[CandidateDeck]) -> List[Player]:
+    imagined = [
+        imagine_player(p_idx, ps, candidate_decks)
+        for p_idx in range(len(ps.public.players))
+    ]
+    return imagined
+
+
+def imagine_decks(ps: PlayerState, candidate_decks: List[CandidateDeck]) -> List[Deck]:
+    public = ps.public
+    imagined = [
+        imagine_deck(public_deck, candidate_deck)
+        for public_deck in public.decks
+    ]
+    return imagined
+
+
+def imagine_deck(public_deck: PublicDeck, candidate_deck: CandidateDeck) -> Deck:
+    return Deck(
+        idx=public_deck.idx,
+        uuid=public_deck.uuid,
+        faceup_stack=(
+            copy.deepcopy(public_deck.faceup_stack)
+            if public_deck.faceup_stack else None
+        ),
+        faceup_spread=(
+            copy.deepcopy(public_deck.faceup_spread)
+            if public_deck.faceup_spread else None
+        ),
+        facedown_stack=(
+            CardStack(
+                hidden=True, 
+                cards=[
+                    candidate_deck.candidates.pop() for _ in range(public_deck.facedown_stack_len)
+                ]
+            )
+            if public_deck.facedown_stack_len > 0 else None
+        ),
+        facedown_spread=(
+            CardSpread(
+                hidden=True,
+                spots=[
+                    candidate_deck.candidates.pop() for _ in range(len(public_deck.facedown_spread_len))
+                ]
+            )
+            if public_deck.facedown_spread_len > 0 else None
+        ),
+        discard_faceup_stack=(
+            copy.deepcopy(public_deck.discard_faceup_stack)
+            if public_deck.discard_faceup_stack else None
+        ),
+        discard_facedown_stack=(
+            CardStack(
+                hidden=True,
+                cards=[
+                    candidate_deck.candidates.pop() for _ in range(public_deck.discard_facedown_stack_len)
+                ]
+            )
+            if public_deck.discard_facedown_stack_len > 0 else None
+        ),
+    )
 
 
 @dispatch(PlayerState)
@@ -4695,7 +4752,9 @@ def imagine_state(ps):
     public = ps.public
     game_config = public.game_config
 
-    # candidates = get_candidates(ps)
+    candidate_decks = get_candadate_decks(ps)
+    imagined_decks = imagine_decks(ps, candidate_decks)
+    imagined_players = imagine_players(ps, candidate_decks)
 
     imagined_kernel = init_state_kernel(
         GameConfig(
@@ -4709,9 +4768,9 @@ def imagine_state(ps):
         nodes=public.nodes,
         piles=public.piles,
         player_idxs=public.player_idxs,
-        decks=imagine_decks(ps),
-        players=imagine_players(ps),
-        history=imagine_history(ps),
+        decks=imagined_decks,
+        players=imagined_players,
+        history=copy.deepcopy(public.history),
     )
     return init_memoized_state(imagined_kernel)
 
@@ -4810,6 +4869,9 @@ def getpublicplayer(s, p):
     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
+    discard_deck_counts = [0 for _ in s.kernel.game_config.fig.board_config.deks]
+    for card in p.discard_tray:
+        discard_deck_counts[s.kernel.carduuid2card[card].deck_idx] += 1
     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.kernel.pieceuuid2piece[piece_uuid].piece_template_idx] += 1

{graph_games_proto-0.3.2112.dist-info → graph_games_proto-0.3.2113.dist-info}/METADATA

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

{graph_games_proto-0.3.2112.dist-info → graph_games_proto-0.3.2113.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=eB_LHgPS8PDOZ2dqre7kq7ih3Jo-WMCeHpZqVlssh_w,202857
+graph_games_proto/fns.py,sha256=t0ghADefUKH3eq4SjRPeuQ-fxQxz4HvuioYrPzBsAqU,204955
 graph_games_proto/main.py,sha256=fj2U7KcwrpZtuUhjOX5yVxY18LZvvsxDFYZ_S5mxe04,145
 graph_games_proto/state.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-graph_games_proto-0.3.2112.dist-info/METADATA,sha256=WiE5jWV3A7fznBTwPKfZ5PQY-_a69TLoK-kBjCUK38k,188
-graph_games_proto-0.3.2112.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-graph_games_proto-0.3.2112.dist-info/top_level.txt,sha256=-4QSrBMf_MM4BGsr2QXBpqDx8c8k_OPnzGyFjqjakes,18
-graph_games_proto-0.3.2112.dist-info/RECORD,,
+graph_games_proto-0.3.2113.dist-info/METADATA,sha256=hRb9YGXOkZ1D0j0Ix5Z8III2hBXE7_ShDdGUPS-SBu8,188
+graph_games_proto-0.3.2113.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+graph_games_proto-0.3.2113.dist-info/top_level.txt,sha256=-4QSrBMf_MM4BGsr2QXBpqDx8c8k_OPnzGyFjqjakes,18
+graph_games_proto-0.3.2113.dist-info/RECORD,,