mcemu 0.1.0__tar.gz

mcemu-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Oğuzhan
+
+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.

mcemu-0.1.0/PKG-INFO

@@ -0,0 +1,42 @@
+Metadata-Version: 2.4
+Name: mcemu
+Version: 0.1.0
+Summary: Minecraft command emulator library
+Author: OguzhanUmutlu
+License: MIT License
+        
+        Copyright (c) 2026 Oğuzhan
+        
+        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.
+        
+Project-URL: Homepage, https://github.com/OguzhanUmutlu/mcemu
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: build>=0.10.0; extra == "dev"
+Requires-Dist: twine>=4.0.0; extra == "dev"
+Dynamic: license-file
+
+# mcemu
+Minecraft command emulator library for PyPI

mcemu-0.1.0/README.md

@@ -0,0 +1,2 @@
+# mcemu
+Minecraft command emulator library for PyPI

mcemu-0.1.0/mcemu/__init__.py

@@ -0,0 +1,4 @@
+from .emulator import Emulator
+from .entity import Entity, Player, World
+
+__all__ = ["Emulator", "Entity", "Player", "World"]

mcemu-0.1.0/mcemu/command_tree/arguments.py

@@ -0,0 +1,176 @@
+class CommandSyntaxError(Exception):
+    pass
+
+
+class ArgumentType:
+    def get_name(self) -> str:
+        return self.__class__.__name__
+
+    def parse(self, tokens, pos: int):
+        raise NotImplementedError()
+
+
+class IntArgument(ArgumentType):
+    def parse(self, tokens, pos: int):
+        if pos >= len(tokens):
+            raise CommandSyntaxError("Expected integer")
+        t = tokens[pos]
+        try:
+            return int(t.value), pos + 1
+        except ValueError:
+            raise CommandSyntaxError(f"Expected integer, got '{t.value}'")
+
+
+class FloatArgument(ArgumentType):
+    def parse(self, tokens, pos: int):
+        if pos >= len(tokens):
+            raise CommandSyntaxError("Expected float")
+        t = tokens[pos]
+        try:
+            return float(t.value), pos + 1
+        except ValueError:
+            raise CommandSyntaxError(f"Expected float, got '{t.value}'")
+
+
+class StringArgument(ArgumentType):
+    def parse(self, tokens, pos: int):
+        if pos >= len(tokens):
+            raise CommandSyntaxError("Expected string")
+        t = tokens[pos]
+        return t.value, pos + 1
+
+
+class GreedyStringArgument(ArgumentType):
+    def parse(self, tokens, pos: int):
+        if pos >= len(tokens):
+            raise CommandSyntaxError("Expected string")
+        val = ""
+        while pos < len(tokens):
+            val += tokens[pos].value + " "
+            pos += 1
+        return val.strip(), pos
+
+
+class PathArgument(ArgumentType):
+    def parse(self, tokens, pos: int):
+        if pos >= len(tokens):
+            raise CommandSyntaxError("Expected path")
+
+        val = ""
+        if tokens[pos].type == "WORD":
+            val += tokens[pos].value
+            pos += 1
+            
+        while pos < len(tokens):
+            t = tokens[pos]
+            if t.value in ("/", "-", "_", ":", ".", "\\"):
+                val += t.value
+                pos += 1
+                if pos < len(tokens) and tokens[pos].type == "WORD":
+                    val += tokens[pos].value
+                    pos += 1
+            else:
+                break
+                
+        if not val:
+            raise CommandSyntaxError("Expected path")
+        return val, pos
+
+
+class TimeArgument(ArgumentType):
+    def parse(self, tokens, pos: int):
+        if pos >= len(tokens):
+            raise CommandSyntaxError("Expected time")
+            
+        t = tokens[pos]
+        val = t.value
+        pos += 1
+        
+        multiplier = 1
+        if val.endswith("t"):
+            val = val[:-1]
+        elif val.endswith("s"):
+            val = val[:-1]
+            multiplier = 20
+        elif val.endswith("d"):
+            val = val[:-1]
+            multiplier = 24000
+            
+        try:
+            return int(val) * multiplier, pos
+        except ValueError:
+            raise CommandSyntaxError(f"Expected time, got '{t.value}'")
+
+
+class WordArgument(ArgumentType):
+    def parse(self, tokens, pos: int):
+        if pos >= len(tokens):
+            raise CommandSyntaxError("Expected word")
+
+        val = tokens[pos].value
+        pos += 1
+
+        while pos < len(tokens):
+            t = tokens[pos]
+            if t.value in (":", "."):
+                val += t.value
+                pos += 1
+                if pos < len(tokens) and tokens[pos].type == "WORD":
+                    val += tokens[pos].value
+                    pos += 1
+            else:
+                break
+        return val, pos
+
+
+class ObjectiveArgument(WordArgument):
+    def get_name(self) -> str:
+        return "objective"
+
+
+class TargetSelectorData:
+    def __init__(self, base: str, arguments: dict = None, is_pseudo: bool = False):
+        self.base = base
+        self.arguments = arguments
+        self.is_pseudo = is_pseudo
+
+
+class PseudoSelectorArgument(ArgumentType):
+    def get_name(self) -> str:
+        return "pseudo_target"
+
+    def parse(self, tokens, pos: int):
+        if pos >= len(tokens):
+            raise CommandSyntaxError("Expected target selector or name")
+
+        t = tokens[pos]
+        if t.value == "@":
+            pos += 1
+            if pos >= len(tokens):
+                raise CommandSyntaxError("Incomplete target selector")
+            base = tokens[pos].value
+            pos += 1
+            args = {}
+            if pos < len(tokens) and tokens[pos].value == "[":
+                pos += 1
+                while pos < len(tokens) and tokens[pos].value != "]":
+                    key_val, pos = WordArgument().parse(tokens, pos)
+                    if pos >= len(tokens) or tokens[pos].value != "=":
+                        raise CommandSyntaxError("Expected '=' in selector")
+                    pos += 1
+                    val, pos = WordArgument().parse(tokens, pos)
+                    args[key_val] = val
+                    if pos < len(tokens) and tokens[pos].value == ",":
+                        pos += 1
+                if pos >= len(tokens) or tokens[pos].value != "]":
+                    raise CommandSyntaxError("Expected ']'")
+                pos += 1
+            return TargetSelectorData(base, args, is_pseudo=False), pos
+        else:
+            val, pos = WordArgument().parse(tokens, pos)
+            return TargetSelectorData(val, None, is_pseudo=True), pos
+
+
+class SelectorArgument(PseudoSelectorArgument):
+    def get_name(self) -> str:
+        return "target"

mcemu-0.1.0/mcemu/command_tree/builder.py

@@ -0,0 +1,10 @@
+from .arguments import ArgumentType
+from .nodes import LiteralNode, ArgumentNode
+
+
+def literal(name: str) -> LiteralNode:
+    return LiteralNode(name)
+
+
+def argument(name: str, arg_type: ArgumentType) -> ArgumentNode:
+    return ArgumentNode(name, arg_type)

mcemu-0.1.0/mcemu/command_tree/dispatcher.py

@@ -0,0 +1,135 @@
+from typing import List, Dict, Any, Tuple
+
+from .arguments import CommandSyntaxError, TargetSelectorData
+from .nodes import CommandNode, LiteralNode, ArgumentNode
+from ..context import ExecutionContext, resolve_target_selector
+from ..tokenizer import Token
+
+
+class ParseContext:
+    def __init__(self, ctx: ExecutionContext):
+        self.ctx = ctx
+        self.arguments: Dict[str, Any] = {}
+        self.executable = None
+        self.modifiers: List[Tuple[Any, Dict[str, Any]]] = []
+
+    def clone(self):
+        new_ctx = ParseContext(self.ctx)
+        new_ctx.arguments = self.arguments.copy()
+        new_ctx.executable = self.executable
+        new_ctx.modifiers = list(self.modifiers)
+        return new_ctx
+
+
+class CommandDispatcher:
+    def __init__(self):
+        self.root = CommandNode()
+
+    def register(self, node: CommandNode):
+        self.root.children[node.get_name()] = node
+
+    def get_valid_paths(self, node: CommandNode) -> List[str]:
+        return [child.get_usage() for child in node.children.values()]
+
+    def parse_node(self, node: CommandNode, tokens: List[Token], pos: int, parse_ctx: ParseContext) -> Tuple[
+        bool, int, ParseContext, CommandNode]:
+
+        if isinstance(node, (LiteralNode, ArgumentNode)):
+            try:
+                val, pos = node.parse(tokens, pos)
+                if isinstance(node, ArgumentNode):
+                    parse_ctx.arguments[node.name] = val
+            except CommandSyntaxError:
+                return False, pos, parse_ctx, node
+
+        if node.executable:
+            parse_ctx.executable = node.executable
+
+        if pos >= len(tokens):
+            if parse_ctx.executable:
+                return True, pos, parse_ctx, node
+            return False, pos, parse_ctx, node
+
+        if node.redirect:
+            if node.modifier:
+                parse_ctx.modifiers.append((node.modifier, parse_ctx.arguments.copy()))
+            return self.parse_node(node.redirect, tokens, pos, parse_ctx)
+
+        best_fail_node = node
+        best_fail_pos = pos
+
+        for child in node.children.values():
+            child_ctx = parse_ctx.clone()
+            success, child_pos, final_ctx, last_node = self.parse_node(child, tokens, pos, child_ctx)
+            if success:
+                return True, child_pos, final_ctx, last_node
+
+            if child_pos > best_fail_pos:
+                best_fail_pos = child_pos
+                best_fail_node = last_node
+
+        return False, best_fail_pos, parse_ctx, best_fail_node
+
+    def dispatch(self, tokens: List[Token], ctx: ExecutionContext) -> int:
+        if not tokens:
+            return 0
+
+        parse_ctx = ParseContext(ctx)
+        best_fail_pos = 0
+        best_fail_node = self.root
+
+        for child in self.root.children.values():
+            child_ctx = parse_ctx.clone()
+            success, pos, final_ctx, last_node = self.parse_node(child, tokens, 0, child_ctx)
+            if success:
+                if pos < len(tokens):
+                    print(f"Error parsing: Trailing data at token {pos} ('{tokens[pos].value}')")
+                    return 0
+                return self.execute(final_ctx)
+
+            if pos > best_fail_pos:
+                best_fail_pos = pos
+                best_fail_node = last_node
+
+        err_token = tokens[best_fail_pos].value if best_fail_pos < len(tokens) else "EOF"
+        paths = self.get_valid_paths(best_fail_node)
+        print(f"Command Error at '{err_token}'. Expected one of: {', '.join(paths)}")
+        return 0
+
+    def _resolve_args(self, args: dict, ctx: ExecutionContext) -> dict:
+        resolved_args = {}
+        for key, val in args.items():
+            if isinstance(val, TargetSelectorData):
+                targets = resolve_target_selector(val, ctx)
+                if not targets and not val.is_pseudo:
+                    print(f"No entity was found for selector {val.base}")
+                resolved_args[key] = targets
+            else:
+                resolved_args[key] = val
+        return resolved_args
+
+    def _run_with_modifiers(self, parse_ctx: ParseContext, ctx: ExecutionContext, mod_idx: int) -> int:
+        if mod_idx >= len(parse_ctx.modifiers):
+            if parse_ctx.executable:
+                resolved_args = self._resolve_args(parse_ctx.arguments, ctx)
+                return parse_ctx.executable(ctx, **resolved_args)
+            return 0
+
+        modifier, args = parse_ctx.modifiers[mod_idx]
+        resolved_args = self._resolve_args(args, ctx)
+
+        contexts = modifier.modify(ctx, resolved_args)
+
+        total_res = 0
+        for sub_ctx in contexts:
+            res = self._run_with_modifiers(parse_ctx, sub_ctx, mod_idx + 1)
+            modifier.on_result(sub_ctx, resolved_args, res)
+            total_res += res
+
+        return total_res
+
+    def execute(self, parse_ctx: ParseContext) -> int:
+        return self._run_with_modifiers(parse_ctx, parse_ctx.ctx, 0)
+
+
+dispatcher = CommandDispatcher()

mcemu-0.1.0/mcemu/command_tree/execute_modifiers.py

@@ -0,0 +1,77 @@
+from typing import List
+
+from .arguments import TargetSelectorData
+from ..context import ExecutionContext
+
+
+class ExecuteModifier:
+    def modify(self, ctx: ExecutionContext, args: dict) -> List[ExecutionContext]:
+        raise NotImplementedError()
+
+    def on_result(self, ctx: ExecutionContext, args: dict, result: int):
+        pass
+
+
+class ExecuteAsModifier(ExecuteModifier):
+    def modify(self, ctx: ExecutionContext, args: dict) -> List[ExecutionContext]:
+        targets = args.get("target", [])
+        contexts = []
+        for t in targets:
+            entity = next((e for e in ctx.world.entities if e.uuid == t or e.name == t), None)
+            if entity:
+                new_ctx = ctx.clone()
+                new_ctx.executor = entity
+                contexts.append(new_ctx)
+        return contexts
+
+
+class ExecuteAtModifier(ExecuteModifier):
+    def modify(self, ctx: ExecutionContext, args: dict) -> List[ExecutionContext]:
+        targets = args.get("target", [])
+        contexts = []
+        for t in targets:
+            entity = next((e for e in ctx.world.entities if e.uuid == t or e.name == t), None)
+            if entity:
+                new_ctx = ctx.clone()
+                new_ctx.position = entity.pos
+                contexts.append(new_ctx)
+        return contexts
+
+
+class ExecuteStoreScoreModifier(ExecuteModifier):
+    def modify(self, ctx: ExecutionContext, args: dict) -> List[ExecutionContext]:
+        return [ctx]
+
+    def on_result(self, ctx: ExecutionContext, args: dict, result: int):
+        targets = args.get("store_target", [])
+        objective = args.get("store_objective", "")
+        for t in targets:
+            ctx.world.set_score(t, objective, int(result))
+
+
+class ExecuteStoreResultModifier(ExecuteModifier):
+    def modify(self, ctx: ExecutionContext, args: dict) -> List[ExecutionContext]:
+        return [ctx]
+
+    def on_result(self, ctx: ExecutionContext, args: dict, result: int):
+        targets = args.get("store_target", [])
+        store_type = args.get("store_type", "entity")
+        path = args.get("store_path", "")
+        multiplier = float(args.get("store_multiplier", 1.0))
+        datatype = args.get("store_datatype", "int")
+
+        from ..commands.data import set_nested_dict
+        if "NBTType" in store_type:
+            store_type = store_type.split(".")[-1].lower()
+
+        scaled_res = result * multiplier
+        if "int" in datatype.lower():
+            scaled_res = int(scaled_res)
+        elif "byte" in datatype.lower():
+            scaled_res = int(scaled_res) & 0xFF
+
+        for t in targets:
+            target_key = f"{store_type}:{t}"
+            if target_key not in ctx.world.nbt_storage:
+                ctx.world.nbt_storage[target_key] = {}
+            set_nested_dict(ctx.world.nbt_storage[target_key], path, scaled_res)

mcemu-0.1.0/mcemu/command_tree/execute_node.py

@@ -0,0 +1,15 @@
+from typing import List, Any, Tuple
+
+from .nodes import CommandNode
+from ..tokenizer import Token
+
+
+class ExecuteNode(CommandNode):
+    def get_name(self) -> str:
+        return "execute"
+
+    def get_usage(self) -> str:
+        return "execute <subcommands> run <command>"
+
+    def parse(self, tokens: List[Token], pos: int) -> Tuple[Any, int]:
+        pass

mcemu-0.1.0/mcemu/command_tree/nodes.py

@@ -0,0 +1,68 @@
+from typing import List, Dict, Callable, Any, Tuple
+
+from .arguments import ArgumentType, CommandSyntaxError
+
+
+class CommandNode:
+    def __init__(self):
+        self.children: Dict[str, "CommandNode"] = {}
+        self.executable: Callable = None
+        self.redirect: "CommandNode" = None
+        self.modifier: Any = None
+
+    def then(self, node: "CommandNode") -> "CommandNode":
+        self.children[node.get_name()] = node
+        return self
+
+    def executes(self, func: Callable) -> "CommandNode":
+        self.executable = func
+        return self
+
+    def forks(self, node: "CommandNode", modifier: Any = None) -> "CommandNode":
+        self.redirect = node
+        self.modifier = modifier
+        return self
+
+    def parse(self, tokens: List[Any], pos: int) -> Tuple[Any, int]:
+        raise NotImplementedError()
+
+    def get_name(self) -> str:
+        raise NotImplementedError()
+
+    def get_usage(self) -> str:
+        raise NotImplementedError()
+
+
+class LiteralNode(CommandNode):
+    def __init__(self, literal: str):
+        super().__init__()
+        self.literal = literal
+
+    def parse(self, tokens: List[Any], pos: int) -> Tuple[Any, int]:
+        if pos >= len(tokens):
+            raise CommandSyntaxError(f"Expected '{self.literal}'")
+        if tokens[pos].value == self.literal:
+            return self.literal, pos + 1
+        raise CommandSyntaxError(f"Expected '{self.literal}', got '{tokens[pos].value}'")
+
+    def get_name(self) -> str:
+        return self.literal
+
+    def get_usage(self) -> str:
+        return self.literal
+
+
+class ArgumentNode(CommandNode):
+    def __init__(self, name: str, arg_type: ArgumentType):
+        super().__init__()
+        self.name = name
+        self.arg_type = arg_type
+
+    def parse(self, tokens: List[Any], pos: int) -> Tuple[Any, int]:
+        return self.arg_type.parse(tokens, pos)
+
+    def get_name(self) -> str:
+        return self.name
+
+    def get_usage(self) -> str:
+        return f"<{self.name}: {self.arg_type.get_name()}>"

mcemu-0.1.0/mcemu/commands/__init__.py

@@ -0,0 +1,13 @@
+from . import data
+from . import execute
+from . import function_cmds
+from . import kill
+from . import schedule
+from . import scoreboard
+from . import summon
+from . import tag
+from . import tick
+from . import tp
+from ..command_tree.dispatcher import dispatcher
+
+__all__ = ["dispatcher"]