batframework 1.0.9a3__tar.gz → 1.0.9a5__tar.gz

{batframework-1.0.9a3 → batframework-1.0.9a5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: batframework
-Version: 1.0.9a3
+Version: 1.0.9a5
 Summary: Pygame framework for making games easier.
 Author-email: Turan Baturay <baturayturan@gmail.com>
 Project-URL: Homepage, https://github.com/TuranBaturay/batFramework

{batframework-1.0.9a3 → batframework-1.0.9a5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "batframework"
-version = "1.0.9a3"
+version = "1.0.9a5"
 description = "Pygame framework for making games easier."
 readme = "README.md"
 classifiers = [ "Programming Language :: Python :: 3", "License :: OSI Approved :: MIT License", "Operating System :: OS Independent",]

{batframework-1.0.9a3 → batframework-1.0.9a5}/src/batFramework/__init__.py

@@ -9,8 +9,8 @@ from .utils import Utils as utils
 from .tileset import Tileset
 from .timeManager import TimeManager,Timer,SceneTimer
 from .easingController import EasingController
-from .cutscene import Cutscene, CutsceneManager
-import batFramework.cutsceneBlocks
+from .cutsceneManager import CutsceneManager
+from .cutscene import *
 from .audioManager import AudioManager
 import batFramework.transition as transition
 from .action import Action

batframework-1.0.9a5/src/batFramework/cutscene.py

@@ -0,0 +1,53 @@
+import batFramework as bf
+from .transition import Transition
+class Cutscene:
+    def __init__(self,*cutscenes):
+        self.is_over : bool = False
+        self.sub_cutscenes : list[Cutscene] = list(cutscenes)
+        self.sub_index = -1
+
+    def start(self):
+        if self.sub_cutscenes:
+            self.sub_index = 0
+            self.sub_cutscenes[self.sub_index].start()
+        else:
+            self.end()
+
+    def process_event(self,event):
+        if self.sub_index > 0: 
+            self.sub_cutscenes[self.sub_index].process_event(event)
+            
+    def update(self,dt):
+        if self.sub_index >= 0: 
+            self.sub_cutscenes[self.sub_index].update(dt)
+            if self.sub_cutscenes[self.sub_index].is_over:
+                self.sub_index +=1
+                if self.sub_index >= len(self.sub_cutscenes):
+                    self.end()
+                    return
+                self.sub_cutscenes[self.sub_index].start()
+            
+    def end(self):
+        self.is_over = True
+
+
+class Wait(Cutscene):
+    def __init__(self,duration:float,scene_name:str="global"):
+        super().__init__()
+        self.duration = duration
+        self.scene_name = scene_name
+    def start(self):
+        self.timer = bf.SceneTimer(duration=self.duration,end_callback=self.end,scene_name=self.scene_name)
+        self.timer.start()
+
+
+
+class TransitionToScene(Cutscene):
+    def __init__(self,scene_name:str,transition:Transition):
+        super().__init__()
+        self.scene_name = scene_name
+        self.transition: Transition = transition
+
+    def start(self):
+        bf.CutsceneManager().manager.transition_to_scene(self.scene_name,self.transition)
+        bf.Timer(self.transition.duration,end_callback=self.end).start()

batframework-1.0.9a5/src/batFramework/cutsceneManager.py

@@ -0,0 +1,31 @@
+import batFramework as bf
+from typing import TYPE_CHECKING,Self
+import pygame
+# if TYPE_CHECKING:
+from .cutscene import Cutscene
+
+
+class CutsceneManager(metaclass=bf.Singleton):
+    def __init__(self) -> None:
+        self.current_cutscene: Cutscene = None
+        self.manager: bf.Manager = None
+
+    def set_manager(self, manager):
+        self.manager = manager
+
+    def process_event(self, event):
+        if self.current_cutscene is not None:
+            self.current_cutscene.process_event(event)
+            if event.type in bf.enums.playerInput:
+                event.consumed = True
+
+    def play(self,cutscene:Cutscene):
+        if self.current_cutscene is not None:return
+        self.current_cutscene = cutscene
+        cutscene.start()
+
+    def update(self,dt):
+        if self.current_cutscene:
+            self.current_cutscene.update(dt)
+            if self.current_cutscene.is_over:
+                self.current_cutscene = None

{batframework-1.0.9a3 → batframework-1.0.9a5}/src/batFramework/enums.py

@@ -1,4 +1,8 @@
 from enum import Enum
+import pygame
+
+playerInput = [pygame.KEYDOWN,pygame.MOUSEBUTTONDOWN,pygame.KEYUP,pygame.MOUSEBUTTONUP]
+
 
 
 class color:
@@ -111,4 +115,6 @@ class textMode(Enum):
     ALPHABETICAL = 0
     NUMERICAL = 1
     ALPHANUMERICAL = 3
-    
+
+
+

{batframework-1.0.9a3 → batframework-1.0.9a5}/src/batFramework/gui/label.py

@@ -246,9 +246,9 @@ class Label(Shape):
 
     def _build_layout(self) -> None:
 
+        # print(self.text_rect.size,self._get_text_rect_required_size(),repr(self.text))
         self.text_rect.size = self._get_text_rect_required_size()
-        # self.text_rect.w = ceil(self.text_rect.w)
-        # self.text_rect.h = ceil(self.text_rect.h) 
+
         if self.autoresize_h or self.autoresize_w:
             target_rect = self.inflate_rect_by_padding((0, 0, *self.text_rect.size))
             if not self.autoresize_w:
@@ -256,9 +256,10 @@ class Label(Shape):
             if not self.autoresize_h:
                 target_rect.h = self.rect.h
             if self.rect.size != target_rect.size:
+                # print("Size not good ! ",self.rect.size,target_rect.size,repr(self.text))
                 self.set_size(target_rect.size)
                 self.apply_updates()
-                return
+
         offset = self._get_outline_offset() if self.show_text_outline else (0,0)
         padded = self.get_padded_rect().move(-self.rect.x + offset[0], -self.rect.y + offset[1])
         self.align_text(self.text_rect, padded, self.alignment)
@@ -271,7 +272,6 @@ class Label(Shape):
         if self.font_object is None:
             print(f"No font for widget with text : '{self}' :(")
             return
-
         params = {
             "font_name": self.font_object.name,
             "text": self.text,
@@ -333,6 +333,3 @@ class Label(Shape):
         super().paint()
         if self.font_object:
             self._paint_text()
-
-    # def set_alignment(self, alignment: bf.alignment) -> Self:
-    #     return self

{batframework-1.0.9a3 → batframework-1.0.9a5}/src/batFramework/gui/styleManager.py

@@ -25,7 +25,7 @@ class StyleManager(metaclass=Singleton):
 
     def refresh_widget(self, widget: Widget):
         if widget in self.widgets:
-            self.lookup[widget] = True
+            self.lookup[widget] = False
             self.update()
 
     def remove_widget(self, widget: Widget):

{batframework-1.0.9a3 → batframework-1.0.9a5}/src/batFramework/manager.py

@@ -74,6 +74,8 @@ class Manager(bf.SceneManager):
             if event.key == pygame.K_p:
                 self.print_status()
                 return
+        self.cutsceneManager.process_event(event)
+        if event.consumed: return
         super().process_event(event)
         if not event.consumed:
             if event.type == pygame.QUIT:

{batframework-1.0.9a3 → batframework-1.0.9a5}/src/batFramework/renderGroup.py

@@ -8,13 +8,13 @@ from typing import Self, Iterator, Callable
 """
 
 
-class RenderGroup(bf.Entity):
+class RenderGroup(bf.Drawable):
     def __init__(
-        self, entity_iterator: Callable[[], Iterator[bf.Entity]], blit_flags: int = 0
+        self, entity_iterator: Callable[[], Iterator[bf.Drawable]], blit_flags: int = 0
     ) -> None:
         super().__init__()
         self.entity_iterator = entity_iterator
-        self.set_blit_flags(blit_flags)
+        # self.set_blit_flags(blit_flags)
         self.set_debug_color("white")
 
     def get_debug_outlines(self):

{batframework-1.0.9a3 → batframework-1.0.9a5}/src/batFramework/sceneManager.py

@@ -171,6 +171,9 @@ class SceneManager:
 
     def process_event(self, event: pygame.Event):
 
+        if self.current_transitions and event in bf.enums.playerInput:
+            return
+
         if event.type in self.shared_events:
             [s.process_event(event) for s in self.scenes]
         else:

{batframework-1.0.9a3 → batframework-1.0.9a5}/src/batFramework/scrollingSprite.py

@@ -17,19 +17,15 @@ class ScrollingSprite(bf.Sprite):
         # Use integer values for the starting points, converted from floating point scroll values
 
         super().__init__(size, data, convert_alpha)
-        self.original_width, self.original_height = self.original_surface.get_size()
+        if self.original_surface:
+            self.original_width, self.original_height = self.original_surface.get_size()
+
 
     def get_debug_outlines(self):
         yield from super().get_debug_outlines()
         for r in self._get_mosaic_rect_list():
             yield r.move(*self.rect.topleft)
 
-    def set_image(
-        self, data: pygame.Surface | str, size: None | tuple[int, int] = None
-    ) -> Self:
-        super().set_image(data, size)
-        self.original_width, self.original_height = self.original_surface.get_size()
-        return self
 
     def set_autoscroll(self, x: float, y: float) -> Self:
         self.auto_scroll.update(x, y)

{batframework-1.0.9a3 → batframework-1.0.9a5}/src/batframework.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: batframework
-Version: 1.0.9a3
+Version: 1.0.9a5
 Summary: Pygame framework for making games easier.
 Author-email: Turan Baturay <baturayturan@gmail.com>
 Project-URL: Homepage, https://github.com/TuranBaturay/batFramework

{batframework-1.0.9a3 → batframework-1.0.9a5}/src/batframework.egg-info/SOURCES.txt

@@ -11,7 +11,7 @@ src/batFramework/camera.py
 src/batFramework/character.py
 src/batFramework/constants.py
 src/batFramework/cutscene.py
-src/batFramework/cutsceneBlocks.py
+src/batFramework/cutsceneManager.py
 src/batFramework/drawable.py
 src/batFramework/dynamicEntity.py
 src/batFramework/easingController.py

batframework-1.0.9a3/src/batFramework/cutscene.py

@@ -1,129 +0,0 @@
-import batFramework as bf
-from typing import TYPE_CHECKING,Self
-
-class CutsceneBlock: ...
-
-if TYPE_CHECKING:
-    from .cutsceneBlocks import CutsceneBlock
-
-
-class Cutscene: ...
-
-
-class CutsceneManager(metaclass=bf.Singleton):
-    def __init__(self) -> None:
-        self.current_cutscene: Cutscene = None
-        self.cutscenes: list[bf.Cutscene] = []
-        self.manager: bf.Manager = None
-
-    def set_manager(self, manager):
-        self.manager = manager
-
-    def get_flag(self, flag):
-        return None
-
-    def process_event(self, event):
-        if self.current_cutscene:
-            self.current_cutscene.process_event(event)
-
-    def queue(self, *cutscenes):
-        self.cutscenes.extend(cutscenes)
-        if self.current_cutscene is None:
-            self.play(self.cutscenes.pop(0))
-
-    def play(self, cutscene: Cutscene):
-        if self.current_cutscene is None:
-            self.current_cutscene = cutscene
-            self.current_cutscene.on_enter()
-            self.current_cutscene.init_blocks()
-            self.current_cutscene.play()
-
-    def enable_player_control(self) -> None:
-        pass
-
-    def disable_player_control(self) -> None:
-        pass
-    
-    def update(self, dt):
-        if not self.current_cutscene is None:
-            self.current_cutscene.update(dt)
-            # print("cutscene manager update")
-            if self.current_cutscene.has_ended():
-                self.current_cutscene.on_exit()
-                self.current_cutscene = None
-                if self.cutscenes:
-                    self.play(self.cutscenes.pop(0))
-                else:
-                    self.current_cutscene = None
-
-
-class Cutscene:
-    def __init__(self) -> None:
-        self.cutscene_blocks : list[CutsceneBlock] = []
-        self.block_index = 0
-        self.end_blocks: list[CutsceneBlock] = []
-        self.ended = False
-
-    def on_enter(self):
-        pass
-
-    def on_exit(self):
-        pass
-
-    def init_blocks(self):
-        pass
-
-    def add_blocks(self, *blocks: CutsceneBlock)->Self:
-        self.cutscene_blocks.extend(blocks)
-        return self
-        
-    def add_end_blocks(self, *blocks: CutsceneBlock)->Self:
-        _ = [block.set_parent_cutscene(self) for block in blocks]
-        self.end_blocks.extend(blocks)
-        return self
-        
-    def get_scene_at(self, index):
-        return bf.CutsceneManager().manager.scenes[index]
-
-    def get_current_scene(self):
-        return bf.CutsceneManager().manager.get_current_scene()
-
-    def set_scene(self, name, index=0):
-        return bf.CutsceneManager().manager.set_scene(name, index)
-
-    def get_scene(self, name):
-        return bf.CutsceneManager().manager.get_scene(name)
-
-    def add_block(self, *blocks: CutsceneBlock):
-        for block in blocks:
-            block.set_parent_cutscene(self)
-            self.cutscene_blocks.append(block)
-
-    def process_event(self, event):
-        if not self.ended and self.block_index < len(self.cutscene_blocks):
-            self.cutscene_blocks[self.block_index].process_event(event)
-
-    def play(self):
-        self.block_index = 0
-        if self.cutscene_blocks:
-            self.cutscene_blocks[self.block_index].start()
-        else:
-            self.ended
-
-    def update(self, dt):
-        if self.ended:
-            return
-        self.cutscene_blocks[self.block_index].update(dt)
-        if self.cutscene_blocks[self.block_index].has_ended():
-            self.block_index += 1
-            if self.block_index == len(self.cutscene_blocks):
-                if not self.end_blocks:
-                    self.ended = True
-                    return
-                else:
-                    self.cutscene_blocks.extend(self.end_blocks)
-                    self.end_blocks = []
-            self.cutscene_blocks[self.block_index].start()
-
-    def has_ended(self):
-        return self.ended

batframework-1.0.9a3/src/batFramework/cutsceneBlocks.py

@@ -1,169 +0,0 @@
-import batFramework as bf
-from .cutscene import Cutscene, CutsceneManager
-from .transition import *
-from typing import Optional,Callable
-
-# Define the base CutsceneBlock class
-class CutsceneBlock:
-    """
-    Base class for cutscene blocks. Represents a unit of action in a cutscene.
-    """
-
-    # Constructor for the CutsceneBlock
-    def __init__(self) -> None:
-        # Callback function, parent cutscene, and state variables
-        self.callback = None
-        self.parent_cutscene: Cutscene = None
-        self.get_flag = CutsceneManager().get_flag
-        self.ended = False
-        self.started = False
-
-    def get_scene_at(self, index):
-        return bf.CutsceneManager().manager.scenes[index]
-
-    def set_scene(self, name, index=0):
-        return CutsceneManager().manager.set_scene(name, index)
-
-    def get_current_scene(self):
-        return CutsceneManager().manager.get_current_scene()
-
-    def get_scene(self, name):
-        return CutsceneManager().manager.get_scene(name)
-
-    # Set the parent cutscene for this block
-    def set_parent_cutscene(self, parent):
-        """
-        Set the parent cutscene for this block.
-
-        Args:
-            parent: The parent cutscene object.
-        """
-        self.parent_cutscene = parent
-
-    # Process an event (placeholder implementation, to be overridden in subclasses)
-    def process_event(self, event):
-        """
-        Process an event for this cutscene block.
-
-        Args:
-            event: The event to be processed.
-        """
-        pass
-
-    # Update the block (placeholder implementation, to be overridden in subclasses)
-    def update(self, dt):
-        """
-        Update the cutscene block.
-
-        Args:
-            dt: Time elapsed since the last update.
-        """
-        pass
-
-    # Start the block
-    def start(self):
-        """
-        Start the cutscene block.
-        """
-        self.started = True
-
-    # Mark the block as ended
-    def end(self):
-        """
-        Mark the cutscene block as ended.
-        """
-        self.ended = True
-
-    # Check if the block has ended
-    def has_ended(self):
-        """
-        Check if the cutscene block has ended.
-
-        Returns:
-            bool: True if the block has ended, False otherwise.
-        """
-        return self.ended
-
-
-# Define the ParallelBlock class, a type of CutsceneBlock
-class ParallelBlock(CutsceneBlock):
-    """
-    Represents a parallel execution block for multiple Cutscene blocks.
-    """
-
-    def __init__(self, *blocks) -> None:
-        super().__init__()
-        # List of blocks to run in parallel
-        self.blocks: list[CutsceneBlock] = list(blocks)
-
-    # Start the parallel block (override the base class method)
-    def start(self):
-        super().start()
-        # Start each block in parallel
-        for block in self.blocks:
-            block.start()
-
-    # Process an event for each block in parallel
-    def process_event(self, event):
-        _ = [b.process_event(event) for b in self.blocks]
-
-    # Update each block in parallel
-    def update(self, dt):
-        _ = [b.update(dt) for b in self.blocks]
-
-    # Check if all blocks have ended
-    def has_ended(self):
-        return all(b.has_ended() for b in self.blocks)
-
-
-# Define the SceneTransitionBlock class, a type of CutsceneBlock
-class SceneTransitionBlock(CutsceneBlock):
-    """
-    Represents a scene transition Cutscene block.
-    """
-
-    # Constructor for SceneTransitionBlock
-    def __init__(
-        self, scene, transition: Transition = Fade(0.1), index: int = 0
-    ) -> None:
-        super().__init__()
-        # Target scene, transition type, duration, and additional keyword arguments
-        self.target_scene = scene
-        self.transition = transition
-        self.index = index
-        # Timer to handle the end of the transition
-        self.timer = bf.Timer(transition.duration, self.end)
-
-    # Start the scene transition block
-    def start(self):
-        """
-        Start the scene transition block.
-        """
-        super().start()
-        # Initiate the scene transition
-        if self.get_current_scene().name == self.target_scene:
-            self.end()
-            return
-        CutsceneManager().manager.transition_to_scene(
-            self.target_scene, self.transition, self.index
-        )
-        # Start the timer to handle the end of the transition
-        self.timer.start()
-
-class DelayBlock(CutsceneBlock):
-    def __init__(self, duration) -> None:
-        super().__init__()
-        self.timer = bf.Timer(duration=duration, end_callback=self.end)
-
-    def start(self):
-        super().start()
-        self.timer.start()
-
-class FunctionBlock(CutsceneBlock):
-    def __init__(self, func : Optional[Callable]) -> None:
-        self.function = func
-
-    def start(self):
-        super().start()
-        if self.function : self.function()
-        self.end()