minecraft-datapack-language 16.0.16__py3-none-any.whl → 16.0.18__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 = '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 = None

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

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

@@ -1,18 +1,18 @@
 minecraft_datapack_language/__init__.py,sha256=0KVXBE4ScRaRUrf83aA2tVB-y8A_jplyaxVvtHH6Uw0,1199
-minecraft_datapack_language/_version.py,sha256=d04fOD3hne3CIblJtZJsJY9-QzwsZ1sOB7PzgWLaDWM,708
+minecraft_datapack_language/_version.py,sha256=mdkSHoP-7a-SjOHB7GFAkWYMURefj-puFhnmsSxEKLE,708
 minecraft_datapack_language/ast_nodes.py,sha256=L5izavSeXDr766vsfRvJrcnflXNJyXcy0WSfyJPq2ZA,4484
 minecraft_datapack_language/cli.py,sha256=R4QZYtox-Da9B8pr_kCg_9qc9aI-ORTah7kMkhsI5tw,10373
 minecraft_datapack_language/dir_map.py,sha256=HmxFkuvWGkzHF8o_GFb4BpuMCRc6QMw8UbmcAI8JVdY,1788
-minecraft_datapack_language/mdl_compiler.py,sha256=5lBvLpBbB90SVg1i10oAkeRVYhVDfeBvbJXONoSgAUE,55612
+minecraft_datapack_language/mdl_compiler.py,sha256=3oF0XjXozma8UugNYSd3BbRADIWDAKYXYkcn_mveGHI,60636
 minecraft_datapack_language/mdl_errors.py,sha256=r0Gu3KhoX1YLPAVW_iO7Q_fPgaf_Dv9tOGSOdKNSzmw,16114
-minecraft_datapack_language/mdl_lexer.py,sha256=bDzAj39-kfnX0uVlYQg1oQ7YDb-JO9UZx8jbODQqg6E,23902
+minecraft_datapack_language/mdl_lexer.py,sha256=YuRflOkoMOcjECPAZzoAkJciMks5amWMtGbcTIVKmAs,24166
 minecraft_datapack_language/mdl_linter.py,sha256=z85xoAglENurCh30bR7kEHZ_JeMxcYaLDcGNRAl-RAI,17253
-minecraft_datapack_language/mdl_parser.py,sha256=Krk7Y_E9OKNCcsDOCT7ATvQLbJII951AU2qzEY00GLE,26068
+minecraft_datapack_language/mdl_parser.py,sha256=Bwfk1i6PFsMB3Zs7Z6a3fgngPaWPv-KKqQRQUkFRquM,27272
 minecraft_datapack_language/python_api.py,sha256=Iao1jbdeW6ekeA80BZG6gNqHVjxQJEheB3DbpVsuTZQ,12304
 minecraft_datapack_language/utils.py,sha256=Aq0HAGlXqj9BUTEjaEilpvzEW0EtZYYMMwOqG9db6dE,684
-minecraft_datapack_language-16.0.16.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-minecraft_datapack_language-16.0.16.dist-info/METADATA,sha256=LLHp-JLyIvV2l7sVIhwgKk_i4NX1S9PRxR-trcER4Zc,8344
-minecraft_datapack_language-16.0.16.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-minecraft_datapack_language-16.0.16.dist-info/entry_points.txt,sha256=c6vjBeCiyQflvPHBRyBk2nJCSfYt3Oc7Sc9V87ySi_U,108
-minecraft_datapack_language-16.0.16.dist-info/top_level.txt,sha256=ADtFI476tbKLLxEAA-aJQAfg53MA3k_DOb0KTFiggfw,28
-minecraft_datapack_language-16.0.16.dist-info/RECORD,,
+minecraft_datapack_language-16.0.18.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+minecraft_datapack_language-16.0.18.dist-info/METADATA,sha256=h_rvudGiJ3j0gffl-lpx0BmXkKs_ycMpjzHeBxnIb_c,8344
+minecraft_datapack_language-16.0.18.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+minecraft_datapack_language-16.0.18.dist-info/entry_points.txt,sha256=c6vjBeCiyQflvPHBRyBk2nJCSfYt3Oc7Sc9V87ySi_U,108
+minecraft_datapack_language-16.0.18.dist-info/top_level.txt,sha256=ADtFI476tbKLLxEAA-aJQAfg53MA3k_DOb0KTFiggfw,28
+minecraft_datapack_language-16.0.18.dist-info/RECORD,,