extends Node3D
class_name Race
# in order of initialization
var car_scene: PackedScene
var track_loader_scene: PackedScene
var ghost_scene: PackedScene
var track_res: TrackResource
var track: TrackLoader
var data: Array[GhostData]
var best_time_data: GhostData
var cars: Array[Car]
var cars_needed: PackedInt32Array = []
var finished_cars := 0
@onready var mp := cars_needed.size() > 1
var ghost: GhostCar
var start_frame: int
var current_lap: PackedInt32Array = []
var playing := false
var timers: Array[GameTimer]
var distances: PackedFloat32Array = []
signal next_lap
signal created_car(car: Car, n: int)
signal created_ghost(ghost: GhostCar)
signal finished(time: float, prev_time: float, n: int)
signal all_finished
signal split(time: float, prev_time: float, n: int)
signal did_reset
func _init(t: TrackResource, ghost_data: GhostData, _car_scene, _ghost_scene, _track_loader_scene) -> void:
car_scene = _car_scene
ghost_scene = _ghost_scene
track_loader_scene = _track_loader_scene
track_res = t
best_time_data = ghost_data
func mkghost() -> void:
ghost = ghost_scene.instantiate()
add_child(ghost)
reset_ghost()
created_ghost.emit(ghost)
func reset_ghost() -> void:
if best_time_data:
ghost.update(best_time_data.load_snap(0), -1)
ghost.engine.volume = .2
else:
ghost.engine.volume = 0
ghost.global_position = track.start_transf.origin + Vector3(0, 1, -2)
ghost.rotation = track.start_transf.basis.get_euler()# + Vector3(0, PI, -PI/2)
ghost.reset()
ghost.hide()
func reset_car(i: int) -> void:
await get_tree().physics_frame
cars[i].rotation = track.start_transf.basis.get_euler()# + Vector3(0, PI, -PI/2)
cars[i].global_position = track.start_transf.origin + Vector3(0, 1, -2)
cars[i].linear_velocity = Vector3.ZERO
cars[i].angular_velocity = Vector3.ZERO
cars[i].current_gear = 0
cars[i].reset()
func mkcar(i: int, dev: int) -> void:
cars[i] = HumanCar.attach(car_scene, dev)
add_child(cars[i])
reset_car(i)
created_car.emit(cars[i], i)
if !mp:
cars[i].collision_mask = 2 ^ 1
func _ready() -> void:
set_physics_process(false)
track = track_loader_scene.instantiate()
track.track = track_res
add_child(track)
data.resize(cars_needed.size())
cars.resize(cars_needed.size())
current_lap.resize(cars_needed.size())
current_lap.fill(0)
timers.resize(cars_needed.size())
if mp:
distances.resize(cars_needed.size())
distances.fill(0)
for i in cars_needed.size():
data[i] = GhostData.new(track.checkpoints.size(), track_res.laps)
timers[i] = GameTimer.new()
add_child(timers[i])
mkcar(i, cars_needed[i])
mkghost()
connect_checkpoints()
func _input(event: InputEvent) -> void:
if event.is_action("reset") and playing:
reset()
func reset() -> void:
playing = false
finished_cars = 0
if best_time_data:
if ghost:
reset_ghost()
distances.fill(0)
for car in cars.size():
await reset_car(car)
current_lap[car] = 0
set_physics_process(false)
for d in data:
d.clear()
for timer in timers:
timer.reset()
did_reset.emit()
func fcar(c: Car) -> int:
return cars.find(c)
func connect_checkpoints() -> void:
for i in len(track.checkpoints):
track.checkpoints[i].collected.connect(func(c: Car): passed_cp(i, fcar(c)))
track.finish.collected.connect(func(c: Car): passed_finish(fcar(c)))
func passed_cp(cp: int, car: int) -> void: if playing and !data[car].has_collected(current_lap[car], cp): collect(cp, car)
func passed_finish(car: int) -> void:
if !playing: return
for i in len(data[car].checkpoints[current_lap[car]]) - 1:
if data[car].checkpoints[current_lap[car]][i] < 0:
return
collect(-1, car)
if track_res.laps - 1 == current_lap[car]:
timers[car].stop()
cars[car].reset()
finished_cars += 1
finished.emit(data[car].time, best_time_data.time if best_time_data else -1.0, car)
if finished_cars > cars.size() - 1: # all finished
var best = {time = INF}
for datapoint in data:
if best.time > datapoint.time:
best = datapoint
if not best_time_data or best.time < best_time_data.time:
best.save(Globals.SAVES % track_res.name)
best_time_data = best
all_finished.emit()
playing = false
else:
current_lap[car] += 1
next_lap.emit()
func _physics_process(delta: float) -> void:
if mp:
for i in cars_needed.size():
if distances[i] < 0:
continue
var flag := true
for j in cars_needed.size():
if j == i: continue
var dist := cars[i].global_position.distance_squared_to(cars[j].global_position)
if dist > 50:
continue
flag = false
break # gdscript cant label loops
if flag:
distances[i] = distances[i] + delta
if distances[i] > 1.5: # when apart for longer than 1.5 seconds, enable collisions
distances[i] = -1
cars[i].collision_mask = 1 ^ 2 # world & players
for i in data.size():
data[i].snapshot(cars[i])
if best_time_data:
if best_time_data.snap_count - 1 < Engine.get_physics_frames() - start_frame:
if ghost.visible:
ghost.hide()
ghost.engine.volume = 0
return
ghost.update(best_time_data.load_snap(Engine.get_physics_frames() - start_frame), delta)
ghost.visible = (ghost.global_position.distance_squared_to(cars[0].global_position) > 10)
ghost.engine.volume = lerpf(ghost.engine.volume, .7, delta * 3) if (ghost.global_position.distance_squared_to(cars[0].global_position) > 20) else lerpf(ghost.engine.volume, .2, delta * 3)
func collect(cp: int, car: int) -> void:
if cp != -1:
cars[car].checkpoint_sound.play()
var time := best_time_data.get_time(current_lap[car], cp) if best_time_data else -1.0
time = best_time_data.time if (not track_res.laps or track_res.laps == current_lap[car] + 1) and cp == -1 and time != -1.0 else time
split.emit(snappedf(timers[car].now(), .001), time, car)
data[car].collect(current_lap[car], cp, snappedf(timers[car].now(), .001))
func start() -> void:
for timer in timers:
timer.start()
start_frame = Engine.get_physics_frames()
playing = true
set_physics_process(true)
for car in cars:
car.start()