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.
if, elif, else
Sección titulada «if, elif, else»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
trueofalse, comohp <= 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.elserecoge lo que queda.elifyelseson opcionales.
Grost mira las condiciones en orden y ejecuta solo el primer bloque cuya condición se cumple.
if con declaración: if x := ...
Sección titulada «if con declaración: if x := ...»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")}targetexiste solo dentro de eseify de suelse.- Un
0o 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 = 3while 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.
break y continue
Sección titulada «break y continue»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}continuesalta a la siguiente vuelta del bucle: se salta el resto de esta.breaksale 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. $nombreencaja con cualquier valor y lo guarda ennombre, para que la rama pueda usarlo.when condiciónañ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}Los ejemplos completos
Sección titulada «Los ejemplos completos»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}