Bienvenue dans cette dernière partie théorique du chapitre 2 !

Nous allons maintenant apprendre à créer des méthodes. 

Qu'est-ce qu'une méthode ?

Pour simplifier, une méthode est un bloc de code que vous pouvez exécuter en appelant son nom. Par exemple, dans un jeu vidéo comme Super Mario Bros., le personnage peut sauter. Vous pourriez donc appeler la méthode Sauter() pour exécuter le bloc de code responsable du saut.

Comment créer une méthode ?

Créer une méthode est très simple. Tout d'abord, vous devez définir si la méthode va retourner une valeur ou non. Commençons par la méthode la plus simple, qui ne retourne aucune valeur.

Voici comment faire :

using UnityEngine;

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

    void Start()
    {
	Attaque();
    }

    void Update()
    {    

    } 

    void Attaque()
    {
        vie = vie - forceAttaque;
	Debug.Log("Vous vous frapez au visage....vous subisé 2 point de dégat");
    }
}

En regardant le code, vous remarquerez le bloc de code Attaque(). Puisque la méthode n'est pas destinée à renvoyer un résultat, mais plutôt à exécuter une action, nous utilisons le mot-clé void pour la déclarer. Ensuite, vous devez choisir un nom pour votre méthode, de préférence un nom explicite qui décrit ce qu'elle fait. Dans notre exemple, j'ai nommé la méthode Attaque. Vous devez ensuite ajouter deux parenthèses () pour indiquer qu'il s'agit bien d'une méthode. Et pour terminer, le code à exécuter est placé entre deux accolades { }.

Vous remarquerez l'énorme ressemblance avec les méthodes Start() et Update(). C'est normal, car ce sont aussi des méthodes, mais elles sont créées par Unity, proviennent de la classe MonoBehaviour et sont appelées automatiquement par Unity.

Lancer une méthode

Si vous testez le code précédent, rien ne se passe. C'est normal : vous avez créé une méthode, mais vous ne l'avez pas utilisée. Pour l'utiliser, il suffit de l'appeler.

Avant de faire cela, je vous invite à modifier la valeur de vie dans l'Inspector. Comme nous avons défini vie comme public, vous pourrez l'observer et la modifier dans l'Inspector. Par exemple, mettez une valeur de 10.

Maintenant, appelons la méthode. Plus tard, nous apprendrons à la déclencher via les touches du clavier, mais pour l'instant, utilisons la méthode Start() pour l'appeler une seule fois, comme ceci : 

using UnityEngine;

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

    void Start()
    {
	Attaque();
    }

    void Update()
    {    

    } 

    void Attaque()
    {
        vie = vie - forceAttaque;
        Debug.Log("Vous vous frapez au visage....vous subisé 2 point de dégat");
    }
}

Comme vous pouvez le voir, c'est très simple. Vous écrivez simplement le nom de la méthode suivi des parenthèses. Encore une fois, les parenthèses indiquent que vous souhaitez utiliser la méthode Attaque() et non une variable du même nom.

Observez la console, mais aussi l'Inspector.

Félicitations, vous venez d'infliger 2 points de dégâts à votre personnage ! 

Nous nous rapprochons maintenant de plus en plus des mécanismes d'un jeu vidéo. Pour l'instant, nous utilisons la console pour observer les effets, ce qui n'est pas très ludique. Cependant, à l'avenir, vous pourrez utiliser le même concept pour calculer les dégâts, tout en ajoutant des animations et l'affichage des points de vie à l'écran, rendant le tout plus interactif. 

Les méthodes qui retournent une valeur

Imaginons que votre jeu calcule les dégâts d'une manière un peu plus complexe, par exemple en prenant en compte la défense du personnage et un multiplicateur lié à l'élément magique de l'attaque. Comment procéder ?

Nous pourrions créer une méthode dédiée à ce calcul, puis récupérer la valeur retournée pour l'utiliser dans notre méthode Attaque(). Prenons l'exemple suivant :

using UnityEngine;

public class Stats : MonoBehaviour
{
    public int vie;
    private int forceAttaque = 2;
    public int elementAttaque = 1 ;// 1 = feu , 2  = glace, 3 = terre

    void Start()
    {
	Attaque();
    }

    void Attaque()
    {
	Debug.Log("Dégats subits: " + CalculPuissanceAttaque());

        vie = vie - CalculPuissanceAttaque();

    }

    int CalculPuissanceAttaque()
    {
	int resultats = 0;
	int resistance = 1;
	int multiplicateur;

	if(elementAttaque == 1)
	{
		multiplicateur = 10;
	}
	else if(elementAttaque == 2)
	{
		multiplicateur = 1;
	}
	else
	{
		multiplicateur = 2;
	}

	resultats = (forceAttaque * multiplicateur) - resistance;
	return resultats;
    }
}

Le code semble plus complexe, mais il est en réalité assez simple. Lorsque vous créez une méthode qui doit retourner une valeur, vous devez spécifier le type de la valeur retournée. Ici, nous utilisons int pour indiquer que la méthode CalculPuissanceAttaque() va retourner un entier. Ensuite, dans le bloc de code, nous utilisons le mot-clé return pour renvoyer la valeur souhaitée, dans ce cas, la variable resultats, après avoir effectué quelques calculs.

Puisque cette méthode renvoie une valeur, nous pouvons l'utiliser dans la ligne vie = vie - CalculPuissanceAttaque(); comme si c'était un entier normal.

Remarque : Amuser vous! Vous pouvez modifier la valeur de la variable elementAttaque dans l'Inspector pour obtenir des résultats différents, car elle influence le calcul du multiplicateur(voir la condition)

Observer dans l'exemple, qui est aussi possible d'appeler une méthode à l'intérieur d'une autre méthode. Vous pouvez le faire autant que nécessaire.

Les paramètres d'une méthode

Vous vous demandez probablement pourquoi nous utilisons des parenthèses dans une méthode. En fait, il est possible d'ajouter des paramètres à une méthode. Un exemple évident est la méthode Log de l'objet Debug. Vous la reconnaissez, n'est-ce pas ?

Debug.Log("Je suis un paramètre!");

Pour ajouter des paramètres à une méthode, vous devez spécifier leur type lors de la déclaration de la méthode. Voici un exemple :

using UnityEngine;

public class Stats : MonoBehaviour
{
    public int vie;

    void Start()
    {
	Exemple(vie);
    }

    void Exemple(int parametre)
    {
	Debug.Log(parametre);
    }

}

Dans cet exemple, la méthode Exemple prend un paramètre de type int. Le nom que vous lui donnez, ici parametre, peut ensuite être utilisé dans le corps de la méthode. Ainsi, dans la ligne Exemple(vie);, la valeur de la variable vie sera passée comme argument, et la méthode Exemple affichera sa valeur via Debug.Log(parametre).

Utiliser plusieurs paramètres

Il est également possible d'utiliser plusieurs paramètres dans une méthode. Pour cela, vous les séparez par des virgules. Voici un exemple :

using UnityEngine;

public class Stats : MonoBehaviour
{
    public int vie;
    public string texte;

    void Start()
    {
	Exemple(vie, texte);
    }

    void Exemple(int parametre1, String parametre2)
    {
 	Debug.Log(parametre1); // affice le int passé en paramétre
	Debug.Log(parametre2); // affiche le String passé en paramétre
    }

}

Vous pouvez déclarer autant de paramètres que nécessaire, tant que vous veillez à bien les séparer par des virgules. 

C'est terminé !

Et voilà, vous avez terminé la partie théorique du chapitre 2. J'espère que cela n'a pas été trop difficile pour vous. Il nous reste encore beaucoup de choses à apprendre, mais maintenant que vous avez les bases de la programmation en C#, le reste devrait vous être beaucoup plus facile à assimiler.

Vous avez de la chance ! Apprendre la programmation lorsque l'on n'en a jamais fait est loin d'être simple. Heureusement, tous les langages de programmation reposent sur les mêmes concepts de base. Vous pouvez désormais apprendre d'autres langages de programmation beaucoup plus facilement, car une variable, une boucle, une méthode, etc., restent les mêmes, peu importe le langage utilisé. Seule la syntaxe peut varier légèrement.

Maintenant que vous savez créer des méthodes, je vous invite à passer à la partie pratique de ce chapitre. Vous y mettrez en pratique les notions vues ici, mais aussi de nouvelles idées. La prochaine partie pratique sera dédiée à la création d'un combat tour par tour.

À la prochaine, nous nous reverrons bientôt !