updates

Author: Nick Schaap

lib/experiments/win_stats.py

@@ -11,7 +11,7 @@
 logger = logging.getLogger(__name__)
 
 
-def win_stats(num_games: int):
+def win_stats(num_games: int) -> None:
     results: list[str] = []
     for i in range(1, num_games + 1):
         game = Game()

lib/gameplay/bank.py

@@ -1,6 +1,6 @@
 from lib.gameplay.pieces import ResourceCard, DevelopmentCard, CardType
 from lib.gameplay.hex import ResourceType
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Union
 import numpy as np
 import random
 
@@ -29,18 +29,31 @@ def get_cards(self, *resourceType: ResourceType) -> list[ResourceCard]:
         return [self.get_card(resource) for resource in resourceType]
 
     def get_card(self, resourceType: ResourceType) -> ResourceCard:
-        if resourceType == ResourceType.BRICK:
-            return self.brick_cards.pop()
-        if resourceType == ResourceType.WOOD:
-            return self.wood_cards.pop()
-        if resourceType == ResourceType.SHEEP:
-            return self.sheep_cards.pop()
-        if resourceType == ResourceType.WHEAT:
-            return self.wheat_cards.pop()
-        if resourceType == ResourceType.ORE:
-            return self.ore_cards.pop()
+        try:
+            if resourceType == ResourceType.BRICK:
+                return self.brick_cards.pop()
+            if resourceType == ResourceType.WOOD:
+                return self.wood_cards.pop()
+            if resourceType == ResourceType.SHEEP:
+                return self.sheep_cards.pop()
+            if resourceType == ResourceType.WHEAT:
+                return self.wheat_cards.pop()
+            if resourceType == ResourceType.ORE:
+                return self.ore_cards.pop()
+        except IndexError:
+            raise ValueError(f"Bank ran out of {resourceType}")
 
-    def get_dev_card(self) -> DevelopmentCard:
+    def get_dev_card(self, type: Union[CardType, None] = None) -> DevelopmentCard:
+        if type is not None:
+            # Find the next card of the passed in type
+            def is_type(card: DevelopmentCard) -> bool:
+                return card.get_type() == type
+
+            index = next((i for i, v in enumerate(self.dev_cards) if is_type(v)), None)
+            if index is None:
+                raise ValueError(f"No {type} cards in the bank")
+            return self.dev_cards.pop(index)
+        # Default to a random card
         index = np.random.randint(0, len(self.dev_cards))
         return self.dev_cards.pop(index)
 
@@ -59,6 +72,10 @@ def return_card(self, card: ResourceCard) -> None:
         if card.resourceType == ResourceType.ORE:
             self.ore_cards.append(card)
 
+    def return_cards(self, cards: list[ResourceCard]) -> None:
+        for card in cards:
+            self.return_card(card)
+
     def purchase_road(self, player: "Player"):
         cards = player.take_resources_from_player(
             [ResourceType.BRICK, ResourceType.WOOD]

lib/gameplay/game.py

@@ -57,8 +57,11 @@ def __init__(self, num_players: int = NUM_PLAYERS, game_delay: int = 0):
         self.board = Board()
         self.dice = Dice()
         self.players = self.setup_players(num_players)
+        self.num_players = num_players
         self.listeners = []
         self.game_delay = game_delay
+        self.player_with_largest_army: Union["Player", None] = None
+        self.player_with_longest_road: Union["Player", None] = None
 
     def listen(self, callback: Callable[[GameEvent], None]) -> None:
         self.listeners.append(callback)
@@ -93,21 +96,50 @@ def get_player_by_color(self, color: str) -> Player:
         raise ValueError("Player not found")
 
     def get_player_with_longest_road(self) -> Union[Player, None]:
-        player_with_longest_road = None
-        longest_road = 4
+        player_with_longest_road = self.player_with_longest_road
+
+        # Minimum length for longest road is greater than 4
+        longest_road = (
+            4
+            if player_with_longest_road is None
+            else self.board.longest_road(player_with_longest_road)
+        )
         for player in self.players:
+            if player == player_with_longest_road:
+                continue
             road_length = self.board.longest_road(player)
+            # Must be explicitly larger than the longest so far
             if road_length > longest_road:
                 player_with_longest_road = player
                 longest_road = road_length
-        return player_with_longest_road
+        self.player_with_longest_road = player_with_longest_road
+        return self.player_with_longest_road
+
+    def get_player_with_largest_army(self) -> Union[Player, None]:
+        player_with_largest_army = self.player_with_largest_army
+        # Minimum length for largest army is greater than 3
+        largest_army = (
+            2
+            if self.player_with_largest_army is None
+            else self.player_with_largest_army.largest_army_size()
+        )
+        for player in self.players:
+            if player == player_with_largest_army:
+                continue
+            army_size = player.largest_army_size()
+            if army_size > largest_army:
+                player_with_largest_army = player
+                largest_army = army_size
+        self.player_with_largest_army = player_with_largest_army
+        return self.player_with_largest_army
 
     def step(self):
         curr_player = self.get_current_player()
-
+        playerWithLargestArmy = self.get_player_with_largest_army()
+        playerWithLongestRoad = self.get_player_with_longest_road()
         for player in self.players:
             logger.info(
-                f"{player} has {player.points(self.players, self.get_player_with_longest_road())} points"
+                f"{player} has {player.points(playerWithLongestRoad, playerWithLargestArmy)} points"
             )
 
         logger.info(f"{curr_player}'s turn")
@@ -119,7 +151,7 @@ def step(self):
             for player in self.players:
                 if len(player.resources) > 7:
                     player.split_cards(self.bank)
-            curr_player.rob(self.board, self.bank)
+            curr_player.move_robber(self.board, self.bank)
         else:
             for player in self.players:
                 logger.info(f"{player} has {len(player.resources)} resources")
@@ -131,7 +163,7 @@ def step(self):
         if curr_player.points(self.players, self.get_player_with_longest_road()) >= 10:
             self.winning_player = curr_player
 
-        self.current_player = (self.current_player + 1) % NUM_PLAYERS
+        self.current_player = (self.current_player + 1) % self.num_players
         if self.game_delay > 0:
             time.sleep(self.game_delay / 1000)
 
@@ -142,9 +174,8 @@ def play(self):
 
         while self.winning_player is None:
             self.step()
-            # TODO: Implement end game condition
             round_num += 1
-            if round_num == 300:
+            if round_num == 100 * self.num_players:
                 self.winning_player = self.get_current_player()
                 logger.warning("Game ended in a draw")
         logger.info(f"{self.winning_player} wins in {round_num} rounds!")

lib/gameplay/hex.py

@@ -118,6 +118,23 @@ def attach_value(self, value: int):
             raise ValueError("Invalid value")
         self.value = value
 
+    def likelihood(self) -> float:
+        if self.value is None:
+            return 0
+        if self.value in [2, 12]:
+            return 0.03
+        if self.value in [3, 11]:
+            return 0.06
+        if self.value in [4, 10]:
+            return 0.08
+        if self.value in [5, 9]:
+            return 0.11
+        if self.value in [6, 8]:
+            return 0.14
+        if self.value == 7:
+            return 0.17
+        raise ValueError("Invalid value")
+
     def attach_edges(self, edges: list[Edge]):
         if len(edges) != 6:
             raise ValueError("Must have 6 edges")

lib/gameplay/player.py

@@ -9,6 +9,7 @@
 from lib.gameplay.bank import Bank
 from lib.gameplay.board import Board
 from functools import reduce
+from lib.gameplay.hex import Hex
 from typing import Union
 from lib.gameplay.hex import ResourceType
 import logging
@@ -57,25 +58,39 @@ def largest_army_size(self) -> int:
         )
 
     def points(
-        self, players: list["Player"], playerWithLongestRoad: Union["Player", None]
+        self,
+        playerWithLongestRoad: Union["Player", None],
+        playerWithLargestArmy: Union["Player", None],
     ) -> int:
-        # TODO: Add support for largest army and longest road
         return (
             reduce(lambda acc, curr: acc + curr.get_points(), self.cities, 0)
             + reduce(lambda acc, curr: acc + curr.get_points(), self.settlements, 0)
             + reduce(
                 lambda acc, curr: acc + curr.get_points(), self.development_cards, 0
             )
             + (2 if playerWithLongestRoad == self else 0)
+            + (2 if playerWithLargestArmy == self else 0)
         )
 
+    def give_development_card(self, card: DevelopmentCard) -> None:
+        self.development_cards.append(card)
+
     def get_active_settlements(self) -> list[Settlement]:
         return [
             settlement
             for settlement in self.settlements
             if settlement.vertex is not None
         ]
 
+    def num_active_settlements(self) -> int:
+        return len(self.get_active_settlements())
+
+    def get_active_cities(self) -> list[City]:
+        return [city for city in self.cities if city.vertex is not None]
+
+    def num_active_cities(self) -> int:
+        return len(self.get_active_cities())
+
     def get_unplaced_settlement(self) -> Union[Settlement, None]:
         for settlement in self.settlements:
             if settlement.position is None:
@@ -142,6 +157,9 @@ def take_resources_from_player(
                 raise ValueError("Player does not have required resources")
         return cards
 
+    def give_resource_to_player(self, card: ResourceCard) -> None:
+        self.resources.append(card)
+
     def resource_counts(self) -> dict[ResourceType, int]:
         counts = {resource: 0 for resource in ResourceType}
         for card in self.resources:
@@ -162,14 +180,11 @@ def can_build_city(self) -> bool:
         resource_counts = self.resource_counts()
         return (
             self.unplaced_city_count() > 0
-            and len(self.current_settlements()) > 0
+            and len(self.get_active_cities()) > 0
             and resource_counts[ResourceType.WHEAT] >= 2
             and resource_counts[ResourceType.ORE] >= 3
         )
 
-    def current_settlements(self) -> list[Settlement]:
-        return [s for s in self.settlements if s.position is not None]
-
     def can_build_road(self) -> bool:
         resource_counts = self.resource_counts()
         return (
@@ -178,11 +193,17 @@ def can_build_road(self) -> bool:
             and resource_counts[ResourceType.WOOD] >= 1
         )
 
-    def pop_least_valuable_resource(self) -> ResourceCard:
-        # TODO: Implement better logic for choosing which cards to return for manual mode
+    def pop_least_valuable_resource(self) -> Union[ResourceCard, None]:
         if len(self.resources) == 0:
-            raise ValueError("Player has no resources")
-        return self.resources.pop()
+            return None
+
+        resource_rankings = reversed(self.rank_resource_values())
+        resource_counts = self.resource_counts()
+
+        for resource in resource_rankings:
+            if resource_counts[resource] > 0:
+                [card] = self.take_resources_from_player([resource])
+                return card
 
     def split_cards(self, bank: Bank):
         if len(self.resources) > 7:
@@ -193,16 +214,9 @@ def split_cards(self, bank: Bank):
     def play_development_card(self, card: DevelopmentCard):
         pass
 
-    def trade(
-        self, other: "Player", offer: list[ResourceCard], request: list[ResourceCard]
-    ):
-        pass
-
-    def trade_bank(self, offer: list[ResourceCard], request: list[ResourceCard]):
-        pass
-
-    def trade_port(self, offer: list[ResourceCard], request: list[ResourceCard]):
-        pass
+    def trade_bank(self, offer: list[ResourceType], request: ResourceType, bank: Bank):
+        bank.return_cards(self.take_resources_from_player(offer))
+        self.resources.append(bank.get_card(request))
 
     def build_settlement(self, board: Board, vertexLoc: int, bank: Bank):
         bank.purchase_settlement(self)
@@ -219,10 +233,35 @@ def build_road(self, board: Board, edgeLoc: int, bank: Bank):
     def buy_development_card(self, bank: Bank):
         bank.purchase_dev_card(self)
 
-    def rob(self, board: Board, bank: Bank):
-        random_hex = random.choice(board.get_hexes())
-        board.move_robber(random_hex.id)
-        # TODO: Implement logic for what happens when robber moves to a hex with a player's settlement
+    def get_hex_to_rob(self, board: Board, bank: Bank) -> Hex:
+        return random.choice(board.get_hexes())
+
+    def choose_player_to_rob(
+        self, players: list["Player"], board: Board, bank: Bank
+    ) -> Union["Player", None]:
+        return None if len(players) == 0 else players[0]
+
+    def rank_resource_values(self) -> list[ResourceType]:
+        """Returns resources valuable to the player from most valuable to least valuable"""
+        return [
+            ResourceType.ORE,
+            ResourceType.BRICK,
+            ResourceType.SHEEP,
+            ResourceType.WHEAT,
+            ResourceType.WOOD,
+        ]
+
+    def rob(self) -> Union[ResourceCard, None]:
+        return self.pop_least_valuable_resource()
+
+    def move_robber(self, board: Board, bank: Bank) -> None:
+        hex = self.get_hex_to_rob(board, bank)
+        board.move_robber(hex.id)
+
+        settled_players = hex.get_settled_players()
+        player_to_rob = self.choose_player_to_rob(settled_players, board, bank)
+        if player_to_rob is not None:
+            player_to_rob.rob()
 
     def take_turn(self, board: Board, bank: Bank, players: list["Player"]):
         pass