I focused on a pause system that does not rely on Time.timeScale. Instead, a centralized GameStateHandler drives the paused state, and player logic explicitly freezes movement + gravity + animation, while storing/restoring values to avoid bugs (like infinite jumping when pausing mid-air).

GameStateHandler (singleton + state machine + pause/resume)

public enum GameState
{
  Playing,
  Paused,
  GameOver
}

public class GameStateHandler : MonoBehaviour
{
  public static GameStateHandler Instance { get; private set; }
  public GameState CurrentState { get; private set; } = GameState.Playing;

  public Animator[] animators;

  private UIManager uiManager;
  private PlayerMovement playerMovement;

  public bool isGameOver = false;

  void Awake()
  {
    if (Instance == null) Instance = this;
    else { Destroy(gameObject); return; }

    uiManager = GetComponent<UIManager>();
    if (uiManager == null)
    {
      Debug.Log("UIManager not found in scene, please attach.");
    }
  }

  void Start()
  {
    if (uiManager != null) uiManager.OnResumePress();
  }

  public void ChangeState(GameState newState)
  {
    if (CurrentState == newState) return;
    CurrentState = newState;

    switch (newState)
    {
      case GameState.Paused:   PauseGame();  break;
      case GameState.Playing:  ResumeGame(); break;
      case GameState.GameOver: GameOver();   break;
    }
  }

  public void TogglePause()
  {
    if (CurrentState == GameState.Playing) ChangeState(GameState.Paused);
    else if (CurrentState == GameState.Paused) ChangeState(GameState.Playing);
  }

  public void PauseGame()
  {
    Debug.Log("Game Paused");

    foreach (Animator animator in animators)
    {
      animator.enabled = false;
    }
  }

  public void ResumeGame()
  {
    if (uiManager != null) uiManager.OnResumePress();
    Debug.Log("Game Resumed");

    ChangeState(GameState.Playing);
  }

  public void GameOver()
  {
    if (CurrentState == GameState.Paused) ResumeGame();

    ChangeState(GameState.GameOver);
    isGameOver = true;
    Debug.Log("Game Over");

    if (playerMovement != null) playerMovement.enabled = false;
  }
}

Player pause guard (freeze gravity + animation, restore cleanly)

// PlayerMovement
if (GameStateHandler.Instance != null &&
    GameStateHandler.Instance.CurrentState == GameState.Paused)
{
  if (ani != null && ani.speed != 0)
  {
    previousAnimatorSpeed = ani.speed;
    ani.speed = 0;
  }

  if (rb.useGravity)
  {
    isGravityEnabled = true;
    rb.useGravity = false;
    rb.linearVelocity = Vector3.zero;
  }

  transform.position = previousPosition;
  return;
}
else
{
  if (!isGravityEnabled && rb.useGravity == false)
  {
    rb.useGravity = true;
  }

  if (ani != null && ani.speed == 0 && previousAnimatorSpeed != 0)
  {
    ani.speed = previousAnimatorSpeed;
  }
}

Checkpoint trigger (store respawn point + feedback)

public class Checkpoint : MonoBehaviour
{
  private Respawner respawner;
  private BoxCollider checkPointCollider;

  public ParticleSystem effect;
  [System.NonSerialized] public AudioManager audioManager;

  void Awake()
  {
    checkPointCollider = GetComponent<BoxCollider>();
    respawner = GameObject.FindGameObjectWithTag("Respawn").GetComponent<Respawner>();
    audioManager = GameObject.FindGameObjectWithTag("Audio").GetComponent<AudioManager>();
  }

  private void OnTriggerEnter(Collider other)
  {
    if (other.gameObject.CompareTag("Player"))
    {
      respawner.respawnPoint = this.gameObject;
      checkPointCollider.enabled = false;

      audioManager.PlaySFX(audioManager.checkpoint);
      effect.Play(true);
    }
  }
}

Damage source trigger (hurt / death routing)

public class DamageSource : MonoBehaviour
{
  PlayerUI playerUI;
  PlayerMovement player;
  CollectionSystem collectionSystem;

  void Awake()
  {
    player = gameObject.GetComponent<PlayerMovement>();
    collectionSystem = GetComponent<CollectionSystem>();

    if (collectionSystem != null)
    {
      playerUI = collectionSystem.playerUI;
    }
  }

  void OnTriggerEnter(Collider other)
  {
    if (other.gameObject.tag == "Enemy")
    {
      if (collectionSystem != null && playerUI != null)
      {
        player.GotHurt();
        playerUI.MinusHealth();
      }
      else
      {
        Debug.Log("Collection system or PlayerUI is missing");
      }
    }

    if (other.gameObject.tag == "Serpent")
    {
      playerUI.Death();
    }
  }
}

Modular approach: a base vehicle pawn holds shared driving behaviors (input, drift, boost, reset), while each car type focuses on tuning data. A unified controller swaps between FPS and vehicle pawns and swaps input mapping contexts.

Base car pawn: shared setup + driving hooks

// Base: shared components + chaos movement access
SetRootComponent(GetMesh());

InteriorSpringArm = CreateDefaultSubobject<USpringArmComponent>(TEXT("Interior Spring Arm"));
InteriorSpringArm->SetupAttachment(GetMesh());

InteriorCamera = CreateDefaultSubobject<UCameraComponent>(TEXT("Interior Camera"));
InteriorCamera->SetupAttachment(InteriorSpringArm, USpringArmComponent::SocketName);

ChaosVehicleMovement = CastChecked<UChaosWheeledVehicleMovementComponent>(GetVehicleMovement());
GetMesh()->SetSimulatePhysics(true);
GetMesh()->SetCollisionProfileName(FName("Vehicle"));

Drift: reduce grip + increase angular damping

// Drift
bIsDrifting = true;

for (auto& WheelSetup : ChaosVehicleMovement->WheelSetups)
{
  if (WheelSetup.WheelClass)
  {
    WheelSetup.WheelClass.GetDefaultObject()->FrictionForceMultiplier
      = DefaultGrip * DriftGripReduction;
  }
}

GetMesh()->SetAngularDamping(DefaultAngularDrag * DriftAngularDragMultiplier);
ChaosVehicleMovement->SetHandbrakeInput(true);

Nitro: temporary engine boost + impulse

// Nitro boost
bIsBoosting = true;
bCanBoost = false;

float OriginalMaxTorque = ChaosVehicleMovement->EngineSetup.MaxTorque;
float OriginalMaxRPM = ChaosVehicleMovement->EngineSetup.MaxRPM;

ChaosVehicleMovement->EngineSetup.MaxTorque *= BoostMultiplier;
ChaosVehicleMovement->EngineSetup.MaxRPM *= 2.5f;

GetMesh()->AddImpulse(GetActorForwardVector() * BoostThrust);

Car feel: muscle car tuning

// MuscleCar: tuning values live in the derived class
GetChaosVehicleMovement()->WheelSetups.SetNum(4);

GetChaosVehicleMovement()->WheelSetups[0].WheelClass = UCPP_BasicFrontWheel::StaticClass();
GetChaosVehicleMovement()->WheelSetups[2].WheelClass = UCPP_BasicRearWheel::StaticClass();

GetChaosVehicleMovement()->EngineSetup.MaxTorque = 750.f;
GetChaosVehicleMovement()->EngineSetup.MaxRPM = 7000.0f;

Unified controller: swap pawns + swap input mapping contexts

// Pawn swap + mapping context swap
Subsystem->ClearAllMappings();

if (NewPawn == VehiclePawn && CarInputMappingContext)
{
  Subsystem->AddMappingContext(CarInputMappingContext, 0);
}
else if (NewPawn == FPSPawn && FPSInputMappingContext)
{
  Subsystem->AddMappingContext(FPSInputMappingContext, 0);
}

Possess(NewPawn);

GameState-driven pause (controller enable/disable)

// FPSController
private void Awake()
{
  characterController = GetComponent<CharacterController>();
  GameStateManager.Instance.OnGameStateChanged += OnGameStateChanged;
  GameStateManager.Instance.SetState(GameState.Play);
}

private void OnDestroy()
{
  GameStateManager.Instance.OnGameStateChanged -= OnGameStateChanged;
}

private void OnGameStateChanged(GameState newState)
{
  enabled = newState == GameState.Play;
  Cursor.lockState = CursorLockMode.None;
  Cursor.visible = newState != GameState.Play;
}

FPS movement + dash (CharacterController)

// FPSController
Vector3 forward = transform.TransformDirection(Vector3.forward);
Vector3 right = transform.TransformDirection(Vector3.right);

bool isRunning = Input.GetKey(KeyCode.LeftShift);

float curSpeedX = canMove ? (isRunning ? runSpeed : walkSpeed) * Input.GetAxis("Vertical") : 0;
float curSpeedY = canMove ? (isRunning ? runSpeed : walkSpeed) * Input.GetAxis("Horizontal") : 0;

Vector3 move = (forward * curSpeedX) + (right * curSpeedY);

if (move.magnitude > 1f)
{
  move.Normalize(); // diagonal speed fix
  move *= (isRunning ? runSpeed : walkSpeed);
}

moveDirection = move;

if (Input.GetButton("Jump") && canMove && characterController.isGrounded)
  moveDirection.y = jumpPower;

if (!characterController.isGrounded)
  moveDirection.y -= gravity * Time.deltaTime;

characterController.Move(moveDirection * Time.deltaTime);

if (Input.GetKeyDown(KeyCode.Mouse1)) dashing = true;

if (dashing)
{
  capsuleCollider.enabled = false;

  m_dashTimer += Time.deltaTime;
  if (m_dashTimer >= 0.5f)
  {
    dashing = false;
    m_dashTimer = 0;
    capsuleCollider.enabled = true;
  }

  Vector3 dashDirection =
    (transform.forward * Input.GetAxis("Vertical") +
     transform.right * Input.GetAxis("Horizontal")).normalized;

  characterController.Move(dashDirection * m_dashDistance);
}

AudioManager (music + SFX routing)

public class AudioManager : MonoBehaviour
{
  [SerializeField] private AudioSource musicSource;
  [SerializeField] private AudioSource sfxSource;

  public AudioClip background;
  [Range(0, 1)] public float backgroundVolume = 1.0f;

  public AudioClip collectable;
  [Range(0, 1)] public float collectableVolume = 1.0f;

  void Start()
  {
    musicSource.clip = background;
    musicSource.volume = backgroundVolume;
    musicSource.Play();
  }

  public void PlaySFX(AudioClip clip)
  {
    if (clip == collectable) sfxSource.volume = collectableVolume;
    sfxSource.PlayOneShot(clip);
  }
}

Footsteps: pick sound by surface under player

// Footsteps
if (GameStateManager.Instance != null &&
    GameStateManager.Instance.CurrentGameState == GameState.Pause) return;

if (characterController.isGrounded && characterController.velocity.magnitude > 1f)
{
  if (!footstepSource.isPlaying)
    PlayFootsteps();
}

string GetCurrentLayer()
{
  if (Physics.Raycast(transform.position, Vector3.down, out RaycastHit hit, 2f))
    return LayerMask.LayerToName(hit.collider.gameObject.layer);

  return "Unknown";
}

Event manager (lightweight gameplay events)

public class EventsManager : MonoBehaviour
{
  public static EventsManager instance { get; private set; }

  private void Awake()
  {
    if (instance != null)
      Debug.LogError("Found more than one Game Events Manager in the scene.");
    instance = this;
  }

  public event Action onPlayerJump;

  public void PlayerJump()
  {
    onPlayerJump?.Invoke();
  }
}

Dialogue: UI show + timed close

// DialogueManager
public void StartDialogue(int day)
{
  UI.SetActive(true);

  nameText.text = baseDialogue.npcName;
  dialogueText.text = Messages[day - 1];

  StartCoroutine(CloseAfterSeconds());
}

IEnumerator CloseAfterSeconds()
{
  yield return new WaitForSeconds(secondsToShow);
  EndDialogue();
}

public void EndDialogue()
{
  UI.SetActive(false);
}

Notes: raycast interact + open UI (disable player + pause controller)

// Raycast
if (Physics.Raycast(_camera.ViewportToWorldPoint(new Vector3(0.5f, 0.5f)),
    transform.forward, out RaycastHit hit, rayLength))
{
  var readableItem = hit.collider.GetComponent<NoteController>();
  if (readableItem != null)
  {
    noteController = readableItem;
    HighlightCrosshair(true);
  }
  else
  {
    ClearNote();
  }
}

if (noteController != null && Input.GetKeyDown(interactKey))
{
  noteController.ShowNote();
}

// NoteController
noteTextUI.text = noteData.noteText;
noteCanvas.SetActive(true);
player.enabled = false;

pauseController = GameObject.FindAnyObjectByType<PauseController>();
if (pauseController != null) pauseController.enabled = false;