Projekt_Sztuczna_Inteligencja/minefield.py

import project_constants as const
from objects import tile as tl, agent as ag
from objects.mines.mine_models.time_mine import TimeMine
import json_generator as jg


class Minefield:
    def __init__(self, json_path):
        self.turn = 0

        self.agent = ag.Agent(const.MAP_RANDOM_10x10)
        self.json_path = json_path

        # open JSON with minefield info
        json_gen = jg.JsonGenerator()
        json_gen.load_from_a_file(json_path)

        # create matrix of a desired size, fill it with default tile objects
        self.matrix = [
            [
                tl.Tile(
                    (row, column),
                    terrain_type=json_gen.get_tile((row, column))["terrain"],
                    mine=jg.create_a_mine(json_gen.get_mine((row, column)), (row, column))
                ) for column in range(const.V_GRID_HOR_TILES)
            ] for row in range(const.V_GRID_VER_TILES)
        ]

        # iterate through chained mines, set mine predecessors
        for pair in jg.get_chained_mine_and_its_predecessor_pairs(json_gen.get_grid()):
            successor_position, predecessor_position = pair
            successor_row, successor_column = successor_position
            predecessor_row, predecessor_column = predecessor_position

            predecessor = self.matrix[predecessor_row][predecessor_column]
            self.matrix[successor_row][successor_column].mine.predecessor = predecessor

    def next_turn(self):
        self.turn += 1

        for row in range(const.V_GRID_VER_TILES):
            for column in range(const.V_GRID_VER_TILES):
                mine = self.matrix[row][column].mine

                if mine is not None and isinstance(mine, TimeMine):
                    mine.timer = max(0, mine.starting_time - int(self.turn / 4))

    def get_active_mines(self):
        mines = list()

        for row in range(const.V_GRID_VER_TILES):
            for column in range(const.V_GRID_VER_TILES):
                mine = self.matrix[row][column].mine

                if mine is not None and mine.active:
                    # do not add mines with predecessors
                    if mine.type == 'chained' and mine.predecessor is not None:
                        continue

                    mines.append(mine)

        return mines

    def disarm_mine(self, x, y):
        tile = self.matrix[x][y]
        mine = tile.mine
        mine.disarm()

    # ================ #
    # === MOVEMENT === #
    # ================ #

    # check if sapper's destination is accessible
    @staticmethod
    def is_valid_move(target_row: int, target_column: int):
        if 0 <= target_row < const.V_GRID_VER_TILES \
                and 0 <= target_column < const.V_GRID_HOR_TILES:
            return True

        return False

    # ============= #
    # === OTHER === #
    # ============= #

    # method that allows copying classes instance
    def __copy__(self):
        copy = Minefield(self.json_path)
        return copy