Ir al contenido
Descargar
El libro de Grost

Contenedores

Un juego casi nunca tiene un solo valor de cada cosa: hay varios enemigos, una lista de puntuaciones, un inventario. Un contenedor guarda muchos valores juntos con un solo nombre. Tienes dos: Array (una lista ordenada) y Dictionary (pares de una clave y su valor).

Usa un array cuando tienes “varios de algo” y su orden importa: los objetos de un inventario, las puntuaciones de cada ronda, los enemigos de una oleada.

Un Array guarda valores en orden. Con []int dices de qué tipo son todos (aquí, números enteros):

mut scores : []int = [30, 10, 20]
scores.append(40)
print(scores) # [30, 10, 20, 40]
print(scores[0]) # 30
print(scores[-1]) # 40 (counts from the end)
scores[1] = 15
print(scores.size()) # 4
  • Los literales van entre corchetes: [30, 10, 20].
  • Cada elemento tiene una posición, su índice, que empieza en 0: scores[0] es el primero. Un índice negativo cuenta desde el final: scores[-1] es el último.
  • Si el array es mut, puedes cambiar sus elementos y su tamaño.

Un array de valores ([]int, []float, []String, []Vector2, []Vector3, []Vector4, []Color) los guarda uno tras otro, sin un Variant por elemento (la caja del motor para un valor de cualquier tipo). Ocupa menos memoria y el motor lo toma tal cual: line.points = puntos no copia nada. Un array de cualquier otro tipo ([]Actor, []bool) es un Array que comprueba su tipo. Los dos se escriben y se usan igual.

Con el tipo puesto, el analizador rechaza meter un String en un []int. Si de verdad necesitas mezclar tipos, usa Array sin más:

mixed : Array = [1, "two", 3.5]
print(mixed.size()) # 3

Un método es una función que pertenece a un valor; se llama con un punto, como scores.append(40). Los arrays traen muchos:

print(scores.has(20)) # true
print(20 in scores) # true
print(scores.find(20)) # 2
scores.sort()
print(scores) # [15, 20, 30, 40]
last : int = scores.pop_back() ?? 0 # an Option[int]: the array may be empty
print(last) # 40
print(scores.slice(0, 2)) # [15, 20]
scores.clear()
print(scores.is_empty()) # true
MétodoQué hace
append(v)Añade al final
size(), is_empty()Cuántos hay, si no hay ninguno
has(v), v in aSi contiene el valor
find(v)Posición del valor, o -1
sort()Ordena en el sitio
pop_back()Quita el último y lo devuelve, como un Option (none si el array está vacío)
map(f), filter(f), reduce(f, inicio)Un array nuevo con f de cada uno, los que dan true en f, todo combinado
slice(desde, hasta)Una copia de un trozo
clear()Lo vacía

En map, filter y reduce, f es una función que les pasas, como una lambda.

Usa un diccionario cuando buscas cosas por un nombre: el precio de cada objeto, la puntuación de cada jugador, los ajustes del juego.

Un Dictionary asocia claves con valores: le das una clave y te da el valor de esa clave. Con Dictionary[K, V] fijas el tipo de las claves (K) y el de los valores (V):

mut ages : Dictionary[String, int] = { "Ana": 30, "Leo": 25 }
ages["Zoe"] = 19
print(ages["Ana"]) # 30
print(ages.size()) # 3

Asignar a una clave que no existe la crea; si ya existe, la reemplaza.

print(ages.has("Leo")) # true
print(ages.get("Max", 0)) # 0
print(ages.keys()) # ["Ana", "Leo", "Zoe"]
print(ages.erase("Leo")) # true
  • has(k) dice si la clave existe.
  • get(k, por_defecto) da el valor, o el valor por defecto cuando la clave no está.
  • keys() y values() dan arrays con las claves y los valores.
  • erase(k) borra la clave y devuelve si existía.

Cuando las claves son nombres, puedes escribirlas sin comillas, con =, como en el lenguaje Lua:

settings : Dictionary = { volume = 0.8, music = true }
print(settings.size()) # 2

{ volume = 0.8 } es lo mismo que escribir la clave como texto, y los dos estilos son igual de rápidos. Un literal usa un estilo o el otro, no los dos.

¿Y si pides la quinta puntuación y solo hay dos? Leer un índice que no existe es un error en tiempo de ejecución: un error que aparece mientras el juego está corriendo. Con ?? detrás, no lo es: si el índice o la clave faltan, obtienes el valor de la derecha.

ids : []int = [10, 20]
print(ids[1] ?? -1) # 20
print(ids[5] ?? -1) # -1, no error
print(ages["Max"] ?? -1) # -1, no error

Para hacer algo con cada elemento (saludar a cada jugador, dañar a cada enemigo cercano), for los recorre uno a uno. El bucle se explica a fondo en el capítulo 4; por ahora basta con esta forma:

names : []String = ["Ana", "Leo"]
for n : String in names {
print($"Hi, {n}")
}

Recorrer un diccionario da sus claves. Para los valores, usa values():

for person : String in ages {
print($"{person} is {ages[person]}")
}
for age : int in ages.values() {
print(age)
}

Pon el tipo de la variable del bucle (n : String). Así el analizador sabe qué tienes en cada vuelta.

Algunas listas nunca cambian de tamaño: las 9 casillas de un tres en raya, los 3 números de una posición. Para eso están los arrays de tamaño fijo.

[N]T es un array de exactamente N elementos de tipo T, como en el lenguaje Odin. Sin valor empieza con N ceros; un literal tiene que traer justo N valores:

mut board : [9]int # 9 zeros
mut origin : [3]float = [0.0, 1.5, 0.0] # exactly 3 values
board[4] = 1
mut copy : [9]int = board # a copy: changing it leaves board as it is
copy[0] = 2
print(board[0], " ", copy[0], " ", origin[1], " ", board.size()) # 0 2 1.5 9
  • Es un valor: asignarlo, pasarlo a una función o devolverlo hace una copia (barata: los elementos solo se copian cuando escribes en ella).
  • Su tamaño no cambia: append, resize, insert, remove_at, clear… dan error, y un índice constante fuera de rango también. Para una lista que crece usa []T.
  • Guarda los valores seguidos, como un []int, así que se puede pasar donde va un []T (una copia: el []T puede crecer).
  • T puede ser int, float, String, Vector2, Vector3, Vector4 o Color.

Un mapa de casillas o un tablero tiene filas y columnas. Con dos dimensiones, [N][M]T son N filas de M elementos, guardadas seguidas en un solo array ([3][4]int ocupa 12 enteros). grid[i][j] es un solo acceso; los índices negativos cuentan desde el final de su dimensión y cada dimensión se comprueba:

mut grid : [3][4]int # 3 rows of 4, all zeros
grid[1][2] = 7
grid[-1][-1] = 9 # last row, last column
mut cells : [2][2]int = [[1, 2], [3, 4]]
mut row : [2]int = cells[1] # a copy of row 1
print(grid[1][2], " ", grid[2][3], " ", row) # 7 9 [3, 4]

grid[i] solo es una copia de la fila. Para cambiarla, asigna sus elementos (grid[i][j] = v). Recórrela con índices (for i in N, for j in M); for x in grid y grid.size() dan error porque mezclarían las filas.

A veces una lista crece y encoge, pero nunca pasa de un número que pone el juego: los 4 objetos que suelta un enemigo, 8 casillas de inventario, las últimas 5 posiciones de una estela. [..N]T es una lista de como mucho N números (int, float, u8… f32):

Enemy :: struct {
hp : int = 10
drops : [..4]int # at most 4, starts empty
}
mut e : Enemy
e.drops.append(7)
e.drops.append(12)
print(e.drops, " ", e.drops.size(), " of ", e.drops.capacity()) # [7, 12] 2 of 4
for d : int in e.drops {
print(d)
}
mut hand : [..5]int = [3, 1] # a literal of at most 5
hand.sort()
  • Funciona como un []T: append, size(), [i], for, clear, pop_back(), sort()… capacity() es N.
  • Añadir un valor cuando ya tiene N para el juego con un error que lo dice, como un índice fuera de rango. Mira antes size() < capacity() si se puede llenar.
  • Solo entra lo que se sabe que cabe: un literal de como mucho N valores, o un [..M]T con M <= N. Un []T podría tener más: añade sus valores uno a uno con append.
  • Es un valor, como [N]T: al asignarlo se copia.
  • Dentro de un struct sus valores van en el propio struct, sin crear nada más. Con miles de enemigos, cada uno con unos pocos objetos, es mucho más rápido que un []int en cada uno.

A veces un trozo de código solo necesita parte de un array, por ejemplo las puntuaciones de las diez últimas rondas. Copiar esa parte lleva tiempo; una vista te deja trabajar con ella donde está.

a[lo:hi] es un view[T]: unas casillas de un array, de lo a hi - 1, sin copiarlas (como los slices de Odin y Rust). Escribir en la vista escribe en el array:

mut all : []int = [1, 2, 3, 4, 5]
mut mid : view[int] = all[1:4] # a view of 2, 3, 4: nothing is copied
mid[0] = 20 # changes all[1]
mut rest : view[int] = all[3:] # [lo:] to the end, [:hi] from the start, [:] all
print(all, " ", mid.size(), " ", rest.to_array()) # [1, 20, 3, 4, 5] 3 [4, 5]
print(total(all[1:3])) # 23: a function that takes some elements
  • Funciona sobre []T, [N]T y otras vistas (una vista de una vista mira el array original). Los límites pueden ser negativos y se comprueban al crearla.
  • s.size(), s[i] (también negativo), for x in s y s.to_array() (una copia).
  • Una vista no crece: cambia lo que hay en sus casillas, pero no cuántas hay (append es un error).
  • Una función que recibe values : view[int] trabaja sobre parte de un array sin copiarlo: total(puntos[10:20]). Para pasar el array entero, a[:].
fn total(values : view[int]) int {
mut sum : int = 0
for v : int in values {
sum += v
}
return sum
}
  • En un [N][M]T, grid[i][lo:hi] es una vista de la fila i (escribir en ella cambia grid).

Casi siempre te basta con int y float. Los números más pequeños son para muchos datos en bruto: los bytes de un archivo, los píxeles de una imagen, los datos de una malla.

int y float son de 64 bits (8 bytes cada uno). Como en Rust, Grost tiene también u8 (de 0 a 255), i8, i16, u16, i32, u32 y f32: un número que se queda en ese rango.

  • Lo que entra en uno da la vuelta: al pasarse del final vuelve a empezar desde el principio (300 as u8 es 44, es decir, 300 - 256).
  • u8 + u8 es un u8.
  • No se mezclan con otros números sin as: b as int, total as u8.
  • Una constante que cabe no necesita nada (b : u8 = 200, b + 1); una que no cabe es un error.
  • Un f32 se muestra como f32, igual que en Rust: x : f32 = 0.1 muestra 0.1 (1.0 / 3.0 muestra 0.33333334, las cifras que guarda un f32).
  • En un struct cada campo ocupa su tamaño: hp : u16 son 2 bytes, speed : f32 4. Con miles de enemigos en un []Enemy, es mucha menos memoria.

Sus arrays también van empaquetados, cada valor en 1, 2 o 4 bytes: []u8 (los bytes de un archivo, una imagen), []i16, []u32, []f32 (los datos de una malla)… y fijos, [64]u8. bytes[i] es un u8.

mut heights : []f32 = [1.5, 2.0]
heights[1] = 3.25
print(heights) # [1.5, 3.25]

Esto importa en cuanto le pasas un contenedor a otra parte de tu código. Un array ([]T, [N]T), un diccionario, un []S o un Pool[S] es un valor, como un número: si lo asignas a otra variable, esa variable tiene su propia copia, y cambiar una nunca cambia la otra.

mut a : []int = [1, 2]
mut b : []int = a # b is a copy of a
b.append(3)
print(a, " ", b) # [1, 2] [1, 2, 3]: a doesn't change

Copiar no cuesta nada hasta que una de las dos cambia: hasta entonces comparten los datos sin que se note. Lo mismo pasa al dar un contenedor a una función, guardarlo en un campo o en otro contenedor, devolverlo o usarlo dentro de una lambda: cada uno tiene su copia. Los nodos y los recursos sí se comparten: son cosas del juego, no valores.

Si una función tiene que cambiar el array de quien la llama, lo dice con & en el parámetro, como un struct del capítulo 5, y quien la llama pone &:

fn add_bonus(scores : &[]int, bonus : int) void {
scores.append(bonus) # the caller's array: it sees the change
}
mut points : []int = [10, 20]
add_bonus(&points, 5) # "&": the function changes this array
print(points) # [10, 20, 5]
ParámetroLa función recibeCambia el array de quien llama
values : []intuna copiano
values : view[int]unas casillas del array (a[lo:hi], a[:])sí, esas casillas; no cuántas hay
values : &[]intel array de quien llama (&a)sí, también cuántos hay

& sirve con una variable mut, un miembro, un parámetro &, un campo de uno de ellos o un elemento de un contenedor (&grupos["rojo"]). Dentro de la función, values no puede pasar a ser otro array (values = [1] es un error): cambia lo que tiene.

module Arrays
fn _ready() void {
mut scores : []int = [30, 10, 20]
scores.append(40)
print(scores) # [30, 10, 20, 40]
print(scores[0]) # 30
print(scores[-1]) # 40 (counts from the end)
scores[1] = 15
print(scores.size()) # 4
print(scores.has(20)) # true
print(20 in scores) # true
print(scores.find(20)) # 2
scores.sort()
print(scores) # [15, 20, 30, 40]
last : int = scores.pop_back() ?? 0 # an Option[int]: the array may be empty
print(last) # 40
print(scores.slice(0, 2)) # [15, 20]
scores.clear()
print(scores.is_empty()) # true
ids : []int = [10, 20]
print(ids[1] ?? -1) # 20
print(ids[5] ?? -1) # -1, no error
mixed : Array = [1, "two", 3.5]
print(mixed.size()) # 3
names : []String = ["Ana", "Leo"]
for n : String in names {
print($"Hi, {n}")
}
mut heights : []f32 = [1.5, 2.0]
heights[1] = 3.25
print(heights) # [1.5, 3.25]
mut board : [9]int # 9 zeros
mut origin : [3]float = [0.0, 1.5, 0.0] # exactly 3 values
board[4] = 1
mut copy : [9]int = board # a copy: changing it leaves board as it is
copy[0] = 2
print(board[0], " ", copy[0], " ", origin[1], " ", board.size()) # 0 2 1.5 9
mut grid : [3][4]int # 3 rows of 4, all zeros
grid[1][2] = 7
grid[-1][-1] = 9 # last row, last column
mut cells : [2][2]int = [[1, 2], [3, 4]]
mut row : [2]int = cells[1] # a copy of row 1
print(grid[1][2], " ", grid[2][3], " ", row) # 7 9 [3, 4]
mut all : []int = [1, 2, 3, 4, 5]
mut mid : view[int] = all[1:4] # a view of 2, 3, 4: nothing is copied
mid[0] = 20 # changes all[1]
mut rest : view[int] = all[3:] # [lo:] to the end, [:hi] from the start, [:] all
print(all, " ", mid.size(), " ", rest.to_array()) # [1, 20, 3, 4, 5] 3 [4, 5]
print(total(all[1:3])) # 23: a function that takes some elements
mut a : []int = [1, 2]
mut b : []int = a # b is a copy of a
b.append(3)
print(a, " ", b) # [1, 2] [1, 2, 3]: a doesn't change
mut points : []int = [10, 20]
add_bonus(&points, 5) # "&": the function changes this array
print(points) # [10, 20, 5]
}
fn total(values : view[int]) int {
mut sum : int = 0
for v : int in values {
sum += v
}
return sum
}
fn add_bonus(scores : &[]int, bonus : int) void {
scores.append(bonus) # the caller's array: it sees the change
}
module Dictionaries
fn _ready() void {
mut ages : Dictionary[String, int] = { "Ana": 30, "Leo": 25 }
ages["Zoe"] = 19
print(ages["Ana"]) # 30
print(ages.size()) # 3
print(ages.has("Leo")) # true
print(ages.get("Max", 0)) # 0
print(ages.keys()) # ["Ana", "Leo", "Zoe"]
print(ages.erase("Leo")) # true
print(ages["Max"] ?? -1) # -1, no error
for person : String in ages {
print($"{person} is {ages[person]}")
}
for age : int in ages.values() {
print(age)
}
settings : Dictionary = { volume = 0.8, music = true }
print(settings.size()) # 2
}