Initial commit

.gitattributes

···
+# Auto detect text files and perform LF normalization
+* text=auto

.vscode/launch.json

···
+{
+    // Use IntelliSense to learn about possible attributes.
+    // Hover to view descriptions of existing attributes.
+    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "name": "Python: Project",
+            "type": "python",
+            "request": "launch",
+            "program": "E:\\Coding\\Python\\Pygame\\Folder 2\\Car-Game\\client.py",
+            "console": "integratedTerminal"
+        }
+    ]
+}

README.md

···
+# Game Engine
+ My Pygame Game Engine

client.py

···
+import pygame, time
+from src.scripts.game import Game
+from src.scripts.project import *
+
+game = Game()
+
+game.initialize()
+
+while game.running:
+    ## Update
+
+    update_start_time = time.time()
+    game.update()
+    update()
+    game.end_update()
+    update_end_time = time.time()
+
+    ## Render
+
+    render_start_time = time.time()
+    game.render()
+    render()
+    game.end_render()
+
+    render_end_time = time.time()
+
+pygame.quit()

src/properties.json

···
+{
+    "id": "Engine",
+    "version": "0.0.1"
+}

src/resources/main/assets/colors.json

···
+{
+    "notification.border": "#495b66",
+    "notification.fill": "#c5d4de",
+    "notification.text": "#272a2e",
+
+    "options.background": "#141517",
+    "options.text": "#ebeff5",
+    
+    "main_menu.background": "#435560", 
+    "main_menu.marker": "#6e7c7c", 
+    "main_menu.text": "#c8c6a7", 
+    "main_menu.dark_text": "#92967d",
+    "main_menu.bright_bg": "#576974",
+    "main_menu.bright_bg_2": "#4d5f6a",
+
+    "game.background": "#5f6169",
+
+    "console.background": "#393a3d",
+    "console.marker": "#f0f0f2",
+    "console.text": "#f0f0f2"
+}

src/resources/main/data/lang/en_US.json

···
+{
+    "factory.main_screen.play": "Play",
+    "factory.main_screen.options": "Options",
+    "factory.main_screen.exit": "Exit",
+
+    "factory.options.show_fps": "Show FPS",
+    "factory.options.reset_save": "Reset Save"
+}

src/scripts/game.py

···
+import pygame, os, json, pyautogui, sys, time
+
+from .modules.input import Input
+from .modules.language import Language_Handler
+from .modules.colors import Color_Handler
+from .modules.sound import Sound_Handler
+from .modules.image import image
+from .modules.math_utils import math_utils
+from .modules.renderer import renderer
+from .modules.fonts import font_handler
+
+from .modules.screens.screen_1 import screen_1
+from .modules.screens.screen_2 import screen_2
+from .modules.screens.screen_3 import screen_3
+from .modules.screens.screen_4 import screen_4
+
+class Game:
+
+    game_speed = 1
+    clock = pygame.time.Clock()
+
+    running = True
+    title = "Game"
+
+    current_assetpack = "main"
+
+    def stop(self):
+        self.running = False
+
+    def change_title(self, title):
+        self.title = title
+        pygame.display.set_caption(title)
+
+    def __init__(self):
+        self.input = Input()
+        self.language_handler = Language_Handler(self)
+        self.color_handler = Color_Handler(self)
+        self.sound_handler = Sound_Handler(self)
+        self.image = image(self)
+        self.math = math_utils()
+        self.renderer = renderer(self)
+        self.font_handler = font_handler(self)
+
+        self.previous_time = time.time()
+
+        self.input.set_input_state('general')
+
+        with open(os.path.join("src", "properties.json"), "r") as file:
+            self.properties = json.load(file)
+
+        self.change_title(self.properties["id"])
+        icon = pygame.image.load(os.path.join("src", "resources", self.current_assetpack, "assets", "icon.png"))
+        pygame.display.set_icon(icon)
+
+    def initialize(self):
+        self.change_title(self.properties["id"])
+        self.input.input_state = "general"
+
+        sscreen_1 = screen_1(self)
+        sscreen_2 = screen_2(self)
+        sscreen_3 = screen_3(self)
+        sscreen_4 = screen_4(self)
+        self.renderer.load_screen(sscreen_1, 'screen_1')
+        self.renderer.load_screen(sscreen_2, 'screen_2')
+        self.renderer.load_screen(sscreen_3, 'screen_3')
+        self.renderer.load_screen(sscreen_4, 'screen_4')
+        self.renderer.switch_screen('screen_1')
+
+        self.screen = 1
+
+    def update(self):
+        # Calculate Delta Time
+        now = time.time()
+        self.delta_time = now - self.previous_time
+        self.previous_time = now
+
+        self.input.any_key_pressed = False
+        for event in pygame.event.get():
+            if event.type == pygame.QUIT:
+                self.stop()
+            if event.type == pygame.KEYDOWN:
+                self.input.any_key_pressed = True
+
+        if self.input.is_just_pressed('LEFT'):
+            self.screen -= 1
+        if self.input.is_just_pressed('RIGHT'):
+            self.screen += 1
+
+        self.screen = min(4, max(self.screen, 1))
+        if self.renderer.current_screen != 'screen_' + str(self.screen):
+            self.renderer.switch_screen('screen_' + str(self.screen))
+
+        # Screens
+        self.renderer.update()
+
+    def end_update(self):
+        self.input.check_keys()
+        self.input.mouse_button_last_frame = self.input.is_mouse_button_pressed()
+
+    def render(self):  
+        self.renderer.render()
+
+    def end_render(self):  
+        pass

src/scripts/modules/colors.py

···
+import json, os
+from colormap import hex2rgb
+
+class Color_Handler:
+    def __init__(self, game):
+        self.game = game
+    
+    def get_hex(self, color_link):
+        with open(os.path.join("src", "resources", self.game.current_assetpack, "assets", "colors.json"), "r") as color_file:
+            color_json = json.load(color_file)
+        if color_link in color_json:
+            return color_json[color_link]
+        else:
+            return "#00000"
+
+    def get_rgb(self, color_link):
+        with open(os.path.join("src", "resources", self.game.current_assetpack, "assets", "colors.json"), "r") as color_file:
+            color_json = json.load(color_file)
+        if color_link in color_json:
+            return hex2rgb(color_json[color_link])
+        else:
+            return (0, 0, 0)
+        

src/scripts/modules/fonts.py

···
+import pygame, os
+pygame.font.init()
+
+class font_handler:
+    def __init__(self, game) -> None:
+        self.game = game
+
+    def render(self, text, font, size, color):
+        font_file = pygame.font.Font(os.path.join('src', 'resources', self.game.current_assetpack, 'assets', 'fonts', font + '.ttf'), size) 
+        return font_file.render(text, True, color)
+
+

src/scripts/modules/gui.py

···
+import pygame
+
+class center_constraint():
+    pass
+
+class aspect_constraint():
+    def __init__(self, aspect_ratio) -> None:
+        self.value = aspect_ratio
+
+class percentage_constraint():
+    def __init__(self, percentage):
+        self.value = percentage
+
+class pixel_constraint():
+    def __init__(self, pixel):
+        self.value = pixel
+
+class gui_rect:
+    x_constraint = None
+    y_constraint = None
+    width_constraint = None
+    height_constraint = None
+
+    x = 0
+    y = 0
+
+    tween = False
+    tween_x = 0
+    tween_y = 0
+    tween_mult = 0
+
+    tween_s = False
+    tween_width = 0
+    tween_height = 0
+    tween_s_mult = 0
+
+    width = 0
+    height = 0
+
+    border_radius = 0
+    outline = 0
+
+    color = (0, 0, 0)
+
+    parent = None
+
+    ## Set Constraints
+
+    # Position Constraints
+
+    def set_x_constraint(self, x_constraint):
+        self.x_constraint = x_constraint
+
+    def set_y_constraint(self, y_constraint):
+        self.y_constraint = y_constraint
+
+    # Size Constraints
+
+    def set_width_constraint(self, width_constraint):
+        self.width_constraint = width_constraint
+
+    def set_height_constraint(self, height_constraint):
+        self.height_constraint = height_constraint
+
+    # Misc to rect
+
+    def set_border_radius(self, radius):
+        self.border_radius = radius
+
+    def set_outline_radius(self, outline):
+        self.outline = outline
+
+    def set_draw_color(self, rgb):
+        self.color = rgb
+
+    # Tools
+
+    def is_touching_mouse(self):
+        mx, my = pygame.mouse.get_pos()
+        if self.game.math.in_rect(mx, my, self.x, self.y , self.width, self.height):
+            return True
+        return False
+
+    def tween_to(self, x, y, mult):
+        self.tween = True
+        self.tween_x = x
+        self.tween_y = y
+        self.tween_mult = mult
+
+    def tween_size(self, width, height, mult):
+        self.tween_s = True
+        self.tween_width = width
+        self.tween_height = height
+        self.tween_s_mult = mult
+
+    def __init__(self, game) -> None:
+        self.game = game
+        self.visible = True
+
+    ## Update thingy
+
+    def update(self):
+
+        ## Set Position thing
+
+        if not self.tween:
+            # Set X Constraints
+
+            if self.x_constraint != None:
+                class_use = type(self.x_constraint)
+                if self.parent == None:
+                    if class_use == center_constraint:
+                        self.x = self.game.renderer.get_screen_size()[0] / 2 - (int(self.width) / 2)
+                    if class_use == percentage_constraint:
+                        self.x = self.game.renderer.get_screen_size()[0] * self.x_constraint.value
+                    if class_use == pixel_constraint:
+                        self.x = self.x_constraint.value
+                else:
+                    if class_use == center_constraint:
+                        self.x = self.parent.x + (self.parent.width / 2) - (int(self.width) / 2)
+                    if class_use == percentage_constraint:
+                        self.x = self.parent.x + (self.parent.width * self.x_constraint.value)
+                    if class_use == pixel_constraint:
+                        self.x = self.parent.x + self.x_constraint.value
+
+            # Set Y Constraints
+
+            if self.y_constraint != None:
+                class_use = type(self.y_constraint)
+                if self.parent == None:
+                    if class_use == center_constraint:
+                        self.y = self.game.renderer.get_screen_size()[1] / 2 - (int(self.height) / 2)
+                    if class_use == percentage_constraint:
+                        self.y = self.game.renderer.get_screen_size()[1] * self.y_constraint.value
+                    if class_use == pixel_constraint:
+                        self.y = self.y_constraint.value
+                else:
+                    if class_use == center_constraint:
+                        self.y = self.parent.y + (self.parent.height / 2) - (int(self.height) / 2)
+                    if class_use == percentage_constraint:
+                        self.y = self.parent.y + (self.parent.height * self.y_constraint.value)
+                    if class_use == pixel_constraint:
+                        self.y = self.parent.y + self.y_constraint.value
+
+        ## Set size thingy
+
+        if not self.tween_s:
+
+            # Set Width Constraints
+
+            if self.width_constraint != None:
+                class_use = type(self.width_constraint)
+                if self.parent == None:
+                    if class_use == percentage_constraint:
+                        self.width = self.game.renderer.get_screen_size()[0] * self.width_constraint.value
+                    if class_use == aspect_constraint:
+                        self.width = self.height * self.width_constraint.value
+                    if class_use == pixel_constraint:
+                        self.width = self.width_constraint.value
+                else:
+                    if class_use == percentage_constraint:
+                        self.width = self.parent.width * self.width_constraint.value
+                    if class_use == aspect_constraint:
+                        self.width = self.height * self.width_constraint.value
+                    if class_use == pixel_constraint:
+                        self.width = self.width_constraint.value
+
+            # Set Height Constraints
+
+            if self.height_constraint != None:
+                class_use = type(self.height_constraint)
+                if self.parent == None: 
+                    if class_use == percentage_constraint:
+                        self.height = self.game.renderer.get_screen_size()[1] * self.height_constraint.value
+                    if class_use == aspect_constraint:
+                        self.height = self.width * self.height_constraint.value
+                    if class_use == pixel_constraint:
+                        self.height = self.height_constraint.value
+                else:
+                    if class_use == percentage_constraint:
+                        self.height = self.parent.height * self.height_constraint.value
+                    if class_use == aspect_constraint:
+                        self.height = self.width * self.height_constraint.value()
+                    if class_use == pixel_constraint:
+                        self.height = self.height_constraint.value
+
+        # Tween Position
+
+        if self.tween:
+            tmp_x = 0
+            tmp_y = 0
+            class_use = type(self.tween_x)
+            if self.parent == None:
+                if class_use == center_constraint:
+                    tmp_x = self.game.renderer.get_screen_size()[0] / 2 - (int(self.width) / 2)
+                if class_use == percentage_constraint:
+                    tmp_x = self.game.renderer.get_screen_size()[0] * self.tween_x.value
+                if class_use == pixel_constraint:
+                    tmp_x = self.tween_x.value
+            else:
+                if class_use == center_constraint:
+                    tmp_x = self.parent.x + (self.parent.width / 2) - (int(self.width) / 2)
+                if class_use == percentage_constraint:
+                    tmp_x = self.parent.x + (self.parent.width * self.tween_x.value)
+                if class_use == pixel_constraint:
+                    tmp_x = self.parent.x + self.tween_x.value
+
+            class_use = type(self.tween_y)
+            if self.parent == None:
+                if class_use == center_constraint:
+                    tmp_y = self.game.renderer.get_screen_size()[1] / 2 - (int(self.height) / 2)
+                if class_use == percentage_constraint:
+                    tmp_y = self.game.renderer.get_screen_size()[1] * self.tween_y.value
+                if class_use == pixel_constraint:
+                    tmp_y = self.tween_y.value
+            else:
+                if class_use == center_constraint:
+                    tmp_y = self.parent.y + (self.parent.height / 2) - (int(self.height) / 2)
+                if class_use == percentage_constraint:
+                    tmp_y = self.parent.y + (self.parent.height * self.tween_y.value)
+                if class_use == pixel_constraint:
+                    tmp_y = self.parent.y + self.tween_y.value
+
+            self.x += (tmp_x - self.x) / ((self.tween_mult * self.game.delta_time) * 600)
+            self.y += (tmp_y - self.y) / ((self.tween_mult * self.game.delta_time) * 600) 
+            if int(self.x) == int(tmp_y) and int(self.y) and int(tmp_y):
+                self.tween = False
+                self.x_constraint = self.tween_x
+                self.y_constraint = self.tween_y
+
+        # Tween Size
+
+        if self.tween_s:
+            tmp_width = 0
+            tmp_height = 0
+            class_use = type(self.tween_width)
+            if self.parent == None:
+                if class_use == percentage_constraint:
+                    tmp_width = self.game.renderer.get_screen_size()[0] * self.tween_width.value
+                if class_use == aspect_constraint:
+                    tmp_width = tmp_height
+                if class_use == pixel_constraint:
+                    tmp_width = self.tween_width.value
+            else:
+                if class_use == percentage_constraint:
+                    tmp_width = self.parent.width * self.tween_width.value
+                if class_use == aspect_constraint:
+                    tmp_width = tmp_height
+                if class_use == pixel_constraint:
+                    tmp_width = self.tween_width.value
+
+            class_use = type(self.tween_height)
+            if self.parent == None: 
+                if class_use == percentage_constraint:
+                    tmp_height = self.game.renderer.get_screen_size()[1] * self.tween_height.value
+                if class_use == aspect_constraint:
+                    tmp_height = tmp_width
+                if class_use == pixel_constraint:
+                    tmp_height = self.tmp_height.value
+            else:
+                if class_use == percentage_constraint:
+                    tmp_height = self.parent.height * self.tmp_height.value
+                if class_use == aspect_constraint:
+                    tmp_height = tmp_width
+                if class_use == pixel_constraint:
+                    tmp_height = self.tmp_height.value
+                    
+            self.width += (tmp_width - self.width) / ((self.tween_s_mult * self.game.delta_time) * 600)
+            self.height += (tmp_height - self.height) / ((self.tween_s_mult * self.game.delta_time) * 600) 
+            if int(self.width) == int(tmp_width) and int(self.height) and int(tmp_height):
+                self.tween_s = False
+                self.width_constraint = self.tween_width
+                self.height_constraint = self.tween_height
+
+    def render(self):
+        if self.visible:
+            pygame.draw.rect(self.game.renderer.screen, self.color, ((self.x, self.y), (self.width, self.height)), self.outline, self.border_radius)
+        
+class gui_toggle_button:
+    def __init__(self, game) -> None:
+        self.game = game
+        self.rect = gui_rect(game)
+    
+        self.hover = False
+        self.toggled = False
+
+    def update(self):
+        self.rect.update()
+        if self.rect.is_touching_mouse():
+            self.hover = True
+        else:
+            self.hover = False
+
+        if self.hover and self.game.input.is_mouse_button_just_pressed():
+            self.toggled = not self.toggled
+
+    def render(self):
+        self.rect.render()
+
+class gui_press_button:
+    def __init__(self, game) -> None:
+        self.game = game
+        self.rect = gui_rect(game)
+    
+        self.hover = False
+        self.pressed = False
+
+    def update(self):
+        self.rect.update()
+        if self.rect.is_touching_mouse():
+            self.hover = True
+        else:
+            self.hover = False
+
+        if self.hover and self.game.input.is_mouse_button_pressed():
+            self.pressed = True
+        else:
+            self.pressed = False
+
+    def render(self):
+        self.rect.render()
+
+class gui_slider:
+    def __init__(self, game, val_start, val_end) -> None:
+        self.game = game
+        self.slider_body = gui_rect(game)
+        self.slider_head = gui_rect(game)
+
+        self.value = 0
+        self.value_range = (val_start, val_end)
+
+    def update(self):
+        self.slider_body.update()
+        self.slider_head.update()
+
+        slider_bigger_bounding_box = ((self.slider_body.x, self.slider_body.y - 10), (self.slider_body.width, self.slider_body.height + 30))
+
+        self.slider_head.x = max(self.slider_body.x, min(self.slider_head.x, self.slider_body.x + self.slider_body.width))
+
+        self.value = (self.slider_head.x - self.slider_body.x) / (self.slider_body.width / self.value_range[1]) * 1.06
+
+        mx, my = pygame.mouse.get_pos()
+        if self.game.math.in_rect(mx, my, slider_bigger_bounding_box[0][0], slider_bigger_bounding_box[0][1], slider_bigger_bounding_box[1][0], slider_bigger_bounding_box[1][1]) and self.game.input.is_mouse_button_pressed():
+            self.slider_head.tween_to(pixel_constraint(mx - self.slider_head.parent.x - self.slider_head.width / 2), center_constraint(), 12)
+
+    def render(self):
+        self.slider_body.render()
+        self.slider_head.render()

src/scripts/modules/image.py

···
+import pygame, os
+
+class image:
+    def __init__(self, game):
+        self.game = game
+
+    def load(self, image):
+        return pygame.image.load(os.path.join('src', 'resources', self.game.current_assetpack, 'assets', 'images', image))

src/scripts/modules/input.py

···
+from re import L
+import pygame, keyboard
+
+class Input:
+
+    input_state = "main"
+
+    record_keys = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z",
+                   "1", "2", "3", "4", "5", "6", "7", "8", "9", "0",
+                   "UP", "DOWN", "LEFT", "RIGHT", 
+                   "SPACE", "CTRL", "SHIFT", "ALT", "RETURN", "ESCAPE", "TAB", "BACKSPACE",
+                   "period", "subtract", "'"]
+
+    def set_input_state(self, state):
+        self.input_state = state
+
+    def __init__(self):
+        self.any_key_pressed = False
+        
+        self.last_frame_keys = []
+        for i in self.record_keys:
+            self.last_frame_keys.append(False)
+
+        self.mouse_button_last_frame = False
+
+    def is_pressed(self, key, input_state=""):
+        if input_state != "":
+            return bool(keyboard.is_pressed(key) and pygame.mouse.get_focused() and input_state == self.input_state)
+        else:
+            return bool(keyboard.is_pressed(key) and pygame.mouse.get_focused())
+
+    def check_keys(self):
+        for i, key in enumerate(self.record_keys):
+            self.last_frame_keys[i] = self.is_pressed(key)
+
+    def is_just_pressed(self, key, input_state=""):
+        if input_state != "":
+            return bool(keyboard.is_pressed(key) and not self.last_frame_keys[self.record_keys.index(key)] and pygame.mouse.get_focused() and input_state == self.input_state)
+        else:
+            return bool(keyboard.is_pressed(key) and not self.last_frame_keys[self.record_keys.index(key)] and pygame.mouse.get_focused())
+
+    def is_any_key_pressed(self):
+        return self.any_key_pressed
+
+    def is_mouse_button_pressed(self):
+        return pygame.mouse.get_pressed()[0]
+    
+    def is_mouse_button_just_pressed(self):
+        return pygame.mouse.get_pressed()[0] and not self.mouse_button_last_frame

src/scripts/modules/language.py

···
+import json, os
+
+class Language_Handler:
+    current_language_id = "en_US"
+
+    def __init__(self, game):
+        self.game = game
+
+        with open(os.path.join("src", "resources", self.game.current_assetpack, "data", "lang", self.current_language_id + ".json"), "r") as lang_file:
+            self.lang_json = json.load(lang_file)
+    
+    def translatable_text(self, lang_file_link):
+        if lang_file_link in self.lang_json:
+            text = self.lang_json[lang_file_link]
+            return text
+        else:
+            return lang_file_link
+        
+
+
+    

src/scripts/modules/math_utils.py

···
+import pygame, math
+
+class math_utils:
+    def rotate_center(self, image, angle, x, y):
+        rotated_image = pygame.transform.rotate(image, angle)
+        new_rect = rotated_image.get_rect(center = image.get_rect(center = (x, y)).center)
+
+        return rotated_image, new_rect
+    
+    def distance_between_points(self, x1, y1, x2, y2):
+        return math.hypot(x2 - x1, y2 - y1)
+
+    def direction_between_points(self, x1, y1, x2, y2):
+        radians = math.atan2(y2-y1, x2-x1)
+        return(math.degrees(radians))
+
+    def lengthdir_x(self, length, angle):
+        radian_angle = angle * math.pi / 180
+        return length * math.cos(radian_angle)
+
+    def lengthdir_y(self, length, angle):
+        radian_angle = angle * math.pi / 180
+        return length * math.sin(radian_angle)
+
+    def in_rect(self, x, y, rectx, recty, width, height):
+        if x > rectx and x < rectx + width:
+            if y > recty and y < recty + height:
+                return True
+        return False

src/scripts/modules/renderer.py

···
+import pygame, pyautogui
+
+class Screen:
+    pass
+
+class Camera:
+    def __init__(self) -> None:
+        self.x = 0
+        self.y = 0
+
+class renderer:
+    def __init__(self, game):
+        self.game = game
+        self.camera = Camera()
+
+        self.screens = {}
+        self.current_screen = ''
+
+        self.screen = pygame.display.set_mode((1280, 720), pygame.RESIZABLE)
+
+    def get_screen_size(self):
+        return (self.screen.get_width(), self.screen.get_height())
+
+    def load_screen(self, screen: Screen, screen_id):
+        screen_add = screen
+        self.screens[screen_id] = screen_add
+
+    def switch_screen(self, screen_id):
+        self.current_screen = screen_id
+
+    def update(self):
+        self.screens[self.current_screen].update()
+
+    def render(self):
+        self.screens[self.current_screen].render()
+        pygame.display.update()

src/scripts/modules/screens/screen_1.py

···
+from src.scripts.modules.renderer import Screen
+from src.scripts.modules.gui import *
+import os
+
+class screen_1(Screen):
+    def __init__(self, game):
+        self.game = game
+
+        self.button = gui_toggle_button(game)
+
+        self.button.rect.set_x_constraint(percentage_constraint(0.06))
+        self.button.rect.set_y_constraint(percentage_constraint(0.07))
+        self.button.rect.set_height_constraint(percentage_constraint(0.1))
+        self.button.rect.set_width_constraint(aspect_constraint(3))
+        self.button.rect.set_border_radius(5)
+        self.button.rect.set_draw_color(self.game.color_handler.get_rgb('main_menu.bright_bg'))
+
+        self.slider = gui_slider(game, 0, 100)
+
+        self.slider.slider_body.set_x_constraint(percentage_constraint(0.06))
+        self.slider.slider_body.set_y_constraint(percentage_constraint(0.25))
+        self.slider.slider_body.set_width_constraint(pixel_constraint(200))
+        self.slider.slider_body.set_height_constraint(pixel_constraint(5))
+        self.slider.slider_body.set_border_radius(50)
+        self.slider.slider_body.set_draw_color(self.game.color_handler.get_rgb('main_menu.bright_bg'))   
+
+        self.slider.slider_head.parent = self.slider.slider_body
+        self.slider.slider_head.set_x_constraint(pixel_constraint(0))
+        self.slider.slider_head.set_y_constraint(center_constraint())
+        self.slider.slider_head.set_width_constraint(pixel_constraint(20))
+        self.slider.slider_head.set_height_constraint(pixel_constraint(20))
+        self.slider.slider_head.set_border_radius(10)
+        self.slider.slider_head.set_draw_color(self.game.color_handler.get_rgb('main_menu.text'))     
+
+        self.button2 = gui_toggle_button(game)   
+
+        self.button2.rect.set_x_constraint(percentage_constraint(0.06))
+        self.button2.rect.set_y_constraint(percentage_constraint(0.32))
+        self.button2.rect.set_width_constraint(percentage_constraint(0.12))
+        self.button2.rect.set_height_constraint(percentage_constraint(0.1))
+        self.button2.rect.set_outline_radius(5)
+        self.button2.rect.set_border_radius(30)
+        self.button2.rect.set_draw_color(self.game.color_handler.get_rgb('main_menu.bright_bg'))
+
+        self.button_inside_rect = gui_rect(game)
+
+        self.button_inside_rect.parent = self.button2.rect
+        self.button_inside_rect.set_x_constraint(percentage_constraint(0.05))
+        self.button_inside_rect.set_y_constraint(center_constraint())
+        self.button_inside_rect.set_width_constraint(aspect_constraint(1))
+        self.button_inside_rect.set_height_constraint(percentage_constraint(0.8))
+        self.button_inside_rect.set_border_radius(30)
+        self.button_inside_rect.set_draw_color(self.game.color_handler.get_rgb('main_menu.bright_bg')) 
+
+    def update(self):
+        self.button.update()
+        self.slider.update()
+        self.button2.update()
+        self.button_inside_rect.update()
+
+        self.button.rect.set_draw_color(self.game.color_handler.get_rgb('main_menu.bright_bg'))
+        if self.button.hover:
+            self.button.rect.tween_to(percentage_constraint(0.08), percentage_constraint(0.07), 24)
+            self.button.rect.set_draw_color(self.game.color_handler.get_rgb('main_menu.bright_bg_2'))
+        else:
+            self.button.rect.tween_to(percentage_constraint(0.06), percentage_constraint(0.07), 24)
+
+        if self.button.toggled:
+            self.button.rect.set_draw_color(self.game.color_handler.get_rgb('main_menu.text'))
+            self.button.rect.tween_to(percentage_constraint(0.08), percentage_constraint(0.07), 24)
+
+        if self.button2.hover:
+            self.button_inside_rect.set_draw_color(self.game.color_handler.get_rgb('main_menu.bright_bg_2'))
+        else:
+            self.button_inside_rect.set_draw_color(self.game.color_handler.get_rgb('main_menu.bright_bg'))
+        
+        self.button_inside_rect.tween_to(percentage_constraint(0.05), center_constraint(), 24)
+        if self.button2.toggled:
+            self.button_inside_rect.tween_to(percentage_constraint(0.57), center_constraint(), 24)
+
+    def render(self):
+        self.game.renderer.screen.fill(self.game.color_handler.get_rgb('main_menu.background'))
+        self.button.render()
+        self.slider.render()
+        self.button2.render()
+        self.button_inside_rect.render()
+        self.game.renderer.screen.blit(self.game.font_handler.render(str(int(self.slider.value)), 'default', 32, self.game.color_handler.get_rgb('main_menu.text')), (300, 160))
+        #value = int((self.slider_head.x - self.slider_body.x) / (self.slider_body.width / 100))
+        #self.game.renderer.screen.blit(self.game.font_handler.render(str(value), 'default', 48, self.game.color_handler.get_rgb('main_menu.text')), (20, 20))

src/scripts/modules/screens/screen_2.py

···
+from src.scripts.modules.renderer import Screen
+from src.scripts.modules.gui import *
+import os
+
+class screen_2(Screen):
+    def __init__(self, game):
+        self.game = game
+
+        self.slider = gui_slider(game, 0, 100)
+
+        self.slider.slider_body.set_x_constraint(center_constraint())
+        self.slider.slider_body.set_y_constraint(center_constraint())
+        self.slider.slider_body.set_width_constraint(pixel_constraint(200))
+        self.slider.slider_body.set_height_constraint(pixel_constraint(5))
+        self.slider.slider_body.set_border_radius(10)
+        self.slider.slider_body.set_draw_color(self.game.color_handler.get_rgb('main_menu.bright_bg'))   
+
+        self.slider.slider_head.parent = self.slider.slider_body
+        self.slider.slider_head.set_x_constraint(pixel_constraint(0))
+        self.slider.slider_head.set_y_constraint(center_constraint())
+        self.slider.slider_head.set_width_constraint(pixel_constraint(20))
+        self.slider.slider_head.set_height_constraint(pixel_constraint(20))
+        self.slider.slider_head.set_border_radius(10)
+        self.slider.slider_head.set_draw_color(self.game.color_handler.get_rgb('main_menu.text'))      
+
+    def update(self):
+        self.slider.update()
+
+    def render(self):
+        self.game.renderer.screen.fill(self.game.color_handler.get_rgb('main_menu.background'))
+        self.slider.render()
+        #value = int((self.slider_head.x - self.slider_body.x) / (self.slider_body.width / 100))
+        #self.game.renderer.screen.blit(self.game.font_handler.render(str(value), 'default', 48, self.game.color_handler.get_rgb('main_menu.text')), (20, 20))

src/scripts/modules/screens/screen_3.py

···
+from src.scripts.modules.renderer import Screen
+from src.scripts.modules.gui import *
+import os
+
+class screen_3(Screen):
+    def __init__(self, game):
+        self.game = game
+
+        self.rect = gui_rect(game)   
+
+        self.rect.set_x_constraint(center_constraint())
+        self.rect.set_y_constraint(pixel_constraint(20))
+        self.rect.set_width_constraint(percentage_constraint(0.1))
+        self.rect.set_height_constraint(aspect_constraint(1))
+        self.rect.set_draw_color(self.game.color_handler.get_rgb('main_menu.bright_bg'))
+
+    def update(self):
+        self.rect.update()
+
+    def render(self):
+        self.game.renderer.screen.fill(self.game.color_handler.get_rgb('main_menu.background'))
+        self.rect.render()

src/scripts/modules/screens/screen_4.py

···
+from src.scripts.modules.renderer import Screen
+from src.scripts.modules.gui import *
+import os
+
+class screen_4(Screen):
+    def __init__(self, game):
+        self.game = game
+
+        self.button = gui_toggle_button(game)   
+
+        self.button.rect.set_x_constraint(center_constraint())
+        self.button.rect.set_y_constraint(center_constraint())
+        self.button.rect.set_width_constraint(percentage_constraint(0.12))
+        self.button.rect.set_height_constraint(percentage_constraint(0.1))
+        self.button.rect.set_outline_radius(5)
+        self.button.rect.set_border_radius(30)
+        self.button.rect.set_draw_color(self.game.color_handler.get_rgb('main_menu.bright_bg'))
+
+        self.button_inside_rect = gui_rect(game)
+
+        self.button_inside_rect.parent = self.button.rect
+        self.button_inside_rect.set_x_constraint(percentage_constraint(0.05))
+        self.button_inside_rect.set_y_constraint(center_constraint())
+        self.button_inside_rect.set_width_constraint(aspect_constraint(1))
+        self.button_inside_rect.set_height_constraint(percentage_constraint(0.8))
+        self.button_inside_rect.set_border_radius(30)
+        self.button_inside_rect.set_draw_color(self.game.color_handler.get_rgb('main_menu.bright_bg'))
+
+
+    def update(self):
+        self.button.update()
+        self.button_inside_rect.update()
+
+        if self.button.hover:
+            self.button_inside_rect.set_draw_color(self.game.color_handler.get_rgb('main_menu.bright_bg_2'))
+        else:
+            self.button_inside_rect.set_draw_color(self.game.color_handler.get_rgb('main_menu.bright_bg'))
+        
+        self.button_inside_rect.tween_to(percentage_constraint(0.05), center_constraint(), 24)
+        if self.button.toggled:
+            self.button_inside_rect.tween_to(percentage_constraint(0.57), center_constraint(), 24)
+
+    def render(self):
+        self.game.renderer.screen.fill(self.game.color_handler.get_rgb('main_menu.background'))
+        self.button.render()
+        self.button_inside_rect.render()

src/scripts/modules/sound.py

···
+import pygame, os
+pygame.mixer.init()
+
+class Sound_Handler:
+
+    sounds = {}
+
+    def __init__(self, game):
+        self.game = game
+
+    def load_sound(self, sound_id, sound_file):
+        self.sounds[sound_id] = {
+            "file": pygame.mixer.Sound(os.path.join("src", "resources", self.game.current_assetpack, "assets", "sounds", sound_file + ".ogg"))
+        }
+
+    def play_sound(self, sound_id):
+        self.sounds[sound_id]["file"].play()

src/scripts/project.py

···
+def update():
+    pass
+
+def render():
+    pass