171 lines
6.9 KiB
Python
171 lines
6.9 KiB
Python
import json
|
|
import random
|
|
import project_constants as const
|
|
|
|
|
|
class JsonGenerator:
|
|
grid = dict()
|
|
|
|
def __init__(self, agent_starting_position):
|
|
self.agent_starting_position = agent_starting_position
|
|
starting_row, starting_column = agent_starting_position
|
|
self.grid["agent_starting_position"] = str(starting_row) + ',' + str(starting_column)
|
|
|
|
# overwrites grid field with a new grid with randomized colors and mines
|
|
def generate_randomized_grid(self, dimensions):
|
|
# clearing grid field
|
|
self.clear_tile_dictionary()
|
|
|
|
# getting grid dimensions
|
|
num_of_rows, num_of_columns = dimensions
|
|
|
|
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)
|
|
random_mine_type = random.choice(const.STRUCT_MINE_TYPES)
|
|
|
|
# randomly checking if a mine should appear
|
|
if random.random() < 0.75:
|
|
# creating a tile without a mine
|
|
self.add_tile((i, j), random_tile_color)
|
|
|
|
else:
|
|
# picking random mine attribute values
|
|
random_attribute_values = []
|
|
|
|
for attr_type in const.STRUCT_MINE_ATTRIBUTE_TYPES[random_mine_type]:
|
|
|
|
if attr_type == int:
|
|
min_value, max_value = (num_of_columns + num_of_rows) / 2, 2 *(num_of_columns + num_of_rows)
|
|
random_value = random.randint(min_value, max_value)
|
|
random_attribute_values.append(random_value)
|
|
|
|
elif attr_type == (int, int):
|
|
|
|
if i > 0:
|
|
rand_i = random.randint(0, (i - 1))
|
|
rand_j = random.randint(0, (num_of_columns - 1))
|
|
random_attribute_values.append(str(rand_i) + ',' + str(rand_j))
|
|
self.set_a_mine((rand_i, rand_j), "chained", [None])
|
|
|
|
elif j > 0:
|
|
rand_i = 0
|
|
rand_j = random.randint(0, (j - 1))
|
|
random_attribute_values.append(str(rand_i) + ',' + str(rand_j))
|
|
self.set_a_mine((rand_i, rand_j), "chained", [None])
|
|
|
|
else:
|
|
random_attribute_values.append(None)
|
|
|
|
# creating a tile with a mine
|
|
self.add_tile_with_a_mine(
|
|
(i, j),
|
|
random_tile_color,
|
|
random_mine_type,
|
|
random_attribute_values)
|
|
|
|
# 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):
|
|
self.grid.clear()
|
|
# resetting agents starting position
|
|
starting_row, starting_column = self.agent_starting_position
|
|
self.grid["agent_starting_position"] = str(starting_row) + ',' + str(starting_column)
|
|
|
|
# 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)
|