import cc_dat_utils import cc_json_utils json_data = cc_json_utils.make_cc_data_from_json("data/sglickma_testData.json") cc_dat_utils.write_cc_data_to_dat(json_data, "data/sglickma_testData.dat") dat_data = cc_dat_utils.make_cc_data_from_dat("data/sglickma_testData.dat") print(dat_data)
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 # Load Custom Data input_json_file = "data/jhliu_cc1.json" with open(input_json_file, "r") as reader: json_data = json.load(reader) level_data = make_level_library_from_json(json_data) # Save Data to DAT cc_dat_utils.write_cc_data_to_dat(level_data, "jhliu_cc1.dat")
import sys import json from cc_json_utils import make_cc_data_from_json #Import functions from other files from cc_dat_utils import write_cc_data_to_dat input_json_file = "eye_testData4.json" cc_dat = make_cc_data_from_json(input_json_file) #input name of json file write_cc_data_to_dat(cc_dat, "eye_testData4.dat") # create dat file from json file
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 input_json_file = "data/lubhaank_cc1.json" with open(input_json_file, "r") as reader: ccdat_json = json.load(reader) cc_data_all_levels = make_ccdat_from_json(ccdat_json) output_dat_file = "data/lubhaank_cc1.dat" cc_dat_utils.write_cc_data_to_dat(cc_data_all_levels, output_dat_file) #print(cc_data_all_levels)
import cc_dat_utils import cc_json_utils import sys # print(str(cc_dat_utils.make_cc_data_from_dat("data/pfgd_test.dat"))) default_input_json_file = "data/uuppal_cc1.json" default_output_dat_file = "data/uuppal_cc1.dat" if len(sys.argv) == 3: input_json_file = sys.argv[1] output_dat_file = sys.argv[2] print("Using command line args:", input_json_file, output_dat_file) else: print("Unknown command line options. Using default values:", default_input_json_file, default_output_dat_file) input_json_file = default_input_json_file output_dat_file = default_output_dat_file json_data = cc_json_utils.make_cc_data_from_json(input_json_file) cc_dat_utils.write_cc_data_to_dat(json_data, output_dat_file) dat_data = cc_dat_utils.make_cc_data_from_dat(output_dat_file) print(dat_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 # Part 3 # Load your custom JSON file with open("data/sehenry_cc_level_data.json", "r") as reader: test_json = json.load(reader) # Convert JSON data to cc_data new_level_library = cc_data.CCDataFile() for level_json in test_json["Levels"]: new_level = make_cc_level_from_json(level_json) new_level_library.add_level(new_level) print(new_level_library) # cc_level_data = make_cc_level_from_json(test_json) # Save converted data to DAT file cc_dat_utils.write_cc_data_to_dat(new_level_library, "data/sehenry_cc_level_data.dat") # # print(pfgd_test_data) # print(cc_level_data)
cc_dat = cc_dat_utils.make_cc_data_from_dat("data/intro.dat") print(cc_dat) #print("data/pfgd_test.dat") #Part 2 input_json_file = "data/test_data.json" ### Begin Add Code Here ### #Open the file specified by input_json_file #Use the json module to load the data from the file #Use make_game_library_from_json(json_data) to convert the data to GameLibrary data #Print out the resulting GameLibrary data using print_game_library(game_library_data) in test_data.py ### End Add Code Here ### game_library = test_json_utils.make_game_library_from_json(input_json_file) #print(game_library) #Part 3 #Load your custom JSON file #Convert JSON data to cc_data #Save converted data to DAT file input_json_file = "data/zxiong_cc1.json" with open(input_json_file, 'r') as reader: json_cc_data = json.load(reader) cc_data_file = cc_json_utils.make_cc_data_file_from_json(json_cc_data) #print(cc_data_file) cc_dat_utils.write_cc_data_to_dat(cc_data_file, "data/zxiong_cc1.dat")
# 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 #Part 3 fileName = "data/sunghoch_cc2" #Load your custom JSON file input_json_file = fileName + ".json" with open(input_json_file, "r") as reader: data = json.load(reader) #Convert JSON data to cc_data data_file = make_data_file_from_json(data) #Save converted data to DAT file output_dat_file = fileName + ".dat" cc_dat_utils.write_cc_data_to_dat(data_file, output_dat_file)
import sys import json from cc_json_utils import make_cc_data_from_json #Import functions from other files from cc_dat_utils import write_cc_data_to_dat default_input_json_file = "data/eye_cc1.json" default_output_dat_file = "data/eye_cc1.dat" if len(sys.argv) == 3: input_json_file = sys.argv[1] output_dat_file = sys.argv[2] print("Using command line args:", input_json_file, output_dat_file) else: print("Unknown command line options. Using default values:", default_input_json_file, default_output_dat_file) input_json_file = default_input_json_file output_dat_file = default_output_dat_file cc_dat = make_cc_data_from_json(input_json_file) #input name of json file write_cc_data_to_dat(cc_dat, output_dat_file) # create dat file from json file
text_file.close() #Part 2 input_json_file = "data/test_data.json" ### Begin Add Code Here ### #Open the file specified by input_json_file #Use the json module to load the data from the file json_data = json.load(open(input_json_file)) #Use make_game_library_from_json(json_data) to convert the data to GameLibrary data game_library = test_json_utils.make_game_library_from_json(json_data) #Print out the resulting GameLibrary data using print_game_library(game_library_data) in test_data.py print (game_library) ### End Add Code Here ### ''' #Part 3 #Load your custom JSON file input_level_json_file = "data/jiajunl2_cc1.json" output_level_dat_file = "data/jiajunl2_cc1.dat" with open(input_level_json_file, 'r') as json_file, open(output_level_dat_file, 'w') as dat_file: json_level_data = json.load(json_file) #Convert JSON data to cc_data cc_data = cc_json_utils.make_cc_data_from_json(json_level_data) #Save converted data to DAT file #print(cc_data) cc_dat_utils.write_cc_data_to_dat(cc_data, output_level_dat_file)
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 input_json_file = "data/level_data.json" with open(input_json_file, "r") as reader: game_json = json.load(reader) dat_file = make_levels_from_json(game_json) cc_dat_utils.write_cc_data_to_dat(dat_file, "data/pfgd_test.dat") print(dat_file)
import cc_dat_utils, cc_json_utils, cc_data, sys if len(sys.argv) == 3: input = sys.argv[1] output = sys.argv[2] print("input:" + input + " --> output:" + output) cc_data = cc_json_utils.make_cc_data_from_json(input) cc_dat_utils.write_cc_data_to_dat(cc_data, output) print("complete") else: print("wrong number of arguments!")
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 input_json_file = "data/format.json" with open(input_json_file, "r") as reader: final = json.load(reader) final2 = make_ccfile_from_json(final) print(final2) cc_dat_utils.write_cc_data_to_dat(final2, "data/format.dat") cc_dat_utils.write_cc_data_to_dat(final2, "tworld1.3.2win32/data/format.dat")
cc_machines.append(machine_control) cc_field = cc_data.CCCloningMachineControlsField(cc_machines) level.add_field(cc_field) elif json_field["type_val"] == 4: json_traps = json_field["traps"] cc_traps = [] for json_trap in json_traps: c = json_trap["button_coord"][0] d = json_trap["button_coord"][1] a = json_trap["trap_coord"][0] b = json_trap["trap_coord"][1] trap_control = cc_data.CCTrapControl(c,d,a,b) cc_traps.append(trap_control) cc_field = cc_data.CCTrapControlsField(cc_traps) level.add_field(cc_field) finalData.add_level(level) print(level) if len(sys.argv) == 3: input_json_file = sys.argv[1] output_dat_file = sys.argv[2] print("Using command line args:", input_json_file, output_dat_file) else: input_json_file = default_input_json_file output_dat_file = default_output_dat_file print("Unknown command line options. Using default values:", input_json_file, output_dat_file) cc_dat_utils.write_cc_data_to_dat(finalData,output_dat_file)
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 cc_dat_utils.write_cc_data_to_dat(load_json_to_CCDataFile("yunziw_cc1.json"), "yunziw_cc1.dat") cc_dat_utils.make_cc_data_from_dat("yunziw_cc1.dat")
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 with open("data/emcdonal_cc1.json", "r") as reader: json_game = json.load(reader) game = convert_json_to_dat(json_game) print(game) cc_dat_utils.write_cc_data_to_dat(game, "data/emcdonal_cc1.dat")
def transform(json_file): cc_dat = cc_data.CCDataFile() for each_level in json_file: ccl = cc_data.CCLevel() ccl.level_number = each_level["level_number"] ccl.time = each_level["time"] ccl.num_chips = each_level["num_chips"] ccl.upper_layer = each_level["upper_layer"] ccl.lower_layer = each_level["lower_layer"] optional_layer = each_level["optional_layer"] title = handling_optional(3, optional_layer) ccmt = cc_data.CCMapTitleField(title) ccl.optional_fields.append(ccmt) if handling_optional(4, optional_layer) != None: brown_button_trap = handling_optional(4, optional_layer) butt_trap_list = [] l = len(brown_button_trap) i = 0 while (i < l): buttCoor = brown_button_trap[i] trapCoor = brown_button_trap[i+1] butt_trap_list.append(cc_data.CCTrapControl (buttCoor[0],buttCoor[1],trapCoor[0],trapCoor[1])) i = i + 2 cctc = cc_data.CCTrapControlsField(butt_trap_list) ccl.optional_fields.append(cctc) if handling_optional(5, optional_layer) != None: red_button = handling_optional(5, optional_layer) red_button_cloning_list = [] for each_set in red_button: buttCoor = each_set[0] cloningCoor = each_set[1] red_button_cloning_list.append(cc_data.CCCloningMachineControl (buttCoor[0],buttCoor[1],cloningCoor[0],cloningCoor[1])) cccm = cc_data.CCCloningMachineControl(red_button_cloning_list) ccl.optional_fields.append(cccm) password = handling_optional(6, optional_layer) ccep = cc_data.CCEncodedPasswordField(password) ccl.optional_fields.append(ccep) if handling_optional(7, optional_layer) != None: hint = handling_optional(7, optional_layer) ccmh = cc_data.CCMapHintField(hint) ccl.optional_fields.append(ccmh) if handling_optional(10, optional_layer) != None: monsters = handling_optional(10, optional_layer) monster_list = [] for each_monster in monsters: mx = each_monster[0] my = each_monster[1] monCoor = cc_data.CCCoordinate(mx, my) monster_list.append(monCoor) ccmm = cc_data.CCMonsterMovementField(monster_list) ccl.optional_fields.append(ccmm) cc_dat.levels.append(ccl) cc_dat_utils.write_cc_data_to_dat(cc_dat, "ziqiaot.dat")
def make_dat_from_json(json_file, dat_output_name): # cc_file made from a given json file cc_file = make_cc_from_json(json_file) return cc_dat_utils.write_cc_data_to_dat(cc_file, dat_output_name)
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 #Part 3 #Load your custom JSON file json_data = (open('data/bwang2_cc1.json','r').read()) #Convert JSON data to cc_data ccdata = json2dat(json_data) #Save converted data to DAT file dat_file_name = 'data/bwang2_cc1.dat' cc_dat_utils.write_cc_data_to_dat(ccdata, dat_file_name)
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 example_data = "data/example_data.json" game_library = make_level_from_dat(example_data) print(game_library) cc_dat_utils.write_cc_data_to_dat(game_library, "data/copy_of_new_game.dat") #Part 3 #Load your custom JSON file #Convert JSON data to cc_data #Save converted data to DAT file
# 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 #Part 2 input_json_file = "data/sarahwan_cc1.json" with open(input_json_file, "r") as reader: cc_json = json.load(reader) print("JSON data:") print(cc_json) print("Function output:") print(make_cc_file_from_json(cc_json)) cc_game_data = make_cc_file_from_json(cc_json) cc_dat_utils.write_cc_data_to_dat(cc_game_data, "data/sarahwan_cc1.dat")
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 with open("data/joannele_cc1.json", "r") as reader: format_json = json.load(reader) CCData = make_CC_data_from_JSON(format_json) dat_file = "data/joannele_cc1.dat" cc_dat_utils.write_cc_data_to_dat(CCData, dat_file)
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 # define load and save file path load_file_path = "data/yunhaol_cc_level_data.json" save_file_path = "data/yunhaol_cc_level_data.dat" with open(load_file_path, "r") as reader: data = json.load(reader) # Convert JSON data to cc_data level_set = make_datafile_from_json(data) # Save converted data to DAT file cc_dat_utils.write_cc_data_to_dat(level_set, save_file_path) # test # read_data = make_cc_data_from_dat(save_file_path) # print(read_data)
# Handling command line arguments # Note: sys.argv is a list of strings that contains each command line argument # The first element in the list is always the name of the python file being run # Command line format: <input json filename> <output dat filename> default_input_json_file = "data/cleo_cc1.json" default_output_dat_file = "data/cleo_cc1.dat" if len(sys.argv) == 3: input_json_file = sys.argv[1] output_dat_file = sys.argv[2] print("Using command line args:", input_json_file, output_dat_file) else: input_json_file = default_input_json_file output_dat_file = default_output_dat_file print("Unknown command line options. Using default values:", input_json_file, output_dat_file) # Reading the JSON data in from the input file json_reader = open(input_json_file, "r") json_data = json.load(json_reader) json_reader.close() #Close the file now that we're done using it # Build the Python data structure from the JSON data cc_levels = make_ccDataFile_from_json(json_data) # Write data to DAT file print("Writing data to output file", output_dat_file) cc_dat_utils.write_cc_data_to_dat(cc_levels, output_dat_file)
#This should enter into one sub heading of the dictionary per entry level_heading = "Level #" + str(index) print("Testing level header" + level_heading) level = make_level_from_json(i[level_heading]) data.levels.append(level) index = index+1 print("Number of levels:" + str(len(data.levels))) return data """ #Ask for the input file input_json_filename = input("Enter your input json filename, then press enter:") #Ask for the output file output_dat_filename = input("Enter your output dat filename, then press enter:") """ #Get command line data command_line_input = sys.argv #Note that the 0th element is the name of this script input_json_filename = command_line_input[1] print("Args" + str(command_line_input)) output_dat_filename = command_line_input[2] print("Now taking data from" +input_json_filename + "and turning it into a playable CC level.") print("Look for the playable level as "+ output_dat_filename) #Make a CCdatafile; change name to output dat file name? cc_data_file = make_cc_data_from_json(input_json_filename) #Make a dat file from the cc_data cc_dat_utils.write_cc_data_to_dat(cc_data_file, output_dat_filename)
import cc_dat_utils,json import cc_json_utils testData = cc_dat_utils.make_cc_data_from_dat("data/pfgd_test.dat") #print(str(testData)) #cc_dat_utils.write_cc_data_to_dat(testData, "data/pfgd_test_remake.dat") from pprint import pprint with open('data/sunghohw_cc1.json') as data_file: data = json.load(data_file) cc_data = cc_json_utils.make_cc_data_from_json("data/sunghohw_cc1.json") cc_dat_utils.write_cc_data_to_dat(cc_data,"data/sunghohw_cc1.dat")