Je code, tu codes… vous codez ? #2

Programmation orientée objet et première approche de Unity

Bonjour à toutes et à tous, et bienvenue dans cette nouvelle série d’articles qui traitera – en long, large et autres travers – de la programmation, et puisque nous sommes sur Cleek, nous parlerons bien entendu ici de l’art geek dans toute sa splendeur : le jeu vidéo et les étapes nécessaires pour créer le vôtre de A à Z !

Non, non, ne fuyez pas tout de suite, rassurez-vous, le développement de logiciels n’est en aucun cas, contrairement à certaines idées reçues, une affaire d’intellos reclus et monomaniaques ! En effet, quelques cuillères à soupe de logique, une ou deux onces de patience ainsi que quelques grammes de curiosité sont les seuls ingrédients requis pour développer la base d’un jeu vidéo.

Comme promis dans le premier article, nous allons discuter en premier lieu des objets, des sortes de variables dotées de supers-pouvoirs bien pratiques, pour enchaîner ensuite sur la prise en main de « Unity », afin de disposer de tous les outils nécessaires pour débuter votre propre jeu !

[divider]Les objets, c’est la classe ![/divider]

Petit rappel au sujet des variables à l’intention de ceux qui dorment près du radiateur : une variable peut être considérée comme une case dans la mémoire de votre ordinateur à laquelle vous associez un nom (le nom de la variable donc), un type (le type de données que cette case peut contenir : numérique, texte…) ainsi qu’une valeur qui est modifiable. Vous pouvez donc utiliser ou modifier le contenu de cette variable en appelant cette dernière par son nom dans votre code.

Les objets (rentrons dans le vif du sujet), sont en fait des variables complexes qui peuvent représenter n’importe quoi : un objet de la vie réelle que nous souhaitons représenter dans notre programme (un chat par exemple ?), ou un concept plus abstrait qui ne pourrait pas être simplement remplacé par une variable simple comme un texte ou un chiffre (une compétence dans un jeu de rôles, une position dans un système en trois dimensions… la liste est potentiellement infinie).

« Super… mais ça ne me dit pas comment ça marche… »

Patience, patience, nous y arrivons ! C’est d’ailleurs un des points les plus passionnants de la programmation : comprendre les objets ! Travaillons avec un exemple : imaginons que vous souhaitiez représenter un chat dans notre logiciel. Voici la marche à suivre pour concevoir notre animal favori – ou pas – dans notre code :

Première étape : réfléchir aux caractéristiques simples (c’est-à-dire que nous pouvons convertir en variables basiques) de notre chat que nous voulons transmettre à son alter ego virtuel. Admettons pour l’exemple, que nous avons besoin de son nom (une variable de type texte), de sa vitesse de déplacement (de type numérique), de son emplacement à l’écran (les coordonnées x et y dans un jeu en 2D, c’est-à-dire deux variables de type numérique) et de ses points de vie (numérique, toujours). Ces caractéristiques simples, représentées par des variables basiques (ou par d’autres objets), s’appellent des « attributs ».

Seconde étape : réfléchir (encore, oui) aux actions que notre boule de poils pourra exécuter dans le jeu. Dans notre cas, nous souhaitons qu’il puisse se mouvoir à l’écran en fonction de sa vitesse de déplacement, dormir (pour régénérer ses points de vie) et malheureusement, mourir (quand ses points de vie tombent à zéro). C’est très triste et nous le déplorons tous. Mais revenons à nos chatons, les actions de notre bestiole sont considérées en programmation comme des « méthodes ». Ces méthodes seront en fait des morceaux de code qui détailleront le fonctionnement de chacune des actions qui nous intéressent.

Voilà, votre chat virtuel est, sur le papier, presque fonctionnel !

Les deux étapes de réflexion que nous avons menées ont un but : elles nous permettent de décrire quelque chose de réel de manière théorique, dans le but de transcrire cette chose dans un programme. La description d’un objet, c’est-à-dire les caractéristiques qui le représentent (ses attributs) et les actions qu’il peut effectuer (ses méthodes), est appelée une « classe », en programmation.

La théorie des objets peut toutefois être creusée un peu plus, notamment la notion d’« héritage » que nous aborderons plus tard, mais ce qu’il faut retenir pour l’instant, c’est qu’un objet est décrit à l’intérieur d’une classe par un assemblage de variables simples auxquelles nous associons des actions inhérentes au fonctionnement de cet objet tel que nous le concevons, et qu’à partir de cette fameuse classe, nous pouvons instancier (créer) l’objet.

Pour expliquer ces notions (un peu particulières, tous les débutants en programmation sont parfois déroutés par le concept d’objets), utilisons une petite métaphore dans laquelle vous voulez fabriquer une armée de figurines représentant des chatons en plâtre… La marche à suivre serait de fabriquer un moule de la forme souhaitée, puis de couler le plâtre à l’intérieur, laisser sécher votre chaton (c’est une idée ignoble), pour le démouler et recommencer à plusieurs reprises jusqu’à ce que vous disposiez de toute une ribambelle de figurines. Et bien, votre moule correspond à votre classe « Chat », et chacune des figurines extraite de ce moule sera donc une instance de cette classe du même nom.

Voilà pour la théorie – basique – des classes et objets !

[divider]Unity, un IDE qu’il est cool[/divider]

L’outil principal de tout programmeur porte le nom générique d’« IDE », acronyme anglais qui signifie « environnement de développement ». Un IDE est en fait un logiciel qui permet de convertir du code informatique et des informations graphiques en un programme fini, tout en offrant des fonctionnalités qui aident dans les tâches les plus importantes à l’élaboration du programme en question, telles que l’analyse de la syntaxe de votre code pour vérifier les erreurs potentielles ou encore la gestion et le positionnement des éléments visibles (les boutons, les textes, et autres images).

Il existe toute une myriade de logiciels de ce genre sur le marché, certains destinés aux professionnels et soumis à des licences d’utilisation payantes tandis que d’autres sont gratuits et totalement open source. Ces IDE se distinguent aussi par l’objectif de la personne qui va les utiliser : un programmeur fera des programmes (sans rire ?) de comptabilité, un autre sera intéressé par la conception de sites internet quand un troisième voudra faire des jeux vidéo… À chaque besoin (nous parlons toujours de programmation, un IDE ne lavera jamais votre linge ou ne préparera de sushis…) peuvent correspondre un ou plusieurs environnements de développement, qui utiliseront des langages différents et proposeront des fonctionnalités plus ou moins spécialisées.

Dans notre cas, nous souhaitons apprendre à créer des jeux vidéo, et une occasion en or se présente à nous : le logiciel « Unity », gratuit pour les amateurs, payant pour les entreprises, présente tous les outils dont nous avons besoin !

Pour commencer, allez sur le site internet de la société qui produit Unity, et téléchargez ce dernier en cliquant sur le bouton « Get Unity 5 ». Ensuite, sur les pages suivantes, sélectionnez l’option « Free Download », et enfin « Download Installer » avant d’installer votre nouvel IDE en suivant les instructions d’installation comme pour n’importe quel autre logiciel.

Une fois l’installation terminée, vous pouvez lancer Unity qui vous proposera par défaut de créer un nouveau projet. Votre écran devrait ressembler à ceci :

Vous devez renseigner quelques champs avant de commencer : le nom de votre projet (« Project name* »), et le répertoire dans lequel vous souhaitez qu’il soit enregistré (« Location* » – je vous recommande d’ailleurs de créer un dossier Unity dans lequel vous créerez un dossier par projet). Sélectionnez ensuite l’option « 2D » puisque notre premier projet se veut simple. Ne vous préoccupez pas des autres informations et terminez en cliquant sur le bouton « Create project ».

Après un bref temps de chargement, Unity se dévoile enfin à vous, avec plein de fenêtres aux noms barbares que nous allons apprivoiser à l’aide de la saisie d’écran ci-dessous :

Nota Bene : La disposition peut être différente par défaut, mais vous pouvez organiser tout les éléments de votre IDE comme bon vous semble, la disposition sur la dernière image est la mienne et si vous débutez la programmation ou que vous avez peur de vous perdre, l’idéal serait de suivre cette disposition le temps de vous sentir plus à l’aise.

Les fenêtres principales sont les suivantes (identifiées sur la capture d’écran grâce aux numéros 1 à 6 en rouge) :

1. « Scene » : tous les objets de votre jeu vont s’agencer ici : le paysage de fond, les personnages, la caméra qui sert de point de vue pour le joueur… Il s’agit d’une vue « technique » de la partie du jeu sur laquelle vous travaillez. Deux choses importantes à noter : une scène est une partie de votre jeu (un niveau, un menu par exemple… un jeu est souvent composé de plusieurs scènes.), et vous allez vous repérer dans votre scène grâce au quadrillage dans le cas d’un jeu 2D et grâce à l’axe « x,y,z » quand vous commencerez la 3D.
2. « Hierarchy » : la liste qui rassemble tous les objets de votre jeu (les objets visibles comme les images, et les autres qui ont des fonctions particulières, comme les sons, les lumières ou encore, la caméra).
3. « Inspector » : Lorsque vous sélectionnez un objet dans la fenêtre « Hierarchy », toutes les propriétés (ses attributs) modifiables de l’objet en question seront visibles ici.
4. « Project » : tous les dossiers, fichiers, scripts et ressources qui composent votre projet : cette fenêtre est en fait le dossier dans lequel votre projet est enregistré,  ainsi que vos images, sons, modèles 3D et toutes vos pages de code qui seront classés ici.
5. « Console » : très important, c’est ici que les messages d’erreurs et de bugs s’afficheront, nous apprendrons ensemble à décrypter les messages étranges qui y défilent et cette fameuse « Console » ne tardera pas à devenir votre plus précieuse alliée !
6. « Game » : un aperçu de votre jeu en temps réel, immobile la plupart du temps. C’est à cet endroit que les choses vont s’animer telles que l’utilisateur de votre jeu le verra dans la version finale, mais aussi lors de vos tests (qui sont très fréquents lors de l’élaboration d’un programme).

« Et bien… moi qui me suis embêté à essayer de comprendre l’algorithmique… je ne vois pas beaucoup de code là-dedans… »

Figurez-vous que Unity utilise un système de « scripts », qui sont en fait des pages de code contenant des fonctionnalités basiques (déplacer une image, jouer un son… bref, interagir avec tous vos objets) que vous pourrez créer et associer aux différentes parties de votre projet pour que le tout fonctionne selon ce que vous voulez faire !

Unity prend en charge deux langages de programmation dans ces fameux scripts, et vous pouvez choisir d’écrire votre code soit en « C# » (prononcer « ci-sharp »), langage phare de Microsoft depuis quelques années, ou en « javascript », une technologie que nous associons plus souvent aux sites web. Vous pouvez utiliser l’un ou l’autre (jamais les deux dans le même script, mais il est possible de mélanger des scripts des deux types).

J’utiliserai le C# dans les prochains articles, pour sa syntaxe plus simple à appréhender à mes yeux, mais aussi car c’est un langage conçu depuis le début pour gérer de la programmation orientée objet.

Ne vous inquiétez pas pour l’instant : cette nouvelle interface, à première vue mystérieuse, deviendra bientôt limpide à vos yeux et nous allons voir tout cela étape par étape !
Voilà pour une présentation succincte de Unity ! Dans le prochain article, nous allons commencer à créer des « GameObjects », l’objet le plus basique du logiciel qui est déclinable en toutes sortes d’objets plus complexes qui, une fois paramétrés, agencés dans votre scène et associés à des scripts, nous permettront d’aboutir rapidement à votre premier jeu !