Cleanup and refactor.

wingedsheep · May 19, 2020 · e43b607 · e43b607
1 parent 197c521
commit e43b607
Show file tree

Hide file tree

Showing 21 changed files with 182 additions and 368 deletions.
diff --git a/main/agent/__init__.py b/main/agent/__init__.py
diff --git a/main/agent/random_agent.py b/main/agent/random_agent.py
diff --git a/main/carcassonne_game.py b/main/carcassonne_game.py
@@ -9,13 +9,12 @@
 class CarcassonneGame:
 
     def __init__(self,
-                 players: object = 2,
-                 tile_sets: object = (TileSet.BASE, TileSet.THE_RIVER, TileSet.INNS_AND_CATHEDRALS)):
+                 players: int = 2,
+                 tile_sets: [TileSet] = (TileSet.BASE, TileSet.THE_RIVER, TileSet.INNS_AND_CATHEDRALS)):
         self.players = players
         self.tile_sets = tile_sets
         self.state: CarcassonneGameState = CarcassonneGameState(tile_sets=tile_sets, players=players)
         self.visualiser = CarcassonneVisualiser()
-        self.action_util = ActionUtil()
 
     def reset(self):
         self.state = CarcassonneGameState(tile_sets=self.tile_sets)

diff --git a/main/carcassonne_game_definition.py b/main/carcassonne_game_definition.py
diff --git a/main/carcassonne_game_player.py b/main/carcassonne_game_player.py
diff --git a/main/carcassonne_game_state.py b/main/carcassonne_game_state.py
@@ -4,26 +4,15 @@
 
 from main.objects.actions.tile_action import TileAction
 from main.objects.coordinate import Coordinate
+from main.objects.game_phase import GamePhase
 from main.tile_sets.base_deck import base_tile_counts, base_tiles
 from main.tile_sets.inns_and_cathedrals_deck import inns_and_cathedrals_tile_counts, inns_and_cathedrals_tiles
 from main.tile_sets.the_river_deck import the_river_tiles, the_river_tile_counts
-from main.objects.playing_position import PlayingPosition
 from main.objects.rotation import Rotation
 from main.objects.tile import Tile
 from main.tile_sets.tile_sets import TileSet
 
 
-class GamePhase(Enum):
-    TILES = "tiles"
-    MEEPLES = "meeples"
-
-    def to_json(self):
-        return self.value
-
-    def __str__(self):
-        return self.value
-
-
 class CarcassonneGameState:
 
     def __init__(

diff --git a/main/objects/game_phase.py b/main/objects/game_phase.py
@@ -0,0 +1,12 @@
+from enum import Enum
+
+
+class GamePhase(Enum):
+    TILES = "tiles"
+    MEEPLES = "meeples"
+
+    def to_json(self):
+        return self.value
+
+    def __str__(self):
+        return self.value
diff --git a/main/run_carcassonne_game_random.py b/main/run_carcassonne_game_random.py
diff --git a/main/utils/game_state_updater.py b/main/utils/game_state_updater.py
diff --git a/main/utils/meeple_util.py b/main/utils/meeple_util.py
@@ -22,13 +22,6 @@ def remove_meeples(game_state: CarcassonneGameState, meeples: [[MeeplePosition]]
             for meeple_position in meeple_positions:
                 MeepleUtil.remove_meeple(game_state, meeple_position, player)
 
-    # @staticmethod
-    # def remove_meeples(game_state: CarcassonneGameState, meeples: [CoordinateWithSide]):
-    #     for player in game_state.players:
-    #         for meeple_position in game_state.placed_meeples[player]:
-    #             if meeple_position.coordinate_with_side in meeples:
-    #                 MeepleUtil.remove_meeple(game_state, meeple_position, player)
-
     @staticmethod
     def remove_meeple(game_state: CarcassonneGameState, meeple_position: MeeplePosition, player: int):
         game_state.placed_meeples[player].remove(meeple_position)

diff --git a/main/utils/points_collector.py b/main/utils/points_collector.py
@@ -23,18 +23,14 @@
 
 class PointsCollector:
 
-    def __init__(self, city_util: CityUtil, road_util: RoadUtil, meeple_util: MeepleUtil):
-        self.city_util = city_util
-        self.road_util = road_util
-        self.meeple_util = meeple_util
-
-    def remove_meeples_and_collect_points(self, game_state: CarcassonneGameState, coordinate: Coordinate):
+    @classmethod
+    def remove_meeples_and_collect_points(cls, game_state: CarcassonneGameState, coordinate: Coordinate):
 
         # Points for finished cities
-        cities: [City] = self.city_util.find_cities(game_state=game_state, coordinate=coordinate)
+        cities: [City] = CityUtil.find_cities(game_state=game_state, coordinate=coordinate)
         for city in cities:
             if city.finished:
-                meeples: [[MeeplePosition]] = self.city_util.find_meeples(game_state=game_state, city=city)
+                meeples: [[MeeplePosition]] = CityUtil.find_meeples(game_state=game_state, city=city)
                 meeple_counts_per_player = PointsCollector.get_meeple_counts_per_player(meeples)
                 print("City finished. Meeples:", json.dumps(meeple_counts_per_player))
                 if sum(meeple_counts_per_player) == 0:
@@ -44,13 +40,13 @@ def remove_meeples_and_collect_points(self, game_state: CarcassonneGameState, co
                     points = PointsCollector.count_city_points(game_state=game_state, city=city)
                     print(points, "points for player", winning_player)
                     game_state.scores[winning_player] += points
-                self.meeple_util.remove_meeples(game_state=game_state, meeples=meeples)
+                MeepleUtil.remove_meeples(game_state=game_state, meeples=meeples)
 
         # Points for finished roads
-        roads: [Road] = self.road_util.find_roads(game_state=game_state, coordinate=coordinate)
+        roads: [Road] = RoadUtil.find_roads(game_state=game_state, coordinate=coordinate)
         for road in roads:
             if road.finished:
-                meeples: [[MeeplePosition]] = self.road_util.find_meeples(game_state=game_state, road=road)
+                meeples: [[MeeplePosition]] = RoadUtil.find_meeples(game_state=game_state, road=road)
                 meeple_counts_per_player = PointsCollector.get_meeple_counts_per_player(meeples)
                 print("Road finished. Meeples:", json.dumps(meeple_counts_per_player))
                 if sum(meeple_counts_per_player) == 0:
@@ -60,7 +56,7 @@ def remove_meeples_and_collect_points(self, game_state: CarcassonneGameState, co
                     points = PointsCollector.count_road_points(game_state=game_state, road=road)
                     print(points, "points for player", winning_player)
                     game_state.scores[winning_player] += points
-                self.meeple_util.remove_meeples(game_state=game_state, meeples=meeples)
+                MeepleUtil.remove_meeples(game_state=game_state, meeples=meeples)
 
         # Points for finished chapels
         for row in range(coordinate.row - 1, coordinate.row + 2):
@@ -72,7 +68,7 @@ def remove_meeples_and_collect_points(self, game_state: CarcassonneGameState, co
 
                 coordinate = Coordinate(row=row, column=column)
                 coordinate_with_side = CoordinateWithSide(coordinate=coordinate, side=Side.CENTER)
-                meeple_of_player = self.meeple_util.position_contains_meeple(game_state=game_state,
+                meeple_of_player = MeepleUtil.position_contains_meeple(game_state=game_state,
                                                                              coordinate_with_side=coordinate_with_side)
                 if tile.chapel_or_flowers and meeple_of_player is not None:
                     points = PointsCollector.chapel_or_flowers_points(game_state=game_state, coordinate=coordinate)
@@ -86,7 +82,7 @@ def remove_meeples_and_collect_points(self, game_state: CarcassonneGameState, co
                             meeples_per_player.append([])
                         meeples_per_player[meeple_of_player].append(coordinate_with_side)
 
-                        self.meeple_util.remove_meeples(game_state=game_state, meeples=meeples_per_player)
+                        MeepleUtil.remove_meeples(game_state=game_state, meeples=meeples_per_player)
 
     @staticmethod
     def get_winning_player(meeple_counts_per_player: [int]):
@@ -183,9 +179,9 @@ def count_final_scores(self, game_state: CarcassonneGameState):
                 terrrain_type: TerrainType = tile.get_type(meeple_position.coordinate_with_side.side)
 
                 if terrrain_type == TerrainType.CITY:
-                    city: City = self.city_util.find_city(game_state=game_state,
+                    city: City = CityUtil.find_city(game_state=game_state,
                                                           city_position=meeple_position.coordinate_with_side)
-                    meeples: [CoordinateWithSide] = self.city_util.find_meeples(game_state=game_state, city=city)
+                    meeples: [CoordinateWithSide] = CityUtil.find_meeples(game_state=game_state, city=city)
                     meeple_counts_per_player = self.get_meeple_counts_per_player(meeples)
                     print("Collecting points for unfinished city. Meeples:", json.dumps(meeple_counts_per_player))
                     winning_player = self.get_winning_player(meeple_counts_per_player)
@@ -194,21 +190,21 @@ def count_final_scores(self, game_state: CarcassonneGameState):
                         print(points, "points for player", player)
                         game_state.scores[winning_player] += points
 
-                    self.meeple_util.remove_meeples(game_state=game_state, meeples=meeples)
+                    MeepleUtil.remove_meeples(game_state=game_state, meeples=meeples)
                     continue
 
                 if terrrain_type == TerrainType.ROAD:
-                    road: [Road] = self.road_util.find_road(game_state=game_state,
+                    road: [Road] = RoadUtil.find_road(game_state=game_state,
                                                             road_position=meeple_position.coordinate_with_side)
-                    meeples: [CoordinateWithSide] = self.road_util.find_meeples(game_state=game_state, road=road)
+                    meeples: [CoordinateWithSide] = RoadUtil.find_meeples(game_state=game_state, road=road)
                     meeple_counts_per_player = self.get_meeple_counts_per_player(meeples)
                     print("Collecting points for unfinished road. Meeples:", json.dumps(meeple_counts_per_player))
                     winning_player = self.get_winning_player(meeple_counts_per_player)
                     if winning_player is not None:
                         points = self.count_road_points(game_state=game_state, road=road)
                         print(points, "points for player", player)
                         game_state.scores[winning_player] += points
-                    self.meeple_util.remove_meeples(game_state=game_state, meeples=meeples)
+                    MeepleUtil.remove_meeples(game_state=game_state, meeples=meeples)
                     continue
 
                 if terrrain_type == TerrainType.CHAPEL_OR_FLOWERS:
@@ -223,7 +219,7 @@ def count_final_scores(self, game_state: CarcassonneGameState):
                         meeples_per_player.append([])
                     meeples_per_player[player].append(meeple_position)
 
-                    self.meeple_util.remove_meeples(game_state=game_state, meeples=meeples_per_player)
+                    MeepleUtil.remove_meeples(game_state=game_state, meeples=meeples_per_player)
                     continue
 
                 if meeple_position.meeple_type == MeepleType.FARMER or meeple_position.meeple_type == MeepleType.BIG_FARMER:
@@ -236,7 +232,7 @@ def count_final_scores(self, game_state: CarcassonneGameState):
                         points = self.count_farm_points(game_state=game_state, farm=farm)
                         print(points, "points for player", winning_player)
                         game_state.scores[winning_player] += points
-                    self.meeple_util.remove_meeples(game_state=game_state, meeples=meeples)
+                    MeepleUtil.remove_meeples(game_state=game_state, meeples=meeples)
                     continue
 
                 print("Collecting points for unknown type", terrrain_type)