Zig: Players

Player

pub const Player = struct {
    sel_kind: SelKind,
    sel_value: []const u8,
    // ...
};

One player, named by a selector.

Player.byName

pub fn byName(sel_name: []const u8) Player

• Parameters:
  • sel_name : []const u8
• Return type: Player

Player.byXuid

pub fn byXuid(sel_xuid: []const u8) Player

• Parameters:
  • sel_xuid : []const u8
• Return type: Player

Player.byUuid

pub fn byUuid(sel_uuid: []const u8) Player

• Parameters:
  • sel_uuid : []const u8
• Return type: Player

Player.cSel

pub fn cSel(self: Player) core.c.PierPlayerSel

• Return type: core.c.PierPlayerSel

Player.gameType

pub fn gameType(self: Player) core.Error!f64

PIER_PPROP_GAME_TYPE: (G) Player::getPlayerGameType; write via player_set_gamemode

• Return type: core.Error!f64
• Slots: player_get_num

Player.level

pub fn level(self: Player) core.Error!f64

PIER_PPROP_LEVEL: (S) attribute Player::LEVEL()

• Return type: core.Error!f64
• Slots: player_get_num

Player.setLevel

pub fn setLevel(self: Player, new_value: f64) core.Error!void

Writes PIER_PPROP_LEVEL: (S) attribute Player::LEVEL()

• Parameters:
  • new_value : f64
• Return type: core.Error!void
• Slots: player_set_num

Player.experience

pub fn experience(self: Player) core.Error!f64

PIER_PPROP_EXPERIENCE: (S) attribute Player::EXPERIENCE() (progress 0..1)

• Return type: core.Error!f64
• Slots: player_get_num

Player.setExperience

pub fn setExperience(self: Player, new_value: f64) core.Error!void

Writes PIER_PPROP_EXPERIENCE: (S) attribute Player::EXPERIENCE() (progress 0..1)

• Parameters:
  • new_value : f64
• Return type: core.Error!void
• Slots: player_set_num

Player.hunger

pub fn hunger(self: Player) core.Error!f64

PIER_PPROP_HUNGER: (S) attribute Player::HUNGER()

• Return type: core.Error!f64
• Slots: player_get_num

Player.setHunger

pub fn setHunger(self: Player, new_value: f64) core.Error!void

Writes PIER_PPROP_HUNGER: (S) attribute Player::HUNGER()

• Parameters:
  • new_value : f64
• Return type: core.Error!void
• Slots: player_set_num

Player.saturation

pub fn saturation(self: Player) core.Error!f64

PIER_PPROP_SATURATION: (S) attribute Player::SATURATION()

• Return type: core.Error!f64
• Slots: player_get_num

Player.setSaturation

pub fn setSaturation(self: Player, new_value: f64) core.Error!void

Writes PIER_PPROP_SATURATION: (S) attribute Player::SATURATION()

• Parameters:
  • new_value : f64
• Return type: core.Error!void
• Slots: player_set_num

Player.exhaustion

pub fn exhaustion(self: Player) core.Error!f64

PIER_PPROP_EXHAUSTION: (S) attribute Player::EXHAUSTION()

• Return type: core.Error!f64
• Slots: player_get_num

Player.setExhaustion

pub fn setExhaustion(self: Player, new_value: f64) core.Error!void

Writes PIER_PPROP_EXHAUSTION: (S) attribute Player::EXHAUSTION()

• Parameters:
  • new_value : f64
• Return type: core.Error!void
• Slots: player_set_num

Player.xpNeededNextLevel

pub fn xpNeededNextLevel(self: Player) core.Error!f64

PIER_PPROP_XP_NEEDED_NEXT_LEVEL: (G) Player::getXpNeededForNextLevel

• Return type: core.Error!f64
• Slots: player_get_num

Player.luck

pub fn luck(self: Player) core.Error!f64

PIER_PPROP_LUCK: (G) Player::getLuck

• Return type: core.Error!f64
• Slots: player_get_num

Player.selectedSlot

pub fn selectedSlot(self: Player) core.Error!f64

PIER_PPROP_SELECTED_SLOT: (G) Player::getSelectedItemSlot; set via PIER_PACT_SET_SELECTED_SLOT

• Return type: core.Error!f64
• Slots: player_get_num

Player.isOperator

pub fn isOperator(self: Player) core.Error!bool

PIER_PPROP_IS_OPERATOR: (G) Player::isOperator

• Return type: core.Error!bool
• Slots: player_get_num

Player.canUseOperatorBlocks

pub fn canUseOperatorBlocks(self: Player) core.Error!bool

PIER_PPROP_CAN_USE_OPERATOR_BLOCKS: (G) Player::canUseOperatorBlocks

• Return type: core.Error!bool
• Slots: player_get_num

Player.isFlying

pub fn isFlying(self: Player) core.Error!bool

PIER_PPROP_IS_FLYING: (G) Player::isFlying

• Return type: core.Error!bool
• Slots: player_get_num

Player.canJump

pub fn canJump(self: Player) core.Error!bool

PIER_PPROP_CAN_JUMP: (G) Player::canJump

• Return type: core.Error!bool
• Slots: player_get_num

Player.isEmoting

pub fn isEmoting(self: Player) core.Error!bool

PIER_PPROP_IS_EMOTING: (G) Player::isEmoting

• Return type: core.Error!bool
• Slots: player_get_num

Player.isInRaid

pub fn isInRaid(self: Player) core.Error!bool

PIER_PPROP_IS_IN_RAID: (G) Player::isInRaid

• Return type: core.Error!bool
• Slots: player_get_num

Player.isHurt

pub fn isHurt(self: Player) core.Error!bool

PIER_PPROP_IS_HURT: (G) Player::isHurt

• Return type: core.Error!bool
• Slots: player_get_num

Player.isScoping

pub fn isScoping(self: Player) core.Error!bool

PIER_PPROP_IS_SCOPING: (G) Player::isScoping

• Return type: core.Error!bool
• Slots: player_get_num

Player.canSleep

pub fn canSleep(self: Player) core.Error!bool

PIER_PPROP_CAN_SLEEP: (G) Player::canSleep

• Return type: core.Error!bool
• Slots: player_get_num

Player.hasRespawnPosition

pub fn hasRespawnPosition(self: Player) core.Error!bool

PIER_PPROP_HAS_RESPAWN_POSITION: (G) Player::hasRespawnPosition

• Return type: core.Error!bool
• Slots: player_get_num

Player.clientSubId

pub fn clientSubId(self: Player) core.Error!f64

PIER_PPROP_CLIENT_SUB_ID: (G) Player::getClientSubId

• Return type: core.Error!f64
• Slots: player_get_num

Player.canUseAbility

pub fn canUseAbility(self: Player) core.Error!bool

PIER_PPROP_CAN_USE_ABILITY: (G) Player::canUseAbility; the ability index is passed through the player_action GET path, see PIER_PACT_CAN_USE_ABILITY

• Return type: core.Error!bool
• Slots: player_get_num

Player.direction

pub fn direction(self: Player) core.Error!f64

PIER_PPROP_DIRECTION: (G) Player::getDirection (0=S,1=W,2=N,3=E)

• Return type: core.Error!f64
• Slots: player_get_num

Player.chunkRadius

pub fn chunkRadius(self: Player) core.Error!f64

PIER_PPROP_CHUNK_RADIUS: (G) Player::getChunkRadius

• Return type: core.Error!f64
• Slots: player_get_num

Player.networkRtt

pub fn networkRtt(self: Player) core.Error!f64

PIER_PPROP_NETWORK_RTT: (G) getNetworkStatus().mPing (ms)

• Return type: core.Error!f64
• Slots: player_get_num

Player.platform

pub fn platform(self: Player) core.Error!f64

PIER_PPROP_PLATFORM: (G) Player::getPlatform

• Return type: core.Error!f64
• Slots: player_get_num

Player.enchantmentSeed

pub fn enchantmentSeed(self: Player) core.Error!f64

PIER_PPROP_ENCHANTMENT_SEED: (G) Player::getEnchantmentSeed

• Return type: core.Error!f64
• Slots: player_get_num

Player.isUsingItem

pub fn isUsingItem(self: Player) core.Error!bool

PIER_PPROP_IS_USING_ITEM: (G) Player::isUsingItem

• Return type: core.Error!bool
• Slots: player_get_num

Player.isBlocking

pub fn isBlocking(self: Player) core.Error!bool

PIER_PPROP_IS_BLOCKING: (G) Player::isBlocking

• Return type: core.Error!bool
• Slots: player_get_num

Player.isGliding

pub fn isGliding(self: Player) core.Error!bool

PIER_PPROP_IS_GLIDING: (G) Player::isGliding

• Return type: core.Error!bool
• Slots: player_get_num

Player.isSwimming

pub fn isSwimming(self: Player) core.Error!bool

PIER_PPROP_IS_SWIMMING: (G) Player::isSwimming

• Return type: core.Error!bool
• Slots: player_get_num

Player.permissionLevel

pub fn permissionLevel(self: Player) core.Error!f64

PIER_PPROP_PERMISSION_LEVEL: (G) Player::getPlayerPermissionLevel

• Return type: core.Error!f64
• Slots: player_get_num

Player.score

pub fn score(self: Player) core.Error!f64

PIER_PPROP_SCORE: (G) Player::getScore

• Return type: core.Error!f64
• Slots: player_get_num

Player.fallDistance

pub fn fallDistance(self: Player) core.Error!f64

PIER_PPROP_FALL_DISTANCE: (G) Actor::getFallDistance

• Return type: core.Error!f64
• Slots: player_get_num

Player.isDead

pub fn isDead(self: Player) core.Error!bool

PIER_PPROP_IS_DEAD: (G) Actor::isDead

• Return type: core.Error!bool
• Slots: player_get_num

Player.hasDiedBefore

pub fn hasDiedBefore(self: Player) core.Error!bool

PIER_PPROP_HAS_DIED_BEFORE: (G) Player::hasDiedBefore

• Return type: core.Error!bool
• Slots: player_get_num

Player.dimension

pub fn dimension(self: Player) core.Error!f64

PIER_PPROP_DIMENSION: (G) Actor::getDimensionId

• Return type: core.Error!f64
• Slots: player_get_num

Player.realName

pub fn realName(self: Player, allocator: std.mem.Allocator) core.Error![]u8

PIER_PSTR_REAL_NAME: Player::getRealName

• Parameters:
  • allocator : std.mem.Allocator
• Return type: core.Error![]u8
• Slots: player_get_str

Player.uuid

pub fn uuid(self: Player, allocator: std.mem.Allocator) core.Error![]u8

PIER_PSTR_UUID: Player::getUuid().asString()

• Parameters:
  • allocator : std.mem.Allocator
• Return type: core.Error![]u8
• Slots: player_get_str

Player.xuid

pub fn xuid(self: Player, allocator: std.mem.Allocator) core.Error![]u8

PIER_PSTR_XUID: Player::getXuid

• Parameters:
  • allocator : std.mem.Allocator
• Return type: core.Error![]u8
• Slots: player_get_str

Player.ipAndPort

pub fn ipAndPort(self: Player, allocator: std.mem.Allocator) core.Error![]u8

PIER_PSTR_IP_AND_PORT: Player::getIPAndPort

• Parameters:
  • allocator : std.mem.Allocator
• Return type: core.Error![]u8
• Slots: player_get_str

Player.localeCode

pub fn localeCode(self: Player, allocator: std.mem.Allocator) core.Error![]u8

PIER_PSTR_LOCALE_CODE: Player::getLocaleCode

• Parameters:
  • allocator : std.mem.Allocator
• Return type: core.Error![]u8
• Slots: player_get_str

Player.nameTag

pub fn nameTag(self: Player, allocator: std.mem.Allocator) core.Error![]u8

PIER_PSTR_NAME_TAG: Actor::getNameTag (display name)

• Parameters:
  • allocator : std.mem.Allocator
• Return type: core.Error![]u8
• Slots: player_get_str

Player.lastDeathPos

pub fn lastDeathPos(self: Player, allocator: std.mem.Allocator) core.Error![]u8

PIER_PSTR_LAST_DEATH_POS: SNBT {x,y,z} or "" if none

• Parameters:
  • allocator : std.mem.Allocator
• Return type: core.Error![]u8
• Slots: player_get_str

Player.lastDeathDimension

pub fn lastDeathDimension(self: Player, allocator: std.mem.Allocator) core.Error![]u8

PIER_PSTR_LAST_DEATH_DIMENSION: dimension id as string

• Parameters:
  • allocator : std.mem.Allocator
• Return type: core.Error![]u8
• Slots: player_get_str

Player.networkStatus

pub fn networkStatus(self: Player, allocator: std.mem.Allocator) core.Error![]u8

PIER_PSTR_NETWORK_STATUS: SNBT {ping,avg_ping,packet_loss,max_ping}

• Parameters:
  • allocator : std.mem.Allocator
• Return type: core.Error![]u8
• Slots: player_get_str

Player.platformOnlineId

pub fn platformOnlineId(self: Player, allocator: std.mem.Allocator) core.Error![]u8

PIER_PSTR_PLATFORM_ONLINE_ID: Player::getPlatformOnlineId

• Parameters:
  • allocator : std.mem.Allocator
• Return type: core.Error![]u8
• Slots: player_get_str

Player.respawnPos

pub fn respawnPos(self: Player, allocator: std.mem.Allocator) core.Error![]u8

PIER_PSTR_RESPAWN_POS: SNBT {x,y,z,dim}: where this player would respawn. Never empty; a player with no bed reports the world spawn, and the two are not distinguishable.

• Parameters:
  • allocator : std.mem.Allocator
• Return type: core.Error![]u8
• Slots: player_get_str

Player.setAbility

pub fn setAbility(self: Player, allocator: std.mem.Allocator, s_arg: []const u8, n_a: f64, n_b: f64, n_c: f64) core.Error![]u8

PIER_PACT_SET_ABILITY: a=AbilitiesIndex, b=0/1 (bool slots) or float (FlySpeed etc.). Restores PlayerPermissionLevel to its pre-write value afterwards: the engine's LayeredAbilities::setAbility is the "switch to custom permissions" path and pushes the player to Custom, and that level ships to the client inside UpdateAbilitiesPacket together with the ability layer. To change the level, use PIER_PACT_SET_PERMISSION_LEVEL. Refused (false) until the player has finished joining (Player::isPlayerInitialized): an ability written while the client is still loading desynchronizes until the player rejoins. Simulated players are exempt.

The output, when the verb has one, is returned; abi.h names each argument.

• Parameters:
  • allocator : std.mem.Allocator
  • s_arg : []const u8
  • n_a : f64
  • n_b : f64
  • n_c : f64
• Return type: core.Error![]u8
• Slots: player_action

Player.canUseAbilityAction

pub fn canUseAbilityAction(self: Player, allocator: std.mem.Allocator, s_arg: []const u8, n_a: f64, n_b: f64, n_c: f64) core.Error![]u8

PIER_PACT_CAN_USE_ABILITY: a=AbilitiesIndex → out "0"/"1" Player::canUseAbility

The output, when the verb has one, is returned; abi.h names each argument.

• Parameters:
  • allocator : std.mem.Allocator
  • s_arg : []const u8
  • n_a : f64
  • n_b : f64
  • n_c : f64
• Return type: core.Error![]u8
• Slots: player_action

Player.setSelectedSlot

pub fn setSelectedSlot(self: Player, allocator: std.mem.Allocator, s_arg: []const u8, n_a: f64, n_b: f64, n_c: f64) core.Error![]u8

PIER_PACT_SET_SELECTED_SLOT: a=slot Player::setSelectedSlot

The output, when the verb has one, is returned; abi.h names each argument.

• Parameters:
  • allocator : std.mem.Allocator
  • s_arg : []const u8
  • n_a : f64
  • n_b : f64
  • n_c : f64
• Return type: core.Error![]u8
• Slots: player_action

Player.giveItem

pub fn giveItem(self: Player, allocator: std.mem.Allocator, s_arg: []const u8, n_a: f64, n_b: f64, n_c: f64) core.Error![]u8

PIER_PACT_GIVE_ITEM: sarg=item SNBT ItemStack::fromTag + Player::addAndRefresh

The output, when the verb has one, is returned; abi.h names each argument.

• Parameters:
  • allocator : std.mem.Allocator
  • s_arg : []const u8
  • n_a : f64
  • n_b : f64
  • n_c : f64
• Return type: core.Error![]u8
• Slots: player_action

Player.setSpawnPoint

pub fn setSpawnPoint(self: Player, allocator: std.mem.Allocator, s_arg: []const u8, n_a: f64, n_b: f64, n_c: f64) core.Error![]u8

PIER_PACT_SET_SPAWN_POINT: a,b,c=pos, sarg=dim id (any registered dim); native Player::setRespawnPosition

The output, when the verb has one, is returned; abi.h names each argument.

• Parameters:
  • allocator : std.mem.Allocator
  • s_arg : []const u8
  • n_a : f64
  • n_b : f64
  • n_c : f64
• Return type: core.Error![]u8
• Slots: player_action

Player.clearTitle

pub fn clearTitle(self: Player, allocator: std.mem.Allocator, s_arg: []const u8, n_a: f64, n_b: f64, n_c: f64) core.Error![]u8

PIER_PACT_CLEAR_TITLE: native SetTitlePacket(Clear)

The output, when the verb has one, is returned; abi.h names each argument.

• Parameters:
  • allocator : std.mem.Allocator
  • s_arg : []const u8
  • n_a : f64
  • n_b : f64
  • n_c : f64
• Return type: core.Error![]u8
• Slots: player_action

Player.setTitle

pub fn setTitle(self: Player, allocator: std.mem.Allocator, s_arg: []const u8, n_a: f64, n_b: f64, n_c: f64) core.Error![]u8

PIER_PACT_SET_TITLE: sarg=text, a=slot(0 title,1 subtitle,2 actionbar); native SetTitlePacket, text sent verbatim

The output, when the verb has one, is returned; abi.h names each argument.

• Parameters:
  • allocator : std.mem.Allocator
  • s_arg : []const u8
  • n_a : f64
  • n_b : f64
  • n_c : f64
• Return type: core.Error![]u8
• Slots: player_action

Player.addExperience

pub fn addExperience(self: Player, allocator: std.mem.Allocator, s_arg: []const u8, n_a: f64, n_b: f64, n_c: f64) core.Error![]u8

PIER_PACT_ADD_EXPERIENCE: a=xp Player::addExperience

The output, when the verb has one, is returned; abi.h names each argument.

• Parameters:
  • allocator : std.mem.Allocator
  • s_arg : []const u8
  • n_a : f64
  • n_b : f64
  • n_c : f64
• Return type: core.Error![]u8
• Slots: player_action

Player.addLevels

pub fn addLevels(self: Player, allocator: std.mem.Allocator, s_arg: []const u8, n_a: f64, n_b: f64, n_c: f64) core.Error![]u8

PIER_PACT_ADD_LEVELS: a=levels Player::addLevels

The output, when the verb has one, is returned; abi.h names each argument.

• Parameters:
  • allocator : std.mem.Allocator
  • s_arg : []const u8
  • n_a : f64
  • n_b : f64
  • n_c : f64
• Return type: core.Error![]u8
• Slots: player_action

Player.startCooldown

pub fn startCooldown(self: Player, allocator: std.mem.Allocator, s_arg: []const u8, n_a: f64, n_b: f64, n_c: f64) core.Error![]u8

PIER_PACT_START_COOLDOWN: sarg=item name, a=ticks Player::startItemCooldown

The output, when the verb has one, is returned; abi.h names each argument.

• Parameters:
  • allocator : std.mem.Allocator
  • s_arg : []const u8
  • n_a : f64
  • n_b : f64
  • n_c : f64
• Return type: core.Error![]u8
• Slots: player_action

Player.startRiding

pub fn startRiding(self: Player, allocator: std.mem.Allocator, s_arg: []const u8, n_a: f64, n_b: f64, n_c: f64) core.Error![]u8

PIER_PACT_START_RIDING: a=vehicle ActorUniqueID (lower 64b) Player::startRiding

The output, when the verb has one, is returned; abi.h names each argument.

• Parameters:
  • allocator : std.mem.Allocator
  • s_arg : []const u8
  • n_a : f64
  • n_b : f64
  • n_c : f64
• Return type: core.Error![]u8
• Slots: player_action

Player.stopRiding

pub fn stopRiding(self: Player, allocator: std.mem.Allocator, s_arg: []const u8, n_a: f64, n_b: f64, n_c: f64) core.Error![]u8

PIER_PACT_STOP_RIDING: Player::stopRiding

The output, when the verb has one, is returned; abi.h names each argument.

• Parameters:
  • allocator : std.mem.Allocator
  • s_arg : []const u8
  • n_a : f64
  • n_b : f64
  • n_c : f64
• Return type: core.Error![]u8
• Slots: player_action

Player.attack

pub fn attack(self: Player, allocator: std.mem.Allocator, s_arg: []const u8, n_a: f64, n_b: f64, n_c: f64) core.Error![]u8

PIER_PACT_ATTACK: a=target ActorUniqueID (lower 64b) Player::attack

The output, when the verb has one, is returned; abi.h names each argument.

• Parameters:
  • allocator : std.mem.Allocator
  • s_arg : []const u8
  • n_a : f64
  • n_b : f64
  • n_c : f64
• Return type: core.Error![]u8
• Slots: player_action

Player.drop

pub fn drop(self: Player, allocator: std.mem.Allocator, s_arg: []const u8, n_a: f64, n_b: f64, n_c: f64) core.Error![]u8

PIER_PACT_DROP: sarg=item SNBT, a=random(0/1) Player::drop

The output, when the verb has one, is returned; abi.h names each argument.

• Parameters:
  • allocator : std.mem.Allocator
  • s_arg : []const u8
  • n_a : f64
  • n_b : f64
  • n_c : f64
• Return type: core.Error![]u8
• Slots: player_action

Player.interact

pub fn interact(self: Player, allocator: std.mem.Allocator, s_arg: []const u8, n_a: f64, n_b: f64, n_c: f64) core.Error![]u8

PIER_PACT_INTERACT: a=target ActorUniqueID Player::interact

The output, when the verb has one, is returned; abi.h names each argument.

• Parameters:
  • allocator : std.mem.Allocator
  • s_arg : []const u8
  • n_a : f64
  • n_b : f64
  • n_c : f64
• Return type: core.Error![]u8
• Slots: player_action

Player.startUsingItem

pub fn startUsingItem(self: Player, allocator: std.mem.Allocator, s_arg: []const u8, n_a: f64, n_b: f64, n_c: f64) core.Error![]u8

PIER_PACT_START_USING_ITEM: sarg=item SNBT, a=duration Player::startUsingItem

The output, when the verb has one, is returned; abi.h names each argument.

• Parameters:
  • allocator : std.mem.Allocator
  • s_arg : []const u8
  • n_a : f64
  • n_b : f64
  • n_c : f64
• Return type: core.Error![]u8
• Slots: player_action

Player.stopUsingItem

pub fn stopUsingItem(self: Player, allocator: std.mem.Allocator, s_arg: []const u8, n_a: f64, n_b: f64, n_c: f64) core.Error![]u8

PIER_PACT_STOP_USING_ITEM: Player::stopUsingItem

The output, when the verb has one, is returned; abi.h names each argument.

• Parameters:
  • allocator : std.mem.Allocator
  • s_arg : []const u8
  • n_a : f64
  • n_b : f64
  • n_c : f64
• Return type: core.Error![]u8
• Slots: player_action

Player.setChunkRadius

pub fn setChunkRadius(self: Player, allocator: std.mem.Allocator, s_arg: []const u8, n_a: f64, n_b: f64, n_c: f64) core.Error![]u8

PIER_PACT_SET_CHUNK_RADIUS: a=radius Player::setChunkRadius

The output, when the verb has one, is returned; abi.h names each argument.

• Parameters:
  • allocator : std.mem.Allocator
  • s_arg : []const u8
  • n_a : f64
  • n_b : f64
  • n_c : f64
• Return type: core.Error![]u8
• Slots: player_action

Player.setEnchantmentSeed

pub fn setEnchantmentSeed(self: Player, allocator: std.mem.Allocator, s_arg: []const u8, n_a: f64, n_b: f64, n_c: f64) core.Error![]u8

PIER_PACT_SET_ENCHANTMENT_SEED: a=seed Player::setEnchantmentSeed

The output, when the verb has one, is returned; abi.h names each argument.

• Parameters:
  • allocator : std.mem.Allocator
  • s_arg : []const u8
  • n_a : f64
  • n_b : f64
  • n_c : f64
• Return type: core.Error![]u8
• Slots: player_action

Player.registerTrackedBoss

pub fn registerTrackedBoss(self: Player, allocator: std.mem.Allocator, s_arg: []const u8, n_a: f64, n_b: f64, n_c: f64) core.Error![]u8

PIER_PACT_REGISTER_TRACKED_BOSS: a=boss ActorUniqueID Player::registerTrackedBoss

The output, when the verb has one, is returned; abi.h names each argument.

• Parameters:
  • allocator : std.mem.Allocator
  • s_arg : []const u8
  • n_a : f64
  • n_b : f64
  • n_c : f64
• Return type: core.Error![]u8
• Slots: player_action

Player.unregisterTrackedBoss

pub fn unregisterTrackedBoss(self: Player, allocator: std.mem.Allocator, s_arg: []const u8, n_a: f64, n_b: f64, n_c: f64) core.Error![]u8

PIER_PACT_UNREGISTER_TRACKED_BOSS: a=boss ActorUniqueID Player::unRegisterTrackedBoss

The output, when the verb has one, is returned; abi.h names each argument.

• Parameters:
  • allocator : std.mem.Allocator
  • s_arg : []const u8
  • n_a : f64
  • n_b : f64
  • n_c : f64
• Return type: core.Error![]u8
• Slots: player_action

Player.playEmote

pub fn playEmote(self: Player, allocator: std.mem.Allocator, s_arg: []const u8, n_a: f64, n_b: f64, n_c: f64) core.Error![]u8

PIER_PACT_PLAY_EMOTE: sarg=piece id Player::playEmote

The output, when the verb has one, is returned; abi.h names each argument.

• Parameters:
  • allocator : std.mem.Allocator
  • s_arg : []const u8
  • n_a : f64
  • n_b : f64
  • n_c : f64
• Return type: core.Error![]u8
• Slots: player_action

Player.resendAllChunks

pub fn resendAllChunks(self: Player, allocator: std.mem.Allocator, s_arg: []const u8, n_a: f64, n_b: f64, n_c: f64) core.Error![]u8

PIER_PACT_RESEND_ALL_CHUNKS: Player::resendAllChunks

The output, when the verb has one, is returned; abi.h names each argument.

• Parameters:
  • allocator : std.mem.Allocator
  • s_arg : []const u8
  • n_a : f64
  • n_b : f64
  • n_c : f64
• Return type: core.Error![]u8
• Slots: player_action

Player.openInventory

pub fn openInventory(self: Player, allocator: std.mem.Allocator, s_arg: []const u8, n_a: f64, n_b: f64, n_c: f64) core.Error![]u8

PIER_PACT_OPEN_INVENTORY: Player::openInventory

The output, when the verb has one, is returned; abi.h names each argument.

• Parameters:
  • allocator : std.mem.Allocator
  • s_arg : []const u8
  • n_a : f64
  • n_b : f64
  • n_c : f64
• Return type: core.Error![]u8
• Slots: player_action

Player.sidebarSet

pub fn sidebarSet(self: Player, allocator: std.mem.Allocator, s_arg: []const u8, n_a: f64, n_b: f64, n_c: f64) core.Error![]u8

PIER_PACT_SIDEBAR_SET: sarg="obj\ntitle\nline…" per-player sidebar

The output, when the verb has one, is returned; abi.h names each argument.

• Parameters:
  • allocator : std.mem.Allocator
  • s_arg : []const u8
  • n_a : f64
  • n_b : f64
  • n_c : f64
• Return type: core.Error![]u8
• Slots: player_action

Player.sidebarClear

pub fn sidebarClear(self: Player, allocator: std.mem.Allocator, s_arg: []const u8, n_a: f64, n_b: f64, n_c: f64) core.Error![]u8

PIER_PACT_SIDEBAR_CLEAR: sarg=objective RemoveObjectivePacket

The output, when the verb has one, is returned; abi.h names each argument.

• Parameters:
  • allocator : std.mem.Allocator
  • s_arg : []const u8
  • n_a : f64
  • n_b : f64
  • n_c : f64
• Return type: core.Error![]u8
• Slots: player_action

Player.setPermissionLevel

pub fn setPermissionLevel(self: Player, allocator: std.mem.Allocator, s_arg: []const u8, n_a: f64, n_b: f64, n_c: f64) core.Error![]u8

PIER_PACT_SET_PERMISSION_LEVEL: a=PlayerPermissionLevel (0 Visitor, 1 Member, 2 Operator, 3 Custom). LayeredAbilities::setPlayerPermissions plus UpdateAbilitiesPacket. The read side is PIER_PPROP_PERMISSION_LEVEL. Refused until the player has finished joining, like PIER_PACT_SET_ABILITY.

The output, when the verb has one, is returned; abi.h names each argument.

• Parameters:
  • allocator : std.mem.Allocator
  • s_arg : []const u8
  • n_a : f64
  • n_b : f64
  • n_c : f64
• Return type: core.Error![]u8
• Slots: player_action

SelKind

pub const SelKind = enum(i32) {
    name = 0, xuid = 1, uuid = 2
};

How a Player selector names its player. A decision about permissions, money or ownership keys on the xuid: a name can change hands.