Struct AreMiniGamePlayer 

pub struct AreMiniGamePlayer {

    pub vehicle: AreMiniGameVehicle,
    pub camera: ResRef,
    pub camera_rotate: bool,
    pub minimum_speed: f32,
    pub maximum_speed: f32,
    pub accel_secs: f32,
    pub tunnel_x_pos: f32,
    pub tunnel_x_neg: f32,
    pub tunnel_y_pos: f32,
    pub tunnel_y_neg: f32,
    pub tunnel_z_pos: f32,
    pub tunnel_z_neg: f32,
    pub tunnel_infinite: [f32; 3],
    pub start_offset_x: f32,
    pub start_offset_y: f32,
    pub start_offset_z: f32,
    pub target_offset_x: f32,
    pub target_offset_y: f32,
    pub target_offset_z: f32,
}

Typed view over the MiniGame.Player sub-struct.

Fields

vehicle: AreMiniGameVehicle

The vehicle fields shared with every enemy.

camera: ResRef

Camera resref (Camera) - only used for turret type (type 2).

camera_rotate: bool

Camera rotation flag (CameraRotate).

minimum_speed: f32

Lower speed bound (Minimum_Speed).

Default -1.0, a sentinel: the engine applies the value only when it is at or above zero, so a negative bound leaves the constructed one.

maximum_speed: f32

Upper speed bound (Maximum_Speed), default 100.0.

Gated the same way as Self::minimum_speed, which for a default of 100.0 means the gate never rejects it.

accel_secs: f32

Seconds to accelerate across the speed range (Accel_Secs).

The engine keeps only the acceleration it derives from this and the two speed bounds, never the field itself, and the derivation has three branches: exactly 0.0 gives the full speed range as the rate, a negative value skips the derivation, and anything else divides the range by it. The view models the file’s value, since that is what the file holds and what a caller edits.

tunnel_x_pos: f32

Positive-X track boundary (TunnelXPos).

tunnel_x_neg: f32

Negative-X track boundary (TunnelXNeg).

tunnel_y_pos: f32

Positive-Y track boundary (TunnelYPos).

tunnel_y_neg: f32

Negative-Y track boundary (TunnelYNeg).

tunnel_z_pos: f32

Positive-Z track boundary (TunnelZPos).

tunnel_z_neg: f32

Negative-Z track boundary (TunnelZNeg).

tunnel_infinite: [f32; 3]

Per-axis flags for an unbounded tunnel (TunnelInfinite).

A GFF vector rather than three floats, unlike the bounds it modifies.

start_offset_x: f32

Start position X offset (Start_Offset_X).

The engine assembles the three into one vector and feeds it to the vehicle’s origin. They stay three fields here because that is how the file stores them.

start_offset_y: f32

Start position Y offset (Start_Offset_Y).

start_offset_z: f32

Start position Z offset (Start_Offset_Z).

target_offset_x: f32

Camera target X offset (Target_Offset_X).

Three independent floats, and not assembled into a vector the way the start offsets are.

target_offset_y: f32

Camera target Y offset (Target_Offset_Y).

target_offset_z: f32

Camera target Z offset (Target_Offset_Z).

Implementations

impl AreMiniGamePlayer

pub const SCHEMA: [Field; 18]

This view’s schema, one entry per declared field.

pub const PARTS: &'static [&'static [Field]]

This type’s schema in parts, which is what a container holding it references.

Own fields first, then one part per flattened child in the order they are declared.

pub fn read_declared(root: &GffStruct) -> Self

Reads every declared field off root.

Absent fields take the entry’s own answer, so a fallback is derived from the declaration rather than restated beside it.

A field declaring a hand-written read is left at that answer for the view to overwrite.

pub fn write_declared(&self, root: &mut GffStruct)

Writes every declared field onto root, leaving out the ones their entry says the engine’s own writer leaves out.

A field declaring a hand-written write is not touched here.

pub fn read_element(structure: &GffStruct) -> Self

Reads one element of a list of this type.

pub fn write_element(&self, structure: &mut GffStruct)

Writes one element of a list of this type.

Trait Implementations

impl Clone for AreMiniGamePlayer

fn clone(&self) -> AreMiniGamePlayer

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for AreMiniGamePlayer

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for AreMiniGamePlayer

fn default() -> Self

What a file omitting every label loads to, which is what makes an authored file land in a known state rather than at zero.

impl HasSchema for AreMiniGamePlayer

fn schema() -> &'static [Field]

The root field schema for this resource type.

fn parts() -> &'static [&'static [Field]]

The same schema in parts, own fields first.

impl PartialEq for AreMiniGamePlayer

fn eq(&self, other: &AreMiniGamePlayer) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for AreMiniGamePlayer