Dialogsystem for enhed

Et dialogsystem i games er en mekanisme, der giver mulighed for interaktive og fordybende samtaler mellem spilleren og karaktererne i spilverdenen. Det fungerer som en kommunikationskanal, hvorigennem spillere kan engagere sig i ikke-spillerfigurer (NPC'er) eller andre entiteter, hvilket giver et middel til historiefortælling, missionsprogression, karakterudvikling og verdensopbygning.

Det primære mål med et dialogsystem er at skabe en dynamisk og engagerende oplevelse for spillere ved at sætte dem i stand til at træffe valg, påvirke spillets fortælling og forme deres forhold til karakterer i spillet. Et veldesignet dialogsystem kan forbedre spillerens fordybelse, følelsesmæssige investering og genspilbarhed.

Når det kommer til spiludvikling i Unity, kan det være ret omfattende at skabe et fuldgyldigt dialogsystem fra bunden, men det er muligt at starte med et forenklet eksempel for at komme i gang. Eksemplet nedenfor vil dække et grundlæggende tekstbaseret dialogsystem, der bruger C# og Unity UI systemet. Husk at dette kun er et udgangspunkt, og kan udvides og tilpasses ud fra de specifikke behov.

Opret Dialog Manager

Opret et nyt script, kald det "DialogueManager", og indsæt derefter koden nedenfor 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ølg nedenstående trin for at konfigurere UI-tekst- og knapobjekterne i Unity til DialogueManager-scriptet:

I Unity-editoren skal du højreklikke i hierarkivinduet og vælge "UI -> Text" for at oprette et nyt UI-tekstobjekt.
Omdøb UI-tekstobjektet til "DialogueText."
På samme måde skal du oprette tre UI Button-objekter: et til valg 1, et til valg 2 og et til knappen "Next" (til at fremme dialogen).
Navngiv knapperne som henholdsvis "Choice1Button," "Choice2Button," og "NextButton".
Placer UI-teksten og -knapperne på lærredet i overensstemmelse med dit foretrukne layout. Du vil måske placere UI-teksten i midten af skærmen og knapperne under tekstboksen.
Juster tekstskrifttype, størrelse, farve og andre egenskaber for UI-teksten, så den passer til dit spils visuelle stil.
Tilpas udseendet af UI-knapperne, såsom at ændre deres farver og tekstetiketter.
I Unity-editoren skal du vælge "DialogueManager" GameObject (det du oprettede for at vedhæfte scriptet).
I Inspector-vinduet vil du se "Dialogue Manager" script-komponenten. Træk og slip UI-tekst- og knapobjekterne fra hierarkivinduet til de tilsvarende offentlige felter i scriptkomponenten.
Ved at tildele disse referencer kan DialogueManager-scriptet få adgang til UI-teksten og -knapperne i scenen, så det kan opdatere tekstindholdet og kontrollere deres synlighed efter behov under dialogen.
Gem scenen for at gemme de variable ændringer.

Når du kører spillet eller interagerer med dialogtriggerne, bør DialogueManageren være i stand til at vise dialogteksten og valg ved hjælp af de refererede UI-elementer på lærredet.

Konklusion

Et effektivt dialogsystem i spil giver spillerne handlekraft, gennemslagskraft og en følelse af involvering i den virtuelle verden, hvilket gør spiloplevelsen rigere og mere engagerende. Efterhånden som spilfortællinger og interaktiv historiefortælling bliver mere sofistikeret, spiller dialogsystemer en stadig vigtigere rolle i at forme spillerens rejse og skabe mindeværdige spiloplevelser.

unity unity3d dialog dialog system ds scripting programmering kodning eksempel tutorial lærred ui tekst knap controller