Struct AreMiniGameBullet 

pub struct AreMiniGameBullet {
    pub damage: u32,
    pub lifespan: f32,
    pub rate_of_fire: f32,
    pub speed: f32,
    pub target_type: u32,
    pub bullet_model: ResRef,
    pub collision_sound: ResRef,
}

The ballistics of one gun bank (Bullet).

The first five fields are a presence-gated chain: each read reports whether the file supplied the field, and that gates whether the next one is attempted at all. If any is genuinely absent the chain truncates and the bank is never created, so there is no such thing as a partial bank built from defaults. Bullet_Model and Collision_Sound are read unconditionally once the chain completes.

The view models all seven as plain fields rather than making the chain visible in the type. A file missing one of the five is malformed, and saying so is a diagnostic’s job: the schema marks them required and lint reports the dropped bank. Seven Options would push that judgement onto every caller that only wanted to read a rate of fire.

Fields

damage: u32

Damage per hit (Damage).

lifespan: f32

Seconds before the bullet expires (Lifespan).

rate_of_fire: f32

Seconds between shots (Rate_Of_Fire).

speed: f32

Travel speed (Speed).

target_type: u32

What the bank is allowed to shoot at (Target_Type).

bullet_model: ResRef

Bullet model resref (Bullet_Model).

collision_sound: ResRef

Sound played on impact (Collision_Sound).

Implementations

impl AreMiniGameBullet

pub const SCHEMA: [Field; 7]

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 AreMiniGameBullet

fn clone(&self) -> AreMiniGameBullet

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for AreMiniGameBullet

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

Formats the value using the given formatter.

impl Default for AreMiniGameBullet

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 AreMiniGameBullet

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 AreMiniGameBullet

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