fix dragging out from block children not working

CREDITS

@@ -1,3 +1,6 @@
+Trash Can icon by Icons8
+https://icons8.com/icon/rdRR1tq1xIo1/trash-can
+
 The Roboto Black font used in this project is licensed under the Open Font License. Read assets/fonts/OFL.txt for more information.
 
 Thanks to OpenGameArt and pixelsphere.org / The Cynic Project for the music! (https://opengameart.org/content/crystal-cave-mysterious-ambience-seamless-loop)

game/file_manager.py

@@ -7,7 +7,7 @@ from arcade.gui.experimental.scroll_area import UIScrollArea, UIScrollBar
 
 class FileManager(arcade.gui.UIAnchorLayout):
     def __init__(self, width, allowed_extensions):
-        super().__init__(size_hint=(0.95, 0.9), vertical=False)
+        super().__init__(size_hint=(0.95, 0.875), vertical=False)
 
         self.filemanager_width = width
 
@@ -20,11 +20,11 @@ class FileManager(arcade.gui.UIAnchorLayout):
         self.content_cache = {}
         self.pre_cache_contents()
 
-        self.current_directory_label = self.add(arcade.gui.UILabel(text=self.current_directory, font_name="Roboto", font_size=24), anchor_x="center", anchor_y="top", align_y=-5)
+        self.current_directory_label = self.add(arcade.gui.UILabel(text=self.current_directory, font_name="Roboto", font_size=22), anchor_x="center", anchor_y="top", align_y=-10)
 
         self.scroll_area = UIScrollArea(size_hint=(0.665, 0.7)) # center on screen
         self.scroll_area.scroll_speed = -50
-        self.add(self.scroll_area, anchor_x="center", anchor_y="center", align_y=self.filemanager_width * 0.05)
+        self.add(self.scroll_area, anchor_x="center", anchor_y="center", align_y=self.filemanager_width * 0.025)
 
         self.scrollbar = UIScrollBar(self.scroll_area)
         self.scrollbar.size_hint = (0.02, 1)
@@ -33,21 +33,18 @@ class FileManager(arcade.gui.UIAnchorLayout):
         self.files_box = arcade.gui.UIBoxLayout(space_between=5)
         self.scroll_area.add(self.files_box)
 
-        self.bottom_box = self.add(arcade.gui.UIBoxLayout(space_between=10), anchor_x="center", anchor_y="bottom", align_y=10)
+        self.bottom_box = self.add(arcade.gui.UIBoxLayout(space_between=5), anchor_x="center", anchor_y="bottom", align_y=5)
 
-        self.filename_label = self.bottom_box.add(arcade.gui.UILabel(text="Filename:", font_name="Roboto", font_size=20))
+        self.filename_label = self.bottom_box.add(arcade.gui.UILabel(text="Filename:", font_name="Roboto", font_size=17))
-        self.filename_input = self.bottom_box.add(arcade.gui.UIInputText(width=self.filemanager_width * 0.35, height=self.filemanager_width * 0.025).with_border(color=arcade.color.WHITE))
+        self.filename_input = self.bottom_box.add(arcade.gui.UIInputText(width=self.filemanager_width * 0.35, height=self.filemanager_width * 0.02).with_border(color=arcade.color.WHITE))
-        self.submit_button = self.bottom_box.add(arcade.gui.UITextureButton(texture=button_texture, texture_hovered=button_hovered_texture, text="Submit", style=button_style, width=self.filemanager_width * 0.2, height=self.filemanager_width * 0.05))
+        
+        self.submit_button = self.bottom_box.add(arcade.gui.UITextureButton(texture=button_texture, texture_hovered=button_hovered_texture, text="Submit", style=button_style, width=self.filemanager_width * 0.5, height=self.filemanager_width * 0.025))
         self.submit_button.on_click = lambda event: self.submit(self.current_directory)
 
         self.submit_button.visible = False
         self.filename_label.visible = False
         self.filename_input.visible = False
 
-        self.back_button = arcade.gui.UITextureButton(texture=button_texture, texture_hovered=button_hovered_texture, text='<--', style=button_style, width=100, height=50)
-        self.back_button.on_click = lambda event: self.exit()
-        self.add(self.back_button, anchor_x="left", anchor_y="top", align_x=5, align_y=-5)
-
         self.show_directory()
 
     def change_mode(self, mode):
@@ -125,10 +122,6 @@ class FileManager(arcade.gui.UIAnchorLayout):
     def disable(self):
         self.parent.parent.disable() # The FileManager UIManager. self.parent is the FileManager UIAnchorLayout
 
-    def exit(self):
-        self.disable()
-        self.submitted_content = "exit"
-
     def change_directory(self, directory):
         if directory.startswith("//"): # Fix / paths
             directory = directory[1:]

game/play.py

@@ -1,9 +1,9 @@
 import arcade, arcade.gui, pyglet, random, json
 
 from utils.preload import SPRITE_TEXTURES, button_texture, button_hovered_texture
-from utils.constants import button_style, dropdown_style, DO_RULES, IF_RULES, SHAPES, ALLOWED_INPUT, menu_background_color
+from utils.constants import button_style, DO_RULES, IF_RULES, SHAPES, ALLOWED_INPUT
 
-from game.rules import RuleUIBox
+from game.rules import RuleUI
 from game.sprites import BaseShape, Rectangle, Circle, Triangle
 from game.file_manager import FileManager
 
@@ -19,7 +19,7 @@ class Game(arcade.gui.UIView):
 
         self.anchor = self.add_widget(arcade.gui.UIAnchorLayout(size_hint=(1, 1)))
 
-        self.rules_box = RuleUIBox(self.window)
+        self.rules_box = RuleUI(self.window)
 
         self.file_manager = FileManager(self.window.width * 0.95, [".json"]).with_border()
 
@@ -35,8 +35,7 @@ class Game(arcade.gui.UIView):
         self.y_gravity = self.settings.get("default_y_gravity", 5)
         self.triggered_events = []
 
-        self.rulesets = self.rules_box.rulesets
+        self.rulesets, self.if_rules = self.rules_box.get_rulesets()
-        self.rule_values = self.rules_box.rule_values
 
         self.sprites_box = arcade.gui.UIAnchorLayout(size_hint=(0.95, 0.9))
 
@@ -165,9 +164,6 @@ class Game(arcade.gui.UIView):
     def on_show_view(self):
         super().on_show_view()
 
-        self.rules_box.add_rule(None, ["on_left_click", "spawn"])
-        self.rules_box.refresh_rules_display()
-
         self.sprites_box.add(arcade.gui.UILabel(text="Sprites", font_size=24, text_color=arcade.color.WHITE), anchor_x="center", anchor_y="top")
 
         self.sprites_grid = self.sprites_box.add(arcade.gui.UIGridLayout(columns=8, row_count=8, align="left", vertical_spacing=10, horizontal_spacing=10, size_hint=(0.95, 0.85)), anchor_x="center", anchor_y="center").with_border()
@@ -180,13 +176,13 @@ class Game(arcade.gui.UIView):
 
         self.triggered_events.append(["game_launch", {}])
 
-    def get_rule_values(self, ruleset_num, rule_num, rule_dict, event_args):
+    def get_rule_values(self, rule_dict, rule_values, event_args):
-        args = [self.rule_values[f"{ruleset_num}_{rule_num}_{user_var}_{n}"] for n, user_var in enumerate(rule_dict["user_vars"])]
+        args = [rule_values[f"{user_var}_{n}"] for n, user_var in enumerate(rule_dict["user_vars"])]
 
         return args + [event_args[var] for var in rule_dict.get("vars", []) if not var in rule_dict["user_vars"]]
 
-    def check_rule(self, ruleset_num, rule_num, rule_dict, event_args):
+    def check_rule(self, rule_dict, rule_values, event_args):
-        return rule_dict["func"](*self.get_rule_values(ruleset_num, rule_num, rule_dict, event_args))
+        return rule_dict["func"](*self.get_rule_values(rule_dict, rule_values, event_args))
     
     def get_action_function(self, action_dict):
         ACTION_FUNCTION_DICT = {
@@ -211,8 +207,8 @@ class Game(arcade.gui.UIView):
 
         return ACTION_FUNCTION_DICT[action_dict["type"]][action_dict["name"]]
 
-    def run_do_rule(self, ruleset_num, rule_num, rule_dict, event_args):
+    def run_do_rule(self, rule_dict, rule_values, event_args):
-        self.get_action_function(rule_dict["action"])(*self.get_rule_values(ruleset_num, rule_num, rule_dict, event_args))
+        self.get_action_function(rule_dict["action"])(*self.get_rule_values(rule_dict, rule_values, event_args))
 
     def on_update(self, delta_time):
         if self.mode == "import" and self.file_manager.submitted_content:
@@ -225,23 +221,8 @@ class Game(arcade.gui.UIView):
 
             self.rule_values = data["rule_values"]
             self.triggered_events = []
-            self.current_ruleset_num = 0
-            self.current_ruleset_page = 0
 
-            self.rules_content_box.clear()
+            # TODO: add rule loading here
-
-            for rule_box in self.rule_boxes.values():
-                rule_box.clear()
-                del rule_box
-
-            self.rule_labels = {}
-            self.rule_var_changers = {}
-            self.rule_boxes = {}
-            
-            for ruleset in data["rulesets"].values():
-                self.add_ruleset(ruleset)
-
-            self.refresh_rules_display()
 
         if self.mode == "export" and self.file_manager.submitted_content:            
             with open(self.file_manager.submitted_content, "w") as file:
@@ -257,57 +238,32 @@ class Game(arcade.gui.UIView):
 
         while len(self.triggered_events) > 0:
             trigger, trigger_args = self.triggered_events.pop(0)
-            for key, ruleset in self.rulesets.items():
-                if len(ruleset) == 2:
-                    if_rule_dict = IF_RULES[ruleset[0]]
-                    do_rule_dict = DO_RULES[ruleset[1]]
 
-                    if not if_rule_dict["trigger"] == trigger:
+            # In the new version, a DO rule's dependencies are the ruleset itself which trigger it
-                        continue
+            # Since there could be multiple IFs that depend on each other, we need to get the entrypoint values first and then interpret the tree.
+            event_args = trigger_args
 
-                    if do_rule_dict["action"]["type"] == "shape_action" or "shape_type" in if_rule_dict["user_vars"]:
+            if_rule_values = {}
-                        for shape in self.shapes:                            
+
-                            event_args = trigger_args.copy()
+            for if_rule in self.if_rules:
-                            if not "event_shape_type" in trigger_args:
+                if_rule_dict = IF_RULES[if_rule[0]]
-                                event_args.update({"event_shape_type": shape.shape_type, "shape_size": shape.shape_size, "shape_x": shape.x, "shape_y": shape.y, "shape": shape, "shape_color": shape.shape_color})
+                if "shape_type" in if_rule_dict["user_vars"]:
+                    is_true = False
+                    for shape in self.shapes:
+                        if is_true:
+                            break
 
-                            if self.check_rule(key, 1, if_rule_dict, event_args):
-                                self.run_do_rule(key, 2, do_rule_dict, event_args)
-                    else:
                         event_args = trigger_args.copy()
-                        if self.check_rule(key, 1, if_rule_dict, event_args):
+                        if not "event_shape_type" in trigger_args:
-                            self.run_do_rule(key, 2, do_rule_dict, event_args)
+                            event_args.update({"event_shape_type": shape.shape_type, "shape_size": shape.shape_size, "shape_x": shape.x, "shape_y": shape.y, "shape": shape, "shape_color": shape.shape_color})
+                        
+                        is_true = self.check_rule(if_rule_dict, if_rule[1], trigger_args)
+
+                    if_rule_values[if_rule[2]] = is_true
 
                 else:
-                    if_rule_dicts = IF_RULES[ruleset[0]], IF_RULES[ruleset[2]]
+                    event_args = trigger_args.copy()
-                    do_rule_dict = DO_RULES[ruleset[3]]
+                    if_rule_values[if_rule[2]] = self.check_rule(if_rule_dict, if_rule[1], trigger_args)
-
-                    if not (if_rule_dicts[0]["trigger"] == trigger and if_rule_dicts[0]["trigger"] == trigger):
-                        continue
-
-                    if do_rule_dict["action"]["type"] == "shape_action":
-                        for shape in self.shapes:
-                            event_args = trigger_args
-                            
-                            if not "event_shape_type" in trigger_args:
-                                event_args.update({"event_shape_type": shape.shape_type, "shape_size": shape.shape_size, "shape_x": shape.x, "shape_y": shape.y, "shape": shape, "shape_color": shape.shape_color})
-
-                            if ruleset[1] == "and":
-                                if self.check_rule(key, 1, if_rule_dicts[0], event_args) and self.check_rule(key, 2, if_rule_dicts[1], event_args):
-                                    self.run_do_rule(key, 3, do_rule_dict, event_args)
-
-                            elif ruleset[1] == "or":
-                                if self.check_rule(key, 1, if_rule_dicts[0], event_args) or self.check_rule(key, 2, if_rule_dicts[1], event_args):
-                                    self.run_do_rule(key, 3, do_rule_dict, event_args)
-                    else:
-                        event_args = trigger_args
-                        if ruleset[1] == "and":
-                            if self.check_rule(key, 1, if_rule_dicts[0], event_args) and self.check_rule(key, 2, if_rule_dicts[1], event_args):
-                                self.run_do_rule(key, 3, do_rule_dict, event_args)
-
-                        elif ruleset[1] == "or":
-                            if self.check_rule(key, 1, if_rule_dicts[0], event_args) or self.check_rule(key, 2, if_rule_dicts[1], event_args):
-                                self.run_do_rule(key, 3, do_rule_dict, event_args)
 
         for shape in self.shapes:
             for shape_b in self.shapes:
@@ -330,14 +286,28 @@ class Game(arcade.gui.UIView):
             self.triggered_events.append(["on_input", {"event_key": chr(symbol)}])
 
     def on_mouse_press(self, x, y, button, modifiers):
+        if not self.mode == "simulation":
+            return
+        
         if button == arcade.MOUSE_BUTTON_LEFT:
             self.triggered_events.append(["on_left_click", {}])
         elif self.mode == "simulation" and button == arcade.MOUSE_BUTTON_RIGHT:
             self.triggered_events.append(["on_right_click", {}])
 
     def on_mouse_motion(self, x, y, button, modifiers):
+        if not self.mode == "simulation":
+            return
+
         self.triggered_events.append(["on_mouse_move", {}])
 
+    def on_mouse_drag(self, x, y, dx, dy, _buttons, _modifiers):
+        if self.mode == "rules" and arcade.MOUSE_BUTTON_MIDDLE == _buttons:
+            self.rules_box.camera.position -= (dx, dy)
+
+    def on_mouse_scroll(self, x, y, scroll_x, scroll_y):
+        if self.mode == "rules":
+            self.rules_box.camera.zoom *= 1 + scroll_y * 0.1
+
     def disable_previous(self):
         if self.mode in ["import", "export"]:
             self.anchor.remove(self.file_manager)
@@ -361,7 +331,7 @@ class Game(arcade.gui.UIView):
         self.mode = "export"
 
         self.file_manager.change_mode("export")
-        self.anchor.add(self.file_manager, anchor_x="center", anchor_y="top")
+        self.anchor.add(self.file_manager, anchor_x="center", anchor_y="top", align_y=-self.window.height * 0.025)
 
     def import_file(self):
         self.disable_previous()
@@ -369,7 +339,7 @@ class Game(arcade.gui.UIView):
         self.mode = "import"
 
         self.file_manager.change_mode("import")
-        self.anchor.add(self.file_manager, anchor_x="center", anchor_y="top")
+        self.anchor.add(self.file_manager, anchor_x="center", anchor_y="top", align_y=-self.window.height * 0.025)
 
     def sprites(self):
         self.disable_previous()
@@ -381,6 +351,7 @@ class Game(arcade.gui.UIView):
     def simulation(self):
         self.disable_previous()
         
+        self.rulesets, self.if_rules = self.rules_box.get_rulesets()
         self.mode = "simulation"
 
     def main_exit(self):
@@ -392,5 +363,10 @@ class Game(arcade.gui.UIView):
         
         if self.mode == "simulation":
             self.shape_batch.draw()
+        elif self.mode == "rules":
+            with self.rules_box.camera.activate():
+                self.rules_box.draw()
+                
+            self.rules_box.draw_unproject()
    
         self.ui.draw()

game/rules.py

@@ -1,5 +1,23 @@
-from utils.constants import DO_RULES, IF_RULES, LOGICAL_OPERATORS, NON_COMPATIBLE_WHEN, NON_COMPATIBLE_DO_WHEN, VAR_NAMES, VAR_DEFAULT, VAR_OPTIONS, dropdown_style, slider_style
+from utils.constants import (
-import arcade, arcade.gui, random
+    DO_RULES,
+    IF_RULES,
+    NON_COMPATIBLE_WHEN,
+    NON_COMPATIBLE_DO_WHEN,
+    VAR_NAMES,
+    VAR_DEFAULT,
+    TRIGGER_RULES,
+    FOR_RULES,
+    button_style,
+    DO_COLOR,
+    IF_COLOR,
+    FOR_COLOR,
+    TRIGGER_COLOR
+)
+from typing import List
+from utils.preload import button_texture, button_hovered_texture, trash_bin
+from arcade.gui.experimental.scroll_area import UIScrollArea, UIScrollBar
+from dataclasses import dataclass, field
+import arcade, arcade.gui, pyglet, random
 
 IF_KEYS = tuple(IF_RULES.keys())
 DO_KEYS = tuple(DO_RULES.keys())
@@ -7,249 +25,372 @@ DO_KEYS = tuple(DO_RULES.keys())
 BAD_WHEN = {tuple(sorted(pair)) for pair in NON_COMPATIBLE_WHEN}
 BAD_DO_WHEN = {tuple(pair) for pair in NON_COMPATIBLE_DO_WHEN}
 
-def generate_ruleset(ruleset_type):
+def generate_rule(rule_type):
-    when_a = random.choice(IF_KEYS)
+    if rule_type == "if":
+        return random.choice(IF_KEYS)
+    elif rule_type == "do":
+        return random.choice(DO_KEYS)
     
-    if ruleset_type == "advanced":
+def get_rule_description(rule_type, rule):
-        valid_b = [
+    if rule_type == "if":
-            b for b in IF_KEYS
+        return IF_RULES[rule]["description"]
-            if b != when_a and tuple(sorted((when_a, b))) not in BAD_WHEN
+    if rule_type == "for":
-        ]
+        return FOR_RULES[rule]["description"]
+    if rule_type == "trigger":
+        return TRIGGER_RULES[rule]["description"]
+    if rule_type == "do":
+        return DO_RULES[rule]["description"]
     
-        if not valid_b:
+def per_widget_height(height, widget_count):
-            return [when_a, random.choice(DO_KEYS)]
+    return height // widget_count
 
-        when_b = random.choice(valid_b)
+def get_rule_defaults(rule_type):
-        logical = random.choice(LOGICAL_OPERATORS)
+    if rule_type == "if":
-    else:
+        return {
-        when_b = None
+            rule_key: (
-        logical = None
+                rule_dict["description"].format_map(
+                    {
+                        VAR_NAMES[n]: VAR_NAMES[n]
+                        for n, variable in enumerate(rule_dict["user_vars"])
+                    }
+                ),
+                {
+                    VAR_NAMES[n]: VAR_DEFAULT[variable]
+                    for n, variable in enumerate(rule_dict["user_vars"])
+                },
+            )
+            for rule_key, rule_dict in IF_RULES.items()
+        }
 
-    if when_b:
+    elif rule_type == "do":
-        valid_do = [
+        return {
-            d for d in DO_KEYS
+            rule_key: (
-            if (when_a, d) not in BAD_DO_WHEN
+                rule_dict["description"].format_map(
-            and (when_b, d) not in BAD_DO_WHEN
+                    {
-            and (d, when_a) not in BAD_DO_WHEN
+                        VAR_NAMES[n]: VAR_NAMES[n]
-            and (d, when_b) not in BAD_DO_WHEN
+                        for n, variable in enumerate(rule_dict["user_vars"])
-        ]
+                    }
-    else:
+                ),
-        valid_do = [
+                {
-            d for d in DO_KEYS
+                    VAR_NAMES[n]: VAR_DEFAULT[variable]
-            if (when_a, d) not in BAD_DO_WHEN
+                    for n, variable in enumerate(rule_dict["user_vars"])
-            and (d, when_a) not in BAD_DO_WHEN
+                },
-        ]
+            )
+            for rule_key, rule_dict in DO_RULES.items()
+        }
 
-    do = random.choice(valid_do)
+@dataclass
+class Block:
+    x: float
+    y: float
+    label: str
+    rule_type: str
+    rule: str
+    rule_num: int
+    rule_values: dict[str, int | str]
+    children: List["Block"] = field(default_factory=list)
 
-    if logical:
+class BlockRenderer:
-        return [when_a, logical, when_b, do]
+    def __init__(self, blocks: List[Block], indent: int = 10):
-    else:
+        self.blocks = blocks
-        return [when_a, do]
+        self.indent = indent
+        self.shapes = pyglet.graphics.Batch()
+        self.shapes_by_rule_num = {}
+        self.text_objects = []
+        self.text_by_rule_num = {}
+        self.refresh()
+
+    def refresh(self):
+        for shapes_list in self.shapes_by_rule_num.values():
+            for shape in shapes_list:
+                shape.delete()
+        
+        for text_list in self.text_by_rule_num.values():
+            for text in text_list:
+                text.delete()
+
+        self.shapes = pyglet.graphics.Batch()
+        self.shapes_by_rule_num = {}
+        self.text_objects = []
+        self.text_by_rule_num = {}
+        for b in self.blocks.values():
+            self._build_block(b, b.x, b.y)
+
+    def _build_block(self, b: Block, x: int, y: int) -> int:
+        is_wrap = b.rule_type != "do"
+        h, w = 42, 280
+
+        if b.rule_type == "if":
+            color = IF_COLOR
+        elif b.rule_type == "trigger":
+            color = TRIGGER_COLOR
+        elif b.rule_type == "do":
+            color = DO_COLOR
+        elif b.rule_type == "for":
+            color = FOR_COLOR
+
+        lx, ly = x, y - h 
+        
+        if b.rule_num not in self.shapes_by_rule_num:
+            self.shapes_by_rule_num[b.rule_num] = []
+        if b.rule_num not in self.text_by_rule_num:
+            self.text_by_rule_num[b.rule_num] = []
+        
+        rect = pyglet.shapes.BorderedRectangle(lx, ly, w, h, 2, color, arcade.color.BLACK, batch=self.shapes)
+        self.shapes_by_rule_num[b.rule_num].append(rect)
+        
+        text_obj = pyglet.text.Label(text=b.label, x=lx + 10, y=ly + 20, color=arcade.color.BLACK, font_size=12, weight="bold")
+        self.text_objects.append(text_obj)
+        self.text_by_rule_num[b.rule_num].append(text_obj)
+
+        ny = ly
+        if is_wrap:
+            iy = ny
+            for child in b.children:
+                child.x = lx + self.indent + 5
+                child.y = iy - 2
+                iy = self._build_block(child, lx + self.indent + 5, iy - 2)
+            
+            bar_h = ny - iy 
+            bar_filled = pyglet.shapes.Rectangle(lx + 2, iy + 2, self.indent, bar_h, color, batch=self.shapes)
+            line1 = pyglet.shapes.Line(lx, ny, lx, iy, 2, arcade.color.BLACK, batch=self.shapes)
+            bottom = pyglet.shapes.BorderedRectangle(lx, iy - 8, w, 24, 2, color, arcade.color.BLACK, batch=self.shapes)
+
+            self.shapes_by_rule_num[b.rule_num].extend([bar_filled, line1, bottom])
+            
+            return iy - 24
+        else:
+            for child in b.children:
+                ny = self._build_block(child, lx, ny)
+            return ny
+
+    def move_block(self, x, y, rule_num):
+        for element in self.shapes_by_rule_num[rule_num] + self.text_by_rule_num[rule_num]:
+            element.x += x
+            element.y += y
+
+        block = self._find_block(rule_num)
+
+        for child in block.children:
+            self.move_block(x, y, child.rule_num)
+
+    def _find_block(self, rule_num):
+        if rule_num in self.blocks:
+            return self.blocks[rule_num]
+        
+        for block in self.blocks.values():
+            found = self._find_block_recursive(block, rule_num)
+            if found:
+                return found
+        return None
+
+    def _find_block_recursive(self, block, rule_num):
+        for child in block.children:
+            if child.rule_num == rule_num:
+                return child
+            found = self._find_block_recursive(child, rule_num)
+            if found:
+                return found
+        return None
+
+    def draw(self):
+        self.shapes.draw()
+        for t in self.text_objects:
+            t.draw()
+
+class RuleUI(arcade.gui.UIAnchorLayout):
+    def __init__(self, window: arcade.Window):
+        super().__init__(size_hint=(1, 0.875))
 
-class RuleUIBox(arcade.gui.UIBoxLayout):
-    def __init__(self, window):
-        super().__init__(space_between=10, align="center", size_hint=(0.95, 0.75))
         self.window = window
-        self.current_ruleset_num = 0
+        self.current_rule_num = 0
-        self.current_ruleset_page = 0
-        self.rulesets_per_page = 2
-        self.rulesets = {}
         self.rule_values = {}
 
-        self.rule_labels = {}
+        self.rulesets: dict[int, Block] = {}
-        self.rule_var_changers = {}
-        self.rule_boxes = {}
 
-        self.nav_buttons_box = None
+        self.block_renderer = BlockRenderer(self.rulesets)
+        self.camera = arcade.Camera2D()
     
-        self.rules_label = self.add(arcade.gui.UILabel(text="Rules", font_size=20, text_color=arcade.color.WHITE))
+        self.dragged_rule_ui: Block | None = None
-        self.add(arcade.gui.UISpace(height=self.window.height / 70, width=self.window.width * 0.25))
 
-        self.add_simple_rule_button = self.add(arcade.gui.UIFlatButton(text="Add Simple rule", width=self.window.width * 0.225, height=self.window.height / 25, style=dropdown_style))
+        self.rules_label = self.add(
-        self.add_simple_rule_button.on_click = lambda event: self.add_rule("simple")
+            arcade.gui.UILabel(
+                text="Rules", font_size=20, text_color=arcade.color.WHITE
+            ),
+            anchor_x="center",
+            anchor_y="top"
+        )
 
-        self.add(arcade.gui.UISpace(height=self.window.height / 85))
+        self.add(
+            arcade.gui.UISpace(
+                height=self.window.height / 70, width=self.window.width * 0.25
+            )
+        )
 
-        self.add_advanced_rule_button = self.add(arcade.gui.UIFlatButton(text="Add Advanced rule", width=self.window.width * 0.225, height=self.window.height / 25, style=dropdown_style))
+        self.create_sidebar = self.add(arcade.gui.UIBoxLayout(size_hint=(0.15, 1), vertical=False, space_between=5), anchor_x="left", anchor_y="bottom")
-        self.add_advanced_rule_button.on_click = lambda event: self.add_rule("advanced")
 
-        self.add(arcade.gui.UISpace(height=self.window.height / 85))
+        self.scroll_area = UIScrollArea(size_hint=(0.95, 1)) # center on screen
+        self.scroll_area.scroll_speed = -50
+        self.create_sidebar.add(self.scroll_area)
 
-        self.nav_buttons_box = self.add(arcade.gui.UIBoxLayout(vertical=False, space_between=10))
+        self.scrollbar = UIScrollBar(self.scroll_area)
+        self.scrollbar.size_hint = (0.075, 1)
+        self.create_sidebar.add(self.scrollbar)
 
-        self.prev_button = self.nav_buttons_box.add(arcade.gui.UIFlatButton(text="Previous", width=self.window.width * 0.1, height=self.window.height / 25, style=dropdown_style))
+        self.create_box = self.scroll_area.add(arcade.gui.UIBoxLayout(space_between=10))
-        self.prev_button.on_click = self.prev_page
 
-        self.next_button = self.nav_buttons_box.add(arcade.gui.UIFlatButton(text="Next", width=self.window.width * 0.1, height=self.window.height / 25, style=dropdown_style))
+        self.create_box.add(arcade.gui.UISpace(height=self.window.height / 100))
-        self.next_button.on_click = self.next_page
+        self.create_box.add(arcade.gui.UILabel(text="Trigger Rules", font_size=18))
+        self.create_box.add(arcade.gui.UISpace(height=self.window.height / 200))
+        for trigger_rule, trigger_rule_data in TRIGGER_RULES.items():
+            create_button = self.create_box.add(arcade.gui.UITextureButton(text=trigger_rule_data["description"].format_map({
+                "a": "a",
+                "b": "b",
+                "c": "c"
+            }), width=self.window.width * 0.125, multiline=True, height=self.window.height * 0.05, style=button_style, texture=button_texture, texture_hovered=button_hovered_texture))
+            create_button.on_click = lambda event, trigger_rule=trigger_rule: self.add_rule("trigger", trigger_rule)
 
-        self.rules_content_box = self.add(arcade.gui.UIBoxLayout(align="center"))
+        self.create_box.add(arcade.gui.UISpace(height=self.window.height / 100))
+        self.create_box.add(arcade.gui.UILabel(text="IF Rules", font_size=18))
+        self.create_box.add(arcade.gui.UISpace(height=self.window.height / 200))
+        for if_rule, if_rule_data in IF_RULES.items():
+            create_button = self.create_box.add(arcade.gui.UITextureButton(text=if_rule_data["description"].format_map({
+                "a": "a",
+                "b": "b",
+                "c": "c"
+            }), width=self.window.width * 0.135, multiline=True, height=self.window.height * 0.05, style=button_style, texture=button_texture, texture_hovered=button_hovered_texture))
+            create_button.on_click = lambda event, if_rule=if_rule: self.add_rule("if", if_rule)
 
-    def get_rule_defaults(self, rule_type):
+        self.create_box.add(arcade.gui.UISpace(height=self.window.height / 100))
-        if rule_type == "if":
+        self.create_box.add(arcade.gui.UILabel(text="DO Rules", font_size=18))
-            return {
+        self.create_box.add(arcade.gui.UISpace(height=self.window.height / 200))
-                    rule_key: (
+        for do_rule, do_rule_data in DO_RULES.items():
-                        rule_dict["description"].format_map({VAR_NAMES[n]: VAR_NAMES[n] for n, variable in enumerate(rule_dict["user_vars"])}), 
+            create_button = self.create_box.add(arcade.gui.UITextureButton(text=do_rule_data["description"].format_map({
-                        {VAR_NAMES[n]: VAR_DEFAULT[variable] for n, variable in enumerate(rule_dict["user_vars"])}
+                "a": "a",
-                    ) 
+                "b": "b",
-                    for rule_key, rule_dict in IF_RULES.items()
+                "c": "c"
-            }
+            }), width=self.window.width * 0.135, multiline=True, height=self.window.height * 0.05, style=button_style, texture=button_texture, texture_hovered=button_hovered_texture))
-        elif rule_type == "do":
+            create_button.on_click = lambda event, do_rule=do_rule: self.add_rule("do", do_rule)
-            return {
-                    rule_key: (
-                        rule_dict["description"].format_map({VAR_NAMES[n]: VAR_NAMES[n] for n, variable in enumerate(rule_dict["user_vars"])}), 
-                        {VAR_NAMES[n]: VAR_DEFAULT[variable] for n, variable in enumerate(rule_dict["user_vars"])}
-                    ) 
-                    for rule_key, rule_dict in DO_RULES.items()
-            }
             
-    def create_rule_ui(self, rule_box: arcade.gui.UIBoxLayout, rule, rule_type, rule_num=1, is_import=False):
+        self.create_box.add(arcade.gui.UISpace(height=self.window.height / 100))
-        defaults = self.get_rule_defaults(rule_type)
+        self.create_box.add(arcade.gui.UILabel(text="For Rules", font_size=18))
-        rule_dict = IF_RULES[rule] if rule_type == "if" else DO_RULES[rule]
+        self.create_box.add(arcade.gui.UISpace(height=self.window.height / 200))
-        ruleset_num = self.current_ruleset_num
+        for for_rule, for_rule_data in FOR_RULES.items():
-        default_values = defaults[rule][1]
+            create_button = self.create_box.add(arcade.gui.UITextureButton(text=for_rule_data["description"].format_map({
+                "a": "a",
+                "b": "b",
+                "c": "c"
+            }), width=self.window.width * 0.135, multiline=True, height=self.window.height * 0.05, style=button_style, texture=button_texture, texture_hovered=button_hovered_texture))
+            create_button.on_click = lambda event, for_rule=for_rule: self.add_rule("for", for_rule)
             
-        dropdown_options = [desc for desc, _ in defaults.values()]
+        self.trash_spritelist = arcade.SpriteList()
-        desc_label = rule_box.add(arcade.gui.UIDropdown(default=defaults[rule][0], options=dropdown_options, font_size=13, width=self.window.width * 0.225, active_style=dropdown_style, primary_style=dropdown_style, dropdown_style=dropdown_style))
+        self.trash_sprite = trash_bin
-        desc_label.on_change = lambda event, rule_type=rule_type, ruleset_num=ruleset_num, rule_num=rule_num: self.change_rule_type(ruleset_num, rule_num, rule_type, event.new_value)
+        self.trash_sprite.scale = 0.5
-        self.rule_labels[f"{self.current_ruleset_num}_{rule_num}_desc"] = desc_label
+        self.trash_sprite.position = (self.window.width * 0.9, self.window.height * 0.2)
+        self.trash_spritelist.append(self.trash_sprite)
 
-        for n, variable_type in enumerate(rule_dict["user_vars"]):
+    def get_rulesets(self):
-            key = f"{self.current_ruleset_num}_{rule_num}_{variable_type}_{n}"
+        # TODO: remove this
+        return [], []
 
-            if not is_import:
+    def generate_pos(self):
-                self.rule_values[key] = default_values[VAR_NAMES[n]]
+        return random.randint(
+            self.window.width * 0.1, int(self.window.width * 0.9)
+        ), random.randint(self.window.height * 0.1, int(self.window.height * 0.7))
 
-            label = rule_box.add(arcade.gui.UILabel(f'{VAR_NAMES[n]}: {self.rule_values[key]}', font_size=11, width=self.window.width * 0.225, height=self.window.height / 30))
+    def add_rule(self, rule_type, force=None):
-            self.rule_labels[key] = label
+        rule = force or generate_rule(rule_type)
+        rule_box = Block(
+            *self.generate_pos(),
+            get_rule_description(rule_type, rule),
+            rule_type,
+            rule,
+            self.current_rule_num,
+            {},
+            []
+        )
 
-            if variable_type in ["variable", "size"]: 
+        self.rulesets[self.current_rule_num] = rule_box
-                slider = rule_box.add(arcade.gui.UISlider(value=self.rule_values[key], min_value=VAR_OPTIONS[variable_type][0], max_value=VAR_OPTIONS[variable_type][1], step=1, style=slider_style, width=self.window.width * 0.225, height=self.window.height / 30))
+        self.current_rule_num += 1
-                slider._render_steps = lambda surface: None  
+        self.block_renderer.refresh()
-                slider.on_change = lambda event, variable_type=variable_type, rule=rule, rule_type=rule_type, ruleset_num=ruleset_num, rule_num=rule_num, n=n: self.change_rule_value(ruleset_num, rule_num, rule, rule_type, variable_type, n, event.new_value)
-                self.rule_var_changers[key] = slider
 
+        return rule_box
+
+    def draw(self):
+        self.block_renderer.draw()
+
+    def draw_unproject(self):
+        self.trash_spritelist.draw()
+
+    def drag_n_drop_check(self, blocks):
+        for block in blocks:
+            if block == self.dragged_rule_ui:
+                continue
+
+            if arcade.LBWH(block.x, block.y - 44, 280, 44).intersection(arcade.LBWH(self.dragged_rule_ui.x, self.dragged_rule_ui.y - 44, 280, 44)):
+                block.children.append(self.dragged_rule_ui)
+                del self.rulesets[self.dragged_rule_ui.rule_num]
+                self.block_renderer.refresh()
+                break
             else:
-                dropdown = rule_box.add(arcade.gui.UIDropdown(default=self.rule_values[key], options=VAR_OPTIONS[variable_type], active_style=dropdown_style, primary_style=dropdown_style, dropdown_style=dropdown_style, width=self.window.width * 0.225, height=self.window.height / 30))
+                self.drag_n_drop_check(block.children)
-                dropdown.on_change = lambda event, variable_type=variable_type, rule=rule, rule_type=rule_type, ruleset_num=ruleset_num, rule_num=rule_num, n=n: self.change_rule_value(ruleset_num, rule_num, rule, rule_type, variable_type, n, event.new_value)
-                self.rule_var_changers[key] = dropdown
 
-    def change_rule_type(self, ruleset_num, rule_num, rule_type, new_rule_text):
+    def remove_from_parent(self, block_to_remove, parents):
-        defaults = self.get_rule_defaults(rule_type)
+        for parent in parents:
-        new_rule_name = next(key for key, default_list in defaults.items() if default_list[0] == new_rule_text)
+            if block_to_remove in parent.children:
+                self.rulesets[block_to_remove.rule_num] = block_to_remove 
+                parent.children.remove(block_to_remove)
+                return True
+            if self.remove_from_parent(block_to_remove, parent.children):
+                return True
+        return False
 
-        ruleset = self.rulesets[ruleset_num]
+    def press_check(self, event, blocks):
+        for block in blocks:
+            if block == self.dragged_rule_ui:
+                continue
 
-        if len(ruleset) == 2:
+            projected_vec = self.camera.unproject((event.x, event.y))
-            if rule_type == "if":
+            if arcade.LBWH(block.x, block.y - 44, 280, 44).point_in_rect((projected_vec.x, projected_vec.y)):
-                ruleset[0] = new_rule_name
+                if block not in list(self.rulesets.values()):  # its children
+                    self.remove_from_parent(block, list(self.rulesets.values()))
+                    self.block_renderer.refresh()
+                self.dragged_rule_ui = block
+                break
             else:
-                ruleset[1] = new_rule_name
+                self.press_check(event, block.children)
+
+    def on_event(self, event):
+        super().on_event(event)
+
+        if isinstance(event, arcade.gui.UIMouseDragEvent):
+            if event.buttons == arcade.MOUSE_BUTTON_LEFT:
+                if self.dragged_rule_ui is not None:
+                    self.dragged_rule_ui.x += event.dx
+                    self.dragged_rule_ui.y += event.dy
+                    self.block_renderer.move_block(event.dx, event.dy, self.dragged_rule_ui.rule_num)
+
+        elif isinstance(event, arcade.gui.UIMousePressEvent):
+            self.press_check(event, list(self.rulesets.values()))
+
+        elif isinstance(event, arcade.gui.UIMouseReleaseEvent):
+            if self.dragged_rule_ui:
+                block_vec = self.camera.unproject((self.dragged_rule_ui.x, self.dragged_rule_ui.y))
+                if self.trash_sprite.rect.intersection(arcade.LBWH(block_vec.x, block_vec.y, 280, 44)) and not self.trash_sprite._current_keyframe_index == self.trash_sprite.animation.num_frames - 1:
+                    del self.rulesets[self.dragged_rule_ui.rule_num]
+                    self.dragged_rule_ui = None
+                    self.block_renderer.refresh()
+                    return
+
+                self.drag_n_drop_check(list(self.rulesets.values()))
+
+            self.dragged_rule_ui = None
+
+    def on_update(self, dt):
+        if self.dragged_rule_ui:
+            block_vec = self.camera.unproject((self.dragged_rule_ui.x, self.dragged_rule_ui.y))
+            if self.trash_sprite.rect.intersection(arcade.LBWH(block_vec.x, block_vec.y, 280, 44)) and not self.trash_sprite._current_keyframe_index == self.trash_sprite.animation.num_frames - 1:
+                self.trash_sprite.update_animation()
         else:
-            if rule_type == "if":
+            self.trash_sprite.time = 0
-                if rule_num == 1:
+            self.trash_sprite.update_animation()
-                    ruleset[0] = new_rule_name
-                else:
-                    ruleset[2] = new_rule_name
-            else:
-                ruleset[3] = new_rule_name
-
-        self.rebuild_ruleset_ui(ruleset_num)
-
-    def rebuild_ruleset_ui(self, ruleset_num):
-        rule_box = self.rule_boxes[ruleset_num]
-        
-        keys_to_remove = [k for k in self.rule_labels.keys() if k.startswith(f"{ruleset_num}_")]
-        for key in keys_to_remove:
-            del self.rule_labels[key]
-        
-        keys_to_remove = [k for k in self.rule_var_changers.keys() if k.startswith(f"{ruleset_num}_")]
-        for key in keys_to_remove:
-            del self.rule_var_changers[key]
-        
-        keys_to_remove = [k for k in self.rule_values.keys() if k.startswith(f"{ruleset_num}_")]
-        for key in keys_to_remove:
-            del self.rule_values[key]
-        
-        rule_box.clear()
-        
-        ruleset = self.rulesets[ruleset_num]
-        old_ruleset_num = self.current_ruleset_num
-        self.current_ruleset_num = ruleset_num
-        
-        if len(ruleset) == 2:
-            self.create_rule_ui(rule_box, ruleset[0], "if")
-            self.create_rule_ui(rule_box, ruleset[1], "do", 2)
-        else:
-            self.create_rule_ui(rule_box, ruleset[0], "if")
-            rule_box.add(arcade.gui.UILabel(ruleset[1].upper(), font_size=14, width=self.window.width * 0.25))
-            self.create_rule_ui(rule_box, ruleset[2], "if", 2)
-            self.create_rule_ui(rule_box, ruleset[3], "do", 3)
-        
-        self.current_ruleset_num = old_ruleset_num
-
-    def add_ruleset(self, ruleset, is_import=False):
-        rule_box = arcade.gui.UIBoxLayout(space_between=5, align="left")
-        self.rule_boxes[self.current_ruleset_num] = rule_box
-
-        if len(ruleset) == 2:
-            self.rulesets[self.current_ruleset_num] = ruleset
-            
-            self.create_rule_ui(rule_box, ruleset[0], "if", 1, is_import)
-            self.create_rule_ui(rule_box, ruleset[1], "do", 2, is_import)
-
-        else:
-            self.rulesets[self.current_ruleset_num] = ruleset
-
-            self.create_rule_ui(rule_box, ruleset[0], "if", 1, is_import)
-            rule_box.add(arcade.gui.UILabel(ruleset[1].upper(), font_size=14, width=self.window.width * 0.25))
-            self.create_rule_ui(rule_box, ruleset[2], "if", 2, is_import)
-            self.create_rule_ui(rule_box, ruleset[3], "do", 3, is_import)
-
-    def refresh_rules_display(self):
-        self.rules_content_box.clear()
-
-        sorted_keys = sorted(self.rule_boxes.keys())
-        start_idx = self.current_ruleset_page * self.rulesets_per_page
-        end_idx = start_idx + self.rulesets_per_page
-        visible_keys = sorted_keys[start_idx:end_idx]
-
-        for key in visible_keys:
-            self.rules_content_box.add(self.rule_boxes[key])
-            self.rules_content_box.add(arcade.gui.UISpace(height=self.window.height / 50))
-
-    def next_page(self, event):
-        sorted_keys = sorted(self.rule_boxes.keys())
-        max_page = (len(sorted_keys) - 1) // self.rulesets_per_page
-        if self.current_ruleset_page < max_page:
-            self.current_ruleset_page += 1
-            self.refresh_rules_display()
-
-    def prev_page(self, event):
-        if self.current_ruleset_page > 0:
-            self.current_ruleset_page -= 1
-            self.refresh_rules_display()
-
-    def change_rule_value(self, ruleset_num, rule_num, rule, rule_type, variable_type, n, value):
-        rule_dict = IF_RULES[rule] if rule_type == "if" else DO_RULES[rule]
-        key = f"{ruleset_num}_{rule_num}_{variable_type}_{n}"
-        
-        self.rule_values[key] = value
-        
-        values = {}
-        for i, variable in enumerate(rule_dict["user_vars"]):
-            lookup_key = f"{ruleset_num}_{rule_num}_{variable}_{i}"
-            values[VAR_NAMES[i]] = self.rule_values.get(lookup_key, VAR_DEFAULT[variable])
-        
-        description = rule_dict["description"].format_map(values)
-        
-        self.rule_labels[f"{ruleset_num}_{rule_num}_desc"].text = description
-        self.rule_labels[key].text = f'{VAR_NAMES[n]}: {value}'
-
-    def add_rule(self, ruleset_type=None, force=None):
-        self.rulesets[self.current_ruleset_num] = generate_ruleset(ruleset_type) if not force else force
-        self.add_ruleset(self.rulesets[self.current_ruleset_num])
-        self.current_ruleset_num += 1
-        if self.rules_content_box:
-            self.refresh_rules_display()

utils/constants.py

@@ -3,12 +3,16 @@ from arcade.types import Color
 from arcade.gui.widgets.buttons import UITextureButtonStyle, UIFlatButtonStyle
 from arcade.gui.widgets.slider import UISliderStyle
 
-LOGICAL_OPERATORS = ["and", "or"]
 SHAPES = ["rectangle", "circle", "triangle"]
 VAR_NAMES = ["a", "b", "c", "d", "e", "f", "g"]
 
 ALLOWED_INPUT = ["a", "b", "c", "d", "e", "q", "w", "s", "t"]
 
+TRIGGER_COLOR = (255, 204, 102)
+DO_COLOR = (102, 178, 255)
+IF_COLOR = (144, 238, 144)
+FOR_COLOR = (255, 182, 193)
+
 COLORS = [
     "BLACK", "WHITE", "GRAY", "DARK_GRAY", "CYAN", 
     "AMBER", "AQUA", "GREEN", "LIGHT_GREEN",
@@ -45,38 +49,43 @@ VAR_OPTIONS = {
     "comparison": COMPARISONS
 }
 
-IF_RULES = {
+TRIGGER_RULES = {
+    "every_update": {
+        "key": "every_update",
+        "description": "Every Update",
+    },
+    "start": {
+        "key": "start",
+        "description": "On Game Start",
+    },
+    "on_input": {
+        "key": "on_input",
+        "description": "IF {a} key is pressed",
+    },
     "x_position_compare": {
         "key": "x_position_compare",
         "description": "IF X for {a} shape is {b} {c}",
-        "trigger": "every_update",
         "user_vars": ["shape_type", "comparison", "variable"],
         "vars": ["shape_type", "comparison", "variable", "event_shape_type", "shape_x"],
         "func": lambda *v: (v[0] == v[3]) and eval(f"{v[4]} {v[1]} {v[2]}")
     },
-    
     "y_position_compare": {
         "key": "y_position_compare",
         "description": "IF Y for {a} shape is {b} {c}",
-        "trigger": "every_update",
         "user_vars": ["shape_type", "comparison", "variable"],
         "vars": ["shape_type", "comparison", "variable", "event_shape_type", "shape_y"],
         "func": lambda *v: (v[0] == v[3]) and eval(f"{v[4]} {v[1]} {v[2]}")
     },
-    
     "size_compare": {
         "key": "size_compare",
         "description": "IF {a} shape size is {b} {c}",
-        "trigger": "every_update",
         "user_vars": ["shape_type", "comparison", "variable"],
         "vars": ["shape_type", "comparison", "variable", "event_shape_type", "shape_size"],
         "func": lambda *v: (v[0] == v[3]) and eval(f"{v[4]} {v[1]} {v[2]}")
     },
-    
     "spawns": {
         "key": "spawns",
         "description": "IF {a} shape spawns",
-        "trigger": "spawn",
         "user_vars": ["shape_type"],
         "vars": ["shape_type", "event_shape_type"],
         "func": lambda *v: v[0] == v[1]
@@ -84,7 +93,6 @@ IF_RULES = {
     "destroyed": {
         "key": "destroyed",
         "description": "IF {a} shape is destroyed",
-        "trigger": "destroyed",
         "user_vars": ["shape_type"],
         "vars": ["shape_type", "event_shape_type"],
         "func": lambda *v: v[0] == v[1]
@@ -92,7 +100,6 @@ IF_RULES = {
     "x_velocity_changes": {
         "key": "x_velocity_changes",
         "description": "IF {a} shape X velocity changes",
-        "trigger": "x_velocity_change",
         "user_vars": ["shape_type"],
         "vars": ["shape_type", "event_shape_type"],
         "func": lambda *v: v[0] == v[1]
@@ -100,7 +107,6 @@ IF_RULES = {
     "y_velocity_changes": {
         "key": "y_velocity_changes",
         "description": "IF {a} shape Y velocity changes",
-        "trigger": "y_velocity_change",
         "user_vars": ["shape_type"],
         "vars": ["shape_type", "event_shape_type"],
         "func": lambda *v: v[0] == v[1]
@@ -108,7 +114,6 @@ IF_RULES = {
     "color_changes": {
         "key": "color_changes",
         "description": "IF {a} shape color changes",
-        "trigger": "color_change",
         "user_vars": ["shape_type"],
         "vars": ["shape_type", "event_shape_type"],
         "func": lambda *v: v[0] == v[1]
@@ -116,7 +121,6 @@ IF_RULES = {
     "size_changes": {
         "key": "size_changes",
         "description": "IF {a} shape size changes",
-        "trigger": "size_change",
         "user_vars": ["shape_type"],
         "vars": ["shape_type", "event_shape_type"],
         "func": lambda *v: v[0] == v[1]
@@ -124,7 +128,6 @@ IF_RULES = {
     "morphs": {
         "key": "morphs",
         "description": "IF {a} shape morphs into {b}",
-        "trigger": "morph",
         "user_vars": ["shape_type", "target_type"],
         "vars": ["shape_type", "target_type", "event_a_type", "event_b_type"],
         "func": lambda *v: (v[0] == v[2]) and (v[3] == v[1])
@@ -132,59 +135,62 @@ IF_RULES = {
     "collides": {
         "key": "collides",
         "description": "IF {a} shape collides with {b}",
-        "trigger": "collision",
         "user_vars": ["shape_type", "target_type"],
         "vars": ["shape_type", "target_type", "event_a_type", "event_b_type"],
         "func": lambda *v: (v[0] == v[2]) and (v[3] == v[1])
     },
-    "on_left_click": {
+}
-        "key": "on_left_click",
+
-        "description": "IF you left click",
+FOR_RULES = {
-        "trigger": "on_left_click",
+    "every_shape": {
-        "user_vars": [],
+        "key": "every_shape",
-        "vars": [],
+        "description": "For every shape",
-        "func": lambda *v: True
+    }
+}
+
+IF_RULES = {
+    "x_position_compare": {
+        "key": "x_position_compare",
+        "description": "IF X is {a} {b}",
+        "user_vars": ["comparison", "variable"],
+        "vars": ["comparison", "variable", "shape_x"],
+        "func": lambda *v: eval(f"{v[2]} {v[0]} {v[1]}")
     },
-    "on_right_click": {
+    "y_position_compare": {
-        "key": "on_right_click",
+        "key": "y_position_compare",
-        "description": "IF you right click",
+        "description": "IF Y is {a} {b}",
-        "trigger": "on_right_click",
+        "user_vars": ["comparison", "variable"],
-        "user_vars": [],
+        "vars": ["comparison", "variable", "shape_y"],
-        "vars": [],
+        "func": lambda *v: eval(f"{v[2]} {v[0]} {v[1]}")
-        "func": lambda *v: True
     },
-    "on_mouse_move": {
+    "size_compare": {
-        "key": "on_mouse_move",
+        "key": "size_compare",
-        "description": "IF mouse moves",
+        "description": "IF size is {a} {b}",
-        "trigger": "on_mouse_move",
+        "user_vars": ["comparison", "variable"],
-        "user_vars": [],
+        "vars": ["comparison", "variable", "shape_size"],
-        "vars": [],
+        "func": lambda *v: eval(f"{v[2]} {v[0]} {v[1]}")
-        "func": lambda *v: True
     },
-    "on_input": {
+    "x_velocity_compare": {
-        "key": "on_input",
+        "key": "x_velocity_compare",
-        "description": "IF {a} key is pressed",
+        "description": "IF X velocity is {a} {b}",
-        "trigger": "on_input",
+        "user_vars": ["comparison", "variable"],
-        "user_vars": ["key_input"],
+        "vars": ["comparison", "variable", "shape_x_velocity"],
-        "vars": ["key_input", "event_key"],
+        "func": lambda *v: eval(f"{v[2]} {v[0]} {v[1]}")
+    },
+    "y_velocity_compare": {
+        "key": "y_velocity_compare",
+        "description": "IF Y velocity is {a} {b}",
+        "user_vars": ["comparison", "variable"],
+        "vars": ["comparison", "variable", "shape_y_velocity"],
+        "func": lambda *v: eval(f"{v[2]} {v[0]} {v[1]}")
+    },
+    "color_is": {
+        "key": "color_is",
+        "description": "IF color is {a}",
+        "user_vars": ["color"],
+        "vars": ["color", "shape_color"],
         "func": lambda *v: v[0] == v[1]
     },
-    "game_launch": {
-        "key": "game_launch",
-        "description": "IF game launches",
-        "trigger": "game_launch",
-        "user_vars": [],
-        "vars": [],
-        "func": lambda *v: True
-    },
-    "every_update": {
-        "key": "every_update",
-        "description": "Every update",
-        "trigger": "every_update",
-        "user_vars": [],
-        "vars": [],
-        "func": lambda *v: True
-    }
 }
 
 NON_COMPATIBLE_WHEN = [

utils/preload.py

@@ -8,9 +8,10 @@ button_texture = arcade.gui.NinePatchTexture(64 // 4, 64 // 4, 64 // 4, 64 // 4,
 button_hovered_texture = arcade.gui.NinePatchTexture(64 // 4, 64 // 4, 64 // 4, 64 // 4, arcade.load_texture(os.path.join(_assets_dir, 'graphics', 'button_hovered.png')))
 
 SPRITE_TEXTURES = {
-    "circle": arcade.load_texture(os.path.join(_assets_dir, 'graphics', 'sprites', 'circle.png')),
+    os.path.splitext(file_name)[0]: arcade.load_texture(os.path.join(_assets_dir, 'graphics', 'sprites', file_name))
-    "rectangle": arcade.load_texture(os.path.join(_assets_dir, 'graphics', 'sprites', 'rectangle.png')),
+    for file_name in os.listdir(os.path.join(_assets_dir, 'graphics', 'sprites'))
-    "triangle": arcade.load_texture(os.path.join(_assets_dir, 'graphics', 'sprites', 'triangle.png')),
 }
 
 theme_sound = arcade.Sound(os.path.join(_assets_dir, 'sound', 'music.ogg'))
+
+trash_bin = arcade.load_animated_gif(os.path.join(_assets_dir, 'graphics', 'trash_bin.gif'))