SchimmelSpreu83
a4100e3026
- Made the character inherit from StairsCharacter3D (Plugin) - Made the players head smoothly adjust when stepping. - Reintroduced the previously broken headbobbing. - Adjusted collisions.
228 lines
8.2 KiB
GDScript
228 lines
8.2 KiB
GDScript
class_name PlayerHead
|
|
extends Node3D
|
|
|
|
const ACTION_CAMERA_UP: StringName = &"camera_up"
|
|
const ACTION_CAMERA_DOWN: StringName = &"camera_down"
|
|
const ACTION_CAMERA_LEFT: StringName = &"camera_left"
|
|
const ACTION_CAMERA_RIGHT: StringName = &"camera_right"
|
|
|
|
const MOUSE_SENSITIVITY_PATH: StringName = &"game/input/sensitivity"
|
|
const CONTROLLER_SENSITIVITY_PATH: StringName = &"game/input/controller_sensitivity"
|
|
const INVERT_X_PATH: StringName = &"game/input/camera_invert_x"
|
|
const INVERT_Y_PATH: StringName = &"game/input/camera_invert_y"
|
|
const CONTROLLER_INVERT_X_PATH: StringName = &"game/input/camera_controller_invert_x"
|
|
const CONTROLLER_INVERT_Y_PATH: StringName = &"game/input/camera_controller_invert_y"
|
|
|
|
@export var camera: ShakingCamera
|
|
@export_range(-360, 360, 0.5, "suffix:°") var look_min_vertical_angle: float = -85.0
|
|
@export_range(-360, 360, 0.5, "suffix:°") var look_max_vertical_angle: float = 85.0
|
|
|
|
@export_group("Acceleration")
|
|
@export var mouse_acceleration: bool = false
|
|
@export_exp_easing("attenuation") var mouse_friction: float = 15.0
|
|
@export var controller_acceleration: bool = true
|
|
@export_exp_easing("attenuation") var controller_friction: float = 15.0
|
|
|
|
@export_group("Input")
|
|
@export_subgroup("Sensitivity")
|
|
@export_range(0.0, 100.0, 0.001, "or_greater") var mouse_sensitivity: float = 1.0
|
|
@export_range(0.0, 100.0, 0.001, "or_greater") var controller_sensitivity: float = 0.75
|
|
@export_subgroup("Invert")
|
|
@export var invert_x: bool = false
|
|
@export var invert_y: bool = false
|
|
@export var controller_invert_x: bool = false
|
|
@export var controller_invert_y: bool = false
|
|
|
|
@export_group("Headbobbing", "headbob_")
|
|
@export var headbob_range: float = 0.25
|
|
@export var headbob_frequency: float = 0.5
|
|
@export var headbob_multiplier: float = 1.0
|
|
@export var headbob_character: Character3D
|
|
@export var headbob_target: Node3D
|
|
|
|
@export_group("Step Smoothing", "step_")
|
|
@export var step_smoothing_target: Node3D
|
|
@export var step_speed: float = 8.0
|
|
|
|
var rotational_direction: Vector2
|
|
var rotational_velocity: Vector2
|
|
var input_event: InputEvent
|
|
var using_controller: bool = false
|
|
# Headbobbing
|
|
var headbob_time: float = 0.0
|
|
var headbob_enabled: bool = true
|
|
# Stair smooting
|
|
var stair_camera_offset_height: float = 0.0
|
|
var _previous_position: Vector3
|
|
var _stair_camera_target_height: float = 0.0
|
|
var _stair_camera_step_smoothing: bool = false
|
|
|
|
|
|
func _ready() -> void:
|
|
# Update values based on project settings.
|
|
var _update_settings: Callable = func() -> void:
|
|
mouse_sensitivity = ProjectSettings.get_setting(MOUSE_SENSITIVITY_PATH, 1.6)
|
|
controller_sensitivity = ProjectSettings.get_setting(CONTROLLER_SENSITIVITY_PATH, 5.0)
|
|
invert_x = ProjectSettings.get_setting(INVERT_X_PATH, false)
|
|
invert_y = ProjectSettings.get_setting(INVERT_Y_PATH, false)
|
|
controller_invert_x = ProjectSettings.get_setting(CONTROLLER_INVERT_X_PATH, false)
|
|
controller_invert_y = ProjectSettings.get_setting(CONTROLLER_INVERT_Y_PATH, false)
|
|
headbob_enabled = SettingsManager.get_setting(&"misc", &"headbobbing")
|
|
|
|
SettingsManager.settings_changed.connect(_update_settings)
|
|
ProjectSettings.settings_changed.connect(_update_settings)
|
|
_update_settings.call()
|
|
|
|
_setup_step_smoothing()
|
|
|
|
|
|
func _process(delta: float) -> void:
|
|
if not GameGlobals.in_cutscene:
|
|
_process_input(delta)
|
|
_perform_head_bob(delta)
|
|
|
|
_process_step_smoothing(delta)
|
|
|
|
|
|
func _unhandled_input(event: InputEvent) -> void:
|
|
if event is InputEventMouseMotion or event is InputEventJoypadMotion:
|
|
input_event = event
|
|
|
|
|
|
#region Mouse/Controller rotation
|
|
func apply_rotation(rot: Vector2) -> void:
|
|
rotate_y(-rot.x)
|
|
rotation.x = rotation.x - rot.y
|
|
rotation_degrees.x = clampf(rotation_degrees.x, look_min_vertical_angle, look_max_vertical_angle)
|
|
|
|
|
|
func get_sensitivity() -> float:
|
|
var sensitivity: float = mouse_sensitivity if not using_controller else controller_sensitivity
|
|
var frame_rate: float = Engine.get_frames_per_second() / 60.0
|
|
sensitivity *= frame_rate
|
|
#print(frame_rate)
|
|
|
|
return sensitivity
|
|
|
|
|
|
func _process_input(delta: float) -> void:
|
|
if Input.mouse_mode != Input.MOUSE_MODE_CAPTURED or not InputManager.window_focused():
|
|
return
|
|
|
|
if input_event is InputEventMouseMotion:
|
|
_process_mouse(input_event, delta)
|
|
using_controller = false
|
|
rotational_direction = Vector2.ZERO
|
|
input_event = null
|
|
|
|
elif input_event is InputEventJoypadMotion:
|
|
_process_controller(delta)
|
|
using_controller = true
|
|
rotational_direction = Vector2.ZERO
|
|
|
|
# Decelerating when nothing is being pressed.
|
|
elif not rotational_velocity.is_zero_approx() and rotational_direction.is_zero_approx():
|
|
input_event = null
|
|
|
|
if not using_controller and mouse_acceleration:
|
|
rotational_velocity = _lerp_rotational_velocity(get_sensitivity() / 10, mouse_friction, delta)
|
|
elif using_controller and controller_acceleration:
|
|
rotational_velocity = _lerp_rotational_velocity(get_sensitivity(), controller_friction,delta)
|
|
apply_rotation(rotational_velocity)
|
|
else:
|
|
rotational_velocity = Vector2.ZERO
|
|
|
|
apply_rotation(rotational_velocity)
|
|
|
|
|
|
func _process_mouse(event: InputEventMouseMotion, delta: float) -> void:
|
|
# TODO: Somehow fix the fps-dependent mouse :/
|
|
# https://yosoyfreeman.github.io/godot/achieving-better-mouse-input-in-godot-4-the-perfect-camera-controller-full-project/
|
|
var viewport_transform: Transform2D = get_tree().get_root().get_final_transform()
|
|
rotational_direction = event.xformed_by(viewport_transform).get_relative()
|
|
|
|
if invert_x:
|
|
rotational_direction.x = -rotational_direction.x
|
|
|
|
if invert_y:
|
|
rotational_direction.y = -rotational_direction.y
|
|
|
|
if mouse_acceleration:
|
|
rotational_velocity = _lerp_rotational_velocity(deg_to_rad(get_sensitivity() / 10.0), mouse_friction, delta)
|
|
apply_rotation(rotational_velocity)
|
|
else:
|
|
apply_rotation(rotational_direction * deg_to_rad(get_sensitivity() / 10.0))
|
|
|
|
|
|
func _process_controller(delta: float) -> void:
|
|
rotational_direction = Input.get_vector(ACTION_CAMERA_LEFT, ACTION_CAMERA_RIGHT, ACTION_CAMERA_UP, ACTION_CAMERA_DOWN)
|
|
|
|
if controller_invert_x:
|
|
rotational_direction.x = -rotational_direction.x
|
|
|
|
if controller_invert_y:
|
|
rotational_direction.y = -rotational_direction.y
|
|
|
|
if controller_acceleration:
|
|
rotational_velocity = _lerp_rotational_velocity(deg_to_rad(get_sensitivity()), controller_friction, delta)
|
|
apply_rotation(rotational_velocity)
|
|
else:
|
|
apply_rotation(rotational_direction * deg_to_rad(get_sensitivity()))
|
|
|
|
|
|
func _lerp_rotational_velocity(sensitivity: float, friction: float, delta: float) -> Vector2:
|
|
return rotational_velocity.lerp(rotational_direction * sensitivity, friction * delta)
|
|
#endregion
|
|
|
|
|
|
#region Headbobbing
|
|
func _perform_head_bob(delta: float) -> void:
|
|
if not headbob_enabled:
|
|
headbob_target.position = Vector3.ZERO
|
|
headbob_target.rotation.z = 0.0
|
|
headbob_time = 0.0
|
|
return
|
|
|
|
var headbob_speed: float = maxf((headbob_character.velocity * Utils.VEC3_HOR).length(), 1.0)
|
|
SPrint.print_msgf(str("Headbob-Speed: ", headbob_speed), true)
|
|
SPrint.print_msgf(str("Headbob-Clock: ", headbob_time), true)
|
|
|
|
headbob_time += delta * headbob_speed * headbob_multiplier
|
|
headbob_time = fposmod(headbob_time, TAU)
|
|
|
|
headbob_target.position.y = sin(headbob_time * headbob_frequency) * headbob_range
|
|
headbob_target.position.x = cos(headbob_time * headbob_frequency / 2) * headbob_range
|
|
headbob_target.rotation.z = deg_to_rad(lerp(headbob_target.position.x, headbob_target.position.y, 0.5)) * TAU
|
|
SPrint.print_msgf(str("Head Z-Rotation: ", headbob_target.rotation.z), true)
|
|
#endregion
|
|
|
|
|
|
#region Step Smoothing
|
|
func smooth_step(height_change: float) -> void:
|
|
_stair_camera_target_height -= height_change
|
|
_stair_camera_step_smoothing = true
|
|
|
|
|
|
func _setup_step_smoothing() -> void:
|
|
headbob_character.on_stair_step.connect(_on_stair_step)
|
|
stair_camera_offset_height = step_smoothing_target.position.y
|
|
|
|
|
|
func _on_stair_step() -> void:
|
|
smooth_step(global_position.y - _previous_position.y)
|
|
|
|
|
|
func _process_step_smoothing(delta: float) -> void:
|
|
if _stair_camera_step_smoothing and is_instance_valid(step_smoothing_target):
|
|
_stair_camera_target_height = lerp(_stair_camera_target_height, 0.0, step_speed * delta)
|
|
|
|
if absf(_stair_camera_target_height) < 0.0025:
|
|
_stair_camera_target_height = 0.0
|
|
_stair_camera_step_smoothing = false
|
|
|
|
var target_pos := Vector3.UP * (stair_camera_offset_height + _stair_camera_target_height)
|
|
step_smoothing_target.position = target_pos.rotated(Vector3.LEFT, rotation.x)
|
|
|
|
_previous_position = global_position
|
|
#endregion
|