🎮 Unity – Moteur de Jeu, C# & Développement Multiplateforme

Le Unity Hub est l'utilitaire de gestion (obligatoire) pour installer et gérer les versions de l'Éditeur Unity et vos projets.

Fonctionnalités Clés

• Gestion des Installations (Versions) :
  • Permet d'installer plusieurs versions de l'Éditeur Unity côte à côte (ex: 2021.3, 2022.3, 2023.1).
  • LTS (Long-Term Support) : (ex: 2022.3.x LTS) Version recommandée pour la production (stable, supportée 2 ans).
  • Tech Stream : (ex: 2023.1.x) Version "Beta", inclut les nouvelles fonctionnalités (instable).
• Gestion des Modules : Permet d'ajouter des modules (cibles de build) à une installation (ex: "Android Build Support", "iOS Build Support", "WebGL").
• Gestion des Projets :
  • Liste tous vos projets.
  • Permet de "binder" (lier) un projet à une version spécifique de l'Éditeur.
  • Création de nouveaux projets (Templates : 2D, 3D URP, 3D HDRP...).

L'Éditeur Unity est l'interface (GUI) principale. Il est composé de plusieurs fenêtres (Views) modulables.

Le GameObject est l'entité fondamentale dans Unity. C'est la "chose" (Thing) de base.

Analogie : Un GameObject est un conteneur vide, ou une "coquille".

Par lui-même, un GameObject (créé via Create Empty) ne fait rien. Il n'a ni apparence, ni comportement. Il n'a qu'un nom et un Transform (2.3).

Tout ce qui existe dans votre Scène (le Joueur, l'Ennemi, la Caméra, la Lumière, le Sol, le Manager de Score) est un GameObject.

Philosophie (Composition over Inheritance)

C'est la philosophie centrale d'Unity. Un GameObject (la "coquille" vide) obtient ses fonctionnalités en y attachant des Composants (Components).

Un Component est une "brique" de fonctionnalité (un script C#).

Exemple (Créer un "Joueur")

1. Créer un GameObject vide (Create Empty). Renommer en "Joueur".
2. (Apparence) Ajouter un Mesh Renderer (Component) -> (Pour le Rendu 3D).
3. (Apparence) Ajouter un Mesh Filter (Component) -> (Pour la Forme 3D, ex: Capsule).
4. (Physique) Ajouter un Rigidbody (Component) -> (Pour la Gravité, les forces).
5. (Physique) Ajouter un Capsule Collider (Component) -> (Pour les collisions).
6. (Logique) Ajouter un PlayerController.cs (Script C#) (Component) -> (Pour le Mouvement, les PV).

Le GameObject "Joueur" n'est que la somme de ses composants.

Accès (C#)

public class PlayerController : MonoBehaviour
{
    private Rigidbody rb;

    void Start()
    {
        // Récupérer un autre composant sur le MÊME GameObject
        rb = GetComponent<Rigidbody>();
    }
    
    // (Ajouter un nouveau composant via le code)
    // AudioSource audio = AddComponent<AudioSource>();
}

Le Transform est le seul composant obligatoire sur chaque GameObject. Il ne peut pas être supprimé.

Il définit la "place" du GameObject dans l'espace (la Scène).

Propriétés (Vecteur 3D)

• Position : (Où il est) Coordonnées (X, Y, Z) par rapport au "monde" (World Space) ou au Parent.
• Rotation : (Où il regarde) Angles d'Euler (X, Y, Z) (stocké en Quaternion).
• Scale (Échelle) : (Sa taille/proportion) (X, Y, Z). (Défaut : 1, 1, 1).

Hiérarchie (Parent/Enfant)

Le Transform gère la hiérarchie (vue dans la fenêtre "Hierarchy").

Si vous glissez "Main (Caméra)" sur "Joueur" (dans Hierarchy), "Joueur" devient le Parent.

Résultat : La Position/Rotation de la Caméra devient relative à celle du Joueur. (Si le Joueur bouge, la caméra suit -> Caméra 3e personne).

Accès (C#)

// 'transform' (en minuscule) est un raccourci direct
// (Pas besoin de GetComponent())

// Déplacer l'objet (ex: dans Update())
// (Vector3.forward = (0, 0, 1))
transform.Translate(Vector3.forward * vitesse * Time.deltaTime);

// Changer la position
transform.position = new Vector3(0, 10, 0);

// Rotation
transform.Rotate(0, 90, 0);

Pour qu'un script C# puisse être attaché (Add Component) à un GameObject, il doit hériter (:) de la classe MonoBehaviour.

MonoBehaviour est la classe de base qui "connecte" votre script au moteur de jeu Unity (lui donnant accès au cycle de vie (Update), aux Coroutines, et aux GetComponent).

Variables Publiques (L'Inspecteur)

Si vous déclarez une variable (champ) comme public dans un script MonoBehaviour, elle apparaît automatiquement dans l'Inspecteur (Panneau droit) de l'Éditeur.

C'est la méthode n°1 pour paramétrer un script (sans "hardcoder").

// Fichier : PlayerMovement.cs
using UnityEngine;

public class PlayerMovement : MonoBehaviour
{
    // Apparaît dans l'Inspecteur
    public float moveSpeed = 10.0f;
    
    // (Serialisé) Apparaît aussi (bonne pratique)
    [SerializeField]
    private float jumpForce = 300.0f;
    
    // (Privé) N'apparaît pas
    private Rigidbody rb;
    
    void Start()
    {
        rb = GetComponent<Rigidbody>();
    }

    void Update()
    {
        // Le Game Designer peut changer 'moveSpeed'
        // dans l'Inspecteur (à 15.0) sans toucher au code.
        float h = Input.GetAxis("Horizontal");
        transform.Translate(h * moveSpeed * Time.deltaTime, 0, 0);
    }
}

MonoBehaviour utilise des "fonctions magiques" (événements) qui sont appelées automatiquement par le moteur dans un ordre précis.

Ordre d'Exécution (1 Frame) :
1. (Physique) ...
2. (Physique) FixedUpdate()
3. (Physique) ...
4. (Jeu) Update()
5. (Jeu) LateUpdate()
6. (Rendu) Rendu de la Scène

Le Rigidbody (ou Rigidbody2D) est le composant clé pour la simulation physique. C'est ce qui "donne vie" à un objet.

Fonction : Il dit au moteur physique (NVIDIA PhysX pour 3D, Box2D pour 2D) de prendre le contrôle du Transform de cet objet.

Propriétés Clés (Inspecteur)

• Mass (Masse) : (ex: 1 kg).
• Drag (Friction) : Friction de l'air.
• Angular Drag : Friction de rotation.
• Use Gravity (Utiliser Gravité) : (Coché par défaut) Fait tomber l'objet.
• Is Kinematic (Cinématique) :
  • (Décoché - Défaut) : Mode "Dynamique". L'objet est contrôlé par la physique (Forces, Collisions). (Ex: Caisse, Balle de ragdoll).
  • (Coché) : Mode "Statique/Contrôlé". L'objet est contrôlé par le script (transform.Translate), mais il *peut* affecter les objets dynamiques (ex: une plateforme mobile).

Scripting (C#)

Règle d'Or : Si un objet a un Rigidbody (Dynamique), ne JAMAIS le déplacer avec transform.Translate() (casse la simulation). Toujours utiliser FixedUpdate() et les forces.

public Rigidbody rb;
void Start() { rb = GetComponent<Rigidbody>(); }

// (Appelé 50x/sec, lié à la physique)
void FixedUpdate()
{
    // (Pour un mouvement continu, type FPS)
    rb.velocity = new Vector3(Input.GetAxis("Horizontal"), rb.velocity.y, Input.GetAxis("Vertical"));
    
    // (Pour un impact, type explosion)
    rb.AddForce(Vector3.up * 500);
}

Les Colliders (Collisionneurs) sont des composants qui définissent la forme physique (Hitbox) d'un objet, pour la simulation de physique et de collisions.

Ils sont (normalement) invisibles, mais n'ont pas besoin de correspondre au "Mesh" (le visuel).

Types de Colliders

• Primitifs (Rapides) : Box Collider, Sphere Collider, Capsule Collider. (Très performants, à utiliser 99% du temps).
• Mesh Collider (Complexe) : (Lent) Utilise le "maillage" (mesh) 3D exact de l'objet.
  • (Statique) : OK pour le sol/décor (ex: un rocher complexe).
  • (Dynamique) : (Avec Rigidbody) -> Très coûteux en performance.

Collisions (Physiques)

Pour qu'une collision (blocage) se produise, au moins un des deux objets doit avoir un Rigidbody (Dynamique).

Le script (MonoBehaviour) sur l'objet reçoit un événement :

// (Appelé 1 fois, au moment de l'impact)
void OnCollisionEnter(Collision collisionInfo)
{
    // collisionInfo.gameObject = L'autre objet (ex: la Balle)
    Debug.Log("Touché par : " + collisionInfo.gameObject.name);
}

Un Trigger est un Collider (ex: Box Collider) dont l'option Is Trigger est cochée.

Fonctionnement : Il désactive la physique (collisions). Au lieu de "bloquer" les objets, il les laisse passer, mais il détecte quand un autre Rigidbody entre ou sort de sa zone.

Usage : Zones de détection (ex: "Zone de Checkpoint", "Zone de Dégâts (Lave)", "Zone d'ouverture de porte").

Scripting (C#)

Le script (MonoBehaviour) sur l'objet reçoit des événements (other est le Collider qui est entré) :

// (Appelé quand un Rigidbody ENTRE dans la zone)
void OnTriggerEnter(Collider other)
{
    // (Ex: Vérifier si c'est le joueur)
    if (other.CompareTag("Player"))
    {
        Debug.Log("Le Joueur est entré dans le Checkpoint !");
        // (Logique : Sauvegarder la position)
    }
}

// (Appelé quand un Rigidbody SORT de la zone)
void OnTriggerExit(Collider other)
{
    if (other.CompareTag("Player"))
    {
        Debug.Log("Le Joueur a quitté la zone.");
    }
}

// (Appelé à chaque frame où le Rigidbody RESTE dans la zone)
void OnTriggerStay(Collider other)
{
    // (Ex: Appliquer des dégâts de lave)
}

Le système "Unity UI" (UGUI) est basé sur le concept de Canvas.

Problème : Vous avez 100 types d'épées. Si vous stockez les stats (Dégâts=10, Prix=50) dans le script MonoBehaviour (dans le Prefab), c'est difficile à gérer et à équilibrer.

Solution : ScriptableObject (SO)

Un ScriptableObject est une classe C# (qui hérite de ScriptableObject) conçue uniquement pour stocker des données (Data). Ce n'est pas un Component (on ne peut pas l'attacher à un GameObject). C'est un Asset (comme une Texture ou un Prefab).

Exemple de Workflow

// 1. Le "Plan" de la donnée (C#)
// (Crée un menu "Créer -> Stats -> Arme")
[CreateAssetMenu(fileName = "NewWeapon", menuName = "Stats/Arme")]
public class WeaponStats : ScriptableObject
{
    public string weaponName;
    public int damage;
    public float attackSpeed;
    public GameObject weaponPrefab;
}

// 2. L'Asset (Donnée)
// (Dans l'Éditeur, Clic Droit -> Créer -> Stats -> Arme)
// (Crée "EpeeEnBois.asset")
// (Dans l'Inspecteur) :
//   Name: "Épée en Bois"
//   Damage: 5
//   AttackSpeed: 1.2

// 3. Le Script (MonoBehaviour)
public class PlayerAttack : MonoBehaviour
{
    // Glisser "EpeeEnBois.asset" ici dans l'Inspecteur
    public WeaponStats currentWeapon;
    
    void Attack() {
        int dmg = currentWeapon.damage;
        // ...
    }
}

Avantage : Sépare la Logique (MonoBehaviour) des Données (ScriptableObject). Très facile à gérer pour les Game Designers.

Le Unity Package Manager (UPM) est le gestionnaire de "paquets" (modules) intégré à Unity (similaire à npm ou Composer).

Il gère l'installation, la mise à jour et les dépendances des fonctionnalités "cœur" d'Unity et des outils tiers.

manifest.json

La configuration du UPM est stockée dans Packages/manifest.json (le package.json d'Unity).

Packages Courants (gérés par UPM)

• Input System : Le nouveau système d'entrées.
• TextMeshPro : (Maintenant obligatoire).
• URP / HDRP : Les pipelines de rendu.
• Cinemachine : Système de caméras (cinématiques, suivi).
• Visual Scripting : (Équivalent des Blueprints Unreal).
• Post-Processing : (Effets (Bloom, Vignette...)).

C'est la force majeure d'Unity. La fenêtre File > Build Settings est le hub de compilation multiplateforme.

Processus de Build

1. Choisir la Scène : Ajouter les scènes à inclure dans le build.
2. Choisir la Plateforme (Target) : (ex: "Windows, Mac, Linux" ou "Android" ou "WebGL").
3. (Switcher) : Cliquer sur "Switch Platform". (Unity ré-importe tous les assets (textures, audio) pour les optimiser pour cette plateforme).
4. Player Settings : Configurer les icônes, le nom de l'entreprise, les permissions (Android), la résolution...
5. Build : Cliquer "Build" (Crée l'exécutable .exe) ou "Build and Run".

Cibles (Targets) Courantes

• PC (Windows, macOS, Linux)
• WebGL (HTML5, WASM)
• iOS (Génère un projet Xcode)
• Android (Génère un .apk ou .aab)
• Consoles (PlayStation, Xbox, Switch) (Nécessite une licence/approbation)

L'Asset Store est la marketplace (marché) d'Unity. C'est l'un des plus grands avantages de l'écosystème (surtout pour les indépendants et les petites équipes).

Il permet d'acheter ou de télécharger (gratuitement) des "Assets" (ressources) pré-faits pour accélérer le développement :

• Modèles 3D (Personnages, Décors, Véhicules)
• Textures & Materials
• Audio (Musique, Effets sonores)
• Outils d'Éditeur (Extensions de l'IDE)
• Scripts (Systèmes d'IA, Inventaires, Sauvegardes...)

DOTS (Data-Oriented Technology Stack) est une ré-écriture (optionnelle) du cœur d'Unity, conçue pour la haute performance (ex: jeux de stratégie avec 100 000 unités).

Ce n'est pas la philosophie GameObject/Component (POO). C'est une philosophie DOD (Data-Oriented Design).

Composants de DOTS

• ECS (Entity Component System) :
  • Entity : Un simple ID (un int).
  • Component (Data) : Uniquement des données (structs). (ex: Position, Vitesse).
  • System : Uniquement de la logique (le code). (ex: MouvementSystem qui prend toutes les Position et Vitesse et les met à jour).
• C# Job System : Permet d'exécuter du code C# en parallèle (multi-thread) de manière sécurisée (évite les "race conditions").
• Burst Compiler : Un compilateur qui traduit le C# (optimisé) en code machine (assembleur) ultra-performant.

Le choix du moteur est la première décision d'un studio.

Ordre d'exécution des fonctions "magiques" principales.

// --- 1. INITIALISATION (1 FOIS) ---

void Awake()
{
    // (Appelé 1er)
    // (Utiliser pour initialiser cet objet, ex: GetComponent())
}

void Start()
{
    // (Appelé 2e, juste avant le 1er Update)
    // (Utiliser pour communiquer avec d'autres objets)
}

// --- 2. PHYSIQUE (MULTIPLE FOIS / FRAME) ---

void FixedUpdate()
{
    // (Appelé à intervalle fixe : 50x/sec par défaut)
    // (Utiliser pour TOUTE la logique de Rigidbody : AddForce, velocity)
}
// (Exécution de la physique)
// (Appels OnCollisionEnter, OnTriggerEnter...)

// --- 3. LOGIQUE DE JEU (1 FOIS / FRAME) ---

void Update()
{
    // (Appelé à chaque frame)
    // (Utiliser pour Input, Logique de jeu, Mouvement non-physique)
}

void LateUpdate()
{
    // (Appelé après tous les Update())
    // (Utiliser pour les caméras "Follow")
}

// --- 4. RENDU ---
// (Rendu de la scène)
// (OnGUI - Legacy)