Pumpkin-MC/pumpkin-plugin-wit
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

first commit

Browse Source
This commit is contained in:
Alexander Medvedev 2026-05-19 17:43:50 +02:00
commit 41d8c71c65
32 changed files with 6765 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

400
v0.1/bedrock-packets.wit Normal file
View File

@ -0,0 +1,400 @@
package pumpkin:plugin@0.1.0;
interface bedrock-packets {
use uuid.{ uuid };
record s-animate {
action: string,
runtime-entity-id: string,
boat-rowing-time: option<f32>,
}
record s-client-cache-status {
cache-supported: bool,
}
record s-command-request {
command: string,
command-type: string,
command-uuid: uuid,
request-id: string,
player-actor-unique-id: s64,
is-internal-source: bool,
version: string,
}
record s-container-close {
container-id: u8,
container-type: u8,
server-initiated: bool,
}
record s-interaction {
action: string,
target-runtime-id: string,
position: option<tuple<f64, f64, f64>>,
}
record s-loading-screen {
status: s32,
id: option<s32>,
}
record s-login {
protocol-version: s32,
jwt: list<u8>,
raw-token: list<u8>,
}
record s-modal-form-response {
form-id: s32,
form-data: option<string>,
}
record s-player-action {
runtime-id: s32,
action: string,
block-pos: tuple<s32, s32, s32>,
result-pos: tuple<s32, s32, s32>,
face: s32,
}
record s-player-auth-input {
pitch: f32,
yaw: f32,
position: tuple<f64, f64, f64>,
move-vec: string,
head-yaw: f32,
input-data: string,
input-mode: s32,
play-mode: s32,
interaction-model: s32,
interact-pitch: f32,
interact-yaw: f32,
tick: string,
delta: tuple<f64, f64, f64>,
block-actions: option<list<string>>,
vehicle-rotation: option<string>,
vehicle-unique-id: option<string>,
analog-move: string,
camera-orientation: tuple<f64, f64, f64>,
raw-move: string,
}
record s-connected-ping {
time: s64,
}
record s-connection-request {
client-guid: s64,
time: s64,
security: bool,
}
record s-new-incoming-connection {
server-address: string,
internal-address: string,
ping-time: s64,
pong-time: s64,
}
record s-open-connection-request1 {
magic: string,
protocol-version: u8,
mtu: s32,
}
record s-open-connection-request2 {
magic: string,
server-address: string,
mtu: s32,
client-guid: s64,
}
record s-unconnected-ping {
time: s64,
magic: string,
client-guid: s64,
}
record s-request-chunk-radius {
chunk-radius: s32,
max-radius: u8,
}
record s-request-network-settings {
protocol-version: s32,
}
record s-resource-pack-response {
response: u8,
download-size: s32,
}
record s-set-local-player-as-initialized {
runtime-entity-id: string,
}
record s-text {
needs-translation: bool,
r-type: string,
source-name: string,
message: string,
parameters: list<string>,
xuid: string,
platform-chat-id: string,
filtered-message: option<string>,
}
record c-available-commands {
enum-values: list<string>,
chained-subcommand-values: list<string>,
suffixes: list<string>,
enums: list<string>,
chained-subcommands: list<string>,
commands: list<string>,
soft-enums: list<string>,
constraints: list<string>,
}
record c-chunk-radius-update {
chunk-radius: s32,
}
record c-container-open {
container-id: u8,
container-type: u8,
position: tuple<s32, s32, s32>,
target-entity-id: string,
}
record c-correct-player-move {
prediction-type: u8,
pos: tuple<f64, f64, f64>,
pos-delta: tuple<f64, f64, f64>,
on-ground: bool,
tick: string,
}
record creative-content {
groups: list<string>,
entries: list<string>,
}
record c-disconnect-player {
reason: s32,
skip-message: bool,
message: string,
filtered-message: string,
}
record c-gamerules-changed {
rule-data: string,
}
record c-handshake {
jwt-data: string,
}
record c-inventory-content {
inventory-id: s32,
slots: list<string>,
container-name: u8,
dynamic-id: option<s32>,
storage-item: string,
}
record c-level-chunk {
dimension: s32,
cache-enabled: bool,
chunk: string,
}
record c-level-event {
event-id: s32,
position: tuple<f64, f64, f64>,
data: s32,
}
record c-modal-form-request {
form-id: s32,
form-data: string,
}
record c-move-player {
player-runtime-id: string,
position: tuple<f64, f64, f64>,
pitch: f32,
yaw: f32,
head-yaw: f32,
mode: u8,
on-ground: bool,
riding-runtime-id: string,
tick: string,
}
record c-network-chunk-publisher-update {
pos-for-view: tuple<s32, s32, s32>,
new-radius: s32,
server-build-chunk-list: list<string>,
}
record c-network-settings {
compression-threshold: s32,
compression-method: s32,
client-throttle-enabled: bool,
client-throttle-threshold: u8,
client-throttle-scalar: f32,
}
record c-player-hotbar {
selected-slot: s32,
container-id: u8,
should-select-block: bool,
}
record c-connected-pong {
ping: s64,
pong: s64,
}
record c-connection-request-accepted {
client-address: string,
system-index: s32,
system-addresses: string,
requested-timestamp: s64,
timestamp: s64,
}
record c-incompatible-protocol-version {
protocol-version: u8,
magic: string,
server-guid: s64,
}
record c-open-connection-reply1 {
magic: string,
server-guid: s64,
has-server-security: bool,
mtu: s32,
}
record c-open-connection-reply2 {
magic: string,
server-guid: s64,
client-address: string,
mtu: s32,
security: bool,
}
record c-unconnected-pong {
time: s64,
server-guid: s64,
magic: string,
server-id: string,
}
record c-resource-pack-stack-packet {
resource-pack-required: bool,
resource-packs: list<string>,
game-version: string,
experiments: string,
include-editor-packs: bool,
}
record c-resource-packs-info {
resource-pack-required: bool,
has-addon-packs: bool,
has-scripts: bool,
is-vibrant-visuals-force-disabled: bool,
world-template-id: uuid,
world-template-version: string,
resource-packs: list<string>,
}
record c-set-actor-data {
actor-runtime-id: string,
metadata: string,
synced-properties: string,
tick: string,
}
record c-set-actor-motion {
target-runtime-id: string,
motion: tuple<f64, f64, f64>,
tick: string,
}
record c-set-health {
health: s32,
}
record c-set-player-gamemode {
gamemode: string,
}
record c-set-time {
time: s32,
}
record c-set-title {
action-type: s32,
text: string,
fade-in-duration: s32,
remain-duration: s32,
fade-out-duration: s32,
xuid: string,
platform-online-id: string,
filtered-message: string,
}
record c-start-game {
entity-id: string,
runtime-entity-id: string,
player-gamemode: string,
position: tuple<f64, f64, f64>,
pitch: f32,
yaw: f32,
level-settings: string,
level-id: string,
level-name: string,
premium-world-template-id: string,
is-trial: bool,
rewind-history-size: s32,
server-authoritative-block-breaking: bool,
current-level-time: s64,
enchantment-seed: s32,
block-properties-size: s32,
multiplayer-correlation-id: string,
enable-itemstack-net-manager: bool,
server-version: string,
compound-id: u8,
compound-len: s32,
compound-end: u8,
block-registry-checksum: s64,
world-template-id: uuid,
enable-clientside-generation: bool,
blocknetwork-ids-are-hashed: bool,
server-auth-sounds: bool,
server-join-information: option<string>,
telemetry: string,
}
record c-update-abilities {
target-player-raw-id: s64,
player-permission: u8,
command-permission: u8,
layers: list<string>,
}
record c-update-attributes {
runtime-id: string,
attributes: list<string>,
player-tick: string,
}
variant serverbound-packet {
s-animate(s-animate),
s-client-cache-status(s-client-cache-status),
s-command-request(s-command-request),
s-container-close(s-container-close),
s-interaction(s-interaction),
s-loading-screen(s-loading-screen),
s-login(s-login),
s-modal-form-response(s-modal-form-response),
s-player-action(s-player-action),
s-player-auth-input(s-player-auth-input),
s-connected-ping(s-connected-ping),
s-connection-request(s-connection-request),
s-new-incoming-connection(s-new-incoming-connection),
s-disconnect,
s-open-connection-request1(s-open-connection-request1),
s-open-connection-request2(s-open-connection-request2),
s-unconnected-ping(s-unconnected-ping),
s-request-chunk-radius(s-request-chunk-radius),
s-request-network-settings(s-request-network-settings),
s-resource-pack-response(s-resource-pack-response),
s-set-local-player-as-initialized(s-set-local-player-as-initialized),
s-text(s-text),
}
variant clientbound-packet {
c-available-commands(c-available-commands),
c-chunk-radius-update(c-chunk-radius-update),
c-container-open(c-container-open),
c-correct-player-move(c-correct-player-move),
creative-content(creative-content),
c-disconnect-player(c-disconnect-player),
c-gamerules-changed(c-gamerules-changed),
c-handshake(c-handshake),
c-inventory-content(c-inventory-content),
c-level-chunk(c-level-chunk),
c-level-event(c-level-event),
c-modal-form-request(c-modal-form-request),
c-move-player(c-move-player),
c-network-chunk-publisher-update(c-network-chunk-publisher-update),
c-network-settings(c-network-settings),
c-player-hotbar(c-player-hotbar),
c-connected-pong(c-connected-pong),
c-connection-request-accepted(c-connection-request-accepted),
c-incompatible-protocol-version(c-incompatible-protocol-version),
c-open-connection-reply1(c-open-connection-reply1),
c-open-connection-reply2(c-open-connection-reply2),
c-unconnected-pong(c-unconnected-pong),
c-resource-pack-stack-packet(c-resource-pack-stack-packet),
c-resource-packs-info(c-resource-packs-info),
c-set-actor-data(c-set-actor-data),
c-set-actor-motion(c-set-actor-motion),
c-set-health(c-set-health),
c-set-player-gamemode(c-set-player-gamemode),
c-set-time(c-set-time),
c-set-title(c-set-title),
c-start-game(c-start-game),
c-update-abilities(c-update-abilities),
c-update-attributes(c-update-attributes),
}
}

71
v0.1/biomes.wit Normal file
View File

@ -0,0 +1,71 @@
package pumpkin:plugin@0.1.0;
interface biomes {
enum biome {
badlands,
bamboo-jungle,
basalt-deltas,
beach,
birch-forest,
cherry-grove,
cold-ocean,
crimson-forest,
dark-forest,
deep-cold-ocean,
deep-dark,
deep-frozen-ocean,
deep-lukewarm-ocean,
deep-ocean,
desert,
dripstone-caves,
end-barrens,
end-highlands,
end-midlands,
eroded-badlands,
flower-forest,
forest,
frozen-ocean,
frozen-peaks,
frozen-river,
grove,
ice-spikes,
jagged-peaks,
jungle,
lukewarm-ocean,
lush-caves,
mangrove-swamp,
meadow,
mushroom-fields,
nether-wastes,
ocean,
old-growth-birch-forest,
old-growth-pine-taiga,
old-growth-spruce-taiga,
pale-garden,
plains,
river,
savanna,
savanna-plateau,
small-end-islands,
snowy-beach,
snowy-plains,
snowy-slopes,
snowy-taiga,
soul-sand-valley,
sparse-jungle,
stony-peaks,
stony-shore,
sunflower-plains,
swamp,
taiga,
the-end,
the-void,
warm-ocean,
warped-forest,
windswept-forest,
windswept-gravelly-hills,
windswept-hills,
windswept-savanna,
wooded-badlands,
}
}

84
v0.1/block-entity.wit Normal file
View File

@ -0,0 +1,84 @@
interface block-entity {
use common.{block-pos};
resource block-entity {
resource-location: func() -> string;
get-position: func() -> block-pos;
get-id: func() -> u32;
is-dirty: func() -> bool;
clear-dirty: func();
}
resource command-block-entity {
get-block-entity: func () -> block-entity;
last-output: func() -> string;
track-output: func() -> bool;
success-count: func() -> u32;
command: func() -> string;
auto: func() -> bool;
condition-met: func() -> bool;
powered: func() -> bool;
}
enum dye-color {
white,
orange,
magenta,
light-blue,
yellow,
lime,
pink,
gray,
light-gray,
cyan,
purple,
blue,
brown,
green,
red,
black,
}
record sign-text {
messages: list<string>,
color: dye-color,
has-glowing-text: bool,
}
resource sign-block-entity {
get-block-entity: func() -> block-entity;
get-front-text: func() -> sign-text;
set-front-text: func(text: sign-text);
get-back-text: func() -> sign-text;
set-back-text: func(text: sign-text);
is-waxed: func() -> bool;
set-waxed: func(waxed: bool);
}
resource jukebox-block-entity {
get-block-entity: func() -> block-entity;
is-playing: func() -> bool;
stop-playing: func();
start-playing: func(length-in-ticks: u64);
}
resource chest-block-entity {
get-block-entity: func() -> block-entity;
viewer-count: func() -> u32;
}
resource mob-spawner-block-entity {
get-block-entity: func() -> block-entity;
get-spawn-count: func() -> s32;
get-spawn-range: func() -> s32;
get-delay: func() -> s32;
}
variant block-entity-type {
command-block-entity(command-block-entity),
sign-block-entity(sign-block-entity),
jukebox-block-entity(jukebox-block-entity),
chest-block-entity(chest-block-entity),
mob-spawner-block-entity(mob-spawner-block-entity),
}
}

83
v0.1/boss-bar.wit Normal file
View File

@ -0,0 +1,83 @@
interface boss-bar {
use text.{text-component};
use player.{player};
/// Represents the color of a boss bar.
enum boss-bar-color {
pink,
blue,
red,
green,
yellow,
purple,
white,
}
/// Represents the notches/divisions of a boss bar.
enum boss-bar-division {
no-division,
notches-6,
notches-10,
notches-12,
notches-20,
}
/// Metadata flags that can be toggled on a boss bar.
record boss-bar-metadata {
/// Darkens the sky for players who see the boss bar.
darken-sky: bool,
/// If true, the bar is considered a "dragon bar" (used for Ender Dragon).
dragon-bar: bool,
/// If true, fog is created around the players who see the boss bar.
create-fog: bool,
}
/// Represents a boss bar that can be shown to players.
resource boss-bar {
/// Creates a new boss bar.
constructor(title: text-component, color: boss-bar-color, division: boss-bar-division);
/// Returns the title of this boss bar.
get-title: func() -> text-component;
/// Sets the title of this boss bar.
set-title: func(title: text-component);
/// Returns the health (0.0 to 1.0) of this boss bar.
get-health: func() -> f32;
/// Sets the health (0.0 to 1.0) of this boss bar.
set-health: func(health: f32);
/// Returns the color of this boss bar.
get-color: func() -> boss-bar-color;
/// Sets the color of this boss bar.
set-color: func(color: boss-bar-color);
/// Returns the division of this boss bar.
get-division: func() -> boss-bar-division;
/// Sets the division of this boss bar.
set-division: func(division: boss-bar-division);
/// Returns the currently active metadata on this boss bar.
get-metadata: func() -> boss-bar-metadata;
/// Updates the metadata on this boss bar.
set-metadata: func(metadata: boss-bar-metadata);
/// Adds a player to this boss bar, making it visible to them.
add-player: func(player: player);
/// Removes a player from this boss bar, hiding it from them.
remove-player: func(player: player);
/// Returns a list of all players currently seeing this boss bar.
get-players: func() -> list<player>;
/// Removes this boss bar from all players and cleans it up.
remove-all: func();
}
}

224
v0.1/command.wit Normal file
View File

@ -0,0 +1,224 @@
interface command {
use %world.{%world, entity};
use player.{player};
use block-entity.{command-block-entity};
use common.{position, block-pos, locale, game-mode};
use item-stack.{item-stack};
use server.{server, difficulty};
use text.{text-component};
variant command-error {
invalid-consumption(option<string>),
invalid-requirement,
permission-denied,
command-failed(text-component),
}
resource command-node {
literal: static func(name: string) -> command-node;
argument: static func(name: string, %type: argument-type) -> command-node;
then: func(node: command-node);
execute-with-handler-id: func(handler-id: u32);
require-with-handler-id: func(handler-id: u32);
}
variant argument-type {
%bool,
float(tuple<option<f32>, option<f32>>),
double(tuple<option<f64>, option<f64>>),
integer(tuple<option<s32>, option<s32>>),
long(tuple<option<s64>, option<s64>>),
%string(string-type),
entities,
entity,
players,
game-profile,
block-pos,
column-pos,
position3d,
position2d,
block-state,
block-predicate,
item,
item-predicate,
color,
component,
style,
message,
nbt-compound-tag,
nbt-tag,
nbt-path,
objective,
objective-criteria,
operation,
particle,
angle,
rotation,
scoreboard-slot,
score-holder(bool),
swizzle,
team,
item-slot,
resource-location,
mob-effect,
function,
entity-anchor,
int-range,
float-range,
dimension,
gamemode,
difficulty,
time(option<s32>),
%resource(string),
resource-or-tag(string),
resource-or-tag-key(string),
resource-key(string),
template-mirror,
template-rotation,
uuid,
}
record entity-argument {
single: bool,
players-only: bool,
}
variant command-sender-type {
rcon,
console,
player(player),
command-block(tuple<command-block-entity, %world>),
dummy,
}
enum permission-level {
zero,
one,
two,
three,
four,
}
resource command-sender {
get-command-sender-type: func() -> command-sender-type;
get-name: func() -> string;
send-message: func(text: text-component);
send-system-message: func(text: text-component);
send-error: func(text: text-component);
set-success-count: func(count: s32);
is-player: func() -> bool;
is-console: func() -> bool;
as-player: func() -> option<player>;
permission-level: func() -> permission-level;
has-permission-level: func(level: permission-level) -> bool;
has-permission: func(server: borrow<server>, node: string) -> bool;
position: func() -> option<position>;
%world: func() -> option<%world>;
get-locale: func() -> locale;
should-receive-feedback: func() -> bool;
should-broadcast-console-to-ops: func() -> bool;
should-track-output: func() -> bool;
}
enum string-type {
single-word,
quotable,
greedy,
}
enum suggestion-type {
ask-server,
all-recipes,
available-sounds,
available-biomes,
summonable-entities,
}
variant arg {
simple(string),
msg(string),
%bool(bool),
item(string),
item-predicate(string),
resource-location(string),
block(string),
block-predicate(string),
time(s32),
num(result<number, not-in-bounds>),
block-pos(block-pos),
pos3d(tuple<f64, f64, f64>),
pos2d(tuple<f64, f64>),
rotation(tuple<f32, bool, f32, bool>),
gamemode(game-mode),
difficulty(difficulty),
players(list<player>),
particle(string),
text-component(text-component),
bossbar-color(bossbar-color),
bossbar-style(bossbar-style),
sound-category(sound-category),
damage-type(string),
effect(string),
enchantment(string),
entity-anchor(entity-anchor),
}
enum bossbar-color {
pink,
blue,
red,
green,
yellow,
purple,
white,
}
enum bossbar-style {
no-division,
notches6,
notches10,
notches12,
notches20,
}
enum sound-category {
master,
music,
records,
weather,
blocks,
hostile,
neutral,
players,
ambient,
voice,
}
enum entity-anchor {
eyes,
feet,
}
variant number {
float64(f64),
float32(f32),
int32(s32),
int64(s64),
}
variant not-in-bounds {
lower-bound(tuple<number, number>),
upper-bound(tuple<number, number>),
}
resource consumed-args {
get-value: func(key: string) -> arg;
}
resource command {
/// First name is primary, rest are aliases
constructor(names: list<string>, description: string);
then: func(node: command-node);
execute-with-handler-id: func(handler-id: u32);
}
}

233
v0.1/common.wit Normal file
View File

@ -0,0 +1,233 @@
/// Provides common types and utilities used across the entire plugin API.
interface common {
/// Serialized text component as a postcard byte array.
/// @deprecated Use the text-component resource from the text interface instead.
type raw-text-component = list<u8>;
/// A position in the world grid (integers).
record block-pos {
x: s32,
y: s32,
z: s32,
}
/// A precise coordinate in the world (floats).
type position = tuple<f64, f64, f64>;
/// Represents the hands of a player.
enum hand {
left,
right,
}
/// Represents the game modes available in Minecraft.
enum game-mode {
survival,
creative,
adventure,
spectator,
}
/// The 16 base Minecraft colors.
enum named-color {
black,
dark-blue,
dark-green,
dark-aqua,
dark-red,
dark-purple,
gold,
gray,
dark-gray,
blue,
green,
aqua,
red,
light-purple,
yellow,
white,
}
/// An RGB color represented by its red, green, and blue components.
record rgb-color {
r: u8,
g: u8,
b: u8,
}
/// An ARGB color with alpha (transparency) channel.
record argb-color {
a: u8,
r: u8,
g: u8,
b: u8,
}
/// Represents the type of click interaction in a GUI.
enum click-type {
left,
right,
shift-left,
shift-right,
middle,
drop,
control-drop,
double-click,
number-key,
unknown,
}
/// Represents the various poses an entity can be in.
enum entity-pose {
standing,
fall-flying,
sleeping,
swimming,
spin-attack,
crouching,
long-jumping,
dying,
croaking,
using-tongue,
sitting,
roaring,
sniffing,
emerging,
digging,
sliding,
shooting,
inhaling,
}
/// All Minecraft-supported locales.
enum locale {
af-za,
ar-sa,
ast-es,
az-az,
ba-ru,
bar,
be-by,
bg-bg,
br-fr,
brb,
bs-ba,
ca-es,
cs-cz,
cy-gb,
da-dk,
de-at,
de-ch,
de-de,
el-gr,
en-au,
en-ca,
en-gb,
en-nz,
en-pt,
en-ud,
en-us,
enp,
enws,
eo-uy,
es-ar,
es-cl,
es-ec,
es-es,
es-mx,
es-uy,
es-ve,
esan,
et-ee,
eu-es,
fa-ir,
fi-fi,
fil-ph,
fo-fo,
fr-ca,
fr-fr,
fra-de,
fur-it,
fy-nl,
ga-ie,
gd-gb,
gl-es,
haw-us,
he-il,
hi-in,
hr-hr,
hu-hu,
hy-am,
id-id,
ig-ng,
io-en,
is-is,
isv,
it-it,
ja-jp,
jbo-en,
ka-ge,
kk-kz,
kn-in,
ko-kr,
ksh,
kw-gb,
la-la,
lb-lu,
li-li,
lmo,
lo-la,
lol-us,
lt-lt,
lv-lv,
lzh,
mk-mk,
mn-mn,
ms-my,
mt-mt,
nah,
nds-de,
nl-be,
nl-nl,
nn-no,
no-no,
oc-fr,
ovd,
pl-pl,
pt-br,
pt-pt,
qya-aa,
ro-ro,
rpr,
ru-ru,
ry-ua,
sah-sah,
se-no,
sk-sk,
sl-si,
so-so,
sq-al,
sr-cs,
sr-sp,
sv-se,
sxu,
szl,
ta-in,
th-th,
tl-ph,
tlh-aa,
tok,
tr-tr,
tt-ru,
uk-ua,
val-es,
vec-it,
vi-vn,
yi-de,
yo-ng,
zh-cn,
zh-hk,
zh-tw,
zlm-arab,
}
}

33
v0.1/context.wit Normal file
View File

@ -0,0 +1,33 @@
/// The core context provided to a plugin during initialization and event handling.
interface context {
use server.{server};
use event.{event-type, event-priority};
use command.{command};
use permission.{permission};
/// A contextual handle for plugin-related operations.
resource context {
/// Registers a handler for a specific event.
///
/// * `handler-id`: Unique ID for the event handler.
/// * `event-type`: The type of event to listen for.
/// * `event-priority`: When this handler should be called relative to others.
/// * `blocking`: Whether the event should wait for this handler to finish.
register-event: func(handler-id: u32, event-type: event-type, event-priority: event-priority, blocking: bool);
/// Registers a new command.
///
/// * `command`: The command definition.
/// * `permission`: The required permission node to execute this command.
register-command: func(command: command, permission: string);
/// Registers a permission node with the server.
register-permission: func(permission: permission) -> result<_, string>;
/// Returns the path to the plugin's private data folder.
get-data-folder: func() -> string;
/// Returns the global server instance.
get-server: func() -> server;
}
}

116
v0.1/data-components.wit Normal file
View File

@ -0,0 +1,116 @@
package pumpkin:plugin@0.1.0;
interface data-components {
enum data-component {
custom-data,
max-stack-size,
max-damage,
damage,
unbreakable,
use-effects,
custom-name,
minimum-attack-charge,
damage-type,
item-name,
item-model,
lore,
rarity,
enchantments,
can-place-on,
can-break,
attribute-modifiers,
custom-model-data,
tooltip-display,
repair-cost,
creative-slot-lock,
enchantment-glint-override,
intangible-projectile,
food,
consumable,
use-remainder,
use-cooldown,
damage-resistant,
tool,
weapon,
attack-range,
enchantable,
equippable,
repairable,
glider,
tooltip-style,
death-protection,
blocks-attacks,
piercing-weapon,
kinetic-weapon,
swing-animation,
additional-trade-cost,
stored-enchantments,
dye,
dyed-color,
map-color,
map-id,
map-decorations,
map-post-processing,
charged-projectiles,
bundle-contents,
potion-contents,
potion-duration-scale,
suspicious-stew-effects,
writable-book-content,
written-book-content,
trim,
debug-stick-state,
entity-data,
bucket-entity-data,
block-entity-data,
instrument,
provides-trim-material,
ominous-bottle-amplifier,
jukebox-playable,
provides-banner-patterns,
recipes,
lodestone-tracker,
firework-explosion,
fireworks,
profile,
note-block-sound,
banner-patterns,
base-color,
pot-decorations,
container,
block-state,
bees,
lock,
container-loot,
break-sound,
villager-variant,
wolf-variant,
wolf-sound-variant,
wolf-collar,
fox-variant,
salmon-size,
parrot-variant,
tropical-fish-pattern,
tropical-fish-base-color,
tropical-fish-pattern-color,
mooshroom-variant,
rabbit-variant,
pig-variant,
pig-sound-variant,
cow-variant,
cow-sound-variant,
chicken-variant,
chicken-sound-variant,
zombie-nautilus-variant,
frog-variant,
horse-variant,
painting-variant,
llama-variant,
axolotl-variant,
cat-variant,
cat-sound-variant,
cat-collar,
sheep-color,
shulker-color,
}
}

49
v0.1/enchantments.wit Normal file
View File

@ -0,0 +1,49 @@
package pumpkin:plugin@0.1.0;
interface enchantments {
enum enchantment {
aqua-affinity,
bane-of-arthropods,
binding-curse,
blast-protection,
breach,
channeling,
density,
depth-strider,
efficiency,
feather-falling,
fire-aspect,
fire-protection,
flame,
fortune,
frost-walker,
impaling,
infinity,
knockback,
looting,
loyalty,
luck-of-the-sea,
lunge,
lure,
mending,
multishot,
piercing,
power,
projectile-protection,
protection,
punch,
quick-charge,
respiration,
riptide,
sharpness,
silk-touch,
smite,
soul-speed,
sweeping-edge,
swift-sneak,
thorns,
unbreaking,
vanishing-curse,
wind-burst,
}
}

163
v0.1/entity-types.wit Normal file
View File

@ -0,0 +1,163 @@
package pumpkin:plugin@0.1.0;
interface entity-types {
enum entity-type {
acacia-boat,
acacia-chest-boat,
allay,
area-effect-cloud,
armadillo,
armor-stand,
arrow,
axolotl,
bamboo-chest-raft,
bamboo-raft,
bat,
bee,
birch-boat,
birch-chest-boat,
blaze,
block-display,
bogged,
breeze,
breeze-wind-charge,
camel,
camel-husk,
cat,
cave-spider,
cherry-boat,
cherry-chest-boat,
chest-minecart,
chicken,
cod,
command-block-minecart,
copper-golem,
cow,
creaking,
creeper,
dark-oak-boat,
dark-oak-chest-boat,
dolphin,
donkey,
dragon-fireball,
drowned,
egg,
elder-guardian,
end-crystal,
ender-dragon,
ender-pearl,
enderman,
endermite,
evoker,
evoker-fangs,
experience-bottle,
experience-orb,
eye-of-ender,
falling-block,
fireball,
firework-rocket,
fishing-bobber,
fox,
frog,
furnace-minecart,
ghast,
giant,
glow-item-frame,
glow-squid,
goat,
guardian,
happy-ghast,
hoglin,
hopper-minecart,
horse,
husk,
illusioner,
interaction,
iron-golem,
item,
item-display,
item-frame,
jungle-boat,
jungle-chest-boat,
leash-knot,
lightning-bolt,
lingering-potion,
llama,
llama-spit,
magma-cube,
mangrove-boat,
mangrove-chest-boat,
mannequin,
marker,
minecart,
mooshroom,
mule,
nautilus,
oak-boat,
oak-chest-boat,
ocelot,
ominous-item-spawner,
painting,
pale-oak-boat,
pale-oak-chest-boat,
panda,
parched,
parrot,
phantom,
pig,
piglin,
piglin-brute,
pillager,
player,
polar-bear,
pufferfish,
rabbit,
ravager,
salmon,
sheep,
shulker,
shulker-bullet,
silverfish,
skeleton,
skeleton-horse,
slime,
small-fireball,
sniffer,
snow-golem,
snowball,
spawner-minecart,
spectral-arrow,
spider,
splash-potion,
spruce-boat,
spruce-chest-boat,
squid,
stray,
strider,
tadpole,
text-display,
tnt,
tnt-minecart,
trader-llama,
trident,
tropical-fish,
turtle,
vex,
villager,
vindicator,
wandering-trader,
warden,
wind-charge,
witch,
wither,
wither-skeleton,
wither-skull,
wolf,
zoglin,
zombie,
zombie-horse,
zombie-nautilus,
zombie-villager,
zombified-piglin,
}
}

1
v0.1/entity.wit Normal file
View File

@ -0,0 +1 @@
interface entity { use %world.{entity, raycast-result, block-direction}; }

392
v0.1/event.wit Normal file
View File

@ -0,0 +1,392 @@
interface event {
use common.{block-pos, game-mode, hand, position, click-type};
use item-stack.{item-stack};
use player.{player};
use text.{text-component};
use %world.{%world};
use java-packets.{serverbound-packet as java-serverbound-packet, clientbound-packet as java-clientbound-packet};
use bedrock-packets.{serverbound-packet as bedrock-serverbound-packet, clientbound-packet as bedrock-clientbound-packet};
use uuid.{uuid};
variant serverbound-packet {
java(java-serverbound-packet),
bedrock(bedrock-serverbound-packet),
}
variant clientbound-packet {
java(java-clientbound-packet),
bedrock(bedrock-clientbound-packet),
}
enum event-priority {
highest,
high,
normal,
low,
lowest,
}
record player-join-event-data {
player: player,
join-message: text-component,
cancelled: bool
}
record player-leave-event-data {
player: player,
leave-message: text-component,
cancelled: bool
}
record player-login-event-data {
player: player,
kick-message: text-component,
cancelled: bool
}
record player-chat-event-data {
player: player,
message: string,
recipients: list<player>,
cancelled: bool
}
record player-command-send-event-data {
player: player,
command: string,
cancelled: bool
}
record player-permission-check-event-data {
player: player,
permission: string,
permission-result: bool
}
record player-move-event-data {
player: player,
from-position: position,
to-position: position,
cancelled: bool
}
record player-teleport-event-data {
player: player,
from-position: position,
to-position: position,
cancelled: bool
}
record player-change-world-event-data {
player: player,
previous-world: %world,
new-world: %world,
position: position,
yaw: f32,
pitch: f32,
cancelled: bool
}
record player-exp-change-event-data {
player: player,
amount: s32
}
record player-item-held-event-data {
player: player,
previous-slot: u8,
new-slot: u8,
cancelled: bool
}
record player-changed-main-hand-event-data {
player: player,
main-hand: hand
}
record player-gamemode-change-event-data {
player: player,
previous-gamemode: game-mode,
new-gamemode: game-mode,
cancelled: bool
}
record player-custom-payload-event-data {
player: player,
channel: string,
data: list<u8>
}
enum player-fish-state {
fishing,
caught-fish,
caught-entity,
in-ground,
failed-attempt,
reel-in,
bite,
}
record player-fish-event-data {
player: player,
caught-uuid: option<uuid>,
caught-type: string,
hook-uuid: uuid,
state: player-fish-state,
hand: hand,
exp-to-drop: s32,
cancelled: bool
}
record player-egg-throw-event-data {
player: player,
egg-uuid: uuid,
hatching: bool,
num-hatches: u8,
hatching-type: string,
cancelled: bool
}
enum entity-interaction-action {
interact,
attack,
interact-at,
}
enum interact-action {
left-click-block,
left-click-air,
right-click-air,
right-click-block,
}
record player-interact-event-data {
player: player,
action: interact-action,
clicked-pos: option<block-pos>,
block: string,
cancelled: bool
}
record player-toggle-sneak-event-data {
player: player,
is-sneaking: bool,
cancelled: bool
}
record player-toggle-flight-event-data {
player: player,
is-flying: bool,
cancelled: bool
}
record player-toggle-sprint-event-data {
player: player,
is-sprinting: bool,
cancelled: bool
}
record player-interact-unknown-entity-event-data {
player: player,
entity-id: s32,
action: entity-interaction-action,
cancelled: bool
}
record inventory-click-event-data {
player: player,
window-type: option<string>,
click-type: click-type,
slot: s16,
raw-slot: s16,
clicked-item: option<item-stack>,
cursor: option<item-stack>,
hotbar-button: s32,
cancelled: bool
}
record inventory-close-event-data {
player: player,
window-type: option<string>
}
record block-redstone-event-data {
target-world: %world,
state-id: u16,
block-pos: block-pos,
old-current: s32,
new-current: s32,
cancelled: bool
}
record block-break-event-data {
player: option<player>,
block: string,
block-pos: block-pos,
exp: u32,
should-drop: bool,
cancelled: bool
}
record block-burn-event-data {
igniting-block: string,
block: string,
cancelled: bool
}
record block-can-build-event-data {
block-to-build: string,
buildable: bool,
player: player,
block: string,
cancelled: bool
}
record block-grow-event-data {
target-world: %world,
old-block: string,
old-state-id: u16,
new-block: string,
new-state-id: u16,
block-pos: block-pos,
cancelled: bool
}
record block-place-event-data {
player: player,
block-placed: string,
block-placed-against: string,
block-pos: block-pos,
can-build: bool,
cancelled: bool
}
record bedrock-form-response-event-data {
player: player,
form-id: u32,
response-data: option<string>,
}
record custom-click-action-event-data {
player: player,
id: string,
payload: option<list<u8>>,
}
record server-command-event-data {
command: string,
cancelled: bool
}
record spawn-change-event-data {
target-world: %world,
previous-position: block-pos,
previous-yaw: f32,
previous-pitch: f32,
new-position: block-pos,
new-yaw: f32,
new-pitch: f32
}
record server-broadcast-event-data {
message: text-component,
sender: text-component,
cancelled: bool
}
record server-tick-start-event-data {
tick: s32
}
record packet-received-event-data {
player: player,
packet: serverbound-packet,
cancelled: bool
}
record packet-sent-event-data {
player: player,
packet: clientbound-packet,
cancelled: bool
}
enum event-type {
player-join-event,
player-leave-event,
player-login-event,
player-chat-event,
player-command-send-event,
player-permission-check-event,
player-move-event,
player-teleport-event,
player-change-world-event,
player-exp-change-event,
player-item-held-event,
player-changed-main-hand-event,
player-gamemode-change-event,
player-custom-payload-event,
player-fish-event,
player-egg-throw-event,
player-interact-unknown-entity-event,
player-interact-event,
player-toggle-sneak-event,
player-toggle-flight-event,
player-toggle-sprint-event,
inventory-click-event,
inventory-close-event,
block-redstone-event,
block-break-event,
block-burn-event,
block-can-build-event,
block-grow-event,
block-place-event,
bedrock-form-response-event,
custom-click-action-event,
server-command-event,
spawn-change-event,
server-broadcast-event,
server-tick-start-event,
packet-received-event,
packet-sent-event,
}
variant event {
player-join-event(player-join-event-data),
player-leave-event(player-leave-event-data),
player-login-event(player-login-event-data),
player-chat-event(player-chat-event-data),
player-command-send-event(player-command-send-event-data),
player-permission-check-event(player-permission-check-event-data),
player-move-event(player-move-event-data),
player-teleport-event(player-teleport-event-data),
player-change-world-event(player-change-world-event-data),
player-exp-change-event(player-exp-change-event-data),
player-item-held-event(player-item-held-event-data),
player-changed-main-hand-event(player-changed-main-hand-event-data),
player-gamemode-change-event(player-gamemode-change-event-data),
player-custom-payload-event(player-custom-payload-event-data),
player-fish-event(player-fish-event-data),
player-egg-throw-event(player-egg-throw-event-data),
player-interact-unknown-entity-event(player-interact-unknown-entity-event-data),
player-interact-event(player-interact-event-data),
player-toggle-sneak-event(player-toggle-sneak-event-data),
player-toggle-flight-event(player-toggle-flight-event-data),
player-toggle-sprint-event(player-toggle-sprint-event-data),
inventory-click-event(inventory-click-event-data),
inventory-close-event(inventory-close-event-data),
block-redstone-event(block-redstone-event-data),
block-break-event(block-break-event-data),
block-burn-event(block-burn-event-data),
block-can-build-event(block-can-build-event-data),
block-grow-event(block-grow-event-data),
block-place-event(block-place-event-data),
bedrock-form-response-event(bedrock-form-response-event-data),
custom-click-action-event(custom-click-action-event-data),
server-command-event(server-command-event-data),
spawn-change-event(spawn-change-event-data),
server-broadcast-event(server-broadcast-event-data),
server-tick-start-event(server-tick-start-event-data),
packet-received-event(packet-received-event-data),
packet-sent-event(packet-sent-event-data),
}
}

51
v0.1/forms.wit Normal file
View File

@ -0,0 +1,51 @@
interface forms {
use text.{text-component};
enum image-type {
url,
path,
}
record form-image {
%type: image-type,
data: string,
}
record simple-form-button {
text: text-component,
image: option<form-image>,
}
record simple-form {
title: text-component,
content: text-component,
buttons: list<simple-form-button>,
}
record modal-form {
title: text-component,
content: text-component,
button1: text-component,
button2: text-component,
}
variant custom-form-element {
label(text-component),
toggle(tuple<text-component, bool>),
slider(tuple<text-component, f32, f32, f32, f32>), // text, min, max, step, default
step-slider(tuple<text-component, list<string>, u32>), // text, steps, default
dropdown(tuple<text-component, list<string>, u32>), // text, options, default
input(tuple<text-component, string, string>), // text, placeholder, default
}
record custom-form {
title: text-component,
elements: list<custom-form-element>,
}
variant form {
simple(simple-form),
modal(modal-form),
custom(custom-form),
}
}

63
v0.1/gui.wit Normal file
View File

@ -0,0 +1,63 @@
interface gui {
use text.{text-component};
use common.{click-type};
use item-stack.{item-stack};
enum gui-type {
generic-9x1,
generic-9x2,
generic-9x3,
generic-9x4,
generic-9x5,
generic-9x6,
generic-3x3,
crafter-3x3,
anvil,
beacon,
blast-furnace,
brewing-stand,
crafting,
enchantment,
furnace,
grindstone,
hopper,
lectern,
loom,
merchant,
shulker-box,
smithing,
smoker,
cartography-table,
stonecutter,
}
resource gui {
constructor(%type: gui-type, title: text-component);
set-item: func(slot: u32, item: item-stack);
get-item: func(slot: u32) -> option<item-stack>;
/// Returns the type of this GUI.
get-type: func() -> gui-type;
/// Returns the title of this GUI.
get-title: func() -> text-component;
/// Returns the number of slots in this GUI.
get-size: func() -> u32;
/// Clears all items from the GUI.
clear-items: func();
/// Sets whether players can grab items out of the inventory.
set-allow-grab-items: func(allow: bool);
/// Returns whether players can grab items out of the inventory.
get-allow-grab-items: func() -> bool;
/// Sets whether players can put items into the inventory from their own.
set-allow-put-items: func(allow: bool);
/// Returns whether players can put items into the inventory from their own.
get-allow-put-items: func() -> bool;
}
}

21
v0.1/i18n.wit Normal file
View File

@ -0,0 +1,21 @@
interface i18n {
use common.{locale};
/// Retrieves a translated string from the host.
///
/// # Arguments
/// * `key`: The namespaced translation key (e.g. `pumpkin:my_key`).
/// * `locale`: The target locale.
///
/// # Returns
/// The localized string, falling back to English or the key itself.
translate: func(key: string, locale: locale) -> string;
/// Loads custom translations from a JSON string.
///
/// # Arguments
/// * `namespace`: The namespace to associate these keys with.
/// * `json`: A JSON string containing a flat map of translations.
/// * `locale`: The target locale for these translations.
load-translations: func(namespace: string, json: string, locale: locale);
}

59
v0.1/item-stack.wit Normal file
View File

@ -0,0 +1,59 @@
interface item-stack {
use data-components.{data-component};
use enchantments.{enchantment};
use text.{text-component};
/// Represents an enchantment and its level.
record enchantment-value {
enchantment: enchantment,
level: u32,
}
/// Represents a data component and its serialized value.
record data-component-value {
component: data-component,
/// The serialized value of the component.
value: list<u8>,
}
resource item-stack {
constructor(registry-key: string, count: u8);
/// Returns the unique registry key of the item (e.g., "minecraft:diamond").
get-registry-key: func() -> string;
/// Returns the number of items in the stack.
get-count: func() -> u8;
/// Sets the number of items in the stack.
set-count: func(count: u8);
/// Returns the maximum number of items that can be in this stack.
get-max-count: func() -> u8;
/// Returns all enchantments on this item stack.
get-enchantments: func() -> list<enchantment-value>;
/// Adds an enchantment to this item stack.
add-enchantment: func(enchantment: enchantment, level: u32);
/// Removes an enchantment from this item stack.
remove-enchantment: func(enchantment: enchantment);
/// Returns the lore of this item stack.
get-lore: func() -> list<text-component>;
/// Sets the lore of this item stack.
set-lore: func(lore: list<text-component>);
/// Adds a line to the lore of this item stack.
add-lore: func(line: text-component);
/// Returns the custom name of this item stack, if set.
get-custom-name: func() -> option<text-component>;
/// Sets the custom name of this item stack.
set-custom-name: func(name: option<text-component>);
/// Returns all data components on this item stack.
get-components: func() -> list<data-component-value>;
/// Sets a data component on this item stack.
set-component: func(component: data-component, value: list<u8>);
/// Removes a data component from this item stack.
remove-component: func(component: data-component);
}
}

155
v0.1/java-dialogs.wit Normal file
View File

@ -0,0 +1,155 @@
/// Provides types and utilities for displaying rich dialogs to Java Edition players.
/// These dialogs support various layouts, body elements (text and items),
/// and interactive inputs (checkboxes, text fields, sliders).
interface java-dialogs {
use text.{text-component};
use item-stack.{item-stack};
/// Represents the layout and button configuration of a dialog.
enum dialog-type {
/// A simple dialog with a single "OK" button.
notice,
/// A dialog with "Yes" and "No" buttons.
confirmation,
/// A scrollable list of custom buttons.
multi-action,
/// A list of buttons that open other registered dialogs.
dialog-list,
/// A dedicated menu for displaying server-related links.
server-links,
}
/// Represents an element in the main content area of a dialog.
variant dialog-body {
/// A simple text message.
plain-message(text-component),
/// A visual item display.
item(item-stack),
}
/// Represents an interactive input control in a dialog.
variant dialog-input {
/// A checkbox for true/false states.
%bool(dialog-input-bool),
/// A simple string input field.
%text(dialog-input-text),
/// A slider for numerical input within a range.
number-range(dialog-input-number-range),
/// A multiple-choice selection button.
single-option(dialog-input-single-option),
}
/// A checkbox input control.
record dialog-input-bool {
label: text-component,
default-value: bool,
}
/// A text field input control.
record dialog-input-text {
label: text-component,
placeholder: text-component,
default-value: string,
}
/// A numerical range slider input control.
record dialog-input-number-range {
label: text-component,
min-value: f32,
max-value: f32,
initial-value: f32,
step: f32,
label-format: option<string>,
}
/// A multiple-choice selection input control.
record dialog-input-single-option {
label: text-component,
options: list<text-component>,
initial-index: u32,
}
/// Defines what happens after a dialog is closed.
enum after-action {
/// Returns the player to the previous screen (e.g., keeping an inventory open).
peek,
/// Closes all open screens.
pop,
}
/// Represents a clickable button in a dialog.
record action-button {
text: text-component,
tooltip: option<text-component>,
width: option<u32>,
action: action,
}
/// Represents an action triggered by a button click.
variant action {
/// Opens an external URL.
open-url(string),
/// Triggers a custom server-side callback with an ID and optional payload.
custom-click(custom-click-action),
}
/// Represents a custom server-side action.
record custom-click-action {
/// A unique identifier for the action (sent back to the server).
id: string,
/// Optional binary data to send with the action.
payload: option<list<u8>>,
}
/// Represents a link displayed in a Java Edition dialog.
record link {
/// The label to display for the link.
label: link-label,
/// The URL the link points to.
url: string,
}
/// The label for a link, which can be a built-in type or custom text.
variant link-label {
/// A built-in link type with a predefined icon/label.
built-in(link-type),
/// A custom text component label.
custom(text-component),
}
/// Built-in link types recognized by the Java Edition client.
enum link-type {
bug-report,
community-guidelines,
support,
status,
feedback,
community,
website,
forums,
news,
announcements,
}
/// Represents a dialog shown to a Java Edition player.
record dialog {
/// The main title of the dialog.
title: text-component,
/// The layout type of the dialog.
%type: dialog-type,
/// A list of body elements to display in the main area.
body: list<dialog-body>,
/// A list of interactive input controls.
inputs: list<dialog-input>,
/// A list of clickable buttons (for multi-action and other types).
buttons: list<action-button>,
/// A list of links (primarily for server-links type).
links: list<link>,
/// What to do after the dialog is closed.
after-action: option<after-action>,
/// Whether the player can exit the dialog using the Esc key.
can-close-with-escape: bool,
/// The text shown on buttons that link to/open this dialog.
external-title: option<text-component>,
}
}

864
v0.1/java-packets.wit Normal file
View File

@ -0,0 +1,864 @@
package pumpkin:plugin@0.1.0;
interface java-packets {
use uuid.{ uuid };
record s-attack {
entity-id: s32,
}
record s-change-game-mode {
game-mode: string,
}
record s-chat-command {
command: string,
}
record s-chat-message {
message: string,
timestamp: s64,
salt: s64,
signature: option<list<list<u8>>>,
message-count: s32,
acknowledged: list<list<u8>>,
checksum: u8,
}
record s-chunk-batch {
chunks-per-tick: f32,
}
record s-click-slot {
sync-id: s32,
revision: s32,
slot: s32,
button: u8,
mode: string,
length-of-array: s32,
array-of-changed-slots: list<string>,
carried-item: string,
}
record s-client-command {
action-id: s32,
}
record s-client-information-play {
locale: string,
view-distance: u8,
chat-mode: s32,
chat-colors: bool,
skin-parts: u8,
main-hand: s32,
text-filtering: bool,
server-listing: bool,
}
record s-close-container {
window-id: s32,
}
record s-command-suggestion {
id: s32,
command: string,
}
record s-confirm-teleport {
teleport-id: s32,
}
record s-container-button-click {
window-id: s32,
button-id: s32,
}
record s-cookie-response {
key: string,
payload: option<list<list<u8>>>,
}
record s-custom-click-action {
action-id: string,
payload: option<list<list<u8>>>,
}
record s-custom-payload {
channel: string,
data: list<list<u8>>,
}
record s-interact {
entity-id: s32,
r-type: s32,
target-position: option<tuple<f64, f64, f64>>,
hand: option<s32>,
sneaking: bool,
}
record s-keep-alive {
keep-alive-id: s64,
}
record s-move-vehicle {
x: f64,
y: f64,
z: f64,
yaw: f32,
pitch: f32,
}
record s-paddle-boat {
left-paddle: bool,
right-paddle: bool,
}
record s-pick-item-from-block {
pos: tuple<s32, s32, s32>,
include-data: bool,
}
record s-pick-item-from-entity {
id: s32,
include-data: bool,
}
record s-play-ping-request {
payload: s64,
}
record s-place-recipe {
container-id: u8,
recipe-display-id: s32,
use-max-items: bool,
}
record s-player-abilities {
%flags: u8,
}
record s-player-action {
status: s32,
position: tuple<s32, s32, s32>,
face: u8,
sequence: s32,
}
record s-player-command {
entity-id: s32,
action: string,
jump-boost: s32,
}
record s-set-player-ground {
on-ground: bool,
}
record s-player-input {
input: u8,
}
record s-player-position {
position: tuple<f64, f64, f64>,
collision: u8,
}
record s-player-position-rotation {
position: tuple<f64, f64, f64>,
yaw: f32,
pitch: f32,
collision: u8,
}
record s-player-rotation {
yaw: f32,
pitch: f32,
ground: bool,
}
record s-player-session {
session-id: uuid,
expires-at: s64,
public-key: list<list<u8>>,
key-signature: list<list<u8>>,
}
record s-recipe-book-change-settings {
book-type: s32,
is-open: bool,
is-filtering: bool,
}
record s-recipe-book-seen-recipe {
recipe-display-id: s32,
}
record s-rename-item {
item-name: string,
}
record s-select-trade {
selected-slot: s32,
}
record s-set-beacon {
primary-effect: option<s32>,
secondary-effect: option<s32>,
}
record s-set-command-block {
pos: tuple<s32, s32, s32>,
command: string,
mode: s32,
%flags: u8,
}
record s-set-creative-slot {
slot: s32,
clicked-item: string,
}
record s-set-held-item {
slot: s32,
}
record s-swing-arm {
hand: s32,
}
record s-update-sign {
location: tuple<s32, s32, s32>,
is-front-text: bool,
line-1: string,
line-2: string,
line-3: string,
line-4: string,
}
record s-use-item {
hand: s32,
sequence: s32,
yaw: f32,
pitch: f32,
}
record s-use-item-on {
hand: s32,
position: tuple<s32, s32, s32>,
face: s32,
cursor-pos: tuple<f64, f64, f64>,
inside-block: bool,
is-against-world-border: bool,
sequence: s32,
}
record c-acknowledge-block-change {
sequence-id: s32,
}
record c-action-bar {
action-bar: string,
}
record c-set-block-destroy-stage {
entity-id: s32,
location: tuple<s32, s32, s32>,
destroy-stage: u8,
}
record c-block-entity-data {
location: tuple<s32, s32, s32>,
r-type: s32,
nbt-data: list<list<u8>>,
}
record c-block-event {
location: tuple<s32, s32, s32>,
action-id: u8,
action-parameter: u8,
block-type: s32,
}
record c-block-update {
location: tuple<s32, s32, s32>,
state-id: s32,
}
record c-boss-event {
uuid: uuid,
action: string,
}
record c-center-chunk {
chunk-x: s32,
chunk-z: s32,
}
record c-change-difficulty {
difficulty: u8,
locked: bool,
}
record c-chunk-batch-end {
batch-size: s32,
}
record c-clear-title {
reset: bool,
}
record c-close-container {
sync-id: s32,
}
record c-combat-death {
player-id: s32,
message: string,
}
record c-command-suggestions {
id: s32,
start: s32,
length: s32,
matches: list<list<string>>,
}
record c-commands {
nodes: list<list<string>>,
root-node-index: s32,
}
record c-play-cookie-request {
key: string,
}
record c-custom-payload {
channel: string,
data: list<u8>,
}
record c-damage-event {
entity-id: s32,
source-type-id: s32,
source-cause-id: s32,
source-direct-id: s32,
source-position: option<tuple<f64, f64, f64>>,
}
record c-play-disconnect {
reason: string,
}
record c-disguised-chat-message {
message: string,
chat-type: s32,
sender-name: string,
target-name: option<string>,
}
record c-display-objective {
position: s32,
score-name: string,
}
record c-entity-animation {
entity-id: s32,
animation: u8,
}
record c-set-entity-metadata {
entity-id: s32,
metadata: list<list<u8>>,
}
record c-entity-position-sync {
entity-id: s32,
position: tuple<f64, f64, f64>,
delta: tuple<f64, f64, f64>,
yaw: f32,
pitch: f32,
on-ground: bool,
}
record c-entity-sound-effect {
sound-event: string,
sound-category: s32,
entity-id: s32,
volume: f32,
pitch: f32,
seed: s64,
}
record c-entity-status {
entity-id: s32,
entity-status: u8,
}
record c-entity-velocity {
entity-id: s32,
velocity: string,
}
record c-explosion {
center: tuple<f64, f64, f64>,
radius: f32,
block-count: s32,
knockback: option<tuple<f64, f64, f64>>,
particle: s32,
sound: string,
block-particles-pool-size: s32,
}
record c-game-event {
event: u8,
value: f32,
}
record c-head-rot {
entity-id: s32,
head-yaw: u8,
}
record c-hurt-animation {
entity-id: s32,
yaw: f32,
}
record c-initialize-world-border {
x: f64,
z: f64,
old-diameter: f64,
new-diameter: f64,
speed: string,
portal-teleport-boundary: s32,
warning-blocks: s32,
warning-time: s32,
}
record c-item-cooldown {
group: string,
cooldown: s32,
}
record c-keep-alive {
keep-alive-id: s64,
}
record c-level-event {
event: s32,
location: tuple<s32, s32, s32>,
data: s32,
disable-relative-volume: bool,
}
record c-login {
entity-id: s32,
is-hardcore: bool,
dimension-names: list<string>,
max-players: s32,
view-distance: s32,
simulated-distance: s32,
reduced-debug-info: bool,
enabled-respawn-screen: bool,
limited-crafting: bool,
dimension: string,
hashed-seed: s64,
game-mode: u8,
previous-gamemode: u8,
debug: bool,
is-flat: bool,
death-dimension-name: option<string>,
portal-cooldown: s32,
sealevel: s32,
enforce-secure-chat: bool,
}
record c-map-item-data {
map-id: s32,
scale: u8,
locked: bool,
icons: option<list<string>>,
data: option<string>,
}
record c-merchant-offers {
window-id: s32,
offers: list<string>,
villager-level: s32,
experience: s32,
is-regular-villager: bool,
can-restock: bool,
}
record c-multi-block-update {
chunk-section: s64,
updates: list<string>,
}
record c-open-screen {
sync-id: s32,
window-type: s32,
window-title: string,
}
record c-open-sign-editor {
location: tuple<s32, s32, s32>,
is-front-text: bool,
}
record c-particle {
force-spawn: bool,
important: bool,
position: tuple<f64, f64, f64>,
offset: tuple<f64, f64, f64>,
max-speed: f32,
particle-count: s32,
particle-id: s32,
data: list<u8>,
}
record c-ping-response {
payload: s64,
}
record c-player-abilities {
%flags: u8,
flying-speed: f32,
field-of-view: f32,
}
record c-player-chat-message {
global-index: s32,
sender: uuid,
index: s32,
message-signature: option<list<list<u8>>>,
message: string,
timestamp: s64,
salt: s64,
previous-messages: list<list<string>>,
unsigned-content: option<string>,
filter-type: string,
chat-type: s32,
sender-name: string,
target-name: option<string>,
}
record c-player-info-update {
actions: u8,
players: list<string>,
}
record c-player-position {
teleport-id: s32,
position: tuple<f64, f64, f64>,
delta: tuple<f64, f64, f64>,
yaw: f32,
pitch: f32,
relatives: list<string>,
}
record c-remove-player-info {
players: list<uuid>,
}
record c-player-spawn-position {
dimension-name: string,
location: tuple<s32, s32, s32>,
yaw: f32,
pitch: f32,
}
record c-recipe-book-add {
replace: bool,
}
record c-recipe-book-settings {
crafting-open: bool,
crafting-filtering: bool,
furnace-open: bool,
furnace-filtering: bool,
blast-furnace-open: bool,
blast-furnace-filtering: bool,
smoker-open: bool,
smoker-filtering: bool,
}
record c-remove-entities {
entity-ids: list<s32>,
}
record c-remove-mob-effect {
entity-id: s32,
effect-id: s32,
}
record c-reset-score {
entity-name: string,
objective-name: option<string>,
}
record c-respawn {
dimension-type: s32,
dimension-name: string,
hashed-seed: s64,
game-mode: u8,
previous-gamemode: u8,
debug: bool,
is-flat: bool,
death-dimension-name: option<string>,
portal-cooldown: s32,
sealevel: s32,
data-kept: u8,
}
record c-play-server-links {
links: list<string>,
}
record c-set-border-center {
x: f64,
z: f64,
}
record c-set-border-lerp-size {
old-diameter: f64,
new-diameter: f64,
speed: string,
}
record c-set-border-size {
diameter: f64,
}
record c-set-border-warning-delay {
warning-time: s32,
}
record c-set-border-warning-distance {
warning-blocks: s32,
}
record c-set-container-content {
window-id: s32,
state-id: s32,
slot-data: list<string>,
carried-item: string,
}
record c-set-container-property {
window-id: s32,
property: s32,
value: s32,
}
record c-set-container-slot {
window-id: u8,
state-id: s32,
slot: s32,
slot-data: string,
}
record c-set-cursor-item {
stack: string,
}
record c-set-equipment {
entity-id: s32,
equipment: list<string>,
}
record c-set-experience {
progress: f32,
level: s32,
total-experience: s32,
}
record c-set-health {
health: f32,
food: s32,
food-saturation: f32,
}
record c-set-passengers {
entity-id: s32,
passengers: list<s32>,
}
record c-set-player-inventory {
slot: s32,
item: string,
}
record c-set-player-team {
team-name: string,
method: string,
parameters: option<string>,
players: list<string>,
}
record c-update-time {
game-time: s64,
clock-updates: list<string>,
}
record c-title-text {
title: string,
}
record c-title-animation {
fade-in-ticks: s32,
stay-ticks: s32,
fade-out-ticks: s32,
}
record c-play-show-dialog {
dialog: string,
}
record c-sound-effect {
sound-event: string,
sound-category: s32,
position: tuple<f64, f64, f64>,
volume: f32,
pitch: f32,
seed: f64,
}
record c-spawn-entity {
entity-id: s32,
entity-uuid: uuid,
r-type: s32,
position: tuple<f64, f64, f64>,
velocity: string,
pitch: u8,
yaw: u8,
head-yaw: u8,
data: s32,
}
record c-stop-sound {
sound-id: option<string>,
category: option<string>,
}
record c-store-cookie {
key: string,
payload: list<u8>,
}
record c-subtitle {
subtitle: string,
}
record c-system-chat-message {
content: string,
overlay: bool,
}
record c-tab-list {
header: string,
footer: string,
}
record c-take-item-entity {
entity-id: s32,
collector-entity-id: s32,
stack-amount: s32,
}
record c-teleport-entity {
entity-id: s32,
position: tuple<f64, f64, f64>,
delta: tuple<f64, f64, f64>,
yaw: f32,
pitch: f32,
relatives: list<string>,
on-ground: bool,
}
record c-ticking-state {
tick-rate: f32,
is-frozen: bool,
}
record c-ticking-step {
tick-steps: s32,
}
record c-transfer {
host: string,
port: s32,
}
record c-unload-chunk {
z: s32,
x: s32,
}
record c-update-attributes {
entity-id: s32,
properties: list<string>,
}
record c-update-entity-pos {
entity-id: s32,
delta: tuple<f64, f64, f64>,
on-ground: bool,
}
record c-update-entity-pos-rot {
entity-id: s32,
delta: tuple<f64, f64, f64>,
yaw: u8,
pitch: u8,
on-ground: bool,
}
record c-update-entity-rot {
entity-id: s32,
yaw: u8,
pitch: u8,
on-ground: bool,
}
record c-update-mob-effect {
entity-id: s32,
effect-id: s32,
amplifier: s32,
duration: s32,
%flags: u8,
}
record c-update-objectives {
objective-name: string,
mode: u8,
display-name: string,
render-type: s32,
number-format: option<string>,
}
record c-update-score {
entity-name: string,
objective-name: string,
value: s32,
display-name: option<string>,
number-format: option<string>,
}
record c-world-event {
event: s32,
location: tuple<s32, s32, s32>,
data: s32,
disable-relative-volume: bool,
}
variant serverbound-packet {
s-attack(s-attack),
s-change-game-mode(s-change-game-mode),
s-chat-command(s-chat-command),
s-chat-message(s-chat-message),
s-chunk-batch(s-chunk-batch),
s-click-slot(s-click-slot),
s-client-command(s-client-command),
s-client-information-play(s-client-information-play),
s-client-tick-end,
s-close-container(s-close-container),
s-command-suggestion(s-command-suggestion),
s-confirm-teleport(s-confirm-teleport),
s-container-button-click(s-container-button-click),
s-cookie-response(s-cookie-response),
s-custom-click-action(s-custom-click-action),
s-custom-payload(s-custom-payload),
s-interact(s-interact),
s-keep-alive(s-keep-alive),
s-move-vehicle(s-move-vehicle),
s-paddle-boat(s-paddle-boat),
s-pick-item-from-block(s-pick-item-from-block),
s-pick-item-from-entity(s-pick-item-from-entity),
s-play-ping-request(s-play-ping-request),
s-place-recipe(s-place-recipe),
s-player-abilities(s-player-abilities),
s-player-action(s-player-action),
s-player-command(s-player-command),
s-set-player-ground(s-set-player-ground),
s-player-input(s-player-input),
s-player-loaded,
s-player-position(s-player-position),
s-player-position-rotation(s-player-position-rotation),
s-player-rotation(s-player-rotation),
s-player-session(s-player-session),
s-recipe-book-change-settings(s-recipe-book-change-settings),
s-recipe-book-seen-recipe(s-recipe-book-seen-recipe),
s-rename-item(s-rename-item),
s-select-trade(s-select-trade),
s-set-beacon(s-set-beacon),
s-set-command-block(s-set-command-block),
s-set-creative-slot(s-set-creative-slot),
s-set-held-item(s-set-held-item),
s-swing-arm(s-swing-arm),
s-update-sign(s-update-sign),
s-use-item(s-use-item),
s-use-item-on(s-use-item-on),
}
variant clientbound-packet {
c-acknowledge-block-change(c-acknowledge-block-change),
c-action-bar(c-action-bar),
c-set-block-destroy-stage(c-set-block-destroy-stage),
c-block-entity-data(c-block-entity-data),
c-block-event(c-block-event),
c-block-update(c-block-update),
c-boss-event(c-boss-event),
c-center-chunk(c-center-chunk),
c-change-difficulty(c-change-difficulty),
c-chunk-batch-end(c-chunk-batch-end),
c-chunk-batch-start,
c-chunk-data,
c-play-clear-dialog,
c-clear-title(c-clear-title),
c-close-container(c-close-container),
c-combat-death(c-combat-death),
c-command-suggestions(c-command-suggestions),
c-commands(c-commands),
c-play-cookie-request(c-play-cookie-request),
c-custom-payload(c-custom-payload),
c-damage-event(c-damage-event),
c-play-disconnect(c-play-disconnect),
c-disguised-chat-message(c-disguised-chat-message),
c-display-objective(c-display-objective),
c-entity-animation(c-entity-animation),
c-set-entity-metadata(c-set-entity-metadata),
c-entity-position-sync(c-entity-position-sync),
c-entity-sound-effect(c-entity-sound-effect),
c-entity-status(c-entity-status),
c-entity-velocity(c-entity-velocity),
c-explosion(c-explosion),
c-game-event(c-game-event),
c-head-rot(c-head-rot),
c-hurt-animation(c-hurt-animation),
c-initialize-world-border(c-initialize-world-border),
c-item-cooldown(c-item-cooldown),
c-keep-alive(c-keep-alive),
c-level-event(c-level-event),
c-light-update,
c-login(c-login),
c-map-item-data(c-map-item-data),
c-merchant-offers(c-merchant-offers),
c-multi-block-update(c-multi-block-update),
c-open-screen(c-open-screen),
c-open-sign-editor(c-open-sign-editor),
c-particle(c-particle),
c-ping-response(c-ping-response),
c-player-abilities(c-player-abilities),
c-player-chat-message(c-player-chat-message),
c-player-info-update(c-player-info-update),
c-player-position(c-player-position),
c-remove-player-info(c-remove-player-info),
c-player-spawn-position(c-player-spawn-position),
c-recipe-book-add(c-recipe-book-add),
c-recipe-book-settings(c-recipe-book-settings),
c-remove-entities(c-remove-entities),
c-remove-mob-effect(c-remove-mob-effect),
c-reset-score(c-reset-score),
c-respawn(c-respawn),
c-play-server-links(c-play-server-links),
c-set-border-center(c-set-border-center),
c-set-border-lerp-size(c-set-border-lerp-size),
c-set-border-size(c-set-border-size),
c-set-border-warning-delay(c-set-border-warning-delay),
c-set-border-warning-distance(c-set-border-warning-distance),
c-set-container-content(c-set-container-content),
c-set-container-property(c-set-container-property),
c-set-container-slot(c-set-container-slot),
c-set-cursor-item(c-set-cursor-item),
c-set-equipment(c-set-equipment),
c-set-experience(c-set-experience),
c-set-health(c-set-health),
c-set-passengers(c-set-passengers),
c-set-player-inventory(c-set-player-inventory),
c-set-player-team(c-set-player-team),
c-update-time(c-update-time),
c-title-text(c-title-text),
c-title-animation(c-title-animation),
c-play-show-dialog(c-play-show-dialog),
c-sound-effect(c-sound-effect),
c-spawn-entity(c-spawn-entity),
c-stop-sound(c-stop-sound),
c-store-cookie(c-store-cookie),
c-subtitle(c-subtitle),
c-system-chat-message(c-system-chat-message),
c-tab-list(c-tab-list),
c-take-item-entity(c-take-item-entity),
c-teleport-entity(c-teleport-entity),
c-ticking-state(c-ticking-state),
c-ticking-step(c-ticking-step),
c-transfer(c-transfer),
c-unload-chunk(c-unload-chunk),
c-update-attributes(c-update-attributes),
c-update-entity-pos(c-update-entity-pos),
c-update-entity-pos-rot(c-update-entity-pos-rot),
c-update-entity-rot(c-update-entity-rot),
c-update-mob-effect(c-update-mob-effect),
c-update-objectives(c-update-objectives),
c-update-score(c-update-score),
c-world-event(c-world-event),
}
}

14
v0.1/log.wit Normal file
View File

@ -0,0 +1,14 @@
interface logging {
enum level {
trace,
debug,
info,
warn,
error,
}
/// log any general purpose message
log: func(level: level, message: string);
/// This function is meant to be used by the tracing crate.
log-tracing: func(event: list<u8>);
}

19
v0.1/metadata.wit Normal file
View File

@ -0,0 +1,19 @@
/// Plugin metadata describing the plugin and its compatibility.
interface metadata {
record plugin-metadata {
/// Name of the plugin.
name: string,
/// Plugin version (semver).
version: string,
/// Plugin authors.
authors: list<string>,
/// Short description of the plugin.
description: string,
/// Plugin dependencies.
dependencies: list<string>,
/// Permissions requested by the plugin.
permissions: list<string>,
}
get-metadata: func() -> plugin-metadata;
}

123
v0.1/particles.wit Normal file
View File

@ -0,0 +1,123 @@
package pumpkin:plugin@0.1.0;
interface particles {
enum particle {
angry-villager,
block,
block-marker,
bubble,
cloud,
copper-fire-flame,
crit,
damage-indicator,
dragon-breath,
dripping-lava,
falling-lava,
landing-lava,
dripping-water,
falling-water,
dust,
dust-color-transition,
effect,
elder-guardian,
enchanted-hit,
enchant,
end-rod,
entity-effect,
explosion-emitter,
explosion,
gust,
small-gust,
gust-emitter-large,
gust-emitter-small,
sonic-boom,
falling-dust,
firework,
fishing,
flame,
infested,
cherry-leaves,
pale-oak-leaves,
tinted-leaves,
sculk-soul,
sculk-charge,
sculk-charge-pop,
soul-fire-flame,
soul,
flash,
happy-villager,
composter,
heart,
instant-effect,
item,
vibration,
trail,
pause-mob-growth,
reset-mob-growth,
item-slime,
item-cobweb,
item-snowball,
large-smoke,
lava,
mycelium,
note,
poof,
portal,
rain,
smoke,
white-smoke,
sneeze,
spit,
squid-ink,
sweep-attack,
totem-of-undying,
underwater,
splash,
witch,
bubble-pop,
current-down,
bubble-column-up,
nautilus,
dolphin,
campfire-cosy-smoke,
campfire-signal-smoke,
dripping-honey,
falling-honey,
landing-honey,
falling-nectar,
falling-spore-blossom,
ash,
crimson-spore,
warped-spore,
spore-blossom-air,
dripping-obsidian-tear,
falling-obsidian-tear,
landing-obsidian-tear,
reverse-portal,
white-ash,
small-flame,
snowflake,
dripping-dripstone-lava,
falling-dripstone-lava,
dripping-dripstone-water,
falling-dripstone-water,
glow-squid-ink,
glow,
wax-on,
wax-off,
electric-spark,
scrape,
shriek,
egg-crack,
dust-plume,
trial-spawner-detection,
trial-spawner-detection-ominous,
vault-connection,
dust-pillar,
ominous-spawning,
raid-omen,
trial-omen,
block-crumble,
firefly,
}
}

46
v0.1/permission.wit Normal file
View File

@ -0,0 +1,46 @@
interface permission {
/// Represents the player's permission level
///
/// Permission levels determine the player's access to commands and server operations.
/// Each numeric level corresponds to a specific role:
/// - `Zero`: `normal`: Player can use basic commands.
/// - `One`: `moderator`: Player can bypass spawn protection.
/// - `Two`: `gamemaster`: Player or executor can use more commands and player can use command blocks.
/// - `Three`: `admin`: Player or executor can use commands related to multiplayer management.
/// - `Four`: `owner`: Player or executor can use all of the commands, including commands related to server management.
enum permission-level {
zero,
one,
two,
three,
four,
}
/// Describes the default behavior for permissions
variant permission-default {
/// Permission is not granted by default
deny,
/// Permission is granted by default
allow,
/// Permission is granted by default to operators
op(permission-level),
}
/// A child permission entry
record permission-child {
node: string,
value: bool,
}
/// Defines a permission node in the system
record permission {
/// The full node name (e.g., "minecraft:command.gamemode")
node: string,
/// Description of what this permission does
description: string,
/// The default value of this permission
default: permission-default,
/// Children nodes that are affected by this permission
children: list<permission-child>,
}
}

796
v0.1/player.wit Normal file
View File

@ -0,0 +1,796 @@
/// Represents a player connected to the Minecraft server.
interface player {
use common.{hand, position, game-mode};
use item-stack.{item-stack};
use %world.{%world, entity};
use permission.{permission-level};
use text.{text-component};
use gui.{gui};
use forms.{form};
use java-dialogs.{dialog};
use java-packets.{clientbound-packet as java-packet};
use bedrock-packets.{clientbound-packet as bedrock-packet};
use uuid.{uuid};
/// Various abilities a player can have.
record player-abilities {
/// Whether the player is invulnerable to damage.
invulnerable: bool,
/// Whether the player is currently flying.
flying: bool,
/// Whether the player is allowed to fly.
allow-flying: bool,
/// Whether the player is in creative mode.
creative: bool,
/// Whether the player can modify the world.
allow-modify-world: bool,
/// The speed at which the player flies.
fly-speed: f32,
/// The speed at which the player walks.
walk-speed: f32,
}
/// Represents a player's skin textures and metadata.
record player-skin {
/// The base64-encoded texture data (usually JSON containing skin/cape URLs).
value: string,
/// The optional signature for the texture data.
signature: option<string>,
}
/// Represents which skin parts are visible.
flags skin-parts {
cape,
jacket,
left-sleeve,
right-sleeve,
left-pants-leg,
right-pants-leg,
hat,
}
/// Represents the various abilities a Bedrock Edition player can have.
enum bedrock-ability {
/// Whether the player can build.
build,
/// Whether the player can mine blocks.
mine,
/// Whether the player can use doors and switches.
doors-and-switches,
/// Whether the player can open containers.
open-containers,
/// Whether the player can attack other players.
attack-players,
/// Whether the player can attack mobs.
attack-mobs,
/// Whether the player can use operator commands.
operator-commands,
/// Whether the player can teleport.
teleport,
/// Whether the player is invulnerable.
invulnerable,
/// Whether the player is currently flying.
flying,
/// Whether the player is allowed to fly.
may-fly,
/// Whether the player has instant build (creative).
instabuild,
/// Whether the player can use lightning-related abilities.
lightning,
/// The speed at which the player flies.
fly-speed,
/// The speed at which the player walks.
walk-speed,
/// Whether the player is muted.
muted,
/// Whether the player is a world builder.
world-builder,
/// Whether the player has no-clip enabled.
no-clip,
/// Whether the player is a privileged builder.
privileged-builder,
/// The speed at which the player flies vertically.
vertical-fly-speed,
}
/// Represents the various status flags a Bedrock Edition entity can have.
/// These flags control client-side rendering and behavior.
enum bedrock-status-flag {
/// Whether the entity is currently on fire.
on-fire,
/// Whether the entity is sneaking.
sneaking,
/// Whether the entity is riding another entity.
riding,
/// Whether the entity is sprinting.
sprinting,
/// Whether the entity is using an item (e.g., eating, blocking).
using-item,
/// Whether the entity is invisible.
invisible,
/// Whether the entity is tempted by an item.
tempted,
/// Whether the entity is in love (breeding).
in-love,
/// Whether the entity is saddled.
saddled,
/// Whether the entity is powered (e.g., charged creeper).
powered,
/// Whether the entity is ignited.
ignited,
/// Whether the entity is a baby.
baby,
/// Whether the entity is currently converting to another type.
converting,
/// Whether the entity is in a critical state.
critical,
/// Whether to show the entity's name tag.
show-name,
/// Whether to always show the entity's name tag.
always-show-name,
/// Whether the entity has no AI.
no-ai,
/// Whether the entity is silent.
silent,
/// Whether the entity is climbing a wall.
wall-climbing,
/// Whether the entity is climbing.
climb,
/// Whether the entity is swimming.
swim,
/// Whether the entity is flying.
fly,
/// Whether the entity is walking.
walk,
/// Whether the entity is resting.
resting,
/// Whether the entity is sitting.
sitting,
/// Whether the entity is angry.
angry,
/// Whether the entity is interested.
interested,
/// Whether the entity is charged.
charged,
/// Whether the entity is tamed.
tamed,
/// Whether the entity is orphaned.
orphaned,
/// Whether the entity is leashed.
leashed,
/// Whether the entity is sheared.
sheared,
/// Whether the entity is gliding (elytra).
gliding,
/// Whether the entity is an elder (e.g., elder guardian).
elder,
/// Whether the entity is moving.
moving,
/// Whether the entity is breathing.
breathing,
/// Whether the entity has a chest (e.g., donkey).
chested,
/// Whether the entity is stackable.
stackable,
/// Whether to show the bottom of the entity.
show-bottom,
/// Whether the entity is standing.
standing,
/// Whether the entity is shaking.
shaking,
/// Whether the entity is idling.
idling,
/// Whether the entity is casting (e.g., evoker).
casting,
/// Whether the entity is charging an attack.
charging,
/// Whether the entity is controlled by a keyboard.
keyboard-controlled,
/// Whether the entity is performing a power jump.
power-jump,
/// Whether the entity is dashing.
dash,
/// Whether the entity is lingering.
lingering,
/// Whether the entity has collision.
has-collision,
/// Whether the entity has gravity.
has-gravity,
/// Whether the entity is immune to fire.
fire-immune,
/// Whether the entity is dancing.
dancing,
/// Whether the entity is enchanted.
enchanted,
/// Whether a trident will return to the entity.
return-trident,
/// Whether the container is private.
container-private,
/// Whether the entity is transforming.
transforming,
/// Whether the entity damages nearby mobs.
damage-nearby-mobs,
/// Whether the entity is swimming.
swimming,
/// Whether the entity has been bribed.
bribed,
/// Whether the entity is pregnant.
pregnant,
/// Whether the entity is laying an egg.
laying-egg,
/// Whether a passenger can pick up the entity.
passenger-can-pick,
/// Whether the entity is transitioning to sitting.
transition-sitting,
/// Whether the entity is eating.
eating,
/// Whether the entity is laying down.
laying-down,
/// Whether the entity is sneezing.
sneezing,
/// Whether the entity is trusting.
trusting,
/// Whether the entity is rolling.
rolling,
/// Whether the entity is scared.
scared,
/// Whether the entity is in scaffolding.
in-scaffolding,
/// Whether the entity is over scaffolding.
over-scaffolding,
/// Whether the entity is descending through a block.
descend-through-block,
/// Whether the entity is blocking.
blocking,
/// Whether the entity is transitioning to blocking.
transition-blocking,
/// Whether the entity is blocked using a shield.
blocked-using-shield,
/// Whether the entity is blocked using a damaged shield.
blocked-using-damaged-shield,
/// Whether the entity is sleeping.
sleeping,
/// Whether the entity wants to wake up.
wants-to-wake,
/// Whether the entity shows interest in trading.
trade-interest,
/// Whether the entity can break doors.
door-breaker,
/// Whether the entity is breaking an obstruction.
breaking-obstruction,
/// Whether the entity can open doors.
door-opener,
/// Whether the entity is a captain (raid).
captain,
/// Whether the entity is stunned.
stunned,
/// Whether the entity is roaring.
roaring,
/// Whether the entity has a delayed attack.
delayed-attack,
/// Whether the entity is avoiding mobs.
avoiding-mobs,
/// Whether the entity is avoiding a block.
avoiding-block,
/// Whether the entity is facing a target for a ranged attack.
facing-target-to-range-attack,
/// Whether the entity is hidden when invisible.
hidden-when-invisible,
/// Whether the entity is in a UI.
in-ui,
/// Whether the entity is stalking.
stalking,
/// Whether the entity is emoting.
emoting,
/// Whether the entity is celebrating.
celebrating,
/// Whether the entity is admiring (piglin).
admiring,
/// Whether the entity is celebrating a special event.
celebrating-special,
/// Whether the entity is out of control.
out-of-control,
/// Whether the entity is performing a ram attack.
ram-attack,
/// Whether the entity is playing dead.
playing-dead,
/// Whether the entity is in an ascending block.
in-ascending-block,
/// Whether the entity is over a descending block.
over-descending-block,
/// Whether the entity is croaking (frog).
croaking,
/// Whether the entity is digesting a mob.
digest-mob,
/// Whether the entity has a jump goal.
jump-goal,
/// Whether the entity is emerging.
emerging,
/// Whether the entity is sniffing.
sniffing,
/// Whether the entity is digging.
digging,
/// Whether the entity is performing a sonic boom.
sonic-boom,
/// Whether the entity has a dash timeout.
has-dash-timeout,
/// Whether the entity is pushed towards the closest space.
push-towards-closest-space,
/// Whether the entity is scenting.
scenting,
/// Whether the entity is rising.
rising,
/// Whether the entity is feeling happy.
feeling-happy,
/// Whether the entity is searching.
searching,
/// Whether the entity is crawling.
crawling,
/// Whether the entity's body rotation is blocked.
body-rotation-blocked,
/// Whether the entity is rendered when invisible.
render-when-invisible,
/// Whether the entity's body rotation is axis-aligned.
body-rotation-axis-aligned,
/// Whether the entity is collidable.
collidable,
/// Whether the entity is air-controlled via WASD.
wasd-air-controlled,
/// Whether only the server can authorize a dismount.
does-server-auth-only-dismount,
/// Whether the body rotation always follows the head.
body-rotation-always-follows-head,
/// Whether the entity can use vertical movement actions.
can-use-vertical-movement-action,
/// Whether rotation is locked to the vehicle.
rotation-locked-to-vehicle,
}
/// Represents a specific version of the Minecraft Java Edition protocol.
enum java-minecraft-version {
v-1-7-2,
v-1-7-6,
v-1-8,
v-1-9,
v-1-9-1,
v-1-9-2,
v-1-9-3,
v-1-10,
v-1-11,
v-1-11-1,
v-1-12,
v-1-12-1,
v-1-12-2,
v-1-13,
v-1-13-1,
v-1-13-2,
v-1-14,
v-1-14-1,
v-1-14-2,
v-1-14-3,
v-1-14-4,
v-1-15,
v-1-15-1,
v-1-15-2,
v-1-16,
v-1-16-1,
v-1-16-2,
v-1-16-3,
v-1-16-4,
v-1-17,
v-1-17-1,
v-1-18,
v-1-18-2,
v-1-19,
v-1-19-1,
v-1-19-3,
v-1-19-4,
v-1-20,
v-1-20-2,
v-1-20-3,
v-1-20-5,
v-1-21,
v-1-21-2,
v-1-21-4,
v-1-21-5,
v-1-21-6,
v-1-21-7,
v-1-21-9,
v-1-21-11,
v-26-1,
unknown,
}
/// Represents a specific version of the Minecraft Bedrock Edition protocol.
enum bedrock-minecraft-version {
v-1-21,
v-1-26-20,
unknown,
}
/// Represents settings for a Java Edition player.
record java-player-settings {
/// The player's preferred language (e.g., \"en_us\").
locale: string,
/// The maximum distance at which chunks are rendered.
view-distance: u8,
/// The player's chat visibility settings.
chat-mode: chat-mode,
/// Whether chat colors are enabled.
chat-colors: bool,
/// The player's skin configuration options.
skin-parts: skin-parts,
/// The player's dominant hand (left or right).
main-hand: hand,
/// Whether text filtering is enabled.
text-filtering: bool,
/// Whether the player wants to appear in the server list.
server-listing: bool,
}
/// The chat visibility settings for a player.
enum chat-mode {
/// Chat is fully enabled.
enabled,
/// Only system messages and commands are shown.
commands-only,
/// Chat is completely hidden.
hidden,
}
/// Represents the operating system of a Bedrock Edition client.
enum bedrock-device-os {
android,
ios,
osx,
amazon,
gear-vr,
holo-lens,
windows-10,
win-32,
dedicated,
tv-os,
playstation,
nintendo,
xbox,
windows-phone,
linux,
/// Fallback for unrecognized operating systems.
unknown,
}
/// Represents the input mode used by a Bedrock Edition client.
enum bedrock-input-mode {
/// Unknown input mode.
unknown,
/// Mouse and keyboard.
mouse,
/// Touch screen.
touch,
/// Game controller.
game-pad,
/// Motion-based controller.
motion-controller,
}
/// Represents the UI profile used by a Bedrock Edition client.
enum bedrock-ui-profile {
/// Classic desktop UI.
classic,
/// Pocket/Mobile optimized UI.
pocket,
/// Unknown UI profile.
unknown,
}
/// Represents the graphics mode used by a Bedrock Edition client.
enum bedrock-graphics-mode {
simple,
fancy,
ray-traced,
unknown,
}
/// Represents settings and client data for a Bedrock Edition player.
record bedrock-player-settings {
/// The client's specific game version string.
game-version: string,
/// The operating system of the client device.
device-os: bedrock-device-os,
/// A unique identifier for the client device.
device-id: string,
/// The model name of the client device.
device-model: string,
/// The player's preferred language code (e.g., \"en_US\").
language-code: string,
/// The input mode currently used by the player.
current-input-mode: bedrock-input-mode,
/// The default input mode for the client device.
default-input-mode: bedrock-input-mode,
/// The UI layout profile used by the client.
ui-profile: bedrock-ui-profile,
/// The current GUI scale setting.
gui-scale: s32,
/// Whether the player is in Editor mode.
is-editor-mode: bool,
/// The maximum view distance the client supports.
max-view-distance: s32,
/// The memory tier of the client device (indicates performance level).
memory-tier: s32,
/// The graphics mode used by the client.
graphics-mode: bedrock-graphics-mode,
/// The player's unique PlayFab identifier.
playfab-id: string,
/// A random 64-bit ID generated by the client.
client-random-id: s64,
/// Platform-specific offline identifier.
platform-offline-id: string,
/// Platform-specific online identifier.
platform-online-id: string,
/// The unique ID of the player's current skin.
skin-id: string,
/// The model arm size (e.g., \"wide\" or \"slim\").
arm-size: string,
/// Whether the player is using a Character Creator (Persona) skin.
is-persona-skin: bool,
/// Whether the skin is a premium (paid) skin.
is-premium-skin: bool,
/// Whether the skin is from a trusted source.
is-trusted-skin: bool,
}
/// A handle to a player on the server.
resource player {
/// Returns the player as an entity.
as-entity: func () -> entity;
/// Returns the player's unique UUID as a string.
get-id: func () -> uuid;
/// Returns the player's username.
get-name: func () -> string;
// Basic state
/// Returns the player's current position in the world.
get-position: func () -> position;
/// Returns the player's current yaw (horizontal rotation).
get-yaw: func () -> f32;
/// Returns the player's current pitch (vertical rotation).
get-pitch: func () -> f32;
/// Returns the world the player is currently in.
get-world: func () -> %world;
/// Returns the player's current game mode.
get-gamemode: func () -> game-mode;
/// Changes the player's game mode. Returns true if successful.
set-gamemode: func (mode: game-mode) -> bool;
/// Returns the player's locale (e.g., \"en_us\").
get-locale: func () -> string;
/// Returns the player's current ping in milliseconds.
get-ping: func () -> u32;
// Permissions & metadata
/// Returns the player's permission level (0-4).
get-permission-level: func () -> permission-level;
/// Sets the player's permission level.
set-permission-level: func (level: permission-level);
/// Grants or denies a specific permission node for the player.
set-permission: func(node: string, value: bool);
/// Removes an explicitly set permission node from the player.
unset-permission: func(node: string);
/// Returns `Some(true)` if granted, `Some(false)` if denied, or `None` if not set.
has-permission-set: func (node: string) -> option<bool>;
/// Checks if the player has a specific permission node.
has-permission: func (node: string) -> bool;
/// Returns the player's display name, which may include formatting.
get-display-name: func () -> text-component;
/// Sets the player's display name.
set-display-name: func (display-name: text-component);
/// Gets the player's custom tab list name.
get-tab-list-name: func () -> option<text-component>;
/// Sets the player's custom tab list name.
set-tab-list-name: func (name: option<text-component>);
// Messaging & titles
/// Sends a system message to the player's chat.
send-system-message: func (text: text-component, overlay: bool);
/// Sets the header and footer of the player's Tab list.
set-tab-list-header-footer: func (header: text-component, footer: text-component);
/// Sets the sorting order of the player in the Tab list.
set-tab-list-order: func (order: s32);
/// Sets the latency (ping) shown for the player in the Tab list.
set-tab-list-latency: func (latency: s32);
/// Sets whether the player is visible in the Tab list.
set-tab-list-listed: func (listed: bool);
/// Shows a large title on the player's screen.
show-title: func (text: text-component);
/// Shows a smaller subtitle on the player's screen.
show-subtitle: func (text: text-component);
/// Shows a message in the action bar area.
show-actionbar: func (text: text-component);
/// Sets the fade-in, stay, and fade-out times for titles.
send-title-animation: func (fade-in: s32, stay: s32, fade-out: s32);
// Teleport & kick
/// Teleports the player to a position in a world.
teleport: func (position: position, yaw: option<f32>, pitch: option<f32>, %world: %world);
/// Teleports the player to another world at a specific position.
teleport-world: func (world-ref: %world, position: position, yaw: option<f32>, pitch: option<f32>);
/// Kicks the player from the server with the specified reason.
kick: func (message: text-component);
/// Forces the player to respawn.
respawn: func ();
/// Opens a GUI for the player.
open-gui: func (gui-ref: gui);
/// Bans the player with an optional reason.
ban: func (reason: option<text-component>);
/// Bans the player's IP address with an optional reason.
ban-ip: func (reason: option<text-component>);
/// Transfers the player to another server.
transfer: func (host: string, port: u16);
// Inventory
/// Returns the index of the currently selected hotbar slot (0-8).
get-selected-slot: func () -> u8;
/// Returns the item currently in the specified hand.
get-item-in-hand: func (hand: hand) -> option<item-stack>;
/// Returns the item in the specified inventory slot.
get-inventory-item: func (slot: u8) -> option<item-stack>;
/// Sets the item in the specified hand.
set-item-in-hand: func (hand: hand, stack: option<item-stack>);
/// Sets the item in the specified inventory slot.
set-inventory-item: func (slot: u8, stack: option<item-stack>);
// Status
/// Returns the player's current health.
get-health: func () -> f32;
/// Sets the player's current health.
set-health: func (health: f32);
/// Returns the player's maximum health.
get-max-health: func () -> f32;
/// Sets the player's maximum health.
set-max-health: func (max-health: f32);
/// Returns the player's food level (0-20).
get-food-level: func () -> u8;
/// Sets the player's food level.
set-food-level: func (food-level: u8);
/// Returns the player's food saturation level.
get-saturation: func () -> f32;
/// Sets the player's food saturation level.
set-saturation: func (saturation: f32);
/// Returns the player's food exhaustion level.
get-exhaustion: func () -> f32;
/// Sets the player's food exhaustion level.
set-exhaustion: func (exhaustion: f32);
/// Returns the player's current absorption amount.
get-absorption: func () -> f32;
/// Sets the player's current absorption amount.
set-absorption: func (absorption: f32);
/// Returns the player's total experience level.
get-experience-level: func() -> s32;
/// Returns the player's progress toward the next level (0.0 to 1.0).
get-experience-progress: func() -> f32;
/// Returns the total experience points the player has.
get-experience-points: func() -> s32;
/// Sets the player's total experience level.
set-experience-level: func(level: s32);
/// Sets the player's progress toward the next level.
set-experience-progress: func(progress: f32);
/// Sets the player's total experience points.
set-experience-points: func(points: s32);
/// Adds experience levels to the player.
add-experience-levels: func(levels: s32);
/// Adds experience points to the player.
add-experience-points: func(points: s32);
/// Returns whether the player is currently flying.
is-flying: func() -> bool;
/// Sets whether the player should be flying.
set-flying: func(flying: bool);
/// Returns the player's current abilities.
get-abilities: func() -> player-abilities;
/// Updates the player's abilities.
set-abilities: func(abilities: player-abilities);
/// Returns the player's IP address.
get-ip: func() -> string;
/// Returns the player's current skin textures.
get-skin: func() -> option<player-skin>;
/// Updates the player's skin textures.
/// Note: this only updates the fields, it doesn't reload the skin.
set-skin: func(skin: player-skin);
/// Returns which skin parts are visible.
get-skin-parts: func() -> skin-parts;
/// Sets which skin parts are visible.
set-skin-parts: func(parts: skin-parts);
/// Returns a Java-specific player handle, if the player is connected via Java Edition.
///
/// This allows access to Java-exclusive features like sending specific packets
/// or retrieving the client brand.
as-java: func() -> option<java-player>;
/// Returns a Bedrock-specific player handle, if the player is connected via Bedrock Edition.
///
/// This allows access to Bedrock-exclusive features like custom forms
/// or detailed device information.
as-bedrock: func() -> option<bedrock-player>;
}
/// A handle to a player connected via the Java Edition.
resource java-player {
/// Returns the Minecraft Java Edition version of the player.
get-version: func() -> java-minecraft-version;
/// Returns the brand of the player's client (e.g., \"vanilla\", \"fabric\").
get-brand: func() -> string;
/// Returns the server address the player used to connect.
get-server-address: func() -> string;
/// Returns the player's configuration settings.
get-settings: func() -> java-player-settings;
/// Sends a Java-specific clientbound packet to the player.
send-packet: func(packet: java-packet);
/// Sends a custom payload packet (plugin message) to the player.
send-custom-payload: func(channel: string, data: list<u8>);
/// Shows a dialog to the player.
show-dialog: func(dialog: dialog);
/// Clears any currently shown dialog for the player.
clear-dialog: func();
}
/// A handle to a player connected via the Bedrock Edition.
resource bedrock-player {
/// Returns the Minecraft Bedrock Edition version of the player.
get-version: func() -> bedrock-minecraft-version;
/// Returns the player's configuration settings.
get-settings: func() -> bedrock-player-settings;
/// Returns whether a specific Bedrock-only ability is enabled for the player.
get-ability: func(ability: bedrock-ability) -> bool;
/// Sets whether a specific Bedrock-only ability is enabled for the player.
set-ability: func(ability: bedrock-ability, value: bool);
/// Returns whether a specific Bedrock-only status flag is enabled for the player.
///
/// Status flags control things like whether the player is on fire, sneaking,
/// sprinting, or has specific visual effects.
get-status-flag: func(flag: bedrock-status-flag) -> bool;
/// Sets whether a specific Bedrock-only status flag is enabled for the player.
///
/// This can be used to manually trigger client-side visual states.
set-status-flag: func(flag: bedrock-status-flag, value: bool);
/// Sends a Bedrock-specific clientbound packet to the player.
send-packet: func(packet: bedrock-packet);
/// Opens a Bedrock custom form for the player.
open-form: func(form: form) -> u32;
}
/// Returns a list of all players in a specific world.
get-world-players: func(world-ref: %world) -> list<player>;
}

68
v0.1/plugin.wit Normal file
View File

@ -0,0 +1,68 @@
/// The main entry point for a Pumpkin plugin.
/// This world defines the exports that the plugin must provide to the host
/// and the imports that the host provides to the plugin.
package pumpkin:plugin@0.1.0;
world plugin {
use context.{context};
use event.{event};
use server.{server as server-instance};
use command.{command-sender, consumed-args, command-error};
// --- Host-provided imports ---
/// Provides logging capabilities to the plugin.
import logging;
/// Provides GUI creation and management.
import gui;
/// Provides scoreboard management.
import scoreboard;
/// Provides global server information and player lookup.
import server;
/// Provides text component building and formatting.
import text;
/// Provides command registration and argument parsing.
import command;
/// Provides the plugin execution context.
import context;
/// Provides internationalization and translation support.
import i18n;
/// Provides task scheduling for delayed or repeating logic.
import scheduler;
/// Provides world information and block manipulation.
import %world;
/// Provides entity types and manipulation.
import entity;
/// Provides boss bar creation and management.
import boss-bar;
/// Provides Bedrock custom forms.
import forms;
/// Provides Java Edition dialogs.
import java-dialogs;
// --- Plugin-provided exports ---
/// Called by the host once to initialize the plugin.
/// Internal use only; plugins should use the `register_plugin!` macro.
export init-plugin: func();
/// Called when the plugin is being loaded.
/// Use this to register commands, events, and perform initial setup.
export on-load: func(context: context) -> result<_, string>;
/// Called when the plugin is being unloaded.
/// Use this to save data and clean up resources.
export on-unload: func(context: context) -> result<_, string>;
/// Provides plugin metadata (name, version, etc.) to the host.
export metadata;
/// Dispatches an event to the plugin for handling.
export handle-event: func(event-id: u32, server: server-instance, event: event) -> event;
/// Dispatches a command execution to the plugin.
export handle-command: func(command-id: u32, sender: command-sender, server: server-instance, args: consumed-args) -> result<s32, command-error>;
/// Dispatches a scheduled task execution to the plugin.
export handle-task: func(handler-id: u32, server: server-instance);
}

67
v0.1/recipe.wit Normal file
View File

@ -0,0 +1,67 @@
interface recipe {
use item-stack.{item-stack};
/// Represents an ingredient in a recipe.
variant ingredient {
/// A specific item.
item(string),
/// A tag group of items (e.g., "minecraft:logs").
tag(string),
}
/// Represents a shaped crafting recipe.
record shaped-recipe {
/// The pattern of the recipe (e.g., ["# #", " s ", "# #"]).
pattern: list<string>,
/// Mapping of characters in the pattern to ingredients.
key: list<tuple<string, ingredient>>,
/// The resulting item stack.
output: item-stack,
/// The recipe group (optional).
group: option<string>,
}
/// Represents a shapeless crafting recipe.
record shapeless-recipe {
/// The list of ingredients required.
ingredients: list<ingredient>,
/// The resulting item stack.
output: item-stack,
/// The recipe group (optional).
group: option<string>,
}
/// Represents a cooking recipe (Smelting, Blasting, Smoking, Campfire).
record cooking-recipe {
/// The ingredient to cook.
ingredient: ingredient,
/// The resulting item stack.
output: item-stack,
/// Experience points awarded.
experience: f32,
/// Cooking time in ticks.
cooking-time: u32,
/// The recipe group (optional).
group: option<string>,
}
/// Types of cooking stations.
enum cooking-type {
smelting,
blasting,
smoking,
campfire,
}
/// Common interface for registering recipes.
resource recipe-manager {
/// Registers a shaped crafting recipe.
register-shaped: func(id: string, recipe: shaped-recipe);
/// Registers a shapeless crafting recipe.
register-shapeless: func(id: string, recipe: shapeless-recipe);
/// Registers a cooking recipe.
register-cooking: func(id: string, station-type: cooking-type, recipe: cooking-recipe);
}
}

24
v0.1/scheduler.wit Normal file
View File

@ -0,0 +1,24 @@
/// Provides functionality to schedule tasks to be executed later on the server.
interface scheduler {
/// Schedules a task to be executed once after the specified number of ticks.
///
/// * `handler-id`: The unique ID of the handler to call when the task executes.
/// * `delay-ticks`: The number of game ticks to wait before execution (20 ticks = 1 second).
///
/// Returns a unique task ID that can be used to cancel the task.
schedule-delayed-task: func(handler-id: u32, delay-ticks: u64) -> u32;
/// Schedules a task to be executed repeatedly.
///
/// * `handler-id`: The unique ID of the handler to call when the task executes.
/// * `delay-ticks`: The number of game ticks to wait before the first execution.
/// * `period-ticks`: The number of game ticks between subsequent executions.
///
/// Returns a unique task ID that can be used to cancel the task.
schedule-repeating-task: func(handler-id: u32, delay-ticks: u64, period-ticks: u64) -> u32;
/// Cancels a scheduled task if it hasn't finished yet.
///
/// * `task-id`: The ID of the task to cancel.
cancel-task: func(task-id: u32);
}

72
v0.1/scoreboard.wit Normal file
View File

@ -0,0 +1,72 @@
interface scoreboard {
use text.{text-component};
use common.{named-color};
enum render-type {
integer,
hearts
}
enum display-slot {
player-list,
sidebar,
below-name,
sidebar-team-black,
sidebar-team-dark-blue,
sidebar-team-dark-green,
sidebar-team-dark-aqua,
sidebar-team-dark-red,
sidebar-team-dark-purple,
sidebar-team-gold,
sidebar-team-gray,
sidebar-team-dark-gray,
sidebar-team-blue,
sidebar-team-green,
sidebar-team-aqua,
sidebar-team-red,
sidebar-team-light-purple,
sidebar-team-yellow,
sidebar-team-white,
}
enum nametag-visibility {
always,
never,
hide-for-other-teams,
hide-for-own-team
}
enum collision-rule {
always,
never,
push-other-teams,
push-own-team
}
record team-settings {
display-name: text-component,
friendly-fire: bool,
see-friendly-invisibles: bool,
nametag-visibility: nametag-visibility,
collision-rule: collision-rule,
color: named-color,
prefix: text-component,
suffix: text-component
}
resource scoreboard {
add-objective: func(name: string, display-name: text-component, render-type: render-type);
remove-objective: func(name: string);
set-display-slot: func(slot: display-slot, objective-name: string);
update-score: func(entity-name: string, objective-name: string, value: s32);
remove-score: func(entity-name: string, objective-name: string);
create-team: func(name: string, settings: team-settings);
remove-team: func(name: string);
update-team: func(name: string, settings: team-settings);
add-player-to-team: func(team-name: string, player-name: string);
remove-player-from-team: func(team-name: string, player-name: string);
}
}

122
v0.1/server.wit Normal file
View File

@ -0,0 +1,122 @@
interface server {
use player.{player};
use common.{game-mode};
use %world.{%world};
use text.{text-component};
use uuid.{uuid};
use recipe.{recipe-manager};
/// Represents the difficulty setting of a Minecraft server.
enum difficulty {
/// Hostile mobs do not spawn. Players regain health automatically.
peaceful,
/// Hostile mobs deal less damage.
easy,
/// Standard Minecraft difficulty.
normal,
/// Hostile mobs deal more damage.
hard,
}
/// Represents the three main Minecraft dimensions.
enum dimension {
overworld,
nether,
end,
}
record sys-info {
cpu-count: option<u32>,
total-memory: option<u64>,
used-memory: option<u64>,
os-name: option<string>,
os-version: option<string>,
pumpkin-version: string,
}
variant command-sender {
console,
player(player),
}
/// Represents the global server instance.
resource server {
/// Returns system information (CPU, Memory, OS).
/// Fields are returned only if the plugin has the corresponding permissions.
get-sys-info: func() -> sys-info;
/// Returns the current difficulty level of the server.
get-difficulty: func() -> difficulty;
/// Returns the total number of players currently connected to the server.
get-player-count: func() -> u32;
/// Returns the rolling average Milliseconds Per Tick (MSPT).
/// A value below 50.0 is required for a stable 20 TPS.
get-mspt: func() -> f64;
/// Returns the effective Ticks Per Second (TPS).
/// Ideal value is 20.0.
get-tps: func() -> f64;
/// Returns a list of all online players across all worlds.
get-all-players: func() -> list<player>;
/// Searches for a player by their exact name.
get-player-by-name: func(name: string) -> option<player>;
/// Searches for a player by their UUID string.
get-player-by-uuid: func(id: uuid) -> option<player>;
/// Returns a list of all worlds on this server.
get-all-worlds: func() -> list<%world>;
/// Gets a world by its dimension name (e.g., "minecraft:overworld").
get-world-by-name: func(name: string) -> option<%world>;
execute-command: func(command: string, sender: command-sender);
/// Creates or loads a world by its name and dimension.
/// If a world with the given name already exists, it will be returned.
create-world: func(name: string, dimension: dimension) -> %world;
/// Broadcasts a system chat message to all players.
broadcast: func(message: string);
/// Broadcasts a tab list header and footer to all players.
broadcast-tab-list-header-footer: func(header: text-component, footer: text-component);
/// Returns the maximum number of players allowed on the server.
get-max-players: func() -> u32;
/// Returns whether the server is in hardcore mode.
is-hardcore: func() -> bool;
/// Returns whether the server is in online mode (authenticates with Mojang).
is-online-mode: func() -> bool;
/// Returns the server's Message of the Day (MOTD).
get-motd: func() -> string;
/// Returns whether the server has a whitelist enabled.
has-whitelist: func() -> bool;
/// Returns whether the server allows the Nether dimension.
get-allow-nether: func() -> bool;
/// Returns whether the server allows the End dimension.
get-allow-end: func() -> bool;
/// Returns the server's maximum view distance.
get-view-distance: func() -> u8;
/// Returns the server's maximum simulation distance.
get-simulation-distance: func() -> u8;
/// Returns the server's default gamemode.
get-default-gamemode: func() -> game-mode;
/// Returns the recipe manager to register custom recipes.
get-recipe-manager: func() -> recipe-manager;
}
}

1908
v0.1/sounds.wit Normal file
View File

File diff suppressed because it is too large Load Diff

41
v0.1/text.wit Normal file
View File

@ -0,0 +1,41 @@
interface text {
use common.{named-color, rgb-color, argb-color};
resource text-component {
text: static func(plain: string) -> text-component;
translate: static func(key: string, %with: list<text-component>) -> text-component;
add-child: func(child: text-component);
add-text: func(text: string);
get-text: func() -> string;
encode: func() -> list<u8>;
// Style
color-named: func(color: named-color);
color-rgb: func(color: rgb-color);
bold: func(value: bool);
italic: func(value: bool);
underlined: func(value: bool);
strikethrough: func(value: bool);
obfuscated: func(value: bool);
/// Text inserted into chat when shift-clicked
insertion: func(text: string);
font: func(font: string);
shadow-color: func(color: argb-color);
// Click events
click-open-url: func(url: string);
click-run-command: func(command: string);
click-suggest-command: func(command: string);
click-copy-to-clipboard: func(text: string);
// Hover events
hover-show-text: func(text: text-component);
/// Item data as SNBT string
hover-show-item: func(item: string);
hover-show-entity: func(entity-type: string, id: string, name: option<text-component>);
}
}

16
v0.1/uuid.wit Normal file
View File

@ -0,0 +1,16 @@
interface uuid {
/// A 128-bit UUID represented as two 64-bit integers.
record uuid {
high: u64,
low: u64,
}
/// Generates a new random v4 UUID.
generate: func() -> uuid;
/// Parses a UUID from a string. Returns none if the string is not a valid UUID.
parse: func(s: string) -> option<uuid>;
/// Converts a UUID to its standard string representation.
to-string: func(id: uuid) -> string;
}

387
v0.1/world.wit Normal file
View File

@ -0,0 +1,387 @@
interface %world {
use common.{position, entity-pose, block-pos};
use block-entity.{block-entity, command-block-entity, block-entity-type};
use text.{text-component};
use scoreboard.{scoreboard};
use particles.{particle};
use sounds.{sound};
use entity-types.{entity-type};
use biomes.{biome};
use uuid.{uuid};
/// Defines how a block reacts when pushed by a piston.
enum piston-behavior {
/// Normal behavior; the block can be pushed and pulled.
normal,
/// The block is destroyed when pushed.
destroy,
/// The block cannot be pushed or pulled.
block,
/// The block is ignored by pistons.
ignore,
/// The block can only be pushed, not pulled.
push-only
}
/// Categories for sounds to control their volume independently.
enum sound-category {
master,
music,
records,
weather,
blocks,
hostile,
neutral,
players,
ambient,
voice,
}
/// Defines how an explosion interacts with blocks in the world.
enum explosion-interaction {
/// No interaction with blocks.
none,
/// Blocks are destroyed and may drop loot.
block,
/// Interaction typical for mob-caused explosions.
mob,
/// Interaction typical for TNT explosions.
tnt,
/// Triggers specific block behaviors.
trigger,
}
/// Flags used to control block updates and notifications.
flags block-flags {
/// Notifies neighbor blocks of the change.
notify-neighbors,
/// Notifies client listeners of the change.
notify-listeners,
/// Forces the block state even if it's the same.
force-state,
/// Skips dropping items when the block is removed.
skip-drops,
/// Indicates the block was moved (e.g., by a piston).
moved,
/// Skips state replacement for redstone wires.
skip-redstone-wire-state-replacement,
/// Skips the callback when a block entity is replaced.
skip-block-entity-replaced-callback,
/// Skips the callback when a block is added.
skip-block-added-callback,
}
/// Detailed information about a block's state.
record block-state {
/// The internal numerical ID of the block state.
id: u16,
/// The light level emitted by this block (0-15).
luminance: u8,
/// How much light this block blocks.
opacity: u8,
/// The hardness of the block, determining mining speed.
hardness: f32,
/// Whether this block is considered air.
is-air: bool,
/// Whether this block is a liquid.
is-liquid: bool,
/// Whether this block is a solid.
is-solid: bool,
/// Whether this block occupies a full cube.
is-full-cube: bool,
/// How this block behaves when pushed by a piston.
piston-behavior: piston-behavior,
/// Whether this block receives random ticks.
has-random-ticks: bool,
/// Whether this block can catch fire.
burnable: bool,
/// Whether a specific tool is required to mine this block and get drops.
tool-required: bool,
/// Whether this block has transparency on its sides.
sided-transparency: bool,
/// Whether this block can be replaced by another block (e.g., grass).
replaceable: bool,
/// Whether this block is considered a solid block for redstone purposes.
is-solid-block: bool,
/// The numerical ID of the block entity type, if any.
block-entity-type: u16,
/// The instrument used for note blocks when placed on top of this block.
instrument: noteblock-instrument,
/// The collision shapes of this block.
collision-shapes: list<bounding-box>,
/// The outline shapes of this block.
outline-shapes: list<bounding-box>,
/// Whether the bottom side of the block is solid.
down-side-solid: bool,
/// Whether the top side of the block is solid.
up-side-solid: bool,
/// Whether the north side of the block is solid.
north-side-solid: bool,
/// Whether the south side of the block is solid.
south-side-solid: bool,
/// Whether the west side of the block is solid.
west-side-solid: bool,
/// Whether the east side of the block is solid.
east-side-solid: bool,
/// Whether the center of the bottom side is solid.
down-center-solid: bool,
/// Whether the center of the top side is solid.
up-center-solid: bool,
/// The color of this block when displayed on a map.
map-color: u8,
}
/// Musical instruments used by note blocks.
enum noteblock-instrument {
harp,
basedrum,
snare,
hat,
bass,
flute,
bell,
guitar,
chime,
xylophone,
iron-xylophone,
cow-bell,
didgeridoo,
bit,
banjo,
pling,
trumpet,
trumpet-exposed,
trumpet-oxidized,
trumpet-weathered,
zombie,
skeleton,
creeper,
dragon,
wither-skeleton,
piglin,
custom-head,
}
/// A simple wrapper for a block state ID.
record block-state-id {
id: u16,
}
resource entity {
get-id: func() -> u32;
get-uuid: func() -> uuid;
get-type: func() -> entity-type;
get-position: func() -> position;
get-world: func() -> %world;
get-yaw: func() -> f32;
get-pitch: func() -> f32;
get-head-yaw: func() -> f32;
teleport: func(pos: position, world-ref: %world);
set-velocity: func(velocity: position);
get-velocity: func() -> position;
get-pose: func() -> entity-pose;
get-name: func() -> text-component;
set-custom-name: func(name: text-component);
get-custom-name: func() -> option<text-component>;
set-custom-name-visible: func(visible: bool);
is-custom-name-visible: func() -> bool;
is-invulnerable: func() -> bool;
set-invulnerable: func(invulnerable: bool);
get-fire-ticks: func() -> s32;
set-fire-ticks: func(ticks: s32);
get-health: func() -> f32;
set-health: func(health: f32);
get-max-health: func() -> f32;
damage: func(amount: f32);
is-dead: func() -> bool;
get-absorption: func() -> f32;
set-absorption: func(amount: f32);
get-age: func() -> s32;
set-age: func(age: s32);
get-fall-distance: func() -> f32;
set-fall-distance: func(distance: f32);
get-ticks-lived: func() -> s32;
set-ticks-lived: func(ticks: s32);
is-sneaking: func() -> bool;
set-sneaking: func(sneaking: bool);
is-sprinting: func() -> bool;
set-sprinting: func(sprinting: bool);
is-swimming: func() -> bool;
set-swimming: func(swimming: bool);
is-invisible: func() -> bool;
set-invisible: func(invisible: bool);
is-glowing: func() -> bool;
set-glowing: func(glowing: bool);
is-fall-flying: func() -> bool;
set-fall-flying: func(fall-flying: bool);
get-width: func() -> f32;
get-height: func() -> f32;
set-rotation: func(yaw: f32, pitch: f32);
is-on-ground: func() -> bool;
is-on-fire: func() -> bool;
set-on-fire: func(on-fire: bool);
has-visual-fire: func() -> bool;
set-visual-fire: func(visual-fire: bool);
get-portal-cooldown: func() -> u32;
set-portal-cooldown: func(cooldown: u32);
get-remaining-air: func() -> s32;
set-remaining-air: func(air: s32);
get-max-air: func() -> s32;
send-system-message: func(message: text-component);
get-eye-height: func() -> f32;
get-eye-position: func() -> position;
get-nearby-entities: func(x: f64, y: f64, z: f64) -> list<entity>;
get-vehicle: func() -> option<entity>;
get-passengers: func() -> list<entity>;
add-passenger: func(passenger: entity);
remove-passenger: func(passenger: entity);
eject-passengers: func();
get-bounding-box: func() -> bounding-box;
is-in-water: func() -> bool;
is-in-lava: func() -> bool;
remove: func();
/// Performs a raycast from the entity's eye position in its looking direction.
raycast: func(max-distance: f64, fluid-handling: bool) -> option<raycast-result>;
}
/// Result of a raycast operation.
record raycast-result {
/// The block position that was hit.
pos: block-pos,
/// The face of the block that was hit.
face: block-direction,
}
/// Represents an axis-aligned bounding box.
record bounding-box {
min: position,
max: position,
}
/// Represents a cardinal direction or block face.
enum block-direction {
down,
up,
north,
south,
west,
east,
}
/// Represents a Minecraft world (dimension).
resource %world {
/// Returns the unique identifier of this world.
get-id: func() -> string;
/// Gets the block state ID at the specified position.
get-block-state-id: func(pos: block-pos) -> u16;
/// Gets detailed block state information at the specified position.
get-block-state: func(pos: block-pos) -> block-state;
/// Sets the block state at the specified position.
set-block-state: func(pos: block-pos, state: u16, update-flags: block-flags);
/// Returns the current time of day in ticks.
get-time-of-day: func() -> u64;
/// Sets the current time of day in ticks.
set-time-of-day: func(time: u64);
/// Returns the total age of the world in ticks.
get-world-age: func() -> u64;
/// Returns the dimension type (e.g., \"minecraft:overworld\").
get-dimension: func() -> string;
/// Gets the highest non-air block Y coordinate at the specified X and Z.
get-top-block-y: func(x: s32, z: s32) -> s32;
/// Gets the highest motion-blocking block Y coordinate.
get-motion-blocking-height: func(x: s32, z: s32) -> s32;
/// Returns whether it is currently raining or snowing.
is-raining: func() -> bool;
/// Sets whether it should be raining or snowing.
set-raining: func(raining: bool);
/// Returns whether there is currently a thunderstorm.
is-thundering: func() -> bool;
/// Sets whether there should be a thunderstorm.
set-thundering: func(thundering: bool);
/// Broadcasts a system message to all players in this world.
broadcast-system-message: func(message: text-component, overlay: bool);
/// Returns the scoreboard associated with this world.
get-scoreboard: func() -> scoreboard;
/// Plays a sound at the specified position for all players in the world.
play-sound: func(sound: sound, category: sound-category, pos: position, volume: f32, pitch: f32);
/// Spawns particles at the specified position.
spawn-particle: func(particle: particle, pos: position, offset: position, max-speed: f32, count: s32);
/// Creates an explosion at the specified position.
create-explosion: func(pos: position, power: f32, create-fire: bool, interaction: explosion-interaction);
/// Returns the sea level of this world.
get-sea-level: func() -> s32;
/// Returns the minimum Y coordinate (bottom of the world).
get-min-y: func() -> s32;
/// Returns the sky light level at the specified position.
get-sky-light: func(pos: block-pos) -> u8;
/// Sets the sky light level at the specified position.
set-sky-light: func(pos: block-pos, level: u8);
/// Returns the block light level at the specified position.
get-block-light: func(pos: block-pos) -> u8;
/// Sets the block light level at the specified position.
set-block-light: func(pos: block-pos, level: u8);
/// Returns the biome at the specified position.
get-biome: func(pos: block-pos) -> biome;
/// Spawns an entity of the specified type at the given position.
spawn-entity: func(entity-type: entity-type, pos: position) -> entity;
/// Returns a list of all entities in this world.
get-entities: func() -> list<entity>;
/// Returns the block entity at the specified position, if any.
get-block-entity: func(pos: block-pos) -> option<block-entity-type>;
}
}