113 lines
3.8 KiB
Zig
113 lines
3.8 KiB
Zig
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),
|
|
highlighted_node: ?*Node,
|
|
|
|
pub fn init(allocator: std.mem.Allocator) !NodeManager {
|
|
return .{
|
|
.temp_node = null,
|
|
.nodes = try .initCapacity(allocator, c.ALLOC_SIZE),
|
|
.highlighted_node = null,
|
|
};
|
|
}
|
|
|
|
pub fn deinit(self: *NodeManager, allocator: std.mem.Allocator) void {
|
|
self.clear(allocator);
|
|
self.nodes.deinit(allocator);
|
|
}
|
|
|
|
pub fn draw(self: *const NodeManager, display_details: bool) void {
|
|
for (self.nodes.items) |node| {
|
|
if (display_details) rl.drawCircleV(node.pos, c.NODE_SNAP_RADIUS, .pink);
|
|
rl.drawCircleV(node.pos, c.NODE_RADIUS, .brown);
|
|
}
|
|
|
|
const pos = rl.getMousePosition();
|
|
|
|
if (self.temp_node) |node| {
|
|
rl.drawLineEx(node.pos, pos, c.ROAD_SIZE, .black);
|
|
rl.drawCircleV(node.pos, c.NODE_RADIUS, .brown);
|
|
|
|
rl.drawCircleV(pos, c.NODE_RADIUS, .blue);
|
|
}
|
|
}
|
|
|
|
/// Adds a new node to the list, and if the temp_node already has a value it returns the pointer to the 2nd one
|
|
pub fn add(self: *NodeManager, pos: rl.Vector2) ?*Node {
|
|
const pos_node = self.getSelectedNode(pos);
|
|
|
|
if (self.temp_node != null) return pos_node;
|
|
|
|
self.temp_node = pos_node;
|
|
return null;
|
|
}
|
|
|
|
pub fn getNodeWithinRadius(self: *const NodeManager, pos: rl.Vector2) ?*Node {
|
|
for (self.nodes.items) |*node| {
|
|
if (!node.withinSnappingRadius(pos))
|
|
continue;
|
|
|
|
return node;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
/// Returns the pointer to the node that is in the snapping node radius of the pos
|
|
/// or creates a new node and returns pointer to it
|
|
fn getSelectedNode(self: *NodeManager, pos: rl.Vector2) *Node {
|
|
if (self.getNodeWithinRadius(pos)) |node| 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", .{err});
|
|
};
|
|
|
|
return self.getLastRef().?;
|
|
}
|
|
|
|
/// Returns the reference to the last element in the list; returns null if there are no elements in the list
|
|
fn getLastRef(self: *const NodeManager) ?*Node {
|
|
const nlen = self.nodes.items.len;
|
|
return if (nlen == 0) null else &self.nodes.items[nlen - 1];
|
|
}
|
|
|
|
/// generates finds the last element in the list and returns id + 1 or 0 if there are no elements in the list
|
|
fn getNewID(self: *const NodeManager) usize {
|
|
return if (self.getLastRef()) |ref| ref.*.id + 1 else 0;
|
|
}
|
|
|
|
/// Iterates through all nodes and runs the deinit procedure on each of them
|
|
pub fn clear(self: *NodeManager, allocator: std.mem.Allocator) void {
|
|
for (self.nodes.items) |*node| {
|
|
node.deinit(allocator);
|
|
}
|
|
}
|
|
|
|
/// Removes the node from the list with all appropriate checks
|
|
pub fn remove(self: *NodeManager, allocator: std.mem.Allocator, node_to_remove: *Node) !void {
|
|
// In case the node has references to the existing roads we can not remove it
|
|
// This also means we don't have to deinit it, since it has no elements
|
|
if (node_to_remove.roads.items.len > 0) return;
|
|
|
|
for (self.nodes.items, 0..) |*node, i| {
|
|
if (node.id != node_to_remove.id) continue;
|
|
|
|
node.deinit(allocator);
|
|
_ = self.nodes.swapRemove(i);
|
|
return;
|
|
}
|
|
|
|
return error.NodeNotExist;
|
|
}
|
|
|
|
|
|
}; |