batframework 1.0.8a3__tar.gz → 1.0.8a6__tar.gz

{batframework-1.0.8a3 → batframework-1.0.8a6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: batframework
-Version: 1.0.8a3
+Version: 1.0.8a6
 Summary: Pygame framework for making games easier.
 Author-email: Turan Baturay <baturayturan@gmail.com>
 Project-URL: Homepage, https://github.com/TuranBaturay/batFramework
@@ -12,9 +12,9 @@ Description-Content-Type: text/markdown
 License-File: LICENCE
 Requires-Dist: pygame-ce
 
-# batFramework & gamejam Project
+# batFramework
 
-Welcome to the `batFramework` and the accompanying `gamejam` project. This README provides an overview of both the game framework and the specific game project developed using the framework.
+Welcome to the `batFramework`. This README provides an overview of the game framework.
 
 ## batFramework
 
@@ -38,18 +38,6 @@ The `batFramework` is a Python game development framework based on pygame, desig
 
 For more detailed information on how to use the framework, refer to the documentation (if available) or explore the source code in the `batFramework` directory.
 
-## gamejam Project
 
-The `gamejam` project is a specific game developed using the `batFramework`. It serves as an example of how the framework can be used to create a game from scratch.
-
-### Play the gamejam Project
-
-1. Install Python (version 3.10 or higher) and the latest stable version of pygame-ce.
-2. Clone or download this repository.
-3. Navigate to the `gamejam` directory.
-4. Run the game by executing the main script (e.g., `python main.py`).
-5. Play the game and have fun!
-
-Feel free to explore the code in the `gamejam` directory to see how the `batFramework` is utilized to create the game. You can modify, extend, or use the project as a starting point for your own games.
 
 

{batframework-1.0.8a3 → batframework-1.0.8a6}/README.md

@@ -1,6 +1,6 @@
-# batFramework & gamejam Project
+# batFramework
 
-Welcome to the `batFramework` and the accompanying `gamejam` project. This README provides an overview of both the game framework and the specific game project developed using the framework.
+Welcome to the `batFramework`. This README provides an overview of the game framework.
 
 ## batFramework
 
@@ -24,18 +24,6 @@ The `batFramework` is a Python game development framework based on pygame, desig
 
 For more detailed information on how to use the framework, refer to the documentation (if available) or explore the source code in the `batFramework` directory.
 
-## gamejam Project
 
-The `gamejam` project is a specific game developed using the `batFramework`. It serves as an example of how the framework can be used to create a game from scratch.
-
-### Play the gamejam Project
-
-1. Install Python (version 3.10 or higher) and the latest stable version of pygame-ce.
-2. Clone or download this repository.
-3. Navigate to the `gamejam` directory.
-4. Run the game by executing the main script (e.g., `python main.py`).
-5. Play the game and have fun!
-
-Feel free to explore the code in the `gamejam` directory to see how the `batFramework` is utilized to create the game. You can modify, extend, or use the project as a starting point for your own games.
 
 

{batframework-1.0.8a3 → batframework-1.0.8a6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "batframework"
-version = "1.0.8a3"
+version = "1.0.8a6"
 authors = [
     { name="Turan Baturay", email="baturayturan@gmail.com" }
 ]

{batframework-1.0.8a3 → batframework-1.0.8a6}/src/batFramework/__init__.py

@@ -8,7 +8,7 @@ from .resourceManager import ResourceManager
 from .fontManager import FontManager
 from .utils import Utils as utils
 from .tileset import Tileset
-from .time import TimeManager, Timer
+from .time import *
 from .easingController import EasingController
 from .cutscene import Cutscene, CutsceneManager
 from .cutsceneBlocks import *
@@ -24,12 +24,15 @@ from .dynamicEntity import DynamicEntity
 from .sprite import Sprite
 from .scrollingSprite import ScrollingSprite
 from .particle import *
-from .animatedSprite import AnimatedSprite, AnimState
+from .animatedSprite import AnimatedSprite, Animation
+from .character import Character
 from .stateMachine import State, StateMachine
 from .scene import Scene
 from .gui import *
 from .sceneManager import SceneManager
 from .manager import Manager
+from .templates import *
+import importlib.metadata
 
 
 def init_screen(resolution: tuple[int, int], flags: int = 0, vsync: int = 0):
@@ -44,6 +47,16 @@ def init_screen(resolution: tuple[int, int], flags: int = 0, vsync: int = 0):
     )
 
 
+
+def print_version():
+    package_name = "batFramework"
+    try:
+        version = importlib.metadata.version(package_name)
+        print(f"{package_name} version: {version}")
+    except importlib.metadata.PackageNotFoundError:
+        print(f"{package_name} is not installed")
+
+
 def init(
     resolution: tuple[int, int],
     flags: int = 0,
@@ -54,6 +67,7 @@ def init(
     window_title: str = "BatFramework Project",
     fps_limit: int = 0,
 ):
+    print_version()
     pygame.display.set_caption(window_title)
     init_screen(resolution, flags, vsync)
 

batframework-1.0.8a6/src/batFramework/animatedSprite.py

@@ -0,0 +1,176 @@
+import batFramework as bf
+import pygame
+from typing import List, Dict, Tuple, Union, Optional, Self
+
+
+def search_index(target: int, lst: List[int]) -> int:
+    cumulative_sum = 0
+    for index, value in enumerate(lst):
+        cumulative_sum += value
+        if cumulative_sum >= target:
+            return index
+    return -1
+
+
+class Animation:
+    def __init__(
+        self,
+        name: str
+    ) -> None:
+        self.name = name
+        self.frames: list[pygame.Surface] = []
+        self.frames_flipX : list[pygame.Surface] = []
+        self.duration_list = []
+        self.duration_list_length = 1
+
+    def from_surface(self,surface:pygame.Surface,size : Tuple[int,int])->Self:
+        self.frames         : List[pygame.Surface] = list(bf.utils.split_surface(surface, size).values())
+        self.frames_flipX   : List[pygame.Surface] = list(bf.utils.split_surface(surface, size,func=lambda s : pygame.transform.flip(s,True,False)).values())
+        return self
+
+    def __repr__(self):
+        return f"Animation({self.name})"
+
+    def counter_to_frame(self, counter: Union[float, int]) -> int:
+        if not self.frames : 
+            raise ValueError("Animation has no frames")
+        return search_index(
+            int(counter % self.duration_list_length), self.duration_list
+        )
+
+    def get_frame(self, counter: Union[float, int], flip: bool) -> pygame.Surface:
+        i = self.counter_to_frame(counter)
+        return self.frames_flipX[i] if flip else self.frames[i]
+
+    def set_duration_list(self, duration_list: Union[List[int], int]) -> Self:
+        if isinstance(duration_list, int):
+            duration_list = [duration_list] * len(self.frames)
+        if len(duration_list) != len(self.frames):
+            raise ValueError("duration_list should have values for all frames")
+        self.duration_list = duration_list
+        self.duration_list_length = sum(self.duration_list)
+        return self
+
+class AnimatedSprite(bf.Entity):
+    def __init__(self, size: Optional[Tuple[int, int]] = None) -> None:
+        super().__init__(size, no_surface=True)
+        self.float_counter: float = 0
+        self.animations: Dict[str, Animation] = {}
+        self.current_state: Optional[Animation] = None
+        self.flipX: bool = False
+        self._locked: bool = False
+        self._paused: bool = False
+        self.animation_end_callback = None
+        self.transition_end_animation = None
+
+    def set_animation_end_callback(self,callback)->Self:
+        self.animation_end_callback = callback
+        return self
+
+    @property
+    def paused(self) -> bool:
+        return self._paused
+
+    @paused.setter
+    def paused(self, value: bool) -> None:
+        self._paused = value
+
+    def toggle_pause(self) -> None:
+        self.paused = not self.paused
+
+    def set_counter(self, value: float) -> None:
+        self.float_counter = value
+
+    def set_frame(self, frame_index: int) -> None:
+        if not self.current_state:
+            return
+        self.set_counter(sum(self.current_state.duration_list[:frame_index]))
+
+    def lock(self) -> None:
+        self._locked = True
+
+    def unlock(self) -> None:
+        self._locked = False
+
+    def set_flipX(self, value: bool) -> None:
+        self.flipX = value
+
+    def remove_animation(self, name: str) -> bool:
+        if name not in self.animations:
+            return False
+        self.animations.pop(name)
+        if self.current_state and self.current_state.name == name:
+            self.current_state = (
+                list(self.animations.values())[0] if self.animations else None
+            )
+        return True
+
+    def add_animation(
+        self,
+        animation:Animation
+    ) -> bool:
+        if animation.name in self.animations:
+            return False
+        self.animations[animation.name] = animation
+        return True
+
+    def set_animation(
+        self, state: str, reset_counter: bool = True, lock: bool = False
+    ) -> bool:
+        if state not in self.animations or self._locked:
+            return False
+        
+        animation = self.animations[state]
+        self.current_state = animation
+
+        if self.current_state.frames:
+            self.rect = self.current_state.frames[0].get_frect(center=self.rect.center)
+
+        if reset_counter or (self.float_counter > animation.duration_list_length):
+            self.float_counter = 0
+
+        if lock:
+            self.lock()
+        
+        if self.transition_end_animation is not None:
+            self.transition_end_animation = None
+        return True
+    
+    def transition_to_animation(self,transition:str,animation:str)->Self:
+        self.set_animation(transition)
+        self.transition_end_animation = animation
+        return self
+    
+    def get_current_animation(self) -> Optional[Animation]:
+        return self.current_state
+
+    def update(self, dt: float) -> None:
+        s = self.get_current_animation()
+        if  self.animations and s is not None:
+            if not self.paused:
+                self.float_counter += 60 * dt
+                if self.float_counter > s.duration_list_length:
+                    if self.transition_end_animation is not None:
+                        # print(f"{self.transition_end_animation=}, {self.get_current_animation()=}")
+                        self.set_animation(self.transition_end_animation)
+                    if self.animation_end_callback is not None:
+                        self.animation_end_callback()
+                    self.float_counter = 0
+        super().update(dt)
+
+
+    def get_current_frame(self)->pygame.Surface:
+        return self.current_state.get_frame(self.float_counter, self.flipX)
+
+    def draw(self, camera: bf.Camera) -> None:
+        if (
+            not self.visible
+            or not camera.rect.colliderect(self.rect)
+            or not self.current_state
+        ):
+            return
+        camera.surface.blit(
+            self.get_current_frame(),
+            camera.world_to_screen(self.rect),
+        )
+        return 

{batframework-1.0.8a3 → batframework-1.0.8a6}/src/batFramework/audioManager.py

@@ -68,7 +68,7 @@ class AudioManager(metaclass=bf.Singleton):
             self.sounds[name]["sound"].play()
             return True
         except KeyError:
-            # print(f"Sound '{name}' not loaded in AudioManager.")
+            print(f"Sound '{name}' not loaded in AudioManager.")
             return False
 
     def stop_sound(self, name) -> bool:
@@ -77,7 +77,7 @@ class AudioManager(metaclass=bf.Singleton):
             return True
         except KeyError:
             return False
-            # print(f"Sound '{name}' not loaded in AudioManager.")
+            print(f"Sound '{name}' not loaded in AudioManager.")
 
     def load_music(self, name, path):
         self.musics[name] = bf.ResourceManager().get_path(path)

batframework-1.0.8a6/src/batFramework/character.py

@@ -0,0 +1,27 @@
+import batFramework as bf
+from .stateMachine import State
+from .animatedSprite import AnimatedSprite
+from .dynamicEntity import DynamicEntity
+
+class Character(AnimatedSprite,DynamicEntity):
+    def __init__(self) -> None:
+        super().__init__()
+        self.state_machine = bf.StateMachine(self)
+        self.do_setup_animations()
+        self.do_setup_states()
+
+    def set_state(self,state_name:str):
+        self.state_machine.set_state(state_name)
+
+    def get_current_state(self)->State:
+        return self.state_machine.get_current_state()
+    
+    def update(self, dt: float) -> None:
+        self.state_machine.update(dt)
+        super().update(dt)
+
+    def do_setup_states(self):
+        pass
+    
+    def do_setup_animations(self):
+        pass

{batframework-1.0.8a3 → batframework-1.0.8a6}/src/batFramework/cutscene.py

@@ -1,8 +1,11 @@
 import batFramework as bf
-
+from typing import TYPE_CHECKING
 
 class CutsceneBlock: ...
 
+if TYPE_CHECKING:
+    from .cutsceneBlocks import CutsceneBlock
+
 
 class Cutscene: ...
 
@@ -58,7 +61,7 @@ class CutsceneManager(metaclass=bf.Singleton):
 
 class Cutscene:
     def __init__(self) -> None:
-        self.cutscene_blocks = []
+        self.cutscene_blocks : list[CutsceneBlock] = []
         self.block_index = 0
         self.end_blocks: list[CutsceneBlock] = []
         self.ended = False

{batframework-1.0.8a3 → batframework-1.0.8a6}/src/batFramework/cutsceneBlocks.py

@@ -1,7 +1,7 @@
 import batFramework as bf
 from .cutscene import Cutscene, CutsceneManager
 from .transition import *
-
+from typing import Optional,Callable
 
 # Define the base CutsceneBlock class
 class CutsceneBlock:
@@ -150,7 +150,6 @@ class SceneTransitionBlock(CutsceneBlock):
         # Start the timer to handle the end of the transition
         self.timer.start()
 
-
 class DelayBlock(CutsceneBlock):
     def __init__(self, duration) -> None:
         super().__init__()
@@ -160,12 +159,11 @@ class DelayBlock(CutsceneBlock):
         super().start()
         self.timer.start()
 
-
 class FunctionBlock(CutsceneBlock):
-    def __init__(self, func) -> None:
+    def __init__(self, func : Optional[Callable]) -> None:
         self.function = func
 
     def start(self):
         super().start()
-        self.function()
+        if self.function : self.function()
         self.end()

{batframework-1.0.8a3 → batframework-1.0.8a6}/src/batFramework/dynamicEntity.py

@@ -8,15 +8,22 @@ class DynamicEntity(bf.Entity):
         self,
         size: None | tuple[int, int] = None,
         surface_flags: int = 0,
-        convert_alpha: bool = False,
+        convert_alpha: bool = False,*args,**kwargs
     ) -> None:
-        super().__init__(size, surface_flags, convert_alpha)
+        super().__init__(size, surface_flags, convert_alpha,*args,**kwargs)
         self.velocity = pygame.math.Vector2(0, 0)
+        self.ignore_collisions : bool = False
 
-    def on_collideX(self, collider: Self):
+    def on_collideX(self, collider: "DynamicEntity"):
+        """
+        Return true if collision
+        """
         return False
 
-    def on_collideY(self, collider: Self):
+    def on_collideY(self, collider: "DynamicEntity"):
+        """
+        Return true if collision
+        """
         return False
 
     def move_by_velocity(self, dt) -> None:

{batframework-1.0.8a3 → batframework-1.0.8a6}/src/batFramework/enums.py

@@ -51,7 +51,7 @@ class easing(Enum):
     EASE_IN = (0.95, 0, 1, 0.55)
     EASE_OUT = (0.5, 1, 0.5, 1)
     EASE_IN_OUT = (0.55, 0, 0.45, 1)
-    EASE_IN_OUT_ELASTIC = (0.39, -0.55, 0.3, 1.3)
+    EASE_IN_OUT_ELASTIC = (0.76,-0.36,0.41,1.34)
 
     def __init__(self, *control_points):
         self.control_points = control_points
@@ -110,4 +110,4 @@ class actionType(Enum):
 class textMode(Enum):
     ALPHABETICAL = 0
     NUMERICAL = 1
-    ALPHANUMERIC = 3
+    ALPHANUMERICAL = 3

{batframework-1.0.8a3 → batframework-1.0.8a6}/src/batFramework/fontManager.py

@@ -42,7 +42,7 @@ class FontManager(metaclass=Singleton):
             filename = name  # if name is not given, name is the filename
         self.FONTS[filename] = {}
         # fill the dict
-        for size in range(self.MIN_FONT_SIZE, self.MAX_FONT_SIZE, 2):
+        for size in range(self.MIN_FONT_SIZE, self.MAX_FONT_SIZE+1, 2):
             self.FONTS[filename][size] = pygame.font.Font(path, size=size)
 
     def load_sysfont(self, font_name: str | None, key: str | None = ""):
@@ -52,7 +52,7 @@ class FontManager(metaclass=Singleton):
             raise FileNotFoundError(f"Requested font '{font_name}' was not found")
         self.FONTS[font_name] = {}
 
-        for size in range(self.MIN_FONT_SIZE, self.MAX_FONT_SIZE, 2):
+        for size in range(self.MIN_FONT_SIZE, self.MAX_FONT_SIZE+1, 2):
             self.FONTS[key][size] = pygame.font.SysFont(font_name, size=size)
 
     def get_font(

{batframework-1.0.8a3 → batframework-1.0.8a6}/src/batFramework/gui/clickableWidget.py

@@ -27,7 +27,7 @@ class ClickableWidget(Shape, InteractiveWidget):
         self.set_debug_color("cyan")
         self.set_relief(self.unpressed_relief)
 
-    def set_unpressed_relief(self, relief: int = 0) -> Self:
+    def set_unpressed_relief(self, relief: int) -> Self:
         if relief == self.unpressed_relief:
             return self
         self.unpressed_relief = relief
@@ -36,18 +36,17 @@ class ClickableWidget(Shape, InteractiveWidget):
             self.set_relief(relief)
         return self
 
-    def set_silent_focus(self, value: bool) -> Self:
-        self.silent_focus = value
-        return self
-
-    def set_pressed_relief(self, relief: int = 0) -> Self:
+    def set_pressed_relief(self, relief: int) -> Self:
         if relief == self.pressed_relief:
             return self
         self.pressed_relief = relief
         self.dirty_shape = True
         if self.is_pressed:
             self.set_relief(relief)
+        return self
 
+    def set_silent_focus(self, value: bool) -> Self:
+        self.silent_focus = value
         return self
 
     def set_click_down_sound(self, sound_name: str) -> Self:
@@ -141,15 +140,16 @@ class ClickableWidget(Shape, InteractiveWidget):
             if not self.get_focus():
                 return
             self.is_pressed = True
-            bf.AudioManager().play_sound(self.click_down_sound)
-
+            if self.click_down_sound:
+                bf.AudioManager().play_sound(self.click_down_sound)
             pygame.mouse.set_cursor(self.click_cursor)
             self.set_relief(self.pressed_relief)
 
     def do_on_click_up(self, button) -> None:
         if self.enabled and button == 1 and self.is_pressed:
             self.is_pressed = False
-            bf.AudioManager().play_sound(self.click_up_sound)
+            if self.click_up_sound:
+                bf.AudioManager().play_sound(self.click_up_sound)
             self.set_relief(self.unpressed_relief)
             self.click()
 
@@ -217,3 +217,4 @@ class ClickableWidget(Shape, InteractiveWidget):
             self._paint_disabled()
         elif self.is_hovered:
             self._paint_hovered()
+