Développement C# et Agile Unity 5 - 1ère Partie.
4.4 (20 ratings)
Instead of using a simple lifetime average, Udemy calculates a course's star rating by considering a number of different factors such as the number of ratings, the age of ratings, and the likelihood of fraudulent ratings.
136 students enrolled
Wishlisted Wishlist

Please confirm that you want to add Développement C# et Agile Unity 5 - 1ère Partie. to your Wishlist.

Add to Wishlist

Développement C# et Agile Unity 5 - 1ère Partie.

Prototyper un jeu d'action 2D multi-platforme en C# avec Unity 5, et l'esprit "Agile".
4.4 (20 ratings)
Instead of using a simple lifetime average, Udemy calculates a course's star rating by considering a number of different factors such as the number of ratings, the age of ratings, and the likelihood of fraudulent ratings.
136 students enrolled
Created by Fred Moreau
Last updated 2/2017
French
Curiosity Sale
Current price: $10 Original price: $130 Discount: 92% off
30-Day Money-Back Guarantee
Includes:
  • 13 hours on-demand video
  • 1 Supplemental Resource
  • Full lifetime access
  • Access on mobile and TV
  • Certificate of Completion
What Will I Learn?
  • Importer des sprites, et planches d'animation, et les organiser en niveaux et objets réutilisables
  • Developer un contrôleur simple et multi-platforme pour piloter un vaisseau spatial avec le clavier et écran tactile
  • Construire des éléments de jeu visibles dans l'éditeur
  • Utiliser le debugging visuel et les math vectorielles pour contrôler l'emplacement d'apparition des objets
  • Mettre en oeuvre la physics 2D avec des "colliders" et "rigid-bodies"
  • Utiliser les "State Machine" de Animator pour diriger les animations conditionnelles
  • Utiliser les fonctionnalités avancées de MonoDevelop, telles que les Tasks, Code Templates et le Debugger.
  • Utiliser toutes les fonctionnalités C# et Unity nécessaires au développement de jeu
  • Enregistrer des scores et préférences du joueurs
  • Utiliser le système d'interface de Unity pour afficher des valeurs et boites de dialogue
  • Utiliser le Mixer Audio pour gérer le volume des différentes pistes
View Curriculum
Requirements
  • Installer Unity 5.x
  • (Option) Installer Xcode et/ou Android SDK
Description

Au travers de cette série de videos, vous apprendrez à développer un projet de jeu vidéo avec Unity 5, ainsi que les bonnes pratiques du développement Agile.

Dans la première partie, nous allons nous intéresser aux concepts fondamentaux de programmation avec Unity pour rapidement livrer un prototype. Pour cela, on va développer un petit space shooter 2D. Tous les sprites, les sons et autres resources sont fournies, afin de se concentrer sur la programmation.

Cette formation s’adresse à tous ceux qui veulent apprendre la programmation orientée objet dans le cadre d’un projet de jeu-vidéo.
Il y a quelques chapitres d’introduction, que certains pourront passer rapidement.
Les bases de la programmation sont expliquées, ainsi que les fonctionnalités de Unity.
La programmation est le sujet principal, on travaille sur un projet de jeu 2D pour que tout reste simple et éviter la complexité des fonctionnalités graphiques déjà bien documentées. Que vous sachiez programmer ou non, que vous soyez débutant avec Unity ou ayez déjà un peu d’expérience, cette formation vous donnera les bons usages et vous aidera à vous organiser dans le chaos d’un projet de jeu-vidéo.

Je suis développeur autodidacte. Je travaille avec Unity depuis 2011 et j’ai eu la chance de rencontrer d’excellents mentors qui m’ont beaucoup appris sur la programmation objet.
C’est beaucoup de choses à apprendre lorsque vous n’avez pas un parcours d’ingénieur. Cependant, si j’y suis parvenu, n’importe qui peut en faire autant.

J’ai commencé à préparer cette formation pour une Master Class avec Unity. Puis j’ai décidé de la pousser encore plus loin lorsque j’ai réalisé que de nombreux développeurs étaient comme moi d’anciens graphistes ou designers, cherchant à se former à la programmation.

J’ai aussi voulu mettre en avant les pratiques Agile, bien que ce ne soit pas une formation à l’Agile, compte tenu de la demande grandissante de développeurs Agile.
Le développement Agile c’est vraiment un état d’esprit qu’on ne peut pas forcer. Du point de vue du développeur, il s’agit surtout de lâcher prise sur le désire de complétude et de perfection d’architecture, et vouloir livrer une version jouable le plus tôt possible. La responsabilité donnée aux programmeurs apporte beaucoup de stress, avec lequel vient le besoin de prévoir, planifier et contrôler le développement. Tout changement devient alors un problème.
La confiance de l’équipe en elle même est clé dans le développement Agile et la confiance vient avec la connaissance.
Plus vous en savez, plus vous avez confiance en vous, et moins vous doutez.
Moins vous redouter le changement, et moins vous ressentez le besoin de sur-planifier et complexifier le code, and le plus tôt vous livrer vos prototypes.
Cette formation veut renforcer les développeurs avec la connaissance nécessaire pour avoir confiance en leur capacité à réagir aux changements et toujours fournir le plus de valeur dans le temps imparti.

Maintenant, le développement Agile, ce n’est pas seulement pour prototyper. Nous allons aussi parler de Performances, de facteurs d’échelle et d’économie de code, ce qui est aussi très important pour la maintenance d’un projet.

J’ai vraiment voulu porter cette formation au delà du modèle académique standard.
Il y a une bonne part de théorie, toujours mise en pratique. Son déroulement est planifié pour offrir une courbe de difficulté croissante et digeste, et sa présentation est à la façon d’une session live dans laquelle je partage le cheminement de ma pensée, ainsi que beaucoup de trucs et astuces.

Who is the target audience?
  • Artistes et/ou Designers souhaitant apprendre la programmation
  • Développeurs de jeux souhaitant apprendre Unity
  • Non programmeurs souhaitant apprendre le développement de jeux
Students Who Viewed This Course Also Viewed
Curriculum For This Course
32 Lectures
12:53:58
+
Start Here
1 Lecture 02:06

Introduction et description de la formation.

Preview 02:06
+
Introduction à Unity
4 Lectures 34:03

Présentation de l'éditeur et concepts clés de Unity.

Preview 06:37

Création d'un nouveau projet 3D.
Création de GameObjects et ajout de Components pour en définir l'usage.
Import d'assets (textures) et création d'assets natives (matériaux) à appliquer aux objets.

Preview 17:39

Identification des différences entre les modes 2D et 3D, et bascule du projet en mode 2D.

Preview 04:20

Définition de la plateforme cible initiale et paramètres de la publication du projet.

Introduction - Réglages de compilation (Build Settings)
05:27
+
Chapitre 1 : Préparation du projet.
2 Lectures 50:45

Import de Sprites.
Positionnement des sprites dans la scène, définition de leur échelle et point de pivot, ainsi que de l'ordre d'affichage au moyen des calques de tri (sorting layers).
Import de sprites animés et réglage de la vitesse de lecture des animations.
Découpe des sprites d'une planche d'animation.
Enregistrement de la scène de travail et du projet sur le serveur.

Mise en scène
40:31

Création d'objets réutilisables (Prefabs).

Prefabs
10:14
+
Chapitre 2 : Pilotage du vaisseau.
2 Lectures 52:49

Développement d'un composant permettant de piloter le vaisseau au clavier.
Ajout d'un nouveau composant C#.
Ajout de variables à une classe.
Déplacement d'un objet via le composant Transform.
Réglage des paramètres d'Input dans l'éditeur.
Utilisation des axes "Horizontal" et "Vertical" pour déplacer et orienter le vaisseau à chaque "Frame".

Pilotage au clavier
35:03

Utilisation des instructions pré-compilatoires pour créer des "branches" de code spécifiques à chaque plateforme ciblées.
Récupération des informations de déplacement de l'écran tactile pour piloter le vaisseau.
Utilisation de Unity Remote pour tester les fonctionnalités tactiles dans l'éditeur.
Compilation du projet pour tester le jeu sur la plateforme cible.

Pilotage tactile
17:46

Testez vos connaissances en C# et Unity.
4 questions
+
Chapitre 3 : Aire de jeu.
4 Lectures 01:34:10

Test de la position d'un objet vis à vis d'une zone rectangulaire et modification si nécéssaire.
Sortie rapide d'une méthode (fonction) lorsque une condition est rencontrée.
Ajout d'un attribut à la classe pour organiser les composants en catégories dans l'éditeur.

Limitation des déplacements
22:38

Documentation du code à l'aide de balises.
Déplacement d'une propriété dans un autre composant et y faire référence.
Définition d'une propriété (variable accessor).
Mise à jour des propriétés lors de modifications dans l'éditeur.
Changement du nom d'un membre dans l'ensemble du projet (Refactoring).
Affichage de Gizmos pour représenter un game object dans l'éditeur.
Conversion d'une position de l'espace du monde à celui d'un autre objet, et inversement.

L'aire de jeu
35:09

Ajout d'un attribut pour définir la dépendance d'un script à un autre composant.
Utilisation d'un Accessor pour accéder ponctuellement à un autre composant du GameObject.
Ajustement de la taille de la zone de jeu depuis la taille et le ratio d'une caméra.
Accès à la Caméra principale de la scène.
Changement du nom d'un composant MonoBehaviour.
Utilisation de la documentation du code pour connaitre l'usage d'un composant.

Ajustement à la Camera
23:10

Forcer l'ordre d'éxécution des scripts lors de conflits.
Ré-architecture de deux composants pour éviter les conflits d'éxécution.
Remplacement d'une Method par un Accessor.
Ajout d'attributs aux variables pour forcer leur enregistrement (sérialisation) et les masquer dans l'éditeur.

Concurrance de Scripts
13:13

Testez vos connaissances en C# et Unity.
3 questions
+
Chapitre 4 : Trous noirs et astéroïdes
7 Lectures 02:53:43

Déclaration d'une référence à un gameObject.
Instanciation d'un gameObject au runtime.
Mesure du temps écoulé pour maintenir un débit constant.
Utilisation d'une Coroutine et de l'expression "while", pour éxécuter une commande en boucle à rythme constant.
Utilisation d'un attribut pour limiter la valeur d'un paramètre dans l'éditeur.
Regroupement des paramètres d'un composant en "catégories" dans l'éditeur à l'aide d'attribut.

Instantiation & Coroutines
30:18

Implémentation d'une méthode retournant une valeur (Vector3).
Construction d'une position aléatoire exprimée dans le monde à partir des valeurs de la zone de jeu.
Conversion d'une valeur de type Vector3 en type Vector2 (Cast) pour en supprimer la composante Z.
Utilisation de l'aléatoire (Random) pour obtenir un débit variant.
Définition d'un paramètre optionnel d'un composant.
Usage d'un Ternary Operator pour affecter une valeur ou une autre à une variable, en fonction d'une condition.

Position Aléatoire
17:23

Recherche d'un objet portant un "Tag" (Player).
Eloignement de la position d'un objet lorsque celle-ci est trop proche de celle du vaisseau.
Affichages de lignes dans l'éditeur et mise en pause du jeu pour visualiser et vérifier le reposionnement des objets.
Affichage des messages d'avertissement dans la console de l'éditeur.

Distance du joueur
22:23

Ajout des composants de type Collider2D aux objets pour définir leur enveloppe de collision.
Ajustement des contours du Collider du vaisseau.
Ajout d'un composant RigidBody2D aux objets pour les soumettre aux lois de la physique (gravité, inertie, collisions).
Annulation de la gravité dans les réglages de Physics2D du projet.
Ajustement du comportement des objets aux moyens des paramètres des composants RigidBody2D.
Modification des contrôles du vaisseau pour le piloter à l'aide de la physique.
Attribution aux objets des matériaux Physics2D pour définir leur propriétés de friction et de rebond.

Physics 2D
27:11

Récupération de la référence à un objet instancié pour accéder au composant RigidBody2D associé.
Modification de la vélocité (direction et vitesse) d'un objet.
Conversion d'un angle en direction 2D.

Direction aléatoire
20:42

Import d'une planche d'animation de Sprite.
Création d'un Animator Controller spécifique pour les trous noirs.
Inversion de la vitesse de lecture d'une animation.
Ajout d'un calque d'animation pour mélanger plusieurs animations sur un même objet.
Création d'une animation de propriété (opacité).
Ajout d'états (State) à l'Animator Controller pour définir un état "inactif" et un état "actif".
Ajout de transitions d'un état à l'autre.
Ajout d'un paramètre à l'Animator Controller pour définir une condition de transition.
Pilotage d'un paramètre de l'Animator Controller depuis le composant, pour le synchroniser avec l'instanciation des objets.

Animator
31:07

Remplacement des références aux objets présents dans la scène par des Prefabs.
Contournement des limitations de référencement imposées par les Prefabs à l'aide d'un Accessor "Static" permettant de retrouver, ou créer la zone de jeu principale.
Ajout de commentaires de "tâche" permettant de suivre le travail restant dans MonoDevelop.

Aire de jeu principale
24:39

Testez vos connaissances en C# et Unity.
3 questions
+
Chapitre 5 : Dégât, Réparation et Fin de partie.
3 Lectures 01:30:15

Présentation des principaux Design Patterns (modèles d'architecture logicielle)
Utilisation des Code Templates pour rapidement implémenter des modèles de code souvent utilisés.
Récupération des collisions entre le vaisseau et les astéroids pour augmenter le dommage causé.
Expérimentation des différents schémas de communication entre composants.
Mesure du niveau de dommage en fonction des informations de la collision et des matériaux physiques.
Création d'une classe "Static" pour gérer l'ensemble des information du jeu (Game Manager).

Collisions
57:02

Ajout d'un Collider2D en mode "Trigger" pour détecter l'entrée d'un objet dans une zone.
Ajout d'une AudioSource à un objet pour jouer un son lors de la récupération d'un RepairKit ou ExtraLife.
Déclaration d'un type sous forme de Enum pour déterminer le type RepairKit ou ExtraLife.
Utilisation d'un "switch" pour déterminer l'action selon le type.
Utilisation d'une Coroutine pour attendre la fin de lecture d'une source audio avant de supprimer un objet.

Triggers
24:39

Ajout d'une propriété pour suivre le nombre de vies.
Ajout d'un BreakPoint pour interrompre l'execution du jeu lorsque une valeur change.
Utilisation du Debugger, attaché à l'éditeur, pour inspecter les valeurs du jeu pendant l'execution.

Preview 08:34

Testez vos connaissances en C# et Unity.
2 questions
+
Chapitre 6 : Armes et Scores.
2 Lectures 01:09:16

Remplacement d'une "Asset" du projet.
Affectation aux missiles d'une vitesse constante et indépendante du FrameRate.
Ajout des commandes de tir au clavier et à l'écran tactile.
Utilisation d'un Accessor de type Bool pour implémenter la mécanique de tir.
Utilisation des "invocations" de méthodes pour obtenir un tir automatic.
Positionnement d'un objet sur un calque, et désactivation des collisions d'un calque avec un autre.
Désactivation de la collision d'un objet avec un autre.
Limite de la portée des missiles, en les supprimant au delà d'une distance parcourue.

Tirs de missiles
52:46

Incrémentation de la valeur de Score ajoutée au GameManager lors de la collision entre un missile et un astéroid.
Mise à jour du HighScore lorsque le Score lui est supérieur.
Enregistrement du HighScore dans les données du jeu d'une partie à la suivante.

Score
16:30

Testez vos connaissances en C# et Unity.
2 questions
+
Chapitre 7 : Interface et Audio.
7 Lectures 03:26:51

Ajout d'un texte (UIText).
Ajustement du composant Canvas pour travailler dans les conditions de la plateforme cible.
Positionnement des objets de l'interface (UI), manuellement et à l'aide des "presets".
Import d'une police de caractère pour personnaliser l'affichage des textes.

Interface Graphique
25:08

Création d'un Slider et modification pour en faire une jauge.
Ajustement des bordures d'un Sprite pour préserver les bords de l'image lorsqu'elle est étirée.
Modification de l'ordre d'affichage des éléments UI.
Regroupement des objets UI pour les masquer ou les déplacer.

Jauge de dommage
16:52

Usage de la méthode "Format" pour composer des lignes de textes riches à partir de paramètres.
Ajout d'événements (C#) pour notifier d'autres composants de changements de valeurs.
Abonnement d'une méthode ou "delegate" à un évenement d'un autre composant, pour définir ce qu'il se produit lors de cet évenement.
Interpolation entre deux couleurs.

Gestionnaire d'interface
40:14

Ajout des boutons et évenements pour afficher/masquer des éléments UI.
Ajout d'un "état" du jeu (en cours, en pause, perdu), et notification de l'interface du changement d'état.
Figer le jeu au moyen de la vitesse du temps.

Pause
41:34

Ajout d'une musique de fond en boucle.
Création d'un nouvel Audio Mixer pour séparer les canaux audio (music et effets) du jeu.
Affectation d'un canal (Group) à chaque AudioSource.

Audio Mixer
10:47

Ajout de "sliders" permettant de régler les niveaux sonores de la musique et des effets.
Exposition des paramètres de l'Audio Mixer pour y accéder depuis un composant.
Enregistrement des valeurs de préférences automatiquement lorsqu'elles sont modifiées.
Lien des "sliders" aux valeurs de composant.
Conversions d'une valeur linéaire en décibel.
Ajout d'une extension de type, pour accéder à la conversion linéaire - décibel depuis tout le projet.

Réglages du joueur
55:58

Ajout d'un bouton Restart et l'aligner automatiquement avec le bouton Resume avec les composants Layout.
(Re)charger un niveau (Scene) pour redémarrer la partie.
Réinitialisation des valeurs de jeu.
Réinitialisation des évenements (events) pour supprimer les références aux objets détruits.

Redémarrage
16:18

Testez vos connaissances en C# et Unity.
3 questions
About the Instructor
Fred Moreau
4.5 Average rating
129 Reviews
729 Students
7 Courses
Game Developer, Unity Instructor, Agile Coach

Coach and Consultant - Design & Development, Business, Training

[ English ]

With a strong technical expertise and a taste for design, I've had the opportunity to lead teams of creative people through development of innovative projects.

I'm passionate about learning and training, I started giving training early and have been involved in training certification programs. When you work in this industry, sharing your knowledge is not only a duty, it's the opportunity to learn even more.

I'm a self-taught developer myself. I work with Unity since 2011, and was very lucky to meet with mentors who taught me a great deal about OOP. That's a lot to learn about when your background is not in engineering, though, I figured that if I could do it, anyone can.

[ Français ]

Je suis passionné par l’apprentissage et l’enseignement. J’ai donné mes premières formations très tôt et me suis impliqué dans les programmes de certifications de grands éditeurs. Quand on travaille dans cette industrie, partager ses connaissances est plus qu’un devoir, c’est aussi le meilleur moyen d’apprendre d’avantage.

Je suis développeur autodidacte. Je travaille avec Unity depuis 2011 et j’ai eu la chance de rencontrer d’excellents mentors qui m’ont beaucoup appris sur la programmation objet.
C’est beaucoup de choses à apprendre lorsque vous n’avez pas un parcours d’ingénieur. Cependant, si j’y suis parvenu, n’importe qui peut en faire autant.