Dialogsystem för enhet

Ett dialogsystem i spel är en mekanism som möjliggör interaktiva och uppslukande samtal mellan spelaren och karaktärerna i spelvärlden. Den fungerar som en kommunikationskanal genom vilken spelare kan engagera sig med karaktärer som inte spelar (NPC) eller andra enheter, vilket ger ett sätt för berättande, uppdragsutveckling, karaktärsutveckling och världsbyggande.

Det primära målet med ett dialogsystem är att skapa en dynamisk och engagerande upplevelse för spelare genom att göra det möjligt för dem att göra val, påverka spelets narrativ och forma deras relationer med karaktärer i spelet. Ett väldesignat dialogsystem kan förbättra spelarens fördjupning, känslomässiga investeringar och omspelbarhet.

När det kommer till spelutveckling i Unity kan det vara ganska omfattande att skapa ett fullfjädrat dialogsystem från grunden, men det är möjligt att börja med ett förenklat exempel för att komma igång. Exemplet nedan kommer att täcka ett grundläggande textbaserat dialogsystem som använder C# och Unity UI-systemet. Kom ihåg att detta bara är en utgångspunkt, och kan utökas och anpassas utifrån de specifika behoven.

Skapa dialoghanteraren

• Skapa ett nytt skript, kalla det "DialogueManager" och klistra sedan in koden nedan i det:

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;
    }
}

För att ställa in UI-text- och knappobjekten i Unity för DialogueManager-skriptet, följ stegen nedan:

• I Unity-redigeraren högerklickar du i hierarkifönstret och väljer "UI -> Text" för att skapa ett nytt UI-textobjekt.
• Byt namn på UI Text-objektet till "DialogueText."
• Skapa på samma sätt tre UI Button-objekt: ett för val 1, ett för val 2 och ett för knappen "Next" (för att föra dialogen framåt).
• Namnge knapparna som "Choice1Button," "Choice2Button," respektive "NextButton".
• Placera UI-texten och knapparna på duken enligt din föredragna layout. Du kanske vill placera UI-texten i mitten av skärmen och knapparna under textrutan.
• Justera texttypsnitt, storlek, färg och andra egenskaper för UI-texten så att den passar ditt spels visuella stil.
• Anpassa utseendet på UI-knapparna, som att ändra deras färger och textetiketter.
• I Unity-redigeraren väljer du "DialogueManager" GameObject (det du skapade för att bifoga skriptet).
• I inspektörsfönstret kommer du att se skriptkomponenten "Dialogue Manager". Dra och släpp UI-text- och knappobjekten från hierarkifönstret till motsvarande offentliga fält i skriptkomponenten.
• Genom att tilldela dessa referenser kan DialogueManager-skriptet komma åt UI-texten och knapparna i scenen, vilket gör att det kan uppdatera textinnehållet och kontrollera deras synlighet efter behov under dialogen.
• Spara scenen för att spara variabeländringarna.

När du kör spelet eller interagerar med dialogutlösare ska DialogueManager kunna visa dialogtexten och valen med hjälp av de refererade användargränssnittselementen på duken.

Slutsats

Ett effektivt dialogsystem i spel ger spelare frihet, inflytande och en känsla av engagemang i den virtuella världen, vilket gör spelupplevelsen rikare och mer engagerande. När spelberättelser och interaktivt berättande blir mer sofistikerade spelar dialogsystem en allt viktigare roll för att forma spelarens resa och skapa minnesvärda spelupplevelser.