3D Third-Person - Core (Make game skill)

​

Minimum playable base (build this first)

​

Player scene tree

Player (CharacterBody3D)
  CharacterRotationRoot (Node3D)      # model rotation lives here, not on body
    CharacterSkin (Node3D)            # mesh + AnimationTree
    MeleeAnchor (Node3D)
      AnimationPlayer                 # "Attack" anim toggles hitbox
      MeleeAttackArea (Area3D + CollisionShape3D, disabled)
  CameraController (Node3D)           # follows via code, NOT rigid parenting
    CameraSpringArm (SpringArm3D)
      CameraThirdPersonPivot (Node3D)
    CameraOverShoulderPivot (Node3D)  # right + closer, for aiming
    PlayerCamera (Camera3D)
      CameraRayCast (RayCast3D, target (0,0,-100))  # aim target
  GrenadeLauncher (Node3D)            # LaunchPoint, ShapeCast3D, TrailMesh
  GroundShapeCast (ShapeCast3D, down) # ground height for camera
  StepSound / LandingSound (AudioStreamPlayer3D)
  UI (CanvasLayer)                    # %AimRecticle, %CoinsContainer, WeaponUI

​

Controller: the decisions that matter

func _get_camera_oriented_input() -> Vector3:
	if _attack_animation_player.is_playing():
		return Vector3.ZERO                # attacking locks movement
	var raw := Input.get_vector("move_left", "move_right", "move_up", "move_down")
	var input := Vector3.ZERO
	input.x = -raw.x * sqrt(1.0 - raw.y * raw.y / 2.0)   # no faster diagonals
	input.z = -raw.y * sqrt(1.0 - raw.x * raw.x / 2.0)
	input = _camera_controller.global_transform.basis * input
	input.y = 0.0
	return input

if _move_direction.length() > 0.2:
	_last_strong_direction = _move_direction.normalized()
if is_aiming:
	_last_strong_direction = (_camera_controller.global_transform.basis * Vector3.BACK).normalized()

var y_velocity := velocity.y
velocity.y = 0.0
velocity = velocity.lerp(_move_direction * move_speed, acceleration * delta)
if _move_direction.length() == 0 and velocity.length() < stopping_speed:
	velocity = Vector3.ZERO
velocity.y = y_velocity

​

Camera system

• Orbit uses accumulated euler angles from mouse (_unhandled_input, only while mouse captured) plus joystick strength added in _process; inputs are consumed and zeroed every frame. Tilt clamped -60..60 deg. Never look_at() per frame - it jitters.
• SpringArm3D handles wall avoidance for free, but MUST exclude the player: _camera_spring_arm.add_excluded_object(anchor.get_rid()) and _camera_raycast.add_exception_rid(anchor.get_rid()) in setup().
• Ground-height tracking: camera Y lerps toward the player’s _ground_height (from GroundShapeCast), not the player’s Y - so jumps do not bounce the camera. The player computes _ground_height as the max collision point of the downward ShapeCast, clamped to its own Y when falling below it.
• Aim target: CameraRayCast collision point (or the ray end if no hit) is what bullets fly toward and what the grenade locks onto - get_aim_target() / get_aim_collider().

​

Character skin (AnimationTree)

func set_moving(value: bool):      # SETTER - travel only on change
	moving = value
	state_machine.travel("move" if moving else "idle")

func punch():
	animation_tree["parameters/PunchOneShot/request"] = AnimationNodeOneShot.ONE_SHOT_REQUEST_FIRE

​

Level assembly

• WorldEnvironment: sky background (ProceduralSkyMaterial), ACES tonemap (tonemap_mode = 2), glow enabled. Without WorldEnvironment everything is flat and dark.
• DirectionalLight3D angled ~45 deg, shadow_enabled = true (off by default; without shadows objects float).
• Geometry: CSGCombiner3D with use_collision = true, CSGBox3D/ CSGCylinder3D children; boolean subtraction (operation 2) for tunnels. Materials with uv1_triplanar = true so textures map on any face.
• DeathPlane: big Area3D at y -20; body_entered on the Player calls reset_position() (respawn at _start_position captured in _ready).
• Jump pad: Area3D setting body.velocity = Vector3.UP * body.jump_initial_impulse + transform.basis * Vector3.UP * impulse_strength (basis-relative so rotated pads launch at angles) + squash-and-elastic rebound tween on the mesh.
• Project: 1920x1080, stretch canvas_items / keep_height.
• Pause menu node needs process_mode = ALWAYS and must flip mouse mode between CAPTURED (gameplay) and VISIBLE (menu).

​

Build order

1. Project settings + input actions + layer names.
2. Player scene tree above; movement + jump with a placeholder capsule.
3. CameraController: spring arm orbit, then over-shoulder aim pivot.
4. CharacterSkin AnimationTree once movement feels right.
5. Level: imported location/props (asset-strategy) where they fit; CSG floor/platforms only as blockout or for missing pieces; light, environment, death plane, jump pad.
6. Combat + enemies + coins (3d-third-person-systems.md).

​

Traps

• Parenting the camera rigidly to the player - it inherits every rotation and nauseates. Follow via code with offset + lerp.
• Skipping SpringArm3D (camera clips walls) or forgetting to exclude the player’s RID from it (camera collides with the player).
• look_at() every frame for camera or state_machine.travel() every frame for animation - both jitter/reset; only act on change.
• Scaling the CharacterBody3D itself - scale the mesh under CharacterRotationRoot. Physics on scaled bodies misbehaves.
• 1 unit = 1 meter. Characters are 1-2 units tall; extreme scales break physics and lighting.
• Toggling CollisionShape3D disabled directly inside physics callbacks - always set_deferred("disabled", ...).
• Low gravity. -30 for the player feels right; project-default 16 is floaty. Tune player gravity independently of the physics setting.