999 lines
30 KiB
Go
999 lines
30 KiB
Go
// Generated by `wit-bindgen` 0.57.1. DO NOT EDIT!
|
|
//
|
|
// This code was generated from the following packages:
|
|
// pumpkin:plugin@0.1.0
|
|
|
|
package pumpkin_plugin_player
|
|
|
|
import (
|
|
"github.com/Pumpkin-MC/pumpkin-api-go/pkg/pumpkin_plugin_common"
|
|
"github.com/Pumpkin-MC/pumpkin-api-go/pkg/pumpkin_plugin_gui"
|
|
"github.com/Pumpkin-MC/pumpkin-api-go/pkg/pumpkin_plugin_permission"
|
|
"github.com/Pumpkin-MC/pumpkin-api-go/pkg/pumpkin_plugin_text"
|
|
"github.com/Pumpkin-MC/pumpkin-api-go/pkg/pumpkin_plugin_world"
|
|
witRuntime "go.bytecodealliance.org/pkg/wit/runtime"
|
|
witTypes "go.bytecodealliance.org/pkg/wit/types"
|
|
"runtime"
|
|
"unsafe"
|
|
)
|
|
|
|
type Hand = pumpkin_plugin_common.Hand
|
|
type ItemStack = pumpkin_plugin_common.ItemStack
|
|
type Position = witTypes.Tuple3[float64, float64, float64]
|
|
type GameMode = pumpkin_plugin_common.GameMode
|
|
type World = pumpkin_plugin_world.World
|
|
type Entity = pumpkin_plugin_world.Entity
|
|
type PermissionLevel = pumpkin_plugin_permission.PermissionLevel
|
|
type TextComponent = pumpkin_plugin_text.TextComponent
|
|
type Gui = pumpkin_plugin_gui.Gui
|
|
|
|
// Various abilities a player can have.
|
|
type PlayerAbilities struct {
|
|
// Whether the player is invulnerable to damage.
|
|
Invulnerable bool
|
|
// Whether the player is currently flying.
|
|
Flying bool
|
|
// Whether the player is allowed to fly.
|
|
AllowFlying bool
|
|
// Whether the player is in creative mode.
|
|
Creative bool
|
|
// Whether the player can modify the world.
|
|
AllowModifyWorld bool
|
|
// The speed at which the player flies.
|
|
FlySpeed float32
|
|
// The speed at which the player walks.
|
|
WalkSpeed float32
|
|
}
|
|
|
|
// Represents a player's skin textures and metadata.
|
|
type PlayerSkin struct {
|
|
// The base64-encoded texture data (usually JSON containing skin/cape URLs).
|
|
Value string
|
|
// The optional signature for the texture data.
|
|
Signature witTypes.Option[string]
|
|
}
|
|
|
|
const (
|
|
SkinPartsCape uint8 = 1 << 0
|
|
SkinPartsJacket uint8 = 1 << 1
|
|
SkinPartsLeftSleeve uint8 = 1 << 2
|
|
SkinPartsRightSleeve uint8 = 1 << 3
|
|
SkinPartsLeftPantsLeg uint8 = 1 << 4
|
|
SkinPartsRightPantsLeg uint8 = 1 << 5
|
|
SkinPartsHat uint8 = 1 << 6
|
|
)
|
|
|
|
// Flags representing visible skin parts.
|
|
type SkinParts = uint8
|
|
|
|
//go:wasmimport pumpkin:plugin/player@0.1.0 [resource-drop]player
|
|
func resourceDropPlayer(handle int32)
|
|
|
|
// A handle to a player on the server.
|
|
type Player struct {
|
|
handle *witRuntime.Handle
|
|
}
|
|
|
|
func (self *Player) TakeHandle() int32 {
|
|
return self.handle.Take()
|
|
}
|
|
|
|
func (self *Player) SetHandle(handle int32) {
|
|
self.handle.Set(handle)
|
|
}
|
|
|
|
func (self *Player) Handle() int32 {
|
|
return self.handle.Use()
|
|
}
|
|
|
|
func (self *Player) Drop() {
|
|
handle := self.handle.TakeOrNil()
|
|
if handle != 0 {
|
|
resourceDropPlayer(handle)
|
|
}
|
|
}
|
|
|
|
func PlayerFromOwnHandle(handleValue int32) *Player {
|
|
handle := witRuntime.MakeHandle(handleValue)
|
|
value := &Player{handle}
|
|
runtime.AddCleanup(value, func(_ int) {
|
|
handleValue := handle.TakeOrNil()
|
|
if handleValue != 0 {
|
|
resourceDropPlayer(handleValue)
|
|
}
|
|
}, 0)
|
|
return value
|
|
}
|
|
|
|
func PlayerFromBorrowHandle(handleValue int32) *Player {
|
|
handle := witRuntime.MakeHandle(handleValue)
|
|
return &Player{handle}
|
|
}
|
|
|
|
//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.as-entity
|
|
func wasm_import_method_player_as_entity(arg0 int32) int32
|
|
|
|
func (self *Player) AsEntity() *pumpkin_plugin_world.Entity {
|
|
|
|
result := wasm_import_method_player_as_entity((self).Handle())
|
|
return pumpkin_plugin_world.EntityFromOwnHandle(int32(uintptr(result)))
|
|
|
|
}
|
|
|
|
//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.get-id
|
|
func wasm_import_method_player_get_id(arg0 int32, arg1 uintptr)
|
|
|
|
func (self *Player) GetId() string {
|
|
pinner := &runtime.Pinner{}
|
|
defer pinner.Unpin()
|
|
|
|
returnArea := uintptr(witRuntime.Allocate(pinner, (2 * 4), 4))
|
|
wasm_import_method_player_get_id((self).Handle(), returnArea)
|
|
value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4)))
|
|
result := value
|
|
return result
|
|
|
|
}
|
|
|
|
//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.get-name
|
|
func wasm_import_method_player_get_name(arg0 int32, arg1 uintptr)
|
|
|
|
func (self *Player) GetName() string {
|
|
pinner := &runtime.Pinner{}
|
|
defer pinner.Unpin()
|
|
|
|
returnArea := uintptr(witRuntime.Allocate(pinner, (2 * 4), 4))
|
|
wasm_import_method_player_get_name((self).Handle(), returnArea)
|
|
value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4)))
|
|
result := value
|
|
return result
|
|
|
|
}
|
|
|
|
//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.get-position
|
|
func wasm_import_method_player_get_position(arg0 int32, arg1 uintptr)
|
|
|
|
func (self *Player) GetPosition() witTypes.Tuple3[float64, float64, float64] {
|
|
pinner := &runtime.Pinner{}
|
|
defer pinner.Unpin()
|
|
|
|
returnArea := uintptr(witRuntime.Allocate(pinner, 24, 8))
|
|
wasm_import_method_player_get_position((self).Handle(), returnArea)
|
|
result := witTypes.Tuple3[float64, float64, float64]{*(*float64)(unsafe.Add(unsafe.Pointer(returnArea), 0)), *(*float64)(unsafe.Add(unsafe.Pointer(returnArea), 8)), *(*float64)(unsafe.Add(unsafe.Pointer(returnArea), 16))}
|
|
return result
|
|
|
|
}
|
|
|
|
//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.get-yaw
|
|
func wasm_import_method_player_get_yaw(arg0 int32) float32
|
|
|
|
func (self *Player) GetYaw() float32 {
|
|
|
|
result := wasm_import_method_player_get_yaw((self).Handle())
|
|
return result
|
|
|
|
}
|
|
|
|
//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.get-pitch
|
|
func wasm_import_method_player_get_pitch(arg0 int32) float32
|
|
|
|
func (self *Player) GetPitch() float32 {
|
|
|
|
result := wasm_import_method_player_get_pitch((self).Handle())
|
|
return result
|
|
|
|
}
|
|
|
|
//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.get-world
|
|
func wasm_import_method_player_get_world(arg0 int32) int32
|
|
|
|
func (self *Player) GetWorld() *pumpkin_plugin_world.World {
|
|
|
|
result := wasm_import_method_player_get_world((self).Handle())
|
|
return pumpkin_plugin_world.WorldFromOwnHandle(int32(uintptr(result)))
|
|
|
|
}
|
|
|
|
//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.get-gamemode
|
|
func wasm_import_method_player_get_gamemode(arg0 int32) int32
|
|
|
|
func (self *Player) GetGamemode() pumpkin_plugin_common.GameMode {
|
|
|
|
result := wasm_import_method_player_get_gamemode((self).Handle())
|
|
return uint8(result)
|
|
|
|
}
|
|
|
|
//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.set-gamemode
|
|
func wasm_import_method_player_set_gamemode(arg0 int32, arg1 int32) int32
|
|
|
|
func (self *Player) SetGamemode(mode pumpkin_plugin_common.GameMode) bool {
|
|
|
|
result := wasm_import_method_player_set_gamemode((self).Handle(), int32(mode))
|
|
return (result != 0)
|
|
|
|
}
|
|
|
|
//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.get-locale
|
|
func wasm_import_method_player_get_locale(arg0 int32, arg1 uintptr)
|
|
|
|
func (self *Player) GetLocale() string {
|
|
pinner := &runtime.Pinner{}
|
|
defer pinner.Unpin()
|
|
|
|
returnArea := uintptr(witRuntime.Allocate(pinner, (2 * 4), 4))
|
|
wasm_import_method_player_get_locale((self).Handle(), returnArea)
|
|
value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4)))
|
|
result := value
|
|
return result
|
|
|
|
}
|
|
|
|
//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.get-ping
|
|
func wasm_import_method_player_get_ping(arg0 int32) int32
|
|
|
|
func (self *Player) GetPing() uint32 {
|
|
|
|
result := wasm_import_method_player_get_ping((self).Handle())
|
|
return uint32(result)
|
|
|
|
}
|
|
|
|
//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.get-permission-level
|
|
func wasm_import_method_player_get_permission_level(arg0 int32) int32
|
|
|
|
func (self *Player) GetPermissionLevel() pumpkin_plugin_permission.PermissionLevel {
|
|
|
|
result := wasm_import_method_player_get_permission_level((self).Handle())
|
|
return uint8(result)
|
|
|
|
}
|
|
|
|
//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.set-permission-level
|
|
func wasm_import_method_player_set_permission_level(arg0 int32, arg1 int32)
|
|
|
|
func (self *Player) SetPermissionLevel(level pumpkin_plugin_permission.PermissionLevel) {
|
|
|
|
wasm_import_method_player_set_permission_level((self).Handle(), int32(level))
|
|
|
|
}
|
|
|
|
//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.set-permission
|
|
func wasm_import_method_player_set_permission(arg0 int32, arg1 uintptr, arg2 uint32, arg3 int32)
|
|
|
|
func (self *Player) SetPermission(node string, value bool) {
|
|
pinner := &runtime.Pinner{}
|
|
defer pinner.Unpin()
|
|
|
|
utf8 := unsafe.Pointer(unsafe.StringData(node))
|
|
pinner.Pin(utf8)
|
|
var result int32
|
|
if value {
|
|
result = 1
|
|
} else {
|
|
result = 0
|
|
}
|
|
wasm_import_method_player_set_permission((self).Handle(), uintptr(utf8), uint32(len(node)), result)
|
|
|
|
}
|
|
|
|
//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.unset-permission
|
|
func wasm_import_method_player_unset_permission(arg0 int32, arg1 uintptr, arg2 uint32)
|
|
|
|
func (self *Player) UnsetPermission(node string) {
|
|
pinner := &runtime.Pinner{}
|
|
defer pinner.Unpin()
|
|
|
|
utf8 := unsafe.Pointer(unsafe.StringData(node))
|
|
pinner.Pin(utf8)
|
|
wasm_import_method_player_unset_permission((self).Handle(), uintptr(utf8), uint32(len(node)))
|
|
|
|
}
|
|
|
|
//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.has-permission-set
|
|
func wasm_import_method_player_has_permission_set(arg0 int32, arg1 uintptr, arg2 uint32, arg3 uintptr)
|
|
|
|
func (self *Player) HasPermissionSet(node string) witTypes.Option[bool] {
|
|
pinner := &runtime.Pinner{}
|
|
defer pinner.Unpin()
|
|
|
|
returnArea := uintptr(witRuntime.Allocate(pinner, 2, 1))
|
|
utf8 := unsafe.Pointer(unsafe.StringData(node))
|
|
pinner.Pin(utf8)
|
|
wasm_import_method_player_has_permission_set((self).Handle(), uintptr(utf8), uint32(len(node)), returnArea)
|
|
var option witTypes.Option[bool]
|
|
switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
|
|
case 0:
|
|
|
|
option = witTypes.None[bool]()
|
|
case 1:
|
|
|
|
option = witTypes.Some[bool]((uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 1))) != 0))
|
|
default:
|
|
panic("unreachable")
|
|
}
|
|
result := option
|
|
return result
|
|
|
|
}
|
|
|
|
//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.has-permission
|
|
func wasm_import_method_player_has_permission(arg0 int32, arg1 uintptr, arg2 uint32) int32
|
|
|
|
func (self *Player) HasPermission(node string) bool {
|
|
pinner := &runtime.Pinner{}
|
|
defer pinner.Unpin()
|
|
|
|
utf8 := unsafe.Pointer(unsafe.StringData(node))
|
|
pinner.Pin(utf8)
|
|
result := wasm_import_method_player_has_permission((self).Handle(), uintptr(utf8), uint32(len(node)))
|
|
return (result != 0)
|
|
|
|
}
|
|
|
|
//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.get-display-name
|
|
func wasm_import_method_player_get_display_name(arg0 int32) int32
|
|
|
|
func (self *Player) GetDisplayName() *pumpkin_plugin_text.TextComponent {
|
|
|
|
result := wasm_import_method_player_get_display_name((self).Handle())
|
|
return pumpkin_plugin_text.TextComponentFromOwnHandle(int32(uintptr(result)))
|
|
|
|
}
|
|
|
|
//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.set-display-name
|
|
func wasm_import_method_player_set_display_name(arg0 int32, arg1 int32)
|
|
|
|
func (self *Player) SetDisplayName(displayName *pumpkin_plugin_text.TextComponent) {
|
|
|
|
wasm_import_method_player_set_display_name((self).Handle(), (displayName).TakeHandle())
|
|
|
|
}
|
|
|
|
//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.send-system-message
|
|
func wasm_import_method_player_send_system_message(arg0 int32, arg1 int32, arg2 int32)
|
|
|
|
func (self *Player) SendSystemMessage(text *pumpkin_plugin_text.TextComponent, overlay bool) {
|
|
|
|
var result int32
|
|
if overlay {
|
|
result = 1
|
|
} else {
|
|
result = 0
|
|
}
|
|
wasm_import_method_player_send_system_message((self).Handle(), (text).TakeHandle(), result)
|
|
|
|
}
|
|
|
|
//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.set-tab-list-header-footer
|
|
func wasm_import_method_player_set_tab_list_header_footer(arg0 int32, arg1 int32, arg2 int32)
|
|
|
|
func (self *Player) SetTabListHeaderFooter(header *pumpkin_plugin_text.TextComponent, footer *pumpkin_plugin_text.TextComponent) {
|
|
|
|
wasm_import_method_player_set_tab_list_header_footer((self).Handle(), (header).TakeHandle(), (footer).TakeHandle())
|
|
|
|
}
|
|
|
|
//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.set-tab-list-order
|
|
func wasm_import_method_player_set_tab_list_order(arg0 int32, arg1 int32)
|
|
|
|
func (self *Player) SetTabListOrder(order int32) {
|
|
|
|
wasm_import_method_player_set_tab_list_order((self).Handle(), order)
|
|
|
|
}
|
|
|
|
//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.set-tab-list-latency
|
|
func wasm_import_method_player_set_tab_list_latency(arg0 int32, arg1 int32)
|
|
|
|
func (self *Player) SetTabListLatency(latency int32) {
|
|
|
|
wasm_import_method_player_set_tab_list_latency((self).Handle(), latency)
|
|
|
|
}
|
|
|
|
//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.set-tab-list-listed
|
|
func wasm_import_method_player_set_tab_list_listed(arg0 int32, arg1 int32)
|
|
|
|
func (self *Player) SetTabListListed(listed bool) {
|
|
|
|
var result int32
|
|
if listed {
|
|
result = 1
|
|
} else {
|
|
result = 0
|
|
}
|
|
wasm_import_method_player_set_tab_list_listed((self).Handle(), result)
|
|
|
|
}
|
|
|
|
//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.show-title
|
|
func wasm_import_method_player_show_title(arg0 int32, arg1 int32)
|
|
|
|
func (self *Player) ShowTitle(text *pumpkin_plugin_text.TextComponent) {
|
|
|
|
wasm_import_method_player_show_title((self).Handle(), (text).TakeHandle())
|
|
|
|
}
|
|
|
|
//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.show-subtitle
|
|
func wasm_import_method_player_show_subtitle(arg0 int32, arg1 int32)
|
|
|
|
func (self *Player) ShowSubtitle(text *pumpkin_plugin_text.TextComponent) {
|
|
|
|
wasm_import_method_player_show_subtitle((self).Handle(), (text).TakeHandle())
|
|
|
|
}
|
|
|
|
//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.show-actionbar
|
|
func wasm_import_method_player_show_actionbar(arg0 int32, arg1 int32)
|
|
|
|
func (self *Player) ShowActionbar(text *pumpkin_plugin_text.TextComponent) {
|
|
|
|
wasm_import_method_player_show_actionbar((self).Handle(), (text).TakeHandle())
|
|
|
|
}
|
|
|
|
//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.send-title-animation
|
|
func wasm_import_method_player_send_title_animation(arg0 int32, arg1 int32, arg2 int32, arg3 int32)
|
|
|
|
func (self *Player) SendTitleAnimation(fadeIn int32, stay int32, fadeOut int32) {
|
|
|
|
wasm_import_method_player_send_title_animation((self).Handle(), fadeIn, stay, fadeOut)
|
|
|
|
}
|
|
|
|
//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.teleport
|
|
func wasm_import_method_player_teleport(arg0 int32, arg1 float64, arg2 float64, arg3 float64, arg4 int32, arg5 float32, arg6 int32, arg7 float32, arg8 int32)
|
|
|
|
func (self *Player) Teleport(position witTypes.Tuple3[float64, float64, float64], yaw witTypes.Option[float32], pitch witTypes.Option[float32], world *pumpkin_plugin_world.World) {
|
|
|
|
var option int32
|
|
var option0 float32
|
|
switch yaw.Tag() {
|
|
case witTypes.OptionNone:
|
|
|
|
option = int32(0)
|
|
option0 = 0
|
|
case witTypes.OptionSome:
|
|
payload := yaw.Some()
|
|
|
|
option = int32(1)
|
|
option0 = payload
|
|
default:
|
|
panic("unreachable")
|
|
}
|
|
var option1 int32
|
|
var option2 float32
|
|
switch pitch.Tag() {
|
|
case witTypes.OptionNone:
|
|
|
|
option1 = int32(0)
|
|
option2 = 0
|
|
case witTypes.OptionSome:
|
|
payload := pitch.Some()
|
|
|
|
option1 = int32(1)
|
|
option2 = payload
|
|
default:
|
|
panic("unreachable")
|
|
}
|
|
wasm_import_method_player_teleport((self).Handle(), (position).F0, (position).F1, (position).F2, option, option0, option1, option2, (world).TakeHandle())
|
|
|
|
}
|
|
|
|
//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.teleport-world
|
|
func wasm_import_method_player_teleport_world(arg0 int32, arg1 int32, arg2 float64, arg3 float64, arg4 float64, arg5 int32, arg6 float32, arg7 int32, arg8 float32)
|
|
|
|
func (self *Player) TeleportWorld(worldRef *pumpkin_plugin_world.World, position witTypes.Tuple3[float64, float64, float64], yaw witTypes.Option[float32], pitch witTypes.Option[float32]) {
|
|
|
|
var option int32
|
|
var option0 float32
|
|
switch yaw.Tag() {
|
|
case witTypes.OptionNone:
|
|
|
|
option = int32(0)
|
|
option0 = 0
|
|
case witTypes.OptionSome:
|
|
payload := yaw.Some()
|
|
|
|
option = int32(1)
|
|
option0 = payload
|
|
default:
|
|
panic("unreachable")
|
|
}
|
|
var option1 int32
|
|
var option2 float32
|
|
switch pitch.Tag() {
|
|
case witTypes.OptionNone:
|
|
|
|
option1 = int32(0)
|
|
option2 = 0
|
|
case witTypes.OptionSome:
|
|
payload := pitch.Some()
|
|
|
|
option1 = int32(1)
|
|
option2 = payload
|
|
default:
|
|
panic("unreachable")
|
|
}
|
|
wasm_import_method_player_teleport_world((self).Handle(), (worldRef).TakeHandle(), (position).F0, (position).F1, (position).F2, option, option0, option1, option2)
|
|
|
|
}
|
|
|
|
//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.kick
|
|
func wasm_import_method_player_kick(arg0 int32, arg1 int32)
|
|
|
|
func (self *Player) Kick(message *pumpkin_plugin_text.TextComponent) {
|
|
|
|
wasm_import_method_player_kick((self).Handle(), (message).TakeHandle())
|
|
|
|
}
|
|
|
|
//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.respawn
|
|
func wasm_import_method_player_respawn(arg0 int32)
|
|
|
|
func (self *Player) Respawn() {
|
|
|
|
wasm_import_method_player_respawn((self).Handle())
|
|
|
|
}
|
|
|
|
//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.open-gui
|
|
func wasm_import_method_player_open_gui(arg0 int32, arg1 int32)
|
|
|
|
func (self *Player) OpenGui(guiRef *pumpkin_plugin_gui.Gui) {
|
|
|
|
wasm_import_method_player_open_gui((self).Handle(), (guiRef).TakeHandle())
|
|
|
|
}
|
|
|
|
//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.ban
|
|
func wasm_import_method_player_ban(arg0 int32, arg1 int32, arg2 int32)
|
|
|
|
func (self *Player) Ban(reason witTypes.Option[*pumpkin_plugin_text.TextComponent]) {
|
|
|
|
var option int32
|
|
var option0 int32
|
|
switch reason.Tag() {
|
|
case witTypes.OptionNone:
|
|
|
|
option = int32(0)
|
|
option0 = 0
|
|
case witTypes.OptionSome:
|
|
payload := reason.Some()
|
|
|
|
option = int32(1)
|
|
option0 = (payload).TakeHandle()
|
|
default:
|
|
panic("unreachable")
|
|
}
|
|
wasm_import_method_player_ban((self).Handle(), option, option0)
|
|
|
|
}
|
|
|
|
//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.ban-ip
|
|
func wasm_import_method_player_ban_ip(arg0 int32, arg1 int32, arg2 int32)
|
|
|
|
func (self *Player) BanIp(reason witTypes.Option[*pumpkin_plugin_text.TextComponent]) {
|
|
|
|
var option int32
|
|
var option0 int32
|
|
switch reason.Tag() {
|
|
case witTypes.OptionNone:
|
|
|
|
option = int32(0)
|
|
option0 = 0
|
|
case witTypes.OptionSome:
|
|
payload := reason.Some()
|
|
|
|
option = int32(1)
|
|
option0 = (payload).TakeHandle()
|
|
default:
|
|
panic("unreachable")
|
|
}
|
|
wasm_import_method_player_ban_ip((self).Handle(), option, option0)
|
|
|
|
}
|
|
|
|
//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.get-selected-slot
|
|
func wasm_import_method_player_get_selected_slot(arg0 int32) int32
|
|
|
|
func (self *Player) GetSelectedSlot() uint8 {
|
|
|
|
result := wasm_import_method_player_get_selected_slot((self).Handle())
|
|
return uint8(result)
|
|
|
|
}
|
|
|
|
//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.get-item-in-hand
|
|
func wasm_import_method_player_get_item_in_hand(arg0 int32, arg1 int32, arg2 uintptr)
|
|
|
|
func (self *Player) GetItemInHand(hand pumpkin_plugin_common.Hand) witTypes.Option[pumpkin_plugin_common.ItemStack] {
|
|
pinner := &runtime.Pinner{}
|
|
defer pinner.Unpin()
|
|
|
|
returnArea := uintptr(witRuntime.Allocate(pinner, (4 * 4), 4))
|
|
wasm_import_method_player_get_item_in_hand((self).Handle(), int32(hand), returnArea)
|
|
var option witTypes.Option[pumpkin_plugin_common.ItemStack]
|
|
switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
|
|
case 0:
|
|
|
|
option = witTypes.None[pumpkin_plugin_common.ItemStack]()
|
|
case 1:
|
|
value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4))))
|
|
|
|
option = witTypes.Some[pumpkin_plugin_common.ItemStack](pumpkin_plugin_common.ItemStack{value, uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4)))))})
|
|
default:
|
|
panic("unreachable")
|
|
}
|
|
result := option
|
|
return result
|
|
|
|
}
|
|
|
|
//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.get-inventory-item
|
|
func wasm_import_method_player_get_inventory_item(arg0 int32, arg1 int32, arg2 uintptr)
|
|
|
|
func (self *Player) GetInventoryItem(slot uint8) witTypes.Option[pumpkin_plugin_common.ItemStack] {
|
|
pinner := &runtime.Pinner{}
|
|
defer pinner.Unpin()
|
|
|
|
returnArea := uintptr(witRuntime.Allocate(pinner, (4 * 4), 4))
|
|
wasm_import_method_player_get_inventory_item((self).Handle(), int32(slot), returnArea)
|
|
var option witTypes.Option[pumpkin_plugin_common.ItemStack]
|
|
switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
|
|
case 0:
|
|
|
|
option = witTypes.None[pumpkin_plugin_common.ItemStack]()
|
|
case 1:
|
|
value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4))))
|
|
|
|
option = witTypes.Some[pumpkin_plugin_common.ItemStack](pumpkin_plugin_common.ItemStack{value, uint8(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4)))))})
|
|
default:
|
|
panic("unreachable")
|
|
}
|
|
result := option
|
|
return result
|
|
|
|
}
|
|
|
|
//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.get-health
|
|
func wasm_import_method_player_get_health(arg0 int32) float32
|
|
|
|
func (self *Player) GetHealth() float32 {
|
|
|
|
result := wasm_import_method_player_get_health((self).Handle())
|
|
return result
|
|
|
|
}
|
|
|
|
//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.set-health
|
|
func wasm_import_method_player_set_health(arg0 int32, arg1 float32)
|
|
|
|
func (self *Player) SetHealth(health float32) {
|
|
|
|
wasm_import_method_player_set_health((self).Handle(), health)
|
|
|
|
}
|
|
|
|
//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.get-max-health
|
|
func wasm_import_method_player_get_max_health(arg0 int32) float32
|
|
|
|
func (self *Player) GetMaxHealth() float32 {
|
|
|
|
result := wasm_import_method_player_get_max_health((self).Handle())
|
|
return result
|
|
|
|
}
|
|
|
|
//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.set-max-health
|
|
func wasm_import_method_player_set_max_health(arg0 int32, arg1 float32)
|
|
|
|
func (self *Player) SetMaxHealth(maxHealth float32) {
|
|
|
|
wasm_import_method_player_set_max_health((self).Handle(), maxHealth)
|
|
|
|
}
|
|
|
|
//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.get-food-level
|
|
func wasm_import_method_player_get_food_level(arg0 int32) int32
|
|
|
|
func (self *Player) GetFoodLevel() uint8 {
|
|
|
|
result := wasm_import_method_player_get_food_level((self).Handle())
|
|
return uint8(result)
|
|
|
|
}
|
|
|
|
//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.set-food-level
|
|
func wasm_import_method_player_set_food_level(arg0 int32, arg1 int32)
|
|
|
|
func (self *Player) SetFoodLevel(foodLevel uint8) {
|
|
|
|
wasm_import_method_player_set_food_level((self).Handle(), int32(foodLevel))
|
|
|
|
}
|
|
|
|
//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.get-saturation
|
|
func wasm_import_method_player_get_saturation(arg0 int32) float32
|
|
|
|
func (self *Player) GetSaturation() float32 {
|
|
|
|
result := wasm_import_method_player_get_saturation((self).Handle())
|
|
return result
|
|
|
|
}
|
|
|
|
//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.set-saturation
|
|
func wasm_import_method_player_set_saturation(arg0 int32, arg1 float32)
|
|
|
|
func (self *Player) SetSaturation(saturation float32) {
|
|
|
|
wasm_import_method_player_set_saturation((self).Handle(), saturation)
|
|
|
|
}
|
|
|
|
//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.get-exhaustion
|
|
func wasm_import_method_player_get_exhaustion(arg0 int32) float32
|
|
|
|
func (self *Player) GetExhaustion() float32 {
|
|
|
|
result := wasm_import_method_player_get_exhaustion((self).Handle())
|
|
return result
|
|
|
|
}
|
|
|
|
//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.set-exhaustion
|
|
func wasm_import_method_player_set_exhaustion(arg0 int32, arg1 float32)
|
|
|
|
func (self *Player) SetExhaustion(exhaustion float32) {
|
|
|
|
wasm_import_method_player_set_exhaustion((self).Handle(), exhaustion)
|
|
|
|
}
|
|
|
|
//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.get-absorption
|
|
func wasm_import_method_player_get_absorption(arg0 int32) float32
|
|
|
|
func (self *Player) GetAbsorption() float32 {
|
|
|
|
result := wasm_import_method_player_get_absorption((self).Handle())
|
|
return result
|
|
|
|
}
|
|
|
|
//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.set-absorption
|
|
func wasm_import_method_player_set_absorption(arg0 int32, arg1 float32)
|
|
|
|
func (self *Player) SetAbsorption(absorption float32) {
|
|
|
|
wasm_import_method_player_set_absorption((self).Handle(), absorption)
|
|
|
|
}
|
|
|
|
//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.get-experience-level
|
|
func wasm_import_method_player_get_experience_level(arg0 int32) int32
|
|
|
|
func (self *Player) GetExperienceLevel() int32 {
|
|
|
|
result := wasm_import_method_player_get_experience_level((self).Handle())
|
|
return result
|
|
|
|
}
|
|
|
|
//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.get-experience-progress
|
|
func wasm_import_method_player_get_experience_progress(arg0 int32) float32
|
|
|
|
func (self *Player) GetExperienceProgress() float32 {
|
|
|
|
result := wasm_import_method_player_get_experience_progress((self).Handle())
|
|
return result
|
|
|
|
}
|
|
|
|
//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.get-experience-points
|
|
func wasm_import_method_player_get_experience_points(arg0 int32) int32
|
|
|
|
func (self *Player) GetExperiencePoints() int32 {
|
|
|
|
result := wasm_import_method_player_get_experience_points((self).Handle())
|
|
return result
|
|
|
|
}
|
|
|
|
//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.set-experience-level
|
|
func wasm_import_method_player_set_experience_level(arg0 int32, arg1 int32)
|
|
|
|
func (self *Player) SetExperienceLevel(level int32) {
|
|
|
|
wasm_import_method_player_set_experience_level((self).Handle(), level)
|
|
|
|
}
|
|
|
|
//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.set-experience-progress
|
|
func wasm_import_method_player_set_experience_progress(arg0 int32, arg1 float32)
|
|
|
|
func (self *Player) SetExperienceProgress(progress float32) {
|
|
|
|
wasm_import_method_player_set_experience_progress((self).Handle(), progress)
|
|
|
|
}
|
|
|
|
//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.set-experience-points
|
|
func wasm_import_method_player_set_experience_points(arg0 int32, arg1 int32)
|
|
|
|
func (self *Player) SetExperiencePoints(points int32) {
|
|
|
|
wasm_import_method_player_set_experience_points((self).Handle(), points)
|
|
|
|
}
|
|
|
|
//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.add-experience-levels
|
|
func wasm_import_method_player_add_experience_levels(arg0 int32, arg1 int32)
|
|
|
|
func (self *Player) AddExperienceLevels(levels int32) {
|
|
|
|
wasm_import_method_player_add_experience_levels((self).Handle(), levels)
|
|
|
|
}
|
|
|
|
//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.add-experience-points
|
|
func wasm_import_method_player_add_experience_points(arg0 int32, arg1 int32)
|
|
|
|
func (self *Player) AddExperiencePoints(points int32) {
|
|
|
|
wasm_import_method_player_add_experience_points((self).Handle(), points)
|
|
|
|
}
|
|
|
|
//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.is-flying
|
|
func wasm_import_method_player_is_flying(arg0 int32) int32
|
|
|
|
func (self *Player) IsFlying() bool {
|
|
|
|
result := wasm_import_method_player_is_flying((self).Handle())
|
|
return (result != 0)
|
|
|
|
}
|
|
|
|
//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.set-flying
|
|
func wasm_import_method_player_set_flying(arg0 int32, arg1 int32)
|
|
|
|
func (self *Player) SetFlying(flying bool) {
|
|
|
|
var result int32
|
|
if flying {
|
|
result = 1
|
|
} else {
|
|
result = 0
|
|
}
|
|
wasm_import_method_player_set_flying((self).Handle(), result)
|
|
|
|
}
|
|
|
|
//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.get-abilities
|
|
func wasm_import_method_player_get_abilities(arg0 int32, arg1 uintptr)
|
|
|
|
func (self *Player) GetAbilities() PlayerAbilities {
|
|
pinner := &runtime.Pinner{}
|
|
defer pinner.Unpin()
|
|
|
|
returnArea := uintptr(witRuntime.Allocate(pinner, 16, 4))
|
|
wasm_import_method_player_get_abilities((self).Handle(), returnArea)
|
|
result := PlayerAbilities{(uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) != 0), (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 1))) != 0), (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 2))) != 0), (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 3))) != 0), (uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))) != 0), *(*float32)(unsafe.Add(unsafe.Pointer(returnArea), 8)), *(*float32)(unsafe.Add(unsafe.Pointer(returnArea), 12))}
|
|
return result
|
|
|
|
}
|
|
|
|
//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.set-abilities
|
|
func wasm_import_method_player_set_abilities(arg0 int32, arg1 int32, arg2 int32, arg3 int32, arg4 int32, arg5 int32, arg6 float32, arg7 float32)
|
|
|
|
func (self *Player) SetAbilities(abilities PlayerAbilities) {
|
|
|
|
var result int32
|
|
if (abilities).Invulnerable {
|
|
result = 1
|
|
} else {
|
|
result = 0
|
|
}
|
|
var result0 int32
|
|
if (abilities).Flying {
|
|
result0 = 1
|
|
} else {
|
|
result0 = 0
|
|
}
|
|
var result1 int32
|
|
if (abilities).AllowFlying {
|
|
result1 = 1
|
|
} else {
|
|
result1 = 0
|
|
}
|
|
var result2 int32
|
|
if (abilities).Creative {
|
|
result2 = 1
|
|
} else {
|
|
result2 = 0
|
|
}
|
|
var result3 int32
|
|
if (abilities).AllowModifyWorld {
|
|
result3 = 1
|
|
} else {
|
|
result3 = 0
|
|
}
|
|
wasm_import_method_player_set_abilities((self).Handle(), result, result0, result1, result2, result3, (abilities).FlySpeed, (abilities).WalkSpeed)
|
|
|
|
}
|
|
|
|
//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.get-ip
|
|
func wasm_import_method_player_get_ip(arg0 int32, arg1 uintptr)
|
|
|
|
func (self *Player) GetIp() string {
|
|
pinner := &runtime.Pinner{}
|
|
defer pinner.Unpin()
|
|
|
|
returnArea := uintptr(witRuntime.Allocate(pinner, (2 * 4), 4))
|
|
wasm_import_method_player_get_ip((self).Handle(), returnArea)
|
|
value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4)))
|
|
result := value
|
|
return result
|
|
|
|
}
|
|
|
|
//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.get-skin
|
|
func wasm_import_method_player_get_skin(arg0 int32, arg1 uintptr)
|
|
|
|
func (self *Player) GetSkin() witTypes.Option[PlayerSkin] {
|
|
pinner := &runtime.Pinner{}
|
|
defer pinner.Unpin()
|
|
|
|
returnArea := uintptr(witRuntime.Allocate(pinner, (6 * 4), 4))
|
|
wasm_import_method_player_get_skin((self).Handle(), returnArea)
|
|
var option1 witTypes.Option[PlayerSkin]
|
|
switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
|
|
case 0:
|
|
|
|
option1 = witTypes.None[PlayerSkin]()
|
|
case 1:
|
|
value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4))))
|
|
var option witTypes.Option[string]
|
|
switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (3 * 4)))) {
|
|
case 0:
|
|
|
|
option = witTypes.None[string]()
|
|
case 1:
|
|
value0 := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (4 * 4)))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (5 * 4))))
|
|
|
|
option = witTypes.Some[string](value0)
|
|
default:
|
|
panic("unreachable")
|
|
}
|
|
|
|
option1 = witTypes.Some[PlayerSkin](PlayerSkin{value, option})
|
|
default:
|
|
panic("unreachable")
|
|
}
|
|
result := option1
|
|
return result
|
|
|
|
}
|
|
|
|
//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.get-skin-parts
|
|
func wasm_import_method_player_get_skin_parts(arg0 int32) int32
|
|
|
|
func (self *Player) GetSkinParts() SkinParts {
|
|
|
|
result := wasm_import_method_player_get_skin_parts((self).Handle())
|
|
return uint8(result)
|
|
|
|
}
|
|
|
|
//go:wasmimport pumpkin:plugin/player@0.1.0 [method]player.set-skin-parts
|
|
func wasm_import_method_player_set_skin_parts(arg0 int32, arg1 int32)
|
|
|
|
func (self *Player) SetSkinParts(parts SkinParts) {
|
|
|
|
wasm_import_method_player_set_skin_parts((self).Handle(), int32(parts))
|
|
|
|
}
|