Implemented valid route setting

removed

src/common/structures.odin

@@ -15,4 +15,16 @@ Entity :: enum {
 	Node,
 	Road,
 	Car,
+}
+
+Infrastructure :: enum {
+	Node,
+	Road
+}
+
+Car_Position :: struct {
+	// Tracks which infrastructure the vehicle occupies
+	type: Infrastructure,
+	// Tracks the reference
+	ref: u32,
 }

src/draw.odin

@@ -45,7 +45,10 @@ draw_nodes :: proc(self: ^Simulator) {
 @(private="file")
 draw_cars :: proc(self: ^Simulator) {
 	for &car in self.cars {
-		pos := self.nodes[car.origin].pos
+		ref := car.pos.ref
+		// TODO fix in the future
+		// let's fix it by tracking length of the road and 
+		pos := car.pos.type == .Node ? self.nodes[ref].pos : self.nodes[self.roads[ref].nodes[0]].pos
 		
 		rect := rl.Rectangle {
 			x = pos.x,

src/infrastructure_helpers.odin

@@ -76,6 +76,14 @@ delete_entity :: proc(self: ^Simulator, entity_index: u32, type: common.Entity)
 	
 	switch type {
 	case .Node:
+		// get cars that are on that node
+		for i in 0..<len(self.cars) {
+			pos := self.cars[i].pos
+			if pos.type != .Node || pos.ref != entity_index do continue
+			
+			delete_entity(self, u32(i), .Car)
+		}
+		
 		unordered_remove(&self.nodes, entity_index)
 		if !swap_made do return {}, false
 		
@@ -83,6 +91,14 @@ delete_entity :: proc(self: ^Simulator, entity_index: u32, type: common.Entity)
 		for &car in self.cars do v.car_update_node_reference(&car, index_change[0], index_change[1])
 		return index_change, true
 	case .Road:
+		// get cars that are on that road
+		for i in 0..<len(self.cars) {
+			pos := self.cars[i].pos
+			if pos.type != .Road || pos.ref != entity_index do continue
+			
+			delete_entity(self, u32(i), .Car)
+		}
+		
 		unordered_remove(&self.roads, entity_index)
 		if !swap_made do return {}, false
 		
@@ -103,15 +119,13 @@ get_free_node :: proc(self: ^Simulator) -> Maybe(u32) {
 	car_occupied_nodes: [dynamic]u32
 	
 	for car in self.cars {
-		node, ok := car.node_pos.?
-		if !ok do continue
+		if car.pos.type != .Node do continue
 		
-		if common.list_contains(car_occupied_nodes[:], node) do continue
-		append(&car_occupied_nodes, node)
+		if common.list_contains(car_occupied_nodes[:], car.pos.ref) do continue
+		append(&car_occupied_nodes, car.pos.ref)
 	}
 	
 	if len(car_occupied_nodes) == len(self.nodes) do return nil
-	
 	for {
 		node := rand.uint32_max(u32(len(self.nodes)))
 		

src/input.odin

@@ -2,6 +2,7 @@ package main
 
 import rl "vendor:raylib"
 
+import "common"
 import inf "infrastructure"
 import v "vehicles"
 
@@ -27,8 +28,12 @@ handle_keyboard_input :: proc(self: ^Simulator) {
 
 	if !rl.IsKeyReleased(.N) || len(self.nodes) == 0 do return
 
-	car := v.car_init(get_free_node(self), self.nodes[:])
-	append(&self.cars, car)
+	if node_id, ok := get_free_node(self).?; ok {
+		car := v.car_init(node_id, self.nodes[:])
+		set_car_route(self, &car)
+		append(&self.cars, car)
+		v.car_print_route(u32(len(self.cars)) - 1, &car)
+	}
 }
 
 // Generally mouse event handler

src/pathfinding.odin

@@ -1,7 +1,10 @@
 package main
 
+import "core:math/rand"
+
 import "common"
 import inf "infrastructure"
+import v "vehicles"
 
 // Returns path to destination node => road => node
 get_path_to_destination :: proc(self: ^Simulator, source: u32, destination: u32) -> []u32 {
@@ -40,4 +43,25 @@ get_neighbouring_nodes :: proc(self: ^Simulator, node_index: u32) -> []u32 {
 	}
 	
 	return neighbour_nodes[:]
+}
+
+set_car_route :: proc(self: ^Simulator, car: ^v.Car) {
+	destination_reachable := false
+	destination: u32
+	
+	for !destination_reachable {
+		ignored_nodes: [dynamic]u32
+		
+		for {
+			destination = rand.uint32_max(u32(len(self.nodes)))
+			
+			if car.pos.type != .Node || car.pos.ref != destination do break
+		}
+		
+		// TODO this will need be fixed because we have not encountered what to do if car is at the middle of the road
+		source := car.pos.type == .Node ? car.pos.ref : self.roads[car.pos.ref].nodes[0]
+		destination_reachable = get_destination_reachable(self, source, destination, &ignored_nodes)
+	}
+	
+	car.destination = destination
 }

src/vehicles/car.odin

@@ -1,7 +1,8 @@
 package vehicles
 
-import "core:math/rand"
+import "core:fmt"
 import rl "vendor:raylib"
+import sc "core:strconv"
 
 import "../common"
 import inf "../infrastructure"
@@ -14,18 +15,13 @@ Car :: struct {
 	
 	// Pathfinding
 	
-	// Car's origin node
-	origin: u32,
+	// Car's current node/road
+	pos: common.Car_Position,
 	// Car's destination node
 	destination: Maybe(u32),
-	// Tracks on which node car has been last
-	// 
-	// if null car is not on node
-	node_pos: Maybe(u32), 
-	// if null car is not on road
-	road_pos: Maybe(u32),
-	// tracks absolute pos
-	actual_pos: rl.Vector2,
+	
+	// tracks absolute pos (within canvas)
+	absolute_pos: rl.Vector2,
 }
 
 // Constructor
@@ -33,21 +29,29 @@ car_init :: proc(spawn_node: u32, nodes: []inf.Node) -> Car {
 	return {
 		fuel_level = common.FUEL_MAX,
 		max_speed = common.CAR_MAX_SPEED,
-		origin = spawn_node,
-		node_pos = spawn_node,
-		actual_pos = nodes[spawn_node].pos
+		pos = common.Car_Position {
+			type = .Node,
+			ref = spawn_node,
+		},
+		absolute_pos = nodes[spawn_node].pos
 	}
 }
 
-// Sets a (valid) route for the car
-// 
-// Does NOT guarantee the route is reachable (TODO!)
-car_set_route :: proc(self: ^Car, nodes_len: u32) {
-	for self.origin == self.destination do self.destination = rand.uint32_max(nodes_len)
-}
-
 // Updates (origin and destination) node reference
 car_update_node_reference :: proc(self: ^Car, old_ref: u32, new_ref: u32) {
-	if self.origin == old_ref do self.origin = new_ref
+	if self.pos.type == .Node && self.pos.ref == old_ref do self.pos.ref = new_ref
 	if self.destination == old_ref do self.destination = new_ref
+}
+
+// Prints car's route
+car_print_route :: proc(id: Maybe(u32) = nil, self: ^Car) {
+	val, ok := self.destination.?
+	destination := ok ? fmt.aprintf("N%d", val) : "/"
+	source_type := self.pos.type == .Node ? 'N' : 'R'
+	
+	car_id, ok_val := id.?
+	buf: [100]u8
+	id_str := ok_val ? sc.write_uint(buf[:], u64(car_id), 10) : "N/A"
+	
+	fmt.printfln("ID=%s Source=%c%d, Destination=%s", id_str, source_type, self.pos.ref, destination)
 }