Tracks
/
Factor
Factor
/
Übungen
/
Rollenspiel
Rollenspiel

Rollenspiel

Lernübung

Einführung

Ein Tupel bündelt mehrere benannte Werte zu einem Objekt. Andere Sprachen nennen so etwas Record, Struct oder Klasse. Jede Tupel-Klasse hat eine feste Menge benannter Slots, und Factor erzeugt automatisch Getter und Setter dafür.

Ein Tupel definieren

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

Jeder Slot wird mit { name initial: default-value } deklariert. Ohne eine initial:-Klausel ist der Standardwert f.

Ein Tupel erzeugen

Der einfachste Konstruktor ist new:

point new .
! => T{ point }

boa (kurz für „by order of arguments“) füllt Slots in der Reihenfolge ihrer Deklaration aus dem Datenstack:

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

Mit der Literal-Syntax T{ class { slot value } … } erzeugst du ein Tupel, bei dem nur ein Teil der Slots gesetzt ist, und es wird genauso ausgegeben:

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

Wenn der Wert eines Slots seinem Standardwert entspricht, lässt der Printer ihn weg.

Ein Slot lesen

Factor erzeugt für jeden Slot einen Getter slot>>. Getter liegen in accessors:

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

Ein Slot aktualisieren

Setter werden als >>slot geschrieben und verändern das Tupel direkt:

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

Um das Original unverändert zu lassen, rufst du zuerst clone auf:

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

change-slot nimmt eine Quotation, die den aktuellen Wert auf den neuen abbildet:

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

Auch change-x verändert das Tupel direkt. Ruf also clone auf, bevor du es aufrufst, wenn du das Original erhalten willst.

Anleitung

Sarah arbeitet an einem neuen Rollenspiel und braucht deine Hilfe bei der Mechanik des Spielers.

1. Definiere das player-Tupel

Definiere eine Tupelklasse player mit vier Slots und Standardwerten:

Slot Standardwert
name f
level 0
health 100
mana f

Nach der Definition kannst du einen Spieler als Literal erzeugen:

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

2. Stelle den Spieler vor

Definiere introduce so, dass der Name des Spielers zurückgegeben wird. Heimliche Spieler verbergen ihren Namen (name ist f) und sollten als "Mighty Magician" vorgestellt werden.

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

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

3. Belebe einen gefallenen Spieler wieder

Definiere revive so, dass ein neuer Spieler zurückgegeben wird, bei dem health auf 100 und mana auf 100 gesetzt ist, aber nur, wenn health des Spielers 0 ist. Ist der Spieler noch am Leben, gib f zurück.

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

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

4. Nimm Schaden

Definiere take-damage so, dass ein neuer Spieler zurückgegeben wird, dessen health um den angegebenen Betrag verringert wurde und dabei nie unter 0 fällt.

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

T{ player { health 5 } } 30 take-damage .
! => T{ player { health 0 } }
Über GitHub bearbeiten Der Link öffnet sich in einem neuen Fenster oder Tab
Factor Exercism

Bereit, mit Rollenspiel zu starten?

Melde dich bei Exercism an, um Factor mit 47 Konzepte163 Übungen und echtem menschlichen Mentoring zu lernen und zu meistern, alles kostenlos.