Aprendiendo Rust - Kiwi Towers

#34 Mas te vale que no existe.

Como funciona en el motor el Bundle, he mirado la doc oficial por encima pero no lo he acabado de pillar.

Lo que hace es sacar de tus entidades/struct los subcomponentes para gestionarlos en el sistema?

Me ha parecido que hacia algo del estilo.

Esta interesante el framework.

#38 Yo personalmente he odiado siempre que el ide no te diga si compila o no compila, creo que es un trauma adquirido en la uni de programar en vi a pelo y luego acomodarme en un ide y lenguajes simplones como C#/Java/Kt.

Hoy en día solo soy capaz de programar en js así. Al final con lo demas mezclo sintaxis

Ayer monte lo de los github actions con algo muy parecido a lo que hace el propio engine (ya que me faltaban las mismas librerias). Y todo furula bien, le tuve que quitar algunas cosas que luego ire arreglando poco a poco pero por ahora todo funciona bien.

Obviamente no se puede rular los test sin compilar pero creo que se refiere a que si no tira los test, no pase la build xD (y eso ya es asi, ya que el exit code != 0 y eso la falla)

Pues sigo en ello, ahora mismo ya tengo un sistema (en verdad son varios), que spawnean una oleada de mobs. Por ahora lo tengo solamente el primer mob ya que todavia no tengo ni idea como lo hare al final pero bueno, esta testeado y lo siguiente sera ver como lo puedo meter en el plugin para un mapa muy simple.

He rehecho (otra vez) el como se spawnean las cosas aunque es bastante parecido a la ultima vez. Ahora he decidido que esto sea (mas o menos), lo que continee los datos y se convierte en componentes al llamar a spawn, de esta manera podemos generar multiple spawns desde un mismo mob.

#[derive(Debug, Bundle)]
pub struct Tower {
    pub hp: f32,
    pub attack: Attack,
    pub critical: Option<Critical>,
    pub slow: Option<Slow>,
    pub stun: Option<Stun>,
}

impl Spawnable for Tower {
    fn spawn(self, commands: &mut Commands) -> Entity {
        let timer = Timer::new(Duration::from_secs_f32(self.attack.attack_speed.0), true);
        return commands
            .spawn(())
            .with(TowerComp)
            .with(HealthPoints(self.hp))
            .with(self.attack.clone())
            .with(self.critical.clone())
            .with(self.slow.clone())
            .with(self.stun.clone())
            .with(timer)
            .current_entity()
            .unwrap();
    }
}

Sobre el spawn de las oleadas, la cosa funciona de la siguiente manera, lo que hago es spawnear una serie de timers (1 por oleada) que tiene como propiedad cuantas veces se va a ejecutar altes de hacerse el harakiri:

// Esto mira los wavetimer y spawnea los mobs cada vez que termina
pub(crate) fn spawn_wave(mut commands: Commands, mut query: Query<(&Timer, &WaveTimer, &Mob)>) {
    for (timer, _, mob) in query.iter() {
        if timer.finished {
            println!("Spawning mob.");
            mob.spawn(&mut commands);
        }
    }
}

// Este se encarga de que el wavetimer no este para siempre!
pub(crate) fn check_multiple_timers(
    mut commands: Commands,
    mut query: Query<(Entity, &Timer, &mut WaveTimer)>,
) {
    for (entity, timer, mut mult_times) in query.iter_mut() {
        if timer.just_finished {
            mult_times.times -= 1;
        }

        if mult_times.times <= 0 {
            commands.despawn(entity);
        }
    }
}

Y el como se spawnean estos timers tambien esta hecho en su propio sistema asi que no tienen ni idea uno del otro!

pub struct WaveTimer {
    duration: Duration,
    times: i32,
}

impl WaveTimer {
    fn from(wave: &Wave) -> Self {
        Self {
            duration: Duration::from_secs_f32(wave.timer),
            times: wave.mobs.len().try_into().unwrap(),
        }
    }

    fn new(duration: Duration, times: i32) -> Self {
        Self { duration, times }
    }
}

impl Spawnable for WaveTimer {
    fn spawn(self, commands: &mut Commands) -> Entity {
        let timer = Timer::new(self.duration, true);
        return commands
            .spawn(())
            .with(self)
            .with(timer)
            .current_entity()
            .unwrap();
    }
}

Asi que ya tengo esto mas o menos furulando y los mobs estan siendo spawneados. Asi que como he dicho antes, ahora lo que tengo que hacer es cambiar el mob.spawn system del simple plugin al system que hace spawn de las waves y esperar

Ah, pues si que funciona bien lo del spawn de los mobs, pero es todo tan rapido que creia que no lul

2020-11-29T13:09:40.778105+01:00 INFO kiwi_towers - Initializing
2020-11-29T13:09:40.780010+01:00 INFO kiwi_towers::plugins::simple - Initializing SimpleMapPlugin
2020-11-29T13:09:41.282286+01:00 INFO kiwi_towers::plugins::tower_defense - Spawning mob. Mob { hp: 100.0, ms: Speed(0), attack: None }
2020-11-29T13:09:41.782576+01:00 INFO kiwi_towers::plugins::tower_defense - Spawning mob. Mob { hp: 100.0, ms: Speed(0), attack: None }
2020-11-29T13:09:41.782795+01:00 INFO kiwi_towers::attack - Now the mob 3v0 has 0 hp.
2020-11-29T13:09:41.782830+01:00 INFO kiwi_towers::attack - Killed mob 3v0
2020-11-29T13:09:41.782851+01:00 INFO kiwi_towers::attack - Now the mob 4v0 has 0 hp.
2020-11-29T13:09:41.782870+01:00 INFO kiwi_towers::attack - Killed mob 4v0

Ahi si podemos ver que hay 0.5 segundos entre el spawn de uno y otro.

Otro ejemplo con 2 torres, una con 22,1 (ataque y velocidad) y otra 100,2.5

2020-11-29T13:13:25.705309+01:00 INFO kiwi_towers - Initializing
2020-11-29T13:13:25.707140+01:00 INFO kiwi_towers::plugins::simple - Initializing SimpleMapPlugin
2020-11-29T13:13:26.209176+01:00 INFO kiwi_towers::plugins::tower_defense - Spawning mob. Mob { hp: 100.0, ms: Speed(0), attack: None }
2020-11-29T13:13:26.709448+01:00 INFO kiwi_towers::plugins::tower_defense - Spawning mob. Mob { hp: 100.0, ms: Speed(0), attack: None }
2020-11-29T13:13:26.709700+01:00 INFO kiwi_towers::attack - Now the mob 3v0 has 78 hp.
2020-11-29T13:13:26.709741+01:00 INFO kiwi_towers::attack - Now the mob 4v0 has 78 hp.
2020-11-29T13:13:26.709806+01:00 INFO kiwi_towers::attack - Now the mob 3v0 has 56 hp.
2020-11-29T13:13:26.709830+01:00 INFO kiwi_towers::attack - Now the mob 4v0 has 56 hp.
2020-11-29T13:13:27.709219+01:00 INFO kiwi_towers::attack - Now the mob 3v0 has 34 hp.
2020-11-29T13:13:27.709277+01:00 INFO kiwi_towers::attack - Now the mob 4v0 has 34 hp.
2020-11-29T13:13:27.709337+01:00 INFO kiwi_towers::attack - Now the mob 3v0 has 12 hp.
2020-11-29T13:13:27.709368+01:00 INFO kiwi_towers::attack - Now the mob 4v0 has 12 hp.
2020-11-29T13:13:28.209664+01:00 INFO kiwi_towers::attack - Now the mob 3v0 has -88 hp.
2020-11-29T13:13:28.209717+01:00 INFO kiwi_towers::attack - Killed mob 3v0
2020-11-29T13:13:28.709517+01:00 INFO kiwi_towers::attack - Now the mob 4v0 has -10 hp.
2020-11-29T13:13:28.709576+01:00 INFO kiwi_towers::attack - Killed mob 4v0

Y todo parece funcionar perfecto

Ahora he a;adido que el jugador pierda si se queda sin vidas aunque todavia no esta codificado que los mobs lleguen al final. Asi el jugador no va a perder nunca pero bueno, ya tengo mis tests funcionando tranquilamente. Se queda super limpito (aunque en el futuro ha de cambiar ya que hay diferentes maneras de perder)

fn finish_no_lives_game(state: Res<GameState>, mut app_exit: ResMut<Events<AppExit>>) {
    if state.lives <= 0 {
        app_exit.send(AppExit)
    }
}

Por otra parte he refactorizado un poquito y metido todo bien en plugins, con sus funciones privadas ya que asi no puedo ni tan siquier caer en la tentacion de usarlas fuera de donde deberia. Cada plugin hace una cosa y por ahora tengo unos cuantos:

1. Plugin para a;adir las scenes necesarias (por ahora ninguna, pero ya esta preparado)
2. Plugin que maneja el ataque
3. Plugin para cuando ha de terminar la partida (por ejemplo tiene dos checkeos, el numero de vidas y cuando termina la partida satisfactoriamente)
4. Grupo con todos los plugins ya que asi solo necesito aplicar un plugin en el main

Ejemplo

#[derive(Default)]
pub struct EndGamePlugin;

impl Plugin for EndGamePlugin {
    fn build(&self, app: &mut AppBuilder) {
        app.add_system_to_stage(stage::POST_UPDATE, finish_successful_game);
        app.add_system_to_stage(stage::POST_UPDATE, finish_no_lives_game);
    }
}

Y por ahora todo va 12/12, he de hacer algunos tests mas (sobre todo probando mejor los plugins antes que las funciones), pero por ahora estoy bastante contento conforme esta quedando.

Pues siguiente episodio, he estado investigando un poquito mas sobre Bevy y las cosas que van haciendo en master, la verdad es que el desarrollo es super activo, y su discord aun mas.

Hay una forma de que un componente en la entidad no este en la Query como tal (los datos sobre los que luego vas a iterar) si no que sean una especie de condiciones.

fn attack_mobs(
    commands: &mut Commands,
    mut towers: Query<(&Attack, &Timer, Option<&Critical>), (With<TowerComp>)>,
    mut mobs: Query<(Entity, &mut HealthPoints), (Without<Dead>, With<MobComp>)>,
)

Ahora tambien existe un derive que te completa los parametros de la query con los items de la struct, asi no se te quedan queries kilometricas, aunque por ahora no me esta pasando, cuando tenga que a;adir el Slow, Stun, Invis.... supongo que habra unas cuantas todavia no se como quedara eso pero bueno, estoy en ello.

Ademas, como el snippet anterior indica, ya he implementado el ataque critico, aunque no me gusta que todo este en el mismo sistema, seguramente lo acabe dividiendo de alguna manera.

He continuado con la macro de los tests y aunque he escrito mas codigo del que me he ahorrado por ahora, me ha bajado un cojon las lineas de codigo de los tests que no tendran los siguientes.

Ahora se me ha quedado asi:

        test_setup!(
            world;
            run_times: 1;
            spawn: tower, mob1;
            res: game, game_state;
            system: advance_timers, attack_mobs;
            system: despawn_dead_entities "post_update"
        );

Le he a;adido para que en una linea puedas tener varios items. Tambien para que en un sistema le puedas decir la stage en la que correr, cuantos frames han de pasar (run_times) y tambien para resources. Asi que por ahora voy a cerrar este capitulo aunque lo vaya mejorando poco a poco ya voy a dejar de centrarme en esto.

Ejemplo de test:

    #[test]
    fn multi_attack_tower() {
        let tower = Tower::new(
            Damage(50_f32),
            100_f32,
            Bullet::default(),
            AttackSpeed(0.5_f32),
            Targets(2),
        );
        let mob1 = Mob::new(100_f32);
        let mob2 = Mob::new(100_f32);

        test_setup!(
            world;
            run_times: 1;
            spawn: tower, mob1, mob2;
            system: advance_timers, attack_mobs
        );

        let mob1_health_points = world.get::<HealthPoints>(mob1).unwrap();
        let mob2_health_points = world.get::<HealthPoints>(mob2).unwrap();

        assert_eq!(mob1_health_points.0, 50_f32);
        assert_eq!(mob2_health_points.0, 50_f32);
    }

Para ma;ana, tengo 3 issues abiertas sobre las oleadas de mobs que voy a revisar.

Y estoy bastante pendiente de https://github.com/bevyengine/bevy/pull/1021 que hace un poco un rework de como funcionan las stages y tiene una pinta de puta madre (y me tocara actualizar la macro :D)

Pues he migrado todo y bastante mas sencillo de lo que parecia. Me gusta mucho que su sistema de automatizacion de builds es un script de Kotlin por lo que puedes incluso programar ahi. No es una basura de yml como en todos los demas sitios basura.

job("Build Towers") {
    container("bevybuild:latest") {
    	shellScript {
    	    content = "cargo build"
        }
    }
}

Tan simple como eso. Ahora tengo que ver mas formas de personalizarlo pero la verdad es que me gusta bastante el ecosistema que han montado, no solo eso si no que tambien tienen los gestores de paquetes (contenedores incluidos) y todo bastante integrado. Les doy mis dieses por ahora.

Lo siguiente es mover los Plugins que tengo hacia la carpeta examples para poder tener mas de uno y poder ir testeando diferentes cosas. Despues de eso me pondre a averiguar como funciona lo del slow/stun y me gustaria tambien jugar con los scripts y los eventos dentro del juego para llamar a diferentes funciones cuando X cosa pasa.