Aprendiendo Rust - Kiwi Towers

<3 por los animos

#3 no se en que quede la cosa, pero como poco voy a aprender Rust xDDDD.

Ayer estuve mirando un poco como funciona Bevy y su ECS (nunca he usado ECS) asi que estuve faileando un buen rato. Tengo que aprender mejor como funcionan los eventos para poder hacer spawn/kill/damage y estas mierdas pero ayer solo tenia panic!s por todos sitios lmao

#7 Bevy es de hace un par de meses: https://bevyengine.org/news/ hace a;o y medio estaba todo en pa;ales me parece a mi.

Pues he estado jugando otro rato con el engine y me va gustando lo que veo, hiper personalizable y empiezo a entender un poco mas sobre ECS. He aprendido que existen los bundles para no tener que crear objetos mega enormes cuando haces spawn si no que spawneas la Tower y de ahi puedes sacar lo que quieras. Asi que por ahora no creo que hagan falta tantas struct como Damage ya que seguramente pueda ir como propiedad, ese es el siguiente experimento que quiero hacer.

Consegui enviar 2 eventos de que una torre le quita vida a un mob que hay vivo (2 veces), y se ve en el output como de verdad pone que le queda menos vida que con la que empezo.

Trying to damage a mob
Tower: Tower { damage: Damage(100.0), hp: HealthPoints(1000.0), bullet: Bullet { speed: Speed(100) } }
Event received: TowerPlaced(1v0)
Event received: MobSpawned(2v0)
Event received: TowerDamaged(0v0, 1v0)
Tower has damaged a mob! HealthPoints(1000.0) for Damage(100.0)
Event received: TowerDamaged(0v0, 1v0)
Tower has damaged a mob! HealthPoints(900.0) for Damage(100.0)

El cogido queda asi, es bastante engorroso por ahora ya que es el fruto de muchos tests y aprendizaje pero creo que el core empiezo a entenderlo mucho mas.

use crate::GameEvent::{TowerPlaced, MobSpawned, TowerDamaged};


use bevy::prelude::*;


fn main() {
    App::build()
        .add_event::<GameEvent>()
        .init_resource::<EventListenerState>()
        .add_startup_system(add_towers.system())
        .add_startup_system(add_mobs.system())
        .add_system(damage_mob.system())
        .add_system(print_tower.system())
        .add_system(event_listener_system.system())
        .run();
}

#[derive(Debug, Bundle)]
struct Tower {
    damage: Damage,
    hp: HealthPoints,
    bullet: Bullet,
}

#[derive(Debug, Bundle)]
struct Bullet {
    speed: Speed
}

#[derive(Debug)]
struct Damage(f32);

#[derive(Debug)]
struct Speed(i32);

#[derive(Debug)]
struct HealthPoints(f32);

#[derive(Debug, Bundle)]
struct Mob {
    damage: Damage,
    hp: HealthPoints,
    ms: Speed,
}

#[derive(Debug)]
enum GameEvent {
    TowerPlaced(Entity),
    TowerDamaged(Entity, Entity),
    MobSpawned(Entity),
}

#[derive(Default)]
struct EventListenerState {
    event_reader: EventReader<GameEvent>,
}

fn print_tower(tower: &Tower) {
    println!("Tower: {:?}", tower);
}

fn damage_mob(
    mut events: ResMut<Events<GameEvent>>,
) {
    println!("Trying to damage a mob");
    events.send(TowerDamaged(Entity::new(0), Entity::new(1)));
    events.send(TowerDamaged(Entity::new(0), Entity::new(1)));
}

fn add_mobs(mut commands: Commands, mut events: ResMut<Events<GameEvent>>) {
    let entity1 = Entity::new(2);
    let mob = Mob {
        hp: HealthPoints(1000_f32),
        damage: Damage(100_f32),
        ms: Speed(100),
    };
    commands.spawn((mob, entity1));
    events.send(MobSpawned(entity1));
}

fn add_towers(mut commands: Commands, mut events: ResMut<Events<GameEvent>>) {
    let entity1 = Entity::new(1);
    let tower = Tower {
        damage: Damage(100_f32),
        hp: HealthPoints(1000_f32),
        bullet: Bullet {
            speed: Speed(100)
        }
    };
    let tower = (tower, entity1);
    commands.spawn(tower);
    events.send(TowerPlaced(entity1));
}

fn event_listener_system(
    mut state: ResMut<EventListenerState>,
    events: ResMut<Events<GameEvent>>,
    mut towers: Query<(Entity, &Tower)>,
    mut mobs: Query<(Entity, &mut Mob)>,
) {
    for event in state.event_reader.iter(&events) {
        println!("Event received: {:?}", &event);
        match event {
            GameEvent::TowerDamaged(_from, _to) => {
                let mut tower_query = towers.entity(*_from);
                let mut tower_query = tower_query.unwrap();
                let (_, tower) = tower_query.get().unwrap();
                let mut mob_query = mobs.entity(*_to).unwrap();
                let (_, mut mob) = mob_query.get().unwrap();
                println!("Tower has damaged a mob! {:?} for {:?}", &mob.hp, &tower.damage);
                mob.hp.0 -= &tower.damage.0;
            },
            GameEvent::TowerPlaced(tower_entity) => {
                if let Ok(mut query) = towers.entity(*tower_entity) {
                    if let Some((_entity, tower)) = query.get() {
                        println!(
                            "Tower has been placed with {:?} damage and {:?} hp",
                            &tower.damage, &tower.hp
                        );
                    }
                }
            }
            _ => {}
        }
    }
}

Para lo siguiente

1. Me gustaria hacer un system por cada tipo de eventos y que no sea el mismo metodo para todos los eventos.
2. Ver si un evento puede ser ejecutado por 2 sistemas diferentes.
3. Como funciona el testing?

Pues si, he visto una forma mejor (aunque requiere algo de sincronizacion entre el modelo y el bundle), que se trata de tener el modelo con sus tipos normales (aunque sean alias). Teniendo una implementacion de la struct que se puedan crear nuevas torres y algo que lo convierte a bundle parece lo optimo.

use bevy::prelude::*;

use crate::model::common::{Bullet, Damage, HealthPoints, Speed};
use bevy::ecs::DynamicBundle;

#[derive(Debug, Bundle)]
pub struct Tower {
    pub damage: Damage,
    pub hp: HealthPoints,
    pub bullet: Bullet,
    pub attack_speed: Speed,
}

pub mod components {

    #[derive(Debug)]
    pub struct AttackSpeed;

    #[derive(Debug)]
    pub struct Damage;

}

impl Tower {
    pub fn as_bundle(self,) -> impl DynamicBundle {
        (Entity::new(1), self, components::AttackSpeed, components::Damage)
    }

    pub fn new(
        damage: Damage,
        hp: HealthPoints,
        bullet: Bullet,
        attack_speed: i32,
    ) -> Self {
        Tower {
            damage,
            hp,
            bullet,
            attack_speed,
        }
    }
}

Luego para hacer spawn (en los components), es easy!

    let tower = Tower::new(100_f32, 1000_f32, Bullet {
        speed: 100
    }, 100);
    let tower = tower.as_bundle();
    commands.spawn(tower);

De esta manera me deja hacer Queries por los componentes que a mi me venga en gana y actualizar lo que se necesite:

fn print_damage(mut attacking_towers: Query<(&Tower, &AttackSpeed)>) {
    for (tower, attack_speed) in attacking_towers.iter().iter() {
        println!("Damage: {:?}", tower.damage);
    }
}

No solo eso si no que Bevy tiene bastantes tipos de queries, por ejemplo las Or, Query<(Or<&Tower, &Mob>, &AttackSpeed)>, esto me daria un iterador de tuplas que contiene en cada tupla (tower, attack_speed) o (mob, attack_speed), asi que la flexibilidad que le veo ahora mismo es inmensa.

Si, el iter().iter() queda feo, pero es porque estoy usando una version mas antigua de bevy (la que estan en git tiene cambios importantes en ECS) y uno de esos cambios es que Query es un iter normal (https://github.com/bevyengine/bevy/pull/741) asi que es algo que va a cambiar en la siguiente release. Ademas de que si no se hace pronto, cambiare de release a la version de git (que es alo que se puede hacer de forma nativa en Rust).

Bueno, pues creo que por ahora tengo un buen entendimiento de como funciona el engine con ECS y sus eventos como para seguir refactorizar lo que tengo hasta ahora de esta manera y hacer el prototipo de una torre que tiene velocidad de ataque y ataca a todos los mobs que ve en cada frame.

Cosas para investigar:

1. Ver como funcionan los timer para en vez de hacer una cosa cada frame, hacer una cosa cada X tiempo (se que existe, pero no me he molestado todavia)
2. Sigo teniendo que mirar los test lul

Pues hoy he quitado un monton de mierda de todas las pruebas que he estado haciendo durante estos dias mientras aprendia sobre Bevy y ya he conseguido usar bien los timers y ya tengo a 2 torres atacando a un mob (aunque este no muere todavia). Tambien le he configurado loggers asi puedo saber tiempos y esas cosas para comprobar mejor lo de los timers xDD

Este es el system que ataca, es de lo mas sencillo y lo unico que hay que comprobar es si el timer ha terminado, los plugins que vienen ya preconfigurados se encargan (ya que son componentes) de hacer el tick para cada componente del tipo Timer. Como se ve, es lo mas sencillo de la historia y la unica linea con chicha es la de mob.hp

fn attack_mobs(
    mut towers: Query<(&Tower, &mut Timer)>,
    mut mobs: Query<(&mut Mob)>
) {
    for (tower, mut timer) in towers.iter_mut() {
        if timer.just_finished {
            for (mut mob) in mobs.iter_mut().take(1) {
                // Handle stuff like critical strike, stun, slow
                mob.hp -= &tower.attack.damage;
                info!("Now the mob has {} hp.", mob.hp);
            }
        }
    }
}

Por lo demas, me he creado un plugin propio donde a;ado unas cuantas torres y mobs ya que asi puedo intercambiar los plugins y hacerlos como si fueran mapas. Es super comodo y se intercambian con una simple linea de codigo. Asi que por ahora todo queda bastante guay y modularizado. Creo que lo siguiente si deberia ser ya los tests xDDD

El main queda asi:

fn main() {
    log4rs::init_file("config/log4rs.yaml", Default::default()).unwrap();

    info!("Initializing");

    App::build()
        .add_plugin(TypeRegistryPlugin::default())
        .add_plugin(CorePlugin::default())
        .add_plugin(ScheduleRunnerPlugin::default())
        .add_plugin(SimpleMapPlugin)
        .add_plugin(AttackPlugin)
        .run();
}