server.item #

Non-block items of the combat and progression family; the block items live in server/block/combat_progression_item.v. Non-block items of the farming family; the block items live in server/block/farming_components_item.v.

fn all_recipes() []Recipe

fn apply_palette_fallbacks(entries []FallbackEntry)

apply_palette_fallbacks fills in every wire-palette item that has no hand written class yet, so it's still holdable. Safe to call more than once - an already-registered id is left untouched. Each Hub calls this with its own loaded palette, since the palette itself comes from disk per Hub.

fn book_pages_from_nbt(raw []u8) []string

fn combat_progression_items() []Item

fn consume_result(id string, meta int) ?ConsumeResult

fn cooldown_ticks(id string) ?int

fn damage_item(it Item, current_meta int, amount int) DamageResult

damage_item computes the result of applying amount points of durability damage to an item currently at current_meta.

fn farming_items() []Item

fn get(id string) ?Item

get returns the registered class for id, or none if unregistered.

fn max_stack_size(id string) int

max_stack_size returns the stack size for id, falling back to 64 for unregistered items.

fn new_apple() AppleItem

fn new_armor_item(tier ArmorTier, slot ArmorSlot) ArmorItem

new_armor_item builds the class for a tier x slot combination.

fn new_baked_potato() BakedPotatoItem

fn new_beef() BeefItem

fn new_beetroot() BeetrootItem

fn new_beetroot_soup() BeetrootSoupItem

fn new_bone_meal_item() BoneMealItem

fn new_bread() BreadItem

fn new_bucket_item() BucketItem

fn new_cake() CakeItem

fn new_carrot() CarrotItem

fn new_chicken() ChickenItem

fn new_coal() CoalItem

fn new_cod() CodItem

fn new_compass_item() CompassItem

fn new_cooked_beef() CookedBeefItem

fn new_cooked_chicken() CookedChickenItem

fn new_cooked_cod() CookedCodItem

fn new_cooked_mutton() CookedMuttonItem

fn new_cooked_porkchop() CookedPorkchopItem

fn new_cooked_salmon() CookedSalmonItem

fn new_cookie() CookieItem

fn new_copper_ingot() CopperIngotItem

fn new_custom_registry() CustomRegistry

fn new_diamond() DiamondItem

fn new_dried_kelp() DriedKelpItem

fn new_emerald() EmeraldItem

fn new_glow_berries() GlowBerriesItem

fn new_goat_horn_item() GoatHornItem

fn new_gold_ingot() GoldIngotItem

fn new_golden_apple() GoldenAppleItem

fn new_golden_carrot() GoldenCarrotItem

fn new_honey_bottle() HoneyBottleItem

fn new_iron_ingot() IronIngotItem

fn new_lapis_lazuli() LapisLazuliItem

fn new_lodestone_compass_item() LodestoneCompassItem

fn new_melon_slice() MelonSliceItem

fn new_mushroom_stew() MushroomStewItem

fn new_mutton() MuttonItem

fn new_poisonous_potato() PoisonousPotatoItem

fn new_porkchop() PorkchopItem

fn new_potato() PotatoItem

fn new_pumpkin_pie() PumpkinPieItem

fn new_rabbit_stew() RabbitStewItem

fn new_raw_copper() RawCopperItem

fn new_raw_gold() RawGoldItem

fn new_raw_iron() RawIronItem

fn new_recovery_compass_item() RecoveryCompassItem

fn new_registry() Registry

new_registry builds a Registry pre-populated with the built-in item classes.

fn new_salmon() SalmonItem

fn new_stick() StickItem

fn new_sweet_berries() SweetBerriesItem

fn new_tool_item(tier ToolTier, typ ToolType) ToolItem

new_tool_item builds the class for a tier x tool-type combination.

fn new_wheat() WheatItem

fn potion_from_meta(meta int) PotionType

fn recipe_by_network_id(id u32) ?Recipe

fn register(it Item)

register adds or overrides the class for an item id. Use this for a hand-written Item; register_custom (custom.v) is the data-driven form.

fn register_custom(def CustomItemDefinition) int

register_custom registers a data-driven item: allocates its runtime id and makes it resolvable everywhere immediately (get, max_stack_size, ...). Call it from your own main(), before server.new(). Registering the same id twice just returns the id already allocated to it.

fn registered_custom() []CustomItemDefinition

registered_custom returns every item registered via register_custom so far, each with its runtime id filled in.

fn use_on_block_result(id string, block_name string, meta int) ?UseOnBlockResult

fn use_on_entity_result(id string, entity_name string, meta int) ?UseOnEntityResult

fn use_result(id string, meta int) ?UseResult

fn writable_book_nbt(pages []string) []u8

fn written_book_nbt(title string, author string, generation int, pages []string) []u8

fn ArmorSlot.from[W](input W) !ArmorSlot

fn ArmorTier.from[W](input W) !ArmorTier

fn ToolTier.from[W](input W) !ToolTier

fn ToolType.from[W](input W) !ToolType

interface ConsumableItem {
	consume_result(meta int) ConsumeResult
}

interface CooldownItem {
	cooldown_ticks() int
}

CooldownItem is implemented by items that can't be used again for a period after use (e.g. the goat horn).

interface Item {
	// identifier returns the namespaced item id used on the wire.
	identifier() string
	// max_stack_size is how many of this item fit in a single slot.
	max_stack_size() int
	// attack_damage is the melee damage dealt on hit, 0 for non-weapons.
	attack_damage() f32
	// nutrition is the hunger points restored on eat, 0 for non-food.
	nutrition() int
	// saturation is the saturation modifier applied on eat, 0 for non-food.
	saturation() f32
	// block_runtime_id is the block placed on use, 0 for non-block items.
	block_runtime_id() int
	// durability is the max number of uses before the item breaks, 0 for
	// items that don't take durability damage.
	durability() int
	// mining_speed is the block breaking speed multiplier this item grants
	// as a tool, 1.0 (no bonus) for non-tools.
	mining_speed() f32
	// armor_points is the defense value this item grants when worn, 0 for
	// non-armor.
	armor_points() int
}

Item is the behaviour contract every item class implements. Every item is its own class built on a family base struct (ToolItem, ArmorItem, FoodItem, SimpleItem, or block.BlockItem for the items that place a block) and registered in the Registry so the session layer can look it up by its string identifier (e.g. 'minecraft:diamond_sword').

interface MiningTool {
	// block_tool_type is the block tool family bitflag this item belongs to.
	block_tool_type() int
	// harvest_level is the tier this item harvests up to.
	harvest_level() int
}

MiningTool is implemented by items that mine a matching block family faster than a bare hand. Items that don't implement it break every block at hand speed.

interface UsableOnBlockItem {
	use_on_block_result(block_name string, meta int) ?UseOnBlockResult
}

UsableOnBlockItem is implemented by items with a behaviour when used on a specific kind of block (e.g. bone meal on crops). Returns none if this item does nothing to a block named block_name.

interface UsableOnEntityItem {
	use_on_entity_result(entity_name string, meta int) ?UseOnEntityResult
}

UsableOnEntityItem is implemented by items with a behaviour when used on a specific kind of entity (e.g. milk bucket on a cow). Returns none if this item does nothing to an entity named entity_name.

interface UseableItem {
	use_result(meta int) UseResult
}

UseableItem is implemented by items with a behaviour on right-click in air (item_use_action_click_air), separate from ConsumableItem's eat on use flow.

enum ArmorSlot {
	helmet
	chestplate
	leggings
	boots
}

ArmorSlot is the equipment slot an armor piece occupies.

enum ArmorTier {
	leather
	gold
	copper
	iron
	diamond
	netherite
}

ArmorTier is the material tier shared by every armor piece.

enum ToolTier {
	wood
	stone
	copper
	iron
	gold
	diamond
	netherite
}

ToolTier is the material tier shared by every tool and weapon.

enum ToolType {
	sword
	pickaxe
	axe
	shovel
	hoe
}

ToolType is the tool/weapon shape. Attack damage differs by type; mining speed and durability are tier-only (same across all five shapes).

struct AppleItem {
	FoodItem
}

AppleItem is the class for 'minecraft:apple'.

struct ArmorItem {
pub:
	id             string
	tier           ArmorTier
	slot           ArmorSlot
	defense        int
	max_durability int
}

fn (i ArmorItem) identifier() string

fn (i ArmorItem) max_stack_size() int

fn (i ArmorItem) attack_damage() f32

fn (i ArmorItem) nutrition() int

fn (i ArmorItem) saturation() f32

fn (i ArmorItem) block_runtime_id() int

fn (i ArmorItem) durability() int

fn (i ArmorItem) mining_speed() f32

fn (i ArmorItem) armor_points() int

struct BakedPotatoItem {
	FoodItem
}

BakedPotatoItem is the class for 'minecraft:baked_potato'.

struct BeefItem {
	FoodItem
}

BeefItem is the class for 'minecraft:beef'.

struct BeetrootItem {
	FoodItem
}

BeetrootItem is the class for 'minecraft:beetroot'.

fn (i BeetrootItem) use_on_block_result(block_name string, meta int) ?UseOnBlockResult

struct BeetrootSoupItem {
	FoodItem
}

BeetrootSoupItem is the class for 'minecraft:beetroot_soup'.

struct BoneMealItem {
	SimpleItem
}

BoneMealItem is the class for 'minecraft:bone_meal'.

fn (i BoneMealItem) use_on_block_result(block_name string, meta int) ?UseOnBlockResult

struct BreadItem {
	FoodItem
}

BreadItem is the class for 'minecraft:bread'.

struct BucketItem {
	SimpleItem
}

BucketItem is the class for 'minecraft:bucket' (the empty bucket). Filled buckets (milk_bucket, water_bucket, lava_bucket) stay on the fallback path, only the empty bucket has a UsableOnEntityItem behaviour.

fn (i BucketItem) use_on_entity_result(entity_name string, meta int) ?UseOnEntityResult

struct CakeItem {
	FoodItem
}

CakeItem is the class for 'minecraft:cake'.

struct CarrotItem {
	FoodItem
pub:
	block_runtime int
}

CarrotItem is the class for 'minecraft:carrot'. No separate seed item exists (unlike wheat/beetroot).

fn (i CarrotItem) block_runtime_id() int

fn (i CarrotItem) use_on_block_result(block_name string, meta int) ?UseOnBlockResult

struct ChickenItem {
	FoodItem
}

ChickenItem is the class for 'minecraft:chicken'.

struct CoalItem {
	SimpleItem
}

CoalItem is the class for 'minecraft:coal'.

struct CodItem {
	FoodItem
}

CodItem is the class for 'minecraft:cod'.

struct CompassItem {
	SimpleItem
}

CompassItem is the class for 'minecraft:compass'.

struct ConsumeResult {
pub:
	effects           []effect.Effect
	replacement_id    string
	replacement_count int
}

struct CookedBeefItem {
	FoodItem
}

CookedBeefItem is the class for 'minecraft:cooked_beef'.

struct CookedChickenItem {
	FoodItem
}

CookedChickenItem is the class for 'minecraft:cooked_chicken'.

struct CookedCodItem {
	FoodItem
}

CookedCodItem is the class for 'minecraft:cooked_cod'.

struct CookedMuttonItem {
	FoodItem
}

CookedMuttonItem is the class for 'minecraft:cooked_mutton'.

struct CookedPorkchopItem {
	FoodItem
}

CookedPorkchopItem is the class for 'minecraft:cooked_porkchop'.

struct CookedSalmonItem {
	FoodItem
}

CookedSalmonItem is the class for 'minecraft:cooked_salmon'.

struct CookieItem {
	FoodItem
}

CookieItem is the class for 'minecraft:cookie'.

struct CooldownComponent {
pub:
	category string
	duration f32
}

CooldownComponent gives the item a use cooldown, grouped by category.

struct CopperIngotItem {
	SimpleItem
}

CopperIngotItem is the class for 'minecraft:copper_ingot'.

struct CustomItemClass {
pub:
	def CustomItemDefinition
}

CustomItemClass adapts a definition to the Item interface so the session layer treats custom items like any built-in class.

fn (c CustomItemClass) identifier() string

fn (c CustomItemClass) max_stack_size() int

fn (c CustomItemClass) attack_damage() f32

fn (c CustomItemClass) nutrition() int

fn (c CustomItemClass) saturation() f32

fn (c CustomItemClass) block_runtime_id() int

fn (c CustomItemClass) durability() int

fn (c CustomItemClass) mining_speed() f32

fn (c CustomItemClass) armor_points() int

struct CustomItemDefinition {
pub mut:
	id                      string
	display_name            string
	texture                 string
	max_stack_size          int = 64
	attack_damage_value     int
	hand_equipped           bool
	allow_off_hand          bool
	glint                   bool
	can_destroy_in_creative bool = true
	mining_speed            f32  = 1.0
	fuel_duration           f32
	creative_group_index    int
	tags                    []string
	digger_speeds           []DiggerSpeed
	food                    ?FoodComponent
	wearable                ?WearableComponent
	cooldown                ?CooldownComponent
	enchantable             ?EnchantableComponent
	durability_component    ?DurabilityComponent
	runtime_id              int
}

CustomItemDefinition describes a data-driven item a plugin registers. The definition is turned into component NBT and shipped to the client inside the ItemRegistryPacket, so no resource pack code is needed server-side beyond the texture name.

fn (d &CustomItemDefinition) components() nbt.RootTag

components builds the component NBT the client consumes: an item_properties compound for the base properties and one minecraft:* compound per opted-in component.

struct CustomRegistry {
mut:
	defs    []CustomItemDefinition
	ids     map[string]int
	next_id int = custom_item_runtime_id_start
}

CustomRegistry owns every registered custom item definition and hands out runtime ids sequentially, starting at custom_item_runtime_id_start.

fn (mut r CustomRegistry) register(def CustomItemDefinition) int

register allocates a runtime id for def and stores it. Registering the same id again returns the previously allocated runtime id unchanged.

fn (r &CustomRegistry) all() []CustomItemDefinition

all returns every registered definition with its runtime id filled in.

fn (r &CustomRegistry) len() int

fn (r &CustomRegistry) runtime_id(id string) ?int

fn (r &CustomRegistry) names() []string

struct DamageResult {
pub:
	broken   bool
	new_meta int
}

DamageResult is the outcome of applying durability damage to a stack. broken means the item should be removed (or replaced with its broken item, once anything defines one. For now, every durable item just disappears.

struct DiamondItem {
	SimpleItem
}

DiamondItem is the class for 'minecraft:diamond'.

struct DiggerSpeed {
pub:
	block string
	speed int
}

DiggerSpeed is one block (or block tag query) the item digs faster.

struct DriedKelpItem {
	FoodItem
}

DriedKelpItem is the class for 'minecraft:dried_kelp'.

struct DurabilityComponent {
pub:
	max_durability int
}

DurabilityComponent gives the item a durability bar.

struct DurabilityItem {
pub:
	id             string
	damage         f32
	max_durability int
}

DurabilityItem is the base class for held combat items whose only shared behaviour is "takes durability damage, one per slot"; unlike ToolItem/ ArmorItem there's no tier x shape matrix here (shield/bow/crossbow/trident are each one-off items).

fn (i DurabilityItem) identifier() string

fn (i DurabilityItem) max_stack_size() int

fn (i DurabilityItem) attack_damage() f32

fn (i DurabilityItem) nutrition() int

fn (i DurabilityItem) saturation() f32

fn (i DurabilityItem) block_runtime_id() int

fn (i DurabilityItem) durability() int

fn (i DurabilityItem) mining_speed() f32

fn (i DurabilityItem) armor_points() int

struct EmeraldItem {
	SimpleItem
}

EmeraldItem is the class for 'minecraft:emerald'.

struct EnchantableComponent {
pub:
	slot  string
	value int
}

EnchantableComponent controls which enchantment slot the item accepts and its enchantability value.

struct FallbackEntry {
pub:
	id            string
	block_runtime int
}

struct FoodComponent {
pub:
	nutrition      int
	saturation     f32
	can_always_eat bool
}

FoodComponent makes a custom item edible.

struct FoodItem {
pub:
	id             string
	food_points    int
	saturation_mod f32
	stack_max      int = 64
}

FoodItem is the base class for edibles. food_points is the number of hunger points restored on eat, saturation_mod the saturation modifier. Concrete foods embed it, one class per food.

fn (i FoodItem) identifier() string

fn (i FoodItem) max_stack_size() int

fn (i FoodItem) attack_damage() f32

fn (i FoodItem) nutrition() int

fn (i FoodItem) saturation() f32

fn (i FoodItem) block_runtime_id() int

fn (i FoodItem) durability() int

fn (i FoodItem) mining_speed() f32

fn (i FoodItem) armor_points() int

struct GlowBerriesItem {
	FoodItem
}

GlowBerriesItem is the class for 'minecraft:glow_berries'.

struct GoatHornItem {
	SimpleItem
}

GoatHornItem is the class for 'minecraft:goat_horn'.

fn (i GoatHornItem) use_result(meta int) UseResult

fn (i GoatHornItem) cooldown_ticks() int

struct GoldIngotItem {
	SimpleItem
}

GoldIngotItem is the class for 'minecraft:gold_ingot'.

struct GoldenAppleItem {
	FoodItem
}

GoldenAppleItem is the class for 'minecraft:golden_apple'.

struct GoldenCarrotItem {
	FoodItem
}

GoldenCarrotItem is the class for 'minecraft:golden_carrot'.

struct HoneyBottleItem {
	FoodItem
}

HoneyBottleItem is the class for 'minecraft:honey_bottle'.

struct IronIngotItem {
	SimpleItem
}

IronIngotItem is the class for 'minecraft:iron_ingot'.

struct LapisLazuliItem {
	SimpleItem
}

LapisLazuliItem is the class for 'minecraft:lapis_lazuli'.

struct LodestoneCompassItem {
	SimpleItem
}

LodestoneCompassItem is the class for 'minecraft:lodestone_compass'.

struct MelonSliceItem {
	FoodItem
}

MelonSliceItem is the class for 'minecraft:melon_slice'.

struct MushroomStewItem {
	FoodItem
}

MushroomStewItem is the class for 'minecraft:mushroom_stew'.

struct MuttonItem {
	FoodItem
}

MuttonItem is the class for 'minecraft:mutton'.

struct PoisonousPotatoItem {
	FoodItem
}

PoisonousPotatoItem is the class for 'minecraft:poisonous_potato'.

struct PorkchopItem {
	FoodItem
}

PorkchopItem is the class for 'minecraft:porkchop'.

struct PotatoItem {
	FoodItem
pub:
	block_runtime int
}

PotatoItem is the class for 'minecraft:potato'. No separate seed item exists (unlike wheat/beetroot).

fn (i PotatoItem) block_runtime_id() int

fn (i PotatoItem) use_on_block_result(block_name string, meta int) ?UseOnBlockResult

struct PotionItem {}

fn (i PotionItem) identifier() string

fn (i PotionItem) max_stack_size() int

fn (i PotionItem) attack_damage() f32

fn (i PotionItem) nutrition() int

fn (i PotionItem) saturation() f32

fn (i PotionItem) block_runtime_id() int

fn (i PotionItem) durability() int

fn (i PotionItem) mining_speed() f32

fn (i PotionItem) armor_points() int

fn (i PotionItem) consume_result(meta int) ConsumeResult

struct PotionType {
	value int
}

fn (p PotionType) id() int

fn (p PotionType) effects() []effect.Effect

struct PumpkinPieItem {
	FoodItem
}

PumpkinPieItem is the class for 'minecraft:pumpkin_pie'.

struct RabbitStewItem {
	FoodItem
}

RabbitStewItem is the class for 'minecraft:rabbit_stew'.

struct RawCopperItem {
	SimpleItem
}

RawCopperItem is the class for 'minecraft:raw_copper'.

struct RawGoldItem {
	SimpleItem
}

RawGoldItem is the class for 'minecraft:raw_gold'.

struct RawIronItem {
	SimpleItem
}

RawIronItem is the class for 'minecraft:raw_iron'.

struct Recipe {
pub:
	id           string
	ingredients  []RecipeIngredient
	output_name  string
	output_count int
	block        string = 'crafting_table'
	width        int
	height       int
	pattern      []string
	// 0 is never a valid recipe_network_id on the wire.
	network_id u32
}

Recipe is a crafting table recipe. Matching is identity & quantity only (ignores grid position). width/height/pattern exist only for CraftingDataPacket's wire encoding.

struct RecipeIngredient {
pub:
	name  string
	count int
}

RecipeIngredient is one required input for a Recipe, aggregated by identity. Name + total count needed, grid position never checked.

struct RecipeRegistry {
mut:
	recipes    []Recipe
	by_network map[u32]int
}

fn (r &RecipeRegistry) by_network_id(id u32) ?Recipe

fn (r &RecipeRegistry) all() []Recipe

struct RecoveryCompassItem {
	SimpleItem
}

RecoveryCompassItem is the class for 'minecraft:recovery_compass'.

struct Registry {
mut:
	items map[string]Item
}

Registry maps namespaced item ids to their concrete Item class. The session layer holds one Registry and queries it for per-item behaviour (stack size, attack damage, ...) instead of hard-coding numeric ids.

fn (mut r Registry) register(it Item)

register adds or overrides the class for an item id.

fn (mut r Registry) register_fallbacks(entries []FallbackEntry)

fn (r &Registry) get(id string) ?Item

get returns the registered class for id, or none if unregistered.

fn (r &Registry) max_stack_size(id string) int

max_stack_size returns the stack size for id, falling back to 64 for unregistered items.

fn (r &Registry) consume_result(id string, meta int) ?ConsumeResult

fn (r &Registry) use_result(id string, meta int) ?UseResult

fn (r &Registry) use_on_block_result(id string, block_name string, meta int) ?UseOnBlockResult

fn (r &Registry) use_on_entity_result(id string, entity_name string, meta int) ?UseOnEntityResult

fn (r &Registry) cooldown_ticks(id string) ?int

fn (r &Registry) len() int

len is the number of registered item classes.

struct SalmonItem {
	FoodItem
}

SalmonItem is the class for 'minecraft:salmon'.

struct SimpleItem {
pub:
	id        string
	stack_max int = 64
}

SimpleItem is the base class for items that carry no special behaviour (dyes, sticks, string, ...). Concrete simple items embed it and fill in their identity; anything unregistered behaves like a default SimpleItem.

fn (i SimpleItem) identifier() string

fn (i SimpleItem) max_stack_size() int

fn (i SimpleItem) attack_damage() f32

fn (i SimpleItem) nutrition() int

fn (i SimpleItem) saturation() f32

fn (i SimpleItem) block_runtime_id() int

fn (i SimpleItem) durability() int

fn (i SimpleItem) mining_speed() f32

fn (i SimpleItem) armor_points() int

struct StickItem {
	SimpleItem
}

StickItem is the class for 'minecraft:stick'.

struct SweetBerriesItem {
	FoodItem
}

SweetBerriesItem is the class for 'minecraft:sweet_berries'.

struct ToolItem {
pub:
	id             string
	tier           ToolTier
	tool_type      ToolType
	damage         f32
	max_durability int
	speed          f32
}

ToolItem is the class for every tier x type combination (e.g. tier .diamond, tool_type .pickaxe -> 'minecraft:diamond_pickaxe'). One parametrized struct instead of 30 near-identical classes, since nothing about a tool's behaviour is unique per material - it's entirely tier+type data (see ITEMS_BLOCKS.md open question 1).

fn (i ToolItem) armor_points() int

fn (i ToolItem) attack_damage() f32

fn (i ToolItem) block_runtime_id() int

fn (i ToolItem) block_tool_type() int

fn (i ToolItem) durability() int

fn (i ToolItem) harvest_level() int

fn (i ToolItem) identifier() string

fn (i ToolItem) max_stack_size() int

fn (i ToolItem) mining_speed() f32

fn (i ToolItem) nutrition() int

fn (i ToolItem) saturation() f32

struct UseOnBlockResult {
pub:
	sound       string
	state_key   string
	state_delta int
}

UseOnBlockResult describes what a UsableOnBlockItem does when used on a qualifying block: which int block-state to advance and by how much, plus an optional sound.

struct UseOnEntityResult {
pub:
	sound         string
	replaces_with string
}

UseOnEntityResult describes what a UsableOnEntityItem does when used on a qualifying entity: an optional sound plus an optional item id the held stack is replaced with (empty means no swap, just the sound).

struct UseResult {
pub:
	sound string
}

UseResult describes what happens when a UseableItem is used. sound is broadcast at the user's position if non empty; empty means no sound.

struct WearableComponent {
pub:
	slot       string
	protection int
}

WearableComponent makes a custom item equippable as armor. Slot is a vanilla slot string like 'slot.armor.head', 'slot.armor.chest', 'slot.armor.legs', 'slot.armor.feet'.

struct WheatItem {
	SimpleItem
}

WheatItem is the class for raw 'minecraft:wheat'.

fn (i WheatItem) use_on_block_result(block_name string, meta int) ?UseOnBlockResult