Système de dialogue pour l'unité

Un système de dialogue dans les jeux est un mécanisme qui permet des conversations interactives et immersives entre le joueur et les personnages dans le monde du jeu. Il sert de canal de communication par lequel les joueurs peuvent interagir avec des personnages non-joueurs (PNJ) ou d'autres entités, fournissant un moyen de narration, de progression de quête, de développement de personnage et construction du monde.

L'objectif principal d'un système de dialogue est de créer une expérience dynamique et attrayante pour les joueurs en leur permettant de faire des choix, d'influencer le récit du jeu et de façonner leurs relations avec les personnages du jeu. Un système de dialogue bien conçu peut améliorer l'immersion du joueur, l'investissement émotionnel et la rejouabilité.

En ce qui concerne le développement de jeux dans Unity, la création d'un système de dialogue complet à partir de zéro peut être assez complexe, mais il est possible de commencer avec un exemple simplifié pour commencer. L'exemple ci-dessous couvrira un système de dialogue textuel de base utilisant C# et l'interface utilisateur Unity système. N'oubliez pas qu'il ne s'agit que d'un point de départ et qu'il peut être étendu et personnalisé en fonction des besoins spécifiques.

Créer le gestionnaire de dialogue

Créez un nouveau script, appelez-le "DialogueManager", puis collez-y le code ci-dessous:

using System.Collections;
using UnityEngine;
using UnityEngine.UI;

public class DialogueManager : MonoBehaviour
{
    public Text dialogueText;
    public Button choice1Button;
    public Button choice2Button;
    public Button nextButton;

    private Dialogue currentDialogue;
    private int currentLineIndex = 0;

    void Start()
    {
        // You can load your dialogue data from an external source (e.g., JSON, XML) or create it programmatically.
        // For simplicity, we'll create a sample dialogue here.
        currentDialogue = CreateSampleDialogue();

        // Set up event listeners for buttons
        choice1Button.onClick.AddListener(OnChoice1Selected);
        choice2Button.onClick.AddListener(OnChoice2Selected);
        nextButton.onClick.AddListener(OnNextButtonClicked);

        // Start the dialogue
        StartDialogue();
    }

    private void StartDialogue()
    {
        currentLineIndex = 0;
        DisplayLine(currentDialogue.lines[currentLineIndex]);
    }

    private void DisplayLine(DialogueLine line)
    {
        dialogueText.text = line.text;
        choice1Button.gameObject.SetActive(line.hasChoice);
        choice2Button.gameObject.SetActive(line.hasChoice);
        nextButton.gameObject.SetActive(!line.hasChoice);
    }

    private void OnNextButtonClicked()
    {
        currentLineIndex++;
        if (currentLineIndex < currentDialogue.lines.Length)
        {
            DisplayLine(currentDialogue.lines[currentLineIndex]);
        }
        else
        {
            // Dialogue is over
            EndDialogue();
        }
    }

    private void OnChoice1Selected()
    {
        HandleChoice(currentDialogue.lines[currentLineIndex].choice1);
    }

    private void OnChoice2Selected()
    {
        HandleChoice(currentDialogue.lines[currentLineIndex].choice2);
    }

    private void HandleChoice(Choice choice)
    {
        // Handle the chosen choice (e.g., change variables, trigger events)
        Debug.Log("Selected Choice: " + choice.text);

        // Advance to the next line
        currentLineIndex++;
        DisplayLine(currentDialogue.lines[currentLineIndex]);
    }

    private void EndDialogue()
    {
        // Reset the dialogue UI or close the dialogue box
        Debug.Log("End of Dialogue");
    }

    // Sample dialogue data (you can replace this with loading from an external source)
    private Dialogue CreateSampleDialogue()
    {
        Dialogue dialogue = new Dialogue();

        dialogue.lines = new DialogueLine[]
        {
            new DialogueLine("Hello there! Welcome to the Unity dialogue system example.", false),
            new DialogueLine("What would you like to do?", true, new Choice("Go on an adventure"), new Choice("Stay here")),
            new DialogueLine("Great choice! Have a fantastic adventure!", false),
            new DialogueLine("That's okay. Sometimes staying in one place can be just as exciting!", false),
            new DialogueLine("Thanks for trying out the Unity dialogue system example!", false)
        };

        return dialogue;
    }
}

[System.Serializable]
public class Dialogue
{
    public DialogueLine[] lines;
}

[System.Serializable]
public class DialogueLine
{
    public string text;
    public bool hasChoice;
    public Choice choice1;
    public Choice choice2;

    public DialogueLine(string text, bool hasChoice, Choice choice1 = null, Choice choice2 = null)
    {
        this.text = text;
        this.hasChoice = hasChoice;
        this.choice1 = choice1;
        this.choice2 = choice2;
    }
}

[System.Serializable]
public class Choice
{
    public string text;

    public Choice(string text)
    {
        this.text = text;
    }
}

Pour configurer les objets UI Text et Button dans Unity pour le script DialogueManager, suivez les étapes ci-dessous:

Dans l'éditeur Unity, cliquez avec le bouton droit dans la fenêtre Hiérarchie et sélectionnez "UI -> Text" pour créer un nouvel objet Texte de l'interface utilisateur.
Renommez l'objet Texte de l'interface utilisateur en "DialogueText."
De même, créez trois objets Bouton d'interface utilisateur: un pour le Choix 1, un pour le Choix 2 et un pour le bouton "Next" (pour faire avancer le dialogue).
Nommez les boutons comme "Choice1Button," "Choice2Button," et "NextButton" respectivement.
Positionnez le texte et les boutons de l'interface utilisateur sur le canevas en fonction de votre disposition préférée. Vous pouvez placer le texte de l'interface utilisateur au centre de l'écran et les boutons sous la zone de texte.
Ajustez la police, la taille, la couleur et d'autres propriétés du texte de l'interface utilisateur pour l'adapter au style visuel de votre jeu.
Personnalisez l'apparence des boutons de l'interface utilisateur, par exemple en modifiant leurs couleurs et leurs libellés de texte.
Dans l'éditeur Unity, sélectionnez le "DialogueManager" GameObject (celui que vous avez créé pour attacher le script).
Dans la fenêtre Inspecteur, vous verrez le composant de script "Dialogue Manager". Faites glisser et déposez les objets Texte de l'interface utilisateur et Bouton de la fenêtre Hiérarchie vers les champs publics correspondants dans le composant de script.
En attribuant ces références, le script DialogueManager peut accéder au texte et aux boutons de l'interface utilisateur dans la scène, ce qui lui permet de mettre à jour le contenu du texte et de contrôler leur visibilité selon les besoins pendant le dialogue.
Enregistrez la scène pour enregistrer les modifications de variables.

Lors de l'exécution du jeu ou de l'interaction avec les déclencheurs de dialogue, le DialogueManager doit pouvoir afficher le texte du dialogue et les choix à l'aide des éléments d'interface utilisateur référencés sur le canevas.

Conclusion

Un système de dialogue efficace dans les jeux offre aux joueurs une agence, un impact et un sentiment d'implication dans le monde virtuel, ce qui rend l'expérience de jeu plus riche et plus engageante. Alors que les récits de jeu et la narration interactive deviennent plus sophistiqués, les systèmes de dialogue jouent un rôle de plus en plus vital dans le façonnement du parcours du joueur et la création d'expériences de jeu mémorables.

unité unity3d dialogue dialogue système ds script programmation codage exemple didacticiel canevas interface utilisateur texte bouton contrôleur