crystalwindow 2.4__py3-none-any.whl → 2.9.8__py3-none-any.whl

crystalwindow/gravity.py

@@ -0,0 +1,75 @@
+class Gravity:
+    def __init__(self, obj, force=1, terminal_velocity=15, bouncy=False, bounce_strength=0.7):
+        self.obj = obj
+        if not hasattr(self.obj, "vel_y"):
+            self.obj.vel_y = 0
+        self.force = force
+        self.terminal_velocity = terminal_velocity
+        self.bouncy = bouncy
+        self.bounce_strength = bounce_strength
+        self.on_ground = False
+        self.stretch_factor = 0  # for squishy effect
+
+        # --- NEW: choose mode ---
+        # If object has .sprite use that, else fallback to rect mode
+        if hasattr(obj, "sprite"):
+            self.mode = "sprite"
+        else:
+            self.mode = "rect"
+
+    def get_obj_rect(self):
+        # helper to get x,y,w,h depending on mode
+        if self.mode == "sprite":
+            s = self.obj.sprite
+            x = getattr(s, "x", 0)
+            y = getattr(s, "y", 0)
+            w = getattr(s, "width", getattr(s, "w", 32))
+            h = getattr(s, "height", getattr(s, "h", 32))
+        else:
+            x = getattr(self.obj, "x", 0)
+            y = getattr(self.obj, "y", 0)
+            w = getattr(self.obj, "width", getattr(self.obj, "w", 32))
+            h = getattr(self.obj, "height", getattr(self.obj, "h", 32))
+        return x, y, w, h
+
+    def update(self, dt, platforms=[]):
+        # apply gravity
+        self.obj.vel_y += self.force * dt * 60
+        if self.obj.vel_y > self.terminal_velocity:
+            self.obj.vel_y = self.terminal_velocity
+
+        # move object
+        x, y, w, h = self.get_obj_rect()
+        y += self.obj.vel_y
+        self.on_ground = False
+
+        # check collisions
+        for plat in platforms:
+            plat_w = getattr(plat, "width", getattr(plat, "w", 0))
+            plat_h = getattr(plat, "height", getattr(plat, "h", 0))
+            if (x + w > plat.x and x < plat.x + plat_w and
+                y + h > plat.y and y < plat.y + plat_h):
+                
+                y = plat.y - h
+                self.on_ground = True
+
+                if self.bouncy:
+                    self.obj.vel_y = -self.obj.vel_y * self.bounce_strength
+                    self.stretch_factor = min(0.5, self.stretch_factor + 0.2)
+                else:
+                    self.obj.vel_y = 0
+                    self.stretch_factor = 0
+
+        # slowly reset stretch
+        if self.stretch_factor > 0:
+            self.stretch_factor -= 0.05
+            if self.stretch_factor < 0:
+                self.stretch_factor = 0
+
+        # write back position
+        if self.mode == "sprite":
+            self.obj.sprite.x = x
+            self.obj.sprite.y = y
+        else:
+            self.obj.x = x
+            self.obj.y = y

crystalwindow/gui.py

@@ -0,0 +1,69 @@
+#gui.py
+import random
+
+# ----------------- Color Helpers -----------------
+def hex_to_rgb(hex_str):
+    """Convert hex color string to RGB tuple"""
+    hex_str = hex_str.lstrip("#")
+    return tuple(int(hex_str[i:i+2], 16) for i in (0, 2, 4))
+
+def random_color():
+    """Return a random RGB color"""
+    return (random.randint(0,255), random.randint(0,255), random.randint(0,255))
+
+def lerp_color(c1, c2, t):
+    """Linearly interpolate between two colors"""
+    return tuple(int(a + (b-a)*t) for a,b in zip(c1,c2))
+
+# ----------------- GUI Elements -----------------
+class Button:
+    def __init__(self, rect, text, color=(200,200,200), hover_color=(255,255,255), callback=None):
+        self.rect = rect  # (x, y, w, h)
+        self.text = text
+        self.color = color
+        self.hover_color = hover_color
+        self.callback = callback
+        self.hovered = False
+
+    def draw(self, win):
+        x, y, w, h = self.rect
+        mx, my = win.mouse_pos
+        self.hovered = x <= mx <= x+w and y <= my <= y+h
+        cur_color = self.hover_color if self.hovered else self.color
+        win.draw_rect(cur_color, self.rect)
+        win.draw_text(self.text, pos=(x+5, y+5))
+
+    def check_click(self, win):
+        mx, my = win.mouse_pos
+        x, y, w, h = self.rect
+        if x <= mx <= x+w and y <= my <= y+h and win.mouse_pressed(1):
+            if self.callback:
+                self.callback()
+
+class Label:
+    def __init__(self, pos, text, color=(255,255,255), font="Arial", size=16):
+        self.pos = pos
+        self.text = text
+        self.color = color
+        self.font = font
+        self.size = size
+
+    def draw(self, win):
+        win.draw_text(self.text, font=self.font, size=self.size, color=self.color, pos=self.pos)
+
+# ----------------- Optional GUI Manager -----------------
+class GUIManager:
+    def __init__(self):
+        self.elements = []
+
+    def add(self, element):
+        self.elements.append(element)
+
+    def draw(self, win):
+        for e in self.elements:
+            e.draw(win)
+
+    def update(self, win):
+        for e in self.elements:
+            if isinstance(e, Button):
+                e.check_click(win)

crystalwindow/gui_ext.py

@@ -0,0 +1,66 @@
+from .window import Window
+from .assets import load_image
+from .sprites import Sprite
+from .gui import Button
+
+class Toggle:
+    def __init__(self, rect, value=False, color=(200,200,200), hover_color=(255,255,255)):
+        # rect = (x, y, w, h)
+        self.rect = rect
+        self.value = value
+        self.color = color
+        self.hover_color = hover_color
+        self.hovered = False
+
+    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
+        if self.hovered and win.mouse_pressed(1):
+            self.value = not self.value
+
+    def draw(self, win: Window):
+        draw_color = self.hover_color if self.hovered else self.color
+        win.draw_rect(draw_color, self.rect)
+        # optional: small “on” indicator
+        if self.value:
+            inner = (self.rect[0]+4, self.rect[1]+4, self.rect[2]-8, self.rect[3]-8)
+            win.draw_rect((0,255,0), inner)
+
+
+class Slider:
+    def __init__(self, rect, min_val=0, max_val=100, value=50, color=(150,150,150), handle_radius=10):
+        # rect = (x, y, w, h)
+        self.rect = rect
+        self.min_val = min_val
+        self.max_val = max_val
+        self.value = value
+        self.color = 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
+        handle_y = y + h // 2
+
+        # start drag if mouse clicks inside slider bar area
+        if win.mouse_pressed(1):
+            if not self.dragging and (x <= mx <= x+w and y <= my <= y+h):
+                self.dragging = True
+        else:
+            self.dragging = False  # stop drag when released
+
+        # update value while dragging
+        if self.dragging:
+            rel_x = max(0, min(mx - x, w))  # clamp
+            self.value = self.min_val + (rel_x / w) * (self.max_val - self.min_val)
+
+    def draw(self, win: Window):
+        x, y, w, h = self.rect
+        win.draw_rect(self.color, (x, y + h//2 - 2, w, 4))
+        handle_x = x + ((self.value - self.min_val) / (self.max_val - self.min_val)) * w
+        handle_y = y + h // 2
+        win.draw_circle((255, 0, 0), (int(handle_x), int(handle_y)), self.handle_radius)

crystalwindow/math.py

@@ -0,0 +1,40 @@
+class Mathematics:
+    """
+    A class used to perform basic mathematical operations.
+
+    Methods:
+    --------
+    add(num1, num2) : Adds two numbers.
+    subtract(num1, num2) : Subtracts two numbers.
+    multiply(num1, num2) : Multiplies two numbers.
+    divide(num1, num2) : Divides two numbers.
+    """
+
+    @staticmethod
+    def add(x, y):
+        """Adds two numbers together"""
+        return x + y
+
+    @staticmethod
+    def subtract(num1, num2):
+        """Subtracts two numbers."""
+        return num1 - num2
+
+    @staticmethod
+    def multiply(num1, num2):
+        """Multiplies two numbers."""
+        return num1 * num2
+
+    @staticmethod
+    def divide(num1, num2):
+        """
+        Divides two numbers.
+
+        Raises:
+        ------
+        ZeroDivisionError : If num2 is zero.
+        """
+        if num2 == 0:
+            raise ZeroDivisionError("Cannot divide by zero!")
+        return num1 / num2
+

crystalwindow/player.py

@@ -0,0 +1,106 @@
+import math, os, re
+from .assets import load_folder_images
+from .animation import Animation
+
+class Player:
+    def __init__(self, pos=(0, 0), speed=5, size=(32, 32)):
+        self.x, self.y = pos
+        self.speed = speed
+        self.width, self.height = size
+        self.animations = {}
+        self.current_anim = None
+        self.image = None
+        self.rect = self._make_rect()
+    
+    # make a lil rect obj for collisions
+    def _make_rect(self):
+        return type("Rect", (), {"x": self.x, "y": self.y, "w": self.width, "h": self.height,
+                                 "topleft": (self.x, self.y)})()
+
+    # === animation setup ===
+    def idle(self, folder):
+        imgs = self._load_sorted(folder)
+        anim = Animation(imgs)
+        self.animations["idle"] = anim
+        self.current_anim = anim
+        return anim
+
+    class walk:
+        @staticmethod
+        def cycle(folder):
+            imgs = Player._load_sorted_static(folder)
+            anim = Animation(imgs)
+            anim.loop = True
+            return anim
+        
+        @staticmethod
+        def once(folder):
+            imgs = Player._load_sorted_static(folder)
+            anim = Animation(imgs)
+            anim.loop = False
+            return anim
+
+    class jump:
+        @staticmethod
+        def cycle(folder):
+            imgs = Player._load_sorted_static(folder)
+            anim = Animation(imgs)
+            anim.loop = True
+            return anim
+
+        @staticmethod
+        def once(folder):
+            imgs = Player._load_sorted_static(folder)
+            anim = Animation(imgs)
+            anim.loop = False
+            return anim
+
+    # === main update ===
+    def update(self, dt, win):
+        moving = False
+        if win.is_key_pressed("left"):
+            self.x -= self.speed * dt * 60
+            moving = True
+        if win.is_key_pressed("right"):
+            self.x += self.speed * dt * 60
+            moving = True
+        if win.is_key_pressed("up"):
+            self.y -= self.speed * dt * 60
+            moving = True
+        if win.is_key_pressed("down"):
+            self.y += self.speed * dt * 60
+            moving = True
+
+        # update animation
+        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"]
+
+        if self.current_anim:
+            self.current_anim.update(dt)
+            self.image = self.current_anim.get_frame()
+
+        self.rect.x, self.rect.y = self.x, self.y
+        self.rect.topleft = (self.x, self.y)
+
+    def draw(self, win):
+        if self.image:
+            win.screen.blit(self.image, (self.x, self.y))
+
+    # ---------- helpers ----------
+    def _load_sorted(self, folder):
+        imgs_dict = load_folder_images(folder)
+        return self._sort_images(imgs_dict)
+
+    @staticmethod
+    def _load_sorted_static(folder):
+        imgs_dict = load_folder_images(folder)
+        return Player._sort_images(imgs_dict)
+
+    @staticmethod
+    def _sort_images(imgs_dict):
+        def extract_num(filename):
+            match = re.search(r'(\d+)', filename)
+            return int(match.group(1)) if match else 0
+        return [img for name, img in sorted(imgs_dict.items(), key=lambda x: extract_num(x[0]))]

crystalwindow/sprites.py

@@ -0,0 +1,37 @@
+#Sprites.py
+from tkinter import PhotoImage
+
+class Sprite:
+    def __init__(self, pos, size=None, image=None, color=(255, 0, 0)):
+        """
+        pos: (x, y) top-left
+        size: (w, h) if you want a plain colored rect
+        image: PhotoImage (Tkinter)
+        color: fill color if size is used
+        """
+        self.pos = pos
+        self.x, self.y = pos
+
+        if image is not None:
+            self.image = image
+            self.width = image.width()
+            self.height = image.height()
+        elif size is not None:
+            self.width, self.height = size
+            self.image = None
+            self.color = color
+        else:
+            raise ValueError("Sprite needs either size or image")
+
+    def draw(self, win):
+        """Draw sprite on given Window"""
+        if self.image:
+            win.canvas.create_image(self.x, self.y, anchor="nw", image=self.image)
+        else:
+            win.draw_rect(self.color, (self.x, self.y, self.width, self.height))
+
+    def move(self, dx, dy):
+        """Move sprite by dx/dy"""
+        self.x += dx
+        self.y += dy
+        self.pos = (self.x, self.y)

crystalwindow/tilemap.py

@@ -0,0 +1,13 @@
+from .sprites import Sprite
+
+class TileMap:
+    def __init__(self, tile_size):
+        self.tile_size = tile_size
+        self.tiles = []
+
+    def add_tile(self, image, x, y):
+        self.tiles.append(Sprite(image, x, y))
+
+    def draw(self, win):
+        for t in self.tiles:
+            win.draw_sprite(t)

crystalwindow/ver_warner.py

@@ -0,0 +1,54 @@
+from importlib.metadata import version as get_version, PackageNotFoundError
+import requests
+import os
+import json
+
+def check_for_update(package_name="crystalwindow"):
+    """
+    Checks PyPI for updates.
+    Warns every run if outdated.
+    Only skips check when version is already latest.
+    """
+    try:
+        # get current version
+        try:
+            current_version = get_version(package_name)
+        except PackageNotFoundError:
+            print(f"(⚠️ Package '{package_name}' not found)")
+            return
+
+        cache_file = os.path.join(os.path.expanduser("~"), f".{package_name}_version_cache.json")
+
+        # load cache
+        if os.path.exists(cache_file):
+            with open(cache_file, "r") as f:
+                cache = json.load(f)
+        else:
+            cache = {}
+
+        # get newest version from PyPI
+        url = f"https://pypi.org/pypi/{package_name}/json"
+        response = requests.get(url, timeout=3)
+
+        if response.status_code == 200:
+            latest_version = response.json()["info"]["version"]
+
+            if latest_version == current_version:
+                # only print once per version
+                if cache.get("last_checked") != current_version:
+                    print(f"✅ Up to date! ver = {current_version}.")
+                    cache["last_checked"] = current_version
+                    with open(cache_file, "w") as f:
+                        json.dump(cache, f)
+            else:
+                # always warn until updated
+                print(f"\n⚠️ Yo dev! '{package_name}' is outdated ({current_version})")
+                print(f"👉 Newest is {latest_version}! Run:")
+                print(f"   pip install --upgrade {package_name}")
+                print(f"Or peep: https://pypi.org/project/{package_name}/{latest_version}/\n")
+
+        else:
+            print("(⚠️ PyPI request failed, skipping version check)")
+
+    except Exception as e:
+        print(f"(⚠️ Version check failed: {e})")