sverpykit 0.2.14__tar.gz → 0.2.16__tar.gz

{sverpykit-0.2.14 → sverpykit-0.2.16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sverpykit
-Version: 0.2.14
+Version: 0.2.16
 Summary: A wrapper for pygame.
 Description-Content-Type: text/markdown
 License-File: LICENSE
@@ -10,6 +10,8 @@ Dynamic: license-file
 # Sverrys PygameTools
 Sverrys PygameTools is a wrapper for the library "pygame" that adds a UI and game logic.
 
+<img src="sverpykit_icon.svg" height=200 width=200>
+
 How to use:<br>
 To use Sverrys PygameTools you must install it from github by executing this command
 in your terminal:<br>

{sverpykit-0.2.14 → sverpykit-0.2.16}/README.md

@@ -1,6 +1,8 @@
 # Sverrys PygameTools
 Sverrys PygameTools is a wrapper for the library "pygame" that adds a UI and game logic.
 
+<img src="sverpykit_icon.svg" height=200 width=200>
+
 How to use:<br>
 To use Sverrys PygameTools you must install it from github by executing this command
 in your terminal:<br>

{sverpykit-0.2.14 → sverpykit-0.2.16}/pyproject.toml

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

sverpykit-0.2.16/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.14 → sverpykit-0.2.16}/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.14/sverpykit/Objects/Entity.py → sverpykit-0.2.16/sverpykit/Objects/Object.py

@@ -2,16 +2,17 @@ from sverpykit.core import Config, Runtime
 from typing import Callable, Any
 import pygame
 
-class Entity:
+class Object:
     def __init__(
             self,
             hitbox: pygame.Rect,
             surface: pygame.Surface,
-            player_events: dict[str, Callable] | None = None,
+            events: dict[str, Callable] | None = None,
             statistics: dict[str, Any] | None = None,
-            states: dict[str, Any] | None = None
+            states: dict[str, Any] | None = None,
+            resize_surface: bool = True
     ):
-        player_events = player_events if isinstance(player_events, dict)\
+        events = events if isinstance(events, dict)\
             else {}
         statistics = statistics if isinstance(statistics, dict)\
             else {}
@@ -19,10 +20,17 @@ class Entity:
             else {}
         self.hitbox = hitbox
         self.surface = surface
-
-        self.states = {
-            "vy": 0,
-            "vx": 0,
+        if resize_surface:
+            self.surface = pygame.transform.scale(surface, (hitbox.w, hitbox.h))
+
+        self.states: dict[str, str | int | float | bool | dict[str, str | int | float | bool]] = {
+            "surface": "solid", # Will be used later with slippery and bouncy.
+            "physics": {
+                "enabled": False,
+                "terminal_velocity": 1 # This is a multiplier, but 0 = off (Keep speeding up forever).
+            },
+            "vy": 0.0,
+            "vx": 0.0,
             "show_hitbox": False
         }
         self.states.update(states)
@@ -34,10 +42,14 @@ class Entity:
         self.stats.update(statistics)
 
         self.accepted_events = {
-            "key": Entity.key_events,
-            "mouse": Entity.mouse_events
+            "key": Object.key_events,
+            "mouse": Object.mouse_events,
+            "random": Object.random_event
         }
-        self.accepted_events.update(player_events)
+        self.accepted_events.update(events)
+
+        self.standing_on: Object | None = None
+        self.on_ground = False
 
     def key_events(self, keys: dict):
         pass
@@ -45,6 +57,9 @@ class Entity:
     def mouse_events(self, button: int, pos: tuple[int, int]):
         pass
 
+    def random_event(self, number):
+        pass
+
     def draw(self):
         Config.screen.blit(
             self.surface, self.hitbox
@@ -57,11 +72,25 @@ class Entity:
                 width=1
             )
 
-    def events(self):
-        self.hitbox.y += self.states["vy"] * Config.delta_time
+    def physics(self):
+        mass = self.hitbox.w * self.hitbox.h
+        terminal_velocity = mass * Config.terminal_velocity
+        self.states["vy"] = min(terminal_velocity, max(-terminal_velocity, self.states["vy"] - Config.delta_time * Config.gravity))
+
+        friction_force_x = int(
+            Config.slippery_friction if self.standing_on.states["surface"] == "slippery" else Config.solid_friction* (mass * Config.gravity)
+        ) if self.standing_on else Config.air_friction
+        if self.states["vx"] > 0:
+            self.states["vx"] = max(0, self.states["vx"] - friction_force_x)
+        if self.states["vx"] < 0:
+            self.states["vx"] = min(0, self.states["vx"] + friction_force_x)
+
+        self.hitbox.y -= self.states["vy"] * Config.delta_time * Config.gravity
         self.check_y_collision()
-        self.hitbox.x += self.states["vx"] * Config.delta_time
+        self.hitbox.x += self.states["vx"] * Config.delta_time * Config.gravity
         self.check_x_collision()
+
+    def events(self):
         click = pygame.mouse.get_pressed()
         mp = pygame.mouse.get_pos()
         if any(click):
@@ -69,6 +98,8 @@ class Entity:
         keys = pygame.key.get_pressed()
         if any(keys):
             self.accepted_events["key"](self, keys)
+        if self.states["physics"]:
+            self.physics()
 
     def check_x_collision(self) -> None:
         """
@@ -82,12 +113,14 @@ class Entity:
                 continue
             if not obj.collides(self.hitbox):
                 continue
+            if obj is self:
+                continue
 
             if self.states["vx"] > 0:
-                self.hitbox.x = obj.rect.x - self.hitbox.w
+                self.hitbox.x = obj.hitbox.x - self.hitbox.w
                 reset_velocity = True
             elif self.states["vx"] < 0:
-                self.hitbox.x = obj.rect.x + obj.rect.w
+                self.hitbox.x = obj.hitbox.x + obj.rect.w
                 reset_velocity = True
 
         if reset_velocity:
@@ -98,20 +131,31 @@ class Entity:
         This check should be run after every time you update the y-position of the entity.
         """
 
+        self.on_ground = False
         reset_velocity = False
+        collides_on = None
 
         for obj in Runtime.game_objects:
+            print(hasattr(obj, "collides"))
             if not hasattr(obj, "collides"):
                 continue
             if not obj.collides(self.hitbox):
                 continue
+            if obj is self:
+                continue
 
             if self.states["vy"] > 0:
-                self.hitbox.y = obj.rect.y - self.hitbox.h
+                self.hitbox.y = obj.hitbox.y + obj.hitbox.h
                 reset_velocity = True
             elif self.states["vy"] < 0:
-                self.hitbox.y = obj.rect.y + obj.rect.h
+                self.hitbox.y = obj.hitbox.y - self.hitbox.h
                 reset_velocity = True
+                collides_on = obj
+                self.on_ground = True
 
         if reset_velocity:
-            self.states["vy"] = 0
+            self.states["vy"] = 0
+        self.standing_on = collides_on
+
+    def collides(self, hitbox: pygame.Rect):
+        return self.hitbox.colliderect(hitbox)

sverpykit-0.2.16/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.14 → sverpykit-0.2.16}/sverpykit/Ui/SearchBar.py

@@ -12,17 +12,20 @@ class SearchBar:
             display: pygame.Surface,
             function: Callable = lambda x: None,
             color: pygame.Color | tuple[int, int, int] = (50, 50, 50),
+            preset: str = "",
             **kwargs
     ):
         self.rect: pygame.Rect = rect
         self.hitbox_offset = (0, 0)
 
+        self.preset = preset
+
         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.fonts['default'].render(self.stored, True, Config.BEIGE)
+        self.stored_surf: pygame.Surface = Config.fonts['default'].render(f"{self.preset}: {self.stored}", True, Config.BEIGE)
 
         self.selected: bool = False
 
@@ -84,13 +87,13 @@ class SearchBar:
                     self.stored += event.unicode
 
         if self.stored != self.last_stored:
-            self.stored_surf = Draw.render_text(self.stored)
+            self.stored_surf = Draw.render_text(f"{self.preset}: {self.stored}")
         self.last_stored = self.stored
 
         if not click:
             return
 
-        if Collide.rect_point(
+        if Collide.collides.rect_point(
             rect=pygame.Rect(
                 self.rect.x + self.hitbox_offset[0],
                 self.rect.y + self.hitbox_offset[1],

{sverpykit-0.2.14 → sverpykit-0.2.16}/sverpykit/Ui/TextBlock.py

@@ -1,6 +1,6 @@
 from sverpykit.core import Config
 from sverpykit.Draw import Draw
-from sverpykit.Ui import Window
+from sverpykit.Ui import Window, SearchBar
 from typing import Callable, Any
 import pygame
 
@@ -15,6 +15,7 @@ class TextBlock:
         self.rect = rect
         self.text = text
         self.text_surfs: list[dict] = [{"text": Draw.render_text(str(text), name=font), "newline": newline}]
+        self.searchbars: list[SearchBar.SearchBar] = []
         self.font = font
 
         self.owner = None
@@ -28,6 +29,7 @@ class TextBlock:
 
         offset_x = 0
         offset_y = 0
+        searchbars_index = 0
         for payload in self.text_surfs:
             Draw.draw_surface(
                 payload["text"], (
@@ -52,7 +54,17 @@ class TextBlock:
                 offset_x = 0
             else:
                 offset_x += payload["text"].get_width()
+
+            if payload.get("input", False) and payload["input"][0]:
+                sb = self.searchbars[searchbars_index]
+                if self.owner:
+                    sb.hitbox_offset = (self.owner.rect.x, self.owner.rect.y)
+                sb.rect.x = offset_x
+                sb.rect.y = offset_y
+                searchbars_index += 1
         self.last_size = offset_y
+        [sb.draw(display) for sb in self.searchbars]
+        [sb.events() for sb in self.searchbars]
 
     def events(self):
         mp = pygame.mouse.get_pos()
@@ -112,14 +124,25 @@ class TextBlock:
             font: str,
             color: tuple[int, int, int],
             hyperlink: tuple[Callable, list[Any]] | None = None,
+            input_: tuple[bool, Callable, list[Any], str] = (False, lambda : None, [], ""),
             newline: bool = False
     ):
-        self.text = self.text + "\n" + text
+        self.text = self.text + text
         self.text_surfs.append({
             "text": Draw.render_text(text, True, color, font),
             "hyperlink": hyperlink,
-            "newline": newline
+            "newline": newline,
+            "input": input_
         })
+        if input_[0]:
+            print(input_)
+            self.searchbars.append(SearchBar.SearchBar(
+                *input_[2],
+                rect=pygame.Rect(0, 0, 200, Config.fonts[self.font].get_height()),
+                display=Config.screen,
+                function=input_[1],
+                preset=input_[3]
+            ))
 
     def reset(self):
         self.text = ""

{sverpykit-0.2.14 → sverpykit-0.2.16}/sverpykit/__init__.py

@@ -6,12 +6,19 @@ from .core.Runtime import add_layer, add_game_object, start, update as run_frame
 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,\
     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.Platform import Platform
+
+# Object
+from .Objects.Object import Object
 
 # Ui parts
 from .Ui.Button import Button
@@ -20,6 +27,9 @@ from .Ui.DropDown import DropDown
 from .Ui.Window import Window
 from .Ui.TextBlock import TextBlock
 
+# Colors
+from .core.Config import BEIGE
+
 __all__ = [
     "Config",
     "Runtime",

{sverpykit-0.2.14 → sverpykit-0.2.16}/sverpykit/core/Config.py

@@ -24,6 +24,14 @@ events: list[pygame.event.Event] = []
 clock: pygame.time.Clock = pygame.time.Clock()
 delta_time: int
 
+# Physics
+gravity = 20
+terminal_velocity = 10
+
+solid_friction = 1
+slippery_friction = 0.7
+air_friction = 0.25
+
 # Functions
 exit_function: Callable = default_exit
 frame_function: Callable = frame

{sverpykit-0.2.14 → sverpykit-0.2.16}/sverpykit/core/FileManager.py

@@ -12,6 +12,5 @@ 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'):
-        print("Not supported yet!")
         return os.path.join(sys._MEIPASS, f"{relative_path}")
     return os.path.join(src_path, f"{relative_path}")

sverpykit-0.2.16/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.14 → sverpykit-0.2.16}/sverpykit/core/Runtime.py

@@ -107,9 +107,9 @@ def update():
     register_tick()
 
     Config.screen.fill(Config.background_color)
-    Config.frame_function()
     [layer.draw() for layer in ui_layers]
     [obj.draw() for obj in game_objects]
+    Config.frame_function()
 
     pygame.display.flip()
 

{sverpykit-0.2.14 → sverpykit-0.2.16}/sverpykit.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sverpykit
-Version: 0.2.14
+Version: 0.2.16
 Summary: A wrapper for pygame.
 Description-Content-Type: text/markdown
 License-File: LICENSE
@@ -10,6 +10,8 @@ Dynamic: license-file
 # Sverrys PygameTools
 Sverrys PygameTools is a wrapper for the library "pygame" that adds a UI and game logic.
 
+<img src="sverpykit_icon.svg" height=200 width=200>
+
 How to use:<br>
 To use Sverrys PygameTools you must install it from github by executing this command
 in your terminal:<br>

{sverpykit-0.2.14 → sverpykit-0.2.16}/sverpykit.egg-info/SOURCES.txt

@@ -9,8 +9,8 @@ sverpykit.egg-info/requires.txt
 sverpykit.egg-info/top_level.txt
 sverpykit/Collide/Collide.py
 sverpykit/Draw/Draw.py
-sverpykit/Objects/Entity.py
-sverpykit/Objects/Platform.py
+sverpykit/Objects/Object.py
+sverpykit/Shapes/Circle.py
 sverpykit/Ui/Button.py
 sverpykit/Ui/DropDown.py
 sverpykit/Ui/SearchBar.py
@@ -18,6 +18,7 @@ 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.14/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.14/sverpykit/Objects/Platform.py

@@ -1,28 +0,0 @@
-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)