minecraft-datapack-language 16.0.16__tar.gz → 16.0.18__tar.gz

{minecraft_datapack_language-16.0.16/minecraft_datapack_language.egg-info → minecraft_datapack_language-16.0.18}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: minecraft-datapack-language
-Version: 16.0.16
+Version: 16.0.18
 Summary: Compile MDL language with explicit scoping into a Minecraft datapack (1.21+ ready). Features variables, control flow, error handling, and VS Code extension.
 Project-URL: Homepage, https://www.mcmdl.com
 Project-URL: Documentation, https://www.mcmdl.com/docs

minecraft_datapack_language-16.0.18/docs/_data/version.yml

@@ -0,0 +1,3 @@
+current: "16.0.17"
+tag: "v16.0.17"
+updated_at: "2025-09-10T05:04:21Z"

{minecraft_datapack_language-16.0.16 → minecraft_datapack_language-16.0.18}/minecraft_datapack_language/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '16.0.16'
-__version_tuple__ = version_tuple = (16, 0, 16)
+__version__ = version = '16.0.18'
+__version_tuple__ = version_tuple = (16, 0, 18)
 
-__commit_id__ = commit_id = 'g0215f8c88'
+__commit_id__ = commit_id = 'gaeacc3d7b'

{minecraft_datapack_language-16.0.16 → minecraft_datapack_language-16.0.18}/minecraft_datapack_language/mdl_compiler.py

@@ -824,7 +824,7 @@ class MDLCompiler:
         Returns one of: '>', '>=', '<', '<=', '==', '!=' or None if unknown.
         """
         # Direct symbol passthrough
-        if op_in in ('>', '>=', '<', '<=', '==', '!='):
+        if op_in in ('>', '>=', '<', '<=', '==', '!=', '&&', '||', '!'):
             return op_in
         # TokenType instances
         try:
@@ -840,6 +840,13 @@ class MDLCompiler:
                 return '=='
             if op_in == TokenType.NOT_EQUAL:
                 return '!='
+            # Logical
+            if getattr(TokenType, 'AND', None) and op_in == TokenType.AND:
+                return '&&'
+            if getattr(TokenType, 'OR', None) and op_in == TokenType.OR:
+                return '||'
+            if getattr(TokenType, 'NOT', None) and op_in == TokenType.NOT:
+                return '!'
         except Exception:
             pass
         # String names from bindings or parser
@@ -857,6 +864,12 @@ class MDLCompiler:
                 return '=='
             if upper == 'NOT_EQUAL' or upper == 'NE':
                 return '!='
+            if upper in ('AND', '&&'):
+                return '&&'
+            if upper in ('OR', '||'):
+                return '||'
+            if upper in ('NOT', '!'):
+                return '!'
         return None
     
     def _expression_to_condition(self, expression: Any) -> str:
@@ -887,10 +900,38 @@ class MDLCompiler:
                 e = e.expression
             return e
 
+        # Handle logical operators by compiling to a boolean temp scoreboard var
+        unwrapped = unwrap(expression)
+        op_sym_unwrapped = None
+        # Import here to avoid top-level cycle
+        from .ast_nodes import UnaryExpression as _UnaryExpr
+        if isinstance(unwrapped, BinaryExpression) or isinstance(unwrapped, _UnaryExpr):
+            op_sym_unwrapped = self._normalize_operator(getattr(unwrapped, 'operator', None))
+        if op_sym_unwrapped in ('&&', '||', '!'):
+            bool_var = self._compile_boolean_expression(unwrapped)
+            return (f"score @s {bool_var} matches 1..", False)
+
         if isinstance(expression, BinaryExpression):
             left = unwrap(expression.left)
             right = unwrap(expression.right)
             op_sym = self._normalize_operator(expression.operator)
+            # Treat a leading logical NOT on a comparator operand as negating the entire comparison
+            # Example: !$a > 0  =>  NOT ( $a > 0 )
+            if op_sym in (">", ">=", "<", "<=", "==", "!="):
+                try:
+                    from .ast_nodes import UnaryExpression as _UnaryExpr
+                except Exception:
+                    _UnaryExpr = None
+                if _UnaryExpr is not None and isinstance(left, _UnaryExpr) and self._normalize_operator(getattr(left, 'operator', None)) == '!':
+                    # Build condition for (left.operand op right) and invert
+                    inner = BinaryExpression(left=left.operand, operator=expression.operator, right=right)
+                    cond_str, inv = self._build_condition(inner)
+                    return (cond_str, not inv)
+                if _UnaryExpr is not None and isinstance(right, _UnaryExpr) and self._normalize_operator(getattr(right, 'operator', None)) == '!':
+                    # Build condition for (left op right.operand) and invert
+                    inner = BinaryExpression(left=left, operator=expression.operator, right=right.operand)
+                    cond_str, inv = self._build_condition(inner)
+                    return (cond_str, not inv)
             # Variable vs literal
             if op_sym and isinstance(left, VariableSubstitution) and isinstance(right, LiteralExpression) and isinstance(right.value, (int, float)):
                 objective = self.variables.get(left.name, left.name)
@@ -967,6 +1008,53 @@ class MDLCompiler:
         
         # Fallback: treat as generic condition string
         return (self._expression_to_condition(expression), False)
+
+    def _compile_boolean_expression(self, expression: Any, out_var: Optional[str] = None) -> str:
+        """Compile a logical expression into a temporary boolean scoreboard variable (1 true, 0 false).
+        Returns the objective name for the boolean temp variable.
+        """
+        from .ast_nodes import BinaryExpression as Bin, UnaryExpression as Un, ParenthesizedExpression as Par
+        if out_var is None:
+            out_var = self._generate_temp_variable_name()
+        # Ensure initialized to 0
+        self._store_temp_command(f"scoreboard players set @s {out_var} 0")
+
+        def emit_set_true_when(cond_expr: Any):
+            cond_str, inv = self._build_condition(cond_expr)
+            prefix = "unless" if inv else "if"
+            self._store_temp_command(f"execute {prefix} {cond_str} run scoreboard players set @s {out_var} 1")
+
+        expr = expression
+        # Parentheses
+        if isinstance(expr, Par):
+            return self._compile_boolean_expression(expr.expression, out_var)
+        # Unary NOT
+        if isinstance(expr, Un):
+            op = self._normalize_operator(expr.operator)
+            if op == '!':
+                inner_var = self._compile_boolean_expression(expr.operand)
+                # out = NOT inner
+                self._store_temp_command(f"execute unless score @s {inner_var} matches 1.. run scoreboard players set @s {out_var} 1")
+                return out_var
+        # Binary logical
+        if isinstance(expr, Bin):
+            op = self._normalize_operator(expr.operator)
+            if op == '&&':
+                left_var = self._compile_boolean_expression(expr.left)
+                right_var = self._compile_boolean_expression(expr.right)
+                # Set true only when both true
+                self._store_temp_command(f"execute if score @s {left_var} matches 1.. if score @s {right_var} matches 1.. run scoreboard players set @s {out_var} 1")
+                return out_var
+            if op == '||':
+                left_var = self._compile_boolean_expression(expr.left)
+                right_var = self._compile_boolean_expression(expr.right)
+                # Set true when either true
+                self._store_temp_command(f"execute if score @s {left_var} matches 1.. run scoreboard players set @s {out_var} 1")
+                self._store_temp_command(f"execute if score @s {right_var} matches 1.. run scoreboard players set @s {out_var} 1")
+                return out_var
+        # Base comparator or non-logical: set true if base condition holds
+        emit_set_true_when(expr)
+        return out_var
     
     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-16.0.16 → minecraft_datapack_language-16.0.18}/minecraft_datapack_language/mdl_lexer.py

@@ -59,6 +59,9 @@ class TokenType:
     LESS = "LESS"                    # <
     GREATER_EQUAL = "GREATER_EQUAL"  # >=
     LESS_EQUAL = "LESS_EQUAL"        # <=
+    AND = "AND"                      # &&
+    OR = "OR"                        # ||
+    NOT = "NOT"                      # ! (logical not)
     
     # Delimiters
     SEMICOLON = "SEMICOLON"          # ;
@@ -552,7 +555,7 @@ class MDLLexer:
         if self.current + 1 < len(self.source):
             two_char = self.source[self.current:self.current + 2]
             
-            if two_char in ['==', '!=', '>=', '<=', '..']:
+            if two_char in ['==', '!=', '>=', '<=', '..', '&&', '||']:
                 self.current += 2
                 self.column += 2
                 
@@ -561,7 +564,9 @@ class MDLLexer:
                     '!=': TokenType.NOT_EQUAL,
                     '>=': TokenType.GREATER_EQUAL,
                     '<=': TokenType.LESS_EQUAL,
-                    '..': TokenType.RANGE
+                    '..': TokenType.RANGE,
+                    '&&': TokenType.AND,
+                    '||': TokenType.OR
                 }[two_char]
                 
                 self.tokens.append(Token(token_type, two_char, self.line, self.column - 2))
@@ -576,6 +581,7 @@ class MDLLexer:
             '=': TokenType.ASSIGN,
             '>': TokenType.GREATER,
             '<': TokenType.LESS,
+            '!': TokenType.NOT,
             ';': TokenType.SEMICOLON,
             ',': TokenType.COMMA,
             ':': TokenType.COLON,

{minecraft_datapack_language-16.0.16 → minecraft_datapack_language-16.0.18}/minecraft_datapack_language/mdl_parser.py

@@ -465,7 +465,27 @@ class MDLParser:
     
     def _parse_expression(self) -> Any:
         """Parse an expression with operator precedence."""
-        return self._parse_comparison()
+        return self._parse_or()
+
+    def _parse_or(self) -> Any:
+        """Parse logical OR (||) with left associativity."""
+        expr = self._parse_and()
+        while not self._is_at_end() and self._peek().type == TokenType.OR:
+            operator = self._peek().type
+            self._advance()
+            right = self._parse_and()
+            expr = BinaryExpression(left=expr, operator=operator, right=right)
+        return expr
+
+    def _parse_and(self) -> Any:
+        """Parse logical AND (&&) with left associativity."""
+        expr = self._parse_comparison()
+        while not self._is_at_end() and self._peek().type == TokenType.AND:
+            operator = self._peek().type
+            self._advance()
+            right = self._parse_comparison()
+            expr = BinaryExpression(left=expr, operator=operator, right=right)
+        return expr
     
     def _parse_comparison(self) -> Any:
         """Parse comparison expressions (>, <, >=, <=, ==, !=)."""
@@ -496,15 +516,24 @@ class MDLParser:
     
     def _parse_factor(self) -> Any:
         """Parse multiplication and division factors."""
-        expr = self._parse_primary()
+        expr = self._parse_unary()
         
         while not self._is_at_end() and self._peek().type in [TokenType.MULTIPLY, TokenType.DIVIDE]:
             operator = self._peek().type
             self._advance()
-            right = self._parse_primary()
+            right = self._parse_unary()
             expr = BinaryExpression(left=expr, operator=operator, right=right)
         
         return expr
+
+    def _parse_unary(self) -> Any:
+        """Parse unary expressions (logical NOT)."""
+        if not self._is_at_end() and self._peek().type in [TokenType.NOT]:
+            operator = self._peek().type
+            self._advance()
+            operand = self._parse_unary()
+            return UnaryExpression(operator=operator, operand=operand)
+        return self._parse_primary()
     
     def _parse_primary(self) -> Any:
         """Parse primary expressions (literals, variables, parenthesized expressions)."""

{minecraft_datapack_language-16.0.16 → minecraft_datapack_language-16.0.18/minecraft_datapack_language.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: minecraft-datapack-language
-Version: 16.0.16
+Version: 16.0.18
 Summary: Compile MDL language with explicit scoping into a Minecraft datapack (1.21+ ready). Features variables, control flow, error handling, and VS Code extension.
 Project-URL: Homepage, https://www.mcmdl.com
 Project-URL: Documentation, https://www.mcmdl.com/docs

{minecraft_datapack_language-16.0.16 → minecraft_datapack_language-16.0.18}/minecraft_datapack_language.egg-info/SOURCES.txt

@@ -3,8 +3,6 @@
 .tmp_compile_bwe2.py
 .tmp_compile_bwe3.py
 .tmp_verify_loops.py
-COMPILER_FIXES_SUMMARY.md
-CONDITIONALS_IMPLEMENTATION.md
 LICENSE
 Makefile
 README.md

minecraft_datapack_language-16.0.16/COMPILER_FIXES_SUMMARY.md

@@ -1,216 +0,0 @@
-# MDL Compiler Fixes Summary
-
-## Overview
-This document summarizes all the fixes implemented to resolve the critical issues in the MDL (Minecraft Datapack Language) compiler.
-
-## Issues Identified and Fixed
-
-### 1. ❌ **Complex Expressions Not Working**
-**Problem**: The compiler was generating invalid Minecraft syntax like `scoreboard players set @s score score @s counter + score @s health * score @s bonus`
-
-**Root Cause**: The `_expression_to_value` method was trying to concatenate strings instead of generating valid Minecraft scoreboard commands.
-
-**Solution Implemented**:
-- Added `_compile_expression_to_temp()` method to handle complex expressions
-- Added `_store_temp_command()` method to collect temporary operations
-- Added `_generate_temp_variable_name()` method for unique temporary variables
-- Updated `_variable_assignment_to_command()` to use temporary variables for complex expressions
-
-**Result**: ✅ Complex expressions now generate valid Minecraft commands:
-```mcfunction
-# Before (invalid):
-scoreboard players set @s score score @s counter + score @s health * score @s bonus
-
-# After (valid):
-scoreboard players set @s temp_2 score @s counter
-scoreboard players add @s temp_2 score @s health
-scoreboard players set @s temp_1 score @s temp_2
-scoreboard players operation @s temp_1 *= score @s bonus
-scoreboard players operation @s score = @s temp_1
-```
-
-### 2. ❌ **If/Else If/Else Not Working**
-**Problem**: The compiler was only generating comments for if statements instead of actual Minecraft conditional logic.
-
-**Root Cause**: The `_if_statement_to_command()` method was incomplete and only generated comments.
-
-**Solution Implemented**:
-- Complete rewrite of `_if_statement_to_command()` method
-- Proper handling of `else if` as nested if statements
-- Generation of `execute if score` and `execute unless score` commands
-- Creation of separate generated functions for if/else blocks
-
-**Result**: ✅ If/else if/else now generates proper Minecraft conditional logic:
-```mcfunction
-# Before (just comments):
-# if $counter<@s>$ > 5
-say "Counter is high!";
-
-# After (proper conditional logic):
-execute if score @s counter GREATER 5.0 run function test:if_1
-execute if score @s counter GREATER 2.0 run function test:if_3
-execute unless score @s counter GREATER 2.0 run function test:else_1
-```
-
-### 3. ❌ **While Loops Not Working**
-**Problem**: The compiler was only generating comments for while loops instead of actual loop logic.
-
-**Root Cause**: The `_while_loop_to_command()` method was incomplete and only generated comments.
-
-**Solution Implemented**:
-- Complete rewrite of `_while_loop_to_command()` method
-- Generation of recursive function calls for loop continuation
-- Proper condition checking with `execute if score`
-
-**Result**: ✅ While loops now generate proper Minecraft loop logic:
-```mcfunction
-# Before (just comments):
-# while $counter<@s>$ < 5
-counter<@s> = $counter<@s>$ + 1;
-
-# After (proper loop logic):
-function test:while_1
-# ... loop body ...
-execute if score @s counter LESS 5.0 run function test:while_1
-```
-
-### 4. ❌ **Function Execution Scope Issues**
-**Problem**: Function execution scope was not being properly handled.
-
-**Root Cause**: The `_function_call_to_command()` method needed improvement.
-
-**Solution Implemented**:
-- Enhanced `_function_call_to_command()` method
-- Proper handling of `exec function:name` vs `exec function:name<@s>`
-- Generation of appropriate `execute as` commands
-
-**Result**: ✅ Function execution now works correctly with proper scope handling:
-```mcfunction
-# Function call without scope:
-function test:helper
-
-# Function call with @s scope:
-execute as @s run function test:helper
-
-# Function call with @a scope:
-execute as @a run function test:helper
-```
-
-### 5. ❌ **Generated Functions Not Being Created**
-**Problem**: The compiler was generating function calls but not creating the actual generated functions.
-
-**Root Cause**: The `_store_generated_function()` method was storing functions but they weren't being included in the output.
-
-**Solution Implemented**:
-- Enhanced `_generate_function_content()` method
-- Proper inclusion of generated functions in function output
-- Temporary command handling for complex expressions
-
-**Result**: ✅ Generated functions are now properly created and included in the output.
-
-## Technical Implementation Details
-
-### Temporary Variable System
-The compiler now uses a sophisticated temporary variable system for complex expressions:
-
-1. **Expression Analysis**: Complex expressions are broken down into simple operations
-2. **Temporary Variable Generation**: Unique temporary variables are created for intermediate results
-3. **Command Generation**: Valid Minecraft scoreboard commands are generated for each operation
-4. **Result Assignment**: The final result is assigned to the target variable
-
-### Control Structure Compilation
-Control structures are compiled using a function-based approach:
-
-1. **Condition Evaluation**: Conditions are converted to scoreboard comparisons
-2. **Function Generation**: Separate functions are created for each control block
-3. **Execute Commands**: `execute if` and `execute unless` commands are generated
-4. **Recursive Calls**: While loops use recursive function calls for iteration
-
-### Scope Handling
-Variable and function scopes are handled explicitly:
-
-1. **Variable Scopes**: Each variable operation specifies its scope with `<>` brackets
-2. **Function Scopes**: Function calls can specify execution scope
-3. **Scoreboard Operations**: All operations use proper Minecraft scoreboard syntax
-
-## Testing and Verification
-
-### Test Files Created
-1. **`test_complex_scenarios.mdl`** - Tests complex expressions and function execution
-2. **`test_comprehensive_fixes.mdl`** - Comprehensive test of all fixes
-3. **`test_compiler_fixes.py`** - Python test suite for programmatic verification
-
-### Test Results
-✅ **Complex Expressions**: Working correctly with valid Minecraft syntax
-✅ **If/Else If/Else**: Working correctly with proper conditional logic
-✅ **While Loops**: Working correctly with recursive function calls
-✅ **Function Execution**: Working correctly with proper scope handling
-✅ **Variable Scopes**: Working correctly across different scopes
-✅ **Generated Functions**: Working correctly with proper output
-
-### CLI Testing
-The fixes have been tested using the local MDL compiler (`./mdllocal.sh`) and verified to generate valid Minecraft datapack files.
-
-## Files Modified
-
-### Core Compiler Files
-- **`minecraft_datapack_language/mdl_compiler.py`**
-  - Added complex expression compilation methods
-  - Fixed if/else if/else compilation
-  - Fixed while loop compilation
-  - Enhanced function execution scope handling
-  - Added temporary variable system
-  - Fixed generated function output
-
-### Test Files
-- **`test_complex_scenarios.mdl`** - Test file for complex scenarios
-- **`test_comprehensive_fixes.mdl`** - Comprehensive test file
-- **`test_compiler_fixes.py`** - Python test suite
-- **`mdllocal.sh`** - Local compiler shim for testing
-
-### Documentation
-- **`docs/_docs/language-reference.md`** - Updated to reflect working features
-- **`COMPILER_FIXES_SUMMARY.md`** - This summary document
-
-## Build and Test Commands
-
-### Testing the Fixes
-```bash
-# Test with local compiler
-./mdllocal.sh build --mdl test_comprehensive_fixes.mdl -o dist
-
-# Run Python test suite
-python test_compiler_fixes.py
-
-# Run via Makefile
-make test-compiler
-```
-
-### Building Examples
-```bash
-# Build comprehensive test
-./mdllocal.sh build --mdl test_comprehensive_fixes.mdl -o dist
-
-# Build complex scenarios test
-./mdllocal.sh build --mdl test_complex_scenarios.mdl -o dist
-```
-
-## Conclusion
-
-All critical compiler issues have been resolved:
-
-1. ✅ **Complex expressions now compile to valid Minecraft syntax**
-2. ✅ **If/else if/else statements work correctly**
-3. ✅ **While loops work correctly**
-4. ✅ **Function execution scope handling works correctly**
-5. ✅ **Generated functions are properly created and included**
-
-The MDL compiler now generates valid, functional Minecraft datapack files that can be used in actual Minecraft worlds. The fixes maintain backward compatibility while adding robust support for complex language constructs.
-
-## Next Steps
-
-1. **Integration Testing**: Test the fixes with real Minecraft datapacks
-2. **Performance Optimization**: Optimize the temporary variable system for large expressions
-3. **Error Handling**: Add better error messages for edge cases
-4. **Documentation**: Update user documentation with working examples
-5. **CI Integration**: Add the test suite to continuous integration

minecraft_datapack_language-16.0.16/CONDITIONALS_IMPLEMENTATION.md

@@ -1,164 +0,0 @@
-# Conditional Functionality Implementation Summary
-
-## Overview
-
-This document summarizes the implementation of if/else if/else functionality in the Minecraft Datapack Language (MDL).
-
-## ✅ Implementation Status
-
-### Core Functionality
-- ✅ **Parser Support**: Conditional blocks are parsed as regular commands
-- ✅ **Post-Processing**: Conditional blocks are converted to separate functions
-- ✅ **Execute Commands**: Proper Minecraft `execute` syntax is generated
-- ✅ **Complex Conditions**: Support for NBT data and complex selectors
-- ✅ **Multiple else if**: Support for multiple else if blocks
-- ✅ **Else blocks**: Optional else blocks are supported
-
-### Syntax Support
-- ✅ `if "condition":` - Simple if statements
-- ✅ `else if "condition":` - Else if statements
-- ✅ `else:` - Else blocks
-- ✅ Complex conditions with NBT data
-- ✅ Mixed commands with conditionals
-
-### Generated Output
-- ✅ Main function contains `execute` commands
-- ✅ Conditional blocks become separate functions
-- ✅ Proper function naming convention
-- ✅ Correct `execute if` and `execute unless` syntax
-
-## 📁 Files Modified
-
-### Core Implementation
-- `minecraft_datapack_language/pack.py` - Added `_process_conditionals` method
-- `minecraft_datapack_language/mdl_parser_js.py` - JavaScript-style parser with modern syntax
-
-### Documentation
-- `README.md` - Added conditional blocks section
-- `docs/_docs/language-reference.md` - Added comprehensive conditional documentation
-- `docs/_docs/examples.md` - Added conditional examples
-- `docs/_docs/python-bindings.md` - Added conditional Python bindings examples
-
-### Tests
-- `test_examples/conditionals.mdl` - Comprehensive MDL test file
-- `test_examples/conditionals.py` - Python bindings test file
-- `test_regression.py` - Regression test suite
-- `test_examples/run_all_tests.py` - Updated to include conditionals
-
-## 🧪 Testing
-
-### Test Coverage
-- ✅ Basic conditional syntax
-- ✅ Complex conditions with NBT
-- ✅ Multiple else if blocks
-- ✅ Mixed commands with conditionals
-- ✅ Conditional function calls
-- ✅ Invalid syntax handling
-- ✅ Regression testing (existing functionality)
-- ✅ Python bindings compatibility
-
-### Test Results
-- **Regression Tests**: 7/7 passed ✅
-- **Comprehensive Tests**: 17/17 passed ✅
-- **Python bindings tests**: All passed ✅
-
-## 📖 Documentation
-
-### Syntax Examples
-
-```mdl
-function "weapon_effects":
-    if "entity @s[type=minecraft:player,nbt={SelectedItem:{id:\"minecraft:diamond_sword\"}}]":
-        say Diamond sword detected!
-        effect give @s minecraft:strength 10 1
-    else if "entity @s[type=minecraft:player,nbt={SelectedItem:{id:\"minecraft:golden_sword\"}}]":
-        say Golden sword detected!
-        effect give @s minecraft:speed 10 1
-    else if "entity @s[type=minecraft:player]":
-        say Player without special sword
-        effect give @s minecraft:haste 5 0
-    else:
-        say No player found
-```
-
-### Generated Output
-
-The above MDL generates:
-
-**Main function (`weapon_effects.mcfunction`):**
-```mcfunction
-execute if entity @s[type=minecraft:player,nbt={SelectedItem:{id:"minecraft:diamond_sword"}}] run function test:weapon_effects_if_1
-execute unless entity @s[type=minecraft:player,nbt={SelectedItem:{id:"minecraft:diamond_sword"}}] if entity @s[type=minecraft:player,nbt={SelectedItem:{id:"minecraft:golden_sword"}}] run function test:weapon_effects_elif_2
-execute unless entity @s[type=minecraft:player,nbt={SelectedItem:{id:"minecraft:diamond_sword"}}] unless entity @s[type=minecraft:player,nbt={SelectedItem:{id:"minecraft:golden_sword"}}] if entity @s[type=minecraft:player] run function test:weapon_effects_elif_3
-execute unless entity @s[type=minecraft:player,nbt={SelectedItem:{id:"minecraft:diamond_sword"}}] unless entity @s[type=minecraft:player,nbt={SelectedItem:{id:"minecraft:golden_sword"}}] unless entity @s[type=minecraft:player] run function test:weapon_effects_else
-```
-
-**Conditional functions:**
-- `weapon_effects_if_1.mcfunction` - Diamond sword effects
-- `weapon_effects_elif_2.mcfunction` - Golden sword effects  
-- `weapon_effects_elif_3.mcfunction` - Default player effects
-- `weapon_effects_else.mcfunction` - No player found
-
-## 🔧 Technical Details
-
-### Implementation Approach
-1. **Parser**: Treats conditional blocks as regular commands
-2. **Post-Processing**: Converts conditional blocks to separate functions
-3. **Execute Commands**: Generates proper Minecraft execute syntax
-4. **Function Generation**: Creates separate functions for each conditional block
-
-### Key Features
-- **Backward Compatible**: Existing MDL files continue to work
-- **Robust**: Handles complex conditions and edge cases
-- **Efficient**: Minimal overhead in parsing
-- **Flexible**: Supports all valid Minecraft selector syntax
-
-### Error Handling
-- Invalid conditional syntax is treated as regular commands
-- Clear error messages for malformed conditions
-- Graceful degradation for edge cases
-
-## 🎯 Use Cases
-
-### Common Patterns
-1. **Weapon Effects**: Different effects based on held items
-2. **Entity Detection**: Different behavior for different entity types
-3. **Conditional Function Calls**: Call different functions based on conditions
-4. **Complex Logic**: Multi-level conditional logic
-
-### Examples
-- Combat systems with different weapon effects
-- UI systems that adapt to player state
-- AI systems with different behaviors
-- Game mechanics with conditional triggers
-
-## 🚀 Future Enhancements
-
-### Potential Improvements
-- **Nested Conditionals**: Support for nested if/else blocks
-- **Switch Statements**: Alternative syntax for multiple conditions
-- **Conditional Macros**: Reusable conditional patterns
-- **Performance Optimizations**: More efficient execute command generation
-
-### Considerations
-- **Complexity**: Keep the language simple and readable
-- **Performance**: Ensure generated commands are efficient
-- **Compatibility**: Maintain backward compatibility
-- **Documentation**: Keep examples and documentation up to date
-
-## 📋 Checklist
-
-- ✅ Core functionality implemented
-- ✅ Comprehensive testing completed
-- ✅ Documentation updated
-- ✅ Examples created
-- ✅ Python bindings support
-- ✅ Regression tests passing
-- ✅ Backward compatibility verified
-- ✅ Error handling implemented
-
-## 🎉 Conclusion
-
-The conditional functionality has been successfully implemented and thoroughly tested. The feature provides a clean, intuitive syntax for conditional logic in MDL while maintaining full backward compatibility and generating efficient Minecraft commands.
-
-The implementation follows MDL's design principles of simplicity, readability, and compatibility with existing Minecraft datapack standards.

minecraft_datapack_language-16.0.16/docs/_data/version.yml

@@ -1,3 +0,0 @@
-current: "16.0.15"
-tag: "v16.0.15"
-updated_at: "2025-09-10T04:17:24Z"