minecraft-datapack-language 15.4.23__tar.gz → 15.4.26__tar.gz

{minecraft_datapack_language-15.4.23/minecraft_datapack_language.egg-info → minecraft_datapack_language-15.4.26}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: minecraft-datapack-language
-Version: 15.4.23
+Version: 15.4.26
 Summary: Compile JavaScript-style MDL language or Python API 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.26/data/test/function/main_if_0.mcfunction

@@ -0,0 +1 @@
+tellraw @a [{"text":"Counter is greater than 3"}]

minecraft_datapack_language-15.4.26/data/test/function/main_if_1.mcfunction

@@ -0,0 +1 @@
+tellraw @a [{"text":"Value is greater than 3"}]

minecraft_datapack_language-15.4.26/docs/_data/version.yml

@@ -0,0 +1,3 @@
+current: "15.4.25"
+tag: "v15.4.25"
+updated_at: "2025-09-03T00:35:14Z"

{minecraft_datapack_language-15.4.23 → minecraft_datapack_language-15.4.26}/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.23'
-__version_tuple__ = version_tuple = (15, 4, 23)
+__version__ = version = '15.4.26'
+__version_tuple__ = version_tuple = (15, 4, 26)
 
-__commit_id__ = commit_id = 'g21ed7334d'
+__commit_id__ = commit_id = 'g506d6e0af'

{minecraft_datapack_language-15.4.23 → minecraft_datapack_language-15.4.26}/minecraft_datapack_language/ast_nodes.py

@@ -40,6 +40,7 @@ class VariableDeclaration(ASTNode):
 @dataclass
 class VariableAssignment(ASTNode):
     name: str
+    scope: Optional[str]
     value: Any
 
 

{minecraft_datapack_language-15.4.23 → minecraft_datapack_language-15.4.26}/minecraft_datapack_language/cli_build.py

@@ -176,7 +176,7 @@ def _generate_scoreboard_objectives(ast: Dict[str, Any], output_dir: Path) -> Li
             if 'body' in func:
                 for statement in func['body']:
                     # Look for variable assignments and usage
-                    if statement['type'] in ['variable_assignment', 'explicit_scope_assignment']:
+                    if statement['type'] == 'variable_assignment':
                         if statement['name'] not in seen_variables:
                             variables.append(statement['name'])
                             seen_variables.add(statement['name'])
@@ -280,7 +280,8 @@ def _process_say_command_with_variables(content: str, selector: str, variable_sc
                 var_selector = var_parts[1][:-1]  # Remove trailing >
                 components.append(f'{{"score":{{"name":"{var_selector}","objective":"{base_var}"}}}}')
             else:
-                # Simple variable: $variable$ - use declared scope if available, otherwise default to current selector
+                # Simple variable: $variable$ - determine selector based on declared scope
+                var_selector = "@e[type=armor_stand,tag=mdl_server,limit=1]"  # Default to global
                 if variable_scopes and var_name in variable_scopes:
                     declared_scope = variable_scopes[var_name]
                     if declared_scope == 'global':
@@ -289,8 +290,7 @@ def _process_say_command_with_variables(content: str, selector: str, variable_sc
                         var_selector = declared_scope
                     print(f"DEBUG: Variable {var_name} using declared scope {declared_scope} -> selector {var_selector}")
                 else:
-                    var_selector = selector  # Use current selector (@s)
-                    print(f"DEBUG: Variable {var_name} has no declared scope, using default selector {var_selector}")
+                    print(f"DEBUG: Variable {var_name} has no declared scope, using default global selector")
                 
                 components.append(f'{{"score":{{"name":"{var_selector}","objective":"{var_name}"}}}}')
     
@@ -336,25 +336,16 @@ def _process_statement(statement: Any, namespace: str, function_name: str, state
         var_name = statement['name']
         value = statement['value']
         
-        # For implicit assignments, always default to @s (current entity)
-        # Declared scopes only affect variable substitutions, not assignments
-        var_selector = selector  # Default to current selector (@s)
-        print(f"DEBUG: Variable {var_name} assignment using selector: {var_selector} (implicit scope, ignoring declared scope: {variable_scopes.get(var_name, 'none')})")
-    
-    elif statement['type'] == 'explicit_scope_assignment':
-        var_name = statement['name']
-        value = statement['value']
-        explicit_scope = statement['scope']
+        # Determine the correct selector for this variable based on its declared scope
+        var_selector = selector  # Default to current selector
+        if variable_scopes and var_name in variable_scopes:
+            declared_scope = variable_scopes[var_name]
+            if declared_scope == 'global':
+                var_selector = "@e[type=armor_stand,tag=mdl_server,limit=1]"
+            else:
+                var_selector = declared_scope
+        print(f"DEBUG: Variable {var_name} assignment using selector: {var_selector} (declared scope: {variable_scopes.get(var_name, 'none')})")
         
-        # For explicit scope assignments, use the specified scope
-        if explicit_scope == 'global':
-            var_selector = "@e[type=armor_stand,tag=mdl_server,limit=1]"
-        else:
-            var_selector = explicit_scope
-        print(f"DEBUG: Variable {var_name} assignment using explicit selector: {var_selector}")
-    
-    # Handle assignment value processing for both types
-    if statement['type'] in ['variable_assignment', 'explicit_scope_assignment']:
         # Handle different value types
         if isinstance(value, int):
             commands.append(f"scoreboard players set {var_selector} {var_name} {value}")
@@ -850,22 +841,22 @@ def _ast_to_pack(ast: Dict[str, Any], mdl_files: List[Path]) -> Pack:
                             else:
                                 # Simple function call without scope
                                 function.commands.append(f"function {func_namespace}:{func_name}")
-                        elif statement.get('type') in ['variable_assignment', 'explicit_scope_assignment']:
+                        elif statement.get('type') == 'variable_assignment':
                             # Handle variable assignments
                             var_name = statement['name']
                             value = statement['value']
                             
-                            # Determine selector based on assignment type
-                            if statement.get('type') == 'explicit_scope_assignment':
-                                # Explicit scope assignment - use specified scope
-                                explicit_scope = statement['scope']
-                                if explicit_scope == 'global':
-                                    var_selector = "@e[type=armor_stand,tag=mdl_server,limit=1]"
-                                else:
-                                    var_selector = explicit_scope
-                            else:
-                                # Implicit assignment - always default to @s
-                                var_selector = "@s"
+                            # Determine selector based on variable scope
+                            var_selector = "@s"  # Default
+                            if 'variables' in ast:
+                                for var_decl in ast['variables']:
+                                    if var_decl.get('name') == var_name:
+                                        var_scope = var_decl.get('scope')
+                                        if var_scope == 'global':
+                                            var_selector = "@e[type=armor_stand,tag=mdl_server,limit=1]"
+                                        elif var_scope:
+                                            var_selector = var_scope
+                                        break
                             
                             if hasattr(value, 'value'):
                                 # Simple literal value

{minecraft_datapack_language-15.4.23 → minecraft_datapack_language-15.4.26}/minecraft_datapack_language/mdl_parser_js.py

@@ -316,15 +316,10 @@ class MDLParser:
                     suggestion="Replace 'for' with 'while' and adjust the loop structure"
                 )
             
-            # Check if this is a variable assignment
-            # Pattern 1: identifier = (simple assignment)
+            # Check if this is a variable assignment (identifier followed by =)
             if (self.current + 1 < len(self.tokens) and 
                 self.tokens[self.current + 1].type == TokenType.ASSIGN):
                 return self._parse_variable_assignment()
-            
-            # Pattern 2: identifier<scope> = (explicit scope assignment)
-            elif self._is_explicit_scope_assignment():
-                return self._parse_explicit_scope_assignment()
             else:
                 # Assume it's a command
                 return self._parse_command()
@@ -342,31 +337,29 @@ class MDLParser:
         
         # Check for scope selector after variable name
         scope = None
-        if not self._is_at_end() and self._peek().type == TokenType.SCOPE:
-            self._match(TokenType.SCOPE)  # consume 'scope'
+        if not self._is_at_end() and self._peek().type == TokenType.LANGLE:
+            self._match(TokenType.LANGLE)  # consume '<'
             
-            # Parse scope selector in angle brackets
-            if not self._is_at_end() and self._peek().type == TokenType.LANGLE:
-                self._match(TokenType.LANGLE)  # consume '<'
-                
-                # Parse scope selector content
-                scope_parts = []
-                while not self._is_at_end() and self._peek().type != TokenType.RANGLE:
-                    scope_parts.append(self._peek().value)
-                    self._advance()
-                
-                if self._is_at_end():
-                    raise create_parser_error(
-                        message="Unterminated scope selector",
-                        file_path=self.source_file,
-                        line=self._peek().line,
-                        column=self._peek().column,
-                        line_content=self._peek().value,
-                        suggestion="Add a closing '>' to terminate the scope selector"
-                    )
-                
-                self._match(TokenType.RANGLE)  # consume '>'
-                scope = ''.join(scope_parts)
+            # Parse scope selector content
+            scope_parts = []
+            while not self._is_at_end() and self._peek().type != TokenType.RANGLE:
+                scope_parts.append(self._peek().value)
+                self._advance()
+            
+            if self._is_at_end():
+                raise create_parser_error(
+                    message="Unterminated scope selector",
+                    file_path=self.source_file,
+                    line=self._peek().line,
+                    column=self._peek().column,
+                    line_content=self._peek().value,
+                    suggestion="Add a closing '>' to terminate the scope selector"
+                )
+            
+            self._match(TokenType.RANGLE)  # consume '>'
+            scope = ''.join(scope_parts)
+            # Update the name to include the scope selector
+            name = f"{name}<{scope}>"
         
         self._match(TokenType.ASSIGN)
         
@@ -382,80 +375,40 @@ class MDLParser:
         name_token = self._match(TokenType.IDENTIFIER)
         name = name_token.value
         
-        self._match(TokenType.ASSIGN)
-        
-        # Parse the value (could be a number or expression)
-        value = self._parse_expression()
-        
-        self._match(TokenType.SEMICOLON)
-        
-        return {"type": "variable_assignment", "name": name, "value": value}
-    
-    def _is_explicit_scope_assignment(self) -> bool:
-        """Check if current position is an explicit scope assignment pattern: var<scope> = value"""
-        if self.current >= len(self.tokens):
-            return False
+        # Check for scope selector after variable name
+        scope = None
+        if not self._is_at_end() and self._peek().type == TokenType.LANGLE:
+            self._match(TokenType.LANGLE)  # consume '<'
             
-        # Look for pattern: IDENTIFIER LANGLE ... RANGLE ASSIGN
-        idx = self.current + 1
-        
-        # Must have LANGLE after identifier
-        if idx >= len(self.tokens) or self.tokens[idx].type != TokenType.LANGLE:
-            return False
-        idx += 1
-        
-        # Skip tokens until we find RANGLE
-        while idx < len(self.tokens) and self.tokens[idx].type != TokenType.RANGLE:
-            idx += 1
-        
-        # Must find RANGLE
-        if idx >= len(self.tokens) or self.tokens[idx].type != TokenType.RANGLE:
-            return False
-        idx += 1
-        
-        # Must have ASSIGN after RANGLE
-        if idx >= len(self.tokens) or self.tokens[idx].type != TokenType.ASSIGN:
-            return False
+            # Parse scope selector content
+            scope_parts = []
+            while not self._is_at_end() and self._peek().type != TokenType.RANGLE:
+                scope_parts.append(self._peek().value)
+                self._advance()
             
-        return True
-    
-    def _parse_explicit_scope_assignment(self) -> dict:
-        """Parse variable assignment with explicit scope: var<scope> = value"""
-        # Parse variable name
-        name_token = self._match(TokenType.IDENTIFIER)
-        name = name_token.value
-        
-        # Parse scope: <scope>
-        self._match(TokenType.LANGLE)
-        
-        # Parse scope selector content
-        scope_parts = []
-        while not self._is_at_end() and self._peek().type != TokenType.RANGLE:
-            scope_parts.append(self._peek().value)
-            self._advance()
-        
-        if self._is_at_end():
-            raise create_parser_error(
-                message="Unterminated scope selector in assignment",
-                file_path=self.source_file,
-                line=self._peek().line,
-                column=self._peek().column,
-                line_content=self._peek().value,
-                suggestion="Add a closing '>' to terminate the scope selector"
-            )
-        
-        self._match(TokenType.RANGLE)
-        scope = ''.join(scope_parts)
+            if self._is_at_end():
+                raise create_parser_error(
+                    message="Unterminated scope selector",
+                    file_path=self.source_file,
+                    line=self._peek().line,
+                    column=self._peek().column,
+                    line_content=self._peek().value,
+                    suggestion="Add a closing '>' to terminate the scope selector"
+                )
+            
+            self._match(TokenType.RANGLE)  # consume '>'
+            scope = ''.join(scope_parts)
+            # Update the name to include the scope selector
+            name = f"{name}<{scope}>"
         
-        # Parse assignment
         self._match(TokenType.ASSIGN)
         
-        # Parse the value
+        # Parse the value (could be a number or expression)
         value = self._parse_expression()
         
         self._match(TokenType.SEMICOLON)
         
-        return {"type": "explicit_scope_assignment", "name": name, "scope": scope, "value": value}
+        return {"type": "variable_assignment", "name": name, "scope": scope, "value": value}
     
     def _parse_if_statement(self) -> IfStatement:
         """Parse if statement."""
@@ -756,8 +709,47 @@ class MDLParser:
         """Parse a command."""
         command_parts = []
         while not self._is_at_end() and self._peek().type != TokenType.SEMICOLON:
-            command_parts.append(self._peek().value)
-            self._advance()
+            current_token = self._peek()
+            
+            # Check if this is an identifier that might be followed by a scope selector
+            if current_token.type == TokenType.IDENTIFIER:
+                identifier_name = current_token.value
+                command_parts.append(identifier_name)
+                self._advance()  # consume the identifier
+                
+                # Look ahead to see if there's a scope selector
+                if not self._is_at_end() and self._peek().type == TokenType.LANGLE:
+                    # This is a scoped variable - parse the scope selector
+                    self._match(TokenType.LANGLE)  # consume '<'
+                    
+                    # Parse scope selector content
+                    scope_parts = []
+                    while not self._is_at_end() and self._peek().type != TokenType.RANGLE:
+                        scope_parts.append(self._peek().value)
+                        self._advance()
+                    
+                    if self._is_at_end():
+                        raise create_parser_error(
+                            message="Unterminated scope selector in command",
+                            file_path=self.source_file,
+                            line=self._peek().line,
+                            column=self._peek().column,
+                            line_content=self._peek().value,
+                            suggestion="Add a closing '>' to terminate the scope selector"
+                        )
+                    
+                    self._match(TokenType.RANGLE)  # consume '>'
+                    scope_selector = ''.join(scope_parts)
+                    
+                    # Add the scope selector to the command parts
+                    command_parts.append(f"<{scope_selector}>")
+                else:
+                    # No scope selector, continue with next token
+                    continue
+            else:
+                # Regular token, just add it
+                command_parts.append(current_token.value)
+                self._advance()
         
         if self._is_at_end():
             raise create_parser_error(
@@ -907,9 +899,10 @@ class MDLParser:
             identifier_name = token.value
             self._advance()  # consume the identifier
             
-            # Check for explicit scope syntax: identifier<scope>
+            # Check if this identifier is followed by a scope selector
             if not self._is_at_end() and self._peek().type == TokenType.LANGLE:
-                self._advance()  # consume <
+                # This is a scoped variable - parse the scope selector
+                self._match(TokenType.LANGLE)  # consume '<'
                 
                 # Parse scope selector content
                 scope_parts = []
@@ -927,21 +920,12 @@ class MDLParser:
                         suggestion="Add a closing '>' to terminate the scope selector"
                     )
                 
-                self._advance()  # consume >
+                self._match(TokenType.RANGLE)  # consume '>'
                 scope_selector = ''.join(scope_parts)
                 
-                # Return variable expression with explicit scope encoded in name
-                return VariableExpression(f"{identifier_name}<{scope_selector}>")
-            
-            # Check if the identifier contains a scope selector (legacy single-token format)
-            elif '<' in identifier_name and identifier_name.endswith('>'):
-                # Extract variable name and scope selector
-                parts = identifier_name.split('<', 1)
-                if len(parts) == 2:
-                    var_name = parts[0]
-                    scope_selector = parts[1][:-1]  # Remove the closing >
-                    # For variable expressions in assignments, keep the full scoped name
-                    return VariableExpression(identifier_name)
+                # Create a scoped variable expression
+                full_name = f"{identifier_name}<{scope_selector}>"
+                return VariableExpression(full_name)
             
             # Regular variable expression without scope
             return VariableExpression(identifier_name)

{minecraft_datapack_language-15.4.23 → minecraft_datapack_language-15.4.26/minecraft_datapack_language.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: minecraft-datapack-language
-Version: 15.4.23
+Version: 15.4.26
 Summary: Compile JavaScript-style MDL language or Python API 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.23 → minecraft_datapack_language-15.4.26}/minecraft_datapack_language.egg-info/SOURCES.txt

@@ -12,11 +12,15 @@ dist_final.zip
 dist_test.zip
 pyproject.toml
 test_all_registry.mdl
+test_final_explicit_output.zip
 test_final_output.zip
+test_output.zip
+test_output_complex.zip
 test_output_scope.zip
 test_scoped_output.zip
 test_scoped_output2.zip
 test_scoped_output_final.zip
+test_scoped_variables.mdl
 test_single.zip
 test_single_debug.zip
 test_single_debug2.zip
@@ -112,7 +116,6 @@ data/test/function/main_else_1.mcfunction
 data/test/function/main_else_5.mcfunction
 data/test/function/main_if_0.mcfunction
 data/test/function/main_if_1.mcfunction
-data/test/function/main_if_2.mcfunction
 data/test/function/main_if_5.mcfunction
 data/test/function/main_while_0.mcfunction
 data/test/function/main_while_1.mcfunction
@@ -1267,6 +1270,12 @@ test_examples/test_output_while_loops_fixed/data/while_loops/function/load.mcfun
 test_examples/test_output_while_loops_fixed/data/while_loops/function/main.mcfunction
 test_examples/test_output_while_loops_fixed/data/while_loops/function/test_countdown_while_1.mcfunction
 test_examples/test_output_while_loops_fixed/data/while_loops/function/test_main_while_2.mcfunction
+test_output/pack.mcmeta
+test_output/data/minecraft/tags/function/load.json
+test_output/data/scoped_variables_test/function/load.mcfunction
+test_output_complex/pack.mcmeta
+test_output_complex/data/minecraft/tags/function/load.json
+test_output_complex/data/scoped_variables_test/function/load.mcfunction
 test_project/README.md
 test_project/main.mdl
 test_single/pack.mcmeta

minecraft_datapack_language-15.4.26/test_output/data/minecraft/tags/function/load.json

@@ -0,0 +1,6 @@
+{
+  "values": [
+    "scoped_variables_test:load",
+    "Scoped Variables Test:load"
+  ]
+}

minecraft_datapack_language-15.4.26/test_output/data/scoped_variables_test/function/load.mcfunction

@@ -0,0 +1,2 @@
+execute unless entity @e[type=armor_stand,tag=mdl_server,limit=1] run summon armor_stand ~ 320 ~ {Tags:["mdl_server"],Invisible:1b,Marker:1b,NoGravity:1b,Invulnerable:1b}
+scoreboard objectives add player_score<@s> dummy

minecraft_datapack_language-15.4.26/test_output/pack.mcmeta

@@ -0,0 +1,6 @@
+{
+  "pack": {
+    "pack_format": 82,
+    "description": "A test pack for scoped variables"
+  }
+}

minecraft_datapack_language-15.4.26/test_output_complex/data/minecraft/tags/function/load.json

@@ -0,0 +1,6 @@
+{
+  "values": [
+    "scoped_variables_test:load",
+    "Scoped Variables Test:load"
+  ]
+}

minecraft_datapack_language-15.4.26/test_output_complex/data/scoped_variables_test/function/load.mcfunction

@@ -0,0 +1,4 @@
+execute unless entity @e[type=armor_stand,tag=mdl_server,limit=1] run summon armor_stand ~ 320 ~ {Tags:["mdl_server"],Invisible:1b,Marker:1b,NoGravity:1b,Invulnerable:1b}
+scoreboard objectives add player_score<@s> dummy
+scoreboard objectives add global_counter<@a> dummy
+scoreboard objectives add team_score<@p[team=red]> dummy

minecraft_datapack_language-15.4.26/test_output_complex/pack.mcmeta

@@ -0,0 +1,6 @@
+{
+  "pack": {
+    "pack_format": 82,
+    "description": "A test pack for scoped variables"
+  }
+}

minecraft_datapack_language-15.4.26/test_scoped_variables.mdl

@@ -0,0 +1,15 @@
+// Test file for scoped variables
+pack "Scoped Variables Test" "A test pack for scoped variables" 15;
+
+// Test variable declarations with scope selectors
+var num player_score<@s> = 0;
+var num global_counter<@a> = 100;
+var num team_score<@p[team=red]> = 50;
+
+// Test variable assignments with scope selectors
+player_score<@s> = player_score<@s> + 1;
+global_counter<@a> = global_counter<@a> - 5;
+team_score<@p[team=red]> = team_score<@p[team=red]> * 2;
+
+// Test complex expressions with scoped variables
+player_score<@s> = (player_score<@s> + global_counter<@a>) / 2;

{minecraft_datapack_language-15.4.23 → minecraft_datapack_language-15.4.26}/tests/test_basic.py

@@ -52,7 +52,7 @@ class TestBasicLexer(unittest.TestCase):
         # Check for string content (may be in different format)
         # The lexer might tokenize this as a single command token
         token_values = [t.value for t in tokens]
-        self.assertIn('"Hello, World!"', token_values)
+        self.assertIn('say "Hello, World!";', token_values)
 
 
 class TestBasicParser(unittest.TestCase):

{minecraft_datapack_language-15.4.23 → minecraft_datapack_language-15.4.26}/tests/test_comprehensive.py

@@ -50,7 +50,7 @@ class TestMDLLexer(unittest.TestCase):
         # The lexer processes say commands as SAY tokens, not STRING tokens
         say_tokens = [t for t in tokens if t.type == TokenType.SAY]
         self.assertEqual(len(say_tokens), 1)
-        self.assertIn('Hello, World!', say_tokens[0].value)
+        self.assertIn('say "Hello, World!";', say_tokens[0].value)
     
     def test_raw_blocks(self):
         """Test raw block tokenization"""