Projekt_Sztuczna_Inteligencja/minefield.py

import json

import project_constants as const
import tile as tl
from mines_models import standard_mine as sm

tile_asset_options = {
    "BLUE": const.ASSET_TILE_BLUE,
    "GREEN": const.ASSET_TILE_GREEN,
    "ORANGE": const.ASSET_TILE_ORANGE,
    "PURPLE": const.ASSET_TILE_PURPLE,
    "RED": const.ASSET_TILE_RED,
    "WHITE": const.ASSET_TILE_WHITE,
    "YELLOW": const.ASSET_TILE_YELLOW
}

mine_asset_options = {
    'A': const.ASSET_MINE_A,
    'B': const.ASSET_MINE_B,
    'F': const.ASSET_MINE_F,
    'K': const.ASSET_MINE_K
}


def calculate_screen_position(x, y):
    coords = (
        const.V_SCREEN_PADDING + const.V_TILE_SIZE * x,
        const.V_SCREEN_PADDING + const.V_TILE_SIZE * y,
    )

    return coords


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

        # self.sapper = new Sapper Object (yet to be implemented)

        # open JSON with minefield info
        with open(json_path) as json_data:
            data = json.load(json_data)

        # create matrix of a desired size, fill it with default tile objects
        self.matrix = [
            [
                tl.Tile((x, y)) for y in range(const.V_GRID_VER_TILES)
            ] for x in range(const.V_GRID_HOR_TILES)
        ]

        # iterate through tiles, set their colors and add mines
        for x in range(const.V_GRID_HOR_TILES):
            for y in range(const.V_GRID_VER_TILES):

                # load tile's data from json
                tile_data = data[f"{x},{y}"]

                # create and add mine if there is one
                if tile_data["mine"] is not None:
                    # TODO: check mine type and create suitable one
                    # JSON file doesn't represent new mine types yet, so every mine is a standard one at the moment
                    mine = sm.StandardMine((x, y))
                    self.matrix[x][y].mine = mine

                self.matrix[x][y].color = tile_data["color"].upper()

        # probably a temporary solution
        # (depends on sapper's movement implementation)
        sapper_x, sapper_y = data['agent_starting_position'].split(",")
        self.sapper_position = (int(sapper_x), int(sapper_y))

    def draw(self, window):
        # iterate through tiles
        for raw in self.matrix:
            for tile in raw:

                # calculate tile position on the screen
                tile_screen_coords = calculate_screen_position(tile.position[0], tile.position[1])

                # draw a tile
                window.blit(tile_asset_options.get(tile.color), tile_screen_coords)

                # draw a mine on top if there is one
                if tile.mine is not None:
                    # TODO: blit appropriate mine type
                    # current icons don't represent actual types, thus every mine has the same icon (temporary solution)
                    window.blit(mine_asset_options['A'], tile_screen_coords)

        # draw the sapper
        sapper_screen_coords = calculate_screen_position(self.sapper_position[0], self.sapper_position[1])
        window.blit(const.ASSET_SAPPER, sapper_screen_coords)

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

    # check if sapper's destination is accessible
    def is_valid_move(self, target_x: int, target_y: int):
        if 0 <= target_x < const.V_GRID_HOR_TILES and \
                0 <= target_y < const.V_GRID_VER_TILES and \
                self.matrix[target_x][target_y].mine is None:
            return True

        return False

    # Here are defined functions that move our agent. They are being called in main when certain key is pressed

    def go_right(self):
        target_x = self.sapper_position[0] + 1
        target_y = self.sapper_position[1]
        if self.is_valid_move(target_x, target_y):
            self.sapper_position = (target_x, target_y)

    def go_left(self):
        target_x = self.sapper_position[0] - 1
        target_y = self.sapper_position[1]
        if self.is_valid_move(target_x, target_y):
            self.sapper_position = (target_x, target_y)

    def go_up(self):
        target_x = self.sapper_position[0]
        target_y = self.sapper_position[1] - 1
        if self.is_valid_move(target_x, target_y):
            self.sapper_position = (target_x, target_y)

    def go_down(self):
        target_x = self.sapper_position[0]
        target_y = self.sapper_position[1] + 1
        if self.is_valid_move(target_x, target_y):
            self.sapper_position = (target_x, target_y)