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

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

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.

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

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".

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.

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.

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.

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.

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.

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.

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.

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.

ERRATUM : 

La ligne suivante créer la position "relative" au vaisseau.

_position = (_position-player.position).normalized * minDistanceFromPlayer; 

Pour qu'elle soit de nouveau dans le repère du "monde", il faut lui ajouter la position du vaisseau à nouveau.

_position += player.position; 

Un grand merci à Jeff pour avoir relevé cette erreur.

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.

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.

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.

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.

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).

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

Allez plus loin en apprenant à architecturer un projet et optimiser les performances.