import os from enum import Enum, auto from math import floor from typing import Optional import platformdirs import pygame from src.image_handler import ImageHandler from src.graph.graph import Graph class Editor: WIDTH: int = 800 HEIGHT: int = 600 MAP_SIZE: int = 1024 MAPS_DIR: str = os.path.join(platformdirs.user_cache_dir(appname="lycacraft-paths", appauthor="Lycacraft"), "maps") ZOOMS: tuple[float] = (0.25, 0.5, 1, 2, 4) CROSSHAIR_SIZE: int = 10 def __init__(self): pygame.init() self.width: int = self.WIDTH self.height: int = self.HEIGHT self.win: pygame.Surface = pygame.display.set_mode([self.width, self.height], pygame.RESIZABLE) pygame.display.set_caption("Lycacraft Map Editor") self.center: list[int] = [0, 0] self.zoom_i: int = 2 self.zoom: float = self.ZOOMS[self.zoom_i] self.running: bool = False self.image_handler: ImageHandler = ImageHandler(self.MAPS_DIR, self.MAP_SIZE) self.clock: pygame.time.Clock = pygame.time.Clock() self.left_drag_pos: Optional[tuple[int, int]] = None self.mid_drag_pos: Optional[tuple[int, int]] = None self.font: pygame.font.Font = pygame.font.SysFont("Ubuntu", 20) self.loading_font: pygame.font.Font = pygame.font.SysFont("Ubuntu", 30) self.zooms_texts: list[pygame.Surface] = list(map( lambda z: self.font.render(str(z), True, (255, 255, 255)), self.ZOOMS )) self.is_creating_node: bool = False self.typing: bool = False self.state: State = State.STOPPING self.graph = Graph() self.typing_text: str = "" self.node_candidate_pos: tuple[int, int] = None self.node_radius: int = 10 self.line_size: int = (int) (self.node_radius / 5) self.edge_detect_radius: int = 3 * self.line_size self.selected_nodes: list[int] = [] self.selected_edges: list[int] = [] def mainloop(self) -> None: self.state = State.LOADING while self.state != State.STOPPING: pygame.display.set_caption(f"Lycacraft Map Editor - {self.clock.get_fps():.2f}fps") self.process_events() if self.state == State.LOADING: self.render_loading() if not self.image_handler.loading: self.state = State.RUNNING elif self.state == State.RUNNING: self.render() self.clock.tick(30) def process_events(self) -> None: events = pygame.event.get() keys = pygame.key.get_pressed() for event in events: if event.type == pygame.QUIT: self.state = State.STOPPING elif event.type == pygame.WINDOWRESIZED: self.width = event.x self.height = event.y elif event.type == pygame.KEYDOWN: if self.typing: if event.key == pygame.K_ESCAPE: self.typing = False self.is_creating_node = False self.node_candidate_pos = None self.typing_text = "" elif event.key == pygame.K_RETURN: self.create_node() elif event.key == pygame.K_BACKSPACE: self.typing_text = self.typing_text[:-1] else: self.typing_text += event.unicode else: if event.key == pygame.K_ESCAPE: if self.selected_nodes != [] or self.selected_edges != []: self.clear_selection() else: self.state = State.STOPPING elif event.key == pygame.K_PAGEUP: self.zoom_in() elif event.key == pygame.K_PAGEDOWN: self.zoom_out() elif event.type == pygame.MOUSEBUTTONDOWN: if event.button == 2: self.mid_drag_pos = event.pos elif event.button == 1: if keys[pygame.K_LCTRL]: self.left_drag_pos = event.pos else: self.select_object(keys[pygame.K_LSHIFT] or keys[pygame.K_RSHIFT]) elif event.button == 3: self.node_candidate_pos = self.screen_to_world(event.pos[0], event.pos[1]) self.is_creating_node = True self.typing = True elif event.button == 4: self.zoom_in() elif event.button == 5: self.zoom_out() elif event.type == pygame.MOUSEBUTTONUP: if event.button == 2: self.mid_drag_pos = None elif event.button == 1: self.left_drag_pos = None if keys[pygame.K_LEFT]: self.center[0] -= 4 / self.zoom if keys[pygame.K_RIGHT]: self.center[0] += 4 / self.zoom if keys[pygame.K_UP]: self.center[1] -= 4 / self.zoom if keys[pygame.K_DOWN]: self.center[1] += 4 / self.zoom mbtns = pygame.mouse.get_pressed() mpos = pygame.mouse.get_pos() if mbtns[1] or (mbtns[0] and keys[pygame.K_LCTRL]): drag_pos = self.mid_drag_pos if mbtns[1] else self.left_drag_pos dx = mpos[0] - drag_pos[0] dy = mpos[1] - drag_pos[1] self.center[0] -= dx / self.zoom self.center[1] -= dy / self.zoom if mbtns[0] and keys[pygame.K_LCTRL]: self.left_drag_pos = mpos if mbtns[1]: self.mid_drag_pos = mpos def render(self) -> None: self.win.fill((0, 0, 0)) off_x = (self.center[0] * self.zoom) % self.MAP_SIZE off_y = (self.center[1] * self.zoom) % self.MAP_SIZE w2 = self.width / 2 h2 = self.height / 2 # In game top-left / bottom-right corners x0 = floor(self.center[0] - w2 / self.zoom) y0 = floor(self.center[1] - h2 / self.zoom) x1 = floor(self.center[0] + w2 / self.zoom) y1 = floor(self.center[1] + h2 / self.zoom) # Top-left / bottom-right maps mx0 = floor(x0 * self.zoom / self.MAP_SIZE) my0 = floor(y0 * self.zoom / self.MAP_SIZE) mx1 = floor(x1 * self.zoom / self.MAP_SIZE) my1 = floor(y1 * self.zoom / self.MAP_SIZE) h_maps = mx1 - mx0 + 1 v_maps = my1 - my0 + 1 cx = floor(self.center[0] * self.zoom / self.MAP_SIZE) cy = floor(self.center[1] * self.zoom / self.MAP_SIZE) ox = w2 + (mx0 - cx) * self.MAP_SIZE - off_x oy = h2 + (my0 - cy) * self.MAP_SIZE - off_y for y in range(v_maps): for x in range(h_maps): map_image = self.image_handler.get_for_pos(mx0 + x, my0 + y, self.zoom) if map_image is None: continue self.win.blit(map_image, [ ox + x * self.MAP_SIZE, oy + y * self.MAP_SIZE ]) self.render_graph() pygame.draw.line(self.win, (150, 150, 150), [w2 - self.CROSSHAIR_SIZE, h2], [w2 + self.CROSSHAIR_SIZE, h2]) pygame.draw.line(self.win, (150, 150, 150), [w2, h2 - self.CROSSHAIR_SIZE], [w2, h2 + self.CROSSHAIR_SIZE]) self.render_zoom_slider() mpos = pygame.mouse.get_pos() world_x, world_z = self.screen_to_world(*mpos) mouse_txt = self.font.render(f"x: {world_x} / z: {world_z}", True, (255, 255, 255)) pygame.draw.rect(self.win, (80, 80, 80), [0, 0, mouse_txt.get_width() + 10, mouse_txt.get_height() + 10]) self.win.blit(mouse_txt, [5, 5]) if self.is_creating_node: self.render_node_creator() pygame.display.flip() def render_zoom_slider(self) -> None: zoom_height = self.height * 0.2 zoom_h_margin = self.width * 0.02 zoom_v_margin = self.height * 0.05 zoom_x = self.width - zoom_h_margin zoom_y = self.height - zoom_v_margin - zoom_height zoom_space = zoom_height / 4 zoom_r = zoom_space / 4 zoom_width = max(s.get_width() for s in self.zooms_texts) + 2 * zoom_r + 5 pygame.draw.rect(self.win, (80, 80, 80), [ zoom_x + zoom_r - zoom_width - 5, zoom_y - zoom_r - 5, zoom_width + 10, zoom_height + 2 * zoom_r + 10 ]) pygame.draw.line(self.win, (255, 255, 255), [zoom_x, zoom_y], [zoom_x, zoom_y + zoom_height]) for i, txt in enumerate(self.zooms_texts): y = zoom_y + zoom_height - i * zoom_space col = (255, 0, 0) if i == self.zoom_i else (255, 255, 255) pygame.draw.circle(self.win, col, [zoom_x, y], zoom_r) self.win.blit(txt, [zoom_x - txt.get_width() - zoom_r - 5, y - txt.get_height() / 2]) def render_loading(self) -> None: self.win.fill((0, 0, 0)) count = self.image_handler.count total = self.image_handler.total txt = self.loading_font.render(f"Loading maps - {count}/{total}", True, (255, 255, 255)) width = self.width * 0.6 height = self.height * 0.05 w2 = self.width / 2 h2 = self.height / 2 x0 = w2 - width / 2 y0 = h2 - height / 2 loaded_width = 0 if total == 0 else width * count / total pygame.draw.rect(self.win, (160, 160, 160), [x0, y0, width, height]) pygame.draw.rect(self.win, (90, 250, 90), [x0, y0, loaded_width, height]) self.win.blit(txt, [w2 - txt.get_width() / 2, y0 - txt.get_height() - 5]) pygame.display.flip() def render_node_creator(self) -> None: width = self.width / 2 height = self.height / 2 x0 = (self.width - width) / 2 y0 = (self.height - height) / 2 line_height = height / 6 nc_txt = self.loading_font.render("NODE CREATOR", True, (255, 255, 255)) name_txt = self.loading_font.render("Name:", True, (255, 255, 255)) txt = self.loading_font.render(self.typing_text, True, (255, 255, 255)) pygame.draw.rect(self.win, (0, 0, 0), [x0, y0, width, height]) self.win.blit(nc_txt, [self.width / 2 - nc_txt.get_width() / 2, y0 + line_height]) self.win.blit(name_txt, [self.width / 2 - name_txt.get_width() / 2, y0 + 3 * line_height]) self.win.blit(txt, [self.width / 2 - txt.get_width() / 2, y0 + 4 * line_height]) def render_graph(self) -> None: self.render_edges() hover_index, is_node = self.get_hover_object() if is_node: self.render_nodes() self.render_hover_node(hover_index) else: self.render_hover_edge(hover_index) self.render_nodes() def render_edges(self) -> None: for edge in self.graph.edges: node_1, node_2 = self.graph.get_edge_nodes(edge) color = (0, 255, 255) if edge.index in self.selected_edges else (255, 0, 0) pygame.draw.line(self.win, color, self.world_to_screen(node_1.x, node_1.z), self.world_to_screen(node_2.x, node_2.z), self.line_size) def render_nodes(self) -> None: for node in self.graph.nodes: blitpos = self.world_to_screen(node.x, node.z) pygame.draw.circle(self.win, (255, 0, 0), (blitpos[0], blitpos[1]), self.node_radius) for node_index in self.selected_nodes: node = self.graph.nodes[node_index] blitpos = self.world_to_screen(node.x, node.z) pygame.draw.circle(self.win, (0, 255, 255), (blitpos[0], blitpos[1]), self.node_radius) def render_hover_node(self, node_index): if node_index != -1: node = self.graph.nodes[node_index] txt = self.loading_font.render(node.name, True, (0, 0, 0)) node_pos = self.world_to_screen(node.x, node.z) self.win.blit(txt, [node_pos[0] - txt.get_width(), node_pos[1] - txt.get_height()]) pygame.draw.circle(self.win, (0, 0, 0), (node_pos[0], node_pos[1]), self.node_radius, self.line_size) def render_hover_edge(self, edge_index): if edge_index != -1: node_1, node_2 = self.graph.get_edge_nodes(self.graph.edges[edge_index]) pygame.draw.line(self.win, (0, 0, 0), self.world_to_screen(node_1.x, node_1.z), self.world_to_screen(node_2.x, node_2.z), self.edge_detect_radius) color = (0, 255, 255) if edge_index in self.selected_edges else (255, 0, 0) pygame.draw.line(self.win, color, self.world_to_screen(node_1.x, node_1.z), self.world_to_screen(node_2.x, node_2.z), self.line_size) def set_zoom(self, zoom_i: int) -> None: self.zoom_i = max(0, min(len(self.ZOOMS) - 1, zoom_i)) self.zoom = self.ZOOMS[self.zoom_i] def zoom_in(self) -> None: self.set_zoom(self.zoom_i + 1) def zoom_out(self) -> None: self.set_zoom(self.zoom_i - 1) def screen_to_world(self, x: int, y: int) -> tuple[int, int]: w2 = self.width / 2 h2 = self.height / 2 world_x = floor((x - w2) / self.zoom + self.center[0]) world_z = floor((y - h2) / self.zoom + self.center[1]) return int(world_x), int(world_z) def world_to_screen(self, world_x: int, world_z: int) -> tuple[int, int]: w2 = self.width / 2 h2 = self.height / 2 screen_x = (world_x - self.center[0]) * self.zoom + w2 screen_y = (world_z - self.center[1]) * self.zoom + h2 return int(screen_x), int(screen_y) def select_object(self, shifting: bool = False) -> None: hover_index, is_node = self.get_hover_object() if is_node: self.select_node(hover_index, shifting) elif hover_index != -1: self.select_edge(hover_index, shifting) else: self.clear_selection() def select_node(self, node: int, shifting: bool = False) -> None: if shifting: if node in self.selected_nodes: self.selected_nodes.remove(node) return if node != -1: self.selected_nodes.append(node) return if node in self.selected_nodes: self.selected_nodes.remove(node) self.clear_selection() return if node != -1: for sel_node in self.selected_nodes: self.link_nodes(sel_node, node) self.selected_nodes = [] if node == -1 else [node] self.selected_edges = [] def select_edge(self, edge: int, shifting: bool = False) -> None: if shifting: if edge in self.selected_edges: self.selected_edges.remove(edge) return if edge != -1: self.selected_edges.append(edge) return if edge in self.selected_edges: self.clear_selection() return self.selected_edges = [] if edge == -1 else [edge] self.selected_nodes = [] def link_nodes(self, node_1: int, node_2: int) -> None: if not self.graph.edge_exists(node_1, node_2): self.create_edge(node_1, node_2) def clear_selection(self) -> None: self.selected_nodes = [] self.selected_edges = [] def create_node(self) -> None: self.graph.add_node(self.node_candidate_pos[0], self.node_candidate_pos[1], self.typing_text) self.typing_text = "" self.node_candidate_pos = None self.typing = False self.is_creating_node = False self.select_node(self.graph.number_of_nodes() - 1) def create_edge(self, node_1: int, node_2: int): n1 = self.graph.nodes[node_1] n2 = self.graph.nodes[node_2] self.graph.add_edge(node_1, node_2, ((n1.x - n2.x) ** 2 + (n1.z - n2.z) ** 2) ** 0.5) def get_hovering_nodes(self) -> tuple[list[int], list[float]]: hovering = [] dists = [] mouse_pos = pygame.mouse.get_pos() for node in self.graph.nodes: dist = self.get_node_distance(node.index, mouse_pos[0], mouse_pos[1]) if dist < self.node_radius: hovering.append(node.index) dists.append(dist) return hovering, dists def get_hover_node(self) -> int: hover_nodes, distances = self.get_hovering_nodes() return -1 if len(hover_nodes) == 0 else hover_nodes[distances.index(min(distances))] def get_hovering_edges(self) -> tuple[list[int], list[float]]: hovering = [] dists = [] mouse_pos = pygame.mouse.get_pos() for edge in self.graph.edges: dist = self.get_edge_distance(edge.index, mouse_pos[0], mouse_pos[1]) print(dist) if dist < self.edge_detect_radius: hovering.append(edge.index) dists.append(dist) return hovering, dists def get_hover_edge(self) -> int: hover_edges, distances = self.get_hovering_edges() return -1 if len(hover_edges) == 0 else hover_edges[distances.index(min(distances))] def get_hover_object(self) -> tuple[int, bool]: node = self.get_hover_node() if node != -1: return node, True edge = self.get_hover_edge() if edge != -1: return edge, False return -1, False def get_edge_distance(self, edge_i: int, px: int, pz: int) -> float: start_n, end_n = self.graph.get_edge_nodes(self.graph.edges[edge_i]) start_p = self.world_to_screen(start_n.x, start_n.z) end_p = self.world_to_screen(end_n.x, end_n.z) edge_vec = (end_p[0] - start_p[0], end_p[1] - start_p[1]) start_vec = (px - start_p[0], pz - start_p[1]) edge_vec_len = (edge_vec[0] ** 2 + edge_vec[1] ** 2) ** 0.5 if edge_vec_len == 0: return self.get_node_distance(start_n.index, px, pz) scal_prod = start_vec[0] * edge_vec[0] + start_vec[1] * edge_vec[1] proj_len = scal_prod / edge_vec_len print(proj_len, edge_vec_len) if proj_len < 0: return self.get_node_distance(start_n.index, px, pz) if proj_len > edge_vec_len: return self.get_node_distance(end_n.index, px, pz) return abs((edge_vec[0] * start_vec[1] - edge_vec[1] * start_vec[0]) / edge_vec_len) def get_node_distance(self, node_i: int, px: int, pz: int) -> float: node = self.graph.nodes[node_i] node_pos = self.world_to_screen(node.x, node.z) return ((px - node_pos[0]) ** 2 + (pz - node_pos[1]) ** 2) ** 0.5 class State(Enum): STOPPING = auto() LOADING = auto() RUNNING = auto() CREATING_NODE = auto()