Struct ItemDef 

pub struct ItemDef {
    pub id: String,
    pub max_stack: u8,
    pub name: Option<String>,
    pub tooltip: Option<String>,
    pub max_damage: u32,
    pub fire_resistant: bool,
    pub fuel_ticks: u32,
    pub food: Option<FoodDef>,
    pub tool: Option<ToolItem>,
    pub armor: Option<ArmorPiece>,
    pub wearable: Option<ArmorSlot>,
    pub hangs: Option<Hangs>,
}

A custom item to register, identified by namespace:path.

Fields

id: String

max_stack: u8

name: Option<String>

tooltip: Option<String>

max_damage: u32

Durability. 0 = non-damageable. If set, max_stack is forced to 1.

fire_resistant: bool

Immune to fire and lava damage (like netherite items).

fuel_ticks: u32

Furnace fuel burn time in ticks (0 = not fuel; 200 = one coal equivalent).

food: Option<FoodDef>

Nutritional properties; None = not food.

tool: Option<ToolItem>

A tool or a weapon of a material.

armor: Option<ArmorPiece>

A piece of armor of a material.

wearable: Option<ArmorSlot>

Worn in this slot without being armor.

hangs: Option<Hangs>

Used on a block’s side, it hangs there as an entity of a hanging type.

Implementations

impl ItemDef

pub fn new(id: impl Into<String>) -> ItemDef

pub fn tool( self, kind: impl Into<String>, material: impl Into<String>, ) -> ItemDef

A tool (pickaxe, axe, shovel, hoe, a mod’s mineable tag mymod:mineable/hammer) or a sword, of material (a [ToolMaterial]: the game’s iron… or a mod’s), attacking as the game’s tool of the kind does (Self::tool_attack changes it).

pub fn tool_attack(self, damage: Option<f32>, speed: Option<f32>) -> ItemDef

The tool’s own attack damage (on top of the material’s) and speed change; none: the game’s tool’s. Nothing without Self::tool.

pub fn armor(self, slot: ArmorSlot, material: impl Into<String>) -> ItemDef

A piece of armor for slot (head, chest, legs, feet) of material (an [ArmorMaterial]: the game’s diamond… or a mod’s).

pub fn wearable(self, slot: ArmorSlot) -> ItemDef

Worn in slot without being armor.

pub fn hangs(self, entity: impl Into<String>, size: Option<[u32; 2]>) -> ItemDef

Used on a block’s side, it hangs an entity (a hanging type) there, size blocks wide and high (None: the type’s own); the entity keeps one of this item and drops it when it breaks.

pub fn max_stack(self, n: u8) -> ItemDef

Maximum stack size (default 64). Ignored when max_damage is set.

pub fn name(self, name: impl Into<String>) -> ItemDef

Display name shown in-game.

pub fn tooltip(self, tooltip: impl Into<String>) -> ItemDef

A tooltip line shown on hover.

pub fn max_damage(self, durability: u32) -> ItemDef

Make this a damageable item (tool/weapon/armour). Forces stack size to 1.

pub fn fire_resistant(self) -> ItemDef

Make this item fire-resistant (won’t burn in fire or lava).

pub fn fuel(self, ticks: u32) -> ItemDef

Register as furnace fuel burning for ticks (200 ticks = 1 item smelted).

pub fn food(self, food: FoodDef) -> ItemDef

Make this item edible with the given nutritional properties.

Trait Implementations

impl Clone for ItemDef

fn clone(&self) -> ItemDef

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ItemDef

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

Formats the value using the given formatter.

impl Fields for ItemDef

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

impl Schema for ItemDef

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<ItemDef>

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<ItemDef>

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<ItemDef>

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.