feat: add example commands

Author: wu-vincent

src/endstone_example/example_plugin.py

@@ -1,4 +1,7 @@
+from endstone.command import Command, CommandSender
 from endstone.plugin import Plugin
+from endstone_example.python_command import PythonCommand, PythonCommandExecutor
+from endstone_example.test_command import TestCommand
 
 
 class ExamplePlugin(Plugin):
@@ -7,6 +10,18 @@ def on_load(self) -> None:
 
     def on_enable(self) -> None:
         self.logger.info("on_enable is called!")
+        # note we pass in PythonCommand instead of PythonCommand() - use a class rather than an instance
+        self.register_command(PythonCommand).executor = PythonCommandExecutor()
+        self.register_command(TestCommand)
 
     def on_disable(self) -> None:
         self.logger.info("on_disable is called!")
+
+    def on_command(self, sender: CommandSender, command: Command, args: list[str]) -> bool:
+        # You can also handle commands here instead of setting an executor in on_enable if you prefer
+        if not args:
+            sender.send_message(f"/{command.name} is executed from Python!")
+        else:
+            sender.send_message(f"/{command.name} is executed from Python with argument {args[0]}!")
+
+        return True

src/endstone_example/python_command.py

@@ -0,0 +1,38 @@
+from endstone.command import Command, CommandSender, CommandExecutor
+
+# Zen of python - https://peps.python.org/pep-0020/
+zen_of_python = """The Zen of Python, by Tim Peters
+
+Beautiful is better than ugly.
+Explicit is better than implicit.
+Simple is better than complex.
+Complex is better than complicated.
+Flat is better than nested.
+Sparse is better than dense.
+Readability counts.
+Special cases aren't special enough to break the rules.
+Although practicality beats purity.
+Errors should never pass silently.
+Unless explicitly silenced.
+In the face of ambiguity, refuse the temptation to guess.
+There should be one-- and preferably only one --obvious way to do it.
+Although that way may not be obvious at first unless you're Dutch.
+Now is better than never.
+Although never is often better than *right* now.
+If the implementation is hard to explain, it's a bad idea.
+If the implementation is easy to explain, it may be a good idea.
+Namespaces are one honking great idea -- let's do more of those!"""
+
+
+class PythonCommand(Command):
+    def __init__(self):
+        Command.__init__(self, "python")
+        self.description = "Zen of python"
+        self.usages = ["/python"]
+        self.aliases = ["py"]
+
+
+class PythonCommandExecutor(CommandExecutor):
+    def on_command(self, sender: CommandSender, command: Command, args: list[str]) -> bool:
+        sender.send_message(zen_of_python)
+        return True

src/endstone_example/test_command.py

@@ -0,0 +1,8 @@
+from endstone.command import Command
+
+
+class TestCommand(Command):
+    def __init__(self):
+        Command.__init__(self, "test")
+        self.description = "This is a test command from python"
+        self.usages = ["/test", "/test [value: int]"]