Struct Airships

pub struct Airships {
    pub airship_docks: Vec<AirshipDockPositions>,
    pub routes: Vec<Vec<AirshipRouteLeg>>,
    pub spawning_locations: Vec<AirshipSpawningLocation>,
}

Data for airship operations. This is generated world data.

Fields

airship_docks: Vec<AirshipDockPositions>

routes: Vec<Vec<AirshipRouteLeg>>

spawning_locations: Vec<AirshipSpawningLocation>

Implementations

impl Airships

pub const AIRSHIP_SPACING: f32 = 5000f32

The nominal distance between airships when they are first spawned in the world.

const AIRSHIP_TO_DOCK_Z_OFFSET: f32 = -3f32

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

pub const CRUISE_HEIGHTS: [f32; 4]

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

const DEFAULT_DOCK_DURATION: f32 = 60f32

const DOCKING_TRANSITION_OFFSET: f32 = 175f32

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 MIN_SPAWN_POINT_DIST_FROM_DOCK: f32 = 300f32

The minimum distance from the docking position where the airship can be initially placed in the world.

const SPAWN_TARGET_DIST_INCREMENT: f32 = 47f32

The algorithm that computes where to initially place airships in the world (spawning locations) increments the candidate location of the first airship on each route by this amount. This is just a prime number that is small enough that the AIRSHIP_SPACING is not exceeded by the expected number of iterations required to find a starting spawning point such that all airships are not too close to docking positions when spawned. TODO: check that this still if a larger world map is used.

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 assign_docking_platforms( route_segments: &[Vec<usize>], dock_locations: &[Vec2<f32>], ) -> Vec<Vec<AirshipRouteLeg>>

Assign the docking platforms for each leg of each route. Each route consists of 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).

pub fn calculate_spawning_locations(&mut self, all_dock_points: &[Point])

For each route, calculate the location along the route where airships should be initially located when the server starts. This attempts to space airships evenly along the route while ensuring that no airship is too close to a docking position. Each airship needs separation from the docking position such that the airship can initially move forward towards its target docking location when it first starts flying because it will start in the cruise phase of flight.

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_transition_point( &self, dock_index: usize, route_index: usize, platform: AirshipDockPlatform, from: Vec2<f32>, ) -> Option<Vec3<f32>>

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

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

                     F
                    ∙
                   ∙
                  ∙
                 ∙
                ∙
               T
              ∙
             ∙
            D

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

The transition point between cruise flight and docking is on a line between the route leg starting point (F) 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. I.e., the position of the dock for the previous route leg.

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 approach_for_route_and_leg( &self, route_index: usize, leg_index: usize, ) -> 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 copy 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.