Merge branch 'feat/graph-edition' of https://git.kb28.ch/HEL/LycacraftMaps into feat/graph-edition

src/editor.py

@@ -7,6 +7,7 @@ import platformdirs
 import pygame
 
 from src.image_handler import ImageHandler
+from src.graph.graph import Graph
 
 
 class Editor:
@@ -37,7 +38,14 @@ class Editor:
             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.selected_node: int = -1
 
     def mainloop(self) -> None:
         self.state = State.LOADING
@@ -63,17 +71,40 @@ class Editor:
                 self.width = event.x
                 self.height = event.y
             elif event.type == pygame.KEYDOWN:
-                if event.key == pygame.K_ESCAPE:
+                if self.typing:
-                    self.state = State.STOPPING
+                    if event.key == pygame.K_ESCAPE:
-                elif event.key == pygame.K_PAGEUP:
+                        self.typing = False
-                    self.zoom_in()
+                        self.is_creating_node = False
-                elif event.key == pygame.K_PAGEDOWN:
+                        self.node_candidate_pos = None
-                    self.zoom_out()
+                        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_node != -1:
+                            self.selected_node = -1
+                        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 and keys[pygame.K_LCTRL]:
+                elif event.button == 1:
-                    self.left_drag_pos = event.pos
+                    if keys[pygame.K_LCTRL]:
+                        self.left_drag_pos = event.pos
+                    else:
+                        self.selected_node = self.get_hover_node()
+                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:
@@ -143,6 +174,8 @@ class Editor:
                     oy + y * self.MAP_SIZE
                 ])
         
+        self.render_nodes()
+
         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 +186,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_creating_node:
+            self.render_node_creator()
+
         pygame.display.flip()
 
     def render_zoom_slider(self) -> None:
@@ -189,12 +225,50 @@ 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_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_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)
+        if self.selected_node != -1:
+            node = self.graph.nodes[self.selected_node]
+            node_pos = self.world_to_screen(node.x, node.z)
+            pygame.draw.circle(self.win, (0, 255, 255), (node_pos[0], node_pos[1]), self.node_radius)
+        self.render_mouse_hover_node()
+        
+    
+    def render_mouse_hover_node(self):
+        node_index = self.get_hover_node()
+        if node_index != -1:
+            node = self.graph.nodes[self.get_hover_node()]
+            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, (int) (self.node_radius / 5))
+
     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,8 +287,43 @@ 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 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
+    
+    def get_hovering_nodes(self) -> list[int]:
+        hovering = []
+        mouse_pos = pygame.mouse.get_pos()
+
+        for node in self.graph.nodes:
+            node_pos = self.world_to_screen(node.x, node.z)
+            if ((mouse_pos[0] - node_pos[0]) ** 2 + (mouse_pos[1] - node_pos[1]) ** 2) < self.node_radius ** 2 :
+                hovering.append(self.graph.nodes.index(node))
+        
+        return hovering
+    
+    def get_hover_node(self) -> int:
+        hover_nodes = self.get_hovering_nodes()
+        return -1 if len(hover_nodes) == 0 else hover_nodes[0]
+
+
+
+
+
 
 class State(Enum):
     STOPPING = auto()
     LOADING = auto()
     RUNNING = auto()
+    CREATING_NODE = auto()

src/graph/edge.py

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

src/graph/graph.py

@@ -1,27 +1,16 @@
 from math import inf
 from typing import Iterator, Optional
 
-
+from src.graph.node import Node
-class Node:
+from src.graph.edge import Edge
-    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:
+    def add_node(self, x: int, y: int, name: str) -> None:
-        self.nodes.append(Node(x, y))
+        self.nodes.append(Node(x, y, name))
 
     def add_edge(self, start_index: int, end_index: int, length: float) -> None:
         self.edges.append(Edge(start_index, end_index, length))
@@ -64,25 +53,3 @@ class Graph:
                     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()

src/graph/node.py

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