From 1e917e196b5ea0143a31afeaf1ff24ca7025506a Mon Sep 17 00:00:00 2001 From: daddy Date: Sun, 6 Sep 2026 14:33:49 +0000 Subject: [PATCH] Free-orbit third-person camera The mouse now orbits the camera around the player a full 360 in yaw (unclamped) with a wide pitch range -- swing it around to look at the avatar's face. The body no longer snaps to the camera yaw; instead it turns smoothly to face its movement direction (lerp_angle at BODY_TURN_SPEED), so controls feel the same: W is still "away from camera", A/D still strafe relative to view. Implementation: CameraPivot is set top_level so it doesn't inherit the body's rotation; _update_camera() places it at the head each frame and points it by _camera_yaw / _camera_pitch. Movement direction is built from a yaw-only camera basis. net_input.look_yaw is now the body's movement facing, so remote players render facing the way they walk. Verified: headless boot clean, 2p multiplayer still connects/moves, avatar smoke 14/14 (source + exported pack), fresh-clone PASS, and eyeballed the orbit in rendered screenshots (behind -> side -> face). Co-Authored-By: Claude Sonnet 5 Claude-Session: https://claude.ai/code/session_015jtxAiu5dAW4WxCNdGkrkJ --- scripts/player.gd | 69 +++++++++++++++++++++++++++++++++-------------- 1 file changed, 49 insertions(+), 20 deletions(-) diff --git a/scripts/player.gd b/scripts/player.gd index 3a22dee..46815d6 100644 --- a/scripts/player.gd +++ b/scripts/player.gd @@ -3,9 +3,12 @@ extends CharacterBody3D ## The player character controller. ## ## A CharacterBody3D with WASD/arrow locomotion, gravity, jump, and a -## third-person camera (SpringArm3D behind the player) with mouse-look -- -## yaw turns the body, pitch orbits the camera. Reads the spawn point from -## the current scene's `PlayerSpawn` Marker3D. +## free-orbit third-person camera. The mouse orbits the camera around the +## player a full 360 (yaw) plus a wide pitch range -- swing it around to see +## the avatar's face if you want. Movement is camera-relative (W = away from +## camera) and the body turns to face the direction it's moving, independent +## of where the camera is pointed. Reads the spawn point from the current +## scene's `PlayerSpawn` Marker3D. # --------------------------------------------------------------------------- @@ -25,6 +28,7 @@ const MOUSE_SENSITIVITY: float = 0.003 # --------------------------------------------------------------------------- var _input_direction := Vector2.ZERO +var _camera_yaw: float = 0.0 # free orbit, unclamped (wraps 360) var _camera_pitch: float = -0.12 var _spawn_position: Vector3 = Vector3(0, 1.5, 0) @@ -32,10 +36,15 @@ var _spawn_position: Vector3 = Vector3(0, 1.5, 0) ## line up with the bottom of the player's collision capsule. const AVATAR_FEET_OFFSET: float = -0.8 -## Third-person pitch limits (radians): a bit up, a lot down (looking over -## the avatar's shoulder toward the ground). -const PITCH_MIN: float = -1.1 -const PITCH_MAX: float = 0.45 +## Camera pitch limits (radians): from nearly top-down to looking up at the +## avatar from below. Yaw is deliberately unclamped -- full 360 orbit. +const PITCH_MIN: float = -1.35 +const PITCH_MAX: float = 1.2 + +## Where the camera pivot sits relative to the player origin, and how quickly +## the body swings to face its movement direction. +const CAMERA_PIVOT_OFFSET: Vector3 = Vector3(0.0, 1.2, 0.0) +const BODY_TURN_SPEED: float = 12.0 @onready var _camera: Camera3D = $CameraPivot/SpringArm3D/Camera3D @onready var _camera_pivot: Node3D = $CameraPivot @@ -79,8 +88,12 @@ func _ready() -> void: var arm := $CameraPivot/SpringArm3D as SpringArm3D arm.add_excluded_object(self) - # Start the camera arm tilted down a little so the avatar is framed. - _camera_pivot.rotation.x = _camera_pitch + # The camera pivot orbits the player freely, so it can't be a child that + # inherits the body's yaw -- detach it and drive its world transform + # ourselves each frame. + _camera_pivot.top_level = true + _camera_yaw = rotation.y + _update_camera() # Capture the mouse for look. Headless/test runs have no real window to # capture input for, so guard against that rather than error. @@ -159,12 +172,21 @@ func _clear_input_direction(key: InputEventKey) -> void: func _handle_mouse_look(event: InputEventMouseMotion) -> void: - # Yaw rotates the whole body (so movement direction turns with the - # look direction); pitch orbits the camera arm around the player, so the - # capsule itself never tips over. - rotation.y -= event.relative.x * MOUSE_SENSITIVITY + # Mouse orbits the camera only -- the body is left alone (it turns to face + # movement in _physics_process). Yaw wraps freely; pitch is clamped. + _camera_yaw = wrapf(_camera_yaw - event.relative.x * MOUSE_SENSITIVITY, -PI, PI) _camera_pitch = clampf(_camera_pitch - event.relative.y * MOUSE_SENSITIVITY, PITCH_MIN, PITCH_MAX) - _camera_pivot.rotation.x = _camera_pitch + _update_camera() + + +## Place the free-orbit camera pivot at the player's head and point it per the +## current yaw/pitch. Called from _ready, on mouse-look, and every frame (the +## player moves under it). +func _update_camera() -> void: + if not is_instance_valid(_camera_pivot): + return + _camera_pivot.global_position = global_position + CAMERA_PIVOT_OFFSET + _camera_pivot.global_rotation = Vector3(_camera_pitch, _camera_yaw, 0.0) # --------------------------------------------------------------------------- @@ -189,17 +211,24 @@ func _physics_process(delta: float) -> void: velocity.y = JUMP_VELOCITY jumped = true - # Build movement direction from input. Godot's local "forward" is -Z, not - # +Z, so W (input.y = +1) must use -basis.z -- using +basis.z here would - # move the player backward when pressing forward (confirmed by reading - # Camera3D/Node3D's own convention: a node looks down its local -Z). - var direction := (_input_direction.x * transform.basis.x - - _input_direction.y * transform.basis.z).normalized() + # Movement is camera-relative: W (input.y = +1) heads away from the camera, + # A/D strafe. A node looks down its local -Z, so forward = -cam_basis.z. + var cam_basis := Basis.from_euler(Vector3(0.0, _camera_yaw, 0.0)) + var direction := (_input_direction.x * cam_basis.x - + _input_direction.y * cam_basis.z).normalized() velocity.x = direction.x * WALK_SPEED velocity.z = direction.z * WALK_SPEED + # Turn the body to face where it's moving (independent of the camera). + if direction.length_squared() > 0.01: + var target_yaw := atan2(-direction.x, -direction.z) + rotation.y = lerp_angle(rotation.y, target_yaw, clampf(BODY_TURN_SPEED * delta, 0.0, 1.0)) + move_and_slide() + # Keep the orbit camera on the player as it moves. + _update_camera() + if _limb_anim != null: _limb_anim.set("speed", Vector2(velocity.x, velocity.z).length())