Enums
enum Estado { QUIETO, CORRIENDO, SALTANDO }1 · Nombrar las opcionesenum crea un tipo con una lista cerrada de opciones. Las opciones se suelen escribir en MAYÚSCULAS.Este código todavía no imprime nada.
enum Estado { QUIETO, CORRIENDO, SALTANDO }
mut estado : Estado = Estado.QUIETO
estado = Estado.CORRIENDO
print(estado == Estado.CORRIENDO)2 · Una variable de ese tipoCada opción se escribe con el nombre del enum delante: Estado.CORRIENDO. Se comparan con ==, como los números.true
enum Estado { QUIETO, CORRIENDO, SALTANDO }
fn animacion(e: Estado) String {
match e {
Estado.QUIETO: {
return "reposo"
}
Estado.CORRIENDO: {
return "carrera"
}
_: {
return "salto"
}
}
}
print(animacion(Estado.CORRIENDO))3 · Decidir con matchmatch elige qué hacer según la opción. Cada caso es una opción del enum, y _ recoge las demás.carrera
enum Estado { QUIETO, CORRIENDO, SALTANDO }
print(Estado.QUIETO)
print(Estado.SALTANDO)4 · Por dentro, númerosCada opción es un número entero: la primera vale 0, la siguiente 1, y así. Por eso al imprimir un enum ves un número.0 2
Tu personaje puede estar quieto, corriendo o saltando. ¿Cómo guardas en qué estado está?
Podrías usar un texto ("corriendo") o un número (1). Pero con un texto, basta una errata
("coriendo") para que nada funcione, y con un número nadie recuerda qué significaba el 2.
Un enum le pone nombre a cada opción y deja que Grost vigile que solo uses las que existen.
Opciones con nombre
module Estados
enum Estado { QUIETO, CORRIENDO, SALTANDO }
mut estado : Estado = Estado.QUIETO
fn _ready() void { print(estado == Estado.QUIETO) estado = Estado.SALTANDO print(estado == Estado.QUIETO)}| Parte | Qué hace |
|---|---|
enum | Dice que empieza un enum |
Estado | El nombre del tipo nuevo |
{ QUIETO, CORRIENDO, SALTANDO } | Sus opciones, separadas por comas |
Estado.QUIETO | Así se escribe una de las opciones |
- Como un struct, un enum se declara a nivel de script, y después es un tipo más: puedes tener
variables, parámetros y campos de tipo
Estado. - Dale un valor inicial a las variables de tipo enum, como
Estado.QUIETO.
Por qué no un texto
Con un texto, una errata es otro texto válido: el if no se cumple nunca y no sabes por qué.
Con un enum, Grost no encuentra la opción y te lo dice antes de ejecutar:
module Errata
enum Estado { QUIETO, CORRIENDO, SALTANDO }
fn _ready() void { estado : Estado = Estado.QUIETO if estado == Estado.CORRER { print("corre") }}El mensaje dice que Estado no tiene ninguna opción llamada CORRER. Te enteras antes
de ejecutar, no en mitad de una partida.
Decidir con match
Un enum y match van de la mano: un caso por opción.
module Animaciones
enum Estado { QUIETO, CORRIENDO, SALTANDO }
fn animar(e: Estado) void { match e { Estado.QUIETO: { print("animación: reposo") } Estado.CORRIENDO: { print("animación: carrera") } Estado.SALTANDO: { print("animación: salto") } }}
fn _ready() void { animar(Estado.QUIETO) animar(Estado.SALTANDO)}- Cada caso es una opción del enum, con su nombre completo.
- Varias opciones pueden compartir caso:
Estado.CORRIENDO, Estado.SALTANDO: { ... }. _:recoge las opciones que no tienen caso propio.
Por dentro, números
Cada opción es un número entero. Empiezan en 0 y suben de uno en uno, salvo que les des tú un
valor con =:
module Numeros
enum Arma { ESPADA, ARCO, MAGIA }enum Medalla { BRONCE = 10, PLATA = 25, ORO = 50 }
fn _ready() void { print(Arma.ESPADA, " ", Arma.MAGIA) print(Medalla.ORO) puntos : int = Medalla.PLATA print(puntos)}Darles valor sirve cuando el número significa algo, como los puntos que da cada medalla. Si solo necesitas distinguir opciones, no te hace falta.
Un estado que cambia
Lo más habitual es guardar el estado en una variable del script y cambiarlo cuando pasa algo:
module Personaje
enum Estado { QUIETO, CORRIENDO, SALTANDO }
mut estado : Estado = Estado.QUIETO
fn saltar() void { if estado == Estado.SALTANDO { print("ya está en el aire") } else { estado = Estado.SALTANDO print("salta") }}
fn aterrizar() void { estado = Estado.QUIETO print("aterriza")}
fn _ready() void { saltar() saltar() aterrizar() saltar()}El estado decide qué puede hacer el personaje: en el aire no se puede volver a saltar, y al aterrizar vuelve a estar quieto. Esta idea, que lo que puedes hacer depende del estado en el que estás, aparece en casi todos los juegos.
Hora de practicar
¿Qué imprime este código?
enum Arma { ESPADA, ARCO, MAGIA }
print(Arma.MAGIA)ESPADA es 0, ARCO es 1 y MAGIA es 2.Completa el código: abre la puerta y elige el mensaje según su estado.
puedes pasar
enum Puerta { ABIERTA, CERRADA }
fn _ready() void {
mut puerta : Puerta = Puerta.CERRADA
puerta = .ABIERTA
puerta {
Puerta.ABIERTA: {
print("puedes pasar")
}
Puerta.CERRADA: {
print("está cerrada")
}
}
}enum Puerta { ABIERTA, CERRADA }
fn _ready() void {
mut puerta : Puerta = Puerta.CERRADA
puerta = Puerta.ABIERTA
match puerta {
Puerta.ABIERTA: {
print("puedes pasar")
}
Puerta.CERRADA: {
print("está cerrada")
}
}
}¿Qué imprime este código?
enum Estado { QUIETO, CORRIENDO, SALTANDO }
fn velocidad(e: Estado) int {
match e {
Estado.CORRIENDO: {
return 200
}
Estado.SALTANDO: {
return 120
}
_: {
return 0
}
}
}
fn _ready() void {
print(velocidad(Estado.QUIETO))
}QUIETO no tiene su propio caso, así que entra en _ y devuelve 0.¿Por qué es mejor guardar el estado como Estado.CORRIENDO que como el texto "corriendo"?
"coriendo", con una sola erre?