Parcours
/
Factor
Factor
/
Exercices
/
Jeu de rôle
Jeu de rôle

Jeu de rôle

Exercice d'apprentissage

Introduction

Un tuple regroupe plusieurs valeurs nommées dans un seul objet, ce que d'autres langages appellent un enregistrement, une structure ou une classe. Chaque classe de tuple possède un ensemble fixe d'emplacements nommés, et Factor génère automatiquement les accesseurs et les mutateurs correspondants.

Définis un tuple

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

Chaque emplacement se déclare { name initial: default-value }. Sans clause initial:, la valeur par défaut est f.

Construis un tuple

Le constructeur le plus simple est new :

point new .
! => T{ point }

boa (« par ordre des arguments ») remplit les emplacements dans l'ordre de déclaration, depuis la pile de données :

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

La syntaxe littérale T{ class { slot value } … } permet de construire un tuple en ne définissant qu'une partie des emplacements, et s'affiche de la même façon :

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

Lorsque la valeur d'un emplacement correspond à sa valeur par défaut, l'affichage l'omet.

Lis un emplacement

Factor génère un accesseur slot>> pour chaque emplacement. Les accesseurs se trouvent dans accessors :

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

Mets à jour un emplacement

Les mutateurs s'écrivent >>slot et modifient le tuple sur place :

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

Pour ne pas toucher à l'original, commence par clone :

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

change-slot prend une quotation qui associe la valeur actuelle à la nouvelle :

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

change-x modifie lui aussi le tuple, donc fais un clone avant de l'appeler si tu veux préserver l'original.

Instructions

Sarah travaille sur un nouveau jeu de rôle et a besoin de ton aide pour les mécaniques du joueur.

1. Définis le tuple player

Définis une classe tuple player avec quatre emplacements et des valeurs par défaut :

emplacement valeur par défaut
name f
level 0
health 100
mana f

Une fois définie, on peut construire un joueur sous forme de littéral :

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

2. Présente le joueur

Définis introduce pour renvoyer le nom du joueur. Les joueurs furtifs cachent leur nom (name vaut f) et doivent être présentés comme "Mighty Magician".

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

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

3. Ranime un joueur tombé

Définis revive pour renvoyer un nouveau joueur avec health fixé à 100 et mana fixé à 100, mais uniquement si le health du joueur vaut 0. Si le joueur est encore en vie, renvoie f.

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

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

4. Subis des dégâts

Définis take-damage pour renvoyer un nouveau joueur dont le health a été réduit de la quantité donnée, sans jamais descendre en dessous de 0.

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

T{ player { health 5 } } 30 take-damage .
! => T{ player { health 0 } }
Modifie via GitHub Le lien s'ouvre dans une nouvelle fenêtre ou un nouvel onglet
Factor Exercism

Prêt à commencer Jeu de rôle ?

Inscris-toi sur Exercism pour apprendre et maîtriser Factor avec 47 concepts163 exercices, et un vrai mentorat humain, le tout gratuitement.