Come funzionano gli alberi di dialogo?

Cioè, cosa è collegato a cosa e come spostarsi tra le linee di discorso al termine di una conversazione secondaria?

Se hai esempi di un albero di dialogo di base in C #, pubblicali.

Il nome "albero di dialogo" è un po 'fuorviante: di solito sono semplici grafici diretti , non solo alberi . La struttura dei dati di base di tali grafici di solito consiste in una sorta di "dati" per i nodi, che rappresentano i punti in cui ci troviamo nella conversazione, e collegamenti da essi ad altri nodi, che rappresentano ciò che viene detto e fatto dai partecipanti e facoltativamente hanno condizioni su di loro per limitare la loro visibilità o script per eseguire varie azioni aggiuntive. Di solito uno dei nodi è il nodo iniziale predefinito (le etichette tipiche sono "ROOT", "START" e "SALUTO") e i nodi che non hanno collegamenti validi che conducono da loro terminano la conversazione.

Nella maggior parte dei casi, il grafico è rappresentato in memoria come un elenco di Nodestrutture dati, ognuna con almeno un ID e un elenco di 0..n Linkstrutture dati. L'elenco può essere locale all'NPC o globale; il secondo caso è preferito se si hanno molti NPC generici che possono essere consultati per informazioni, ma non offrono conversazioni specifiche per conto proprio. Il sistema stesso trova il nodo di conversazione iniziale per l'NPC, ricorda il suo ID come ID di conversazione corrente, presenta i collegamenti attualmente validi per il giocatore tra cui scegliere (o "[termina conversazione]" se non ci sono collegamenti validi) e attende ingresso. Quando il giocatore sceglie un collegamento, vengono visualizzate le linee di dialogo associate e tutti gli script associati vengono eseguiti.

Invece di avere regole e condizioni complesse sui collegamenti, puoi invece cavartela con una semplice variabile booleana "valida", che può quindi essere modificata dagli script di altri collegamenti di conversazione (incluso quello predefinito dal nodo iniziale) o dall'esterno meccanismi. In generale, questo approccio è più semplice ma adatto solo a giochi con pochissime conversazioni di questo tipo, poiché sposta la logica di "Quando è possibile questa risposta?" lontano dai dati di risposta stessi.

Si noti che la struttura che descrivo qui è leggermente diversa da quella di Byte56 in quanto i nodi non hanno bisogno di avere linee di dialogo; i collegamenti possono averli tutti. Nella variante più semplice, questo si traduce nella seguente struttura.

Gli alberi delle finestre di dialogo vengono creati con una struttura grafica diretta .

Il grafico viene attraversato in base alle decisioni di dialogo prese dal giocatore. Le opzioni della finestra di dialogo fornite all'utente provengono dai bordi che definiscono i percorsi verso altri nodi della finestra di dialogo.

I grafici diretti sono una struttura di dati di base. Possono essere facilmente implementati e probabilmente vorrai implementarlo da solo. Dal momento che vorrai personalizzare il grafico in base alle tue esigenze di dialogo.

Alcuni dei nodi potrebbero aver bisogno di condizioni speciali soddisfatte per mostrarsi. Ad esempio, il giocatore richiederebbe un'abilità nel discorso sopra X. Oppure il giocatore deve aver completato la missione Z prima di poter avanzare in un ramo della finestra di dialogo. Oppure devono chiedere qualcosa 4 volte prima che l'NPC ne discuterà con loro. Queste funzionalità saranno personalizzate per il tuo gioco. Ma vale la pena menzionare quando si implementano il nodo e l'attraversamento dei bordi. Ovviamente è sempre meglio iniziare con la forma più semplice e costruire da lì.

Ho creato un semplice sistema dialogtree: http://iki.fi/sol/d3/ il "motore" stesso è attualmente semplice, ma i dati prodotti dall'editore sono piuttosto semplici da usare in qualsiasi lingua. Lo strumento genera XML, JSON e un formato binario personalizzato.

Il concetto principale è piuttosto semplice:

Ogni nodo (che io chiamo "carta", come con l'analogo sopra) della finestra di dialogo è costituito da un testo di domanda e zero o più risposte. Ciascuna delle risposte porta ad un'altra carta.

C'è anche un sistema di tag in cui determinate risposte vengono mostrate all'utente solo se è impostato un tag (o un tag non è impostato). L'immissione di una scheda imposta (o disinserisce) i tag specificati.

Questo è praticamente tutto ciò che serve per qualsiasi tipo di dialogo in un gioco. Il "testo della domanda" può essere un testo semplice oppure può essere uno script per guidare l'animazione o quant'altro.

È possibile utilizzare TreeSharp e alberi comportamentali per modellare un sistema di dialogo. TreeSharp è una libreria che fornisce una semplice implementazione dell'albero del comportamento. IA robot per wow sono fatti con questo, quindi è maturo ... :)

La mia implementazione ha nodi che consentono di scegliere tra le risposte e ogni risposta può essere unita a un altro dialogo o un'azione, o una sequenza di azioni, o un nodo che consente di passare a un'altra finestra di dialogo ... o ciò che si desidera ...

Ho usato l'editor per il cervello per renderlo visivamente ... ma alla fine produce un codice c # basato sull'albero ...

http://www.youtube.com/watch?v=6uGg6bUYyUU

Vuoi un grafico diretto (possibilmente ciclico).

Modelleresti i nodi come oggetti e anche tutte le frecce in uscita nel nodo di un grafico sono modellate come oggetti separati. Il nodo ha un elenco di frecce in uscita e ogni oggetto "freccia" ha un testo da visualizzare e un riferimento alla destinazione. Non sono sicuro, ma penso che in C # gli oggetti facciano sempre riferimento, quindi devi solo creare prima gli oggetti, quindi quando crei gli oggetti freccia, collega lo stesso oggetto nel campo di destinazione di due frecce. (In C ++ useresti un tipo di riferimento o puntatore, Nodo e o Nodo *)

Per caricare cose come queste dal disco, di solito si dà a ciascun nodo un numero ID univoco, quindi si caricano tutti i nodi in un array in cui l'indice è quel numero univoco. Quindi le frecce vengono serializzate scrivendo il numero, non l'oggetto reale.

Quando si carica una freccia, si utilizzano l'array e l'ID per ottenere un riferimento al nodo a cui punta. Se scrivessi l'oggetto due volte, otterrai due oggetti separati che sembrano identici, il che probabilmente non è quello che volevi.

L'elaborazione di un albero di dialogo diventa molto semplice. Basta inserire il nodo radice in una currentNodevariabile, visualizzare l'intera cosa in qualche modo, quindi quando viene effettuata una scelta, impostare rootNodela destinazione della freccia. In pseudocodice:

Node&    currentNode = dialogTree.node[0];
while( currentNode != END_CONVERSATION_PSEUDO_NODE )
{
    stage.displayNode( currentNode );
    currentNode = stage.waitForUserToChoose();
}

Di recente ho dovuto sviluppare qualcosa di simile usando Node e ho optato per una struttura di file di testo molto semplice per rappresentare un grafico diretto dei nodi di conversazione.

Puoi vedere il codice e il formato di testo risultanti su:

https://github.com/scottbw/dialoguejs

Non supporta le condizioni o i trigger di eventi (ancora), ma è probabilmente abbastanza semplice da iniziare per molti sviluppatori di giochi.

(Il codice stesso in GPL, btw)