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)