space-crush/space-crush-common/src/systems/ships_movement.rs

#![allow(dead_code)]

use specs::{prelude::*, ParJoin, Read, ReadStorage, System, WriteStorage};

use crate::{
    components::{Fleet, FleetOwned, Player, PlayerOwned, Position, Ship, ShipMoving, ShipType},
    resources::Global,
};

#[derive(Default)]
pub struct ShipsMovement;

#[derive(SystemData)]
pub struct ShipsMovementData<'a> {
    positions: WriteStorage<'a, Position>,
    ships: ReadStorage<'a, Ship>,
    ships_moving: ReadStorage<'a, ShipMoving>,
    fleet_owned: ReadStorage<'a, FleetOwned>,
    fleets: ReadStorage<'a, Fleet>,
    player_owned: ReadStorage<'a, PlayerOwned>,
    players: ReadStorage<'a, Player>,
    global: Read<'a, Global>,
}

impl<'a> System<'a> for ShipsMovement {
    type SystemData = ShipsMovementData<'a>;

    fn run(&mut self, data: Self::SystemData) {
        let ShipsMovementData {
            mut positions,
            ships,
            ships_moving,
            fleet_owned,
            fleets,
            player_owned,
            players,
            global,
        } = data;

        (
            &mut positions,
            &player_owned,
            &fleet_owned,
            &ships,
            ships_moving.maybe(),
        )
            .par_join()
            .for_each(|(position, player_owned, fleet_owned, ship, ship_moving)| {
                let delta = global.delta * global.world_speed;
                let position = position.get_mut();
                let player_id = player_owned.owner();
                let player = players.get(player_id).unwrap();
                let ships_data = player.ships_data();
                let type_ = ship.type_();

                let speed = if ship_moving.is_some() {
                    let fleet_id = fleet_owned.owner();
                    let fleet = fleets.get(fleet_id).unwrap();

                    let mut speed = ships_data[type_].speed;

                    macro_rules! merge {
                        ($t:path) => {
                            if fleet.count()[$t] > 0 {
                                speed = speed.min(ships_data[$t].speed);
                            }
                        };
                    }

                    merge!(ShipType::Fighter);
                    merge!(ShipType::Bomber);
                    merge!(ShipType::Transporter);

                    speed
                } else {
                    ships_data[type_].speed
                };

                *position += ship.dir() * speed * delta;
            });
    }
}