server.enchant

Constants #

const custom_enchantment_id_start = 256

Vanilla enchantment ids end below this; plugin enchantments allocate from here up.

const id_protection = 0

const id_fire_protection = 1

const id_feather_falling = 2

const id_blast_protection = 3

const id_projectile_protection = 4

const id_thorns = 5

const id_respiration = 6

const id_depth_strider = 7

const id_aqua_affinity = 8

const id_sharpness = 9

const id_smite = 10

const id_bane_of_arthropods = 11

const id_knockback = 12

const id_fire_aspect = 13

const id_looting = 14

const id_efficiency = 15

const id_silk_touch = 16

const id_unbreaking = 17

const id_fortune = 18

const id_power = 19

const id_punch = 20

const id_flame = 21

const id_infinity = 22

const id_luck_of_the_sea = 23

const id_lure = 24

const id_frost_walker = 25

const id_mending = 26

const id_curse_of_binding = 27

const id_curse_of_vanishing = 28

const id_impaling = 29

const id_riptide = 30

const id_loyalty = 31

const id_channeling = 32

const id_multishot = 33

const id_piercing = 34

const id_quick_charge = 35

const id_soul_speed = 36

const id_swift_sneak = 37

fn ench_nbt #

fn ench_nbt(entries []Applied) nbt.Tag

ench_nbt builds the Bedrock 'ench' list tag for an item stack: one compound per enchantment with short id and lvl fields.

fn new_registry #

fn new_registry() Registry

new_registry builds a Registry pre-populated with the vanilla enchantments.

fn register_defaults #

fn register_defaults(mut r Registry)

register_defaults registers the vanilla Bedrock enchantment set with their numeric ids and level caps.

interface Enchantment #

interface Enchantment {
	// id returns the numeric enchantment id used in item NBT.
	id() int
	// name returns the identifier without namespace, e.g. 'sharpness'.
	name() string
	// min_level is the lowest valid level.
	min_level() int
	// max_level is the highest valid level.
	max_level() int
	// can_enchant reports whether the enchantment applies to the item id.
	can_enchant(item_id string) bool
	// attack_bonus is extra melee damage granted at level, 0 for non-offense.
	attack_bonus(level int) f32
	// protection_factor is the damage reduction weight at level, 0 for
	// non-armor enchantments.
	protection_factor(level int) f32
}

Enchantment is the behaviour contract every enchantment implements. Vanilla enchantments and plugin ones share the same interface, so combat and armor code can query them uniformly.

struct Applied #

struct Applied {
pub:
	eid   int
	level int
}

Applied is one enchantment instance on an item stack.

struct Registry #

struct Registry {
mut:
	by_id       map[int]Enchantment
	by_name     map[string]Enchantment
	next_custom int = custom_enchantment_id_start
}

Registry maps enchantment ids and names to their classes. It boots with the vanilla set registered; plugins add theirs with ids from custom_enchantment_id_start up.

fn (Registry) register #

fn (mut r Registry) register(e Enchantment) bool

fn (Registry) next_custom_id #

fn (r &Registry) next_custom_id() int

next_custom_id returns the next free id in the custom range without claiming it.

fn (Registry) get #

fn (r &Registry) get(id int) ?Enchantment

fn (Registry) get_by_name #

fn (r &Registry) get_by_name(name string) ?Enchantment

fn (Registry) len #

fn (r &Registry) len() int

fn (Registry) names #

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

fn (Registry) attack_bonus #

fn (r &Registry) attack_bonus(applied []Applied) f32

attack_bonus sums the melee damage bonus of every applied enchantment.

fn (Registry) protection_factor #

fn (r &Registry) protection_factor(applied []Applied) f32

protection_factor sums the damage reduction weight of every applied enchantment.

struct SimpleEnchantment #

struct SimpleEnchantment {
pub:
	eid     int
	ident   string
	min_lvl int = 1
	max_lvl int = 1
	// item_match holds substrings an item id must contain, e.g. ['sword',
	// 'axe']. Empty matches every item.
	item_match           []string
	attack_per_level     f32
	protection_per_level f32
}

SimpleEnchantment is the base class for enchantments that carry flat per-level bonuses and match items by id substring.

fn (SimpleEnchantment) id #

fn (e SimpleEnchantment) id() int

fn (SimpleEnchantment) name #

fn (e SimpleEnchantment) name() string

fn (SimpleEnchantment) min_level #

fn (e SimpleEnchantment) min_level() int

fn (SimpleEnchantment) max_level #

fn (e SimpleEnchantment) max_level() int

fn (SimpleEnchantment) can_enchant #

fn (e SimpleEnchantment) can_enchant(item_id string) bool

fn (SimpleEnchantment) attack_bonus #

fn (e SimpleEnchantment) attack_bonus(level int) f32

fn (SimpleEnchantment) protection_factor #

fn (e SimpleEnchantment) protection_factor(level int) f32