Partie 1 : Se préparer à l'unité

Chapitre 1 : Préparer l'unité

1.1 Qu'est-ce que le moteur Unity ?
1.2 Configuration de l'environnement de développement
1.3 Créer votre premier projet
1.4 En conclusion

Chapitre 2 : Exploration de l'interface Unity

2.1 Ouverture d'un projet existant
2.2 Modification de la mise en page
2.3 Fenêtre principale
2.4 Outil d'édition de scène
2.5 Modification des objets du jeu
2.6 Gizmo de scène
2.7 Bouton de lecture de scène
Bouton Cloud Unity 2.8
2.9 En conclusion

Chapitre 3 : Fonctionnement du moteur Unity

3.1 Héritage et réutilisation
3.2 Modèle de composants : Assemblage des mondes de jeu
3.3 Composants dans l'éditeur Unity
3.4 Messages et diffusion
3.5 En conclusion

Partie 2 Programmation C#

Chapitre 4 : Premiers pas avec la programmation C#

4.1 Comprendre le concept de variables
4.2 Comprendre le concept de fonctions (méthodes)
4.3 Écrire votre premier scénario
4.4 Règles de base du codage
4.5 Mise en pratique des variables
4.6 Mise en pratique de la méthode
4.7 Déclarations de contrôle
4.8 Tableau
4.9 En conclusion

Chapitre 5 : Contrôler les objets du jeu

5.1 Classes et objets
5.2 Création d'une classe C#
5.3 Types de référence
5.4 Utilisation des composants comme variables
5.5 En conclusion

Partie 3 Bullet Hell Shooting Game_Dodge

Chapitre 6 Esquive : Création de joueur

6.1 Configuration de la scène
6.2 Configuration de la caméra
6.3 Création de joueur
6.4 Création d'un script de joueur
6.5 Détection des entrées utilisateur
6.6 Gestion de la mort des joueurs
6.7 Amélioration du script PlayerController
6.8 Gestionnaire de saisie
6.9 En conclusion

Chapitre 7 Esquive : Fabrication de balles

7.1 Préparation de l'objet de jeu Bullet
7.2 Préparation du script Bullet
7.3 Gestion des collisions de balles
7.4 Préparer le générateur de balles
7.5 Création d'un script de générateur de puces
7.6 En conclusion

Chapitre 8 : Esquive : Gestionnaire de jeu et interface utilisateur, achèvement final

8.1 Résumé du projet
8.2 Rotation du sol
8.3 Création d'une interface utilisateur de jeu
8.4 Création d'un gestionnaire de jeu
Bâtiment 8.5
8.6 En conclusion

Partie 4 Espace

Chapitre 9 Orientation, échelle et rotation

9.1 Mathématiques vectorielles
9.2 Vecteurs Unity C#
9.3 Quaternions
9.4 En conclusion

Chapitre 10 Espace et mouvement

10.1 Espace Unity
10.2 Objets en mouvement et en rotation
10.3 Mise en œuvre de la traduction parallèle avec des opérations vectorielles
10.4 En conclusion

Partie 5 Jeu de course 2D_UniRun

Chapitre 11 : Unirun : Création de joueur

11.1 Ouverture d'un projet Unity 2D
11.2 Créer un point de départ
11.3 Modification des sprites de personnages
11.4 Préparation de l'objet de jeu Personnage 2D
11.5 Préparation de l'animation des personnages
11.6 Script PlayerController
11.7 En conclusion

Chapitre 12 : Unirun : Défilement en arrière-plan et gestionnaire de jeu

12.1 Ajout d'un arrière-plan
12.2 Arrière-plans et plateformes en mouvement
12.3 Création d'une interface utilisateur de jeu
12.4 Création d'un gestionnaire de jeu
12.5 En conclusion

Chapitre 13 : Unirun : Créer un point d’appui à plusieurs reprises et terminer le jeu

13.1 Créer un point d'appui
13.2 Création d'un générateur de points d'appui
13.3 Bâtiment
13.4 En conclusion

Partie 6 Jeu de tir à vue de dessus_Survivant zombie

Chapitre 14 : Survivant zombie : Conception graphique des niveaux et préparation du joueur

14.1 Structure du projet
14.2 Pipeline de rendu universel
14.3 Paramètres graphiques et d'éclairage des niveaux
14.4 Composition du personnage joueur et de l'animation
14.5 Mise en œuvre du mouvement des personnages
14.6 Configuration de la caméra de suivi Cinemachine
14.7 En conclusion

Chapitre 15 Survivant zombie : Armes à feu et tireurs

15.1 Interface
15.2 Préparation de l'ensemble des objets du jeu
Script GunData 15.3
15.4 Script d'arme
15.5 Création d'un tireur
15.6 En conclusion

Chapitre 16 : Survivant zombie : Vie et IA zombie

16.1 Polymorphisme
16.2 Classes basées sur LivingEntity
16.3 Interface utilisateur de santé du joueur
Script 16.4 PlayerHealth
16.5 Système de navigation et préparation aux zombies
16.6 Script Zombie
16.7 En conclusion

Chapitre 17 : Survivant zombie : Finitions finales et post-traitement

17.1 Gestionnaire de canevas et d'interface utilisateur HUD
17.2 Gestionnaire de jeu
17.3 Générateur de zombies
17.4 Création d'objets
17.5 Post-traitement
Version finale 17.6
17.7 En conclusion

Partie 7 Jeu en réseau_Pong

Chapitre 18 : Pong : Théorie des réseaux et implémentation des menus

18.1 Synchronisation réseau
18.2 Types de serveurs de jeu
18.3 Séparation des privilèges réseau
18.4 Préparation du projet
18.5 Configuration de la scène d'initialisation
18.6 Configuration du menu
18.7 En conclusion

Chapitre 19 : Pong : Mise en place d'un lobby en réseau

19.1 Composants d'objet réseau
19.2 Mise en œuvre par le lobbying
19.3 En conclusion

Chapitre 20 Pong : Mise en œuvre du jeu en réseau

20.1 Scène en jeu
20.2 Composant de synchronisation de localisation
20.3 Mise en œuvre de la raquette du joueur
20.4 Mise en œuvre du ballon
20.5 Mise en œuvre d'un gestionnaire de jeu
20.6 Construction et tests
20.7 En conclusion

Annexe A - Version Android

A.1 Activation du mode développeur sur votre appareil Android
A.2 Préparation du SDK Android
A.3 Vérification de l'intégration d'Unity et du SDK Android
A.4 Paramètres de compilation Android
Bâtiment A.5

Annexe B Version iOS

B.1 Préparation de l'environnement de développement
B.2 Paramètres de compilation Unity iOS
B.3 Création d'iOS dans Xcode

Annexe C Système adressable

C.1 Qu'est-ce qu'un système adressable ?
C.2 Activation du système adressable
C.3 Profil adressable
C.4 Désignation des actifs comme adressables
C.5 Spécification des groupes d'actifs et des adressables
C.6 Paramètres adressables
C.7 Codage du système adressable
C.8 Création de contenu adressable
C.9 Autres

Qu'est-ce qui a changé dans la 3e édition ?

1.
Mise à jour de la version Unity
- Passage d'Unity 2021 à Unity 2023.2 et Unity 6 Beta
- Captures d'écran et code entièrement revus (reflétant la nouvelle interface utilisateur et les nouvelles fonctionnalités d'Unity 6)

2.
Ajout d'un mode multijoueur (Pong)
- Ajout d'un mode multijoueur en réseau qui n'était pas disponible dans la version précédente.
- Apprenez les RPC, la synchronisation et l'architecture client-serveur avec Unity Netcode.

3.
Ajout de fonctionnalités d'adressage des actifs et système de correctifs
- Ajout d'une méthode pour implémenter un système de mise à jour de contenu et de distribution à distance
- Inclut un guide du système de patch inédit pour les utilisateurs avancés (expliquant comment mettre à jour le jeu).

4. Systèmes d'IA et de navigation améliorés
- Ajout d'une IA zombie, d'un système de navigation et de fonctionnalités de détection des impacts basées sur le lancer de rayons, qui n'étaient pas disponibles auparavant.
- Description détaillée de l'implémentation de l'IA ennemie (mouvements, schémas d'attaque, etc.)

5. Améliorations de l'interface utilisateur (UGUI) et ajout du post-traitement
- Reflète la dernière version du système d'interface utilisateur Unity (réorganisation UGUI)
- Ajout de techniques de post-traitement → Amélioration de la qualité graphique du jeu

★ Caractéristiques de ce livre

Un plan de progression adapté aux débutants et aux étudiants non spécialisés.

Ce livre s'adresse aux débutants, aux étudiants non spécialisés et aux artistes qui n'ont aucune connaissance en programmation, et encore moins en Unity.
C'est pourquoi il est organisé de manière à être facilement compréhensible par les étudiants non spécialisés.
Le contenu mathématique utilise des exemples faciles à comprendre pour les non-spécialistes, plutôt que des termes techniques.

De nombreux exemples et illustrations

Les concepts difficiles sont remplacés par des analogies et des exemples, et les descriptions complexes par des illustrations.
Avec plus de 700 illustrations, vous pouvez suivre sans en perdre une miette.

Ensemble tout-en-un

Il couvre tout ce dont vous avez besoin pour le développement de jeux, des bases aux concepts avancés, y compris le fonctionnement d'Unity, la programmation C#, la programmation orientée objet, l'algèbre linéaire, l'interface utilisateur, le développement mobile, le post-traitement, la mise en réseau et la programmation.
Nous fournissons également une annexe au Guide complet Addressable pour les utilisateurs avancés qui souhaitent mettre en œuvre un système de correctifs.
Ce seul ouvrage peut remplacer à la fois un livre d'introduction à la programmation C# et un livre d'introduction aux moteurs de jeux.

★ Structure de ce livre

Ce livre est divisé en sept parties.
Dans les parties 1 et 2, vous apprendrez rapidement les concepts fondamentaux les plus essentiels pour comprendre Unity et la programmation immédiatement.
Les parties 3, 5, 6 et 7, qui impliquent des projets pratiques, vous aideront à comprendre la théorie par la pratique en réalisant un jeu par genre.
Les projets pratiques consistent à trouver de nouvelles façons de surmonter des problèmes difficiles à résoudre avec les seules connaissances existantes.
La partie 4 aborde les fondements mathématiques du développement de jeux d'un point de vue non spécialisé, et l'annexe traite des versions mobiles et de la gestion de contenu à l'aide d'Addressable.

Partie 1 : Se préparer à l'unité

Préparez-vous à Unity et apprenez comment il fonctionne et quelle est son interface.
Préparez votre environnement de développement Unity et créez un projet d'exemple.
Principes des objets et composants du jeu
et comprendre les mouvements.
Comprendre la structure et les méthodes de développement des moteurs de jeu.

Partie 2 : Programmation en C#

Apprenez la programmation C# et l'orientation objet du point de vue d'un débutant.
Les principes de programmation et l'orientation objet sont expliqués à l'aide d'exemples graphiques immédiatement compréhensibles.
Vous apprendrez la majeure partie de la syntaxe C# dont vous avez besoin en écrivant vos propres scripts C#.
Comprendre comment les principes d'Unity abordés dans la partie 1 s'articulent avec l'approche orientée objet de C# et comment les scripts peuvent contrôler les objets et les composants du jeu.

Partie 3 : Bullet Hell Shooter - Esquive

Créez un jeu d'esquive de balles en 3D.

En partant d'un petit exemple de lancer une balle à l'aide du clavier, nous allons créer des projectiles, une interface utilisateur, un gestionnaire de jeu et tout le reste nécessaire pour finaliser le jeu, jusqu'à la version finale.
Vous apprendrez également comment répéter périodiquement la création de puces et comment sauvegarder votre score.

Apprenez à contrôler la force et la vitesse en fonction des commandes du joueur.
Nous utiliserons des exemples concrets pour illustrer pourquoi des concepts de base comme les gestionnaires d'entrée et les intervalles de temps sont essentiels.

Partie 4 : L'espace

Apprenez l'algèbre linéaire pour contrôler l'espace, la vitesse et la rotation.
Vous apprendrez les mathématiques vectorielles, les espaces locaux et globaux, et les quaternions utilisés pour les rotations.
Pour les non-spécialistes et les développeurs qui n'ont pas le temps d'étudier l'algèbre linéaire séparément, le processus de démonstration complexe a été remplacé par des diagrammes intuitifs et concis.
De plus, vous comprendrez rapidement les connaissances mathématiques par la pratique plutôt que par la théorie.

Partie 5 : Jeu de course 2D - Unirun

Nous développons un jeu de course en 2D avec des plateformes infinies générées aléatoirement.
Apprenez à créer des animations 2D et à adapter les animations en fonction de la situation du personnage.
Apprenez à mettre en œuvre le regroupement d'objets pour placer des arrière-plans et des obstacles à l'infini et de manière répétée.
Nous implémentons et utilisons également directement Singleton, l'un des modèles de conception.

Partie 6 : Jeu de tir à défilement vertical - Survivant zombie

Nous sommes en train de créer un jeu de tir à défilement vertical où vous tirez sur des zombies contrôlés par l'IA qui vous attaquent.
Implémenter l'IK et les masques animés.
Créer un système de score et d'invocation d'ennemis par IA, ainsi qu'une interface utilisateur en jeu.
Nous utilisons le système de navigation d'Unity pour implémenter l'IA et le lancer de rayons pour implémenter des collisions de balles précises.
Vous apprendrez à utiliser les interfaces, les événements et les expressions lambda de C# pour réduire de manière concise le code de gestion des dégâts pour les joueurs et les ennemis contrôlés par l'IA.
Utilisez la post-production pour sublimer vos vidéos.

Partie 7 : Jeux en réseau - Pong

Nous transformons des jeux classiques célèbres en jeux multijoueurs en réseau à 2 joueurs.
Apprenez les théories communes à tous les types de jeux en réseau, quelle que soit l'API.
Implémente les halls d'accueil, la synchronisation de position, les RPC, etc. via Netcode, la bibliothèque réseau Unity.
Découvrez les procédures de synchronisation, les clients et les hôtes, les environnements locaux et distants, ainsi que les autorisations de manipulation.

supplément

Apprenez à créer des jeux Unity pour Android et iOS.
Découvrez comment gérer et diffuser du contenu à distance grâce au système Addressable Asset System.