Débuter sur Unity : créez votre premier petit jeu 2D étape par étape

Pour débuter sur Unity avec un jeu 2D, installez Unity Hub et une version LTS du moteur, créez un projet en deux dimensions, puis construisez un prototype très court : déplacer un personnage, ramasser des objets et atteindre une sortie. Ce premier jeu n’exige pas un univers complet, mais il demande les bases de l’éditeur et quelques scripts C#.

Unity est un moteur de jeu qui réunit une scène, des objets, des graphismes, de la physique et du code dans un même projet. Ce tutoriel Unity débutant suit un objectif volontairement limité : créer un jeu de collecte en vue 2D, jouable sur ordinateur, afin de comprendre une boucle de gameplay complète avant d’ajouter des animations, des niveaux ou des effets plus ambitieux.

Comprendre Unity avant de créer son jeu

Unity organise un jeu autour d’une scène Unity, qui contient les objets visibles, leurs composants et leurs comportements. Un Sprite Renderer affiche une image 2D, un Collider 2D définit une zone de contact, un Rigidbody 2D gère la physique, tandis qu’un script C# ajoute les règles de votre jeu.

Pour ce premier projet Unity 2D, le résultat attendu est simple : le joueur se déplace avec le clavier, récupère des jetons et gagne lorsque tous les jetons ont disparu. Cette boucle permet d’apprendre les éléments qui se retrouvent dans de nombreux jeux de plateforme 2D, jeux d’exploration ou petits puzzles : entrée joueur, déplacement, collisions, état et interface.

Élément Unity	Usage dans ce prototype	Limite à connaître
Scene	Contient le niveau, le joueur et les objets à collecter.	Une scène mal rangée ralentit vite les corrections.
Sprite Renderer	Affiche le personnage, le décor et les jetons.	Il ne crée ni collision ni mouvement à lui seul.
Collider 2D	Détecte les murs, les objets et les zones de sortie.	Il doit correspondre à la forme utile du sprite.
Rigidbody 2D	Permet au personnage de réagir au système physique 2D.	Une mauvaise configuration peut provoquer glissements ou traversées.
Script C#	Transforme les entrées clavier et collisions en règles de jeu.	Le nom du fichier et celui de la classe doivent correspondre.

Un premier prototype n’a pas besoin d’être beau : il doit rendre une action lisible, une règle vérifiable et une fin possible.

Quels prérequis faut-il préparer avant de débuter sur Unity ?

Pour créer un jeu 2D avec Unity, prévoyez un ordinateur compatible avec l’éditeur, une connexion pour l’installation, Unity Hub, un projet 2D et des images temporaires pour le joueur, le décor et les objets. Unity recommande généralement de commencer avec la dernière version LTS disponible : vérifiez la version proposée dans Unity Hub avant de créer le projet.

Le niveau attendu n’est pas celui d’un programmeur confirmé. Vous devez toutefois accepter de lire et modifier de petites lignes de C#, car le déplacement personnage Unity et les interactions ne se règlent pas durablement avec des clics seuls. Réservez plusieurs séances courtes : le bon repère n’est pas une durée fixe, mais un prototype qui fonctionne du lancement à la victoire.

• Unity Hub installé pour gérer l’éditeur et les projets.
• Une version LTS d’Unity choisie dans Hub, avec le module de compilation de votre plateforme cible si nécessaire.
• Un éditeur de code associé à Unity pour ouvrir les scripts C#.
• Quatre images temporaires : joueur, mur, jeton et sortie, même dessinées très simplement.
• Un objectif réduit : un seul écran de jeu et une seule condition de victoire.

Comment créer un premier jeu 2D dans Unity ?

Pour créer un premier jeu 2D dans Unity, ouvrez un projet 2D, posez un décor et un personnage dans la scène, ajoutez des collisions, programmez le mouvement en C#, puis testez après chaque étape. Le projet de collecte proposé ici limite volontairement le contenu afin de rendre chaque bug identifiable.

La méthode consiste à produire un résultat jouable avant de soigner les assets. Unity offre notamment des Tilemaps pour construire des niveaux sur grille, des outils d’animation 2D et un système physique avec colliders et rigidbodies, mais ces outils ne sont utiles que lorsqu’ils répondent à une règle précise du prototype.

Étape 1 : créer le projet 2D et ranger les dossiers

Dans Unity Hub, créez un nouveau projet avec un modèle 2D, donnez-lui un nom explicite comme « Collecte2D », puis choisissez un dossier de travail facile à retrouver. Dans la fenêtre Project, créez immédiatement les dossiers Scenes, Scripts, Sprites et Prefabs pour séparer le niveau, le code, les images et les objets réutilisables.

Enregistrez la scène actuelle dans Scenes sous le nom Niveau01. Cette organisation évite de chercher un script ou un sprite dans un projet qui grandit sans structure. Le résultat attendu est une scène enregistrée et un panneau Project dont chaque fichier a une place claire.

Étape 2 : construire un écran de jeu lisible

Glissez un sprite de fond dans la scène, puis ajoutez des sprites pour les murs, les jetons et la sortie. Placez la caméra de sorte que l’ensemble de l’écran de jeu soit visible dans la fenêtre Game, sans chercher encore un niveau long ou une caméra qui suit le joueur.

Créez un objet vide nommé Decor et placez-y les éléments statiques afin de garder la Hierarchy lisible. Le résultat attendu est un terrain simple : une zone de départ, quelques obstacles, trois jetons visibles et une sortie que le joueur pourra atteindre.

Étape 3 : créer le personnage et ses composants

Ajoutez le sprite du joueur dans la scène et renommez l’objet Player. Dans l’inspecteur, ajoutez un Rigidbody2D et un BoxCollider2D, puis ajustez le collider afin qu’il couvre le personnage sans englober inutilement les pixels transparents.

Pour un déplacement vu de dessus, désactivez la gravité du Rigidbody 2D dans ses réglages afin que le personnage ne tombe pas hors de la scène. Le résultat attendu est un objet Player sélectionnable, visible dans Game et prêt à recevoir les règles de mouvement.

Étape 4 : programmer le déplacement en C#

Dans le dossier Scripts, créez un script nommé PlayerMovement et attachez-le à l’objet Player. Le fichier et la classe doivent garder exactement le même nom ; cette correspondance est une cause fréquente de script impossible à ajouter dans Unity.

Le code suivant utilise l’ancien système Input Manager et convient à un déplacement vu de dessus. Si votre projet utilise uniquement le nouveau Input System, configurez les actions correspondantes ou activez la compatibilité avec l’ancien système avant de lancer le test.

using UnityEngine;

public class PlayerMovement : MonoBehaviour
{
    public float speed = 5f;
    private Rigidbody2D playerBody;
    private Vector2 movement;

    void Start()
    {
        playerBody = GetComponent<Rigidbody2D>();
    }

    void Update()
    {
        movement.x = Input.GetAxisRaw("Horizontal");
        movement.y = Input.GetAxisRaw("Vertical");
    }

    void FixedUpdate()
    {
        playerBody.MovePosition(playerBody.position + movement.normalized * speed * Time.fixedDeltaTime);
    }
}

Ouvrez la fenêtre Game et lancez le bouton Play. Le résultat attendu est un personnage qui se déplace avec les flèches ou les touches directionnelles configurées dans votre projet. Si Unity signale une erreur dans Console, corrigez-la avant d’ajouter des objets : une seule erreur de compilation bloque l’exécution des scripts.

Étape 5 : empêcher le joueur de traverser les murs

Ajoutez un BoxCollider2D aux sprites qui servent de murs, sans leur ajouter de Rigidbody 2D pour ce prototype fixe. Le Rigidbody 2D du joueur et les colliders des murs permettent alors au système physique de bloquer le déplacement à leur contact.

Testez chaque mur depuis plusieurs directions, surtout dans les angles. Le résultat attendu est un personnage qui ne traverse pas le décor et qui ne reste pas coincé sur une zone de collision disproportionnée.

Étape 6 : créer les jetons et compter le score

Créez un objet Jeton avec un Sprite Renderer et un CircleCollider2D, puis activez l’option Is Trigger du collider. Dupliquez l’objet pour obtenir trois jetons, car une série courte facilite la vérification de la victoire et évite de confondre problème de code et problème de level design.

Attribuez le tag Collectible à chaque jeton, puis ajoutez ce script Collectible sur chacun d’eux. Le GameManager mis en place à l’étape suivante utilisera ce tag pour compter les jetons au démarrage.

using UnityEngine;

public class Collectible : MonoBehaviour
{
    private void OnTriggerEnter2D(Collider2D other)
    {
        if (other.CompareTag("Player"))
        {
            GameManager.Instance.CollectOne();
            Destroy(gameObject);
        }
    }
}

Attribuez le tag Player à l’objet Player dans l’inspecteur, sinon la condition du script ne sera jamais vraie. Le résultat attendu est direct : chaque jeton disparaît au passage du personnage, tandis que les murs restent solides.

Comment ajouter un score et une condition de victoire ?

Un score simple doit afficher une donnée que le joueur peut relier à son action : le nombre de jetons restants ou collectés. Pour ce premier jeu, comptez les objets tagués « Collectible » au démarrage, décrémentez le total lors d’une collecte et affichez un message de victoire lorsque le compteur atteint zéro.

Ajoutez un Canvas et un texte d’interface dans la scène, ainsi qu’un second texte ou panneau qui affichera « Victoire ! ». Créez un objet vide GameManager, ajoutez-lui le script GameManager, puis reliez dans l’inspecteur le texte UI au champ scoreText. Reliez également l’objet de message de victoire au champ victoryMessage.

using UnityEngine;
using UnityEngine.UI;

public class GameManager : MonoBehaviour
{
    public static GameManager Instance;
    public Text scoreText;
    public GameObject victoryMessage;
    private int remaining;

    void Awake()
    {
        Instance = this;
    }

    void Start()
    {
        remaining = GameObject.FindGameObjectsWithTag("Collectible").Length;
        UpdateScore();
        if (victoryMessage != null) victoryMessage.SetActive(false);
    }

    public void CollectOne()
    {
        remaining--;
        UpdateScore();
        if (remaining <= 0 && victoryMessage != null) victoryMessage.SetActive(true);
    }

    void UpdateScore()
    {
        if (scoreText != null) scoreText.text = "Jetons restants : " + remaining;
    }
}

Vérifiez que tous les jetons portent bien le tag Collectible, que le texte du score est relié au GameManager et que le message de victoire est assigné. Au lancement, le compteur affiche le nombre de jetons présents ; après le dernier jeton, le message de victoire devient visible.

Chaque script doit répondre à une responsabilité visible : bouger, collecter ou compter. Quand un fichier essaie de tout faire, le débogage devient plus long que le jeu.

Tester, corriger et exporter un jeu Unity

Le test utile commence dans l’éditeur : lancez la scène, déplacez le personnage, touchez les murs, récupérez tous les jetons et vérifiez l’état final. Une build n’est pertinente qu’après cette vérification, car elle ajoute une couche de configuration sans résoudre les bugs de logique présents dans la scène.

Pour préparer une version jouable, ouvrez File > Build Settings dans les versions d’Unity qui proposent ce menu, ou File > Build Profiles dans les versions récentes. Ajoutez Niveau01 à la liste des scènes incluses, choisissez la plateforme cible, puis lancez une compilation dans un dossier distinct du projet. Si la scène est absente, ouvrez-la puis utilisez Add Open Scenes ou ajoutez-la depuis la liste. Si le build ne démarre pas, vérifiez que la scène figure bien dans le build, que le module de la plateforme cible est installé depuis Unity Hub et relisez la Console après une nouvelle compilation.

1. Lancez la scène depuis l’éditeur et vérifiez le déplacement dans toutes les directions.
2. Contrôlez que chaque mur bloque le joueur et que chaque jeton disparaît une seule fois.
3. Testez le redémarrage de la scène après une victoire ou un échec éventuel.
4. Ajoutez la scène au build, choisissez votre plateforme et compilez dans un dossier dédié.
5. Ouvrez le programme généré et refaites le parcours complet hors de l’éditeur.

Unity, Godot ou GameMaker : quel outil choisir pour un premier jeu 2D ?

Unity convient à un premier jeu 2D si vous voulez apprendre un moteur largement utilisé, manipuler des composants et écrire des scripts C#. Godot constitue une alternative cohérente pour un projet 2D léger, tandis que GameMaker peut convenir si vous cherchez un workflow plus orienté création 2D avec une approche différente du code.

Le choix n’est pas une question de prestige. Choisissez le moteur qui vous permet de terminer un prototype adapté à votre projet, plutôt que celui qui promet le plus de fonctions. Changer d’outil avant d’avoir terminé une boucle de jeu reporte souvent l’apprentissage au lieu de le simplifier.

Outil	À privilégier si…	Compromis à accepter
Unity	Vous voulez apprendre C# et un workflow à composants pour des projets 2D évolutifs.	L’interface et les réglages demandent une prise en main méthodique.
Godot	Vous cherchez un moteur reconnu pour la 2D avec une structure de projet différente.	Les tutoriels Unity ne sont pas transposables directement.
GameMaker	Votre idée est centrée sur une production 2D rapide et des mécaniques simples.	Le workflow et le langage diffèrent de ceux d’Unity.

Erreurs fréquentes quand on apprend Unity

Les premiers blocages sur Unity viennent rarement d’un problème complexe. Ils apparaissent quand plusieurs réglages sont ajoutés sans test intermédiaire, quand un tutoriel vise une ancienne interface ou quand un script n’est pas relié à l’objet prévu.

• Choisir un projet trop vaste : un monde ouvert, un multijoueur ou dix niveaux empêchent de vérifier la boucle de base. Gardez une scène, une règle et une fin.
• Copier du C# sans comprendre son rôle : identifiez au minimum l’objet ciblé, l’événement déclencheur et le résultat visible du script.
• Oublier le Rigidbody 2D ou le Collider 2D : le personnage peut sembler correct à l’écran, mais aucune collision Unity ne fonctionnera comme prévu.
• Modifier plusieurs réglages avant de relancer Play : vous perdez l’origine du bug. Testez après l’ajout d’un composant, d’un script ou d’une règle.
• Suivre un tutoriel non daté : vérifiez la version d’Unity affichée et recoupez les menus avec la documentation de votre version.

Ressources fiables pour continuer après ce premier prototype

Après ce jeu de collecte, reprenez la même boucle avec une seule variation : une minuterie, une patrouille ennemie, une porte qui s’ouvre après collecte ou un second niveau. Unity met à disposition des parcours dans Unity Learn ainsi que des projets d’exemples 2D, dont Match Gem Hunter, Dragon Crashers et Happy Harvest.

Les outils 2D de Unity couvrent également les Tilemaps, l’import de sprites, l’animation, le rigging et l’éclairage 2D. Ne les ajoutez pas tous au même projet d’apprentissage : choisissez le prochain test en fonction du résultat voulu, par exemple une Tilemap si votre difficulté actuelle est de construire un niveau sur grille.

À retenir

Questions fréquentes sur les débuts avec Unity

Peut-on débuter sur Unity sans savoir programmer ?

Vous pouvez découvrir l’interface Unity sans programmer, placer des sprites et créer une scène. Pour réaliser un jeu interactif, le C# devient rapidement nécessaire afin de gérer le mouvement, les collisions, le score et les conditions de victoire.

Combien de temps faut-il pour créer un petit jeu 2D ?

Un petit prototype peut se construire sur plusieurs séances de travail, selon votre familiarité avec Unity et le C#. Le bon objectif est de terminer une boucle jouable courte avant d’ajouter des graphismes, des menus ou plusieurs niveaux.

Faut-il créer soi-même les images et les sons ?

Non. Des formes simples, des images temporaires ou des assets autorisés suffisent pour apprendre Unity. Les éléments graphiques définitifs doivent arriver après validation des règles de jeu, car ils ne corrigent ni collision ni code.

Pourquoi mon script Unity ne fonctionne-t-il pas ?

Vérifiez d’abord la Console, le nom identique du fichier et de la classe, puis l’attachement du script au bon GameObject. Contrôlez aussi les tags, les colliders et les composants exigés par le code, comme Rigidbody2D.