From a4bc74d5f26eab1cab527270fe78aa011d48880e Mon Sep 17 00:00:00 2001 From: JakubR Date: Wed, 21 Apr 2021 20:10:18 +0200 Subject: [PATCH] added useful functions to json_generator.py; code refactoring --- json_generator.py | 199 ++++++++++++++++++++++++++++++++++------------ 1 file changed, 148 insertions(+), 51 deletions(-) diff --git a/json_generator.py b/json_generator.py index 04f1fd3..1a5ce14 100644 --- a/json_generator.py +++ b/json_generator.py @@ -1,18 +1,15 @@ import json import random + import project_constants as const +# import tile class +import tile as tl -# 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 +# import mine models +import mine_models.standard_mine as sm +import mine_models.time_mine as tm +import mine_models.chained_mine as cm class JsonGenerator: @@ -24,12 +21,9 @@ class JsonGenerator: 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), + "position": format_position_to_str(agents_initial_position), "direction": agents_initial_direction } @@ -39,19 +33,16 @@ class JsonGenerator: 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), + "position": format_position_to_str(position), "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() + self.clear_grid() # getting grid dimensions num_of_rows, num_of_columns = dimensions @@ -60,6 +51,7 @@ class JsonGenerator: 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) @@ -86,7 +78,7 @@ class JsonGenerator: 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)) + random_attribute_values.append(_get_random_attribute_values(attr_type, dimensions)) # adding the mine self.set_a_mine((i, j), random_mine_type, random_attribute_values) @@ -94,15 +86,14 @@ class JsonGenerator: # if is ChainedMine create predecessors if random_mine_type == "chained": predecessor_appearance_chance = 1.0 - current_tile = str(i) + ',' + str(j) + current_tile = format_position_to_str((i, 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) + predecessor = format_position_to_str(predecessor_position) tile_pool.remove(predecessor_position) self.set_a_mine(predecessor_position, "chained", []) @@ -114,19 +105,14 @@ class JsonGenerator: # 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)] = { + self.grid[format_position_to_str(position)] = { "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] @@ -135,29 +121,23 @@ class JsonGenerator: mine_values[key] = attribute_values.pop(0) # creating a new tile - self.grid[str(row) + ',' + str(column)] = { + self.grid[format_position_to_str(position)] = { "color": color } # updating the tile with a mine field - self.grid[str(row) + ',' + str(column)]["mine"] = {} + self.grid[format_position_to_str(position)]["mine"] = {} for key in mine_values.keys(): - self.grid[str(row) + ',' + str(column)]["mine"][key] = mine_values[key] + self.grid[format_position_to_str()]["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)) + self.grid.pop(format_position_to_str(position)) # 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] @@ -166,34 +146,36 @@ class JsonGenerator: mine_values[key] = attribute_values.pop(0) # adding a mine to the edited tile - self.grid[str(row) + ',' + str(column)]["mine"] = {} + self.grid[format_position_to_str(position)]["mine"] = {} for key in mine_values.keys(): - self.grid[str(row) + ',' + str(column)]["mine"][key] = mine_values[key] + self.grid[format_position_to_str(position)]["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 + self.grid[format_position_to_str(position)]["mine"] = None + + # returns chosen tiles data + def get_tile(self, position): + return self.grid[format_position_to_str(position)] + + # returns chosen mines data + def get_mine(self, position): + return self.grid[format_position_to_str(position)]["mine"] # returns the grid field - def get_tile_dictionary(self): + def get_grid(self): return self.grid # clears the grid field - def clear_tile_dictionary(self): + def clear_grid(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), + "position": format_position_to_str(self.agents_initial_position), "direction": self.agents_initial_direction } @@ -226,3 +208,118 @@ class JsonGenerator: with open(file_path, "w") as output_file: # saving the newly created grid json.dump(new_grid, output_file, indent=2, sort_keys=True) + + +# STATIC "PUBLIC" FUNCTIONS + +# creates a Mine (Standard or Time or Chained) instance from mine dict data +# doesn't link chained mines, since it has no actual access to a grid +def create_a_mine(mine_dict, position): + # initializing a mine with no value + mine = None + + # if mine doesn't exist - returning None + if mine_dict is None: + return mine + + # formatting position to right format - in case it's not + position = format_position_to_tuple(position) + + # if mine's type is "standard" - creating standard mine + if mine_dict["mine_type"] == "standard": + mine = sm.StandardMine(position) + + # if mine's type is "time" - creating time mine + elif mine_dict["mine_type"] == "time": + timer_value = mine_dict["timer"] + mine = tm.TimeMine(position, timer_value) + + # if mine's type is "chained" - creating chained mine (no successors assigned yet) + elif mine_dict["mine_type"] == "chained": + mine = cm.ChainedMine(position) + + return mine + + +# creates a Tile instance with a mine (if a mine exists) from tile dict data +def create_a_tile(tile_dict, position): + # formatting position to right format - in case it's not + position = format_position_to_tuple(position) + + # getting tile's parameters + color = tile_dict["color"] + mine = create_a_mine(position, tile_dict["mine"]) + + # creating and returning a tile with the parameters set above + return tl.Tile(position, color, mine) + + +# returns a list of tuples containing chained mine's position and it's predecessors position +# data is in format [(chained_mine_position, its_predecessors_position), ...] +def get_chained_mine_and_its_predecessor_pairs(minefield_dictionary): + predecessors = list() + + # iterate for each key in the grid field + for key in minefield_dictionary.keys(): + # if a chained mine with predecessor exists - adding it's and it's predecessors positions as a tuple to a list + if key != "agents_initial_state" and minefield_dictionary[key]["mine"] is not None\ + and minefield_dictionary[key]["mine"]["mine_type"] == "chained"\ + and minefield_dictionary[key]["mine"]["predecessor"] is not None: + + # getting the chained mines and it's predecessors positions + this_mines_position = tuple(int(i) for i in key.split(',')) + its_predecessors_position = tuple(int(i) for i in minefield_dictionary[key]["mine"]["predecessor"].split(',')) + + # adding the positions to the list as a tuple + predecessors.append((this_mines_position, its_predecessors_position)) + + return predecessors + + +# changes position from str or tuple format to str format +def format_position_to_str(position): + # if mine's position is in "row,column" format - that means position parameter is already in good format + if isinstance(position, str): + pass + + # if mine's position is in (row:int, column:int) - creating string from tuple + elif isinstance(position, tuple) and list(map(type, position)) == [int, int]: + row, column = position + return str(row) + ',' + str(column) + + # if mine's position is not in any of 2 formats above - returning None - unsupported format + else: + return None + + return position + + +# changes position from str or tuple format to tuple format +def format_position_to_tuple(position): + # if mine's position is in "row,column" format - getting parameters from string + if isinstance(position, str): + position = tuple(int(i) for i in position.split(',')) + + # if mine's position is in (row:int, column:int) - that means position parameter is already in good format + elif isinstance(position, tuple) and list(map(type, position)) == [int, int]: + pass + + # if mine's position is not in any of 2 formats above - returning None - unsupported format + else: + return None + + return position + + +# AUXILIARY "PRIVATE" FUNCTIONS + +# auxiliary function that returns random attribute values based on their type +def _get_random_attribute_values(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