minecraft-datapack-language 15.4.32__py3-none-any.whl → 15.4.34__py3-none-any.whl

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 = None

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/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.dist-info → minecraft_datapack_language-15.4.34.dist-info}/METADATA

@@ -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.dist-info → minecraft_datapack_language-15.4.34.dist-info}/RECORD

@@ -1,17 +1,17 @@
 minecraft_datapack_language/__init__.py,sha256=YoTmZWZVH6POAVYMvOTEBKdC-cxQsWi2VomSWZDgYFw,1158
-minecraft_datapack_language/_version.py,sha256=42aiYhTCVtqfiLB0RL_MLmflGwWJl3Iw48JjY1hYnoc,708
+minecraft_datapack_language/_version.py,sha256=AX5FvjEPvDBWIH6kE1FoeWiGRzaIAu7H64ji0BuRH1s,708
 minecraft_datapack_language/ast_nodes.py,sha256=nbWrRz137MGMRpmnq8QkXNzrtlaCgyPEknytbkrS_M8,3899
-minecraft_datapack_language/cli.py,sha256=dy1KBDULHpaHYYzNfL42EuhOAB5_GTfSVt7_bMImSno,9000
+minecraft_datapack_language/cli.py,sha256=-TMAL1HCCtwf0aG46x88MVBsYUswPRCVhy854li7X9c,9780
 minecraft_datapack_language/dir_map.py,sha256=HmxFkuvWGkzHF8o_GFb4BpuMCRc6QMw8UbmcAI8JVdY,1788
-minecraft_datapack_language/mdl_compiler.py,sha256=SbyguTUwOalz75hQNhGNW-TbcAbxv2LGfGW0EtYT0Ys,30605
+minecraft_datapack_language/mdl_compiler.py,sha256=9wNQRZizlXqdIJcG5TQPtmAULz77hwCaPoXN9bvUo9o,35310
 minecraft_datapack_language/mdl_errors.py,sha256=r0Gu3KhoX1YLPAVW_iO7Q_fPgaf_Dv9tOGSOdKNSzmw,16114
 minecraft_datapack_language/mdl_lexer.py,sha256=CjbEUpuuF4eU_ucA_WIhw6wSMcHGk2BchtQ0bLAGvwg,22033
 minecraft_datapack_language/mdl_linter.py,sha256=z85xoAglENurCh30bR7kEHZ_JeMxcYaLDcGNRAl-RAI,17253
 minecraft_datapack_language/mdl_parser.py,sha256=aQPKcmATM9BOMzO7vCXmMdxU1qjOJNLCSAKJopu5h3g,23429
 minecraft_datapack_language/utils.py,sha256=Aq0HAGlXqj9BUTEjaEilpvzEW0EtZYYMMwOqG9db6dE,684
-minecraft_datapack_language-15.4.32.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-minecraft_datapack_language-15.4.32.dist-info/METADATA,sha256=kzWvTqvwdSuw7UDKCyFkCF-VJMBt-wUCtJ0XVJduNHA,8360
-minecraft_datapack_language-15.4.32.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-minecraft_datapack_language-15.4.32.dist-info/entry_points.txt,sha256=c6vjBeCiyQflvPHBRyBk2nJCSfYt3Oc7Sc9V87ySi_U,108
-minecraft_datapack_language-15.4.32.dist-info/top_level.txt,sha256=ADtFI476tbKLLxEAA-aJQAfg53MA3k_DOb0KTFiggfw,28
-minecraft_datapack_language-15.4.32.dist-info/RECORD,,
+minecraft_datapack_language-15.4.34.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+minecraft_datapack_language-15.4.34.dist-info/METADATA,sha256=A8QcpemF22cVUa-5UYxStXPZiN62FDyXEOSdGET0ffU,8360
+minecraft_datapack_language-15.4.34.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+minecraft_datapack_language-15.4.34.dist-info/entry_points.txt,sha256=c6vjBeCiyQflvPHBRyBk2nJCSfYt3Oc7Sc9V87ySi_U,108
+minecraft_datapack_language-15.4.34.dist-info/top_level.txt,sha256=ADtFI476tbKLLxEAA-aJQAfg53MA3k_DOb0KTFiggfw,28
+minecraft_datapack_language-15.4.34.dist-info/RECORD,,