class Obstacles(): def __init__(self, screen, obstacles, characters, items): self.screen = screen self.obstacles = obstacles self.characters = characters self.items = items self.layers = [[], []] self.rect_obstacles = [] self.charactermap = [] self.triggers = [] self.item_map = [] self.selected = None self.screen_offset = [0, 0] self.properties_frame = None def save(self, path): final_characters = [character.get_dict() for character in self.charactermap] final_items = [item.get_dict() for item in self.item_map] final_triggers = [trigger.get_dict() for trigger in self.triggers] final_obstacles = [[obstacle.get_dict() for obstacle in self.layers[0] + self.rect_obstacles], [obstacle.get_dict() for obstacle in self.layers[1]]] with open(os.path.join(path, "characters.py"), "w") as f: f.write("characters = " + repr(final_characters)) with open(os.path.join(path, "items.py"), "w") as f: f.write("items = " + repr(final_items)) with open(os.path.join(path, "triggers.py"), "w") as f: f.write("triggers = " + repr(final_triggers)) with open(os.path.join(path, "obstacles.py"), "w") as f: f.write("layers = " + repr(final_obstacles)) def gen_real_rect(self, mapsize): self.mapsize = mapsize real_height = mapsize[1] * (ISOHEIGHT // 2) + mapsize[0] * (ISOHEIGHT // 2) real_width = mapsize[1] * (ISOWIDTH // 2) + mapsize[0] * (ISOWIDTH // 2) startx = -(mapsize[1] * (ISOWIDTH // 2)) starty = 0 return Rect(startx, starty, real_width, real_height) def create_map(self, mapsize): self.realrect_quadtree = QuadTree(self.gen_real_rect(mapsize), 0, 5, 10, [], "realrect") self.floor_quadtree = QuadTree(Rect(0, 0, mapsize[0] * WIDTH, mapsize[1] * TILEHEIGHT), 0, 5, 10, [], "rect") self.layers = [[], []] self.rect_obstacles = [] self.charactermap = [] self.triggers = [] self.item_map = [] self.refresh_realrect_quadtree() self.refresh_floor_quadtree() self.map_diam = math.ceil(math.sqrt(self.mapsize[0] ** 2 + self.mapsize[1] ** 2)) def load_map(self, path, mapsize): self.realrect_quadtree = QuadTree(self.gen_real_rect(mapsize), 0, 5, 10, [], "realrect") self.floor_quadtree = QuadTree(Rect(0, 0, mapsize[0] * WIDTH, mapsize[1] * TILEHEIGHT), 0, 5, 10, [], "rect") self.load_obstaclemap(os.path.join(path, "obstacles.py")) self.load_charactermap(os.path.join(path, "characters.py")) self.load_triggermap(os.path.join(path, "triggers.py")) self.load_item_map(os.path.join(path, "items.py")) self.refresh_realrect_quadtree() self.refresh_floor_quadtree() self.map_diam = math.ceil(math.sqrt(self.mapsize[0] ** 2 + self.mapsize[1] ** 2)) def change_size(self, size): self.mapsize = size self.realrect_quadtree = QuadTree(self.gen_real_rect(self.mapsize), 0, 5, 10, [], "realrect") self.floor_quadtree = QuadTree(Rect(0, 0, self.mapsize[0] * WIDTH, self.mapsize[1] * TILEHEIGHT), 0, 5, 10, [], "rect") self.refresh_realrect_quadtree() self.refresh_floor_quadtree() self.map_diam = math.ceil(math.sqrt(self.mapsize[0] ** 2 + self.mapsize[1] ** 2)) def delete_item(self, item): self.item_map.remove(item) def add_item(self, item): self.item_map.append(self.create_item(item)) def create_item(self, info): item_info = self.items[info["type"]].copy() temp = item_info.copy() temp.update(info) temp.update({"item_info": item_info.copy()}) return Item(self.screen, **temp) def refresh_realrect_quadtree(self): self.realrect_quadtree.clear() self.realrect_quadtree.particles = [j for i in self.layers for j in i] + self.charactermap + self.item_map self.realrect_quadtree.update() def refresh_floor_quadtree(self): self.floor_quadtree.clear() self.floor_quadtree.particles = self.triggers + self.rect_obstacles self.floor_quadtree.update() def delete_obs(self, **kwargs): obs = kwargs.get("obstacle", None) for index, layer in enumerate(self.layers): try: layer.remove(obs) break except: continue def delete_trigger(self, trigger): try: self.triggers.remove(trigger) except: pass def delete_character(self, identifier): try: self.characters.remove(character) except: pass def create_obstacle(self, **info): if info["type"] == "RECT": return BasicObstacle(self.screen, x=info["x"], y=info["y"], width=info.get("width", 1), height=info.get("height", 1), type="RECT") else: tile_dict = self.obstacles[int(info["type"])] if type(tile_dict["images"]) == list: tile_dict["images"] = tile_dict["images"][0] complete_info = tile_dict.copy() complete_info.update(info) return Obstacle(self.screen, **complete_info) def spawn_character(self, **kwargs): if kwargs.get("info", None): self.charactermap.append(self.create_character(kwargs["info"])) else: self.charactermap.append(Character(self.screen, x=kwargs.get("x", 0), y=kwargs.get("y", 0), name=kwargs["name"])) def load_obstaclemap(self, path): self.layers = [] temp = load_module(path) for layer in temp.layers: self.layers.append([]) for obs in layer: new = self.create_obstacle(**obs) if type(new) == BasicObstacle: self.rect_obstacles.append(new) else: self.layers[-1].append(new) self.refresh_floor_quadtree() self.refresh_realrect_quadtree() def load_charactermap(self, path): self.charactermap = [] temp = load_module(path) for character in temp.characters: self.charactermap.append(self.create_character(character)) self.refresh_realrect_quadtree() def load_triggermap(self, path): self.triggers = [] temp = load_module(path) for trigger in temp.triggers: self.triggers.append(Trigger(self.screen, **trigger)) self.refresh_floor_quadtree() def load_item_map(self, path): self.item_map = [] temp = load_module(path) for item in temp.items: self.item_map.append(self.create_item(item)) self.refresh_realrect_quadtree() def create_character(self, info): temp = self.characters[info["name"]].copy() temp.update(info) temp.update({"orig_info": self.characters[info["name"]].copy()}) return Character(self.screen, obstaclemap=self, **temp) def set_entry_value(self, entry, value): entry.delete(0, "end") entry.insert(0, value) def click(self, mouse_pos, tile_pos, mode, current_obs, current_layer, current_item, current_character, current_tab, properties_frame): for thing in [j for i in self.layers for j in i] + self.charactermap + self.item_map + self.rect_obstacles + self.triggers: thing.deselect() self.selected = None if mode == 0: selected = self.realrect_quadtree.collidepoint(mouse_pos) selected1 = self.floor_quadtree.collidepoint((tile_pos[0] * WIDTH, tile_pos[1] * HEIGHT)) if selected or selected1: self.selected = max(selected + selected1, key=lambda x: (x.x, x.y)) self.selected.select() elif mode == 1: if current_tab == "Obstacles": new_obs = self.create_obstacle(type=current_obs, x=tile_pos[0], y=tile_pos[1], width=1, height=1) if type(new_obs) == BasicObstacle: self.rect_obstacles.append(new_obs) else: self.layers[current_layer].append(new_obs) elif current_tab == "Items": new_obs = self.create_item({"type": current_item, "x": tile_pos[0], "y": tile_pos[1]}) self.item_map.append(new_obs) elif current_tab == "Characters": new_obs = self.create_character({"name": current_character, "x": tile_pos[0], "y": tile_pos[1]}) self.charactermap.append(new_obs) elif current_tab == "Triggers": new_obs = Trigger(self.screen, x=tile_pos[0], y=tile_pos[1], width=1, height=1) self.triggers.append(new_obs) self.selected = new_obs new_obs.select() self.refresh_realrect_quadtree() self.refresh_floor_quadtree() self.create_properties_widget(properties_frame) if self.selected: return True else: return False def destroy_properties_widget(self): if self.properties_frame: self.properties_frame.destroy() self.properties_frame = None self.widgets = {} def create_properties_widget(self, parent): self.destroy_properties_widget() if self.selected: obs_type = type(self.selected) if obs_type == BasicObstacle: possible_options = ["x", "y", "width", "height", "identifier"] elif obs_type == Trigger: possible_options = ["x", "y", "width", "height", "deactivate_after_use", "active", "identifier", "trigger"] elif obs_type == Obstacle: possible_options = ["x", "y", "identifier", "action", "after_looting", "items", "animation", "label", "onclick"] elif obs_type == Character: possible_options = ["x", "y", "dead", "weapon", "label", "identifier", "aggression_distance", "direction", "health", "random_walk_area", "waypoints", "ondeath"] elif obs_type == Item: possible_options = ["x", "y", "label", "identifier"] self.properties_frame = ttk.Frame(parent) self.widgets = {} for index, option in enumerate(possible_options): if option in ["x", "y", "width", "height", "aggression_distance", "health"]: if option in ["x", "width"]: self.widgets[option] = tk.Spinbox(self.properties_frame, from_=0, to=self.mapsize[0], increment=0.1) elif option in ["y", "height"]: self.widgets[option] = tk.Spinbox(self.properties_frame, from_=0, to=self.mapsize[1], increment=0.1) elif option == "aggression_distance": self.widgets[option] = tk.Spinbox(self.properties_frame, from_=0, to=self.map_diam, increment=0.1) elif option == "health": self.widgets[option] = tk.Spinbox(self.properties_frame, from_=0, to=1000) self.set_entry_value(self.widgets[option], getattr(self.selected, option)) self.widgets[option].grid(row=index, column=1, sticky="w") elif option in ["action", "weapon", "label", "identifier", "direction", "animation", "after_looting", "items"]: self.widgets[option] = ttk.Entry(self.properties_frame) attr = getattr(self.selected, option) if option == "items" and attr is not None: attr = ";".join(attr) if attr is None: attr = "" self.set_entry_value(self.widgets[option], attr) self.widgets[option].grid(row=index, column=1, sticky="w") elif option in ["active", "deactivate_after_use", "dead"]: variable = tk.IntVar() variable.set(int(getattr(self.selected, option))) self.widgets[option] = {"widget": ttk.Checkbutton(self.properties_frame, text=option, variable=variable), "variable": variable} self.widgets[option]["widget"].grid(row=index, column=1, sticky="w") elif option in ["onclick", "trigger", "ondeath"]: self.widgets[option] = [ttk.Combobox(self.properties_frame, values=("REPLACE", "DELETE", "ADD", "KILL", "KILLALL", "SPAWN", "OPEN", "CLOSE", "DEACTIVATE", "ACTIVATE", "WINGAME", "TRYWINGAME", "CHANGEMAP")), ttk.Combobox(self.properties_frame, values=("obstacle", "character", "item", "trigger")), ttk.Entry(self.properties_frame), ttk.Entry(self.properties_frame), ttk.Entry(self.properties_frame)] for widget_index, widget in enumerate(self.widgets[option]): try: if type(widget) == ttk.Combobox: widget.set(getattr(self.selected, option)[widget_index]) else: self.set_entry_value(widget, getattr(self.selected, option)[widget_index]) except: pass widget.grid(row=index + widget_index, column=1, sticky="w") elif option == "waypoints": self.widgets[option] = ttk.Entry(self.properties_frame) self.widgets[option].grid(row=index, column=1, sticky="w") self.set_entry_value(self.widgets[option], ";".join(",".join([str(y) for y in x]) for x in getattr(self.selected, option))) elif option == "random_walk_area": self.widgets[option] = ttk.Entry(self.properties_frame) self.widgets[option].grid(row=index, column=1, sticky="w") self.set_entry_value(self.widgets[option], ";".join(str(x) for x in getattr(self.selected, option))) if option not in ["deactivate_after_use", "dead", "active"]: ttk.Label(self.properties_frame, text=option).grid(row=index, column=0, sticky="w") self.properties_frame.grid(row=1, column=0, sticky="nswe") def mousedrag(self, mouse_pos, pos_change): if self.selected: self.set_attributes(x=self.selected.x + pos_change[0], y=self.selected.y + pos_change[1]) self.refresh_realrect_quadtree() self.refresh_floor_quadtree() def delete(self, *args): if self.selected: if type(self.selected) == Character: self.charactermap.remove(self.selected) elif type(self.selected) == Obstacle: try: self.layers[0].remove(self.selected) except: self.layers[1].remove(self.selected) elif type(self.selected) == Item: self.item_map.remove(self.selected) elif type(self.selected) == BasicObstacle: self.rect_obstacles.remove(self.selected) elif type(self.selected) == Trigger: self.triggers.remove(self.selected) self.selected = None self.refresh_floor_quadtree() self.refresh_realrect_quadtree() def set_attributes(self, **kwargs): if self.selected: if self.properties_frame: final_dict = {} for key, item in self.widgets.items(): if type(item) == dict: value = bool(item["variable"].get()) elif type(item) == list: value = [] for part in item: temp_val = part.get() if temp_val: value.append(temp_val) else: value = item.get() try: if key in ["after_looting", "health"]: value = int(value) else: value = float(value) except: pass if key in ["x", "y", "width", "height"]: try: final_dict[key] = float(value) except: pass elif key == "direction": if value in ["NW", "N", "NE", "E", "W", "SW", "SE", "S"]: final_dict[key] = value elif key == "items": if value: value = [x.strip() for x in value.split(";")] final_dict[key] = value elif key == "waypoints": try: if value: value = [[float(y) for y in x.split(",")] for x in value.split(";")] for x in value: if len(x) < 2: break else: final_dict[key] = value except: pass elif key == "random_walk_area": try: if value: value = [float(x) for x in value.split(";")] if len(value) == 4 or not value: final_dict[key] = value except: pass else: final_dict[key] = value final_dict.update(kwargs) self.selected.set_values(**final_dict) for key, item in kwargs.items(): if key in ["x", "y"]: self.set_entry_value(self.widgets[key], item) def draw_cursor(self, tile_pos, current_obs, current_item, current_char, current_tab, screen_offset): if current_tab == "Obstacles": temp = self.create_obstacle(type=current_obs, x=tile_pos[0], y=tile_pos[1]) elif current_tab == "Items": temp = self.create_item({"type": current_item, "x": tile_pos[0], "y": tile_pos[1]}) elif current_tab == "Characters": temp = self.create_character({"name": current_char, "x": tile_pos[0], "y": tile_pos[1]}) elif current_tab == "Triggers": temp = Trigger(self.screen, x=tile_pos[0], y=tile_pos[1]) temp.draw(screen_offset) def draw(self, screen_offset): self.set_attributes() final = sorted(self.layers[1] + self.charactermap, key=lambda x: (x.x, x.y)) ground = sorted(self.layers[0] + self.triggers + self.rect_obstacles + self.item_map, key=lambda x: (x.x, x.y)) for ground_obs in ground: ground_obs.draw(screen_offset) for thing in final: thing.draw(screen_offset)
class Obstacles(): def __init__(self, screen, obstacles, characters, items): self.screen = screen self.obstacles = obstacles self.characters = characters self.items = items self.layers = [[], []] self.rect_obstacles = [] self.charactermap = [] self.triggers = [] self.item_map = [] self.selected = None self.screen_offset = [0, 0] self.properties_frame = None def save(self, path): final_characters = [ character.get_dict() for character in self.charactermap ] final_items = [item.get_dict() for item in self.item_map] final_triggers = [trigger.get_dict() for trigger in self.triggers] final_obstacles = [[ obstacle.get_dict() for obstacle in self.layers[0] + self.rect_obstacles ], [obstacle.get_dict() for obstacle in self.layers[1]]] with open(os.path.join(path, "characters.py"), "w") as f: f.write("characters = " + repr(final_characters)) with open(os.path.join(path, "items.py"), "w") as f: f.write("items = " + repr(final_items)) with open(os.path.join(path, "triggers.py"), "w") as f: f.write("triggers = " + repr(final_triggers)) with open(os.path.join(path, "obstacles.py"), "w") as f: f.write("layers = " + repr(final_obstacles)) def gen_real_rect(self, mapsize): self.mapsize = mapsize real_height = mapsize[1] * (ISOHEIGHT // 2) + mapsize[0] * (ISOHEIGHT // 2) real_width = mapsize[1] * (ISOWIDTH // 2) + mapsize[0] * (ISOWIDTH // 2) startx = -(mapsize[1] * (ISOWIDTH // 2)) starty = 0 return Rect(startx, starty, real_width, real_height) def create_map(self, mapsize): self.realrect_quadtree = QuadTree(self.gen_real_rect(mapsize), 0, 5, 10, [], "realrect") self.floor_quadtree = QuadTree( Rect(0, 0, mapsize[0] * WIDTH, mapsize[1] * TILEHEIGHT), 0, 5, 10, [], "rect") self.layers = [[], []] self.rect_obstacles = [] self.charactermap = [] self.triggers = [] self.item_map = [] self.refresh_realrect_quadtree() self.refresh_floor_quadtree() self.map_diam = math.ceil( math.sqrt(self.mapsize[0]**2 + self.mapsize[1]**2)) def load_map(self, path, mapsize): self.realrect_quadtree = QuadTree(self.gen_real_rect(mapsize), 0, 5, 10, [], "realrect") self.floor_quadtree = QuadTree( Rect(0, 0, mapsize[0] * WIDTH, mapsize[1] * TILEHEIGHT), 0, 5, 10, [], "rect") self.load_obstaclemap(os.path.join(path, "obstacles.py")) self.load_charactermap(os.path.join(path, "characters.py")) self.load_triggermap(os.path.join(path, "triggers.py")) self.load_item_map(os.path.join(path, "items.py")) self.refresh_realrect_quadtree() self.refresh_floor_quadtree() self.map_diam = math.ceil( math.sqrt(self.mapsize[0]**2 + self.mapsize[1]**2)) def change_size(self, size): self.mapsize = size self.realrect_quadtree = QuadTree(self.gen_real_rect(self.mapsize), 0, 5, 10, [], "realrect") self.floor_quadtree = QuadTree( Rect(0, 0, self.mapsize[0] * WIDTH, self.mapsize[1] * TILEHEIGHT), 0, 5, 10, [], "rect") self.refresh_realrect_quadtree() self.refresh_floor_quadtree() self.map_diam = math.ceil( math.sqrt(self.mapsize[0]**2 + self.mapsize[1]**2)) def delete_item(self, item): self.item_map.remove(item) def add_item(self, item): self.item_map.append(self.create_item(item)) def create_item(self, info): item_info = self.items[info["type"]].copy() temp = item_info.copy() temp.update(info) temp.update({"item_info": item_info.copy()}) return Item(self.screen, **temp) def refresh_realrect_quadtree(self): self.realrect_quadtree.clear() self.realrect_quadtree.particles = [ j for i in self.layers for j in i ] + self.charactermap + self.item_map self.realrect_quadtree.update() def refresh_floor_quadtree(self): self.floor_quadtree.clear() self.floor_quadtree.particles = self.triggers + self.rect_obstacles self.floor_quadtree.update() def delete_obs(self, **kwargs): obs = kwargs.get("obstacle", None) for index, layer in enumerate(self.layers): try: layer.remove(obs) break except: continue def delete_trigger(self, trigger): try: self.triggers.remove(trigger) except: pass def delete_character(self, identifier): try: self.characters.remove(character) except: pass def create_obstacle(self, **info): if info["type"] == "RECT": return BasicObstacle(self.screen, x=info["x"], y=info["y"], width=info.get("width", 1), height=info.get("height", 1), type="RECT") else: tile_dict = self.obstacles[int(info["type"])] if type(tile_dict["images"]) == list: tile_dict["images"] = tile_dict["images"][0] complete_info = tile_dict.copy() complete_info.update(info) complete_info.update( {"orig_info": self.obstacles[int(info["type"])]}) return Obstacle(self.screen, **complete_info) def spawn_character(self, **kwargs): if kwargs.get("info", None): self.charactermap.append(self.create_character(kwargs["info"])) else: self.charactermap.append( Character(self.screen, x=kwargs.get("x", 0), y=kwargs.get("y", 0), name=kwargs["name"])) def load_obstaclemap(self, path): self.layers = [] self.rect_obstacles = [] temp = load_module(path) for layer in temp.layers: self.layers.append([]) for obs in layer: new = self.create_obstacle(**obs) if type(new) == BasicObstacle: self.rect_obstacles.append(new) else: self.layers[-1].append(new) self.refresh_floor_quadtree() self.refresh_realrect_quadtree() def load_charactermap(self, path): self.charactermap = [] temp = load_module(path) for character in temp.characters: self.charactermap.append(self.create_character(character)) self.refresh_realrect_quadtree() def load_triggermap(self, path): self.triggers = [] temp = load_module(path) for trigger in temp.triggers: self.triggers.append(Trigger(self.screen, **trigger)) self.refresh_floor_quadtree() def load_item_map(self, path): self.item_map = [] temp = load_module(path) for item in temp.items: self.item_map.append(self.create_item(item)) self.refresh_realrect_quadtree() def create_character(self, info): temp = self.characters[info["name"]].copy() temp.update(info) temp.update({"orig_info": self.characters[info["name"]].copy()}) return Character(self.screen, obstaclemap=self, **temp) def set_entry_value(self, entry, value): entry.delete(0, "end") entry.insert(0, value) def click(self, mouse_pos, tile_pos, mode, current_obs, current_layer, current_item, current_character, current_tab, properties_frame): for thing in [ j for i in self.layers for j in i ] + self.charactermap + self.item_map + self.rect_obstacles + self.triggers: thing.deselect() self.selected = None if mode == 0: selected = self.realrect_quadtree.collidepoint(mouse_pos) selected1 = self.floor_quadtree.collidepoint( (tile_pos[0] * WIDTH, tile_pos[1] * HEIGHT)) if selected or selected1: self.selected = max(selected + selected1, key=lambda x: (x.x, x.y)) self.selected.select() elif mode == 1: if current_tab == "Obstacles": new_obs = self.create_obstacle(type=current_obs, x=tile_pos[0], y=tile_pos[1], width=1, height=1) if type(new_obs) == BasicObstacle: self.rect_obstacles.append(new_obs) else: self.layers[current_layer].append(new_obs) elif current_tab == "Items": new_obs = self.create_item({ "type": current_item, "x": tile_pos[0], "y": tile_pos[1] }) self.item_map.append(new_obs) elif current_tab == "Characters": new_obs = self.create_character({ "name": current_character, "x": tile_pos[0], "y": tile_pos[1] }) self.charactermap.append(new_obs) elif current_tab == "Triggers": new_obs = Trigger(self.screen, x=tile_pos[0], y=tile_pos[1], width=1, height=1) self.triggers.append(new_obs) self.selected = new_obs new_obs.select() self.refresh_realrect_quadtree() self.refresh_floor_quadtree() self.create_properties_widget(properties_frame) if self.selected: return True else: return False def destroy_properties_widget(self): if self.properties_frame: self.properties_frame.destroy() self.properties_frame = None self.widgets = {} def create_properties_widget(self, parent): self.destroy_properties_widget() if self.selected: obs_type = type(self.selected) if obs_type == BasicObstacle: possible_options = ["x", "y", "width", "height", "identifier"] elif obs_type == Trigger: possible_options = [ "x", "y", "width", "height", "deactivate_after_use", "active", "identifier", "trigger" ] elif obs_type == Obstacle: possible_options = [ "x", "y", "identifier", "action", "after_looting", "items", "animation", "label", "onclick" ] elif obs_type == Character: possible_options = [ "x", "y", "dead", "weapon", "label", "identifier", "aggression_distance", "direction", "health", "random_walk_area", "waypoints", "ondeath" ] elif obs_type == Item: possible_options = [ "x", "y", "label", "identifier", "onpickup" ] self.properties_frame = ttk.Frame(parent) self.widgets = {} for index, option in enumerate(possible_options): if option in [ "x", "y", "width", "height", "aggression_distance", "health" ]: if option in ["x", "width"]: self.widgets[option] = tk.Spinbox( self.properties_frame, from_=0, to=self.mapsize[0], increment=0.1) elif option in ["y", "height"]: self.widgets[option] = tk.Spinbox( self.properties_frame, from_=0, to=self.mapsize[1], increment=0.1) elif option == "aggression_distance": self.widgets[option] = tk.Spinbox( self.properties_frame, from_=0, to=self.map_diam, increment=0.1) elif option == "health": self.widgets[option] = tk.Spinbox( self.properties_frame, from_=0, to=1000) self.set_entry_value(self.widgets[option], getattr(self.selected, option)) self.widgets[option].grid(row=index, column=1, sticky="w") elif option in [ "action", "weapon", "label", "identifier", "direction", "animation", "after_looting", "items" ]: self.widgets[option] = ttk.Entry(self.properties_frame) attr = getattr(self.selected, option) if option == "items" and attr is not None: attr = ";".join(attr) if attr is None: attr = "" self.set_entry_value(self.widgets[option], attr) self.widgets[option].grid(row=index, column=1, sticky="w") elif option in ["active", "deactivate_after_use", "dead"]: variable = tk.IntVar() variable.set(int(getattr(self.selected, option))) self.widgets[option] = { "widget": ttk.Checkbutton(self.properties_frame, text=option, variable=variable), "variable": variable } self.widgets[option]["widget"].grid(row=index, column=1, sticky="w") elif option in ["onclick", "trigger", "ondeath", "onpickup"]: self.widgets[option] = [ ttk.Combobox(self.properties_frame, values=("REPLACE", "DELETE", "ADD", "KILL", "KILLALL", "SPAWN", "OPEN", "CLOSE", "DEACTIVATE", "ACTIVATE", "WINGAME", "TRYWINGAME", "CHANGEMAP", "TRYCHANGEMAP")), ttk.Combobox(self.properties_frame, values=("obstacle", "character", "item", "trigger")), ttk.Entry(self.properties_frame), ttk.Entry(self.properties_frame), ttk.Entry(self.properties_frame) ] for widget_index, widget in enumerate( self.widgets[option]): try: if type(widget) == ttk.Combobox: widget.set( getattr(self.selected, option)[widget_index]) else: self.set_entry_value( widget, getattr(self.selected, option)[widget_index]) except: pass widget.grid(row=index + widget_index, column=1, sticky="w") elif option == "waypoints": self.widgets[option] = ttk.Entry(self.properties_frame) self.widgets[option].grid(row=index, column=1, sticky="w") self.set_entry_value( self.widgets[option], ";".join(",".join([str(y) for y in x]) for x in getattr(self.selected, option))) elif option == "random_walk_area": self.widgets[option] = ttk.Entry(self.properties_frame) self.widgets[option].grid(row=index, column=1, sticky="w") self.set_entry_value( self.widgets[option], ";".join( str(x) for x in getattr(self.selected, option))) if option not in ["deactivate_after_use", "dead", "active"]: ttk.Label(self.properties_frame, text=option).grid(row=index, column=0, sticky="w") self.properties_frame.grid(row=1, column=0, sticky="nswe") def mousedrag(self, mouse_pos, pos_change): if self.selected: self.set_attributes(x=self.selected.x + pos_change[0], y=self.selected.y + pos_change[1]) self.refresh_realrect_quadtree() self.refresh_floor_quadtree() def delete(self, *args): if self.selected: if type(self.selected) == Character: self.charactermap.remove(self.selected) elif type(self.selected) == Obstacle: try: self.layers[0].remove(self.selected) except: self.layers[1].remove(self.selected) elif type(self.selected) == Item: self.item_map.remove(self.selected) elif type(self.selected) == BasicObstacle: self.rect_obstacles.remove(self.selected) elif type(self.selected) == Trigger: self.triggers.remove(self.selected) self.selected = None self.refresh_floor_quadtree() self.refresh_realrect_quadtree() def set_attributes(self, **kwargs): if self.selected: if self.properties_frame: final_dict = {} for key, item in self.widgets.items(): if type(item) == dict: value = bool(item["variable"].get()) elif type(item) == list: value = [] for part in item: temp_val = part.get() if temp_val: value.append(temp_val) else: value = item.get() try: if key in ["after_looting", "health"]: value = int(value) elif key in ["x", "y", "width", "height"]: value = float(value) except: pass if key in [ "x", "y", "width", "height", "aggression_distance" ]: try: final_dict[key] = float(value) except: pass elif key == "direction": if value in [ "NW", "N", "NE", "E", "W", "SW", "SE", "S" ]: final_dict[key] = value elif key == "items": if value: value = [x.strip() for x in value.split(";")] final_dict[key] = value elif key == "waypoints": try: if value: value = [[float(y) for y in x.split(",")] for x in value.split(";")] for x in value: if len(x) < 2: break else: final_dict[key] = value except: pass elif key == "random_walk_area": try: if value: value = [float(x) for x in value.split(";")] if len(value) == 4 or not value: final_dict[key] = value except: pass else: final_dict[key] = value final_dict.update(kwargs) self.selected.set_values(**final_dict) for key, item in kwargs.items(): if key in ["x", "y"]: self.set_entry_value(self.widgets[key], item) def draw_cursor(self, tile_pos, current_obs, current_item, current_char, current_tab, screen_offset): if current_tab == "Obstacles": temp = self.create_obstacle(type=current_obs, x=tile_pos[0], y=tile_pos[1]) elif current_tab == "Items": temp = self.create_item({ "type": current_item, "x": tile_pos[0], "y": tile_pos[1] }) elif current_tab == "Characters": temp = self.create_character({ "name": current_char, "x": tile_pos[0], "y": tile_pos[1] }) elif current_tab == "Triggers": temp = Trigger(self.screen, x=tile_pos[0], y=tile_pos[1]) temp.draw(screen_offset) def draw(self, screen_offset): self.set_attributes() final = sorted(self.layers[1] + self.charactermap, key=lambda x: (x.x, x.y)) ground = sorted(self.layers[0] + self.triggers + self.rect_obstacles + self.item_map, key=lambda x: (x.x, x.y)) for ground_obs in ground: ground_obs.draw(screen_offset) for thing in final: thing.draw(screen_offset)