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

pumpkin_api/impl.py

@@ -0,0 +1,355 @@
+# pumpkin-api-py: Pumpkin plugin API for Python
+# Copyright (C) 2024 alex
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+import traceback
+from typing import Any, Callable, Dict, Optional, Type, TypedDict
+
+import wit_world
+import wit_world.exports
+from componentize_py_types import Err
+from wit_world.exports import metadata
+from wit_world.imports import command, context, event, scheduler, server, text, world
+
+
+class AiGoal(TypedDict):
+    can_start: Callable[[server.Server, world.Entity], bool]
+    should_continue: Callable[[server.Server, world.Entity], bool]
+    start: Callable[[server.Server, world.Entity], None]
+    tick: Callable[[server.Server, world.Entity], None]
+    stop: Callable[[server.Server, world.Entity], None]
+
+
+_PLUGIN_INSTANCE: Optional["Plugin"] = None
+_EVENT_HANDLERS: Dict[int, Callable[[server.Server, Any], Any]] = {}
+_COMMAND_HANDLERS: Dict[
+    int, Callable[[command.CommandSender, server.Server, command.ConsumedArgs], int]
+] = {}
+_COMMAND_SUGGESTION_HANDLERS: Dict[
+    int,
+    Callable[
+        [command.CommandSender, server.Server, command.SuggestionRequest],
+        command.CommandSuggestions,
+    ],
+] = {}
+_TASK_HANDLERS: Dict[int, Callable[[server.Server], None]] = {}
+_AI_GOALS: Dict[int, AiGoal] = {}
+_GENERATORS: Dict[int, Callable[[world.GenerationPhase, world.ChunkBuffer], None]] = {}
+
+_NEXT_HANDLER_ID: int = 0
+
+
+def _exception_message(exc: Exception) -> str:
+    if hasattr(exc, "value"):
+        value = getattr(exc, "value")
+        if value is not None:
+            return str(value)
+    message = str(exc)
+    if message:
+        return message
+    return "".join(traceback.format_exception_only(type(exc), exc)).strip()
+
+
+def _format_exception(exc: Exception) -> str:
+    details = "".join(
+        traceback.format_exception(type(exc), exc, exc.__traceback__)
+    ).strip()
+    if details:
+        return details
+    return _exception_message(exc)
+
+
+def _get_next_handler_id() -> int:
+    global _NEXT_HANDLER_ID
+    handler_id = _NEXT_HANDLER_ID
+    _NEXT_HANDLER_ID += 1
+    return handler_id
+
+
+class Plugin:
+    def __init__(self):
+        self._pending_events = []
+
+    def metadata(self) -> metadata.PluginMetadata:
+        raise NotImplementedError
+
+    def on_load(self, ctx: context.Context) -> None:
+        for event_type, handler, priority, blocking in self._pending_events:
+            self.register_event(ctx, event_type, handler, priority, blocking)
+
+    def on_unload(self, ctx: context.Context) -> None:
+        pass
+
+    def register_event(
+        self,
+        ctx: context.Context,
+        event_type: event.EventType,
+        handler: Callable[[server.Server, Any], Any],
+        priority=event.EventPriority.NORMAL,
+        blocking=True,
+    ):
+        handler_id = _get_next_handler_id()
+        _EVENT_HANDLERS[handler_id] = handler
+        ctx.register_event(handler_id, event_type, priority, blocking)
+
+    def register_command_handler(
+        self,
+        handler: Callable[
+            [command.CommandSender, server.Server, command.ConsumedArgs], int
+        ],
+    ) -> int:
+        handler_id = _get_next_handler_id()
+        _COMMAND_HANDLERS[handler_id] = handler
+        return handler_id
+
+    def register_command_suggestion_handler(
+        self,
+        handler: Callable[
+            [command.CommandSender, server.Server, command.SuggestionRequest],
+            command.CommandSuggestions,
+        ],
+    ) -> int:
+        handler_id = _get_next_handler_id()
+        _COMMAND_SUGGESTION_HANDLERS[handler_id] = handler
+        return handler_id
+
+    def register_command(
+        self,
+        ctx: context.Context,
+        cmd: command.Command,
+        handler: Callable[
+            [command.CommandSender, server.Server, command.ConsumedArgs], int
+        ],
+        suggestion_handler: Callable[
+            [command.CommandSender, server.Server, command.SuggestionRequest],
+            command.CommandSuggestions,
+        ]
+        | None = None,
+        permission: str = "",
+        extra_nodes: list[command.CommandNode] | None = None,
+    ):
+        suggestion_id = None
+        if suggestion_handler:
+            suggestion_id = self.register_command_suggestion_handler(suggestion_handler)
+        handler_id = self.register_command_handler(handler)
+        cmd.execute_with_handler_id(handler_id)
+        if extra_nodes:
+            for node in extra_nodes:
+                node.execute_with_handler_id(handler_id)
+                if suggestion_id:
+                    node.suggest_with_handler_id(suggestion_id)
+        ctx.register_command(cmd, permission)
+
+    def register_ai_goal(self, goal: AiGoal) -> int:
+        goal_id = _get_next_handler_id()
+        _AI_GOALS[goal_id] = goal
+        return goal_id
+
+    def register_chunk_generator(
+        self, generator: Callable[[world.GenerationPhase, world.ChunkBuffer], None]
+    ) -> int:
+        generator_id = _get_next_handler_id()
+        _GENERATORS[generator_id] = generator
+        return generator_id
+
+    def schedule_delayed_task(
+        self, delay_ticks: int, handler: Callable[[server.Server], None]
+    ) -> int:
+        handler_id = _get_next_handler_id()
+        _TASK_HANDLERS[handler_id] = handler
+        return scheduler.schedule_delayed_task(handler_id, delay_ticks)
+
+    def schedule_repeating_task(
+        self,
+        delay_ticks: int,
+        period_ticks: int,
+        handler: Callable[[server.Server], None],
+    ) -> int:
+        handler_id = _get_next_handler_id()
+        _TASK_HANDLERS[handler_id] = handler
+        return scheduler.schedule_repeating_task(handler_id, delay_ticks, period_ticks)
+
+    def event_handler(
+        self,
+        event_type: event.EventType,
+        priority=event.EventPriority.NORMAL,
+        blocking=True,
+    ):
+        def decorator(func):
+            self._pending_events.append((event_type, func, priority, blocking))
+            return func
+
+        return decorator
+
+    def handle_ipc_message(self, sender: str, message: bytes) -> bytes:
+        raise NotImplementedError
+
+
+def register_plugin(plugin_class: Type[Plugin]):
+    global _PLUGIN_INSTANCE
+    _PLUGIN_INSTANCE = plugin_class()
+
+
+class WitWorldImpl(wit_world.WitWorld):
+    def init_plugin(self) -> None:
+        pass
+
+    def on_load(self, context: context.Context) -> None:
+        if _PLUGIN_INSTANCE:
+            try:
+                # In WIT, on-load returns result<_, string>
+                # componentize-py handles this by expecting None or raising Err
+                _PLUGIN_INSTANCE.on_load(context)
+            except Err as e:
+                raise Err(_exception_message(e))
+            except Exception as e:
+                raise Err(_format_exception(e))
+
+    def on_unload(self, context: context.Context) -> None:
+        if _PLUGIN_INSTANCE:
+            try:
+                _PLUGIN_INSTANCE.on_unload(context)
+            except Err as e:
+                raise Err(_exception_message(e))
+            except Exception as e:
+                raise Err(_format_exception(e))
+
+    def handle_event(
+        self, event_id: int, server: server.Server, event: event.Event
+    ) -> event.Event:
+        if event_id in _EVENT_HANDLERS:
+            # Pass the inner event data to the handler
+            result = _EVENT_HANDLERS[event_id](server, event.value)
+            # If the handler returns something, assume it's the updated event data
+            if result is not None:
+                event.value = result
+        return event
+
+    def handle_command(
+        self,
+        command_id: int,
+        sender: command.CommandSender,
+        server: server.Server,
+        args: command.ConsumedArgs,
+    ) -> int:
+        if command_id in _COMMAND_HANDLERS:
+            try:
+                return _COMMAND_HANDLERS[command_id](sender, server, args)
+            except Exception as e:
+                if hasattr(e, "value") and isinstance(
+                    e.value,
+                    (
+                        command.CommandError_InvalidConsumption,
+                        command.CommandError_InvalidRequirement,
+                        command.CommandError_PermissionDenied,
+                        command.CommandError_CommandFailed,
+                    ),
+                ):
+                    raise e
+                raise Err(
+                    command.CommandError_CommandFailed(
+                        text.TextComponent.text(_format_exception(e))
+                    )
+                )
+
+        raise Err(
+            command.CommandError_CommandFailed(
+                text.TextComponent.text(
+                    f"no handler registered for command id {command_id}"
+                )
+            )
+        )
+
+    def handle_command_suggestion(
+        self,
+        handler_id: int,
+        sender: command.CommandSender,
+        server: server.Server,
+        request: command.SuggestionRequest,
+    ) -> command.CommandSuggestions:
+        if handler_id in _COMMAND_SUGGESTION_HANDLERS:
+            return _COMMAND_SUGGESTION_HANDLERS[handler_id](sender, server, request)
+
+        raise Exception(f"No suggestion handler registered for ID {handler_id}")
+
+    def handle_task(self, handler_id: int, server: server.Server) -> None:
+        if handler_id in _TASK_HANDLERS:
+            _TASK_HANDLERS[handler_id](server)
+
+    def handle_ipc_message(self, sender: str, message: bytes) -> bytes:
+        if _PLUGIN_INSTANCE:
+            try:
+                return _PLUGIN_INSTANCE.handle_ipc_message(sender, message)
+            except Err as e:
+                raise Err(_exception_message(e))
+            except Exception as e:
+                raise Err(_format_exception(e))
+
+        raise Err("Internal error: No plugin instance available?")
+
+    def handle_ai_goal_can_start(
+        self, goal_id: int, server: server.Server, entity: world.Entity
+    ) -> bool:
+        if goal_id in _AI_GOALS:
+            return _AI_GOALS[goal_id]["can_start"](server, entity)
+
+        raise Exception(f"No AI goal registered for ID {goal_id}")
+
+    def handle_ai_goal_should_continue(
+        self, goal_id: int, server: server.Server, entity: world.Entity
+    ) -> bool:
+        if goal_id in _AI_GOALS:
+            return _AI_GOALS[goal_id]["should_continue"](server, entity)
+
+        raise Exception(f"No AI goal registered for ID {goal_id}")
+
+    def handle_ai_goal_start(
+        self, goal_id: int, server: server.Server, entity: world.Entity
+    ) -> None:
+        if goal_id in _AI_GOALS:
+            _AI_GOALS[goal_id]["start"](server, entity)
+            return
+        raise Exception(f"No AI goal registered for ID {goal_id}")
+
+    def handle_ai_goal_tick(
+        self, goal_id: int, server: server.Server, entity: world.Entity
+    ) -> None:
+        if goal_id in _AI_GOALS:
+            _AI_GOALS[goal_id]["tick"](server, entity)
+            return
+        raise Exception(f"No AI goal registered for ID {goal_id}")
+
+    def handle_ai_goal_stop(
+        self, goal_id: int, server: server.Server, entity: world.Entity
+    ) -> None:
+        if goal_id in _AI_GOALS:
+            _AI_GOALS[goal_id]["stop"](server, entity)
+            return
+        raise Exception(f"No AI goal registered for ID {goal_id}")
+
+    def handle_generate_phase(
+        self, generator_id: int, phase: world.GenerationPhase, chunk: world.ChunkBuffer
+    ) -> None:
+        if generator_id in _AI_GOALS:
+            _GENERATORS[generator_id](phase, chunk)
+            return
+        raise Exception(f"No generator registered for ID {generator_id}")
+
+
+class MetadataImpl:
+    def get_metadata(self) -> metadata.PluginMetadata:
+        if _PLUGIN_INSTANCE:
+            return _PLUGIN_INSTANCE.metadata()
+        return metadata.PluginMetadata("unknown", "0.0.0", [], "No metadata", [], [])

pumpkin_api/wit/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<string>,
+        x: f32,
+        y: f32,
+    }
+
+    /// Detailed information about an advancement.
+    record advancement-info {
+        id: string,
+        parent-id: option<string>,
+        criteria: list<string>,
+        display: option<advancement-display>,
+    }
+
+    /// Represents progress of an advancement for a player.
+    record advancement-progress {
+        advancement-id: string,
+        done: bool,
+        awarded-criteria: list<string>,
+        remaining-criteria: list<string>,
+    }
+}

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