server.player

fn new_player() &Player

interface View {
	name() string
	has_permission(name string) bool
	is_player() bool
mut:
	send_message(message string) !
	send_translation(key string, parameters []string) !
	set_gamemode(mode int)
	kill()
	disconnect(message string)
	position() (f32, f32, f32)
	teleport(x f32, y f32, z f32)
	clear_inventory()
	give_item(id string, count int) bool
	send_form(f form.Form) !
	show_scoreboard(title string, lines []string)
	clear_scoreboard()
}

View is the narrow, capability-only contract for "acts like a player": identity, permission, messaging, movement, inventory, UI, etc. It exists so lower layers (event and later entity for AI targeting) can reference a player without importing session and without each one re deriving its own slice of what a player is.

struct Movement {
pub:
	position types.Vector3
	pitch    f32
	yaw      f32
	head_yaw f32
	vy       f32
}

Movement is a consistent snapshot of the player's position and orientation. Reads go through this type, while registered session writes are owned by the Hub thread.

struct Player {
pub mut:
	identity auth.Identity
	perm     permission.Permissible
mut:
	// state_mutex guards the mutable player state below, excluding fields
	// covered by their own mutexes. State accessors must hold this lock because
	// player state may now be accessed from multiple actor threads.
	state_mutex      &sync.Mutex = sync.new_mutex()
	game_mode        int
	health           f32 = 20.0
	dead             bool
	held_item        types.ItemStackWrapper
	held_slot        int
	inv_stacks       map[int]types.ItemStack
	inv_slots        map[int]int
	inv_next_id      int = 1
	pending_creative ?types.ItemStack
	loaded_items     []playerdb.InvItem
	effects          effect.Manager
	has_last_death   bool
	last_death_pos   types.Vector3
	air_supply_ticks i64 = max_air_supply_ticks
	fire_ticks       i64
	pos_mutex        &sync.Mutex = sync.new_mutex()
	position         types.Vector3
	pitch            f32
	yaw              f32
	head_yaw         f32
	vy               f32
	prev_y           f32
	fall_distance    f32
	grounded         bool
}

Player holds the gamestate fields that belong to a player as an entity, independent of whichever network connection (if any) is currently driving it. It holds no transport/packet send capability by design.

Behavior methods that need to send a packet or broadcast (send_message, teleport, kill, give_item, etc.) stay on NetworkSession, which reads and writes through this struct's accessors for the state they operate on.

fn (p &Player) name() string

fn (p &Player) has_permission(name string) bool

fn (p &Player) game_mode() int

fn (mut p Player) set_game_mode(mode int)

fn (p &Player) health() f32

fn (mut p Player) set_health(value f32)

fn (p &Player) is_dead() bool

fn (mut p Player) set_dead(value bool)

fn (p &Player) air_supply() i64

fn (mut p Player) set_air_supply(value i64)

fn (p &Player) fire_ticks() i64

fn (mut p Player) set_fire_ticks(value i64)

fn (p &Player) held_item() types.ItemStackWrapper

fn (p &Player) held_slot() int

fn (mut p Player) set_held(slot int, item types.ItemStackWrapper)

set_held updates the held slot and its wrapper together. Every current caller sets both at once.

fn (p &Player) inv_stack(net_id int) ?types.ItemStack

fn (mut p Player) put_stack(net_id int, stack types.ItemStack)

fn (mut p Player) delete_stack(net_id int)

fn (p &Player) inv_slot(slot int) ?int

fn (p &Player) has_slot(slot int) bool

fn (mut p Player) set_slot(slot int, net_id int)

fn (mut p Player) delete_slot(slot int)

fn (p &Player) snapshot_slot_stacks() map[int]types.ItemStack

snapshot_slot_stacks returns a cloned map of inventory slot to item stack. The network-id indirection is resolved while holding state_mutex so callers get a consistent slot layout.

fn (mut p Player) track_stack(stack types.ItemStack) int

track_stack assigns stack a new network ID, stores it and returns that ID. It is the only method that reads or advances inv_next_id.

fn (mut p Player) clear_inventory()

fn (p &Player) pending_creative() ?types.ItemStack

fn (mut p Player) set_pending_creative(stack ?types.ItemStack)

fn (mut p Player) set_loaded_items(items []playerdb.InvItem)

fn (p &Player) loaded_items_len() int

fn (p &Player) loaded_item(i int) playerdb.InvItem

fn (mut p Player) add_effect_result(e effect.Effect) effect.AddResult

fn (mut p Player) remove_effect(typ effect.Type) ?effect.Effect

fn (mut p Player) tick_effects() effect.TickResult

fn (p &Player) effect(typ effect.Type) ?effect.Effect

fn (p &Player) active_effects() []effect.Effect

fn (p &Player) has_last_death() bool

fn (p &Player) last_death_pos() types.Vector3

fn (mut p Player) set_last_death(pos types.Vector3)

fn (p &Player) movement() Movement

fn (p &Player) on_ground() bool

on_ground reports the last client reported ground state, trusted like the rest of the movement snapshot.

fn (p &Player) position() types.Vector3

position is a convenience accessor for the common case of needing just the position, still going through the same lock as movement().

fn (mut p Player) apply_movement(position types.Vector3, pitch f32, yaw f32, head_yaw f32, on_ground bool) f32

apply_movement updates the player's position and orientation as one unit, deriving vertical velocity from the change in Y. Registered session callers must invoke it on the Hub thread.

fn (mut p Player) reset_position(position types.Vector3)

fn (mut p Player) set_orientation(pitch f32, yaw f32, head_yaw f32)

set_orientation applies saved orientation during pre registration setup. Live sessions must update orientation through apply_movement instead.