Initial commit

src/constants.zig

@@ -0,0 +1,7 @@
+pub const WIDTH = 1920;
+pub const HEIGHT = 1080;
+
+pub const ALLOC_SIZE = 50;
+pub const NODE_RADIUS = 20;
+pub const NODE_SNAP_RADIUS = 3;
+pub const ROAD_SIZE = 20;

src/infrastructure/node.zig

@@ -0,0 +1,38 @@
+const std = @import("std");
+
+const s = @import("../structures.zig");
+const c = @import("../constants.zig");
+
+const Road = @import("road.zig").Road;
+
+pub const Node = struct {
+    id: usize,
+    pos: s.Vector2,
+    roads: std.ArrayList(*Road),
+
+    pub fn init(new_id: usize, new_pos: s.Vector2) Node {
+        return .{
+            .id = new_id,
+            .pos = new_pos,
+            .roads = .empty,
+        };
+    }
+
+    pub fn deinit(self: *Node, allocator: std.mem.Allocator) void {
+        self.roads.deinit(allocator);
+    }
+
+    pub fn referenceRoad(self: *Node, allocator: std.mem.Allocator, road: *Road) !void {
+        if (self.roadInList(road)) return;
+
+        try self.roads.append(allocator, road);
+    }
+
+    fn roadInList(self: *const Node, road_to_add: *const Road) bool {
+        for (self.roads.items) |road| {
+            if (road.id == road_to_add.id) return true;
+        }
+
+        return false;
+    }
+};

src/infrastructure/node_manager.zig

@@ -0,0 +1,81 @@
+const std = @import("std");
+const rl = @import("raylib");
+
+const c = @import("../constants.zig");
+const Node = @import("node.zig").Node;
+
+pub const NodeManager = struct {
+    temp_node: ?*Node,
+    nodes: std.ArrayList(Node),
+
+    pub fn init(allocator: std.mem.Allocator) !NodeManager {
+        return .{
+            .temp_node = null,
+            .nodes = try .initCapacity(allocator, c.ALLOC_SIZE),
+        };
+    }
+
+    pub fn deinit(self: *NodeManager, allocator: std.mem.Allocator) void {
+        for (self.nodes.items) |*node| {
+            node.deinit(allocator);
+        }
+        self.nodes.deinit(allocator);
+    }
+
+    pub fn draw(self: *const NodeManager, display_details: bool) void {
+        for (self.nodes.items) |node| {
+            rl.drawCircleV(node.pos, c.NODE_RADIUS, .brown);
+        }
+
+        const pos = rl.getMousePosition();
+
+        if (self.temp_node) |node| {
+            if (display_details) rl.drawCircleV(node.pos, c.NODE_SNAP_RADIUS * c.NODE_RADIUS, .pink);
+
+            rl.drawLineEx(node.pos, pos, c.ROAD_SIZE, .black);
+            rl.drawCircleV(node.pos, c.NODE_RADIUS, .brown);
+
+            rl.drawCircleV(pos, c.NODE_RADIUS, .blue);
+        }
+    }
+
+    pub fn add(self: *NodeManager, pos: rl.Vector2) ?*Node {
+        const pos_node = self.getSelectedNode(pos);
+
+        if (self.temp_node) |_| {
+            return pos_node;
+        }
+
+        self.temp_node = pos_node;
+        return null;
+    }
+
+    fn getSelectedNode(self: *NodeManager, pos: rl.Vector2) *Node {
+        for (self.nodes.items) |*node| {
+            if (!rl.checkCollisionPointCircle(pos, node.pos, c.NODE_SNAP_RADIUS * c.NODE_RADIUS))
+                continue;
+
+            return node;
+        }
+
+        // We couldn't find the existing node and as such must create a new one
+        const node: Node = .init(self.getNewID(), pos);
+
+        self.nodes.appendBounded(node) catch |err| {
+            std.debug.panic("This is because preallocated size got exceeded, TODO fix:\n{}\n", .{err});
+        };
+
+        return self.getLastRef().?;
+    }
+
+    fn getNewID(self: *const NodeManager) usize {
+        const last_ref = self.getLastRef();
+
+        return if (last_ref) |ref| ref.*.id + 1 else 0;
+    }
+
+    fn getLastRef(self: *const NodeManager) ?*Node {
+        const nlen = self.nodes.items.len;
+        return if (nlen == 0) null else &self.nodes.items[nlen - 1];
+    }
+};

src/infrastructure/road.zig

@@ -0,0 +1,13 @@
+const Node = @import("node.zig").Node;
+
+pub const Road = struct {
+    id: usize,
+    nodes: [2]*Node,
+
+    pub fn init(new_id: usize, start_node: *Node, end_node: *Node) Road {
+        return .{
+            .id = new_id,
+            .nodes = .{start_node, end_node},
+        };
+    }
+};

src/infrastructure/road_manager.zig

@@ -0,0 +1,52 @@
+const std = @import("std");
+const rl = @import("raylib");
+
+const c = @import("../constants.zig");
+const Road = @import("road.zig").Road;
+const Node = @import("node.zig").Node;
+
+pub const RoadManager = struct {
+    roads: std.ArrayList(Road),
+
+    pub fn init(allocator: std.mem.Allocator) !RoadManager {
+        return .{
+            .roads = try .initCapacity(allocator, c.ALLOC_SIZE),
+        };
+    }
+
+    pub fn deinit(self: *RoadManager, allocator: std.mem.Allocator) void {
+        self.roads.deinit(allocator);
+    }
+
+    pub fn draw(self: *const RoadManager) void {
+        for (self.roads.items) |road| {
+            rl.drawLineEx(road.nodes[0].*.pos, road.nodes[1].*.pos, c.ROAD_SIZE, .black);
+        }
+    }
+
+    pub fn add(self: *RoadManager, allocator: std.mem.Allocator, start_node: *Node, end_node: *Node) !void {
+        const road: Road = .init(self.getNewID(), start_node, end_node);
+
+        self.roads.appendBounded(road) catch |err| {
+            std.debug.print("This is because preallocated size got exceeded, TODO fix:\n{}\n", .{err});
+            return error.OutOfMemoryBounded;
+        };
+
+        const road_ref = self.getLastRef().?;
+
+        try start_node.referenceRoad(allocator, road_ref);
+        try end_node.referenceRoad(allocator, road_ref);
+    }
+
+    fn getLastRef(self: *const RoadManager) ?*Road {
+        const rlen = self.roads.items.len;
+
+        return if (rlen == 0) null else &self.roads.items[rlen - 1];
+    }
+
+    fn getNewID(self: *const RoadManager) usize {
+        const last_ref = self.getLastRef();
+
+        return if (last_ref) |ref| ref.*.id + 1 else 0;
+    }
+};

src/main.zig

@@ -0,0 +1,33 @@
+const std = @import("std");
+const rl = @import("raylib");
+
+const c = @import("constants.zig");
+const Simulator = @import("simulator.zig").Simulator;
+
+pub fn main() !void {
+    var gpa: std.heap.DebugAllocator(.{}) = .init;
+    defer {
+        const result = gpa.deinit();
+        if (result == .leak) @panic("MEMORY LEAK DETECTED");
+    }
+
+    rl.setConfigFlags(.{.msaa_4x_hint = true, .window_highdpi = true});
+    rl.initWindow(c.WIDTH, c.HEIGHT, "Base Road Network");
+    defer rl.closeWindow();
+
+    const monitor = 0;
+    rl.setWindowMonitor(monitor);
+    rl.setTargetFPS(rl.getMonitorRefreshRate(0));
+
+    var sim: Simulator = try .init(gpa.allocator());
+    defer sim.deinit();
+
+    while (!rl.windowShouldClose()) {
+        rl.beginDrawing();
+        defer rl.endDrawing();
+
+        sim.handleInput();
+
+        sim.draw();
+    }
+}

src/simulator.zig

@@ -0,0 +1,58 @@
+const std = @import("std");
+const rl = @import("raylib");
+
+const NodeManager = @import("infrastructure/node_manager.zig").NodeManager;
+const RoadManager = @import("infrastructure/road_manager.zig").RoadManager;
+
+pub const Simulator = struct {
+    allocator: std.mem.Allocator,
+    node_man: NodeManager,
+    road_man: RoadManager,
+    display_details: bool,
+    auto_continue: bool,
+
+    pub fn init(allocator: std.mem.Allocator) !Simulator {
+        return .{
+            .allocator = allocator,
+            .node_man = try .init(allocator),
+            .road_man = try .init(allocator),
+            .display_details = false,
+            .auto_continue = false,
+        };
+    }
+
+    pub fn deinit(self: *Simulator) void {
+        self.node_man.deinit(self.allocator);
+        self.road_man.deinit(self.allocator);
+    }
+
+    pub fn handleInput(self: *Simulator) void {
+        self.handleKeyboardInput();
+        self.handleMouseInput();
+    }
+
+    fn handleKeyboardInput(self: *Simulator) void {
+        self.display_details = rl.isKeyDown(.left_alt);
+        self.auto_continue = rl.isKeyDown(.left_control);
+    }
+
+    fn handleMouseInput(self: *Simulator) void {
+        const pos = rl.getMousePosition();
+        if (!rl.isMouseButtonReleased(.left)) return;
+
+        if (self.node_man.add(pos)) |node| {
+            self.road_man.add(self.allocator, self.node_man.temp_node.?, node) catch |err| {
+                std.debug.panic("Error while attempting to add a road:\n{}\n", .{err});
+            };
+
+            self.node_man.temp_node = if (self.auto_continue) node else null;
+        }
+    }
+
+    pub fn draw(self: *const Simulator) void {
+        self.road_man.draw();
+        self.node_man.draw(self.display_details);
+
+        rl.clearBackground(.light_gray);
+    }
+};

src/structures.zig

@@ -0,0 +1 @@
+pub const Vector2 = @import("raylib").Vector2;