sverpykit 0.2.13__tar.gz → 0.2.15__tar.gz

{sverpykit-0.2.13 → sverpykit-0.2.15}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sverpykit
-Version: 0.2.13
+Version: 0.2.15
 Summary: A wrapper for pygame.
 Description-Content-Type: text/markdown
 License-File: LICENSE

{sverpykit-0.2.13 → sverpykit-0.2.15}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "sverpykit"
-version = "0.2.13"
+version = "0.2.15"
 description = "A wrapper for pygame."
 readme = "README.md"
 dependencies = [

sverpykit-0.2.15/sverpykit/Collide/Collide.py

@@ -0,0 +1,57 @@
+from sverpykit.Shapes import Circle
+import pygame, math
+
+class collides:
+
+    @ staticmethod
+    def rect_rect(
+            rect1: pygame.Rect,
+            rect2: pygame.Rect
+    ) -> bool:
+        return rect1.colliderect(rect2)
+
+    @ staticmethod
+    def rect_point(
+            rect: pygame.Rect,
+            point: tuple[int, int]
+    ) -> bool:
+        return rect.collidepoint(point)
+
+    @ staticmethod
+    def circle_circle(
+            circle1: Circle.Circle,
+            circle2: Circle.Circle
+    ) -> bool:
+        """
+        :param circle1: The first circle.
+        :param circle2: The second circle.
+        :return: Returns if the circles collide.
+        """
+        return math.sqrt(
+            math.pow(circle1.center[0] - circle2.center[0], 2) + math.pow(circle1.center[1] - circle2.center[1], 2)
+        ) < circle1.diameter/2 + circle2.diameter/2
+
+    @ staticmethod
+    def circle_point(
+            circle: Circle.Circle,
+            point: tuple[int, int]
+    ) -> bool:
+        """
+        :param circle: The circle.
+        :param point: The coordinates of the point.
+        :return: Returns if the coordinates are in the circle.
+        """
+        return math.sqrt(
+            math.pow(circle.center[0] - point[0], 2) + math.pow(circle.center[1] - point[1], 2)
+        ) < circle.diameter
+
+    # @ staticmethod
+    # def circle_rect(
+    #         circle: Circle.Circle,
+    #         rect: pygame.Rect
+    # ) -> bool:
+    #     """
+    #     :param circle: The circle.
+    #     :param rect: The rect.
+    #     :return: Returns if the rectangle collides with the circle.
+    #     """

{sverpykit-0.2.13 → sverpykit-0.2.15}/sverpykit/Draw/Draw.py

@@ -49,7 +49,7 @@ def draw_circle(
         color: pygame.Color | tuple[int, int, int],
         center: tuple[int, int],
         radius: float | int,
-        width: int,
+        width: int = 0,
         draw_top_left: bool = False,
         draw_top_right: bool = False,
         draw_bottom_left: bool = False,

sverpykit-0.2.15/sverpykit/Objects/Block.py

@@ -0,0 +1,28 @@
+import pygame
+
+class Platform:
+    def __init__(
+            self,
+            rect: pygame.Rect,
+            surface: pygame.Surface,
+            display: pygame.Surface,
+            resize_surface: bool = True
+    ):
+        self.rect = rect
+        self.surface = pygame.transform.scale(
+            surface, (self.rect.w, self.rect.h)
+        ) if resize_surface else surface
+        self.display = display
+
+    def draw(self, display: pygame.Surface | None = None):
+        display = display if display else self.display
+
+        display.blit(
+            self.surface, self.rect
+        )
+
+    def events(self):
+        pass
+
+    def collides(self, rect: pygame.Rect):
+        return self.rect.colliderect(rect)

sverpykit-0.2.15/sverpykit/Objects/Entity.py

@@ -0,0 +1,117 @@
+from sverpykit.core import Config, Runtime
+from typing import Callable, Any
+import pygame
+
+class Entity:
+    def __init__(
+            self,
+            hitbox: pygame.Rect,
+            surface: pygame.Surface,
+            events: dict[str, Callable] | None = None,
+            statistics: dict[str, Any] | None = None,
+            states: dict[str, Any] | None = None
+    ):
+        events = events if isinstance(events, dict)\
+            else {}
+        statistics = statistics if isinstance(statistics, dict)\
+            else {}
+        states = states if isinstance(states, dict)\
+            else {}
+        self.hitbox = hitbox
+        self.surface = surface
+
+        self.states = {
+            "vy": 0,
+            "vx": 0,
+            "show_hitbox": False
+        }
+        self.states.update(states)
+
+        self.stats = {
+            "speed": 100,
+            "jump_power": 15
+        }
+        self.stats.update(statistics)
+
+        self.accepted_events = {
+            "key": Entity.key_events,
+            "mouse": Entity.mouse_events
+        }
+        self.accepted_events.update(events)
+
+    def key_events(self, keys: dict):
+        pass
+
+    def mouse_events(self, button: int, pos: tuple[int, int]):
+        pass
+
+    def draw(self):
+        Config.screen.blit(
+            self.surface, self.hitbox
+        )
+        if self.states["show_hitbox"]:
+            pygame.draw.rect(
+                Config.screen,
+                (255, 255, 255),
+                self.hitbox,
+                width=1
+            )
+
+    def events(self):
+        self.hitbox.y += self.states["vy"] * Config.delta_time
+        self.check_y_collision()
+        self.hitbox.x += self.states["vx"] * Config.delta_time
+        self.check_x_collision()
+        click = pygame.mouse.get_pressed()
+        mp = pygame.mouse.get_pos()
+        if any(click):
+            self.accepted_events["mouse"](self, click, mp)
+        keys = pygame.key.get_pressed()
+        if any(keys):
+            self.accepted_events["key"](self, keys)
+
+    def check_x_collision(self) -> None:
+        """
+        This check should be run after every time you update the x-position of the entity.
+        """
+
+        reset_velocity = False
+
+        for obj in Runtime.game_objects:
+            if not hasattr(obj, "collides"):
+                continue
+            if not obj.collides(self.hitbox):
+                continue
+
+            if self.states["vx"] > 0:
+                self.hitbox.x = obj.rect.x - self.hitbox.w
+                reset_velocity = True
+            elif self.states["vx"] < 0:
+                self.hitbox.x = obj.rect.x + obj.rect.w
+                reset_velocity = True
+
+        if reset_velocity:
+            self.states["vx"] = 0
+
+    def check_y_collision(self) -> None:
+        """
+        This check should be run after every time you update the y-position of the entity.
+        """
+
+        reset_velocity = False
+
+        for obj in Runtime.game_objects:
+            if not hasattr(obj, "collides"):
+                continue
+            if not obj.collides(self.hitbox):
+                continue
+
+            if self.states["vy"] > 0:
+                self.hitbox.y = obj.rect.y - self.hitbox.h
+                reset_velocity = True
+            elif self.states["vy"] < 0:
+                self.hitbox.y = obj.rect.y + obj.rect.h
+                reset_velocity = True
+
+        if reset_velocity:
+            self.states["vy"] = 0

sverpykit-0.2.15/sverpykit/Shapes/Circle.py

@@ -0,0 +1,22 @@
+import pygame
+
+class Circle:
+    def __init__(
+            self,
+            center: tuple[int, int],
+            diameter: int
+    ):
+        self.center = center
+        self.diameter = diameter
+
+    def draw(
+            self,
+            display: pygame.Surface,
+            color: tuple[int, int, int]
+    ) -> None:
+        pygame.draw.circle(
+            surface=display,
+            color=color,
+            center=self.center,
+            radius=self.diameter/2
+        )

{sverpykit-0.2.13 → sverpykit-0.2.15}/sverpykit/Ui/TextBlock.py

@@ -120,3 +120,7 @@ class TextBlock:
             "hyperlink": hyperlink,
             "newline": newline
         })
+
+    def reset(self):
+        self.text = ""
+        self.text_surfs = []

{sverpykit-0.2.13 → sverpykit-0.2.15}/sverpykit/__init__.py

@@ -2,14 +2,22 @@
 import pygame
 pygame.init()
 from .core import Config, Runtime
-from .core.Runtime import add_layer, add_game_object, start, update as run_frame
+from .core.Runtime import add_layer, add_game_object, start, update as run_frame, load_image
 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
+    set_src_path, max_rate
+
+# File Management
+from .core import Json
+from .core.FileManager import resource_path
+
+# Collision
+from .Collide.Collide import collides
 
 # Drawing
 from .Draw.Draw import draw_surface, draw_rect, draw_circle, render_text
 from .Objects.Entity import Entity
+from .Objects.Block import Platform
 
 # Ui parts
 from .Ui.Button import Button

{sverpykit-0.2.13 → sverpykit-0.2.15}/sverpykit/core/Config.py

@@ -1,3 +1,4 @@
+from sverpykit.core import FileManager
 import pygame, sys
 from typing import Callable
 
@@ -32,6 +33,7 @@ tick_function: Callable = tick
 fonts: dict[str, pygame.font.Font] = {
     "default": pygame.font.SysFont("arial",32)
 }
+images: dict[str, pygame.Surface] = {}
 
 # Colors
 background_color: pygame.Color | tuple[int, int, int] = (25, 25, 25)

sverpykit-0.2.15/sverpykit/core/FileManager.py

@@ -0,0 +1,16 @@
+import sys, os, pygame
+from pathlib import Path
+
+base_path = Path(__file__).resolve().parent
+def spk_resource_path(relative_path: str) -> str:
+    if hasattr(sys, '_MEIPASS'):
+        return os.path.join(sys._MEIPASS, f"../{relative_path}")
+    return os.path.join(base_path, f"../{relative_path}")
+
+src_path = ""
+def resource_path(relative_path: str) -> str:
+    if not os.path.exists(src_path):
+        raise TypeError(f"Please set the src path before you run this function!")
+    if hasattr(sys, '_MEIPASS'):
+        return os.path.join(sys._MEIPASS, f"{relative_path}")
+    return os.path.join(src_path, f"{relative_path}")

sverpykit-0.2.15/sverpykit/core/Json.py

@@ -0,0 +1,19 @@
+import json
+
+def read_json(path: str, obj: int | str | None = None) -> dict | list | int | str:
+    with open(path, "r") as f:
+        data = json.load(f)
+    return data.get(obj, data)
+
+def write_json(path: str, obj: dict | list) -> None:
+    with open(path, "w") as f:
+        json.dump(obj, f, indent=4)
+
+def update_json(path: str, obj: dict | list) -> None:
+    with open(path, "r") as f:
+        data: list | dict = json.load(f)
+    if not isinstance(obj, type(data)):
+        raise ValueError("Object does not have the same type as JSON file!")
+    with open(path, "w") as f:
+        data.update(obj) if isinstance(data, dict) else data.extend(obj)
+        json.dump(data, f, indent=4)

sverpykit-0.2.15/sverpykit/core/Objects.py

@@ -0,0 +1,17 @@
+import pygame
+
+def create_rect(
+        x: int | float,
+        y: int | float,
+        width: int | float,
+        height: int | float
+) -> pygame.Rect:
+    """
+    This is the same
+    :param x: The x position of the rectangle.
+    :param y: The y position of the rectangle.
+    :param width: The width of the rectangle.
+    :param height: The height of the rectangle.
+    :return: Returns a pygame rectangle.
+    """
+    return pygame.Rect(x, y, width, height)

{sverpykit-0.2.13 → sverpykit-0.2.15}/sverpykit/core/Runtime.py

@@ -1,21 +1,73 @@
 from sverpykit.Ui.Window import Window
 from sverpykit.Ui.TextBlock import TextBlock
 from sverpykit.core import Config
-import pygame
+import pygame, sys, os
+from pathlib import Path
 
 ui_layers = []
 game_objects = []
 
+def load_image(
+        path: str,
+        name: str
+) -> pygame.Surface:
+    """
+    :param path: The path to your file (Be sure this is a full path!).
+    :param name: The name that the image gets stored to.
+    :return: Returns the image, but also saves it in sverpykit's cache.
+    """
+    img = pygame.image.load(path)
+    Config.images[name] = img
+    return img
+
+def resize_image(
+        name: str,
+        width: int | float,
+        height: int | float,
+        save: bool = True
+) -> pygame.Surface:
+    """
+    :param name: This is the same name as where you loaded the image.
+    :param width: The width of the resized surface.
+    :param height: The height of the resized surface.
+    :param save: Decides if the image will be cached with or without changes.
+    :return: Returns the resized image.
+    """
+    img = pygame.transform.scale(Config.images[name], (width, height))
+    if save:
+        Config.images[name] = img
+    return img
+
+def rotate_image(
+        name: str,
+        rotation: float | int,
+        save: bool = False
+) -> pygame.Surface:
+    """
+    :param name: This is the same name as where you loaded the image.
+    :param rotation: The rotation of the new image in degrees.
+    :param save: Decides if the image will be cached with or without changes.
+    :return: Returns the rotated image.
+    """
+    img = pygame.transform.rotate(
+        Config.images[name],
+        rotation
+    )
+    if save:
+        Config.images[name] = img
+    return img
+
 def add_layer(
         layer_type: str,
         rectangle: pygame.Rect,
         components: list,
-        color: tuple[int, int, int] = (150, 150, 150)
+        color: tuple[int, int, int] = (150, 150, 150),
+        **kwargs
 ) -> Window:
     """
     :return: Returns nothing.
     """
-    w = Window(ui_layers, rectangle, components, color)
+    w = Window(ui_layers, rectangle, components, color, **kwargs)
     for component in w.components:
         if isinstance(component, TextBlock):
             component.owner = w

{sverpykit-0.2.13 → sverpykit-0.2.15}/sverpykit/core/initialize.py

@@ -1,6 +1,7 @@
-from sverpykit.core import Config, Runtime
+from sverpykit.core import Config, Runtime, FileManager
 from typing import Callable, Optional
-import pygame
+import pygame, os
+from pathlib import Path
 
 # Automatic initialization
 pygame.key.set_repeat(500, 50)
@@ -12,7 +13,8 @@ def set_display(
         flags: int = 0,
         depth: int = 0,
         display: int = 0,
-        vsync: int = 0
+        vsync: int = 0,
+        title: str = "Pygame Window"
 ) -> pygame.Surface:
     """
     :param width: Width of the screen
@@ -21,11 +23,22 @@ def set_display(
     :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.)
+    :param title: What gets displayed in the title bar.
     :return:
     """
     Config.screen = pygame.display.set_mode((width, height), flags, depth, display, vsync)
+    pygame.display.set_caption(title)
     return Config.screen
 
+def set_src_path(src_path: Path) -> None:
+    """
+    :param src_path: Use `pathlib.Path(__file__).resolve().parent`.
+    :return: Returns nothing.
+    """
+    if not os.path.exists(src_path):
+        print("WARNING: Src-Path does not exist!")
+    FileManager.src_path = src_path
+
 def max_rate(
         fps: int | None = None,
         tick: int | None = None

{sverpykit-0.2.13 → sverpykit-0.2.15}/sverpykit.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sverpykit
-Version: 0.2.13
+Version: 0.2.15
 Summary: A wrapper for pygame.
 Description-Content-Type: text/markdown
 License-File: LICENSE

{sverpykit-0.2.13 → sverpykit-0.2.15}/sverpykit.egg-info/SOURCES.txt

@@ -9,12 +9,17 @@ sverpykit.egg-info/requires.txt
 sverpykit.egg-info/top_level.txt
 sverpykit/Collide/Collide.py
 sverpykit/Draw/Draw.py
+sverpykit/Objects/Block.py
 sverpykit/Objects/Entity.py
+sverpykit/Shapes/Circle.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/FileManager.py
+sverpykit/core/Json.py
+sverpykit/core/Objects.py
 sverpykit/core/Runtime.py
 sverpykit/core/initialize.py

sverpykit-0.2.13/sverpykit/Collide/Collide.py

@@ -1,13 +0,0 @@
-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.2.13/sverpykit/Objects/Entity.py

@@ -1,68 +0,0 @@
-from sverpykit.core import Config
-from typing import Callable, Any
-import pygame
-
-class Entity:
-    def __init__(
-            self,
-            hitbox: pygame.Rect,
-            surface: pygame.Surface,
-            player_events: dict[str, Callable] | None = None,
-            statistics: dict[str, Any] | None = None,
-            states: dict[str, Any] | None = None
-    ):
-        player_events = player_events if isinstance(player_events, dict)\
-            else {}
-        statistics = statistics if isinstance(statistics, dict)\
-            else {}
-        states = states if isinstance(states, dict)\
-            else {}
-        self.hitbox = hitbox
-        self.surface = surface
-
-        self.states = {
-            "vy": 0,
-            "vx": 0,
-            "show_hitbox": False
-        }
-        self.states.update(states)
-
-        self.stats = {
-            "speed": 100,
-            "jump_power": 15
-        }
-        self.stats.update(statistics)
-
-        self.accepted_events = {
-            "key": self.key_events,
-            "mouse": self.mouse_events
-        }
-        self.accepted_events.update(player_events)
-
-    def key_events(self, keys: dict):
-        pass
-
-    def mouse_events(self, button, pos):
-        pass
-
-    def draw(self):
-        Config.screen.blit(
-            self.surface, self.hitbox
-        )
-        if self.states["show_hitbox"]:
-            pygame.draw.rect(
-                Config.screen,
-                (255, 255, 255),
-                self.hitbox,
-                width=1
-            )
-
-    def events(self):
-        self.hitbox.y -= self.states["vy"] * Config.delta_time
-        click = pygame.mouse.get_pressed()
-        mp = pygame.mouse.get_pos()
-        if any(click):
-            self.accepted_events["mouse"](click, mp)
-        keys = pygame.key.get_pressed()
-        if any(keys):
-            self.accepted_events["key"](keys)