PyScene 1.0.0__tar.gz

pyscene-1.0.0/.gitignore

@@ -0,0 +1,12 @@
+__pycache__/
+*.pyc
+
+.venv/
+.env
+
+build/
+dist/
+*.egg-info/
+
+.vscode/
+.idea/

pyscene-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) [year] [fullname]
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pyscene-1.0.0/PKG-INFO

@@ -0,0 +1,18 @@
+Metadata-Version: 2.5
+Name: PyScene
+Version: 1.0.0
+Summary: A small example package
+Project-URL: Homepage, https://github.com/sfertig/PyScene
+Project-URL: Issues, https://github.com/sfertig/PyScene/issues
+Author-email: Sam Fertig <sfertig007@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# PyScene
+
+PyScene is a custom python + pygame framework / engine developed to streamline 2d game development.
+

pyscene-1.0.0/README.md

@@ -0,0 +1,4 @@
+# PyScene
+
+PyScene is a custom python + pygame framework / engine developed to streamline 2d game development.
+

pyscene-1.0.0/pyproject.toml

@@ -0,0 +1,22 @@
+[build-system]
+requires = ["hatchling >= 1.26"]
+build-backend = "hatchling.build"
+[project]
+name = "PyScene"
+version = "1.0.0"
+authors = [
+  { name="Sam Fertig", email="sfertig007@gmail.com" },
+]
+description = "A small example package"
+readme = "README.md"
+requires-python = ">=3.9"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+]
+license = "MIT"
+license-files = ["LICEN[CS]E*"]
+
+[project.urls]
+Homepage = "https://github.com/sfertig/PyScene"
+Issues = "https://github.com/sfertig/PyScene/issues"

pyscene-1.0.0/src/PyScene/Collisions.py

@@ -0,0 +1,62 @@
+import pygame
+
+#collisions generators
+
+def _coll_gen_combination(Game): #this functions as the main function for collision rect generation
+    if not Game._update_coll: return
+    # -- else start collisions generation -- #
+    Game.collisions.clear() #clear existing rects
+
+    #get rects
+    rects: list[pygame.Rect] = []
+    for col in Game.col: rects.append(col.rect.copy())
+
+    if Game.optimize_static_colliders: rects = _optimize_static_colliders(Game, rects)
+
+    #set collisions
+    Game.collisions = rects
+
+    #add dynamic rects
+    for col in Game.dynamic_col: 
+        if col.active: rects.append(col.rect)
+
+    Game._update_coll = False
+
+def _optimize_static_colliders(Game, colliders: list[pygame.Rect]):
+    if not colliders:
+        return []
+
+    rects = sorted([r.copy() for r in colliders], key=lambda r: (r.y, r.x))
+    merged = []
+
+    # 2. Horizontal Merge Pass
+    while rects:
+        current = rects.pop(0)
+        i = 0
+        while i < len(rects):
+            other = rects[i]
+            if current.top == other.top and current.height == other.height and current.right == other.x:
+                current.width += other.width
+                rects.pop(i)
+            else:
+                i += 1
+        merged.append(current)
+
+    # 3. Vertical Merge Pass
+    final_rects = []
+    merged = sorted(merged, key=lambda r: (r.x, r.y))
+    while merged:
+        current = merged.pop(0)
+        i = 0
+        while i < len(merged):
+            other = merged[i]
+            if current.left == other.left and current.width == other.width and current.bottom == other.y:
+                current.height += other.height
+                merged.pop(i)
+            else:
+                i += 1
+        final_rects.append(current)
+
+    return final_rects
+
+

pyscene-1.0.0/src/PyScene/Game.py

@@ -0,0 +1,297 @@
+import pygame
+import sys
+
+from .Keys import Keys
+from .Math import Vector2D
+from .Collisions import _coll_gen_combination
+
+class _game:
+    def __init__(self):
+        self.__on = False
+        pygame.init()
+        pygame.font.init()
+
+    def init(self, width, height, title, bg="black", fps=60, fullscreen=False):
+        self.__on = True
+        self.width = width
+        self.height = height
+        self.title = title
+        self.bg = bg
+        self.fps = fps
+        self.clock = pygame.time.Clock()
+        self.dt = 0.0
+        self.mouse_down = False
+        self.click = False
+        self.events = []
+        self.cam = Camera(self)
+
+        self.show_collisions: bool = False
+        self.optimize_static_colliders: bool = False
+
+        #screen
+        if not fullscreen: self.screen = pygame.display.set_mode((self.width, self.height))
+        else: self.screen = pygame.display.set_mode((width, height), pygame.SCALED | pygame.FULLSCREEN)
+        pygame.display.set_caption(self.title)
+
+        Keys._add_net(self) #to accsess events
+
+        #game obj info
+        self.objects = []
+        self.queue_creation = []
+        self.queue_del = []
+
+        self.collisions: list[pygame.Rect] = [] #accual list of rects
+        self.col = []
+        self.queue_creation_coll = []
+        self.queue_del_coll = []
+        self._update_coll = False
+
+        self.dynamic_col = []
+        self.queue_creation_D_coll = []
+        self.queue_del_D_coll = []
+
+        self.render_queue = []
+
+        self.active_scene = None
+        self.scenes = {}
+        self.id = 0
+
+
+    def _queue_add(self, obj): 
+        if self.active_scene is None: self.queue_creation.append(obj)
+        else: self.active_scene._queue_add(obj)
+    def _queue_remove(self, obj): 
+        if obj in self.objects: self.objects.remove(obj)
+        else: self.active_scene._queue_remove(obj)
+    def _get_id(self):
+        self.id += 1
+        return self.id
+
+    def _queue_add_coll(self, obj): self.queue_creation_coll.append(obj)
+    def _queue_remove_coll(self, obj): self.queue_del_coll.append(obj)
+    def _queue_add_D_coll(self, obj): self.queue_creation_D_coll.append(obj)
+    def _queue_remove_D_coll(self, obj): self.queue_del_D_coll.append(obj)
+
+    def __update_render_queue(self): #update order of the renders based on z-index
+        self.render_queue = sorted(self.objects, key=lambda obj: obj.z_index)
+
+    def __handle_queue(self):
+        for obj in self.queue_creation: self.objects.append(obj)
+        for obj in self.queue_del: self.objects.remove(obj)
+        if len(self.queue_creation) > 0 or len(self.queue_del) > 0: self.__update_render_queue()
+        self.queue_creation.clear()
+        self.queue_del.clear()
+        #collisions
+        for obj in self.queue_creation_coll: self.col.append(obj)
+        for obj in self.queue_del_coll: self.col.remove(obj)
+        self.queue_creation_coll.clear()
+        self.queue_del_coll.clear()
+        for obj in self.queue_creation_D_coll: self.dynamic_col.append(obj)
+        for obj in self.queue_del_D_coll: self.dynamic_col.remove(obj)
+        self.queue_creation_D_coll.clear()
+        self.queue_del_D_coll.clear()
+        _coll_gen_combination(self)
+        self._update_coll = False
+
+    def __update(self):
+        self.click = False
+        self.dt = self.clock.tick(self.fps)/1000.0
+        self.events = pygame.event.get()
+
+        for obj in self.dynamic_col: obj.update()
+        
+        for event in self.events:
+            if event.type == pygame.QUIT:
+                self.quit()
+            if event.type == pygame.MOUSEBUTTONDOWN: 
+                if event.button == 1: 
+                    self.mouse_down = True
+            if event.type == pygame.MOUSEBUTTONUP and self.mouse_down: 
+                if event.button == 1: 
+                    self.mouse_down = False
+                    self.click = True
+
+    def update(self, _clear=True):
+        if not self.__on: return
+        self.__update()
+        self.__handle_queue()
+
+        #update objs
+        for obj in self.objects: obj.update()
+        #update scene
+        if self.active_scene is not None: 
+            self.active_scene.update()
+            self.active_scene._update()
+
+        if _clear: self.clear_screen() #used if user is drawing objects themselves
+        
+
+    def clear_screen(self): self.screen.fill(self.bg)
+
+    def render(self, _clear=True):
+        if not self.__on: return
+
+        if _clear: self.screen.fill(self.bg)
+        #render call
+        if self.active_scene is None: 
+            for obj in self.render_queue: obj.render(self.cam)
+        #render scene
+        else: 
+            self.active_scene.render(self.cam)
+            self.active_scene._render(self.cam)
+        if self.show_collisions: self.__render_collisions()
+        #update screen
+        pygame.display.flip()
+
+    def __render_collisions(self):
+        for coll in self.collisions:
+            pygame.draw.rect(self.screen, "yellow", coll, 2)
+
+    def quit(self):
+        self.__on = False
+        pygame.quit()
+        sys.exit()
+
+    def set_title(self, title):
+        self.title = title
+        pygame.display.set_caption(self.title)
+
+    def Tick(self):
+        self.update()
+        self.render()
+    def Run(self, _esc=False):
+        while True:
+            self.Tick()
+            if _esc and Keys.is_pressed(pygame.K_ESCAPE): self.quit()
+    def full_reset(self):
+        self.objects = []
+        self.queue_creation = []
+        self.queue_del = []
+        self.render_queue = []
+        self.scenes = {}
+        self.id = 0
+        self.active_scene = None
+        self._clear_all_collisions_()
+    def _clear_all_collisions_(self):
+        self.collisions = []
+        self.col = []
+        self.queue_creation_coll = []
+        self.queue_del_coll = []
+        self._update_coll = False
+
+    def set_scene(self, scene=None):
+        if self.active_scene is not None: self.active_scene.destroy()
+        self._clear_all_collisions_()
+        self.active_scene = self.scenes.get(scene, None)
+        if self.active_scene: self.active_scene.on_change()
+
+
+class Scene:
+    def __init__(self, name):
+        self.name = name
+        Game.scenes[name] = self
+        self._objects = []
+        self._render_queue = []
+        self.queue_creation = []
+        self.queue_del = []
+        Game.set_scene(name)
+
+    def on_change(self): pass
+
+    def update(self): pass #user defined
+    def _update(self): #built in method
+        self.__handle_queue()
+        for obj in self._objects: obj.update()
+
+    def render(self, cam): pass #user defined
+    def _render(self, cam): #built in method
+        #update render queue based on global objects
+        _length = len(self._objects)+len(Game.objects)
+        if _length != len(self._render_queue): self.__update_render_queue()
+        #render
+        for obj in self._render_queue: obj.render(cam)
+
+    def _queue_add(self, obj): self.queue_creation.append(obj)
+    def _queue_remove(self, obj): self.queue_del.append(obj)
+    def __update_render_queue(self):
+        objs = self._objects + Game.objects
+        self._render_queue = sorted(objs, key=lambda obj: obj.z_index)
+    def __handle_queue(self):
+        for obj in self.queue_creation: self._objects.append(obj)
+        for obj in self.queue_del: self._objects.remove(obj)
+        if len(self.queue_creation) > 0 or len(self.queue_del) > 0: self.__update_render_queue()
+        self.queue_creation = []
+        self.queue_del = []
+
+    def destroy(self):
+        for obj in self._objects: obj.destroy()
+        self._objects = []
+        self._render_queue = []
+        self.queue_creation = []
+        self.queue_del = []
+
+Game: _game = _game()
+
+class Camera:
+    def __init__(self, game):
+        self.pos = Vector2D(0, 0)
+        self.game = game
+
+    #rendering helpers
+    def draw_rect(self, rect, color, width=0, offset=True):
+        r = rect.copy()
+        if offset: r.topleft = (r.x - self.pos.x, r.y - self.pos.y)
+        pygame.draw.rect(self.game.screen, color, r, width)
+    def draw_circle(self, pos, r, color, width=0, offset=True):
+        p = pos.copy()
+        if offset: p -= self.pos
+        pygame.draw.circle(self.game.screen, color, p.to_int(), r, width)
+    def draw_line(self, start, end, color, width=1, offset=True):
+        s = start.copy()
+        e = end.copy()
+        if offset:
+            s -= self.pos
+            e -= self.pos
+        pygame.draw.line(self.game.screen, color, s.to_int(), e.to_int(), width)
+    def draw_text(self, surface, rect, offset=True):
+        r = rect.copy()
+        if offset: r.topleft = (r.x - self.pos.x, r.y - self.pos.y)
+        self.game.screen.blit(surface, r)
+    def draw_image(self, image, pos, offset=True):
+        p = pos.copy()
+        if offset: p -= self.pos
+        self.game.screen.blit(image, p.to_int())
+
+def handle_collision(self, dim: Vector2D, Rect=None, ignore_self=True) -> dict:
+    returns = {"on_floor": False, "on_wall": False}
+
+    # 1. Horizontal Collisions
+    self.pos.x += self.vel.x * Game.dt
+    player_rect = pygame.Rect(self.pos.to_int(), dim.to_int())
+    for rect in Game.collisions:
+        if ignore_self and Rect is not None: 
+            if rect == Rect: continue
+        if player_rect.colliderect(rect):
+            returns["on_wall"] = True
+            self.pos.x -= self.vel.x * Game.dt
+            self.vel.x = 0
+            break 
+
+    # 2. Vertical Collisions
+    self.pos.y += self.vel.y * Game.dt
+    player_rect = pygame.Rect(self.pos.to_int(), dim.to_int())
+    for rect in Game.collisions:
+        if ignore_self and Rect is not None: 
+            if rect == Rect: continue
+        if player_rect.colliderect(rect):
+            # Step back first
+            self.pos.y -= self.vel.y * Game.dt
+
+            if self.vel.y > 0 and player_rect.bottom >= rect.top and player_rect.top < rect.top:
+                returns["on_floor"] = True
+                
+            self.vel.y = 0
+            break
+
+    return returns
+

pyscene-1.0.0/src/PyScene/Keys.py

@@ -0,0 +1,100 @@
+import pygame
+from .Math import Vector2D
+
+class _keys:
+    def __init__(self):
+
+        #alphabet
+        self.a = pygame.K_a
+        self.b = pygame.K_b
+        self.c = pygame.K_c
+        self.d = pygame.K_d
+        self.e = pygame.K_e
+        self.f = pygame.K_f
+        self.g = pygame.K_g
+        self.h = pygame.K_h
+        self.i = pygame.K_i
+        self.j = pygame.K_j
+        self.k = pygame.K_k
+        self.l = pygame.K_l
+        self.m = pygame.K_m
+        self.n = pygame.K_n
+        self.o = pygame.K_o
+        self.p = pygame.K_p
+        self.q = pygame.K_q
+        self.r = pygame.K_r
+        self.s = pygame.K_s
+        self.t = pygame.K_t
+        self.u = pygame.K_u
+        self.v = pygame.K_v
+        self.w = pygame.K_w
+        self.x = pygame.K_x
+        self.y = pygame.K_y
+        self.z = pygame.K_z
+
+        #numbers
+        self.n0 = pygame.K_0
+        self.n1 = pygame.K_1
+        self.n2 = pygame.K_2
+        self.n3 = pygame.K_3
+        self.n4 = pygame.K_4
+        self.n5 = pygame.K_5
+        self.n6 = pygame.K_6
+        self.n7 = pygame.K_7
+        self.n8 = pygame.K_8
+        self.n9 = pygame.K_9
+
+        #special keys
+        self.enter = pygame.K_RETURN
+        self.escape = pygame.K_ESCAPE
+        self.space = pygame.K_SPACE
+        self.backspace = pygame.K_BACKSPACE
+        self.tab = pygame.K_TAB
+        self.control = pygame.K_LCTRL
+        self.alt = pygame.K_LALT
+
+        #arrow keys
+        self.up = pygame.K_UP
+        self.down = pygame.K_DOWN
+        self.left = pygame.K_LEFT
+        self.right = pygame.K_RIGHT
+
+        self.shift = pygame.K_LSHIFT
+
+        #mouse
+        self.mouse_x, self.mouse_y = 0, 0
+
+    def is_pressed(self, key):
+        events = self.Net.events
+        if events is None: return False
+        for event in events:
+            if event.type == pygame.KEYDOWN:
+                if event.key == key: return True
+        return False
+
+    def is_pressed_list(self, keys):
+        for key in keys:
+            if self.is_pressed(key): return True
+        return False
+
+    def is_held(self, key):
+        keys = pygame.key.get_pressed()
+        return keys[key]
+
+    def get_axis(self, negative_action, positive_action) -> int: 
+        value = 0
+        if self.is_held(positive_action): value += 1
+        if self.is_held(negative_action): value -= 1
+        return value
+    def get_vector(self, neg_x, pos_x, neg_y, pos_y, normalise=True) -> Vector2D:
+        value =  Vector2D(self.get_axis(neg_x, pos_x), self.get_axis(neg_y, pos_y))
+        if normalise and value.length() > 1.0: 
+            value.normalize()
+        return value
+
+    def _add_net(self, net): self.Net = net
+
+    def update(self): self.mouse_x, self.mouse_y = pygame.mouse.get_pos()
+
+
+Keys = _keys()

pyscene-1.0.0/src/PyScene/Math.py

@@ -0,0 +1,52 @@
+import pygame
+
+class Vector2D:
+    def __init__(self, x, y):
+        self.x = x
+        self.y = y
+    def to_int(self): return (int(self.x), int(self.y))
+    def to_tuple(self): return (tuple(self.x), tuple(self.y))
+    def copy(self): return Vector2D(self.x, self.y)
+    def int(self):
+        self.x = int(self.x)
+        self.y = int(self.y)
+
+    def length(self):
+        return (self.x**2 + self.y**2)**0.5
+
+    def normalize(self):
+        length = self.length()
+        self.x /= length
+        self.y /= length
+        return self
+
+    def __add__(self, other):
+        if type(other) == Vector2D:
+            return Vector2D(self.x + other.x, self.y + other.y)
+        else:
+            return Vector2D(self.x + other, self.y + other)
+
+    def __sub__(self, other):
+        if type(other) == Vector2D:
+            return Vector2D(self.x - other.x, self.y - other.y)
+        else:
+            return Vector2D(self.x - other, self.y - other)
+
+    def __mul__(self, other):
+        if type(other) == Vector2D:
+            return Vector2D(self.x * other.x, self.y * other.y)
+        else:
+            return Vector2D(self.x * other, self.y * other)
+
+    def __truediv__(self, other):
+        if type(other) == Vector2D:
+            return Vector2D(self.x / other.x, self.y / other.y)
+        else:
+            return Vector2D(self.x / other, self.y / other)
+
+def clamp(value, min, max):
+    if value < min: return min
+    if value > max: return max
+    return value
+
+

pyscene-1.0.0/src/PyScene/Net.py

@@ -0,0 +1,31 @@
+import pygame
+
+class _net_:
+    def __init__(self):
+        self.screen: pygame.Surface = None
+        self.dt: float = 0.0
+        self.clock: pygame.time.Clock = None
+        self.width, self.height = 0, 0
+        self.fps = 0
+
+        self.events = []
+        self.click = False
+
+    def _update(self):
+        self.click = False
+        self.dt = self.clock.tick(self.FPS)/1000.0
+        self.events = pygame.event.get()
+        
+        for event in self.events:
+            if event.type == pygame.QUIT:
+                self.shut_down()
+            if event.type == pygame.MOUSEBUTTONDOWN: 
+                if event.button == 1: 
+                    self.mouse_down = True
+            if event.type == pygame.MOUSEBUTTONUP and self.mouse_down: 
+                if event.button == 1: 
+                    self.mouse_down = False
+                    self.click = True
+
+
+Net = _net_()

pyscene-1.0.0/src/PyScene/__init__.py

@@ -0,0 +1,34 @@
+#imports
+"PyScene is a custom python + pygame framework / engine developed to streamline 2d game development."
+"Version: 1.0.0"
+
+from .Game import Game, Scene, handle_collision
+from .Math import *
+from .utils.Subscreen import *
+
+from .Keys import *
+from .objs import *
+from .utils import *
+
+
+#all
+__all__ = [
+    "Vector2D",
+    "SubScreen",
+    "Game",
+    "Scene",
+    "Keys",
+
+    "GameObj",
+    "Rect",
+    "Circle",
+    "Line",
+    "Text",
+    "Image",
+
+    "StaticCollisionRect",
+    "DynamicCollisionRect",
+
+    "Assets",
+    "handle_collision"
+]

pyscene-1.0.0/src/PyScene/objs/Collision_shapes.py

@@ -0,0 +1,41 @@
+import pygame
+from ..Game import Game, handle_collision
+from ..Math import Vector2D
+from .GameObj import GameObj
+
+class StaticCollisionRect:
+    def __init__(self, x, y, w, h, active=True):
+        self.rect = pygame.Rect(x, y, w, h)
+        self.active = active
+
+        Game._update_coll = True
+        Game._queue_add_coll(self)
+
+    def set_active(self, active=True):
+        self.active = active
+        Game._update_coll = True
+    def destroy(self):
+        Game._queue_remove_coll(self)
+
+class DynamicCollisionRect:
+    def __init__(self, x, y, w, h, active=True):
+        self.pos = Vector2D(x, y)
+        self.dim = Vector2D(w, h)
+        self.active = active
+        self.vel = Vector2D(0.0, 0.0)
+        self.rect = pygame.Rect(x, y, w, h)
+
+        Game._update_coll = True
+        Game._queue_add_D_coll(self)
+
+    def update(self):
+        if self.vel.to_int != (0.0, 0.0): Game._update_coll = True
+        #print(self.active, len(Game.collisions), self.vel.x)
+        handle_collision(self, self.dim, self.rect)
+        self.rect.topleft = self.pos.to_int()
+
+    def set_active(self, active=True):
+        self.active = active
+        Game._update_coll = True
+    def destroy(self):
+        Game._queue_remove_D_coll(self)

pyscene-1.0.0/src/PyScene/objs/GameObj.py

@@ -0,0 +1,20 @@
+import pygame
+from ..Math import Vector2D
+from ..Game import Game
+
+class GameObj: #this will be the base class of every game obj
+    def __init__(self, pos, z_index=0, active=True, visible=True):
+        self.pos: Vector2D = pos
+        self.vel: Vector2D = Vector2D(0, 0)
+        self.z_index = z_index
+        self.active = active
+        self.visible = visible
+        self._id = Game._get_id()
+
+        #add to creation
+        Game._queue_add(self)
+
+    def update(self): pass
+    def render(self, cam): pass
+    def destroy(self): Game._queue_remove(self)
+

pyscene-1.0.0/src/PyScene/objs/Shapes.py

@@ -0,0 +1,45 @@
+import pygame
+from ..Math import Vector2D
+from ..Game import Game
+
+from .GameObj import GameObj
+
+class Rect(GameObj):
+    def __init__(self, x, y, w, h, color, z_index=0, width=0, active=True, visible=True, offset=True):
+        super().__init__(Vector2D(x, y), z_index, active, visible)
+        self.dim = Vector2D(w, h)
+        self.color = color
+        self.rect = pygame.Rect((x, y), (w, h))
+        self.offset = offset
+        self.width = width
+
+    def update(self):
+        if self.pos.to_int() != self.rect.topleft: self.rect.topleft = self.pos.to_int()
+
+    def render(self, cam):
+        if not self.visible: return
+        cam.draw_rect(self.rect, self.color, self.width, self.offset)
+
+class Circle(GameObj):
+    def __init__(self, x, y, r, color, z_index=0, width=0, active=True, visible=True, offset=True):
+        super().__init__(Vector2D(x, y), z_index, active, visible)
+        self.radius = r
+        self.color = color
+        self.width = width
+        self.offset = offset
+
+    def render(self, cam):
+        if not self.visible: return
+        cam.draw_circle(self.pos, self.radius, self.color, self.width, self.offset)
+
+class Line(GameObj):
+    def __init__(self, x1, y1, x2, y2, color, z_index=0, width=1, active=True, visible=True, offset=True):
+        super().__init__(Vector2D(x1, y1), z_index, active, visible)
+        self.end = Vector2D(x2, y2)
+        self.color = color
+        self.width = width
+        self.offset = offset
+
+    def render(self, cam): 
+        if not self.visible: return
+        cam.draw_line(self.pos, self.end, self.color, self.width, self.offset)

pyscene-1.0.0/src/PyScene/objs/Text.py

@@ -0,0 +1,50 @@
+from ..Math import Vector2D
+from ..Game import Game
+from .GameObj import GameObj
+import pygame
+
+class Text(GameObj):
+    def __init__(self, font, text, color, pos=Vector2D(0, 0), align="center", z_index=0, active=True, visible=True, offset=True):
+        super().__init__(pos, z_index, active, visible)
+        self.font = font
+        self.text = text
+        self.color = color
+        self.align = align
+        self.surface = None
+        self.rect = None
+        self.offset = offset
+
+        self._update_surface()
+
+    def _update_surface(self):
+        """Internal method to re-render surface only when text changes."""
+        self.surface = self.font.render(str(self.text), False, self.color)  # False for sharp pixel fonts!
+        # Dynamically set rect based on alignment (topleft, center, topright, etc.)
+        self.rect = self.surface.get_rect(**{self.align: self.pos.to_int()})
+
+    def set_text(self, new_text, color=None):
+        """Only call this when the string actually changes!"""
+        if color is not None:
+            self.color = color
+        if new_text != self.text:
+            self.text = new_text
+            self._update_surface()
+
+    def set_pos(self, new_pos):
+        self.pos = new_pos
+        self.rect = self.surface.get_rect(**{self.align: self.pos})
+
+    def render(self, cam):
+        if not self.visible: return
+        cam.draw_text(self.surface, self.rect, self.offset)
+
+class Image(GameObj):
+    def __init__(self, image, pos=Vector2D(0, 0), z_index=0, active=True, visible=True, offset=True):
+        super().__init__(pos, z_index, active, visible)
+        self.image = image
+        self.offset = offset
+
+    def render(self, cam):
+        if not self.visible: return
+        cam.draw_image(self.image, self.pos, self.offset)
+

pyscene-1.0.0/src/PyScene/objs/__init__.py

@@ -0,0 +1,7 @@
+from .GameObj import GameObj
+from .Shapes import *
+from .Text import *
+from .animation import *
+from .Collision_shapes import *
+
+__all__ = ["GameObj", "Rect", "Circle", "Line", "Text", "Image", "Animation", "AnimationManager", "StaticCollisionRect", "DynamicCollisionRect"]

pyscene-1.0.0/src/PyScene/objs/animation.py

@@ -0,0 +1,116 @@
+import pygame
+
+from ..Math import Vector2D
+from .GameObj import GameObj
+from ..Game import Game
+
+class Animation(GameObj):
+    def __init__(self, image, size, fps, loop=True, pos=Vector2D(0, 0), z_index=0, active=True, visible=True, offset=True):
+        super().__init__(pos, z_index, active, visible)
+        self.offset = offset
+        self.image = image
+        self.size = size
+        self.fps = fps
+        self.images = []
+        self.index = 0.0
+        self.loop=loop
+        self.done=False
+
+        # Automatically calculate frames based on image width
+        total_frames = int(image.get_width() // size)
+
+        img_rect = image.get_rect()
+        
+        for i in range(total_frames):
+            # Slice each frame from the sheet
+            frame_rect = pygame.Rect(i * size, 0, size, size)
+            #checks
+            #if frame_rect.height > img_rect.height: frame_rect.height = img_rect.height
+            self.images.append(self.image.subsurface(frame_rect))
+
+    def last_frame(self):
+        return int(self.index) >= (len(self.images) - 1)
+    def reset(self):
+        self.index = 0
+        self.done = False
+
+    def update(self):
+        if self.done:
+            return
+
+        self.index += self.fps * Game.dt
+        
+        if self.index >= len(self.images):
+            if self.loop:
+                # Wrap around using modulo so fractional progress carries over smoothly
+                self.index %= len(self.images)
+            else:
+                # Clamp to the exact last frame index and mark as finished
+                self.index = float(len(self.images) - 1)
+                self.done = True
+
+    def get_image(self):
+        # Safe indexing guard
+        idx = min(int(self.index), len(self.images) - 1)
+        return self.images[idx]
+
+    def flip_v(self):
+        for i in range(len(self.images)):
+            self.images[i] = pygame.transform.flip(self.images[i], False, True)
+
+    def flip_h(self):
+        for i in range(len(self.images)):
+            self.images[i] = pygame.transform.flip(self.images[i], True, False)
+
+    def copy(self):
+        return Animation(self.image, self.size, self.fps, self.loop)
+    def render(self, cam):
+        if not self.visible: return
+        cam.draw_image(self.get_image(), self.pos, self.offset)
+
+class AnimationManager(GameObj):
+    def __init__(self, animations: dict[str, Animation], current_anim=None, z_index=0, active=True, visible=True, offset=True):
+        super().__init__(Vector2D(0, 0), z_index, active, visible)
+        self.animations = animations
+        self.current_anim = current_anim
+
+        for anim in self.animations:
+            anim.destroy() #remove from global or scene calls
+
+    def new_anim(self, name, anim):
+        self.animations[name] = anim
+        anim.destroy()
+
+    def new_anim_set(self, anims: dict[str, Animation]):
+        #add new anims to existing ones
+        self.animations.update(anims)
+        for anim in anims:
+            anims[anim].destroy()
+
+    def flip_v(self):
+        for name in self.animations:
+            self.animations[name].flip_v()
+
+    def flip_h(self):
+        for name in self.animations:
+            self.animations[name].flip_h()
+
+    def change_anim(self, name):
+        self.current_anim = name
+
+    def update(self):
+        if self.current_anim is None and self.current_anim in self.animations:
+            return
+        self.animations[self.current_anim].update(Game.dt)
+    def get_image(self) -> pygame.Surface:
+        if self.current_anim is None and self.current_anim in self.animations:
+            return
+        return self.animations[self.current_anim].get_image()
+    def get_animation(self) -> Animation:
+        if self.current_anim is None and self.current_anim in self.animations:
+            return
+        return self.animations[self.current_anim]
+
+    def render(self, cam):
+        if not self.visible: return
+        self.get_animation().render(cam)

pyscene-1.0.0/src/PyScene/utils/Assets.py

@@ -0,0 +1,151 @@
+import pygame
+
+from ..objs import Animation
+from ..Math import Vector2D
+
+class _assets:
+    def __init__(self):
+        self.images: dict[str, pygame.Surface] = {}
+        self.animations: dict[str, Animation] = {}
+        self.fonts: dict[str, pygame.font.Font] = {}
+        self.sounds: dict[str, pygame.mixer.Sound] = {}
+        self.tilesets: dict[str, dict[tuple[int, int], pygame.surface.Surface]] = {}
+        self._tileset_cache_data: dict[str, tuple[int, int]] = {}
+
+    #clearing
+    def _clear(self, _confirm=False):
+        if _confirm:
+            self.images = {}
+            self.animations = {}
+            self.fonts = {}
+            self.sounds = {}
+            self.tilesets = {}
+            self._tileset_cache_data = {}
+
+    def clear_images(self, _confirm=False):
+        if _confirm:
+            self.images = {}
+
+    def del_image(self, name):
+        if name in self.images:
+            del self.images[name]
+
+    def clear_animations(self, _confirm=False):
+        if _confirm:
+            self.animations = {}
+
+    def del_animation(self, name):
+        if name in self.animations:
+            del self.animations[name]
+
+    def clear_fonts(self, _confirm=False):
+        if _confirm:
+            self.fonts = {}
+
+    def del_font(self, name):
+        if name in self.fonts:
+            del self.fonts[name]
+
+    def clear_sounds(self, _confirm=False):
+        if _confirm:
+            self.sounds = {}
+
+    def del_sound(self, name):
+        if name in self.sounds:
+            del self.sounds[name]
+
+    def clear_tilesets(self, _confirm=False):
+        if _confirm:
+            self.tilesets = {}
+            self._tileset_cache_data = {}
+
+    def del_tileset(self, name):
+        if name in self.tilesets:
+            del self.tilesets[name]
+            del self._tileset_cache_data[name]
+
+    #creation
+    def new_image(self, name, path, rect=None, scale=1.0, colorKey=None, sWidth=None, sHeight=None):
+        image = pygame.image.load(path)
+        #rect
+        if rect is not None:
+            image = image.subsurface(rect)
+        #scale
+        if scale != 1.0:
+            image = pygame.transform.scale_by(image, scale)
+        #colorkey
+        if colorKey is not None:
+            image.set_colorkey(colorKey)
+        #size
+        if sWidth is not None and sHeight is not None:
+            image = pygame.transform.scale(image, (sWidth, sHeight))
+        self.images[name] = image.convert()
+
+    def new_font(self, name, path, size):
+        self.fonts[name] = pygame.font.Font(path, size)
+
+    def new_animation(self, name, image, size=16, fps=3, loop=True, pos=Vector2D(0, 0), z_index=0, active=True, visible=True, offset=True):
+        self.animations[name] = Animation(image, size, fps, loop, pos, z_index, active, visible, offset)
+    def new_anim_nIMG(self, name, size=16, fps=3, path=None, rect=None, scale=1.0, colorKey=(0, 0, 0), sWidth=None, sHeight=None, loop=True, pos=Vector2D(0, 0), z_index=0, active=True, visible=True, offset=True):
+        #create image
+        self.new_image(name, path, rect, scale, colorKey, sWidth, sHeight)
+        #create animation
+        self.new_animation(name, self.images[name], size*scale, fps, loop, pos, z_index, active, visible, offset)
+
+    def new_sound(self, name, path):
+        self.sounds[name] = pygame.mixer.Sound(path)
+
+    def new_tileset(self, path, name, width=16, height=16, scale=1.0, colorkey=None):
+        image = pygame.image.load(path).convert_alpha()
+        if colorkey is not None:
+            image.set_colorkey(colorkey)
+        if scale != 1.0:
+            image = pygame.transform.scale(image, (int(image.get_width()*scale), int(image.get_height()*scale)))
+        data, cache = load_tileset(image, width*scale, height*scale)
+        self.tilesets[name] = data
+        self._tileset_cache_data[name] = cache
+
+    #getters
+    def get_image(self, name):
+        if name in self.images:
+            return self.images[name]
+        else:
+            return None
+
+    def get_animation(self, name):
+        if name in self.animations:
+            return self.animations[name]
+        else:
+            return None
+
+    def get_font(self, name):
+        if name in self.fonts:
+            return self.fonts[name]
+        else:
+            return None
+
+    def get_sound(self, name):
+        if name in self.sounds:
+            return self.sounds[name]
+        else:
+            return None
+
+    def get_tileset(self, name):
+        if name in self.tilesets:
+            return self.tilesets[name]
+        else:
+            return None
+
+    
+
+Assets = _assets()
+
+def load_tileset(image, width, height):
+    tileset = {}
+    w, h = image.get_size()
+    w = int(w/width)
+    h = int(h/height)
+    for y in range(int(image.get_height()//height)):
+        for x in range(int(image.get_width()//width)):
+            tileset[(x, y)] = image.subsurface(pygame.Rect(x*width, y*height, width, height))
+    return tileset, (w, h)

pyscene-1.0.0/src/PyScene/utils/Subscreen.py

@@ -0,0 +1,36 @@
+import pygame
+
+from ..Math import Vector2D
+
+
+class SubScreen:
+    def __init__(self, x, y, w, h, bgColor: None, displaySurface: pygame.Surface = None, parent=None):
+        self.pos = Vector2D(x, y)
+        self.dim = Vector2D(w, h)
+        self.color = bgColor
+        self._screen = displaySurface
+        self.parent = parent  # Reference to parent SubScreen
+        if self.color == None: self.screen = pygame.Surface((w, h), pygame.SRCALPHA).convert_alpha()
+        else: self.screen = pygame.Surface((w, h)).convert()
+
+    def clear(self):
+        if self.color == None: self.screen.fill((0, 0, 0, 0))
+        else: self.screen.fill(self.color)
+
+    def get_absolute_pos(self):
+        """Recursively calculates the true global screen position."""
+        if self.parent:
+            return self.pos + self.parent.get_absolute_pos()
+        return self.pos
+
+    def local_mouse_pos(self, cam: Vector2D = Vector2D(0, 0)):
+        # Uses absolute position so nested screens correctly account for parent offsets
+        return Vector2D(*pygame.mouse.get_pos()) - (self.get_absolute_pos() - cam)
+
+    def get_global_rect(self, rect):
+        # Uses absolute position so hitboxes align on screen regardless of nesting level
+        abs_pos = self.get_absolute_pos()
+        return pygame.Rect((abs_pos.x + rect.x, abs_pos.y + rect.y), rect.size)
+
+    def render(self, cam: Vector2D = Vector2D(0, 0)):
+        self._screen.blit(self.screen, (self.pos - cam).to_int())

pyscene-1.0.0/src/PyScene/utils/__init__.py

@@ -0,0 +1,4 @@
+from .Subscreen import *
+from .Assets import *
+
+__all__ = ["SubScreen", "Assets"]

pyscene-1.0.0/tests/flappy_bird.py

@@ -0,0 +1,38 @@
+from src import *
+import pygame
+from random import randint as I
+while True:
+    Game.full_reset()
+    Game.init(640, 360, "Floppy Bird", "darkblue")
+    bird = Circle(100, 25, 10, "yellow", -1) #show behind pipes
+    vel = 0
+    top_pipes = [Rect(400, 0, 20, I(20, 100), "green"),Rect(600, 0, 20, I(20, 100), "green"),Rect(800, 0, 20, I(20, 100), "green"),Rect(1000, 0, 20, I(20, 100), "green"),]
+    bottom_pipes = [Rect(400, Game.height-I(175, 225), 20, 225, "green"),Rect(600, Game.height-I(175, 225), 20, 225, "green"),Rect(800, Game.height-I(175, 225), 20, 225, "green"),Rect(1000, Game.height-I(175, 225), 20, 225, "green"),]
+    text = Text(pygame.font.Font(None, 20), "Score: 0", "white", Vector2D(3, Game.height-20), "topleft", 100)
+    score = 0
+    added = False
+    while True:
+        bird.pos.y += vel*Game.dt
+        if bird.pos.y < -10 or bird.pos.y > Game.height-10: break
+        vel += 4
+        if Keys.is_pressed(Keys.space): vel = -150
+        for pipe in top_pipes: pipe.pos.x -= 100*Game.dt
+        for pipe in bottom_pipes: pipe.pos.x -= 100*Game.dt
+        #lose
+        if top_pipes[0].rect.collidepoint(bird.pos.to_int()): break
+        elif bottom_pipes[0].rect.collidepoint(bird.pos.to_int()): break
+        elif top_pipes[0].pos.x <= bird.pos.x and not added: #score
+            score+=1
+            text.set_text(f"Score: {score}")
+            added = True
+        #resetting pipes
+        if top_pipes[0].pos.x < -21:
+            top_pipes[0].destroy()
+            top_pipes.pop(0)
+            top_pipes.append(Rect(top_pipes[-1].pos.x + 200, 0, 20, I(20, 100), "green"))
+            bottom_pipes[0].destroy()
+            bottom_pipes.pop(0)
+            bottom_pipes.append(Rect(bottom_pipes[-1].pos.x + 200, Game.height-I(175, 225), 20, 225, "green"))
+            added = False
+        Game.Tick()
+        if Keys.is_pressed(Keys.escape): Game.quit()

pyscene-1.0.0/tests/test.py

@@ -0,0 +1,21 @@
+from src import *
+import pygame
+
+
+Game.init(640, 360, "Test - 01", "darkblue", fullscreen=False)
+
+class player(GameObj):
+    def __init__(self):
+        super().__init__(Vector2D(0, 0), 0)
+        #create animation
+        Assets.new_anim_nIMG("player", 8, 2, "tests/pause.png", (0, 0, 16, 8), colorKey=None, scale=3.0)
+        self.anim = Assets.get_animation("player")
+
+    def update(self):
+        self.pos += (Keys.get_vector(Keys.a, Keys.d, Keys.w, Keys.s, False)*150)*Game.dt
+        self.anim.pos = self.pos #positions stay linked
+
+player()
+
+Game.Run()
+

pyscene-1.0.0/tests/testColl.py

@@ -0,0 +1,39 @@
+from src import *
+import pygame
+
+Game.init(640, 360, "Test - 02: Collisions", "black")
+Game.show_collisions = True
+Game.optimize_static_colliders = True
+
+class Player(GameObj):
+    def __init__(self):
+        super().__init__(Vector2D(200, 0))
+        self.coll = DynamicCollisionRect(*self.pos.to_int(), 25, 25)
+
+    def update(self):
+        self.coll.vel = Keys.get_vector(Keys.a, Keys.d, Keys.w, Keys.s, False)*150
+
+class TestDynamic(GameObj):
+    def __init__(self):
+        super().__init__(Vector2D(0, 0), 5)
+        self.coll = DynamicCollisionRect(100, 100, 20, 40, True)
+        self.coll.vel.x = 100
+        self.vel.x = 100
+        self.timer = 0.0
+
+    def update(self):
+        self.timer += Game.dt
+        if self.timer >= 3.0: 
+            self.vel.x *= -1
+            self.timer = 0.0
+        self.coll.vel = self.vel.copy()
+
+StaticCollisionRect(0, 0, 50, 100, True)
+StaticCollisionRect(0, 100, 50, 50, True)
+StaticCollisionRect(250, 100, 50, 50, True)
+StaticCollisionRect(300, 100, 50, 50, True)
+TestDynamic()
+
+Player()
+Game.Run(True)
+