server.permission

Constants #

const default_permissions_file = 'permissions.yml'

const default_player_permissions_file = 'player_permissions.yml'

const default_ops_file = 'ops.txt'

const command_version = 'vedrock.cmd.version'

Defaults

const command_status = 'vedrock.cmd.status'

const command_gamemode_self = 'vedrock.cmd.gamemode.self'

const command_gamemode_other = 'vedrock.cmd.gamemode.other'

const command_op = 'vedrock.cmd.op'

const command_whitelist = 'vedrock.cmd.whitelist'

const command_kill_self = 'vedrock.cmd.kill.self'

const command_kill_other = 'vedrock.cmd.kill.other'

const command_teleport_self = 'vedrock.cmd.teleport.self'

const command_teleport_other = 'vedrock.cmd.teleport.other'

const command_clear_self = 'vedrock.cmd.clear.self'

const command_clear_other = 'vedrock.cmd.clear.other'

const command_give = 'vedrock.cmd.give'

const command_difficulty = 'vedrock.cmd.difficulty'

const command_say = 'vedrock.cmd.say'

const command_title = 'vedrock.cmd.title'

const command_world = 'vedrock.cmd.world'

const registry = new_registry()

const default_whitelist_file = 'whitelist.txt'

fn all #

fn all() []Permission

all returns every permission currently known to the shared registry.

fn load_ops #

fn load_ops(path string) !OpList

fn load_permissions_config #

fn load_permissions_config(path string) !PermissionsConfig

fn load_player_grants #

fn load_player_grants(path string) !PlayerGrants

fn load_whitelist #

fn load_whitelist(path string) !Whitelist

fn lookup #

fn lookup(name string) Permission

lookup resolves name against the shared registry.

fn register #

fn register(perm Permission)

register adds or replaces a permission definition on the shared registry. Safe to call at any point after startup.

fn set_default #

fn set_default(name string, value DefaultValue)

set_default overrides a permission's default access level on the shared registry. Safe to call at any point after startup.

fn DefaultValue.from #

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

enum DefaultValue #

enum DefaultValue {
	granted // everyone has it
	denied  // nobody has it unless explicitly granted
	op      // only operators have it
	not_op  // everyone except operators has it
}

fn (DefaultValue) str #

fn (v DefaultValue) str() string

struct OpList #

struct OpList {
mut:
	path  string
	names map[string]bool
}

fn (OpList) is_op #

fn (o &OpList) is_op(name string) bool

fn (OpList) add #

fn (mut o OpList) add(name string) !

fn (OpList) remove #

fn (mut o OpList) remove(name string) !

struct Permissible #

struct Permissible {
mut:
	is_op     bool
	overrides map[string]bool
}

Permissible is attached to a player-session (or console) and answers permission checks for it. An explicit override always wins; otherwise the permission's own default (granted / denied / op / not_op) decides based on whether this Permissible is currently operator.

fn (Permissible) op #

fn (p &Permissible) op() bool

fn (Permissible) set_op #

fn (mut p Permissible) set_op(op bool)

fn (Permissible) has_permission #

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

has_permission checks name against any explicit override first, then falls back to the permission's registered default.

fn (Permissible) set_permission #

fn (mut p Permissible) set_permission(name string, value bool)

fn (Permissible) unset_permission #

fn (mut p Permissible) unset_permission(name string)

struct Permission #

struct Permission {
pub:
	name        string
	description string
	default     DefaultValue = .denied
}

struct PermissionsConfig #

struct PermissionsConfig {
pub:
	disabled_commands []string
}

struct PlayerGrants #

struct PlayerGrants {
mut:
	by_key map[string][]PlayerGrant
}

fn (PlayerGrants) apply #

fn (g &PlayerGrants) apply(mut p Permissible, name string, xuid string, uuid string)

struct Registry #

@[heap]

struct Registry {
mut:
	permissions map[string]Permission
}

Registry is a mutable set of known permissions. The shared registry below is the one every Permissible checks against; register() may be called on it at any time after startup (e.g. by a future plugin)

fn (Registry) register #

fn (mut r Registry) register(perm Permission)

fn (Registry) get #

fn (r &Registry) get(name string) Permission

fn (Registry) set_default #

fn (mut r Registry) set_default(name string, value DefaultValue)

set_default overrides the default access level of an already-registered permission, preserving its name/description. Registers a bare entry (no description) if name isn't known yet.

fn (Registry) all #

fn (r &Registry) all() []Permission

all returns every permission currently known to the registry.

struct Whitelist #

struct Whitelist {
mut:
	path    string
	enabled bool
	names   map[string]bool
}

fn (Whitelist) is_enabled #

fn (w &Whitelist) is_enabled() bool

fn (Whitelist) set_enabled #

fn (mut w Whitelist) set_enabled(value bool) !

fn (Whitelist) is_allowed #

fn (w &Whitelist) is_allowed(name string) bool

is_allowed reports whether name may join: always true while the whitelist is disabled, otherwise only true for names explicitly added.

fn (Whitelist) is_whitelisted #

fn (w &Whitelist) is_whitelisted(name string) bool

fn (Whitelist) add #

fn (mut w Whitelist) add(name string) !

fn (Whitelist) remove #

fn (mut w Whitelist) remove(name string) !

fn (Whitelist) names_list #

fn (w &Whitelist) names_list() []string