Ir al contenido
Descargar
El libro de Grost

Expresiones y tipos

Todo programa trabaja con valores: la vida del jugador, su nombre, si está vivo o no. En este capítulo ves cómo guardarlos, de qué tipo son (qué clase de valor: un número, un texto, un sí o un no) y cómo combinarlos.

Un juego tiene que recordar cosas: cuánta vida queda, lo rápido que corre el jugador, el título del juego. Cada una se guarda con un nombre:

MAX_HP :: 100 # constant
GRAVITY :: float = 9.8 # typed constant
title : String = "Gobu" # immutable: assigning it is an error
mut hp : int = MAX_HP # mutable, typed
mut speed := 4.5 # mutable, the type (float) comes from the literal

Hay tres formas de guardar un valor:

FormaQué es
mut hp : int = 100Variable: puede cambiar
title : String = "Gobu"Inmutable: se fija al declararla; asignarla es un error
MAX_HP :: 100Constante: se conoce antes de ejecutar el juego
  • El tipo va después de :.
  • Si escribes := en lugar de : Tipo =, Grost deduce el tipo, es decir, lo saca del valor: mut speed := 4.5 es un float.
  • Una constante también puede llevar tipo: GRAVITY :: float = 9.8. Las constantes se suelen escribir en MAYÚSCULAS, para distinguirlas de un vistazo.

La vida, las monedas y la velocidad son números. “¿Está vivo el jugador?” es una pregunta de sí o no. Estos son los tipos para las dos cosas:

coins : int = 7
ratio : float = 0.5
alive : bool = true
print(coins + 3) # 10
print(coins * ratio) # 3.5
print(coins % 3) # 1
print(coins / 2.0) # 3.5
print(int(3.9)) # 3
print(float(coins)) # 7.0
print(alive and hp > 0) # true
print(not alive or hp == MAX_HP) # true
  • int son números enteros (7, -3) y float números con decimales (0.5). Mezclarlos da un float.
  • + - * / suman, restan, multiplican y dividen. % da el resto de una división: 7 % 3 es 1.
  • Dividir dos enteros descarta el resto, y el analizador te lo advierte. Divide entre un float (coins / 2.0) si quieres decimales.
  • int(x) y float(x) convierten. int(3.9) corta los decimales: da 3.
  • bool (un booleano) vale true o false. Se combinan con and, or y not (también !).
  • Las comparaciones dan un bool: ==, !=, <, <=, >, >=.
  • hp -= 10 y speed *= 2.0 son atajos de hp = hp - 10 y speed = speed * 2.0.

Nombres, mensajes, diálogos: un juego muestra mucho texto.

engine_name : String = "Gobu"
action : StringName = &"jump"
print(engine_name + " Engine") # Gobu Engine
print(engine_name.length()) # 4
print(engine_name.to_upper()) # GOBU
print("42".to_int() + 1) # 43
print(str(3.5) + "!") # 3.5!
print(action == &"jump") # true
  • String es texto normal, entre comillas. + une dos textos.
  • Un texto trae sus propias funciones, que se llaman con un punto: length() cuenta sus caracteres, to_upper() lo da en mayúsculas, to_int() lee un número de él.
  • str(x) convierte un valor en texto.
  • StringName (escrito &"jump") es un nombre que el motor compara muy rápido; lo vas a ver en nombres de acciones, señales y grupos. Para texto que muestras o editas, usa String.

Montar un mensaje como “HP: 7/10” a partir de trozos es tan habitual que Grost tiene una forma corta de hacerlo. Interpolar es meter valores dentro del texto: pon $ delante de las comillas y las expresiones entre llaves:

hp : int = 7
max_hp : int = 10
print($"HP: {hp}/{max_hp}") # HP: 7/10
print($"Next: {hp + 1}, double: {hp * 2}")
print($"Braces {{literal}} and {hp}") # Braces {literal} and 7
  • Dentro de { } va cualquier expresión, no solo una variable: {hp * 2}.
  • Para una llave literal escribe {{ o }}.
  • Un texto sin $ no interpola nada: "{hp}" son solo esos cuatro caracteres.

print escribe en la pestaña Output. Es la forma más rápida de ver qué hace tu código, y se puede usar de varias maneras:

print("hp: {}\n", .{ hp })
print("Name: {s}, HP: {}\n", .{ engine_name, hp })
print("%d coins" % hp)
prints("a", "b", "c") # a b c
  • print(a, b, ...) imprime todo seguido, sin espacios; prints separa con espacios.
  • print("...{}...", .{ a, b }) rellena cada {} con un valor, en orden. {s} marca un texto. Aquí el salto de línea lo pones tú con \n.
  • "%d coins" % hp es el formato clásico con %.

En el día a día, $"..." es lo más claro.

A veces no hay respuesta: el enemigo más cercano cuando no quedan enemigos, el precio de algo que la tienda no vende. Grost hace visible ese caso, para que tu código no pueda olvidarlo.

Una función que a veces no tiene nada que dar devuelve un Option[int]: un int, o none (nada). Basta con devolver el valor (return 3 es some(3), “hay un valor: 3”); none es el vacío:

fn lookup(found: bool) Option[int] {
if found {
return 3 # The same as some(3).
}
return none
}

(El if lo verás en el capítulo 4.)

Un Option[int] no es un int. Hasta que lo compruebes, no puedes sumarlo, pasarlo como int ni guardarlo en un int, y el analizador te lo dice.

La forma más corta de sacar el valor es ??. a ?? b da el valor de dentro de a, o b cuando a es none:

print(lookup(true) ?? 9) # 3
print(lookup(false) ?? 9) # 9
amount : int = lookup(false) ?? 0
print(amount) # 0

Las otras formas de sacar el valor:

if lookup(true) is some(n) {
print(n + 1) # 4: n is the int inside
}
match lookup(false) {
some(n): {
print(n)
}
none: {
print("nothing") # nothing
}
}
print(lookup(true).expect("lookup(true) always finds it")) # 3
  • if x is some(n) { }: el bloque se ejecuta cuando hay valor, y n es ese valor. x is some y x is none solos dan un bool.
  • match con some(n): y none: tiene que tratar los dos casos (o _): el código no puede olvidarse del caso sin valor.
  • x.expect("por qué") da el valor, o detiene el juego con ese mensaje: para los casos en que none sería un error de tu código.

Para llamar a algo de un actor que puede no existir, ?. hace la llamada solo si existe. En un juego escribirías body?.collect_coin() en el código que se ejecuta cuando algo toca una moneda. Aquí el actor falta a propósito (null quiere decir “ningún objeto”):

mut objetivo : Spatial2D = null # todavía no hay actor
objetivo?.hide() # no se llama: objetivo es null
print("sigue funcionando")

Algunas cosas que da el motor no tienen un tipo que pueda prometer: lo que lees de un JSON (un formato de texto para datos), un elemento de un Array o un Dictionary sin tipo de elementos (capítulo 2), el valor de call().

Grost no te deja usar uno como int (ni como otra cosa) a ciegas, porque un error así solo aparecería al ejecutar el juego. hp : int = datos["hp"] es un error: datos["hp"] no tiene un tipo conocido. Tómalo con as, que lo comprueba:

datos : Dictionary = {"hp": 10}
hp : int = (datos["hp"] as int) ?? 0 # bien: 0 si no es un número
print(hp)
if n := datos["hp"] as int { # o solo cuando lo es
print(n + 1)
}

valor as int es un Option[int]: el valor cuando es un int (o se convierte en uno, como un 10.0 de un JSON), none si no. Imprimirlo, compararlo con == o probarlo con is funcionan sin as. Los contenedores con tipo ([]int, Dictionary[String, int]) dan sus valores con su tipo, así que no necesitan as.

A menudo quieres un valor u otro según algo: la palabra “low” cuando queda poca vida, “ok” si no.

hp : int = 15
label : String = "low" if hp < 20 else "ok"
print(label) # low

a if condición else b vale a si la condición se cumple y b si no. Los dos lados deberían ser del mismo tipo.

is y as también funcionan con objetos del motor, como los actores. Así preguntas “¿esto es un Spatial2D?” (un actor con posición en 2D) antes de tratarlo como tal:

thing : Object = Spatial2D.new()
print(thing is Spatial2D) # true
print(thing is Control) # false
sprite : Spatial2D = thing as Spatial2D
print(sprite.position) # (0.0, 0.0)
print(thing as Control) # <null>
thing.free()
  • valor is Tipo dice si el valor es de ese tipo (o de uno que hereda de él).
  • valor as Tipo lo trata como ese tipo. Si no lo es, da null.
  • Spatial2D.new() crea un objeto del motor y free() lo libera. Normalmente no los creas a mano: vienen de tu escena (capítulo 6).

Variables, constantes y números, en un solo script:

module Values
MAX_HP :: 100 # constant
GRAVITY :: float = 9.8 # typed constant
title : String = "Gobu" # immutable: assigning it is an error
mut hp : int = MAX_HP # mutable, typed
mut speed := 4.5 # mutable, the type (float) comes from the literal
fn _ready() void {
coins : int = 7
ratio : float = 0.5
alive : bool = true
print(coins + 3) # 10
print(coins * ratio) # 3.5
print(coins % 3) # 1
print(coins / 2.0) # 3.5
print(int(3.9)) # 3
print(float(coins)) # 7.0
print(alive and hp > 0) # true
print(not alive or hp == MAX_HP) # true
hp -= 10
speed *= 2.0
print(hp, " ", speed, " ", GRAVITY, " ", title)
}