Scripting e Cinematica senza thread

Ho avuto difficoltà a implementare gli script nel mio motore di gioco. Ho solo alcuni requisiti: dovrebbe essere intuitivo, non voglio scrivere un linguaggio personalizzato, parser e interprete e non voglio usare il threading. (Sono certo che esiste una soluzione più semplice; non ho bisogno della seccatura di più thread di logica di gioco.) Ecco uno script di esempio, in Python (aka pseudocodice):

def dramatic_scene(actors):
    alice = actors["alice"]
    bob = actors["bob"]

    alice.walk_to(bob)
    if bob.can_see(alice):
        bob.say("Hello again!")
    else:
        alice.say("Excuse me, Bob?")

Quella parte epica della narrazione pone problemi di implementazione. Non posso semplicemente valutare l'intero metodo in una volta, perché walk_torichiede tempo di gioco. Se ritorna subito, Alice inizia a camminare verso Bob, e (nella stessa cornice) saluta (o si saluta). Ma se walk_toè una chiamata bloccante che ritorna quando raggiunge Bob, allora il mio gioco si blocca, perché sta bloccando lo stesso filo di esecuzione che farebbe camminare Alice.

Ho pensato di rendere ogni funzione accodata in un'azione: alice.walk_to(bob)spingevo un oggetto in una coda, che sarebbe saltato fuori dopo che Alice avesse raggiunto Bob, dovunque fosse. È più sottilmente rotto: il iframo viene valutato immediatamente, quindi Bob potrebbe salutare Alice anche se le si volge le spalle.

In che modo altri motori / persone gestiscono gli script senza creare thread? Sto iniziando a cercare idee in aree non sviluppate dal gioco, come catene di animazioni jQuery. Sembra che ci dovrebbero essere alcuni buoni schemi per questo tipo di problema.

Il modo in cui qualcosa come Panda fa questo è con i callback. Invece di bloccare sarebbe qualcosa di simile

def dramatic_scene(actors):
    alice = actors["alice"]
    bob = actors["bob"]

    def cb():
        if bob.can_see(alice):
            bob.say("Hello again!")
        else:
            alice.say("Excuse me, Bob?")
    alice.walk_to(bob, cb)

Avere una richiamata completa consente di concatenare questo tipo di eventi nel modo desiderato.

EDIT: esempio JavaScript poiché ha una sintassi migliore per questo stile:

function dramatic_scene(actors) {
    var alice = actors.alice;
    var bob = actors.bob;
    alice.walk_to(bob, function() {
        if(bob.can_see(alice)) {
            bob.say('Hello again!');
        } else {
            alice.say('Excuse me, Bob?');
        }
     });
}

Il termine che si desidera cercare qui è " coroutine " (e in genere la parola chiave lingua o il nome della funzione è yield).

Le coroutine sono componenti del programma che generalizzano le subroutine per consentire più punti di ingresso per sospendere e riprendere l'esecuzione in determinate posizioni.

L'implementazione dipenderà innanzitutto dalla tua lingua. Per un gioco vuoi che l'implementazione sia il più leggera possibile (più leggera dei fili o persino delle fibre). La pagina Wikipedia (collegata) contiene alcuni collegamenti a varie implementazioni specifiche della lingua.

Ho sentito che Lua ha il supporto integrato per le coroutine. Lo stesso vale per GameMonkey.

UnrealScript implementa questo con ciò che chiama "stati" e "funzioni latenti".

Se usi C # puoi guardare questo post sul blog di Nick Gravelyn.

Inoltre, l'idea delle "catene di animazioni", sebbene non sia la stessa cosa, è una soluzione praticabile allo stesso problema. Anche Nick Gravelyn ha implementato questo C # .

non andare in thread è intelligente.

La maggior parte dei motori di gioco funziona come una serie di fasi modulari con elementi in memoria che guidano ogni fase. Per la tua "passeggiata verso l'esempio", di solito hai una fase AI in cui i tuoi personaggi camminati sono in uno stato in cui non dovrebbero cercare nemici da uccidere, una fase di animazione in cui dovrebbero eseguire l'animazione X, una fase di fisica (o fase di simulazione) in cui viene aggiornata la loro posizione effettiva, ecc.

nel tuo esempio sopra, 'alice' è un attore composto da pezzi che vivono in molte di queste fasi, quindi un attore bloccante.walk_to call (o una coroutine che chiami next () su una volta per frame) probabilmente non avrebbe il giusto contesto prendere molte decisioni.

Invece, una funzione 'start_walk_to' probabilmente farebbe qualcosa del genere:

def start_cutscene_walk_to(actor,target):
    actor.ai.setbrain(cutscene_brain)
    actor.physics.nocoll = 1
    actor.anims.force_anim('walk')
    # etc.

Quindi, il tuo loop principale esegue il suo tick ai, il tick della fisica, il tick dell'animazione e il tick del filmato, e il filmato aggiorna lo stato per ciascuno dei sottosistemi nel tuo motore. Il sistema del filmato dovrebbe sicuramente tenere traccia di ciò che sta facendo ciascuno dei suoi filmati, e un sistema guidato dal coroutine per qualcosa di lineare e deterministico come un custscene potrebbe avere un senso.

Il motivo di questa modularità è che mantiene le cose belle e semplici e per alcuni sistemi (come la fisica e l'IA), è necessario conoscere lo stato di tutto allo stesso tempo per risolvere le cose correttamente e mantenere il gioco in uno stato coerente .

spero che sia di aiuto!