GH-2: Added old work starting to implement computer players.

Author: ben-ryder

project/game/breadth_search.py

@@ -0,0 +1,69 @@
+# Ben-Ryder 2019
+
+"""
+Currently not true Breadth First Search Algorithm. It will not return a path to the target. Currently it can use a
+breadth first style search to find the nearest occurrence of a value in a 2d-array grid based on a start position.
+"""
+
+
+class BreadthSearch:
+    def __init__(self, grid):
+        self.grid = grid
+        self.size = [len(self.grid), len(self.grid[0])]
+
+    def get_value(self, location):
+        return self.grid[location[0]][location[1]]
+
+    def get_nearest(self, position, target_value):
+        open_queue = [position]
+        closed_queue = []
+
+        while len(open_queue) > 0:
+            current_location = open_queue[0]
+
+            # See if current location is equal to the target value
+            if self.get_value(current_location) == target_value and current_location != position:
+                return current_location
+
+            # Add remaining neighbours to queue
+            neighbours = self.get_neighbours(current_location)
+            for location in neighbours:
+                if location not in closed_queue and location not in open_queue and \
+                        location[0] in range(0, self.size[0]) and \
+                        location[1] in range(0, self.size[1]):  # stops infinite expansion
+                    open_queue.append(location)
+
+            closed_queue.append(open_queue.pop(0))  # close the current location
+
+        return None  # no occurrences of the value
+
+    def get_all(self, position, target_value):
+        open_queue = [position]
+        closed_queue = []
+        occurrences = []
+
+        while len(open_queue) > 0:
+            current_location = open_queue[0]
+
+            # See if current location is equal to the target value
+            if self.get_value(current_location) == target_value:
+                occurrences.append(current_location)
+
+            # Add remaining neighbours to queue
+            neighbours = self.get_neighbours(current_location)
+            for location in neighbours:
+                if location not in closed_queue and location not in open_queue and \
+                        location[0] in range(0, self.size[0]) and \
+                        location[1] in range(0, self.size[1]):  # stops infinite expansion
+                    open_queue.append(location)
+
+            closed_queue.append(open_queue.pop(0))  # close the current location
+
+        return occurrences
+
+    def get_neighbours(self, location):  # CAN RETURN LOCATIONS OUT OF RANGE.
+        neighbours = []
+        for x in range(location[0] - 1, location[0] + 2):
+            for y in range(location[1] - 1, location[1] + 2):
+                neighbours.append([x, y])
+        return neighbours

project/game/computer_player.py

@@ -0,0 +1,103 @@
+import random
+
+import constants
+
+import project.game.breadth_search as breadth_first
+import project.game.shortest_path as shortest_path
+
+MAP_WALLS = ["s", "l", "m", "o"]
+
+# SPOILERS!!
+# By reading this file, you can learn how the computer plays against you. This could make it easier to win against it
+# and thus spoil the strategy of the game a bit. You have been warned :)
+
+
+class Logic:
+    def take_go(self, model):
+        model.current_player.start_turn()
+
+        self.handle_cities(model)
+        self.handle_units(model)
+
+        model.current_player.end_turn()
+
+    def handle_cities(self, model):
+        for city in model.current_player.settlements:
+            # Spawning Units
+            affordable_units = [name for name, values in constants.UNIT_SPECS.items()
+                                if model.current_player.get_ap() - values["spawn_cost"] > 0]
+            unit_choice = random.choice(affordable_units)
+            model.try_spawn(unit_choice, city.get_position())
+
+    def handle_units(self, model):
+        for unit in model.current_player.units:
+            if False:  # in city conquer it
+                pass
+            else:
+                # breadth_search = breadth_first.BreadthSearch(model.world.get_format())
+                #
+                # nearest_city = breadth_search.get_nearest(unit.position, "c")
+                # path = shortest_path.GridPath(
+                #     model.world.get_format(),
+                #     unit.position, nearest_city,
+                #     walls=MAP_WALLS
+                # ).get_path()
+                # print(path)
+
+                # See if unit can take a city
+                if model.check_conquer(unit):
+                    model.conquer(unit.position)
+                else:
+                    # Make Random Move
+                    all_moves = model.get_moves(unit)
+                    if len(all_moves) > 0:
+                        move = random.choice(all_moves)
+                        model.move_unit(move, unit)
+
+                    # Make Random Attack (if possible)
+                    all_attacks = model.get_attacks(unit)
+                    if len(all_attacks) > 0:
+                        all_units = sorted(
+                            [model.get_unit(position) for position in all_attacks],
+                            key=lambda x: x.health)
+                        enemy_unit = all_units[0]  # target the weakest enemy
+                        model.make_attack(unit, enemy_unit)
+
+
+"""
+aspects of controlling a player:
+
+- spawning units
+- moving units
+- attacking units
+- conquering units
+
+- upgrade cities
+
+
+Unit (that is spawned)
+if in city, conquer it.
+
+else:
+
+- if can move into city, do so.
+
+shortest path can be used between units and the nearest city, so allways moving towards nearest city.
+(prioritise un-populated cities then the enemy).
+if can move towards "nearest" city, do it.
+
+- if enemy in range, attack it.
+
+Upgrade and Spawn
+keep a record of the players actions (ie. if they spawned units or/and upgraded a city)
+
+try to match the number of units spawned (and type?).
+then, try to match city upgrades
+if left over ap:
+	if big diffrence in ap per turn, apply upgrades only.
+	else if big diffrence in units, spawn units.
+	else
+	randomly pick units, or upgrades
+	apply these
+	
+"""

project/game/model.py

@@ -5,6 +5,7 @@
 import constants
 
 import project.game.calculations as calculations
+import project.game.computer_player as computer_player
 
 
 class Model:
@@ -14,8 +15,9 @@ def __init__(self, game_name, map_name, players):  # only when creating new game
         self.map_name = map_name
         self.game_end = False
 
-        self.players = [Player(p["name"], p["colour"]) for p in players]
+        self.players = [Player(p["name"], p["colour"], p["control"]) for p in players]
         self.current_player = self.players[0]
+        self.computer_logic = computer_player.Logic()
 
         self.world = World(self.map_name, self.players)  # assigns settlements to players
 
@@ -27,24 +29,46 @@ def all_units(self):
     def next_turn(self):
         self.current_player.end_turn()
 
-        # Getting new turn
+        # Getting new human player turn
         if not self.is_winner():  # if more than 1 player alive
-            self.current_player = self.get_next_player()
+            self.cycle_player()
         else:
             self.game_end = True
 
         self.current_player.start_turn()
 
     def get_next_player(self):
         valid_choice = False
-        player = self.current_player
+        index = self.players.index(self.current_player)
+
         while not valid_choice:  # wont be infinite, as to be called at least two players are left.
-            if self.players.index(player) < len(self.players) - 1:
-                player = self.players[self.players.index(player) + 1]
+            if index < len(self.players) - 1:
+                index += 1
             else:
-                player = self.players[0]
-            valid_choice = not player.is_dead()
-        return player
+                index = 0
+
+            valid_choice = not self.players[index].is_dead() and self.players[index].get_control() == "human"
+
+        return self.players[index]
+
+    def cycle_player(self):
+        valid_choice = False
+
+        while not valid_choice:  # wont be infinite, as to be called at least two players are left.
+            if self.players.index(self.current_player) < len(self.players) - 1:
+                self.current_player = self.players[self.players.index(self.current_player) + 1]
+            else:
+                self.current_player = self.players[0]
+
+            # Computer takes go, then we go on to find next human player
+            if self.current_player.get_control() == "computer":
+                self.computer_logic.take_go(self)  # of current player
+                if self.current_player.is_dead():
+                    self.current_player.units = []
+
+            valid_choice = not self.current_player.is_dead() and self.current_player.get_control() == "human"
+
+        return self.current_player
 
     def try_spawn(self, unit_type, position):
         if not self.get_unit(position):
@@ -145,13 +169,18 @@ def get_attacks(self, unit):
                             attacks.append([x, y])
         return attacks
 
+    def computer_turn(self):
+        pass
+
 
 class Player:
     """ Each player of the game, which holds their units, key values and links to settlements etc"""
-    def __init__(self, name, colour):
+    def __init__(self, name, colour, control):
         self.name = name
         self.colour = colour
-        self.camera_focus = [None, None]  # TODO: system to auto-scroll to spawn
+        self.control = control
+
+        self.camera_focus = [None, None]  # TODO: system to assign player 1 city (as "spawn") on creation
         self.show_minimap = False
 
         self.units = []
@@ -162,22 +191,12 @@ def __init__(self, name, colour):
         self.dead = False
         self.max_score = self.ap
 
-        # self.wood = 0
-        # self.stone = 0
-        # self.metal = 0
-
-    # def add_wood(self, amount):
-    #     self.wood += amount
-    #
-    # def add_stone(self, amount):
-    #     self.stone += amount
-    #
-    # def add_metal(self, amount):
-    #     self.metal += amount
-
     def get_name(self):
         return self.name
 
+    def get_control(self):
+        return self.control
+
     def is_dead(self):
         return self.dead
 
@@ -258,38 +277,13 @@ class Tile:
     def __init__(self, tile_type, position):
         self.type = tile_type
         self.position = position
-        # self.wood, self.stone, self.metal = constants.TILE_DATA[tile_type]
 
     def get_type(self):
         return self.type
 
     def get_position(self):
         return self.position
 
-    # def take_wood(self, amount=1): # defaults, left for future in case decide change.
-    #     if self.wood > 0:
-    #         self.wood = self.wood - amount
-    #         if self.wood < 0:
-    #             self.wood = 0  # ensures resource is fully used, but cant go negative.
-    #         return True
-    #     return False
-    #
-    # def take_stone(self, amount=1):
-    #     if self.stone > 0:
-    #         self.stone = self.stone - amount
-    #         if self.stone < 0:
-    #             self.stone = 0
-    #         return True
-    #     return False
-    #
-    # def take_metal(self, amount=1):
-    #     if self.metal > 0:
-    #         self.metal = self.metal - amount
-    #         if self.metal < 0:
-    #             self.metal = 0
-    #         return True
-    #     return False
-
 
 class City:
     def __init__(self, name, position):