Track
/
Factor
Factor
/
Esercizi
/
Gioco di ruolo
Gioco di ruolo

Gioco di ruolo

Esercizio di apprendimento

Introduzione

Una tupla raggruppa diversi valori con un nome in un unico oggetto: quello che altri linguaggi chiamano record, struct o classe. Ogni classe di tupla ha un insieme fisso di slot con un nome, e Factor genera automaticamente i getter e i setter corrispondenti.

Definire una tupla

TUPLE: point
    { x initial: 0 }
    { y initial: 0 } ;

Ogni slot si dichiara con { name initial: default-value }. Senza una clausola initial: il valore predefinito è f.

Costruire una tupla

Il costruttore più semplice è new:

point new .
! => T{ point }

boa («by order of arguments») riempie gli slot nell'ordine in cui sono dichiarati, prendendo i valori dalla pila dei dati:

3 4 point boa .
! => T{ point { x 3 } { y 4 } }

La sintassi letterale T{ class { slot value } … } permette di costruire una tupla impostandone solo una parte degli slot, e si stampa allo stesso modo:

T{ point { x 3 } } .
! => T{ point { x 3 } }

Quando il valore di uno slot coincide con il suo valore predefinito, la stampa lo omette.

Leggere uno slot

Factor genera un getter slot>> per ogni slot. I getter si trovano in accessors:

T{ point { x 3 } { y 4 } } x>> .
! => 3

Aggiornare uno slot

I setter si scrivono >>slot e mutano la tupla sul posto:

T{ point { x 3 } { y 4 } } 10 >>x .
! => T{ point { x 10 } { y 4 } }

Per lasciare intatto l'originale, fai prima un clone:

: shifted ( pt -- pt' )
    clone 10 >>x ;

change-slot prende una quotation che trasforma il valore attuale in quello nuovo:

: shift-x ( pt dx -- pt )
    [ + ] curry change-x ;

Anche change-x muta la tupla, quindi fai un clone prima di chiamarla se vuoi conservare l'originale.

Istruzioni

Sarah sta lavorando a un nuovo gioco di ruolo e ha bisogno del tuo aiuto con le meccaniche del giocatore.

1. Definisci la tupla player

Definisci una classe tupla player con quattro slot e valori predefiniti:

slot predefinito
name f
level 0
health 100
mana f

Una volta definita, puoi costruire un giocatore usando un letterale:

T{ player { name "Merlin" } { level 5 } } .
! => T{ player { name "Merlin" } { level 5 } }

2. Presenta il giocatore

Definisci introduce in modo che restituisca il nome del giocatore. I giocatori furtivi nascondono il proprio nome (name è f) e devono essere presentati come "Mighty Magician".

T{ player { name "Merlin" } } introduce .
! => "Merlin"

T{ player { health 8 } } introduce .
! => "Mighty Magician"

3. Rianima un giocatore caduto

Definisci revive in modo che restituisca un nuovo giocatore con health impostato a 100 e mana impostato a 100, ma solo se il health del giocatore è 0. Se il giocatore è ancora vivo, restituisci f.

T{ player { name "Merlin" } { health 0 } } revive .
! => T{ player { name "Merlin" } { health 100 } { mana 100 } }

T{ player { health 50 } } revive .
! => f

4. Subisci danni

Definisci take-damage in modo che restituisca un nuovo giocatore il cui health è stato ridotto della quantità indicata, senza mai scendere sotto 0.

T{ player { health 100 } } 30 take-damage .
! => T{ player { health 70 } }

T{ player { health 5 } } 30 take-damage .
! => T{ player { health 0 } }
Modifica tramite GitHub Il link si apre in una nuova finestra o scheda
Factor Exercism

Vuoi iniziare Gioco di ruolo?

Iscriviti a Exercism per imparare e padroneggiare Factor con 47 concetti163 esercizi e il mentoring di persone reali, tutto gratis.