Unity Patterns

Patterns canoniques pour développer sur Unity 6 / 2023.x LTS en suivant les meilleures pratiques 2026.

1. Architecture — MonoBehaviour vs DOTS/ECS

Type de jeu
├── 1-100 entités (RPG, puzzle, plateformer, mobile casual)
│   └── MonoBehaviour classique + ScriptableObjects
├── 100-10k entités (RTS, simulation économique, action multi-units)
│   └── Hybrid : MonoBehaviour pour gameplay, Job System + Burst pour calculs lourds
├── 10k+ entités (battle royale, MMO instanciel, voxel, cellular automata)
│   └── DOTS / ECS (Entities, Components, Systems) full
└── XR / VR / AR
    └── XR Interaction Toolkit + URP, MonoBehaviour

Règle pratique : ne pas partir en DOTS par défaut. C'est puissant mais double la courbe d'apprentissage et casse beaucoup d'assets store. Justifié uniquement pour des cas où la perf MonoBehaviour est insuffisante.

2. ScriptableObjects (data-driven design)

// Items/ItemData.cs
using UnityEngine;

[CreateAssetMenu(fileName = "NewItem", menuName = "Game/Item Data")]
public class ItemData : ScriptableObject
{
    public string itemName;
    public Sprite icon;
    public int maxStack = 99;
    public ItemRarity rarity;
    public int basePrice;
    [TextArea(3, 10)] public string description;
}

// Inventory/Inventory.cs — utilise les ItemData comme références
public class Inventory : MonoBehaviour
{
    [SerializeField] private List<ItemSlot> slots = new();

    public bool TryAddItem(ItemData item, int quantity)
    {
        // logic
    }
}

[System.Serializable]
public class ItemSlot
{
    public ItemData item;
    public int quantity;
}

Avantages :

• Designers éditent dans l'inspecteur sans toucher au code
• Données partagées sans dupliquer (1 ItemData = N instances qui le référencent)
• Hot-reload : modifier en runtime visible immédiatement
• Versioning Git lisible (asset YAML)

3. Addressables (asset streaming)

// Async load
using UnityEngine.AddressableAssets;
using UnityEngine.ResourceManagement.AsyncOperations;

public async Task LoadLevelAsync(string levelKey)
{
    AsyncOperationHandle<GameObject> handle = Addressables.LoadAssetAsync<GameObject>(levelKey);
    await handle.Task;

    if (handle.Status == AsyncOperationStatus.Succeeded)
    {
        GameObject level = Instantiate(handle.Result);
        // ... use level ...

        // IMPORTANT: release when done
        Addressables.Release(handle);
    }
}

Bonnes pratiques :

• 1 group Addressable par "moment de chargement" (boot, hub, level X, DLC)
• Activer Build Remote Catalog pour CDN deployment
• Memory budget : surveiller Addressables.GetDownloadSizeAsync avant download
• Tester sur device cible (texture compression varie)
• Migration depuis Resources/ folder → Addressables (Resources/ load-all-at-startup, à éviter)

4. UI Toolkit (remplaçant uGUI)

<!-- MainMenu.uxml -->
<ui:UXML xmlns:ui="UnityEngine.UIElements">
  <ui:VisualElement class="root">
    <ui:Label text="My Game" class="title" />
    <ui:Button name="play-button" text="Play" class="primary-button" />
    <ui:Button name="settings-button" text="Settings" class="secondary-button" />
    <ui:Button name="quit-button" text="Quit" class="secondary-button" />
  </ui:VisualElement>
</ui:UXML>

/* MainMenu.uss */
.root {
    flex-grow: 1;
    align-items: center;
    justify-content: center;
    background-color: rgb(20, 20, 30);
}

.title {
    font-size: 64px;
    color: white;
    -unity-font-style: bold;
    margin-bottom: 40px;
}

.primary-button {
    width: 240px;
    height: 60px;
    background-color: rgb(0, 150, 200);
    color: white;
    margin-bottom: 12px;
    border-radius: 8px;
}

// MainMenuController.cs
using UnityEngine;
using UnityEngine.UIElements;

public class MainMenuController : MonoBehaviour
{
    [SerializeField] private UIDocument uiDocument;

    private void OnEnable()
    {
        var root = uiDocument.rootVisualElement;
        root.Q<Button>("play-button").clicked += OnPlay;
        root.Q<Button>("settings-button").clicked += OnSettings;
        root.Q<Button>("quit-button").clicked += Application.Quit;
    }

    private void OnPlay() => SceneManager.LoadScene("Level01");
    private void OnSettings() => { /* show settings */ };
}

Avantages UI Toolkit vs uGUI :

• CSS-like styling (USS) → réutilisable + responsive
• Performance bien meilleure pour UI complexe
• Editor UI partagé avec runtime UI (1 seule API)

5. Input System (Action Maps)

// PlayerInput.inputactions (généré via Inspector)
// → ActionMap "Gameplay" avec actions Move, Jump, Attack, Interact

using UnityEngine;
using UnityEngine.InputSystem;

[RequireComponent(typeof(PlayerInput))]
public class PlayerController : MonoBehaviour
{
    private Vector2 moveInput;

    public void OnMove(InputAction.CallbackContext ctx) => moveInput = ctx.ReadValue<Vector2>();
    public void OnJump(InputAction.CallbackContext ctx)
    {
        if (ctx.performed) Jump();
    }

    private void Update()
    {
        transform.position += new Vector3(moveInput.x, 0, moveInput.y) * speed * Time.deltaTime;
    }
}

Avantages :

• Cross-platform natif (clavier/manette/touch/VR)
• Action remapping runtime sans code custom
• Multi-joueur local (PlayerInputManager)

6. Job System + Burst (parallélisme CPU)

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

[BurstCompile]
public struct CalculatePositionsJob : IJobParallelFor
{
    [ReadOnly] public NativeArray<float3> velocities;
    public NativeArray<float3> positions;
    public float deltaTime;

    public void Execute(int index)
    {
        positions[index] += velocities[index] * deltaTime;
    }
}

// Schedule
var job = new CalculatePositionsJob {
    velocities = velocityArray,
    positions = positionArray,
    deltaTime = Time.deltaTime
};
JobHandle handle = job.Schedule(positionArray.Length, 64);
handle.Complete();

Cas d'usage : pathfinding mass, simulation physique custom, procedural generation, post-processing par pixel.

7. Performance — règles de base

• Profiler régulier (CPU, GPU, Memory, Rendering tabs)
• Static batching sur les meshes statiques
• GPU instancing sur les materials répétés
• Texture compression par plateforme (ASTC mobile, BC7 desktop)
• LOD groups sur les meshes éloignés
• Object pooling pour les bullets, particules, ennemis spawnés
• Pas d'allocations dans Update() (string concat, new List<>, foreach sur Dictionary)
• StringBuilder pour les concaténations
• OnTriggerEnter light — déléguer le travail lourd à Update sur frame suivante
• UpdateMode = ScriptOrder au lieu de chercher à chaque frame

8. Anti-patterns

1. Find() / GameObject.Find() dans Update — refs sérialisées dans l'inspecteur ou cache au Start
2. SendMessage() / Invoke() — préférer events C# typés ou UnityEvents
3. Singleton MonoBehaviour partout — pollution architecture, préférer DI ou GameObjects spawnés intentionnellement
4. Resources/ folder — préférer Addressables (Resources load-all-at-startup, fichu pour la mémoire)
5. gameObject.GetComponent<>() dans Update — cache au Start
6. Update() vide ou inutile — coût appel quand même
7. new Vector3() dans Update boucle — préférer une variable locale
8. OnGUI() en runtime — désuet, lent, casse les batches
9. Pas de scènes additives pour le menu/UI/loading — scènes monolithiques difficiles à maintenir
10. Mode Play sans Profiler une fois par jour — perf qui se dégrade silencieusement
11. Pas de .gitignore Unity correct — Library/, Temp/, obj/ committés = repo énorme
12. Build Standalone sans IL2CPP sur mobile/console — taille + perf moins bonnes que IL2CPP

Checklist livraison

• Unity LTS (6.0 ou 2023.x)
• Universal Render Pipeline ou HDRP choisi tôt
• Addressables au lieu de Resources/
• UI Toolkit au lieu de uGUI (ou justifier uGUI)
• Input System au lieu de Input legacy
• ScriptableObjects pour les data
• .gitignore Unity correct (pas de Library/)
• Tests Unity Test Framework
• Profiler pass régulier
• IL2CPP pour les builds release
• Texture compression par plateforme
• Build pipelines automatisés (Unity Cloud Build ou GitHub Actions)

Quand déléguer

• Multiplayer / netcode → skill game-multiplayer-patterns (ce plugin)
• Asset pipelines → skill game-asset-pipelines (ce plugin)
• Architecture → agent game-architect (ce plugin)
• Unity expert agent → agent unity-expert (ce plugin)
• Deploy mobile stores → skills deploy-app-store, deploy-play-store (atum-workflows)

Ressources

• https://docs.unity3d.com/Manual/index.html
• https://github.com/Unity-Technologies/EntityComponentSystemSamples
• https://learn.unity.com/
• https://github.com/Donchitos/Claude-Code-Game-Studios (inspiration MIT)