veloren_rtsim/data/

airship.rs

use crate::data::Npcs;
use common::{rtsim::NpcId, terrain::MapSizeLg};
use std::cmp::Ordering;
use vek::*;
use world::{
    World,
    civ::airship_travel::{
        AirshipDockingApproach, AirshipFlightPhase, AirshipSpawningLocation, Airships,
    },
    util::DHashMap,
};

/// Data for airship operations. This is part of RTSimData and is NOT persisted.
#[derive(Clone, Default, Debug)]
pub struct AirshipSim {
    /// The pilot route assignments. The key is the pilot NpcId, the value is
    /// a tuple. The first element is the index for the outer Airships::routes
    /// Vec (the route loop index), and the second element is the index for the
    /// pilot's initial route leg in the inner Airships::routes Vec.
    pub assigned_routes: DHashMap<NpcId, (usize, usize)>,

    /// The pilots assigned to a route in the order they fly the route.
    pub route_pilots: DHashMap<usize, Vec<NpcId>>,
}

#[cfg(debug_assertions)]
macro_rules! debug_airships {
    ($level:expr, $($arg:tt)*) => {
        match $level {
            0 => tracing::info!($($arg)*),
            1 => tracing::warn!($($arg)*),
            2 => tracing::error!($($arg)*),
            3 => tracing::debug!($($arg)*),
            4 => tracing::trace!($($arg)*),
            _ => tracing::trace!($($arg)*),
        }
    }
}

#[cfg(not(debug_assertions))]
macro_rules! debug_airships {
    ($($arg:tt)*) => {};
}

impl AirshipSim {
    /// Called from world generation code to set the route and initial leg
    /// indexes for an airship captain NPC. World generation is dynamic and
    /// can change across runs, and existing captain (and ship) NPCs may
    /// change the assigned route and leg, and new NPCs may be added to the
    /// world. This is the function that connects the saved RTSim data to
    /// the world generation data.
    pub fn register_airship_captain(
        &mut self,
        location: &AirshipSpawningLocation,
        captain_id: NpcId,
        airship_id: NpcId,
        world: &World,
        npcs: &mut Npcs,
    ) {
        self.assigned_routes
            .insert(captain_id, (location.route_index, location.leg_index));

        assert!(
            location.dir.is_normalized(),
            "Airship direction {:?} is not normalized",
            location.dir
        );
        let airship_wpos3d = match location.flight_phase {
            AirshipFlightPhase::DepartureCruise
            | AirshipFlightPhase::ApproachCruise
            | AirshipFlightPhase::Transition => location.pos.with_z(
                world
                    .sim()
                    .get_alt_approx(location.pos.map(|e| e as i32))
                    .unwrap_or(0.0)
                    + location.height,
            ),
            _ => location.pos.with_z(location.height),
        };
        let airship_mount_offset = if let Some(airship) = npcs.get_mut(airship_id) {
            airship.wpos = airship_wpos3d;
            airship.dir = location.dir;
            airship.body.mount_offset()
        } else {
            tracing::warn!(
                "Failed to find airship {:?} for captain {:?}",
                airship_id,
                captain_id,
            );
            Vec3::new(0.0, 0.0, 0.0)
        };
        if let Some(captain) = npcs.get_mut(captain_id) {
            let captain_pos = airship_wpos3d
                + Vec3::new(
                    location.dir.x * airship_mount_offset.x,
                    location.dir.y * airship_mount_offset.y,
                    airship_mount_offset.z,
                );
            captain.wpos = captain_pos;
            captain.dir = location.dir;
        }

        debug_airships!(
            4,
            "Registering airship {:?}/{:?} for spawning location {:?}",
            airship_id,
            captain_id,
            location,
        );
    }

    /// Called from world generation code after all airship captains have been
    /// registered. This function generates the route_pilots hash map which
    /// provides a list of pilots assigned to each route index, in the order
    /// they will fly the route. This provides for determining the "next
    /// pilot" on a route, which is used for deconfliction and
    /// "traffic control" of airships.
    pub fn configure_route_pilots(&mut self, airships: &Airships, npcs: &Npcs) {
        debug_airships!(4, "Airship Assigned Routes: {:?}", self.assigned_routes);
        // for each route index and leg index, find all pilots that are assigned to
        // the route index and leg index. Sort them by their distance to the starting
        // position of the leg. Repeat for all legs of the route, then add the resulting
        // list to the route_pilots hash map.

        for route_index in 0..airships.route_count() {
            let mut pilots_on_route = Vec::new();
            for leg_index in 0..airships.docking_site_count_for_route(route_index) {
                // Find all pilots that are spawned on the same route_index and leg_index.
                let mut pilots_on_leg: Vec<_> = self
                    .assigned_routes
                    .iter()
                    .filter(|(_, (rti, li))| *rti == route_index && *li == leg_index)
                    .map(|(pilot_id, _)| *pilot_id)
                    .collect();

                if !pilots_on_leg.is_empty() {
                    // Sort pilots by their distance to the starting position of the leg.
                    let start_pos = airships.route_leg_departure_location(route_index, leg_index);
                    pilots_on_leg.sort_by(|&pilot1, &pilot2| {
                        let pilot1_pos = npcs.get(pilot1).map_or(start_pos, |npc| npc.wpos.xy());
                        let pilot2_pos = npcs.get(pilot2).map_or(start_pos, |npc| npc.wpos.xy());
                        start_pos
                            .distance_squared(pilot1_pos)
                            .partial_cmp(&start_pos.distance_squared(pilot2_pos))
                            .unwrap_or(Ordering::Equal)
                    });
                    pilots_on_route.extend(pilots_on_leg);
                }
            }
            if !pilots_on_route.is_empty() {
                debug_airships!(4, "Route {} pilots: {:?}", route_index, pilots_on_route);
                self.route_pilots.insert(route_index, pilots_on_route);
            }
        }
    }

    /// Retrieves two airship destinations - the current and the next.
    pub fn next_destinations(
        &self,
        airships: &Airships,
        map: &MapSizeLg,
        route_index: usize,
        current_leg: Option<(usize, AirshipFlightPhase)>,
    ) -> Option<(AirshipDockingApproach, AirshipDockingApproach)> {
        if let Some(current_leg) = current_leg {
            match current_leg.1 {
                // If docked, retrieve the next two.
                AirshipFlightPhase::Docked | AirshipFlightPhase::Ascent => {
                    let next_route_leg = airships.increment_route_leg(route_index, current_leg.0);
                    Some((
                        airships.approach_for_route_and_leg(route_index, next_route_leg, map),
                        airships.approach_for_route_and_leg(
                            route_index,
                            airships.increment_route_leg(route_index, next_route_leg),
                            map,
                        ),
                    ))
                },
                // If not docked, retrieve the current and next.
                AirshipFlightPhase::ApproachCruise
                | AirshipFlightPhase::DepartureCruise
                | AirshipFlightPhase::Descent
                | AirshipFlightPhase::Transition => Some((
                    airships.approach_for_route_and_leg(route_index, current_leg.0, map),
                    airships.approach_for_route_and_leg(
                        route_index,
                        airships.increment_route_leg(route_index, current_leg.0),
                        map,
                    ),
                )),
            }
        } else {
            None
        }
    }

    /// Given a route index and pilot id, find the next pilot on the route (the
    /// one that is ahead of the given pilot).
    pub fn next_pilot(&self, route_index: usize, pilot_id: NpcId) -> Option<NpcId> {
        if let Some(pilots) = self.route_pilots.get(&route_index) {
            if pilots.len() < 2 {
                // If there is only one pilot on the route, return the pilot itself.
                tracing::warn!(
                    "Route {} has only one pilot, 'next_pilot' doesn't make sense.",
                    route_index,
                );
                return None;
            }
            if let Some(pilot_index) = pilots.iter().position(|&p_id| p_id == pilot_id) {
                if pilot_index == pilots.len() - 1 {
                    // If the pilot is the last one in the list, return the first one.
                    return Some(pilots[0]);
                } else {
                    // Otherwise, return the next pilot in the list.
                    return Some(pilots[pilot_index + 1]);
                }
            }
        }
        tracing::warn!(
            "Failed to find next pilot for route index {} and pilot id {:?}",
            route_index,
            pilot_id
        );
        None
    }
}