poggers

.vscode/settings.json

···
+{
+    "python.pythonPath": "C:\\Users\\wille\\AppData\\Local\\Programs\\Python\\Python39\\python.exe"
+}

client.py

···
 import pygame, time
-from src.scripts.game import Game
+from src.scripts.game_manager import Game_Manager
 from src.scripts.project import *
 
-game = Game()
+game = Game_Manager()
 
 game.initialize()
 

src/scripts/game.py src/scripts/game_manager.py

···
 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
+from .screens.main_menu import main_menu
 
-class Game:
+class Game_Manager:
 
     game_speed = 1
     clock = pygame.time.Clock()
···
         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
+        screen_main_menu = main_menu(self)
+        self.renderer.load_screen(screen_main_menu, 'main_menu')
+        self.renderer.switch_screen('main_menu')
 
     def update(self):
         # Calculate Delta Time
···
                 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()

src/scripts/game/player.py

···
+import pygame, math
+from src.scripts.modules.entity import *
+
+class player_movement_component:
+    def __init__(self, game, parent) -> None:
+        self.game = game
+        self.parent = parent
+    
+    def update(self):
+        if self.game.input.is_pressed("a"):
+            self.parent.transform.x -= 1
+        if self.game.input.is_pressed("d"):
+            self.parent.transform.x += 1
+        if self.game.input.is_pressed("w"):
+            self.parent.transform.y-= 1
+        if self.game.input.is_pressed("s"):
+            self.parent.transform.y += 1
+
+    def render(self):
+        pass
+
+class player_renderer_component:
+    def __init__(self, game, parent) -> None:
+        self.game = game
+        self.parent = parent
+
+        self.image = self.game.image.load("player.png")
+
+    def update(self):
+        pass
+    
+    def render(self):
+        self.game.renderer.screen.blit(self.image, (self.parent.transform.x, self.parent.transform.y))
+
+class Player(Entity):
+    def __init__(self, game) -> None:
+        self.game = game
+
+        self.components = []
+
+        self.transform = Transform()
+        self.transform.y = 500
+
+        self.add_component(player_movement_component(game, self))
+        self.add_component(player_renderer_component(game, self))

src/scripts/modules/entity.py

···
+class Transform:
+    def __init__(self) -> None:
+        self.x = 0
+        self.y = 0
+
+class Entity:
+    def add_component(self, component):
+        if component not in self.components:
+            self.components.append(component)
+
+    def remove_component(self, component):
+        if component not in self.components:
+            self.components.remove(self.components.index(component))
+
+    def update(self):
+        for component in self.components:
+            component.update()
+
+    def render(self):
+        for component in self.components:
+            component.render()

src/scripts/modules/gui.py

···
 import pygame
 
-class center_constraint():
+class rect_constraints():
     pass
 
-class aspect_constraint():
+class center_constraint(rect_constraints):
+    pass
+
+class aspect_constraint(rect_constraints):
     def __init__(self, aspect_ratio) -> None:
         self.value = aspect_ratio
 
-class percentage_constraint():
+class percentage_constraint(rect_constraints):
     def __init__(self, percentage):
         self.value = percentage
 
-class pixel_constraint():
+class pixel_constraint(rect_constraints):
     def __init__(self, pixel):
         self.value = pixel
+
+class text_size_constraint:
+    pass
+
+class resize_constraint:
+    pass
+
+class samesize_constraint:
+    pass
 
 class gui_rect:
     x_constraint = None
···
                 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:
+                    elif class_use == percentage_constraint:
                         self.x = self.game.renderer.get_screen_size()[0] * self.x_constraint.value
-                    if class_use == pixel_constraint:
+                    elif 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:
+                    elif class_use == percentage_constraint:
                         self.x = self.parent.x + (self.parent.width * self.x_constraint.value)
-                    if class_use == pixel_constraint:
+                    elif class_use == pixel_constraint:
                         self.x = self.parent.x + self.x_constraint.value
 
             # Set Y Constraints
···
                 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:
+                    elif class_use == percentage_constraint:
                         self.y = self.game.renderer.get_screen_size()[1] * self.y_constraint.value
-                    if class_use == pixel_constraint:
+                    elif 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:
+                    elif class_use == percentage_constraint:
                         self.y = self.parent.y + (self.parent.height * self.y_constraint.value)
-                    if class_use == pixel_constraint:
+                    elif class_use == pixel_constraint:
                         self.y = self.parent.y + self.y_constraint.value
 
         ## Set size thingy
···
                 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:
+                    elif class_use == aspect_constraint:
                         self.width = self.height * self.width_constraint.value
-                    if class_use == pixel_constraint:
+                    elif 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:
+                    elif class_use == aspect_constraint:
                         self.width = self.height * self.width_constraint.value
-                    if class_use == pixel_constraint:
+                    elif class_use == pixel_constraint:
                         self.width = self.width_constraint.value
 
             # Set Height Constraints
···
                 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:
+                    elif class_use == aspect_constraint:
                         self.height = self.width * self.height_constraint.value
-                    if class_use == pixel_constraint:
+                    elif 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:
+                    elif class_use == aspect_constraint:
                         self.height = self.width * self.height_constraint.value()
-                    if class_use == pixel_constraint:
+                    elif class_use == pixel_constraint:
                         self.height = self.height_constraint.value
 
         # Tween Position
···
             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:
+                elif class_use == percentage_constraint:
                     tmp_x = self.game.renderer.get_screen_size()[0] * self.tween_x.value
-                if class_use == pixel_constraint:
+                elif 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:
+                elif class_use == percentage_constraint:
                     tmp_x = self.parent.x + (self.parent.width * self.tween_x.value)
-                if class_use == pixel_constraint:
+                elif 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:
+                elif class_use == percentage_constraint:
                     tmp_y = self.game.renderer.get_screen_size()[1] * self.tween_y.value
-                if class_use == pixel_constraint:
+                elif 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:
+                elif class_use == percentage_constraint:
                     tmp_y = self.parent.y + (self.parent.height * self.tween_y.value)
-                if class_use == pixel_constraint:
+                elif 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)
···
             if self.parent == None:
                 if class_use == percentage_constraint:
                     self.tmp_width = self.game.renderer.get_screen_size()[0] * self.tween_width.value
-                if class_use == aspect_constraint:
+                elif class_use == aspect_constraint:
                     self.tmp_width = self.tmp_height
-                if class_use == pixel_constraint:
+                elif class_use == pixel_constraint:
                     self.tmp_width = self.tween_width.value
             else:
                 if class_use == percentage_constraint:
                     self.tmp_width = self.parent.width * self.tween_width.value
-                if class_use == aspect_constraint:
+                elif class_use == aspect_constraint:
                     self.tmp_width = self.tmp_height
-                if class_use == pixel_constraint:
+                elif class_use == pixel_constraint:
                     self.tmp_width = self.tween_width.value
 
             class_use = type(self.tween_height)
             if self.parent == None: 
                 if class_use == percentage_constraint:
                     self.tmp_height = self.game.renderer.get_screen_size()[1] * self.tween_height.value
-                if class_use == aspect_constraint:
+                elif class_use == aspect_constraint:
                     self.tmp_height = self.tmp_width
-                if class_use == pixel_constraint:
+                elif class_use == pixel_constraint:
                     self.tmp_height = self.self.tmp_height.value
             else:
                 if class_use == percentage_constraint:
                     self.tmp_height = self.parent.height * self.tween_height.value
-                if class_use == aspect_constraint:
+                elif class_use == aspect_constraint:
                     self.tmp_height = self.tmp_width
-                if class_use == pixel_constraint:
+                elif class_use == pixel_constraint:
                     self.tmp_height = self.self.tmp_height.value
                     
             self.width += (self.tmp_width - self.width) / ((self.tween_s_mult * self.game.delta_time) * 600)
···
         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_text:
+    def set_size_constraint(self, constraint):
+        self.size_constraint = constraint
+
+    def __init__(self, game) -> None:
+        self.game = game
+
+        self.text = ""
+        self.draw_text = self.text
+        self.parent = None
+
+    def update(self):
+        if self.parent == None:
+            print('Parent of text field must be set')
+            return
+
+        class_use = type(self.size_constraint)
+        if class_use == resize_constraint:
+            pass    
+
+    def render(self):
+        pass
+
 class gui_toggle_button:
     def __init__(self, game) -> None:
         self.game = game

src/scripts/modules/screens/screen_1.py src/scripts/screens/gui_test.py

···
 from src.scripts.modules.gui import *
 import os
 
-class screen_1(Screen):
+class gui_test(Screen):
     def __init__(self, game):
         self.game = game
 

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/screens/main_menu.py

···
+from src.scripts.modules.renderer import Screen
+from src.scripts.modules.gui import *
+import os
+
+from src.scripts.game.player import Player
+
+class main_menu(Screen):
+    def __init__(self, game):
+        self.game = game
+
+        self.player = Player(game)
+
+    def update(self):
+        self.player.update()
+
+    def render(self):
+        self.game.renderer.screen.fill(self.game.color_handler.get_rgb('main_menu.background'))
+        self.player.render()