s&box PlayerData Pattern: Persistent Stats with Auto-Respawn

/// <summary>
/// Holds persistent player information like deaths, kills.
/// Survives player character death/respawn.
/// </summary>
public sealed partial class PlayerData : Component, Global.ISaveEvents
{
    [Property] public Guid PlayerId { get; set; }  // Connection.Id
    [Property] public long SteamId { get; set; } = -1L;
    [Property] public string DisplayName { get; set; }
    
    // Synced stats (visible to all clients)
    [Sync] public int Kills { get; set; }
    [Sync] public int Deaths { get; set; }
    [Sync] public bool IsGodMode { get; set; }
    
    // Static lookup helpers
    public static PlayerData For(Connection connection) => 
        connection == null ? default : For(connection.Id);
    
    public static PlayerData For(Guid playerId) => 
        All.FirstOrDefault(x => x.PlayerId == playerId);
    
    public static IEnumerable<PlayerData> All => 
        Game.ActiveScene.GetAll<PlayerData>();
    
    public Connection Connection => Connection.Find(PlayerId);
    public float Ping => Connection?.Ping ?? 0;
    public bool IsMe => PlayerId == Connection.Local.Id;
}

private PlayerData CreatePlayerInfo(Connection channel)
{
    // Check if already exists (reconnecting)
    var existing = PlayerData.For(channel);
    if (existing.IsValid()) return existing;
    
    // Create new PlayerData GameObject
    var go = new GameObject(true, $"PlayerInfo - {channel.DisplayName}");
    var data = go.AddComponent<PlayerData>();
    data.SteamId = (long)channel.SteamId;
    data.PlayerId = channel.Id;
    data.DisplayName = channel.DisplayName;
    
    go.NetworkSpawn(null);  // Host-owned
    go.Network.SetOwnerTransfer(OwnerTransfer.Fixed);
    
    return data;
}

public sealed partial class PlayerData : Component
{
    private bool _needsRespawn;
    private RealTimeSince _timeSinceDied;
    
    // Called when player dies
    public void MarkForRespawn()
    {
        _needsRespawn = true;
        _timeSinceDied = 0;
    }
    
    // Auto-respawn after 4 seconds
    protected override void OnUpdate()
    {
        if (!Networking.IsHost) return;
        if (!_needsRespawn) return;
        if (_timeSinceDied < 4f) return;
        
        RequestRespawn();
    }
    
    // Called by PlayerObserver or auto-timer
    [Rpc.Host(NetFlags.OwnerOnly | NetFlags.Reliable)]
    public void RequestRespawn()
    {
        _needsRespawn = false;
        
        // Clean up observer (spectator) if exists
        foreach (var observer in Scene.GetAllComponents<PlayerObserver>()
            .Where(x => x.Network.Owner?.Id == PlayerId))
        {
            observer.GameObject.Destroy();
        }
        
        GameManager.Current?.SpawnPlayer(this);
    }
}

// Called on host, RPCs to player for Stats.Increment
public void AddStat(string identifier, int amount = 1)
{
    if (Application.CheatsEnabled) return;
    Assert.True(Networking.IsHost, "PlayerData.AddStat is host-only!");
    
    using (Rpc.FilterInclude(Connection))
    {
        RpcAddStat(identifier, amount);
    }
}

[Rpc.Broadcast]
private void RpcAddStat(string identifier, int amount = 1)
{
    Sandbox.Services.Stats.Increment(identifier, amount);
}

Connection (network layer)
    │ (matches Connection.Id)
    ▼
PlayerData (persistent, host-owned)
    │ (referenced by Player component)
    ▼
Player (character, spawned/destroyed per life)
    │ (parented to PlayerData on spawn)
    ▼
PlayerInventory, etc. (character components)