Framework in codice
Come Fabled esegue il tuo codice
Segui un progetto dal sorgente al gioco: cosa viene eseguito e quando, come funziona il registro e cosa dimostra uno scenario.
Dal sorgente al gioco
Il tuo progetto passa per cinque passi. Solo l'ultimo è il gioco vero e proprio. I passi prima non cambiano mai un personaggio attivo.
- Scrivi
Modifichi i file sorgente nell'editor del sorgente. Per ora non viene eseguito nulla.
- Verifica
Verifica e anteprima compila le tue modifiche attuali ed esegue ogni scenario, salvate o no. I problemi compaiono nel pannello Problemi. Non viene pubblicato nulla.
- Salva
Salva progetto conserva il sorgente come nuova versione del tuo gioco. Prepara funziona solo su una versione salvata, quindi salva prima di preparare.
- Prepara
Prepara il mio gioco costruisce Framework, Frame e contenuti privati dalla versione salvata. Il server verifica di nuovo il progetto e il suo verdetto è quello che conta.
- Gioca
Un giocatore crea un personaggio dal tuo Framework. Il costruttore lo costruisce e le azioni lo modificano.
Cosa viene eseguito e quando
| Parte | Quando viene eseguita | Cosa fa |
|---|---|---|
| Costruttore | Una volta, quando un Elemento viene creato dal Framework. | Trasforma gli input nei valori iniziali. Non scrive mai. |
| Funzione del registro | Quando l'Elemento viene costruito, nell'ordine in cui lo schema dichiara le funzioni, e di nuovo dopo ogni azione. | Ricava un valore dai valori salvati. Un'azione non può scriverlo. |
| Azione | Quando un giocatore usa un pulsante che la chiama. | Scrive nel registro con ledger.set e ledger.add. |
| Frame | Ogni volta che la scheda viene mostrata. | Legge i valori salvati e li disegna. I suoi pulsanti chiamano le azioni. |
| Scenario | In Verifica e anteprima, mai nel gioco. | Costruisce un Elemento, esegue azioni e confronta ogni valore e ogni scrittura. |
Il registro
I valori di un Elemento non si modificano mai direttamente. Ogni modifica è una scrittura nel suo registro. ledger.set sostituisce un valore e ledger.add vi aggiunge un numero. Gli scenari elencano queste scritture, così vedi esattamente cosa fa una regola.
Un valore derivato viene da una funzione del registro, quindi un'azione non può scriverlo. La verifica lo rifiuta:
which is a non-writable state fieldIl costruttore restituisce comunque un campo che una funzione del registro ricava, con un segnaposto come 0. La funzione del registro sostituisce il segnaposto quando l'Elemento viene costruito. Uno scenario confronta i suoi expectedValues con i valori dopo l'esecuzione delle funzioni del registro, quindi scrivi lì il valore derivato, non il segnaposto.
Le funzioni del registro vengono eseguite nell'ordine in cui lo schema le dichiara, e ognuna vede i risultati delle precedenti. Dichiara una funzione dopo quelle di cui legge i campi. Qui total legge base, ma è dichiarata per prima, quindi legge il segnaposto:
{
"ledgerFunctions": [
{
"id": "total",
"name": "Total",
"field": "total",
"source": "rules/total.ts"
},
{
"id": "base",
"name": "Base",
"field": "base",
"source": "rules/base.ts"
}
]
}expectedValues.total: expected 11, constructor returned 1Usa una funzione del registro per un valore che deve seguire altri campi e che nessuna azione scrive. Usa un valore del costruttore per un numero che appartiene al personaggio e che le azioni cambiano, come hp. Il costruttore lo calcola una sola volta, quindi una modifica successiva ai campi da cui deriva non lo sposta.
Cosa dimostra uno scenario
- Il costruttore restituisce i valori che ti aspetti.
- Ogni azione fa esattamente le scritture che elenchi.
- I valori derivati escono giusti, anche dopo un'azione.
- Ogni file viene usato e l'intero progetto compila.
Uno scenario non dimostra che aspetto ha una scheda, né come si sente una regola mentre si gioca. Per questo prova il gioco preparato.