pumpkin-api-py 0.1.0__py3-none-any.whl

pumpkin_api/wit/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<string>),
+        invalid-requirement,
+        permission-denied,
+        command-failed(text-component),
+    }
+
+    resource command-node {
+        literal: static func(name: string) -> command-node;
+        argument: static func(name: string, %type: argument-type) -> command-node;
+        then: func(node: command-node);
+        execute-with-handler-id: func(handler-id: u32);
+        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<text-component>,
+    }
+
+    record command-suggestions {
+        start: u32,
+        length: u32,
+        values: list<command-suggestion>,
+    }
+
+    variant argument-type {
+        %bool,
+        float(tuple<option<f32>, option<f32>>),
+        double(tuple<option<f64>, option<f64>>),
+        integer(tuple<option<s32>, option<s32>>),
+        long(tuple<option<s64>, option<s64>>),
+        %string(string-type),
+        entities,
+        entity,
+        players,
+        game-profile,
+        block-pos,
+        column-pos,
+        position3d,
+        position2d,
+        block-state,
+        block-predicate,
+        item,
+        item-predicate,
+        color,
+        component,
+        style,
+        message,
+        nbt-compound-tag,
+        nbt-tag,
+        nbt-path,
+        objective,
+        objective-criteria,
+        operation,
+        particle,
+        angle,
+        rotation,
+        scoreboard-slot,
+        score-holder(bool),
+        swizzle,
+        team,
+        item-slot,
+        resource-location,
+        mob-effect,
+        function,
+        entity-anchor,
+        int-range,
+        float-range,
+        dimension,
+        gamemode,
+        difficulty,
+        time(option<s32>),
+        %resource(string),
+        resource-or-tag(string),
+        resource-or-tag-key(string),
+        resource-key(string),
+        template-mirror,
+        template-rotation,
+        uuid,
+    }
+
+    record entity-argument {
+        single: bool,
+        players-only: bool,
+    }
+
+    variant command-sender-type {
+        rcon,
+        console,
+        player(player),
+        command-block(tuple<command-block-entity, %world>),
+        dummy,
+    }
+
+    enum permission-level {
+        zero,
+        one,
+        two,
+        three,
+        four,
+    }
+
+    resource command-sender {
+        get-command-sender-type: func() -> command-sender-type;
+        get-name: func() -> string;
+        send-message: func(text: text-component);
+        send-system-message: func(text: text-component);
+        send-error: func(text: text-component);
+        set-success-count: func(count: s32);
+        is-player: func() -> bool;
+        is-console: func() -> bool;
+        as-player: func() -> option<player>;
+        permission-level: func() -> permission-level;
+        has-permission-level: func(level: permission-level) -> bool;
+        has-permission: func(server: borrow<server>, node: string) -> bool;
+        position: func() -> option<position>;
+        %world: func() -> option<%world>;
+        get-locale: func() -> locale;
+        should-receive-feedback: func() -> bool;
+        should-broadcast-console-to-ops: func() -> bool;
+        should-track-output: func() -> bool;
+    }
+
+    enum string-type {
+        single-word,
+        quotable,
+        greedy,
+    }
+
+    enum suggestion-type {
+        ask-server,
+        all-recipes,
+        available-sounds,
+        available-biomes,
+        summonable-entities,
+    }
+
+    variant arg {
+        simple(string),
+        msg(string),
+        %bool(bool),
+        item(string),
+        item-predicate(string),
+        resource-location(string),
+        block(string),
+        block-predicate(string),
+        time(s32),
+        num(result<number, not-in-bounds>),
+        block-pos(block-pos),
+        pos3d(tuple<f64, f64, f64>),
+        pos2d(tuple<f64, f64>),
+        rotation(tuple<f32, bool, f32, bool>),
+        gamemode(game-mode),
+        difficulty(difficulty),
+        players(list<player>),
+        particle(string),
+        text-component(text-component),
+        bossbar-color(bossbar-color),
+        bossbar-style(bossbar-style),
+        sound-category(sound-category),
+        damage-type(string),
+        effect(string),
+        enchantment(string),
+        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<number, number>),
+        upper-bound(tuple<number, number>),
+    }
+
+    resource consumed-args {
+        get-value: func(key: string) -> arg;
+    }
+
+    resource command {
+        /// First name is primary, rest are aliases
+        constructor(names: list<string>, description: string);
+        then: func(node: command-node);
+        execute-with-handler-id: func(handler-id: u32);
+    }
+}

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

pumpkin_api/wit/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<string>,
+        /// 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<marketplace-metadata>;
+    }
+}
+

pumpkin_api/wit/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,
+  }
+}