Performance Best Practices

public class BulletPool : Component
{
    private Queue<Bullet> _pool = new();
    private const int POOL_SIZE = 50;
    
    void InitializePool()
    {
        for (int i = 0; i < POOL_SIZE; i++)
        {
            var bullet = new GameObject();
            bullet.Components.Create<Bullet>();
            bullet.Enabled = false;
            _pool.Enqueue(bullet.Components.Get<Bullet>());
        }
    }
    
    public Bullet GetBullet()
    {
        if (_pool.Count > 0)
        {
            var bullet = _pool.Dequeue();
            bullet.GameObject.Enabled = true;
            return bullet;
        }
        
        // Fallback: create new (but warn)
        Log.Warning("Bullet pool exhausted!");
        var newBullet = new GameObject();
        return newBullet.Components.Create<Bullet>();
    }
    
    public void ReturnBullet(Bullet bullet)
    {
        bullet.GameObject.Enabled = false;
        _pool.Enqueue(bullet);
    }
}

public class Weapon : Component
{
    // Cache all needed components
    private ModelRenderer _renderer;
    private SoundPointComponent _sound;
    private List<Attachment> _attachments = new();
    
    protected override void OnAwake()
    {
        // One-time lookup
        _renderer = Components.Get<ModelRenderer>();
        _sound = Components.Get<SoundPointComponent>();
        _attachments = Components.GetAll<Attachment>().ToList();
    }
}

public class EnemySpawner : Component
{
    private List<GameObject> _cachedEnemies = new();
    private RealTimeSince _lastCacheUpdate;
    
    protected override void OnUpdate()
    {
        // Refresh cache every second, not every frame
        if (_lastCacheUpdate > 1.0f)
        {
            _cachedEnemies = Scene.FindAllObjectsWithTag("enemy").ToList();
            _lastCacheUpdate = 0;
        }
        
        // Use cached list
        foreach (var enemy in _cachedEnemies)
        {
            if (!enemy.IsValid()) continue;
            UpdateEnemy(enemy);
        }
    }
}

public class HUD : Component
{
    // ❌ Bad: Allocates every frame
    protected override void OnUpdate()
    {
        ScoreLabel.Text = $"Score: {Score}";
    }
    
    // ✅ Good: Only update when changed
    private int _lastScore = -1;
    protected override void OnUpdate()
    {
        if (Score != _lastScore)
        {
            ScoreLabel.Text = $"Score: {Score}";
            _lastScore = Score;
        }
    }
}

void OptimizedTrace()
{
    // ✅ Good: Use collision rules instead of checking tags after
    var tr = Scene.Trace
        .Ray(start, end)
        .WithCollisionRules("weapon", "player")
        .WithoutTag("trigger", "decal")
        .Run();
}

public class PlayerState : Component
{
    // ✅ Good: Batch sync properties, use interpolation
    [Sync(SyncFlags.Interpolate)]
    public Vector3 Position { get; set; }
    
    [Sync]
    public int Health { get; set; }
    
    // ✅ Good: Rate-limit network updates
    private RealTimeSince _lastHealthUpdate;
    
    void UpdateHealth(int newHealth)
    {
        if (_lastHealthUpdate < 0.1f) return; // Max 10 updates/sec
        Health = newHealth;
        _lastHealthUpdate = 0;
    }
}

// ✅ Good: Use BuildHash to prevent rebuilds
public class ScorePanel : Panel
{
    public int Score { get; set; }
    
    // Panel only rebuilds when hash changes
    public override int BuildHash() => Score.GetHashCode();
}