Nous avons vu dans la page précédente comment créer des variables. Nous allons maintenant apprendre à les manipuler davantage.

Les mathématiques : une histoire d'amour !

Si vous souhaitez créer des jeux vidéo, il est indispensable de maîtriser un minimum de mathématiques. Heureusement, les manipulations de base sont souvent suffisantes pour commencer. Cependant, plus vous aurez de connaissances en mathématiques, comme la géométrie, plus vous aurez de possibilités pour vos scripts.

Mais pour l'instant, restons simples. Nous allons commencer par des additions !

Exemple d'addition dans un script

Recopiez ce code dans votre script Stats.

using UnityEngine;

public class Stats : MonoBehaviour
{
    private int vie;

    void Start()
    {
        vie = 3 + 1;
	Debug.Log(vie);
    }

    void Update()
    {
        
    }
}

Lancez votre scène et observez la console. Elle affiche "4". L'addition a bien été effectuée.

Vous pouvez utiliser ce type de calcul pour tout : les multiplications (*), les soustractions (-) et les divisions (/) peuvent également être utilisées de la même manière, comme ci-dessous.

using UnityEngine;

public class Stats : MonoBehaviour
{
    private int vie;

    void Start()
    {
        vie = 10 / 2; // 10 divisé par 2 donc vie vaux 5
	Debug.Log(vie); // affiche 5
    }

    void Update()
    {
        
    }
}

Dans cette exemple, nous divison 10 par 2 avec la ligne ( 10 / 2 ), Faites bien attentions à ne pas confronde la division / avec les // qui signifie que le reste de la ligne est un commentaire. 

Additionner des variables

Vous pouvez aussi additionner des nombres avec des variables comme ceci :

using UnityEngine;

public class Stats : MonoBehaviour
{
    private int vie = 10;

    void Start()
    {
        vie = vie + 1;
	Debug.Log(vie); // affiche 11
    }

    void Update()
    {
        
    }
}

Dans cet exemple, nous modifions la valeur de vie pour qu'elle soit égale à elle-même + 1.

Vous pouvez aussi effectuer des opérations mathémathique sur deux variables du même type comme dans l'exemple suivant.

Exemple de soustraction entre deux variables

using UnityEngine;

public class Stats : MonoBehaviour
{
    private int vie = 10;
    private int degat = 3;

    void Start()
    {
        vie = vie - degat;
	Debug.Log(vie); // affiche 7
    }

    void Update()
    {
        
    }
}

Avec cet exemple, vous commencez à voir où nous voulons en venir. En effet, la création d'un jeu vidéo repose en grande partie sur les mathématiques. Modifier une valeur, comme la variable vie, chaque fois que notre personnage subit des dégâts, relève de simples opérations mathématiques de base. Il ne nous reste plus qu'à trouver comment afficher cela pour le joueur, et nous serons alors très proches de créer un jeu de type RPG.

Les opérateurs d'assignation : un raccourci

Souvent, vous aurez besoin d'ajouter un nombre à une variable, comme nous l'avons fait dans l'exemple précédent.

using UnityEngine;

public class Stats : MonoBehaviour
{
    private int vie = 10;

    void Start()
    {
        vie = vie + 1;
	Debug.Log(vie); // affiche 11
    }

    void Update()
    {
        
    }
}

 Il existe une manière plus simple de faire cette opération en utilisant un opérateur d'assignation. Concrètement, cela revient à écrire vie += 1; 

using UnityEngine;

public class Stats : MonoBehaviour
{
    private int vie = 10;

    void Start()
    {
        vie += 1;
	Debug.Log(vie); // affiche 11
    }

    void Update()
    {
        
    }
}

Le signe += indique que la variable vie prendra sa valeur actuelle, à laquelle sera ajoutée la valeur à droite du signe =.

Vous pouvez utiliser les autres opérateurs mathématiques de la même manière, comme dans l'exemple suivant.

using UnityEngine;

public class Stats : MonoBehaviour
{
    private int vie = 10;

    void Start()
    {
        vie -= 1;
	Debug.Log(vie); // affiche 9
    }

    void Update()
    {
        
    }
}

Je vous conseille de prendre le temps de bien comprendre ce concept.

Un raccourci encore plus efficace pour incrémenter ou décrémenter de 1 :

Si vous souhaitez augmenter ou diminuer la valeur de votre variable de 1, il existe également une autre méthode. Il vous suffit d'écrire vie++ pour incrémenter ou vie-- pour décrémenter, comme ceci.

using UnityEngine;

public class Stats : MonoBehaviour
{
	public int vie = 2;

    void Start()
    {
		vie++;
		Debug.Log(vie); // affiche 3
    }

    void Update()
    {    

    } 
}

Tester avec Update

Essayez aussi d’utiliser la méthode Update pour tester ce type d’opération. Par exemple :

using UnityEngine;

public class Stats : MonoBehaviour
{
    private int vie = 10;

    void Start()
    {

    }

    void Update()
    {
        vie++;
	Debug.Log(vie); // affiche un nombre qui grandit de 1 .       
    }
}

Dans cet exemple, la valeur de vie augmente de 1 à chaque fois que le jeu calcule une nouvelle image (frame). 

 

Vous remarquerez que la variable s'incrémente à l'infini, car Update s'exécute en boucle. De plus, à la fin de chaque boucle, toutes les modifications de variables sont conservées et utilisées pour la prochaine itération, ce qui a pour effet une augmentation infinie de la valeur de vie. 

Additionner des textes !

Les nombres ne sont pas les seules choses qu'on peut additionner. Il est également possible de concaténer des chaînes de caractères, comme l'exemple suivant.

using UnityEngine;

public class Stats : MonoBehaviour
{
    private string nom = "Bob";

    void Start()
    {
          nom = nom + " subit une attaque" ;
          Debug.Log(nom); // affiche Bob subit une attaque
    }

    void Update()
    {    

    }
}

Encore une fois,  pensez à toutes les possibilités qu’offre cette simple ligne de code. Cela pourrait, par exemple, être utilisé pour afficher le nom d’un joueur dans un dialogue. 

Mélanger les types de données

Comme je l’ai mentionné précédemment, vous pouvez généralement effectuer des opérations mathématiques que entre des variables du même type. Cependant, il y a quelques exceptions.

Par exemple, une variable de type string peut contenir des "nombres". Si vous additionnez une chaîne de caractères avec un nombre, ce dernier sera automatiquement converti en texte. Essayez ce code :

using UnityEngine;

public class Stats : MonoBehaviour
{
        private string nom = "Rei";
	private int nombreDeJumelle = 2; 
	private string dialogue;

    void Start()
    {
        dialogue = "je suis " + nom + " l'une des " + nombreDeJumelle + " jumelles";
	Debug.Log(dialogue);
    }

    void Update()
    {    

    } 
}

Et vous obtiendrez ce résultats.

Comme vous pouvez le voir, la variable dialogue, qui est une string, contient à la fois une autre chaîne de caractères et un entier. Le nombre sera automatiquement converti en texte.

Essayez maintenant l’inverse, en ajoutant un string à un int comme ce code :

using UnityEngine;

public class Stats : MonoBehaviour
{

    private int vie = 2;
    private string soin = "10";


    void Start()
    {
        vie = vie + soin;
	Debug.Log(vie);
    }

    void Update()
    {    

    } 
}

Cette fois, vous obtiendrez une erreur. En effet, vous ne pouvez pas additionner un string à un int directement.

 Cela nous amène à la conversion des variables.

Convertir des variables

En règle générale, vous ne pouvez pas mélanger des variables de types différents, mais il est possible de convertir une variable d’un type à un autre.

Par exemple, si vous souhaitez additionner un int et un float, vous devez convertir les variables pour qu’elles aient le même type. Voici un exemple :

using UnityEngine;

public class Stats : MonoBehaviour
{

    private int vie = 2;
    private float soin = 1.5f;


    void Start()
    {
        vie = vie + (int)soin;
	Debug.Log(vie);
    }

    void Update()
    {    

    } 
}

Dans cet exemple, la conversion (int) permet de convertir la variable soin de type float en int. Le résultat est un nombre entier (3) car la partie décimale est perdue lors de la conversion. Si vous essayez de retirer (int), une erreur se produira.

Vous pouvez utiliser d'autres types de conversion, tels que (float), (byte), etc.

Essayons l'inverse, en additionnant un int avec un float :

using UnityEngine;

public class Stats : MonoBehaviour
{

    private float vie = 2.5f;
    private int soin = 1;


    void Start()
    {
        vie = vie + soin;
	Debug.Log(vie);
    }

    void Update()
    {    

    } 
}

Ici, il n’est pas nécessaire de convertir la variable soin en float, car le type float peut contenir à la fois des entiers et des nombres à virgule flottante. On peut donc un entier dans un flottant, mais l’inverse n’est pas possible sans conversion.

En reprenant notre analogie qui compare les variable à des boîtes. Nous pouvons penser à mettre une petit boite (int) dans un grande (float), mais l'inverse ne serait pas possible.

Pour vous entraîner davantage, utilisez les types de variables du tableau pour les entiers et celui pour les nombres à virgule. Par exemple, essayez de mettre une variable de type byte dans une int et vice versa. Certains cas fonctionneront sans conversion, d'autres non. Essayez de bien comprendre pourquoi cela se produit.

Convertir du texte en nombre

Les variables de type string sont spéciales. Elles ne peuvent pas être directement converties en nombres en utilisant (int) ou (float). Vous devez utiliser la méthode int.Parse pour effectuer cette conversion.

using UnityEngine;

public class Stats : MonoBehaviour
{

    private int vie = 10;
    private string soin = "2";


    void Start()
    {
       vie = vie + int.Parse(soin);
       Debug.Log(vie); // affiche 12
    }

    void Update()
    {    

    } 
}

Ici, nous avons utilisé la méthode int.Parse pour convertir la variable soin, qui est une string, en un int. Cela permet d'ajouter le nombre contenu dans soin à la variable vie.

J'aimerais attirer votre attention sur le fait que la conversion d'une variable est temporaire. Elle n'est effectuée que pour permettre à la variable vie de notre exemple de l'utiliser. Si vous réutilisez plus tard la variable soin, elle restera de type string.

Si vous souhaitez conserver la conversion, vous devez l'enregistrer dans une nouvelle variable, comme ceci :

using UnityEngine;

public class Stats : MonoBehaviour
{
	private string soinString = "2";
	private int soinInt;


    void Start()
    {
		soinInt = int.Parse(soinString);
		Debug.Log(soinInt);
    }

    void Update()
    {    

    } 
}

et ensuite vous n'utiliserez que la nouvelle variable (soinInt) pour garder la conversion.

Remarque : en C#, il n'est pas nécessaire de libérer manuellement la mémoire allouée à une variable lorsqu'elle n'est plus utilisée. En général, cela se fait automatiquement, contrairement à d'autres langages de programmation.

Conclusion

Dans ce chapitre, vous avez vu de nombreux exemples de manipulation de variables, ainsi que des concepts importants comme la conversion de types de données. Ces notions sont fondamentales en programmation et sont communes à la plupart des langages.

Voici les points essentiels à retenir :

1. Effectuer des opérations mathématiques sur des variables.
2. Convertir des variables d’un type à un autre.

Ces concepts sont utilisés quotidiennement dans le développement de jeux vidéo. Vous les rencontrerez sans doute des milliers de fois au cours de votre apprentissage.

Si vous vous sentez prêt à continuer, dans la prochaine page, nous verrons comment utiliser les conditions pour, par exemple, afficher la mort d'un personnage lorsque sa vie atteint zéro.

À bientôt !