Update requirements.txt, add saving and loading, add file manager, convert each UI group to a category controlled by buttons at the bottom, fix crash induced by non shape_action if rules not getting shape_type

CREDITS

@@ -1,5 +1,7 @@
 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)
+
 Huge Thanks to Python for being the programming language used in this game.
 https://www.python.org/
 

README.md

@@ -2,3 +2,5 @@ Chaos Protocol is a simulation game where you have a rule engine and objects, wh
 Basically a framework of sorts, which can even be random!
 
 The project is a huge WIP! You can't do much yet, but you have basic rules and simulation.
+
+[![Demo Video](https://img.youtube.com/vi/iMB4mmjTIB4/hqdefault.jpg)](https://youtu.be/iMB4mmjTIB4)

game/file_manager.py

@@ -0,0 +1,138 @@
+import arcade, arcade.gui, os, time
+
+from utils.constants import button_style
+from utils.preload import button_texture, button_hovered_texture
+
+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)
+
+        self.filemanager_width = width
+
+        self.current_directory = os.path.expanduser("~")
+        self.allowed_extensions = allowed_extensions
+        self.file_buttons = []
+        self.submitted_content = ""
+        self.mode = None
+
+        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.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.scrollbar = UIScrollBar(self.scroll_area)
+        self.scrollbar.size_hint = (0.02, 1)
+        self.add(self.scrollbar, anchor_x="right", anchor_y="bottom")
+
+        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.filename_label = self.bottom_box.add(arcade.gui.UILabel(text="Filename:", font_name="Roboto", font_size=20))
+        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.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.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):
+        self.mode = mode
+        self.filename_input.visible = self.mode == "export"
+        self.filename_label.visible = self.mode == "export"
+        self.submit_button.visible = self.mode == "export"
+
+    def submit(self, content):
+        self.submitted_content = content if self.mode == "import" else f"{content}/{self.filename_input.text}"
+
+        self.disable()
+
+    def get_content(self, directory):
+        if not directory in self.content_cache or time.perf_counter() - self.content_cache[directory][-1] >= 30:
+            try:
+                entries = os.listdir(directory)
+            except PermissionError:
+                return None
+
+            filtered = [
+                entry for entry in entries
+                if (os.path.isdir(os.path.join(directory, entry)) and not "." in entry) or
+                os.path.splitext(entry)[1].lower() in self.allowed_extensions
+            ]
+
+            sorted_entries = sorted(
+                filtered,
+                key=lambda x: (0 if os.path.isdir(os.path.join(directory, x)) else 1, x.lower())
+            )
+
+            self.content_cache[directory] = sorted_entries
+            self.content_cache[directory].append(time.perf_counter())
+
+        return self.content_cache[directory][:-1]
+
+    def pre_cache_contents(self):
+        for directory in self.walk_limited_depth(self.current_directory):
+            self.get_content(directory)
+
+    def walk_limited_depth(self, start_dir, max_depth=2):
+        start_dir = os.path.abspath(start_dir)
+
+        def _walk(current_dir, current_depth):
+            if current_depth > max_depth:
+                return
+
+            yield current_dir
+            try:
+                with os.scandir(current_dir) as it:
+                    for entry in it:
+                        if entry.is_dir(follow_symlinks=False):
+                            yield from _walk(entry.path, current_depth + 1)
+            except PermissionError:
+                pass  # skip directories you can't access
+
+        return _walk(start_dir, 0)
+
+    def show_directory(self):
+        self.files_box.clear()
+        self.file_buttons.clear()
+
+        self.current_directory_label.text = self.current_directory
+
+        self.file_buttons.append(self.files_box.add(arcade.gui.UITextureButton(texture=button_texture, texture_hovered=button_hovered_texture, text="Go up", style=button_style, width=self.filemanager_width / 1.5)))
+        self.file_buttons[-1].on_click = lambda event, directory=self.current_directory: self.change_directory(os.path.dirname(directory))
+
+        for file in self.get_content(self.current_directory):
+            self.file_buttons.append(self.files_box.add(arcade.gui.UITextureButton(texture=button_texture, texture_hovered=button_hovered_texture, text=file, style=button_style, width=self.filemanager_width / 1.5)))
+            if os.path.isdir(f"{self.current_directory}/{file}"):
+                self.file_buttons[-1].on_click = lambda event, directory=f"{self.current_directory}/{file}": self.change_directory(directory)
+            else:
+                self.file_buttons[-1].on_click = lambda event, file=f"{self.current_directory}/{file}": self.submit(file)
+
+    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:]
+
+        self.current_directory = directory
+
+        self.show_directory()

game/play.py

@@ -1,10 +1,11 @@
-import arcade, arcade.gui, pyglet, random
+import arcade, arcade.gui, pyglet, random, json
 
-from utils.preload import SPRITE_TEXTURES
-from utils.constants import slider_style, dropdown_style, VAR_NAMES, VAR_DEFAULT, DEFAULT_X_GRAVITY, DEFAULT_Y_GRAVITY, VAR_OPTIONS, DO_RULES, IF_RULES, SHAPES, ALLOWED_INPUT
+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 game.rules import generate_ruleset
+from game.rules import RuleUIBox
 from game.sprites import BaseShape, Rectangle, Circle, Triangle
+from game.file_manager import FileManager
 
 class Game(arcade.gui.UIView):
     def __init__(self, pypresence_client):
@@ -13,32 +14,40 @@ class Game(arcade.gui.UIView):
         self.pypresence_client = pypresence_client
         self.pypresence_client.update(state="Causing Chaos")
 
+        with open("settings.json", "r") as file:
+            self.settings = json.load(file)
+
         self.anchor = self.add_widget(arcade.gui.UIAnchorLayout(size_hint=(1, 1)))
 
-        self.rules_box = arcade.gui.UIBoxLayout(align="center", size_hint=(0.25, 0.95)).with_background(color=arcade.color.DARK_GRAY)
-        self.anchor.add(self.rules_box, anchor_x="right", anchor_y="center", align_x=-self.window.height * 0.025)
+        self.rules_box = RuleUIBox(self.window)
 
-        self.sprites_box = self.anchor.add(arcade.gui.UIBoxLayout(size_hint=(0.15, 0.95), align="center", space_between=10).with_background(color=arcade.color.DARK_GRAY), anchor_x="left", anchor_y="center", align_x=self.window.height * 0.025)
+        self.file_manager = FileManager(self.window.width * 0.95, [".json"]).with_border()
 
-        self.x_gravity = DEFAULT_X_GRAVITY
-        self.y_gravity = DEFAULT_Y_GRAVITY
+        self.ui_selector_box = self.anchor.add(arcade.gui.UIBoxLayout(vertical=False, space_between=self.window.width / 100), anchor_x="left", anchor_y="bottom", align_y=5, align_x=self.window.width / 100)
+        self.add_ui_selector("Simulation", lambda event: self.simulation())
+        self.add_ui_selector("Rules", lambda event: self.rules())
+        self.add_ui_selector("Sprites", lambda event: self.sprites())
+        self.add_ui_selector("Import", lambda event: self.import_file())
+        self.add_ui_selector("Export", lambda event: self.export_file())
+        self.mode = "simulation"
 
-        self.current_ruleset_num = 0
-        self.current_ruleset_page = 0
-        self.rulesets_per_page = 3
-        self.rulesets = {}
-        self.rule_values = {}
+        self.x_gravity = self.settings.get("default_x_gravity", 0)
+        self.y_gravity = self.settings.get("default_y_gravity", 5)
         self.triggered_events = []
 
-        self.rule_labels = {}
-        self.rule_var_changers = {}
-        self.rule_boxes = {}
+        self.rulesets = self.rules_box.rulesets
+        self.rule_values = self.rules_box.rule_values
+
+        self.sprites_box = arcade.gui.UIAnchorLayout(size_hint=(0.95, 0.9))
 
         self.shapes = []
         self.shape_batch = pyglet.graphics.Batch()
 
-        self.rules_content_box = None
-        self.nav_buttons_box = None
+        self.simulation()
+
+    def add_ui_selector(self, button_text, on_click):
+        button = self.ui_selector_box.add(arcade.gui.UITextureButton(text=button_text, width=self.window.width / 5.5, height=self.window.height / 15, style=button_style, texture=button_texture, texture_hovered=button_hovered_texture))
+        button.on_click = on_click
 
     def move_x(self, a, shape):
         if isinstance(shape, Triangle):
@@ -80,11 +89,11 @@ class Game(arcade.gui.UIView):
 
     def change_x_velocity(self, a, shape):
         shape.x_velocity = a
-        self.triggered_events.append(["x_velocity_change", {"event_shape_type": shape.shape_type, "shape_size": shape.shape_size, "shape_x": shape.x, "shape_y": shape.y, "shape": shape, "shape_color": shape.color}])
+        self.triggered_events.append(["x_velocity_change", {"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}])
 
     def change_y_velocity(self, a, shape):
         shape.y_velocity = a
-        self.triggered_events.append(["y_velocity_change", {"event_shape_type": shape.shape_type, "shape_size": shape.shape_size, "shape_x": shape.x, "shape_y": shape.y, "shape": shape, "shape_color": shape.color}])
+        self.triggered_events.append(["y_velocity_change", {"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}])
 
     def change_x_gravity(self, a):
         self.x_gravity = a
@@ -95,8 +104,8 @@ class Game(arcade.gui.UIView):
         self.triggered_events.append(["y_gravity_change", {}])
 
     def change_color(self, a, shape):
-        shape.color = getattr(arcade.color, a)
-        self.triggered_events.append(["color_change", {"event_shape_type": shape.shape_type, "shape_size": shape.shape_size, "shape_x": shape.x, "shape_y": shape.y, "shape": shape, "shape_color": shape.color}])
+        shape.shape_color = getattr(arcade.color, a)
+        self.triggered_events.append(["color_change", {"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}])
 
     def destroy(self, shape: BaseShape):
         self.triggered_events.append(["destroyed", {"event_shape_type": shape.shape_type}])
@@ -122,7 +131,7 @@ class Game(arcade.gui.UIView):
             shape.x3 += size
             shape.y3 += size
 
-        self.triggered_events.append(["size_change", {"event_shape_type": shape.shape_type, "shape_size": shape.shape_size, "shape_x": shape.x, "shape_y": shape.y, "shape": shape, "shape_color": shape.color}])
+        self.triggered_events.append(["size_change", {"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}])
 
     def spawn(self, shape_type):
         x, y = random.randint(int(self.window.width * 0.15) + 50, int(self.window.width * 0.75) - 50), random.randint(100, self.window.height - 100)
@@ -138,7 +147,7 @@ class Game(arcade.gui.UIView):
 
         shape = self.shapes[-1]
 
-        self.triggered_events.append(["spawns", {"event_shape_type": shape.shape_type, "shape_size": shape.shape_size, "shape_x": shape.x, "shape_y": shape.y, "shape": shape, "shape_color": shape.color}])
+        self.triggered_events.append(["spawn", {"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}])
 
     def morph(self, a, shape):
         old_shape_x, old_shape_y, old_shape_size, old_shape_color = shape.x, shape.y, shape.shape_size, shape.shape_color
@@ -153,195 +162,24 @@ class Game(arcade.gui.UIView):
         elif a == "triangle":
             self.shapes.append(Triangle(old_shape_x, old_shape_y, old_shape_x + old_shape_size, old_shape_y, old_shape_x + int(old_shape_size / 2), old_shape_y + old_shape_size, color=getattr(arcade.color, old_shape_color), batch=self.shape_batch))
 
-    def get_rule_defaults(self, rule_type):
-        if rule_type == "if":
-            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 IF_RULES.items()
-            }
-        elif rule_type == "do":
-            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):
-        defaults = self.get_rule_defaults(rule_type)
-        rule_dict = IF_RULES[rule] if rule_type == "if" else DO_RULES[rule]
-        ruleset_num = self.current_ruleset_num
-        default_values = defaults[rule][1]
-
-        dropdown_options = [desc for desc, _ in defaults.values()]
-        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))
-        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.rule_labels[f"{self.current_ruleset_num}_{rule_num}_desc"] = desc_label
-
-        for n, variable_type in enumerate(rule_dict["user_vars"]):
-            key = f"{self.current_ruleset_num}_{rule_num}_{variable_type}_{n}"
-
-            self.rule_values[key] = default_values[VAR_NAMES[n]]
-
-            label = rule_box.add(arcade.gui.UILabel(f'{VAR_NAMES[n]}: {default_values[VAR_NAMES[n]]}', font_size=11, width=self.window.width * 0.225, height=self.window.height / 30))
-            self.rule_labels[key] = label
-
-            if variable_type in ["variable", "size"]: 
-                slider = rule_box.add(arcade.gui.UISlider(value=default_values[VAR_NAMES[n]], 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))
-                slider._render_steps = lambda surface: None  
-                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
-
-            else:
-                dropdown = rule_box.add(arcade.gui.UIDropdown(default=default_values[VAR_NAMES[n]], 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))
-                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):
-        defaults = self.get_rule_defaults(rule_type)
-        new_rule_name = next(key for key, default_list in defaults.items() if default_list[0] == new_rule_text)
-        
-        ruleset = self.rulesets[ruleset_num]
-        
-        if len(ruleset) == 2:
-            if rule_type == "if":
-                ruleset[0] = new_rule_name
-            else:
-                ruleset[1] = new_rule_name
-        else:
-            if rule_type == "if":
-                if rule_num == 1:
-                    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):
-        rule_box = arcade.gui.UIBoxLayout(space_between=5, align="left").with_background(color=arcade.color.DARK_SLATE_GRAY)
-        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")
-            self.create_rule_ui(rule_box, ruleset[1], "do", 2)                
-        
-        else:
-            self.rulesets[self.current_ruleset_num] = ruleset
-
-            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)
-
-    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 on_show_view(self):
         super().on_show_view()
 
-        self.rules_box.add(arcade.gui.UILabel(text="Rules", font_size=20, text_color=arcade.color.BLACK))
-        self.rules_box.add(arcade.gui.UISpace(height=self.window.height / 70, width=self.window.width * 0.25))
+        self.rules_box.add_rule(None, ["on_left_click", "spawn"])
+        self.rules_box.refresh_rules_display()
 
-        add_simple_rule_button = self.rules_box.add(arcade.gui.UIFlatButton(text="Add Simple rule", width=self.window.width * 0.225, height=self.window.height / 25, style=dropdown_style))
-        add_simple_rule_button.on_click = lambda event: self.add_rule("simple")
+        self.sprites_box.add(arcade.gui.UILabel(text="Sprites", font_size=24, text_color=arcade.color.WHITE), anchor_x="center", anchor_y="top")
 
-        self.rules_box.add(arcade.gui.UISpace(height=self.window.height / 85))
+        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()
 
-        add_advanced_rule_button = self.rules_box.add(arcade.gui.UIFlatButton(text="Add Advanced rule", width=self.window.width * 0.225, height=self.window.height / 25, style=dropdown_style))
-        add_advanced_rule_button.on_click = lambda event: self.add_rule("advanced")
-
-        self.rules_box.add(arcade.gui.UISpace(height=self.window.height / 70))
-
-        self.nav_buttons_box = self.rules_box.add(arcade.gui.UIBoxLayout(vertical=False, space_between=10))
-        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))
-        prev_button.on_click = self.prev_page
-        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))
-        next_button.on_click = self.next_page
-
-        self.rules_box.add(arcade.gui.UISpace(height=self.window.height / 70))
-
-        self.rules_content_box = self.rules_box.add(arcade.gui.UIBoxLayout(align="center"))
-
-        self.add_rule(None, ["on_left_click", "spawn"])
-
-        self.refresh_rules_display()
-
-        self.sprites_box.add(arcade.gui.UILabel(text="Sprites", font_size=24, text_color=arcade.color.BLACK))
-        self.sprites_box.add(arcade.gui.UISpace(height=self.window.height / 50))
-
-        for shape in SHAPES:
-            self.sprites_box.add(arcade.gui.UILabel(text=shape, font_size=16, text_color=arcade.color.BLACK))
-            self.sprites_box.add(arcade.gui.UIImage(texture=SPRITE_TEXTURES[shape], width=self.window.width / 15, height=self.window.width / 15))
+        for n, shape in enumerate(SHAPES):
+            row, col = n % 8, n // 8
+            box = self.sprites_grid.add(arcade.gui.UIBoxLayout(), row=row, column=col)
+            box.add(arcade.gui.UILabel(text=shape, font_size=16, text_color=arcade.color.WHITE))
+            box.add(arcade.gui.UIImage(texture=SPRITE_TEXTURES[shape], width=self.window.width / 15, height=self.window.width / 15))
 
         self.triggered_events.append(["game_launch", {}])
 
-    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()
-
     def get_rule_values(self, ruleset_num, rule_num, rule_dict, event_args):
         args = [self.rule_values[f"{ruleset_num}_{rule_num}_{user_var}_{n}"] for n, user_var in enumerate(rule_dict["user_vars"])]
 
@@ -377,6 +215,44 @@ class Game(arcade.gui.UIView):
         self.get_action_function(rule_dict["action"])(*self.get_rule_values(ruleset_num, rule_num, rule_dict, event_args))
 
     def on_update(self, delta_time):
+        if self.mode == "import" and self.file_manager.submitted_content:
+            with open(self.file_manager.submitted_content, "r") as file:
+                data = json.load(file)
+
+            if not data or not "rulesets" in data or not "rule_values" in data:
+                self.add_widget(arcade.gui.UIMessageBox(message_text="Invalid file. Could not import rules.", width=self.window.width * 0.5, height=self.window.height * 0.25))
+                return
+
+            self.rule_values = data["rule_values"]
+            self.triggered_events = []
+            self.current_ruleset_num = 0
+            self.current_ruleset_page = 0
+
+            self.rules_content_box.clear()
+
+            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:
+                file.write(json.dumps({
+                    "rulesets": self.rulesets,
+                    "rule_values": self.rule_values
+                }, indent=4))
+
+        if not self.mode == "simulation":
+            return
+
         self.triggered_events.append(["every_update", {}])
 
         while len(self.triggered_events) > 0:
@@ -389,11 +265,11 @@ class Game(arcade.gui.UIView):
                     if not if_rule_dict["trigger"] == trigger:
                         continue
                     
-                    if do_rule_dict["action"]["type"] == "shape_action":
+                    if do_rule_dict["action"]["type"] == "shape_action" or "shape_type" in if_rule_dict["user_vars"]:
                         for shape in self.shapes:                            
                             event_args = trigger_args.copy()
                             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.color})
+                                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 self.check_rule(key, 1, if_rule_dict, event_args):
                                 self.run_do_rule(key, 2, do_rule_dict, event_args)
@@ -414,7 +290,7 @@ class Game(arcade.gui.UIView):
                             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.color})
+                                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):
@@ -434,47 +310,87 @@ class Game(arcade.gui.UIView):
                                 self.run_do_rule(key, 3, do_rule_dict, event_args)
 
         for shape in self.shapes:
+            for shape_b in self.shapes:
+                if shape.check_collision(shape_b):
+                    self.triggered_events.append(["collision", {"event_a_type": shape.shape_type, "event_b_type": shape.shape_type, "shape_size": shape.shape_size, "shape_x": shape.x, "shape_y": shape.y, "shape": shape, "shape_color": shape.color}])
+
             shape.update(self.x_gravity, self.y_gravity)
 
             if shape.x < 0 or shape.x > self.window.width or shape.y < 0 or shape.y > self.window.height:
                 self.destroy(shape)
 
-    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}'
+        if len(self.shapes) > self.settings.get("max_shapes", 120):
+            for shape in self.shapes[:-self.settings.get("max_shapes", 120)]:
+                self.destroy(shape)
 
     def on_key_press(self, symbol, modifiers):
         if symbol == arcade.key.ESCAPE:
             self.main_exit()
-        elif symbol in [ord(key) for key in ALLOWED_INPUT]:
+        elif self.mode == "simulation" and symbol in [ord(key) for key in ALLOWED_INPUT]:
             self.triggered_events.append(["on_input", {"event_key": chr(symbol)}])
 
     def on_mouse_press(self, x, y, button, modifiers):
         if button == arcade.MOUSE_BUTTON_LEFT:
             self.triggered_events.append(["on_left_click", {}])
-        elif button == arcade.MOUSE_BUTTON_RIGHT:
+        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):
         self.triggered_events.append(["on_mouse_move", {}])
 
+    def disable_previous(self):
+        if self.mode in ["import", "export"]:
+            self.anchor.remove(self.file_manager)
+        elif self.mode == "rules":
+            self.anchor.remove(self.rules_box)
+        elif self.mode == "sprites":
+            self.anchor.remove(self.sprites_box)
+
+        self.anchor.trigger_full_render()
+
+    def rules(self):
+        self.disable_previous()
+
+        self.mode = "rules"
+
+        self.anchor.add(self.rules_box, anchor_x="center", anchor_y="top")
+
+    def export_file(self):
+        self.disable_previous()
+        
+        self.mode = "export"
+
+        self.file_manager.change_mode("export")
+        self.anchor.add(self.file_manager, anchor_x="center", anchor_y="top")
+
+    def import_file(self):
+        self.disable_previous()
+
+        self.mode = "import"
+
+        self.file_manager.change_mode("import")
+        self.anchor.add(self.file_manager, anchor_x="center", anchor_y="top")
+
+    def sprites(self):
+        self.disable_previous()
+
+        self.mode = "sprites"
+
+        self.anchor.add(self.sprites_box, anchor_x="center", anchor_y="top")
+
+    def simulation(self):
+        self.disable_previous()
+        
+        self.mode = "simulation"
+
     def main_exit(self):
         from menus.main import Main
         self.window.show_view(Main(self.pypresence_client))
 
     def on_draw(self):
         self.window.clear()
-        self.shape_batch.draw()
+        
+        if self.mode == "simulation":
+            self.shape_batch.draw()
+   
         self.ui.draw()

game/rules.py

@@ -1,6 +1,5 @@
-from utils.constants import DO_RULES, IF_RULES, LOGICAL_OPERATORS, NON_COMPATIBLE_WHEN, NON_COMPATIBLE_DO_WHEN
-
-import random
+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
+import arcade, arcade.gui, random
 
 IF_KEYS = tuple(IF_RULES.keys())
 DO_KEYS = tuple(DO_RULES.keys())
@@ -47,3 +46,210 @@ def generate_ruleset(ruleset_type):
         return [when_a, logical, when_b, do]
     else:
         return [when_a, do]
+    
+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_ruleset_page = 0
+        self.rulesets_per_page = 2
+        self.rulesets = {}
+        self.rule_values = {}
+
+        self.rule_labels = {}
+        self.rule_var_changers = {}
+        self.rule_boxes = {}
+
+        self.nav_buttons_box = None
+
+        self.rules_label = self.add(arcade.gui.UILabel(text="Rules", font_size=20, text_color=arcade.color.WHITE))
+        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.add_simple_rule_button.on_click = lambda event: self.add_rule("simple")
+
+        self.add(arcade.gui.UISpace(height=self.window.height / 85))
+
+        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.add_advanced_rule_button.on_click = lambda event: self.add_rule("advanced")
+    
+        self.add(arcade.gui.UISpace(height=self.window.height / 85))
+
+        self.nav_buttons_box = self.add(arcade.gui.UIBoxLayout(vertical=False, space_between=10))
+        
+        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.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.next_button.on_click = self.next_page
+
+        self.rules_content_box = self.add(arcade.gui.UIBoxLayout(align="center"))
+
+    def get_rule_defaults(self, rule_type):
+        if rule_type == "if":
+            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 IF_RULES.items()
+            }
+        elif rule_type == "do":
+            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):
+        defaults = self.get_rule_defaults(rule_type)
+        rule_dict = IF_RULES[rule] if rule_type == "if" else DO_RULES[rule]
+        ruleset_num = self.current_ruleset_num
+        default_values = defaults[rule][1]
+
+        dropdown_options = [desc for desc, _ in defaults.values()]
+        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))
+        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.rule_labels[f"{self.current_ruleset_num}_{rule_num}_desc"] = desc_label
+
+        for n, variable_type in enumerate(rule_dict["user_vars"]):
+            key = f"{self.current_ruleset_num}_{rule_num}_{variable_type}_{n}"
+
+            if not is_import:
+                self.rule_values[key] = default_values[VAR_NAMES[n]]
+
+            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))
+            self.rule_labels[key] = label
+
+            if variable_type in ["variable", "size"]: 
+                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))
+                slider._render_steps = lambda surface: None  
+                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
+
+            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))
+                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):
+        defaults = self.get_rule_defaults(rule_type)
+        new_rule_name = next(key for key, default_list in defaults.items() if default_list[0] == new_rule_text)
+        
+        ruleset = self.rulesets[ruleset_num]
+        
+        if len(ruleset) == 2:
+            if rule_type == "if":
+                ruleset[0] = new_rule_name
+            else:
+                ruleset[1] = new_rule_name
+        else:
+            if rule_type == "if":
+                if rule_num == 1:
+                    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()

game/sprites.py

@@ -1,12 +1,16 @@
-import pyglet, arcade.color
+import pyglet, arcade.color, math, json
 
-from utils.constants import DEFAULT_X_VELOCITY, DEFAULT_Y_VELOCITY
+# I am so sorry but this file has AI code cause i didn't have enough time to implement collision :C
+
+with open("settings.json", "r") as file:
+    settings = json.load(file)
 
 class BaseShape():
     def __init__(self):
         self.shape_type = ""
-        self.x_velocity = DEFAULT_X_VELOCITY
-        self.y_velocity = DEFAULT_Y_VELOCITY
+
+        self.x_velocity = settings.get("default_x_velocity", 0)
+        self.y_velocity = settings.get("default_y_velocity", 0)
         self._shape_color = "WHITE"
     
     def update(self, x_gravity, y_gravity):
@@ -24,6 +28,15 @@ class BaseShape():
         self._shape_color = color
         self.color = getattr(arcade.color, color)
     
+    def check_collision(self, other):
+        if isinstance(other, Circle):
+            return self._collides_with_circle(other)
+        elif isinstance(other, Rectangle):
+            return self._collides_with_rectangle(other)
+        elif isinstance(other, Triangle):
+            return self._collides_with_triangle(other)
+        return False
+
 class Circle(pyglet.shapes.Circle, BaseShape):
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
@@ -34,6 +47,65 @@ class Circle(pyglet.shapes.Circle, BaseShape):
     def shape_size(self):
         return self.radius
     
+    def _collides_with_circle(self, other):
+        dx = self.x - other.x
+        dy = self.y - other.y
+        distance = math.sqrt(dx * dx + dy * dy)
+        return distance < (self.radius + other.radius)
+    
+    def _collides_with_rectangle(self, rect):
+        closest_x = max(rect.x, min(self.x, rect.x + rect.width))
+        closest_y = max(rect.y, min(self.y, rect.y + rect.height))
+        
+        dx = self.x - closest_x
+        dy = self.y - closest_y
+        distance = math.sqrt(dx * dx + dy * dy)
+        
+        return distance < self.radius
+    
+    def _collides_with_triangle(self, tri):
+        if self._point_in_triangle(self.x, self.y, tri):
+            return True
+        
+        edges = [
+            (tri.x, tri.y, tri.x2, tri.y2),
+            (tri.x2, tri.y2, tri.x3, tri.y3),
+            (tri.x3, tri.y3, tri.x, tri.y)
+        ]
+        
+        for x1, y1, x2, y2 in edges:
+            if self._distance_to_segment(x1, y1, x2, y2) < self.radius:
+                return True
+        
+        return False
+    
+    def _distance_to_segment(self, x1, y1, x2, y2):
+        dx = x2 - x1
+        dy = y2 - y1
+        
+        if dx == 0 and dy == 0:
+            return math.sqrt((self.x - x1)**2 + (self.y - y1)**2)
+        
+        t = max(0, min(1, ((self.x - x1) * dx + (self.y - y1) * dy) / (dx * dx + dy * dy)))
+        
+        closest_x = x1 + t * dx
+        closest_y = y1 + t * dy
+        
+        return math.sqrt((self.x - closest_x)**2 + (self.y - closest_y)**2)
+    
+    def _point_in_triangle(self, px, py, tri):
+        def sign(x1, y1, x2, y2, x3, y3):
+            return (x1 - x3) * (y2 - y3) - (x2 - x3) * (y1 - y3)
+        
+        d1 = sign(px, py, tri.x, tri.y, tri.x2, tri.y2)
+        d2 = sign(px, py, tri.x2, tri.y2, tri.x3, tri.y3)
+        d3 = sign(px, py, tri.x3, tri.y3, tri.x, tri.y)
+        
+        has_neg = (d1 < 0) or (d2 < 0) or (d3 < 0)
+        has_pos = (d1 > 0) or (d2 > 0) or (d3 > 0)
+        
+        return not (has_neg and has_pos)
+
 class Rectangle(pyglet.shapes.Rectangle, BaseShape):
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
@@ -44,6 +116,71 @@ class Rectangle(pyglet.shapes.Rectangle, BaseShape):
     def shape_size(self):
         return self.width
     
+    def _collides_with_circle(self, circle):
+        return circle._collides_with_rectangle(self)
+    
+    def _collides_with_rectangle(self, other):
+        return (self.x < other.x + other.width and
+                self.x + self.width > other.x and
+                self.y < other.y + other.height and
+                self.y + self.height > other.y)
+    
+    def _collides_with_triangle(self, tri):
+        vertices = [(tri.x, tri.y), (tri.x2, tri.y2), (tri.x3, tri.y3)]
+        for vx, vy in vertices:
+            if (self.x <= vx <= self.x + self.width and
+                self.y <= vy <= self.y + self.height):
+                return True
+        
+        rect_vertices = [
+            (self.x, self.y),
+            (self.x + self.width, self.y),
+            (self.x + self.width, self.y + self.height),
+            (self.x, self.y + self.height)
+        ]
+        for rx, ry in rect_vertices:
+            if self._point_in_triangle(rx, ry, tri):
+                return True
+        
+        tri_edges = [
+            (tri.x, tri.y, tri.x2, tri.y2),
+            (tri.x2, tri.y2, tri.x3, tri.y3),
+            (tri.x3, tri.y3, tri.x, tri.y)
+        ]
+        rect_edges = [
+            (self.x, self.y, self.x + self.width, self.y),
+            (self.x + self.width, self.y, self.x + self.width, self.y + self.height),
+            (self.x + self.width, self.y + self.height, self.x, self.y + self.height),
+            (self.x, self.y + self.height, self.x, self.y)
+        ]
+        
+        for t_edge in tri_edges:
+            for r_edge in rect_edges:
+                if self._segments_intersect(*t_edge, *r_edge):
+                    return True
+        
+        return False
+    
+    def _point_in_triangle(self, px, py, tri):
+        def sign(x1, y1, x2, y2, x3, y3):
+            return (x1 - x3) * (y2 - y3) - (x2 - x3) * (y1 - y3)
+        
+        d1 = sign(px, py, tri.x, tri.y, tri.x2, tri.y2)
+        d2 = sign(px, py, tri.x2, tri.y2, tri.x3, tri.y3)
+        d3 = sign(px, py, tri.x3, tri.y3, tri.x, tri.y)
+        
+        has_neg = (d1 < 0) or (d2 < 0) or (d3 < 0)
+        has_pos = (d1 > 0) or (d2 > 0) or (d3 > 0)
+        
+        return not (has_neg and has_pos)
+    
+    def _segments_intersect(self, x1, y1, x2, y2, x3, y3, x4, y4):
+        def ccw(ax, ay, bx, by, cx, cy):
+            return (cy - ay) * (bx - ax) > (by - ay) * (cx - ax)
+        
+        return (ccw(x1, y1, x3, y3, x4, y4) != ccw(x2, y2, x3, y3, x4, y4) and
+                ccw(x1, y1, x2, y2, x3, y3) != ccw(x1, y1, x2, y2, x4, y4))
+
 class Triangle(pyglet.shapes.Triangle, BaseShape):
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
@@ -53,3 +190,59 @@ class Triangle(pyglet.shapes.Triangle, BaseShape):
     @property
     def shape_size(self):
         return max(self.x, self.x2, self.x3) - min(self.x, self.x2, self.x3)
+    
+    def _collides_with_circle(self, circle):
+        return circle._collides_with_triangle(self)
+    
+    def _collides_with_rectangle(self, rect):
+        return rect._collides_with_triangle(self)
+    
+    def _collides_with_triangle(self, other):
+        vertices_self = [(self.x, self.y), (self.x2, self.y2), (self.x3, self.y3)]
+        vertices_other = [(other.x, other.y), (other.x2, other.y2), (other.x3, other.y3)]
+        
+        for vx, vy in vertices_self:
+            if self._point_in_triangle(vx, vy, other):
+                return True
+        
+        for vx, vy in vertices_other:
+            if self._point_in_triangle(vx, vy, self):
+                return True
+        
+        edges_self = [
+            (self.x, self.y, self.x2, self.y2),
+            (self.x2, self.y2, self.x3, self.y3),
+            (self.x3, self.y3, self.x, self.y)
+        ]
+        edges_other = [
+            (other.x, other.y, other.x2, other.y2),
+            (other.x2, other.y2, other.x3, other.y3),
+            (other.x3, other.y3, other.x, other.y)
+        ]
+        
+        for e1 in edges_self:
+            for e2 in edges_other:
+                if self._segments_intersect(*e1, *e2):
+                    return True
+        
+        return False
+    
+    def _point_in_triangle(self, px, py, tri):
+        def sign(x1, y1, x2, y2, x3, y3):
+            return (x1 - x3) * (y2 - y3) - (x2 - x3) * (y1 - y3)
+        
+        d1 = sign(px, py, tri.x, tri.y, tri.x2, tri.y2)
+        d2 = sign(px, py, tri.x2, tri.y2, tri.x3, tri.y3)
+        d3 = sign(px, py, tri.x3, tri.y3, tri.x, tri.y)
+        
+        has_neg = (d1 < 0) or (d2 < 0) or (d3 < 0)
+        has_pos = (d1 > 0) or (d2 > 0) or (d3 > 0)
+        
+        return not (has_neg and has_pos)
+    
+    def _segments_intersect(self, x1, y1, x2, y2, x3, y3, x4, y4):
+        def ccw(ax, ay, bx, by, cx, cy):
+            return (cy - ay) * (bx - ax) > (by - ay) * (cx - ax)
+        
+        return (ccw(x1, y1, x3, y3, x4, y4) != ccw(x2, y2, x3, y3, x4, y4) and
+                ccw(x1, y1, x2, y2, x3, y3) != ccw(x1, y1, x2, y2, x4, y4))

menus/main.py

@@ -52,10 +52,10 @@ class Main(arcade.gui.UIView):
 
         self.title_label = self.box.add(arcade.gui.UILabel(text="Chaos Protocol", font_name="Roboto", font_size=48))
 
-        self.play_button = self.box.add(arcade.gui.UITextureButton(text="Play", texture=button_texture, texture_hovered=button_hovered_texture, width=self.window.width / 2, height=150, style=big_button_style))
+        self.play_button = self.box.add(arcade.gui.UITextureButton(text="Play", texture=button_texture, texture_hovered=button_hovered_texture, width=self.window.width / 2, height=self.window.height / 10, style=big_button_style))
         self.play_button.on_click = lambda event: self.play()
 
-        self.settings_button = self.box.add(arcade.gui.UITextureButton(text="Settings", texture=button_texture, texture_hovered=button_hovered_texture, width=self.window.width / 2, height=150, style=big_button_style))
+        self.settings_button = self.box.add(arcade.gui.UITextureButton(text="Settings", texture=button_texture, texture_hovered=button_hovered_texture, width=self.window.width / 2, height=self.window.height / 10, style=big_button_style))
         self.settings_button.on_click = lambda event: self.settings()
 
     def play(self):

requirements.txt

@@ -1,12 +1,12 @@
 # This file was autogenerated by uv via the following command:
 #    uv pip compile pyproject.toml -o requirements.txt
-arcade==3.2.0
-    # via game-name (pyproject.toml)
+arcade==3.3.3
+    # via chaos-protocol (pyproject.toml)
 attrs==25.3.0
     # via pytiled-parser
 cffi==1.17.1
     # via pymunk
-pillow==11.0.0
+pillow==11.3.0
     # via arcade
 pycparser==2.22
     # via cffi
@@ -15,7 +15,7 @@ pyglet==2.1.6
 pymunk==6.9.0
     # via arcade
 pypresence==4.3.0
-    # via game-name (pyproject.toml)
+    # via chaos-protocol (pyproject.toml)
 pytiled-parser==2.2.9
     # via arcade
 typing-extensions==4.14.1

run.py

@@ -10,11 +10,10 @@ script_dir = os.path.dirname(os.path.abspath(__file__))
 pyglet.resource.path.append(script_dir)
 pyglet.font.add_directory(os.path.join(script_dir, 'assets', 'fonts'))
 
-
 from utils.utils import get_closest_resolution, print_debug_info, on_exception
 from utils.constants import log_dir, menu_background_color
 from menus.main import Main
-# from utils.preload import theme_sound # needed for preload
+from utils.preload import theme_sound # needed for preload
 from arcade.experimental.controller_window import ControllerWindow
 
 sys.excepthook = on_exception
@@ -87,8 +86,8 @@ else:
     with open("settings.json", "w") as file:
         file.write(json.dumps(settings))
 
-# if settings.get("music", True):
-#     theme_sound.play(volume=settings.get("music_volume", 50) / 100, loop=True)
+if settings.get("music", True):
+    theme_sound.play(volume=settings.get("music_volume", 50) / 100, loop=True)
 
 try:
     window = ControllerWindow(width=resolution[0], height=resolution[1], title='Chaos Protocol', samples=antialiasing, antialiasing=antialiasing > 0, fullscreen=fullscreen, vsync=vsync, resizable=False, style=style, visible=False)

utils/constants.py

@@ -7,12 +7,6 @@ LOGICAL_OPERATORS = ["and", "or"]
 SHAPES = ["rectangle", "circle", "triangle"]
 VAR_NAMES = ["a", "b", "c", "d", "e", "f", "g"]
 
-DEFAULT_X_GRAVITY = 0
-DEFAULT_Y_GRAVITY = 2
-
-DEFAULT_X_VELOCITY = 0
-DEFAULT_Y_VELOCITY = 0
-
 ALLOWED_INPUT = ["a", "b", "c", "d", "e", "q", "w", "s", "t"]
 
 COLORS = [
@@ -82,7 +76,7 @@ IF_RULES = {
     "spawns": {
         "key": "spawns",
         "description": "IF {a} shape spawns",
-        "trigger": "spawns",
+        "trigger": "spawn",
         "user_vars": ["shape_type"],
         "vars": ["shape_type", "event_shape_type"],
         "func": lambda *v: v[0] == v[1]
@@ -111,22 +105,6 @@ IF_RULES = {
         "vars": ["shape_type", "event_shape_type"],
         "func": lambda *v: v[0] == v[1]
     },
-    "x_gravity_changes": {
-        "key": "x_gravity_changes",
-        "description": "IF {a} shape X gravity changes",
-        "trigger": "gravity_x_change",
-        "user_vars": ["shape_type"],
-        "vars": ["shape_type", "event_shape_type"],
-        "func": lambda *v: v[0] == v[1]
-    },
-    "y_gravity_changes": {
-        "key": "y_gravity_changes",
-        "description": "IF {a} shape Y gravity changes",
-        "trigger": "gravity_y_change",
-        "user_vars": ["shape_type"],
-        "vars": ["shape_type", "event_shape_type"],
-        "func": lambda *v: v[0] == v[1]
-    },
     "color_changes": {
         "key": "color_changes",
         "description": "IF {a} shape color changes",
@@ -438,16 +416,21 @@ slider_style = {'normal': slider_default_style, 'hover': slider_hover_style, 'pr
 settings = {
     "Graphics": {
         "Window Mode": {"type": "option", "options": ["Windowed", "Fullscreen", "Borderless"], "config_key": "window_mode", "default": "Windowed"},
-        "Resolution": {"type": "option", "options": ["1366x768", "1440x900", "1600x900", "1920x1080", "2560x1440", "3840x2160"], "config_key": "resolution"},
+        "Resolution": {"type": "option", "options": ["1440x900", "1600x900", "1920x1080", "2560x1440", "3840x2160"], "config_key": "resolution"},
         "Anti-Aliasing": {"type": "option", "options": ["None", "2x MSAA", "4x MSAA", "8x MSAA", "16x MSAA"], "config_key": "anti_aliasing", "default": "4x MSAA"},
         "VSync": {"type": "bool", "config_key": "vsync", "default": True},
         "FPS Limit": {"type": "slider", "min": 0, "max": 480, "config_key": "fps_limit", "default": 60},
     },
     "Sound": {
         "Music": {"type": "bool", "config_key": "music", "default": True},
-        "SFX": {"type": "bool", "config_key": "sfx", "default": True},
         "Music Volume": {"type": "slider", "min": 0, "max": 100, "config_key": "music_volume", "default": 50},
-        "SFX Volume": {"type": "slider", "min": 0, "max": 100, "config_key": "sfx_volume", "default": 50},
+    },
+    "Game": {
+        "Default X velocity": {"type": "slider", "min": -999, "max": 999, "config_key": "default_x_velocity", "default": 0},
+        "Default Y velocity": {"type": "slider", "min": -999, "max": 999, "config_key": "default_y_velocity", "default": 0},
+        "Default X gravity": {"type": "slider", "min": -999, "max": 999, "config_key": "default_x_gravity", "default": 0},
+        "Default Y gravity": {"type": "slider", "min": -999, "max": 999, "config_key": "default_y_gravity", "default": 5},
+        "Max Shapes": {"type": "slider", "min": 0, "max": 999, "config_key": "max_shapes", "default": 120},
     },
     "Miscellaneous": {
         "Discord RPC": {"type": "bool", "config_key": "discord_rpc", "default": True},

utils/preload.py

@@ -12,3 +12,5 @@ SPRITE_TEXTURES = {
     "rectangle": arcade.load_texture(os.path.join(_assets_dir, 'graphics', 'sprites', 'rectangle.png')),
     "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'))

utils/utils.py

@@ -41,7 +41,7 @@ def on_exception(*exc_info):
     logging.error(f"Unhandled exception:\n{''.join(traceback.format_exception(exc_info[1], limit=None))}")
 
 def get_closest_resolution():
-    allowed_resolutions = [(1366, 768), (1440, 900), (1600,900), (1920,1080), (2560,1440), (3840,2160)]
+    allowed_resolutions = [(1440, 900), (1600,900), (1920,1080), (2560,1440), (3840,2160)]
     screen_width, screen_height = arcade.get_screens()[0].width, arcade.get_screens()[0].height
     if (screen_width, screen_height) in allowed_resolutions:
         if not allowed_resolutions.index((screen_width, screen_height)) == 0: