294 lines
8.1 KiB
GDScript
294 lines
8.1 KiB
GDScript
class_name BuggedVehicle
|
|
extends VehicleBody
|
|
|
|
signal speed_updated(speed_kph, speed_percent)
|
|
signal rpm_updated(rpm, rpm_percent)
|
|
signal throttle_updated(throttle_percent)
|
|
signal brake_updated(brake_percent)
|
|
signal clutch_updated(clutch_percent)
|
|
signal gear_updated(gear)
|
|
signal steering_updated(steering_angle, steering_percent)
|
|
signal position_updated(player_id, position)
|
|
|
|
enum GearRequest { NONE, UP, DOWN }
|
|
|
|
export(float) var max_steer_input = 30
|
|
|
|
export(float) var max_engine_force = 85.0
|
|
export(float) var max_brake_force = 50.0
|
|
export(float) var throttle_power = 6000.0
|
|
export(float) var max_rpm_loss_ps = 3000.0
|
|
export(float) var base_engine_pitch = 0.5
|
|
export(float) var expected_max_speed = 200
|
|
|
|
export(float) var drag_factor = 1.0
|
|
export(float) var downforce_factor = 1.0
|
|
|
|
export(Array) var gear_ratios = [3.4, 2.5, 2.0, 1.5, 1.25]
|
|
export(float) var reverse_ratio = -3
|
|
export(float) var final_drive = 3.45
|
|
export(float) var max_rpm = 3500
|
|
export(float) var min_rpm = 900
|
|
export(float) var gear_switch_time = 0.2
|
|
export(Curve) var power_curve = null
|
|
export(Curve) var sound_curve = null
|
|
|
|
export(float) var automatic_gear_up_threshold = 0.8
|
|
export(float) var automatic_gear_down_threshold = 0.3
|
|
|
|
var clutch_position: float = 0.0
|
|
var rpm = 0
|
|
var gear = 1
|
|
|
|
var gear_timer = 0
|
|
|
|
var traction_wheels: Array
|
|
var reset_transform: Transform = Transform.IDENTITY
|
|
|
|
var inputs: VehicleInputs = VehicleInputs.new()
|
|
|
|
onready var frwheel: VehicleWheel = $front_right
|
|
onready var flwheel: VehicleWheel = $front_left
|
|
onready var rrwheel: VehicleWheel = $rear_right
|
|
onready var rlwheel: VehicleWheel = $rear_left
|
|
onready var frsmoke: TireSmoke = $fr_tire_smoke
|
|
onready var flsmoke: TireSmoke = $fl_tire_smoke
|
|
onready var rrsmoke: TireSmoke = $rr_tire_smoke
|
|
onready var rlsmoke: TireSmoke = $rl_tire_smoke
|
|
|
|
onready var engine_sound_player: AudioStreamPlayer3D = $engine_sound_player
|
|
onready var wind_sound_player: AudioStreamPlayer3D = $wind_sound_player
|
|
|
|
onready var max_steer_input_rad: float = deg2rad(max_steer_input)
|
|
|
|
onready var auto_clutch_rpm_limit = max_rpm * automatic_gear_down_threshold
|
|
|
|
|
|
class VehicleInputs:
|
|
var gear_request = GearRequest.NONE
|
|
var clutch = 0.0
|
|
var throttle = 0.0
|
|
var brake = 0.0
|
|
var handbrake = 0.0
|
|
# Left is positive, right is negative
|
|
var steering = 0.0
|
|
|
|
func to_array() -> Array:
|
|
return [gear_request, clutch, throttle, brake, handbrake, steering]
|
|
|
|
func from_array(array: Array) -> void:
|
|
gear_request = array[0]
|
|
clutch = array[1]
|
|
throttle = array[2]
|
|
brake = array[3]
|
|
handbrake = array[4]
|
|
steering = array[5]
|
|
|
|
|
|
func _ready():
|
|
for wheel in [frwheel, flwheel, rrwheel, rlwheel]:
|
|
if wheel.use_as_traction:
|
|
traction_wheels.append(wheel)
|
|
|
|
_generate_engine_sound(0)
|
|
engine_sound_player.play()
|
|
wind_sound_player.play()
|
|
|
|
|
|
func get_cockpit_position() -> Node:
|
|
return $cockpit
|
|
|
|
|
|
func get_hood_position() -> Node:
|
|
return $hood
|
|
|
|
|
|
func get_bumper_position() -> Node:
|
|
return $bumper
|
|
|
|
|
|
func get_static_follow_position() -> Node:
|
|
return $static_follow
|
|
|
|
|
|
func _integrate_forces(state: PhysicsDirectBodyState) -> void:
|
|
if reset_transform != Transform.IDENTITY:
|
|
state.linear_velocity = Vector3.ZERO
|
|
state.angular_velocity = Vector3.ZERO
|
|
state.set_transform(reset_transform)
|
|
reset_transform = Transform.IDENTITY
|
|
|
|
|
|
func _get_gear_ratio():
|
|
if gear == 0:
|
|
return 0
|
|
elif gear == -1:
|
|
return reverse_ratio
|
|
else:
|
|
return gear_ratios[gear - 1]
|
|
|
|
|
|
func _handle_gear_switch(delta: float):
|
|
if gear_timer > 0:
|
|
gear_timer = max(0, gear_timer - delta)
|
|
if clutch_position > 0.8 or GlobalSettings.auto_clutch or GlobalSettings.automatic_transmission:
|
|
match inputs.gear_request:
|
|
GearRequest.UP:
|
|
_gear_up()
|
|
GearRequest.DOWN:
|
|
_gear_down()
|
|
|
|
|
|
func _gear_up():
|
|
if gear + 1 <= gear_ratios.size():
|
|
gear += 1
|
|
gear_timer = gear_switch_time * (2 - clutch_position)
|
|
emit_signal("gear_updated", gear)
|
|
|
|
|
|
func _gear_down():
|
|
if gear - 1 >= -1:
|
|
gear -= 1
|
|
gear_timer = gear_switch_time * (2 - clutch_position)
|
|
emit_signal("gear_updated", gear)
|
|
|
|
|
|
func _has_traction():
|
|
for wheel in traction_wheels:
|
|
if wheel.is_in_contact():
|
|
return true
|
|
return false
|
|
|
|
|
|
func _update_wheels_smoke():
|
|
for wheelnsmoke in [
|
|
[frwheel, frsmoke], [flwheel, flsmoke], [rrwheel, rrsmoke], [rlwheel, rlsmoke]
|
|
]:
|
|
wheelnsmoke[1].update(wheelnsmoke[0].get_skidinfo())
|
|
|
|
|
|
func _lerp_rpm(from, to, delta, factor):
|
|
var new_val = lerp(from, to, factor)
|
|
if abs(from - new_val) > max_rpm_loss_ps * delta:
|
|
var new_factor = inverse_lerp(
|
|
from, to, from - sign(from - new_val) * max_rpm_loss_ps * delta
|
|
)
|
|
new_val = lerp(from, to, new_factor)
|
|
return new_val
|
|
|
|
|
|
func _physics_process(delta: float):
|
|
_update_wheels_smoke()
|
|
clutch_position = inputs.clutch
|
|
_handle_gear_switch(delta)
|
|
var throttle = inputs.throttle
|
|
var brake_input = inputs.brake
|
|
|
|
var wheel_rpm = traction_wheels[0].get_rpm()
|
|
var speed = wheel_rpm * 2.0 * PI * rrwheel.wheel_radius / 60.0 * 3600.0 / 1000.0
|
|
|
|
if GlobalSettings.automatic_transmission and speed < 1 and gear == 1 and brake_input > 0.1:
|
|
_gear_down()
|
|
_gear_down()
|
|
|
|
if GlobalSettings.automatic_transmission and speed > -1 and gear == -1 and throttle > 0.1:
|
|
_gear_up()
|
|
_gear_up()
|
|
|
|
if GlobalSettings.automatic_transmission and gear == -1:
|
|
var swap = throttle
|
|
throttle = brake_input
|
|
brake_input = swap
|
|
|
|
if GlobalSettings.auto_clutch or GlobalSettings.automatic_transmission:
|
|
clutch_position = 1 - min(rpm, auto_clutch_rpm_limit) / auto_clutch_rpm_limit
|
|
if throttle == 0.0 and linear_velocity.length() < 1:
|
|
clutch_position = 1
|
|
|
|
apply_central_impulse(linear_velocity * -1 * drag_factor)
|
|
apply_central_impulse(
|
|
linear_velocity.length() * -1 * global_transform.basis.y * downforce_factor
|
|
)
|
|
|
|
if gear_timer > 0:
|
|
clutch_position = 1
|
|
throttle = 0
|
|
|
|
var final_rpm = abs(wheel_rpm) * final_drive
|
|
var transmission_rpm = final_rpm * abs(_get_gear_ratio())
|
|
|
|
if gear != 0:
|
|
rpm = lerp(rpm, transmission_rpm, delta * 10 * (1 - clutch_position))
|
|
rpm = _lerp_rpm(rpm, min_rpm, delta, delta * clutch_position)
|
|
else:
|
|
rpm = _lerp_rpm(rpm, min_rpm, delta, delta)
|
|
if _has_traction():
|
|
rpm += throttle * delta * (max(clutch_position, 1 if gear == 0 else 0)) * throttle_power
|
|
else:
|
|
rpm += throttle * delta * throttle_power
|
|
rpm = clamp(rpm, 0, max_rpm)
|
|
var rpm_factor = clamp(rpm / max_rpm, 0.0, 1.0)
|
|
var power_factor = power_curve.interpolate_baked(rpm_factor)
|
|
|
|
_generate_engine_sound(rpm_factor)
|
|
_generate_wind_sound(speed)
|
|
|
|
# Transfer to transmission
|
|
var transmission_input = power_factor * (1 - clutch_position) * _get_gear_ratio()
|
|
|
|
var final_input = transmission_input * final_drive
|
|
|
|
emit_signal("throttle_updated", throttle)
|
|
emit_signal("brake_updated", brake_input)
|
|
emit_signal("clutch_updated", clutch_position)
|
|
brake = brake_input * max_brake_force
|
|
engine_force = throttle * final_input * max_engine_force
|
|
|
|
var handbrake = inputs.handbrake
|
|
rrwheel.brake = handbrake * max_brake_force
|
|
rlwheel.brake = handbrake * max_brake_force
|
|
|
|
if GlobalSettings.automatic_transmission and rpm_factor > automatic_gear_up_threshold:
|
|
_gear_up()
|
|
elif GlobalSettings.automatic_transmission and rpm_factor < automatic_gear_down_threshold:
|
|
if gear > 1:
|
|
_gear_down()
|
|
|
|
emit_signal("speed_updated", speed, speed / expected_max_speed)
|
|
emit_signal("rpm_updated", rpm, rpm_factor)
|
|
|
|
var steering_input = inputs.steering * max_steer_input_rad
|
|
|
|
steering = clamp(steering_input, -max_steer_input_rad, max_steer_input_rad)
|
|
emit_signal("steering_updated", steering, steering / max_steer_input_rad)
|
|
|
|
emit_signal("position_updated", get_network_master(), global_transform)
|
|
|
|
if MultiplayerController.is_online():
|
|
if get_network_master() == get_tree().get_network_unique_id():
|
|
_synchronize()
|
|
|
|
|
|
func _generate_engine_sound(rpm_factor):
|
|
engine_sound_player.pitch_scale = base_engine_pitch + 2 * rpm_factor
|
|
engine_sound_player.unit_db = 1 + 2 * rpm_factor
|
|
|
|
|
|
func _generate_wind_sound(speed):
|
|
wind_sound_player.pitch_scale = 1 + speed / 150
|
|
wind_sound_player.unit_db = pow(speed, 2) / 1500 * (0.5 + drag_factor) - 20
|
|
|
|
|
|
func _synchronize():
|
|
rpc("sync_position", transform)
|
|
rpc("sync_inputs", inputs.to_array())
|
|
|
|
|
|
remote func sync_position(position: Transform):
|
|
reset_transform = position
|
|
emit_signal("position_updated", get_network_master(), global_transform)
|
|
|
|
|
|
remote func sync_inputs(remote_inputs):
|
|
inputs.from_array(remote_inputs)
|