Percursos
/
Factor
Factor
/
Exercícios
/
Jogo de interpretação de papéis
Jogo de interpretação de papéis

Jogo de interpretação de papéis

Exercício de aprendizagem

Introdução

Um tuplo agrupa vários valores nomeados num único objeto: aquilo a que outras linguagens chamam registo, struct ou classe. Cada classe de tuplo tem um conjunto fixo de fendas nomeadas, e o Factor gera automaticamente getters e setters para elas.

Definir um tuplo

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

Cada fenda é declarada como { name initial: default-value }. Sem a cláusula initial:, o valor predefinido é f.

Construir um tuplo

O construtor mais simples é new:

point new .
! => T{ point }

boa («por ordem dos argumentos») preenche as fendas pela ordem de declaração, a partir da pilha de dados:

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

A sintaxe literal T{ class { slot value } … } permite-te construir um tuplo com apenas um subconjunto de fendas definidas, e imprime-se da mesma forma:

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

Quando o valor de uma fenda corresponde ao predefinido, ele é omitido na impressão.

Ler uma fenda

O Factor gera um getter slot>> para cada fenda. Os getters vivem em accessors:

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

Atualizar uma fenda

Os setters escrevem-se >>slot e modificam o tuplo no local:

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

Para deixares o original intacto, faz clone primeiro:

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

change-slot recebe uma quotation que transforma o valor atual no novo:

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

change-x também modifica o tuplo, por isso faz clone antes de a chamares, se quiseres preservar o original.

Instruções

A Sarah está a trabalhar num novo jogo de RPG e precisa da tua ajuda com a mecânica do jogador.

1. Define o tuplo player

Define uma classe de tuplo player com quatro fendas e valores predefinidos:

fenda predefinido
name f
level 0
health 100
mana f

Depois de a definires, podes construir um jogador como um literal:

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

2. Apresenta o jogador

Define introduce para devolver o nome do jogador. Os jogadores furtivos escondem o nome (name é f) e devem ser apresentados como "Mighty Magician".

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

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

3. Reanima um jogador caído

Define revive para devolver um jogador novo com health definido como 100 e mana definido como 100, mas apenas se o health do jogador for 0. Se o jogador ainda estiver vivo, devolve f.

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

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

4. Recebe dano

Define take-damage para devolver um jogador novo cujo health foi reduzido na quantidade indicada, nunca ficando abaixo de 0.

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

T{ player { health 5 } } 30 take-damage .
! => T{ player { health 0 } }
Editar via GitHub A ligação abre numa nova janela ou separador
Factor Exercism

Estás pronto para começar Jogo de interpretação de papéis?

Inscreve-te no Exercism para aprenderes e dominares Factor com 47 conceitos163 exercícios, e mentoria humana real, tudo grátis.