Struct Airships 

pub struct Airships {
    pub airship_docks: Vec<AirshipDockPositions>,
    pub routes: Vec<AirshipRoute>,
    pub nominal_speed: f32,
}

Data for airship operations. This is generated world data.

Fields

airship_docks: Vec<AirshipDockPositions>

The docking positions for all airship docks in the world.

routes: Vec<AirshipRoute>

The routes flown by the collective airships in the world.

nominal_speed: f32

The speed of simulated airships (and the nominal speed of loaded airships) in world blocks per second.

Implementations

impl Airships

pub const AIRSHIP_ASCENT_DURATION: f64 = 30f64

The duration of the ascent flight phase.

pub const AIRSHIP_DESCENT_DURATION: f64 = 30f64

The duration of the descent flight phase.

pub const AIRSHIP_DOCKING_DURATION: f64 = 60f64

The duration of the docked phase.

pub const AIRSHIP_TIME_SPACING: f64 = 240f64

The time spacing between airships on the same route.

const AIRSHIP_TO_DOCK_Z_OFFSET: f32 = -3f32

The Z offset between the docking alignment point and the AirshipDock plot docking position.

pub const AIRSHIP_TRANSITION_SPEED_RATIO: f32 = 0.75f32

The ratio of the speed used when transitioning from cruising to docking as a percentage of the nominal airship speed.

pub const CRUISE_HEIGHTS: [f32; 4]

The cruising height varies by route index and there can be only four routes.

const DOCKING_TRANSITION_OFFSET: f32 = 175f32

The distance from the docking position where the airship starts the transition flight phase.

const DOCK_ALIGN_POS_PORT: Vec2<f32>

The vector from the dock alignment point when the airship is docked on the port side.

const DOCK_ALIGN_POS_STARBOARD: Vec2<f32>

The vector from the dock alignment point on the airship when the airship is docked on the starboard side.

const DOCK_ALIGN_X: f32 = 18f32

The absolute offset from the airship’s position to the docking alignment point on the X axis. The airship is assumed to be facing positive Y.

const DOCK_ALIGN_Y: f32 = 1f32

The offset from the airship’s position to the docking alignment point on the Y axis. The airship is assumed to be facing positive Y. This is positive if the docking alignment point is in front of the airship’s center position.

const ROUTE_LEG_MIDPOINT_MARGIN: f32 = 200f32

The minimum distance from the route leg midpoint to the world boundaries.

const ROUTE_LEG_MIDPOINT_OFFSET_RADIANS: f32 = 0.0872659981f32

The angle for calculating the route leg midpoint.

pub fn docking_duration() -> f32

fn all_airshipdock_positions(sites: &Store<Site>) -> Vec<AirshipDockPositions>

Get all the airship docking positions from the world sites.

pub fn increment_route_leg(&self, route_index: usize, leg_index: usize) -> usize

Convienence function that returns the next route leg accounting for wrap around.

pub fn decrement_route_leg(&self, route_index: usize, leg_index: usize) -> usize

Convienence function that returns the previous route leg accounting for wrap around.

pub fn route_count(&self) -> usize

Convienence function returning the number of routes.

pub fn docking_site_count_for_route(&self, route_index: usize) -> usize

Safe function to get the number of AirshipDock sites on a route.

fn create_route_legs( &mut self, route_segments: &[Vec<usize>], dock_locations: &[Vec2<f32>], map_size_lg: &MapSizeLg, ) -> Vec<AirshipRoute>

Calculate the legs for each route. A docking platform is assigned for each leg of each route. Each route in the route_segments argument is a series (Vec) of docking node indices on the docking site graph. This function loops over the routes docking nodes and assigns a docking platform based on the approach direction to each dock node while making sure that no docking platform is used more than once (globally, over all routes). It then calculates the leg segments (flight phases) for each leg of each route. The output is a Vec of up to four routes, each of which is a closed loop of route legs.

pub fn calculate_spawning_locations(&mut self)

pub fn generate_airship_routes_inner( &mut self, map_size_lg: &MapSizeLg, seed: u32, _index: Option<&Index>, _sampler: Option<&WorldSim>, _map_image_path: Option<&str>, )

Generates the airship routes.

pub fn generate_airship_routes( &mut self, world_sim: &mut WorldSim, index: &Index, )

pub fn approach_waypoints( &self, from_dock_center: &Vec2<f32>, to_dock_positions: &AirshipDockPositions, platform: AirshipDockPlatform, map_size_lg: &MapSizeLg, ) -> (Vec2<f32>, Vec2<f32>)

Compute the route midpoint and the transition point where the airship should stop the cruise flight phase and start the docking phase.

 F : From position
 M : Midpoint
 T : Transition point
 D : Docking position
 C : Center of the airship dock
 X : Airship dock

                           F
                        •
                     •
                  M
                 ∙
                ∙
               T
              ∙
             ∙
            D

          XXXXX
        XX     XX
       X         X
       X    C    X
       X         X
        XX     XX
          XXXXX

The midpoint is for route leg deconfliction and is where the airship makes a coarse correction to point at the destination. The transition point (T) between cruise flight and docking approach is on a line between the route leg midpoint (M) and the docking position (D), short of the docking position by Airships::DOCKING_TRANSITION_OFFSET blocks.

Arguments

• dock_index - The airship dock index in airship_docks.
• route_index - The index of the route (outer vector of airships.routes). This is used to determine the cruise height.
• platform - The platform on the airship dock where the airship is to dock.
• from - The position from which the airship is approaching the dock.

Returns

The 2D position calculated with the Z coordinate set to the docking_position.z + cruise height.

fn vec3_relative_eq(a: &Vec3<f32>, b: &Vec3<f32>, epsilon: f32) -> bool

pub fn docking_position_and_dir_for_route_and_leg( from_dock_positions: &AirshipDockPositions, to_dock_positions: &AirshipDockPositions, platform: AirshipDockPlatform, ) -> (Vec3<f32>, Dir)

pub fn approach_for_route_and_leg( &self, route_index: usize, leg_index: usize, map_size_lg: &MapSizeLg, ) -> AirshipDockingApproach

pub fn airship_spawning_locations(&self) -> Vec<AirshipSpawningLocation>

pub fn route_leg_departure_location( &self, route_index: usize, leg_index: usize, ) -> Vec2<f32>

Get the position a route leg originates from.

pub fn airship_vec_for_docking_pos( docking_pos: Vec3<f32>, airship_dock_center: Vec2<f32>, docking_side: Option<AirshipDockingSide>, ) -> (Vec3<f32>, Dir)

Get the position and direction for the airship to dock at the given docking position. If use_starboard_boarding is None, the side for boarding is randomly chosen. The center of the airship position with respect to the docking position is an asymmetrical offset depending on which side of the airship will be used for boarding and where the captain is located on the airship. The returned position is the position where the captain will be when the airship is docked (because the captain NPC is the one that is positioned in the agent or rtsim code).

pub fn angle_between_vectors_ccw(v1: Vec2<f32>, v2: Vec2<f32>) -> f32

Returns the angle from vec v1 to vec v2 in the CCW direction.

pub fn angle_between_vectors_cw(v1: Vec2<f32>, v2: Vec2<f32>) -> f32

Returns the angle from vec v1 to vec v2 in the CW direction.

Trait Implementations

impl Clone for Airships

fn clone(&self) -> Airships

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Default for Airships

fn default() -> Airships

Returns the “default value” for a type.