crystalwindow 4.6__py3-none-any.whl → 4.7__py3-none-any.whl

crystalwindow/gui_ext.py

@@ -1,28 +1,20 @@
 import time
 from .window import Window
-from .assets import load_image
-from .sprites import Sprite
-from .gui import Button
-from .color_handler import Colors, Color
-
-def parse_color(c):
-    if isinstance(c, tuple):
-        return c
-    if isinstance(c, Color):
-        return c.to_tuple()
-    if isinstance(c, str):
-        if hasattr(Colors, c):
-            return getattr(Colors, c).to_tuple()
-        return (255,255,255)
-    return (255,255,255)
+
+
+# ============================================================
+#   T O G G L E  (behaves EXACTLY like old version)
+# ============================================================
 
 class Toggle:
-    def __init__(self, rect, value=False, color="gray", hover_color="white", cooldown=0.1):
+    def __init__(self, rect, value=False,
+                 color=(200, 200, 200), hover_color=(255, 255, 255),
+                 cooldown=0.1):
+
         self.rect = rect
         self.value = value
-
-        self.color = parse_color(color)
-        self.hover_color = parse_color(hover_color)
+        self.color = color
+        self.hover_color = hover_color
 
         self.hovered = False
         self.cooldown = cooldown
@@ -31,20 +23,22 @@ class Toggle:
     def update(self, win: Window):
         mx, my = win.mouse_pos
         x, y, w, h = self.rect
-        self.hovered = x <= mx <= x + w and y <= my <= y + h
 
-        now = time.time()
-        can_toggle = now - self._last_toggle >= self.cooldown
+        # hover check
+        self.hovered = (x <= mx <= x + w and y <= my <= y + h)
 
-        if self.hovered and win.mouse_pressed(1) and can_toggle:
-            self.value = not self.value
-            self._last_toggle = now
+        # cooldown logic (same as old ver)
+        now = time.time()
+        if self.hovered and win.mouse_pressed(1):
+            if now - self._last_toggle >= self.cooldown:
+                self.value = not self.value
+                self._last_toggle = now
 
     def draw(self, win: Window):
         draw_color = self.hover_color if self.hovered else self.color
         win.draw_rect(draw_color, self.rect)
 
-        # ON glow
+        # ON glow (same as old ver)
         if self.value:
             inner = (
                 self.rect[0] + 4,
@@ -55,44 +49,62 @@ class Toggle:
             win.draw_rect((0, 255, 0), inner)
 
 
+
+# ============================================================
+#   S L I D E R  (old logic fully restored)
+# ============================================================
+
 class Slider:
-    def __init__(self, rect, min_val=0, max_val=100, value=50, color="lightgray", handle_color="red", handle_radius=10):
+    def __init__(self, rect, min_val=0, max_val=100, value=50,
+                 color=(150, 150, 150), handle_color=(255, 0, 0),
+                 handle_radius=10):
+
         self.rect = rect
         self.min_val = min_val
         self.max_val = max_val
         self.value = value
 
-        self.color = parse_color(color)
-        self.handle_color = parse_color(handle_color)
-
+        self.color = color
+        self.handle_color = handle_color
         self.handle_radius = handle_radius
+
         self.dragging = False
 
     def update(self, win: Window):
         mx, my = win.mouse_pos
         x, y, w, h = self.rect
 
-        handle_x = x + ((self.value - self.min_val) / (self.max_val - self.min_val)) * w
+        # compute handle pos
+        handle_x = x + ((self.value - self.min_val) /
+                        (self.max_val - self.min_val)) * w
         handle_y = y + h // 2
 
+        inside_slider = (x <= mx <= x + w and y <= my <= y + h)
+
         if win.mouse_pressed(1):
-            if not self.dragging and (x <= mx <= x+w and y <= my <= y+h):
+            # start drag if within slider area (old behavior)
+            if not self.dragging and inside_slider:
                 self.dragging = True
         else:
             self.dragging = False
 
+        # dragging updates value
         if self.dragging:
-            rel_x = max(0, min(mx - x, w))
-            self.value = self.min_val + (rel_x / w) * (self.max_val - self.min_val)
+            rel = max(0, min(mx - x, w))
+            t = rel / w
+            self.value = self.min_val + t * (self.max_val - self.min_val)
 
     def draw(self, win: Window):
         x, y, w, h = self.rect
 
-        # bar
-        win.draw_rect(self.color, (x, y + h//2 - 2, w, 4))
+        # slider bar
+        win.draw_rect(self.color, (x, y + h // 2 - 2, w, 4))
 
-        # handle
-        handle_x = x + ((self.value - self.min_val) / (self.max_val - self.min_val)) * w
+        # handle pos
+        handle_x = x + ((self.value - self.min_val) /
+                        (self.max_val - self.min_val)) * w
         handle_y = y + h // 2
 
-        win.draw_circle(self.handle_color, (int(handle_x), int(handle_y)), self.handle_radius)
+        win.draw_circle(self.handle_color,
+                        (int(handle_x), int(handle_y)),
+                        self.handle_radius)

crystalwindow/objects.py

@@ -0,0 +1,171 @@
+import math, re
+from .sprites import Sprite
+from .assets import load_folder_images, load_image
+from .animation import Animation
+
+
+# ============================================================
+#   PLAYER / ENEMY WITH HP SECURITY + COOLDOWN + RESPAWN
+# ============================================================
+
+class Player(Sprite):
+    def __init__(self, name="Player", pos=(0, 0), size=(32, 32), speed=4, hp=100):
+        self.name = name
+        self.hp = hp
+        self.max_hp = hp     # allows 0–100 or even 0–500
+        self.speed = speed
+
+        # frames
+        self.animations = {}
+        self.current_anim = None
+        self.flip_x = False
+
+        # death / respawn flags
+        self.dead = False
+
+        super().__init__(pos, size=size, image=None)
+
+    # ----------------------------------------------------
+    # BASIC DAMAGE HANDLING
+    # ----------------------------------------------------
+    def take_damage(self, dmg):
+        if self.dead:
+            return
+
+        self.hp -= dmg
+        if self.hp <= 0:
+            self.hp = 0
+            self.dead = True
+
+    # ----------------------------------------------------
+    # RESPAWN (normal redraw logic kept)
+    # ----------------------------------------------------
+    def respawn(self, win):
+        """Manual respawn call if coder wants it."""
+        self.hp = self.max_hp
+        self.dead = False
+        self.redraw(win)
+
+    # ----------------------------------------------------
+    # LOAD ANIMATION
+    # ----------------------------------------------------
+    def load_anim(self, key, folder, loop=True):
+        imgs = self._load_sorted(folder)
+        anim = Animation(imgs)
+        anim.loop = loop
+        self.animations[key] = anim
+
+        if self.current_anim is None:
+            self.current_anim = anim
+
+    # ----------------------------------------------------
+    # UPDATE (movement + anim)
+    # ----------------------------------------------------
+    def update(self, dt, win):
+        if self.dead:
+            # still draw corpse frame
+            self.draw(win)
+            return
+
+        moving = False
+        spd = self.speed * dt * 60
+
+        # movement
+        if win.is_key_pressed("left"):
+            self.x -= spd
+            self.flip_x = True
+            moving = True
+
+        if win.is_key_pressed("right"):
+            self.x += spd
+            self.flip_x = False
+            moving = True
+
+        if win.is_key_pressed("up"):
+            self.y -= spd
+            moving = True
+
+        if win.is_key_pressed("down"):
+            self.y += spd
+            moving = True
+
+        self.pos = (self.x, self.y)
+
+        # anim switching
+        if moving and "run" in self.animations:
+            self.current_anim = self.animations["run"]
+        elif not moving and "idle" in self.animations:
+            self.current_anim = self.animations["idle"]
+
+        # apply anim frame
+        if self.current_anim:
+            self.current_anim.update(dt)
+            frame = self.current_anim.get_frame()
+            self.set_image(frame)
+
+        # final draw
+        self.draw(win)
+
+    # ----------------------------------------------------
+    # FOLDER LOADING (unchanged)
+    # ----------------------------------------------------
+    def _load_sorted(self, folder):
+        imgs_dict = load_folder_images(folder)
+        return self._sort_images(imgs_dict)
+
+    @staticmethod
+    def _sort_images(imgs_dict):
+        def extract_num(f):
+            m = re.search(r"(\d+)", f)
+            return int(m.group(1)) if m else 0
+
+        items = [(name, img) for name, img in imgs_dict.items() if not isinstance(img, dict)]
+        sorted_imgs = [img for name, img in sorted(items, key=lambda x: extract_num(x[0]))]
+        return sorted_imgs
+
+
+# ============================================================
+# BLOCK (same)
+# ============================================================
+class Block(Sprite):
+    def __init__(self, pos, w, h, color=None, texture=None):
+        if texture:
+            img = load_image(texture)
+            super().__init__(pos, size=(w, h), image=img)
+        else:
+            super().__init__(pos, size=(w, h), color=color or (150,150,150))
+
+    def collide_with(self, other):
+        return self.colliderect(other)
+
+
+# ============================================================
+# ENEMY WITH DAMAGE COOLDOWN
+# ============================================================
+class Enemy(Sprite):
+    def __init__(self, pos, w, h, dmg=10, speed=2, color=(200,50,50), texture=None, cooldown_max=5):
+        self.dmg = dmg
+        self.speed = speed
+
+        # cooldown system
+        self.cooldown = 0
+        self.cooldown_max = cooldown_max
+
+        if texture:
+            super().__init__(pos, size=(w, h), image=load_image(texture))
+        else:
+            super().__init__(pos, size=(w, h), color=color)
+
+    # enemy tick
+    def update(self, dt):
+        if self.cooldown > 0:
+            self.cooldown -= dt * 60
+
+    def collide_with(self, other):
+        return self.colliderect(other)
+
+    # enemy tries to damage
+    def hit_player(self, player):
+        if self.cooldown <= 0:
+            player.take_damage(self.dmg)
+            self.cooldown = self.cooldown_max

crystalwindow/sprites.py

@@ -1,6 +1,6 @@
-# sprites.py
 import random
 from tkinter import PhotoImage
+from .assets import generate_missing_texture
 
 try:
     from PIL import Image, ImageTk
@@ -8,94 +8,175 @@ except ImportError:
     Image = None
     ImageTk = None
 
+
 class Sprite:
     def __init__(self, pos, size=None, image=None, color=(255, 0, 0)):
         """
         pos: (x, y)
-        size: (w, h) optional
+        size: (w, h)
         image: PhotoImage or PIL ImageTk.PhotoImage
-        color: fallback rectangle color
         """
         self.pos = pos
         self.x, self.y = pos
         self.image = image
         self.color = color
 
-        # Determine width/height
+        # drawn object id
+        self.canvas_id = None
+
+        # sprite states
+        self.visible = True      # can draw
+        self.alive = True        # can collide / move / draw
+
+        # save original spawn
+        self.spawn_point = pos
+
+        # width / height
         if image is not None:
             try:
-                # Tkinter PhotoImage
                 self.width = image.width()
                 self.height = image.height()
             except Exception:
                 try:
-                    # PIL ImageTk.PhotoImage
                     self.width = image.width
                     self.height = image.height
                 except Exception:
                     raise ValueError("Sprite image has no size info")
+
         elif size is not None:
             self.width, self.height = size
         else:
             raise ValueError("Sprite needs 'size' or 'image'")
 
-        # Optional velocity
+        # optional velocity
         self.vel_x = 0
         self.vel_y = 0
 
+        self._last_win = None
+
+
     # === CLASS METHODS ===
     @classmethod
     def image(cls, img, pos):
-        """
-        Create a sprite from an image.
-        Accepts fallback dict or actual PhotoImage.
-        """
+        """Create sprite from image OR fallback dict"""
         if isinstance(img, dict) and img.get("fallback"):
             w, h = img["size"]
-            color = img["color"]
-            return cls(pos, size=(w, h), color=color)
+            missing = generate_missing_texture((w, h))
+            return cls(pos, image=missing, size=(w, h))
+        # normal image
         return cls(pos, image=img)
 
+
     @classmethod
     def rect(cls, pos, w, h, color=(255, 0, 0)):
-        """Create sprite using a plain colored rectangle"""
+        """Create sprite using a simple rectangle"""
         return cls(pos, size=(w, h), color=color)
 
-    # === METHODS ===
+
+    # === MOVE / DRAW ===
     def draw(self, win, cam=None):
-        """Draw sprite on CrystalWindow / Tk canvas"""
+        """Draw sprite onto Tk canvas. Skips when not visible/alive."""
+        if not self.alive or not self.visible:
+            return
+
+        self._last_win = win
+
+        # delete previous drawing
+        if self.canvas_id is not None:
+            try:
+                win.canvas.delete(self.canvas_id)
+            except:
+                pass
+
+        # camera offset
         if cam:
             draw_x, draw_y = cam.apply(self)
         else:
             draw_x, draw_y = self.x, self.y
 
+        # draw img or rect
         if self.image:
-            win.canvas.create_image(draw_x, draw_y, anchor="nw", image=self.image)
+            self.canvas_id = win.canvas.create_image(
+                draw_x, draw_y, anchor="nw", image=self.image
+            )
         else:
-            win.draw_rect(self.color, (draw_x, draw_y, self.width, self.height))
+            # draw_rect MUST return the canvas ID
+            self.canvas_id = win.draw_rect(
+                self.color, (draw_x, draw_y, self.width, self.height)
+            )
+
 
     def move(self, dx, dy):
+        if not self.alive:
+            return
         self.x += dx
         self.y += dy
         self.pos = (self.x, self.y)
 
+
     def apply_velocity(self, dt=1):
+        if not self.alive:
+            return
         self.x += self.vel_x * dt
         self.y += self.vel_y * dt
         self.pos = (self.x, self.y)
 
+
+    # === COLLISION ===
     def colliderect(self, other):
+        if not self.alive or not other.alive:
+            return False
+
         return (
-            self.x < other.x + getattr(other, "width", 0) and
-            self.x + getattr(self, "width", 0) > other.x and
-            self.y < other.y + getattr(other, "height", 0) and
-            self.y + getattr(self, "height", 0) > other.y
-        )  # returns tuple for consistency
+            self.x < other.x + getattr(other, "width", 0)
+            and self.x + getattr(self, "width", 0) > other.x
+            and self.y < other.y + getattr(other, "height", 0)
+            and self.y + getattr(self, "height", 0) > other.y
+        )
+
 
+    # === RESPAWN / REDRAW ===
+    def redraw(self, win, new_pos=None, flash=True):
+        if not self.alive:
+            return
+
+        self._last_win = win
+
+        # save original spawn ONCE
+        if not hasattr(self, "spawn_pos"):
+            self.spawn_pos = (self.x, self.y)
+
+        # delete old draw
+        if self.canvas_id is not None:
+            try:
+                win.canvas.delete(self.canvas_id)
+            except:
+                pass
+            self.canvas_id = None
+
+        # teleport
+        if new_pos is not None:
+            self.x, self.y = new_pos
+        else:
+            self.x, self.y = self.spawn_pos
+
+        self.pos = (self.x, self.y)
+
+        # flash effect
+        if flash and self.image is None:
+            og_color = self.color
+            self.color = (255, 255, 255)
+            self.draw(win)
+            win.canvas.update()
+            self.color = og_color
+
+        self.draw(win)
+
+
+    # === IMAGE SWITCH ===
     def set_image(self, img):
-        """Update sprite's image at runtime (like flipping)"""
         self.image = img
-        # update width/height
+
         if img is not None:
             try:
                 self.width = img.width()
@@ -106,3 +187,71 @@ class Sprite:
                     self.height = img.height
                 except:
                     pass
+
+
+    # === FULL REMOVE ===
+    def remove(self):
+        """
+        Removes from screen AND disables collisions/movement/drawing.
+        Fully out of the game world.
+        """
+        self.visible = False
+        self.alive = False
+
+        # erase from canvas
+        if self.canvas_id is not None:
+            try:
+                win = self._last_win
+                win.canvas.delete(self.canvas_id)
+            except:
+                pass
+
+        self.canvas_id = None
+        self._last_win = None
+
+class CollisionHandler:
+    def __init__(self):
+        """Initialize the collision handler with an empty list of sprites."""
+        self.sprites = []
+
+    def add(self, sprite):
+        """Add a sprite to the collision handler."""
+        self.sprites.append(sprite)
+
+    def check_collisions(self):
+        """Check for collisions between all sprites in the handler."""
+        for i in range(len(self.sprites)):
+            for j in range(i + 1, len(self.sprites)):
+                sprite_a = self.sprites[i]
+                sprite_b = self.sprites[j]
+
+                if sprite_a.colliderect(sprite_b):
+                    self.handle_collision(sprite_a, sprite_b)
+
+    def handle_collision(self, sprite_a, sprite_b):
+        """Handle the collision between two sprites."""
+        
+        # Prevent "noclip": Adjust positions or velocities to prevent overlap
+
+        # Stop both sprites' movement upon collision
+        if sprite_a.vel_x != 0 and sprite_b.vel_x != 0:
+            sprite_a.vel_x = 0
+            sprite_b.vel_x = 0
+        
+        if sprite_a.vel_y != 0 and sprite_b.vel_y != 0:
+            sprite_a.vel_y = 0
+            sprite_b.vel_y = 0
+
+        # Prevent overlap by adjusting their positions after a collision
+        if sprite_a.x < sprite_b.x:
+            sprite_a.x = sprite_b.x - sprite_a.width
+        else:
+            sprite_b.x = sprite_a.x - sprite_b.width
+
+        if sprite_a.y < sprite_b.y:
+            sprite_a.y = sprite_b.y - sprite_a.height
+        else:
+            sprite_b.y = sprite_a.y - sprite_b.height
+
+        # You can add more sophisticated handling (e.g., bounce, adjust based on velocity)
+        # For now, this simple solution ensures no overlap and stops movement

crystalwindow/tilemap.py

@@ -6,7 +6,7 @@ class TileMap:
         self.tiles = []
 
     def add_tile(self, image, x, y):
-        self.tiles.append(Sprite(image, x, y))
+        self.tiles.append(Sprite.image(image, x, y))
 
     def draw(self, win):
         for t in self.tiles: