sverpykit 0.1.14__tar.gz

sverpykit-0.1.14/PKG-INFO

@@ -0,0 +1,4 @@
+Metadata-Version: 2.4
+Name: sverpykit
+Version: 0.1.14
+Requires-Dist: pygame

sverpykit-0.1.14/README.md

@@ -0,0 +1,10 @@
+# Sverrys PygameTools
+Sverrys PygameTools is a wrapper for the library "pygame" that adds a basic runtime and UI logic.
+
+How to use:<br>
+To use Sverrys PygameTools you must install it from github by executing this command
+in your terminal:<br>
+`python3 -m pip install git+https://github.com/Sverryboiii/PygameTools.git`.<br>
+This will install all the files from the directory `sverpykit`.
+
+Huge thank you to the developers of pygame and python. Without you all this wouldn't be possible!

sverpykit-0.1.14/pyproject.toml

@@ -0,0 +1,10 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "sverpykit"
+version = "0.1.14"
+dependencies = [
+    "pygame"
+]

sverpykit-0.1.14/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

sverpykit-0.1.14/sverpykit/Collide/Collide.py

@@ -0,0 +1,13 @@
+import pygame
+
+def rect_rect(
+        rect1: pygame.Rect,
+        rect2: pygame.Rect
+):
+    return rect1.colliderect(rect2)
+
+def rect_point(
+        rect: pygame.Rect,
+        point: tuple[int, int]
+):
+    return rect.collidepoint(point)

sverpykit-0.1.14/sverpykit/Draw/Draw.py

@@ -0,0 +1,123 @@
+from sverpykit.core import Config
+import pygame
+
+def draw_rect(
+        display: pygame.Surface,
+        color: tuple[int, int, int] | pygame.color.Color,
+        rectangle: pygame.Rect,
+        width: int = 0,
+        border_radius: int = 0,
+        border_top_left_radius: int = 0,
+        border_top_right_radius: int = 0,
+        border_bottom_left_radius: int = 0,
+        border_bottom_right_radius: int = 0
+) -> None:
+    """
+    :param display: The output surface.
+    :param color: The color of the rectangle.
+    :param rectangle: The dimensions of the rectangle.
+    :param width: The width of the rectangle border (Turns the rectangle itself into the border).
+    :param border_radius: The rounding of all corners.
+    :param border_top_left_radius: The rounding of the top-left corner.
+    :param border_top_right_radius: The rounding of the top-right corner.
+    :param border_bottom_left_radius: The rounding of the bottom-left corner.
+    :param border_bottom_right_radius: The rounding of the bottom-right corner.
+    """
+    if any([border_top_left_radius, border_top_right_radius, border_bottom_left_radius, border_bottom_right_radius]):
+        pygame.draw.rect(
+            surface=display,
+            color=color,
+            rect=rectangle,
+            width=width,
+            border_radius=border_radius,
+            border_top_left_radius=border_top_left_radius,
+            border_top_right_radius=border_top_right_radius,
+            border_bottom_left_radius=border_bottom_left_radius,
+            border_bottom_right_radius=border_bottom_right_radius
+        )
+        return
+    pygame.draw.rect(
+        surface=display,
+        color=color,
+        rect=rectangle,
+        width=width,
+        border_radius=border_radius
+    )
+
+def draw_circle(
+        display: pygame.Surface,
+        color: pygame.Color | tuple[int, int, int],
+        center: tuple[int, int],
+        radius: float | int,
+        width: int,
+        draw_top_left: bool = False,
+        draw_top_right: bool = False,
+        draw_bottom_left: bool = False,
+        draw_bottom_right: bool = False,
+):
+    """
+    :param display: The surface the circle gets drawn on.
+    :param color: The color of the circle.
+    :param center: The center position of the circle.
+    :param radius: The radius of the circle.
+    :param width: How thick the edges of the circle are (0 is full circle).
+
+    :param draw_top_left: Decides if pygame draws the top left segment. (If this and the next 3 are False the whole circle gets drawn.
+    :param draw_top_right: Decides if pygame draws the top right segment.
+    :param draw_bottom_left: Decides if pygame draws the bottom left segment.
+    :param draw_bottom_right: Decides if pygame draws the bottom right segment.
+    :return:
+    """
+    pygame.draw.circle(
+        surface=display,
+        color=color,
+        center=center,
+        radius=radius,
+        width=width,
+        draw_top_left=draw_top_left,
+        draw_top_right=draw_top_right,
+        draw_bottom_left=draw_bottom_left,
+        draw_bottom_right=draw_bottom_right
+    )
+
+def draw_surface(
+        surface: pygame.Surface,
+        destination: tuple[float | int, float | int],
+        area: pygame.Rect | None = None,
+        special_flags: int = 0,
+        display=None
+) -> None:
+    """
+    :param surface: The surface to draw the surface on.
+    :param destination: The x and y coordinate of the surface.
+    :param area: Where the surface gets cut off.
+    :param special_flags: How the colors are shown.
+    :param display: The surface that will be used to draw on.
+    """
+    if not display:
+        display = Config.screen
+    display.blit(
+        source=surface,
+        dest=destination,
+        area=area,
+        special_flags=special_flags
+    )
+
+def render_text(
+        text: str,
+        antialias: bool = True,
+        color: pygame.Color | tuple[int, int, int] = Config.BEIGE,
+        name: str = "default"
+) -> pygame.Surface:
+    """
+    :param text: The text displayed.
+    :param antialias: Blends outer edges of the text, so it looks smoother.
+    :param color: The color of the text.
+    :param name: Choose what font you want to use. (Must be initialized as font)
+    :return: Returns the surface so you can use it in Draw.draw_surface().
+    """
+    return Config.fonts[name].render(
+        text,
+        antialias,
+        color
+    )

sverpykit-0.1.14/sverpykit/Ui/Button.py

@@ -0,0 +1,134 @@
+from sverpykit.Draw import Draw
+from sverpykit.core import Config
+from typing import Any, Callable
+import pygame
+
+button_border_width = 3
+color_change_when_pressed = 30
+
+class Button:
+    def __init__(
+            self,
+            *args,
+            rect: pygame.Rect,
+            button_color: tuple[int, int, int] | pygame.Color,
+
+            surface: pygame.Surface,
+
+            display: pygame.Surface,
+
+            function: Callable = lambda : None,
+            rounding: int = 0,
+            resize_surface: bool = False,
+            alpha_surface: bool = True,
+            center_surface: bool = True,
+            **kwargs
+    ):
+        """
+        :param rect: A rectangle made with pygame.Rect.
+        :param button_color: The background color of the button.
+        :param display: The surface where the button gets placed on (Most of the time just the base display).
+        :param surface: A surface of any kind (Text, Image, Even a surface with a rectangle).
+        :param rounding: How much the corners of the button is rounded.
+        :param resize_surface: Resize the screen to the highest resolution possible for the button (Could mess up the surface).
+        :param alpha_surface: If the background of the surface is invisible (Not needed if the surface is already alpha or
+        if you rendered a text).
+        :param center_surface: If the surface should be centered or just be at the 0,0 coordinate of the button.
+        :param function: This function gets executed when you release the button.
+        :param args: Used as arguments for the function of the button.
+        :param kwargs: Used as key-word arguments for the function of the button.
+        """
+
+        self.display = display
+
+        self.button_color = button_color
+
+        self.rect = rect
+        self.hitbox_offset = (0, 0)
+        self.rounding = rounding
+
+        self.function = function
+        self.args = args
+        self.kwargs = kwargs
+
+        self.surf = surface
+        self.resize_surf = resize_surface
+        self.alpha_surface = alpha_surface
+        self.center_surf = center_surface
+
+        self.pressed = False
+
+    def draw(self, display=None) -> None:
+        if not display:
+            display = self.display
+
+        # Background
+        Draw.draw_rect(
+            display=display,
+            color=self.button_color if not self.pressed else (
+                max(0, self.button_color[0] - 30),
+                max(0, self.button_color[1] - 30),
+                max(0, self.button_color[2] - 30)
+            ),
+            rectangle=self.rect,
+            border_radius=self.rounding
+        )
+        Draw.draw_rect(
+            display=display,
+            color=(
+                max(0, self.button_color[0] + color_change_when_pressed),
+                max(0, self.button_color[1] + color_change_when_pressed),
+                max(0, self.button_color[2] + color_change_when_pressed)
+            ),
+            rectangle=self.rect,
+            width=button_border_width,
+            border_radius=self.rounding
+        )
+
+        # Text
+        Draw.draw_surface(
+            surface=self.surf,
+            destination=(0,0) if not self.center_surf else (
+                self.rect.x + self.rect.w/2 - self.surf.get_width()/2,
+                self.rect.y + self.rect.h/2 - self.surf.get_height()/2
+            ),
+            display=display
+        )
+
+    def events(self) -> Any | None:
+        """
+        :return: Will return None unless pressed and released (In that case it will return the returned value of the function)
+        """
+        mp = pygame.mouse.get_pos()
+        click = False
+        for event in Config.events:
+            if event.type == pygame.MOUSEBUTTONDOWN and event.button == 1:
+                click = True
+
+        if self.pressed:
+            if not click or not pygame.Rect(
+            self.rect.x + self.hitbox_offset[0],
+            self.rect.y + self.hitbox_offset[1],
+            self.rect.w,
+            self.rect.h
+        ).collidepoint(mp):
+                self.pressed = False
+                return self.function(*self.args, **self.kwargs)
+            return None
+
+        if not click:
+            return None
+
+        if pygame.Rect(
+            self.rect.x + self.hitbox_offset[0],
+            self.rect.y + self.hitbox_offset[1],
+            self.rect.w,
+            self.rect.h
+        ).collidepoint(mp):
+            self.pressed = True
+        return None
+
+    def update(self) -> Any | None:
+        value = self.events()
+        self.draw()
+        return value

sverpykit-0.1.14/sverpykit/Ui/DropDown.py

@@ -0,0 +1,144 @@
+from sverpykit.Collide import Collide
+from sverpykit.Draw import Draw
+from sverpykit.core import Config
+from typing import Any
+import pygame
+
+class DropDown:
+    def __init__(
+            self,
+            rect: pygame.Rect,
+            display: pygame.Surface,
+            choices: list[Any],
+            color: pygame.Color | tuple[int, int, int] = (50, 50, 50),
+            font: str = "default"
+    ):
+        self.rect = rect
+        self.hitbox_offset = (0, 0)
+        self.font = font
+
+        self.display = display
+        self.color = color
+        self.choices = choices
+        self.choice_rects = []
+        for i in range(len(self.choices)):
+            self.choice_rects.append(pygame.Rect(
+                self.rect.x,
+                self.rect.y + i*self.rect.h + self.rect.h,
+                self.rect.w,
+                self.rect.h
+            ))
+
+        self.selected: Any = ""
+        self.opened: bool = False
+        self.pressed: bool = False
+
+    def draw(self, display=None) -> None:
+        if not display:
+            display = self.display
+
+        Draw.draw_rect(
+            display=display,
+            color=self.color,
+            rectangle=self.rect,
+            border_radius=10,
+        )
+        Draw.draw_rect(
+            display=display,
+            color=(
+                self.color[0] + 30,
+                self.color[1] + 30,
+                self.color[2] + 30
+            ),
+            rectangle=self.rect,
+            border_radius=10,
+            width=3
+        )
+
+        Draw.draw_surface(
+            Draw.render_text(
+                str(self.selected),
+                True,
+                Config.BEIGE,
+                self.font
+            ), (
+                self.rect.x+10, self.rect.y-3
+            ),
+            display=display
+        )
+
+        if not self.opened:
+            return
+
+        for c, rect in enumerate(self.choice_rects):
+            Draw.draw_rect(
+                display=display,
+                color=(
+                    min(255, self.color[0] + 30),
+                    min(255, self.color[1] + 30),
+                    min(255, self.color[2] + 30)
+                ),
+                rectangle=rect,
+                border_radius=10
+            )
+            Draw.draw_rect(
+                display=display,
+                color=(
+                    min(255, self.color[0] + 60),
+                    min(255, self.color[1] + 60),
+                    min(255, self.color[2] + 60)
+                ),
+                rectangle=rect,
+                border_radius=10,
+                width=3
+            )
+            text = Draw.render_text(
+                text=str(self.choices[c]),
+                antialias=True,
+                color=Config.BEIGE,
+                name=self.font
+            )
+            Draw.draw_surface(text, (rect.x+10, rect.y-3), display=display)
+
+    def events(self) -> Any | None:
+        mp = pygame.mouse.get_pos()
+        click = False
+        for event in Config.events:
+            if event.type == pygame.MOUSEBUTTONDOWN and event.button == 1:
+                click = True
+
+        if not click:
+            self.pressed = False
+
+        if self.opened and click:
+            for count, rect in enumerate(self.choice_rects):
+                if not Collide.rect_point(pygame.Rect(
+                    self.rect.x + self.hitbox_offset[0],
+                    self.rect.y + self.hitbox_offset[1],
+                    self.rect.w,
+                    self.rect.h
+                ), mp):
+                    continue
+                self.selected = self.choices[count]
+                self.opened = False
+
+        if Collide.rect_point(pygame.Rect(
+            self.rect.x + self.hitbox_offset[0],
+            self.rect.y + self.hitbox_offset[1],
+            self.rect.w,
+            self.rect.h
+        ), mp) and click:
+            if self.pressed:
+                return False
+            self.opened = not self.opened
+            self.pressed = True
+        elif click:
+            self.opened = False
+
+        return None
+
+    def update(self, check_events: bool = True) -> Any | None:
+        value = None
+        if check_events: value = self.events()
+        self.draw()
+        return value

sverpykit-0.1.14/sverpykit/Ui/SearchBar.py

@@ -0,0 +1,110 @@
+from sverpykit.Collide import Collide
+from sverpykit.Draw import Draw
+from sverpykit.core import Config
+import pygame
+from typing import Any, Callable
+
+class SearchBar:
+    def __init__(
+            self,
+            *args,
+            rect: pygame.Rect,
+            display: pygame.Surface,
+            function: Callable = lambda : None,
+            color: pygame.Color | tuple[int, int, int] = (50, 50, 50),
+            **kwargs
+    ):
+        self.rect: pygame.Rect = rect
+        self.hitbox_offset = (0, 0)
+
+        self.display: pygame.Surface = display
+        self.color: pygame.Color | tuple[int, int, int] = color
+
+        self.stored: str = ""
+        self.last_stored: str = ""
+        self.stored_surf: pygame.Surface = Config.font.render(self.stored, True, Config.BEIGE)
+
+        self.selected: bool = False
+
+        self.function = function
+        self.args = args
+        self.kwargs = kwargs
+
+    def draw(self, display=None) -> None:
+        if not display:
+            display = self.display
+
+        color = self.color
+        if self.selected:
+            color = (
+                min(255, color[0] + 30),
+                min(255, color[1] + 30),
+                min(255, color[2] + 30)
+            )
+        Draw.draw_rect(
+            display=display,
+            color=color,
+            rectangle=self.rect,
+            border_radius=int(self.rect.h/2)
+        )
+        Draw.draw_rect(
+            display=display,
+            color=(
+                min(255, color[0] + 30),
+                min(255, color[1] + 30),
+                min(255, color[2] + 30)
+            ),
+            rectangle=self.rect,
+            border_radius=int(self.rect.h/2),
+            width=3
+        )
+        Draw.draw_surface(self.stored_surf, (
+            self.rect.x + self.rect.w/2 - self.stored_surf.get_width()/2,
+            self.rect.y + self.rect.h/2 - self.stored_surf.get_height()/2
+        ), display=display)
+
+    def events(self) -> Any:
+        click = False
+        for event in Config.events:
+            if event.type == pygame.MOUSEBUTTONDOWN and event.button == 1:
+                click = True
+        mp = pygame.mouse.get_pos()
+
+        if self.selected:
+            for event in Config.events:
+                if event.type != pygame.KEYDOWN:
+                    continue
+                if event.key == pygame.K_BACKSPACE:
+                    self.stored = self.stored[:-1]
+                elif event.key == pygame.K_RETURN:
+                    self.function(self.stored, *self.args, **self.kwargs)
+                    self.stored = ""
+                elif event.unicode.isprintable():
+                    self.stored += event.unicode
+
+        if self.stored != self.last_stored:
+            self.stored_surf = Draw.render_text(self.stored)
+        self.last_stored = self.stored
+
+        if not click:
+            return
+
+        if Collide.rect_point(
+            rect=pygame.Rect(
+                self.rect.x + self.hitbox_offset[0],
+                self.rect.y + self.hitbox_offset[1],
+                self.rect.w,
+                self.rect.h
+            ),
+            point=mp
+        ):
+            self.selected = True
+        else:
+            self.selected = False
+
+    def update(self, check_events: bool = True):
+        value = None
+        if check_events:
+            value = self.events()
+        self.draw()
+        return value

sverpykit-0.1.14/sverpykit/Ui/TextBlock.py

@@ -0,0 +1,22 @@
+from sverpykit.Draw import Draw
+import pygame
+
+class TextBlock:
+    def __init__(
+            self,
+            rect: pygame.Rect,
+            text: str,
+            font: str = "default"
+    ):
+        self.rect = rect
+        self.text_surf = Draw.render_text(str(text), name=font)
+
+    def draw(self):
+        Draw.draw_surface(
+            self.text_surf, (
+                self.rect.x, self.rect.y
+            ),
+        )
+
+    def change_text(self, text: str):
+        self.text_surf = Draw.render_text(str(text))

sverpykit-0.1.14/sverpykit/Ui/Window.py

@@ -0,0 +1,138 @@
+import pygame
+from sverpykit.core import Config
+from sverpykit.Draw import Draw
+from sverpykit.Ui.Button import Button
+
+title_bar_height = 30
+title_bar_font = pygame.font.SysFont("arial", 30)
+
+class Window:
+    def __init__(
+            self,
+            owner: list,
+            rect: pygame.Rect,
+            components: list,
+            color: tuple[int, int, int] =  (150, 150, 150),
+            title_bar: bool = True
+    ):
+        self.owner = owner
+
+        self.rect = rect
+        self.components = components
+        self.color = color
+        self.title_bar = title_bar
+        self.title_bar_rect = pygame.Rect(
+            self.rect.x,
+            self.rect.y - title_bar_height,
+            self.rect.w,
+            title_bar_height
+        )
+
+        # Events
+        self.last_title_bar_touch = None
+
+        self.operational_buttons = [
+            Button(
+                rect=pygame.Rect(
+                    self.rect.x + self.rect.w - title_bar_height * 2,
+                    self.rect.y - title_bar_height,
+                    title_bar_height,
+                    title_bar_height
+                ),
+                button_color=(50, 50, 50),
+                surface=title_bar_font.render("-", True, Config.BEIGE),
+                display=Config.screen,
+                rounding=int(title_bar_height / 3),
+                function=self.minimize
+            ),
+            Button(
+                rect=pygame.Rect(
+                    self.rect.x + self.rect.w - title_bar_height,
+                    self.rect.y - title_bar_height,
+                    title_bar_height,
+                    title_bar_height
+                ),
+                button_color=(50, 50, 50),
+                surface=title_bar_font.render("x", True, Config.BEIGE),
+                display=Config.screen,
+                rounding=int(title_bar_height / 3),
+                function=self.close
+            )
+        ]
+
+        for component in self.components:
+            component.hitbox_offset = (self.rect.x, self.rect.y)
+
+    def close(self):
+        self.owner.remove(self)
+
+    def minimize(self):
+        pass
+
+    def events(self):
+        mp, click = pygame.mouse.get_pos(), pygame.mouse.get_pressed()[0]
+        if self.owner[-1] is not self:
+            if (self.rect.collidepoint(mp) or self.title_bar_rect.collidepoint(mp)) and click:
+                self.owner.remove(self)
+                self.owner.append(self)
+            else:
+                return
+
+
+        if self.title_bar:
+            if self.last_title_bar_touch:
+                x_offset, y_offset = mp[0] - self.last_title_bar_touch[0], mp[1] - self.last_title_bar_touch[1]
+                self.rect.x += x_offset
+                self.rect.y += y_offset
+                self.title_bar_rect.x += x_offset
+                self.title_bar_rect.y += y_offset
+                for component in self.components:
+                    component.hitbox_offset = (self.rect.x, self.rect.y)
+                for component in self.operational_buttons:
+                    component.rect.x += x_offset
+                    component.rect.y += y_offset
+            if self.title_bar_rect.collidepoint(mp) and click:
+                self.last_title_bar_touch = mp
+            else:
+                self.last_title_bar_touch = None
+
+        [component.events() for component in self.components]
+
+        return self.rect.collidepoint(mp) or self.title_bar_rect.collidepoint(mp)
+
+    def draw(self):
+        Draw.draw_rect(
+            display=Config.screen,
+            color=self.color,
+            rectangle=self.rect,
+            border_bottom_left_radius=3,
+            border_bottom_right_radius=3
+        )
+        Draw.draw_rect(
+            display=Config.screen,
+            color=(
+                max(0, self.color[0] - 10),
+                max(0, self.color[1] - 10),
+                max(0, self.color[2] - 10)
+            ),
+            rectangle=self.rect,
+            border_bottom_left_radius=3,
+            border_bottom_right_radius=3,
+            width=2
+        )
+
+        display = pygame.Surface((self.rect.w, self.rect.h)).convert_alpha()
+        display.fill((0,0,0,0))
+        [component.draw(display) for component in self.components]
+        Draw.draw_surface(display, (self.rect.x, self.rect.y))
+
+        if self.title_bar:
+            Draw.draw_rect(
+                display=Config.screen,
+                color=(200, 200, 200),
+                rectangle=self.title_bar_rect,
+                border_top_left_radius=3,
+                border_top_right_radius=3
+            )
+
+            [button.update() for button in self.operational_buttons]

sverpykit-0.1.14/sverpykit/__init__.py

@@ -0,0 +1,25 @@
+# Core
+import pygame
+pygame.init()
+from .core import Config, Runtime
+from .core.Runtime import add_layer, start
+from .core.Config import default_exit as quit_game
+from .core.initialize import set_display, set_frame_method, set_font, set_quit_method, set_tick_method,\
+    max_rate
+
+# Drawing
+from .Draw.Draw import draw_surface, draw_rect, draw_circle, render_text
+
+# Ui parts
+from .Ui.Button import Button
+from .Ui.SearchBar import SearchBar
+from .Ui.DropDown import DropDown
+from .Ui.Window import Window
+from .Ui.TextBlock import TextBlock
+
+__all__ = [
+    "Config",
+    "Runtime",
+    "Draw",
+    "Button"
+]

sverpykit-0.1.14/sverpykit/core/Config.py

@@ -0,0 +1,40 @@
+import pygame, sys
+from typing import Callable
+
+def default_exit():
+    pygame.quit()
+    sys.exit()
+
+welcome_text = pygame.font.SysFont("arial", 100).render("Welcome!", True, (255, 255, 255))
+def frame():
+    pygame.transform.scale(welcome_text, (screen.get_width(), screen.get_height()))
+    screen.blit(welcome_text, (0, 0))
+
+def tick():
+    pass
+
+# WINDOW
+screen: pygame.Surface
+
+# Events
+max_fps: int | float = 60
+tick_rate: int | float = 60
+events: list[pygame.event.Event] = []
+clock: pygame.time.Clock = pygame.time.Clock()
+delta_time: int
+
+# Functions
+exit_function: Callable = default_exit
+frame_function: Callable = frame
+tick_function: Callable = tick
+
+# Ui
+fonts: dict[str, pygame.font.Font] = {
+    "default": pygame.font.SysFont("arial",32)
+}
+
+# Colors
+background_color: pygame.Color | tuple[int, int, int] = (25, 25, 25)
+
+# Color names
+BEIGE = (220, 245, 245)

sverpykit-0.1.14/sverpykit/core/Runtime.py

@@ -0,0 +1,62 @@
+from sverpykit.Ui.Window import Window
+from sverpykit.core import Config
+import pygame
+
+ui_layers = []
+
+def add_layer(
+        layer_type: str,
+        rectangle: pygame.Rect,
+        components: list,
+        color: tuple[int, int, int] = (150, 150, 150),
+
+        **kwargs
+) -> None:
+    """
+    :param layer_type: Currently possible: Window.
+    :param rectangle: x, y, width, height of the layer.
+    :param components: A list of UI parts that belong to the layer.
+    :param color: The base color of the layer.
+    :param kwargs: Any extra arguments that may not be accessible for all layer types
+    :return: Returns nothing.
+    """
+    if layer_type.lower() == "window":
+        ui_layers.append(Window(ui_layers, rectangle, components, color, **kwargs))
+
+tick_counter = 0
+def register_tick() -> None:
+    global tick_counter
+    tick_counter -= Config.delta_time
+    while tick_counter < 0:
+        Config.events = pygame.event.get()
+        tick_counter += 1 / Config.tick_rate
+
+        for event in Config.events:
+            if event.type == pygame.QUIT:
+                Config.exit_function()
+
+        Config.tick_function()
+        for layer in reversed(ui_layers):
+            if layer.events(): break
+
+def start() -> None:
+    """
+    Makes the main game loop so you don't have to.
+    Features:
+     - Main loop
+     - Events
+     - FPS control
+     - Updating the screen
+     - Resetting the screen
+
+    You can change almost all of these!
+    """
+    while True:
+        Config.delta_time = Config.clock.tick(Config.max_fps)/1000
+        register_tick()
+
+        Config.screen.fill(Config.background_color)
+        Config.frame_function()
+        [layer.draw() for layer in ui_layers]
+
+        pygame.display.flip()

sverpykit-0.1.14/sverpykit/core/initialize.py

@@ -0,0 +1,82 @@
+from sverpykit.core import Config, Runtime
+from typing import Callable, Optional
+import pygame
+
+# Automatic initialization
+pygame.key.set_repeat(500, 50)
+
+# Manual initialization
+def set_display(
+        width: int,
+        height: int,
+        flags: int = 0,
+        depth: int = 0,
+        display: int = 0,
+        vsync: int = 0
+) -> pygame.Surface:
+    """
+    :param width: Width of the screen
+    :param height: Height of the screen
+    :param flags: Special properties for the display, pygame.RESIZABLE makes the user able to resize the screen.
+    :param depth: How many colors you can use (Most of the time 8-bit is good enough. In which case just leave it blank).
+    :param display: Decides which monitor is used for the window.
+    :param vsync: Caps framerate to the monitor to avoid screen tearing (Screen tearing is just a visual glitch.)
+    :return:
+    """
+    Config.screen = pygame.display.set_mode((width, height), flags, depth, display, vsync)
+    return Config.screen
+
+def max_rate(
+        fps: int | None = None,
+        tick: int | None = None
+) -> None:
+    """
+    :param fps: Caps the max frame rate (Can alwasy go below this number if anything is struggling).
+    :param tick: Sets the max tick rate (If the frame rate is lower than the tick rate the ticks will build up, so this is not a cap)
+    """
+    Config.max_fps = fps if fps else Config.max_fps
+    Config.tick_rate = tick if tick else Config.tick_rate
+
+def set_font(
+        name: str = "default",
+        font: str = "arial",
+        size: int = 25,
+        bold: bool = False,
+        italic: bool = False,
+        constructor: Optional[Callable[[Optional[str], int, bool, bool], pygame.font.Font]] = None
+) -> pygame.font.Font:
+    """
+    :param name: How to get the font in other parts of sverpykit.
+    :param font: The font of the text.
+    :param size: How big the font is.
+    :param bold: If the font is bold or not.
+    :param italic: If the font is italic or not.
+    :param constructor: If you like a custom class to be attached to the font.
+    :return: Returns the font. Most of the time not needed though.
+    """
+    Config.fonts[name] = pygame.font.SysFont(font, size, bold, italic, constructor)
+    return Config.fonts[name]
+
+def set_quit_method(method: Callable) -> None:
+    """
+    :param method: This method/function gets ran when the player presses Alt + F4 or the X in the top right.
+    """
+    Config.exit_function = method
+
+def set_frame_method(method: Callable) -> None:
+    """
+    :param method: This method/function gets ran every frame.
+    """
+    Config.frame_function = method
+
+def set_tick_method(method: Callable) -> None:
+    """
+    :param method: This method/function gets ran every tick.
+    """
+    Config.tick_function = method
+
+def get_delta() -> int | float:
+    """
+    :return: Returns the time it took for the last frame in ms.
+    """
+    return Config.delta_time

sverpykit-0.1.14/sverpykit.egg-info/PKG-INFO

@@ -0,0 +1,4 @@
+Metadata-Version: 2.4
+Name: sverpykit
+Version: 0.1.14
+Requires-Dist: pygame

sverpykit-0.1.14/sverpykit.egg-info/SOURCES.txt

@@ -0,0 +1,18 @@
+README.md
+pyproject.toml
+sverpykit/__init__.py
+sverpykit.egg-info/PKG-INFO
+sverpykit.egg-info/SOURCES.txt
+sverpykit.egg-info/dependency_links.txt
+sverpykit.egg-info/requires.txt
+sverpykit.egg-info/top_level.txt
+sverpykit/Collide/Collide.py
+sverpykit/Draw/Draw.py
+sverpykit/Ui/Button.py
+sverpykit/Ui/DropDown.py
+sverpykit/Ui/SearchBar.py
+sverpykit/Ui/TextBlock.py
+sverpykit/Ui/Window.py
+sverpykit/core/Config.py
+sverpykit/core/Runtime.py
+sverpykit/core/initialize.py

sverpykit-0.1.14/sverpykit.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

sverpykit-0.1.14/sverpykit.egg-info/requires.txt

@@ -0,0 +1 @@
+pygame

sverpykit-0.1.14/sverpykit.egg-info/top_level.txt

@@ -0,0 +1 @@
+sverpykit