Struct EntityDef 

pub struct EntityDef {

    pub id: String,
    pub name: Option<String>,
    pub kind: EntityKind,
    pub category: String,
    pub width: f32,
    pub height: f32,
    pub eye_height: Option<f32>,
    pub fire_immune: bool,
    pub no_gravity: bool,
    pub pushable: Option<bool>,
    pub solid: bool,
    pub tracking_range: u32,
    pub update_interval: u32,
    pub attributes: Ordered<f64>,
    pub model: Option<String>,
    pub animations: Option<String>,
    pub clips: Ordered<String>,
    pub spawn_egg: Option<[u32; 2]>,
    pub goals: Vec<String>,
    pub ticks: bool,
    pub place_sound: Option<String>,
    pub break_sound: Option<String>,
}

An entity type to register (.yentity). Its look is a body model (model, .ymodel) with clips by state; what it does beyond goals is the mod’s code (entity events, a tick of its own).

Fields

id: String

Its id; a source may leave it out: the file’s name, the build fills it in.

name: Option<String>

Its name (a text or a @Set.key resource); default: the id’s lang key.

kind: EntityKind

category: String

Its spawn group (MobCategory): misc, monster, creature, ambient, water_creature, water_ambient, underground_water_creature.

width: f32

Hitbox, blocks.

height: f32

eye_height: Option<f32>

Eye height, blocks; default 85% of the height.

fire_immune: bool

Lava and fire don’t hurt it.

no_gravity: bool

It doesn’t fall.

pushable: Option<bool>

Others push it (living things by default).

solid: bool

Others stand on and bump into it as into a block (a boat).

tracking_range: u32

How far players see it, chunks.

update_interval: u32

How often its movement is sent, ticks.

attributes: Ordered<f64>

Living and mob attributes by id: max_health, movement_speed, attack_damage, follow_range, armor, knockback_resistance… (the game’s, minecraft: optional, or a mod’s).

model: Option<String>

Its body model (.ymodel id); none: the mod draws it (on_body).

animations: Option<String>

Its clips (.yanim id).

clips: Ordered<String>

Clip by state: idle, walk, attack, hurt, death, or the mod’s own states (entity data yog:state).

spawn_egg: Option<[u32; 2]>

Spawn egg colors [base, spots] (0xRRGGBB); none: no egg.

goals: Vec<String>

Mobs’ AI goals, in priority order — the game’s by name: float, panic, melee_attack, wander, look_at_player, look_around, target_player, avoid_player.

ticks: bool

The mod handles each tick of every entity of this type (yog_event::entity::game::Tick, keyed by the type).

place_sound: Option<String>

A hanging thing’s sound events when it’s placed and when it breaks; default: a painting’s.

break_sound: Option<String>

Implementations

impl EntityDef

pub fn new( id: impl Into<String>, kind: EntityKind, width: f32, height: f32, ) -> EntityDef

pub fn with_default_sounds(self) -> EntityDef

Itself with the sounds it doesn’t name: a painting’s.

Trait Implementations

impl Clone for EntityDef

fn clone(&self) -> EntityDef

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for EntityDef

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

Formats the value using the given formatter.

impl Fields for EntityDef

const FIELDS: &'static [(&'static str, &'static str)]

impl Schema for EntityDef

fn encode(&self, __yog_w: &mut Writer)

Writes itself in the binary form, straight — Schema::write’s value encoded, unless the type knows better (derived ones do).

fn decode(__yog_d: &mut Decoder<'_>) -> Option<EntityDef>

Reads itself from the binary form, straight; None when it isn’t what Schema::encode writes — then read_bytes reads the slow way, which says what’s wrong. Through a value unless the type knows better (derived ones do).

fn pack(&self, __yog_p: &mut Packer)

Packs itself into a frame (crate::frame): its binary form as bytes, unless the type packs itself (derived ones and plain types do).

fn unpack(__yog_u: &mut Unpacker<'_>) -> Option<EntityDef>

Reads itself out of a frame; None if the bytes aren’t what Schema::pack writes.

fn shape() -> Shape

What the format looks like.

fn read(v: &ValueRef<'_>, cx: &mut Reader<'_>) -> Option<EntityDef>

Reads v. Problems go to cx at its current path; None when the value couldn’t be read (the problem is in cx).

fn write(&self) -> Value

The value, as the format writes it.

fn absent() -> Option<Self>

The value of a field that isn’t there — None: the field is required.

fn skip(&self) -> bool

Whether a struct leaves this field out when writing it.

fn pack_list(items: &[Self], p: &mut Packer)

A list of these packed: a count, then each one (floats raw).

fn unpack_list(u: &mut Unpacker<'_>) -> Option<Vec<Self>>

A list of these out of a frame.

fn encode_list(items: &[Self], w: &mut Writer)

A list of these written straight (numbers pack theirs).

fn decode_list(d: &mut Decoder<'_>) -> Option<Vec<Self>>

A list of these read straight.