// BAD: Expensive call every frame
private void Update()
{
    var target = GameObject.FindWithTag("Player"); // Allocates + searches
    transform.LookAt(target.transform);
}

// GOOD: Cache references
private Transform _target;

private void Start()
{
    _target = GameObject.FindWithTag("Player").transform;
}

private void Update()
{
    transform.LookAt(_target);
}

using UnityEngine;

public class AIPerception : MonoBehaviour
{
    [SerializeField] private float _scanInterval = 0.2f;

    private float _nextScanTime;

    private void Update()
    {
        if (Time.time < _nextScanTime) return;
        _nextScanTime = Time.time + _scanInterval;

        PerformScan();
    }

    private void PerformScan()
    {
        // Expensive detection logic runs 5× per second instead of 60+
    }
}

// Pre-allocated physics buffers
private readonly Collider[] _overlapResults = new Collider[32];
private readonly RaycastHit[] _raycastResults = new RaycastHit[16];

private void DetectNearby(Vector3 center, float radius, LayerMask mask)
{
    int count = Physics.OverlapSphereNonAlloc(center, radius, _overlapResults, mask);
    for (int i = 0; i < count; i++)
    {
        ProcessHit(_overlapResults[i]);
        _overlapResults[i] = null; // Clear reference to avoid keeping objects alive
    }
}

using Unity.Burst;
using Unity.Collections;
using Unity.Jobs;
using UnityEngine;

[BurstCompile]
public struct DistanceJob : IJobParallelFor
{
    [ReadOnly] public NativeArray<Vector3> Positions;
    public Vector3 Target;
    public NativeArray<float> Distances;

    public void Execute(int index)
    {
        Distances[index] = Vector3.Distance(Positions[index], Target);
    }
}

public class DistanceCalculator : MonoBehaviour
{
    public void CalculateDistances(Vector3[] positions, Vector3 target)
    {
        var positionsNative = new NativeArray<Vector3>(positions, Allocator.TempJob);
        var distances = new NativeArray<float>(positions.Length, Allocator.TempJob);

        var job = new DistanceJob
        {
            Positions = positionsNative,
            Target = target,
            Distances = distances
        };

        JobHandle handle = job.Schedule(positions.Length, 64);
        handle.Complete();

        // Read results from distances...

        positionsNative.Dispose();
        distances.Dispose();
    }
}

LOD Group Component Setup:
- LOD 0 (0%-50%):    Full-detail mesh (100% screen height threshold)
- LOD 1 (50%-25%):   Medium mesh (~50% triangles)
- LOD 2 (25%-10%):   Low mesh (~25% triangles)
- Culled (< 10%):    Not rendered at all

// Programmatic LOD adjustment for performance scaling
using UnityEngine;

public class QualityAdjuster : MonoBehaviour
{
    public void SetLODBias(float bias)
    {
        // Higher bias = higher quality LODs at greater distance
        // Lower bias = switch to lower LODs sooner
        QualitySettings.lodBias = bias; // Default is 2.0
    }
}

using UnityEngine;
using UnityEngine.AddressableAssets;
using UnityEngine.ResourceManagement.AsyncOperations;

public class AsyncLoader : MonoBehaviour
{
    [SerializeField] private AssetReference _prefabRef;
    private AsyncOperationHandle<GameObject> _handle;

    public async void LoadAndInstantiate(Vector3 position)
    {
        _handle = Addressables.InstantiateAsync(_prefabRef, position, Quaternion.identity);
        await _handle.Task;

        if (_handle.Status == AsyncOperationStatus.Succeeded)
            Debug.Log($"Loaded: {_handle.Result.name}");
    }

    public void Unload()
    {
        if (_handle.IsValid())
            Addressables.ReleaseInstance(_handle);
    }
}

using UnityEngine;
using UnityEngine.Pool;

public class BulletPool : MonoBehaviour
{
    [SerializeField] private Bullet _bulletPrefab;
    [SerializeField] private int _defaultCapacity = 20;
    [SerializeField] private int _maxSize = 100;

    private IObjectPool<Bullet> _pool;

    public IObjectPool<Bullet> Pool => _pool;

    private void Awake()
    {
        _pool = new ObjectPool<Bullet>(
            createFunc: () =>
            {
                var bullet = Instantiate(_bulletPrefab);
                bullet.SetPool(_pool);
                return bullet;
            },
            actionOnGet: bullet => bullet.gameObject.SetActive(true),
            actionOnRelease: bullet => bullet.gameObject.SetActive(false),
            actionOnDestroy: bullet => Destroy(bullet.gameObject),
            defaultCapacity: _defaultCapacity,
            maxSize: _maxSize
        );
    }

    public Bullet Get(Vector3 position, Quaternion rotation)
    {
        var bullet = _pool.Get();
        bullet.transform.SetPositionAndRotation(position, rotation);
        return bullet;
    }
}

public class Bullet : MonoBehaviour
{
    private IObjectPool<Bullet> _pool;
    [SerializeField] private float _lifetime = 3f;

    public void SetPool(IObjectPool<Bullet> pool) => _pool = pool;

    private void OnEnable()
    {
        CancelInvoke();
        Invoke(nameof(ReturnToPool), _lifetime);
    }

    private void ReturnToPool()
    {
        _pool.Release(this);
    }
}

// Disable auto-simulation for deterministic physics
// Physics.simulationMode = SimulationMode.Script;
// Then call Physics.Simulate(Time.fixedDeltaTime) manually.

// Disable AI for off-screen enemies
private void OnBecameInvisible() => enabled = false;
private void OnBecameVisible() => enabled = true;

using System.Collections.Generic;
using UnityEngine;

public class SpatialGrid<T>
{
    private readonly Dictionary<Vector2Int, List<T>> _cells = new();
    private readonly float _cellSize;

    public SpatialGrid(float cellSize) => _cellSize = cellSize;

    public Vector2Int GetCell(Vector3 position)
    {
        return new Vector2Int(
            Mathf.FloorToInt(position.x / _cellSize),
            Mathf.FloorToInt(position.z / _cellSize)
        );
    }

    public void Insert(Vector3 position, T item)
    {
        var cell = GetCell(position);
        if (!_cells.TryGetValue(cell, out var list))
        {
            list = new List<T>();
            _cells[cell] = list;
        }
        list.Add(item);
    }

    public void Clear() => _cells.Clear();

    public IEnumerable<T> GetNearby(Vector3 position, int radius = 1)
    {
        var center = GetCell(position);
        for (int x = -radius; x <= radius; x++)
        for (int y = -radius; y <= radius; y++)
        {
            var cell = new Vector2Int(center.x + x, center.y + y);
            if (_cells.TryGetValue(cell, out var list))
            {
                foreach (var item in list)
                    yield return item;
            }
        }
    }
}

using UnityEngine;

public class PerformanceMonitor : MonoBehaviour
{
    [SerializeField] private float _updateInterval = 0.5f;

    private float _accum;
    private int _frames;
    private float _fps;

    private void Update()
    {
        _accum += Time.unscaledDeltaTime;
        _frames++;

        if (_accum >= _updateInterval)
        {
            _fps = _frames / _accum;
            _accum = 0f;
            _frames = 0;

            if (_fps < 30f)
                Debug.LogWarning($"Low FPS: {_fps:F1}");
        }
    }

    // Expose for debug UI
    public float CurrentFPS => _fps;
    public float FrameTime => 1000f / Mathf.Max(_fps, 0.001f);
}