Struct AreMiniGameGunBank 

pub struct AreMiniGameGunBank {
    pub bank_id: u32,
    pub gun_model: ResRef,
    pub bullet: Option<AreMiniGameBullet>,
    pub fire_sound: ResRef,
    pub targeting: Option<AreMiniGameTargeting>,
}

One entry in a vehicle’s Gun_Banks list.

Fields

bank_id: u32

Which hardpoint this bank occupies (BankID).

BANK_ID_NONE means the engine skips the bank entirely.

gun_model: ResRef

Gun model resref (Gun_Model).

An invalid or absent resref aborts the bank, so an empty value here describes a bank that will not be created.

bullet: Option<AreMiniGameBullet>

Ballistics (Bullet), absent when the bank carries no such struct.

Option because absence is not the same as a zeroed struct. The engine skips a bank with no Bullet; a view that materialised an all-zero one and wrote it back would turn a bank the engine drops into one it creates and fires at zero speed. That is a silent change of meaning on write, which is the failure this type exists to avoid.

fire_sound: ResRef

Sound played when the bank fires (Fire_Sound).

A sibling of Bullet, not a field inside it, despite reading like one.

targeting: Option<AreMiniGameTargeting>

AI aiming parameters, absent on a player’s own banks.

Flat on the bank entry rather than under a label of its own, so the four sit beside Bullet in the file. Whether the bank carries them at all is a rule no attribute states, which is why both codec halves are this type’s: the engine reads the four as a presence-gated chain and drops the whole bank if one is missing, so a partial set is not a group to fill in with defaults.

Implementations

impl AreMiniGameGunBank

pub const SCHEMA: [Field; 4]

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.

Trait Implementations

impl Clone for AreMiniGameGunBank

fn clone(&self) -> AreMiniGameGunBank

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for AreMiniGameGunBank

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

Formats the value using the given formatter.

impl Default for AreMiniGameGunBank

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 AreMiniGameGunBank

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 AreMiniGameGunBank

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