def parse_event(event_dict):
"""Dynamic parsing of DialogEvent"""
text = get_element(event_dict, "text")
if text is None:
return None
text2 = get_element(event_dict, "text2")
if text2 is None:
text2 = ''
dialog_event = DialogEvent(get_level(), text, text2)
answers = get_element(event_dict, "answers")
if answers is not None:
for answer_key in answers:
if isinstance(answers[answer_key],dict):
answers[answer_key] = parse_event_json(answers[answer_key], dialog_event)
elif isinstance(answers[answer_key], CONST.string_type):
answers[answer_key] = load_event(answers[answer_key], dialog_event)
dialog_event.set_answers(answers)
return dialog_event
def load_image_from_json(image_data, level, image_type=None):
global global_object_id
image = None
if image_type is None:
try:
image_type = image_data["type"]
except KeyError:
log("Error: No image_type for:" + str(image_data),1)
return
pos = get_element(image_data, "pos")
size = get_element(image_data, "size")
layer = get_element(image_data, "layer")
angle = get_element(image_data, "angle")
object_id = get_element(image_data, "id")
if object_id is None:
object_id = global_object_id
if angle is None:
angle = 0
if image_type == "GameObject":
image = GameObject()
image.pos = Vector2(pos)
image.size = Vector2(size)
image.update_rect()
image.angle = angle
image.id = object_id
elif image_type == "Image":
image = Image.parse_image(image_data, pos, size, angle)
if image is not None:
image.id = object_id
elif image_type == "Text":
font = get_element(image_data, "font")
text = get_element(image_data, "text")
color = get_element(image_data, "color")
if font and text:
font = CONST.path_prefix+font
else:
log("Invalid arg font and text not defined for Text",1)
return
if not color:
color = [0,0,0]
image = Text(pos, size, font, text, angle,color)
image.id = object_id
else:
if not isinstance(image_type,CONST.string_type):
log("image_type not a string",1)
return
for c in image_type:
if c != '.' and c != '_' and not c.isalpha():
return
dir_list = image_type.split(".")
try:
exec('''from %s import %s'''%(".".join(dir_list[0:len(dir_list)-1]), dir_list[len(dir_list)-1]))
except ImportError:
log("Error: ImportError with: "+str(image_type),1)
return
try:
d = locals()
exec('''image = %s.parse_image(image_data, pos, size, angle)'''%(dir_list[len(dir_list)-1]),globals(),d)
image = d['image']
except Exception as e:
import traceback
log('Error with loading image_type: %s'%(image_type)+" "+str(e),1)
traceback.print_exc()
return
physic_objects = get_element(image_data, "physic_objects")
if physic_objects:
load_physic_objects(physic_objects, image)
event_path = get_element(image_data, "event")
if image and event_path:
image.event = load_event(event_path)
if not layer or layer < 0:
layer = 1
elif layer > len(level.objects)-1:
layer = len(level.objects)-1
if image:
level.objects[layer-1].append(image)
global_object_id += 1
return image
def load_level(level):
"""
Import a level with:
-Physics static object
-Images with or without animation
-IA (if any)
-Player position, size, etc... but not recreate the player!!!
"""
level_data = load_json(CONST.path_prefix+level.filename)
if level_data is not None:
log("LOAD PLAYER")
player_data = get_element(level_data, 'player')
if player_data is not None:
'''load the json containing the player
and treat it as an AnimImage'''
player = None
if isinstance(player_data, CONST.string_type):
log("Loading player "+player_data)
player_json = load_json(CONST.path_prefix + player_data)
player = load_image_from_json(player_json, level)
elif isinstance(player_data,dict):
player = load_image_from_json(player_data, level)
else:
log("Warning: Invalid format for player JSON",1)
if player:
level.player = player
log("LOAD GUI")
gui_data = get_element(level_data, 'gui')
if gui_data is not None:
'''load the json containing the gui
parameters'''
if isinstance(gui_data, CONST.string_type):
GUI.load_gui_json(load_json(gui_data),level)
elif isinstance(gui_data,dict):
GUI.load_gui_json(gui_data,level)
else:
log("Warning: invalid format for GUI JSON",1)
log("LOAD_BG COLOR")
bg_color = get_element(level_data,'bg_color')
if bg_color is not None:
level.bg_color = bg_color
show_mouse = get_element(level_data,'show_mouse')
if show_mouse is not None:
level.show_mouse = show_mouse
use_physics = get_element(level_data,'use_physics')
if use_physics is not None:
level.use_physics = use_physics
network = get_element(level_data, 'network')
if network is not None:
level.use_network = network
log("LOAD EVENTS")
event_data = get_element(level_data, "events")
if event_data:
for e in event_data.keys():
level.event[e] = load_event(event_data[e])
log("LOAD ImAGE OBJECTS")
objects_dict = get_element(level_data, 'objects')
reset_object_id()
if objects_dict is not None:
for object_data in objects_dict:
if isinstance(object_data, CONST.string_type):
load_image_from_json(load_json(object_data), level, None)
elif isinstance(object_data,dict):
image_type = get_element(object_data,"type")
load_image_from_json(object_data,level,image_type)
checkpoints = get_element(level_data, 'checkpoints')
if checkpoints:
log("CHECKPOINTS LIST: "+str(checkpoints))
v_checkpoints = []
for c in checkpoints:
v_checkpoints.append(Vector2(c))
level.checkpoints = v_checkpoints
log("END OF LOADING")
return True
return False
