Struct AreMiniGame 

pub struct AreMiniGame {

    pub mini_game_type: u32,
    pub movement_per_sec: f32,
    pub lateral_accel: f32,
    pub bump_plane: u32,
    pub do_bumping: bool,
    pub use_inertia: bool,
    pub dof: u32,
    pub music: ResRef,
    pub far_clip: f32,
    pub near_clip: f32,
    pub camera_view_angle: f32,
    pub player: Option<AreMiniGamePlayer>,
    pub mouse: Option<AreMiniGameMouse>,
    pub enemies: Vec<AreMiniGameEnemy>,
    pub obstacles: Vec<AreMiniGameObstacle>,
}

Typed view over the ARE MiniGame nested struct.

Fields

mini_game_type: u32

Mini-game type (Type): 1 = swoop, 2 = turret.

movement_per_sec: f32

Movement speed (MovementPerSec).

lateral_accel: f32

Lateral acceleration (LateralAccel).

bump_plane: u32

Bump plane index (Bump_Plane).

do_bumping: bool

Bumping enabled (DoBumping).

use_inertia: bool

Inertia enabled (UseInertia).

dof: u32

Degrees of freedom (DOF).

music: ResRef

Music resref (Music).

far_clip: f32

Far clip distance (Far_Clip).

near_clip: f32

Near clip distance (Near_Clip).

camera_view_angle: f32

Camera view angle (CameraViewAngle).

player: Option<AreMiniGamePlayer>

Player sub-struct (Player).

mouse: Option<AreMiniGameMouse>

Mouse axis settings (Mouse), when the area carries the struct.

A sibling of Player, not a child of it. One vanilla minigame area of four has it.

Option rather than a defaulted value, because presence and default are different questions for a struct. A default answers what the engine substitutes for an absent scalar; it says nothing about whether a nested struct exists. Materializing an all-zero Mouse for the three files without one and then writing it back would invent structure those files never had. MiniGame itself is an Option on Are for the same reason, so this matches the convention already in place rather than adding a second one.

What the engine does with an absent Mouse is untraced, which is the argument for Option rather than against it: preserving the file’s actual state invents nothing under that ignorance.

enemies: Vec<AreMiniGameEnemy>

Enemy list (Enemies), a sibling of Player.

obstacles: Vec<AreMiniGameObstacle>

Obstacle list (Obstacles), a sibling of Player.

Implementations

impl AreMiniGame

pub const SCHEMA: [Field; 15]

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 AreMiniGame

fn clone(&self) -> AreMiniGame

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for AreMiniGame

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

Formats the value using the given formatter.

impl Default for AreMiniGame

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 AreMiniGame

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 AreMiniGame

fn eq(&self, other: &AreMiniGame) -> 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 AreMiniGame