Decidir y repetir
vidas : int = 0
if vidas <= 0 {
print("fuera")1 · Decidir con ifif ejecuta su bloque solo si la condición se cumple. Si no, se ejecuta el del else.} else {
print("sigue")
}fuera
for i : int in range(3) {2 · Repetir con forfor repite el bloque una vez por cada valor. range(3) da 0, 1 y 2: empieza en 0 y no llega al 3. print(i)
}0 1 2
mut combustible : int = 3
while combustible > 0 {
print($"combustible {combustible}")
combustible -= 13 · Repetir mientraswhile repite mientras la condición sea verdadera. Si nunca deja de serlo, el bucle no termina nunca.}combustible 3 combustible 2 combustible 1
fn tirada(dado: int) String {
match dado {
1: {
return "fallo"
}
6: {
return "¡crítico!"
}
_: {4 · Elegir con matchmatch compara un valor con varios casos y ejecuta el que coincide. _ es el caso para todo lo demás. return "normal"
}
}
}Este código todavía no imprime nada.
Hasta ahora tu código se ejecutaba de arriba abajo, una línea tras otra. Pero un juego tiene que decidir (¿le quedan vidas al jugador?) y repetir (crear diez enemigos, revisar cada moneda). En esta lección aprendes las dos cosas.
Decidir con if
module Si
fn estado(vidas: int) String { if vidas <= 0 { return "fuera" } elif vidas == 1 { return "en peligro" } else { return "bien" }}
fn _ready() void { print(estado(0)) print(estado(1)) print(estado(3))}if condición { ... }ejecuta el bloque solo si la condición estrue.elif(“si no, si…”) prueba otra condición cuando la anterior no se cumplió. Puedes poner tantos como quieras.elserecoge todo lo que no cumplió ninguna. Es opcional.
Grost mira las condiciones en orden y ejecuta solo el primer bloque que se cumple.
Repetir con for
for recorre una serie de valores y ejecuta el bloque una vez con cada uno:
module Bucles
fn _ready() void { for i : int in range(3) { print(i) } for i : int in range(10, 0, -5) { print(i) }}| Escribes | Da |
|---|---|
range(3) | 0, 1, 2 |
range(2, 5) | 2, 3, 4: desde el primero, sin llegar al segundo |
range(10, 0, -5) | 10, 5: el tercero es el paso, aquí hacia atrás |
i es una variable nueva que en cada vuelta toma el siguiente valor. Con for también puedes
recorrer listas, como las de enemigos o monedas; lo verás en el módulo de colecciones.
Repetir mientras: while y loop
while repite mientras su condición sea verdadera. Es útil cuando no sabes cuántas vueltas
van a hacer falta:
module Mientras
fn _ready() void { mut combustible : int = 3 while combustible > 0 { print($"combustible {combustible}") combustible -= 1 }}loop repite para siempre, hasta que lo cortas con break:
module Repetir
fn _ready() void { mut intentos : int = 0 loop { intentos += 1 if intentos == 3 { break } } print(intentos)}Saltar y salir: continue y break
Dentro de cualquier bucle:
continuesalta al principio de la siguiente vuelta.breaksale del bucle del todo.
module Romper
fn _ready() void { for i : int in range(10) { if i == 1 { continue } if i == 4 { break } print(i) }}El 1 se salta por el continue, y al llegar al 4 el break termina el bucle, así que del 5 al
9 ni se prueban.
Elegir entre muchos casos: match
Cuando comparas un mismo valor con muchas posibilidades, match queda más claro que una
cadena de elif:
module Dado
fn tirada(dado: int) String { match dado { 1: { return "fallo" } 2, 3: { return "baja" } 6: { return "¡crítico!" } _: { return "normal" } }}
fn _ready() void { print(tirada(1)) print(tirada(3)) print(tirada(5)) print(tirada(6))}- Cada caso es un valor, dos puntos y su bloque.
2, 3:vale para cualquiera de los dos._:es el comodín: recoge lo que no coincidió con ningún otro caso. Ponlo el último.
Hora de practicar
¿Qué imprime este código?
for i : int in range(2, 5) {
print(i)
}range(2, 5) da 2, 3 y 4: el 5 no entra.range empieza en el primer número y se detiene antes del segundo.Haz que el mensaje salga solo cuando queda una vida.
¡Última vida!
fn _ready() void {
vidas : int = 1
vidas == 1 {
print("¡Última vida!")
}
}fn _ready() void {
vidas : int = 1
if vidas == 1 {
print("¡Última vida!")
}
}¿Qué imprime este código?
mut total := 0
for i : int in range(5) {
if i == 3 { break }
total += i
}
print(total)i llega a 3, el break sale del bucle antes de sumarlo. 0 + 1 + 2 = 3.total en cada vuelta y fíjate en qué vuelta se ejecuta el break.Completa el match: el 0 da cero y cualquier otro número, otro.
cero otro
fn tipo(n: int) String {
n {
0: {
return "cero"
}
: {
return "otro"
}
}
}
fn _ready() void {
print(tipo(0))
print(tipo(7))
}fn tipo(n: int) String {
match n {
0: {
return "cero"
}
_: {
return "otro"
}
}
}
fn _ready() void {
print(tipo(0))
print(tipo(7))
}