Créer un gestionnaire de jeu simple dans Unity

Un Game Manager dans Unity est un script ou un système central qui supervise et contrôle les mécanismes et la logique de base d'un jeu. Il gère généralement les états du jeu (par exemple, démarrage, pause, fin), la progression du joueur, les scores, les niveaux et les paramètres globaux. Le Game Manager est essentiel pour garantir une structure propre dans votre projet et éviter le code redondant. Dans ce tutoriel, nous allons créer un Game Manager de base pour gérer l'état du jeu et le suivi des scores.

Étape 1: Mise en place de la scène

Pour commencer, préparez une scène Unity simple:

1. Créez un nouveau projet Unity 3D.
2. Ajoutez une disposition de niveau de base, comme un Plane pour le sol et quelques objets pour les éléments de jeu.
3. Créez un canevas d'interface utilisateur pour afficher des informations telles que le score.

Étape 2: création du script du gestionnaire de jeu

Le gestionnaire de jeu sera un singleton pour garantir qu'il soit facilement accessible et qu'une seule instance existe tout au long du jeu. Écrivons le script:

1. Cliquez avec le bouton droit de la souris dans le panneau Projet et sélectionnez Créer > Script C#. Nommez-le GameManager.
2. Ouvrez le script dans votre éditeur de code et remplacez son contenu par ce qui suit:

using UnityEngine;

public class GameManager : MonoBehaviour
{
    public static GameManager Instance; // Singleton instance

    public int score = 0; // Player's score
    public bool isGameActive = true; // Is the game running?

    void Awake()
    {
        // Ensure there is only one instance of GameManager
        if (Instance == null)
        {
            Instance = this;
            DontDestroyOnLoad(gameObject); // Persist across scenes
        }
        else
        {
            Destroy(gameObject); // Destroy duplicate instances
        }
    }

    // Method to increase the score
    public void AddScore(int points)
    {
        if (isGameActive)
        {
            score += points;
            Debug.Log("Score: " + score);
        }
    }

    // Method to end the game
    public void EndGame()
    {
        isGameActive = false;
        Debug.Log("Game Over!");
        // Additional logic to handle game over, like displaying UI
    }
}

Étape 3: Ajout du gestionnaire de jeu à la scène

Maintenant, ajoutons le Game Manager à la scène:

1. Créez un GameObject vide dans la hiérarchie et nommez-le GameManager.
2. Faites glisser et déposez le script GameManager sur le GameObject.
3. Assurez-vous qu'il n'y a pas de GameObjects GameManager en double dans la scène.

Étape 4: Mise à jour de la logique de jeu

Utilisons le gestionnaire de jeu pour gérer les interactions entre les joueurs. Par exemple, nous allons modifier les objets de jeu pour interagir avec le gestionnaire de jeu:

1. Créez un nouveau script appelé Target pour les objets avec lesquels le joueur peut interagir.
2. Utilisez le code suivant pour le script cible:

using UnityEngine;

public class Target : MonoBehaviour
{
    public int pointValue = 10; // Points awarded for interacting with this target

    void OnMouseDown()
    {
        if (GameManager.Instance.isGameActive)
        {
            // Add points to the score
            GameManager.Instance.AddScore(pointValue);

            // Destroy the target
            Destroy(gameObject);
        }
    }
}

Ce script suppose que le joueur interagit avec les objets en cliquant dessus. Vous pouvez l'adapter aux mécanismes de votre jeu, comme les collisions ou les déclencheurs.

Étape 5: Affichage du score

Pour afficher le score au joueur:

1. Créez un élément d'interface utilisateur Text dans le canevas et nommez-le ScoreText.
2. Créez un nouveau script appelé ScoreUI et attachez-le au Canvas.
3. Utilisez le code suivant pour mettre à jour l’affichage du score:

using UnityEngine;
using UnityEngine.UI;

public class ScoreUI : MonoBehaviour
{
    public Text scoreText;

    void Update()
    {
        if (GameManager.Instance != null)
        {
            scoreText.text = "Score: " + GameManager.Instance.score;
        }
    }
}

Faites glisser l’élément d’interface utilisateur ScoreText dans le champ ScoreText de l’inspecteur.

Étape 6: Test du gestionnaire de jeu

Pour tester votre Game Manager:

1. Exécutez la scène et interagissez avec les objets qui utilisent le script Target.
2. Observez la mise à jour du score dans l'interface utilisateur lorsque vous interagissez avec les cibles.
3. Appelez la méthode EndGame (par exemple, en utilisant un déclencheur ou un bouton) pour tester la fin du jeu.

Améliorations facultatives

Vous pouvez étendre les fonctionnalités du Game Manager avec ces fonctionnalités:

• Gestion des niveaux: Chargez de nouveaux niveaux ou réinitialisez la scène à la fin du jeu.
• Minuterie de jeu: Ajoutez un compte à rebours pour défier les joueurs.
• Sauvegarde de la progression: Stockez et récupérez la progression du joueur à l'aide de PlayerPrefs ou d'un système de sauvegarde.
• Menu Pause: Implémenter un menu de pause pour arrêter le jeu et afficher les options.

Conclusion

Nous avons créé un gestionnaire de jeu simple pour gérer l'état du jeu et le suivi des scores dans Unity. Le gestionnaire de jeu centralise la logique de base, ce qui rend votre projet plus organisé et évolutif. Expérimentez des fonctionnalités supplémentaires pour adapter le gestionnaire de jeu aux besoins de votre jeu.