commit a902e9d548250d3e2460a308c2fe0f619272ef56 Author: Demetrius Kanios Date: Mon Sep 14 11:02:09 2026 -0700 Squashed 'crates/pumpkin-plugin-wit/' content from commit 1ad73fff1 git-subtree-dir: crates/pumpkin-plugin-wit git-subtree-split: 1ad73fff1e0a9e21b99255816df5f99f6260c1b9 diff --git a/.github/workflows/test-bindgen.yml b/.github/workflows/test-bindgen.yml new file mode 100644 index 000000000..fc4e2a2ed --- /dev/null +++ b/.github/workflows/test-bindgen.yml @@ -0,0 +1,20 @@ +name: Test `wit-bindgen` against the WIT +on: [push, pull_request, workflow_dispatch] + +permissions: + contents: write + pull-requests: write + +jobs: + test-bindgen: + name: Test with `wit-bindgen` + runs-on: ubuntu-latest + steps: + - name: Checkout + uses: actions/checkout@v7 + + - name: Setup `wit-bindgen` + uses: bytecodealliance/actions/wit-bindgen/setup@v1 + + - name: Test WIT + run: wit-bindgen rust v0.1 diff --git a/LICENSE-APACHE b/LICENSE-APACHE new file mode 100644 index 000000000..c6e5ba771 --- /dev/null +++ b/LICENSE-APACHE @@ -0,0 +1,176 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + +TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + +1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + +2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + +3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + +4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + +5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + +6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + +7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + +8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or exemplary damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + +9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + +END OF TERMS AND CONDITIONS diff --git a/LICENSE-MIT b/LICENSE-MIT new file mode 100644 index 000000000..36a056ecd --- /dev/null +++ b/LICENSE-MIT @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2024-2026 Pumpkin Contributors + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/v0.1/advancement.wit b/v0.1/advancement.wit new file mode 100644 index 000000000..f2985937d --- /dev/null +++ b/v0.1/advancement.wit @@ -0,0 +1,41 @@ +package pumpkin:plugin@0.1.0; + +interface advancement { + use text.{text-component}; + + /// Frame type for an advancement. + enum frame-type { + task, + challenge, + goal, + } + + /// Display information for an advancement. + record advancement-display { + title: text-component, + description: text-component, + frame: frame-type, + show-toast: bool, + hidden: bool, + announce-to-chat: bool, + background: option, + x: f32, + y: f32, + } + + /// Detailed information about an advancement. + record advancement-info { + id: string, + parent-id: option, + criteria: list, + display: option, + } + + /// Represents progress of an advancement for a player. + record advancement-progress { + advancement-id: string, + done: bool, + awarded-criteria: list, + remaining-criteria: list, + } +} diff --git a/v0.1/attributes.wit b/v0.1/attributes.wit new file mode 100644 index 000000000..7481d3afa --- /dev/null +++ b/v0.1/attributes.wit @@ -0,0 +1,56 @@ +package pumpkin:plugin@0.1.0; + +interface attributes { + enum attribute { + air-drag-modifier, + armor, + armor-toughness, + attack-damage, + attack-knockback, + attack-speed, + below-name-distance, + block-break-speed, + block-interaction-range, + bounciness, + burning-time, + camera-distance, + explosion-knockback-resistance, + entity-interaction-range, + fall-damage-multiplier, + flying-speed, + follow-range, + friction-modifier, + gravity, + jump-strength, + knockback-resistance, + luck, + max-absorption, + max-health, + mining-efficiency, + movement-efficiency, + movement-speed, + name-tag-distance, + oxygen-bonus, + safe-fall-distance, + scale, + sneaking-speed, + spawn-reinforcements, + step-height, + submerged-mining-speed, + sweeping-damage-ratio, + tempt-range, + water-movement-efficiency, + waypoint-transmit-range, + waypoint-receive-range, + } + enum modifier-operation { + add, + multiply-base, + multiply-total, + } + record attribute-modifier { + id: string, + amount: f64, + operation: modifier-operation, + } +} diff --git a/v0.1/bedrock-packets.wit b/v0.1/bedrock-packets.wit new file mode 100644 index 000000000..a3fd4d432 --- /dev/null +++ b/v0.1/bedrock-packets.wit @@ -0,0 +1,1709 @@ +package pumpkin:plugin@0.1.0; + +interface bedrock-packets { + use uuid.{ uuid }; + record s-actor-event { + target-runtime-id: s64, + event-id: actor-event-id, + data: s32, + fire-at-position: option>, + } + enum actor-event-id { + none, + jump, + hurt, + death, + start-attacking, + stop-attacking, + taming-failed, + taming-succeeded, + shake-wetness, + eat-grass, + fishhook-bubble, + fishhook-fish-pos, + fishhook-hook-time, + fishhook-tease, + squid-fleeing, + zombie-converting, + play-ambient, + spawn-alive, + start-offer-flower, + stop-offer-flower, + love-hearts, + villager-angry, + villager-happy, + witch-hat-magic, + fireworks-explode, + in-love-hearts, + silverfish-merge-animation, + guardian-attack-sound, + drink-potion, + throw-potion, + prime-tnt-cart, + prime-creeper, + air-supply, + deprecated-add-player-levels, + guardian-mining-fatigue, + agent-swing-arm, + dragon-start-death-anim, + ground-dust, + shake, + feed, + baby-age, + instant-death, + notify-trade, + leash-destroyed, + caravan-updated, + talisman-activate, + deprecated-update-structure-feature, + player-spawned-mob, + puke, + update-stack-size, + start-swimming, + balloon-pop, + treasure-hunt, + summon-agent, + finished-charging-item, + actor-grow-up, + vibration-detected, + drink-milk, + shake-wetness-stop, + kinetic-damage-dealt, + hurt-without-receiving-damage, + } + enum animate-action { + no-action, + swing-arm, + wake-up, + critical-hit, + magic-critical-hit, + } + enum actor-swing-source { + none, + build, + mine, + interact, + attack, + use-item, + throw-item, + drop-item, + event, + } + record s-animate { + action: animate-action, + target-actor-runtime-id: s64, + data: f32, + swing-source: option, + } + record s-block-pick-request { + position: tuple, + with-data: bool, + max-slots: u8, + } + record s-client-cache-blob-status { + miss-hashes: list, + hit-hashes: list, + } + record s-client-cache-status { + is-cache-supported: bool, + } + record s-command-request { + command: string, + origin: command-origin-data, + is-internal: bool, + version: string, + } + record command-origin-data { + r-type: string, + uuid: uuid, + request-id: string, + player-id: s64, + } + record s-container-close { + container-id: u8, + container-type: u8, + server-initiated-close: bool, + } + record s-emote { + actor-runtime-id: s64, + emote-id: string, + emote-length-ticks: s32, + xuid: string, + platform-id: string, + %flags: u8, + } + record s-emote-list { + runtime-id: s64, + emote-piece-ids: list, + } + record s-interact { + action: action, + target-runtime-id: s64, + position: option>, + } + enum action { + invalid, + stop-riding, + interact-update, + npc-open, + open-inventory, + } + variant inventory-action-source { + container, + %world, + creative, + todo, + unknown(s32), + } + variant transaction-data { + normal(string), + mismatch(string), + use-item(use-item-transaction-data), + use-item-on-entity(use-item-on-entity-transaction-data), + release-item(release-item-transaction-data), + } + record legacy-set-item-slot { + container-id: u8, + slots: list, + } + record inventory-action { + source-type: s32, + window-id: option, + source-flags: option, + inventory-slot: s32, + old-item: network-item-descriptor, + new-item: network-item-descriptor, + } + record use-item-transaction-data { + action-type: s32, + trigger-type: u8, + block-position: tuple, + block-face: u8, + hot-bar-slot: s32, + item-in-hand: network-item-descriptor, + player-position: tuple, + click-position: tuple, + block-runtime-id: s32, + client-prediction: u8, + client-cooldown-state: u8, + } + record use-item-on-entity-transaction-data { + target-entity-runtime-id: s64, + action-type: s32, + hot-bar-slot: s32, + item-in-hand: network-item-descriptor, + player-position: tuple, + click-position: tuple, + } + record release-item-transaction-data { + action-type: s32, + hot-bar-slot: s32, + item-in-hand: network-item-descriptor, + head-position: tuple, + } + record s-inventory-transaction { + legacy-request-id: s32, + legacy-set-item-slots: list, + has-value: bool, + actions: list, + transaction-type: s32, + transaction-data: transaction-data, + } + record item-stack-request-slot-info { + container-name: full-container-name, + slot-id: u8, + stack-id: s32, + } + record stack-request-item { + identifier: option, + metadata-value: s32, + count: s32, + block-runtime-id: s32, + extra-data: list, + } + record item-stack-request-action-take { + count: u8, + source: item-stack-request-slot-info, + destination: item-stack-request-slot-info, + } + record item-stack-request-action-place { + count: u8, + source: item-stack-request-slot-info, + destination: item-stack-request-slot-info, + } + record item-stack-request-action-swap { + slot1: item-stack-request-slot-info, + slot2: item-stack-request-slot-info, + } + record item-stack-request-action-drop { + count: u8, + source: item-stack-request-slot-info, + randomly: bool, + } + record item-stack-request-action-destroy { + count: u8, + source: item-stack-request-slot-info, + } + record item-stack-request-action-consume { + count: u8, + source: item-stack-request-slot-info, + } + record item-stack-request-action-create { + result-index: u8, + } + record item-stack-request-action-beacon-payment { + primary-effect-id: s32, + secondary-effect-id: s32, + } + record item-stack-request-action-mine-block { + hotbar-slot: s32, + predicted-durability: s32, + stack-id: s32, + } + record item-stack-request-action-craft-recipe { + recipe-id: s32, + repetitions: u8, + } + record item-stack-request-action-craft-recipe-auto { + recipe-id: s32, + repetitions: u8, + } + record item-stack-request-action-craft-creative { + creative-item-id: s32, + repetitions: u8, + } + record item-stack-request-action-optional { + recipe-id: s32, + filter-string-index: s32, + } + record item-stack-request-action-grindstone { + recipe-id: s32, + repair-cost: s32, + repetitions: u8, + } + record item-stack-request-action-loom { + pattern-id: string, + repetitions: u8, + } + record item-stack-request-action-craft-results-deprecated { + result-items: list, + times-crafted: u8, + } + variant item-stack-request-action { + take(item-stack-request-action-take), + place(item-stack-request-action-place), + swap(item-stack-request-action-swap), + drop(item-stack-request-action-drop), + destroy(item-stack-request-action-destroy), + consume(item-stack-request-action-consume), + create(item-stack-request-action-create), + lab-table-combine, + beacon-payment(item-stack-request-action-beacon-payment), + mine-block(item-stack-request-action-mine-block), + craft-recipe(item-stack-request-action-craft-recipe), + craft-recipe-auto(item-stack-request-action-craft-recipe-auto), + craft-creative(item-stack-request-action-craft-creative), + optional(item-stack-request-action-optional), + grindstone(item-stack-request-action-grindstone), + loom(item-stack-request-action-loom), + craft-non-implemented, + craft-results-deprecated(item-stack-request-action-craft-results-deprecated), + } + record item-stack-request { + request-id: s32, + actions: list, + filter-strings: list, + filter-cause: s32, + } + record s-item-stack-request { + requests: list, + } + record s-loading-screen { + loading-screen-packet-type: loading-screen-packet-type, + loading-screen-id: option, + } + enum loading-screen-packet-type { + start-loading-screen, + end-loading-screen, + } + record s-login { + protocol-version: s32, + jwt: list, + raw-token: list, + } + record skin-animation { + frames: f64, + image: string, + image-height: s32, + image-width: s32, + animation-type: s32, + animation-expression: s32, + } + record persona-piece { + is-default: bool, + pack-id: string, + piece-id: string, + piece-type: string, + product-id: string, + } + record persona-piece-tint-colour { + colours: list, + piece-type: string, + } + record client-data { + client-random-id: s64, + device-os: s32, + device-id: string, + game-version: string, + language-code: string, + current-input-mode: s32, + default-input-mode: s32, + ui-profile: s32, + server-address: string, + device-model: string, + gui-scale: s32, + client-is-editor-capable: bool, + client-editor-connection-intent: s32, + max-view-distance: s32, + memory-tier: s32, + platform-type: s32, + graphics-mode: s32, + compatible-with-client-side-chunk-gen: bool, + platform-offline-id: string, + platform-online-id: string, + platform-user-id: string, + self-signed-id: string, + play-fab-id: string, + third-party-name: string, + third-party-name-only: bool, + skin-id: string, + skin-data: string, + skin-image-height: s32, + skin-image-width: s32, + skin-colour: string, + arm-size: string, + persona-skin: bool, + premium-skin: bool, + trusted-skin: bool, + override-skin: bool, + cape-data: string, + cape-id: string, + cape-image-height: s32, + cape-image-width: s32, + cape-on-classic-skin: bool, + skin-geometry: string, + skin-geometry-version: string, + skin-resource-patch: string, + animated-image-data: list, + skin-animation-data: string, + persona-pieces: list, + piece-tint-colours: list, + } + record s-mob-equipment { + entity-runtime-id: s64, + item: network-item-stack-descriptor, + slot: u8, + selected-slot: u8, + container-id: u8, + } + record s-modal-form-response { + form-id: s32, + json-response: option, + form-cancel-reason: option, + } + record s-packet-violation-warning { + violation-type: s32, + violation-severity: s32, + violation-packet-id: s32, + violation-context: string, + } + record s-player-action { + player-runtime-id: s64, + action: player-action-type, + block-position: tuple, + result-pos: tuple, + face: s32, + } + enum player-action-type { + unknown, + start-destroy-block, + abort-destroy-block, + stop-destroy-block, + get-updated-block, + drop-item, + start-sleeping, + stop-sleeping, + respawn, + start-jump, + start-sprinting, + stop-sprinting, + start-sneaking, + stop-sneaking, + creative-destroy-block, + change-dimension-ack, + start-gliding, + stop-gliding, + deny-destroy-block, + crack-block, + change-skin, + updated-enchanting-seed, + start-swimming, + stop-swimming, + start-spin-attack, + stop-spin-attack, + interact-with-block, + predict-destroy-block, + continue-destroy-block, + start-item-use-on, + stop-item-use-on, + handled-teleport, + missed-swing, + start-crawling, + stop-crawling, + start-flying, + stop-flying, + client-ack-server-data, + start-using-item, + internal-update, + count, + } + record s-player-auth-input { + pitch: f32, + yaw: f32, + position: tuple, + move-vec: tuple, + head-yaw: f32, + input-data: list, + input-mode: s32, + play-mode: s32, + interaction-model: s32, + interact-pitch: f32, + interact-yaw: f32, + tick: s64, + delta: tuple, + block-actions: option>, + item-interaction: option, + item-stack-request: option, + vehicle-rotation: option>, + vehicle-unique-id: option, + analog-move: tuple, + camera-orientation: tuple, + raw-move: tuple, + } + record player-inventory-action { + legacy-request-id: s32, + legacy-slots: list, + actions: list, + transaction: player-use-item-transaction-data, + } + record player-use-item-transaction-data { + action-type: s32, + trigger-type: u8, + block-position: tuple, + block-face: u8, + hot-bar-slot: s32, + item-in-hand: network-item-descriptor, + player-position: tuple, + click-position: tuple, + block-runtime-id: s32, + client-prediction: u8, + client-cooldown-state: u8, + } + record player-block-action { + action: s32, + block-pos: tuple, + face: s32, + } + enum input-mode { + mouse, + touch, + game-pad, + motion-controller, + } + enum play-mode { + normal, + teaser, + screen, + exit-level, + num-modes, + } + enum interaction-model { + touch, + crosshair, + classic, + } + enum input-data { + ascend, + descend, + north-jump, + jump-down, + sprint-down, + change-height, + jumping, + auto-jumping-in-water, + sneaking, + sneak-down, + up, + down, + left, + right, + up-left, + up-right, + want-up, + want-down, + want-down-slow, + want-up-slow, + sprinting, + ascend-block, + descend-block, + sneak-toggle-down, + persist-sneak, + start-sprinting, + stop-sprinting, + start-sneaking, + stop-sneaking, + start-swimming, + stop-swimming, + start-jumping, + start-gliding, + stop-gliding, + perform-item-interaction, + perform-block-actions, + perform-item-stack-request, + handled-teleport, + emoting, + missed-swing, + start-crawling, + stop-crawling, + start-flying, + stop-flying, + client-ack-server-data, + client-predicted-vehicle, + paddling-left, + paddling-right, + block-breaking-delay-enabled, + horizontal-collision, + vertical-collision, + down-left, + down-right, + start-using-item, + camera-relative-movement-enabled, + rot-controlled-by-move-direction, + start-spin-attack, + stop-spin-attack, + is-hotbar-touch-only, + jump-released-raw, + jump-pressed-raw, + jump-current-raw, + sneak-released-raw, + sneak-pressed-raw, + sneak-current-raw, + internal-update, + } + record s-player-hotbar { + selected-slot: s32, + container-id: u8, + should-select-slot: bool, + } + variant ability-value { + %bool(bool), + float(f32), + } + record s-request-ability { + ability: s32, + value: ability-value, + } + record s-request-chunk-radius { + chunk-radius: s32, + max-chunk-radius: u8, + } + record s-request-network-settings { + client-network-version: s32, + } + record s-resource-pack-client-response { + response: u8, + download-size: s32, + pack-ids: list, + } + record s-respawn { + position: tuple, + state: respawn-state, + player-runtime-id: s64, + } + enum respawn-state { + searching-for-spawn, + ready-to-spawn, + client-ready-to-spawn, + } + record s-set-local-player-as-initialized { + player-id: s64, + } + record s-set-player-inventory-options { + left-inventory-tab: s32, + right-inventory-tab: s32, + filtering: bool, + layout-inv: s32, + layout-craft: s32, + } + record s-text { + needs-translation: bool, + r-type: text-packet-type, + source-name: string, + message: string, + parameters: list, + xuid: string, + platform-chat-id: string, + filtered-message: option, + } + enum text-packet-type { + raw, + chat, + translation, + popup, + jukebox-popup, + tip, + system, + whisper, + announcement, + json-whisper, + json, + json-announcement, + } + record c-add-actor { + target-actor-id: s64, + target-runtime-id: s64, + actor-type: string, + position: tuple, + velocity: tuple, + rotation: tuple, + y-head-rotation: f32, + y-body-rotation: f32, + attributes-list: list, + actor-data: string, + synced-properties: property-sync-data, + actor-links: list, + } + record synced-attribute { + attribute-name: string, + min-value: f32, + current-value: f32, + max-value: f32, + } + record c-add-item-actor { + target-actor-id: s64, + target-runtime-id: s64, + item: item-stack-wrapper, + position: tuple, + velocity: tuple, + entity-data: string, + is-from-fishing: bool, + } + record c-add-player { + uuid: uuid, + player-name: string, + target-runtime-id: s64, + platform-chat-id: string, + position: tuple, + velocity: tuple, + rotation: tuple, + y-head-rotation: f32, + carried-item: network-item-stack-descriptor, + player-game-type: game-type, + entity-data: string, + synced-properties: property-sync-data, + abilities-data: serialized-abilities-data, + actor-links: list, + device-id: string, + build-platform: build-platform, + } + record c-available-commands { + enum-values: list, + chained-subcommand-values: list, + post-fixes: list, + enum-data: list, + chained-subcommand-data: list, + commands: list, + soft-enums: list, + constraints: list, + } + record enum-data { + name: string, + values: list, + } + record chained-subcommand-data { + name: string, + subcommand-values: list, + } + record chained-subcommand-relationship { + index: s32, + value: s32, + } + record command-data { + name: string, + description: string, + %flags: s32, + permission-level: command-permission-level, + alias-enum: s32, + command-data-chained-subcommand-indexes: list, + overloads: list, + } + record overload-data { + is-chaining: bool, + parameter-data: list, + } + record param-data { + name: string, + parse-symbol: s32, + is-optional: bool, + options: u8, + } + record soft-enum-data { + enum-name: string, + enum-options: list, + } + record constrained-value-data { + enum-value-symbol: s32, + enum-symbol: s32, + constraint-indices: list, + } + record c-block-actor-data { + block-position: tuple, + actor-data-tags: string, + } + record c-block-event { + block-position: tuple, + event-type: s32, + event-value: s32, + } + record c-boss-event { + boss-entity-id: s64, + player-entity-id: s64, + event-type: u8, + title: string, + filtered-title: string, + health-percentage: f32, + color: u8, + overlay: u8, + } + record c-change-dimension { + dimension-id: s32, + position: tuple, + respawn: bool, + loading-screen-id: option, + } + record c-chunk-radius-updated { + chunk-radius: s32, + } + record missing-blob-data { + blob-id: s64, + blob-data: list, + } + record c-client-cache-miss-response { + missing-blobs: list, + } + enum build-platform { + unknown, + google, + ios, + osx, + amazon, + gear-vr, + uwp, + win32, + dedicated, + tv-os, + sony, + nx, + xbox, + windows-phone, + linux, + } + enum game-type { + unknown, + survival, + creative, + adventure, + default, + spectator, + } + record serialized-abilities-data { + target-player-raw-id: s64, + player-permissions: player-permission-level, + command-permissions: command-permission-level, + layers: list, + } + enum player-permission-level { + visitor, + member, + operator, + custom, + } + enum command-permission-level { + any, + game-directors, + admin, + host, + owner, + internal, + } + record serialized-abilities-data-serialized-layer { + serialized-layer: s32, + abilities-set: s32, + ability-value: s32, + fly-speed: f32, + vertical-fly-speed: f32, + walk-speed: f32, + } + record actor-link { + ridden-unique-id: s64, + rider-unique-id: s64, + link-type: u8, + immediate: bool, + rider-initiated: bool, + vehicle-angular-velocity: f32, + } + record c-container-open { + container-id: u8, + container-type: u8, + position: tuple, + target-entity-id: s64, + } + record c-correct-player-move-prediction { + prediction-type: u8, + pos: tuple, + pos-delta: tuple, + rotation: tuple, + vehicle-angular-velocity: option, + on-ground: bool, + tick: s64, + } + record item-descriptor-count { + item-identifier: string, + metadata-value: s32, + count: s32, + } + record recipe-unlock-requirement { + context: s32, + } + record bedrock-shapeless-recipe { + recipe-id: string, + input: list, + output: list, + uuid: uuid, + block: string, + priority: s32, + unlock-requirement: recipe-unlock-requirement, + recipe-network-id: s32, + } + record bedrock-shaped-recipe { + recipe-id: string, + width: s32, + height: s32, + input: list, + output: list, + uuid: uuid, + block: string, + priority: s32, + assume-symmetry: bool, + unlock-requirement: recipe-unlock-requirement, + recipe-network-id: s32, + } + variant bedrock-recipe { + shapeless(bedrock-shapeless-recipe), + shaped(bedrock-shaped-recipe), + } + record c-crafting-data { + recipes: list, + clean-recipes: bool, + } + record c-creative-content { + groups: list, + entries: list, + } + enum creative-category { + all, + construction, + nature, + equipment, + items, + item-command-only, + undefined, + } + record creative-group-info-payload { + creative-category: creative-category, + name: string, + group-icon-item: network-item-descriptor, + } + record creative-item-entry-payload { + id: s32, + item: network-item-descriptor, + group-index: s32, + } + record c-disconnect { + reason: s32, + skip-message: bool, + message: string, + filtered-message: string, + } + record c-gamerules-changed { + rule-data: list, + } + record game-rule { + rule-name: string, + rule-can-be-modified: bool, + rule-value: rule-value, + } + enum rule-value { + null, + } + record c-inventory-content { + container-id: s32, + slots: list, + full-container-name: full-container-name, + storage-item: network-item-stack-descriptor, + } + record c-inventory-slot { + container-id: s32, + slot: s32, + full-container-name: option, + storage-item: option, + item: network-item-stack-descriptor, + } + record c-item-registry { + items: list, + } + record item-data { + item-name: string, + item-id: s32, + is-component-based: bool, + item-version: s32, + component-data: list, + } + record item-stack-response-slot-info { + requested-slot: u8, + slot: u8, + amount: u8, + item-stack-net-id: s32, + custom-name: string, + filtered-custom-name: string, + durability-correction: s32, + } + record item-stack-response-container-info { + full-container-name: full-container-name, + slots: list, + } + record item-stack-response-info { + %result: u8, + client-request-id: s32, + containers: list, + } + record c-item-stack-response { + responses: list, + } + record c-level-chunk { + dimension: s32, + cache-enabled: bool, + chunk: list, + block-actors: list, + } + record c-level-event { + event-id: s32, + position: tuple, + data: s32, + } + enum level-event { + particles-destroy-block, + block-start-break, + block-stop-break, + block-update-break, + } + record c-level-sound-event { + sound-event: string, + position: tuple, + data: s32, + actor-identifier: string, + is-baby: bool, + is-global: bool, + actor-unique-id: s64, + fire-at-position: option>, + } + record c-mob-effect { + target-runtime-id: s64, + event-id: u8, + effect-id: s32, + effect-amplifier: s32, + show-particles: bool, + effect-duration-ticks: s32, + tick: s64, + ambient: bool, + } + record c-mob-equipment { + target-runtime-id: s64, + item: network-item-stack-descriptor, + slot: u8, + selected-slot: u8, + container-id: u8, + } + record c-modal-form-request { + form-id: s32, + form-ui-json: string, + } + record c-move-actor-absolute { + actor-runtime-id: s64, + header: u8, + position: tuple, + rotation-x: u8, + rotation-y: u8, + rotation-y-head: u8, + } + record c-move-actor-delta { + entity-runtime-id: s64, + %flags: s32, + x: f32, + y: f32, + z: f32, + pitch: u8, + yaw: u8, + head-yaw: u8, + } + record c-move-player { + player-runtime-id: s64, + position: tuple, + pitch: f32, + yaw: f32, + head-yaw: f32, + mode: u8, + on-ground: bool, + riding-runtime-id: s64, + teleport-cause: s32, + teleport-source-entity-type: s32, + tick: s64, + } + record c-network-chunk-publisher-update { + pos-for-view: tuple, + new-radius: s32, + server-build-chunk-list: list>, + } + record c-network-settings { + compression-threshold: s32, + compression-algorithm: s32, + client-throttle-enabled: bool, + client-throttle-threshold: u8, + client-throttle-scalar: f32, + } + enum c-play-status { + login-success, + outdated-client, + outdated-server, + player-spawn, + invalid-tenant, + edition-mismatch-edu-to-vanilla, + edition-mismatch-vanilla-to-edu, + server-full-sub-client, + editor-mismatch-editor-to-vanilla, + editor-mismatch-vanilla-to-editor, + } + record c-player-hotbar { + selected-slot: s32, + container-id: u8, + should-select-slot: bool, + } + record c-player-list { + action: u8, + entries: list, + } + record player-list-entry { + uuid: uuid, + entity-unique-id: s64, + username: string, + xuid: string, + platform-chat-id: string, + build-platform: build-platform, + skin: skin, + is-teacher: bool, + is-host: bool, + is-sub-client: bool, + player-color: list, + } + record skin { + skin-id: string, + play-fab-id: string, + resource-patch: list, + image-width: s32, + image-height: s32, + skin-data: list, + animations: list, + cape-width: s32, + cape-height: s32, + cape-data: list, + geometry-data: list, + animation-data: list, + geometry-data-engine-version: list, + cape-id: string, + full-id: string, + arm-size: string, + skin-color: string, + persona-pieces: list, + piece-tint-colors: list, + is-premium: bool, + is-persona: bool, + persona-cape-on-classic: bool, + is-primary-user: bool, + override-appearance: bool, + is-trusted: bool, + profile-hash: string, + } + record piece-tint-color { + piece-type: string, + colors: list, + } + record c-remove-actor { + target-actor-id: s64, + } + record c-remove-objective { + objective-name: string, + } + record pack-instance-id { + pack-id: string, + version: string, + sub-pack-name: string, + } + record c-resource-pack-stack-packet { + texture-pack-required: bool, + texture-pack-list: list, + base-game-version: string, + experiments: experiments, + include-editor-packs: bool, + } + record pack-info-data { + pack-id-version: pack-id-version, + pack-size: s64, + content-key: string, + subpack-name: string, + content-identity: string, + has-scripts: bool, + is-addon-pack: bool, + is-ray-tracing-capable: bool, + cdn-url: string, + } + record c-resource-packs-info { + resource-pack-required: bool, + has-addon-packs: bool, + has-scripts: bool, + force-disable-vibrant-visuals: bool, + world-template-id-and-version: pack-id-version, + resource-packs: list, + } + record pack-id-version { + pack-uuid: uuid, + pack-version: string, + } + record c-set-actor-data { + target-runtime-id: s64, + actor-data: string, + synced-properties: property-sync-data, + tick: s64, + } + variant metadata-value { + byte(u8), + short(s32), + int(s32), + float(f32), + %string(string), + compound-tag, + item-pos(tuple), + int64(s64), + vec3(tuple), + } + record property-sync-data { + int-entries-list: list>, + float-entries-list: list>, + } + record c-set-actor-link { + link: actor-link, + } + record c-set-actor-motion { + target-runtime-id: s64, + motion: tuple, + tick: s64, + } + record c-set-difficulty { + difficulty: s32, + } + record c-set-display-objective { + display-slot-name: string, + objective-name: string, + objective-display-name: string, + criteria-name: string, + sort-order: s32, + } + record c-set-health { + health: s32, + } + record c-set-player-game-type { + player-game-type: game-type, + } + record c-set-score { + action: s32, + entries: list, + } + record score-entry { + scoreboard-id: s64, + objective-name: string, + score: s32, + entry-type: s32, + entity-unique-id: s64, + custom-name: string, + } + record c-set-spawn-position { + spawn-position-type: spawn-position-type, + block-position: tuple, + dimension-type: s32, + spawn-block-pos: tuple, + } + enum spawn-position-type { + player-respawn, + world-respawn, + } + record c-set-time { + time: s32, + } + record c-set-title { + title-type: title-type, + title-text: string, + fade-in-time: s32, + stay-time: s32, + fade-out-time: s32, + xuid: string, + platform-online-id: string, + filtered-title-message: string, + } + enum title-type { + clear, + reset, + title, + subtitle, + actionbar, + times, + title-text-object, + subtitle-text-object, + actionbar-text-object, + } + record c-show-credits { + player-runtime-id: s64, + credits-state: s32, + } + record c-start-game { + entity-id: s64, + runtime-entity-id: s64, + player-gamemode: game-type, + position: tuple, + pitch: f32, + yaw: f32, + level-settings: level-settings, + 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, + telemetry: server-telemetry-data, + } + record server-join-information { + gathering: option, + store-entry-point: option, + presence: option, + } + record gathering-join-info { + experience-id: uuid, + experience-name: string, + experience-world-id: uuid, + experience-world-name: string, + creator-id: string, + unknown-uuid-1: uuid, + unknown-uuid-2: uuid, + server-id: string, + } + record store-entry-point-info { + store-id: string, + store-name: string, + } + record presence-info { + experience-name: string, + world-name: string, + } + record server-telemetry-data { + server-id: string, + scenario-id: string, + world-id: string, + owner-id: string, + } + record level-settings { + seed: s64, + spawn-biome-type: s32, + custom-biome-name: string, + dimension: s32, + generator-type: s32, + world-gamemode: game-type, + hardcore: bool, + difficulty: s32, + spawn-position: tuple, + has-achievements-disabled: bool, + editor-world-type: s32, + is-created-in-editor: bool, + is-exported-from-editor: bool, + day-cycle-stop-time: s32, + education-edition-offer: s32, + has-education-features-enabled: bool, + education-product-id: string, + rain-level: f32, + lightning-level: f32, + has-confirmed-platform-locked-content: bool, + was-multiplayer-intended: bool, + was-lan-broadcasting-intended: bool, + xbox-live-broadcast-setting: game-publish-setting, + platform-broadcast-setting: game-publish-setting, + commands-enabled: bool, + is-texture-packs-required: bool, + rule-data: list, + experiments: experiments, + bonus-chest: bool, + has-start-with-map-enabled: bool, + permission-level: u8, + server-simulation-distance: s32, + has-locked-behavior-pack: bool, + has-locked-resource-pack: bool, + is-from-locked-world-template: bool, + is-using-msa-gamertags-only: bool, + is-from-world-template: bool, + is-world-template-option-locked: bool, + is-only-spawning-v1-villagers: bool, + is-disabling-personas: bool, + is-disabling-custom-skins: bool, + emote-chat-muted: bool, + game-version: string, + limited-world-width: s32, + limited-world-height: s32, + new-nether: bool, + edu-shared-uri-button-name: string, + edu-shared-uri-link-uri: string, + override-force-experimental-gameplay-has-value: bool, + chat-restriction-level: u8, + disable-player-interactions: bool, + server-editor-connection-policy: s32, + allow-anonymous-block-drops-in-editor-worlds: bool, + } + record experiments { + toggles: list, + experiments-ever-toggled: bool, + } + record experiment-toggle { + name: string, + enabled: bool, + } + enum game-publish-setting { + no-multi-play, + invite-only, + friends-only, + friends-of-friends, + public, + } + record gg { + name: string, + id: u8, + len: s32, + end: u8, + } + record c-take-item-actor { + item-runtime-id: s64, + actor-runtime-id: s64, + } + record c-transfer { + server-address: string, + server-port: s32, + reload-world: bool, + } + record c-update-abilities { + data: serialized-abilities-data, + } + enum ability { + build, + mine, + doors-and-switches, + open-containers, + attack-players, + attack-mobs, + operator-commands, + teleport, + invulnerable, + flying, + may-fly, + instabuild, + lightning, + fly-speed, + walk-speed, + muted, + world-builder, + no-clip, + privileged-builder, + vertical-fly-speed, + ability-count, + } + record c-update-attributes { + target-runtime-id: s64, + attribute-list: list, + tick: s64, + } + record attribute-data { + min-value: f32, + max-value: f32, + current-value: f32, + default-min-value: f32, + default-max-value: f32, + default-value: f32, + name: string, + modifiers: list, + } + record attribute-modifier { + id: string, + name: string, + amount: f32, + operation: s32, + operand: s32, + is-serializable: bool, + } + record c-update-block { + block-position: tuple, + block-runtime-id: s32, + %flags: s32, + layer: s32, + } + record c-update-trade { + container-id: u8, + r-type: u8, + size: s32, + trader-tier: s32, + entity-unique-id: s64, + last-trading-player: s64, + display-name: string, + use-new-trade-screen: bool, + using-economy-trade: bool, + data: string, + } + record network-item-descriptor { + id: s32, + stack-size: s32, + aux-value: s32, + block-runtime-id: s32, + nbt-data: string, + place-on-blocks: list, + destroy-blocks: list, + shield-blocking-tick: s64, + } + record item-stack-wrapper { + id: s32, + stack-size: s32, + aux-value: s32, + block-runtime-id: s32, + nbt-data: string, + place-on-blocks: list, + destroy-blocks: list, + shield-blocking-tick: s64, + net-id: option, + } + record network-item-stack-descriptor { + id: s32, + stack-size: s32, + aux-value: s32, + block-runtime-id: s32, + extra-data: list, + net-id: option, + } + record full-container-name { + container-name: container-name, + dynamic-id: option, + } + enum container-name { + anvil-input, + anvil-material, + anvil-result-preview, + smithing-table-input, + smithing-table-material, + smithing-table-result-preview, + armor, + level-entity, + beacon-payment, + brewing-stand-input, + brewing-stand-result, + brewing-stand-fuel, + combined-hot-bar-and-inventory, + crafting-input, + crafting-output-preview, + recipe-construction, + recipe-nature, + recipe-items, + recipe-search, + recipe-search-bar, + recipe-equipment, + recipe-book, + enchanting-input, + enchanting-material, + furnace-fuel, + furnace-ingredient, + furnace-result, + horse-equip, + hot-bar, + inventory, + shulker-box, + trade-ingredient1, + trade-ingredient2, + trade-result-preview, + offhand, + compound-creator-input, + compound-creator-output-preview, + element-constructor-output-preview, + material-reducer-input, + material-reducer-output, + lab-table-input, + loom-input, + loom-dye, + loom-material, + loom-result-preview, + blast-furnace-ingredient, + smoker-ingredient, + trade2-ingredient1, + trade2-ingredient2, + trade2-result-preview, + grindstone-input, + grindstone-additional, + grindstone-result-preview, + stonecutter-input, + stonecutter-result-preview, + cartography-input, + cartography-additional, + cartography-result-preview, + barrel, + cursor, + created-output, + smithing-table-template, + crafter-level-entity, + dynamic, + recipe-food, + recipe-blocks, + recipe-furnace-items, + } + record network-item-stack { + id: s32, + count: s32, + aux-value: s32, + block-runtime-id: s32, + extra-data: list, + } + variant serverbound-packet { + s-actor-event(s-actor-event), + s-animate(s-animate), + s-block-pick-request(s-block-pick-request), + s-client-cache-blob-status(s-client-cache-blob-status), + s-client-cache-status(s-client-cache-status), + s-command-request(s-command-request), + s-container-close(s-container-close), + s-emote(s-emote), + s-emote-list(s-emote-list), + s-interact(s-interact), + s-inventory-transaction(s-inventory-transaction), + s-item-stack-request(s-item-stack-request), + s-loading-screen(s-loading-screen), + s-login(s-login), + s-mob-equipment(s-mob-equipment), + s-modal-form-response(s-modal-form-response), + s-packet-violation-warning(s-packet-violation-warning), + s-player-action(s-player-action), + s-player-auth-input(s-player-auth-input), + s-player-hotbar(s-player-hotbar), + s-request-ability(s-request-ability), + s-request-chunk-radius(s-request-chunk-radius), + s-request-network-settings(s-request-network-settings), + s-resource-pack-client-response(s-resource-pack-client-response), + s-respawn(s-respawn), + s-set-local-player-as-initialized(s-set-local-player-as-initialized), + s-set-player-inventory-options(s-set-player-inventory-options), + s-text(s-text), + unknown, + } + variant clientbound-packet { + c-add-actor(c-add-actor), + c-add-item-actor(c-add-item-actor), + c-add-player(c-add-player), + c-available-commands(c-available-commands), + c-biome-definition-list, + c-block-actor-data(c-block-actor-data), + c-block-event(c-block-event), + c-boss-event(c-boss-event), + c-change-dimension(c-change-dimension), + c-chunk-radius-updated(c-chunk-radius-updated), + c-client-cache-miss-response(c-client-cache-miss-response), + c-container-open(c-container-open), + c-correct-player-move-prediction(c-correct-player-move-prediction), + c-crafting-data(c-crafting-data), + c-creative-content(c-creative-content), + c-disconnect(c-disconnect), + c-gamerules-changed(c-gamerules-changed), + c-inventory-content(c-inventory-content), + c-inventory-slot(c-inventory-slot), + c-item-registry(c-item-registry), + c-item-stack-response(c-item-stack-response), + c-level-chunk(c-level-chunk), + c-level-event(c-level-event), + c-level-sound-event(c-level-sound-event), + c-mob-effect(c-mob-effect), + c-mob-equipment(c-mob-equipment), + c-modal-form-request(c-modal-form-request), + c-move-actor-absolute(c-move-actor-absolute), + c-move-actor-delta(c-move-actor-delta), + c-move-player(c-move-player), + c-network-chunk-publisher-update(c-network-chunk-publisher-update), + c-network-settings(c-network-settings), + c-play-status(c-play-status), + c-player-hotbar(c-player-hotbar), + c-player-list(c-player-list), + c-remove-actor(c-remove-actor), + c-remove-objective(c-remove-objective), + 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-link(c-set-actor-link), + c-set-actor-motion(c-set-actor-motion), + c-set-difficulty(c-set-difficulty), + c-set-display-objective(c-set-display-objective), + c-set-health(c-set-health), + c-set-player-game-type(c-set-player-game-type), + c-set-score(c-set-score), + c-set-spawn-position(c-set-spawn-position), + c-set-time(c-set-time), + c-set-title(c-set-title), + c-show-credits(c-show-credits), + c-start-game(c-start-game), + c-take-item-actor(c-take-item-actor), + c-transfer(c-transfer), + c-update-abilities(c-update-abilities), + c-update-attributes(c-update-attributes), + c-update-block(c-update-block), + c-update-trade(c-update-trade), + unknown, + } +} diff --git a/v0.1/biomes.wit b/v0.1/biomes.wit new file mode 100644 index 000000000..c761fb7da --- /dev/null +++ b/v0.1/biomes.wit @@ -0,0 +1,72 @@ +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, + sulfur-caves, + sunflower-plains, + swamp, + taiga, + the-end, + the-void, + warm-ocean, + warped-forest, + windswept-forest, + windswept-gravelly-hills, + windswept-hills, + windswept-savanna, + wooded-badlands, + } +} diff --git a/v0.1/block-entity.wit b/v0.1/block-entity.wit new file mode 100644 index 000000000..363c7d766 --- /dev/null +++ b/v0.1/block-entity.wit @@ -0,0 +1,423 @@ +interface block-entity { + use common.{block-pos, nbt-tree}; + use item-stack.{item-stack}; + use inventory.{inventory}; + + resource block-entity { + resource-location: func() -> string; + get-position: func() -> block-pos; + get-id: func() -> u32; + is-dirty: func() -> bool; + clear-dirty: func(); + + /// Sets a namespaced custom data value on this block entity. + set-custom-data: func(namespace: string, key: string, value: nbt-tree); + /// Returns a namespaced custom data value from this block entity, if set. + get-custom-data: func(namespace: string, key: string) -> option; + /// Removes a namespaced custom data value from this block entity. + remove-custom-data: func(namespace: string, key: string); + /// Returns whether this block entity has a namespaced custom data value. + has-custom-data: func(namespace: string, key: string) -> bool; + } + + resource container-block-entity { + get-block-entity: func() -> block-entity; + /// Returns the generic inventory handle for this container. + get-inventory: func() -> inventory; + get-size: func() -> u32; + is-empty: func() -> bool; + get-stack: func(slot: u32) -> option; + set-stack: func(slot: u32, stack: option); + remove-stack: func(slot: u32) -> option; + clear: 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, + 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; + get-container: func() -> container-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; + get-container: func() -> container-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; + } + + resource map-block-entity { + get-block-entity: func() -> block-entity; + get-map-id: func() -> s32; + set-map-id: func(map-id: s32); + get-colors: func() -> list; + set-colors: func(colors: list); + set-pixel: func(x: u32, y: u32, color: u8); + get-pixel: func(x: u32, y: u32) -> u8; + update: func(); + stream-frame: func(frame-data: list); + } + + resource hanging-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 trapped-chest-block-entity { + get-block-entity: func() -> block-entity; + get-container: func() -> container-block-entity; + viewer-count: func() -> u32; + } + + resource banner-block-entity { + get-block-entity: func() -> block-entity; + get-custom-name: func() -> option; + } + + resource barrel-block-entity { + get-block-entity: func() -> block-entity; + get-container: func() -> container-block-entity; + viewer-count: func() -> u32; + } + + resource beacon-block-entity { + get-block-entity: func() -> block-entity; + get-container: func() -> container-block-entity; + get-primary-effect: func() -> s32; + get-secondary-effect: func() -> s32; + get-levels: func() -> s32; + } + + resource bed-block-entity { + get-block-entity: func() -> block-entity; + } + + resource beehive-block-entity { + get-block-entity: func() -> block-entity; + get-bee-count: func() -> u32; + } + + resource bell-block-entity { + get-block-entity: func() -> block-entity; + is-ringing: func() -> bool; + get-ring-ticks: func() -> s32; + } + + resource blasting-furnace-block-entity { + get-block-entity: func() -> block-entity; + get-container: func() -> container-block-entity; + get-cooking-time-spent: func() -> u16; + get-cooking-total-time: func() -> u16; + get-lit-time-remaining: func() -> u16; + get-lit-total-time: func() -> u16; + is-burning: func() -> bool; + } + + resource brewing-stand-block-entity { + get-block-entity: func() -> block-entity; + get-container: func() -> container-block-entity; + get-brew-time: func() -> s32; + get-fuel: func() -> s32; + } + + resource brushable-block-block-entity { + get-block-entity: func() -> block-entity; + } + + resource calibrated-sculk-sensor-block-entity { + get-block-entity: func() -> block-entity; + } + + resource campfire-block-entity { + get-block-entity: func() -> block-entity; + get-container: func() -> container-block-entity; + } + + resource chiseled-bookshelf-block-entity { + get-block-entity: func() -> block-entity; + get-container: func() -> container-block-entity; + get-last-interacted-slot: func() -> s8; + } + + resource comparator-block-entity { + get-block-entity: func() -> block-entity; + get-output-signal: func() -> u8; + } + + resource conduit-block-entity { + get-block-entity: func() -> block-entity; + } + + resource copper-golem-statue-block-entity { + get-block-entity: func() -> block-entity; + } + + resource crafter-block-entity { + get-block-entity: func() -> block-entity; + get-container: func() -> container-block-entity; + get-crafting-ticks-remaining: func() -> s32; + is-triggered: func() -> bool; + } + + resource creaking-heart-block-entity { + get-block-entity: func() -> block-entity; + get-creaking-uuid: func() -> option; + } + + resource daylight-detector-block-entity { + get-block-entity: func() -> block-entity; + } + + resource decorated-pot-block-entity { + get-block-entity: func() -> block-entity; + } + + resource dispenser-block-entity { + get-block-entity: func() -> block-entity; + get-container: func() -> container-block-entity; + } + + resource dropper-block-entity { + get-block-entity: func() -> block-entity; + get-container: func() -> container-block-entity; + } + + resource enchanting-table-block-entity { + get-block-entity: func() -> block-entity; + } + + resource end-gateway-block-entity { + get-block-entity: func() -> block-entity; + get-age: func() -> s64; + is-exact-teleport: func() -> bool; + } + + resource end-portal-block-entity { + get-block-entity: func() -> block-entity; + } + + resource ender-chest-block-entity { + get-block-entity: func() -> block-entity; + viewer-count: func() -> u32; + } + + resource furnace-block-entity { + get-block-entity: func() -> block-entity; + get-container: func() -> container-block-entity; + get-cooking-time-spent: func() -> u16; + get-cooking-total-time: func() -> u16; + get-lit-time-remaining: func() -> u16; + get-lit-total-time: func() -> u16; + is-burning: func() -> bool; + } + + resource hopper-block-entity { + get-block-entity: func() -> block-entity; + get-container: func() -> container-block-entity; + get-cooldown: func() -> s32; + } + + resource jigsaw-block-entity { + get-block-entity: func() -> block-entity; + get-name: func() -> string; + get-target: func() -> string; + get-pool: func() -> string; + get-final-state: func() -> string; + get-selection-priority: func() -> s32; + get-placement-priority: func() -> s32; + } + + resource lectern-block-entity { + get-block-entity: func() -> block-entity; + get-container: func() -> container-block-entity; + get-page: func() -> u32; + } + + resource piston-block-entity { + get-block-entity: func() -> block-entity; + get-progress: func() -> f32; + is-extending: func() -> bool; + is-source: func() -> bool; + } + + resource potent-sulfur-block-entity { + get-block-entity: func() -> block-entity; + } + + resource sculk-catalyst-block-entity { + get-block-entity: func() -> block-entity; + } + + resource sculk-sensor-block-entity { + get-block-entity: func() -> block-entity; + } + + resource sculk-shrieker-block-entity { + get-block-entity: func() -> block-entity; + get-warning-level: func() -> s32; + } + + resource shelf-block-entity { + get-block-entity: func() -> block-entity; + get-container: func() -> container-block-entity; + } + + resource shulker-box-block-entity { + get-block-entity: func() -> block-entity; + get-container: func() -> container-block-entity; + viewer-count: func() -> u32; + } + + resource skull-block-entity { + get-block-entity: func() -> block-entity; + get-note-block-sound: func() -> option; + } + + resource smoker-block-entity { + get-block-entity: func() -> block-entity; + get-container: func() -> container-block-entity; + get-cooking-time-spent: func() -> u16; + get-cooking-total-time: func() -> u16; + get-lit-time-remaining: func() -> u16; + get-lit-total-time: func() -> u16; + is-burning: func() -> bool; + } + + resource structure-block-block-entity { + get-block-entity: func() -> block-entity; + get-name: func() -> string; + get-author: func() -> string; + get-mode: func() -> string; + get-integrity: func() -> f32; + get-seed: func() -> s64; + } + + resource test-block-block-entity { + get-block-entity: func() -> block-entity; + } + + resource test-instance-block-block-entity { + get-block-entity: func() -> block-entity; + } + + resource trial-spawner-block-entity { + get-block-entity: func() -> block-entity; + } + + resource vault-block-entity { + get-block-entity: func() -> block-entity; + } + + variant block-entity-type { + command-block-entity(command-block-entity), + sign-block-entity(sign-block-entity), + hanging-sign-block-entity(hanging-sign-block-entity), + jukebox-block-entity(jukebox-block-entity), + chest-block-entity(chest-block-entity), + trapped-chest-block-entity(trapped-chest-block-entity), + mob-spawner-block-entity(mob-spawner-block-entity), + map-block-entity(map-block-entity), + banner-block-entity(banner-block-entity), + barrel-block-entity(barrel-block-entity), + beacon-block-entity(beacon-block-entity), + bed-block-entity(bed-block-entity), + beehive-block-entity(beehive-block-entity), + bell-block-entity(bell-block-entity), + blasting-furnace-block-entity(blasting-furnace-block-entity), + brewing-stand-block-entity(brewing-stand-block-entity), + brushable-block-block-entity(brushable-block-block-entity), + calibrated-sculk-sensor-block-entity(calibrated-sculk-sensor-block-entity), + campfire-block-entity(campfire-block-entity), + chiseled-bookshelf-block-entity(chiseled-bookshelf-block-entity), + comparator-block-entity(comparator-block-entity), + conduit-block-entity(conduit-block-entity), + copper-golem-statue-block-entity(copper-golem-statue-block-entity), + crafter-block-entity(crafter-block-entity), + creaking-heart-block-entity(creaking-heart-block-entity), + daylight-detector-block-entity(daylight-detector-block-entity), + decorated-pot-block-entity(decorated-pot-block-entity), + dispenser-block-entity(dispenser-block-entity), + dropper-block-entity(dropper-block-entity), + enchanting-table-block-entity(enchanting-table-block-entity), + end-gateway-block-entity(end-gateway-block-entity), + end-portal-block-entity(end-portal-block-entity), + ender-chest-block-entity(ender-chest-block-entity), + furnace-block-entity(furnace-block-entity), + hopper-block-entity(hopper-block-entity), + jigsaw-block-entity(jigsaw-block-entity), + lectern-block-entity(lectern-block-entity), + piston-block-entity(piston-block-entity), + potent-sulfur-block-entity(potent-sulfur-block-entity), + sculk-catalyst-block-entity(sculk-catalyst-block-entity), + sculk-sensor-block-entity(sculk-sensor-block-entity), + sculk-shrieker-block-entity(sculk-shrieker-block-entity), + shelf-block-entity(shelf-block-entity), + shulker-box-block-entity(shulker-box-block-entity), + skull-block-entity(skull-block-entity), + smoker-block-entity(smoker-block-entity), + structure-block-block-entity(structure-block-block-entity), + test-block-block-entity(test-block-block-entity), + test-instance-block-block-entity(test-instance-block-block-entity), + trial-spawner-block-entity(trial-spawner-block-entity), + vault-block-entity(vault-block-entity), + container-block-entity(container-block-entity), + } +} diff --git a/v0.1/boss-bar.wit b/v0.1/boss-bar.wit new file mode 100644 index 000000000..ea59509e5 --- /dev/null +++ b/v0.1/boss-bar.wit @@ -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; + + /// Removes this boss bar from all players and cleans it up. + remove-all: func(); + } +} diff --git a/v0.1/command.wit b/v0.1/command.wit new file mode 100644 index 000000000..32668d5a9 --- /dev/null +++ b/v0.1/command.wit @@ -0,0 +1,244 @@ +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), + 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); + suggest-with-handler-id: func(handler-id: u32); + require-with-handler-id: func(handler-id: u32); + } + + record suggestion-request { + input: string, + cursor: u32, + start: u32, + remaining: string, + } + + record command-suggestion { + value: string, + tooltip: option, + } + + record command-suggestions { + start: u32, + length: u32, + values: list, + } + + variant argument-type { + %bool, + float(tuple, option>), + double(tuple, option>), + integer(tuple, option>), + long(tuple, option>), + %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), + %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), + 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; + permission-level: func() -> permission-level; + has-permission-level: func(level: permission-level) -> bool; + has-permission: func(server: borrow, node: string) -> bool; + position: func() -> option; + %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), + block-pos(block-pos), + pos3d(tuple), + pos2d(tuple), + rotation(tuple), + gamemode(game-mode), + difficulty(difficulty), + players(list), + 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), + advancement(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), + upper-bound(tuple), + } + + resource consumed-args { + get-value: func(key: string) -> arg; + } + + resource command { + /// First name is primary, rest are aliases + constructor(names: list, description: string); + then: func(node: command-node); + execute-with-handler-id: func(handler-id: u32); + } +} diff --git a/v0.1/common.wit b/v0.1/common.wit new file mode 100644 index 000000000..f76aec181 --- /dev/null +++ b/v0.1/common.wit @@ -0,0 +1,261 @@ +/// 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; + + /// Represents one entry in an NBT compound tag. + record nbt-entry { + key: string, + value: u32, + } + + /// Represents a Minecraft NBT tag tree. + record nbt-tree { + root: u32, + tags: list, + } + + /// Represents a Minecraft NBT tag. + variant nbt-tag { + byte(s8), + short(s16), + int(s32), + long(s64), + float(f32), + double(f64), + byte-array(list), + string-tag(string), + list-tag(list), + compound(list), + int-array(list), + long-array(list), + } + + /// 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; + + /// 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, + } +} diff --git a/v0.1/context.wit b/v0.1/context.wit new file mode 100644 index 000000000..966eea743 --- /dev/null +++ b/v0.1/context.wit @@ -0,0 +1,61 @@ +/// 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}; + + /// Verified marketplace metadata for signed plugins. + record marketplace-metadata { + /// The marketplace base URL where this plugin is registered. + marketplace-url: string, + /// The unique plugin ID on the marketplace. + plugin-id: s64, + /// The canonical plugin name. + plugin-name: string, + /// The semver version string of the plugin. + version: string, + /// Developer ID. + dev-id: s64, + /// Developer display name or username. + dev-name: string, + /// Whether this is a paid marketplace plugin. + is-paid: bool, + /// The buyer / licensee user ID (0 for free/open-source). + user-id: s64, + /// Unique license key issued to the buyer, if paid. + license-key: option, + /// ISO-8601 timestamp of when this binary/license was issued. + issued-at: string, + } + + /// 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; + + /// Returns verified marketplace metadata if this plugin binary is signed, or none if unsigned. + get-marketplace-metadata: func() -> option; + } +} + diff --git a/v0.1/damage-types.wit b/v0.1/damage-types.wit new file mode 100644 index 000000000..7acebb9b0 --- /dev/null +++ b/v0.1/damage-types.wit @@ -0,0 +1,57 @@ +package pumpkin:plugin@0.1.0; + +interface damage-types { + enum damage-type { + arrow, + bad-respawn-point, + cactus, + campfire, + cramming, + dragon-breath, + drown, + dry-out, + ender-pearl, + explosion, + fall, + falling-anvil, + falling-block, + falling-stalactite, + fireball, + fireworks, + fly-into-wall, + freeze, + generic, + generic-kill, + hot-floor, + in-fire, + in-wall, + indirect-magic, + lava, + lightning-bolt, + mace-smash, + magic, + mob-attack, + mob-attack-no-aggro, + mob-projectile, + on-fire, + out-of-world, + outside-border, + player-attack, + player-explosion, + sonic-boom, + spear, + spit, + stalagmite, + starve, + sting, + sulfur-cube-hot, + sweet-berry-bush, + thorns, + thrown, + trident, + unattributed-fireball, + wind-charge, + wither, + wither-skull, + } +} diff --git a/v0.1/data-components.wit b/v0.1/data-components.wit new file mode 100644 index 000000000..09ed193a4 --- /dev/null +++ b/v0.1/data-components.wit @@ -0,0 +1,117 @@ +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, + sulfur-cube-content, + 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, + } +} diff --git a/v0.1/datapack.wit b/v0.1/datapack.wit new file mode 100644 index 000000000..28345c9df --- /dev/null +++ b/v0.1/datapack.wit @@ -0,0 +1,54 @@ +package pumpkin:plugin@0.1.0; + +interface datapack { + /// Information about a discovered or loaded datapack. + record datapack-info { + id: string, + name: string, + description: string, + pack-format: u32, + is-enabled: bool, + recipe-count: u32, + function-count: u32, + } + + /// Position options for enabling a datapack relative to other packs. + variant enable-position { + first, + last, + before(string), + after(string), + } + + /// Global manager for inspecting and controlling server datapacks. + resource datapack-manager { + /// Returns all known datapacks (both enabled and available/disabled). + list-all-packs: func() -> list; + + /// Returns only currently enabled datapacks. + list-enabled-packs: func() -> list; + + /// Returns available (disabled) datapacks. + list-available-packs: func() -> list; + + /// Retrieves details about a specific datapack by name or ID. + get-pack: func(name: string) -> option; + + /// Checks if a datapack is currently enabled. + is-enabled: func(name: string) -> bool; + + /// Enables a datapack with a specific priority position. + enable-pack: func(name: string, position: enable-position) -> result<_, string>; + + /// Disables an enabled datapack. + disable-pack: func(name: string) -> result<_, string>; + + /// Reloads all enabled datapacks, recipes, and function tags, + /// synchronizes recipes with online players, and triggers `#minecraft:load`. + reload: func() -> result<_, string>; + + /// Executes a datapack function or function tag (e.g. "namespace:fn" or "#namespace:tag"). + /// Returns the number of commands executed. + execute-function: func(name: string) -> result; + } +} diff --git a/v0.1/display.wit b/v0.1/display.wit new file mode 100644 index 000000000..db5db52e2 --- /dev/null +++ b/v0.1/display.wit @@ -0,0 +1,171 @@ +interface display { + use %world.{entity}; + use text.{text-component}; + use item-stack.{item-stack}; + use uuid.{uuid}; + + /// Billboard rendering constraints for display entities. + enum billboard-mode { + fixed, + vertical, + horizontal, + center, + } + + /// Item display transformation modes for item display entities. + enum item-display-mode { + none, + thirdperson-lefthand, + thirdperson-righthand, + firstperson-lefthand, + firstperson-righthand, + head, + gui, + ground, + fixed, + } + + /// Text alignment options for text display entities. + enum text-alignment { + center, + left, + right, + } + + /// 3D single-precision vector. + record vector3f { + x: f32, + y: f32, + z: f32, + } + + /// Single-precision quaternion representing a 3D rotation. + record quaternionf { + x: f32, + y: f32, + z: f32, + w: f32, + } + + /// Transformation (translation, scale, left and right rotations) for display entities. + record display-transformation { + translation: vector3f, + scale: vector3f, + left-rotation: quaternionf, + right-rotation: quaternionf, + } + + /// Common base resource for all display entities. + resource display-entity { + from-entity: static func(entity: borrow) -> option; + get-entity: func() -> entity; + + get-transformation: func() -> display-transformation; + set-transformation: func(transformation: display-transformation); + + get-interpolation-duration: func() -> s32; + set-interpolation-duration: func(duration: s32); + + get-interpolation-start: func() -> s32; + set-interpolation-start: func(delta-ticks: s32); + + get-teleport-duration: func() -> s32; + set-teleport-duration: func(duration: s32); + + get-billboard: func() -> billboard-mode; + set-billboard: func(mode: billboard-mode); + + get-view-range: func() -> f32; + set-view-range: func(range: f32); + + get-shadow-radius: func() -> f32; + set-shadow-radius: func(radius: f32); + + get-shadow-strength: func() -> f32; + set-shadow-strength: func(strength: f32); + + get-display-width: func() -> f32; + set-display-width: func(width: f32); + + get-display-height: func() -> f32; + set-display-height: func(height: f32); + + get-glow-color-override: func() -> s32; + set-glow-color-override: func(color: s32); + + get-brightness: func() -> s32; + set-brightness: func(brightness: s32); + } + + /// Resource specifically for Block Display entities. + resource block-display-entity { + from-entity: static func(entity: borrow) -> option; + get-display: func() -> display-entity; + get-entity: func() -> entity; + + get-block-state-id: func() -> u16; + set-block-state-id: func(state-id: u16); + } + + /// Resource specifically for Item Display entities. + resource item-display-entity { + from-entity: static func(entity: borrow) -> option; + get-display: func() -> display-entity; + get-entity: func() -> entity; + + get-item: func() -> option; + set-item: func(item: option); + + get-item-display-mode: func() -> item-display-mode; + set-item-display-mode: func(mode: item-display-mode); + } + + /// Resource specifically for Text Display entities. + resource text-display-entity { + from-entity: static func(entity: borrow) -> option; + get-display: func() -> display-entity; + get-entity: func() -> entity; + + get-text: func() -> text-component; + set-text: func(text: text-component); + + get-line-width: func() -> s32; + set-line-width: func(width: s32); + + get-background: func() -> s32; + set-background: func(color: s32); + + get-text-opacity: func() -> s8; + set-text-opacity: func(opacity: s8); + + get-shadow: func() -> bool; + set-shadow: func(shadow: bool); + + get-see-through: func() -> bool; + set-see-through: func(see-through: bool); + + get-default-background: func() -> bool; + set-default-background: func(default-background: bool); + + get-alignment: func() -> text-alignment; + set-alignment: func(alignment: text-alignment); + } + + /// Resource specifically for Interaction entities. + resource interaction-entity { + from-entity: static func(entity: borrow) -> option; + get-entity: func() -> entity; + + get-width: func() -> f32; + set-width: func(width: f32); + + get-height: func() -> f32; + set-height: func(height: f32); + + get-response: func() -> bool; + set-response: func(response: bool); + + get-last-attacker: func() -> option; + get-last-interaction: func() -> option; + } +} diff --git a/v0.1/enchantments.wit b/v0.1/enchantments.wit new file mode 100644 index 000000000..51d602e45 --- /dev/null +++ b/v0.1/enchantments.wit @@ -0,0 +1,102 @@ +package pumpkin:plugin@0.1.0; + +interface enchantments { + use text.{text-component}; + + /// Equipment slot where an enchantment is active. + enum attribute-modifier-slot { + any, + main-hand, + off-hand, + hand, + feet, + legs, + chest, + head, + armor, + body, + saddle, + } + + /// Vanilla enchantments enum. + 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, + } + + /// Represents a custom enchantment definition. + record custom-enchantment { + /// Unique identifier for the enchantment (e.g. "my_plugin:lifesteal"). + id: string, + /// Description or display name of the enchantment. + description: text-component, + /// Maximum level of the enchantment (e.g. 1..=10). + max-level: u32, + /// Base anvil repair/combination cost multiplier. + anvil-cost: u32, + /// Tag or item pattern for supported items (e.g. "#minecraft:enchantable/weapon"). + supported-items: string, + /// Weight / rarity of the enchantment (higher = more common, default 5). + weight: u32, + /// Equipment slots where this enchantment is active. + slots: list, + /// List of exclusive/conflicting enchantment IDs. + exclusive-set: list, + } + + /// Global manager for registering and querying custom enchantments. + resource enchantment-manager { + /// Registers a new custom enchantment with the server. + register-enchantment: func(enchantment: custom-enchantment) -> result<_, string>; + + /// Gets an enchantment definition by its ID. + get-enchantment: func(id: string) -> option; + + /// Checks if an enchantment ID is registered. + has-enchantment: func(id: string) -> bool; + + /// Returns all registered custom enchantment IDs. + get-all-enchantment-ids: func() -> list; + } +} diff --git a/v0.1/entity-statuses.wit b/v0.1/entity-statuses.wit new file mode 100644 index 000000000..8cea92e7d --- /dev/null +++ b/v0.1/entity-statuses.wit @@ -0,0 +1,68 @@ +package pumpkin:plugin@0.1.0; + +interface entity-statuses { + enum entity-status { + armadillo-peek, + armorstand-wobble, + body-break, + cancel-shake-wetness, + chest-break, + death, + dolphin-looking-for-treasure, + drown-particles, + eat-grass, + end-ram, + feet-break, + fireworks-explode, + fishing-rod-reel-in, + fox-eat, + full-debug-info, + guardian-attack-sound, + head-break, + honey-jump, + honey-slide, + in-love-hearts, + jump, + kinetic-hit, + legs-break, + love-hearts, + mainhand-break, + offer-flower, + offhand-break, + permission-level-admins, + permission-level-all, + permission-level-gamemasters, + permission-level-moderators, + permission-level-owners, + poof, + protected-from-death, + ravager-roared, + ravager-stunned, + reduced-debug-info, + saddle-break, + shake, + shake-wetness, + silverfish-merge-anim, + sniffer-digging-sound, + sonic-charge, + squid-anim-synch, + start-attacking, + start-ram, + stop-attacking, + stop-offer-flower, + swap-hands, + taming-failed, + taming-succeeded, + teleport, + tendrils-shiver, + tnt-prime, + trusting-failed, + trusting-succeeded, + use-item-complete, + villager-angry, + villager-happy, + villager-sweat, + witch-hat-magic, + zombie-converting, + } +} diff --git a/v0.1/entity-types.wit b/v0.1/entity-types.wit new file mode 100644 index 000000000..a374ebe87 --- /dev/null +++ b/v0.1/entity-types.wit @@ -0,0 +1,164 @@ +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, + sulfur-cube, + 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, + } +} diff --git a/v0.1/entity.wit b/v0.1/entity.wit new file mode 100644 index 000000000..1c286b71d --- /dev/null +++ b/v0.1/entity.wit @@ -0,0 +1 @@ +interface entity { use %world.{entity, living-entity, mob, path-node-type, dye-color, villager-profession, mob-data, sheep-data, wolf-data, cat-data, villager-data, creeper-data, slime-data, enderman-data, iron-golem-data, fox-data, ageable-data, zombie-data, shulker-data, raycast-result, ray-trace-block-result, ray-trace-entity-result, block-direction}; } diff --git a/v0.1/event.wit b/v0.1/event.wit new file mode 100644 index 000000000..1d281d012 --- /dev/null +++ b/v0.1/event.wit @@ -0,0 +1,2435 @@ +interface event { + use common.{block-pos, game-mode, hand, position, click-type}; + use item-stack.{item-stack}; + use enchantments.{enchantment}; + use damage-types.{damage-type}; + use screens.{screen}; + 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}; + use java-dialogs.{dialog}; + + variant serverbound-packet { + java(java-serverbound-packet), + bedrock(bedrock-serverbound-packet), + unknown, + } + + variant clientbound-packet { + java(java-clientbound-packet), + bedrock(bedrock-clientbound-packet), + unknown, + } + + 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, + signature: option>, + 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-respawn-event-data { + player: player, + previous-world: %world, + respawned-world: %world, + position: position, + yaw: f32, + pitch: f32, + alive: 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 + } + + 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, + 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: 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, + click-type: click-type, + slot: s16, + raw-slot: s16, + clicked-item: option, + cursor: option, + hotbar-button: s32, + cancelled: bool + } + + record inventory-close-event-data { + player: player, + window-type: option + } + + 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, + 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, + } + + record dialog-click-action-event-data { + player: player, + id: string, + payload: option>, + cancelled: bool, + } + + record dialog-show-event-data { + player: player, + dialog: dialog, + cancelled: bool, + } + + record dialog-clear-event-data { + player: player, + cancelled: bool, + } + + record server-command-event-data { + command: string, + cancelled: bool + } + + record server-list-ping-address { + host: string, + port: u16 + } + + record server-list-ping-event-data { + hostname: string, + address: server-list-ping-address, + motd: text-component, + max-players: u32, + num-players: u32, + favicon: option + } + + enum server-load-type { + startup, + reload, + } + + record server-load-event-data { + load-type: server-load-type + } + + 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 server-tick-end-event-data { + tick: s32, + duration-nanos: s64 + } + + record packet-received-event-data { + player: player, + packet: serverbound-packet, + packet-id: s32, + raw-payload: list, + cancelled: bool + } + + record packet-sent-event-data { + player: player, + packet: clientbound-packet, + packet-id: s32, + raw-payload: list, + cancelled: bool + } + + record player-interact-entity-event-data { + player: player, + entity-id: s32, + action: entity-interaction-action, + sneaking: bool, + cancelled: bool + } + + record chunk-load-event-data { + target-world: %world, + chunk-x: s32, + chunk-z: s32, + cancelled: bool + } + + record chunk-save-event-data { + target-world: %world, + chunk-x: s32, + chunk-z: s32, + cancelled: bool + } + + record chunk-send-event-data { + target-world: %world, + chunk-x: s32, + chunk-z: s32, + cancelled: bool + } + + record entity-damage-event-data { + entity-id: s32, + damage: f32, + damage-type: damage-type, + cancelled: bool + } + + record entity-death-event-data { + entity-id: s32, + dropped-exp: s32 + } + + record player-death-event-data { + player: player, + death-message: text-component, + dropped-exp: s32, + keep-inventory: bool, + cancelled: bool + } + + record entity-spawn-event-data { + entity-id: s32, + entity-type: string, + position: position, + target-world: %world, + cancelled: bool + } + + record entity-combust-event-data { + entity-id: s32, + duration-secs: f32, + cancelled: bool + } + + record entity-regain-health-event-data { + entity-id: s32, + amount: f32, + cancelled: bool + } + + record entity-air-change-event-data { + entity-id: s32, + amount: s32, + cancelled: bool + } + + record entity-breed-event-data { + father-id: s32, + mother-id: s32, + child-id: s32, + cancelled: bool + } + + record entity-dismount-event-data { + entity-id: s32, + dismounted-id: s32, + cancelled: bool + } + + record entity-dye-event-data { + entity-id: s32, + color: string, + player: option, + cancelled: bool + } + + record entity-enter-love-mode-event-data { + entity-id: s32, + human-entity-id: option, + ticks-in-love: s32, + cancelled: bool + } + + record entity-explode-event-data { + entity-id: s32, + position: position, + yield-rate: f32, + cancelled: bool + } + + record entity-mount-event-data { + entity-id: s32, + mounted-id: s32, + cancelled: bool + } + + record entity-pickup-item-event-data { + entity-id: s32, + item-name: string, + count: u8, + cancelled: bool + } + + record entity-portal-event-data { + entity-id: s32, + portal-pos: block-pos, + cancelled: bool + } + + record entity-resurrect-event-data { + entity-id: s32, + cancelled: bool + } + + record entity-shoot-bow-event-data { + entity-id: s32, + weapon-name: string, + force: f32, + cancelled: bool + } + + record entity-tame-event-data { + entity-id: s32, + owner: player, + cancelled: bool + } + + record entity-target-event-data { + entity-id: s32, + target-id: option, + cancelled: bool + } + + record entity-teleport-event-data { + entity-id: s32, + from-position: position, + to-position: position, + cancelled: bool + } + + record entity-toggle-glide-event-data { + entity-id: s32, + is-gliding: bool, + cancelled: bool + } + + record entity-transform-event-data { + entity-id: s32, + new-entity-id: s32, + transform-reason: string, + cancelled: bool + } + + record creature-spawn-event-data { + entity-id: s32, + entity-type: string, + position: position, + target-world: %world, + spawn-reason: string, + cancelled: bool + } + + record ender-dragon-change-phase-event-data { + entity-id: s32, + current-phase: string, + new-phase: string, + cancelled: bool + } + + record entity-break-door-event-data { + entity-id: s32, + block-pos: block-pos, + cancelled: bool + } + + record entity-change-block-event-data { + entity-id: s32, + block-pos: block-pos, + new-block: string, + cancelled: bool + } + + record entity-damage-by-block-event-data { + entity-id: s32, + damager-pos: option, + damage: f32, + cause: string, + cancelled: bool + } + + record entity-damage-by-entity-event-data { + entity-id: s32, + damager-id: s32, + damage: f32, + cause: string, + cancelled: bool + } + + record entity-drop-item-event-data { + entity-id: s32, + item-name: string, + count: u8, + cancelled: bool + } + + record entity-enter-block-event-data { + entity-id: s32, + block-pos: block-pos, + cancelled: bool + } + + record entity-exhaustion-event-data { + entity-id: s32, + exhaustion: f32, + cancelled: bool + } + + record entity-interact-event-data { + entity-id: s32, + block-pos: block-pos, + cancelled: bool + } + + record entity-knockback-event-data { + entity-id: s32, + hit-by-id: option, + knockback: position, + cancelled: bool + } + + record entity-place-event-data { + entity-id: s32, + block-pos: block-pos, + block-name: string, + cancelled: bool + } + + record entity-pose-change-event-data { + entity-id: s32, + pose: string, + cancelled: bool + } + + record entity-potion-effect-event-data { + entity-id: s32, + effect-name: string, + duration: s32, + amplifier: u8, + cancelled: bool + } + + record entity-spell-cast-event-data { + entity-id: s32, + spell: string, + cancelled: bool + } + + record entity-target-living-entity-event-data { + entity-id: s32, + target-id: option, + reason: string, + cancelled: bool + } + + record entity-toggle-swim-event-data { + entity-id: s32, + is-swimming: bool, + cancelled: bool + } + + record explosion-prime-event-data { + entity-id: s32, + radius: f32, + fire: bool, + cancelled: bool + } + + record firework-explode-event-data { + entity-id: s32, + cancelled: bool + } + + record food-level-change-event-data { + entity-id: s32, + food-level: u8, + cancelled: bool + } + + record item-despawn-event-data { + entity-id: s32, + cancelled: bool + } + + record item-merge-event-data { + entity-id: s32, + target-id: s32, + cancelled: bool + } + + record item-spawn-event-data { + entity-id: s32, + position: position, + item-name: string, + cancelled: bool + } + + record piglin-barter-event-data { + entity-id: s32, + input-item: item-stack, + outcome: list, + cancelled: bool + } + + record projectile-hit-event-data { + entity-id: s32, + hit-position: position, + hit-entity-id: option, + cancelled: bool + } + + record projectile-launch-event-data { + entity-id: s32, + shooter-id: option, + cancelled: bool + } + + record sheep-dye-wool-event-data { + entity-id: s32, + dye-color: u8, + player-id: option, + cancelled: bool + } + + record sheep-regrow-wool-event-data { + entity-id: s32, + cancelled: bool + } + + record slime-split-event-data { + entity-id: s32, + count: s32, + cancelled: bool + } + + record strider-temperature-change-event-data { + entity-id: s32, + is-shivering: bool, + cancelled: bool + } + + record villager-acquire-trade-event-data { + entity-id: s32, + recipe-index: s32, + cancelled: bool + } + + record villager-career-change-event-data { + entity-id: s32, + profession: string, + reason: string, + cancelled: bool + } + + record villager-replenish-trade-event-data { + entity-id: s32, + restock-quantity: s32, + cancelled: bool + } + + record warden-anger-change-event-data { + entity-id: s32, + target-id: s32, + old-anger: s32, + new-anger: s32, + cancelled: bool + } + + record area-effect-cloud-apply-event-data { + entity-id: s32, + affected-entities: list, + cancelled: bool + } + + record arrow-body-count-change-event-data { + entity-id: s32, + old-amount: u32, + new-amount: u32, + cancelled: bool + } + + record bat-toggle-sleep-event-data { + entity-id: s32, + is-awake: bool, + cancelled: bool + } + + record creeper-power-event-data { + entity-id: s32, + lightning-id: option, + cause: string, + cancelled: bool + } + + record entity-combust-by-block-event-data { + entity-id: s32, + combuster: block-pos, + duration: f32, + cancelled: bool + } + + record entity-combust-by-entity-event-data { + entity-id: s32, + combuster-id: s32, + duration: f32, + cancelled: bool + } + + record entity-knockback-by-entity-event-data { + entity-id: s32, + hit-by-id: s32, + force: f64, + x: f64, + z: f64, + cancelled: bool + } + + record entity-portal-enter-event-data { + entity-id: s32, + location: block-pos, + cancelled: bool + } + + record entity-portal-exit-event-data { + entity-id: s32, + from-pos: block-pos, + to-pos: option, + cancelled: bool + } + + record entity-remove-event-data { + entity-id: s32, + cause: string, + cancelled: bool + } + + record entity-target-block-event-data { + entity-id: s32, + block-pos: block-pos, + cancelled: bool + } + + record entity-unleash-event-data { + entity-id: s32, + reason: string, + cancelled: bool + } + + record exp-bottle-event-data { + entity-id: s32, + experience: s32, + location: block-pos, + show-effect: bool, + cancelled: bool + } + + record horse-jump-event-data { + entity-id: s32, + power: f32, + cancelled: bool + } + + record lingering-potion-splash-event-data { + entity-id: s32, + location: block-pos, + potion-item: string, + cancelled: bool + } + + record pig-zap-event-data { + entity-id: s32, + lightning-id: s32, + pig-zombie-id: s32, + cancelled: bool + } + + record pig-zombie-anger-event-data { + entity-id: s32, + target-id: option, + new-anger: s32, + cancelled: bool + } + + record potion-splash-event-data { + entity-id: s32, + location: block-pos, + potion-item: string, + affected-entities: list, + cancelled: bool + } + + record spawner-spawn-event-data { + entity-id: s32, + spawner-pos: block-pos, + cancelled: bool + } + + record trial-spawner-spawn-event-data { + entity-id: s32, + spawner-pos: block-pos, + cancelled: bool + } + + record villager-reputation-change-event-data { + entity-id: s32, + target-id: s32, + reputation-change: s32, + cancelled: bool + } + + record player-item-consume-event-data { + player: player, + item-name: string, + cancelled: bool + } + + record player-item-damage-event-data { + player: player, + item-name: string, + damage: s32, + cancelled: bool + } + + record player-drop-item-event-data { + player: player, + item-name: string, + count: u8, + cancelled: bool + } + + record player-bed-enter-event-data { + player: player, + bed-pos: block-pos, + cancelled: bool + } + + record player-bed-leave-event-data { + player: player, + bed-pos: block-pos + } + + record player-bucket-empty-event-data { + player: player, + block-pos: block-pos, + bucket: string, + cancelled: bool + } + + record player-bucket-fill-event-data { + player: player, + block-pos: block-pos, + bucket: string, + cancelled: bool + } + + record async-player-chat-event-data { + player: player, + message: string, + format: text-component, + cancelled: bool + } + + record async-player-pre-login-event-data { + player-name: string, + player-uuid: string, + ip-address: string, + kick-message: text-component, + cancelled: bool + } + + record player-advancement-done-event-data { + player: player, + advancement-id: string, + cancelled: bool + } + + record player-animation-event-data { + player: player, + animation-type: string, + cancelled: bool + } + + record player-armor-stand-manipulate-event-data { + player: player, + armor-stand-id: s32, + slot: u8, + cancelled: bool + } + + record player-bucket-entity-event-data { + player: player, + entity-id: s32, + bucket-item: string, + cancelled: bool + } + + record player-changed-world-event-data { + player: player, + from-world: %world, + to-world: %world, + cancelled: bool + } + + record player-channel-event-data { + player: player, + channel: string, + cancelled: bool + } + + record player-command-preprocess-event-data { + player: player, + command: string, + cancelled: bool + } + + record player-edit-book-event-data { + player: player, + slot: u32, + pages: list, + title: option, + signing: bool, + cancelled: bool + } + + record player-elytra-boost-event-data { + player: player, + firework-id: s32, + cancelled: bool + } + + record player-exp-cooldown-change-event-data { + player: player, + new-cooldown: s32, + cancelled: bool + } + + record player-harvest-block-event-data { + player: player, + block-pos: block-pos, + harvested-items: list, + cancelled: bool + } + + record player-hide-entity-event-data { + player: player, + entity-id: s32, + cancelled: bool + } + + record player-item-break-event-data { + player: player, + item-name: string + } + + record player-item-mend-event-data { + player: player, + item-name: string, + repair-amount: s32, + exp-consumed: s32, + cancelled: bool + } + + record player-kick-event-data { + player: player, + reason: string, + cancelled: bool + } + + record player-leash-entity-event-data { + player: player, + entity-id: s32, + holder-id: s32, + cancelled: bool + } + + record player-level-change-event-data { + player: player, + old-level: s32, + new-level: s32 + } + + record player-locale-change-event-data { + player: player, + new-locale: string, + cancelled: bool + } + + record player-name-entity-event-data { + player: player, + entity-id: s32, + name: text-component, + cancelled: bool + } + + record player-open-sign-event-data { + player: player, + block-pos: block-pos, + is-front: bool, + cancelled: bool + } + + record player-portal-event-data { + player: player, + from-pos: block-pos, + to-pos: option, + cancelled: bool + } + + record player-pre-login-event-data { + player-name: string, + player-uuid: string, + ip-address: string, + kick-message: text-component, + cancelled: bool + } + + record player-riptide-event-data { + player: player, + item-name: string, + cancelled: bool + } + + record player-shear-entity-event-data { + player: player, + entity-id: s32, + hand: u8, + cancelled: bool + } + + record player-show-entity-event-data { + player: player, + entity-id: s32, + cancelled: bool + } + + record player-spawn-change-event-data { + player: player, + new-spawn: option, + forced: bool, + cancelled: bool + } + + record player-statistic-increment-event-data { + player: player, + statistic-id: string, + amount: s32, + cancelled: bool + } + + record player-swap-hands-event-data { + player: player, + cancelled: bool + } + + record player-take-lectern-book-event-data { + player: player, + block-pos: block-pos, + book: item-stack, + cancelled: bool + } + + record player-unleash-entity-event-data { + player: player, + entity-id: s32, + cancelled: bool + } + + record player-velocity-event-data { + player: player, + velocity: position, + cancelled: bool + } + + record player-input-event-data { + player: player, + input: string, + cancelled: bool + } + + record player-interact-at-entity-event-data { + player: player, + entity-id: s32, + clicked-x: f64, + clicked-y: f64, + clicked-z: f64, + hand: u8, + cancelled: bool + } + + record player-links-send-event-data { + player: player, + links: list, + cancelled: bool + } + + record player-pickup-arrow-event-data { + player: player, + arrow-id: s32, + cancelled: bool + } + + record player-recipe-book-click-event-data { + player: player, + recipe-id: string, + make-all: bool, + cancelled: bool + } + + record player-recipe-book-settings-change-event-data { + player: player, + book-type: string, + is-open: bool, + is-filtering: bool, + cancelled: bool + } + + record player-recipe-discover-event-data { + player: player, + recipe-id: string, + cancelled: bool + } + + record player-register-channel-event-data { + player: player, + channel: string, + cancelled: bool + } + + record player-resource-pack-status-event-data { + player: player, + pack-id: string, + status: string, + cancelled: bool + } + + record player-spawn-location-event-data { + player: player, + spawn-pos: position, + cancelled: bool + } + + record player-unregister-channel-event-data { + player: player, + channel: string, + cancelled: bool + } + + record raid-finish-event-data { + victory: bool, + cancelled: bool + } + + record raid-spawn-wave-event-data { + wave: u32, + pos: block-pos, + cancelled: bool + } + + record raid-stop-event-data { + reason: string, + cancelled: bool + } + + record raid-trigger-event-data { + pos: block-pos, + cancelled: bool + } + + record block-damage-event-data { + player: player, + block-pos: block-pos, + insta-break: bool, + cancelled: bool + } + + record block-ignite-event-data { + block-pos: block-pos, + cancelled: bool + } + + record block-from-to-event-data { + from-pos: block-pos, + to-pos: block-pos, + cancelled: bool + } + + record block-form-event-data { + block-pos: block-pos, + cancelled: bool + } + + record block-fade-event-data { + block-pos: block-pos, + cancelled: bool + } + + record block-dispense-event-data { + block-pos: block-pos, + item-name: string, + cancelled: bool + } + + record block-explode-event-data { + block-pos: block-pos, + yield-rate: f32, + cancelled: bool + } + + record block-physics-event-data { + block-pos: block-pos, + changed-pos: block-pos, + cancelled: bool + } + + record block-piston-extend-event-data { + block-pos: block-pos, + direction: string, + cancelled: bool + } + + record block-piston-retract-event-data { + block-pos: block-pos, + direction: string, + cancelled: bool + } + + record note-play-event-data { + block-pos: block-pos, + instrument: string, + note: u8, + cancelled: bool + } + + record sign-change-event-data { + player: player, + block-pos: block-pos, + lines: list, + cancelled: bool + } + + record sponge-absorb-event-data { + block-pos: block-pos, + cancelled: bool + } + + record tnt-prime-event-data { + block-pos: block-pos, + prime-reason: string, + cancelled: bool + } + + record map-initialize-event-data { + map-id: s32 + } + + record hanging-break-event-data { + entity-id: s32, + remover-entity-id: option, + cancelled: bool + } + + record hanging-break-by-entity-event-data { + entity-id: s32, + remover-entity-id: s32, + cancelled: bool + } + + record hanging-place-event-data { + entity-id: s32, + player: option, + block-pos: block-pos, + block-face: string, + cancelled: bool + } + + record bell-resonate-event-data { + block-pos: block-pos, + target-world: %world, + cancelled: bool + } + + record bell-ring-event-data { + block-pos: block-pos, + target-world: %world, + entity-id: option, + direction: option, + cancelled: bool + } + + record block-brush-event-data { + block-pos: block-pos, + target-world: %world, + player: player, + item: item-stack, + cancelled: bool + } + + record block-cook-event-data { + block-pos: block-pos, + target-world: %world, + source: item-stack, + %result: item-stack, + cancelled: bool + } + + record block-damage-abort-event-data { + player: player, + block-pos: block-pos, + target-world: %world, + item-in-hand: item-stack + } + + record block-dispense-armor-event-data { + block-pos: block-pos, + target-world: %world, + target-entity-id: s32, + item: item-stack, + cancelled: bool + } + + record block-dispense-loot-event-data { + block-pos: block-pos, + target-world: %world, + items: list, + cancelled: bool + } + + record block-drop-item-event-data { + block-pos: block-pos, + target-world: %world, + player: option, + items: list, + cancelled: bool + } + + record block-exp-event-data { + block-pos: block-pos, + target-world: %world, + exp: s32 + } + + record block-fertilize-event-data { + block-pos: block-pos, + target-world: %world, + player: option, + changed-blocks: list>, + cancelled: bool + } + + record block-multi-place-event-data { + player: player, + target-world: %world, + placed-blocks: list>, + cancelled: bool + } + + record block-receive-game-event-data { + block-pos: block-pos, + target-world: %world, + game-event: string, + source-entity-id: option, + cancelled: bool + } + + record block-shear-entity-event-data { + block-pos: block-pos, + target-world: %world, + target-entity-id: s32, + item: item-stack, + cancelled: bool + } + + record block-spread-event-data { + source-pos: block-pos, + target-pos: block-pos, + target-world: %world, + new-state-id: u16, + cancelled: bool + } + + record brewing-start-event-data { + block-pos: block-pos, + target-world: %world, + brewing-time: s32, + cancelled: bool + } + + record campfire-start-event-data { + block-pos: block-pos, + target-world: %world, + item: item-stack, + slot: u8, + cooking-time: s32, + cancelled: bool + } + + record cauldron-level-change-event-data { + block-pos: block-pos, + target-world: %world, + old-level: s32, + new-level: s32, + reason: string, + entity-id: option, + cancelled: bool + } + + record crafter-craft-event-data { + block-pos: block-pos, + target-world: %world, + %result: item-stack, + cancelled: bool + } + + record entity-block-form-event-data { + entity-id: s32, + block-pos: block-pos, + target-world: %world, + new-state-id: u16, + cancelled: bool + } + + record fluid-level-change-event-data { + block-pos: block-pos, + target-world: %world, + new-state-id: u16, + cancelled: bool + } + + record inventory-block-start-event-data { + block-pos: block-pos, + target-world: %world + } + + record leaves-decay-event-data { + block-pos: block-pos, + target-world: %world, + cancelled: bool + } + + record moisture-change-event-data { + block-pos: block-pos, + target-world: %world, + new-moisture: s32, + cancelled: bool + } + + record sculk-bloom-event-data { + block-pos: block-pos, + target-world: %world, + charge: s32, + cancelled: bool + } + + record vault-display-item-event-data { + block-pos: block-pos, + target-world: %world, + item: item-stack, + cancelled: bool + } + + record weather-change-event-data { + target-world: %world, + to-weather-state: bool, + cancelled: bool + } + + record thunder-change-event-data { + target-world: %world, + to-thunder-state: bool, + cancelled: bool + } + + record world-load-event-data { + target-world: %world + } + + record world-unload-event-data { + target-world: %world, + cancelled: bool + } + + record async-structure-generate-event-data { + world-name: string, + structure-name: string, + pos: block-pos, + cancelled: bool + } + + record async-structure-spawn-event-data { + world-name: string, + structure-name: string, + pos: block-pos, + cancelled: bool + } + + record chunk-populate-event-data { + chunk-x: s32, + chunk-z: s32, + cancelled: bool + } + + record chunk-unload-event-data { + chunk-x: s32, + chunk-z: s32, + cancelled: bool + } + + record entities-load-event-data { + chunk-x: s32, + chunk-z: s32, + entity-count: u32, + cancelled: bool + } + + record entities-unload-event-data { + chunk-x: s32, + chunk-z: s32, + entity-count: u32, + cancelled: bool + } + + record generic-game-event-data { + event-id: string, + pos: position, + cancelled: bool + } + + record loot-generate-event-data { + loot-table: string, + cancelled: bool + } + + record portal-create-event-data { + pos: block-pos, + portal-type: string, + cancelled: bool + } + + record structure-grow-event-data { + pos: block-pos, + species: string, + bone-meal: bool, + cancelled: bool + } + + record time-skip-event-data { + skip-amount: s64, + cancelled: bool + } + + record world-init-event-data { + target-world: %world + } + + record world-save-event-data { + world-name: string, + cancelled: bool + } + + record inventory-open-event-data { + player: player, + cancelled: bool + } + + record inventory-drag-event-data { + player: player, + cancelled: bool + } + + record craft-item-event-data { + player: player, + recipe-id: string, + cancelled: bool + } + + record furnace-smelt-event-data { + block-pos: block-pos, + source-item: string, + result-item: string, + cancelled: bool + } + + record brew-event-data { + block-pos: block-pos, + fuel-level: u8, + cancelled: bool + } + + record brewing-stand-fuel-event-data { + block-pos: block-pos, + fuel-power: u16, + cancelled: bool + } + + record furnace-burn-event-data { + block-pos: block-pos, + fuel-item: string, + burn-time: u32, + cancelled: bool + } + + record furnace-extract-event-data { + player: player, + block-pos: block-pos, + item-id: string, + item-amount: u32, + exp-gained: f32 + } + + record furnace-start-smelt-event-data { + block-pos: block-pos, + source-item: string, + cooking-time: u32, + cancelled: bool + } + + record hopper-inventory-search-event-data { + block-pos: block-pos, + search-pos: block-pos, + cancelled: bool + } + + record inventory-creative-event-data { + player: player, + slot: s16, + item-id: string, + item-count: u8, + cancelled: bool + } + + record inventory-interact-event-data { + player: player, + cancelled: bool + } + + record inventory-move-item-event-data { + source-pos: block-pos, + target-pos: block-pos, + item-id: string, + item-amount: u32, + cancelled: bool + } + + record inventory-pickup-item-event-data { + block-pos: block-pos, + item-entity-id: s32, + item-id: string, + cancelled: bool + } + + record prepare-anvil-event-data { + player: player, + rename-text: string, + repair-cost: u32 + } + + record prepare-grindstone-event-data { + player: player, + result-item: option + } + + record prepare-inventory-result-event-data { + player: player, + result-item: option + } + + record prepare-item-craft-event-data { + player: player, + recipe-id: string, + cancelled: bool + } + + record prepare-smithing-event-data { + player: player, + result-item: option + } + + record smith-item-event-data { + player: player, + recipe-id: string, + cancelled: bool + } + + record trade-select-event-data { + player: player, + slot-index: u8, + cancelled: bool + } + + record vehicle-block-collision-event-data { + vehicle-id: s32, + block-pos: block-pos, + cancelled: bool + } + + record vehicle-collision-event-data { + vehicle-id: s32, + cancelled: bool + } + + record vehicle-create-event-data { + vehicle-id: s32, + cancelled: bool + } + + record vehicle-damage-event-data { + vehicle-id: s32, + damage: f32, + attacker-id: option, + cancelled: bool + } + + record vehicle-destroy-event-data { + vehicle-id: s32, + attacker-id: option, + cancelled: bool + } + + record vehicle-enter-event-data { + vehicle-id: s32, + entered-id: s32, + cancelled: bool + } + + record vehicle-entity-collision-event-data { + vehicle-id: s32, + collided-entity-id: s32, + cancelled: bool + } + + record vehicle-exit-event-data { + vehicle-id: s32, + exited-id: s32, + cancelled: bool + } + + record vehicle-move-event-data { + vehicle-id: s32, + from-position: position, + to-position: position, + cancelled: bool + } + + record vehicle-update-event-data { + vehicle-id: s32, + cancelled: bool + } + + record enchantment-offer { + cost: s32, + enchantment-id: s32, + enchantment-level: s32 + } + + record prepare-item-enchant-event-data { + player: player, + item: item-stack, + offers: list, + bookshelf-count: s32, + cancelled: bool + } + + record enchantment-value { + enchantment: enchantment, + level: u32 + } + + record enchant-item-event-data { + player: player, + item: item-stack, + %option: s32, + cost: s32, + enchantments-to-add: list, + cancelled: bool + } + + record lightning-strike-event-data { + position: position, + is-effect: bool, + 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-respawn-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-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, + dialog-click-action-event, + dialog-show-event, + dialog-clear-event, + server-command-event, + server-list-ping-event, + server-load-event, + spawn-change-event, + server-broadcast-event, + server-tick-start-event, + server-tick-end-event, + packet-received-event, + packet-sent-event, + chunk-load-event, + chunk-save-event, + chunk-send-event, + entity-damage-event, + entity-death-event, + player-death-event, + entity-spawn-event, + entity-combust-event, + entity-regain-health-event, + entity-air-change-event, + entity-breed-event, + entity-dismount-event, + entity-dye-event, + entity-enter-love-mode-event, + entity-explode-event, + entity-mount-event, + entity-pickup-item-event, + entity-portal-event, + entity-resurrect-event, + entity-shoot-bow-event, + entity-tame-event, + entity-target-event, + entity-teleport-event, + entity-toggle-glide-event, + entity-transform-event, + player-item-consume-event, + player-item-damage-event, + player-drop-item-event, + player-bed-enter-event, + player-bed-leave-event, + player-bucket-empty-event, + player-bucket-fill-event, + block-damage-event, + block-ignite-event, + block-from-to-event, + block-form-event, + block-fade-event, + block-dispense-event, + block-explode-event, + block-physics-event, + block-piston-extend-event, + block-piston-retract-event, + note-play-event, + sign-change-event, + sponge-absorb-event, + tnt-prime-event, + weather-change-event, + thunder-change-event, + world-load-event, + world-unload-event, + async-structure-generate-event, + async-structure-spawn-event, + chunk-populate-event, + chunk-unload-event, + entities-load-event, + entities-unload-event, + generic-game-event, + loot-generate-event, + portal-create-event, + structure-grow-event, + time-skip-event, + world-init-event, + world-save-event, + inventory-open-event, + inventory-drag-event, + craft-item-event, + furnace-smelt-event, + brew-event, + brewing-stand-fuel-event, + furnace-burn-event, + furnace-extract-event, + furnace-start-smelt-event, + hopper-inventory-search-event, + inventory-creative-event, + inventory-interact-event, + inventory-move-item-event, + inventory-pickup-item-event, + prepare-anvil-event, + prepare-grindstone-event, + prepare-inventory-result-event, + prepare-item-craft-event, + prepare-smithing-event, + smith-item-event, + trade-select-event, + vehicle-block-collision-event, + vehicle-collision-event, + vehicle-create-event, + vehicle-damage-event, + vehicle-destroy-event, + vehicle-enter-event, + vehicle-entity-collision-event, + vehicle-exit-event, + vehicle-move-event, + vehicle-update-event, + prepare-item-enchant-event, + enchant-item-event, + map-initialize-event, + hanging-break-event, + hanging-break-by-entity-event, + hanging-place-event, + bell-resonate-event, + bell-ring-event, + block-brush-event, + block-cook-event, + block-damage-abort-event, + block-dispense-armor-event, + block-dispense-loot-event, + block-drop-item-event, + block-exp-event, + block-fertilize-event, + block-multi-place-event, + block-receive-game-event, + block-shear-entity-event, + block-spread-event, + brewing-start-event, + campfire-start-event, + cauldron-level-change-event, + crafter-craft-event, + entity-block-form-event, + fluid-level-change-event, + inventory-block-start-event, + leaves-decay-event, + moisture-change-event, + sculk-bloom-event, + vault-display-item-event, + creature-spawn-event, + ender-dragon-change-phase-event, + entity-break-door-event, + entity-change-block-event, + entity-damage-by-block-event, + entity-damage-by-entity-event, + entity-drop-item-event, + entity-enter-block-event, + entity-exhaustion-event, + entity-interact-event, + entity-knockback-event, + entity-place-event, + entity-pose-change-event, + entity-potion-effect-event, + entity-spell-cast-event, + entity-target-living-entity-event, + entity-toggle-swim-event, + explosion-prime-event, + firework-explode-event, + food-level-change-event, + item-despawn-event, + item-merge-event, + item-spawn-event, + piglin-barter-event, + projectile-hit-event, + projectile-launch-event, + sheep-dye-wool-event, + sheep-regrow-wool-event, + slime-split-event, + strider-temperature-change-event, + villager-acquire-trade-event, + villager-career-change-event, + villager-replenish-trade-event, + warden-anger-change-event, + area-effect-cloud-apply-event, + arrow-body-count-change-event, + bat-toggle-sleep-event, + creeper-power-event, + entity-combust-by-block-event, + entity-combust-by-entity-event, + entity-knockback-by-entity-event, + entity-portal-enter-event, + entity-portal-exit-event, + entity-remove-event, + entity-target-block-event, + entity-unleash-event, + exp-bottle-event, + horse-jump-event, + lingering-potion-splash-event, + pig-zap-event, + pig-zombie-anger-event, + potion-splash-event, + spawner-spawn-event, + trial-spawner-spawn-event, + villager-reputation-change-event, + async-player-chat-event, + async-player-pre-login-event, + player-advancement-done-event, + player-animation-event, + player-armor-stand-manipulate-event, + player-bucket-entity-event, + player-changed-world-event, + player-channel-event, + player-command-preprocess-event, + player-edit-book-event, + player-elytra-boost-event, + player-exp-cooldown-change-event, + player-harvest-block-event, + player-hide-entity-event, + player-item-break-event, + player-item-mend-event, + player-kick-event, + player-leash-entity-event, + player-level-change-event, + player-locale-change-event, + player-name-entity-event, + player-open-sign-event, + player-portal-event, + player-pre-login-event, + player-riptide-event, + player-shear-entity-event, + player-show-entity-event, + player-spawn-change-event, + player-statistic-increment-event, + player-swap-hands-event, + player-take-lectern-book-event, + player-unleash-entity-event, + player-velocity-event, + player-input-event, + player-interact-at-entity-event, + player-links-send-event, + player-pickup-arrow-event, + player-recipe-book-click-event, + player-recipe-book-settings-change-event, + player-recipe-discover-event, + player-register-channel-event, + player-resource-pack-status-event, + player-spawn-location-event, + player-unregister-channel-event, + raid-finish-event, + raid-spawn-wave-event, + raid-stop-event, + raid-trigger-event, + lightning-strike-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-respawn-event(player-respawn-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-entity-event(player-interact-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), + dialog-click-action-event(dialog-click-action-event-data), + dialog-show-event(dialog-show-event-data), + dialog-clear-event(dialog-clear-event-data), + bedrock-form-response-event(bedrock-form-response-event-data), + server-command-event(server-command-event-data), + server-list-ping-event(server-list-ping-event-data), + server-load-event(server-load-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), + server-tick-end-event(server-tick-end-event-data), + packet-received-event(packet-received-event-data), + packet-sent-event(packet-sent-event-data), + chunk-load-event(chunk-load-event-data), + chunk-save-event(chunk-save-event-data), + chunk-send-event(chunk-send-event-data), + entity-damage-event(entity-damage-event-data), + entity-death-event(entity-death-event-data), + player-death-event(player-death-event-data), + entity-spawn-event(entity-spawn-event-data), + entity-combust-event(entity-combust-event-data), + entity-regain-health-event(entity-regain-health-event-data), + entity-air-change-event(entity-air-change-event-data), + entity-breed-event(entity-breed-event-data), + entity-dismount-event(entity-dismount-event-data), + entity-dye-event(entity-dye-event-data), + entity-enter-love-mode-event(entity-enter-love-mode-event-data), + entity-explode-event(entity-explode-event-data), + entity-mount-event(entity-mount-event-data), + entity-pickup-item-event(entity-pickup-item-event-data), + entity-portal-event(entity-portal-event-data), + entity-resurrect-event(entity-resurrect-event-data), + entity-shoot-bow-event(entity-shoot-bow-event-data), + entity-tame-event(entity-tame-event-data), + entity-target-event(entity-target-event-data), + entity-teleport-event(entity-teleport-event-data), + entity-toggle-glide-event(entity-toggle-glide-event-data), + entity-transform-event(entity-transform-event-data), + player-item-consume-event(player-item-consume-event-data), + player-item-damage-event(player-item-damage-event-data), + player-drop-item-event(player-drop-item-event-data), + player-bed-enter-event(player-bed-enter-event-data), + player-bed-leave-event(player-bed-leave-event-data), + player-bucket-empty-event(player-bucket-empty-event-data), + player-bucket-fill-event(player-bucket-fill-event-data), + block-damage-event(block-damage-event-data), + block-ignite-event(block-ignite-event-data), + block-from-to-event(block-from-to-event-data), + block-form-event(block-form-event-data), + block-fade-event(block-fade-event-data), + block-dispense-event(block-dispense-event-data), + block-explode-event(block-explode-event-data), + block-physics-event(block-physics-event-data), + block-piston-extend-event(block-piston-extend-event-data), + block-piston-retract-event(block-piston-retract-event-data), + note-play-event(note-play-event-data), + sign-change-event(sign-change-event-data), + sponge-absorb-event(sponge-absorb-event-data), + tnt-prime-event(tnt-prime-event-data), + weather-change-event(weather-change-event-data), + thunder-change-event(thunder-change-event-data), + world-load-event(world-load-event-data), + world-unload-event(world-unload-event-data), + async-structure-generate-event(async-structure-generate-event-data), + async-structure-spawn-event(async-structure-spawn-event-data), + chunk-populate-event(chunk-populate-event-data), + chunk-unload-event(chunk-unload-event-data), + entities-load-event(entities-load-event-data), + entities-unload-event(entities-unload-event-data), + generic-game-event(generic-game-event-data), + loot-generate-event(loot-generate-event-data), + portal-create-event(portal-create-event-data), + structure-grow-event(structure-grow-event-data), + time-skip-event(time-skip-event-data), + world-init-event(world-init-event-data), + world-save-event(world-save-event-data), + inventory-open-event(inventory-open-event-data), + inventory-drag-event(inventory-drag-event-data), + craft-item-event(craft-item-event-data), + furnace-smelt-event(furnace-smelt-event-data), + brew-event(brew-event-data), + brewing-stand-fuel-event(brewing-stand-fuel-event-data), + furnace-burn-event(furnace-burn-event-data), + furnace-extract-event(furnace-extract-event-data), + furnace-start-smelt-event(furnace-start-smelt-event-data), + hopper-inventory-search-event(hopper-inventory-search-event-data), + inventory-creative-event(inventory-creative-event-data), + inventory-interact-event(inventory-interact-event-data), + inventory-move-item-event(inventory-move-item-event-data), + inventory-pickup-item-event(inventory-pickup-item-event-data), + prepare-anvil-event(prepare-anvil-event-data), + prepare-grindstone-event(prepare-grindstone-event-data), + prepare-inventory-result-event(prepare-inventory-result-event-data), + prepare-item-craft-event(prepare-item-craft-event-data), + prepare-smithing-event(prepare-smithing-event-data), + smith-item-event(smith-item-event-data), + trade-select-event(trade-select-event-data), + vehicle-block-collision-event(vehicle-block-collision-event-data), + vehicle-collision-event(vehicle-collision-event-data), + vehicle-create-event(vehicle-create-event-data), + vehicle-damage-event(vehicle-damage-event-data), + vehicle-destroy-event(vehicle-destroy-event-data), + vehicle-enter-event(vehicle-enter-event-data), + vehicle-entity-collision-event(vehicle-entity-collision-event-data), + vehicle-exit-event(vehicle-exit-event-data), + vehicle-move-event(vehicle-move-event-data), + vehicle-update-event(vehicle-update-event-data), + prepare-item-enchant-event(prepare-item-enchant-event-data), + enchant-item-event(enchant-item-event-data), + map-initialize-event(map-initialize-event-data), + hanging-break-event(hanging-break-event-data), + hanging-break-by-entity-event(hanging-break-by-entity-event-data), + hanging-place-event(hanging-place-event-data), + bell-resonate-event(bell-resonate-event-data), + bell-ring-event(bell-ring-event-data), + block-brush-event(block-brush-event-data), + block-cook-event(block-cook-event-data), + block-damage-abort-event(block-damage-abort-event-data), + block-dispense-armor-event(block-dispense-armor-event-data), + block-dispense-loot-event(block-dispense-loot-event-data), + block-drop-item-event(block-drop-item-event-data), + block-exp-event(block-exp-event-data), + block-fertilize-event(block-fertilize-event-data), + block-multi-place-event(block-multi-place-event-data), + block-receive-game-event(block-receive-game-event-data), + block-shear-entity-event(block-shear-entity-event-data), + block-spread-event(block-spread-event-data), + brewing-start-event(brewing-start-event-data), + campfire-start-event(campfire-start-event-data), + cauldron-level-change-event(cauldron-level-change-event-data), + crafter-craft-event(crafter-craft-event-data), + entity-block-form-event(entity-block-form-event-data), + fluid-level-change-event(fluid-level-change-event-data), + inventory-block-start-event(inventory-block-start-event-data), + leaves-decay-event(leaves-decay-event-data), + moisture-change-event(moisture-change-event-data), + sculk-bloom-event(sculk-bloom-event-data), + vault-display-item-event(vault-display-item-event-data), + creature-spawn-event(creature-spawn-event-data), + ender-dragon-change-phase-event(ender-dragon-change-phase-event-data), + entity-break-door-event(entity-break-door-event-data), + entity-change-block-event(entity-change-block-event-data), + entity-damage-by-block-event(entity-damage-by-block-event-data), + entity-damage-by-entity-event(entity-damage-by-entity-event-data), + entity-drop-item-event(entity-drop-item-event-data), + entity-enter-block-event(entity-enter-block-event-data), + entity-exhaustion-event(entity-exhaustion-event-data), + entity-interact-event(entity-interact-event-data), + entity-knockback-event(entity-knockback-event-data), + entity-place-event(entity-place-event-data), + entity-pose-change-event(entity-pose-change-event-data), + entity-potion-effect-event(entity-potion-effect-event-data), + entity-spell-cast-event(entity-spell-cast-event-data), + entity-target-living-entity-event(entity-target-living-entity-event-data), + entity-toggle-swim-event(entity-toggle-swim-event-data), + explosion-prime-event(explosion-prime-event-data), + firework-explode-event(firework-explode-event-data), + food-level-change-event(food-level-change-event-data), + item-despawn-event(item-despawn-event-data), + item-merge-event(item-merge-event-data), + item-spawn-event(item-spawn-event-data), + piglin-barter-event(piglin-barter-event-data), + projectile-hit-event(projectile-hit-event-data), + projectile-launch-event(projectile-launch-event-data), + sheep-dye-wool-event(sheep-dye-wool-event-data), + sheep-regrow-wool-event(sheep-regrow-wool-event-data), + slime-split-event(slime-split-event-data), + strider-temperature-change-event(strider-temperature-change-event-data), + villager-acquire-trade-event(villager-acquire-trade-event-data), + villager-career-change-event(villager-career-change-event-data), + villager-replenish-trade-event(villager-replenish-trade-event-data), + warden-anger-change-event(warden-anger-change-event-data), + area-effect-cloud-apply-event(area-effect-cloud-apply-event-data), + arrow-body-count-change-event(arrow-body-count-change-event-data), + bat-toggle-sleep-event(bat-toggle-sleep-event-data), + creeper-power-event(creeper-power-event-data), + entity-combust-by-block-event(entity-combust-by-block-event-data), + entity-combust-by-entity-event(entity-combust-by-entity-event-data), + entity-knockback-by-entity-event(entity-knockback-by-entity-event-data), + entity-portal-enter-event(entity-portal-enter-event-data), + entity-portal-exit-event(entity-portal-exit-event-data), + entity-remove-event(entity-remove-event-data), + entity-target-block-event(entity-target-block-event-data), + entity-unleash-event(entity-unleash-event-data), + exp-bottle-event(exp-bottle-event-data), + horse-jump-event(horse-jump-event-data), + lingering-potion-splash-event(lingering-potion-splash-event-data), + pig-zap-event(pig-zap-event-data), + pig-zombie-anger-event(pig-zombie-anger-event-data), + potion-splash-event(potion-splash-event-data), + spawner-spawn-event(spawner-spawn-event-data), + trial-spawner-spawn-event(trial-spawner-spawn-event-data), + villager-reputation-change-event(villager-reputation-change-event-data), + async-player-chat-event(async-player-chat-event-data), + async-player-pre-login-event(async-player-pre-login-event-data), + player-advancement-done-event(player-advancement-done-event-data), + player-animation-event(player-animation-event-data), + player-armor-stand-manipulate-event(player-armor-stand-manipulate-event-data), + player-bucket-entity-event(player-bucket-entity-event-data), + player-changed-world-event(player-changed-world-event-data), + player-channel-event(player-channel-event-data), + player-command-preprocess-event(player-command-preprocess-event-data), + player-edit-book-event(player-edit-book-event-data), + player-elytra-boost-event(player-elytra-boost-event-data), + player-exp-cooldown-change-event(player-exp-cooldown-change-event-data), + player-harvest-block-event(player-harvest-block-event-data), + player-hide-entity-event(player-hide-entity-event-data), + player-item-break-event(player-item-break-event-data), + player-item-mend-event(player-item-mend-event-data), + player-kick-event(player-kick-event-data), + player-leash-entity-event(player-leash-entity-event-data), + player-level-change-event(player-level-change-event-data), + player-locale-change-event(player-locale-change-event-data), + player-name-entity-event(player-name-entity-event-data), + player-open-sign-event(player-open-sign-event-data), + player-portal-event(player-portal-event-data), + player-pre-login-event(player-pre-login-event-data), + player-riptide-event(player-riptide-event-data), + player-shear-entity-event(player-shear-entity-event-data), + player-show-entity-event(player-show-entity-event-data), + player-spawn-change-event(player-spawn-change-event-data), + player-statistic-increment-event(player-statistic-increment-event-data), + player-swap-hands-event(player-swap-hands-event-data), + player-take-lectern-book-event(player-take-lectern-book-event-data), + player-unleash-entity-event(player-unleash-entity-event-data), + player-velocity-event(player-velocity-event-data), + player-input-event(player-input-event-data), + player-interact-at-entity-event(player-interact-at-entity-event-data), + player-links-send-event(player-links-send-event-data), + player-pickup-arrow-event(player-pickup-arrow-event-data), + player-recipe-book-click-event(player-recipe-book-click-event-data), + player-recipe-book-settings-change-event(player-recipe-book-settings-change-event-data), + player-recipe-discover-event(player-recipe-discover-event-data), + player-register-channel-event(player-register-channel-event-data), + player-resource-pack-status-event(player-resource-pack-status-event-data), + player-spawn-location-event(player-spawn-location-event-data), + player-unregister-channel-event(player-unregister-channel-event-data), + raid-finish-event(raid-finish-event-data), + raid-spawn-wave-event(raid-spawn-wave-event-data), + raid-stop-event(raid-stop-event-data), + raid-trigger-event(raid-trigger-event-data), + lightning-strike-event(lightning-strike-event-data), + } +} diff --git a/v0.1/forms.wit b/v0.1/forms.wit new file mode 100644 index 000000000..c428155b8 --- /dev/null +++ b/v0.1/forms.wit @@ -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, + } + + record simple-form { + title: text-component, + content: text-component, + buttons: list, + } + + record modal-form { + title: text-component, + content: text-component, + button1: text-component, + button2: text-component, + } + + variant custom-form-element { + label(text-component), + toggle(tuple), + slider(tuple), // text, min, max, step, default + step-slider(tuple, u32>), // text, steps, default + dropdown(tuple, u32>), // text, options, default + input(tuple), // text, placeholder, default + } + + record custom-form { + title: text-component, + elements: list, + } + + variant form { + simple(simple-form), + modal(modal-form), + custom(custom-form), + } +} diff --git a/v0.1/game-events.wit b/v0.1/game-events.wit new file mode 100644 index 000000000..0700f43d7 --- /dev/null +++ b/v0.1/game-events.wit @@ -0,0 +1,67 @@ +package pumpkin:plugin@0.1.0; + +interface game-events { + enum game-event { + block-activate, + block-attach, + block-change, + block-close, + block-deactivate, + block-destroy, + block-detach, + block-open, + block-place, + bounce, + container-close, + container-open, + drink, + eat, + elytra-glide, + entity-damage, + entity-die, + entity-dismount, + entity-interact, + entity-mount, + entity-place, + entity-action, + equip, + explode, + flap, + fluid-pickup, + fluid-place, + hit-ground, + instrument-play, + item-interact-finish, + item-interact-start, + jukebox-play, + jukebox-stop-play, + lightning-strike, + note-block-play, + prime-fuse, + projectile-land, + projectile-shoot, + sculk-sensor-tendrils-clicking, + shear, + shriek, + splash, + step, + swim, + teleport, + unequip, + resonate-1, + resonate-2, + resonate-3, + resonate-4, + resonate-5, + resonate-6, + resonate-7, + resonate-8, + resonate-9, + resonate-10, + resonate-11, + resonate-12, + resonate-13, + resonate-14, + resonate-15, + } +} diff --git a/v0.1/game-rules.wit b/v0.1/game-rules.wit new file mode 100644 index 000000000..0ac2b9d68 --- /dev/null +++ b/v0.1/game-rules.wit @@ -0,0 +1,69 @@ +package pumpkin:plugin@0.1.0; + +interface game-rules { + enum game-rule { + advance-time, + advance-weather, + allow-entering-nether-using-portals, + block-drops, + block-explosion-drop-decay, + command-block-output, + command-blocks-work, + drowning-damage, + elytra-movement-check, + ender-pearls-vanish-on-death, + entity-drops, + fall-damage, + fire-damage, + fire-spread-radius-around-player, + forgive-dead-players, + freeze-damage, + global-sound-events, + immediate-respawn, + keep-inventory, + lava-source-conversion, + limited-crafting, + locator-bar, + log-admin-commands, + max-block-modifications, + max-command-forks, + max-command-sequence-length, + max-entity-cramming, + max-minecart-speed, + max-snow-accumulation-height, + mob-drops, + mob-explosion-drop-decay, + mob-griefing, + natural-health-regeneration, + player-movement-check, + players-nether-portal-creative-delay, + players-nether-portal-default-delay, + players-sleeping-percentage, + projectiles-can-break-blocks, + pvp, + raids, + random-tick-speed, + reduced-debug-info, + respawn-radius, + send-command-feedback, + show-advancement-messages, + show-death-messages, + spawn-mobs, + spawn-monsters, + spawn-patrols, + spawn-phantoms, + spawn-wandering-traders, + spawn-wardens, + spawner-blocks-work, + spectators-generate-chunks, + spread-vines, + tnt-explodes, + tnt-explosion-drop-decay, + universal-anger, + water-source-conversion, + } + variant game-rule-value { + int(s32), + %bool(bool), + } +} diff --git a/v0.1/gui.wit b/v0.1/gui.wit new file mode 100644 index 000000000..23aa11933 --- /dev/null +++ b/v0.1/gui.wit @@ -0,0 +1,39 @@ +interface gui { + use text.{text-component}; + use common.{click-type}; + use item-stack.{item-stack}; + use screens.{screen}; + use inventory.{inventory}; + + resource gui { + constructor(%type: screen, title: text-component); + /// Returns the underlying inventory handle for this GUI. + get-inventory: func() -> inventory; + set-item: func(slot: u32, item: item-stack); + get-item: func(slot: u32) -> option; + + /// Returns the type of this GUI. + get-type: func() -> screen; + + /// 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; + } +} diff --git a/v0.1/i18n.wit b/v0.1/i18n.wit new file mode 100644 index 000000000..2d7507437 --- /dev/null +++ b/v0.1/i18n.wit @@ -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); +} diff --git a/v0.1/inventory.wit b/v0.1/inventory.wit new file mode 100644 index 000000000..ad236d88c --- /dev/null +++ b/v0.1/inventory.wit @@ -0,0 +1,78 @@ +package pumpkin:plugin@0.1.0; + +interface inventory { + use item-stack.{item-stack}; + use common.{hand}; + + /// Common inventory resource used across GUIs, player inventories, and containers. + resource inventory { + /// Returns the number of slots in this inventory. + get-size: func() -> u32; + + /// Returns true if all slots in this inventory are empty. + is-empty: func() -> bool; + + /// Returns the item in the specified slot index, or none if empty. + get-item: func(slot: u32) -> option; + + /// Sets the item in the specified slot index. + set-item: func(slot: u32, item: option); + + /// Removes and returns the item in the specified slot index. + remove-item: func(slot: u32) -> option; + + /// Clears all items from this inventory. + clear: func(); + + /// Returns all items in this inventory as a list of slots. + get-all-items: func() -> list>; + + /// Sets all items in this inventory from a list. + set-all-items: func(items: list>); + + /// Counts the total number of items with the given ID in this inventory. + count-item: func(item-id: string) -> u32; + + /// Checks if the inventory contains at least one item with the given ID. + contains-item: func(item-id: string) -> bool; + } + + /// Specialized player inventory handle providing access to main inventory, armor, offhand, and hotbar. + resource player-inventory { + /// Returns the generic 36-slot inventory handle (hotbar + main storage). + as-inventory: func() -> inventory; + + /// Returns the item currently held in the specified hand. + get-item-in-hand: func(hand: hand) -> option; + /// Sets the item in the specified hand. + set-item-in-hand: func(hand: hand, item: option); + + /// Returns the currently selected hotbar slot index (0-8). + get-selected-slot: func() -> u8; + /// Sets the currently selected hotbar slot index (0-8). + set-selected-slot: func(slot: u8); + + /// Armor slot accessors + get-helmet: func() -> option; + set-helmet: func(item: option); + + get-chestplate: func() -> option; + set-chestplate: func(item: option); + + get-leggings: func() -> option; + set-leggings: func(item: option); + + get-boots: func() -> option; + set-boots: func(item: option); + + get-off-hand: func() -> option; + set-off-hand: func(item: option); + + /// Clears all armor slots. + clear-armor: func(); + /// Clears the 36 main inventory slots. + clear-main: func(); + /// Clears all slots (main inventory, armor, offhand). + clear-all: func(); + } +} diff --git a/v0.1/ipc.wit b/v0.1/ipc.wit new file mode 100644 index 000000000..950bd5031 --- /dev/null +++ b/v0.1/ipc.wit @@ -0,0 +1,7 @@ +interface ipc { + type plugin-id = string; + type ipc-message = list; + + // Sends a message to the specified plugin, synchronously receiving a response (or an error). + send-ipc-message: func(recipient: plugin-id, message: ipc-message) -> result>; +} diff --git a/v0.1/item-stack.wit b/v0.1/item-stack.wit new file mode 100644 index 000000000..c1ac95f87 --- /dev/null +++ b/v0.1/item-stack.wit @@ -0,0 +1,104 @@ +interface item-stack { + use attributes.{attribute, attribute-modifier}; + use data-components.{data-component}; + use enchantments.{attribute-modifier-slot, enchantment}; + use text.{text-component}; + + /// Represents an enchantment and its level. + record enchantment-value { + enchantment: enchantment, + level: u32, + } + + /// Represents a custom enchantment and its level on an item stack. + record custom-enchantment-value { + enchantment-id: string, + level: u32, + } + + /// Represents an attribute modifier applied to an item stack for a specific slot. + record item-attribute-modifier { + attribute: attribute, + modifier: attribute-modifier, + slot: attribute-modifier-slot, + } + + /// Represents a data component and its serialized value. + record data-component-value { + component: data-component, + /// The serialized value of the component. + value: list, + } + + use common.{nbt-entry, nbt-tree, nbt-tag}; + + 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; + /// 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 all custom enchantments on this item stack. + get-custom-enchantments: func() -> list; + /// Adds a custom enchantment to this item stack. + add-custom-enchantment: func(enchantment-id: string, level: u32); + /// Removes a custom enchantment from this item stack. + remove-custom-enchantment: func(enchantment-id: string); + /// Returns the level of a custom enchantment on this item stack, if present. + get-custom-enchantment-level: func(enchantment-id: string) -> option; + /// Returns whether this item stack has a specific custom enchantment. + has-custom-enchantment: func(enchantment-id: string) -> bool; + + /// Returns all attribute modifiers on this item stack. + get-attribute-modifiers: func() -> list; + /// Adds an attribute modifier to this item stack. + add-attribute-modifier: func(modifier: item-attribute-modifier); + /// Removes all attribute modifiers for a specific attribute from this item stack. + remove-attribute-modifiers: func(attribute: attribute); + /// Clears all custom attribute modifiers from this item stack. + clear-attribute-modifiers: func(); + + /// Returns the lore of this item stack. + get-lore: func() -> list; + /// Sets the lore of this item stack. + set-lore: func(lore: list); + /// 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; + /// Sets the custom name of this item stack. + set-custom-name: func(name: option); + + /// Sets a namespaced custom data value on this item stack. + set-custom-data: func(namespace: string, key: string, value: nbt-tree); + /// Returns a namespaced custom data value from this item stack, if set. + get-custom-data: func(namespace: string, key: string) -> option; + /// Removes a namespaced custom data value from this item stack. + remove-custom-data: func(namespace: string, key: string); + /// Returns whether this item stack has a namespaced custom data value. + has-custom-data: func(namespace: string, key: string) -> bool; + + /// Returns all data components on this item stack. + get-components: func() -> list; + /// Sets a data component on this item stack. + set-component: func(component: data-component, value: list); + /// Removes a data component from this item stack. + remove-component: func(component: data-component); + } +} diff --git a/v0.1/java-dialogs.wit b/v0.1/java-dialogs.wit new file mode 100644 index 000000000..2c93e759f --- /dev/null +++ b/v0.1/java-dialogs.wit @@ -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, + } + + /// A multiple-choice selection input control. + record dialog-input-single-option { + label: text-component, + options: list, + 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, + width: option, + 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>, + } + + /// 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, + /// A list of interactive input controls. + inputs: list, + /// A list of clickable buttons (for multi-action and other types). + buttons: list, + /// A list of links (primarily for server-links type). + links: list, + /// What to do after the dialog is closed. + after-action: option, + /// 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, + } +} diff --git a/v0.1/java-packets.wit b/v0.1/java-packets.wit new file mode 100644 index 000000000..4d3a99957 --- /dev/null +++ b/v0.1/java-packets.wit @@ -0,0 +1,1838 @@ +package pumpkin:plugin@0.1.0; + +interface java-packets { + use uuid.{ uuid }; + record config-s-client-information-config { + locale: string, + view-distance: u8, + chat-mode: s32, + chat-colors: bool, + skin-parts: u8, + main-hand: s32, + text-filtering: bool, + server-listing: bool, + } + record config-s-config-cookie-response { + key: string, + has-payload: bool, + payload: option>, + } + record config-s-custom-click-action { + action-id: string, + payload: option>, + } + record config-s-keep-alive { + keep-alive-id: s64, + } + record config-s-known-packs { + known-packs: list, + } + record config-s-plugin-message { + channel: string, + data: list, + } + record config-s-config-pong { + id: s32, + } + variant resource-pack-response-result { + download-success, + download-fail, + downloaded, + accepted, + declined, + invalid-url, + reload-failed, + discarded, + unknown(s32), + } + record config-s-config-resource-pack { + uuid: uuid, + %result: s32, + } + record login-s-login-cookie-response { + key: string, + payload: option>, + } + record s-encryption-response { + shared-secret: list, + verify-token: list, + } + record login-s-login-start { + name: string, + uuid: uuid, + } + record login-s-login-plugin-response { + message-id: s32, + data: option>, + } + record s-attack { + entity-id: s32, + } + record s-block-entity-tag-query { + transaction-id: s32, + location: tuple, + } + record s-bundle-item-selected { + slot-id: s32, + selected-item-index: s32, + } + record s-change-difficulty { + difficulty: string, + } + record s-change-game-mode { + game-mode: string, + } + record s-chat-ack { + offset: s32, + } + record s-chat-command { + command: string, + } + record argument-signature { + name: string, + signature: list, + } + record s-chat-command-signed { + command: string, + timestamp: s64, + salt: s64, + argument-signatures: list, + message-count: s32, + acknowledged: list, + checksum: u8, + } + record s-chat-message { + message: string, + timestamp: s64, + salt: s64, + signature: option>, + message-count: s32, + acknowledged: list, + checksum: u8, + } + record s-chunk-batch { + chunks-per-tick: f32, + } + record s-click-slot { + sync-id: s32, + revision: s32, + slot: s32, + button: u8, + mode: slot-action-type, + length-of-array: s32, + array-of-changed-slots: list>, + carried-item: string, + } + enum slot-action-type { + pickup, + quick-move, + swap, + clone, + throw, + quick-craft, + pickup-all, + } + 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-container-slot-state-changed { + slot-id: s32, + container-id: s32, + new-state: bool, + } + record s-cookie-response { + key: string, + payload: option>, + } + record s-custom-click-action { + action-id: string, + payload: option>, + } + record s-custom-payload { + channel: string, + data: list, + } + record s-debug-sample-subscription { + sample-type: s32, + } + record s-debug-subscription-request { + sample-type: s32, + } + record s-edit-book { + slot: s32, + pages: list, + title: option, + } + record s-entity-tag-query { + transaction-id: s32, + entity-id: s32, + } + record s-interact { + entity-id: s32, + r-type: s32, + target-position: option>, + hand: option, + sneaking: bool, + } + enum action-type { + interact, + attack, + interact-at, + } + record s-jigsaw-generate { + pos: tuple, + levels: s32, + keep-jigsaws: bool, + } + record s-keep-alive { + keep-alive-id: s64, + } + record s-lock-difficulty { + locked: bool, + } + record s-move-vehicle { + x: f64, + y: f64, + z: f64, + yaw: f32, + pitch: f32, + on-ground: bool, + } + record s-paddle-boat { + left-paddle: bool, + right-paddle: bool, + } + record s-pick-item-from-block { + pos: tuple, + 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, + fly-speed: option, + walk-speed: option, + } + record s-player-action { + status: s32, + position: tuple, + face: u8, + sequence: s32, + } + enum status { + started-digging, + cancelled-digging, + finished-digging, + drop-item-stack, + drop-item, + release-item-in-use, + swap-item, + spear-jab, + } + record s-player-command { + entity-id: s32, + action: action, + jump-boost: s32, + } + enum action { + start-sneaking, + stop-sneaking, + leave-bed, + start-sprinting, + stop-sprinting, + start-horse-jump, + stop-horse-jump, + open-vehicle-inventory, + start-flying-elytra, + } + record s-set-player-ground { + on-ground: bool, + } + record s-player-input { + input: u8, + } + record s-player-position { + position: tuple, + collision: u8, + } + record s-player-position-rotation { + position: tuple, + 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, + key-signature: list, + } + record s-play-pong { + id: s32, + } + 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, + } + variant play-resource-pack-result { + download-success, + declined, + download-fail, + accepted, + downloaded, + invalid-url, + reload-failed, + discarded, + unknown(s32), + } + record s-play-resource-pack { + uuid: uuid, + %result: s32, + } + variant s-seen-advancement { + open-tab(string), + close-tab, + } + record s-select-trade { + selected-slot: s32, + } + record s-set-beacon { + primary-effect: option, + secondary-effect: option, + } + record s-set-command-block { + pos: tuple, + command: string, + mode: s32, + %flags: u8, + } + enum command-block-mode { + chain, + repeating, + impulse, + } + record s-set-command-minecart { + entity-id: s32, + command: string, + track-output: bool, + } + record s-set-creative-slot { + slot: s32, + clicked-item: string, + } + record game-rule-entry { + game-rule-key: string, + value: string, + } + record s-set-game-rule { + entries: list, + } + record s-set-held-item { + slot: s32, + } + record s-set-jigsaw-block { + pos: tuple, + name: string, + target: string, + pool: string, + final-state: string, + joint: string, + selection-priority: s32, + placement-priority: s32, + } + record s-set-structure-block { + location: tuple, + action: s32, + mode: s32, + name: string, + offset-x: u8, + offset-y: u8, + offset-z: u8, + size-x: u8, + size-y: u8, + size-z: u8, + mirror: s32, + rotation: s32, + metadata: string, + integrity: f32, + seed: s64, + %flags: u8, + } + record s-set-test-block { + position: tuple, + mode: test-block-mode, + message: string, + } + enum test-block-mode { + start, + log, + fail, + accept, + } + record s-spectate-entity { + target: uuid, + } + record s-swing-arm { + hand: s32, + } + record s-teleport-to-entity { + target: uuid, + } + record s-test-instance-block-action { + pos: tuple, + action: test-instance-block-action, + data: test-instance-block-data, + } + enum test-instance-block-action { + init, + query, + set, + reset, + save, + %export, + run, + } + record var-int-vector3 { + x: s32, + y: s32, + z: s32, + } + record test-instance-block-data { + test: option, + size: var-int-vector3, + rotation: string, + ignore-entities: bool, + status: test-instance-block-status, + error-message: option, + } + enum test-instance-block-status { + cleared, + running, + success, + failed, + } + record s-update-sign { + location: tuple, + 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, + face: s32, + cursor-pos: tuple, + inside-block: bool, + is-against-world-border: bool, + sequence: s32, + } + record status-s-status-ping-request { + payload: s64, + } + record config-c-config-add-resource-pack { + uuid: uuid, + url: string, + hash: string, + forced: bool, + prompt-message: option, + } + record config-c-code-of-conduct { + code-of-conduct: string, + } + record config-c-config-disconnect { + reason: string, + } + record config-c-cookie-request { + key: string, + } + record config-c-config-custom-report-details { + details: list>, + } + record config-c-feature-flags { + features: list, + } + record config-c-known-packs { + known-packs: list, + } + record config-c-config-ping { + id: s32, + } + record config-c-plugin-message { + channel: string, + data: list, + } + record config-c-registry-data { + registry-id: string, + entries: list, + } + record config-c-config-remove-resource-pack { + uuid: option, + } + record config-c-config-server-links { + links: list, + } + record config-c-config-show-dialog { + dialog: string, + } + record config-c-store-cookie { + key: string, + payload: list, + } + record config-c-transfer { + host: string, + port: s32, + } + record config-c-update-tags { + tags: list, + } + record login-c-login-cookie-request { + key: string, + } + record c-encryption-request { + server-id: string, + public-key: list, + verify-token: list, + should-authenticate: bool, + } + record login-c-login-disconnect { + json-reason: string, + } + record c-login-success { + uuid: uuid, + username: string, + properties: list, + strict-error-handling: bool, + session-id: uuid, + } + record login-c-login-plugin-request { + message-id: s32, + channel: string, + data: list, + } + record login-c-set-compression { + threshold: s32, + } + record c-acknowledge-block-change { + sequence-id: s32, + } + record c-action-bar { + action-bar: string, + } + record c-add-resource-pack { + uuid: uuid, + url: string, + hash: string, + forced: bool, + prompt-message: option, + } + record c-award-stats { + stats: list, + } + record statistic { + category-id: s32, + statistic-id: s32, + value: s32, + } + record c-set-block-destroy-stage { + entity-id: s32, + location: tuple, + destroy-stage: u8, + } + record c-block-entity-data { + location: tuple, + r-type: s32, + nbt-data: list, + } + record c-block-event { + location: tuple, + action-id: u8, + action-parameter: u8, + block-type: s32, + } + record c-block-update { + location: tuple, + state-id: s32, + } + record c-boss-event { + uuid: uuid, + action: bossevent-action, + } + record bossevent-action-add { + title: string, + health: f32, + color: s32, + division: s32, + %flags: u8, + } + record bossevent-action-update-style { + color: s32, + dividers: s32, + } + variant bossevent-action { + add(bossevent-action-add), + remove, + update-health(f32), + update-tile(string), + update-style(bossevent-action-update-style), + update-flags(u8), + } + 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 chunk-biome-entry { + chunk-x: s32, + chunk-z: s32, + data: list, + } + record c-chunks-biomes { + chunks: list, + } + record c-clear-title { + reset: bool, + } + record c-close-container { + sync-id: s32, + } + record c-combat-death { + player-id: s32, + message: string, + } + record c-combat-end { + duration-ticks: s32, + } + record c-command-suggestions { + id: s32, + start: s32, + length: s32, + matches: list, + } + record command-suggestion { + suggestion: string, + tooltip: option, + } + record c-commands { + nodes: list, + root-node-index: s32, + } + record proto-node { + children: list, + node-type: proto-node-type, + } + record proto-node-type-literal { + name: string, + is-executable: bool, + redirect-target: option, + restricted: bool, + } + record proto-node-type-argument { + name: string, + is-executable: bool, + redirect-target: option, + parser: argument-type, + override-suggestion-type: option, + restricted: bool, + } + variant proto-node-type { + root, + literal(proto-node-type-literal), + argument(proto-node-type-argument), + } + record argument-type-float { + min: option, + max: option, + } + record argument-type-double { + min: option, + max: option, + } + record argument-type-integer { + min: option, + max: option, + } + record argument-type-long { + min: option, + max: option, + } + record argument-type-entity { + %flags: u8, + } + record argument-type-score-holder { + %flags: u8, + } + record argument-type-time { + min: s32, + } + record argument-type-resource-or-tag { + identifier: string, + } + record argument-type-resource-or-tag-key { + identifier: string, + } + record argument-type-resource { + identifier: string, + } + record argument-type-resource-key { + identifier: string, + } + variant argument-type { + %bool, + float(argument-type-float), + double(argument-type-double), + integer(argument-type-integer), + long(argument-type-long), + %string(string-proto-arg-behavior), + entity(argument-type-entity), + game-profile, + block-pos, + column-pos, + vec3, + vec2, + block-state, + block-predicate, + item-stack, + item-predicate, + color, + hex-color, + component, + style, + message, + nbt-compound, + nbt-tag, + nbt-path, + objective, + objective-criteria, + operation, + particle, + angle, + rotation, + scoreboard-slot, + score-holder(argument-type-score-holder), + swizzle, + team, + item-slot, + item-slots, + resource-location, + function, + entity-anchor, + int-range, + float-range, + dimension, + gamemode, + time(argument-type-time), + resource-or-tag(argument-type-resource-or-tag), + resource-or-tag-key(argument-type-resource-or-tag-key), + %resource(argument-type-resource), + resource-key(argument-type-resource-key), + resource-selector, + template-mirror, + template-rotation, + heightmap, + loot-table, + loot-predicate, + loot-modifier, + dialog, + uuid, + } + enum string-proto-arg-behavior { + single-word, + quotable-phrase, + greedy-phrase, + } + enum suggestion-providers { + ask-server, + all-recipes, + available-sounds, + summonable-entities, + } + record c-play-cookie-request { + key: string, + } + record c-custom-chat-completions { + action: s32, + entries: list, + } + record c-custom-payload { + channel: string, + data: list, + } + record c-play-custom-report-details { + details: list>, + } + record c-damage-event { + entity-id: s32, + source-type-id: s32, + source-cause-id: s32, + source-direct-id: s32, + source-position: option>, + } + record c-debug-block-value { + pos: tuple, + name: string, + value: string, + } + record c-debug-chunk-value { + chunk-pos: tuple, + name: string, + value: string, + } + record c-debug-entity-value { + entity-id: s32, + name: string, + value: string, + } + record c-debug-event { + name: string, + data: list, + } + record c-debug-sample { + sample: list, + sample-type: s32, + } + record c-delete-chat { + signature-id: s32, + signature: option>, + } + record c-play-disconnect { + reason: string, + } + record c-disguised-chat-message { + message: string, + chat-type: s32, + sender-name: string, + target-name: option, + } + record c-display-objective { + position: s32, + score-name: string, + } + record c-entity-animation { + entity-id: s32, + animation: u8, + } + enum animation { + swing-main-arm, + leave-bed, + swing-offhand, + critical-effect, + magic-criticaleffect, + } + record c-set-entity-metadata { + entity-id: s32, + metadata: list, + } + record c-entity-position-sync { + entity-id: s32, + position: tuple, + delta: tuple, + 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, + radius: f32, + block-count: s32, + knockback: option>, + particle: s32, + sound: string, + block-particles-pool-size: s32, + } + record c-game-event { + event: u8, + value: f32, + } + enum game-event { + no-respawn-block-available, + begin-raining, + end-raining, + change-game-mode, + win-game, + demo-event, + arrow-hit-player, + rain-level-change, + thunder-level-change, + play-pufferfish-string-sound, + play-elder-guardian-mob-appearance, + enabled-respawn-screen, + limited-crafting, + start-waiting-chunks, + } + record c-game-rule-values { + rules: list>, + } + record c-game-test-highlight-pos { + pos: tuple, + color: s32, + label: string, + duration-ms: s32, + } + 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: s64, + 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, + data: s32, + disable-relative-volume: bool, + } + record c-light-update { + chunk-x: s32, + chunk-z: s32, + light-data: light-data, + } + record light-data { + trust-edges: bool, + sky-light-mask: list, + block-light-mask: list, + empty-sky-light-mask: list, + empty-block-light-mask: list, + sky-light-arrays: list>, + block-light-arrays: list>, + } + record c-login { + entity-id: s32, + is-hardcore: bool, + dimension-names: list, + max-players: s32, + view-distance: s32, + simulated-distance: s32, + reduced-debug-info: bool, + enabled-respawn-screen: bool, + limited-crafting: bool, + spawn-data: player-spawn-data, + online-mode: bool, + enforce-secure-chat: bool, + } + record c-map-item-data { + map-id: s32, + scale: u8, + tracking-position: bool, + locked: bool, + icons: option>, + data: option, + } + record map-icon { + icon-type: s32, + x: u8, + z: u8, + direction: u8, + display-name: option, + } + record map-patch { + columns: u8, + rows: u8, + x: u8, + z: u8, + data: list, + } + record merchant-offer { + base-cost-a: string, + output: string, + cost-b: option, + reward-exp: bool, + uses: s32, + max-uses: s32, + xp: s32, + special-price: s32, + price-multiplier: f32, + demand: s32, + } + record c-merchant-offers { + window-id: s32, + offers: list, + villager-level: s32, + experience: s32, + is-regular-villager: bool, + can-restock: bool, + } + record minecart-step { + position: tuple, + movement: tuple, + yaw: f32, + pitch: f32, + weight: f32, + } + record c-move-minecart-along-track { + entity-id: s32, + steps: list, + } + record c-move-vehicle { + x: f64, + y: f64, + z: f64, + yaw: f32, + pitch: f32, + } + record c-multi-block-update { + chunk-section: tuple, + suppress-light-updates: bool, + updates: list, string>>, + } + record c-open-book { + hand: s32, + } + record c-open-mount-screen { + window-id: u8, + slot-count: s32, + entity-id: s32, + } + record c-open-screen { + sync-id: s32, + window-type: s32, + window-title: string, + } + record c-open-sign-editor { + location: tuple, + is-front-text: bool, + } + record c-particle { + force-spawn: bool, + important: bool, + position: tuple, + offset: tuple, + max-speed: f32, + particle-count: s32, + particle-id: s32, + data: list, + } + record c-play-ping { + id: s32, + } + record c-ping-response { + payload: s64, + } + record c-place-ghost-recipe { + window-id: u8, + recipe-id: string, + } + record c-player-abilities { + %flags: u8, + flying-speed: f32, + field-of-view: f32, + } + record player-action-add-player { + name: string, + properties: list, + } + variant player-action { + add-player(player-action-add-player), + initialize-chat(option), + update-game-mode(s32), + update-listed(bool), + update-latency(s32), + update-display-name(option), + update-list-order(s32), + update-hat(bool), + } + record init-chat { + session-id: uuid, + expires-at: s64, + public-key: list, + signature: list, + } + record c-player-chat-message { + global-index: s32, + sender: uuid, + index: s32, + message-signature: option>, + message: string, + timestamp: s64, + salt: s64, + previous-messages: list, + unsigned-content: option, + filter-type: filter-type, + chat-type: s32, + sender-name: string, + target-name: option, + } + record previous-message { + id: s32, + signature: option>, + } + variant filter-type { + pass-through, + fully-filtered, + partially-filtered(list), + } + record c-player-info-update { + actions: u8, + players: list, + } + record player { + uuid: uuid, + actions: list, + } + record c-player-look-at { + from-anchor: s32, + target-x: f64, + target-y: f64, + target-z: f64, + entity: option>, + } + record c-player-position { + teleport-id: s32, + position: tuple, + delta: tuple, + yaw: f32, + pitch: f32, + relatives: list, + } + record c-remove-player-info { + players: list, + } + record c-player-rotation { + yaw: f32, + pitch: f32, + } + record player-spawn-data { + dimension: string, + hashed-seed: s64, + game-mode: u8, + previous-gamemode: u8, + debug: bool, + is-flat: bool, + death-dimension-name: option>>, + portal-cooldown: s32, + sealevel: s32, + } + record c-player-spawn-position { + dimension-name: string, + location: tuple, + yaw: f32, + pitch: f32, + } + record c-projectile-power { + entity-id: s32, + x-power: f64, + y-power: f64, + z-power: f64, + } + record c-recipe-book-add { + replace: bool, + } + record c-recipe-book-remove { + recipes: list, + } + 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, + } + record c-remove-mob-effect { + entity-id: s32, + effect-id: s32, + } + record c-remove-resource-pack { + uuid: option, + } + record c-reset-score { + entity-name: string, + objective-name: option, + } + record c-respawn { + player-spawn-info: player-spawn-data, + data-kept: u8, + } + record c-select-advancements-tab { + tab-id: option, + } + record c-server-data { + motd: string, + icon-base64: option, + } + record c-play-server-links { + links: list, + } + record c-set-border-center { + x: f64, + z: f64, + } + record c-set-border-lerp-size { + old-diameter: f64, + new-diameter: f64, + speed: s64, + } + 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-camera { + camera-id: s32, + } + record c-set-chunk-cache-radius { + radius: s32, + } + record c-set-container-content { + window-id: s32, + state-id: s32, + slot-data: list, + 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-entity-link { + attached-entity-id: s32, + holding-entity-id: s32, + leash: bool, + } + record c-set-equipment { + entity-id: s32, + equipment: list>, + } + 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-selected-slot { + slot: u8, + } + record c-set-passengers { + entity-id: s32, + passengers: list, + } + record c-set-player-inventory { + slot: s32, + item: string, + } + enum team-method { + create, + remove, + update, + add-players, + remove-players, + } + record team-parameters { + display-name: string, + options: u8, + nametag-visibility: string, + collision-rule: string, + color: s32, + player-prefix: string, + player-suffix: string, + } + record c-set-player-team { + team-name: string, + method: team-method, + parameters: option, + players: list, + } + record c-set-simulation-distance { + simulation-distance: s32, + } + record c-update-time { + game-time: s64, + clock-updates: list>, + } + 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, + volume: f32, + pitch: f32, + seed: f64, + } + record c-spawn-entity { + entity-id: s32, + entity-uuid: uuid, + r-type: s32, + position: tuple, + velocity: string, + pitch: u8, + yaw: u8, + head-yaw: u8, + data: s32, + } + record c-spawn-living-entity { + entity-id: s32, + entity-uuid: uuid, + r-type: s32, + position: tuple, + yaw: u8, + pitch: u8, + head-yaw: u8, + velocity: string, + metadata: option>, + } + record c-spawn-painting { + entity-id: s32, + uuid: uuid, + title: string, + %variant: s32, + location: tuple, + direction: u8, + } + record c-stop-sound { + sound-id: option, + category: option, + } + record c-store-cookie { + key: string, + payload: list, + } + record c-subtitle { + subtitle: string, + } + record c-system-chat-message { + content: string, + overlay: bool, + } + record c-tab-list { + header: string, + footer: string, + } + record c-tag-query-response { + transaction-id: s32, + nbt-bytes: list, + } + record c-take-item-entity { + entity-id: s32, + collector-entity-id: s32, + stack-amount: s32, + } + record c-teleport-entity { + entity-id: s32, + position: tuple, + delta: tuple, + yaw: f32, + pitch: f32, + relatives: list, + on-ground: bool, + } + record c-test-instance-block-status { + pos: tuple, + status: s32, + message: option, + } + 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 { + x: s32, + z: s32, + } + record c-update-advancements { + reset: bool, + added: list, + removed: list, + progress: list, + show-advancements: bool, + } + record c-update-attributes { + entity-id: s32, + properties: list, + } + record property { + id: s32, + value: f64, + modifiers: list, + } + record attribute-modifier { + id: string, + amount: f64, + operation: u8, + } + record c-update-entity-pos { + entity-id: s32, + delta: tuple, + on-ground: bool, + } + record c-update-entity-pos-rot { + entity-id: s32, + delta: tuple, + 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, + } + enum mode { + add, + remove, + update, + } + enum render-type { + integer, + hearts, + } + record c-update-recipes { + raw-data: list, + } + record c-update-score { + entity-name: string, + objective-name: string, + value: s32, + display-name: option, + number-format: option, + } + record c-update-tags-play { + tags: list, + } + record c-use-bed { + entity-id: s32, + location: tuple, + } + enum waypoint-operation { + track, + untrack, + update, + } + record waypoint-target-chunk { + x: s32, + z: s32, + } + variant waypoint-target { + position(tuple), + chunk(waypoint-target-chunk), + azimuth(f32), + empty, + } + record waypoint-icon { + style: option, + color: s32, + } + record tracked-waypoint { + identifier: uuid, + icon: option, + target: waypoint-target, + } + record c-waypoint { + operation: waypoint-operation, + waypoint: tracked-waypoint, + } + record c-world-event { + event: s32, + location: tuple, + data: s32, + disable-relative-volume: bool, + } + record status-c-ping-response { + payload: s64, + } + record status-c-status-response { + json-response: string, + } + variant serverbound-packet { + config-s-accept-code-of-conduct, + config-s-acknowledge-finish-config, + config-s-client-information-config(config-s-client-information-config), + config-s-config-cookie-response(config-s-config-cookie-response), + config-s-custom-click-action(config-s-custom-click-action), + config-s-keep-alive(config-s-keep-alive), + config-s-known-packs(config-s-known-packs), + config-s-plugin-message(config-s-plugin-message), + config-s-config-pong(config-s-config-pong), + config-s-config-resource-pack(config-s-config-resource-pack), + login-s-login-cookie-response(login-s-login-cookie-response), + login-s-login-acknowledged, + login-s-login-start(login-s-login-start), + login-s-login-plugin-response(login-s-login-plugin-response), + s-attack(s-attack), + s-block-entity-tag-query(s-block-entity-tag-query), + s-bundle-item-selected(s-bundle-item-selected), + s-change-difficulty(s-change-difficulty), + s-change-game-mode(s-change-game-mode), + s-chat-ack(s-chat-ack), + s-chat-command(s-chat-command), + s-chat-command-signed(s-chat-command-signed), + 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-configuration-acknowledged, + s-container-button-click(s-container-button-click), + s-container-slot-state-changed(s-container-slot-state-changed), + s-cookie-response(s-cookie-response), + s-custom-click-action(s-custom-click-action), + s-custom-payload(s-custom-payload), + s-debug-sample-subscription(s-debug-sample-subscription), + s-debug-subscription-request(s-debug-subscription-request), + s-edit-book(s-edit-book), + s-entity-tag-query(s-entity-tag-query), + s-interact(s-interact), + s-jigsaw-generate(s-jigsaw-generate), + s-keep-alive(s-keep-alive), + s-lock-difficulty(s-lock-difficulty), + 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-play-pong(s-play-pong), + 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-play-resource-pack(s-play-resource-pack), + s-seen-advancement(s-seen-advancement), + s-select-trade(s-select-trade), + s-set-beacon(s-set-beacon), + s-set-command-block(s-set-command-block), + s-set-command-minecart(s-set-command-minecart), + s-set-creative-slot(s-set-creative-slot), + s-set-game-rule(s-set-game-rule), + s-set-held-item(s-set-held-item), + s-set-jigsaw-block(s-set-jigsaw-block), + s-set-structure-block(s-set-structure-block), + s-set-test-block(s-set-test-block), + s-spectate-entity(s-spectate-entity), + s-swing-arm(s-swing-arm), + s-teleport-to-entity(s-teleport-to-entity), + s-test-instance-block-action(s-test-instance-block-action), + s-update-sign(s-update-sign), + s-use-item(s-use-item), + s-use-item-on(s-use-item-on), + status-s-status-ping-request(status-s-status-ping-request), + status-s-status-request, + unknown, + } + variant clientbound-packet { + config-c-config-add-resource-pack(config-c-config-add-resource-pack), + config-c-config-clear-dialog, + config-c-code-of-conduct(config-c-code-of-conduct), + config-c-config-disconnect(config-c-config-disconnect), + config-c-cookie-request(config-c-cookie-request), + config-c-config-custom-report-details(config-c-config-custom-report-details), + config-c-feature-flags(config-c-feature-flags), + config-c-finish-config, + config-c-known-packs(config-c-known-packs), + config-c-config-ping(config-c-config-ping), + config-c-plugin-message(config-c-plugin-message), + config-c-registry-data(config-c-registry-data), + config-c-config-remove-resource-pack(config-c-config-remove-resource-pack), + config-c-config-reset-chat, + config-c-config-server-links(config-c-config-server-links), + config-c-config-show-dialog(config-c-config-show-dialog), + config-c-store-cookie(config-c-store-cookie), + config-c-transfer(config-c-transfer), + config-c-update-tags(config-c-update-tags), + login-c-login-cookie-request(login-c-login-cookie-request), + login-c-login-disconnect(login-c-login-disconnect), + login-c-login-plugin-request(login-c-login-plugin-request), + login-c-set-compression(login-c-set-compression), + c-acknowledge-block-change(c-acknowledge-block-change), + c-action-bar(c-action-bar), + c-add-resource-pack(c-add-resource-pack), + c-award-stats(c-award-stats), + 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-bundle-delimiter, + 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-chunks-biomes(c-chunks-biomes), + c-play-clear-dialog, + c-clear-title(c-clear-title), + c-close-container(c-close-container), + c-combat-death(c-combat-death), + c-combat-enter, + c-combat-end(c-combat-end), + c-command-suggestions(c-command-suggestions), + c-commands(c-commands), + c-play-cookie-request(c-play-cookie-request), + c-custom-chat-completions(c-custom-chat-completions), + c-custom-payload(c-custom-payload), + c-play-custom-report-details(c-play-custom-report-details), + c-damage-event(c-damage-event), + c-debug-block-value(c-debug-block-value), + c-debug-chunk-value(c-debug-chunk-value), + c-debug-entity-value(c-debug-entity-value), + c-debug-event(c-debug-event), + c-debug-sample(c-debug-sample), + c-delete-chat(c-delete-chat), + 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-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-game-rule-values(c-game-rule-values), + c-game-test-highlight-pos(c-game-test-highlight-pos), + 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-light-update), + c-login(c-login), + c-low-disk-space-warning, + c-map-item-data(c-map-item-data), + c-merchant-offers(c-merchant-offers), + c-move-minecart-along-track(c-move-minecart-along-track), + c-move-vehicle(c-move-vehicle), + c-multi-block-update(c-multi-block-update), + c-open-book(c-open-book), + c-open-mount-screen(c-open-mount-screen), + c-open-screen(c-open-screen), + c-open-sign-editor(c-open-sign-editor), + c-particle(c-particle), + c-play-ping(c-play-ping), + c-ping-response(c-ping-response), + c-place-ghost-recipe(c-place-ghost-recipe), + c-player-abilities(c-player-abilities), + c-player-chat-message(c-player-chat-message), + c-player-info-update(c-player-info-update), + c-player-look-at(c-player-look-at), + c-player-position(c-player-position), + c-remove-player-info(c-remove-player-info), + c-player-rotation(c-player-rotation), + c-player-spawn-position(c-player-spawn-position), + c-projectile-power(c-projectile-power), + c-recipe-book-add(c-recipe-book-add), + c-recipe-book-remove(c-recipe-book-remove), + c-recipe-book-settings(c-recipe-book-settings), + c-remove-entities(c-remove-entities), + c-remove-mob-effect(c-remove-mob-effect), + c-remove-resource-pack(c-remove-resource-pack), + c-reset-score(c-reset-score), + c-respawn(c-respawn), + c-select-advancements-tab(c-select-advancements-tab), + c-server-data(c-server-data), + 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-camera(c-set-camera), + c-set-chunk-cache-radius(c-set-chunk-cache-radius), + 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-entity-link(c-set-entity-link), + 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-set-simulation-distance(c-set-simulation-distance), + 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-spawn-living-entity(c-spawn-living-entity), + c-spawn-painting(c-spawn-painting), + c-start-configuration, + c-stop-sound(c-stop-sound), + c-store-cookie(c-store-cookie), + c-subtitle(c-subtitle), + c-tab-list(c-tab-list), + c-tag-query-response(c-tag-query-response), + c-take-item-entity(c-take-item-entity), + c-teleport-entity(c-teleport-entity), + c-test-instance-block-status(c-test-instance-block-status), + c-ticking-state(c-ticking-state), + c-ticking-step(c-ticking-step), + c-transfer(c-transfer), + c-unload-chunk(c-unload-chunk), + c-update-advancements(c-update-advancements), + 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-recipes(c-update-recipes), + c-update-score(c-update-score), + c-use-bed(c-use-bed), + c-waypoint(c-waypoint), + c-world-event(c-world-event), + status-c-ping-response(status-c-ping-response), + status-c-status-response(status-c-status-response), + unknown, + } +} diff --git a/v0.1/log.wit b/v0.1/log.wit new file mode 100644 index 000000000..aafd268bd --- /dev/null +++ b/v0.1/log.wit @@ -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); +} diff --git a/v0.1/metadata.wit b/v0.1/metadata.wit new file mode 100644 index 000000000..b48863704 --- /dev/null +++ b/v0.1/metadata.wit @@ -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, + /// Short description of the plugin. + description: string, + /// Plugin dependencies. + dependencies: list, + /// Permissions requested by the plugin. + permissions: list, + } + + get-metadata: func() -> plugin-metadata; +} diff --git a/v0.1/particles.wit b/v0.1/particles.wit new file mode 100644 index 000000000..567b1d2a5 --- /dev/null +++ b/v0.1/particles.wit @@ -0,0 +1,131 @@ +package pumpkin:plugin@0.1.0; + +interface particles { + enum particle { + angry-villager, + block, + block-marker, + bubble, + sulfur-bubbles, + noxious-gas, + noxious-gas-cloud, + geyser, + geyser-base, + geyser-poof, + geyser-plume, + 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, + sulfur-cube-goo, + } +} diff --git a/v0.1/permission.wit b/v0.1/permission.wit new file mode 100644 index 000000000..3ad4415a9 --- /dev/null +++ b/v0.1/permission.wit @@ -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, + } +} diff --git a/v0.1/player.wit b/v0.1/player.wit new file mode 100644 index 000000000..cdde343eb --- /dev/null +++ b/v0.1/player.wit @@ -0,0 +1,1432 @@ +/// Represents a player connected to the Minecraft server. +interface player { + use common.{hand, position, game-mode, block-pos}; + use item-stack.{item-stack}; + use %world.{%world, entity, ray-trace-block-result, ray-trace-entity-result}; + 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}; + use status-effect.{status-effect-type, status-effect-instance}; + use scoreboard.{scoreboard, bedrock-scoreboard}; + use advancement.{advancement-progress}; + use damage-types.{damage-type}; + use statistics.{statistic-category, custom-statistic}; + use inventory.{inventory, player-inventory}; + use sounds.{sound, sound-category}; + use particles.{particle}; + use entity-statuses.{entity-status}; + + /// Represents per-player weather condition overrides. + enum player-weather { + clear, + downfall, + } + + /// Types of projectiles that can be launched by a player. + enum projectile-type { + arrow, + snowball, + egg, + ender-pearl, + splash-potion, + fireball, + small-fireball, + trident, + wind-charge, + } + + /// Types of clientbound game events. + enum client-game-event { + no-respawn-block-available, + begin-raining, + end-raining, + change-game-mode, + win-game, + demo-event, + arrow-hit-player, + rain-level-change, + thunder-level-change, + play-pufferfish-string-sound, + play-elder-guardian-mob-appearance, + enabled-respawn-screen, + limited-crafting, + start-waiting-chunks, + } + + /// Built-in known server link types displayed in the client Escape pause menu. + enum known-server-link { + bug-report, + community-guidelines, + support, + status, + feedback, + community, + website, + forums, + news, + announcements, + } + + /// Label for a server link: either a built-in standard link type or a custom text component. + variant server-link-label { + known(known-server-link), + custom(text-component), + } + + /// Represents a server link entry with a label and destination URL. + record server-link { + label: server-link-label, + url: string, + } + + /// 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, + } + + /// 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, + v-26-2, + unknown, + } + + /// Represents a specific version of the Minecraft Bedrock Edition protocol. + enum bedrock-minecraft-version { + v-1-21, + v-1-26-30, + 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, + } + + /// Protocol-level disconnect reasons for Minecraft Bedrock Edition. + enum bedrock-disconnect-reason { + unknown, + cant-connect-no-internet, + no-permissions, + unrecoverable-error, + third-party-blocked, + third-party-no-internet, + third-party-bad-ip, + third-party-no-server-or-server-locked, + version-mismatch, + skin-issue, + invite-session-not-found, + edu-level-settings-missing, + local-server-not-found, + legacy-disconnect, + user-leave-game-attempted, + platform-locked-skins-error, + realms-world-unassigned, + realms-server-cant-connect, + realms-server-hidden, + realms-server-disabled-beta, + realms-server-disabled, + cross-platform-disabled, + cant-connect, + session-not-found, + client-settings-incompatible-with-server, + server-full, + invalid-platform-skin, + edition-version-mismatch, + edition-mismatch, + level-newer-than-exe-version, + no-fail-occurred, + banned-skin, + timeout, + server-not-found, + outdated-server, + outdated-client, + no-premium-platform, + multiplayer-disabled, + no-wifi, + world-corruption, + no-reason, + disconnected, + invalid-player, + logged-in-other-location, + server-id-conflict, + not-allowed, + not-authenticated, + invalid-tenant, + unknown-packet, + unexpected-packet, + invalid-command-request-packet, + host-suspended, + login-packet-no-request, + login-packet-no-cert, + missing-client, + kicked, + kicked-for-exploit, + kicked-for-idle, + resource-pack-problem, + incompatible-pack, + out-of-storage, + invalid-level, + disconnect-packet, + block-mismatch, + invalid-heights, + invalid-widths, + connection-lost, + zombie-connection, + shutdown, + reason-not-set, + loading-state-timeout, + resource-pack-loading-failed, + searching-for-session-loading-screen-failed, + nether-net-protocol-version, + subsystem-status-error, + empty-auth-from-discovery, + empty-url-from-discovery, + expired-auth-from-discovery, + unknown-signal-service-sign-in-failure, + xbl-join-lobby-failure, + unspecified-client-instance-disconnection, + nether-net-session-not-found, + nether-net-create-peer-connection, + nether-net-ice, + nether-net-connect-request, + nether-net-connect-response, + nether-net-negotiation-timeout, + nether-net-inactivity-timeout, + stale-connection-being-replaced, + realms-session-not-found, + bad-packet, + nether-net-failed-to-create-offer, + nether-net-failed-to-create-answer, + nether-net-failed-to-set-local-description, + nether-net-failed-to-set-remote-description, + nether-net-negotiation-timeout-waiting-for-response, + nether-net-negotiation-timeout-waiting-for-accept, + nether-net-incoming-connection-ignored, + nether-net-signaling-parsing-failure, + nether-net-signaling-unknown-error, + nether-net-signaling-unicast-delivery-failed, + nether-net-signaling-broadcast-delivery-failed, + nether-net-signaling-generic-delivery-failed, + editor-mismatch-editor-world, + editor-mismatch-vanilla-world, + world-transfer-not-primary-client, + request-server-shutdown, + client-game-setup-cancelled, + client-game-setup-failed, + no-venue, + nether-net-signaling-signin-failed, + session-access-denied, + service-signin-issue, + nether-net-no-signaling-channel, + nether-net-not-logged-in, + nether-net-client-signaling-error, + sub-client-login-disabled, + deep-link-trying-to-open-demo-world-while-signed-in, + async-join-task-denied, + realms-timeline-required, + guest-without-host, + failed-to-join-experience, + nether-net-data-channel-closed, + discovery-environment-mismatch, + host-without-keys, + host-signed-out, + script-watchdog-exception, + script-memory-limit-exceeded, + storage-low-during-gameplay, + storage-full-during-gameplay, + level-storage-corruption, + edition-mismatch-vanilla-to-edu, + edition-mismatch-edu-to-vanilla, + editor-mismatch-editor-to-vanilla, + editor-mismatch-vanilla-to-editor, + deny-listed, + nonce-missing, + nonce-not-found, + nonce-expired, + nonce-not-valid, + host-disconnected, + editor-join-intent-policy-failure, + nether-net-identity-not-allowed, + invalid-name, + expired-token, + host-accepts-no-type-of-auth, + not-authenticated-fast-fail, + editor-not-allowed, + } + + /// Policy for tearing down the player's network connection. + enum socket-teardown-policy { + /// Send the disconnect packet and gracefully close the connection. + graceful, + /// Send the disconnect packet and close the socket immediately. + immediate-close, + /// Terminate the connection immediately without sending any disconnect packet. + drop-connection, + } + + /// Options for disconnecting a Java Edition player. + record java-kick-options { + /// The formatted text component displayed on the Java disconnect screen. + reason: text-component, + /// Whether to log the kick in the server console (default: true). + log-to-console: bool, + /// How the connection is closed (default: graceful). + teardown-policy: socket-teardown-policy, + } + + /// Options for disconnecting a Bedrock Edition player. + record bedrock-kick-options { + /// Protocol level disconnect code (default: kicked). + reason: bedrock-disconnect-reason, + /// Message displayed on the Bedrock disconnect screen (default: ""). + message: string, + /// Whether to suppress the disconnect message on the client screen (default: false). + skip-message: bool, + /// Filtered message string for safety/parental filters (default: ""). + filtered-message: string, + /// Whether to log the kick in the server console (default: true). + log-to-console: bool, + /// How the connection is closed (default: graceful). + teardown-policy: socket-teardown-policy, + } + + /// Options for banning a player. + record ban-player-options { + /// Ban reason displayed to the player and stored in the ban list. + reason: option, + /// Source or authority responsible for the ban (default: "Plugin"). + source: option, + /// Ban expiration in RFC-3339 format, if temporary. + expires-at-utc: option, + /// Ban duration in seconds from now, if temporary. + duration-seconds: option, + /// Whether to immediately kick the player if currently online (default: true). + kick-if-online: bool, + /// Whether to log the ban action to the server console (default: true). + log-to-console: bool, + } + + /// Options for banning an IP address. + record ban-ip-options { + /// Ban reason stored in the IP ban list. + reason: option, + /// Source or authority responsible for the ban (default: "Plugin"). + source: option, + /// Ban expiration in RFC-3339 format, if temporary. + expires-at-utc: option, + /// Ban duration in seconds from now, if temporary. + duration-seconds: option, + /// Whether to immediately kick all online players with this IP (default: true). + kick-matching-players: bool, + /// Whether to log the IP ban action to the server console (default: true). + log-to-console: 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; + /// 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; + /// Sets the player's custom tab list name. + set-tab-list-name: func (name: option); + + // Messaging & titles + + /// Sends a system message to the player's chat. + send-system-message: func (text: text-component, overlay: bool); + /// Deletes a signed chat message from the player's chat window using its 256-byte signature. + delete-message-by-signature: func (signature: list); + /// Deletes a signed chat message from the player's chat window using its signature cache ID. + delete-message-by-id: func (signature-id: s32); + /// 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); + + // Camera & Spectating + + /// Sets the player's camera to view from the perspective of another entity. + /// If `entity` is `none`, the camera is reset back to the player. + set-camera: func (entity: option); + /// Sets the player's camera to view from the perspective of an entity with the given entity ID. + /// If `entity-id` is the player's own entity ID, the camera is reset back to the player. + set-camera-entity-id: func (entity-id: u32); + /// Gets the entity ID of the entity that the player's camera is currently attached to, + /// or the player's own entity ID if the camera has not been overridden. + get-camera-entity-id: func () -> u32; + /// Resets the player's camera back to their own perspective. + reset-camera: func (); + + // Audio & Particles + + /// Plays a sound effect for this player at their current location. + play-sound: func(sound: sound, category: sound-category, volume: f32, pitch: f32); + /// Plays a sound effect for this player at a specific location. + play-sound-at: func(pos: position, sound: sound, category: sound-category, volume: f32, pitch: f32); + /// Stops a sound effect from playing for this player. + stop-sound: func(sound: option, category: option); + + /// Plays a custom resource pack sound identifier for this player at their current location. + play-custom-sound: func(sound-name: string, category: sound-category, volume: f32, pitch: f32); + /// Plays a custom resource pack sound identifier for this player at a specific location. + play-custom-sound-at: func(pos: position, sound-name: string, category: sound-category, volume: f32, pitch: f32); + /// Stops a custom sound identifier from playing for this player. + stop-custom-sound: func(sound-name: option, category: option); + + /// Spawns particles visible only to this player. + spawn-particles: func(particle: particle, pos: position, count: u32, offset: position, max-speed: f32); + + // Visuals & Client Overrides + + /// Sends a temporary fake block change to the player's client without modifying the server world. + send-block-change: func(pos: block-pos, block-id: u16); + /// Resets a temporary fake block change by resending the actual world block at that position. + reset-block-change: func(pos: block-pos); + + /// Sends a hurt / damage-tilt animation to the player's client (causes screen shake in the given yaw direction). + send-hurt-animation: func(yaw: f32); + + /// Opens a written book interface for the player from the specified hand. + open-book: func(hand: hand); + /// Forces the sign text editor to open for the player at the specified sign block position. + open-sign-editor: func(pos: block-pos, is-front-text: bool); + + // Velocity & Physics + + /// Sets the player's velocity / motion vector. + set-velocity: func(velocity: position); + /// Applies directional knockback impulse to the player. + apply-knockback: func(strength: f64, x: f64, z: f64); + + // Movement Lock & Freezing + + /// Sets whether the player's movement is locked (frozen in place) for cutscenes and NPC dialogues. + set-movement-locked: func(locked: bool); + /// Returns whether the player's movement is currently locked. + is-movement-locked: func() -> bool; + + /// Sets the number of freeze ticks on the player (controlling the powdered snow / frostbite screen vignette). + set-freeze-ticks: func(ticks: s32); + /// Returns the current number of freeze ticks on the player. + get-freeze-ticks: func() -> s32; + + /// Sends custom server links to the player (displayed in the client Esc pause menu in 1.21+). + set-server-links: func(links: list); + + // Teleport & kick + + /// Teleports the player to a position in a world. + teleport: func (position: position, yaw: option, pitch: option, %world: %world); + /// Teleports the player to another world at a specific position. + teleport-world: func (world-ref: %world, position: position, yaw: option, pitch: option); + /// Forces the player to respawn. + respawn: func (); + + /// Opens a GUI for the player. + open-gui: func (gui-ref: gui); + + /// Bans the player with the specified options. + ban: func (options: ban-player-options); + /// Bans the player's IP address with the specified options. + ban-ip: func (options: ban-ip-options); + + /// Transfers the player to another server. + transfer: func (host: string, port: u16); + + // Status Effects + + /// Gives a status effect to the player. + add-effect: func(effect: status-effect-instance); + /// Removes a status effect from the player. + remove-effect: func(effect: status-effect-type); + /// Clears all active status effects from the player. + clear-effects: func(); + /// Checks if a status effect is currently applied to the player. + has-effect: func(effect: status-effect-type) -> bool; + /// Returns the status effect instance applied to the player, if any. + get-effect: func(effect: status-effect-type) -> option; + /// Returns all status effects currently applied to the player. + get-active-effects: func() -> list; + + // Health & Damage + + /// Heals the player by a specified amount. + heal: func(amount: f32); + /// Deals damage to the player by a specified amount with a damage type. + damage: func(amount: f32, damage-type: damage-type); + /// Kills the player instantly. + kill: func(); + + // Statistics + + /// Gets the value of a statistic for this player in the given category and ID. + get-statistic: func(category: statistic-category, stat-id: s32) -> s32; + /// Sets the value of a statistic for this player in the given category and ID. + set-statistic: func(category: statistic-category, stat-id: s32, value: s32); + /// Increments the value of a statistic for this player in the given category and ID. + increment-statistic: func(category: statistic-category, stat-id: s32, amount: s32); + + /// Gets the value of a custom statistic for this player. + get-custom-statistic: func(stat: custom-statistic) -> s32; + /// Sets the value of a custom statistic for this player. + set-custom-statistic: func(stat: custom-statistic, value: s32); + /// Increments the value of a custom statistic for this player. + increment-custom-statistic: func(stat: custom-statistic, amount: s32); + + /// Sends the player's updated statistics packet to the client. + send-stats: func(); + + /// Gets the team name that this player belongs to on their active scoreboard, if any. + get-team: func() -> option; + + // Cooldowns + + /// Starts an item cooldown for a specific item group name. + start-cooldown: func(group: string, duration-ticks: s32); + /// Returns the cooldown progress (0.0 to 1.0) for a specific item group. + get-cooldown: func(group: string) -> f32; + /// Checks if a specific item group is currently on cooldown. + is-on-cooldown: func(group: string) -> bool; + + // Abilities & Flight + + /// Sets whether the player is allowed to fly. + set-allow-flight: func(allowed: bool); + /// Sets the player's flying speed. + set-fly-speed: func(speed: f32); + /// Sets the player's walking speed. + set-walk-speed: func(speed: f32); + /// Sets whether the player is invulnerable to damage. + set-invulnerable: func(invulnerable: bool); + + // Inventory + + /// Returns the player's inventory handle for managing main storage, armor, and equipment. + get-inventory: func () -> player-inventory; + /// Returns the player's ender chest inventory handle. + get-ender-chest: func () -> 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; + /// Returns the item in the specified inventory slot. + get-inventory-item: func (slot: u8) -> option; + + /// Sets the item in the specified hand. + set-item-in-hand: func (hand: hand, stack: option); + /// Sets the item in the specified inventory slot. + set-inventory-item: func (slot: u8, stack: option); + + // Ender Chest Inventory + + /// Returns the item in the specified ender chest slot (0-26). + get-ender-chest-item: func (slot: u8) -> option; + /// Sets the item in the specified ender chest slot (0-26). + set-ender-chest-item: func (slot: u8, stack: option); + /// Clears all items from the player's ender chest. + clear-ender-chest: func (); + /// Opens the player's ender chest inventory screen for them. + open-ender-chest: func (); + + // 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; + + /// 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); + + // Per-Player Environment & Overrides + + /// Overrides the time of day shown to this player. + set-player-time: func(time: u64, relative: bool); + /// Resets the player's time to sync with the server world time. + reset-player-time: func(); + /// Returns the custom time set for this player, if any. + get-player-time: func() -> option; + /// Checks if the custom player time is relative to the world time. + is-player-time-relative: func() -> bool; + + /// Overrides the weather condition shown to this player. + set-player-weather: func(weather: player-weather); + /// Resets the player's weather to match the server world weather. + reset-player-weather: func(); + /// Returns the custom weather set for this player, if any. + get-player-weather: func() -> option; + + /// Sets the position where the player's compass points. + set-compass-target: func(pos: position); + /// Returns the position where the player's compass currently points. + get-compass-target: func() -> position; + + /// Sets the player's custom respawn / bed location. + set-respawn-location: func(pos: position); + /// Returns the player's custom respawn / bed location, if set. + get-respawn-location: func() -> option; + + /// Hides another player from this player's view (vanish). + hide-player: func(other: player); + /// Shows a previously hidden player to this player. + show-player: func(other: player); + /// Checks if this player can see another specified player. + can-see: func(other: player) -> bool; + /// Checks if this player can see another specified player. + can-see-player: func(other: player) -> bool; + + /// Sets the tab list ping / latency indicator in milliseconds. + set-tab-list-ping: func(latency-ms: s32); + + /// Sets a client-side item cooldown overlay. + set-item-cooldown: func(item-id: string, ticks: s32); + /// Returns the remaining cooldown ticks for an item, if active. + get-item-cooldown: func(item-id: string) -> option; + /// Checks if an item is currently on cooldown. + has-item-cooldown: func(item-id: string) -> bool; + + /// Performs a ray-trace from the player's eye position in looking direction to find the targeted block. + ray-trace-block: func(max-distance: f64, include-fluids: bool) -> option; + + /// Performs a ray-trace from the player's eye position in looking direction to find the targeted entity. + ray-trace-entity: func(max-distance: f64) -> option; + + /// Returns the entity currently targeted in the looking direction within the specified distance. + get-target-entity: func(max-distance: f64) -> option; + + /// Raycasts from the player's eyes to find the block being targeted. + get-target-block: func(max-distance: u32) -> option; + + /// Performs a raycast from the player's eyes to find the exact block and face being targeted. + get-target-block-exact: func(max-distance: f64, include-fluids: bool) -> option; + /// Launches a projectile from the player's eyes in their line of sight. + launch-projectile: func(%type: projectile-type) -> option; + + // Advancements + + /// Returns the progress of the specified advancement for this player, if the advancement exists. + get-advancement-progress: func(advancement-id: string) -> option; + + /// Awards a specific criterion of an advancement to the player. + /// Returns true if the criterion was successfully awarded (was not already completed). + award-advancement-criterion: func(advancement-id: string, criterion: string) -> bool; + + /// Revokes a specific criterion of an advancement from the player. + /// Returns true if the criterion was successfully revoked (was previously completed). + revoke-advancement-criterion: func(advancement-id: string, criterion: string) -> bool; + + /// Awards all criteria of the specified advancement to the player. + /// Returns true if any criterion was newly awarded. + award-advancement: func(advancement-id: string) -> bool; + + /// Revokes all criteria of the specified advancement from the player. + /// Returns true if any criterion was newly revoked. + revoke-advancement: func(advancement-id: string) -> bool; + + /// Checks whether the player has completed the specified advancement. + has-advancement: func(advancement-id: string) -> bool; + + /// Returns a list of all advancement IDs completed by this player. + get-completed-advancements: func() -> list; + + /// Returns the ID of the currently selected advancement tab for this player, if any. + get-selected-advancement-tab: func() -> option; + + /// Sets the selected advancement tab for this player (must be a root advancement ID). + set-selected-advancement-tab: func(tab-id: option); + + /// 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; + + /// 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; + } + + /// Represents a resource pack sent to a Java Edition player. + record java-resource-pack { + /// Unique identifier for the resource pack. + id: uuid, + /// The URL to the resource pack file. + url: string, + /// The SHA1 hash (40-character hex string) of the pack. + hash: string, + /// Whether the player is forced to accept the pack. + forced: bool, + /// Optional prompt message displayed in the pack acceptance screen. + prompt-message: option, + } + + /// Represents an individual Bedrock Edition resource pack entry. + record bedrock-resource-pack-entry { + /// Unique identifier for the Bedrock pack. + id: uuid, + /// Version string of the Bedrock pack (e.g., "1.0.0"). + version: string, + /// Size of the pack in bytes. + size: u64, + /// Download URL for remote Bedrock packs. + download-url: string, + /// Optional encryption content key for encrypted packs. + content-key: option, + /// Optional sub-pack name inside the archive. + sub-pack-name: option, + /// Optional content identifier. + content-id: option, + /// Whether the pack contains client scripts. + has-scripts: bool, + /// Whether the pack is marked as an addon pack. + addon-pack: bool, + /// Whether Ray Tracing / RTX features are enabled for the pack. + rtx-enabled: bool, + } + + /// Represents the resource packs information payload sent to Bedrock clients. + record bedrock-resource-packs-info { + /// If true, players cannot join without accepting packs. + required: bool, + /// Whether the server offers addon packs. + has-addon-packs: bool, + /// Whether any of the packs contain client scripts. + has-scripts: bool, + /// Whether vibrant visuals should be forced disabled. + is-vibrant-visuals-force-disabled: bool, + /// World template ID, if any. + world-template-id: option, + /// World template version, if any. + world-template-version: option, + /// List of resource packs to send to the player. + packs: list, + } + + /// 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); + + /// Shows a dialog to the player. + show-dialog: func(dialog: dialog); + + /// Clears any currently shown dialog for the player. + clear-dialog: func(); + + /// Returns the Java scoreboard handle for this player. + get-scoreboard: func() -> scoreboard; + + /// Resets the player's custom Java scoreboard back to the world scoreboard. + reset-scoreboard: func(); + + /// Sends a resource pack to the Java player. + send-resource-pack: func(pack: java-resource-pack); + + /// Removes a specific resource pack by UUID for the Java player. + remove-resource-pack: func(id: uuid); + + /// Clears all custom resource packs for the Java player. + clear-resource-packs: func(); + + /// Kicks the Java player with the specified options. + kick: func(options: java-kick-options); + + /// Sends a clientbound GameEvent packet to the Java player. + send-game-event: func(event: client-game-event, value: f32); + + /// Sends an entity status / animation event packet to the Java player for a specific entity ID. + send-entity-status: func(entity-id: s32, status: entity-status); + } + + /// 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 the Bedrock scoreboard handle for this player. + get-scoreboard: func() -> bedrock-scoreboard; + + /// Resets the player's custom Bedrock scoreboard back to the world scoreboard. + reset-scoreboard: func(); + + /// Sends resource packs information to the Bedrock player. + send-resource-packs-info: func(info: bedrock-resource-packs-info); + + /// Kicks the Bedrock player with the specified options. + kick: func(options: bedrock-kick-options); + } + + /// Returns a list of all players in a specific world. + get-world-players: func(world-ref: %world) -> list; +} diff --git a/v0.1/plugin.wit b/v0.1/plugin.wit new file mode 100644 index 000000000..33ee2b8ff --- /dev/null +++ b/v0.1/plugin.wit @@ -0,0 +1,121 @@ +/// 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, command-suggestions, suggestion-request}; + use %world.{entity, chunk-buffer, generation-phase}; + use ipc.{plugin-id, ipc-message}; + + // --- 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; + /// Provides status effect types and instances. + import status-effect; + /// Provides block entity types and instances. + import block-entity; + /// Provides 1 : 1 inter-plugin communication + import ipc; + /// Provides entity attribute types and modifiers. + import attributes; + /// Provides player management. + import player; + /// Provides advancement definitions and progress types. + import advancement; + /// Provides custom recipe registration and management. + import recipe; + /// Provides inventory manipulation and management. + import inventory; + /// Provides datapack inspection and management. + import datapack; + /// Provides custom enchantment registration and management. + import enchantments; + /// Provides damage types. + import damage-types; + /// Provides screen / window types for GUIs and containers. + import screens; + /// Provides player statistics categories and types. + import statistics; + /// Provides Display and Interaction entities. + import display; + /// Provides game rules definitions and queries. + import game-rules; + /// Provides game event types. + import game-events; + /// Provides potion types. + import potions; + /// Provides entity status / animation event types. + import entity-statuses; + + // --- 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; + + /// Dispatches a command suggestion request to the plugin. + export handle-command-suggestion: func(handler-id: u32, sender: command-sender, server: server-instance, request: suggestion-request) -> command-suggestions; + + /// Dispatches a scheduled task execution to the plugin. + export handle-task: func(handler-id: u32, server: server-instance); + + /// Processes an incoming message from another plugin if possible, and returns (a possibly empty) response. + export handle-ipc-message: func(sender: plugin-id, message: ipc-message) -> result; + + export handle-ai-goal-can-start: func(goal-id: u32, server: server-instance, entity: entity) -> bool; + export handle-ai-goal-should-continue: func(goal-id: u32, server: server-instance, entity: entity) -> bool; + export handle-ai-goal-start: func(goal-id: u32, server: server-instance, entity: entity); + export handle-ai-goal-tick: func(goal-id: u32, server: server-instance, entity: entity); + export handle-ai-goal-stop: func(goal-id: u32, server: server-instance, entity: entity); + + /// Dispatches a chunk generation phase to the plugin. + export handle-generate-phase: func(generator-id: u32, phase: generation-phase, chunk: chunk-buffer); +} diff --git a/v0.1/potions.wit b/v0.1/potions.wit new file mode 100644 index 000000000..6e97629ee --- /dev/null +++ b/v0.1/potions.wit @@ -0,0 +1,52 @@ +package pumpkin:plugin@0.1.0; + +interface potions { + enum potion-type { + water, + mundane, + thick, + awkward, + night-vision, + long-night-vision, + invisibility, + long-invisibility, + leaping, + long-leaping, + strong-leaping, + fire-resistance, + long-fire-resistance, + swiftness, + long-swiftness, + strong-swiftness, + slowness, + long-slowness, + strong-slowness, + turtle-master, + long-turtle-master, + strong-turtle-master, + water-breathing, + long-water-breathing, + healing, + strong-healing, + harming, + strong-harming, + poison, + long-poison, + strong-poison, + regeneration, + long-regeneration, + strong-regeneration, + strength, + long-strength, + strong-strength, + weakness, + long-weakness, + luck, + slow-falling, + long-slow-falling, + wind-charged, + weaving, + oozing, + infested, + } +} diff --git a/v0.1/recipe.wit b/v0.1/recipe.wit new file mode 100644 index 000000000..960b889e4 --- /dev/null +++ b/v0.1/recipe.wit @@ -0,0 +1,88 @@ +interface recipe { + use item-stack.{item-stack}; + + /// Recipe category for the recipe book. + enum recipe-category { + building, + redstone, + equipment, + misc, + food, + blocks, + } + + /// Represents an ingredient in a recipe. + variant ingredient { + /// A specific item (e.g. "minecraft:diamond"). + item(string), + /// A tag group of items (e.g., "minecraft:logs"). + tag(string), + /// One of multiple specific items. + one-of(list), + } + + /// Represents a shaped crafting recipe. + record shaped-recipe { + /// The pattern of the recipe (e.g., ["# #", " s ", "# #"]). + pattern: list, + /// Mapping of characters in the pattern to ingredients. + key: list>, + /// The resulting item stack. + output: item-stack, + /// The recipe group (optional). + group: option, + /// The recipe category in the recipe book. + category: option, + /// Whether to show a toast notification when the recipe is unlocked. + show-notification: option, + } + + /// Represents a shapeless crafting recipe. + record shapeless-recipe { + /// The list of ingredients required. + ingredients: list, + /// The resulting item stack. + output: item-stack, + /// The recipe group (optional). + group: option, + /// The recipe category in the recipe book. + category: option, + } + + /// 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, + /// The recipe category in the recipe book. + category: option, + } + + /// 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); + } +} + diff --git a/v0.1/scheduler.wit b/v0.1/scheduler.wit new file mode 100644 index 000000000..cd06e37ee --- /dev/null +++ b/v0.1/scheduler.wit @@ -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); +} diff --git a/v0.1/scoreboard.wit b/v0.1/scoreboard.wit new file mode 100644 index 000000000..a3025b853 --- /dev/null +++ b/v0.1/scoreboard.wit @@ -0,0 +1,111 @@ +interface scoreboard { + use text.{text-component}; + use common.{named-color}; + + enum render-type { + integer, + hearts + } + + variant number-format { + blank, + fixed(text-component), + } + + 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, number-format: option); + update-objective: func(name: string, display-name: text-component, render-type: render-type, number-format: option); + remove-objective: func(name: string); + set-display-slot: func(slot: display-slot, objective-name: string); + clear-display-slot: func(slot: display-slot); + + update-score: func(entity-name: string, objective-name: string, value: s32, number-format: option); + add-score: func(entity-name: string, objective-name: string, delta: s32) -> s32; + remove-score: func(entity-name: string, objective-name: string); + reset-entity-scores: func(entity-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); + clear-team-players: func(team-name: string); + + get-teams: func() -> list; + get-team: func(name: string) -> option; + get-team-players: func(team-name: string) -> list; + get-player-team: func(player-name: string) -> option; + } + + enum bedrock-sort-order { + ascending, + descending + } + + enum bedrock-display-slot { + player-list, + sidebar, + below-name + } + + resource bedrock-scoreboard { + add-objective: func(name: string, display-name: string, sort-order: bedrock-sort-order); + update-objective: func(name: string, display-name: string, sort-order: bedrock-sort-order); + remove-objective: func(name: string); + set-display-slot: func(slot: bedrock-display-slot, objective-name: string); + clear-display-slot: func(slot: bedrock-display-slot); + + update-score: func(entity-name: string, objective-name: string, value: s32); + add-score: func(entity-name: string, objective-name: string, delta: s32) -> s32; + remove-score: func(entity-name: string, objective-name: string); + reset-entity-scores: func(entity-name: string); + } +} diff --git a/v0.1/screens.wit b/v0.1/screens.wit new file mode 100644 index 000000000..5369ee09d --- /dev/null +++ b/v0.1/screens.wit @@ -0,0 +1,31 @@ +package pumpkin:plugin@0.1.0; + +interface screens { + enum screen { + 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, + } +} diff --git a/v0.1/server.wit b/v0.1/server.wit new file mode 100644 index 000000000..fa78ed653 --- /dev/null +++ b/v0.1/server.wit @@ -0,0 +1,286 @@ +interface server { + use player.{player, ban-player-options, ban-ip-options, server-link, known-server-link, server-link-label}; + use common.{game-mode}; + use %world.{%world}; + use text.{text-component}; + use uuid.{uuid}; + use recipe.{recipe-manager}; + use enchantments.{enchantment-manager, custom-enchantment}; + use permission.{permission-level}; + use advancement.{advancement-info}; + use datapack.{datapack-manager, datapack-info}; + + /// Represents an operator entry in the ops configuration. + record op-entry { + uuid: uuid, + name: string, + level: permission-level, + bypasses-player-limit: bool, + } + + /// Interface for querying and managing server operators. + resource op-manager { + /// Checks if a player UUID is currently an operator. + is-op: func(id: uuid) -> bool; + + /// Retrieves the operator entry for a player UUID, if present. + get-op: func(id: uuid) -> option; + + /// Gets the effective permission level for a player UUID (returns zero if not op). + get-permission-level: func(id: uuid) -> permission-level; + + /// Grants operator status to a player (online or offline) with the specified level and bypass setting. + op-player: func(name: string, id: uuid, level: permission-level, bypasses-player-limit: bool); + + /// Revokes operator status from a player (online or offline). Returns true if the player was previously op. + deop-player: func(id: uuid) -> bool; + + /// Returns a list of all operator entries on the server. + list-ops: func() -> list; + } + + /// Represents a banned player entry in the ban list. + record banned-player-entry { + uuid: uuid, + name: string, + created: string, + source: string, + expires: option, + reason: string, + } + + /// Represents a banned IP entry in the IP ban list. + record banned-ip-entry { + ip: string, + created: string, + source: string, + expires: option, + reason: string, + } + + /// Global manager for player and IP bans. + resource ban-manager { + /// Checks if a player UUID is currently banned. + is-player-banned: func(id: uuid) -> bool; + + /// Retrieves the ban entry for a player UUID, if banned. + get-player-ban: func(id: uuid) -> option; + + /// Bans a player by name and UUID with the specified options (works for online and offline players). + ban-player: func(name: string, id: uuid, options: ban-player-options); + + /// Removes a player ban by UUID. Returns true if the player was banned. + unban-player: func(id: uuid) -> bool; + + /// Returns all currently active player bans. + list-player-bans: func() -> list; + + /// Checks if an IP address is currently banned. + is-ip-banned: func(ip: string) -> bool; + + /// Retrieves the ban entry for an IP address, if banned. + get-ip-ban: func(ip: string) -> option; + + /// Bans an IP address with the specified options. + ban-ip: func(ip: string, options: ban-ip-options); + + /// Removes an IP ban. Returns true if the IP was banned. + unban-ip: func(ip: string) -> bool; + + /// Returns all currently active IP bans. + list-ip-bans: func() -> list; + } + + /// Represents a player entry in the server whitelist. + record whitelist-entry { + uuid: uuid, + name: string, + } + + /// Global manager for the server whitelist. + resource whitelist-manager { + /// Returns whether the whitelist is currently enabled. + is-enabled: func() -> bool; + + /// Enables or disables the server whitelist. If enabled and enforce-whitelist is set, kicks non-whitelisted players. + set-enabled: func(enabled: bool); + + /// Checks if a player UUID is on the whitelist. + is-whitelisted: func(id: uuid) -> bool; + + /// Adds a player to the whitelist (online or offline). Returns true if newly added. + add-player: func(name: string, id: uuid) -> bool; + + /// Removes a player from the whitelist. Returns true if the player was on the whitelist. + remove-player: func(id: uuid) -> bool; + + /// Returns all whitelisted player entries. + list-entries: func() -> list; + } + + /// 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, + total-memory: option, + used-memory: option, + os-name: option, + os-version: option, + 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; + + /// Searches for a player by their exact name. + get-player-by-name: func(name: string) -> option; + + /// Searches for a player by their UUID string. + get-player-by-uuid: func(id: uuid) -> option; + + /// 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") or custom world name (e.g., "world", "arena_1"). + get-world-by-name: func(name: string) -> option<%world>; + + /// Checks if a world exists by name or dimension. + has-world: func(name: string) -> bool; + + 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; + + /// Unloads and saves a world by its name or dimension. + /// Returns an error if the world cannot be found, is the primary/default world, or still has players inside. + unload-world: func(name: string) -> result<_, string>; + + /// Saves all players, player advancements, and loaded worlds to disk. + save-all: func() -> result<_, string>; + + /// Returns a list of all online players in a specific world. + get-players-in-world: func(world-ref: %world) -> list; + + /// Returns the number of online players in a specific world. + get-player-count-in-world: func(world-ref: %world) -> u32; + + /// Broadcasts a system chat message to all players. + broadcast: func(message: string); + + /// Deletes a signed chat message from all players' chat windows using its 256-byte signature. + delete-message-by-signature: func(signature: list); + + /// Deletes a signed chat message from all players' chat windows using its signature cache ID. + delete-message-by-id: func(signature-id: s32); + + /// 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; + + /// Returns the operator manager to query or modify server operators. + get-op-manager: func() -> op-manager; + + /// Returns the global ban manager for querying and modifying player and IP bans. + get-ban-manager: func() -> ban-manager; + + /// Returns the global whitelist manager for querying and modifying the server whitelist. + get-whitelist-manager: func() -> whitelist-manager; + + /// Returns detailed information about an advancement by its ID (e.g., "minecraft:story/mine_stone" or "story/mine_stone"). + get-advancement: func(id: string) -> option; + + /// Returns a list of all registered advancement IDs on the server. + get-all-advancement-ids: func() -> list; + + /// Returns the global enchantment manager for registering and querying custom enchantments. + get-enchantment-manager: func() -> enchantment-manager; + + /// Returns information about an enchantment by its ID (vanilla or custom). + get-enchantment: func(id: string) -> option; + + /// Returns a list of all registered enchantment IDs (custom and vanilla) on the server. + get-all-enchantment-ids: func() -> list; + + /// Returns the global datapack manager for inspecting, enabling, disabling, and reloading datapacks. + get-datapack-manager: func() -> datapack-manager; + + /// Broadcasts custom server links to all connected players (displayed in the client Esc pause menu in 1.21+). + set-server-links: func(links: list); + } +} diff --git a/v0.1/sounds.wit b/v0.1/sounds.wit new file mode 100644 index 000000000..dead57f26 --- /dev/null +++ b/v0.1/sounds.wit @@ -0,0 +1,1987 @@ +package pumpkin:plugin@0.1.0; + +interface sounds { + enum sound-category { + master, + music, + records, + weather, + blocks, + hostile, + neutral, + players, + ambient, + voice, + ui, + } + enum sound { + entity-allay-ambient-with-item, + entity-allay-ambient-without-item, + entity-allay-death, + entity-allay-hurt, + entity-allay-item-given, + entity-allay-item-taken, + entity-allay-item-thrown, + ambient-cave, + ambient-basalt-deltas-additions, + ambient-basalt-deltas-loop, + ambient-basalt-deltas-mood, + ambient-crimson-forest-additions, + ambient-crimson-forest-loop, + ambient-crimson-forest-mood, + ambient-nether-wastes-additions, + ambient-nether-wastes-loop, + ambient-nether-wastes-mood, + ambient-soul-sand-valley-additions, + ambient-soul-sand-valley-loop, + ambient-soul-sand-valley-mood, + ambient-warped-forest-additions, + ambient-warped-forest-loop, + ambient-warped-forest-mood, + ambient-underwater-enter, + ambient-underwater-exit, + ambient-underwater-loop, + ambient-underwater-loop-additions, + ambient-underwater-loop-additions-rare, + ambient-underwater-loop-additions-ultra-rare, + block-amethyst-block-break, + block-amethyst-block-chime, + block-amethyst-block-fall, + block-amethyst-block-hit, + block-amethyst-block-place, + block-amethyst-block-resonate, + block-amethyst-block-step, + block-amethyst-cluster-break, + block-amethyst-cluster-fall, + block-amethyst-cluster-hit, + block-amethyst-cluster-place, + block-amethyst-cluster-step, + block-ancient-debris-break, + block-ancient-debris-step, + block-ancient-debris-place, + block-ancient-debris-hit, + block-ancient-debris-fall, + block-anvil-break, + block-anvil-destroy, + block-anvil-fall, + block-anvil-hit, + block-anvil-land, + block-anvil-place, + block-anvil-step, + block-anvil-use, + entity-armadillo-eat, + entity-armadillo-hurt, + entity-armadillo-hurt-reduced, + entity-armadillo-ambient, + entity-armadillo-step, + entity-armadillo-death, + entity-armadillo-roll, + entity-armadillo-land, + entity-armadillo-scute-drop, + entity-armadillo-unroll-finish, + entity-armadillo-peek, + entity-armadillo-unroll-start, + entity-armadillo-brush, + item-armor-equip-chain, + item-armor-equip-diamond, + item-armor-equip-elytra, + item-armor-equip-generic, + item-armor-equip-gold, + item-armor-equip-iron, + item-armor-equip-leather, + item-armor-equip-copper, + item-armor-equip-netherite, + item-armor-equip-turtle, + item-armor-equip-wolf, + item-armor-unequip-wolf, + item-armor-equip-nautilus, + item-armor-unequip-nautilus, + entity-armor-stand-break, + entity-armor-stand-fall, + entity-armor-stand-hit, + entity-armor-stand-place, + entity-arrow-hit, + entity-arrow-hit-player, + entity-arrow-shoot, + item-axe-strip, + item-axe-scrape, + item-axe-wax-off, + entity-axolotl-attack, + entity-axolotl-death, + entity-axolotl-hurt, + entity-axolotl-idle-air, + entity-axolotl-idle-water, + entity-axolotl-splash, + entity-axolotl-swim, + block-azalea-break, + block-azalea-fall, + block-azalea-hit, + block-azalea-place, + block-azalea-step, + block-azalea-leaves-break, + block-azalea-leaves-fall, + block-azalea-leaves-hit, + block-azalea-leaves-place, + block-azalea-leaves-step, + entity-baby-nautilus-ambient, + entity-baby-nautilus-ambient-land, + entity-baby-nautilus-death, + entity-baby-nautilus-death-land, + entity-baby-nautilus-eat, + entity-baby-nautilus-hurt, + entity-baby-nautilus-hurt-land, + entity-nautilus-riding, + entity-baby-nautilus-swim, + block-bamboo-break, + block-bamboo-fall, + block-bamboo-hit, + block-bamboo-place, + block-bamboo-step, + block-bamboo-sapling-break, + block-bamboo-sapling-hit, + block-bamboo-sapling-place, + block-bamboo-wood-break, + block-bamboo-wood-fall, + block-bamboo-wood-hit, + block-bamboo-wood-place, + block-bamboo-wood-step, + block-bamboo-wood-door-close, + block-bamboo-wood-door-open, + block-bamboo-wood-trapdoor-close, + block-bamboo-wood-trapdoor-open, + block-bamboo-wood-button-click-off, + block-bamboo-wood-button-click-on, + block-bamboo-wood-pressure-plate-click-off, + block-bamboo-wood-pressure-plate-click-on, + block-bamboo-wood-fence-gate-close, + block-bamboo-wood-fence-gate-open, + block-barrel-close, + block-barrel-open, + block-basalt-break, + block-basalt-step, + block-basalt-place, + block-basalt-hit, + block-basalt-fall, + entity-bat-ambient, + entity-bat-death, + entity-bat-hurt, + entity-bat-loop, + entity-bat-takeoff, + block-beacon-activate, + block-beacon-ambient, + block-beacon-deactivate, + block-beacon-power-select, + entity-bee-death, + entity-bee-hurt, + entity-bee-loop-aggressive, + entity-bee-loop, + entity-bee-sting, + entity-bee-pollinate, + block-beehive-drip, + block-beehive-enter, + block-beehive-exit, + block-beehive-shear, + block-beehive-work, + block-bell-use, + block-bell-resonate, + block-big-dripleaf-break, + block-big-dripleaf-fall, + block-big-dripleaf-hit, + block-big-dripleaf-place, + block-big-dripleaf-step, + entity-blaze-ambient, + entity-blaze-burn, + entity-blaze-death, + entity-blaze-hurt, + entity-blaze-shoot, + entity-boat-paddle-land, + entity-boat-paddle-water, + entity-bogged-ambient, + entity-bogged-death, + entity-bogged-hurt, + entity-bogged-shear, + entity-bogged-step, + block-bone-block-break, + block-bone-block-fall, + block-bone-block-hit, + block-bone-block-place, + block-bone-block-step, + item-bone-meal-use, + item-book-page-turn, + item-book-put, + block-blastfurnace-fire-crackle, + item-bottle-empty, + item-bottle-fill, + item-bottle-fill-dragonbreath, + entity-breeze-charge, + entity-breeze-deflect, + entity-breeze-inhale, + entity-breeze-idle-ground, + entity-breeze-idle-air, + entity-breeze-shoot, + entity-breeze-jump, + entity-breeze-land, + entity-breeze-slide, + entity-breeze-death, + entity-breeze-hurt, + entity-breeze-whirl, + entity-breeze-wind-burst, + block-brewing-stand-brew, + item-brush-brushing-generic, + item-brush-brushing-sand, + item-brush-brushing-gravel, + item-brush-brushing-sand-complete, + item-brush-brushing-gravel-complete, + block-bubble-column-bubble-pop, + block-bubble-column-upwards-ambient, + block-bubble-column-upwards-inside, + block-bubble-column-whirlpool-ambient, + block-bubble-column-whirlpool-inside, + ui-hud-bubble-pop, + item-bucket-empty, + item-bucket-empty-axolotl, + item-bucket-empty-fish, + item-bucket-empty-lava, + item-bucket-empty-powder-snow, + item-bucket-empty-sulfur-cube, + item-bucket-empty-tadpole, + item-bucket-fill, + item-bucket-fill-axolotl, + item-bucket-fill-fish, + item-bucket-fill-lava, + item-bucket-fill-powder-snow, + item-bucket-fill-sulfur-cube, + item-bucket-fill-tadpole, + item-bundle-drop-contents, + item-bundle-insert, + item-bundle-insert-fail, + item-bundle-remove-one, + block-cactus-flower-break, + block-cactus-flower-place, + block-cake-add-candle, + block-calcite-break, + block-calcite-step, + block-calcite-place, + block-calcite-hit, + block-calcite-fall, + entity-camel-husk-ambient, + entity-camel-husk-dash, + entity-camel-husk-dash-ready, + entity-camel-husk-death, + entity-camel-husk-eat, + entity-camel-husk-hurt, + entity-camel-husk-saddle, + entity-camel-husk-sit, + entity-camel-husk-stand, + entity-camel-husk-step, + entity-camel-husk-step-sand, + entity-camel-ambient, + entity-camel-dash, + entity-camel-dash-ready, + entity-camel-death, + entity-camel-eat, + entity-camel-hurt, + entity-camel-saddle, + entity-camel-sit, + entity-camel-stand, + entity-camel-step, + entity-camel-step-sand, + block-campfire-crackle, + block-candle-ambient, + block-candle-break, + block-candle-extinguish, + block-candle-fall, + block-candle-hit, + block-candle-place, + block-candle-step, + entity-baby-cat-ambient, + entity-baby-cat-stray-ambient, + entity-baby-cat-death, + entity-baby-cat-eat, + entity-baby-cat-hiss, + entity-baby-cat-beg-for-food, + entity-baby-cat-hurt, + entity-baby-cat-purr, + entity-baby-cat-purreow, + entity-cat-ambient, + entity-cat-stray-ambient, + entity-cat-hiss, + entity-cat-hurt, + entity-cat-death, + entity-cat-eat, + entity-cat-beg-for-food, + entity-cat-purr, + entity-cat-purreow, + entity-cat-royal-ambient, + entity-cat-royal-stray-ambient, + entity-cat-royal-hiss, + entity-cat-royal-hurt, + entity-cat-royal-death, + entity-cat-royal-eat, + entity-cat-royal-beg-for-food, + entity-cat-royal-purr, + entity-cat-royal-purreow, + block-cave-vines-break, + block-cave-vines-fall, + block-cave-vines-hit, + block-cave-vines-place, + block-cave-vines-step, + block-cave-vines-pick-berries, + block-chain-break, + block-chain-fall, + block-chain-hit, + block-chain-place, + block-chain-step, + block-cherry-wood-break, + block-cherry-wood-fall, + block-cherry-wood-hit, + block-cherry-wood-place, + block-cherry-wood-step, + block-cherry-sapling-break, + block-cherry-sapling-fall, + block-cherry-sapling-hit, + block-cherry-sapling-place, + block-cherry-sapling-step, + block-cherry-leaves-break, + block-cherry-leaves-fall, + block-cherry-leaves-hit, + block-cherry-leaves-place, + block-cherry-leaves-step, + block-cherry-wood-hanging-sign-step, + block-cherry-wood-hanging-sign-break, + block-cherry-wood-hanging-sign-fall, + block-cherry-wood-hanging-sign-hit, + block-cherry-wood-hanging-sign-place, + block-cherry-wood-door-close, + block-cherry-wood-door-open, + block-cherry-wood-trapdoor-close, + block-cherry-wood-trapdoor-open, + block-cherry-wood-button-click-off, + block-cherry-wood-button-click-on, + block-cherry-wood-pressure-plate-click-off, + block-cherry-wood-pressure-plate-click-on, + block-cherry-wood-fence-gate-close, + block-cherry-wood-fence-gate-open, + block-chest-close, + block-chest-locked, + block-chest-open, + entity-baby-chicken-ambient, + entity-baby-chicken-death, + entity-chicken-egg, + entity-baby-chicken-hurt, + entity-chicken-step, + entity-baby-chicken-step, + entity-chicken-ambient, + entity-chicken-hurt, + entity-chicken-death, + entity-chicken-picky-ambient, + entity-chicken-picky-hurt, + entity-chicken-picky-death, + block-chiseled-bookshelf-break, + block-chiseled-bookshelf-fall, + block-chiseled-bookshelf-hit, + block-chiseled-bookshelf-insert, + block-chiseled-bookshelf-insert-enchanted, + block-chiseled-bookshelf-step, + block-chiseled-bookshelf-pickup, + block-chiseled-bookshelf-pickup-enchanted, + block-chiseled-bookshelf-place, + block-chorus-flower-death, + block-chorus-flower-grow, + item-chorus-fruit-teleport, + block-cobweb-break, + block-cobweb-step, + block-cobweb-place, + block-cobweb-hit, + block-cobweb-fall, + entity-cod-ambient, + entity-cod-death, + entity-cod-flop, + entity-cod-hurt, + block-comparator-click, + block-composter-empty, + block-composter-fill, + block-composter-fill-success, + block-composter-ready, + block-conduit-activate, + block-conduit-ambient, + block-conduit-ambient-short, + block-conduit-attack-target, + block-conduit-deactivate, + block-copper-bulb-break, + block-copper-bulb-step, + block-copper-bulb-place, + block-copper-bulb-hit, + block-copper-bulb-fall, + block-copper-bulb-turn-on, + block-copper-bulb-turn-off, + block-copper-break, + block-copper-step, + block-copper-place, + block-copper-hit, + block-copper-fall, + block-copper-chest-close, + block-copper-chest-open, + block-copper-chest-weathered-close, + block-copper-chest-weathered-open, + block-copper-chest-oxidized-close, + block-copper-chest-oxidized-open, + block-copper-door-close, + block-copper-door-open, + entity-copper-golem-step, + entity-copper-golem-hurt, + entity-copper-golem-death, + entity-copper-golem-weathered-step, + entity-copper-golem-weathered-hurt, + entity-copper-golem-weathered-death, + entity-copper-golem-oxidized-step, + entity-copper-golem-oxidized-hurt, + entity-copper-golem-oxidized-death, + entity-copper-golem-spin, + entity-copper-golem-weathered-spin, + entity-copper-golem-oxidized-spin, + entity-copper-golem-no-item-get, + entity-copper-golem-no-item-no-get, + entity-copper-golem-item-drop, + entity-copper-golem-item-no-drop, + entity-copper-golem-become-statue, + block-copper-golem-statue-break, + block-copper-golem-statue-place, + block-copper-golem-statue-hit, + block-copper-golem-statue-step, + block-copper-golem-statue-fall, + entity-copper-golem-spawn, + entity-copper-golem-shear, + block-copper-grate-break, + block-copper-grate-step, + block-copper-grate-place, + block-copper-grate-hit, + block-copper-grate-fall, + block-copper-trapdoor-close, + block-copper-trapdoor-open, + block-coral-block-break, + block-coral-block-fall, + block-coral-block-hit, + block-coral-block-place, + block-coral-block-step, + entity-cow-milk, + entity-cow-ambient, + entity-cow-hurt, + entity-cow-death, + entity-cow-step, + entity-cow-moody-ambient, + entity-cow-moody-hurt, + entity-cow-moody-death, + entity-cow-moody-step, + block-crafter-craft, + block-crafter-fail, + entity-creaking-ambient, + entity-creaking-activate, + entity-creaking-deactivate, + entity-creaking-attack, + entity-creaking-death, + entity-creaking-step, + entity-creaking-freeze, + entity-creaking-unfreeze, + entity-creaking-spawn, + entity-creaking-sway, + entity-creaking-twitch, + block-creaking-heart-break, + block-creaking-heart-fall, + block-creaking-heart-hit, + block-creaking-heart-hurt, + block-creaking-heart-place, + block-creaking-heart-step, + block-creaking-heart-idle, + block-creaking-heart-spawn, + entity-creeper-death, + entity-creeper-hurt, + entity-creeper-primed, + block-crop-break, + item-crop-plant, + item-crossbow-hit, + item-crossbow-loading-end, + item-crossbow-loading-middle, + item-crossbow-loading-start, + item-crossbow-quick-charge-1, + item-crossbow-quick-charge-2, + item-crossbow-quick-charge-3, + item-crossbow-shoot, + block-deadbush-idle, + block-decorated-pot-break, + block-decorated-pot-fall, + block-decorated-pot-hit, + block-decorated-pot-insert, + block-decorated-pot-insert-fail, + block-decorated-pot-step, + block-decorated-pot-place, + block-decorated-pot-shatter, + block-deepslate-bricks-break, + block-deepslate-bricks-fall, + block-deepslate-bricks-hit, + block-deepslate-bricks-place, + block-deepslate-bricks-step, + block-deepslate-break, + block-deepslate-fall, + block-deepslate-hit, + block-deepslate-place, + block-deepslate-step, + block-deepslate-tiles-break, + block-deepslate-tiles-fall, + block-deepslate-tiles-hit, + block-deepslate-tiles-place, + block-deepslate-tiles-step, + block-dispenser-dispense, + block-dispenser-fail, + block-dispenser-launch, + entity-dolphin-ambient, + entity-dolphin-ambient-water, + entity-dolphin-attack, + entity-dolphin-death, + entity-dolphin-eat, + entity-dolphin-hurt, + entity-dolphin-jump, + entity-dolphin-play, + entity-dolphin-splash, + entity-dolphin-swim, + entity-donkey-ambient, + entity-donkey-angry, + entity-donkey-chest, + entity-donkey-death, + entity-donkey-eat, + entity-donkey-hurt, + entity-donkey-jump, + block-dried-ghast-break, + block-dried-ghast-step, + block-dried-ghast-fall, + block-dried-ghast-ambient, + block-dried-ghast-ambient-water, + block-dried-ghast-place, + block-dried-ghast-place-in-water, + block-dried-ghast-transition, + block-dripstone-block-break, + block-dripstone-block-step, + block-dripstone-block-place, + block-dripstone-block-hit, + block-dripstone-block-fall, + block-dry-grass-ambient, + block-pointed-dripstone-break, + block-pointed-dripstone-step, + block-pointed-dripstone-place, + block-pointed-dripstone-hit, + block-pointed-dripstone-fall, + block-pointed-dripstone-land, + block-pointed-dripstone-drip-lava, + block-pointed-dripstone-drip-water, + block-pointed-dripstone-drip-lava-into-cauldron, + block-pointed-dripstone-drip-water-into-cauldron, + block-big-dripleaf-tilt-down, + block-big-dripleaf-tilt-up, + entity-drowned-ambient, + entity-drowned-ambient-water, + entity-drowned-death, + entity-drowned-death-water, + entity-drowned-hurt, + entity-drowned-hurt-water, + entity-drowned-shoot, + entity-drowned-step, + entity-drowned-swim, + item-dye-use, + entity-egg-throw, + entity-elder-guardian-ambient, + entity-elder-guardian-ambient-land, + entity-elder-guardian-curse, + entity-elder-guardian-death, + entity-elder-guardian-death-land, + entity-elder-guardian-flop, + entity-elder-guardian-hurt, + entity-elder-guardian-hurt-land, + item-elytra-flying, + block-enchantment-table-use, + block-ender-chest-close, + block-ender-chest-open, + entity-ender-dragon-ambient, + entity-ender-dragon-death, + entity-dragon-fireball-explode, + entity-ender-dragon-flap, + entity-ender-dragon-growl, + entity-ender-dragon-hurt, + entity-ender-dragon-shoot, + entity-ender-eye-death, + entity-ender-eye-launch, + entity-enderman-ambient, + entity-enderman-death, + entity-enderman-hurt, + entity-enderman-scream, + entity-enderman-stare, + entity-enderman-teleport, + entity-endermite-ambient, + entity-endermite-death, + entity-endermite-hurt, + entity-endermite-step, + entity-ender-pearl-throw, + block-end-gateway-spawn, + block-end-portal-frame-fill, + block-end-portal-spawn, + entity-evoker-ambient, + entity-evoker-cast-spell, + entity-evoker-celebrate, + entity-evoker-death, + entity-evoker-fangs-attack, + entity-evoker-hurt, + entity-evoker-prepare-attack, + entity-evoker-prepare-summon, + entity-evoker-prepare-wololo, + entity-experience-bottle-throw, + entity-experience-orb-pickup, + block-eyeblossom-open-long, + block-eyeblossom-open, + block-eyeblossom-close-long, + block-eyeblossom-close, + block-eyeblossom-idle, + block-fence-gate-close, + block-fence-gate-open, + item-firecharge-use, + block-firefly-bush-idle, + entity-firework-rocket-blast, + entity-firework-rocket-blast-far, + entity-firework-rocket-large-blast, + entity-firework-rocket-large-blast-far, + entity-firework-rocket-launch, + entity-firework-rocket-shoot, + entity-firework-rocket-twinkle, + entity-firework-rocket-twinkle-far, + block-fire-ambient, + block-fire-extinguish, + entity-fish-swim, + entity-fishing-bobber-retrieve, + entity-fishing-bobber-splash, + entity-fishing-bobber-throw, + item-flintandsteel-use, + block-flowering-azalea-break, + block-flowering-azalea-fall, + block-flowering-azalea-hit, + block-flowering-azalea-place, + block-flowering-azalea-step, + entity-fox-aggro, + entity-fox-ambient, + entity-fox-bite, + entity-fox-death, + entity-fox-eat, + entity-fox-hurt, + entity-fox-screech, + entity-fox-sleep, + entity-fox-sniff, + entity-fox-spit, + entity-fox-teleport, + block-suspicious-sand-break, + block-suspicious-sand-step, + block-suspicious-sand-place, + block-suspicious-sand-hit, + block-suspicious-sand-fall, + block-suspicious-gravel-break, + block-suspicious-gravel-step, + block-suspicious-gravel-place, + block-suspicious-gravel-hit, + block-suspicious-gravel-fall, + block-froglight-break, + block-froglight-fall, + block-froglight-hit, + block-froglight-place, + block-froglight-step, + block-frogspawn-step, + block-frogspawn-break, + block-frogspawn-fall, + block-frogspawn-hatch, + block-frogspawn-hit, + block-frogspawn-place, + entity-frog-ambient, + entity-frog-death, + entity-frog-eat, + entity-frog-hurt, + entity-frog-lay-spawn, + entity-frog-long-jump, + entity-frog-step, + entity-frog-tongue, + block-roots-break, + block-roots-step, + block-roots-place, + block-roots-hit, + block-roots-fall, + block-furnace-fire-crackle, + entity-generic-big-fall, + entity-generic-burn, + entity-generic-death, + entity-generic-drink, + entity-generic-eat, + entity-generic-explode, + entity-generic-extinguish-fire, + entity-generic-hurt, + entity-generic-small-fall, + entity-generic-splash, + entity-generic-swim, + entity-ghast-ambient, + entity-ghast-death, + entity-ghast-hurt, + entity-ghast-scream, + entity-ghast-shoot, + entity-ghast-warn, + entity-ghastling-ambient, + entity-ghastling-death, + entity-ghastling-hurt, + entity-ghastling-spawn, + block-gilded-blackstone-break, + block-gilded-blackstone-fall, + block-gilded-blackstone-hit, + block-gilded-blackstone-place, + block-gilded-blackstone-step, + block-glass-break, + block-glass-fall, + block-glass-hit, + block-glass-place, + block-glass-step, + item-glow-ink-sac-use, + entity-glow-item-frame-add-item, + entity-glow-item-frame-break, + entity-glow-item-frame-place, + entity-glow-item-frame-remove-item, + entity-glow-item-frame-rotate-item, + entity-glow-squid-ambient, + entity-glow-squid-death, + entity-glow-squid-hurt, + entity-glow-squid-squirt, + entity-goat-ambient, + entity-goat-death, + entity-goat-eat, + entity-goat-hurt, + entity-goat-long-jump, + entity-goat-milk, + entity-goat-prepare-ram, + entity-goat-ram-impact, + entity-goat-horn-break, + entity-goat-screaming-ambient, + entity-goat-screaming-death, + entity-goat-screaming-eat, + entity-goat-screaming-hurt, + entity-goat-screaming-long-jump, + entity-goat-screaming-milk, + entity-goat-screaming-prepare-ram, + entity-goat-screaming-ram-impact, + entity-goat-step, + item-golden-dandelion-use, + item-golden-dandelion-unuse, + block-grass-break, + block-grass-fall, + block-grass-hit, + block-grass-place, + block-grass-step, + block-gravel-break, + block-gravel-fall, + block-gravel-hit, + block-gravel-place, + block-gravel-step, + block-grindstone-use, + block-growing-plant-crop, + entity-guardian-ambient, + entity-guardian-ambient-land, + entity-guardian-attack, + entity-guardian-death, + entity-guardian-death-land, + entity-guardian-flop, + entity-guardian-hurt, + entity-guardian-hurt-land, + block-hanging-roots-break, + block-hanging-roots-fall, + block-hanging-roots-hit, + block-hanging-roots-place, + block-hanging-roots-step, + block-hanging-sign-step, + block-hanging-sign-break, + block-hanging-sign-fall, + block-hanging-sign-hit, + block-hanging-sign-place, + entity-happy-ghast-ambient, + entity-happy-ghast-death, + entity-happy-ghast-hurt, + entity-happy-ghast-riding, + block-heavy-core-break, + block-heavy-core-fall, + block-heavy-core-hit, + block-heavy-core-place, + block-heavy-core-step, + block-nether-wood-hanging-sign-step, + block-nether-wood-hanging-sign-break, + block-nether-wood-hanging-sign-fall, + block-nether-wood-hanging-sign-hit, + block-nether-wood-hanging-sign-place, + block-bamboo-wood-hanging-sign-step, + block-bamboo-wood-hanging-sign-break, + block-bamboo-wood-hanging-sign-fall, + block-bamboo-wood-hanging-sign-hit, + block-bamboo-wood-hanging-sign-place, + block-trial-spawner-break, + block-trial-spawner-step, + block-trial-spawner-place, + block-trial-spawner-hit, + block-trial-spawner-fall, + block-trial-spawner-spawn-mob, + block-trial-spawner-about-to-spawn-item, + block-trial-spawner-spawn-item, + block-trial-spawner-spawn-item-begin, + block-trial-spawner-detect-player, + block-trial-spawner-ominous-activate, + block-trial-spawner-ambient, + block-trial-spawner-ambient-ominous, + block-trial-spawner-open-shutter, + block-trial-spawner-close-shutter, + block-trial-spawner-eject-item, + entity-happy-ghast-equip, + entity-happy-ghast-unequip, + entity-happy-ghast-harness-goggles-up, + entity-happy-ghast-harness-goggles-down, + item-hoe-till, + entity-hoglin-ambient, + entity-hoglin-angry, + entity-hoglin-attack, + entity-hoglin-converted-to-zombified, + entity-hoglin-death, + entity-hoglin-hurt, + entity-hoglin-retreat, + entity-hoglin-step, + block-honey-block-break, + block-honey-block-fall, + block-honey-block-hit, + block-honey-block-place, + block-honey-block-slide, + block-honey-block-step, + item-honeycomb-wax-on, + item-honey-bottle-drink, + item-goat-horn-sound-0, + item-goat-horn-sound-1, + item-goat-horn-sound-2, + item-goat-horn-sound-3, + item-goat-horn-sound-4, + item-goat-horn-sound-5, + item-goat-horn-sound-6, + item-goat-horn-sound-7, + entity-horse-ambient, + entity-baby-horse-ambient, + entity-horse-angry, + entity-baby-horse-angry, + entity-horse-armor, + item-horse-armor-unequip, + entity-horse-breathe, + entity-baby-horse-breathe, + entity-horse-death, + entity-baby-horse-death, + entity-horse-eat, + entity-baby-horse-eat, + entity-horse-gallop, + entity-horse-hurt, + entity-baby-horse-hurt, + entity-horse-jump, + entity-horse-land, + entity-baby-horse-land, + entity-horse-saddle, + entity-horse-step, + entity-baby-horse-step, + entity-horse-step-wood, + entity-hostile-big-fall, + entity-hostile-death, + entity-hostile-hurt, + entity-hostile-small-fall, + entity-hostile-splash, + entity-hostile-swim, + entity-husk-ambient, + entity-husk-converted-to-zombie, + entity-husk-death, + entity-husk-hurt, + entity-husk-step, + entity-illusioner-ambient, + entity-illusioner-cast-spell, + entity-illusioner-death, + entity-illusioner-hurt, + entity-illusioner-mirror-move, + entity-illusioner-prepare-blindness, + entity-illusioner-prepare-mirror, + item-ink-sac-use, + block-iron-break, + block-iron-step, + block-iron-place, + block-iron-hit, + block-iron-fall, + block-iron-door-close, + block-iron-door-open, + entity-iron-golem-attack, + entity-iron-golem-damage, + entity-iron-golem-death, + entity-iron-golem-hurt, + entity-iron-golem-repair, + entity-iron-golem-step, + block-iron-trapdoor-close, + block-iron-trapdoor-open, + entity-item-frame-add-item, + entity-item-frame-break, + entity-item-frame-place, + entity-item-frame-remove-item, + entity-item-frame-rotate-item, + entity-item-break, + entity-item-pickup, + block-ladder-break, + block-ladder-fall, + block-ladder-hit, + block-ladder-place, + block-ladder-step, + block-lantern-break, + block-lantern-fall, + block-lantern-hit, + block-lantern-place, + block-lantern-step, + block-large-amethyst-bud-break, + block-large-amethyst-bud-place, + block-lava-ambient, + block-lava-extinguish, + block-lava-pop, + block-leaf-litter-break, + block-leaf-litter-step, + block-leaf-litter-place, + block-leaf-litter-hit, + block-leaf-litter-fall, + item-lead-untied, + item-lead-tied, + item-lead-break, + block-lever-click, + entity-lightning-bolt-impact, + entity-lightning-bolt-thunder, + entity-lingering-potion-throw, + entity-llama-ambient, + entity-llama-angry, + entity-llama-chest, + entity-llama-death, + entity-llama-eat, + entity-llama-hurt, + entity-llama-spit, + entity-llama-step, + entity-llama-swag, + item-llama-carpet-unequip, + entity-magma-cube-death-small, + block-lodestone-break, + block-lodestone-step, + block-lodestone-place, + block-lodestone-hit, + block-lodestone-fall, + item-lodestone-compass-lock, + item-spear-lunge-1, + item-spear-lunge-2, + item-spear-lunge-3, + item-mace-smash-air, + item-mace-smash-ground, + item-mace-smash-ground-heavy, + entity-magma-cube-death, + entity-magma-cube-hurt, + entity-magma-cube-hurt-small, + entity-magma-cube-jump, + entity-magma-cube-squish, + entity-magma-cube-squish-small, + block-mangrove-roots-break, + block-mangrove-roots-fall, + block-mangrove-roots-hit, + block-mangrove-roots-place, + block-mangrove-roots-step, + block-medium-amethyst-bud-break, + block-medium-amethyst-bud-place, + block-metal-break, + block-metal-fall, + block-metal-hit, + block-metal-place, + block-metal-pressure-plate-click-off, + block-metal-pressure-plate-click-on, + block-metal-step, + entity-minecart-inside-underwater, + entity-minecart-inside, + entity-minecart-riding, + entity-mooshroom-convert, + entity-mooshroom-eat, + entity-mooshroom-milk, + entity-mooshroom-suspicious-milk, + entity-mooshroom-shear, + block-moss-carpet-break, + block-moss-carpet-fall, + block-moss-carpet-hit, + block-moss-carpet-place, + block-moss-carpet-step, + block-pink-petals-break, + block-pink-petals-fall, + block-pink-petals-hit, + block-pink-petals-place, + block-pink-petals-step, + block-moss-break, + block-moss-fall, + block-moss-hit, + block-moss-place, + block-moss-step, + block-mud-break, + block-mud-fall, + block-mud-hit, + block-mud-place, + block-mud-step, + block-mud-bricks-break, + block-mud-bricks-fall, + block-mud-bricks-hit, + block-mud-bricks-place, + block-mud-bricks-step, + block-muddy-mangrove-roots-break, + block-muddy-mangrove-roots-fall, + block-muddy-mangrove-roots-hit, + block-muddy-mangrove-roots-place, + block-muddy-mangrove-roots-step, + entity-mule-ambient, + entity-mule-angry, + entity-mule-chest, + entity-mule-death, + entity-mule-eat, + entity-mule-hurt, + entity-mule-jump, + music-creative, + music-credits, + music-disc-5, + music-disc-11, + music-disc-13, + music-disc-blocks, + music-disc-bounce, + music-disc-cat, + music-disc-chirp, + music-disc-far, + music-disc-lava-chicken, + music-disc-mall, + music-disc-mellohi, + music-disc-pigstep, + music-disc-stal, + music-disc-strad, + music-disc-wait, + music-disc-ward, + music-disc-otherside, + music-disc-relic, + music-disc-creator, + music-disc-creator-music-box, + music-disc-precipice, + music-disc-tears, + music-dragon, + music-end, + music-game, + music-menu, + music-nether-basalt-deltas, + music-nether-crimson-forest, + music-overworld-deep-dark, + music-overworld-dripstone-caves, + music-overworld-grove, + music-overworld-jagged-peaks, + music-overworld-lush-caves, + music-overworld-swamp, + music-overworld-forest, + music-overworld-old-growth-taiga, + music-overworld-meadow, + music-overworld-cherry-grove, + music-nether-nether-wastes, + music-overworld-frozen-peaks, + music-overworld-snowy-slopes, + music-nether-soul-sand-valley, + music-overworld-stony-peaks, + music-nether-warped-forest, + music-overworld-flower-forest, + music-overworld-desert, + music-overworld-badlands, + music-overworld-jungle, + music-overworld-sparse-jungle, + music-overworld-bamboo-jungle, + music-overworld-sulfur-caves, + music-under-water, + entity-nautilus-ambient, + entity-nautilus-ambient-land, + entity-nautilus-dash, + entity-nautilus-dash-land, + entity-nautilus-dash-ready, + entity-nautilus-dash-ready-land, + entity-nautilus-death, + entity-nautilus-death-land, + entity-nautilus-eat, + entity-nautilus-hurt, + entity-nautilus-hurt-land, + entity-nautilus-swim, + block-nether-bricks-break, + block-nether-bricks-step, + block-nether-bricks-place, + block-nether-bricks-hit, + block-nether-bricks-fall, + block-nether-wart-break, + item-nether-wart-plant, + block-nether-wood-break, + block-nether-wood-fall, + block-nether-wood-hit, + block-nether-wood-place, + block-nether-wood-step, + block-nether-wood-door-close, + block-nether-wood-door-open, + block-nether-wood-trapdoor-close, + block-nether-wood-trapdoor-open, + block-nether-wood-button-click-off, + block-nether-wood-button-click-on, + block-nether-wood-pressure-plate-click-off, + block-nether-wood-pressure-plate-click-on, + block-nether-wood-fence-gate-close, + block-nether-wood-fence-gate-open, + intentionally-empty, + block-packed-mud-break, + block-packed-mud-fall, + block-packed-mud-hit, + block-packed-mud-place, + block-packed-mud-step, + block-stem-break, + block-stem-step, + block-stem-place, + block-stem-hit, + block-stem-fall, + block-nylium-break, + block-nylium-step, + block-nylium-place, + block-nylium-hit, + block-nylium-fall, + block-nether-sprouts-break, + block-nether-sprouts-step, + block-nether-sprouts-place, + block-nether-sprouts-hit, + block-nether-sprouts-fall, + block-fungus-break, + block-fungus-step, + block-fungus-place, + block-fungus-hit, + block-fungus-fall, + block-weeping-vines-break, + block-weeping-vines-step, + block-weeping-vines-place, + block-weeping-vines-hit, + block-weeping-vines-fall, + block-wart-block-break, + block-wart-block-step, + block-wart-block-place, + block-wart-block-hit, + block-wart-block-fall, + block-netherite-block-break, + block-netherite-block-step, + block-netherite-block-place, + block-netherite-block-hit, + block-netherite-block-fall, + block-netherrack-break, + block-netherrack-step, + block-netherrack-place, + block-netherrack-hit, + block-netherrack-fall, + block-note-block-basedrum, + block-note-block-bass, + block-note-block-bell, + block-note-block-chime, + block-note-block-flute, + block-note-block-guitar, + block-note-block-harp, + block-note-block-hat, + block-note-block-pling, + block-note-block-snare, + block-note-block-trumpet, + block-note-block-trumpet-exposed, + block-note-block-trumpet-oxidized, + block-note-block-trumpet-weathered, + block-note-block-xylophone, + block-note-block-iron-xylophone, + block-note-block-cow-bell, + block-note-block-didgeridoo, + block-note-block-bit, + block-note-block-banjo, + block-note-block-imitate-zombie, + block-note-block-imitate-skeleton, + block-note-block-imitate-creeper, + block-note-block-imitate-ender-dragon, + block-note-block-imitate-wither-skeleton, + block-note-block-imitate-piglin, + entity-ocelot-hurt, + entity-ocelot-ambient, + entity-ocelot-death, + item-ominous-bottle-dispose, + entity-painting-break, + entity-painting-place, + block-pale-hanging-moss-idle, + entity-panda-pre-sneeze, + entity-panda-sneeze, + entity-panda-ambient, + entity-panda-death, + entity-panda-eat, + entity-panda-step, + entity-panda-cant-breed, + entity-panda-aggressive-ambient, + entity-panda-worried-ambient, + entity-panda-hurt, + entity-panda-bite, + entity-parched-ambient, + entity-parched-death, + entity-parched-hurt, + entity-parched-step, + entity-parrot-ambient, + entity-parrot-death, + entity-parrot-eat, + entity-parrot-fly, + entity-parrot-hurt, + entity-parrot-imitate-blaze, + entity-parrot-imitate-bogged, + entity-parrot-imitate-breeze, + entity-parrot-imitate-camel-husk, + entity-parrot-imitate-creaking, + entity-parrot-imitate-creeper, + entity-parrot-imitate-drowned, + entity-parrot-imitate-elder-guardian, + entity-parrot-imitate-ender-dragon, + entity-parrot-imitate-endermite, + entity-parrot-imitate-evoker, + entity-parrot-imitate-ghast, + entity-parrot-imitate-guardian, + entity-parrot-imitate-hoglin, + entity-parrot-imitate-husk, + entity-parrot-imitate-illusioner, + entity-parrot-imitate-magma-cube, + entity-parrot-imitate-phantom, + entity-parrot-imitate-parched, + entity-parrot-imitate-piglin, + entity-parrot-imitate-piglin-brute, + entity-parrot-imitate-pillager, + entity-parrot-imitate-ravager, + entity-parrot-imitate-shulker, + entity-parrot-imitate-silverfish, + entity-parrot-imitate-skeleton, + entity-parrot-imitate-slime, + entity-parrot-imitate-spider, + entity-parrot-imitate-stray, + entity-parrot-imitate-vex, + entity-parrot-imitate-vindicator, + entity-parrot-imitate-warden, + entity-parrot-imitate-witch, + entity-parrot-imitate-wither, + entity-parrot-imitate-wither-skeleton, + entity-parrot-imitate-zoglin, + entity-parrot-imitate-zombie, + entity-parrot-imitate-zombie-horse, + entity-parrot-imitate-zombie-nautilus, + entity-parrot-imitate-zombie-villager, + entity-parrot-step, + entity-phantom-ambient, + entity-phantom-bite, + entity-phantom-death, + entity-phantom-flap, + entity-phantom-hurt, + entity-phantom-swoop, + entity-pig-saddle, + entity-pig-step, + entity-baby-pig-step, + entity-baby-pig-ambient, + entity-baby-pig-eat, + entity-baby-pig-hurt, + entity-baby-pig-death, + entity-pig-ambient, + entity-pig-hurt, + entity-pig-death, + entity-pig-eat, + entity-pig-mini-ambient, + entity-pig-mini-hurt, + entity-pig-mini-death, + entity-pig-mini-eat, + entity-pig-big-ambient, + entity-pig-big-hurt, + entity-pig-big-death, + entity-pig-big-eat, + entity-piglin-admiring-item, + entity-piglin-ambient, + entity-piglin-angry, + entity-piglin-celebrate, + entity-piglin-death, + entity-piglin-jealous, + entity-piglin-hurt, + entity-piglin-retreat, + entity-piglin-step, + entity-piglin-converted-to-zombified, + entity-piglin-brute-ambient, + entity-piglin-brute-angry, + entity-piglin-brute-death, + entity-piglin-brute-hurt, + entity-piglin-brute-step, + entity-piglin-brute-converted-to-zombified, + entity-pillager-ambient, + entity-pillager-celebrate, + entity-pillager-death, + entity-pillager-hurt, + block-piston-contract, + block-piston-extend, + entity-player-attack-crit, + entity-player-attack-knockback, + entity-player-attack-nodamage, + entity-player-attack-strong, + entity-player-attack-sweep, + entity-player-attack-weak, + entity-player-big-fall, + entity-player-breath, + entity-player-burp, + entity-player-death, + entity-player-hurt, + entity-player-hurt-drown, + entity-player-hurt-freeze, + entity-player-hurt-on-fire, + entity-player-hurt-sweet-berry-bush, + entity-player-levelup, + entity-player-small-fall, + entity-player-splash, + entity-player-splash-high-speed, + entity-player-swim, + entity-player-teleport, + entity-polar-bear-ambient, + entity-polar-bear-ambient-baby, + entity-polar-bear-death, + entity-polar-bear-hurt, + entity-polar-bear-step, + entity-polar-bear-warning, + block-polished-deepslate-break, + block-polished-deepslate-fall, + block-polished-deepslate-hit, + block-polished-deepslate-place, + block-polished-deepslate-step, + block-portal-ambient, + block-portal-travel, + block-portal-trigger, + block-powder-snow-break, + block-powder-snow-fall, + block-powder-snow-hit, + block-powder-snow-place, + block-powder-snow-step, + entity-puffer-fish-blow-out, + entity-puffer-fish-blow-up, + entity-puffer-fish-death, + entity-puffer-fish-flop, + entity-puffer-fish-hurt, + entity-puffer-fish-sting, + block-pumpkin-carve, + entity-rabbit-ambient, + entity-rabbit-attack, + entity-rabbit-death, + entity-rabbit-hurt, + entity-rabbit-jump, + event-raid-horn, + entity-ravager-ambient, + entity-ravager-attack, + entity-ravager-celebrate, + entity-ravager-death, + entity-ravager-hurt, + entity-ravager-step, + entity-ravager-stunned, + entity-ravager-roar, + block-nether-gold-ore-break, + block-nether-gold-ore-fall, + block-nether-gold-ore-hit, + block-nether-gold-ore-place, + block-nether-gold-ore-step, + block-nether-ore-break, + block-nether-ore-fall, + block-nether-ore-hit, + block-nether-ore-place, + block-nether-ore-step, + block-redstone-torch-burnout, + block-resin-break, + block-resin-fall, + block-resin-place, + block-resin-step, + block-resin-bricks-break, + block-resin-bricks-fall, + block-resin-bricks-hit, + block-resin-bricks-place, + block-resin-bricks-step, + block-respawn-anchor-ambient, + block-respawn-anchor-charge, + block-respawn-anchor-deplete, + block-respawn-anchor-set-spawn, + block-rooted-dirt-break, + block-rooted-dirt-fall, + block-rooted-dirt-hit, + block-rooted-dirt-place, + block-rooted-dirt-step, + entity-salmon-ambient, + entity-salmon-death, + entity-salmon-flop, + entity-salmon-hurt, + block-sand-break, + block-sand-fall, + block-sand-hit, + block-sand-place, + block-sand-step, + block-sand-idle, + block-scaffolding-break, + block-scaffolding-fall, + block-scaffolding-hit, + block-scaffolding-place, + block-scaffolding-step, + block-sculk-spread, + block-sculk-charge, + block-sculk-break, + block-sculk-fall, + block-sculk-hit, + block-sculk-place, + block-sculk-step, + block-sculk-catalyst-bloom, + block-sculk-catalyst-break, + block-sculk-catalyst-fall, + block-sculk-catalyst-hit, + block-sculk-catalyst-place, + block-sculk-catalyst-step, + block-sculk-sensor-clicking, + block-sculk-sensor-clicking-stop, + block-sculk-sensor-break, + block-sculk-sensor-fall, + block-sculk-sensor-hit, + block-sculk-sensor-place, + block-sculk-sensor-step, + block-sculk-shrieker-break, + block-sculk-shrieker-fall, + block-sculk-shrieker-hit, + block-sculk-shrieker-place, + block-sculk-shrieker-shriek, + block-sculk-shrieker-step, + block-sculk-vein-break, + block-sculk-vein-fall, + block-sculk-vein-hit, + block-sculk-vein-place, + block-sculk-vein-step, + entity-sheep-ambient, + entity-sheep-death, + entity-sheep-hurt, + entity-sheep-shear, + entity-sheep-step, + item-shears-snip, + block-shelf-activate, + block-shelf-break, + block-shelf-deactivate, + block-shelf-fall, + block-shelf-hit, + block-shelf-multi-swap, + block-shelf-place, + block-shelf-place-item, + block-shelf-single-swap, + block-shelf-step, + block-shelf-take-item, + item-shield-block, + item-shield-break, + block-shroomlight-break, + block-shroomlight-step, + block-shroomlight-place, + block-shroomlight-hit, + block-shroomlight-fall, + item-shovel-flatten, + entity-shulker-ambient, + block-shulker-box-close, + block-shulker-box-open, + entity-shulker-bullet-hit, + entity-shulker-bullet-hurt, + entity-shulker-close, + entity-shulker-death, + entity-shulker-hurt, + entity-shulker-hurt-closed, + entity-shulker-open, + entity-shulker-shoot, + entity-shulker-teleport, + entity-silverfish-ambient, + entity-silverfish-death, + entity-silverfish-hurt, + entity-silverfish-step, + entity-skeleton-ambient, + entity-skeleton-converted-to-stray, + entity-skeleton-death, + entity-skeleton-horse-ambient, + entity-skeleton-horse-death, + entity-skeleton-horse-hurt, + entity-skeleton-horse-swim, + entity-skeleton-horse-ambient-water, + entity-skeleton-horse-gallop-water, + entity-skeleton-horse-jump-water, + entity-skeleton-horse-step-water, + entity-skeleton-hurt, + entity-skeleton-shoot, + entity-skeleton-step, + entity-slime-attack, + entity-slime-death, + entity-slime-hurt, + entity-slime-jump, + entity-slime-squish, + block-slime-block-break, + block-slime-block-fall, + block-slime-block-hit, + block-slime-block-place, + block-slime-block-step, + block-small-amethyst-bud-break, + block-small-amethyst-bud-place, + block-small-dripleaf-break, + block-small-dripleaf-fall, + block-small-dripleaf-hit, + block-small-dripleaf-place, + block-small-dripleaf-step, + block-soul-sand-break, + block-soul-sand-step, + block-soul-sand-place, + block-soul-sand-hit, + block-soul-sand-fall, + block-soul-soil-break, + block-soul-soil-step, + block-soul-soil-place, + block-soul-soil-hit, + block-soul-soil-fall, + particle-soul-escape, + block-spawner-break, + block-spawner-fall, + block-spawner-hit, + block-spawner-place, + block-spawner-step, + item-spear-use, + item-spear-hit, + item-spear-attack, + item-spear-wood-use, + item-spear-wood-hit, + item-spear-wood-attack, + block-spore-blossom-break, + block-spore-blossom-fall, + block-spore-blossom-hit, + block-spore-blossom-place, + block-spore-blossom-step, + entity-strider-ambient, + entity-strider-happy, + entity-strider-retreat, + entity-strider-death, + entity-strider-hurt, + entity-strider-step, + entity-strider-step-lava, + entity-strider-eat, + entity-strider-saddle, + entity-slime-death-small, + entity-slime-hurt-small, + entity-slime-jump-small, + entity-slime-squish-small, + block-smithing-table-use, + block-smoker-smoke, + entity-sniffer-step, + entity-sniffer-eat, + entity-sniffer-idle, + entity-sniffer-hurt, + entity-sniffer-death, + entity-sniffer-drop-seed, + entity-sniffer-scenting, + entity-sniffer-sniffing, + entity-sniffer-searching, + entity-sniffer-digging, + entity-sniffer-digging-stop, + entity-sniffer-happy, + block-sniffer-egg-plop, + block-sniffer-egg-crack, + block-sniffer-egg-hatch, + entity-snowball-throw, + block-snow-break, + block-snow-fall, + entity-snow-golem-ambient, + entity-snow-golem-death, + entity-snow-golem-hurt, + entity-snow-golem-shoot, + entity-snow-golem-shear, + block-snow-hit, + block-snow-place, + block-snow-step, + entity-spider-ambient, + entity-spider-death, + entity-spider-hurt, + entity-spider-step, + entity-splash-potion-break, + entity-splash-potion-throw, + block-sponge-break, + block-sponge-fall, + block-sponge-hit, + block-sponge-place, + block-sponge-step, + block-sponge-absorb, + item-spyglass-use, + item-spyglass-stop-using, + entity-squid-ambient, + entity-squid-death, + entity-squid-hurt, + entity-squid-squirt, + block-stone-break, + block-stone-button-click-off, + block-stone-button-click-on, + block-stone-fall, + block-stone-hit, + block-stone-place, + block-stone-pressure-plate-click-off, + block-stone-pressure-plate-click-on, + block-stone-step, + entity-stray-ambient, + entity-stray-death, + entity-stray-hurt, + entity-stray-step, + block-sulfur-spike-break, + block-sulfur-spike-step, + block-sulfur-spike-place, + block-sulfur-spike-hit, + block-sulfur-spike-fall, + block-sulfur-spike-land, + block-sweet-berry-bush-break, + block-sweet-berry-bush-place, + block-sweet-berry-bush-pick-berries, + entity-tadpole-death, + entity-tadpole-flop, + entity-tadpole-grow-up, + entity-tadpole-hurt, + enchant-thorns-hit, + entity-tnt-primed, + item-totem-use, + item-trident-hit, + item-trident-hit-ground, + item-trident-return, + item-trident-riptide-1, + item-trident-riptide-2, + item-trident-riptide-3, + item-trident-throw, + item-trident-thunder, + block-tripwire-attach, + block-tripwire-click-off, + block-tripwire-click-on, + block-tripwire-detach, + entity-tropical-fish-ambient, + entity-tropical-fish-death, + entity-tropical-fish-flop, + entity-tropical-fish-hurt, + block-tuff-break, + block-tuff-step, + block-tuff-place, + block-tuff-hit, + block-tuff-fall, + block-tuff-bricks-break, + block-tuff-bricks-fall, + block-tuff-bricks-hit, + block-tuff-bricks-place, + block-tuff-bricks-step, + block-polished-tuff-break, + block-polished-tuff-fall, + block-polished-tuff-hit, + block-polished-tuff-place, + block-polished-tuff-step, + entity-turtle-ambient-land, + entity-turtle-death, + entity-turtle-death-baby, + entity-turtle-egg-break, + entity-turtle-egg-crack, + entity-turtle-egg-hatch, + entity-turtle-hurt, + entity-turtle-hurt-baby, + entity-turtle-lay-egg, + entity-turtle-shamble, + entity-turtle-shamble-baby, + entity-turtle-swim, + ui-button-click, + ui-loom-select-pattern, + ui-loom-take-result, + ui-cartography-table-take-result, + ui-stonecutter-take-result, + ui-stonecutter-select-recipe, + ui-toast-challenge-complete, + ui-toast-in, + ui-toast-out, + block-vault-activate, + block-vault-ambient, + block-vault-break, + block-vault-close-shutter, + block-vault-deactivate, + block-vault-eject-item, + block-vault-reject-rewarded-player, + block-vault-fall, + block-vault-hit, + block-vault-insert-item, + block-vault-insert-item-fail, + block-vault-open-shutter, + block-vault-place, + block-vault-step, + entity-vex-ambient, + entity-vex-charge, + entity-vex-death, + entity-vex-hurt, + entity-villager-ambient, + entity-villager-celebrate, + entity-villager-death, + entity-villager-hurt, + entity-villager-no, + entity-villager-trade, + entity-villager-yes, + entity-villager-work-armorer, + entity-villager-work-butcher, + entity-villager-work-cartographer, + entity-villager-work-cleric, + entity-villager-work-farmer, + entity-villager-work-fisherman, + entity-villager-work-fletcher, + entity-villager-work-leatherworker, + entity-villager-work-librarian, + entity-villager-work-mason, + entity-villager-work-shepherd, + entity-villager-work-toolsmith, + entity-villager-work-weaponsmith, + entity-vindicator-ambient, + entity-vindicator-celebrate, + entity-vindicator-death, + entity-vindicator-hurt, + block-vine-break, + block-vine-fall, + block-vine-hit, + block-vine-place, + block-vine-step, + block-lily-pad-place, + entity-wandering-trader-ambient, + entity-wandering-trader-death, + entity-wandering-trader-disappeared, + entity-wandering-trader-drink-milk, + entity-wandering-trader-drink-potion, + entity-wandering-trader-hurt, + entity-wandering-trader-no, + entity-wandering-trader-reappeared, + entity-wandering-trader-trade, + entity-wandering-trader-yes, + entity-warden-agitated, + entity-warden-ambient, + entity-warden-angry, + entity-warden-attack-impact, + entity-warden-death, + entity-warden-dig, + entity-warden-emerge, + entity-warden-heartbeat, + entity-warden-hurt, + entity-warden-listening, + entity-warden-listening-angry, + entity-warden-nearby-close, + entity-warden-nearby-closer, + entity-warden-nearby-closest, + entity-warden-roar, + entity-warden-sniff, + entity-warden-sonic-boom, + entity-warden-sonic-charge, + entity-warden-step, + entity-warden-tendril-clicks, + block-hanging-sign-waxed-interact-fail, + block-sign-waxed-interact-fail, + block-water-ambient, + weather-end-flash, + weather-rain, + weather-rain-above, + block-wet-grass-break, + block-wet-grass-fall, + block-wet-grass-hit, + block-wet-grass-place, + block-wet-grass-step, + block-wet-sponge-break, + block-wet-sponge-dries, + block-wet-sponge-fall, + block-wet-sponge-hit, + block-wet-sponge-place, + block-wet-sponge-step, + entity-wind-charge-wind-burst, + entity-wind-charge-throw, + entity-witch-ambient, + entity-witch-celebrate, + entity-witch-death, + entity-witch-drink, + entity-witch-hurt, + entity-witch-throw, + entity-wither-ambient, + entity-wither-break-block, + entity-wither-death, + entity-wither-hurt, + entity-wither-shoot, + entity-wither-skeleton-ambient, + entity-wither-skeleton-death, + entity-wither-skeleton-hurt, + entity-wither-skeleton-step, + entity-wither-spawn, + item-wolf-armor-break, + entity-baby-wolf-ambient, + item-wolf-armor-crack, + item-wolf-armor-damage, + item-wolf-armor-repair, + entity-baby-wolf-death, + entity-baby-wolf-growl, + entity-baby-wolf-hurt, + entity-baby-wolf-pant, + entity-wolf-shake, + entity-wolf-step, + entity-baby-wolf-step, + entity-baby-wolf-whine, + entity-wolf-ambient, + entity-wolf-death, + entity-wolf-growl, + entity-wolf-hurt, + entity-wolf-pant, + entity-wolf-whine, + entity-wolf-puglin-ambient, + entity-wolf-puglin-death, + entity-wolf-puglin-growl, + entity-wolf-puglin-hurt, + entity-wolf-puglin-pant, + entity-wolf-puglin-whine, + entity-wolf-sad-ambient, + entity-wolf-sad-death, + entity-wolf-sad-growl, + entity-wolf-sad-hurt, + entity-wolf-sad-pant, + entity-wolf-sad-whine, + entity-wolf-angry-ambient, + entity-wolf-angry-death, + entity-wolf-angry-growl, + entity-wolf-angry-hurt, + entity-wolf-angry-pant, + entity-wolf-angry-whine, + entity-wolf-grumpy-ambient, + entity-wolf-grumpy-death, + entity-wolf-grumpy-growl, + entity-wolf-grumpy-hurt, + entity-wolf-grumpy-pant, + entity-wolf-grumpy-whine, + entity-wolf-big-ambient, + entity-wolf-big-death, + entity-wolf-big-growl, + entity-wolf-big-hurt, + entity-wolf-big-pant, + entity-wolf-big-whine, + entity-wolf-cute-ambient, + entity-wolf-cute-death, + entity-wolf-cute-growl, + entity-wolf-cute-hurt, + entity-wolf-cute-pant, + entity-wolf-cute-whine, + block-wooden-door-close, + block-wooden-door-open, + block-wooden-trapdoor-close, + block-wooden-trapdoor-open, + block-wooden-button-click-off, + block-wooden-button-click-on, + block-wooden-pressure-plate-click-off, + block-wooden-pressure-plate-click-on, + block-wood-break, + block-wood-fall, + block-wood-hit, + block-wood-place, + block-wood-step, + block-wool-break, + block-wool-fall, + block-wool-hit, + block-wool-place, + block-wool-step, + entity-zoglin-ambient, + entity-zoglin-angry, + entity-zoglin-attack, + entity-zoglin-death, + entity-zoglin-hurt, + entity-zoglin-step, + entity-zombie-ambient, + entity-zombie-attack-wooden-door, + entity-zombie-attack-iron-door, + entity-zombie-break-wooden-door, + entity-zombie-converted-to-drowned, + entity-zombie-death, + entity-zombie-destroy-egg, + entity-zombie-horse-ambient, + entity-zombie-horse-angry, + entity-zombie-horse-death, + entity-zombie-horse-eat, + entity-zombie-horse-hurt, + entity-zombie-hurt, + entity-zombie-infect, + entity-zombie-nautilus-ambient, + entity-zombie-nautilus-ambient-land, + entity-zombie-nautilus-dash, + entity-zombie-nautilus-dash-land, + entity-zombie-nautilus-dash-ready, + entity-zombie-nautilus-dash-ready-land, + entity-zombie-nautilus-death, + entity-zombie-nautilus-death-land, + entity-zombie-nautilus-eat, + entity-zombie-nautilus-hurt, + entity-zombie-nautilus-hurt-land, + entity-zombie-nautilus-swim, + entity-zombified-piglin-ambient, + entity-zombified-piglin-angry, + entity-zombified-piglin-death, + entity-zombified-piglin-hurt, + entity-zombie-step, + entity-zombie-villager-ambient, + entity-zombie-villager-converted, + entity-zombie-villager-cure, + entity-zombie-villager-death, + entity-zombie-villager-hurt, + entity-zombie-villager-step, + event-mob-effect-bad-omen, + event-mob-effect-trial-omen, + event-mob-effect-raid-omen, + item-saddle-unequip, + item-nautilus-saddle-underwater-equip, + item-nautilus-saddle-equip, + block-sulfur-break, + block-sulfur-step, + block-sulfur-place, + block-sulfur-hit, + block-sulfur-fall, + block-potent-sulfur-break, + block-potent-sulfur-step, + block-potent-sulfur-place, + block-potent-sulfur-hit, + block-potent-sulfur-fall, + block-potent-sulfur-geyser-eruption, + block-potent-sulfur-geyser-eruption-active, + block-potent-sulfur-geyser-continuous-eruption, + block-potent-sulfur-geyser-continuous-eruption-active, + block-cinnabar-break, + block-cinnabar-step, + block-cinnabar-place, + block-cinnabar-hit, + block-cinnabar-fall, + entity-sulfur-cube-absorb, + entity-sulfur-cube-bounce, + entity-sulfur-cube-death, + entity-sulfur-cube-eject, + entity-sulfur-cube-hurt, + entity-sulfur-cube-jump, + entity-sulfur-cube-regular-hit, + entity-sulfur-cube-regular-push, + entity-sulfur-cube-bouncy-hit, + entity-sulfur-cube-bouncy-push, + entity-sulfur-cube-slow-bouncy-hit, + entity-sulfur-cube-slow-bouncy-push, + entity-sulfur-cube-slow-flat-hit, + entity-sulfur-cube-slow-flat-push, + entity-sulfur-cube-fast-flat-hit, + entity-sulfur-cube-fast-flat-push, + entity-sulfur-cube-light-hit, + entity-sulfur-cube-light-push, + entity-sulfur-cube-fast-sliding-hit, + entity-sulfur-cube-fast-sliding-push, + entity-sulfur-cube-slow-sliding-hit, + entity-sulfur-cube-slow-sliding-push, + entity-sulfur-cube-sticky-hit, + entity-sulfur-cube-sticky-push, + entity-sulfur-cube-high-resistance-hit, + entity-sulfur-cube-high-resistance-push, + entity-sulfur-cube-explosive-hit, + entity-sulfur-cube-explosive-push, + entity-sulfur-cube-hot-hit, + entity-sulfur-cube-hot-push, + entity-sulfur-cube-squish, + block-potent-sulfur-noxious-gas, + entity-small-sulfur-cube-death, + entity-small-sulfur-cube-hurt, + entity-small-sulfur-cube-jump, + entity-small-sulfur-cube-squish, + entity-small-sulfur-cube-eat, + } +} diff --git a/v0.1/statistics.wit b/v0.1/statistics.wit new file mode 100644 index 000000000..07222d5b2 --- /dev/null +++ b/v0.1/statistics.wit @@ -0,0 +1,94 @@ +package pumpkin:plugin@0.1.0; + +interface statistics { + enum statistic-category { + mined, + crafted, + used, + broken, + picked-up, + dropped, + killed, + killed-by, + custom, + } + enum custom-statistic { + leave-game, + play-time, + total-world-time, + time-since-death, + time-since-rest, + sneak-time, + walk-one-cm, + crouch-one-cm, + sprint-one-cm, + walk-on-water-one-cm, + fall-one-cm, + climb-one-cm, + fly-one-cm, + walk-under-water-one-cm, + minecart-one-cm, + boat-one-cm, + pig-one-cm, + happy-ghast-one-cm, + horse-one-cm, + aviate-one-cm, + swim-one-cm, + strider-one-cm, + nautilus-one-cm, + jump, + drop, + damage-dealt, + damage-dealt-absorbed, + damage-dealt-resisted, + damage-taken, + damage-blocked-by-shield, + damage-absorbed, + damage-resisted, + deaths, + mob-kills, + animals-bred, + player-kills, + fish-caught, + talked-to-villager, + traded-with-villager, + eat-cake-slice, + fill-cauldron, + use-cauldron, + clean-armor, + clean-banner, + clean-shulker-box, + interact-with-brewingstand, + interact-with-beacon, + inspect-dropper, + inspect-hopper, + inspect-dispenser, + play-noteblock, + tune-noteblock, + pot-flower, + trigger-trapped-chest, + open-enderchest, + enchant-item, + play-record, + interact-with-furnace, + interact-with-crafting-table, + open-chest, + sleep-in-bed, + open-shulker-box, + open-barrel, + interact-with-blast-furnace, + interact-with-smoker, + interact-with-lectern, + interact-with-campfire, + interact-with-cartography-table, + interact-with-loom, + interact-with-stonecutter, + bell-ring, + raid-trigger, + raid-win, + interact-with-anvil, + interact-with-grindstone, + target-hit, + interact-with-smithing-table, + } +} diff --git a/v0.1/status-effect.wit b/v0.1/status-effect.wit new file mode 100644 index 000000000..b2cdb4c06 --- /dev/null +++ b/v0.1/status-effect.wit @@ -0,0 +1,54 @@ +package pumpkin:plugin@0.1.0; + +interface status-effect { + enum status-effect-type { + speed, + slowness, + haste, + mining-fatigue, + strength, + instant-health, + instant-damage, + jump-boost, + nausea, + regeneration, + resistance, + fire-resistance, + water-breathing, + invisibility, + blindness, + night-vision, + hunger, + weakness, + poison, + wither, + health-boost, + absorption, + saturation, + glowing, + levitation, + luck, + unluck, + slow-falling, + conduit-power, + dolphins-grace, + bad-omen, + hero-of-the-village, + darkness, + trial-omen, + raid-omen, + wind-charged, + weaving, + oozing, + infested, + } + + record status-effect-instance { + effect-type: status-effect-type, + duration: u32, + amplifier: u8, + ambient: bool, + show-particles: bool, + show-icon: bool, + } +} diff --git a/v0.1/text.wit b/v0.1/text.wit new file mode 100644 index 000000000..82f626a5b --- /dev/null +++ b/v0.1/text.wit @@ -0,0 +1,68 @@ +interface text { + use common.{named-color, rgb-color, argb-color}; + + resource text-component { + /// Creates a plain text component. + text: static func(plain: string) -> text-component; + /// Creates a translation component. + translate: static func(key: string, %with: list) -> text-component; + /// Creates a translation component with a Bedrock-specific fallback key. + translate-cross: static func(java-key: string, bedrock-key: string, %with: list) -> text-component; + /// Creates an entity names / selector text component. + entity-names: static func(selector: string, separator: option) -> text-component; + /// Creates a keybind text component (e.g., "key.jump"). + keybind: static func(keybind: string) -> text-component; + /// Creates a custom translation component. + custom: static func(namespace: string, key: string, locale: string, %with: list) -> text-component; + + /// Parses a legacy Minecraft formatted string (using section signs '§' by default) into a text component. + from-legacy-string: static func(input: string) -> text-component; + /// Parses a legacy formatted string using a custom color code symbol (e.g. '&' or '§'). + from-legacy-string-with-code: static func(input: string, code-symbol: char) -> text-component; + + /// Parses a standard Minecraft JSON text component. + from-json: static func(json: string) -> result; + /// Serializes the text component to JSON format. + to-json: func() -> string; + + add-child: func(child: text-component); + add-text: func(text: string); + get-text: func() -> string; + encode: func() -> list; + to-pretty-console: func() -> string; + + // Style + + color-named: func(color: named-color); + color-rgb: func(color: rgb-color); + gradient-named: func(colors: list); + gradient: func(colors: list); + rainbow: func(); + 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-open-file: func(path: string); + click-run-command: func(command: string); + click-suggest-command: func(command: string); + click-change-page: func(page: u32); + 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); + } +} + diff --git a/v0.1/uuid.wit b/v0.1/uuid.wit new file mode 100644 index 000000000..2f3ee421f --- /dev/null +++ b/v0.1/uuid.wit @@ -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; + + /// Converts a UUID to its standard string representation. + to-string: func(id: uuid) -> string; +} diff --git a/v0.1/world.wit b/v0.1/world.wit new file mode 100644 index 000000000..e0e746f5c --- /dev/null +++ b/v0.1/world.wit @@ -0,0 +1,1050 @@ +interface %world { + use common.{position, entity-pose, block-pos, nbt-tree}; + use block-entity.{block-entity, command-block-entity, block-entity-type}; + use text.{text-component}; + use scoreboard.{scoreboard}; + use particles.{particle}; + use sounds.{sound, sound-category}; + use entity-types.{entity-type}; + use biomes.{biome}; + use attributes.{attribute, modifier-operation, attribute-modifier}; + use item-stack.{item-stack}; + use damage-types.{damage-type}; + use game-rules.{game-rule, game-rule-value}; + + use uuid.{uuid}; + + /// Equipment slots available on living entities (mobs, armor stands, players). + enum equipment-slot { + main-hand, + off-hand, + feet, + legs, + chest, + head, + body, + saddle, + } + + /// 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 + } + + /// Predefined AI goals that can be added to mob entities. + variant builtin-ai-goal { + swim, + wander-around(f32), + melee-attack(f32), + look-at-player(f32), + look-around, + escape-danger(f32), + avoid-entity(f32), + blaze-attack, + creeper-ignite, + eat-grass, + zombie-attack(f32), + } + + /// Node and terrain classification types evaluated during mob pathfinding. + enum path-node-type { + blocked, + open, + walkable, + walkable-door, + trapdoor, + powder-snow, + danger-powder-snow, + fence, + lava, + water, + water-border, + rail, + unpassable-rail, + danger-fire, + damage-fire, + danger-other, + damage-other, + door-open, + door-wood-closed, + door-iron-closed, + breach, + leaves, + sticky-honey, + cocoa, + damage-cautious, + danger-trapdoor, + } + + /// Minecraft 16 dye colors. + enum dye-color { + white, + orange, + magenta, + light-blue, + yellow, + lime, + pink, + gray, + light-gray, + cyan, + purple, + blue, + brown, + green, + red, + black, + } + + /// Villager profession identifiers. + enum villager-profession { + none, + armorer, + butcher, + cartographer, + cleric, + farmer, + fisherman, + fletcher, + leatherworker, + librarian, + mason, + nitwit, + shepherd, + toolsmith, + weaponsmith, + } + + /// Specialized data for sheep entities. + record sheep-data { + color: dye-color, + is-sheared: bool, + } + + /// Specialized data for wolf entities. + record wolf-data { + is-tamed: bool, + owner: option, + is-sitting: bool, + collar-color: dye-color, + is-angry: bool, + is-begging: bool, + } + + /// Specialized data for cat entities. + record cat-data { + is-tamed: bool, + owner: option, + is-sitting: bool, + collar-color: dye-color, + } + + /// Specialized data for villager entities. + record villager-data { + profession: villager-profession, + level: u8, + experience: u32, + } + + /// Specialized data for creeper entities. + record creeper-data { + is-powered: bool, + fuse: s32, + is-ignited: bool, + explosion-radius: u8, + } + + /// Specialized data for slime and magma cube entities. + record slime-data { + size: s32, + } + + /// Specialized data for enderman entities. + record enderman-data { + carried-block-state: option, + is-screaming: bool, + is-staring: bool, + } + + /// Specialized data for iron golem entities. + record iron-golem-data { + is-player-created: bool, + } + + /// Specialized data for fox entities. + record fox-data { + is-sitting: bool, + is-sleeping: bool, + is-crouching: bool, + } + + /// Specialized data for ageable animal mobs. + record ageable-data { + is-baby: bool, + age: s32, + in-love-ticks: s32, + } + + /// Specialized data for zombie entities. + record zombie-data { + is-baby: bool, + can-break-doors: bool, + } + + /// Specialized data for shulker entities. + record shulker-data { + attached-face: block-direction, + peek-amount: u8, + color: option, + } + + /// Tagged variant holding specialized data for specific mob types. + variant mob-data { + sheep(sheep-data), + wolf(wolf-data), + cat(cat-data), + villager(villager-data), + creeper(creeper-data), + slime(slime-data), + enderman(enderman-data), + iron-golem(iron-golem-data), + fox(fox-data), + ageable(ageable-data), + zombie(zombie-data), + shulker(shulker-data), + generic, + } + + /// 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, + } + + /// Flammability properties of a block. + record flammable { + spread-chance: u8, + burn-chance: u8, + } + + /// Detailed information about a block's state. + record block-state { + /// The internal numerical ID of the block state. + id: u16, + /// The numerical ID of the parent block type. + block-id: u16, + /// The namespaced identifier of the parent block type. + block-name: string, + /// 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, + /// The outline shapes of this block. + outline-shapes: list, + + /// 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, + /// The block state's property key-value pairs (e.g. facing=north). + properties: list>, + } + + /// 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, + } + + /// Static definition of a Minecraft block type. + record block { + /// The internal numerical ID of the block type. + id: u16, + /// The unique namespaced ID (e.g., "minecraft:stone"). + name: string, + /// How hard the block is to break (-1.0 for unbreakable blocks). + hardness: f32, + /// Resistance to explosions. + blast-resistance: f32, + /// The color of this block when displayed on a map. + map-color: u8, + /// The friction coefficient (0.6 default, 0.98 for ice). + slipperiness: f32, + /// How much this block affects entity walk speed. + velocity-multiplier: f32, + /// How much this block affects entity jump height. + jump-velocity-multiplier: f32, + /// The item ID associated with this block in inventory/drops. + item-id: u16, + /// The default block state ID when placed without extra properties. + default-state-id: u16, + /// All valid state IDs belonging to this block type. + state-ids: list, + /// Whether this block is solid by default. + is-solid: bool, + /// Whether this block is considered air. + is-air: bool, + /// Whether this block is flammable. + is-flammable: bool, + /// Flammability details if flammable. + flammable: option, + } + + /// 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; + 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-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); + + is-silent: func() -> bool; + set-silent: func(silent: bool); + has-gravity: func() -> bool; + set-has-gravity: func(gravity: 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; + + get-eye-height: func() -> f32; + get-eye-position: func() -> position; + + get-nearby-entities: func(x: f64, y: f64, z: f64) -> list; + + get-vehicle: func() -> option; + set-vehicle: func(vehicle: option); + get-passengers: func() -> list; + 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; + + /// Performs a ray-trace from the entity's eye position in its looking direction to find the targeted block. + ray-trace-block: func(max-distance: f64, include-fluids: bool) -> option; + + /// Performs a ray-trace from the entity's eye position in its looking direction to find the targeted entity. + ray-trace-entity: func(max-distance: f64) -> option; + + /// Returns the entity currently targeted in the looking direction within the specified distance. + get-target-entity: func(max-distance: f64) -> option; + + /// Sets a namespaced custom data value on this entity. + set-custom-data: func(namespace: string, key: string, value: nbt-tree); + /// Returns a namespaced custom data value from this entity, if set. + get-custom-data: func(namespace: string, key: string) -> option; + /// Removes a namespaced custom data value from this entity. + remove-custom-data: func(namespace: string, key: string); + /// Returns whether this entity has a namespaced custom data value. + has-custom-data: func(namespace: string, key: string) -> bool; + + /// Returns this entity as a living-entity if it has health and attributes, or none otherwise. + as-living: func() -> option; + + /// Returns this entity as a mob if it is an AI-driven mob entity, or none otherwise. + as-mob: func() -> option; + + /// Returns whether this entity is a living entity. + is-living: func() -> bool; + + /// Returns whether this entity is an AI-driven mob. + is-mob: func() -> bool; + } + + /// Represents a living entity with health, combat stats, attributes, and equipment (mobs, players, armor stands). + resource living-entity { + /// Converts back to the base entity handle. + as-entity: func() -> entity; + + /// Returns this living entity as a mob if it has AI/navigation, or none otherwise. + as-mob: func() -> option; + + /// Returns whether this living entity is an AI-driven mob. + is-mob: func() -> bool; + + // Health & Combat + get-health: func() -> f32; + set-health: func(health: f32); + get-max-health: func() -> f32; + set-max-health: func(max-health: f32); + damage: func(amount: f32, damage-type: damage-type); + is-dead: func() -> bool; + + get-absorption: func() -> f32; + set-absorption: func(amount: f32); + + // Attributes + get-attribute-value: func(attr: attribute) -> f64; + get-attribute-base: func(attr: attribute) -> f64; + set-attribute-base: func(attr: attribute, value: f64); + add-attribute-modifier: func(attr: attribute, modifier: attribute-modifier); + remove-attribute-modifier: func(attr: attribute, id: string); + get-attribute-modifiers: func(attr: attribute) -> list; + reset-attribute: func(attr: attribute); + reset-all-attributes: func(); + + // Equipment + get-equipment: func(slot: equipment-slot) -> option; + set-equipment: func(slot: equipment-slot, stack: option); + clear-equipment: func(); + + get-age: func() -> s32; + set-age: func(age: s32); + send-system-message: func(message: text-component); + } + + /// Represents an AI-driven mob entity with goals, targeting, and pathfinding navigation (e.g. zombies, villagers). + resource mob { + /// Converts back to the base entity handle. + as-entity: func() -> entity; + + /// Converts to the living-entity handle. + as-living: func() -> living-entity; + + // Goals & Targeting + add-ai-goal: func(priority: u8, goal: builtin-ai-goal); + add-custom-ai-goal: func(priority: u8, goal-id: u32); + clear-ai-goals: func(); + set-ai-disabled: func(disabled: bool); + is-ai-disabled: func() -> bool; + set-target: func(target: option); + get-target: func() -> option; + + // Pathfinding & Navigation + navigate-to-pos: func(pos: position, speed: f64) -> bool; + navigate-to-entity: func(target: entity, speed: f64) -> bool; + stop-navigation: func(); + is-navigating: func() -> bool; + has-reached-destination: func() -> bool; + set-navigation-speed: func(speed: f64); + can-reach: func(pos: position, max-distance: f32) -> bool; + set-pathfinding-malus: func(node-type: path-node-type, malus: f32); + get-pathfinding-malus: func(node-type: path-node-type) -> f32; + look-at: func(pos: position); + look-at-entity: func(target: entity); + + /// Returns the specialized mob-specific data for this mob. + get-mob-data: func() -> mob-data; + + /// Sets the specialized mob-specific data for this mob. + /// Returns false if the provided data variant is incompatible with this mob. + set-mob-data: func(data: mob-data) -> bool; + + /// Sets the number of freeze ticks on this entity (0 to 140). + set-freeze-ticks: func(ticks: s32); + /// Returns the number of freeze ticks currently on this entity. + get-freeze-ticks: func() -> s32; + } + + /// 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, + } + + /// Detailed result of a block ray-trace operation. + record ray-trace-block-result { + /// The block position that was hit. + pos: block-pos, + /// The face of the block that was hit. + face: block-direction, + /// The exact hit coordinates in world space. + hit-pos: position, + } + + /// Result of an entity ray-trace operation. + record ray-trace-entity-result { + /// The entity that was hit. + entity: entity, + /// The exact hit coordinates in world space. + hit-pos: position, + /// The distance from the ray start to the hit position. + distance: f64, + } + + resource chunk { + /// Gets the chunk's X coordinate. + get-x: func() -> s32; + + /// Gets the chunk's Z coordinate. + get-z: func() -> s32; + + /// Gets the block state ID at the specified position relative to the chunk. + /// X and Z must be in the range [0, 15]. + get-block-state-id: func(pos: block-pos) -> u16; + + /// Gets detailed block state information at the specified position relative to the chunk. + /// X and Z must be in the range [0, 15]. + get-block-state: func(pos: block-pos) -> block-state; + + /// Sets the block state at the specified position relative to the chunk. + /// X and Z must be in the range [0, 15]. + set-block-state: func(pos: block-pos, state: u16); + + /// Gets the block at the specified position relative to the chunk. + /// X and Z must be in the range [0, 15]. + get-block: func(pos: block-pos) -> block; + + /// Sets the block at the specified position relative to the chunk using its default state. + /// X and Z must be in the range [0, 15]. + set-block: func(pos: block-pos, block: block); + + /// Sets the block by block ID at the specified position relative to the chunk using its default state. + /// X and Z must be in the range [0, 15]. + set-block-by-id: func(pos: block-pos, block-id: u16); + + /// Gets the biome at the specified position relative to the chunk. + /// X and Z must be in the range [0, 15]. + get-biome: func(pos: block-pos) -> biome; + + /// Gets the block entity at the specified position relative to the chunk, if any. + /// X and Z must be in the range [0, 15]. + get-block-entity: func(pos: block-pos) -> option; + + /// Gets the highest non-air block Y coordinate at the specified X and Z relative to the chunk. + /// X and Z must be in the range [0, 15]. + get-top-block-y: func(x: s32, z: s32) -> s32; + + /// Gets the sky light level at the specified position relative to the chunk. + /// X and Z must be in the range [0, 15]. + get-sky-light: func(pos: block-pos) -> u8; + + /// Gets the block light level at the specified position relative to the chunk. + /// X and Z must be in the range [0, 15]. + get-block-light: func(pos: block-pos) -> u8; + + /// Sets a namespaced custom data value on this chunk. + set-custom-data: func(namespace: string, key: string, value: nbt-tree); + /// Returns a namespaced custom data value from this chunk, if set. + get-custom-data: func(namespace: string, key: string) -> option; + /// Removes a namespaced custom data value from this chunk. + remove-custom-data: func(namespace: string, key: string); + /// Returns whether this chunk has a namespaced custom data value. + has-custom-data: func(namespace: string, key: string) -> bool; + } + + /// Represents the boundaries of a world. + resource world-border { + /// Gets the center X coordinate of the border. + get-center-x: func() -> f64; + /// Gets the center Z coordinate of the border. + get-center-z: func() -> f64; + /// Gets the center position of the border. + get-center: func() -> position; + /// Sets the center coordinates of the border. + set-center: func(x: f64, z: f64); + + /// Gets the current diameter of the border. + get-diameter: func() -> f64; + /// Gets the current diameter of the border (alias for get-diameter). + get-size: func() -> f64; + /// Sets the diameter of the border, optionally with a speed (in ticks) for lerping. + set-diameter: func(diameter: f64, speed: option); + /// Sets the size of the border instantly. + set-size: func(size: f64); + /// Sets the size of the border with a transition duration in seconds. + set-size-transition: func(new-size: f64, time-seconds: u64); + + /// Gets the target diameter when lerping/transitioning. + get-target-diameter: func() -> f64; + /// Gets the target transition duration/speed in ticks. + get-target-speed: func() -> s64; + + /// Gets the distance from the border where warning effects start (in blocks). + get-warning-distance: func() -> s32; + /// Sets the warning distance (in blocks). + set-warning-distance: func(distance: s32); + + /// Gets the time before a player hitting the border is warned (in seconds). + get-warning-delay: func() -> s32; + /// Sets the warning delay (in seconds). + set-warning-delay: func(delay: s32); + /// Gets the warning time (alias for get-warning-delay). + get-warning-time: func() -> s32; + /// Sets the warning time (alias for set-warning-delay). + set-warning-time: func(time: s32); + + /// Gets the safe damage buffer distance outside the border (in blocks). + get-damage-buffer: func() -> f64; + /// Sets the safe damage buffer distance outside the border (in blocks). + set-damage-buffer: func(buffer: f64); + + /// Gets the damage amount inflicted per block per second when outside the buffer. + get-damage-amount: func() -> f64; + /// Sets the damage amount inflicted per block per second when outside the buffer. + set-damage-amount: func(damage: f64); + + /// Returns whether the specified coordinates are within the border. + contains: func(x: f64, z: f64) -> bool; + /// Returns whether the specified position is within the border. + contains-pos: func(pos: position) -> bool; + + /// Resets the world border to vanilla default settings. + reset: func(); + } + + /// Represents an axis-aligned bounding box. + record bounding-box { + min: position, + max: position, + } + + /// Represents the configured shared spawn location for a world. + record world-spawn-location { + /// The block position of the shared world spawn. + pos: block-pos, + /// The yaw players should face when spawning here. + yaw: f32, + /// The pitch players should use when spawning here. + pitch: f32, + } + + /// 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 world border associated with this world (alias for get-world-border). + get-border: func() -> world-border; + + /// Gets the world border associated with this world. + get-world-border: func() -> world-border; + + /// Gets the chunk at the specified chunk coordinates. + get-chunk: func(x: s32, z: s32) -> option; + + /// 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); + + /// Gets the block type at the specified position. + get-block: func(pos: block-pos) -> block; + + /// Gets the numerical block ID at the specified position. + get-block-id: func(pos: block-pos) -> u16; + + /// Sets the block at the specified position using its default state. + set-block: func(pos: block-pos, block: block, update-flags: block-flags); + + /// Sets the block at the specified position by numerical block ID using its default state. + set-block-by-id: func(pos: block-pos, block-id: u16, update-flags: block-flags); + + /// Sets the block at the specified position by namespaced name using its default state. + /// Returns true if the block was recognized and set. + set-block-by-name: func(pos: block-pos, name: string, update-flags: block-flags) -> bool; + + /// 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; + + /// Returns the configured shared spawn location for this world. + get-spawn-location: func() -> world-spawn-location; + + /// 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); + + /// Plays a custom resource pack sound identifier at the specified position for all players in the world. + play-custom-sound: func(sound-name: string, 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; + + /// Spawns a lightning bolt at the specified position. + strike-lightning: func(pos: position, effect-only: bool); + + /// Performs a raycast from start position to end position to hit blocks. + ray-trace-blocks: func(start: position, end: position) -> option; + + /// Performs a raycast from start position to end position to hit blocks, with optional fluid handling. + ray-trace-block: func(start: position, end: position, include-fluids: bool) -> option; + + /// Performs a raycast from start position to end position to find the closest entity hit. + ray-trace-entity: func(start: position, end: position) -> option; + + /// Performs a raycast from start position to end position to find all entities hit along the ray. + ray-trace-entities: func(start: position, end: position) -> list; + + /// Returns the block entity at the specified position, if any. + get-block-entity: func(pos: block-pos) -> option; + + /// Returns the raw NBT bytes of the block entity at the given position, if any. + get-block-entity-nbt: func(pos: block-pos) -> option>; + + /// Restores a block entity from raw NBT bytes at the given position. + /// The NBT must contain a valid "id" field (e.g. "minecraft:chest"). + set-block-entity-nbt: func(pos: block-pos, nbt-data: list) -> result<_, string>; + + /// Returns the name of this world (e.g. "world", "world_nether", "arena_1"). + get-name: func() -> string; + + /// Saves all chunk data, block entities, and entities for this world to disk. + save: func() -> result<_, string>; + + /// Sets a custom chunk generator for this world using a registered generator ID. + set-chunk-generator: func(generator-id: u32); + + /// Sets a namespaced custom data value on this world. + set-custom-data: func(namespace: string, key: string, value: nbt-tree); + /// Returns a namespaced custom data value from this world, if set. + get-custom-data: func(namespace: string, key: string) -> option; + /// Removes a namespaced custom data value from this world. + remove-custom-data: func(namespace: string, key: string); + /// Returns whether this world has a namespaced custom data value. + has-custom-data: func(namespace: string, key: string) -> bool; + + /// Gets the value of a game rule in this world. + get-game-rule: func(rule: game-rule) -> game-rule-value; + /// Sets the value of a game rule in this world. + set-game-rule: func(rule: game-rule, value: game-rule-value); + } + + /// Generation phase for custom chunk generation. + enum generation-phase { + biomes, + noise, + surface, + features, + } + + /// Mutable chunk buffer representing a 16x16 column during custom world generation. + resource chunk-buffer { + /// Returns the chunk X coordinate. + get-x: func() -> s32; + /// Returns the chunk Z coordinate. + get-z: func() -> s32; + /// Returns the minimum Y coordinate for this world. + get-min-y: func() -> s32; + /// Returns the height of the chunk in blocks. + get-height: func() -> u32; + + /// Sets the block state ID at local coordinates (0..16, y, 0..16). + set-block-state-id: func(x: u8, y: s32, z: u8, state-id: u16); + /// Gets the block state ID at local coordinates (0..16, y, 0..16). + get-block-state-id: func(x: u8, y: s32, z: u8) -> u16; + + /// Fills an entire horizontal 16x16 layer at the given Y level with a block state ID. + fill-layer: func(y: s32, state-id: u16); + /// Fills a vertical column from min-y to max-y at local (x, z) with a block state ID. + fill-range: func(x: u8, min-y: s32, max-y: s32, z: u8, state-id: u16); + /// Fills a 3D cuboid with a block state ID. + fill-cuboid: func(min-x: u8, min-y: s32, min-z: u8, max-x: u8, max-y: s32, max-z: u8, state-id: u16); + + /// Sets the biome at local coordinates (0..16, y, 0..16). + set-biome: func(x: u8, y: s32, z: u8, biome: biome); + /// Fills the entire chunk with the given biome. + fill-biome: func(biome: biome); + } + + /// Resolves a block name and optional properties to a block state ID. + /// Returns none if the block name is unknown. + resolve-block-state: func(name: string, properties: list>) -> option; + + /// A block's registry name and its property key-value pairs for a state ID. + record block-state-info { + name: string, + properties: list>, + } + + /// Resolves a block state ID back to its block name and properties. + /// Returns none if the state ID is unknown. + block-state-to-info: func(state-id: u16) -> option; + + /// Gets a block type by its numerical block ID. + get-block-by-id: func(id: u16) -> option; + + /// Gets a block type by its namespaced name (e.g., "minecraft:stone" or "stone"). + get-block-by-name: func(name: string) -> option; + + /// Gets all registered blocks. + get-all-blocks: func() -> list; + + /// Gets the names of all registered blocks. + get-all-block-names: func() -> list; + + /// Gets the total number of registered block types. + get-block-count: func() -> u32; + + /// Gets the total number of registered block states. + get-block-state-count: func() -> u32; + + /// Gets all valid block states for a block type. + get-states-for-block: func(block: block) -> list; + + /// Gets all valid block states for a numerical block ID. + get-states-for-block-id: func(block-id: u16) -> list; + + /// Gets all valid state IDs for a numerical block ID. + get-state-ids-for-block-id: func(block-id: u16) -> list; + + /// Gets property key-value pairs for a numerical block state ID. + get-block-properties: func(state-id: u16) -> list>; + + /// Gets the block type associated with a block state ID. + get-block-from-state-id: func(state-id: u16) -> option; + + /// Gets the block type associated with a block state. + get-block-from-state: func(state: block-state) -> block; + + /// Gets the default block state for a block type. + get-default-state-from-block: func(block: block) -> block-state; + + /// Gets the default block state for a numerical block ID. + get-default-state-from-block-id: func(block-id: u16) -> option; + + /// Gets the detailed block state for a numerical block state ID. + get-block-state-by-id: func(state-id: u16) -> option; +}