Hermes
462d12bee5
- Fix tab character in _build_elevated_walkways() call (line 63) - Fix untyped 'pos' variable in grapple pillar loop (line 376) - Remove fog_sky_affinity (Godot 4.3+ only property) - Replace preload() with load() for runtime script loading - Replace 'is DoubleBarrelShotgun' type check with duck-typing - Fix 'is not OfflineMultiplayerPeer' syntax in grenade spawn - Replace absf() with abs() in state_machine, state_air, state_ground - Update test_level.tscn to remove stale UID reference All fixes verified: PARSE OK and scene runs without script errors on Godot 4.2.1 headless.
244 lines
9.6 KiB
GDScript
244 lines
9.6 KiB
GDScript
extends Node
|
|
class_name StateGround
|
|
|
|
var machine: MovementStateMachine
|
|
var params: MovementParams:
|
|
get: return machine.params
|
|
|
|
var _footstep_timer: float = 0.0
|
|
|
|
func enter(_data: Dictionary = {}) -> void:
|
|
machine.on_ground = true
|
|
machine.current_jump_count = 0
|
|
machine.can_wall_climb = true
|
|
# Clear wall tilt on landing
|
|
var rig = _get_camera_rig()
|
|
if rig:
|
|
rig.clear_wall_tilt()
|
|
|
|
# Ensure capsule is correct when entering ground state
|
|
_update_capsule_height()
|
|
|
|
|
|
func exit() -> void:
|
|
pass
|
|
|
|
|
|
func update(delta: float) -> void:
|
|
var player := machine.player
|
|
var vel: Vector3 = player.velocity
|
|
|
|
# ── Jump (coyote time + jump buffer) ──────────────────────────────────
|
|
if machine.input_jump_just_pressed and machine.coyote_timer > 0.0 and machine.jump_cooldown_timer <= 0.0:
|
|
player.velocity.y = params.jump_velocity
|
|
machine.current_jump_count = 1
|
|
machine.on_ground = false
|
|
machine.coyote_timer = 0.0
|
|
machine.register_chain_mechanic("jump")
|
|
machine.jump_cooldown_timer = params.jump_cooldown
|
|
if player.jump_player:
|
|
player.jump_player.play()
|
|
machine.switch_to("air")
|
|
return
|
|
|
|
# Jump buffer: player pressed jump just before landing
|
|
if machine.on_ground and machine.jump_buffer_time > 0.0 and machine.jump_cooldown_timer <= 0.0:
|
|
player.velocity.y = params.jump_velocity
|
|
machine.current_jump_count = 1
|
|
machine.on_ground = false
|
|
machine.jump_buffer_time = 0.0
|
|
machine.register_chain_mechanic("jump")
|
|
machine.jump_cooldown_timer = params.jump_cooldown
|
|
if player.jump_player:
|
|
player.jump_player.play()
|
|
machine.switch_to("air")
|
|
return
|
|
|
|
# ── Slide (crouch while moving fast enough) ───────────────────────────
|
|
if machine.input_crouch and machine.slide_cooldown_timer <= 0.0:
|
|
var hspeed := Vector3(player.velocity.x, 0.0, player.velocity.z).length()
|
|
if hspeed > params.slide_min_speed:
|
|
machine.switch_to("slide")
|
|
return
|
|
|
|
# ── Determine target speed ────────────────────────────────────────────
|
|
var wish_dir: Vector3 = machine.wish_dir_world
|
|
var speed := params.walk_speed
|
|
if machine.input_crouch:
|
|
speed = params.crouch_speed
|
|
var effective_speed := machine.get_effective_speed(speed)
|
|
|
|
# ── Horizontal movement (exponential interpolation for smoothness) ───
|
|
var hvel := Vector3(vel.x, 0.0, vel.z)
|
|
var target_vel := wish_dir * effective_speed
|
|
|
|
if wish_dir.length_squared() > 0.0:
|
|
hvel = hvel.lerp(target_vel, 1.0 - exp(-params.ground_acceleration * delta))
|
|
else:
|
|
hvel = hvel.lerp(Vector3.ZERO, 1.0 - exp(-params.ground_deceleration * delta))
|
|
|
|
vel.x = hvel.x
|
|
vel.z = hvel.z
|
|
|
|
# ── Gravity (correct direction: downward) ─────────────────────────────
|
|
if not player.is_on_floor():
|
|
vel.y -= params.gravity * delta
|
|
else:
|
|
# Snap to floor: small downward velocity keeps is_on_floor() stable
|
|
# ONLY if we aren't being launched upward by an impulse!
|
|
if vel.y <= 0.0:
|
|
vel.y = -0.5
|
|
|
|
player.velocity = vel
|
|
player.move_and_slide()
|
|
|
|
# ── Stair Stepping ────────────────────────────────────────────────────
|
|
if wish_dir.length_squared() > 0.01 and not machine.input_crouch:
|
|
for i in range(player.get_slide_collision_count()):
|
|
var col = player.get_slide_collision(i)
|
|
if abs(col.get_normal().y) < 0.3: # Hit a wall
|
|
var max_step_height = 0.95
|
|
var space_state = player.get_world_3d().direct_space_state
|
|
var feet_y = player.global_position.y - (machine.original_capsule_height / 2.0)
|
|
|
|
# Raycast down from above the step
|
|
var fwd = wish_dir.normalized()
|
|
var ray_start = player.global_position + fwd * 0.65
|
|
ray_start.y = feet_y + max_step_height + 0.1
|
|
var ray_end = ray_start - Vector3.UP * (max_step_height + 0.2)
|
|
|
|
var ray = PhysicsRayQueryParameters3D.create(ray_start, ray_end)
|
|
ray.exclude = [player.get_rid()]
|
|
var hit = space_state.intersect_ray(ray)
|
|
|
|
if not hit.is_empty() and hit.normal.y > 0.7:
|
|
var step_height = hit.position.y - feet_y
|
|
if step_height > 0.01 and step_height <= max_step_height:
|
|
# Check if we have headroom to move up
|
|
var head_ray_start = player.global_position
|
|
head_ray_start.y += (machine.original_capsule_height / 2.0)
|
|
var head_ray_end = head_ray_start + Vector3.UP * (step_height + 0.1)
|
|
var head_ray = PhysicsRayQueryParameters3D.create(head_ray_start, head_ray_end)
|
|
head_ray.exclude = [player.get_rid()]
|
|
|
|
if space_state.intersect_ray(head_ray).is_empty():
|
|
# Check if there is enough space to move forward after stepping up
|
|
var test_transform = player.global_transform
|
|
test_transform.origin.y += step_height + 0.05
|
|
if not player.test_move(test_transform, fwd * 0.15):
|
|
# We can safely step up
|
|
player.global_position.y += step_height + 0.01
|
|
if player.head_pivot and player.head_pivot.has_method("add_step_offset"):
|
|
player.head_pivot.add_step_offset(-(step_height + 0.01))
|
|
# Push slightly forward to get onto the step
|
|
player.global_position += fwd * 0.1
|
|
# Restore horizontal velocity that was lost from hitting the wall
|
|
player.velocity.x = hvel.x
|
|
player.velocity.z = hvel.z
|
|
break
|
|
|
|
_update_capsule_height()
|
|
|
|
var current_hspeed = Vector2(player.velocity.x, player.velocity.z).length()
|
|
if current_hspeed > 1.0:
|
|
_footstep_timer -= delta
|
|
if _footstep_timer <= 0.0:
|
|
if player.footstep_player:
|
|
player.footstep_player.play()
|
|
_footstep_timer = max(0.2, 3.0 / current_hspeed)
|
|
else:
|
|
_footstep_timer = 0.0
|
|
|
|
# ── Update ground status ──────────────────────────────────────────────
|
|
if player.is_on_floor():
|
|
machine.on_ground = true
|
|
machine.current_jump_count = 0
|
|
else:
|
|
machine.on_ground = false
|
|
|
|
# ── Launch or Falling off ledge → air state ───────────────────────────
|
|
if not machine.on_ground:
|
|
if player.velocity.y > 0.0 or machine.coyote_timer <= 0.0:
|
|
machine.switch_to("air")
|
|
return
|
|
|
|
# ── Wall interaction (Run, Climb, Vault) ──────────────────────────────
|
|
if machine.input_dir.length() > 0.1 and machine.input_dir.y <= 0.0 and machine.wall_cooldown_timer <= 0.0 and not machine.input_crouch:
|
|
var fwd_wall = machine.detect_wall_forward()
|
|
if fwd_wall.hit:
|
|
if fwd_wall.is_short:
|
|
# Instant Vault
|
|
var look_dir := -player.global_transform.basis.z
|
|
var h_look := Vector3(look_dir.x, 0.0, look_dir.z)
|
|
if h_look.length_squared() > 0.01:
|
|
h_look = h_look.normalized()
|
|
player.velocity = h_look * params.wall_climb_vault_forward
|
|
player.velocity.y = params.wall_climb_vault_up
|
|
if player.vault_player:
|
|
player.vault_player.play()
|
|
|
|
# Quick camera animation (tilt up and forward bob)
|
|
var camera = player.camera
|
|
if camera:
|
|
var tween = player.create_tween()
|
|
tween.tween_property(camera, "rotation_degrees:x", camera.rotation_degrees.x + 10.0, 0.15).set_trans(Tween.TRANS_SINE)
|
|
tween.parallel().tween_property(camera, "v_offset", -0.2, 0.15).set_trans(Tween.TRANS_SINE)
|
|
tween.chain().tween_property(camera, "rotation_degrees:x", camera.rotation_degrees.x, 0.2).set_trans(Tween.TRANS_SINE)
|
|
tween.parallel().tween_property(camera, "v_offset", 0.0, 0.2).set_trans(Tween.TRANS_SINE)
|
|
|
|
machine.wall_cooldown_timer = 0.3
|
|
machine.switch_to("air")
|
|
return
|
|
else:
|
|
# Check if moving directly into wall and looking generally towards it
|
|
var look_dir := -player.global_transform.basis.z
|
|
var looking_towards := look_dir.dot(-fwd_wall.normal) > 0.0
|
|
var moving_towards := wish_dir.dot(-fwd_wall.normal) > cos(deg_to_rad(params.wall_climb_max_angle))
|
|
|
|
if looking_towards and moving_towards and machine.can_wall_climb:
|
|
machine.wall_normal = fwd_wall.normal
|
|
machine.switch_to("wall_climb")
|
|
return
|
|
|
|
# Fallback to wall run
|
|
var wall_n := machine.detect_wall_horizontal()
|
|
if wall_n != Vector3.ZERO:
|
|
if not player.is_on_floor():
|
|
var w_look_dir := -player.global_transform.basis.z
|
|
var h_look := Vector3(w_look_dir.x, 0.0, w_look_dir.z).normalized()
|
|
|
|
# Require looking mostly along the wall (angle > 41 degrees from normal)
|
|
# and inputting mostly along the wall (angle > 31 degrees from normal, allows W+A/D diagonally into wall)
|
|
if abs(h_look.dot(wall_n)) < 0.75 and abs(wish_dir.dot(wall_n)) < 0.85:
|
|
machine.switch_to("wall_run")
|
|
return
|
|
|
|
# ── Dash ──────────────────────────────────────────────────────────────
|
|
if machine.input_dash:
|
|
var hspeed := Vector3(player.velocity.x, 0.0, player.velocity.z).length()
|
|
if hspeed > 0.1 or machine.input_dir.length() > 0.1:
|
|
machine.switch_to("dash")
|
|
return
|
|
|
|
|
|
func _get_camera_rig():
|
|
if machine.player and machine.player.has_node("HeadPivot"):
|
|
return machine.player.get_node("HeadPivot")
|
|
return null
|
|
|
|
|
|
func _update_capsule_height() -> void:
|
|
var shape = _get_capsule()
|
|
if shape:
|
|
if machine.input_crouch:
|
|
shape.height = machine.original_capsule_height * 0.5
|
|
else:
|
|
shape.height = machine.original_capsule_height
|
|
|
|
|
|
func _get_capsule() -> CapsuleShape3D:
|
|
for child in machine.player.get_children():
|
|
if child is CollisionShape3D and child.shape is CapsuleShape3D:
|
|
return child.shape as CapsuleShape3D
|
|
return null
|