Some minor fixes

Author: simon816

commands.py

@@ -231,7 +231,7 @@ def at_entity_pos(self, select_arg):
         return self.add('positioned', 'as', ensure_selector(select_arg))
 
     def align(self, axes):
-        assert [axis for axis in axes if axis in 'xyz']
+        assert ''.join(axis for axis in axes if axis in 'xyz') == axes
         return self.add('align', axes)
 
     def facing(self, pos):
@@ -340,7 +340,7 @@ def arg_to_json(self, arg, scope):
             return {'text': arg}
         if isinstance(arg, Ref):
             return {'score':
-                    {'name': EntityTag.resolve(scope),
+                    {'name': arg.selector(None).resolve(scope),
                      'objective': arg.resolve(scope)}}
         else:
             raise RuntimeError('Unknown argument type %r' % type(arg))

compiler/compiler.py

@@ -625,6 +625,7 @@ def visit_pragma(self, pragma):
             'event_condition': self.visit_pragma_event_condition,
             'update_this_entity_data': self.visit_pragma_update_this_entity,
             'select_entities': self.visit_pragma_select_entities,
+            'select_entities_not_matching': self.visit_pragma_select_not_match,
             'if_this_entity': self.visit_pragma_if_this_entity,
             'at_this_entity': self.visit_pragma_at_this_entity,
             'exec_align': self.visit_pragma_exec_align,
@@ -665,9 +666,7 @@ def _execute_chain_helper(self, exec_type, args):
         self.after_next_statement(lambda: self.emit(IR.ExecEnd(label)))
 
     def visit_pragma_select_entities(self, selector):
-        assert 'select_entities' not in self.pragmas
         selector, sel_inv = self.parse_selector_match(selector)
-        self.pragmas['select_entities'] = True
         sel_dict = selector if selector else sel_inv
         label = self.unique_label('exec_sel')
         inv = 'N' if not selector else ''
@@ -679,12 +678,18 @@ def visit_pragma_select_entities(self, selector):
             self.emit(IR.ExecSel(label_inv, 'ASN', 'e', sel_inv.items()))
 
         def run_after():
-            del self.pragmas['select_entities']
             if label_inv:
                 self.emit(IR.ExecEnd(label_inv))
             self.emit(IR.ExecEnd(label))
         self.after_next_statement(run_after)
 
+    def visit_pragma_select_not_match(self, selector):
+        selector, sel_inv = self.parse_selector_match(selector)
+        assert not sel_inv, "TODO"
+        label = self.unique_label('exec_sel_not')
+        self.emit(IR.ExecSel(label, 'ASN', 'e', selector.items()))
+        self.after_next_statement(lambda: self.emit(IR.ExecEnd(label)))
+
     def visit_pragma_if_this_entity(self, selector):
         selector, sel_inv = self.parse_selector_match(selector)
         assert not sel_inv, "TODO"
@@ -783,13 +788,14 @@ def stringify_nbt(self, node):
                                      for k,v in node.items())
         if type(node) == list:
             return '[%s]' % ','.join(map(self.stringify_nbt, node))
-        if type(node) == str:
-            return '"%s"' % node
-        if type(node) == int:
-            return str(node)
-        if type(node) == float:
-            return '%ff' % node
-        assert False
+        if type(node) == tuple:
+            val_type, value = node
+            if val_type == 'string':
+                return '"%s"' % value
+            if val_type in ['int', 'float', 'byte']:
+                return value
+            assert False, val_type
+        assert False, type(node)
 
     def read_nbt_specification(self, parent, path, value):
         path = path.split('.')
@@ -810,21 +816,34 @@ def read_nbt_specification(self, parent, path, value):
                     else:
                         assert type(parent[node]) == list
             parent = parent[node]
-        if value.isdigit():
-            value = int(value)
-        elif value[0].isdigit():
-            # check for floating points
-            if value.count('.') == 1 and value.endswith('f'):
+        val_type = 'string'
+        # check for numbers
+        looks_like_num = value[0].isdigit() or value[0] == '-'
+        if looks_like_num:
+            if value.endswith('b'):
+                try:
+                    int(value[:-1])
+                    val_type = 'byte'
+                except ValueError:
+                    pass
+            elif value.endswith('f'):
+                try:
+                    float(value[:-1])
+                    val_type = 'float'
+                except ValueError:
+                    pass
+            else:
                 try:
-                    value = float(value[:-1])
+                    int(value)
+                    val_type = 'int'
                 except ValueError:
                     pass
         if path[-1].isdigit():
             pos = int(path[-1])
             while len(parent) < pos + 1:
                 parent.append({})
             path[-1] = pos
-        parent[path[-1]] = value
+        parent[path[-1]] = (val_type, value)
 
     ### Declarations
 

compiler/include/entity.h

@@ -10,6 +10,8 @@
 
 #define select_entities(...) _Pragma("select_entities __VA_ARGS__")
 
+#define select_entities_not_matching(...) _Pragma("select_entities_not_matching __VA_ARGS__")
+
 #define select_players(...) _Pragma("select_entities match:type=player, __VA_ARGS__")
 
 #define sel_match(key, value) match:key=value
@@ -35,4 +37,6 @@
 void add_tag_this_entity(const char *tag);
 void remove_tag_this_entity(const char *tag);
 
+void set_scoreboard_tracking(entity_local variable, const char *criterion);
+
 #endif /* __ENTITY_H */

compiler/lib/entity.py

@@ -1,4 +1,5 @@
 from ..ir import IR
+from ..nodes import IdentifierExpr
 
 def add_tag(visitor, expr):
     assert len(expr.args) == 1, "add_tag_this_entity takes 1 argument"
@@ -16,8 +17,22 @@ def remove_tag(visitor, expr):
     cmd = 'tag @s remove ' + tag
     visitor.emit(IR.Asm((('CMD ' + cmd, None, None),)))
 
+def set_tracking(visitor, expr):
+    assert len(expr.args) == 2
+    assert isinstance(expr.args[0], IdentifierExpr)
+    var = visitor.visit_expression(expr.args[0])
+    criterion = visitor.visit_expression(expr.args[1])
+    assert var.type is visitor.type('entity_local')
+    assert isinstance(criterion, IR.LiteralString), ""
+    var_name = '$entity_local:%s$' % expr.args[0].val
+    rem_old = 'scoreboard objectives remove %s' % var_name
+    add_new = 'scoreboard objectives add %s %s' % (var_name, criterion.val)
+    visitor.emit(IR.Asm((('CMD ' + rem_old, None, None),)))
+    visitor.emit(IR.Asm((('CMD ' + add_new, None, None),)))
+
 def exports():
     return {
         'add_tag_this_entity': add_tag,
         'remove_tag_this_entity': remove_tag,
+        'set_scoreboard_tracking': set_tracking,
     }

examples/mclib.h

@@ -28,4 +28,8 @@
  */
 #define ASM_swap(a, b) __asm__("XCHG >?, >?", a, b)
 
+#define EVENT_CONDITION(cond) _Pragma("event_condition cond")
+
+#define EVENT(event, cond, name) _Pragma("event_handler event") cond void name()
+
 #endif /* __MCLIB_H */

session.py

@@ -189,14 +189,19 @@ def add_command_blocks(self, lines):
                 print()
 
     def add_event_handler(self, event_name, conditions, handler):
-        if event_name == 'minecraft:tick':
+        tag_events = {
+            'minecraft:tick': ('minecraft', 'tick'),
+            'minecraft:load': ('minecraft', 'load')
+        }
+        if event_name in tag_events:
             assert not conditions
-            self.writer.write_tag('functions', 'tick', [
+            namespace, tag_name = tag_events[event_name]
+            self.writer.write_tag('functions', tag_name, [
                 self.scope.function_name(handler)
-            ], namespace='minecraft')
+            ], namespace=namespace)
             if self.print_debug:
                 print('Tag')
-                print('Tick handler:', handler)
+                print('%s: %s' % (tag_name, handler))
                 print()
             return
         # TODO refactor