aboutsummaryrefslogtreecommitdiffstats
path: root/source/game/road.odin
blob: dd8985c82750d17541ee577c3855de3a25098bd5 (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
// author: lars
package game

import "core:math"
import "core:math/linalg"

// Landing picks a road this close. The road graph holds the secondary roads and up, so in a city centre the
// nearest one can be 700 m away (Brussels hub: 660 m). Not from the spec or design, see the PR assumptions.
ROAD_LAND_KM :: 1.0

// The airship as a flying car (#67 part 2, #68 option B): on the ground it is locked to the road graph of
// belgium.bin. Its place is an edge and a distance along it, never a free x, y. It lands on a road by descending
// to its lowest height within ROAD_LAND_KM of an edge, and takes off again by climbing (both gradual, see below).
// Throttle drives along the edge (same speed limits as flying), turn picks the next edge at a junction, a
// one-way road is only ever driven its own way. No wind on the ground.

// The edge nearest to pos within radius_km, and the distance along it in km. Brute force over the road points:
// called once when landing, not every step.
road_nearest_edge :: proc(w: ^World, pos: [2]f32, radius_km: f32) -> (edge: int, s_km: f32, ok: bool) {
	best := radius_km
	for e, ei in w.m.road_edges {
		pts := w.m.road_points[e.start:][:e.count]
		along: f32
		for i in 1 ..< len(pts) {
			a, b := pts[i - 1], pts[i]
			ab := b - a
			l2 := linalg.length2(ab)
			f := l2 > 0 ? clamp(linalg.dot(pos - a, ab) / l2, 0, 1) : 0
			d := linalg.length(pos - (a + ab * f))
			seg := math.sqrt(l2)
			if d < best {
				best, edge, s_km, ok = d, ei, along + seg * f, true
			}
			along += seg
		}
	}
	return
}

// Polyline length of an edge in km (length_km is the unsimplified way, the drawn geometry is what we drive on).
road_edge_km :: proc(w: ^World, edge: int) -> f32 {
	e := w.m.road_edges[edge]
	pts := w.m.road_points[e.start:][:e.count]
	km: f32
	for i in 1 ..< len(pts) do km += linalg.length(pts[i] - pts[i - 1])
	return km
}

// Position and heading at s_km along an edge.
road_at :: proc(w: ^World, edge: int, s_km: f32) -> (pos: [2]f32, heading: f32) {
	e := w.m.road_edges[edge]
	pts := w.m.road_points[e.start:][:e.count]
	along: f32
	for i in 1 ..< len(pts) {
		seg := linalg.length(pts[i] - pts[i - 1])
		if along + seg >= s_km || i == len(pts) - 1 {
			f := seg > 0 ? clamp((s_km - along) / seg, 0, 1) : 0
			return linalg.lerp(pts[i - 1], pts[i], f), heading_of(pts[i] - pts[i - 1])
		}
		along += seg
	}
	return pts[0], 0
}

// Heading at the start of an edge.
road_start_heading :: proc(w: ^World, edge: int) -> f32 {
	e := w.m.road_edges[edge]
	pts := w.m.road_points[e.start:][:e.count]
	return heading_of(pts[1] - pts[0])
}

// At the end of edge: the next edge out of its to-node. turn -1..1 bends the wanted heading up to 90 degrees left
// or right of the current one, the edge whose start heading is closest wins. Turning back onto the same road
// (the reverse edge) only at a dead end. -1 when the node has no edge out (a one-way dead end).
road_next_edge :: proc(w: ^World, edge: int, heading: f32, turn: f32) -> int {
	e := w.m.road_edges[edge]
	node := w.m.road_nodes[e.to]
	want := heading + clamp(turn, -1, 1) * math.PI / 2
	best, best_diff := -1, f32(math.F32_MAX)
	back := -1
	for k in node.first ..< node.first + node.count {
		o := w.m.road_edges[k]
		if o.to == e.from && o.count == e.count {
			back = int(k)
			continue
		}
		diff := abs(math.mod(road_start_heading(w, int(k)) - want + 3 * math.PI, math.TAU) - math.PI)
		if diff < best_diff do best, best_diff = int(k), diff
	}
	return best >= 0 ? best : back
}

// Landing and take-off are gradual (Lars, 2026-11-21: a transition between driving and flying). Landing: the
// ship slides onto the road and turns to its heading over ROAD_ALIGN_S while it sinks ROAD_DESCENT_MS from the
// lowest flying height to the road, driving on meanwhile. Take-off: it climbs at least ROAD_LIFT_MS until the
// lowest flying height, the floor does not snap it up. Our values, not from the spec or design.
ROAD_DESCENT_MS :: 4.0
ROAD_LIFT_MS :: 10.0
ROAD_ALIGN_S :: 2.5

// Throttle on the ground: slower than flying, 126 km/h at most. Coming down faster than that, the car brakes.
ROAD_MAX_SPEED :: 35.0
ROAD_ACCEL :: 1.2
ROAD_BRAKE :: 1.6

road_speed :: proc(w: ^World, c: Controls, dt: f32) {
	s := &w.ship
	target := max(c.throttle, 0) * ROAD_MAX_SPEED / ship_jam_factor(w)
	if target > s.speed {
		s.speed = min(s.speed + ROAD_ACCEL * dt, target)
	} else {
		s.speed = max(s.speed - (s.speed > ROAD_MAX_SPEED ? SHIP_BRAKE : ROAD_BRAKE) * dt, target)
	}
}

// Moves road_s on by the speed, onto the next edge at a junction (turn picks it), stops at a dead end.
road_advance :: proc(w: ^World, c: Controls, dt: f32) {
	s := &w.ship
	s.road_s += s.speed * dt / 1000
	for s.road_s > road_edge_km(w, s.road_edge) {
		over := s.road_s - road_edge_km(w, s.road_edge)
		_, h := road_at(w, s.road_edge, s.road_s)
		next := road_next_edge(w, s.road_edge, h, c.turn)
		if next < 0 {
			// A dead end: stop at the node.
			s.road_s = road_edge_km(w, s.road_edge)
			s.speed = 0
			break
		}
		s.road_edge, s.road_s = next, over
	}
}

// One fixed step on the road. Returns false when the ship took off (climb > 0): ship_step then flies on.
road_step :: proc(w: ^World, c: Controls, dt: f32) -> bool {
	s := &w.ship
	if c.climb > 0 {
		s.on_road = false
		s.lifting = true
		return false
	}
	road_speed(w, c, dt)
	road_advance(w, c, dt)
	s.pos, s.heading = road_at(w, s.road_edge, s.road_s)
	s.alt = height_at(w, s.pos.x, s.pos.y)
	s.turn_rate = 0
	s.used_kwh += power_kw(s.speed, 0) * dt / 3600
	s.solar_kwh += solar_kw(cloud_at(w, s.pos.x, s.pos.y, sim_hour(w))) * dt / 3600
	s.warnings = {}
	s.docked = false
	return true
}

// One fixed step of a landing. Returns false when the pilot climbs again: the landing is called off and
// ship_step flies on.
road_landing_step :: proc(w: ^World, c: Controls, dt: f32) -> bool {
	s := &w.ship
	if c.climb > 0 {
		s.landing = false
		return false
	}
	road_speed(w, c, dt)
	road_advance(w, c, dt)
	goal, h := road_at(w, s.road_edge, s.road_s)
	k := min(dt / ROAD_ALIGN_S, 1)
	s.pos += (goal - s.pos) * k
	diff := math.mod(h - s.heading + 3 * math.PI, math.TAU) - math.PI
	s.heading = math.mod(s.heading + diff * k + math.TAU, math.TAU)
	s.turn_rate = diff * k / dt
	ground := height_at(w, goal.x, goal.y)
	s.alt = max(s.alt - ROAD_DESCENT_MS * dt, ground)
	s.used_kwh += power_kw(s.speed, 0) * dt / 3600
	s.solar_kwh += solar_kw(cloud_at(w, s.pos.x, s.pos.y, sim_hour(w))) * dt / 3600
	s.warnings = {}
	s.docked = false
	if s.alt <= ground {
		s.landing = false
		s.on_road = true
		s.pos, s.heading = goal, h
		s.turn_rate = 0
	}
	return true
}

// Landing starts: at the lowest flying height, descending, within ROAD_LAND_KM of a road.
road_try_land :: proc(w: ^World, c: Controls) {
	s := &w.ship
	floor := height_at(w, s.pos.x, s.pos.y) + SHIP_MIN_CLEARANCE
	if s.lifting || c.climb >= 0 || s.alt > floor + 0.5 || len(w.m.road_edges) == 0 do return
	edge, along, ok := road_nearest_edge(w, s.pos, ROAD_LAND_KM)
	if !ok do return
	s.landing = true
	s.road_edge, s.road_s = edge, along
	logf(
		w,
		"ship",
		"landing on road edge %d (%v), %.3f km along",
		edge,
		Map_Kind(w.m.road_edges[edge].kind),
		along,
	)
}