Deletion implemented

src/simulator.zig

@@ -11,6 +11,7 @@ pub const Simulator = struct {
     road_man: RoadManager,
     // vars
     auto_continue: bool,
+    delete_mode: bool,
 
     pub fn init(new_allocator: std.mem.Allocator) Simulator {
         return .{
@@ -18,21 +19,26 @@ pub const Simulator = struct {
             .node_man = .init(),
             .road_man = .init(),
             .auto_continue = false,
+            .delete_mode = false,
         };
     }
 
-    pub fn deinit(self: *Simulator) void {
+    pub fn deinit(self: *Simulator) !void {
         self.road_man.deinit(self.allocator);
-        self.node_man.deinit(self.allocator);
+        try self.node_man.deinit(self.allocator);
     }
 
     pub fn draw(self: *const Simulator, pos: rl.Vector2) void {
         rl.clearBackground(c.BACKGROUND_COLOR);
 
-        self.road_man.draw();
+        self.road_man.draw(self.delete_mode);
         self.node_man.draw(pos);
     }
 
+    pub fn update(self: *Simulator, pos: rl.Vector2) void {
+        self.road_man.update_highlighted_road(pos);
+    }
+
     pub fn handleInput(self: *Simulator, pos: rl.Vector2) void {
         self.handleKeyboardInput();
         self.handleMouseInput(pos);
@@ -40,8 +46,11 @@ pub const Simulator = struct {
 
     fn handleKeyboardInput(self: *Simulator) void {
         self.auto_continue = rl.isKeyDown(.left_control);
+        self.delete_mode = rl.isKeyDown(.left_shift);
 
-        if (rl.isKeyReleased(.c)) self.clear();
+        if (rl.isKeyReleased(.c)) self.clear() catch |err| {
+            std.debug.panic("Failed to clear the entities: {}\n", .{err});
+        };
     }
 
     fn handleMouseInput(self: *Simulator, pos: rl.Vector2) void {
@@ -49,6 +58,16 @@ pub const Simulator = struct {
     }
 
     fn leftClickEvent(self: *Simulator, pos: rl.Vector2) void {
+        if (self.delete_mode) {
+            self.delete_road() catch |err| {
+                std.debug.panic("Failed to delete the road: {}\n", .{err});
+            };
+            return;
+        }
+        self.new_road(pos);
+    }
+
+    fn new_road(self: *Simulator, pos: rl.Vector2) void {
         const cur_node = self.node_man.getSelectedNode(self.allocator, pos) catch |err| {
             std.debug.panic("Failed to append the newly created node at pos ({d}, {d}) to node list: {}\n", .{
                 pos.x, pos.y, err
@@ -68,8 +87,27 @@ pub const Simulator = struct {
         self.node_man.temp_node = cur_node;
     }
 
-    fn clear(self: *Simulator) void {
+    fn delete_road(self: *Simulator) !void {
+        if (self.road_man.highlighted_road == null) return;
+        const h_road = self.road_man.highlighted_road.?;
+
+        const start_node = h_road.*.nodes[0];
+        const end_node = h_road.*.nodes[1];
+
+        self.road_man.deleteRoad(self.allocator, h_road) catch |err| {
+            std.debug.panic("Road deletion failed: {}\n", .{err});
+        };
+        self.road_man.highlighted_road = null;
+
+        if (start_node.roads.items.len == 0)
+            try self.node_man.deleteNode(self.allocator, start_node);
+
+        if (end_node.roads.items.len == 0)
+            try self.node_man.deleteNode(self.allocator, end_node);
+    }
+
+    fn clear(self: *Simulator) !void {
         self.road_man.clear(self.allocator);
-        self.node_man.clear(self.allocator);
+        try self.node_man.clear(self.allocator);
     }
 };