added dirty to move + improved syntax

src/config.py

@@ -0,0 +1,27 @@
+import json
+import os.path
+
+
+class Config:
+    LAST_OPENED_FILE = ""
+    AUTOSAVE_INTERVAL = 5 * 60 * 1000
+
+    def __init__(self, path: str):
+        self._path: str = path
+
+        self.load()
+
+    def load(self) -> None:
+        if os.path.exists(self._path):
+            with open(self._path, "r") as f:
+                config = json.load(f)
+
+            self.LAST_OPENED_FILE = config["last_opened_file"]
+            self.AUTOSAVE_INTERVAL = config["autosave_interval"]
+
+    def save(self) -> None:
+        with open(self._path, "w") as f:
+            json.dump({
+                "last_opened_file": self.LAST_OPENED_FILE,
+                "autosave_interval": self.AUTOSAVE_INTERVAL
+            }, f, indent=4)

src/editor.py

@@ -6,19 +6,29 @@ from typing import Optional
 import platformdirs
 import pygame
 
+from src.config import Config
 from src.image_handler import ImageHandler
+from src.graph.graph import Graph
 
 
 class Editor:
+    APP_NAME: str = "lycacraft-paths"
+    APP_AUTHOR: str = "Lycacraft"
     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")
+    CACHE_DIR: str = platformdirs.user_cache_dir(appname=APP_NAME, appauthor=APP_AUTHOR, ensure_exists=True)
+    CONFIG_DIR: str = platformdirs.user_config_dir(appname=APP_NAME, appauthor=APP_AUTHOR, ensure_exists=True)
+    CONFIG_PATH: str = os.path.join(CONFIG_DIR, "config.json")
+    MAPS_DIR: str = os.path.join(CACHE_DIR, "maps")
+    AUTOSAVE_PATH: str = os.path.join(CACHE_DIR, "AUTOSAVE.txt")
+    AUTOSAVE_EVENT: int = pygame.event.custom_type()
     ZOOMS: tuple[float] = (0.25, 0.5, 1, 2, 4)
     CROSSHAIR_SIZE: int = 10
 
     def __init__(self):
         pygame.init()
+        self.config: Config = Config(self.CONFIG_PATH)
         self.width: int = self.WIDTH
         self.height: int = self.HEIGHT
         self.win: pygame.Surface = pygame.display.set_mode([self.width, self.height], pygame.RESIZABLE)
@@ -37,43 +47,116 @@ class Editor:
             lambda z: self.font.render(str(z), True, (255, 255, 255)),
             self.ZOOMS
         ))
+        self.is_renaming_node: bool = False
         self.state: State = State.STOPPING
+        self.graph = Graph()
+        self.typing_text: str = ""
+        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] = []
+        self.previously_created_nodes: list[int] = []
+        self.selection_rectangle: Optional[list[tuple[int, int], tuple[int, int]]] = None
+        self.original_move_pos: Optional[tuple[int, int]] = None
+        self.move_old_poses: Optional[dict[int, tuple[int, int]]] = None
+        self.dirty: bool = False
+        pygame.time.set_timer(self.AUTOSAVE_EVENT, self.config.AUTOSAVE_INTERVAL)
+
+        if os.path.exists(self.AUTOSAVE_PATH):
+            self.load(self.AUTOSAVE_PATH, False)
+            self.dirty = True
+        elif self.config.LAST_OPENED_FILE != "":
+            self.load(self.config.LAST_OPENED_FILE)
 
     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")
+            caption = f"Lycacraft Map Editor - {self.clock.get_fps():.2f}fps"
+            if self.dirty:
+                caption += " (unsaved)"
+            pygame.display.set_caption(caption)
             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:
+                if self.selection_rectangle is not None:
+                    self.expand_selection_rect()
+                if self.original_move_pos is not None:
+                    self.move_poses()
                 self.render()
             self.clock.tick(30)
 
+    def quit(self) -> None:
+        if self.dirty:
+            self.save(self.AUTOSAVE_PATH, False)
+        self.state = State.STOPPING
+
     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
+                self.quit()
             elif event.type == pygame.WINDOWRESIZED:
                 self.width = event.x
                 self.height = event.y
             elif event.type == pygame.KEYDOWN:
-                if event.key == pygame.K_ESCAPE:
-                    self.state = State.STOPPING
-                elif event.key == pygame.K_PAGEUP:
-                    self.zoom_in()
-                elif event.key == pygame.K_PAGEDOWN:
-                    self.zoom_out()
+                if self.is_renaming_node:
+                    if event.key == pygame.K_ESCAPE:
+                        self.is_renaming_node = False
+                        self.typing_text = ""
+                    elif event.key == pygame.K_RETURN:
+                        self.rename_nodes()
+                    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()
+                            self.previously_created_nodes = []
+                        else:
+                            self.quit()
+                    elif event.key == pygame.K_PAGEUP:
+                        self.zoom_in()
+                    elif event.key == pygame.K_PAGEDOWN:
+                        self.zoom_out()
+                    elif event.key == pygame.K_BACKSPACE:
+                        self.deleted_selected_objects()
+                    elif event.key == pygame.K_s and event.mod & (pygame.KMOD_CTRL | pygame.KMOD_META):
+                        self.save()
+                    elif event.key == pygame.K_l and event.mod & (pygame.KMOD_CTRL | pygame.KMOD_META):
+                        self.load()
+                    elif event.key == pygame.K_RETURN:
+                        if len(self.selected_nodes) > 0:
+                            self.typing_text = ""
+                            if len(self.selected_nodes) == 1:
+                                self.typing_text = self.graph.nodes[self.selected_nodes[0]].name
+                            self.is_renaming_node = True
+            elif event.type == pygame.KEYUP:
+                if event.key == pygame.K_m:
+                    if self.original_move_pos is not None:
+                        self.reset_move_poses()
             elif event.type == pygame.MOUSEBUTTONDOWN:
                 if event.button == 2:
                     self.mid_drag_pos = event.pos
-                elif event.button == 1 and keys[pygame.K_LCTRL]:
-                    self.left_drag_pos = event.pos
+                elif event.button == 1:
+                    if keys[pygame.K_LCTRL]:
+                        self.left_drag_pos = event.pos
+                    elif keys[pygame.K_LALT]:
+                        self.create_selection_rect(keys[pygame.K_LSHIFT] or keys[pygame.K_RSHIFT])
+                    elif keys[pygame.K_m]:
+                        self.original_move_pos = event.pos
+                        self.start_moving()
+                    else:
+                        self.select_object(keys[pygame.K_LSHIFT] or keys[pygame.K_RSHIFT])
+                elif event.button == 3:
+                    self.create_node(self.screen_to_world(event.pos[0], event.pos[1]))
                 elif event.button == 4:
                     self.zoom_in()
                 elif event.button == 5:
@@ -82,7 +165,15 @@ class Editor:
                 if event.button == 2:
                     self.mid_drag_pos = None
                 elif event.button == 1:
-                    self.left_drag_pos = None
+                    if keys[pygame.K_LCTRL]:
+                        self.left_drag_pos = None
+                    elif keys[pygame.K_m] and self.original_move_pos is not None:
+                        self.confirm_move_poses()
+                    elif self.selection_rectangle is not None:
+                        self.release_selection_rect(keys[pygame.K_LSHIFT] or keys[pygame.K_RSHIFT])
+            elif event.type == self.AUTOSAVE_EVENT:
+                if self.dirty:
+                    self.save(self.AUTOSAVE_PATH, False)
 
         if keys[pygame.K_LEFT]:
             self.center[0] -= 4 / self.zoom
@@ -143,6 +234,10 @@ class Editor:
                     oy + y * self.MAP_SIZE
                 ])
 
+        self.render_graph()
+
+        self.render_selection_rect()
+
         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()
@@ -153,6 +248,9 @@ class Editor:
         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_renaming_node:
+            self.render_node_renamer()
+
         pygame.display.flip()
 
     def render_zoom_slider(self) -> None:
@@ -189,12 +287,86 @@ class Editor:
         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, width * count / total, 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_renamer(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("RENAME NODE", True, (255, 255, 255))
+        name_txt = self.loading_font.render("New 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()
+            if self.selection_rectangle is None:
+                self.render_hover_node(hover_index)
+        else:
+            if self.selection_rectangle is None:
+                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)
+            start = self.world_to_screen(node_1.x, node_1.z)
+            end = self.world_to_screen(node_2.x, node_2.z)
+            pygame.draw.line(self.win, color, start, end, 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])
+            start = self.world_to_screen(node_1.x, node_1.z)
+            end = self.world_to_screen(node_2.x, node_2.z)
+            pygame.draw.line(self.win, (0, 0, 0), start, end, 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, start, end, self.line_size)
+
+    def render_selection_rect(self):
+        rect = self.selection_rectangle
+        if rect is not None:
+            left = min(rect[0][0], rect[1][0])
+            top = min(rect[0][1], rect[1][1])
+            width = abs(rect[0][0] - rect[1][0])
+            height = abs(rect[0][1] - rect[1][1])
+            pygame.draw.rect(self.win, (32, 32, 32), pygame.Rect(left, top, width, height), 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]
@@ -213,6 +385,269 @@ class Editor:
 
         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()
+        
+        self.previously_created_nodes = []
+
+        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.clear_selection()
+            self.selected_nodes.append(node)
+            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()
+            self.selected_edges.append(edge)
+            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 rename_nodes(self) -> None:
+        self.dirty = True
+        for node in self.selected_nodes:
+            self.graph.nodes[node].rename_node(self.typing_text)
+        self.typing_text = ""
+        self.is_renaming_node = False
+
+    def create_node(self, pos: tuple[int, int], typing_text: str = "") -> None:
+        self.dirty = True
+        self.graph.add_node(pos[0], pos[1], typing_text)
+        if len(self.selected_nodes) == 1:
+            self.previously_created_nodes.append(self.selected_nodes[0])
+        self.select_node(self.graph.number_of_nodes() - 1)
+    
+    def create_edge(self, node_1: int, node_2: int) -> None:
+        self.dirty = True
+        self.graph.add_edge(node_1, node_2)
+    
+    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])
+            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
+
+        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
+    
+    def deleted_selected_objects(self):
+        self.dirty = True
+        edges_to_delete = [self.graph.edges[i] for i in self.selected_edges]
+        nodes_to_delete = [self.graph.nodes[i] for i in self.selected_nodes]
+        for edge in edges_to_delete:
+            self.graph.delete_edge(edge)
+        for node in nodes_to_delete:
+            self.graph.delete_node(node)
+        self.clear_selection()
+        n = len(self.previously_created_nodes)
+        if n != 0:
+            self.selected_nodes.append(self.previously_created_nodes[n - 1])
+            self.previously_created_nodes.pop()
+
+    def create_selection_rect(self, shifting: bool = False):
+        if not shifting:
+            self.clear_selection()
+            self.previously_created_nodes = []
+        mouse_pos = pygame.mouse.get_pos()
+        self.selection_rectangle = [mouse_pos, mouse_pos]
+
+    def expand_selection_rect(self):
+        self.selection_rectangle[1] = pygame.mouse.get_pos()
+
+    def release_selection_rect(self, shifting: bool = False):
+        if not shifting:
+            self.clear_selection()
+        self.previously_created_nodes = []
+        rect = self.selection_rectangle
+        left = min(rect[0][0], rect[1][0])
+        top = min(rect[0][1], rect[1][1])
+        right = max(rect[0][0], rect[1][0])
+        bottom = max(rect[0][1], rect[1][1])
+        for node in self.graph.nodes:
+            pos = self.world_to_screen(node.x, node.z)
+            if left <= pos[0] <= right and top <= pos[1] <= bottom:
+                if node.index not in self.selected_nodes:
+                    self.selected_nodes.append(node.index)
+            print(left, "<=", pos[0], "<=", right)
+            print(top, "<=", pos[1], "<=", bottom)
+        for edge in self.graph.edges:
+            pos = self.world_to_screen(*self.graph.get_edge_center(edge.index))
+            if left <= pos[0] <= right and top <= pos[1] <= bottom:
+                if edge.index not in self.selected_edges:
+                    self.selected_edges.append(edge.index)
+            print(left, "<=", pos[0], "<=", right)
+            print(top, "<=", pos[1], "<=", bottom)
+        self.selection_rectangle = None
+
+    def start_moving(self):
+        self.move_old_poses = {}
+        for node_index in self.selected_nodes:
+            node = self.graph.nodes[node_index]
+            self.move_old_poses[node_index] = (node.x, node.z)
+
+    def move_poses(self):
+        mouse_pos = pygame.mouse.get_pos()
+        start_pos = self.original_move_pos
+        delta_x = mouse_pos[0] - start_pos[0]
+        delta_z = mouse_pos[1] - start_pos[1]
+        for node_index in self.move_old_poses.keys():
+            node = self.graph.nodes[node_index]
+            old_pos = self.move_old_poses[node_index]
+            node.x = old_pos[0] + delta_x
+            node.z = old_pos[1] + delta_z
+
+    def reset_move_poses(self):
+        self.original_move_pos = None
+        for node_index in self.move_old_poses.keys():
+            node = self.graph.nodes[node_index]
+            old_pos = self.move_old_poses[node_index]
+            node.x = old_pos[0]
+            node.z = old_pos[1]
+        self.move_old_poses = None
+
+    def confirm_move_poses(self):
+        self.dirty = True
+        self.original_move_pos = None
+        self.move_old_poses = None
+
+    def save(self, path: Optional[str] = None, save_config: bool = True) -> None:
+        last_path = self.config.LAST_OPENED_FILE
+        if path is None:
+            path = input(f"Save as ({last_path}): ")
+            if len(path.strip()) == 0:
+                path = last_path
+
+        self.graph.save(path)
+        if save_config:
+            self.config.LAST_OPENED_FILE = path
+            self.config.save()
+            if os.path.exists(self.AUTOSAVE_PATH):
+                os.remove(self.AUTOSAVE_PATH)
+        self.dirty = False
+
+    def load(self, path: Optional[str] = None, save_config: bool = True) -> None:
+        last_path = self.config.LAST_OPENED_FILE
+        if path is None:
+            path = input(f"Load from ({last_path}): ")
+            if len(path.strip()) == 0:
+                path = last_path
+
+        self.graph = Graph.load(path)
+        if save_config:
+            self.config.LAST_OPENED_FILE = path
+            self.config.save()
+        self.dirty = False
+
 
 class State(Enum):
     STOPPING = auto()

src/graph/edge.py

@@ -0,0 +1,6 @@
+class Edge:
+    def __init__(self, start: int, end: int, length: float, index: int):
+        self.length: float = length
+        self.start: int = start
+        self.end: int = end
+        self.index: int = index

src/graph/graph.py

@@ -0,0 +1,139 @@
+from __future__ import annotations
+from math import inf, sqrt
+from typing import Iterator, Optional
+
+from src.graph.node import Node
+from src.graph.edge import Edge
+
+
+class Graph:
+    def __init__(self):
+        self.edges: list[Edge] = []
+        self.nodes: list[Node] = []
+
+    def add_node(self, x: int, z: int, name: str = "") -> None:
+        self.nodes.append(Node(x, z, len(self.nodes), name))
+
+    def add_edge(self, start_index: int, end_index: int, auto_length: bool = True) -> None:
+        length = 0
+        if auto_length:
+            n1, n2 = self.nodes[start_index], self.nodes[end_index]
+            length = sqrt((n1.x - n2.x)**2 + (n1.z - n2.z)**2)
+        self.edges.append(Edge(start_index, end_index, length, len(self.edges)))
+
+    def delete_edge(self, edge: Edge) -> None:
+        self.edges.remove(edge)
+        for ed in self.edges:
+            ed.index = self.edges.index(ed)
+
+    def delete_node(self, node: Node) -> None:
+        edges_to_delete = []
+        for edge in self.edges:
+            if node.index in (edge.start, edge.end):
+                edges_to_delete.append(edge)
+                continue
+            if edge.start > node.index:
+                edge.start -= 1
+            if edge.end > node.index:
+                edge.end -= 1
+        for edge in edges_to_delete:
+            self.delete_edge(edge)
+        self.nodes.remove(node)
+        for no in self.nodes:
+            no.index = self.nodes.index(no)
+
+    def recompute_lengths(self) -> None:
+        for edge in self.edges:
+            n1 = self.nodes[edge.start]
+            n2 = self.nodes[edge.end]
+            edge.length = sqrt((n1.x - n2.x)**2 + (n1.z - n2.z)**2)
+
+    def number_of_nodes(self) -> int:
+        return len(self.nodes)
+    
+    def get_edge(self, node_1: int, node_2: int) -> int:
+        for edge in self.edges:
+            if (edge.start == node_1 and edge.end == node_2) or (edge.start == node_2 and edge.end == node_1):
+                return self.edges.index(edge)
+        return -1
+    
+    def get_edge_nodes(self, edge: Edge) -> tuple[Node, Node]:
+        return self.nodes[edge.start], self.nodes[edge.end]
+
+    def get_edge_center(self, edge_index: int) -> tuple[float, float]:
+        edge = self.edges[edge_index]
+        start_n = self.nodes[edge.start]
+        end_n = self.nodes[edge.end]
+        return (start_n.x + end_n.x) / 2, (start_n.z + end_n.z) / 2
+
+    def edges_adjacent_to(self, node_i: int) -> Iterator[Edge]:
+        return filter(lambda e: e.start == node_i or e.end == node_i, self.edges)
+    
+    def edge_exists(self, node_1: int, node_2: int) -> bool:
+        return self.get_edge(node_1, node_2) != -1
+
+    def dijkstra(self, source_index: int, target_index: int) -> Optional[list[int]]:
+        n = len(self.nodes)
+
+        if source_index < 0 or source_index >= n:
+            return None
+
+        if target_index < 0 or target_index >= n:
+            return None
+
+        unvisited = list(range(n))
+
+        distances_from_start = [inf] * n
+        distances_from_start[source_index] = 0
+
+        node_sequences = [[] for _ in range(n)]
+        node_sequences[source_index] = [source_index]
+
+        while True:
+            current_index = min(unvisited, key=lambda i: distances_from_start[i])
+
+            if current_index == target_index:
+                break
+
+            unvisited.remove(current_index)
+
+            for edge in self.edges_adjacent_to(current_index):
+                start = current_index
+                end = edge.end if edge.start == current_index else edge.start
+
+                if end in unvisited and distances_from_start[end] > distances_from_start[start] + edge.length:
+                    distances_from_start[end] = distances_from_start[start] + edge.length
+                    node_sequences[end] = node_sequences[start].copy()
+                    node_sequences[end].append(end)
+
+        return node_sequences[target_index]
+
+    def save(self, path: str) -> None:
+        with open(path, "w") as f:
+            for node in self.nodes:
+                f.write(f"n {node.x} {node.z} {node.name}\n")
+            f.write("\n")
+            for edge in self.edges:
+                f.write(f"e {edge.start} {edge.end}\n")
+
+    @staticmethod
+    def load(path: str) -> Graph:
+        graph = Graph()
+        with open(path, "r") as f:
+            lines = f.read().splitlines()
+            for line in lines:
+                if len(line.strip()) == 0:
+                    continue
+
+                entry_type, values = line.split(" ", 1)
+                if entry_type == "n":
+                    x, z, name = values.split(" ", 2)
+                    x, z = int(x), int(z)
+                    graph.add_node(x, z, name)
+                elif entry_type == "e":
+                    start, end = values.split(" ", 2)
+                    start, end = int(start), int(end)
+                    graph.add_edge(start, end, False)
+
+        graph.recompute_lengths()
+        return graph

src/graph/node.py

@@ -0,0 +1,9 @@
+class Node:
+    def __init__(self, x: int, z: int, index: int, name: str = ""):
+        self.x: int = x
+        self.z: int = z
+        self.index: int = index
+        self.name: str = name
+
+    def rename_node(self, name: str):
+        self.name = name

utils/dijkstra.py

@@ -1,88 +0,0 @@
-from math import inf
-from typing import Iterator, Optional
-
-
-class Node:
-    def __init__(self, x: int, y: int):
-        self.x: int = x
-        self.y: int = y
-
-
-class Edge:
-    def __init__(self, start: int, end: int, length: float):
-        self.length: float = length
-        self.start: int = start
-        self.end: int = end
-
-
-class Graph:
-    def __init__(self):
-        self.edges: list[Edge] = []
-        self.nodes: list[Node] = []
-
-    def add_node(self, x: int, y: int) -> None:
-        self.nodes.append(Node(x, y))
-
-    def add_edge(self, start_index: int, end_index: int, length: float) -> None:
-        self.edges.append(Edge(start_index, end_index, length))
-
-    def edges_adjacent_to(self, node_i: int) -> Iterator[Edge]:
-        return filter(lambda e: e.start == node_i or e.end == node_i, self.edges)
-
-    def dijkstra(self, source_index: int, target_index: int) -> Optional[list[int]]:
-        n = len(self.nodes)
-
-        if source_index < 0 or source_index >= n:
-            return None
-
-        if target_index < 0 or target_index >= n:
-            return None
-
-        unvisited = list(range(n))
-
-        distances_from_start = [inf] * n
-        distances_from_start[source_index] = 0
-
-        node_sequences = [[] for _ in range(n)]
-        node_sequences[source_index] = [source_index]
-
-        while True:
-            current_index = min(unvisited, key=lambda i: distances_from_start[i])
-
-            if current_index == target_index:
-                break
-
-            unvisited.remove(current_index)
-
-            for edge in self.edges_adjacent_to(current_index):
-                start = current_index
-                end = edge.end if edge.start == current_index else edge.start
-
-                if end in unvisited and distances_from_start[end] > distances_from_start[start] + edge.length:
-                    distances_from_start[end] = distances_from_start[start] + edge.length
-                    node_sequences[end] = node_sequences[start].copy()
-                    node_sequences[end].append(end)
-
-        return node_sequences[target_index]
-
-
-def main() -> None:
-    graph = Graph()
-
-    graph.add_node(1, 2)
-    graph.add_node(4, 7)
-    graph.add_node(3, 1)
-    graph.add_node(-2, 0)
-    graph.add_node(0, 0)
-
-    graph.add_edge(0, 1, 1)
-    graph.add_edge(1, 2, 2)
-    graph.add_edge(2, 3, 3)
-    graph.add_edge(3, 0, 1)
-    graph.add_edge(1, 3, 3)
-
-    print(graph.dijkstra(0, 3))
-
-
-if __name__ == "__main__":
-    main()

utils/map_splitter.py

@@ -8,6 +8,7 @@ Image.MAX_IMAGE_PIXELS = 200000000
 MAP_SIZE = 1024
 DEFAULT_PATH = os.path.join(platformdirs.user_cache_dir(appname="lycacraft-paths", appauthor="Lycacraft"), "maps")
 
+
 def clamp(mn, value, mx):
     return max(mn, min(mx, value))