Structs
Enemigo :: struct {
nombre : String = "slime"
vida : int = 10
}1 · Una ficha con camposEnemigo :: struct crea un tipo nuevo. Cada línea de dentro es un campo: un dato con su tipo y su valor por defecto. Enemigo{} crea uno con esos valores.
fn _ready() void {
e : Enemigo = Enemigo{}
print(e.nombre, " ", e.vida)
}slime 10
Enemigo :: struct {
nombre : String = "slime"
vida : int = 10
}
fn _ready() void {
e : Enemigo = Enemigo{ .nombre = "orco", .vida = 30 }
print(e.nombre, " ", e.vida)2 · Elegir sus valoresEntre las llaves eliges los campos que quieres cambiar, con un punto delante. Con e.nombre lees un campo.}orco 30
Enemigo :: struct {
nombre : String = "slime"
vida : int = 10
}
fn _ready() void {
mut a : Enemigo = Enemigo{}
mut b : Enemigo = a
b.vida = 1
print(a.vida, " ", b.vida)3 · Las copias son independientesAl asignar un struct a otra variable se copia. Cambiar la copia no toca el original, al revés que con las listas.}10 1
Enemigo :: struct {
nombre : String = "slime"
vida : int = 10
}
impl Enemigo {
fn herir(mut self, danio: int) void {
self.vida -= danio
}
}
fn _ready() void {
mut e : Enemigo = Enemigo{}
e.herir(4)4 · Métodos con implUn bloque impl le da funciones al struct: sus métodos. self es el valor sobre el que lo llamas, y mut self deja que el método lo cambie. print(e.vida)
}6
Un enemigo tiene nombre, vida y velocidad. Con lo que sabes, serían tres variables sueltas por
enemigo: nombre_orco, vida_orco, velocidad_orco… y otras tres para el siguiente. Se
complica enseguida.
Un struct agrupa los datos de una cosa bajo un solo nombre, como la ficha de un personaje. Así un enemigo es un valor, con todos sus datos dentro.
Agrupar datos en un struct
module Enemigos
Enemigo :: struct { nombre : String = "slime" vida : int = 10 velocidad : float = 1.5}
fn _ready() void { e : Enemigo = Enemigo{} print(e.nombre, " tiene ", e.vida, " de vida")}| Parte | Qué hace |
|---|---|
Enemigo | El nombre del tipo nuevo. Se suele escribir con la primera letra en mayúscula |
:: struct { ... } | Dice que es un struct y, entre llaves, qué campos tiene |
vida : int = 10 | Un campo: su nombre, su tipo y su valor por defecto |
e.vida | Lee el campo vida del valor e |
- Los structs se declaran a nivel de script, fuera de las funciones.
- Cada campo va en su propia línea.
- Una vez declarado,
Enemigoes un tipo comointoString: puedes tener variables de tipoEnemigo.
Crear valores y cambiar sus campos
module Crear
Enemigo :: struct { nombre : String = "slime" vida : int = 10 velocidad : float = 1.5}
fn _ready() void { a : Enemigo = Enemigo{} mut b : Enemigo = Enemigo{ .nombre = "orco", .vida = 30 } b.vida -= 5 print(a) print(b)}Enemigo{}crea uno con todos los valores por defecto.Enemigo{ .nombre = "orco", .vida = 30 }cambia solo los campos que nombras, con un punto delante. Los demás se quedan como estaban.b.vida -= 5cambia un campo. Si vas a cambiar sus campos, declara la variable conmut.printmuestra el struct con todos sus campos.
Las copias son independientes
Aquí los structs funcionan al revés que las listas y los diccionarios. Al asignar un struct a otra variable, se copia: tienes dos valores separados.
module Copias
Punto :: struct { x : int = 0 y : int = 0}
fn _ready() void { mut a : Punto = Punto{ .x = 1, .y = 2 } mut b : Punto = a b.x = 10 print(a.x, " ", b.x)}b empezó siendo igual que a, pero es otro punto. Cambiar b.x no toca a.x.
Métodos: funciones del struct
Un bloque impl le añade funciones a un struct. Las que trabajan sobre un valor se llaman
métodos:
module Jugadores
Jugador :: struct { nombre : String = "Gobi" vidas : int = 3}
impl Jugador { fn nuevo(nombre: String) Jugador { return Jugador{ .nombre = nombre } }
fn vivo(self) bool { return self.vidas > 0 }
fn herir(mut self, danio: int) void { self.vidas -= danio }}
fn _ready() void { mut j : Jugador = Jugador.nuevo("Bob") j.herir(2) print(j.nombre, " vivo: ", j.vivo()) j.herir(1) print(j.nombre, " vivo: ", j.vivo())}| Función | Cómo se llama | Qué puede hacer |
|---|---|---|
fn vivo(self) | j.vivo() | Leer los campos del valor con self.campo |
fn herir(mut self, ...) | j.herir(2) | Además, cambiarlos |
fn nuevo(...), sin self | Jugador.nuevo("Bob") | Se llama sobre el tipo. Suele servir para crear valores |
Un método con mut self cambia el valor, así que solo se puede llamar sobre una variable
mut:
module SinMut
Jugador :: struct { vidas : int = 3}
impl Jugador { fn herir(mut self, danio: int) void { self.vidas -= danio }}
fn _ready() void { j : Jugador = Jugador{} j.herir(1)}Una lista de structs
Los structs y las listas se llevan bien: una mochila puede ser una lista de objetos, cada uno con su nombre y su cantidad.
module Mochila
Objeto :: struct { nombre : String = "" cantidad : int = 0}
fn _ready() void { mut mochila : []Objeto = [ Objeto{ .nombre = "madera", .cantidad = 3 }, Objeto{ .nombre = "piedra", .cantidad = 1 }, ] mochila.append(Objeto{ .nombre = "llave", .cantidad = 1 }) mochila[1].cantidad += 4 for o : Objeto in mochila { print($"{o.nombre}: {o.cantidad}") }}[]Objetoes una lista deObjeto.mochila[1].cantidad += 4cambia el objeto que está dentro de la lista.- Leer un elemento (
mochila[0], o elodelfor) da una copia: cambiar esa copia no cambia la lista.
¿Struct o diccionario?
Pregúntate si sabes los nombres de los datos al escribir el código. Si los sabes (vida, velocidad, nombre), usa un struct: Grost comprueba que escribes bien cada campo y es más rápido. Si las claves las decide el juego (los objetos que recoge el jugador, los nombres de los jugadores), usa un diccionario.
Hora de practicar
¿Qué imprime este código?
Moneda :: struct {
valor : int = 1
dorada : bool = false
}
fn _ready() void {
m : Moneda = Moneda{ .dorada = true }
print(m.valor, " ", m.dorada)
}dorada; valor conserva su valor por defecto, 1.¿Qué imprime este código?
Punto :: struct {
x : int = 0
}
fn _ready() void {
mut a : Punto = Punto{ .x = 1 }
mut b : Punto = a
b.x = 5
print(a.x)
}b es una copia de a. Cambiar b.x no cambia a.x, que sigue valiendo 1.b es el mismo punto que a o una copia?Completa el código para darle a Jugador un método que le quite una vida.
2
Jugador :: struct {
vidas : int = 3
}
Jugador {
fn perder_vida( self) void {
self.vidas -= 1
}
}
fn _ready() void {
mut j : Jugador = Jugador{}
j.perder_vida()
print(j.vidas)
}Jugador :: struct {
vidas : int = 3
}
impl Jugador {
fn perder_vida(mut self) void {
self.vidas -= 1
}
}
fn _ready() void {
mut j : Jugador = Jugador{}
j.perder_vida()
print(j.vidas)
}¿Qué línea crea un Enemigo con 50 de vida y lo demás por defecto?
.campo = valor. Enemigo(50) y Enemigo{ vida: 50 } son errores, y Enemigo.vida = 50 no crea nada.=.