Animations/ ScriptableObjects/ Editor/ # Editor-only scripts Plugins/ # Third-party plugins Packages/ ProjectSettings/


## MonoBehaviour Lifecycle

Order of execution matters. Use the correct callback:

```csharp
public class GameEntity : MonoBehaviour
{
    // Called once when the script instance is loaded
    void Awake()
    {
        // Initialize self-references (GetComponent, etc.)
        // Do NOT reference other objects here - they may not be ready
    }

    // Called once before the first Update, after all Awake calls
    void Start()
    {
        // Safe to reference other objects
        // Initialize state that depends on other components
    }

    // Called every frame
    void Update()
    {
        // Input handling, non-physics movement
        // Use Time.deltaTime for frame-rate independence
    }

    // Called at fixed intervals (default 0.02s)
    void FixedUpdate()
    {
        // Physics-related code (Rigidbody movement, forces)
    }

    // Called after all Update calls
    void LateUpdate()
    {
        // Camera follow, UI updates that depend on game state
    }

    // Called when the object is destroyed
    void OnDestroy()
    {
        // Unsubscribe events, clean up resources
    }

    void OnEnable() { /* Subscribe to events */ }
    void OnDisable() { /* Unsubscribe from events */ }
}

ScriptableObjects (Data-Driven Design)

Use ScriptableObjects for game data, configuration, and shared state:

[CreateAssetMenu(fileName = "NewWeapon", menuName = "Game/Weapon Data")]
public class WeaponData : ScriptableObject
{
    public string weaponName;
    public int damage;
    public float attackSpeed;
    public float range;
    public GameObject projectilePrefab;
    public AudioClip attackSound;
}

Usage in components:

public class WeaponController : MonoBehaviour
{
    [SerializeField] private WeaponData weaponData;

    public void Attack()
    {
        // Use weaponData.damage, weaponData.attackSpeed, etc.
    }
}

Object Pooling

public class ObjectPool<T> where T : MonoBehaviour
{
    private readonly Queue<T> pool = new();
    private readonly T prefab;
    private readonly Transform parent;

    public ObjectPool(T prefab, int initialSize, Transform parent = null)
    {
        this.prefab = prefab;
        this.parent = parent;
        for (int i = 0; i < initialSize; i++)
            pool.Enqueue(CreateInstance());
    }

    public T Get()
    {
        var obj = pool.Count > 0 ? pool.Dequeue() : CreateInstance();
        obj.gameObject.SetActive(true);
        return obj;
    }

    public void Return(T obj)
    {
        obj.gameObject.SetActive(false);
        pool.Enqueue(obj);
    }

    private T CreateInstance()
    {
        var obj = Object.Instantiate(prefab, parent);
        obj.gameObject.SetActive(false);
        return obj;
    }
}

Event System

// ScriptableObject-based event channel
[CreateAssetMenu(menuName = "Events/Game Event")]
public class GameEvent : ScriptableObject
{
    private readonly List<System.Action> listeners = new();

    public void Raise() => listeners.ForEach(l => l.Invoke());
    public void Register(System.Action listener) => listeners.Add(listener);
    public void Unregister(System.Action listener) => listeners.Remove(listener);
}

Key Rules

Never use Find/FindObjectOfType in Update - Cache references in Awake/Start
Use [SerializeField] over public fields - Encapsulation with inspector access
Use CompareTag() instead of == for tag comparison - Avoids GC allocation
Avoid string-based methods - Prefer direct references over SendMessage/Invoke
Use async/await or coroutines for async operations - Never block the main thread
Dispose resources in OnDestroy - Unsubscribe events, stop coroutines, release resources
Use Assembly Definitions (.asmdef) - Improve compile times in large projects
Use TextMeshPro over legacy UI Text - Better performance and rendering
Pool objects instead of Instantiate/Destroy - Reduce GC pressure
Use Addressables for asset loading - Better memory management than Resources.Load

Common Anti-Patterns

GetComponent<T>() every frame - cache it
new List<T>() in Update - allocates every frame
string + string in hot paths - use StringBuilder
Camera.main repeated calls - cache the reference
Coroutines that never stop - always stop on disable/destroy

DOTS/ECS (Performance-Critical Systems)

For systems needing maximum performance, consider Unity's Data-Oriented Technology Stack:

Use IComponentData for pure data components
Use ISystem or SystemBase for processing logic
Leverage Burst compiler for SIMD optimization
Use NativeContainers for thread-safe collections
Only use DOTS where performance demands it - MonoBehaviour is fine for most gameplay

unity

Unity Development Skill

Engine Detection

Project Structure

More from davincidreams/agent-team-plugins

blender

rigging

animation

vroid

technical-writing

unreal