minecraft-datapack-language 16.0.17__tar.gz → 16.0.19__tar.gz

{minecraft_datapack_language-16.0.17 → minecraft_datapack_language-16.0.19}/PKG-INFO

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

@@ -0,0 +1,3 @@
+current: "16.0.18"
+tag: "v16.0.18"
+updated_at: "2025-09-10T05:13:53Z"

{minecraft_datapack_language-16.0.17 → minecraft_datapack_language-16.0.19}/docs/_docs/examples.md

@@ -22,6 +22,107 @@ function hello:main {
 on_load hello:main;
 ```
 
+## Logical Operators and Precedence
+
+```mdl
+pack "logicalops" "Generated by MDL CLI" 82;
+namespace "logicalops";
+
+// Variables
+var num a<@s> = 0;
+var num b<@s> = 0;
+
+// Main function
+function logicalops:main {
+    say "Hello from logicalops!";
+    exec logicalops:add<@a>;
+}
+
+function logicalops:init {
+    a<@s> = 1;
+    b<@s> = 2;
+}
+
+function logicalops:add {
+    var result<@s> = $a<@s>$ + $b<@s>$;
+    say "Result: $result$";
+}
+
+function logicalops:subtract {
+    var result<@s> = $a<@s>$ - $b<@s>$;
+    say "Result: $result$";
+}
+
+function logicalops:multiply {
+    var result<@s> = $a<@s>$ * $b<@s>$;
+    say "Result: $result$";
+}
+
+function logicalops:divide {
+    var result<@s> = $a<@s>$ / $b<@s>$;
+    say "Result: $result$";
+}
+
+function logicalops:andop {
+    if $a<@s>$ > 0 && $b<@s>$ > 0 {
+        say "Both are greater than 0";
+    } else {
+        say "At least one is not greater than 0";
+    }
+}
+
+function logicalops:orop {
+    if $a<@s>$ > 0 || $b<@s>$ > 0 {
+        say "At least one is greater than 0";
+    } else {
+        say "Both are not greater than 0";
+    }
+}
+
+function logicalops:notop {
+    if !$a<@s>$ > 0 {
+        say "a is not greater than 0";
+    } else {
+        say "a is greater than 0";
+    }
+}
+
+function logicalops:whileloop {
+    a<@s> = 0;
+    while $a<@s>$ < 10 {
+        say "a is less than 10";
+        a<@s> = $a<@s>$ + 1;
+    }
+}
+
+function logicalops:scheduledwhileloop {
+    // the scheduledwhile is just like the while loop, but it is scheduled to run every tick. This is useful for large calculations that would exceed the command recursion limit.
+    a<@s> = 0;
+    scheduledwhile $a<@s>$ < 10 {
+        say "a is less than 10";
+        a<@s> = $a<@s>$ + 1;
+    }
+}
+
+function logicalops:complexops {
+    var c<@s> = 5;
+    var d<@s> = 10;
+    var e<@s> = 15;
+    var f<@s> = 20;
+    var g<@s> = 2;
+    var h<@s> = 0;
+    h<@s> = $h<@s>$ - 1;
+
+    var result<@s> = ($c<@s>$ + $d<@s>$ - $e<@s>$ * $f<@s>$ / $g<@s>$) * $h<@s>$;
+
+    if !$result<@s>$ == 135 {
+        say "Result is not 135, there is an issue!";
+    } else {
+        say "Result is -135, everything is good!";
+    }
+}
+```
+
 ## Counter with Scoped Variables
 
 Demonstrates variables with different scopes:

{minecraft_datapack_language-16.0.17 → minecraft_datapack_language-16.0.19}/docs/_docs/language-reference.md

@@ -314,6 +314,11 @@ exec utils:helper;                              // Execute from different namesp
 < (less than)
 >= (greater than or equal)
 <= (less than or equal)
+
+// Logical
+&& (logical AND)
+|| (logical OR)
+!  (logical NOT)
 ```
 
 ### Expression Examples
@@ -324,10 +329,29 @@ player_score<@s> = $x<@a>$ + $y<@p>$ * $z<@r>$;
 // Parentheses for precedence
 player_score<@s> = ($x<@s>$ + $y<@s>$) * 2;
 
-// Simple comparisons (no logical operators)
+// Comparisons
 if $score<@s>$ > 10 {
     exec game:reward;
 }
+
+// Logical operators
+if $a<@s>$ > 0 && $b<@s>$ > 0 {
+    say "Both are greater than 0";
+}
+
+if $a<@s>$ > 0 || $b<@s>$ > 0 {
+    say "At least one is greater than 0";
+}
+
+// NOT negates the entire comparison when used like: !$a<@s>$ > 0
+if !$a<@s>$ > 0 {
+    say "a is not greater than 0";
+}
+
+// Complex logical expression with parentheses
+if ($a<@s>$ > 0 && $b<@s>$ > 0) || $c<@s>$ > 0 {
+    say "Condition satisfied";
+}
 ```
 
 ## Reserved Names
@@ -1224,6 +1248,13 @@ def _parse_comparison(self) -> Any:
 3. **Terms**: Addition, subtraction
 4. **Comparisons**: Greater, less, equal, not equal
 
+### Logical Operators - Compilation Notes
+
+- Logical expressions compile into temporary boolean scoreboard values (1 true, 0 false) checked via `execute if/unless`.
+- `&&` is compiled as a chain of `execute if` conditions; `||` sets the result true if either operand is true.
+- `!` negates the entire operand. For comparisons like `!$a<@s>$ > 0`, the comparison is evaluated first, then negated.
+- `!=` is compiled using equality with inversion (`unless score ... = ...`) because Minecraft lacks a direct not-equal comparator.
+
 ### AST Traversal and Code Generation
 
 The AST is designed to support efficient code generation:

{minecraft_datapack_language-16.0.17 → minecraft_datapack_language-16.0.19}/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.17'
-__version_tuple__ = version_tuple = (16, 0, 17)
+__version__ = version = '16.0.19'
+__version_tuple__ = version_tuple = (16, 0, 19)
 
-__commit_id__ = commit_id = 'g9a7ffe5b3'
+__commit_id__ = commit_id = 'gabc769e06'

{minecraft_datapack_language-16.0.17 → minecraft_datapack_language-16.0.19}/minecraft_datapack_language/cli.py

@@ -235,32 +235,14 @@ def new_command(args):
     template_content = f'''pack "{pack_name}" "Generated by MDL CLI" {pack_format};
 namespace "{project_name}";
 
-// Variables
-var num counter<@s> = 0;
-var num global_timer<@a> = 0;
-
-// Main function
 function {project_name}:main {{
     say "Hello from {project_name}!";
-    
-    // Variable example
-    counter<@s> = 10;
-    say "Counter: $counter<@s>$";
-    
-    // Conditional example
-    if $counter<@s>$ > 5 {{
-        say "High counter!";
-    }} else {{
-        say "Try again!";
-    }}
 }}
 
-// Init function (avoid reserved names like 'load' or 'tick')
 function {project_name}:init {{
-    say "Datapack initialized successfully!";
+    say "Datapack initialized!";
 }}
 
-// Hook to run on load
 on_load {project_name}:init;
 '''
     
@@ -285,24 +267,9 @@ A Minecraft datapack created with MDL (Minecraft Datapack Language).
    - Run `/reload` in-game
 
 3. **Run the main function:**
-   ```bash
+   ```
    /function {project_name}:main
    ```
-
-## Features
-
-- **Variables**: Player-scoped counter and global timer
-- **Control Flow**: If/else statements
-- **Functions**: Main function and load hook
-- **Automatic Execution**: Runs on datapack load
-
-## Development
-
-- Edit `{project_name}.mdl` to modify the datapack
-- Use `mdl check {project_name}.mdl` to validate syntax
-- Use `mdl build --mdl {project_name}.mdl -o dist` to rebuild
-
-For more information, visit: https://www.mcmdl.com
 '''
     
     with open(readme_file, 'w', encoding='utf-8') as f:

{minecraft_datapack_language-16.0.17 → minecraft_datapack_language-16.0.19}/minecraft_datapack_language/mdl_compiler.py

@@ -12,7 +12,7 @@ from .ast_nodes import (
     Program, PackDeclaration, NamespaceDeclaration, TagDeclaration,
     VariableDeclaration, VariableAssignment, VariableSubstitution, FunctionDeclaration,
     FunctionCall, IfStatement, WhileLoop, ScheduledWhileLoop, HookDeclaration, RawBlock, MacroLine,
-    SayCommand, BinaryExpression, LiteralExpression, ParenthesizedExpression
+    SayCommand, BinaryExpression, UnaryExpression, LiteralExpression, ParenthesizedExpression
 )
 from .dir_map import get_dir_map, DirMap
 from .mdl_errors import MDLCompilerError
@@ -809,6 +809,42 @@ class MDLCompiler:
             objective = self.variables.get(expression.name, expression.name)
             scope = expression.scope.strip("<>")
             return f"score {scope} {objective}"
+        elif isinstance(expression, UnaryExpression):
+            # Handle logical NOT elsewhere; here support unary minus for arithmetic
+            op = self._normalize_operator(expression.operator)
+            if op == '!':
+                # For values, ! is not meaningful; fallback to boolean temp
+                bool_var = self._compile_boolean_expression(expression)
+                return f"score @s {bool_var}"
+            if op == '-':
+                # If operand is a literal, constant-fold
+                if isinstance(expression.operand, LiteralExpression) and isinstance(expression.operand.value, (int, float)):
+                    try:
+                        v = float(expression.operand.value)
+                        v = -v
+                        if v.is_integer():
+                            return str(int(v))
+                        return str(v)
+                    except Exception:
+                        pass
+                # Otherwise, compute 0 - <operand>
+                rhs = self._expression_to_value(expression.operand)
+                temp_var = self._generate_temp_variable_name()
+                self._store_temp_command(f"scoreboard players set @s {temp_var} 0")
+                if isinstance(expression.operand, VariableSubstitution) or (isinstance(rhs, str) and rhs.startswith("score ")):
+                    parts = str(rhs).split()
+                    if len(parts) >= 3:
+                        scope = parts[1]
+                        obj = parts[2]
+                        self._store_temp_command(f"scoreboard players operation @s {temp_var} -= {scope} {obj}")
+                    else:
+                        self._store_temp_command(f"scoreboard players operation @s {temp_var} -= {rhs}")
+                else:
+                    # rhs is a literal number string
+                    self._store_temp_command(f"scoreboard players remove @s {temp_var} {rhs}")
+                return f"score @s {temp_var}"
+            # Fallback
+            return self._expression_to_value(expression.operand)
         elif isinstance(expression, BinaryExpression):
             # For complex expressions, we need to use temporary variables
             temp_var = self._generate_temp_variable_name()
@@ -898,6 +934,18 @@ class MDLCompiler:
         def unwrap(e: Any) -> Any:
             while isinstance(e, ParenthesizedExpression):
                 e = e.expression
+            # Collapse unary minus literal for better comparisons
+            try:
+                from .ast_nodes import UnaryExpression as _UExpr, LiteralExpression as _LExpr
+                if isinstance(e, _UExpr) and self._normalize_operator(getattr(e, 'operator', None)) == '-' and isinstance(e.operand, _LExpr) and isinstance(e.operand.value, (int, float)):
+                    try:
+                        v = float(e.operand.value)
+                        v = -v
+                        return LiteralExpression(value=v, type="number")
+                    except Exception:
+                        return e
+            except Exception:
+                pass
             return e
 
         # Handle logical operators by compiling to a boolean temp scoreboard var
@@ -915,6 +963,23 @@ class MDLCompiler:
             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)

{minecraft_datapack_language-16.0.17 → minecraft_datapack_language-16.0.19}/minecraft_datapack_language/mdl_parser.py

@@ -527,8 +527,8 @@ class MDLParser:
         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]:
+        """Parse unary expressions (logical NOT, unary minus)."""
+        if not self._is_at_end() and self._peek().type in [TokenType.NOT, TokenType.MINUS]:
             operator = self._peek().type
             self._advance()
             operand = self._parse_unary()

{minecraft_datapack_language-16.0.17 → minecraft_datapack_language-16.0.19}/minecraft_datapack_language.egg-info/PKG-INFO

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

@@ -1,3 +0,0 @@
-current: "16.0.16"
-tag: "v16.0.16"
-updated_at: "2025-09-10T04:33:38Z"