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]) # 30print(scores[-1]) # 40 (counts from the end)scores[1] = 15print(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()) # 3Métodos habituales
Sección titulada «Métodos habituales»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)) # trueprint(20 in scores) # trueprint(scores.find(20)) # 2scores.sort()print(scores) # [15, 20, 30, 40]last : int = scores.pop_back() ?? 0 # an Option[int]: the array may be emptyprint(last) # 40print(scores.slice(0, 2)) # [15, 20]scores.clear()print(scores.is_empty()) # true| Método | Qué hace |
|---|---|
append(v) | Añade al final |
size(), is_empty() | Cuántos hay, si no hay ninguno |
has(v), v in a | Si 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.
Diccionarios
Sección titulada «Diccionarios»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"] = 19print(ages["Ana"]) # 30print(ages.size()) # 3Asignar a una clave que no existe la crea; si ya existe, la reemplaza.
print(ages.has("Leo")) # trueprint(ages.get("Max", 0)) # 0print(ages.keys()) # ["Ana", "Leo", "Zoe"]print(ages.erase("Leo")) # truehas(k)dice si la clave existe.get(k, por_defecto)da el valor, o el valor por defecto cuando la clave no está.keys()yvalues()dan arrays con las claves y los valores.erase(k)borra la clave y devuelve si existía.
Claves al estilo Lua
Sección titulada «Claves al estilo Lua»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.
Índices que faltan y ??
Sección titulada «Índices que faltan y ??»¿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) # 20print(ids[5] ?? -1) # -1, no errorprint(ages["Max"] ?? -1) # -1, no errorRecorrer un contenedor
Sección titulada «Recorrer un contenedor»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.
Arrays de tamaño fijo
Sección titulada «Arrays de tamaño fijo»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 zerosmut origin : [3]float = [0.0, 1.5, 0.0] # exactly 3 valuesboard[4] = 1mut copy : [9]int = board # a copy: changing it leaves board as it iscopy[0] = 2print(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[]Tpuede crecer). Tpuede serint,float,String,Vector2,Vector3,Vector4oColor.
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 zerosgrid[1][2] = 7grid[-1][-1] = 9 # last row, last columnmut cells : [2][2]int = [[1, 2], [3, 4]]mut row : [2]int = cells[1] # a copy of row 1print(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.
Arrays con tope: [..N]T
Sección titulada «Arrays con tope: [..N]T»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 : Enemye.drops.append(7)e.drops.append(12)print(e.drops, " ", e.drops.size(), " of ", e.drops.capacity()) # [7, 12] 2 of 4for d : int in e.drops { print(d)}mut hand : [..5]int = [3, 1] # a literal of at most 5hand.sort()- Funciona como un
[]T:append,size(),[i],for,clear,pop_back(),sort()…capacity()esN. - Añadir un valor cuando ya tiene
Npara el juego con un error que lo dice, como un índice fuera de rango. Mira antessize() < capacity()si se puede llenar. - Solo entra lo que se sabe que cabe: un literal de como mucho
Nvalores, o un[..M]TconM <= N. Un[]Tpodría tener más: añade sus valores uno a uno conappend. - 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
[]inten cada uno.
Vistas: parte de un array sin copiar
Sección titulada «Vistas: parte de un array sin copiar»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 copiedmid[0] = 20 # changes all[1]mut rest : view[int] = all[3:] # [lo:] to the end, [:hi] from the start, [:] allprint(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]Ty 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 sys.to_array()(una copia).- Una vista no crece: cambia lo que hay en sus casillas, pero no cuántas hay (
appendes 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 filai(escribir en ella cambiagrid).
Números más pequeños: u8, i16, f32…
Sección titulada «Números más pequeños: u8, i16, f32…»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 u8es 44, es decir, 300 - 256). u8 + u8es unu8.- 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
f32se muestra comof32, igual que en Rust:x : f32 = 0.1muestra0.1(1.0 / 3.0muestra0.33333334, las cifras que guarda unf32). - En un struct cada campo ocupa su tamaño:
hp : u16son 2 bytes,speed : f324. 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.25print(heights) # [1.5, 3.25]Los contenedores son valores
Sección titulada «Los contenedores son valores»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 ab.append(3)print(a, " ", b) # [1, 2] [1, 2, 3]: a doesn't changeCopiar 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 arrayprint(points) # [10, 20, 5]| Parámetro | La función recibe | Cambia el array de quien llama |
|---|---|---|
values : []int | una copia | no |
values : view[int] | unas casillas del array (a[lo:hi], a[:]) | sí, esas casillas; no cuántas hay |
values : &[]int | el 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.
Los ejemplos completos
Sección titulada «Los ejemplos completos»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}