batframework 1.0.8a1__py3-none-any.whl → 1.0.8a2__py3-none-any.whl

batFramework/gui/slider.py

@@ -1,220 +0,0 @@
-import batFramework as bf
-from .meter import Meter
-from .button import Button
-from .indicator import *
-from .meter import Meter
-from .shape import Shape
-from .interactiveWidget import InteractiveWidget
-
-class SliderHandle(Indicator, DraggableWidget):
-
-    def __str__(self) -> str:
-        return "SliderHandle"
-
-    def on_click_down(self, button: int) -> None:
-        super().on_click_down(button)
-        if button == 1:
-            self.parent.get_focus()
-
-    def on_exit(self) -> None:
-        self.is_hovered = False
-        self.do_on_exit()
-
-    def do_on_drag(self,drag_start:tuple[float,float],drag_end: tuple[float,float]) -> None:
-        super().do_on_drag(drag_start,drag_end)
-        m : Meter = self.parent.meter
-        r = m.get_padded_rect()
-        position = self.rect.centerx
-        self.rect.clamp_ip(r)
-        # Adjust handle position to value
-        new_value = self.parent.position_to_value(position)
-        self.parent.set_value(new_value)
-        self.rect.centerx = self.parent.value_to_position(new_value)
-
-    def top_at(self, x, y):
-        return Widget.top_at(self, x, y)
-
-
-class SliderMeter(Meter,InteractiveWidget):
-
-    def __str__(self) -> str:
-        return "SliderMeter"
-
-    def on_click_down(self,button:int)->None:
-        if button == 1 : 
-            self.parent.get_focus()
-            r = self.get_root()
-            if r:
-                pos = r.drawing_camera.screen_to_world(pygame.mouse.get_pos())[0]
-                self.parent.set_value(self.parent.position_to_value(pos))
-
-        self.do_on_click_down(button)
-
-class Slider(Button):
-    def __init__(self, text: str, default_value: float = 1.0) -> None:
-        super().__init__(text, None)
-        self.gap: float | int = 0
-        self.spacing :bf.spacing = bf.spacing.MANUAL 
-        self.modified_callback = None
-        self.meter: SliderMeter = SliderMeter()
-        self.handle =  SliderHandle().set_color(bf.color.CLOUD)
-        self.add(self.meter,self.handle)
-        self.meter.set_debug_color(bf.color.RED)
-        self.set_value(default_value,True)
-        # print(self.handle.rect)
-        # self.handle.set_visible(False)
-        
-    def __str__(self) -> str:
-        return "Slider"
-
-    def set_gap(self, value: int | float) -> Self:
-        value = max(0, value)
-        self.gap = value
-        return self
-
-    def get_min_required_size(self) -> tuple[float, float]:
-        gap = self.gap if self.text else 0
-        if not self.text_rect:
-            params = {
-                "font_name": self.font_object.name,
-                "text": self.text,
-                "antialias": False,
-                "color": "white",
-                "bgcolor": "black",  # if (self.has_alpha_color() or self.draw_mode == bf.drawMode.TEXTURED) else self.color,
-                "wraplength": int(self.get_padded_width()) if self.auto_wraplength else 0,
-            }
-            self.text_rect.size = self._render_font(params).get_size()
-        w,h = self.text_rect.size
-        return self.inflate_rect_by_padding((0, 0,w + gap + self.meter.rect.w,h)).size
-
-    def set_spacing(self,spacing:bf.spacing)->Self:
-        if spacing == self.spacing : return self
-        self.spacing = spacing
-        self.dirty_shape = True
-        return self
-
-    def set_modify_callback(self, callback) -> Self:
-        self.modified_callback = callback
-        return self
-
-    def set_range(self, range_min: float, range_max: float) -> Self:
-        self.meter.set_range(range_min, range_max)
-        return self
-
-    def set_step(self, step: float) -> Self:
-        self.meter.set_step(step)
-        return self
-
-    def set_value(self, value, no_callback: bool = False) -> Self:
-        if self.meter.value != value :
-            self.meter.set_value(value)
-            self.dirty_shape = True
-        if self.modified_callback and (not no_callback):
-            self.modified_callback(self.meter.value)
-        return self
-    
-    def get_value(self)->float:
-        return self.meter.get_value()
-
-    def do_on_key_down(self, key):
-        if key == pygame.K_RIGHT:
-            self.set_value(self.meter.get_value() + self.meter.step)
-            bf.AudioManager().play_sound(self.click_down_sound)
-        elif key == pygame.K_LEFT:
-            self.set_value(self.meter.get_value() - self.meter.step)
-            bf.AudioManager().play_sound(self.click_down_sound)
-            
-    def do_on_click_down(self, button) -> None:
-        if button == 1 : self.get_focus()
-
-    def value_to_position(self, value: float) -> float:
-        """
-        Converts a value to a position on the meter, considering the step size.
-        """
-        rect = self.meter.get_padded_rect()
-        value_range = self.meter.get_range()
-        value = round(value / self.meter.step) * self.meter.step
-        position_ratio = (value - self.meter.min_value) / value_range
-        # print(self.handle.rect)
-        # print(rect.left + (self.handle.rect.w/2) + position_ratio * (rect.width - self.handle.rect.w),self.handle.rect.w,self.rect.right)
-        return rect.left + (self.handle.rect.w/2) + position_ratio * (rect.width - self.handle.rect.w)
-
-    def position_to_value(self, position: float) -> float:
-        """
-        Converts a position on the meter to a value, considering the step size.
-        """
-        handle_half = self.handle.rect.w/2
-        rect = self.meter.get_padded_rect()
-        position = max(rect.left + handle_half, min(position, rect.right - handle_half))
-
-        position_ratio = (position - rect.left - handle_half) / (rect.width - self.handle.rect.w)
-        value_range = self.meter.get_range()
-        value = self.meter.min_value + position_ratio * value_range
-        return round(value / self.meter.step) * self.meter.step
-
-    def _build_layout(self) -> None:        
-
-        gap = self.gap if self.text else 0
-
-        params = {
-            "font_name": self.font_object.name,
-            "text": self.text,
-            "antialias": False,
-            "color": "white",
-            "bgcolor": "black",  # if (self.has_alpha_color() or self.draw_mode == bf.drawMode.TEXTURED) else self.color,
-            "wraplength": int(self.get_padded_width()) if self.auto_wraplength else 0,
-        }
-
-        self.text_rect.size = self._render_font(params).get_size()
-
-        meter_size = [self.text_rect.h * 10, self.font_object.point_size]
-        if not self.autoresize_w:
-            meter_size[0] =  self.get_padded_width() - self.text_rect.w - gap
-
-        tmp_rect = pygame.FRect(0,0,self.text_rect.w + gap + meter_size[0],self.text_rect.h)
-
-
-
-        if self.autoresize_h or self.autoresize_w: 
-            target_rect = self.inflate_rect_by_padding(tmp_rect)
-            if not self.autoresize_w : target_rect.w = self.rect.w
-            if not self.autoresize_h : target_rect.h = self.rect.h
-            if self.rect.size != target_rect.size:
-                self.set_size(target_rect.size)
-                self.build()
-                return
-
-        # ------------------------------------ size is ok
-        padded = self.get_padded_rect().move(-self.rect.x,-self.rect.y)
-
-        self.meter.set_size_if_autoresize(meter_size)
-        handle_size = 2*[self.meter.get_padded_height()]
-        
-        self.handle.set_size_if_autoresize(handle_size)
-
-        self.align_text(tmp_rect,padded,self.alignment)
-        self.text_rect.midleft = tmp_rect.midleft
-
-        if self.text : 
-            match self.spacing:
-                case bf.spacing.MAX:
-                    gap = padded.w - self.text_rect.w - self.meter.rect.w
-                case bf.spacing.MIN:
-                    gap = 0
-                case bf.spacing.HALF:
-                    gap = (padded.w)/2 - self.text_rect.w
-
-        # place meter 
-
-        self.meter.set_position(*self.text_rect.move(self.rect.x + gap,self.rect.y + (self.text_rect.h /2) - meter_size[1]/2).topright)
-        # place handle
-
-        # print(self.meter.rect.top - self.rect.top)
-        # print(self.meter.rect.h)
-        
-        x = self.value_to_position(self.meter.value)
-        r = self.meter.get_padded_rect()
-        self.handle.set_center(x,r.centery)
-
-        # self.handle.set_center(x,self.rect.top)
-

batFramework/gui/textInput.py

@@ -1,134 +0,0 @@
-import batFramework as bf
-from typing import Self,Callable
-from .label import Label
-from .interactiveWidget import InteractiveWidget
-import pygame
-
-
-class TextInput(Label, InteractiveWidget):
-    def __init__(self) -> None:
-        self.cursor_position = 0
-        self.old_key_repeat: tuple = (0, 0)
-        self.cursor_timer = bf.Timer(0.3, self._cursor_toggle, loop=True).start()
-        self.cursor_timer.pause()
-        self.show_cursor: bool = False
-        self.on_modify :Callable[[str],str] = None 
-        self.set_focusable(True)
-        self.set_outline_color("black")
-        super().__init__("")
-
-    def set_modify_callback(self,callback : Callable[[str],str])->Self:
-        self.on_modify = callback
-        return self
-
-    def to_string_id(self) -> str:
-        return f"TextInput({self.text})"
-
-    def _cursor_toggle(self,value:bool = 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.old_key_repeat = pygame.key.get_repeat()
-        self.cursor_timer.resume()
-        self._cursor_toggle(True)
-        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 set_cursor_position(self, position: int) -> Self:
-        if position < 0:
-            position = 0
-        elif position > len(self.get_text()):
-            position = len(self.get_text())
-        self.cursor_position = position
-        self.show_cursor = True
-        self.dirty_surface = True
-        if self.text_rect.w > self.get_padded_width():
-            self.dirty_shape = True
-        return self
-
-    def do_handle_event(self, event):
-        if not self.is_focused:
-            return
-        text = self.get_text()
-        cursor_position = self.cursor_position
-
-        if event.type == pygame.TEXTINPUT:
-            self.set_text(text[:cursor_position] + event.text + text[cursor_position:])
-            self.set_cursor_position(cursor_position + 1)
-        elif event.type == pygame.KEYDOWN:
-            if event.key == pygame.K_ESCAPE:
-                self.lose_focus()
-        
-            elif event.key == pygame.K_BACKSPACE:
-                if cursor_position > 0:
-                    self.set_text(text[:cursor_position - 1] + text[cursor_position:])
-                    self.set_cursor_position(cursor_position - 1)
-
-            elif event.key == pygame.K_RIGHT:
-                self.set_cursor_position(cursor_position + 1)
-
-            elif event.key == pygame.K_LEFT:
-                self.set_cursor_position(cursor_position - 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
-        partial_text_size = self.font_object.size(
-            self.get_text()[: self.cursor_position]
-        )
-        
-        cursor_rect = pygame.Rect(0, 0,1, self.font_object.point_size )
-        if self.cursor_position != 0:  # align left properly
-            cursor_rect.midleft = self.text_rect.move(partial_text_size[0], 0).midleft
-        else:
-            cursor_rect.midright = self.text_rect.midleft
-
-        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):
-        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)
-        w = self.font_object.size(
-            self.get_text()[: self.cursor_position]
-        )[0]
-        if self.text_rect.x + w > area.right:
-            self.text_rect.right = area.right
-        elif self.text_rect.x + w < area.left:
-            self.text_rect.left = area.left - w
-        

batFramework/object.py

@@ -1,115 +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:
-    __instance_count = 0
-
-    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.__instance_count
-        Object.__instance_count += 1
-
-    @staticmethod
-    def new_uid() -> int:
-        i = Object.__instance_count
-        Object.__instance_count += 1
-        return i
-
-    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:
-        self.uid = uid
-        return self
-
-    def get_uid(self) -> int:
-        return self.uid
-
-    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,101 +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
-
-    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.timer = bf.Timer(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(*start_pos, *size)
-        self.surface = pygame.Surface(size).convert()
-        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.surface = self.surface.convert_alpha()
-        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):
-        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):
-        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) -> bool:
-        camera.surface.fblits(
-            [(p.surface, camera.world_to_screen(p.rect).center) for p in self.particles]
-        )
-        return len(self.particles)

batFramework/renderGroup.py

@@ -1,62 +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)