Add WASD character controller with jump and slope sliding

- Add PlayerCharacterController script: CharacterController-based
  movement (camera-relative WASD), jump, gravity, rotate-toward-movement
  and slope sliding so the player slides off surfaces/edges steeper than
  the slope limit instead of balancing on them.
- Update SampleScene: add Player (with CharacterController), ground plane
  and obstacle cubes; parent the paintable paintman_UV under the Player.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Assets/Scripts/PlayerCharacterController.cs

@@ -0,0 +1,212 @@
+using UnityEngine;
+#if ENABLE_INPUT_SYSTEM
+using UnityEngine.InputSystem;
+#endif
+
+/// <summary>
+/// Simple first/third-person style character controller driven by a
+/// <see cref="CharacterController"/>: WASD for horizontal movement and Space to jump.
+///
+/// Movement can be camera-relative (W moves away from the camera) so it feels
+/// natural with the fixed scene camera. Gravity and jumping are integrated
+/// manually because CharacterController does not apply physics on its own.
+///
+/// The script reads input through the new Input System (Keyboard.current) when it
+/// is enabled, and falls back to the legacy Input Manager otherwise. The project
+/// currently runs the new Input System only.
+///
+/// Attach this to the Player GameObject (the one that owns the CharacterController).
+///
+/// Note: the class is intentionally named PlayerCharacterController to avoid a
+/// name clash with Unity.VisualScripting's example "PlayerController" type.
+/// </summary>
+[RequireComponent(typeof(CharacterController))]
+[DisallowMultipleComponent]
+public class PlayerCharacterController : MonoBehaviour
+{
+    [Header("Movement")]
+    [Tooltip("Horizontal movement speed in units per second.")]
+    public float moveSpeed = 4f;
+
+    [Tooltip("If ON, WASD is interpreted relative to the camera (W = away from " +
+             "the camera). If OFF, WASD moves along the world X/Z axes.")]
+    public bool cameraRelative = true;
+
+    [Tooltip("Camera used for camera-relative movement. Empty = Camera.main.")]
+    public Transform cameraTransform;
+
+    [Header("Rotation")]
+    [Tooltip("If ON, the character smoothly turns to face its movement direction.")]
+    public bool rotateTowardMovement = true;
+
+    [Tooltip("Turn speed in degrees per second (used when 'Rotate Toward Movement' is on).")]
+    public float rotationSpeed = 720f;
+
+    [Header("Jump & Gravity")]
+    [Tooltip("Peak jump height in units.")]
+    public float jumpHeight = 1.2f;
+
+    [Tooltip("Gravity in units per second squared (negative = downward).")]
+    public float gravity = -19.62f;
+
+    [Tooltip("Small downward velocity kept while grounded so the controller " +
+             "stays firmly on the ground (and isGrounded stays reliable).")]
+    public float groundedStickVelocity = -2f;
+
+    [Header("Slope Sliding")]
+    [Tooltip("If ON, the character slides down surfaces steeper than the " +
+             "CharacterController's Slope Limit (and off sharp edges/corners) " +
+             "instead of balancing on them.")]
+    public bool slideDownSteepSlopes = true;
+
+    [Tooltip("How quickly the slide accelerates while on a too-steep surface " +
+             "(units per second squared).")]
+    public float slideAcceleration = 20f;
+
+    [Tooltip("Maximum downhill slide speed (units per second).")]
+    public float maxSlideSpeed = 8f;
+
+    [Tooltip("How much steering control the player keeps while sliding " +
+             "(0 = none, 1 = full normal control).")]
+    [Range(0f, 1f)]
+    public float slideControl = 0.3f;
+
+    private CharacterController _controller;
+    private float _verticalVelocity;
+
+    // Ground contact normal collected from the latest Move (used for slope sliding).
+    private Vector3 _groundNormal = Vector3.up;
+    private bool _groundNormalUpdated;
+    private float _slideSpeed;
+
+    void Awake()
+    {
+        _controller = GetComponent<CharacterController>();
+        if (cameraTransform == null && Camera.main != null)
+            cameraTransform = Camera.main.transform;
+    }
+
+    void Update()
+    {
+        // --- Read input -----------------------------------------------------
+        float h = 0f, v = 0f;
+        bool jumpPressed = false;
+
+#if ENABLE_INPUT_SYSTEM
+        var keyboard = Keyboard.current;
+        if (keyboard != null)
+        {
+            if (keyboard.aKey.isPressed) h -= 1f;
+            if (keyboard.dKey.isPressed) h += 1f;
+            if (keyboard.sKey.isPressed) v -= 1f;
+            if (keyboard.wKey.isPressed) v += 1f;
+            jumpPressed = keyboard.spaceKey.wasPressedThisFrame;
+        }
+#else
+        h = Input.GetAxisRaw("Horizontal");
+        v = Input.GetAxisRaw("Vertical");
+        jumpPressed = Input.GetButtonDown("Jump");
+#endif
+
+        // --- Build the horizontal move direction ----------------------------
+        Vector3 inputDir = new Vector3(h, 0f, v);
+        if (inputDir.sqrMagnitude > 1f)
+            inputDir.Normalize();
+
+        Vector3 moveDir;
+        if (cameraRelative && cameraTransform != null)
+        {
+            // Project the camera axes onto the ground plane so movement stays horizontal.
+            Vector3 forward = cameraTransform.forward;
+            forward.y = 0f;
+            forward.Normalize();
+            Vector3 right = cameraTransform.right;
+            right.y = 0f;
+            right.Normalize();
+            moveDir = forward * inputDir.z + right * inputDir.x;
+        }
+        else
+        {
+            moveDir = inputDir;
+        }
+
+        // --- Evaluate the ground slope (for sliding) ------------------------
+        // The ground normal is gathered in OnControllerColliderHit during the
+        // previous Move. If it is steeper than the controller's Slope Limit, the
+        // surface is too steep to stand on (this also covers balancing on a sharp
+        // box edge/corner, whose contact normal is steep).
+        float slopeAngle = Vector3.Angle(_groundNormal, Vector3.up);
+        bool onSteepSlope = slideDownSteepSlopes
+            && _controller.isGrounded
+            && slopeAngle > _controller.slopeLimit + 0.01f;
+
+        // --- Gravity & jumping ---------------------------------------------
+        if (_controller.isGrounded)
+        {
+            // Reset accumulated fall speed and keep a small downward bias on the ground.
+            if (_verticalVelocity < 0f)
+                _verticalVelocity = groundedStickVelocity;
+
+            // No jumping off a slope that is too steep to stand on.
+            if (jumpPressed && !onSteepSlope)
+                _verticalVelocity = Mathf.Sqrt(jumpHeight * -2f * gravity);
+        }
+
+        _verticalVelocity += gravity * Time.deltaTime;
+
+        // --- Slope sliding --------------------------------------------------
+        Vector3 slideVelocity = Vector3.zero;
+        if (onSteepSlope)
+        {
+            // Steepest-descent direction along the slope surface.
+            Vector3 slideDir = Vector3.ProjectOnPlane(Vector3.down, _groundNormal).normalized;
+            // Accelerate the slide up to the maximum slide speed.
+            _slideSpeed = Mathf.Min(_slideSpeed + slideAcceleration * Time.deltaTime, maxSlideSpeed);
+            slideVelocity = slideDir * _slideSpeed;
+            // While sliding the player keeps only reduced steering control.
+            moveDir *= slideControl;
+        }
+        else
+        {
+            _slideSpeed = 0f;
+        }
+
+        // --- Apply movement -------------------------------------------------
+        Vector3 velocity = moveDir * moveSpeed + slideVelocity + Vector3.up * _verticalVelocity;
+
+        // Reset the per-frame ground-normal collection, then Move (which fires
+        // OnControllerColliderHit), then fall back to "up" if nothing was hit.
+        _groundNormalUpdated = false;
+        _controller.Move(velocity * Time.deltaTime);
+        if (!_groundNormalUpdated)
+            _groundNormal = Vector3.up;
+
+        // --- Rotate toward the movement direction ---------------------------
+        if (rotateTowardMovement && moveDir.sqrMagnitude > 0.0001f)
+        {
+            Quaternion target = Quaternion.LookRotation(moveDir, Vector3.up);
+            transform.rotation = Quaternion.RotateTowards(
+                transform.rotation, target, rotationSpeed * Time.deltaTime);
+        }
+    }
+
+    /// <summary>
+    /// Collects the ground contact normal during <see cref="CharacterController.Move"/>.
+    /// Walls and ceilings (normal pointing sideways or down) are ignored; among the
+    /// upward-facing contacts the flattest one is kept, which represents the surface
+    /// the character is actually standing on.
+    /// </summary>
+    private void OnControllerColliderHit(ControllerColliderHit hit)
+    {
+        // Ignore near-vertical walls and ceilings.
+        if (hit.normal.y <= 0.05f)
+            return;
+
+        // Keep the flattest (most supportive) contact seen this frame.
+        if (!_groundNormalUpdated || hit.normal.y > _groundNormal.y)
+        {
+            _groundNormal = hit.normal;
+            _groundNormalUpdated = true;
+        }
+    }
+}

Assets/Scripts/PlayerCharacterController.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 463b6be548abf464287096e1e92fcd01