def make_level_from_dat(reader):
"""Reads all the data to construct a single level from the active reader
Note that this assumes the reader is at new level section in the file.
This code does not error check for invalid data
Args:
reader (BufferedReader) : active reader reading a DAT file
Returns:
A CCLevel object constructed with the read data
"""
level = cc_data.CCLevel()
level.num_bytes = int.from_bytes(do_read(reader, 2),
byteorder=cc_data.BYTE_ORDER)
level.level_number = int.from_bytes(do_read(reader, 2),
byteorder=cc_data.BYTE_ORDER)
level.time = int.from_bytes(do_read(reader, 2),
byteorder=cc_data.BYTE_ORDER)
level.num_chips = int.from_bytes(do_read(reader, 2),
byteorder=cc_data.BYTE_ORDER)
# Note: Map Detail is not used and is expected to always be 1
map_detail = int.from_bytes(do_read(reader, 2),
byteorder=cc_data.BYTE_ORDER)
upper_layer_byte_count = int.from_bytes(do_read(reader, 2),
byteorder=cc_data.BYTE_ORDER)
upper_layer_bytes = do_read(reader, upper_layer_byte_count)
lower_layer_byte_count = int.from_bytes(do_read(reader, 2),
byteorder=cc_data.BYTE_ORDER)
lower_layer_bytes = do_read(reader, lower_layer_byte_count)
level.upper_layer = make_layer_from_bytes(upper_layer_bytes)
level.lower_layer = make_layer_from_bytes(lower_layer_bytes)
level.optional_fields = make_optional_fields_from_dat(reader)
return level
def make_level_library_from_json(json_data):
level_library = cc_data.CCDataFile()
for level_data in json_data["levels"]:
level = cc_data.CCLevel()
level.level_number = level_data["level"]
level.time = level_data["time"]
level.num_chips = level_data["chipNum"]
level.upper_layer = level_data["Upper_layer"]
level.lower_layer = level_data["Lower_layer"]
optional_fields = level_data["optional"]
hint = cc_data.CCMapHintField(optional_fields["hint"])
level.add_field(hint)
title = cc_data.CCMapTitleField(optional_fields["title"])
level.add_field(title)
monsters = []
monster_coords = optional_fields["monsters"]
for i in monster_coords:
monster = cc_data.CCCoordinate(i[0], i[1])
monsters.append(monster)
monster_field = cc_data.CCMonsterMovementField(monsters)
level.add_field(monster_field)
level_library.add_level(level)
return level_library
def make_cc_level_from_json(level_data):
# level_library = cc_data.CCDataFile()
new_level = cc_data.CCLevel()
new_level.level_number = level_data["level_number"]
new_level.num_chips = level_data["num_chips"]
new_level.upper_layer = level_data["upper_layer"]
new_level.time = level_data["time"]
for field_json in level_data["optional_fields"]:
new_field = None
print("field_json: " + str(field_json))
if field_json["id"] == "Hint":
new_field = cc_data.CCMapHintField(field_json["hint_data"])
new_level.add_field(new_field)
if field_json["id"] == "Password":
new_field = cc_data.CCEncodedPasswordField(
field_json["Password_data"])
new_level.add_field(new_field)
if field_json["id"] == "title":
new_field = cc_data.CCMapTitleField(field_json["title_data"])
new_level.add_field(new_field)
elif field_json["id"] == "monsters":
monster_coords = []
for monster_json in field_json["monster_data"]:
monster_coords.append(
cc_data.CCCoordinate(monster_json[0], monster_json[1]))
new_field = cc_data.CCMonsterMovementField(monster_coords)
new_level.add_field(new_field)
return new_level
def convert_json_to_dat(json_file):
game_data = cc_data.CCDataFile()
for level in json_file["levels"]:
game_level = cc_data.CCLevel()
game_level.level_number = level["level number"]
game_level.time = level["time"]
game_level.num_chips = level["chip number"]
game_level.upper_layer = level["upper layer"]
optional_fields_json = level["optional fields"]
for something in optional_fields_json:
if something["id"] == "title":
title = cc_data.CCMapTitleField(something["level title"])
game_level.add_field(title)
elif something["id"] == "password":
password = cc_data.CCEncodedPasswordField(
something["encoded password"])
game_level.add_field(password)
elif something["id"] == "hint":
hint = cc_data.CCMapHintField(something["hint text"])
game_level.add_field(hint)
elif something["id"] == "monsters":
coordinates = []
for coordinate in something["monsters"]:
x = coordinate[0]
y = coordinate[1]
coord = cc_data.CCCoordinate(x, y)
coordinates.append(coord)
game_data.add_level(game_level)
return game_data
def make_level_from_json(json_data):
cclevel = cc_data.CCLevel()
cclevel.level_number = json_data["levelnum"]
cclevel.time = json_data["time"]
cclevel.num_chips = json_data["chips"]
cclevel.upper_layer = json_data["upper"]
cclevel.lower_layer = json_data["lower"]
cclevel.optional_fields = make_optional_field_from_json(json_data["optional_fields"])
return cclevel
def make_cc_level_from_json(json_data): # makes cc level using json data - includes initialized variables and optional fields
cc_level = cc_data.CCLevel() # Create a CCLevel Class from cc_data.py
cc_level.level_number = json_data["level_number"]
cc_level.time = json_data["time"]
cc_level.num_chips = json_data["num_chips"]
cc_level.upper_layer = json_data["upper_layer"]
cc_level.lower_layer = json_data["lower_layer"]
cc_level.optional_fields = make_optional_fields_from_json(json_data["optional_fields"])# make_optional_fields_from_json takes the json_data "optional_fields" and returns list of cc_fields
return cc_level
def make_ccfile_from_json(json_data):
cc_file = cc_data.CCDataFile()
cc_file.levels = []
for level in json_data:
level_object = cc_data.CCLevel()
level_object.level_number = level["level_number"]
level_object.time = level["time"]
level_object.num_chips = level["chip_number"]
level_object.upper_layer = level["upper_layer"]
level_object.lower_layer = level["lower_layer"]
for field in level["optional_fields"]:
if field["field_num"] == 3:
obj = cc_data.CCMapTitleField(field["title"])
level_object.add_field(obj)
elif field["field_num"] == 6:
obj = cc_data.CCEncodedPasswordField(field["list"])
level_object.add_field(obj)
elif field["field_num"] == 7:
obj = cc_data.CCMapHintField(field["hint"])
level_object.add_field(obj)
elif field["field_num"] == 10:
a = []
for i in range(len(field["xcoord"])):
mons = cc_data.CCCoordinate(field["xcoord"][i],
field["ycoord"][i])
a.append(mons)
obj = cc_data.CCMonsterMovementField(a)
level_object.add_field(obj)
elif field["field_num"] == 4:
a = []
for i in range(len(field["trapx"])):
#button = cc_data.CCCoordinate(field["buttonx"][i], field["buttony"][i])
#trap = cc_data.CCCoordinate(field["trapx"][i], field["trapy"][i])
combined = cc_data.CCTrapControl(field["buttonx"][i],
field["buttony"][i],
field["trapx"][i],
field["trapy"][i])
a.append(combined)
obj = cc_data.CCTrapControlsField(a)
level_object.add_field(obj)
elif field["field_num"] == 5:
a = []
for i in range(len(field["buttonx"])):
#button = cc_data.CCCoordinate(field["buttonx"][i], field["buttony"][i])
#machine = cc_data.CCCoordinate(field["machinex"][i], field["machiney"][i])
combined = cc_data.CCCloningMachineControl(
field["buttonx"][i], field["buttony"][i],
field["machinex"][i], field["machiney"][i])
a.append(combined)
obj = cc_data.CCCloningMachineControlsField(a)
level_object.add_field(obj)
else:
print("idk")
cc_file.add_level(level_object)
return cc_file
def make_cc_file_from_json(json_data):
# Initializing CCDataFile
data_file = cc_data.CCDataFile()
# Iterating through level dictionaries in JSON file
for lvl in json_data:
# Initializing CCLevel
level = cc_data.CCLevel()
level.level_number = lvl["level number"]
level.time = lvl["time"]
level.num_chips = lvl["num_chips"]
level.upper_layer = lvl["upper layer"]
level.lower_layer = lvl["lower layer"]
# Iterating through optional fields in level
for fld in lvl["optional_fields"]:
if fld["id"] == "hint":
new_field = cc_data.CCMapHintField(fld["hint_text"])
elif fld["id"] == "title":
new_field = cc_data.CCMapTitleField(fld["title_text"])
elif fld["id"] == "password":
new_field = cc_data.CCEncodedPasswordField(fld["password"])
elif fld["id"] == "monster":
coords = []
# Creating list of CCCoordinate objects
for c in fld["monster_location"]:
new_coord = cc_data.CCCoordinate(c[0], c[1])
coords.append(new_coord)
new_field = cc_data.CCMonsterMovementField(coords)
elif fld["id"] == "trap":
traps = []
b_lst = fld["trap_button"]
l_lst = fld["trap_location"]
# bc = cc_data.CCCoordinate(b_lst[0], b_lst[1])
# tc = cc_data.CCCoordinate(l_lst[0], l_lst[1])
# Initializing trap information
traps.append(
cc_data.CCTrapControl(b_lst[0], b_lst[1], l_lst[0],
l_lst[1]))
new_field = cc_data.CCTrapControlsField(traps)
else:
print("There was an error... Unexpected field!")
# Adding newly made field to level
level.add_field(new_field)
# Adding level to game data file
data_file.add_level(level)
return data_file
def make_CC_data_from_JSON(json_data):
CCData = cc_data.CCDataFile()
for game_level in json_data:
# Make a new CCLevel
level = cc_data.CCLevel()
# Get data from current level
level.level_number = game_level["level_number"]
level.time = game_level["time"]
level.num_chips = game_level["num_chips"]
level.upper_layer = game_level["upper_layer"]
# Retrieve data from optional fields
optional_fields = game_level["optional_fields"]
for field in optional_fields:
if field["type_val"] == 3:
init_field = cc_data.CCMapTitleField(field["title"])
elif field["type_val"] == 4:
coordinates = []
for val in field["traps"]: #retrieve coordinates from array
init_coord = cc_data.CCTrapControl(val[0], val[1], val[2],
val[3])
coordinates.append(init_coord)
init_field = cc_data.CCTrapControlsField(coordinates)
elif field["type_val"] == 5:
coordinates = []
for val in field["clones"]: #retrieve coordinates from array
init_coord = cc_data.CCCloningMachineControl(
val[0], val[1], val[2], val[3])
coordinates.append(init_coord)
init_field = cc_data.CCCloningMachineControlsField(coordinates)
elif field["type_val"] == 6:
init_field = cc_data.CCEncodedPasswordField(field["pass"])
elif field["type_val"] == 7:
init_field = cc_data.CCMapHintField(field["hint"])
elif field["type_val"] == 10:
coordinates = []
for val in field["monsters"]: #retrieve coordinates fom array
init_coord = cc_data.CCCoordinate(val[0], val[1])
coordinates.append(init_coord)
init_field = cc_data.CCMonsterMovementField(coordinates)
else:
return ("Error: field unrecognized")
level.add_field(init_field)
CCData.add_level(level)
print(CCData)
return CCData
def make_datafile_from_json(json_data):
# Initialize a new level set
datafile = cc_data.CCDataFile()
# Loop through the json_data
for level in json_data["levels"]:
# initiate a temp level
new_level = cc_data.CCLevel()
# general info
new_level.level_number = level["level_number"]
new_level.time = level["time"]
new_level.num_chips = level["num_chips"]
new_level.upper_layer = level["upper_layer"]
new_level.lower_layer = level["lower_layer"]
# go through optional fields
fields = level["optional_fields"]
for field in fields:
type_val = field["type_val"]
if type_val == 3:
title = cc_data.CCMapTitleField(field["title"])
new_level.add_field(title)
elif type_val == 6:
password = cc_data.CCEncodedPasswordField(field["password"])
new_level.add_field(password)
elif type_val == 7:
hint = cc_data.CCMapHintField(field["hint"])
new_level.add_field(hint)
elif type_val == 10:
monster_coordinates = []
for coordinate in field["monsters"]:
monster_coordinates.append(cc_data.CCCoordinate(coordinate[0], coordinate[1]))
monsters = cc_data.CCMonsterMovementField(monster_coordinates)
new_level.add_field(monsters)
elif type_val == 4:
a = 0
# cc_password = cc_data.CCEncodedPasswordField(field["password"])
#level.add_field(cc_password)
elif type_val == 5:
b = 0
#c c_password = cc_data.CCEncodedPasswordField(field["password"])
#level.add_field(cc_password)
# Add temp level to the level set
datafile.add_level(new_level)
return datafile
def make_level_from_dat(example_data):
#Initialize a new GameLibrary
with open(example_data) as reader:
#data = json.load(reader)
test = open(example_data)
json_library = json.load(test)
game_library = cc_data.CCDataFile()
for game_json in json_library:
new_game = cc_data.CCLevel()
new_game.level_number = game_json["level_number"]
new_game.time = game_json["time"]
new_game.num_chips = game_json["num_chips"]
new_game.upper_layer = game_json["upper_layer"]
new_game.lower_layer = game_json["lower_layer"]
result = game_json["optional_fields"]
result = []
for optional_fields_json in game_json["optional_fields"]:
new_field = None
if optional_fields_json["id"] == 1:
new_field = cc_data.CCMapHintField(
optional_fields_json["hint_text"])
if optional_fields_json["id"] == 2:
new_field = cc_data.CCEncodedPasswordField(
optional_fields_json["password_data"])
if optional_fields_json["id"] == 3:
new_field = cc_data.CCMapTitleField(
optional_fields_json["title"])
if optional_fields_json["id"] == 6:
monster_cords = []
for cords in optional_fields_json["monsters"]:
x = cords["x"]
y = cords["y"]
new_cord = cc_data.CCCoordinate(x, y)
monster_cords.append(new_cord)
new_field = cc_data.CCMonsterMovementField(monster_cords)
new_game.add_field(new_field)
game_library.add_level(new_game)
return game_library
def make_optional_field_from_json(optional_fields):
cc_level = cc_data.CCLevel()
for field in optional_fields:
if field["type"] == cc_data.CCMapTitleField.TYPE:
CC_title = cc_data.CCMapTitleField(field["title"])
elif field["type"] == cc_data.CCTrapControlsField.TYPE:
TrapFields = []
for trap in field["traps"]:
#print(trap)
bx = trap[0]
by = trap[1]
tx = trap[2]
ty = trap[3]
trapfield = cc_data.CCTrapControl(bx, by, tx, ty)
TrapFields.append(trapfield)
CC_TrapFields = cc_data.CCTrapControlsField(TrapFields)
elif field["type"] == cc_data.CCCloningMachineControlsField.TYPE:
CloFields = []
for clone in field["Cloning"]:
bx = clone[0]
by = clone[1]
tx = clone[2]
ty = clone[3]
clonefield = cc_data.CCCloningMachineControl(bx, by, tx, ty)
CloFields.append(clonefield)
CC_CloneMachine = cc_data.CCCloningMachineControlsField(CloFields)
elif field["type"] == cc_data.CCEncodedPasswordField.TYPE:
passwrod = field["password"]
CC_password = cc_data.CCEncodedPasswordField(passwrod)
elif field["type"] == cc_data.CCMapHintField.TYPE:
hint = field["hint"]
CC_hint = cc_data.CCMapHintField(hint)
elif field["type"] == cc_data.CCMonsterMovementField.TYPE:
MonsterFields = []
for monster in field["monsters"]:
x = monster[0]
y = monster[1]
monsterfield = cc_data.CCCoordinate(x, y)
MonsterFields.append(monsterfield)
CC_Monsterfield = cc_data.CCMonsterMovementField(MonsterFields)
cc_level.add_field(CC_title)
cc_level.add_field(CC_TrapFields)
cc_level.add_field(CC_CloneMachine)
cc_level.add_field(CC_password)
cc_level.add_field(CC_hint)
cc_level.add_field(CC_Monsterfield)
return cc_level.optional_fields
def json2dat(json_data):
dic_data = json.loads(json_data)
ccdata = cc_data.CCDataFile()
for level_dic in dic_data:
cclevel = cc_data.CCLevel()
#set non-field value
cclevel.level_number = level_dic['level_number']
cclevel.time = level_dic['time']
cclevel.num_chips = level_dic['num_chips']
cclevel.upper_layer = level_dic['upper_layer']
cclevel.lower_layer = level_dic['lower_layer']
#set optional field
if "monsters" in level_dic:
monsters = []
for x_y in level_dic["monsters"]:
coord = cc_data.CCCoordinate(x_y[0], x_y[1])
monsters.append(coord)
monsters_field = cc_data.CCMonsterMovementField(monsters)
cclevel.add_field(monsters_field)
if "traps" in level_dic:
trap_controls = []
for i in range(len(level_dic["traps"])):
trap_control = cc_data.CCTrapControl(level_dic["controls"][i][0],level_dic["controls"][i][1],level_dic["traps"][i][0],level_dic["traps"][i][1])
trap_controls.append(trap_control)
trap_controls_field = cc_data.CCTrapControlsField(trap_controls)
cclevel.add_field(trap_controls_field)
if "clone_machine" in level_dic:
clones = []
for i in range(len(level_dic["clone_machine"])):
clone = cc_data.CCCloningMachineControl(level_dic["clone_button"][i][0], level_dic["clone_button"][i][1], level_dic["clone_machine"][i][0], level_dic["clone_machine"][i][1])
clones.append(clone)
clones_field = cc_data.CCCloningMachineControlsField(clones)
cclevel.add_field(clones_field)
#set necessary field
map_title_field = cc_data.CCMapTitleField(level_dic['map_title'])
map_hint_field = cc_data.CCMapHintField(level_dic['map_hint'])
encoded_password_field = cc_data.CCEncodedPasswordField(level_dic['encoded_password'])
cclevel.add_field(map_title_field)
cclevel.add_field(map_hint_field)
cclevel.add_field(encoded_password_field)
#add level to ccdata
ccdata.add_level(cclevel)
return ccdata
def make_cc_from_json(json_file):
data = cc_data.CCDataFile()
for level in json_file["levels"]:
new_level = cc_data.CCLevel()
new_level.level_number = level["level number"]
new_level.time = level["time"]
new_level.num_chips = level["chip number"]
new_level.upper_layer = level["upper layer"]
new_level.lower_layer = level["lower layer"]
fields = make_field_from_optional(level["optional fields"])
for field in fields:
new_level.add_field(field)
data.add_level(new_level)
return data
def make_level_from_json(level_data):
"""
Reads data from a JSON file and constructs a CCLevel object
params:
json_file (string): file name of the JSON file to read
returns:
A CCLevel object constructed with the data from the given file
"""
level = cc_data.CCLevel()
# level.num_bytes = ?
level.level_number = level_data["level number"]
level.time = level_data["time"]
level.num_chips = level_data["chip count"]
level.upper_layer = level_data["upper layer"]
level.lower_layer = level_data["lower layer"]
# optional fields
for json_field in level_data["fields"]:
# determine which field to create based on type number.
cc_field = make_field_from_json(json_field["type"],
json_field["value"])
# add the optional field into the field list
level.add_field(cc_field)
return level
def make_levels_from_json(json_data):
#Initialize a new GameLibrary
data_file = cc_data.CCDataFile()
for level in json_data:
new_level = cc_data.CCLevel()
new_level.level_number = level["level_num"]
new_level.time = level["time"]
new_level.num_chips = level["chip_num"]
new_level.upper_layer = level["upper_layer"]
lower = []
step = 1024
while (step > 0):
lower.append(0)
step -= 1
new_level.lower_layer = lower
for option in level["optional_layers"]:
id = option["id"]
if (id == 3):
result = cc_data.CCMapTitleField(option["title"])
if (id == 6):
result = cc_data.CCEncodedPasswordField(option["pass"])
if (id == 7):
result = cc_data.CCMapHintField(option["hint"])
if (id == 10):
monsterList = []
for monster in option["coord"]:
monsterList.append(
cc_data.CCCoordinate(monster[0], monster[1]))
result = cc_data.CCMonsterMovementField(monsterList)
new_level.optional_fields.append(result)
data_file.add_level(new_level)
return data_file
def make_level_from_json(json_file):
cc_level = cc_data.CCLevel()
cc_level.level_number = json_file["level_number"]
#cc_level.optional_fields = make_optional_fields_from_json(json_datap["optional fields"])
return cc_level
def make_ccdat_from_json(json_data):
cc_dat = cc_data.CCDataFile()
for level in json_data["levels"]:
cclevel = cc_data.CCLevel()
cclevel.level_number = level["level_number"]
cclevel.time = level["time"]
cclevel.num_chips = level["chip_number"]
cclevel.upper_layer = level["upper_layer"]
cclevel.lower_layer = level["lower_layer"]
for field in level["option_fields"]:
if (field["type"] == 3):
mapfield = cc_data.CCMapTitleField(field["title"])
cclevel.add_field(mapfield)
elif (field["type"] == 6):
passwordfield = cc_data.CCEncodedPasswordField(
field["password"])
cclevel.add_field(passwordfield)
elif (field["type"] == 7):
hintfield = cc_data.CCMapHintField(field["hint"])
cclevel.add_field(hintfield)
elif (field["type"] == 10):
monsters = []
for coord in field["monsters"]:
ccCoord = cc_data.CCCoordinate(coord[0], coord[1])
monsters.append(ccCoord)
monsterfield = cc_data.CCMonsterMovementField(monsters)
cclevel.add_field(monsterfield)
elif (field["type"] == 4):
traps = []
for trap in field["traps"]:
coordsbutton = trap["button_coord"]
coordstrap = trap["trap_coord"]
cctrapcontrol = cc_data.CCTrapControl(
coordsbutton[0], coordsbutton[1], coordstrap[0],
coordstrap[1])
traps.append(cctrapcontrol)
trapfield = cc_data.CCTrapControlsField(traps)
cclevel.add_field(trapfield)
elif (field["type"] == 5):
machines = []
for machine in field["machines"]:
coordsbutton = machine["button_coord"]
coordsmachine = machine["machine_coord"]
ccmachinecontrol = cc_data.CCCloningMachineControl(
coordsbutton[0], coordsbutton[1], coordsmachine[0],
coordsmachine[1])
machines.append(ccmachinecontrol)
machinesfield = cc_data.CCCloningMachineControlsField(machines)
cclevel.add_field(machinesfield)
else:
continue
cc_dat.add_level(cclevel)
return cc_dat
def make_data_file_from_json(json_data):
data_file = cc_data.CCDataFile()
# Parse all levels
for level_data in json_data["levels"]:
level = cc_data.CCLevel()
level.level_number = level_data["level_number"]
level.time = level_data["time"]
level.num_chips = level_data["num_chips"]
level.upper_layer = level_data["upper_layer"]
level.lower_layer = level_data["lower_layer"]
# Parse all optional fields
for field_data in level_data["optional_fields"]:
field = None
type_val = field_data["type_val"]
# Parse Map Title
if (type_val == 3):
title = field_data["title"]
field = cc_data.CCMapTitleField(title)
# Parse Traps
elif (type_val == 4):
traps = []
for trap_data in field_data["traps"]:
bx = trap_data["bx"]
by = trap_data["by"]
tx = trap_data["tx"]
ty = trap_data["ty"]
trap = cc_data.CCTrapControl(bx, by, tx, ty)
traps.append(trap)
field = cc_data.CCTrapControlsField(traps)
# Parse Clone Machines
elif (type_val == 5):
machines = []
for machine_data in field_data["machines"]:
bx = machine_data["bx"]
by = machine_data["by"]
tx = machine_data["tx"]
ty = machine_data["ty"]
machine = cc_data.CCCloningMachineControl(bx, by, tx, ty)
machines.append(machine)
field = cc_data.CCCloningMachineControlsField(machines)
# Parse Password
elif (type_val == 6):
password = field_data["password"]
field = cc_data.CCEncodedPasswordField(password)
# Parse Hint
elif (type_val == 7):
hint = field_data["hint"]
field = cc_data.CCMapHintField(hint)
# Parse Moving Monsters
elif (type_val == 10):
monsters = []
for monster_data in field_data["monsters"]:
x = monster_data["x"]
y = monster_data["y"]
monster = cc_data.CCCoordinate(x, y)
monsters.append(monster)
field = cc_data.CCMonsterMovementField(monsters)
level.add_field(field)
data_file.add_level(level)
return data_file
def load_json_to_CCDataFile(json_data):
# ccDataFile is a container to hold all levels
# analagous to an overall list
ccDataFile = cc_data.CCDataFile()
with open(json_data, "r") as reader:
json_data = json.load(reader)
for item in json_data:
# ccLevel is an object that contains all info of a single level
ccLevel = cc_data.CCLevel()
ccLevel.level_number = item["level"]["level_number"]
ccLevel.time = item["level"]["time_limit"]
ccLevel.num_chips = item["level"]["chip_count"]
ccLevel.upper_layer = item["level"]["upper_layer"]
ccLevel.lower_layer = item["level"]["lower_layer"]
# title, password, and hint are three basic fields that
ccMapTitleField = cc_data.CCMapTitleField(
item["level"]["optional_fields"]["field_3"]["title"])
ccLevel.add_field(ccMapTitleField)
ccEncodedPasswordField = cc_data.CCEncodedPasswordField(
item["level"]["optional_fields"]["field_6"]["password"])
ccLevel.add_field(ccEncodedPasswordField)
ccMapHintField = cc_data.CCMapHintField(
item["level"]["optional_fields"]["field_7"]["hint"])
ccLevel.add_field(ccMapHintField)
# adding monsters can also be
ccMonsterMovementField = []
for monster in item["level"]["optional_fields"]["field_10"][
"monsters"]:
ccMonsterMovementField.append(
cc_data.CCCoordinate(monster[0], monster[1]))
ccMonsterMovementField = cc_data.CCMonsterMovementField(
ccMonsterMovementField)
ccLevel.add_field(ccMonsterMovementField)
# adding trap sets
ccTrapCoordinates = []
for trap in item["level"]["optional_fields"]["field_4"]["traps"]:
ccTrapCoordinates.append(
cc_data.CCTrapControl(trap[0], trap[1], trap[2], trap[3]))
ccTrapControlsField = cc_data.CCTrapControlsField(ccTrapCoordinates)
ccLevel.add_field(ccTrapControlsField)
# adding cloning machines
ccCloningMachines = []
for machine in item["level"]["optional_fields"]["field_5"][
"cloning machines"]:
ccCloningMachines.append(
cc_data.CCCloningMachineControl(machine[0], machine[1],
machine[2], machine[3]))
ccCloningMachineField = cc_data.CCCloningMachineControlsField(
ccCloningMachines)
ccLevel.add_field(ccCloningMachineField)
# adding levels into the ccDataFile Object
ccDataFile.levels.append(ccLevel)
return ccDataFile
def make_cc_data_file_from_json(json_data):
cc_data_file = cc_data.CCDataFile()
for json_level in json_data:
cc_level = cc_data.CCLevel()
cc_level.level_number = json_level["level_number"]
cc_level.time = json_level["time"]
cc_level.num_chips = json_level["num_chips"]
cc_level.upper_layer = json_level["upper_layer"]
cc_level.lower_layer = json_level["lower_layer"]
#Handle optional fields
json_fields = json_level["optional_fields"]
for json_field in json_fields:
field_type = json_field["type"]
if field_type == "title":
# print("title field!")
title = json_field["title"]
cc_title_field = cc_data.CCMapTitleField(title)
cc_level.add_field(cc_title_field)
elif field_type == "hint":
# print("hint field!")
hint = json_field["hint"]
cc_hint_field = cc_data.CCMapHintField(hint)
cc_level.add_field(cc_hint_field)
elif field_type == "password":
# print("password field!")
password = json_field["password"]
cc_password_field = cc_data.CCEncodedPasswordField(password)
cc_level.add_field(cc_password_field)
elif field_type == "monster":
# print("monster field!")
monsters = json_field["monsters"]
cc_monster_coordinate = []
for monster in monsters:
cc_monster_coordinate.append(
cc_data.CCCoordinate(monster[0], monster[1]))
cc_monsters_field = cc_data.CCMonsterMovementField(
cc_monster_coordinate)
cc_level.add_field(cc_monsters_field)
elif field_type == "clone_machines":
clone_machines = json_field["clone_machines"]
cc_machine = []
for clone_machine in clone_machines:
bx = clone_machine["button_coord"][0]
by = clone_machine["button_coord"][1]
tx = clone_machine["machine_coord"][0]
ty = clone_machine["machine_coord"][1]
cc_machine.append(
cc_data.CCCloningMachineControl(bx, by, tx, ty))
cc_clone_machine_field = cc_data.CCCloningMachineControlsField(
cc_machine)
cc_level.add_field(cc_clone_machine_field)
elif field_type == "traps":
traps = json_field["traps"]
cc_trap = []
for trap in traps:
bx = trap["button_coord"][0]
by = trap["button_coord"][1]
tx = trap["trap_coord"][0]
ty = trap["trap_coord"][1]
cc_trap.append(cc_data.CCTrapControl(bx, by, tx, ty))
cc_trap_field = cc_data.CCTrapControlsField(cc_trap)
cc_level.add_field(cc_trap_field)
else:
print("no other field")
print(cc_level)
cc_data_file.add_level(cc_level)
return cc_data_file
