Course · 36 lessons

Unity6 Game Development

Real Unity6 Editor scripts, detailed scene setup and separate runnable C# companion labs.

  1. Create a Unity6 script and attach it

    Separate a Unity component script from its portable C# practice.

    Editor foundations · 25 min
  2. GameObjects, components and explicit dependencies

    Acquire a required component once and validate references deliberately.

    Editor foundations · 25 min
  3. Lifecycle: once initialization and repeated activation

    Observe Awake, OnEnable, Start and OnDisable without assuming cross-object order.

    Editor foundations · 25 min
  4. Update, FixedUpdate, LateUpdate and elapsed time

    Choose a loop for the responsibility and integrate rates with the appropriate step.

    Editor foundations · 25 min
  5. Transform local and world coordinates

    Read a child pose relative to its parent and in scene space.

    Editor foundations · 25 min
  6. Rigidbody forces belong to the physics step

    Use AddForce with an explicit ForceMode instead of moving a dynamic body through Transform.

    Editor foundations · 25 min
  7. Collisions, triggers and layer filtering

    Configure a physical interaction before expecting the callback to run.

    Editor foundations · 25 min
  8. Input System actions and their owned lifetime

    Install the Input System package and enable only the action this component owns.

    Editor foundations · 25 min
  9. Serialized fields and runtime state

    Treat Inspector data as stored configuration, not as a live source initializer.

    Gameplay systems · 25 min
  10. Prefabs, instantiation and spawned ownership

    Create runtime instances while keeping template and instance state separate.

    Gameplay systems · 25 min
  11. ScriptableObject configuration and per-instance ownership

    Share authored configuration without sharing every enemy’s mutable health.

    Gameplay systems · 25 min
  12. Events and activation-scoped subscriptions

    Pair subscription with unsubscription using the same handler identity.

    Gameplay systems · 25 min
  13. Coroutines, yields and explicit stopping

    Use Unity’s coroutine scheduler without pretending it is a background thread.

    Gameplay systems · 25 min
  14. Unity Awaitable and destroy-scoped cancellation

    Cache the destroy token while alive and handle cancellation at the async callback boundary.

    Gameplay systems · 25 min
  15. Destroyed Unity objects and managed wrappers

    Distinguish Unity’s overloaded null comparison from ordinary CLR reference null.

    Gameplay systems · 25 min
  16. Scenes, build profiles and asynchronous loading

    Declare the destination in the build scene list and own the loader’s lifetime.

    Gameplay systems · 25 min
  17. uGUI buttons, labels and listener lifetime

    Install Unity UI and configure the EventSystem for the project’s input backend.

    Production practice · 25 min
  18. Pooling and reset-before-activation

    Reuse objects while treating every enable as a new activation lifetime.

    Production practice · 25 min
  19. Profile allocations in the intended Player

    Compare controlled work with GC.Alloc evidence instead of trusting Editor impressions.

    Production practice · 25 min
  20. Unity garbage collection is not CoreCLR generations

    Understand Unity’s collector and measure allocation policy on the actual backend.

    Production practice · 25 min
  21. Save DTOs without serializing scene references

    Version plain data and use a supported persistent path for the actual target.

    Production practice · 25 min
  22. Domain reload and explicit static reset

    Make a Play-session boundary clear when Editor reload settings change.

    Production practice · 25 min
  23. A testable health model behind a Unity shell

    Keep gameplay rules independent from engine callbacks and presentation.

    Production practice · 25 min
  24. Capstone: a tested collect-and-time gameplay loop

    Connect input, physics, trigger identity and terminal rules without hiding the engine boundary.

    Production practice · 25 min
  25. Raycasts, masks and an explicit trigger policy

    Ask a 3D physics query with a finite range and deliberate filtering.

    Interaction and production boundaries · 30 min
  26. Quaternion turning and local forward axes

    Turn toward a local orientation without interpolating Euler components.

    Interaction and production boundaries · 30 min
  27. A follow camera after movement

    Observe an updated target in LateUpdate and keep smoothing state owned.

    Interaction and production boundaries · 30 min
  28. Physics2D triggers and compound actors

    Configure the separate 2D world and count an actor once.

    Interaction and production boundaries · 30 min
  29. Animator parameters are not transition graphs

    Drive a declared Boolean while keeping controller and clip assumptions explicit.

    Interaction and production boundaries · 30 min
  30. One-shot audio and the owner that must survive

    Play a cue without replacing current voices or destroying its audio owner.

    Interaction and production boundaries · 30 min
  31. Cache a specific child component

    Resolve a known hierarchy dependency and decide when a cached reference expires.

    Composition and navigation · 30 min
  32. Assembly definitions and project dependency boundaries

    Put a real MonoBehaviour in an explicitly configured runtime assembly.

    Composition and navigation · 30 min
  33. Resources paths and shared asset lifetime

    Load a known TextAsset without confusing an asset key with a disk path.

    Composition and navigation · 30 min
  34. UI Toolkit runtime controls and document lifetime

    Bind named UXML controls from a UIDocument and release listeners on disable.

    Composition and navigation · 30 min
  35. NavMeshAgent requests, pending paths and arrival

    Observe navigation states only after a compatible NavMesh is prepared.

    Composition and navigation · 30 min
  36. Capstone: a focused, keyed interaction

    Combine input ownership, ray selection and a one-way gameplay state.

    Composition and navigation · 30 min