PyScene 1.0.5__tar.gz → 1.0.7__tar.gz

{pyscene-1.0.5 → pyscene-1.0.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: PyScene
-Version: 1.0.5
+Version: 1.0.7
 Summary: A small example package
 Project-URL: Homepage, https://github.com/sfertig/PyScene
 Project-URL: Issues, https://github.com/sfertig/PyScene/issues
@@ -18,3 +18,5 @@ PyScene is a custom python + pygame framework / engine developed to streamline 2
 
 Please Note: This engine is still in development and many features, like tilemaps and audio, are a work in progress. It also lack any form of documentation, I ask for patience as docs will be rolled out once the core features are more solidified.
 
+PyScene is in developement and API's may change offten, a fully stable version should come with v2.0.0, currently on v1.0.7
+

{pyscene-1.0.5 → pyscene-1.0.7}/README.md

@@ -4,3 +4,5 @@ PyScene is a custom python + pygame framework / engine developed to streamline 2
 
 Please Note: This engine is still in development and many features, like tilemaps and audio, are a work in progress. It also lack any form of documentation, I ask for patience as docs will be rolled out once the core features are more solidified.
 
+PyScene is in developement and API's may change offten, a fully stable version should come with v2.0.0, currently on v1.0.7
+

{pyscene-1.0.5 → pyscene-1.0.7}/pyproject.toml

@@ -3,7 +3,7 @@ requires = ["hatchling >= 1.26"]
 build-backend = "hatchling.build"
 [project]
 name = "PyScene"
-version = "1.0.5"
+version = "1.0.7"
 authors = [
   { name="Sam Fertig", email="sfertig007@gmail.com" },
 ]

{pyscene-1.0.5 → pyscene-1.0.7}/src/PyScene/Game.py

@@ -96,7 +96,7 @@ class _game:
     def __update(self):
         self.click = False
         self.dt = self.clock.tick(self.fps)/1000.0
-        self.events = pygame.event.get()
+        self.events = pygame.event.get().copy()
 
         for obj in self.dynamic_col: obj.update()
         
@@ -134,11 +134,11 @@ class _game:
         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)
+            for obj in self.render_queue: obj.render()
         #render scene
         else: 
-            self.active_scene.render(self.cam)
-            self.active_scene._render(self.cam)
+            self.active_scene.render()
+            self.active_scene._render()
         if self.show_collisions: self.__render_collisions()
         #update screen
         pygame.display.flip()
@@ -179,23 +179,22 @@ class _game:
         self.queue_del_coll = []
         self._update_coll = False
 
-    def set_scene(self, scene=None):
+    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()
+        self.active_scene = scene
+        #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.scenes[name] = self.__class__
-        Game.set_scene(name)
+        if name not in Game.scenes: Game.scenes[name] = self.__class__
+        Game._set_scene(self)
 
     def on_change(self): pass
 
@@ -204,13 +203,13 @@ class Scene:
         self.__handle_queue()
         for obj in self._objects: obj.update()
 
-    def render(self, cam): pass #user defined
-    def _render(self, cam): #built in method
+    def render(self): pass #user defined
+    def _render(self): #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)
+        for obj in self._render_queue: obj.render()
 
     def _queue_add(self, obj): self.queue_creation.append(obj)
     def _queue_remove(self, obj): self.queue_del.append(obj)

{pyscene-1.0.5 → pyscene-1.0.7}/src/PyScene/__init__.py

@@ -1,6 +1,6 @@
 #imports
 "PyScene is a custom python + pygame framework / engine developed to streamline 2d game development."
-"Version: 1.0.5"
+"Version: 1.0.7"
 
 from .Game import Game, Scene, handle_collision
 from .Math import *
@@ -26,6 +26,10 @@ __all__ = [
     "Line",
     "Text",
     "Image",
+    "Timer",
+
+    "Animation",
+    "AnimationManager",
 
     "StaticCollisionRect",
     "DynamicCollisionRect",

{pyscene-1.0.5 → pyscene-1.0.7}/src/PyScene/objs/GameObj.py

@@ -15,7 +15,9 @@ class GameObj: #this will be the base class of every game obj
         if not Global: Game._queue_add(self)
         else: Game.queue_creation.append(self) #if obj is just global anyway
 
+        self._global = Global
+
     def update(self): pass
-    def render(self, cam): pass
+    def render(self): pass
     def destroy(self): Game._queue_remove(self)
 

{pyscene-1.0.5 → pyscene-1.0.7}/src/PyScene/objs/Shapes.py

@@ -5,8 +5,8 @@ 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)
+    def __init__(self, x, y, w, h, color, z_index=0, width=0, active=True, visible=True, offset=True, Global=False):
+        super().__init__(Vector2D(x, y), z_index, active, visible, Global)
         self.dim = Vector2D(w, h)
         self.color = color
         self.rect = pygame.Rect((x, y), (w, h))
@@ -16,30 +16,30 @@ class Rect(GameObj):
     def update(self):
         if self.pos.to_int() != self.rect.topleft: self.rect.topleft = self.pos.to_int()
 
-    def render(self, cam):
+    def render(self):
         if not self.visible: return
-        cam.draw_rect(self.rect, self.color, self.width, self.offset)
+        Game.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)
+    def __init__(self, x, y, r, color, z_index=0, width=0, active=True, visible=True, offset=True, Global=False):
+        super().__init__(Vector2D(x, y), z_index, active, visible, Global)
         self.radius = r
         self.color = color
         self.width = width
         self.offset = offset
 
-    def render(self, cam):
+    def render(self):
         if not self.visible: return
-        cam.draw_circle(self.pos, self.radius, self.color, self.width, self.offset)
+        Game.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)
+    def __init__(self, x1, y1, x2, y2, color, z_index=0, width=1, active=True, visible=True, offset=True, Global=False):
+        super().__init__(Vector2D(x1, y1), z_index, active, visible, Global)
         self.end = Vector2D(x2, y2)
         self.color = color
         self.width = width
         self.offset = offset
 
-    def render(self, cam): 
+    def render(self): 
         if not self.visible: return
-        cam.draw_line(self.pos, self.end, self.color, self.width, self.offset)
+        Game.cam.draw_line(self.pos, self.end, self.color, self.width, self.offset)

{pyscene-1.0.5 → pyscene-1.0.7}/src/PyScene/objs/Text.py

@@ -4,8 +4,8 @@ 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)
+    def __init__(self, font, text, color, pos=Vector2D(0, 0), align="center", z_index=0, active=True, visible=True, offset=True, Global=False):
+        super().__init__(pos, z_index, active, visible, Global)
         self.font = font
         self.text = text
         self.color = color
@@ -34,17 +34,17 @@ class Text(GameObj):
         self.pos = new_pos
         self.rect = self.surface.get_rect(**{self.align: self.pos})
 
-    def render(self, cam):
+    def render(self):
         if not self.visible: return
-        cam.draw_text(self.surface, self.rect, self.offset)
+        Game.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)
+    def __init__(self, image, pos=Vector2D(0, 0), z_index=0, active=True, visible=True, offset=True, Global=False):
+        super().__init__(pos, z_index, active, visible, Global)
         self.image = image
         self.offset = offset
 
-    def render(self, cam):
+    def render(self):
         if not self.visible: return
-        cam.draw_image(self.image, self.pos, self.offset)
+        Game.cam.draw_image(self.image, self.pos, self.offset)
 

pyscene-1.0.7/src/PyScene/objs/Timer.py

@@ -0,0 +1,33 @@
+from .GameObj import GameObj
+from ..Game import Game
+from ..Math import Vector2D
+
+class Timer(GameObj):
+    def __init__(self, duration, active=True, Global=False):
+        super().__init__(Vector2D(0, 0), 0, active, True, Global)
+        self.duration = duration
+        self.elapsed = 0.0
+        self.running = False
+        self.start()
+
+    def start(self):
+        self.elapsed = 0
+        self.running = True
+
+    def stop(self):
+        self.running = False
+
+    def get_time(self):
+        return self.elapsed
+
+    def update(self, dt):
+        if not self.active: return
+        if self.running:
+            self.elapsed += dt
+            if self.elapsed >= self.duration:
+                self.running = False
+                return True
+        return False
+
+    def is_done(self):
+        return not self.running and self.elapsed >= self.duration

{pyscene-1.0.5 → pyscene-1.0.7}/src/PyScene/objs/__init__.py

@@ -3,5 +3,6 @@ from .Shapes import *
 from .Text import *
 from .animation import *
 from .Collision_shapes import *
+from .Timer import Timer
 
-__all__ = ["GameObj", "Rect", "Circle", "Line", "Text", "Image", "Animation", "AnimationManager", "StaticCollisionRect", "DynamicCollisionRect"]
+__all__ = ["GameObj", "Rect", "Circle", "Line", "Text", "Image", "Animation", "AnimationManager", "StaticCollisionRect", "DynamicCollisionRect", "Timer"]

{pyscene-1.0.5 → pyscene-1.0.7}/src/PyScene/objs/animation.py

@@ -5,8 +5,8 @@ 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)
+    def __init__(self, image, size, fps, loop=True, pos=Vector2D(0, 0), z_index=0, active=True, visible=True, offset=True, Global=False):
+        super().__init__(pos, z_index, active, visible, Global)
         self.offset = offset
         self.image = image
         self.size = size
@@ -63,18 +63,18 @@ class Animation(GameObj):
             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):
+        return Animation(self.image, self.size, self.fps, self.loop, self.pos, self.z_index, self.active, self.visible, self.offset, self._global)
+    def render(self):
         if not self.visible: return
-        cam.draw_image(self.get_image(), self.pos, self.offset)
+        Game.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)
+    def __init__(self, animations: dict[str, Animation], current_anim=None, z_index=0, active=True, visible=True, offset=True, Global=False):
+        super().__init__(Vector2D(0, 0), z_index, active, visible, Global)
         self.animations = animations
         self.current_anim = current_anim
 
-        for anim in self.animations:
+        for anim in self.animations.values():
             anim.destroy() #remove from global or scene calls
 
     def new_anim(self, name, anim):
@@ -111,6 +111,6 @@ class AnimationManager(GameObj):
             return
         return self.animations[self.current_anim]
 
-    def render(self, cam):
+    def render(self):
         if not self.visible: return
-        self.get_animation().render(cam)
+        self.get_animation().render()

{pyscene-1.0.5 → pyscene-1.0.7}/src/PyScene/utils/Assets.py

@@ -84,13 +84,17 @@ class _assets:
     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):
+    def new_animation(self, name, image, size=16, fps=3, loop=True, rect=None, pos=Vector2D(0, 0), z_index=0, active=True, visible=True, offset=True, Global=False):
+        m = image
+        if rect is not None:
+            m = image.subsurface(rect)
+        self.animations[name] = Animation(m, size, fps, loop, pos, z_index, active, visible, offset, Global)
+        return self.animations[name]
+    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, Global=False):
         #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)
+        self.new_animation(name, self.images[name], size*scale, fps, loop, pos, z_index, active, visible, offset, Global)
 
     def new_sound(self, name, path):
         self.sounds[name] = pygame.mixer.Sound(path)

{pyscene-1.0.5/tests → pyscene-1.0.7}/test.py

@@ -1,4 +1,4 @@
-from src import *
+from src.PyScene import *
 import pygame
 
 
@@ -15,7 +15,16 @@ class player(GameObj):
         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()
+class Test(Scene):
+    def __init__(self):
+        super().__init__("Test")
+        player()
+
+Test()
+
+Game.Tick()
+print(Game.objects)
+print(Game.active_scene._objects)
 
 Game.Run()