batframework 1.0.9a10__py3-none-any.whl → 1.0.10__py3-none-any.whl

batFramework/gui/textInput.py

@@ -1,306 +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.2, self._cursor_toggle, loop=-1).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"
-
-    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 False
-        self.get_focus()
-        return True
-
-    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 get_debug_outlines(self):
-        yield from super().get_debug_outlines()
-        if self.visible:
-            # offset = self._get_outline_offset() if self.show_text_outline else (0,0)
-            # yield (self.text_rect.move(self.rect.x - offset[0] - self.scroll.x,self.rect.y - offset[1] - self.scroll.y), "purple")
-            yield (self.get_cursor_rect().move(-self.scroll+self.rect.topleft),"green")
-
-
-    def get_min_required_size(self) -> tuple[float, float]:
-        size = self._get_text_rect_required_size()
-        return self.expand_rect_with_padding(
-            (0, 0,size[0]+self.get_cursor_rect().w,size[1])
-        ).size
-
-
-    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.show_cursor = True
-        self.cursor_position = (x,y)
-        self.apply_post_updates(skip_draw=True)
-        offset = self._get_outline_offset() if self.show_text_outline else (0,0)
-        padded = self.get_inner_rect().move(-self.rect.x + offset[0], -self.rect.y + offset[1])
-        self.align_text(self.text_rect,padded,self.alignment)
-        return self
-
-    def get_cursor_rect(self)->pygame.FRect:
-        if not self.font_object:
-            return pygame.FRect(0,0,0,0)
-
-        lines = self.text.split('\n')
-        line_x, line_y = self.cursor_position
-
-        height = self.font_object.get_linesize()
-
-        cursor_y = self.get_inner_rect().__getattribute__(self.alignment.value)[1] - self.rect.top
-        cursor_y += line_y * height
-        cursor_x = self.text_rect.x
-        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, 1, height-1)
-        offset = self._get_outline_offset()
-        cursor_rect.move_ip(offset[0] if self.cursor_position[0] >0 else 0,offset[1] if self.cursor_position[1] > 0 else 0)
-        return cursor_rect
-
-    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 or event.type not in [pygame.TEXTINPUT, pygame.KEYDOWN]:
-            return
-
-        text = self.get_text()
-        current_pos = self.cursor_to_absolute(self.cursor_position)
-        pressed = pygame.key.get_pressed()
-
-        if event.type == pygame.TEXTINPUT:
-            # Insert text at the current cursor position
-            self.set_text(f"{text[:current_pos]}{event.text}{text[current_pos:]}")
-            self.set_cursor_position(self.absolute_to_cursor(current_pos + len(event.text)))
-        elif event.type == pygame.KEYDOWN:
-            match event.key:
-                case pygame.K_ESCAPE:
-                    self.lose_focus()
-
-                case pygame.K_BACKSPACE if current_pos > 0:
-                    # Remove the character before the cursor
-                    delta = current_pos-1
-                    if pressed[pygame.K_LCTRL] or pressed[pygame.K_RCTRL]:
-                        delta = find_prev_word(self.text,current_pos-1)
-                        if delta <0: delta = 0
-                        
-                    self.set_text(f"{text[:delta]}{text[current_pos:]}")
-                    self.set_cursor_position(self.absolute_to_cursor(delta))
-                    self._cursor_toggle(True)
-
-                case pygame.K_DELETE if current_pos < len(text):
-                    # Remove the character at the cursor
-                    self.set_text(f"{text[:current_pos]}{text[current_pos + 1:]}")
-                    self._cursor_toggle(True)
-
-                case pygame.K_RIGHT:
-                    if current_pos < len(text):
-                        self.handle_cursor_movement(pressed, current_pos, direction="right")
-                    self._cursor_toggle(True)
-                    
-                case pygame.K_LEFT:
-                    if current_pos > 0:
-                        self.handle_cursor_movement(pressed, current_pos, direction="left")
-                    self._cursor_toggle(True)
-
-                case pygame.K_UP:
-                    # Move cursor up one line
-                    self.set_cursor_position((self.cursor_position[0], self.cursor_position[1] - 1))
-                    self._cursor_toggle(True)
-
-                case pygame.K_DOWN:
-                    # Move cursor down one line
-                    self.set_cursor_position((self.cursor_position[0], self.cursor_position[1] + 1))
-                    self._cursor_toggle(True)
-
-                case pygame.K_RETURN:
-                    # Insert a newline at the current cursor position
-                    self.set_text(f"{text[:current_pos]}\n{text[current_pos:]}")
-                    self.set_cursor_position(self.absolute_to_cursor(current_pos + 1))
-                    self._cursor_toggle(True)
-                case _ :
-                    if event.unicode:
-                        event.consumed = True
-                    return
-
-        event.consumed = True
-
-    def handle_cursor_movement(self, pressed, current_pos, direction):
-        if direction == "right":
-            if pressed[pygame.K_LCTRL] or pressed[pygame.K_RCTRL]:
-                next_word_pos = find_next_word(self.text, current_pos)
-                self.set_cursor_position(self.absolute_to_cursor(next_word_pos if next_word_pos != -1 else current_pos + 1))
-            else:
-                self.set_cursor_position(self.absolute_to_cursor(current_pos + 1))
-        elif direction == "left":
-            if pressed[pygame.K_LCTRL] or pressed[pygame.K_RCTRL]:
-                prev_word_pos = find_prev_word(self.text, current_pos - 1)
-                self.set_cursor_position(self.absolute_to_cursor(prev_word_pos if prev_word_pos != -1 else current_pos - 1))
-            else:
-                self.set_cursor_position(self.absolute_to_cursor(current_pos - 1))
-
-
-    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
-        cursor_rect = self.get_cursor_rect()
-        cursor_rect.move_ip(-self.scroll)
-        
-        if self.show_text_outline:
-            pygame.draw.rect(self.surface, self.text_outline_color, cursor_rect.inflate(2,2))
-        pygame.draw.rect(self.surface, self.text_color, cursor_rect)
-
-    def paint(self) -> None:
-        super().paint()
-        self._paint_cursor()
-
-    def align_text(
-        self, text_rect: pygame.FRect, area: pygame.FRect, alignment: bf.alignment
-    ):
-        cursor_rect = self.get_cursor_rect()
-        
-        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)
-
-        
-        # if cursor_rect.right > area.right+self.scroll.x:
-        #     self.scroll.x=cursor_rect.right - area.right
-        # elif cursor_rect.x < self.scroll.x+area.left:
-        #     self.scroll.x= cursor_rect.left - area.left
-        # self.scroll.x = max(self.scroll.x,0)
-
-        if cursor_rect.bottom > self.scroll.y + area.bottom:
-            self.scroll.y = cursor_rect.bottom - area.bottom
-        elif cursor_rect.y < self.scroll.y + area.top:
-            self.scroll.y = cursor_rect.top - area.top
-        self.scroll.y = max(self.scroll.y, 0)

batFramework/gui/tooltip.py

@@ -1,30 +0,0 @@
-from .label import Label
-import batFramework as bf
-import sys
-
-class ToolTip(Label):
-    def __init__(self, text = ""):
-        super().__init__(text)
-        self.fade_in_duration : float = 0.1
-        self.fade_out_duration : float = 0.1
-        self.set_render_order(sys.maxsize)
-    
-    def __str__(self):
-        return f"ToolTip('{self.text}')"
-
-    def top_at(self, x, y):
-        return None
-
-    def fade_in(self):
-        self.set_visible(True)
-        bf.PropertyEaser(
-            self.fade_in_duration,bf.easing.EASE_OUT,
-            0,self.parent_scene.name
-        ).add_custom(self.get_alpha,self.set_alpha,255).start()
-
-    def fade_out(self):
-        bf.PropertyEaser(
-            self.fade_out_duration,bf.easing.EASE_IN,
-            0,self.parent_scene.name,
-            lambda : self.set_visible(False)
-        ).add_custom(self.get_alpha,self.set_alpha,0).start()

batFramework/particle.py

@@ -1,118 +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.Drawable):
-    def __init__(self) -> None:
-        super().__init__((0, 0))
-        self.particles: list[Particle] = []
-        self.count = 0
-
-    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)
-        self.count += 1
-
-    def clear(self):
-        self.particles = []
-        self.count = 0
-    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)
-            self.count -= 1
-
-    def draw(self, camera) -> None:
-        camera.surface.fblits(
-            [(p.surface, camera.world_to_screen(p.rect)) for p in self.particles]
-        )

batFramework/propertyEaser.py

@@ -1,79 +0,0 @@
-from .easingController import EasingController
-import pygame
-from typing import Callable, Any, Self
-import batFramework as bf
-
-class PropertyEaser(EasingController):
-    class EasedProperty:
-        def __init__(self, getter: Callable[[], Any], setter: Callable[[Any], None], end_value: Any, start_value: Any = None):
-            self.getter = getter
-            self.setter = setter
-            self.start_value = start_value if start_value is not None else getter()
-            self.end_value = end_value
-
-        def interpolate(self, t: float):
-            a, b = self.start_value, self.end_value
-            if isinstance(a, (int, float)):
-                return a + (b - a) * t
-            elif isinstance(a, pygame.Vector2):
-                return a.lerp(b, t)
-            elif isinstance(a, pygame.Color):
-                return pygame.Color(
-                    round(a.r + (b.r - a.r) * t),
-                    round(a.g + (b.g - a.g) * t),
-                    round(a.b + (b.b - a.b) * t),
-                    round(a.a + (b.a - a.a) * t),
-                )
-            else:
-                raise TypeError(f"Unsupported type for interpolation: {type(a)}")
-
-        def apply(self, t: float):
-            self.setter(self.interpolate(t))
-
-    def __init__(
-        self,
-        duration: float = 1,
-        easing: bf.easing = bf.easing.LINEAR,
-        loop: int = 0,
-        register: str = "global",
-        end_callback: Callable[[], Any] = None,
-    ):
-        self.properties: list[PropertyEaser.EasedProperty] = []
-
-        def update_all(progress):
-            for prop in self.properties:
-                prop.apply(progress)
-
-        super().__init__(duration, easing, update_all, end_callback, loop, register)
-
-    def __str__(self):
-        return f"(PROP){super().__str__()}"
-
-    def add_attr(
-        self,
-        obj: Any,
-        attr: str,
-        end_value: Any,
-        start_value: Any = None,
-    )->Self:
-        self.properties.append(
-            PropertyEaser.EasedProperty(
-                getter=lambda o=obj, a=attr: getattr(o, a),
-                setter=lambda v, o=obj, a=attr: setattr(o, a, v),
-                end_value=end_value,
-                start_value=start_value,
-            )
-        )
-        return self
-
-    def add_custom(
-        self,
-        getter: Callable[[], Any],
-        setter: Callable[[Any], None],
-        end_value: Any,
-        start_value: Any = None,
-    )->Self:
-        self.properties.append(
-            PropertyEaser.EasedProperty(getter, setter, end_value, start_value)
-        )
-        return self

batFramework/renderGroup.py

@@ -1,34 +0,0 @@
-import batFramework as bf
-import pygame
-from typing import Callable, Iterator
-
-
-class RenderGroup(bf.Drawable):
-    def __init__(
-        self, entity_iterator: Callable[[], Iterator[bf.Drawable]], blit_flags: int = 0
-    ) -> None:
-        super().__init__()
-        self.entity_iterator = entity_iterator
-        self.blit_flags = blit_flags
-        self.set_debug_color("white")
-
-    def draw(self, camera: bf.Camera) -> None:
-        if not self.visible:
-            return
-
-        fblits_data = []
-        for e in self.entity_iterator():
-            if not getattr(e, "drawn_by_group", False):
-                # Set flag to skip their individual draw call
-                e.drawn_by_group = True
-
-            if e.visible and camera.rect.colliderect(e.rect):
-                fblits_data.append(
-                    (e.surface, (e.rect.x - camera.rect.x, e.rect.y - camera.rect.y))
-                )
-
-        camera.surface.fblits(fblits_data, self.blit_flags)
-
-    def get_debug_outlines(self):
-        for e in self.entity_iterator():
-            yield from e.get_debug_outlines()

batFramework/resourceManager.py

@@ -1,130 +0,0 @@
-import batFramework as bf
-import os
-import pygame
-import sys
-import json
-from typing import Any, Callable
-from .utils import Singleton
-import asyncio
-
-
-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 = "."
-        self.loading_thread = None
-
-    def load_resources(self, path: str, progress_callback: Callable[[float], Any] = None):
-        """
-        loads resources from a directory.
-        Progress is reported through the callback.
-        Supposed to be asynchronous but don't use it as such yet
-        """
-        self.progress_callback = progress_callback
-
-        total_files = sum(
-            len(files) for _, _, files in os.walk(path) if not any(f.startswith(".") for f in files)
-        )
-
-        loaded_files = 0
-
-        for root, dirs, files in os.walk(path):
-            files = [f for f in files if not f.startswith(".")]
-            dirs[:] = [d for d in dirs if not (d.startswith(".") or d.startswith("__"))]
-            for file in files:
-                file_path = os.path.join(root, file)
-
-                # Simulate resource loading
-                # await asyncio.sleep(0)  # Yield control to the event loop
-
-                if file.lower().endswith((".png", ".jpg", ".jpeg", ".gif")):
-                    self.load_image(file_path)
-                elif file.lower().endswith((".mp3", ".wav", ".ogg")):
-                    bf.AudioManager().load_sound(file.split(".")[0], file_path)
-                elif file.lower().endswith((".ttf", ".otf")):
-                    bf.FontManager().load_font(file_path, file.split(".")[0])
-
-                loaded_files += 1
-                # Report progress
-                # if self.progress_callback:
-                    # self.progress_callback(loaded_files / total_files)
-
-        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 set_sharedVars(self, variables: dict) -> bool:
-        """
-        Set multiple shared variables at once. This will be accessible (read/write) from any scene.
-        """
-        if not isinstance(variables, dict):
-            raise ValueError("Input must be a dictionary")
-        self.shared_variables.update(variables)
-        return True
-
-    def get_sharedVar(self, name, error_value=None):
-        """
-        Get a shared variable
-        """
-        return self.shared_variables.get(name, error_value)