Tutoriel Unity complet : Débuter avec Unity et C# en créant un jeu Pong 3D

Bienvenue dans ce tutoriel Unity complet destiné aux débutants ! Vous allez apprendre à créer votre premier jeu avec Unity en développant une version 3D du classique Pong. Ce projet vous permettra de maîtriser les fondamentaux d'Unity et du langage C#.

Introduction à Unity : Le moteur de jeu incontournable

Pourquoi choisir Unity ?

Unity est un moteur de jeu très populaire qui permet de développer des jeux pour toutes les plateformes :

PC, Mac, Linux (plateformes desktop)
Consoles (PlayStation, Xbox, Nintendo Switch)
Mobile (Android, iOS)
Web (WebGL)
Réalité virtuelle (VR/AR)

L'avantage majeur d'Unity : vous développez votre projet une seule fois et vous pouvez l'exporter pour n'importe quelle plateforme. C'est un gain de temps considérable !

Unity : Un éditeur WYSIWYG

Unity est un éditeur WYSIWYG (What You See Is What You Get). Tout ce que vous créez dans Unity sera visible tel quel par le joueur final. Vous pouvez :

Tester vos niveaux à la volée
Voir le rendu final en temps réel
Itérer rapidement sur votre conception

Le langage C# dans Unity

La création de jeux avec Unity se divise en deux parties :

Unity Editor : conception des niveaux, paramétrage, assemblage
Visual Studio : développement en C#

Le C# est plus simple à apprendre que le C++ grâce à sa syntaxe moins lourde et plus moderne.

Objectif de ce tutoriel

Ce cours vous accompagne dans la prise en main d'Unity de façon progressive et simple. Nous allons créer un clone de Pong en 3D avec une caméra fixe, ce qui nous permettra d'apprendre :

L'interface Unity
La création d'objets 3D
La programmation C#
La physique de base
Les interactions utilisateur

> Important : Ce tutoriel vise la création de petits jeux indépendants. Pour développer des jeux AAA comme GTA ou Fortnite, il faut des équipes de centaines de développeurs et plusieurs années de développement !

Installation et configuration de l'environnement

Étape 1 : Téléchargement d'Unity Hub

Rendez-vous sur le site officiel unity.com et accédez à la section téléchargement. Unity Hub est un utilitaire qui vous permet de :

Télécharger Unity
Gérer différentes versions
Lancer vos projets avec la bonne version

Unity est gratuit tant que vous réalisez moins de 100 000 $ de chiffre d'affaires par an. Choisissez la version "Personal" gratuite.

Étape 2 : Installation d'Unity

Dans Unity Hub, cliquez sur le menu "Installs" puis sur "Install Editor". Choisir version Unity

Recommandation : Installez la version LTS (Long Term Support) la plus récente. Ces versions sont stables et bénéficient de mises à jour sur le long terme. > Évitez les versions alpha ou bêta pour vos vrais projets !

Étape 3 : Configuration de Visual Studio

Lors de l'installation, cochez Visual Studio Community pour le développement C#.

Ouvrez Visual Studio Installer et vérifiez que le "Développement de jeux avec Unity" est installé : Support Unity dans VS

Cette fonctionnalité est indispensable pour bénéficier de l'IntelliSense et des outils de débogage.

Étape 4 : Création du premier projet

Dans Unity Hub, cliquez sur "New project" :

Choisissez le template "3D"
Donnez un nom à votre projet
Sélectionnez un emplacement
Cliquez sur "Create project"

Découverte de l'interface Unity

Une fois Unity ouvert, vous découvrez une interface complète mais bien organisée :

Les zones principales

L'interface Unity est divisée en plusieurs zones redimensionnables :

Menu et barre d'outils (jaune) : Raccourcis pour manipuler les modèles 3D et tester le jeu

Hierarchy (rouge) : Liste de tous les éléments composant votre scène

Scene View (vert) : Espace de travail 3D pour concevoir vos niveaux

Game View : Vue du jeu tel que le verra le joueur

Inspector (bleu) : Propriétés de l'objet sélectionné

Project (violet) : Vos ressources (assets) et console d'erreurs

> Astuce : Toutes les zones peuvent être redimensionnées, déplacées ou masquées selon vos besoins !

Création du terrain de jeu

Passons maintenant à la pratique en créant notre terrain de Pong !

Étape 1 : Création du sol

Créons d'abord le sol de notre jeu. Dans le menu Unity : GameObject → 3D Object → Plane Création plan

Le plan apparaît dans la scène et ses propriétés s'affichent dans l'Inspector : Inspector du plan

Composants du plan

Si on analyse les propriétés, nous pouvons retrouver :

Transform : position, rotation et échelle de la forme 3D
Mesh Renderer : composant qui rend visible le modèle à l'écran
Mesh Collider : composant qui rend solide la forme (collisions)
Material : gère la couleur, texture, transparence, interaction avec la lumière

Étape 2 : Création d'un matériau coloré

Pour donner une couleur à notre sol, nous allons créer un Material. Dans la fenêtre Project, clic droit → Create → Material : Création matériau

Sélectionnez le matériau et modifiez sa couleur dans l'Inspector pour obtenir un bleu foncé : Couleur matériau

Glissez-déposez le matériau sur le plan dans la scène : Application matériau

Étape 3 : Redimensionnement du terrain

Sélectionnez le plan et modifiez ses propriétés dans l'Inspector :

Position : (0, 0, 0)
Scale : (2.5, 1, 3)

Étape 4 : Création des bordures

Créons maintenant les murs latéraux. Ajoutez un cube : GameObject → 3D Object → Cube Création cube

Configurez le premier cube :

Position : (-12, 0.5, 0)
Scale : (1, 1, 30)

Étape 5 : Duplication du mur

Avec le cube sélectionné, faites Ctrl + D pour le dupliquer. Maintenez Ctrl et utilisez la flèche rouge pour déplacer le second cube à la position (12, 0.5, 0) : Déplacement second cube

Étape 6 : Organisation avec les tags

Les tags permettent de classifier les objets pour les identifier facilement dans le code. Créons un tag "Side" pour nos murs. Sélectionnez un cube, puis dans l'Inspector, menu Tag → Add Tag : Création tag

Ajoutez le tag "Side" : Tag Side

Sélectionnez les deux cubes (Ctrl + clic) et appliquez-leur le tag "Side" : Application tag

N'oubliez pas de sauvegarder votre scène (Ctrl + S) : Sauvegarde scène

Création des barres de jeu

Ajout des raquettes

Créons maintenant les barres que le joueur contrôlera. Ajoutez un nouveau cube et configurez-le :

Position : (0, 0.5, -14)
Scale : (4, 1, 1)

Dupliquez cette barre (Ctrl + D) et placez-la à l'opposé :

Position : (0, 0.5, 14)

Configuration physique des barres

Sélectionnez les deux barres et ajoutez-leur un composant Rigidbody : Add Component → Physics → Rigidbody

Désactivez la gravité pour que les barres ne tombent pas : Désactiver gravité

Verrouillez les rotations et certains mouvements dans Constraints : Contraintes

Ajout de tags pour les barres

Créez un nouveau tag "Bar" et appliquez-le aux deux raquettes. Cela permettra au script de la balle de détecter les collisions avec les barres.

Scripts et programmation C#

Création du dossier Scripts

Organisez votre projet en créant un dossier Scripts dans la fenêtre Project : Dossier Scripts

Script de contrôle des barres

Créez un nouveau script C# : Clic droit → Create → C# Script Création script

Nommez-le "PongBar". Double-cliquez pour l'ouvrir dans Visual Studio :

Code de contrôle des barres

Voici le code pour contrôler les barres :

using UnityEngine;

public class PongBar : MonoBehaviour
{
    public float speed = 15f;
    public bool isHumanPlayer = true;
    
    void Update()
    {
        if (isHumanPlayer)
        {
            float horizontal = Input.GetAxis("Horizontal");
            transform.Translate(Vector3.right * horizontal * speed * Time.deltaTime);
        }
        else
        {
            float horizontal2 = Input.GetAxis("Horizontal2");
            transform.Translate(Vector3.right * horizontal2 * speed * Time.deltaTime);
        }
    }
}

Assignation du script

Glissez-déposez le script sur les deux barres dans la Hierarchy : Assignation script

Pour la barre de l'ordinateur, décochez isHumanPlayer dans l'Inspector.

Configuration de la caméra et tests

Positionnement de la caméra

Sélectionnez la Main Camera et configurez sa position :

Position : (0, 12, -22)
Rotation : (35, 0, 0)

Premier test

Cliquez sur le bouton Play pour tester votre jeu : Test jeu

Vous devriez pouvoir contrôler les barres avec les flèches directionnelles !

Création de la balle

Ajout de la balle

Créez une Sphere pour la balle : GameObject → 3D Object → Sphere Cube balle

Positionnez-la au centre : (0, 0.5, 0)

Physique de la balle

Ajoutez un Rigidbody à la balle et configurez-le : Rigidbody balle

Script de mouvement de la balle

Créez un script "PongBall" :

using UnityEngine;

public class PongBall : MonoBehaviour
{
    public float speed = 10f;
    public Vector3 direction;
    private float zMaxDistance = 15f;

    private void Start()
    {
        SetDirection();
    }

    void Update()
    {
        transform.Translate(direction * speed * Time.deltaTime);

        // IA gagne
        if (transform.position.z < -zMaxDistance && direction.z < 0)
        {
            SetDirection();
        }

        // Joueur gagne
        if (transform.position.z > zMaxDistance && direction.z > 0)
        {
            SetDirection();
        }
    }

    public void SetDirection()
    {
        transform.position = new Vector3(0, .5f, 0);
        direction = new Vector3(Random.Range(0.75f, 1.75f), 0, -1).normalized;
    }

    private void OnCollisionEnter(Collision collision)
    {
        if (collision.gameObject.tag == "Bar")
        {
            bool isPlayer = collision.gameObject.GetComponent<PongBar>().isHumanPlayer;
            if ((isPlayer && direction.z < 0) || (!isPlayer && direction.z > 0))
            {
                direction.z *= -1;
            }
        }

        if (collision.gameObject.tag == "Side")
        {
            direction.x *= -1;
        }
    }
}

Configurez la vitesse à 10 dans l'Inspector de la balle.

Intelligence artificielle pour l'adversaire

Script IA simple

Créez un script "PongAI" pour la barre adverse :

using UnityEngine;

public class PongAi : MonoBehaviour
{
    public Transform pongBall;
    public float latency = 4f;
    public float viewDistance = 20;
    public int nbShots = 0;

    void Update()
    {
        if (Vector3.Distance(transform.position, pongBall.position) < viewDistance)
        {
            transform.position = Vector3.MoveTowards(
                transform.position,
                new Vector3(pongBall.transform.position.x, .5f, 14),
                latency * Time.deltaTime
            );
        }
    }

    public void AddBounce()
    {
        nbShots++;
        if(nbShots >= 10)
        {
            nbShots = 0;
            latency -= 0.25f; 
        }
    }
}

Assignez la balle dans le champ Ball de l'IA et retirez le script PongBar de la barre de l'ordinateur.

Amélioration de l'IA avec la fatigue

Modifiez le script PongBall pour ajouter la gestion de la fatigue de l'IA :

private void OnCollisionEnter(Collision collision)
{
    if (collision.gameObject.tag == "Bar")
    {
        bool isPlayer = collision.gameObject.GetComponent<PongBar>().isHumanPlayer;
        if ((isPlayer && direction.z < 0) || (!isPlayer && direction.z > 0))
        {
            direction.z *= -1;
        }

        if(!isPlayer)
        {
            collision.gameObject.GetComponent<PongAi>().AddBounce();
        }
    }

    if (collision.gameObject.tag == "Side")
    {
        direction.x *= -1;
    }
}

L'IA deviendra de plus en plus lente au fil des rebonds, simulant la fatigue.

Interface utilisateur et score

Création du Canvas

Ajoutez un Canvas pour l'interface : GameObject → UI → Text Canvas

Cela créera automatiquement un Canvas et un texte. Configurez le Canvas en Screen Space - Overlay et Scale With Screen Size : Taille écran

Configuration du texte de score

Utilisez l'outil de manipulation UI dans la barre d'outils : Toolbar texte

Positionnez le texte en haut du Canvas et ajustez sa taille : Échelle texte

Configurez le style du texte : Style texte

Script de gestion du score

Modifiez le script PongBall pour gérer le score :

using UnityEngine;
using UnityEngine.UI;

public class PongBall : MonoBehaviour
{
    public float speed;
    public Vector3 direction;
    public Text scoreText;
    private float zMaxDistance = 15f;
    private int scorePlayer = 0;
    private int scoreComputer = 0;

    private void Start()
    {
        SetDirection();
    }

    void Update()
    {
        transform.Translate(direction * speed * Time.deltaTime);

        // IA gagne
        if (transform.position.z < -zMaxDistance && direction.z < 0)
        {
            scoreComputer++;
            SetDirection();
        }

        // Joueur gagne
        if (transform.position.z > zMaxDistance && direction.z > 0)
        {
            scorePlayer++;
            SetDirection();
        }
    }

    public void SetDirection()
    {
        scoreText.text = scorePlayer.ToString() + " - " + scoreComputer.ToString();
        transform.position = new Vector3(0, .5f, 0);
        direction = new Vector3(Random.Range(0.75f, 1.75f), 0, -1).normalized;
    }

    private void OnCollisionEnter(Collision collision)
    {
        if (collision.gameObject.tag == "Bar")
        {
            bool isPlayer = collision.gameObject.GetComponent<PongBar>().isHumanPlayer;
            if ((isPlayer && direction.z < 0) || (!isPlayer && direction.z > 0))
            {
                direction.z *= -1;
            }

            if(!isPlayer)
            {
                collision.gameObject.GetComponent<PongAi>().AddBounce();
            }
        }

        if (collision.gameObject.tag == "Side")
        {
            direction.x *= -1;
        }
    }
}

Assignez le texte à la variable scoreText dans l'Inspector de la balle.

Effets visuels et polissage

Amélioration de la caméra

Pour un meilleur rendu visuel, modifiez la couleur de fond de la caméra en noir : Fond caméra

Trail Renderer pour la balle

Ajoutez un Trail Renderer à la balle pour créer une traînée :

Sélectionnez la balle

Add Component → Effects → Trail Renderer

Configurez le Trail Renderer :

Width : 0.8 avec une courbe qui diminue
Time : 1
Material : Default Line

Post-processing

Installez le package Post Processing via le Package Manager :

Créez un layer "PostProcess" : Layer

Ajoutez les composants Post-process Layer et Post-process Volume à la caméra : Paramètres post

Configurez les effets visuels :
Effets

Description des effets disponibles

Ambient Occlusion : Ajoute des ombres autour des arêtes
Auto Exposure : Simule l'éblouissement des yeux
Bloom : Crée une lueur (effet glowing)
Chromatic Aberration : Effet de séparation des couleurs
Color Grading : Modifie les couleurs globales
Depth of Field : Effet de profondeur avec flou
Grain : Ajoute du grain comme sur les vieilles vidéos
Lens Distortion : Effet fish eye
Motion Blur : Flou de mouvement
Screen Space Reflection : Réflections dans l'eau
Vignette : Assombrit les contours

Ajoutez du Color Grading pour personnaliser l'ambiance :

Résultat final

Compilation et distribution

Build du jeu

Compilez votre jeu via File → Build Settings :

Cliquez sur "Add Open Scenes" pour ajouter votre scène

Cliquez sur "Build" pour lancer la compilation

Vous obtiendrez un exécutable de votre jeu avec ses dépendances : Exe final

Pour quitter le jeu, vous pouvez :

Faire Alt + F4 (Windows)
Ajouter un script avec Application.Quit() sur la touche Échap

Code source complet

PongBar.cs

using UnityEngine;

public class PongBar : MonoBehaviour
{
    public float speed = 15f;
    public bool isHumanPlayer = true;
    
    void Update()
    {
        if (isHumanPlayer)
        {
            float horizontal = Input.GetAxis("Horizontal");
            transform.Translate(Vector3.right * horizontal * speed * Time.deltaTime);
        }
        else
        {
            float horizontal2 = Input.GetAxis("Horizontal2");
            transform.Translate(Vector3.right * horizontal2 * speed * Time.deltaTime);
        }
    }
}

PongBall.cs

using UnityEngine;
using UnityEngine.UI;

public class PongBall : MonoBehaviour
{
    public float speed;
    public Vector3 direction;
    public Text scoreText;
    private float zMaxDistance = 15f;
    private int scorePlayer = 0;
    private int scoreComputer = 0;

    private void Start()
    {
        SetDirection();
    }

    void Update()
    {
        transform.Translate(direction * speed * Time.deltaTime);

        // IA gagne
        if (transform.position.z < -zMaxDistance && direction.z < 0)
        {
            scoreComputer++;
            SetDirection();
        }

        // Joueur gagne
        if (transform.position.z > zMaxDistance && direction.z > 0)
        {
            scorePlayer++;
            SetDirection();
        }
    }

    public void SetDirection()
    {
        scoreText.text = scorePlayer.ToString() + " - " + scoreComputer.ToString();
        transform.position = new Vector3(0, .5f, 0);
        direction = new Vector3(Random.Range(0.75f, 1.75f), 0, -1).normalized;
    }

    private void OnCollisionEnter(Collision collision)
    {
        if (collision.gameObject.tag == "Bar")
        {
            bool isPlayer = collision.gameObject.GetComponent<PongBar>().isHumanPlayer;
            if ((isPlayer && direction.z < 0) || (!isPlayer && direction.z > 0))
            {
                direction.z *= -1;
            }

            if(!isPlayer)
            {
                collision.gameObject.GetComponent<PongAi>().AddBounce();
            }
        }

        if (collision.gameObject.tag == "Side")
        {
            direction.x *= -1;
        }
    }
}

PongAi.cs

using UnityEngine;

public class PongAi : MonoBehaviour
{
    public Transform pongBall;
    public float latency = 4f;
    public float viewDistance = 20;
    public int nbShots = 0;

    void Update()
    {
        if (Vector3.Distance(transform.position, pongBall.position) < viewDistance)
        {
            transform.position = Vector3.MoveTowards(
                transform.position,
                new Vector3(pongBall.transform.position.x, .5f, 14),
                latency * Time.deltaTime
            );
        }
    }

    public void AddBounce()
    {
        nbShots++;
        if(nbShots >= 10)
        {
            nbShots = 0;
            latency -= 0.25f; 
        }
    }
}

Conclusion

Félicitations ! Vous venez de créer votre premier jeu complet avec Unity. Ce tutoriel vous a permis d'apprendre :

Compétences acquises

Installation et configuration d'Unity et Visual Studio
Interface Unity et navigation dans l'éditeur
Création d'objets 3D et manipulation des transforms
Système de matériaux et personnalisation visuelle
Programmation C# et scripts de gameplay
Physique Unity avec Rigidbody et collisions
Intelligence artificielle avec système de fatigue
Interface utilisateur avec Canvas et score
Effets visuels et post-processing
Compilation et distribution

Exercices d'amélioration

Pour continuer votre apprentissage, essayez d'ajouter :

Menu de démarrage avec boutons Start/Quit
Sons et musique de fond
Power-ups temporaires (vitesse, taille des barres)
Niveaux de difficulté progressifs
Contrôles tactiles pour mobile
Particules lors des collisions
Animation des barres et de la balle

Ressources pour continuer

Ce projet Pong 3D constitue une excellente base pour vous lancer sur des projets plus ambitieux. L'important est de pratiquer régulièrement et d'expérimenter avec les différentes fonctionnalités d'Unity.

Télécharger la version complète de ce tutoriel au format PDF

Version PDF de 74 pages

Bon développement et amusez-vous bien avec Unity ! 🎮