Ir al contenido
Descargar
Curso de Grost

Enums

Módulo 2 · Datos y coleccionesLección 9 de 207 min de lectura4 retos
main.groPaso 1 de 4
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.
Output

Este código todavía no imprime nada.

main.groPaso 2 de 4
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.
Output
true
main.groPaso 3 de 4
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.
Output
carrera
main.groPaso 4 de 4
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.
Output
0
2
También con las flechas ← →

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

main.gro
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)
}
Outputtrue false
ParteQué hace
enumDice que empieza un enum
EstadoEl nombre del tipo nuevo
{ QUIETO, CORRIENDO, SALTANDO }Sus opciones, separadas por comas
Estado.QUIETOAsí 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:

main.gro
module Errata
enum Estado { QUIETO, CORRIENDO, SALTANDO }
fn _ready() void {
estado : Estado = Estado.QUIETO
if estado == Estado.CORRER {
print("corre")
}
}
OutputParse Error: Cannot find member "CORRER" in base "Errata.Estado".

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.

main.gro
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)
}
Outputanimación: reposo animación: salto
  • 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 =:

main.gro
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)
}
Output0 2 50 25

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:

main.gro
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()
}
Outputsalta ya está en el aire aterriza salta

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

Retos: 0/4 resueltosSe guardan en este navegador
Reto 1 de 4sin resolver

¿Qué imprime este código?

main.gro
enum Arma { ESPADA, ARCO, MAGIA }

print(Arma.MAGIA)
ESPADA es 0, ARCO es 1 y MAGIA es 2.
Las opciones son números que empiezan en 0.
Reto 2 de 4sin resolver

Completa el código: abre la puerta y elige el mensaje según su estado.

Salida esperada
puedes pasar
main.gro
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")
    }
  }
}
Una opción se escribe con el nombre del enum delante. La palabra que compara con varios casos la viste en el módulo 1.
Solución:
main.gro
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")
    }
  }
}
Reto 3 de 4sin resolver

¿Qué imprime este código?

main.gro
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.
¿Qué caso recoge las opciones que no aparecen en la lista?
Reto 4 de 4sin resolver

¿Por qué es mejor guardar el estado como Estado.CORRIENDO que como el texto "corriendo"?

Un texto mal escrito es otro texto válido, y el error pasa desapercibido. Una opción mal escrita no existe, y Grost lo marca al momento.
¿Qué pasa si escribes "coriendo", con una sola erre?