Catanatron Rust Rewrite

.github/workflows/build.yml

@@ -88,3 +88,41 @@ jobs:
         working-directory: ./ui
       - run: npm run build
         working-directory: ./ui
+
+  build-rust:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+      - name: Set up Rust
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable
+          profile: minimal
+          override: true
+
+      - name: Run `cargo fmt`
+        run: cargo fmt -- --check
+        working-directory: catanatron_rust
+      - name: Run `cargo clippy`
+        run: cargo clippy -- -D warnings
+        working-directory: catanatron_rust
+
+      - name: Run `cargo run`
+        run: cargo run
+        working-directory: catanatron_rust
+      - name: Run `cargo run --release`
+        run: cargo run --release
+        working-directory: catanatron_rust
+
+      - name: Run `cargo test`
+        run: cargo test --verbose
+        working-directory: catanatron_rust
+      - name: Run `cargo test --release`
+        run: cargo test --release --verbose
+        working-directory: catanatron_rust
+
+      - name: Run `cargo bench`
+        run: cargo bench
+        working-directory: catanatron_rust

catanatron_core/catanatron/game.py

@@ -10,7 +10,7 @@
 from catanatron.models.enums import Action, ActionPrompt, ActionType
 from catanatron.state import State, apply_action
 from catanatron.state_functions import player_key, player_has_rolled
-from catanatron.models.map import CatanMap
+from catanatron.models.map_instance import MapInstance
 from catanatron.models.player import Color, Player
 
 # To timeout RandomRobots from getting stuck...
@@ -92,7 +92,7 @@ def __init__(
         seed: Optional[int] = None,
         discard_limit: int = 7,
         vps_to_win: int = 10,
-        catan_map: Optional[CatanMap] = None,
+        map_instance: Optional[MapInstance] = None,
         initialize: bool = True,
     ):
         """Creates a game (doesn't run it).
@@ -102,7 +102,7 @@ def __init__(
             seed (int, optional): Random seed to use (for reproducing games). Defaults to None.
             discard_limit (int, optional): Discard limit to use. Defaults to 7.
             vps_to_win (int, optional): Victory Points needed to win. Defaults to 10.
-            catan_map (CatanMap, optional): Map to use. Defaults to None.
+            map_instance (MapInstance, optional): Map to use. Defaults to None.
             initialize (bool, optional): Whether to initialize. Defaults to True.
         """
         if initialize:
@@ -111,7 +111,7 @@ def __init__(
 
             self.id = str(uuid.uuid4())
             self.vps_to_win = vps_to_win
-            self.state = State(players, catan_map, discard_limit=discard_limit)
+            self.state = State(players, map_instance, discard_limit=discard_limit)
 
     def play(self, accumulators=[], decide_fn=None):
         """Executes game until a player wins or exceeded TURNS_LIMIT.

catanatron_core/catanatron/json.py

@@ -5,7 +5,7 @@
 import json
 from enum import Enum
 
-from catanatron.models.map import Water, Port, LandTile
+from catanatron.models.map_instance import Water, Port, LandTile
 from catanatron.game import Game
 from catanatron.models.player import Color
 from catanatron.models.enums import RESOURCES, Action, ActionType

catanatron_core/catanatron/models/actions.py

@@ -2,6 +2,7 @@
 Move-generation functions (these return a list of actions that can be taken 
 by current player). Main function is generate_playable_actions.
 """
+
 import operator as op
 from functools import reduce
 from typing import Any, Dict, List, Set, Tuple, Union
@@ -51,39 +52,7 @@ def generate_playable_actions(state) -> List[Action]:
     elif action_prompt == ActionPrompt.MOVE_ROBBER:
         return robber_possibilities(state, color)
     elif action_prompt == ActionPrompt.PLAY_TURN:
-        if state.is_road_building:
-            return road_building_possibilities(state, color, False)
-        actions = []
-        # Allow playing dev cards before and after rolling
-        if player_can_play_dev(state, color, "YEAR_OF_PLENTY"):
-            actions.extend(year_of_plenty_possibilities(color, state.resource_freqdeck))
-        if player_can_play_dev(state, color, "MONOPOLY"):
-            actions.extend(monopoly_possibilities(color))
-        if player_can_play_dev(state, color, "KNIGHT"):
-            actions.append(Action(color, ActionType.PLAY_KNIGHT_CARD, None))
-        if (
-            player_can_play_dev(state, color, "ROAD_BUILDING")
-            and len(road_building_possibilities(state, color, False)) > 0
-        ):
-            actions.append(Action(color, ActionType.PLAY_ROAD_BUILDING, None))
-        if not player_has_rolled(state, color):
-            actions.append(Action(color, ActionType.ROLL, None))
-        else:
-            actions.append(Action(color, ActionType.END_TURN, None))
-            actions.extend(road_building_possibilities(state, color))
-            actions.extend(settlement_possibilities(state, color))
-            actions.extend(city_possibilities(state, color))
-
-            can_buy_dev_card = (
-                player_can_afford_dev_card(state, color)
-                and len(state.development_listdeck) > 0
-            )
-            if can_buy_dev_card:
-                actions.append(Action(color, ActionType.BUY_DEVELOPMENT_CARD, None))
-
-            # Trade
-            actions.extend(maritime_trade_possibilities(state, color))
-        return actions
+        return play_turn_possibilities(state, color)
     elif action_prompt == ActionPrompt.DISCARD:
         return discard_possibilities(color)
     elif action_prompt == ActionPrompt.DECIDE_TRADE:
@@ -236,6 +205,42 @@ def robber_possibilities(state, color) -> List[Action]:
     return actions
 
 
+def play_turn_possibilities(state, color) -> List[Action]:
+    if state.is_road_building:
+        return road_building_possibilities(state, color, False)
+    actions = []
+    # Allow playing dev cards before and after rolling
+    if player_can_play_dev(state, color, "YEAR_OF_PLENTY"):
+        actions.extend(year_of_plenty_possibilities(color, state.resource_freqdeck))
+    if player_can_play_dev(state, color, "MONOPOLY"):
+        actions.extend(monopoly_possibilities(color))
+    if player_can_play_dev(state, color, "KNIGHT"):
+        actions.append(Action(color, ActionType.PLAY_KNIGHT_CARD, None))
+    if (
+        player_can_play_dev(state, color, "ROAD_BUILDING")
+        and len(road_building_possibilities(state, color, False)) > 0
+    ):
+        actions.append(Action(color, ActionType.PLAY_ROAD_BUILDING, None))
+    if not player_has_rolled(state, color):
+        actions.append(Action(color, ActionType.ROLL, None))
+    else:
+        actions.append(Action(color, ActionType.END_TURN, None))
+        actions.extend(road_building_possibilities(state, color))
+        actions.extend(settlement_possibilities(state, color))
+        actions.extend(city_possibilities(state, color))
+
+        can_buy_dev_card = (
+            player_can_afford_dev_card(state, color)
+            and len(state.development_listdeck) > 0
+        )
+        if can_buy_dev_card:
+            actions.append(Action(color, ActionType.BUY_DEVELOPMENT_CARD, None))
+
+        # Trade
+        actions.extend(maritime_trade_possibilities(state, color))
+    return actions
+
+
 def initial_road_possibilities(state, color) -> List[Action]:
     # Must be connected to last settlement
     last_settlement_node_id = state.buildings_by_color[color][SETTLEMENT][-1]

catanatron_core/catanatron/models/board.py

@@ -7,19 +7,19 @@
 import networkx as nx  # type: ignore
 
 from catanatron.models.player import Color
-from catanatron.models.map import (
+from catanatron.models.map_instance import (
     BASE_MAP_TEMPLATE,
     MINI_MAP_TEMPLATE,
     NUM_NODES,
-    CatanMap,
+    MapInstance,
     NodeId,
 )
 from catanatron.models.enums import FastBuildingType, SETTLEMENT, CITY
 
 
 # Used to find relationships between nodes and edges
-base_map = CatanMap.from_template(BASE_MAP_TEMPLATE)
-mini_map = CatanMap.from_template(MINI_MAP_TEMPLATE)
+base_map = MapInstance.from_template(BASE_MAP_TEMPLATE)
+mini_map = MapInstance.from_template(MINI_MAP_TEMPLATE)
 STATIC_GRAPH = nx.Graph()
 for tile in base_map.tiles.values():
     STATIC_GRAPH.add_nodes_from(tile.nodes.values())
@@ -54,12 +54,12 @@ class Board:
         robber_coordinate (Coordinate): Coordinate where robber is.
     """
 
-    def __init__(self, catan_map=None, initialize=True):
+    def __init__(self, map_instance=None, initialize=True):
         self.buildable_subgraph: Any = None
         self.buildable_edges_cache = {}
         self.player_port_resources_cache = {}
         if initialize:
-            self.map: CatanMap = catan_map or CatanMap.from_template(
+            self.map: MapInstance = map_instance or MapInstance.from_template(
                 BASE_MAP_TEMPLATE
             )  # Static State (no need to copy)