player/player.gd

   1 class_name Player
   2 extends CharacterBody3D
   3
   4 # signals
   5 signal camera_lockon
   6
   7
   8 # player settings
   9 @export_group("Movement")
  10 @export var walk_speed := 5.0
  11 @export var jog_speed := 10.0
  12 @export var air_speed := 3.0
  13 @export var acceleration := 30.0
  14 @export var jump_speed := 6.0
  15 @export var rotation_speed := 10.0
  16 @export var fall_speed := 1.2
  17 @export var idle_timeout := 5.0
  18 @export var hard_landing_limit := 10.0
  19
  20
  21 @export_group("Camera")
  22 @export_range(1.0, 10.0) var camera_distance := 2.0
  23 @export_range(0.0, 100.0) var camera_lockon_radius := 40.0
  24 @export_enum("locked", "unlocked") var camera_mode: String
  25 @export_range(0.0, 50.0) var lockon_sensitivity := 0.2
  26 @export_range(0.0, 1.0) var mouse_sensitivity := 0.15
  27 @export_range(0.0, 10.0) var joystick_sensitivity_x := 4.0
  28 @export_range(0.0, 10.0) var joystick_sensitivity_y := 2.0
  29
  30
  31 @export_group("Expressions")
  32 @export_range(1.0, 100.0) var head_rotation_speed := 5.0
  33
  34
  35 @onready var _camera_pivot: Node3D = $cameraPivot
  36 @onready var _camera_spring: SpringArm3D = $cameraPivot/SpringArm3D
  37 @onready var _camera: Camera3D = $cameraPivot/SpringArm3D/Camera3D
  38 @onready var _skin: WilliamSkin = %WilliamSkin
  39 @onready var _debug: CanvasLayer = %DebugOverlay
  40
  41
  42 # class variables
  43 var _player_speed := walk_speed
  44 var _camera_input_direction := Vector2.ZERO
  45 var _last_movement_direction := -rotation
  46 var _idle_time := 0.0
  47 var _camera_lockon_node: Node3D = null
  48 var _lockon_direction: Vector3 = Vector3.ZERO
  49 var _lockon_indicator_scene = load("res://ux/lockon_indicator.tscn")
  50 var _lockon_instance: Node3D = _lockon_indicator_scene.instantiate()
  51
  52 var _head_track_arr: Array[Node3D] = []
  53
  54 enum {LOCKON_LEFT, LOCKON_CENTER, LOCKON_RIGHT}
  55 var _lockon_shift := LOCKON_CENTER
  56
  57 enum {CAMERA_MOUSE_INPUT, CAMERA_JOYSTICK_INPUT}
  58 var _camera_input_method := CAMERA_MOUSE_INPUT
  59
  60 enum _states {FREE, POSING, TALKING}
  61 var _player_state := _states.FREE
  62
  63
  64 # inherited functions
  65 func _ready() -> void:
  66         _camera_spring.spring_length = camera_distance
  67
  68         # debug
  69         _debug.draw.add_vector(self, "velocity", 1, 3, Color(0,1,0,1))
  70         _debug.draw.add_vector(self, "_lockon_direction", 1, 2, Color(1,0,0,1))
  71         _debug.draw.add_vector(_camera_pivot, "rotation", 1, 3, Color(1,0,1,1))
  72         _debug.draw.add_vector(self, "_last_movement_direction", 1, 3, Color(1,0,0,1))
  73
  74         _debug.stats.add_property(self, "velocity", "")
  75         _debug.stats.add_property(self, "_idle_time", "round")
  76         _debug.stats.add_property(self, "_lockon_shift", "round")
  77         _debug.stats.add_property(self, "_head_track_arr", "")
  78
  79
  80 func _input(event: InputEvent) -> void:
  81         if event.is_action_pressed("camera-lockon"):
  82                 camera_lockon.emit()
  83         elif event.is_action_pressed("player-run"):
  84                 _player_speed = jog_speed
  85         elif event.is_action_released("player-run"):
  86                 _player_speed = walk_speed
  87         elif event.is_action_pressed("player-pose"):
  88                 _player_state = _states.POSING
  89         elif event.is_action_released("player-pose"):
  90                 _player_state = _states.FREE
  91         elif event.is_action_pressed("player-action"):
  92                 # TODO: contextual action
  93                 if _player_state == _states.FREE:
  94                         _player_state = _states.TALKING
  95                         velocity = Vector3.ZERO
  96                 elif _player_state == _states.TALKING:
  97                         _player_state = _states.FREE
  98
  99
 100 func _unhandled_input(event: InputEvent) -> void:
 101         # If user clicks on the window, capture the mouse and direct the camera with it
 102         if Input.get_mouse_mode() != Input.MOUSE_MODE_CAPTURED:
 103                 return
 104
 105                 #_camera_input_direction *= mouse_sensitivity
 106         if event is InputEventMouseMotion:
 107                 _camera_input_method = CAMERA_MOUSE_INPUT
 108                 _camera_input_direction = event.screen_relative * mouse_sensitivity
 109         elif event is InputEventJoypadMotion:
 110                 _camera_input_method = CAMERA_JOYSTICK_INPUT
 111                 _camera_input_direction = Input.get_vector("camera-left", "camera-right", "camera-up", "camera-down")
 112                 _camera_input_direction *= Vector2(joystick_sensitivity_x, -joystick_sensitivity_y)
 113
 114         if _camera_input_direction == Vector2.ZERO:
 115                 _lockon_shift = LOCKON_CENTER
 116
 117
 118 # class functions
 119 func _physics_process(delta: float) -> void:
 120         _process_player(delta)
 121         _process_camera(delta)
 122
 123
 124 func is_camera_locked() -> bool:
 125         return camera_mode == "locked"
 126
 127
 128 func set_camera_lockon(arr: Array[Node]) -> void:
 129         if _camera_lockon_node:
 130                 _camera_lockon_node.remove_child(_lockon_instance)
 131
 132         if not is_camera_locked() or _lockon_shift != LOCKON_CENTER:
 133                 # pick closest lockon point to center of camera view
 134                 # must be within lockon radius
 135                 var shortest_target_angle = _camera.fov / 360 * 2 * PI
 136                 for n: Node3D in arr:
 137                         if _camera_lockon_node == n:
 138                                 continue
 139
 140                         var target_dir := _camera_pivot.global_position - n.global_position
 141                         if target_dir.length() < camera_lockon_radius:
 142                                 var target_angle = shortest_target_angle
 143                                 if _lockon_shift == LOCKON_CENTER:
 144                                         var camera_dir = _camera.global_position - _camera_pivot.global_position
 145                                         target_angle = target_dir.angle_to(camera_dir)
 146                                 else:
 147                                         # check to make sure if lockon switch is a node to the left if player pressed left,
 148                                         # else lockon switch to something to the right
 149                                         target_angle = target_dir.signed_angle_to(_lockon_direction, Vector3.UP)
 150                                         if _lockon_shift == LOCKON_RIGHT and target_angle <= 0:
 151                                                 continue
 152                                         if _lockon_shift == LOCKON_LEFT and target_angle >= 0:
 153                                                 continue
 154
 155                                         target_angle = abs(target_angle)
 156                                 if target_angle < shortest_target_angle:
 157                                         shortest_target_angle = target_angle
 158                                         _camera_lockon_node = n
 159
 160                 if _camera_lockon_node:
 161                         _camera_lockon_node.add_child(_lockon_instance)
 162                         camera_mode = "locked"
 163         else:
 164                 camera_mode = "unlocked"
 165                 _camera_lockon_node = null
 166                 _lockon_direction = Vector3.ZERO
 167
 168                 # TODO: move all skin stuff to its own reset function
 169                 _skin.move_forward()
 170                 _skin.set_hips_direction(0)
 171
 172                 # always reset shift to center!
 173                 _lockon_shift = LOCKON_CENTER
 174
 175
 176 func _process_camera(delta: float) -> void:
 177         if not is_camera_locked():
 178                 # vertical camera rotation
 179                 _camera_pivot.rotation.x += _camera_input_direction.y * delta
 180                 _camera_pivot.rotation.x = clamp(_camera_pivot.rotation.x, -PI / 6, PI / 3)
 181
 182                 # horizontal camera rotation
 183                 _camera_pivot.rotation.y -= _camera_input_direction.x * delta
 184
 185                 # reset mouse movement vector if mouse input
 186                 if _camera_input_method == CAMERA_MOUSE_INPUT:
 187                         _camera_input_direction = Vector2.ZERO
 188         else:
 189                 # camera should lerp to a set height
 190                 _camera_pivot.rotation.x = lerp(_camera_pivot.rotation.x, 0.0, delta)
 191                 _camera_pivot.rotation.z = lerp(_camera_pivot.rotation.z, 0.0, delta)
 192
 193                 # keep camera pivot pointed towards locked object
 194                 if _camera_lockon_node:
 195                         # calculate target vector between node position and player
 196                         var lock_vector := _camera_pivot.global_position - _camera_lockon_node.global_position
 197                         _lockon_direction = lock_vector
 198                         lock_vector.y = 0
 199                         var target_angle = Vector3.BACK.signed_angle_to(lock_vector, Vector3.UP)
 200                         _camera_pivot.global_rotation.y = lerp_angle(_camera_pivot.global_rotation.y, target_angle, rotation_speed * delta)
 201
 202                         # if player indicates right or left, emit lockon signal again to collect array and split it
 203                         if _camera_input_direction.x < -lockon_sensitivity and _lockon_shift != LOCKON_LEFT:
 204                                 _lockon_shift = LOCKON_LEFT
 205                                 camera_lockon.emit()
 206                         elif _camera_input_direction.x > lockon_sensitivity and _lockon_shift != LOCKON_RIGHT:
 207                                 _lockon_shift = LOCKON_RIGHT
 208                                 camera_lockon.emit()
 209
 210
 211 # Get the XZ input direction based on player's input relative to the camera
 212 func _get_player_move_direction() -> Vector3:
 213         var input_dir := Input.get_vector("player-left", "player-right", "player-forward", "player-backward")
 214         var forward := _camera.global_basis.z
 215         var right := _camera.global_basis.x
 216         var move_direction := (forward * input_dir.y + right * input_dir.x).normalized()
 217         move_direction.y = 0
 218         return move_direction
 219
 220
 221 func _process_player_floor(move_direction: Vector3, delta: float) -> void:
 222         # if player is landing, then just return
 223         if _skin.current_state() == "landing":
 224                 return
 225         elif _skin.current_state() == "fall":
 226                 if velocity.length() > hard_landing_limit:
 227                         velocity = Vector3.ZERO
 228                         _skin.landing()
 229                         return
 230                 else:
 231                         _skin.move_forward()
 232
 233         # if we're not stuck, then it's okay to set the velocity
 234         velocity = velocity.move_toward(move_direction * _player_speed, acceleration * delta)
 235
 236         # if player jumps, then we're done
 237         if Input.is_action_just_pressed("player-jump"):
 238                 velocity.y = jump_speed
 239                 _idle_time = 0.0
 240                 _skin.jump()
 241                 return
 242
 243         # also, if we're moving, we're not idle
 244         # last movement direction required for skin orientation
 245         if move_direction.length() < 0.2:
 246                 if velocity == Vector3.ZERO:
 247                         _idle_time += delta
 248                 if _idle_time > idle_timeout:
 249                         _skin.idle()
 250                         return
 251         else:
 252                 _last_movement_direction = move_direction
 253                 _idle_time = 0.0
 254
 255         # now handle skin rotation and animation
 256         var movement_speed := Vector3(velocity.x, 0, velocity.z).length()
 257         _skin.movement_speed(movement_speed)
 258
 259         # if camera is unlocked, rotate whole skin to face movement direction
 260         # else, rotate to face camera pivot global Y direction
 261         var skin_target_angle := Vector3.BACK.signed_angle_to(_last_movement_direction, Vector3.UP)
 262
 263         # lean into momentum just a little bit
 264         _skin.rotation.z = lerp_angle(
 265                 _skin.rotation.z,
 266                 clamp(_last_movement_direction.signed_angle_to(velocity, Vector3.UP) * movement_speed * 0.08, -PI/4, PI/ 4),
 267                 rotation_speed * delta * 0.25
 268                 )
 269
 270         if not is_camera_locked():
 271                 _skin.move_forward()
 272
 273                 _skin.global_rotation.y = lerp_angle(
 274                         _skin.global_rotation.y,
 275                         skin_target_angle,
 276                         rotation_speed * delta
 277                         )
 278         else: # camera is locked
 279                 var movement_angle := _skin.global_rotation.y - skin_target_angle
 280                 if abs(movement_angle) < (PI / 2):
 281                         _skin.move_forward()
 282                 else:
 283                         _skin.move_backward()
 284
 285                 _skin.global_rotation.y = lerp_angle(
 286                         _skin.global_rotation.y,
 287                         _camera_pivot.global_rotation.y - PI,
 288                         rotation_speed * delta)
 289
 290                 # hips rotate towards the direction of movement
 291                 # else hips rotate toward skin global Y direction
 292                 # if moving backwards, then target_angle is inverted
 293                 if movement_speed > 0.1:
 294                         var target_hips_dir := lerp_angle(
 295                                         _skin.global_rotation.y + _skin.get_hips_direction(),
 296                                         skin_target_angle if abs(movement_angle) < (PI / 2) else (skin_target_angle - PI),
 297                                         rotation_speed * delta
 298                                         ) - _skin.global_rotation.y
 299                         _skin.set_hips_direction(target_hips_dir)
 300                 else:
 301                         _skin.set_hips_direction(lerp_angle(_skin.get_hips_direction(), 0, rotation_speed * delta))
 302
 303
 304 func _process_player_falling(move_direction: Vector3, delta: float) -> void:
 305         velocity += get_gravity() * fall_speed * delta
 306         velocity += move_direction * air_speed * delta
 307         _skin.fall()
 308
 309
 310 func _process_player(delta: float) -> void:
 311         var move_direction := _get_player_move_direction()
 312
 313         if is_on_floor():
 314                 if _player_state == _states.POSING:
 315                         _skin.pose()
 316                 elif _player_state == _states.TALKING:
 317                         _skin.talk()
 318                 else:
 319                         _process_player_floor(move_direction, delta)
 320         else:
 321                 _process_player_falling(move_direction, delta)
 322
 323         move_and_slide()
 324
 325
 326 func _on_head_turn_area_entered(area: Area3D) -> void:
 327         for node in area.get_parent().get_children().filter(func(c): return c.is_in_group("player-headTrack")):
 328                 var i = _head_track_arr.find(node)
 329                 if i < 0:
 330                         _head_track_arr.append(node)
 331
 332
 333 func _on_head_turn_area_exited(area: Area3D) -> void:
 334         for node in area.get_parent().get_children().filter(func(c): return c.is_in_group("player-headTrack")):
 335                 var i = _head_track_arr.find(node)
 336                 if i >= 0:
 337                         _head_track_arr.remove_at(i)