space-crush/space-crush-app/src/debug/ships.rs

use glc::vector::Vector4f;
use space_crush_common::components::{
    Player, PlayerOwned, Position, Ship, ShipMoving, ShipObstacle, ShipOrbiting,
};
use specs::{prelude::*, ReadStorage, System, World, WriteExpect};

use crate::resources::Geometry;

#[derive(Default)]
pub struct Ships;

#[derive(SystemData)]
pub struct ShipsData<'a> {
    geometry: WriteExpect<'a, Geometry>,
    positions: ReadStorage<'a, Position>,
    player_owned: ReadStorage<'a, PlayerOwned>,
    players: ReadStorage<'a, Player>,
    ships: ReadStorage<'a, Ship>,
    ships_orbiting: ReadStorage<'a, ShipOrbiting>,
    ships_moving: ReadStorage<'a, ShipMoving>,
}

impl<'a> System<'a> for Ships {
    type SystemData = ShipsData<'a>;

    fn run(&mut self, data: Self::SystemData) {
        let ShipsData {
            mut geometry,
            positions,
            player_owned,
            players,
            ships,
            ships_orbiting,
            ships_moving,
        } = data;

        gl::enable(gl::BLEND);
        gl::blend_func(gl::SRC_ALPHA, gl::ONE);

        let data = (
            &positions,
            &player_owned,
            &ships,
            ships_orbiting.maybe(),
            ships_moving.maybe(),
        );

        for (position, player_owned, ship, ship_orbiting, ship_moving) in data.join() {
            let ship_pos = position.get();
            let type_ = ship.type_();
            let player_id = player_owned.owner();
            let player = players.get(player_id).unwrap();
            let ship_data = player.ship_data(type_);

            geometry.render_lines(
                Vector4f::new(0.0, 0.0, 1.0, 0.2),
                &[*ship_pos, ship_pos + ship.dir() * ship_data.speed],
            );

            if let Some(ship_orbiting) = &ship_orbiting {
                geometry.render_lines(
                    Vector4f::new(1.0, 0.0, 0.0, 0.2),
                    &[*ship_pos, ship_pos + ship_orbiting.target_dir() * 100.0],
                );
                geometry.render_lines(
                    Vector4f::new(1.0, 1.0, 1.0, 0.2),
                    &[*ship_pos, *ship_orbiting.target_pos()],
                );
            }

            if let Some(ship_moving) = ship_moving {
                if let ShipObstacle::Known(obstacle_id) = ship_moving.obstacle() {
                    let obstacle_pos = positions.get(*obstacle_id).unwrap().get();

                    geometry.render_lines(
                        Vector4f::new(0.0, 1.0, 0.0, 0.2),
                        &[*ship_pos, *obstacle_pos],
                    );
                }
            }
        }

        gl::disable(gl::BLEND);
    }
}