def make_field_from_json(type, value): ''' Reads data from a field data and build different types of fields according to type number. params: type (int): the type number specified in json file value: the value of the field returns: A specific kind of CCField object constructed with the data from the given file ''' if type == 3: return cc_data.CCMapTitleField(value) elif type == 6: return cc_data.CCEncodedPasswordField(value) elif type == 7: return cc_data.CCMapHintField(value) elif type == 10: coordinate_list = [] for i in value: coordinate_list.append(cc_data.CCCoordinate(i[0], i[1])) return cc_data.CCMonsterMovementField(coordinate_list) # optional field types elif type == 4: coordinate_list = [] for i in value: coordinate_list.append( cc_data.CCTrapControl(i[0], i[1], i[2], i[3])) return cc_data.CCTrapControlsField(coordinate_list) elif type == 5: coordinate_list = [] for i in value: coordinate_list.append( cc_data.CCCloningMachineControl(i[0], i[1], i[2], i[3])) return cc_data.CCCloningMachineControlsField(coordinate_list)
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_field_from_bytes(field_type, field_bytes): """Constructs and returns the appropriate cc field Args: field_type (int) : what type of field to construct field_bytes (bytes) : the binary data to be used to create the field """ if field_type == cc_data.CCMapTitleField.TYPE: return cc_data.CCMapTitleField(get_string_from_bytes(field_bytes)) elif field_type == cc_data.CCTrapControlsField.TYPE: trap_count = int(len(field_bytes) / 10) traps = [] for t_index in range(trap_count): i = t_index * 10 bx = int.from_bytes(field_bytes[i:(i + 2)], byteorder=cc_data.BYTE_ORDER) by = int.from_bytes(field_bytes[i + 2:(i + 4)], byteorder=cc_data.BYTE_ORDER) tx = int.from_bytes(field_bytes[i + 4:(i + 6)], byteorder=cc_data.BYTE_ORDER) ty = int.from_bytes(field_bytes[i + 6:(i + 8)], byteorder=cc_data.BYTE_ORDER) traps.append(cc_data.CCTrapControl(bx, by, tx, ty)) return cc_data.CCTrapControlsField(traps) elif field_type == cc_data.CCCloningMachineControlsField.TYPE: machine_count = int(len(field_bytes) / 8) machines = [] for m_index in range(machine_count): i = m_index * 8 bx = int.from_bytes(field_bytes[i:(i + 2)], byteorder=cc_data.BYTE_ORDER) by = int.from_bytes(field_bytes[i + 2:(i + 4)], byteorder=cc_data.BYTE_ORDER) tx = int.from_bytes(field_bytes[i + 4:(i + 6)], byteorder=cc_data.BYTE_ORDER) ty = int.from_bytes(field_bytes[i + 6:(i + 8)], byteorder=cc_data.BYTE_ORDER) machines.append(cc_data.CCCloningMachineControl(bx, by, tx, ty)) return cc_data.CCCloningMachineControlsField(machines) elif field_type == cc_data.CCEncodedPasswordField.TYPE: # passwords are encoded as a list of ints password = [] # A bytes object behaves as a list of integers # password data is terminated with a zero, iterate to one short of the end of the array for b in field_bytes[0:(len(field_bytes)-1)]: password.append(b) return cc_data.CCEncodedPasswordField(password) elif field_type == cc_data.CCMapHintField.TYPE: return cc_data.CCMapHintField(get_string_from_bytes(field_bytes)) elif field_type == cc_data.CCPasswordField.TYPE: return cc_data.CCPasswordField(get_string_from_bytes(field_bytes)) elif field_type == cc_data.CCMonsterMovementField.TYPE: monster_count = int(len(field_bytes) / 2) monsters = [] for m_index in range(monster_count): i = m_index * 2 x = int.from_bytes(field_bytes[i:(i + 1)], byteorder=cc_data.BYTE_ORDER) y = int.from_bytes(field_bytes[i + 1:(i + 2)], byteorder=cc_data.BYTE_ORDER) monsters.append(cc_data.CCCoordinate(x, y)) return cc_data.CCMonsterMovementField(monsters) else: if __debug__: raise AssertionError("Unsupported field type: " + str(field_type)) return cc_data.CCField(field_type, field_bytes)
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_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_optional_fields_from_json(json_optional_fields): cc_fields = [] for json_field in json_optional_fields: field_type = json_field["type"] if field_type == cc_data.CCMapTitleField.TYPE: cc_field = cc_data.CCMapTitleField(json_field["title"]) cc_fields.append(cc_field) elif field_type == cc_data.CCTrapControlsField.TYPE: cc_traps = [] for json_trap in json_field["traps"]: bx = json_trap["button"][0] by = json_trap["button"][1] tx = json_trap["trap"][0] ty = json_trap["trap"][1] cc_traps.append(cc_data.CCTrapControl(bx, by, tx, ty)) cc_field = cc_data.CCTrapControlsField(cc_traps) cc_fields.append(cc_field) elif field_type == cc_data.CCCloningMachineControlsField.TYPE: cc_machines = [] for json_machine in json_field["cloning_machines"]: bx = json_machine["button"][0] by = json_machine["button"][1] tx = json_machine["machine"][0] ty = json_machine["machine"][1] cc_machines.append( cc_data.CCCloningMachineControl(bx, by, tx, ty)) cc_field = cc_data.CCCloningMachineControlsField(cc_machines) cc_fields.append(cc_field) elif field_type == cc_data.CCEncodedPasswordField.TYPE: cc_field = cc_data.CCEncodedPasswordField(json_field["password"]) cc_fields.append(cc_field) elif field_type == cc_data.CCMapHintField.TYPE: cc_field = cc_data.CCMapHintField(json_field["hint"]) cc_fields.append(cc_field) elif field_type == cc_data.CCMonsterMovementField.TYPE: cc_monsters = [] for json_monster in json_field["monsters"]: x = json_monster[0] y = json_monster[1] cc_monsters.append(cc_data.CCCoordinate(x, y)) cc_field = cc_data.CCMonsterMovementField(cc_monsters) cc_fields.append(cc_field) else: return None return cc_fields
def make_optional_fields_from_json(json_optional_fields): #take array of optional fields from json file and returns cc_fields cc_fields = [] for json_field in json_optional_fields: # for each item in array json_optional_fields array... field_type = json_field["type"] # determine field type if field_type == cc_data.CCMapTitleField.TYPE: #Type 3 cc_field = cc_data.CCMapTitleField(json_field["title"])#CCMapTitleField requires input of a string cc_fields.append(cc_field) elif field_type == cc_data.CCTrapControlsField.TYPE: #Type 4 - CCTrapControls field requires input of list of traps cc_traps =[] #create list of traps for json_trap in json_field["traps"]: #each trap in json_field["traps"] array has x,y coordinates for a button and corresponding trap bx = json_trap["button"][0] by = json_trap["button"][1] tx = json_trap["trap"][0] ty = json_trap["trap"][1] cc_traps.append(cc_data.CCTrapControl(bx,by,tx,ty)) # CCTrapControl requires input of four integers cc_field = cc_data.CCTrapControlsField(cc_traps) #add list of traps to CCTrapControlsField cc_fields.append(cc_field) elif field_type == cc_data.CCCloningMachineControlsField.TYPE: #Type 5 cc_machines = [] #A cloning machine control field is defined by a list of machines for json_machine in json_field["machines"]: #single cloning machine control has member vars button coord and machine coord bx= json_machine["button"][0] by = json_machine["button"][1] tx = json_machine["machine"][0] ty = json_machine["machine"][1] cc_machines.append(cc_data.CCCloningMachineControl(bx,by,tx,ty))#similar to Trap field... cc_field = cc_data.CCCloningMachineControlsField(cc_machines) cc_fields.append(cc_field) elif field_type == cc_data.CCEncodedPasswordField.TYPE: #Type 6 - similar to title cc_field = cc_data.CCEncodedPasswordField(json_field["password"])#CCEncodedPasswordField requires list of 4-9 integers cc_fields.append(cc_field) elif field_type == cc_data.CCMapHintField.TYPE: #Type 7 - CCMapHintField requires string input cc_field = cc_data.CCMapHintField(json_field["hint"]) cc_fields.append(cc_field) elif field_type == cc_data.CCMonsterMovementField.TYPE: #Type 10 - CCMonsterMovementField requires a list of monsters coordinates cc_monsters = []#list of monster coordinates for json_monster in json_field["monsters"]:# The monsters list consist of x,y coordinates for each monster x = json_monster[0] y = json_monster[1] cc_monsters.append(cc_data.CCCoordinate(x,y))#CCCordinate requires int input x and y cc_field = cc_data.CCMonsterMovementField(cc_monsters) cc_fields.append(cc_field) return cc_fields
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 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
def make_field_from_optional(optional_fields): fields = [] for field in optional_fields: new_field = None # title field if (field["field type"] == 3): new_field = cc_data.CCMapTitleField(field["title"]) # traps field elif (field["field type"] == 4): traps = [] locations = field["traps"] for location in locations: bx = location["bx"] by = location["by"] tx = location["tx"] ty = location["ty"] control = cc_data.CCTrapControl(bx, by, tx, ty) traps.append(control) new_field = cc_data.CCTrapControlsField(traps) # cloning machine field elif (field["field type"] == 5): machines = [] locations = field["cloning machines"] for location in locations: bx = location["bx"] by = location["by"] tx = location["tx"] ty = location["ty"] control = cc_data.CCCloningMachineControl(bx, by, tx, ty) machines.append(control) new_field = cc_data.CCCloningMachineControlsField(machines) # encoded password field elif (field["field type"] == 6): new_field = cc_data.CCEncodedPasswordField(field["password"]) # hint field elif (field["field type"] == 7): new_field = cc_data.CCMapHintField(field["hint"]) # monsters / moving objects field elif (field["field type"] == 10): monsters = [] locations = field["monsters"] for location in locations: x = location["x"] y = location["y"] coordinate = cc_data.CCCoordinate(x, y) monsters.append(coordinate) new_field = cc_data.CCMonsterMovementField(monsters) fields.append(new_field) return fields
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