Projekt_Sztuczna_Inteligencja/json_generator.py

import json
import random
import project_constants as const


# auxiliary function that returns random attribute values based on their type
def _get_random_attribute_values(self, attr_type, grid_dimensions):
    num_of_rows, num_of_columns = grid_dimensions

    if attr_type == int:
        # temporary solution
        return random.randint(num_of_rows + num_of_columns, (2 * num_of_rows + num_of_columns))

    else:
        return None


class JsonGenerator:
    grid = dict()

    # constructor that can be used to set agent's initial state
    def __init__(self, agents_initial_position=(0, 0), agents_initial_direction=const.Direction.UP.value):
        # saving agent's initial state (position & direction)
        self.agents_initial_position = agents_initial_position
        self.agents_initial_direction = agents_initial_direction

        # getting position coordinates
        starting_row, starting_column = agents_initial_position

        # saving data to the grid dictionary
        self.grid["agents_initial_state"] = {
            "position": str(starting_row) + ',' + str(starting_column),
            "direction": agents_initial_direction
        }

    # sets agent's initial state
    def set_agents_initial_state(self, position=(0, 0), direction=const.Direction.UP.value):
        # setting fields in the instance
        self.agents_initial_position = position
        self.agents_initial_direction = direction

        # getting position coordinates
        starting_row, starting_column = position

        # setting new agent's initial state
        self.grid["agents_initial_state"] = {
            "position": str(starting_row) + ',' + str(starting_column),
            "direction": direction
        }

    # overwrites grid field with a new grid with randomized colors and mines
    def generate_randomized_grid(self, dimensions, mine_appearance_chance=0.15, predecessor_chance_decrease=0.25):
        # clearing grid field
        self.clear_tile_dictionary()

        # getting grid dimensions
        num_of_rows, num_of_columns = dimensions

        tile_pool = []

        for i in range(num_of_rows):
            for j in range(num_of_columns):
                # picking random values for tiles
                random_tile_color = random.choice(const.STRUCT_TILE_COLORS)

                # adding added tile's indexes to a pool
                tile_pool.append((i, j))

                # creating random tile
                self.add_tile((i, j), random_tile_color)

        # deleting agent's starting tile from the pool
        deleted_row, deleted_column = self.agents_initial_position
        tile_pool.remove((int(deleted_row), int(deleted_column)))

        for i in range(num_of_rows):
            for j in range(num_of_columns):

                # checking if a mine will appear
                if random.random() < mine_appearance_chance and len(tile_pool) > 0 and tile_pool.__contains__((i, j)):
                    # removing current tile from the pool
                    tile_pool.remove((i, j))

                    # choosing random mine parameters
                    random_mine_type = random.choice(const.STRUCT_MINE_TYPES)
                    random_attribute_values = []

                    for attr_type in const.STRUCT_MINE_ATTRIBUTE_TYPES[random_mine_type]:
                        random_attribute_values.append(_get_random_attribute_values(self, attr_type, dimensions))

                    # adding the mine
                    self.set_a_mine((i, j), random_mine_type, random_attribute_values)

                    # if is ChainedMine create predecessors
                    if random_mine_type == "chained":
                        predecessor_appearance_chance = 1.0
                        current_tile = str(i) + ',' + str(j)

                        # create chained predecessors
                        while random.random() < predecessor_appearance_chance and len(tile_pool) > 0:
                            predecessor_appearance_chance -= predecessor_chance_decrease

                            predecessor_position = random.choice(tile_pool)
                            pre_row, pre_column = predecessor_position
                            predecessor = str(pre_row) + ',' + str(pre_column)
                            tile_pool.remove(predecessor_position)

                            self.set_a_mine(predecessor_position, "chained", [])

                            self.grid[current_tile]["mine"]["predecessor"] = predecessor
                            self.grid[predecessor]["mine"]["predecessor"] = None

                            current_tile = predecessor

    # adds a new tile or edits an existing one in the grid field
    def add_tile(self, position, color):
        # getting added/edited tile's index values
        row, column = position

        # creating new tile without a mine
        self.grid[str(row) + ',' + str(column)] = {
            "color": color,
            "mine": None
        }

    # adds a new tile with a mine or edits an existing one in the grid field
    def add_tile_with_a_mine(self, position, color, mine_type, attribute_values):
        # getting added/edited tile's index values
        row, column = position
        # setting mine data using attribute_values
        mine_values = const.STRUCT_MINE_ATTRIBUTES[mine_type]

        for key in mine_values.keys():
            if key not in const.HARDCODED_VALUES and len(attribute_values) > 0:
                mine_values[key] = attribute_values.pop(0)

        # creating a new tile
        self.grid[str(row) + ',' + str(column)] = {
            "color": color
        }

        # updating the tile with a mine field
        self.grid[str(row) + ',' + str(column)]["mine"] = {}

        for key in mine_values.keys():
            self.grid[str(row) + ',' + str(column)]["mine"][key] = mine_values[key]

    # deletes a mine with a given position from the grid field
    def delete_a_tile(self, position):
        # getting tile's index values
        row, column = position

        # deleting a tile with given key
        self.grid.pop(str(row) + ',' + str(column))

    # adds a mine to a tile stored in the grid field
    def set_a_mine(self, position, mine_type, attribute_values):
        # getting edited tile's index values
        row, column = position

        # setting mine data using attribute_values
        mine_values = const.STRUCT_MINE_ATTRIBUTES[mine_type]

        for key in mine_values.keys():
            if key not in const.HARDCODED_VALUES and len(attribute_values) > 0:
                mine_values[key] = attribute_values.pop(0)

        # adding a mine to the edited tile
        self.grid[str(row) + ',' + str(column)]["mine"] = {}

        for key in mine_values.keys():
            self.grid[str(row) + ',' + str(column)]["mine"][key] = mine_values[key]

    # deletes a mine from a tile stored in the grid field
    def delete_a_mine(self, position):
        # getting edited tile's index values
        row, column = position

        # removing mine from the edited tile
        self.grid[str(row) + ',' + str(column)]["mine"] = None

    # returns the grid field
    def get_tile_dictionary(self):
        return self.grid

    # clears the grid field
    def clear_tile_dictionary(self):
        # clearing grid dict
        self.grid.clear()

        # getting agent's starting position coordinates
        starting_row, starting_column = self.agents_initial_position

        # re-setting the agent's initial state
        self.grid["agents_initial_state"] = {
            "position": str(starting_row) + ',' + str(starting_column),
            "direction": self.agents_initial_direction
        }

    # loads a grid from a file and overwrites the grid field
    def load_from_a_file(self, file_path):
        # opening a file for reading
        with open(file_path, 'r') as input_file:
            # overwriting the grid field with the grid stored in a file
            self.grid = json.load(input_file)

    # saves the current grid field to a file
    def save_to_a_file(self, file_path, access_mode):
        # opening a file with a given access mode (w - write / a - append)
        with open(file_path, access_mode) as output_file:
            # saving the grid to the file
            json.dump(self.grid, output_file, indent=2, sort_keys=True)

    # edits a grid in a file. doesn't delete data, only overwrites and adds new entries
    def edit_a_file(self, file_path):
        # opening a file for reading
        with open(file_path, "r") as input_file:
            # loading data that was stored in the file previously
            previous_data = json.load(input_file)

            # creating and updating a new grid using it's own grid field
            new_grid = previous_data
            new_grid.update(self.grid)

            # opening the file for writing
            with open(file_path, "w") as output_file:
                # saving the newly created grid
                json.dump(new_grid, output_file, indent=2, sort_keys=True)