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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: minecraft-datapack-language
-Version: 15.4.22
+Version: 15.4.23
 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/data/test/function/main_if_0.mcfunction

@@ -0,0 +1 @@
+tellraw @a [{"text":"Player score is high!"}]

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

@@ -0,0 +1 @@
+tellraw @a [{"text":"Steve has a good score!"}]

minecraft_datapack_language-15.4.23/data/test/function/main_if_2.mcfunction

@@ -0,0 +1 @@
+tellraw @a [{"text":"Global counter is high!"}]

minecraft_datapack_language-15.4.23/docs/_data/version.yml

@@ -0,0 +1,3 @@
+current: "15.4.22"
+tag: "v15.4.22"
+updated_at: "2025-09-02T04:22:04Z"

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

{minecraft_datapack_language-15.4.22 → minecraft_datapack_language-15.4.23}/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'] == 'variable_assignment':
+                    if statement['type'] in ['variable_assignment', 'explicit_scope_assignment']:
                         if statement['name'] not in seen_variables:
                             variables.append(statement['name'])
                             seen_variables.add(statement['name'])
@@ -280,8 +280,7 @@ 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$ - determine selector based on declared scope
-                var_selector = "@e[type=armor_stand,tag=mdl_server,limit=1]"  # Default to global
+                # Simple variable: $variable$ - use declared scope if available, otherwise default to current selector
                 if variable_scopes and var_name in variable_scopes:
                     declared_scope = variable_scopes[var_name]
                     if declared_scope == 'global':
@@ -290,7 +289,8 @@ 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:
-                    print(f"DEBUG: Variable {var_name} has no declared scope, using default global selector")
+                    var_selector = selector  # Use current selector (@s)
+                    print(f"DEBUG: Variable {var_name} has no declared scope, using default selector {var_selector}")
                 
                 components.append(f'{{"score":{{"name":"{var_selector}","objective":"{var_name}"}}}}')
     
@@ -336,16 +336,25 @@ def _process_statement(statement: Any, namespace: str, function_name: str, state
         var_name = statement['name']
         value = statement['value']
         
-        # 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 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']
         
+        # 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}")
@@ -841,22 +850,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') == 'variable_assignment':
+                        elif statement.get('type') in ['variable_assignment', 'explicit_scope_assignment']:
                             # Handle variable assignments
                             var_name = statement['name']
                             value = statement['value']
                             
-                            # 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
+                            # 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"
                             
                             if hasattr(value, 'value'):
                                 # Simple literal value

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

@@ -316,10 +316,15 @@ class MDLParser:
                     suggestion="Replace 'for' with 'while' and adjust the loop structure"
                 )
             
-            # Check if this is a variable assignment (identifier followed by =)
+            # Check if this is a variable assignment
+            # Pattern 1: identifier = (simple assignment)
             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()
@@ -386,6 +391,72 @@ class MDLParser:
         
         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
+            
+        # 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
+            
+        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)
+        
+        # Parse assignment
+        self._match(TokenType.ASSIGN)
+        
+        # Parse the value
+        value = self._parse_expression()
+        
+        self._match(TokenType.SEMICOLON)
+        
+        return {"type": "explicit_scope_assignment", "name": name, "scope": scope, "value": value}
+    
     def _parse_if_statement(self) -> IfStatement:
         """Parse if statement."""
         self._match(TokenType.IF)
@@ -836,8 +907,34 @@ class MDLParser:
             identifier_name = token.value
             self._advance()  # consume the identifier
             
-            # Check if the identifier contains a scope selector
-            if '<' in identifier_name and identifier_name.endswith('>'):
+            # Check for explicit scope syntax: identifier<scope>
+            if not self._is_at_end() and self._peek().type == TokenType.LANGLE:
+                self._advance()  # 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 expression",
+                        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._advance()  # 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:

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

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

@@ -112,6 +112,7 @@ 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

{minecraft_datapack_language-15.4.22 → minecraft_datapack_language-15.4.23}/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('say "Hello, World!";', token_values)
+        self.assertIn('"Hello, World!"', token_values)
 
 
 class TestBasicParser(unittest.TestCase):

{minecraft_datapack_language-15.4.22 → minecraft_datapack_language-15.4.23}/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('say "Hello, World!";', say_tokens[0].value)
+        self.assertIn('Hello, World!', say_tokens[0].value)
     
     def test_raw_blocks(self):
         """Test raw block tokenization"""

{minecraft_datapack_language-15.4.22 → minecraft_datapack_language-15.4.23}/tests/test_comprehensive_features.py

@@ -767,6 +767,121 @@ class TestLexerSpecificFeatures(unittest.TestCase):
         self.assertEqual(var_tokens[0].value, 'globalTimer<global>')
 
 
+class TestExplicitScopeFeatures(unittest.TestCase):
+    """Test explicit scope functionality in variable access"""
+    
+    def test_explicit_scope_in_conditions(self):
+        """Test that explicit scopes work correctly in conditions"""
+        code = '''
+        pack "test" "Test explicit scopes" 82;
+        namespace "test";
+        
+        var num playerScore = 0;
+        var num globalCounter scope<global> = 0;
+        
+        function "main" {
+            if "$playerScore<@s>$ > 10" {
+                say "Player score is high!";
+            }
+            
+            if "$playerScore<@p[name=Steve]>$ > 20" {
+                say "Steve has a good score!";
+            }
+            
+            if "$globalCounter<global>$ > 50" {
+                say "Global counter is high!";
+            }
+        }
+        '''
+        
+        # Should parse without errors
+        ast = parse_mdl_js(code)
+        self.assertIsNotNone(ast)
+        
+        # Should contain the functions
+        self.assertIn('functions', ast)
+        self.assertGreater(len(ast['functions']), 0)
+        
+        # Find the main function
+        main_function = None
+        for func in ast['functions']:
+            if func['name'] == 'main':
+                main_function = func
+                break
+        
+        self.assertIsNotNone(main_function)
+        
+        # Check that conditions contain explicit scopes
+        if_statements = [stmt for stmt in main_function['body'] if stmt['type'] == 'if_statement']
+        
+        # Should have 3 if statements
+        self.assertEqual(len(if_statements), 3)
+        
+        # Check explicit scope conditions
+        self.assertEqual(if_statements[0]['condition'], '$playerScore<@s>$ > 10')
+        self.assertEqual(if_statements[1]['condition'], '$playerScore<@p[name=Steve]>$ > 20')
+        self.assertEqual(if_statements[2]['condition'], '$globalCounter<global>$ > 50')
+    
+    def test_explicit_scope_compilation(self):
+        """Test that explicit scopes compile to correct Minecraft commands"""
+        code = '''
+        pack "test" "Test explicit scopes" 82;
+        namespace "test";
+        
+        var num playerScore = 0;
+        var num globalCounter scope<global> = 0;
+        
+        function "main" {
+            if "$playerScore<@s>$ > 10" {
+                say "Player score is high!";
+            }
+            
+            if "$playerScore<@p[name=Steve]>$ > 20" {
+                say "Steve has a good score!";
+            }
+            
+            if "$globalCounter<global>$ > 50" {
+                say "Global counter is high!";
+            }
+        }
+        '''
+        
+        # Should compile without errors
+        with tempfile.TemporaryDirectory() as temp_dir:
+            output_dir = os.path.join(temp_dir, "output")
+            pack = _ast_to_pack(parse_mdl_js(code), output_dir)
+            
+            # Check that pack was created successfully
+            self.assertIsNotNone(pack)
+            
+            # The compilation should succeed - we can't easily test file paths in temp dirs
+            # but the fact that _ast_to_pack succeeded means it compiled correctly
+    
+    def test_explicit_scope_variable_substitution(self):
+        """Test explicit scopes in variable substitution within say commands"""
+        code = '''
+        pack "test" "Test explicit scopes" 82;
+        namespace "test";
+        
+        var num playerScore = 0;
+        
+        function "main" {
+            say "My score: $playerScore<@s>$";
+            say "Steve's score: $playerScore<@p[name=Steve]>$";
+        }
+        '''
+        
+        # Should compile without errors
+        with tempfile.TemporaryDirectory() as temp_dir:
+            output_dir = os.path.join(temp_dir, "output")
+            pack = _ast_to_pack(parse_mdl_js(code), output_dir)
+            
+            # Check that pack was created successfully
+            self.assertIsNotNone(pack)
+            
+            # The compilation should succeed - explicit scopes work correctly
+
+
 def run_comprehensive_feature_tests():
     """Run all comprehensive feature tests"""
     # Create test suite
@@ -786,7 +901,8 @@ def run_comprehensive_feature_tests():
         TestComplexIntegrationFeatures,
         TestCLIFeatures,
         TestErrorHandlingFeatures,
-        TestLexerSpecificFeatures
+        TestLexerSpecificFeatures,
+        TestExplicitScopeFeatures
     ]
     
     for test_class in test_classes:

minecraft_datapack_language-15.4.22/data/test/function/main_if_0.mcfunction

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

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

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

minecraft_datapack_language-15.4.22/docs/_data/version.yml

@@ -1,3 +0,0 @@
-current: "15.4.21"
-tag: "v15.4.21"
-updated_at: "2025-09-02T04:15:44Z"