Ir al contenido
Descargar
El libro de Grost

Control de flujo

Hasta ahora tu código se ejecutaba de arriba abajo, una línea tras otra. Un juego necesita más. Tiene que decidir (¿le queda vida al jugador?), repetir (hacer algo con cada enemigo) y elegir entre muchos casos (¿qué salió en el dado?).

El orden en que se ejecutan las líneas se llama control de flujo. if, los bucles y match son las herramientas que lo cambian.

Un juego se hace preguntas todo el rato: ¿el jugador está muerto, herido o bien? if ejecuta un bloque de código solo cuando una condición se cumple:

fn describe(hp: int) String {
if hp <= 0 {
return "dead"
} elif hp < 20 {
return "hurt"
} else {
return "fine"
}
}
  • Una condición es cualquier cosa que vale true o false, como hp <= 0. Va sin paréntesis, y el bloque va entre { }.
  • elif (“si no, si…”) prueba otra condición cuando las anteriores no se cumplieron. Puedes encadenar todas las que necesites.
  • else recoge lo que queda.
  • elif y else son opcionales.

Grost mira las condiciones en orden y ejecuta solo el primer bloque cuya condición se cumple.

Los juegos buscan cosas todo el rato: el enemigo más cercano, el objeto de una casilla, una puntuación guardada. A veces no hay nada que encontrar.

Esta función devuelve un Option (capítulo 1): un valor, o none cuando no hay nada.

fn find_target(exists: bool) Option[int] {
if exists {
return 5
}
return none
}

Con if nombre := expresión, el bloque se ejecuta solo si hay un valor (no none, ni un actor liberado). Dentro del bloque, nombre es ese valor: aquí un int, no el Option.

if target := find_target(true) {
print($"found {target}")
} else {
print("nothing")
}
  • target existe solo dentro de ese if y de su else.
  • Un 0 o un texto vacío sí cuentan como valor. Lo único que se descarta es el vacío.
  • if find_target(true) is some(target) hace lo mismo.

Después de una coma puedes añadir más condiciones, que ya pueden usar el nombre:

fn first(values: []int) Option[int] {
if values.is_empty() {
return none
}
return values[0]
}
fn first_positive(values: []int) int {
if v := first(values), v > 0 {
return v
}
return -1
}

Aquí first() devuelve none con un array vacío, en vez de fallar en values[0]. Luego first_positive usa el valor solo si es mayor que 0.

Para hacer algo con cada enemigo, cada moneda o cada nivel, usas un bucle: un bloque que se repite. for recorre una serie de valores y ejecuta su bloque una vez con cada uno.

range(n) da los números de 0 a n - 1. Con más argumentos es range(desde, hasta, paso): empieza en desde, se detiene antes de hasta y salta de paso en paso (un paso negativo cuenta hacia atrás).

for i : int in range(3) {
print(i) # 0, 1, 2
}
for i : int in range(10, 0, -5) {
print(i) # 10, 5
}

i es la variable del bucle: en cada vuelta toma el siguiente valor. Ponle siempre el tipo (i : int).

for también recorre arrays y diccionarios, como viste en el capítulo 2.

A veces no sabes cuántas vueltas hacen falta: sigues mientras algo se cumpla, como gastar combustible hasta vaciar el depósito. while repite mientras su condición sea verdadera:

mut fuel : int = 3
while fuel > 0 {
print($"fuel {fuel}")
fuel -= 1
}

Cuando fuel llega a 0 la condición deja de cumplirse y el bucle termina.

loop { } repite para siempre. Sales de él con break (sale del bucle) o con return (sale de toda la función).

Es la forma natural cuando la salida está en medio del cuerpo, no al principio:

fn first_over(items: []int, min_value: int) int {
mut i : int = 0
loop {
if i >= items.size() {
return -1
}
if items[i] > min_value {
return items[i]
}
i += 1
}
}

El bucle mira un elemento en cada vuelta. Sale con return en cuanto encuentra uno mayor que min_value, o cuando ya no quedan elementos.

Dentro de un bucle a veces quieres saltarte un valor (un enemigo que ya está derrotado) o parar antes (ya encontraste lo que buscabas). Para eso están continue y break, que funcionan en for, while y loop:

for i : int in range(10) {
if i == 1 {
continue # skip the rest of this pass
}
if i == 4 {
break # leave the loop
}
print(i) # 0, 2, 3
}
  • continue salta a la siguiente vuelta del bucle: se salta el resto de esta.
  • break sale del bucle.

El 1 se lo salta el continue, y al llegar al 4 el break termina el bucle, así que del 5 al 9 ni se prueban.

Cuando comparas un valor con muchas posibilidades (la tirada del dado, el estado de un enemigo), una cadena larga de elif se lee mal. match compara un valor con varios patrones y ejecuta el primero que encaja:

fn classify(roll: int) String {
match roll {
1: {
return "fail"
}
2, 3: {
return "low"
}
$big when big > 10: {
return $"huge ({big})"
}
_: {
return "normal"
}
}
}
  • Cada rama es patrón: { ... }. Varias opciones se separan con comas: 2, 3.
  • $nombre encaja con cualquier valor y lo guarda en nombre, para que la rama pueda usarlo.
  • when condición añade una condición extra a la rama.
  • _ encaja con todo. Va al final: lo que pongas detrás no se ejecuta nunca.

Un nombre sin $ no captura: compara con el valor de esa variable. Aquí la rama solo encaja cuando roll es igual a lucky:

fn is_lucky(roll: int, lucky: int) bool {
match roll {
lucky: {
return true
}
}
return false
}
module Branches
fn describe(hp: int) String {
if hp <= 0 {
return "dead"
} elif hp < 20 {
return "hurt"
} else {
return "fine"
}
}
fn find_target(exists: bool) Option[int] {
if exists {
return 5
}
return none
}
fn first(values: []int) Option[int] {
if values.is_empty() {
return none
}
return values[0]
}
fn first_positive(values: []int) int {
if v := first(values), v > 0 {
return v
}
return -1
}
fn _ready() void {
print(describe(0)) # dead
print(describe(10)) # hurt
print(describe(80)) # fine
if target := find_target(true) {
print($"found {target}")
} else {
print("nothing")
}
print(first_positive([3])) # 3
print(first_positive([-2])) # -1
print(first_positive([])) # -1
}
module Loops
fn first_over(items: []int, min_value: int) int {
mut i : int = 0
loop {
if i >= items.size() {
return -1
}
if items[i] > min_value {
return items[i]
}
i += 1
}
}
fn _ready() void {
for i : int in range(3) {
print(i) # 0, 1, 2
}
for i : int in range(10, 0, -5) {
print(i) # 10, 5
}
mut fuel : int = 3
while fuel > 0 {
print($"fuel {fuel}")
fuel -= 1
}
print(first_over([1, 4, 9], 3)) # 4
print(first_over([1, 2], 5)) # -1
for i : int in range(10) {
if i == 1 {
continue # skip the rest of this pass
}
if i == 4 {
break # leave the loop
}
print(i) # 0, 2, 3
}
}
module Matching
fn classify(roll: int) String {
match roll {
1: {
return "fail"
}
2, 3: {
return "low"
}
$big when big > 10: {
return $"huge ({big})"
}
_: {
return "normal"
}
}
}
fn is_lucky(roll: int, lucky: int) bool {
match roll {
lucky: {
return true
}
}
return false
}
fn _ready() void {
print(classify(1)) # fail
print(classify(3)) # low
print(classify(12)) # huge (12)
print(classify(6)) # normal
print(is_lucky(7, 7)) # true
print(is_lucky(5, 7)) # false
}