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")
