minecraft-datapack-language 16.0.2__tar.gz → 16.0.4__tar.gz

{minecraft_datapack_language-16.0.2/minecraft_datapack_language.egg-info → minecraft_datapack_language-16.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: minecraft-datapack-language
-Version: 16.0.2
+Version: 16.0.4
 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.4/docs/_data/version.yml

@@ -0,0 +1,3 @@
+current: "16.0.3"
+tag: "v16.0.3"
+updated_at: "2025-09-08T01:25:33Z"

{minecraft_datapack_language-16.0.2 → minecraft_datapack_language-16.0.4}/docs/_docs/language-reference.md

@@ -177,7 +177,28 @@ while $counter<@s>$ > 0 {
 }
 ```
 
-**Note:** All control structures generate proper Minecraft conditional logic using `execute if` commands and recursive function calls for loops. The compiler automatically handles nested structures and generates the appropriate Minecraft datapack commands.
+**Note:** The standard `while` loop uses recursive function calls internally. This is simple and fast but can hit Minecraft's function call depth limit for very long-running loops.
+
+#### Scheduled While Loops
+
+Use `scheduledwhile` to iterate via the scheduler instead of recursion. This avoids recursion limits by running one iteration per game tick and scheduling the next iteration only if the condition remains true.
+
+```mdl
+scheduledwhile $counter<@s>$ > 0 {
+    counter<@s> = $counter<@s>$ - 1;
+    exec game:countdown;
+}
+```
+
+Compilation strategy:
+- Generates a helper function containing the loop body
+- At the end of the helper, emits `execute if <condition> run schedule function <helper> 1t`
+- Entry point schedules the first iteration with `schedule function <helper> 1t`
+- Breakout occurs naturally when the condition becomes false (no re-schedule)
+
+When to use:
+- Prefer `while` for short/medium loops
+- Prefer `scheduledwhile` for long-running loops, per-tick processes, or when avoiding recursion depth limits
 
 ### Hooks
 ```mdl
@@ -521,7 +542,7 @@ This section defines exactly how MDL source code is broken down into tokens. Thi
 
 #### **Keywords** (Reserved Words)
 ```
-pack, namespace, function, var, num, if, else, while, on_load, on_tick, exec, tag
+pack, namespace, function, var, num, if, else, while, scheduledwhile, on_load, on_tick, exec, tag
 ```
 
 #### **Tag Types** (Resource Categories)

{minecraft_datapack_language-16.0.2 → minecraft_datapack_language-16.0.4}/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.2'
-__version_tuple__ = version_tuple = (16, 0, 2)
+__version__ = version = '16.0.4'
+__version_tuple__ = version_tuple = (16, 0, 4)
 
-__commit_id__ = commit_id = 'ge6a944561'
+__commit_id__ = commit_id = 'g07ccaf26c'

{minecraft_datapack_language-16.0.2 → minecraft_datapack_language-16.0.4}/minecraft_datapack_language/ast_nodes.py

@@ -94,6 +94,13 @@ class WhileLoop(ASTNode):
     body: List[ASTNode]
 
 
+@dataclass
+class ScheduledWhileLoop(ASTNode):
+    """Scheduled-while loop that iterates via Minecraft's schedule command each tick."""
+    condition: Any  # Expression
+    body: List[ASTNode]
+
+
 @dataclass
 class HookDeclaration(ASTNode):
     """Hook declaration (on_load, on_tick)."""

{minecraft_datapack_language-16.0.2 → minecraft_datapack_language-16.0.4}/minecraft_datapack_language/mdl_compiler.py

@@ -11,7 +11,7 @@ from typing import Dict, List, Any, Optional
 from .ast_nodes import (
     Program, PackDeclaration, NamespaceDeclaration, TagDeclaration,
     VariableDeclaration, VariableAssignment, VariableSubstitution, FunctionDeclaration,
-    FunctionCall, IfStatement, WhileLoop, HookDeclaration, RawBlock, MacroLine,
+    FunctionCall, IfStatement, WhileLoop, ScheduledWhileLoop, HookDeclaration, RawBlock, MacroLine,
     SayCommand, BinaryExpression, LiteralExpression, ParenthesizedExpression
 )
 from .dir_map import get_dir_map, DirMap
@@ -270,15 +270,8 @@ class MDLCompiler:
         tags_fn_dir = self.output_dir / "data" / "minecraft" / self.dir_map.tags_function
         tags_fn_dir.mkdir(parents=True, exist_ok=True)
         load_tag_file = tags_fn_dir / "load.json"
-        # Always include namespace:load (contains scoreboard initialization), plus any explicit on_load hooks
+        # Always reference namespace:load (which handles scoreboard init and calls on_load hooks internally)
         values = [f"{self.current_namespace}:load"]
-        if has_on_load:
-            # Add explicit on_load hooks as additional entries
-            for hook in hooks:
-                if hook.hook_type == "on_load":
-                    hook_ref = f"{hook.namespace}:{hook.name}"
-                    if hook_ref not in values:  # Avoid duplicates
-                        values.append(hook_ref)
         with open(load_tag_file, 'w') as f:
             json.dump({"values": values}, f, indent=2)
         
@@ -352,6 +345,8 @@ class MDLCompiler:
             return self._if_statement_to_command(statement)
         elif isinstance(statement, WhileLoop):
             return self._while_loop_to_command(statement)
+        elif isinstance(statement, ScheduledWhileLoop):
+            return self._scheduled_while_to_command(statement)
         elif isinstance(statement, FunctionCall):
             return self._function_call_to_command(statement)
         else:
@@ -614,6 +609,62 @@ class MDLCompiler:
         self._store_generated_function(loop_function_name, loop_body_lines)
         
         return "\n".join(lines)
+
+    def _scheduled_while_to_command(self, while_loop: ScheduledWhileLoop) -> str:
+        """Convert scheduledwhile to tick-scheduled loop to avoid recursion limits.
+        Strategy:
+        - Generate a unique loop function that contains the body, then conditionally schedules itself 1t later.
+        - Entry statement schedules the first tick run.
+        - Breakout occurs naturally by not scheduling when condition is false.
+        """
+        loop_function_name = self._generate_while_function_name()
+
+        # Schedule first iteration for next tick
+        lines: List[str] = []
+        lines.append(f"schedule function {self.current_namespace}:{loop_function_name} 1t")
+
+        # Build the loop function body
+        loop_body_lines: List[str] = [f"# Function: {self.current_namespace}:{loop_function_name}"]
+
+        if not hasattr(self, '_temp_sink_stack'):
+            self._temp_sink_stack = []
+        self._temp_sink_stack.append(loop_body_lines)
+        for stmt in while_loop.body:
+            if isinstance(stmt, VariableAssignment):
+                cmd = self._variable_assignment_to_command(stmt)
+                loop_body_lines.append(cmd)
+            elif isinstance(stmt, VariableDeclaration):
+                cmd = self._variable_declaration_to_command(stmt)
+                loop_body_lines.append(cmd)
+            elif isinstance(stmt, SayCommand):
+                cmd = self._say_command_to_command(stmt)
+                loop_body_lines.append(cmd)
+            elif isinstance(stmt, RawBlock):
+                loop_body_lines.append(stmt.content)
+            elif isinstance(stmt, IfStatement):
+                cmd = self._if_statement_to_command(stmt)
+                loop_body_lines.append(cmd)
+            elif isinstance(stmt, WhileLoop):
+                cmd = self._while_loop_to_command(stmt)
+                loop_body_lines.append(cmd)
+            elif isinstance(stmt, ScheduledWhileLoop):
+                cmd = self._scheduled_while_to_command(stmt)
+                loop_body_lines.append(cmd)
+            elif isinstance(stmt, FunctionCall):
+                cmd = self._function_call_to_command(stmt)
+                loop_body_lines.append(cmd)
+        self._temp_sink_stack.pop()
+
+        cond_str, invert_then = self._build_condition(while_loop.condition)
+        if invert_then:
+            # Inverted means schedule unless condition (NOT desired). We want continue-when-true.
+            # cond_str represents equality in inverted case; continue when not(cond) → use unless.
+            loop_body_lines.append(f"execute unless {cond_str} run schedule function {self.current_namespace}:{loop_function_name} 1t")
+        else:
+            loop_body_lines.append(f"execute if {cond_str} run schedule function {self.current_namespace}:{loop_function_name} 1t")
+
+        self._store_generated_function(loop_function_name, loop_body_lines)
+        return "\n".join(lines)
     
     def _is_scoreboard_condition(self, expression: Any) -> bool:
         """Check if an expression is a scoreboard comparison."""

{minecraft_datapack_language-16.0.2 → minecraft_datapack_language-16.0.4}/minecraft_datapack_language/mdl_lexer.py

@@ -33,6 +33,7 @@ class TokenType:
     IF = "IF"
     ELSE = "ELSE"
     WHILE = "WHILE"
+    SCHEDULED_WHILE = "SCHEDULED_WHILE"
     ON_LOAD = "ON_LOAD"
     ON_TICK = "ON_TICK"
     EXEC = "EXEC"
@@ -599,6 +600,7 @@ class MDLLexer:
             'if': TokenType.IF,
             'else': TokenType.ELSE,
             'while': TokenType.WHILE,
+            'scheduledwhile': TokenType.SCHEDULED_WHILE,
             'on_load': TokenType.ON_LOAD,
             'on_tick': TokenType.ON_TICK,
             'exec': TokenType.EXEC,

{minecraft_datapack_language-16.0.2 → minecraft_datapack_language-16.0.4}/minecraft_datapack_language/mdl_parser.py

@@ -9,7 +9,7 @@ from .mdl_errors import MDLParserError
 from .ast_nodes import (
     ASTNode, Program, PackDeclaration, NamespaceDeclaration, TagDeclaration,
     VariableDeclaration, VariableAssignment, VariableSubstitution, FunctionDeclaration,
-    FunctionCall, IfStatement, WhileLoop, HookDeclaration, RawBlock, MacroLine,
+    FunctionCall, IfStatement, WhileLoop, ScheduledWhileLoop, HookDeclaration, RawBlock, MacroLine,
     SayCommand, TellrawCommand, ExecuteCommand, ScoreboardCommand,
     BinaryExpression, UnaryExpression, ParenthesizedExpression, LiteralExpression,
     ScopeSelector
@@ -87,6 +87,8 @@ class MDLParser:
                     statements.append(self._parse_if_statement())
                 elif self._peek().type == TokenType.WHILE:
                     statements.append(self._parse_while_loop())
+                elif self._peek().type == TokenType.SCHEDULED_WHILE:
+                    statements.append(self._parse_scheduled_while_loop())
                 elif self._peek().type == TokenType.DOLLAR and self._peek(1).type == TokenType.EXCLAMATION:
                     statements.append(self._parse_raw_block())
                 elif self._peek().type == TokenType.IDENTIFIER:
@@ -348,6 +350,18 @@ class MDLParser:
         self._expect(TokenType.RBRACE, "Expected '}' to end while body")
         
         return WhileLoop(condition=condition, body=body)
+
+    def _parse_scheduled_while_loop(self) -> ScheduledWhileLoop:
+        """Parse scheduledwhile loop: scheduledwhile condition { body }"""
+        self._expect(TokenType.SCHEDULED_WHILE, "Expected 'scheduledwhile' keyword")
+        
+        condition = self._parse_expression()
+        
+        self._expect(TokenType.LBRACE, "Expected '{' to start while body")
+        body = self._parse_block()
+        self._expect(TokenType.RBRACE, "Expected '}' to end while body")
+        
+        return ScheduledWhileLoop(condition=condition, body=body)
     
     def _parse_hook_declaration(self) -> HookDeclaration:
         """Parse hook declaration: on_load/on_tick namespace:name<scope>;"""
@@ -524,6 +538,8 @@ class MDLParser:
                 statements.append(self._parse_if_statement())
             elif self._peek().type == TokenType.WHILE:
                 statements.append(self._parse_while_loop())
+            elif self._peek().type == TokenType.SCHEDULED_WHILE:
+                statements.append(self._parse_scheduled_while_loop())
             elif self._peek().type == TokenType.EXEC:
                 statements.append(self._parse_function_call())
             elif self._peek().type == TokenType.MACRO_LINE:

{minecraft_datapack_language-16.0.2 → minecraft_datapack_language-16.0.4/minecraft_datapack_language.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: minecraft-datapack-language
-Version: 16.0.2
+Version: 16.0.4
 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.2 → minecraft_datapack_language-16.0.4}/minecraft_datapack_language.egg-info/SOURCES.txt

@@ -381,6 +381,7 @@ tests/test_examples.py
 tests/test_macros.py
 tests/test_python_api.py
 tests/test_python_bindings.py
+tests/test_scheduledwhile.py
 tests/test_user_regression_test1.py
 vscode-extension/README.md
 vscode-extension/language-configuration.json

{minecraft_datapack_language-16.0.2 → minecraft_datapack_language-16.0.4}/tests/test_python_api.py

@@ -249,7 +249,8 @@ class TestPythonAPITags:
             else:
                 tick_content = {"values": []}
             
-            assert "test:init" in load_content["values"]
+            # load.json always references namespace:load; hooks are invoked from load.mcfunction
+            assert "test:load" in load_content["values"]
             # Only assert tick if present
             if tick_content["values"]:
                 assert "test:tick" in tick_content["values"]

minecraft_datapack_language-16.0.4/tests/test_scheduledwhile.py

@@ -0,0 +1,54 @@
+import tempfile
+from pathlib import Path
+
+from minecraft_datapack_language.mdl_parser import MDLParser
+from minecraft_datapack_language.mdl_compiler import MDLCompiler
+
+
+def compile_source(source: str):
+    parser = MDLParser()
+    ast = parser.parse(source)
+    tmpdir = tempfile.TemporaryDirectory()
+    out = Path(tmpdir.name)
+    MDLCompiler().compile(ast, str(out))
+    return out, tmpdir
+
+
+def test_scheduledwhile_generates_schedule_and_helper():
+    src = (
+        'pack "ns" "desc" 82;\n'
+        'namespace "ns";\n'
+        'var num c<@s> = 0;\n'
+        'function ns:loop { scheduledwhile $c<@s>$ < 3 { c<@s> = $c<@s>$ + 1; } }\n'
+    )
+    out, tmp = compile_source(src)
+    func_dir = out / 'data' / 'ns' / 'function'
+
+    # Main function schedules the helper for next tick
+    loop_main = (func_dir / 'loop.mcfunction').read_text()
+    assert 'schedule function ns:loop__while_' in loop_main
+
+    # Helper exists and conditionally reschedules itself
+    helper_files = sorted(p for p in func_dir.glob('loop__while_*.mcfunction'))
+    assert helper_files, 'Expected generated scheduled helper function file'
+    helper = helper_files[0].read_text()
+    assert 'execute if score @s c <' in helper or 'execute if score @s c matches ..2' in helper
+    assert 'schedule function ns:loop__while_' in helper
+
+
+def test_scheduledwhile_breaks_out_without_reschedule_when_false():
+    src = (
+        'pack "ns" "desc" 82;\n'
+        'namespace "ns";\n'
+        'var num c<@s> = 5;\n'
+        'function ns:loop { scheduledwhile $c<@s>$ > 10 { c<@s> = $c<@s>$ + 1; } }\n'
+    )
+    out, tmp = compile_source(src)
+    func_dir = out / 'data' / 'ns' / 'function'
+    helper_files = sorted(p for p in func_dir.glob('loop__while_*.mcfunction'))
+    assert helper_files, 'Expected generated scheduled helper function file'
+    helper = helper_files[0].read_text()
+    # For > 10, continue condition is false initially; helper should still only schedule if condition true
+    # Verify presence of conditional schedule, not unconditional schedule
+    assert 'execute if ' in helper and 'schedule function ns:loop__while_' in helper
+

minecraft_datapack_language-16.0.2/docs/_data/version.yml

@@ -1,3 +0,0 @@
-current: "16.0.1"
-tag: "v16.0.1"
-updated_at: "2025-09-07T06:17:05Z"