Ir al contenido
Descargar
Curso de Grost

Structs

Módulo 2 · Datos y coleccionesLección 8 de 209 min de lectura4 retos
main.groPaso 1 de 4
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)
}
Output
slime 10
main.groPaso 2 de 4
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.}
Output
orco 30
main.groPaso 3 de 4
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.}
Output
10 1
main.groPaso 4 de 4
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)
}
Output
6
También con las flechas ← →

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

main.gro
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")
}
Outputslime tiene 10 de vida
ParteQué hace
EnemigoEl 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 = 10Un campo: su nombre, su tipo y su valor por defecto
e.vidaLee 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, Enemigo es un tipo como int o String: puedes tener variables de tipo Enemigo.

Crear valores y cambiar sus campos

main.gro
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)
}
OutputEnemigo(nombre: "slime", vida: 10, velocidad: 1.5) Enemigo(nombre: "orco", vida: 25, velocidad: 1.5)
  • 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 -= 5 cambia un campo. Si vas a cambiar sus campos, declara la variable con mut.
  • print muestra 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.

main.gro
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)
}
Output1 10

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:

main.gro
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())
}
OutputBob vivo: true Bob vivo: false
FunciónCómo se llamaQué 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 selfJugador.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:

main.gro
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)
}
OutputParse Error: Cannot call "mut self" method "herir()" on an immutable variable. Declare it with "mut".

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.

main.gro
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}")
}
}
Outputmadera: 3 piedra: 5 llave: 1
  • []Objeto es una lista de Objeto.
  • mochila[1].cantidad += 4 cambia el objeto que está dentro de la lista.
  • Leer un elemento (mochila[0], o el o del for) 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

Retos: 0/4 resueltosSe guardan en este navegador
Reto 1 de 4sin resolver

¿Qué imprime este código?

main.gro
Moneda :: struct {
  valor : int = 1
  dorada : bool = false
}

fn _ready() void {
  m : Moneda = Moneda{ .dorada = true }
  print(m.valor, " ", m.dorada)
}
Solo cambias dorada; valor conserva su valor por defecto, 1.
Los campos que no nombras en el literal se quedan con su valor por defecto.
Reto 2 de 4sin resolver

¿Qué imprime este código?

main.gro
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?
Reto 3 de 4sin resolver

Completa el código para darle a Jugador un método que le quite una vida.

Salida esperada
2
main.gro
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)
}
El primer hueco abre el bloque de métodos. El segundo deja que el método cambie el valor.
Solución:
main.gro
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)
}
Reto 4 de 4sin resolver

¿Qué línea crea un Enemigo con 50 de vida y lo demás por defecto?

Un literal de struct es el nombre, llaves y los campos con .campo = valor. Enemigo(50) y Enemigo{ vida: 50 } son errores, y Enemigo.vida = 50 no crea nada.
Dentro de las llaves, cada campo va con un punto delante y un =.