minecraft-datapack-language 15.4.32__tar.gz → 15.4.34__tar.gz

minecraft_datapack_language-15.4.34/.github/workflows/ci.yml

@@ -0,0 +1,79 @@
+name: CI
+
+on:
+  push:
+    branches: [ "**" ]
+  pull_request:
+  workflow_dispatch:
+
+defaults:
+  run:
+    shell: bash
+
+jobs:
+  build-test:
+    name: build & test (${{ matrix.os }} / py${{ matrix.python-version }})
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, macos-latest, windows-latest]
+        python-version: ["3.10", "3.11", "3.12"]
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Setup Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Upgrade pip & install build deps
+        run: |
+          python -m pip install --upgrade pip
+          python -m pip install build
+
+      - name: Install package (editable)
+        run: |
+          python -m pip install -e .[dev]
+
+      - name: Build sdist & wheel
+        run: |
+          python -m build
+
+      - name: Run consolidated test runner
+        run: |
+          echo "Running consolidated test runner..."
+          python tests/run_all_tests.py
+
+      - name: Upload dist artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: dist-${{ matrix.os }}-py${{ matrix.python-version }}
+          path: dist/*
+          if-no-files-found: error
+
+  comprehensive-tests:
+    name: comprehensive tests
+    runs-on: ubuntu-latest
+    needs: build-test
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Setup Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+
+      - name: Install package (editable)
+        run: |
+          python -m pip install --upgrade pip
+          python -m pip install -e .[dev]
+
+      - name: Run consolidated test runner
+        run: |
+          echo "Running consolidated test runner..."
+          python tests/run_all_tests.py

{minecraft_datapack_language-15.4.32/minecraft_datapack_language.egg-info → minecraft_datapack_language-15.4.34}/PKG-INFO

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

@@ -0,0 +1,3 @@
+current: "15.4.33"
+tag: "v15.4.33"
+updated_at: "2025-09-04T04:55:51Z"

{minecraft_datapack_language-15.4.32 → minecraft_datapack_language-15.4.34}/docs/_docs/language-reference.md

@@ -116,8 +116,8 @@ function game:start_game {
     player_health<@s> = 20;
 }
 
-// Function with scope parameter
-function game:reset_player<@s> {
+// Function declaration (no scope on definition)
+function game:reset_player {
     player_score<@s> = 0;
     player_health<@s> = 20;
 }
@@ -330,7 +330,7 @@ tag advancement "first_sword" "advancements/first_sword.json";
 var num global_counter<@a> = 0;
 var num player_counter<@s> = 0;
 
-function "increment"<@s> {
+function "increment" {
     global_counter<@a> = $global_counter<@a>$ + 1;
     player_counter<@s> = $player_counter<@s>$ + 1;
     
@@ -341,7 +341,7 @@ function "increment"<@s> {
     say "Player $player_counter<@s>$ just incremented the counter!";
 }
 
-function "reset_player"<@s> {
+function "reset_player" {
     player_counter<@s> = 0;
     tellraw @s {"text":"Counter reset!"};
 }
@@ -364,7 +364,7 @@ var num red_score<@a[team=red]> = 0;
 var num blue_score<@a[team=blue]> = 0;
 var num player_score<@s> = 0;
 
-function "award_points"<@s> {
+function "award_points" {
     player_score<@s> = $player_score<@s>$ + 10;
     
     if $player_score<@s>$ > 100 {
@@ -381,14 +381,14 @@ function "award_points"<@s> {
     tellraw @s {"text":"Your score: ","extra":[{"score":{"name":"@s","objective":"player_score"}}]};
 }
 
-function "show_leaderboard"<@s> {
+function "show_leaderboard" {
     tellraw @s {"text":"=== LEADERBOARD ==="};
     tellraw @s {"text":"Red Team: ","extra":[{"score":{"name":"@s","objective":"red_score"}}]};
     tellraw @s {"text":"Blue Team: ","extra":[{"score":{"name":"@s","objective":"blue_score"}}]};
     tellraw @s {"text":"Your Score: ","extra":[{"score":{"name":"@s","objective":"player_score"}}]};
 }
 
-function "countdown_timer"<@s> {
+function "countdown_timer" {
     var num timer<@s> = 10;
     
     while $timer<@s>$ > 0 {
@@ -418,7 +418,7 @@ var num player_exp<@s> = 0;
 var num global_high_score<@a> = 0;
 var num game_timer<@a> = 0;
 
-function "gain_experience"<@s> {
+function "gain_experience" {
     player_exp<@s> = $player_exp<@s>$ + 10;
     
     if $player_exp<@s>$ >= 100 {
@@ -433,7 +433,7 @@ function "gain_experience"<@s> {
     }
 }
 
-function "update_timer"<@a> {
+function "update_timer" {
     game_timer<@a> = $game_timer<@a>$ + 1;
     
     if $game_timer<@a>$ >= 1200 {
@@ -660,7 +660,7 @@ Tokenized as:
 
 #### **Function with Scope**
 ```
-function game:reset_player<@s> {
+function game:reset_player {
 ```
 Tokenized as:
 1. `FUNCTION` (`function`)
@@ -961,7 +961,7 @@ var num _internal_counter<@s> = 0;
 #### **Function Names with Numbers**
 ```mdl
 // Valid - numbers are allowed in function names
-function game:level_1_complete<@s> {
+function game:level_1_complete {
     player_score<@s> = player_score<@s> + 100;
 }
 ```

{minecraft_datapack_language-15.4.32 → minecraft_datapack_language-15.4.34}/minecraft_datapack_language/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '15.4.32'
-__version_tuple__ = version_tuple = (15, 4, 32)
+__version__ = version = '15.4.34'
+__version_tuple__ = version_tuple = (15, 4, 34)
 
-__commit_id__ = commit_id = 'g9a9b794ac'
+__commit_id__ = commit_id = 'g600f6b0c4'

{minecraft_datapack_language-15.4.32 → minecraft_datapack_language-15.4.34}/minecraft_datapack_language/cli.py

@@ -26,6 +26,8 @@ Examples:
   mdl new my_project                        # Create a new project
         """
     )
+    # Global options
+    parser.add_argument('--version', action='store_true', help='Show version and exit')
     
     subparsers = parser.add_subparsers(dest='command', help='Available commands')
     
@@ -34,6 +36,7 @@ Examples:
     build_parser.add_argument('--mdl', required=True, help='MDL file(s) or directory to build')
     build_parser.add_argument('-o', '--output', required=True, help='Output directory for the datapack')
     build_parser.add_argument('--verbose', action='store_true', help='Show detailed output')
+    build_parser.add_argument('--wrapper', help='Optional wrapper directory name for the datapack output')
     
     # Check command
     check_parser = subparsers.add_parser('check', help='Check MDL files for syntax errors')
@@ -45,9 +48,19 @@ Examples:
     new_parser.add_argument('project_name', help='Name of the new project')
     new_parser.add_argument('--pack-name', help='Custom name for the datapack')
     new_parser.add_argument('--pack-format', type=int, default=82, help='Pack format number (default: 82)')
+    new_parser.add_argument('--output', help='Directory to create the project in (defaults to current directory)')
     
     args = parser.parse_args()
     
+    if args.version and not args.command:
+        # Print version and exit
+        try:
+            from . import __version__
+        except Exception:
+            __version__ = "0.0.0"
+        print(__version__)
+        return 0
+
     if not args.command:
         parser.print_help()
         return 1
@@ -133,6 +146,7 @@ def build_command(args):
             print(f"Compiling to {output_dir}...")
         
         compiler = MDLCompiler()
+        # Note: --wrapper is currently accepted for compatibility but not required by compiler
         output_path = compiler.compile(final_ast, str(output_dir))
         
         print(f"Successfully built datapack: {output_path}")
@@ -193,9 +207,10 @@ def new_command(args):
     project_name = args.project_name
     pack_name = args.pack_name or project_name
     pack_format = args.pack_format
+    base_dir = Path(args.output) if getattr(args, 'output', None) else Path('.')
+    project_dir = base_dir / project_name
     
     # Create project directory
-    project_dir = Path(project_name)
     if project_dir.exists():
         print(f"Error: Project directory '{project_name}' already exists")
         return 1
@@ -213,7 +228,7 @@ var num counter<@s> = 0;
 var num global_timer<@a> = 0;
 
 // Main function
-function {project_name}:main<@s> {{
+function {project_name}:main {{
     say "Hello from {project_name}!";
     
     // Variable example
@@ -228,13 +243,13 @@ function {project_name}:main<@s> {{
     }}
 }}
 
-// Load function
-function {project_name}:load<@s> {{
-    say "Datapack loaded successfully!";
+// Init function (avoid reserved names like 'load' or 'tick')
+function {project_name}:init {{
+    say "Datapack initialized successfully!";
 }}
 
 // Hook to run on load
-on_load {project_name}:load<@s>;
+on_load {project_name}:init;
 '''
     
     with open(mdl_file, 'w', encoding='utf-8') as f:
@@ -281,7 +296,7 @@ For more information, visit: https://www.mcmdl.com
     with open(readme_file, 'w', encoding='utf-8') as f:
         f.write(readme_content)
     
-    print(f"Created new MDL project: {project_name}/")
+    print(f"Created new MDL project: {project_dir}/")
     print(f"  - {mdl_file}")
     print(f"  - {readme_file}")
     print(f"\nNext steps:")

{minecraft_datapack_language-15.4.32 → minecraft_datapack_language-15.4.34}/minecraft_datapack_language/mdl_compiler.py

@@ -16,6 +16,7 @@ from .ast_nodes import (
 )
 from .dir_map import get_dir_map, DirMap
 from .mdl_errors import MDLCompilerError
+from .mdl_lexer import TokenType
 
 
 class MDLCompiler:
@@ -164,15 +165,6 @@ class MDLCompiler:
             for temp_cmd in self.temp_commands:
                 lines.append(temp_cmd)
         
-        # Add any generated functions that were created during compilation
-        if hasattr(self, 'generated_functions') and self.generated_functions:
-            lines.append("")
-            lines.append("# Generated functions:")
-            for func_name, func_lines in self.generated_functions.items():
-                lines.append(f"# {func_name}:")
-                lines.extend(func_lines)
-                lines.append("")
-        
         return "\n".join(lines)
     
     def _compile_hooks(self, hooks: List[HookDeclaration], namespace_dir: Path):
@@ -239,6 +231,12 @@ class MDLCompiler:
         load_file = functions_dir / "load.mcfunction"
         with open(load_file, 'w') as f:
             f.write(load_content)
+        # Ensure minecraft load tag points to namespace:load
+        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"
+        with open(load_tag_file, 'w') as f:
+            json.dump({"values": [f"{self.current_namespace}:load"]}, f, indent=2)
         
         # Create tick function if needed
         tick_hooks = [h for h in hooks if h.hook_type == "on_tick"]
@@ -247,6 +245,10 @@ class MDLCompiler:
             tick_file = functions_dir / "tick.mcfunction"
             with open(tick_file, 'w') as f:
                 f.write(tick_content)
+            # Ensure minecraft tick tag points to namespace:tick
+            tick_tag_file = tags_fn_dir / "tick.json"
+            with open(tick_tag_file, 'w') as f:
+                json.dump({"values": [f"{self.current_namespace}:tick"]}, f, indent=2)
     
     def _generate_load_function(self, hooks: List[HookDeclaration]) -> str:
         """Generate the content of load.mcfunction."""
@@ -380,19 +382,19 @@ class MDLCompiler:
     
     def _if_statement_to_command(self, if_stmt: IfStatement) -> str:
         """Convert if statement to proper Minecraft execute if commands."""
-        condition = self._expression_to_condition(if_stmt.condition)
+        condition, invert_then = self._build_condition(if_stmt.condition)
         lines = []
         
-        # Generate the if condition using execute if
-        if self._is_scoreboard_condition(if_stmt.condition):
-            # For scoreboard conditions, use execute if score
-            lines.append(f"execute if score {condition} run function {self.current_namespace}:{self._generate_if_function_name()}")
+        # Prepare function name for the then branch
+        if_function_name = self._generate_if_function_name()
+        # Generate condition command
+        if invert_then:
+            lines.append(f"execute unless {condition} run function {self.current_namespace}:{if_function_name}")
         else:
-            # For other conditions, use execute if
-            lines.append(f"execute if {condition} run function {self.current_namespace}:{self._generate_if_function_name()}")
+            lines.append(f"execute if {condition} run function {self.current_namespace}:{if_function_name}")
         
-        # Generate the if body function
-        if_body_lines = [f"# Function: {self.current_namespace}:{self._generate_if_function_name()}"]
+        # Generate the if body function content
+        if_body_lines = [f"# Function: {self.current_namespace}:{if_function_name}"]
         for stmt in if_stmt.then_body:
             if isinstance(stmt, VariableAssignment):
                 cmd = self._variable_assignment_to_command(stmt)
@@ -415,18 +417,26 @@ class MDLCompiler:
         # Handle else body if it exists
         if if_stmt.else_body:
             if isinstance(if_stmt.else_body, list) and len(if_stmt.else_body) == 1 and isinstance(if_stmt.else_body[0], IfStatement):
-                # This is an else if - handle it recursively
-                else_if_lines = self._if_statement_to_command(if_stmt.else_body[0])
-                lines.extend(else_if_lines.split('\n'))
+                # Else-if: create an else function wrapper that contains the nested if
+                else_function_name = self._generate_else_function_name()
+                if invert_then:
+                    lines.append(f"execute if {condition} run function {self.current_namespace}:{else_function_name}")
+                else:
+                    lines.append(f"execute unless {condition} run function {self.current_namespace}:{else_function_name}")
+                else_body_lines = [f"# Function: {self.current_namespace}:{else_function_name}"]
+                nested_cmd = self._if_statement_to_command(if_stmt.else_body[0])
+                for nested_line in nested_cmd.split('\n'):
+                    if nested_line:
+                        else_body_lines.append(nested_line)
+                self._store_generated_function(else_function_name, else_body_lines)
             else:
-                # This is a regular else
-                if self._is_scoreboard_condition(if_stmt.condition):
-                    lines.append(f"execute unless score {condition} run function {self.current_namespace}:{self._generate_else_function_name()}")
+                # Regular else: compile its body into its own function
+                else_function_name = self._generate_else_function_name()
+                if invert_then:
+                    lines.append(f"execute if {condition} run function {self.current_namespace}:{else_function_name}")
                 else:
-                    lines.append(f"execute unless {condition} run function {self.current_namespace}:{self._generate_else_function_name()}")
-                
-                # Generate the else body function
-                else_body_lines = [f"# Function: {self.current_namespace}:{self._generate_else_function_name()}"]
+                    lines.append(f"execute unless {condition} run function {self.current_namespace}:{else_function_name}")
+                else_body_lines = [f"# Function: {self.current_namespace}:{else_function_name}"]
                 for stmt in if_stmt.else_body:
                     if isinstance(stmt, VariableAssignment):
                         cmd = self._variable_assignment_to_command(stmt)
@@ -445,12 +455,10 @@ class MDLCompiler:
                     elif isinstance(stmt, FunctionCall):
                         cmd = self._function_call_to_command(stmt)
                         else_body_lines.append(cmd)
-                
-                # Store the else function for later generation
-                self._store_generated_function(self._generate_else_function_name(), else_body_lines)
+                self._store_generated_function(else_function_name, else_body_lines)
         
-        # Store the if function for later generation
-        self._store_generated_function(self._generate_if_function_name(), if_body_lines)
+        # Store the if function as its own file
+        self._store_generated_function(if_function_name, if_body_lines)
         
         return "\n".join(lines)
     
@@ -494,7 +502,7 @@ class MDLCompiler:
         else:
             loop_body_lines.append(f"execute if {condition} run function {self.current_namespace}:{loop_function_name}")
         
-        # Store the loop function for later generation
+        # Store the loop function as its own file
         self._store_generated_function(loop_function_name, loop_body_lines)
         
         return "\n".join(lines)
@@ -529,10 +537,15 @@ class MDLCompiler:
         return f"while_{self.while_counter}"
     
     def _store_generated_function(self, name: str, lines: List[str]):
-        """Store a generated function for later output."""
-        if not hasattr(self, 'generated_functions'):
-            self.generated_functions = {}
-        self.generated_functions[name] = lines
+        """Store a generated function as a separate file under the same namespace."""
+        if self.dir_map:
+            functions_dir = self.output_dir / "data" / self.current_namespace / self.dir_map.function
+        else:
+            functions_dir = self.output_dir / "data" / self.current_namespace / "functions"
+        functions_dir.mkdir(parents=True, exist_ok=True)
+        func_file = functions_dir / f"{name}.mcfunction"
+        with open(func_file, 'w') as f:
+            f.write("\n".join(lines) + "\n")
     
     def _function_call_to_command(self, func_call: FunctionCall) -> str:
         """Convert function call to execute command."""
@@ -544,6 +557,15 @@ class MDLCompiler:
     def _expression_to_value(self, expression: Any) -> str:
         """Convert expression to a value string."""
         if isinstance(expression, LiteralExpression):
+            # Format numbers as integers if possible
+            if isinstance(expression.value, (int, float)):
+                try:
+                    v = float(expression.value)
+                    if v.is_integer():
+                        return str(int(v))
+                    return str(v)
+                except Exception:
+                    return str(expression.value)
             return str(expression.value)
         elif isinstance(expression, VariableSubstitution):
             objective = self.variables.get(expression.name, expression.name)
@@ -560,13 +582,76 @@ class MDLCompiler:
             return str(expression)
     
     def _expression_to_condition(self, expression: Any) -> str:
-        """Convert expression to a condition string."""
+        """Legacy: Convert expression to a naive condition string (internal use)."""
         if isinstance(expression, BinaryExpression):
             left = self._expression_to_value(expression.left)
             right = self._expression_to_value(expression.right)
             return f"{left} {expression.operator} {right}"
         else:
             return self._expression_to_value(expression)
+
+    def _build_condition(self, expression: Any) -> (str, bool):
+        """Build a valid Minecraft execute condition.
+        Returns (condition_string, invert_then) where invert_then True means the THEN branch should use 'unless'.
+        """
+        # Default: generic expression string, no inversion
+        invert_then = False
+        
+        if isinstance(expression, BinaryExpression):
+            left = expression.left
+            right = expression.right
+            op = expression.operator
+            # Variable vs literal
+            if 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("<>")
+                # Normalize number
+                try:
+                    v = float(right.value)
+                except Exception:
+                    v = None
+                if v is not None:
+                    n = int(v) if float(v).is_integer() else v
+                    if op == TokenType.GREATER:
+                        rng = f"{int(n)+1}.." if isinstance(n, int) else f"{v+1}.."
+                        return (f"score {scope} {objective} matches {rng}", False)
+                    if op == TokenType.GREATER_EQUAL:
+                        rng = f"{int(n)}.."
+                        return (f"score {scope} {objective} matches {rng}", False)
+                    if op == TokenType.LESS:
+                        rng = f"..{int(n)-1}"
+                        return (f"score {scope} {objective} matches {rng}", False)
+                    if op == TokenType.LESS_EQUAL:
+                        rng = f"..{int(n)}"
+                        return (f"score {scope} {objective} matches {rng}", False)
+                    if op == TokenType.EQUAL:
+                        rng = f"{int(n)}"
+                        return (f"score {scope} {objective} matches {rng}", False)
+                    if op == TokenType.NOT_EQUAL:
+                        rng = f"{int(n)}"
+                        return (f"score {scope} {objective} matches {rng}", True)
+            # Variable vs variable
+            if isinstance(left, VariableSubstitution) and isinstance(right, VariableSubstitution):
+                lobj = self.variables.get(left.name, left.name)
+                lscope = left.scope.strip("<>")
+                robj = self.variables.get(right.name, right.name)
+                rscope = right.scope.strip("<>")
+                if op in (TokenType.GREATER, TokenType.GREATER_EQUAL, TokenType.LESS, TokenType.LESS_EQUAL, TokenType.EQUAL):
+                    comp_map = {
+                        TokenType.GREATER: ">",
+                        TokenType.GREATER_EQUAL: ">=",
+                        TokenType.LESS: "<",
+                        TokenType.LESS_EQUAL: "<=",
+                        TokenType.EQUAL: "="
+                    }
+                    comp = comp_map[op]
+                    return (f"score {lscope} {lobj} {comp} {rscope} {robj}", False)
+                if op == TokenType.NOT_EQUAL:
+                    # Use equals with inversion
+                    return (f"score {lscope} {lobj} = {rscope} {robj}", True)
+        
+        # Fallback: treat as generic condition string
+        return (self._expression_to_condition(expression), False)
     
     def _compile_expression_to_temp(self, expression: BinaryExpression, temp_var: str):
         """Compile a complex expression to a temporary variable using valid Minecraft commands."""

{minecraft_datapack_language-15.4.32 → minecraft_datapack_language-15.4.34/minecraft_datapack_language.egg-info}/PKG-INFO

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

@@ -339,6 +339,10 @@ scripts/git-bash/test_cli-gitbash.sh
 structures/diamond_sword.json
 structures/test_structure.json
 structures/workshop.json
+temp_output/pack.mcmeta
+temp_output/data/test/function/helper.mcfunction
+temp_output/data/test/function/load.mcfunction
+temp_output/data/test/function/main.mcfunction
 test_project/complex_test.mdl
 tests/__init__.py
 tests/run_all_tests.py

minecraft_datapack_language-15.4.34/temp_output/data/test/function/helper.mcfunction

@@ -0,0 +1,4 @@
+# Function: test:helper
+# Scope: <@s>
+
+tellraw @a {"text":"Helper function!"}

minecraft_datapack_language-15.4.34/temp_output/data/test/function/load.mcfunction

@@ -0,0 +1,3 @@
+# Load function - runs when datapack loads
+# Generated by MDL Compiler
+

minecraft_datapack_language-15.4.34/temp_output/data/test/function/main.mcfunction

@@ -0,0 +1,4 @@
+# Function: test:main
+# Scope: <@s>
+
+execute as @s run function test:helper

minecraft_datapack_language-15.4.34/temp_output/pack.mcmeta

@@ -0,0 +1,6 @@
+{
+  "pack": {
+    "pack_format": 82,
+    "description": "Test pack"
+  }
+}