## Command-driven player movement: walk, sprint, crouch, jump, gravity, slopes, ## step-up, sliding, fall damage, wading and swimming. Deterministic: it depends only on ## the entity, the command, the ground and the sea level. class_name Movement extends RefCounted const DT: float = 1.0 / Tuning.TICK_RATE_HZ ## Advances one player by one tick. `command` may be null, meaning no input this tick: ## the player keeps looking the same way and stops trying to move, but still falls. ## `sea_level` is the water surface; the default means no water at all. Breath, stamina ## and drowning are Water's job, after this. static func step(player: SimEntity, command: PlayerCommand, ground: SimGround, sea_level: float = -INF) -> void: var wish: Vector3 = Vector3.ZERO var wants_jump: bool = false player.crouching = false if command != null: player.yaw = command.yaw player.pitch = command.pitch player.crouching = command.is_pressed(PlayerCommand.BUTTON_CROUCH) wants_jump = command.is_pressed(PlayerCommand.BUTTON_JUMP) and not player.crouching wish = _wish_velocity(command, player.crouching) if player.drop_state == Drop.ABOARD: # Riders move with the barge; Simulation places them. return if player.drop_state != Drop.NONE: _fall_from_barge(player, command, ground, sea_level) return if player.swimming: if wants_jump and player.stamina_ticks > 0 and _at_surface(player, sea_level): # Kick up out of the water. Airborne from here; back in if it lands in deep water. player.swimming = false player.on_ground = false player.velocity.y = Tuning.JUMP_VELOCITY else: _swim(player, command, ground, sea_level) return # Wading: water over the feet slows walkers and stops sprinting. if player.on_ground and sea_level - player.position.y > Tuning.WADE_DEPTH: wish = wish.limit_length(Tuning.WADE_SPEED) var velocity: Vector3 = player.velocity if player.on_ground: velocity.x = wish.x velocity.z = wish.z velocity.y = 0.0 if wants_jump: velocity.y = Tuning.JUMP_VELOCITY player.on_ground = false else: velocity.x += (wish.x - velocity.x) * Tuning.AIR_CONTROL velocity.z += (wish.z - velocity.z) * Tuning.AIR_CONTROL velocity = _move_horizontally(player, velocity, ground) _move_vertically(player, velocity, ground, sea_level) # Walked, or the tide rose, into water deep enough to swim. if not player.swimming and player.on_ground and Water.is_deep(sea_level, player.position.y): _enter_water(player) ## Height of the player's body, which shrinks while crouching. static func body_height(player: SimEntity) -> float: return Tuning.CROUCH_HEIGHT if player.crouching else Tuning.PLAYER_HEIGHT static func _wish_velocity(command: PlayerCommand, crouching: bool) -> Vector3: var move: Vector2 = command.move_vector() if move.length() > 1.0: move = move.normalized() var angle: float = command.yaw_radians() var forward: Vector3 = Vector3(sin(angle), 0.0, cos(angle)) # Right is forward x up in Godot's right-handed, y-up frame. var right: Vector3 = Vector3(-cos(angle), 0.0, sin(angle)) var speed: float = Tuning.WALK_SPEED if crouching: speed = Tuning.CROUCH_SPEED elif command.is_pressed(PlayerCommand.BUTTON_SPRINT) and move.y > 0.0: speed = Tuning.SPRINT_SPEED return (right * move.x + forward * move.y) * speed ## Moves along x and z, sliding along whatever blocks the way. Returns the velocity with ## blocked components removed. static func _move_horizontally(player: SimEntity, velocity: Vector3, ground: SimGround) -> Vector3: var delta: Vector3 = Vector3(velocity.x, 0.0, velocity.z) * DT if delta.is_zero_approx(): return velocity var result: Vector3 = velocity if _can_move_to(player, player.position + delta, ground): player.position += delta elif _can_move_to(player, player.position + Vector3(delta.x, 0.0, 0.0), ground): player.position.x += delta.x result.z = 0.0 elif _can_move_to(player, player.position + Vector3(0.0, 0.0, delta.z), ground): player.position.z += delta.z result.x = 0.0 else: result.x = 0.0 result.z = 0.0 var size: float = Tuning.WORLD_SIZE_METRES player.position.x = clampf(player.position.x, 0.0, size) player.position.z = clampf(player.position.z, 0.0, size) return result static func _can_move_to(player: SimEntity, target: Vector3, ground: SimGround) -> bool: var supported: bool = player.on_ground or player.swimming var step: float = Tuning.STEP_HEIGHT if supported else 0.0 # On foot, the body is tested where it will stand: on whatever it steps up onto at # the target. Otherwise the next riser of a stair narrower than the body would block # a player who hasn't been lifted onto the current one yet. var body: Vector3 = target if supported: body.y = maxf(target.y, ground.support_height(target.x, target.z, target.y + step)) if ground.body_blocked(body, Tuning.PLAYER_RADIUS, body_height(player), step): return false # Moving uphill into terrain that's too steep is blocked, on foot or in the air, so # nobody can climb a cliff by pushing into it. Downhill is always allowed. var rise: float = ground.terrain_height(target.x, target.z) - player.position.y if rise > 0.0 and not ground.walkable_terrain(target.x, target.z): if not ground.support_is_solid(target.x, target.z, player.position.y + step): return false return true static func _move_vertically(player: SimEntity, velocity: Vector3, ground: SimGround, sea_level: float) -> void: var feet: Vector3 = player.position if player.on_ground: var reach: float = feet.y + Tuning.STEP_HEIGHT var support: float = ground.support_height(feet.x, feet.z, reach) if support >= feet.y - Tuning.GROUND_SNAP: player.position.y = support player.velocity = Vector3(velocity.x, 0.0, velocity.z) if not _walkable_support(ground, player.position): player.on_ground = false return # Walked off a ledge: start falling from here. player.on_ground = false # Airborne. Exact integration under constant gravity. var new_y: float = feet.y + velocity.y * DT - 0.5 * Tuning.GRAVITY * DT * DT velocity.y -= Tuning.GRAVITY * DT var head_room: Vector3 = Vector3(feet.x, new_y, feet.z) if velocity.y > 0.0 and ground.body_blocked(head_room, Tuning.PLAYER_RADIUS, body_height(player), 0.0): # Bumped a ceiling. new_y = feet.y velocity.y = 0.0 player.position.y = new_y var support: float = ground.support_height(feet.x, feet.z, maxf(feet.y, new_y)) # Falling into deep water: the water catches the player, with no fall damage. if velocity.y <= 0.0 and Water.is_deep(sea_level, support) and new_y <= sea_level - Tuning.SWIM_DEPTH: player.position.y = maxf(new_y, support) player.velocity = velocity _enter_water(player) return if new_y > support: player.velocity = velocity return player.position.y = support if _walkable_support(ground, player.position): _land(player, -velocity.y) velocity.y = 0.0 player.on_ground = true else: # Too steep to stand on: keep only the motion along the slope. var normal: Vector3 = ground.terrain_normal(feet.x, feet.z) var into: float = velocity.dot(normal) if into < 0.0: velocity -= normal * into velocity = velocity.limit_length(Tuning.SLIDE_MAX_SPEED) player.velocity = velocity static func _walkable_support(ground: SimGround, feet: Vector3) -> bool: if ground.support_is_solid(feet.x, feet.z, feet.y + 0.001): return true return ground.walkable_terrain(feet.x, feet.z) ## Applies fall damage for landing at `impact_speed` metres per second, downward. static func _land(player: SimEntity, impact_speed: float) -> void: if impact_speed <= 0.0: return var drop: float = impact_speed * impact_speed / (2.0 * Tuning.GRAVITY) var excess: float = drop - Tuning.FALL_DAMAGE_SAFE_METRES if excess > 0.0: var amount: int = roundi(excess * Tuning.FALL_DAMAGE_PER_METRE) if amount > 0: player.health = maxi(player.health - amount, 0) player.last_cause = SimEntity.CAUSE_FALL static func _enter_water(player: SimEntity) -> void: player.swimming = true player.on_ground = false player.velocity.y *= Tuning.WATER_ENTRY_DAMP ## True when a swimmer is up at the surface, head out, and so can kick out of the water. static func _at_surface(player: SimEntity, sea_level: float) -> bool: return player.position.y >= sea_level - Tuning.SWIM_FLOAT_DEPTH - 0.2 ## One tick in deep water. Swimmers move at SWIM_SPEED (faster sprinting while stamina ## lasts), float with the head out, dive while crouch is held, and rest on the sea floor ## rather than sinking through it. Out of stamina, they slip under. Where the water ## over the floor gets shallow they stand up and walk. static func _swim(player: SimEntity, command: PlayerCommand, ground: SimGround, sea_level: float) -> void: var has_stamina: bool = player.stamina_ticks > 0 var speed: float = Tuning.SWIM_SPEED var diving: bool = false var move: Vector3 = Vector3.ZERO if command != null: var input: Vector2 = command.move_vector() if input.length() > 1.0: input = input.normalized() var angle: float = command.yaw_radians() var forward: Vector3 = Vector3(sin(angle), 0.0, cos(angle)) var right: Vector3 = Vector3(-cos(angle), 0.0, sin(angle)) move = right * input.x + forward * input.y diving = command.is_pressed(PlayerCommand.BUTTON_CROUCH) if command.is_pressed(PlayerCommand.BUTTON_SPRINT) and has_stamina and input.y > 0.0: speed = Tuning.SWIM_SPRINT_SPEED if not has_stamina: speed *= Tuning.SWIM_EXHAUSTED_FACTOR var velocity: Vector3 = move * speed var float_depth: float = Tuning.SWIM_FLOAT_DEPTH if has_stamina else Tuning.SWIM_EXHAUSTED_DEPTH var wanted: float = -Tuning.SWIM_VERTICAL_SPEED if not diving: wanted = clampf((sea_level - float_depth - player.position.y) * 4.0, -Tuning.SWIM_VERTICAL_SPEED, Tuning.SWIM_VERTICAL_SPEED) velocity.y = move_toward(player.velocity.y, wanted, Tuning.SWIM_VERTICAL_ACCEL * DT) velocity = _move_horizontally(player, velocity, ground) var new_y: float = player.position.y + velocity.y * DT var floor_y: float = ground.support_height(player.position.x, player.position.z, maxf(player.position.y, new_y) + Tuning.STEP_HEIGHT) if new_y <= floor_y: new_y = floor_y velocity.y = maxf(velocity.y, 0.0) if velocity.y > 0.0 and ground.body_blocked(Vector3(player.position.x, new_y, player.position.z), Tuning.PLAYER_RADIUS, body_height(player), 0.0): new_y = player.position.y velocity.y = 0.0 player.position.y = new_y player.velocity = velocity # Shallow enough to stand: back on foot, without fall damage. if sea_level - floor_y < Tuning.SWIM_EXIT_DEPTH: player.swimming = false if floor_y >= player.position.y - Tuning.GROUND_SNAP: player.position.y = floor_y player.velocity.y = 0.0 player.on_ground = _walkable_support(ground, player.position) else: player.on_ground = false ## One tick of the drop after leaping: freefall, then the wing-sail. Players steer with ## the move keys relative to where they look; jump opens the sail, and it opens by itself ## WING_AUTO_DEPLOY_HEIGHT above the ground or water. Near the bottom the sail folds and ## ordinary falling (or the water) takes over, slow enough to do no damage. static func _fall_from_barge(player: SimEntity, command: PlayerCommand, ground: SimGround, sea_level: float) -> void: var below: float = _drop_floor(player, ground, sea_level, player.position.y) if player.drop_state == Drop.FREEFALL: var opens: bool = command != null and command.is_pressed(PlayerCommand.BUTTON_JUMP) if opens or player.position.y - below <= Tuning.WING_AUTO_DEPLOY_HEIGHT: player.drop_state = Drop.GLIDING var gliding: bool = player.drop_state == Drop.GLIDING var wish: Vector3 = Vector3.ZERO if command != null: var input: Vector2 = command.move_vector() if input.length() > 1.0: input = input.normalized() var angle: float = command.yaw_radians() var forward: Vector3 = Vector3(sin(angle), 0.0, cos(angle)) var right: Vector3 = Vector3(-cos(angle), 0.0, sin(angle)) wish = (right * input.x + forward * input.y) * (Tuning.GLIDE_SPEED if gliding else Tuning.FREEFALL_STEER_SPEED) var velocity: Vector3 = player.velocity var flat: Vector3 = Vector3(velocity.x, 0.0, velocity.z).move_toward(wish, Tuning.DROP_STEER_ACCEL * DT) velocity.x = flat.x velocity.z = flat.z if gliding: velocity.y = move_toward(velocity.y, -Tuning.GLIDE_FALL_SPEED, Tuning.GLIDE_BRAKE * DT) else: velocity.y = maxf(velocity.y - Tuning.GRAVITY * DT, -Tuning.FREEFALL_MAX_SPEED) velocity = _move_horizontally(player, velocity, ground) var new_y: float = player.position.y + velocity.y * DT var support: float = ground.support_height(player.position.x, player.position.z, maxf(player.position.y, new_y)) below = maxf(support, sea_level if Water.is_deep(sea_level, support) else support) player.velocity = velocity if new_y <= support: # Came down on something in a single tick: set down gently. player.position.y = support player.velocity.y = 0.0 player.drop_state = Drop.NONE player.on_ground = _walkable_support(ground, player.position) return player.position.y = new_y if new_y - below <= Tuning.DROP_LAND_HANDOFF: player.drop_state = Drop.NONE player.on_ground = false player.velocity.y = maxf(velocity.y, -Tuning.GLIDE_FALL_SPEED) ## The ground or deep water under a falling player. static func _drop_floor(player: SimEntity, ground: SimGround, sea_level: float, from_y: float) -> float: var support: float = ground.support_height(player.position.x, player.position.z, from_y) return maxf(support, sea_level) if Water.is_deep(sea_level, support) else support