minecraft-datapack-language 16.0.19__tar.gz → 16.0.21__tar.gz

{minecraft_datapack_language-16.0.19 → minecraft_datapack_language-16.0.21}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: minecraft-datapack-language
-Version: 16.0.19
+Version: 16.0.21
 Summary: Compile MDL language with explicit scoping into a Minecraft datapack (1.21+ ready). Features variables, control flow, error handling, and VS Code extension.
 Project-URL: Homepage, https://www.mcmdl.com
 Project-URL: Documentation, https://www.mcmdl.com/docs

minecraft_datapack_language-16.0.21/docs/_data/version.yml

@@ -0,0 +1,3 @@
+current: "16.0.20"
+tag: "v16.0.20"
+updated_at: "2025-09-10T06:19:23Z"

{minecraft_datapack_language-16.0.19 → minecraft_datapack_language-16.0.21}/docs/_docs/language-reference.md

@@ -294,7 +294,8 @@ exec utils:helper;                              // Execute from different namesp
 <@s[distance=..5]>                                // Current player within 5 blocks
 
 // Global scope (special case)
-<global>                                           // Maps to @e[type=armor_stand,tag=mdl_server,limit=1]
+<global>                                           // Maps to @e[type=armor_stand,tag=mdl_global,limit=1]
+                                                   // A single invisible armor stand with tag 'mdl_global' is ensured on load
 ```
 
 ## Mathematical Expressions
@@ -1255,6 +1256,13 @@ def _parse_comparison(self) -> Any:
 - `!` negates the entire operand. For comparisons like `!$a<@s>$ > 0`, the comparison is evaluated first, then negated.
 - `!=` is compiled using equality with inversion (`unless score ... = ...`) because Minecraft lacks a direct not-equal comparator.
 
+### Integer-Only Arithmetic and Literal Handling
+
+- Scoreboard arithmetic is integer-only. MDL normalizes literals: `2.0` -> `2`; non-integer literals (e.g., `2.5`) are rejected with a compiler error when used in scoreboard operations.
+- Literal addition/subtraction uses `add`/`remove` and elides `+0`/`-0`.
+- Literal multiplication/division uses `multiply`/`divide` and elides `*1`/`/1`; `*0` sets to 0; `/(-k)` becomes `/|k|` then `*-1`.
+- Mixed expressions lower via temps; operations against other scores use `operation +=, -=, *=, /=`.
+
 ### AST Traversal and Code Generation
 
 The AST is designed to support efficient code generation:

{minecraft_datapack_language-16.0.19 → minecraft_datapack_language-16.0.21}/minecraft_datapack_language/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '16.0.19'
-__version_tuple__ = version_tuple = (16, 0, 19)
+__version__ = version = '16.0.21'
+__version_tuple__ = version_tuple = (16, 0, 21)
 
-__commit_id__ = commit_id = 'gabc769e06'
+__commit_id__ = commit_id = 'g8b5718e95'

{minecraft_datapack_language-16.0.19 → minecraft_datapack_language-16.0.21}/minecraft_datapack_language/mdl_compiler.py

@@ -33,6 +33,8 @@ class MDLCompiler:
         self.declared_variables: List[VariableDeclaration] = []
         # Track any temporary scoreboard variables generated during compilation
         self.temp_variables: Set[str] = set()
+        # Track if global scope is used anywhere
+        self.uses_global_scope: bool = False
         
     def compile(self, ast: Program, source_dir: str = None) -> str:
         """Compile MDL AST into a complete Minecraft datapack."""
@@ -174,6 +176,10 @@ class MDLCompiler:
                 lines.append(self._ensure_macro_prefix(cmd))
         # Done routing temp commands for this function body
         self._temp_sink_stack.pop()
+
+        # If global scope is used anywhere in the program, prepend ensure line here too
+        if self.uses_global_scope:
+            self._insert_ensure_global(lines)
         
         return "\n".join(lines)
 
@@ -302,6 +308,11 @@ class MDLCompiler:
             "# Generated by MDL Compiler",
             ""
         ]
+
+        # Ensure a single global armor stand exists if global scope is used
+        if self.uses_global_scope:
+            lines.extend(self._ensure_global_lines())
+            lines.append("")
         
         # Add scoreboard objective creation for variables
         for var_name, objective in self.variables.items():
@@ -774,6 +785,9 @@ class MDLCompiler:
         else:
             functions_dir = self.output_dir / "data" / self.current_namespace / "functions"
         functions_dir.mkdir(parents=True, exist_ok=True)
+        # Insert ensure global if needed
+        if self.uses_global_scope:
+            self._insert_ensure_global(lines)
         func_file = functions_dir / f"{name}.mcfunction"
         with open(func_file, 'w') as f:
             f.write("\n".join(lines) + "\n")
@@ -789,7 +803,7 @@ class MDLCompiler:
 
         base = f"function {func_call.namespace}:{func_call.name}{suffix}"
         if func_call.scope:
-            return f"execute as {func_call.scope.strip('<>')} run {base}"
+            return f"execute as {self._resolve_scope(func_call.scope)} run {base}"
         return base
     
     def _expression_to_value(self, expression: Any) -> str:
@@ -807,7 +821,7 @@ class MDLCompiler:
             return str(expression.value)
         elif isinstance(expression, VariableSubstitution):
             objective = self.variables.get(expression.name, expression.name)
-            scope = expression.scope.strip("<>")
+            scope = self._resolve_scope(expression.scope)
             return f"score {scope} {objective}"
         elif isinstance(expression, UnaryExpression):
             # Handle logical NOT elsewhere; here support unary minus for arithmetic
@@ -983,7 +997,7 @@ class MDLCompiler:
             # Variable vs literal
             if op_sym and isinstance(left, VariableSubstitution) and isinstance(right, LiteralExpression) and isinstance(right.value, (int, float)):
                 objective = self.variables.get(left.name, left.name)
-                scope = left.scope.strip("<>")
+                scope = self._resolve_scope(left.scope)
                 # Normalize number
                 try:
                     v = float(right.value)
@@ -1025,9 +1039,9 @@ class MDLCompiler:
             # Variable vs variable
             if op_sym and isinstance(left, VariableSubstitution) and isinstance(right, VariableSubstitution):
                 lobj = self.variables.get(left.name, left.name)
-                lscope = left.scope.strip("<>")
+                lscope = self._resolve_scope(left.scope)
                 robj = self.variables.get(right.name, right.name)
-                rscope = right.scope.strip("<>")
+                rscope = self._resolve_scope(right.scope)
                 if op_sym in (">", ">=", "<", "<=", "=="):
                     comp = op_sym if op_sym != "==" else "="
                     return (f"score {lscope} {lobj} {comp} {rscope} {robj}", False)
@@ -1057,6 +1071,39 @@ class MDLCompiler:
         # Fallback: treat as generic condition string
         return (self._expression_to_condition(expression), False)
 
+    def _resolve_scope(self, scope_spec: Optional[str]) -> str:
+        """Resolve MDL scope spec to a Minecraft selector string.
+        - None or missing angle brackets defaults to stripping.
+        - <global> maps to the singleton mdl_global armor stand.
+        """
+        if not scope_spec:
+            return "@s"
+        s = scope_spec.strip()
+        if s == "<global>":
+            self.uses_global_scope = True
+            return "@e[type=armor_stand,tag=mdl_global,limit=1]"
+        if s.startswith("<") and s.endswith(">"):
+            return s[1:-1]
+        # Fallback: already looks like a selector
+        return s
+
+    def _ensure_global_lines(self) -> list:
+        return [
+            "# Ensure global armor stand exists",
+            "execute unless entity @e[type=armor_stand,tag=mdl_global,limit=1] run summon armor_stand ~ ~ ~ {NoGravity:1b,Invulnerable:1b,Invisible:1b,Tags:[\"mdl_global\"]}",
+        ]
+
+    def _insert_ensure_global(self, lines: list):
+        # Insert ensure lines after header/comments at top if not already present
+        ensure = self._ensure_global_lines()[0]
+        if any(ensure in l for l in lines):
+            return
+        # Insert after initial comment block
+        insert_at = 0
+        for i, l in enumerate(lines[:5]):
+            insert_at = i + 1
+        lines[insert_at:insert_at] = self._ensure_global_lines() + [""]
+
     def _compile_boolean_expression(self, expression: Any, out_var: Optional[str] = None) -> str:
         """Compile a logical expression into a temporary boolean scoreboard variable (1 true, 0 false).
         Returns the objective name for the boolean temp variable.
@@ -1137,7 +1184,8 @@ class MDLCompiler:
                     obj = parts[2]
                     self._store_temp_command(f"scoreboard players operation @s {temp_var} = {scope} {obj}")
                 else:
-                    self._store_temp_command(f"scoreboard players set @s {temp_var} {left_value}")
+                    lit = self._normalize_integer_literal_string(str(left_value), ctx="addition left operand")
+                    self._store_temp_command(f"scoreboard players set @s {temp_var} {lit}")
             # Add right value
             if isinstance(expression.right, VariableSubstitution) or (isinstance(right_value, str) and right_value.startswith("score ")):
                 parts = str(right_value).split()
@@ -1145,7 +1193,13 @@ class MDLCompiler:
                 obj = parts[2]
                 self._store_temp_command(f"scoreboard players operation @s {temp_var} += {scope} {obj}")
             else:
-                self._store_temp_command(f"scoreboard players add @s {temp_var} {right_value}")
+                lit = self._normalize_integer_literal_string(str(right_value), ctx="addition right operand")
+                if lit == "0":
+                    pass
+                elif lit.startswith("-"):
+                    self._store_temp_command(f"scoreboard players remove @s {temp_var} {lit[1:]}")
+                else:
+                    self._store_temp_command(f"scoreboard players add @s {temp_var} {lit}")
                 
         elif expression.operator == "MINUS":
             if isinstance(expression.left, BinaryExpression):
@@ -1157,7 +1211,8 @@ class MDLCompiler:
                     obj = parts[2]
                     self._store_temp_command(f"scoreboard players operation @s {temp_var} = {scope} {obj}")
                 else:
-                    self._store_temp_command(f"scoreboard players set @s {temp_var} {left_value}")
+                    lit = self._normalize_integer_literal_string(str(left_value), ctx="subtraction left operand")
+                    self._store_temp_command(f"scoreboard players set @s {temp_var} {lit}")
             # Subtract right value
             if isinstance(expression.right, VariableSubstitution) or (isinstance(right_value, str) and right_value.startswith("score ")):
                 parts = str(right_value).split()
@@ -1165,7 +1220,14 @@ class MDLCompiler:
                 obj = parts[2]
                 self._store_temp_command(f"scoreboard players operation @s {temp_var} -= {scope} {obj}")
             else:
-                self._store_temp_command(f"scoreboard players remove @s {temp_var} {right_value}")
+                lit = self._normalize_integer_literal_string(str(right_value), ctx="subtraction right operand")
+                if lit == "0":
+                    pass
+                elif lit.startswith("-"):
+                    # x - (-k) == x + k
+                    self._store_temp_command(f"scoreboard players add @s {temp_var} {lit[1:]}")
+                else:
+                    self._store_temp_command(f"scoreboard players remove @s {temp_var} {lit}")
                 
         elif expression.operator == "MULTIPLY":
             if isinstance(expression.left, BinaryExpression):
@@ -1185,8 +1247,13 @@ class MDLCompiler:
                 # For literal values, keep explicit multiply command for compatibility
                 if isinstance(expression.right, LiteralExpression):
                     # Normalize number formatting (e.g., 2.0 -> 2)
-                    literal_str = self._expression_to_value(expression.right)
-                    self._store_temp_command(f"scoreboard players multiply @s {temp_var} {literal_str}")
+                    literal_str = self._normalize_integer_literal_string(self._expression_to_value(expression.right), ctx="multiply literal")
+                    if literal_str == "0":
+                        self._store_temp_command(f"scoreboard players set @s {temp_var} 0")
+                    elif literal_str == "1":
+                        pass
+                    else:
+                        self._store_temp_command(f"scoreboard players multiply @s {temp_var} {literal_str}")
                 else:
                     # If right_value is a score reference string, strip the leading 'score '
                     if isinstance(right_value, str) and right_value.startswith("score "):
@@ -1198,7 +1265,17 @@ class MDLCompiler:
                         else:
                             self._store_temp_command(f"scoreboard players operation @s {temp_var} *= {right_value}")
                     else:
-                        self._store_temp_command(f"scoreboard players operation @s {temp_var} *= {right_value}")
+                        # If RHS is a numeric literal string (incl. negatives), use multiply
+                        if self._is_numeric_literal_string(right_value):
+                            lit = self._normalize_integer_literal_string(str(right_value), ctx="multiply literal string")
+                            if lit == "0":
+                                self._store_temp_command(f"scoreboard players set @s {temp_var} 0")
+                            elif lit == "1":
+                                pass
+                            else:
+                                self._store_temp_command(f"scoreboard players multiply @s {temp_var} {lit}")
+                        else:
+                            self._store_temp_command(f"scoreboard players operation @s {temp_var} *= {right_value}")
                 
         elif expression.operator == "DIVIDE":
             if isinstance(expression.left, BinaryExpression):
@@ -1218,8 +1295,17 @@ class MDLCompiler:
                 # For literal values, keep explicit divide command for compatibility
                 if isinstance(expression.right, LiteralExpression):
                     # Normalize number formatting (e.g., 2.0 -> 2)
-                    literal_str = self._expression_to_value(expression.right)
-                    self._store_temp_command(f"scoreboard players divide @s {temp_var} {literal_str}")
+                    lit = self._normalize_integer_literal_string(self._expression_to_value(expression.right), ctx="divide literal")
+                    if lit == "0":
+                        raise MDLCompilerError("Division by zero literal is not allowed", "Use a non-zero integer literal")
+                    if lit == "1":
+                        pass
+                    elif lit.startswith("-"):
+                        abs_lit = lit[1:]
+                        self._store_temp_command(f"scoreboard players divide @s {temp_var} {abs_lit}")
+                        self._store_temp_command(f"scoreboard players multiply @s {temp_var} -1")
+                    else:
+                        self._store_temp_command(f"scoreboard players divide @s {temp_var} {lit}")
                 else:
                     # If right_value is a score reference string, strip the leading 'score '
                     if isinstance(right_value, str) and right_value.startswith("score "):
@@ -1231,7 +1317,21 @@ class MDLCompiler:
                         else:
                             self._store_temp_command(f"scoreboard players operation @s {temp_var} /= {right_value}")
                     else:
-                        self._store_temp_command(f"scoreboard players operation @s {temp_var} /= {right_value}")
+                        # If RHS is a numeric literal string (incl. negatives), use divide
+                        if self._is_numeric_literal_string(right_value):
+                            lit = self._normalize_integer_literal_string(str(right_value), ctx="divide literal string")
+                            if lit == "0":
+                                raise MDLCompilerError("Division by zero literal is not allowed", "Use a non-zero integer literal")
+                            if lit == "1":
+                                pass
+                            elif lit.startswith("-"):
+                                abs_lit = lit[1:]
+                                self._store_temp_command(f"scoreboard players divide @s {temp_var} {abs_lit}")
+                                self._store_temp_command(f"scoreboard players multiply @s {temp_var} -1")
+                            else:
+                                self._store_temp_command(f"scoreboard players divide @s {temp_var} {lit}")
+                        else:
+                            self._store_temp_command(f"scoreboard players operation @s {temp_var} /= {right_value}")
         else:
             # For other operators, just set the value
             self._store_temp_command(f"scoreboard players set @s {temp_var} 0")
@@ -1243,6 +1343,36 @@ class MDLCompiler:
         else:
             # Fallback: do nothing, but keep behavior predictable
             pass
+
+    def _is_numeric_literal_string(self, s: Any) -> bool:
+        """Return True if s is a string representing an integer literal (incl. negatives)."""
+        if not isinstance(s, str):
+            return False
+        try:
+            # Allow floats that are integer-valued like "2.0" by casting then checking is_integer
+            if "." in s:
+                f = float(s)
+                return f.is_integer()
+            int(s)
+            return True
+        except Exception:
+            return False
+
+    def _normalize_integer_literal_string(self, s: str, ctx: str = "") -> str:
+        """Normalize a numeric literal string to an integer string, or raise MDLCompilerError.
+        Accepts negatives and floats that are mathematically integers (e.g., "2.0").
+        """
+        try:
+            f = float(s)
+        except Exception:
+            raise MDLCompilerError(f"Expected integer literal, got '{s}'", f"Invalid numeric literal in {ctx}")
+        if not float(f).is_integer():
+            raise MDLCompilerError(f"Scoreboards are integer-only; got non-integer '{s}'", f"Use integers in {ctx}")
+        n = int(f)
+        # Normalize -0 to 0
+        if n == 0:
+            return "0"
+        return str(n)
     
     def _generate_temp_variable_name(self) -> str:
         """Generate a unique temporary variable name."""

{minecraft_datapack_language-16.0.19 → minecraft_datapack_language-16.0.21}/minecraft_datapack_language.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: minecraft-datapack-language
-Version: 16.0.19
+Version: 16.0.21
 Summary: Compile MDL language with explicit scoping into a Minecraft datapack (1.21+ ready). Features variables, control flow, error handling, and VS Code extension.
 Project-URL: Homepage, https://www.mcmdl.com
 Project-URL: Documentation, https://www.mcmdl.com/docs

{minecraft_datapack_language-16.0.19 → minecraft_datapack_language-16.0.21}/minecraft_datapack_language.egg-info/SOURCES.txt

@@ -374,12 +374,14 @@ temp_output/data/test/function/main.mcfunction
 test_project/complex_test.mdl
 tests/__init__.py
 tests/run_all_tests.py
+tests/test_arithmetic_codegen.py
 tests/test_cli.py
 tests/test_codegen_naming_and_logic.py
 tests/test_compiler_fixes.py
 tests/test_complex_scenarios.py
 tests/test_comprehensive_end_to_end.py
 tests/test_examples.py
+tests/test_global_scope.py
 tests/test_macros.py
 tests/test_python_api.py
 tests/test_python_bindings.py

minecraft_datapack_language-16.0.21/tests/test_arithmetic_codegen.py

@@ -0,0 +1,82 @@
+import os
+import re
+import pytest
+from minecraft_datapack_language.mdl_parser import MDLParser
+from minecraft_datapack_language.mdl_compiler import MDLCompiler
+from minecraft_datapack_language.mdl_errors import MDLCompilerError
+
+def compile_snippet(src: str, outdir: str):
+    parser = MDLParser("test.mdl")
+    program = parser.parse(src)
+    compiler = MDLCompiler(output_dir=outdir)
+    return compiler.compile(program, source_dir=outdir)
+
+def test_add_remove_literal(tmp_path):
+    src = '''
+pack "p" "d" 82;
+namespace "p";
+function p:f {
+    var x<@s> = 1;
+    x<@s> = $x<@s>$ + 5;
+    x<@s> = $x<@s>$ + -3;
+}
+'''
+    out = compile_snippet(src, str(tmp_path))
+    # find function file under either 'functions' or 'function'
+    candidates = [
+        os.path.join(out, "data", "p", "functions", "f.mcfunction"),
+        os.path.join(out, "data", "p", "function", "f.mcfunction"),
+    ]
+    for fn in candidates:
+        if os.path.exists(fn):
+            break
+    else:
+        raise FileNotFoundError("f.mcfunction not found in expected directories")
+    text = open(fn, "r", encoding="utf-8").read()
+    # We compile via temps: expect add/remove on a temp variable, not directly on x
+    # Look for add/remove on any objective used as temp or x
+    assert re.search(r"players add @s (temp_\\d+|x) 5", text) is not None or re.search(r"players add @s .* 5", text) is not None
+    assert re.search(r"players (remove|add) @s (temp_\\d+|x) 3", text) is not None or re.search(r"players (remove|add) @s .* 3", text) is not None
+
+def test_multiply_divide_literal(tmp_path):
+    src = '''
+pack "p" "d" 82;
+namespace "p";
+function p:f {
+    var x<@s> = 2;
+    x<@s> = $x<@s>$ * 3;
+    x<@s> = $x<@s>$ * -1;
+    x<@s> = $x<@s>$ / 2;
+}
+'''
+    out = compile_snippet(src, str(tmp_path))
+    candidates = [
+        os.path.join(out, "data", "p", "functions", "f.mcfunction"),
+        os.path.join(out, "data", "p", "function", "f.mcfunction"),
+    ]
+    for fn in candidates:
+        if os.path.exists(fn):
+            break
+    else:
+        raise FileNotFoundError("f.mcfunction not found in expected directories")
+    text = open(fn, "r", encoding="utf-8").read()
+    assert re.search(r"players multiply @s (temp_\\d+|x) 3", text) is not None or re.search(r"players multiply @s .* 3", text) is not None
+    # Presence of multiply and divide is sufficient; negative-paths are covered elsewhere
+    assert re.search(r"players multiply @s ", text) is not None
+    assert re.search(r"players divide @s (temp_\\d+|x) 2", text) is not None or re.search(r"players divide @s .* 2", text) is not None
+
+def test_divide_by_zero_error(tmp_path):
+    src = '''
+pack "p" "d" 82;
+namespace "p";
+function p:f {
+    var x<@s> = 2;
+    x<@s> = $x<@s>$ / 0;
+}
+'''
+    with pytest.raises(MDLCompilerError) as ei:
+        compile_snippet(src, str(tmp_path))
+    msg = str(ei.value).lower()
+    assert ("divide" in msg) or ("division" in msg) or ("integer" in msg)
+
+

minecraft_datapack_language-16.0.21/tests/test_global_scope.py

@@ -0,0 +1,66 @@
+import os
+import re
+from minecraft_datapack_language.mdl_parser import MDLParser
+from minecraft_datapack_language.mdl_compiler import MDLCompiler
+
+
+def compile_snippet(src: str, outdir: str):
+    parser = MDLParser("test.mdl")
+    program = parser.parse(src)
+    compiler = MDLCompiler(output_dir=outdir)
+    return compiler.compile(program, source_dir=outdir)
+
+
+def find_function_file(out_dir: str, ns: str, name: str):
+    candidates = [
+        os.path.join(out_dir, "data", ns, "functions", f"{name}.mcfunction"),
+        os.path.join(out_dir, "data", ns, "function", f"{name}.mcfunction"),
+    ]
+    for fn in candidates:
+        if os.path.exists(fn):
+            return fn
+    raise FileNotFoundError(f"{name}.mcfunction not found under {candidates}")
+
+
+def test_global_scope_ensure_and_assignment(tmp_path):
+    src = '''
+pack "p" "d" 82;
+namespace "p";
+var num g<global> = 0;
+
+function p:f {
+    g<global> = $g<global>$ + 1;
+    if $g<global>$ > 0 {
+        say "ok";
+    }
+}
+'''
+    out = compile_snippet(src, str(tmp_path))
+    # Load function should contain ensure-global
+    load_fn = find_function_file(out, "p", "load")
+    load_text = open(load_fn, "r", encoding="utf-8").read()
+    assert "execute unless entity @e[type=armor_stand,tag=mdl_global,limit=1] run summon armor_stand" in load_text
+    # Function should also have ensure-global lines at top
+    f_fn = find_function_file(out, "p", "f")
+    f_text = open(f_fn, "r", encoding="utf-8").read()
+    assert "execute unless entity @e[type=armor_stand,tag=mdl_global,limit=1] run summon armor_stand" in f_text
+    # Assignment should target the global selector in its score operations
+    assert "@e[type=armor_stand,tag=mdl_global,limit=1]" in f_text
+    # Condition should use the selector in a score comparison
+    assert re.search(r"score @e\[type=armor_stand,tag=mdl_global,limit=1\] g matches", f_text) or re.search(r"score @e\[type=armor_stand,tag=mdl_global,limit=1\] g >", f_text)
+
+
+def test_function_call_with_global_scope(tmp_path):
+    src = '''
+pack "p" "d" 82;
+namespace "p";
+function p:callee {}
+function p:caller {
+    exec p:callee<global>;
+}
+'''
+    out = compile_snippet(src, str(tmp_path))
+    caller_fn = find_function_file(out, "p", "caller")
+    txt = open(caller_fn, "r", encoding="utf-8").read()
+    assert "execute as @e[type=armor_stand,tag=mdl_global,limit=1] run function p:callee" in txt
+

minecraft_datapack_language-16.0.19/docs/_data/version.yml

@@ -1,3 +0,0 @@
-current: "16.0.18"
-tag: "v16.0.18"
-updated_at: "2025-09-10T05:13:53Z"