batframework 1.0.8a7__py3-none-any.whl → 1.0.8a8__py3-none-any.whl

batFramework/gui/textInput.py

@@ -1,247 +0,0 @@
-import batFramework as bf
-from typing import Self, Callable
-from .label import Label
-from .interactiveWidget import InteractiveWidget
-import pygame
-
-def find_next_word(s: str, start_index: int) -> int:
-    length = len(s)
-    # Ensure the starting index is within the bounds of the string
-    if start_index < 0 or start_index >= length:
-        raise ValueError("Starting index is out of bounds")
-    index = start_index
-    # If the start_index is at a space, skip leading spaces
-    if s[index] in [' ','\n']:
-        while index < length and s[index]  in [' ','\n']:
-            index += 1
-        # If we've reached the end of the string
-        if index >= length:
-            return -1
-    else:
-        # If the start_index is within a word, move to the end of that word
-        while index < length and s[index] not in [' ','\n']:
-            index += 1
-        if index == length:
-            return index    
-    # Return the index of the start of the next word or -1 if no more words are found
-    return index if index < length else -1
-
-def find_prev_word(s: str, start_index: int) -> int:
-    if start_index <= 0 : return 0
-    length = len(s)
-    
-    # Ensure the starting index is within the bounds of the string
-    if start_index < 0 or start_index >= length:
-        raise ValueError("Starting index is out of bounds")
-    
-    index = start_index
-    
-    # If the start_index is at a space, skip trailing spaces
-    if s[index] in [' ', '\n']:
-        while index > 0 and s[index-1] in [' ', '\n']:
-            index -= 1
-        # If we've reached the beginning of the string
-        if index <= 0:
-            return 0 if s[0] not in [' ', '\n'] else -1
-    else:
-        # If the start_index is within a word, move to the start of that word
-        while index > 0 and s[index-1] not in [' ', '\n']:
-            index -= 1
-        if index == 0 and s[index] not in [' ', '\n']:
-            return 0
-    
-    # Return the index of the start of the previous word or -1 if no more words are found
-    return index if index > 0 or (index == 0 and s[0] not in [' ', '\n']) else -1
-
-
-class TextInput(Label, InteractiveWidget):
-    def __init__(self) -> None:
-        self.cursor_position = (0, 0)
-        self.old_key_repeat = (0, 0)
-        self.cursor_timer = bf.Timer(0.3, self._cursor_toggle, loop=True).start()
-        self.cursor_timer.pause()
-        self.show_cursor = False
-        self.on_modify: Callable[[str], str] = None
-        self.set_focusable(True)
-        self.set_outline_color("black")
-        super().__init__("")
-        self.alignment = bf.alignment.TOPLEFT
-
-    def set_modify_callback(self, callback: Callable[[str], str]) -> Self:
-        self.on_modify = callback
-        return self
-
-    def __str__(self) -> str:
-        return f"TextInput({repr(self.text)})"
-
-    def _cursor_toggle(self, value: bool | None = None):
-        if value is None:
-            value = not self.show_cursor
-        self.show_cursor = value
-        self.dirty_surface = True
-
-    def do_on_click_down(self, button):
-        if button != 1:
-            return
-        self.get_focus()
-
-    def do_on_enter(self):
-        pygame.mouse.set_cursor(pygame.SYSTEM_CURSOR_IBEAM)
-
-    def do_on_exit(self):
-        pygame.mouse.set_cursor(bf.const.DEFAULT_CURSOR)
-
-    def do_on_get_focus(self):
-        self.cursor_timer.resume()
-        self._cursor_toggle(True)
-        self.old_key_repeat = pygame.key.get_repeat()
-        pygame.key.set_repeat(200, 50)
-
-    def do_on_lose_focus(self):
-        self.cursor_timer.pause()
-        self._cursor_toggle(False)
-        pygame.key.set_repeat(*self.old_key_repeat)
-
-    def get_line(self, line: int) -> str | None:
-        if line < 0:
-            return None
-        lines = self.text.split('\n')
-        if line >= len(lines):
-            return None
-        return lines[line]
-
-    def set_cursor_position(self, position: tuple[int, int]) -> Self:
-        x, y = position
-
-        lines = self.text.split('\n')
-        y = max(0, min(y, len(lines) - 1))
-        line_length = len(lines[y])
-        x = max(0, min(x, line_length))
-
-        self.cursor_position = (x, y)
-        self.show_cursor = True
-        self.dirty_shape = True
-        return self
-
-    def cursor_to_absolute(self, position: tuple[int, int]) -> int:
-        x, y = position
-
-        y = max(0, min(y, len(self.text.split('\n')) - 1))
-        lines = self.text.split('\n')
-        x = max(0, min(x, len(lines[y])))
-
-        absolute_position = sum(len(line) + 1 for line in lines[:y]) + x
-        return absolute_position
-
-    def absolute_to_cursor(self, absolute: int) -> tuple[int, int]:
-        text = self.text
-        lines = text.split('\n')
-        current_pos = 0
-
-        for line_no, line in enumerate(lines):
-            if absolute <= current_pos + len(line):
-                return (absolute - current_pos, line_no)
-            current_pos += len(line) + 1
-
-        return (len(lines[-1]), len(lines) - 1)
-
-    def do_handle_event(self, event):
-        if not self.is_focused:
-            return
-
-        if event.type not in [pygame.TEXTINPUT, pygame.KEYDOWN]:
-            return
-
-        text = self.get_text()
-        current = self.cursor_to_absolute(self.cursor_position)
-        if event.type == pygame.TEXTINPUT:
-            self.set_text(text[:current] + event.text + text[current:])
-            self.set_cursor_position(self.absolute_to_cursor(current + len(event.text)))
-        elif event.type == pygame.KEYDOWN:
-            pressed = pygame.key.get_pressed()
-            if event.key == pygame.K_ESCAPE:
-                self.lose_focus()
-            elif event.key == pygame.K_BACKSPACE:
-                if current > 0:
-                    self.set_text(text[:current - 1] + text[current:])
-                    self.set_cursor_position(self.absolute_to_cursor(current - 1))
-            elif event.key == pygame.K_DELETE:
-                if current < len(text):
-                    self.set_text(text[:current] + text[current + 1:])
-            elif event.key == pygame.K_RIGHT:
-                if self.cursor_to_absolute(self.cursor_position)>=len(self.text):
-                    return
-                if self.cursor_position[0] == len(self.get_line(self.cursor_position[1])):
-                    self.set_cursor_position((0, self.cursor_position[1] + 1))
-                else:
-                    if pressed[pygame.K_LCTRL] or pressed[pygame.K_RCTRL]:
-                        index = find_next_word(self.text,current)
-                        if index ==-1 : index = current+1
-                        self.set_cursor_position(self.absolute_to_cursor(index))
-                    else:
-                        self.set_cursor_position(self.absolute_to_cursor(current + 1))
-            elif event.key == pygame.K_LEFT:
-
-
-                if self.cursor_position[0] == 0 and self.cursor_position[1] > 0:
-                    self.set_cursor_position((len(self.get_line(self.cursor_position[1] - 1)), self.cursor_position[1] - 1))
-                else:
-                    if pressed[pygame.K_LCTRL] or pressed[pygame.K_RCTRL]:
-                        index = find_prev_word(self.text,current-1)
-                        if index ==-1 : index = current-1
-                        self.set_cursor_position(self.absolute_to_cursor(index))
-                    else:
-                        self.set_cursor_position(self.absolute_to_cursor(current - 1))
-            elif event.key == pygame.K_UP:
-                x, y = self.cursor_position
-                self.set_cursor_position((x, y - 1))
-            elif event.key == pygame.K_DOWN:
-                x, y = self.cursor_position
-                self.set_cursor_position((x, y + 1))
-            elif event.key == pygame.K_RETURN:
-                self.set_text(text[:current] + '\n' + text[current:])
-                self.set_cursor_position(self.absolute_to_cursor(current + 1))
-            else:
-                return
-        else:
-            return
-
-        event.consumed = True
-
-    def set_text(self, text: str) -> Self:
-        if self.on_modify:
-            text = self.on_modify(text)
-        return super().set_text(text)
-
-    def _paint_cursor(self) -> None:
-        if not self.font_object or not self.show_cursor:
-            return
-
-        lines = self.text.split('\n')
-        line_x, line_y = self.cursor_position
-
-        cursor_y = self.padding[1] 
-        cursor_y += line_y * self.font_object.get_linesize()
-        cursor_x = self.padding[0]
-        cursor_x += self.font_object.size(lines[line_y][:line_x])[0] if line_x > 0 else 0
-
-        cursor_rect = pygame.Rect(cursor_x, cursor_y, 2, self.font_object.get_height())
-        pygame.draw.rect(self.surface, self.text_color, cursor_rect)
-
-    def paint(self) -> None:
-        super().paint()
-        self._paint_cursor()
-
-    # def set_alignment(self, alignment: bf.alignment) -> Self:
-    #     return self
-
-    # def align_text(
-    #     self, text_rect: pygame.FRect, area: pygame.FRect, alignment: bf.alignment
-    # ):
-    #     if alignment == bf.alignment.LEFT:
-    #         alignment = bf.alignment.MIDLEFT
-    #     elif alignment == bf.alignment.MIDRIGHT:
-    #         alignment = bf.alignment.MIDRIGHT
-    #     pos = area.__getattribute__(alignment.value)
-    #     text_rect.__setattr__(alignment.value, pos)
-    #     return

batFramework/object.py

@@ -1,123 +0,0 @@
-from typing import Any, Self
-import pygame
-import batFramework as bf
-from typing import TYPE_CHECKING
-
-if TYPE_CHECKING:
-    from .camera import Camera
-
-
-class Object:
-    __count = 0
-    __available_uid = set()
-    __used_uid = set()
-
-    def __init__(self) -> None:
-        self.rect = pygame.FRect(0, 0, 0, 0)
-        self.tags: list[str] = []
-        self.parent_scene: bf.Scene | None = None
-        self.debug_color: tuple | str = "red"
-        self.render_order: int = 0
-        self.uid: int = Object.__count
-        Object.__used_uid.add(self.uid)
-
-        if Object.__available_uid:
-            self.name = Object.__available_uid.pop()
-        else:
-            self.name = Object.__count
-            Object.__count += 1
-
-    def __del__(self):
-        Object.__available_uid.add(self.uid)
-
-    def set_position(self, x, y) -> Self:
-        self.rect.topleft = x, y
-        return self
-
-    def set_center(self, x, y) -> Self:
-        self.rect.center = x, y
-        return self
-
-    def get_debug_outlines(self):
-        yield (self.rect, self.debug_color)
-
-    def set_debug_color(self, color) -> Self:
-        self.debug_color = color
-        return self
-
-    def set_parent_scene(self, scene) -> Self:
-        if scene == self.parent_scene:
-            return self
-        if self.parent_scene is not None:
-            self.do_when_removed()
-        self.parent_scene = scene
-        if scene is not None:
-            self.do_when_added()
-        return self
-
-    def do_when_added(self):
-        pass
-
-    def do_when_removed(self):
-        pass
-
-    def set_uid(self, uid: int) -> Self:
-        if uid in Object.__used_uid:
-            print(f"set_uid error : UID '{uid}' is already in use")
-            return self
-        self.uid = uid
-        Object.__used_uid.add(uid)
-        return self
-
-    def add_tags(self, *tags) -> Self:
-        for tag in tags:
-            if tag not in self.tags:
-                self.tags.append(tag)
-        self.tags.sort()
-        return self
-
-    def remove_tags(self, *tags):
-        self.tags = [tag for tag in self.tags if tag not in tags]
-
-    def has_tags(self, *tags) -> bool:
-        return all(tag in self.tags for tag in tags)
-
-    def get_tags(self) -> list[str]:
-        return self.tags
-
-    def process_event(self, event: pygame.Event) -> bool:
-        """
-        Returns bool : True if the method is blocking (no propagation to next object of the scene)
-        """
-        if event.consumed:
-            return
-        self.do_process_actions(event)
-        self.do_handle_event(event)
-
-    def do_process_actions(self, event: pygame.Event) -> None:
-        """
-        Process entity actions you may have set
-        """
-
-    def do_reset_actions(self) -> None:
-        """
-        Reset entity actions you may have set
-        """
-
-    def do_handle_event(self, event: pygame.Event):
-        """
-        Handle specific events with no action support
-        """
-        return False
-
-    def update(self, dt: float) -> None:
-        """
-        Update method to be overriden by subclasses of object (must call do_update and do_reset_actions)
-        """
-        self.do_update(dt)
-        self.do_reset_actions()
-
-    def do_update(self, dt: float) -> None:
-        """
-        Update method to be overriden for specific behavior by the end user
-        """

batFramework/particle.py

@@ -1,115 +0,0 @@
-import batFramework as bf
-import pygame
-from pygame.math import Vector2
-
-
-class Particle:
-    def __init__(self, *args, **kwargs):
-        self.dead = False
-        self.surface = None
-        self.generator = None
-
-    def do_when_added(self):
-        pass
-
-    def update(self, dt):
-        pass
-
-    def kill(self):
-        self.dead = True
-
-    def update_surface(self):
-        pass
-
-
-class TimedParticle(Particle):
-    def __init__(self, duration):
-        super().__init__()
-        self.duration = duration
-
-    def do_when_added(self):
-        if self.generator and self.generator.parent_scene:
-            self.timer = bf.SceneTimer(
-                self.duration, end_callback=self.kill,
-                scene_name=self.generator.parent_scene.name).start()        
-        else:
-            self.timer = bf.Timer(self.duration, end_callback=self.kill).start()
-
-
-class BasicParticle(TimedParticle):
-    def __init__(
-        self,
-        start_pos: tuple[float, float],
-        start_vel: tuple[float, float],
-        duration=1,
-        color=None,
-        size: tuple[int, int] = (4, 4),
-        *args,
-        **kwargs,
-    ):
-        super().__init__(duration)
-        self.rect = pygame.FRect(0,0, *size)
-        self.rect.center = start_pos
-        self.surface = pygame.Surface(size)
-        self.velocity = Vector2(start_vel)
-        if color:
-            self.surface.fill(color)
-        self.start()
-
-    def start(self):
-        pass
-
-    def update(self, dt):
-        super().update(dt)
-        self.rect.center += self.velocity * dt
-        self.update_surface()
-
-    def update_surface(self):
-        self.surface.set_alpha(255 - int(self.timer.get_progression() * 255))
-
-
-class DirectionalParticle(BasicParticle):
-    def start(self):
-        self.original_surface = self.surface.copy()
-
-    def update_surface(self):
-        angle = self.velocity.angle_to(Vector2(1, 0))
-        self.surface = pygame.transform.rotate(self.original_surface, angle)
-        super().update_surface()
-
-
-class ParticleGenerator(bf.Entity):
-    def __init__(self) -> None:
-        super().__init__((0, 0))
-        self.particles: list[Particle] = []
-
-    def get_debug_outlines(self):
-        return
-        for particle in self.particles:
-            yield (
-                particle.rect.move(particle.rect.w // 2, particle.rect.h // 2),
-                "blue",
-            )
-        yield (self.rect, "cyan")
-
-    def add_particle(self, particle:Particle):
-        particle.generator = self
-        particle.do_when_added()
-        self.particles.append(particle)
-
-    def clear(self):
-        self.particles = []
-
-    def update(self, dt: float):
-        particles_to_remove = []
-        for particle in self.particles:
-            particle.update(dt)
-            if particle.dead:
-                particles_to_remove.append(particle)
-        for p in particles_to_remove:
-            self.particles.remove(p)
-
-    def draw(self, camera) -> None:
-        camera.surface.fblits(
-            [(p.surface, camera.world_to_screen(p.rect)) for p in self.particles]
-        )

batFramework/renderGroup.py

@@ -1,67 +0,0 @@
-import batFramework as bf
-import pygame
-from typing import Self, Iterator, Callable
-
-"""
-+ same render order
-+ fblits
-"""
-
-
-class RenderGroup(bf.Entity):
-    def __init__(
-        self, entity_iterator: Callable[[], Iterator[bf.Entity]], blit_flags: int = 0
-    ) -> None:
-        super().__init__()
-        self.entity_iterator = entity_iterator
-        self.set_blit_flags(blit_flags)
-        self.set_debug_color("white")
-
-    def get_debug_outlines(self):
-        # yield (self.rect, self.debug_color)
-        for e in self.entity_iterator():
-            yield from e.get_debug_outlines()
-
-    def set_parent_scene(self, scene) -> Self:
-        self.parent_scene = scene
-        for e in self.entity_iterator():
-            e.set_parent_scene(scene)
-        return self
-
-    def process_event(self, event: pygame.Event) -> bool:
-        """
-        Returns bool : True if the method is blocking (no propagation to next children of the scene)
-        """
-        self.do_process_actions(event)
-        res = self.do_handle_event(event)
-        if res:
-            return res
-        for e in self.entity_iterator():
-            if e.process_event(event):
-                return True
-        return False
-
-    def update(self, dt: float) -> None:
-        """
-        Update method to be overriden by subclasses of entity
-        """
-        for e in self.entity_iterator():
-            e.update(dt)
-        # gen = self.entity_iterator()
-        # self.rect = next(gen).rect.unionall([e.rect for e in gen])
-
-        self.do_update(dt)
-        self.do_reset_actions()
-
-    def draw(self, camera: bf.Camera) -> None:
-        """
-        Draw the entity onto the camera with coordinate transposing
-        """
-        if not self.visible:
-            return
-        fblits_data = (
-            (e.surface, (e.rect.x - camera.rect.x, e.rect.y - camera.rect.y))
-            for e in self.entity_iterator()
-            if camera.rect.colliderect(e.rect)
-        )
-        camera.surface.fblits(fblits_data, self.blit_flags)

batFramework/resourceManager.py

@@ -1,100 +0,0 @@
-import batFramework as bf
-import os
-import pygame
-import sys
-import json
-from typing import Any
-from .utils import Singleton
-
-if getattr(sys, "frozen", False):
-    # If the application is run as a bundle, the PyInstaller bootloader
-    # extends the sys module by a flag frozen=True and sets the app
-    # path into variable _MEIPASS'.
-    application_path = sys._MEIPASS
-else:
-    application_path = os.getcwd()
-
-
-class ResourceManager(metaclass=Singleton):
-    def __init__(self):
-        self.shared_variables: dict[str,Any] = {}
-        self.convert_image_cache = {}
-        self.convert_alpha_image_cache = {}
-        self.sound_cache = {}
-        self.RESOURCE_PATH = "."
-
-    def load_dir(self, path) -> None:
-        for root, dirs, files in os.walk(path):
-            files = [f for f in files if not f[0] == "."]
-            dirs[:] = [d for d in dirs if not d[0] == "."]
-
-            for file in files:
-                file_path = os.path.join(root, file)
-                if file.lower().endswith((".png", ".jpg", ".jpeg", ".gif")):
-                    self.load_image(file_path)
-                    # print(f"Loaded image : '{file_path}'")
-
-                elif file.lower().endswith((".mp3", ".wav")):
-                    bf.AudioManager().load_sound(file.split(".")[0], file_path)
-                    # print(f"Loaded sound : '{file_path}'")
-
-                elif file.lower().endswith((".ttf", ".otf")):
-                    bf.FontManager().load_font(file_path, file.split(".")[0])
-                    # print(f"Loaded font : '{file_path}'")
-
-        print(f"Loaded resources in directory : '{path}'")
-
-    def set_resource_path(self, path: str):
-        self.RESOURCE_PATH = os.path.join(application_path, path)
-        print(f"Resource path : '{self.RESOURCE_PATH}'")
-
-    def get_path(self, path: str) -> str:
-        # Normalize path separators
-        normalized_path = path.replace("/", os.sep).replace("\\", os.sep)
-        return os.path.join(self.RESOURCE_PATH, normalized_path)
-
-    def load_image(self, path) -> None:
-        key = self.get_path(path)
-        if key in self.convert_image_cache:
-            return
-        self.convert_image_cache[key] = pygame.image.load(path).convert()
-        self.convert_alpha_image_cache[key] = pygame.image.load(path).convert_alpha()
-
-    def get_image(self, path, convert_alpha: bool = False) -> pygame.Surface | None:
-        key = self.get_path(path)
-        return (
-            self.convert_alpha_image_cache.get(key, None)
-            if convert_alpha
-            else self.convert_image_cache.get(key, None)
-        )
-
-    def load_json_from_file(self, path: str) -> dict | None:
-        try:
-            with open(self.get_path(path), "r") as file:
-                data = json.load(file)
-            return data
-        except FileNotFoundError:
-            print(f"File '{path}' not found")
-            return None
-
-    def save_json_to_file(self, path: str, data) -> bool:
-        try:
-            with open(self.get_path(path), "w") as file:
-                json.dump(data, file, indent=2)
-            return True
-        except FileNotFoundError:
-            return False
-
-
-    def set_sharedVar(self, name, value) -> bool:
-        """
-        Set a shared variable of any type. This will be accessible (read/write) from any scene
-        """
-        self.shared_variables[name] = value
-        return True
-
-    def get_sharedVar(self, name, error_value=None):
-        """
-        Get a shared variable
-        """
-        return self.shared_variables.get(name, error_value)