crystalwindow 2.5.7__py3-none-any.whl → 2.7.8__py3-none-any.whl

crystalwindow/FileHelper.py

@@ -0,0 +1,142 @@
+"""
+CrystalWindow FileHelper
+------------------------
+A utility class that handles saving/loading text, JSON, and pickle files,
+with optional Tk file dialogs and a default 'saves' directory.
+"""
+
+import os
+import json
+import pickle
+import tkinter as tk
+from tkinter import filedialog
+
+
+class FileHelper:
+    """CrystalWindow integrated file helper with default folders & Tk dialogs."""
+
+    def __init__(self, default_save_folder="saves"):
+        """
+        Initialize the FileHelper.
+
+        Args:
+            default_save_folder (str): Folder to save files in by default.
+                                       Created automatically if missing.
+        """
+        self.default_save_folder = default_save_folder
+        os.makedirs(self.default_save_folder, exist_ok=True)
+
+    # -------------------------------------------------------------------------
+    # TK FILE DIALOGS
+    # -------------------------------------------------------------------------
+    def ask_save_file(self, default_name="save.json",
+                      filetypes=[("JSON files", "*.json"), ("All files", "*.*")]):
+        """Open a Tkinter Save dialog starting in the default folder."""
+        root = tk.Tk()
+        root.withdraw()
+        path = filedialog.asksaveasfilename(
+            title="Save As",
+            initialdir=self.default_save_folder,
+            initialfile=default_name,
+            filetypes=filetypes,
+            defaultextension=filetypes[0][1]
+        )
+        root.destroy()
+        return path if path else None  # Return None if cancelled
+
+    def ask_open_file(self,
+                      filetypes=[("JSON files", "*.json"), ("All files", "*.*")]):
+        """Open a Tkinter Open dialog starting in the default folder."""
+        root = tk.Tk()
+        root.withdraw()
+        path = filedialog.askopenfilename(
+            title="Open File",
+            initialdir=self.default_save_folder,
+            filetypes=filetypes
+        )
+        root.destroy()
+        return path if path else None
+
+    # -------------------------------------------------------------------------
+    # INTERNAL PATH HELPER
+    # -------------------------------------------------------------------------
+    def _resolve_path(self, filename):
+        """Return a full path, resolving relative paths to the default folder."""
+        if not filename:
+            return None
+        if os.path.isabs(filename):
+            return filename
+        return os.path.join(self.default_save_folder, filename)
+
+    # -------------------------------------------------------------------------
+    # TEXT FILES
+    # -------------------------------------------------------------------------
+    def save_text(self, filename, content):
+        """Save plain text data to a file."""
+        path = self._resolve_path(filename)
+        if not path:
+            print("[CANCELLED] No save path provided.")
+            return None
+        os.makedirs(os.path.dirname(path), exist_ok=True)
+        with open(path, "w", encoding="utf-8") as f:
+            f.write(content)
+        print(f"[INFO] Text saved to: {path}")
+        return path
+
+    def load_text(self, filename):
+        """Load plain text data from a file."""
+        path = self._resolve_path(filename)
+        if path and os.path.exists(path):
+            with open(path, "r", encoding="utf-8") as f:
+                return f.read()
+        print(f"[WARN] Text file not found: {path}")
+        return None
+
+    # -------------------------------------------------------------------------
+    # JSON FILES
+    # -------------------------------------------------------------------------
+    def save_json(self, filename, data):
+        """Save JSON-serializable data."""
+        path = self._resolve_path(filename)
+        if not path:
+            print("[CANCELLED] No save path provided.")
+            return None
+        os.makedirs(os.path.dirname(path), exist_ok=True)
+        with open(path, "w", encoding="utf-8") as f:
+            json.dump(data, f, indent=4)
+        print(f"[INFO] JSON saved to: {path}")
+        return path
+
+    def load_json(self, filename):
+        """Load JSON data."""
+        path = self._resolve_path(filename)
+        if path and os.path.exists(path):
+            with open(path, "r", encoding="utf-8") as f:
+                return json.load(f)
+        print(f"[WARN] JSON file not found: {path}")
+        return None
+
+    # -------------------------------------------------------------------------
+    # PICKLE FILES
+    # -------------------------------------------------------------------------
+    def save_pickle(self, filename, obj):
+        """Save a Python object using pickle."""
+        path = self._resolve_path(filename)
+        if not path:
+            print("[CANCELLED] No save path provided.")
+            return None
+        os.makedirs(os.path.dirname(path), exist_ok=True)
+        with open(path, "wb") as f:
+            pickle.dump(obj, f)
+        print(f"[INFO] Pickle saved to: {path}")
+        return path
+
+    def load_pickle(self, filename):
+        """Load a pickled Python object."""
+        path = self._resolve_path(filename)
+        if path and os.path.exists(path):
+            with open(path, "rb") as f:
+                return pickle.load(f)
+        print(f"[WARN] Pickle file not found: {path}")
+        return None
+

crystalwindow/__init__.py

@@ -0,0 +1,57 @@
+# crystalwindow/__init__.py
+# 💎 CrystalWindow - Master Import Hub
+from .ver_warner import check_for_update
+check_for_update("crystalwindow")
+
+# === Core Systems ===
+from .window import Window
+from .sprites import Sprite
+from .tilemap import TileMap
+from .player import Player
+from .gravity import Gravity
+from .FileHelper import FileHelper
+from .math import Mathematics
+
+# === Assets & Animation ===
+from .assets import load_image, load_folder_images, load_music, play_music
+from .animation import Animation
+
+# === Collision ===
+from .collision import check_collision, resolve_collision
+
+# === GUI & Extensions ===
+from .gui import Button, Label, GUIManager, random_color, hex_to_rgb
+from .gui_ext import Toggle, Slider
+
+# === Drawing Helpers ===
+from .draw_helpers import gradient_rect, CameraShake
+from .draw_rects import DrawHelper
+from .draw_text_helper import DrawTextManager
+from .draw_tool import CrystalDraw
+
+# === Misc Helpers ===
+from .fun_helpers import random_name, DebugOverlay
+
+
+__all__ = [
+    # --- Core ---
+    "Window", "Sprite", "TileMap", "Player", "Gravity", "FileHelper", "Mathematics",
+    
+    # --- Assets & Animation ---
+    "load_image", "load_folder_images", "load_music", "play_music", "Animation",
+    
+    # --- Collision ---
+    "check_collision", "resolve_collision",
+    
+    # --- GUI ---
+    "Button", "Label", "GUIManager", "random_color", "hex_to_rgb",
+    
+    # --- GUI Extensions ---
+    "Toggle", "Slider",
+    
+    # --- Drawing ---
+    "gradient_rect", "CameraShake", "DrawHelper", "DrawTextManager", "CrystalDraw",
+    
+    # --- Misc ---
+    "random_name", "DebugOverlay",
+]

crystalwindow/animation.py

@@ -0,0 +1,15 @@
+class Animation:
+    def __init__(self, frames, speed=0.1):
+        self.frames = frames
+        self.speed = speed
+        self.current = 0
+        self.timer = 0
+
+    def update(self, dt):
+        self.timer += dt
+        if self.timer >= self.speed:
+            self.timer = 0
+            self.current = (self.current + 1) % len(self.frames)
+
+    def get_frame(self):
+        return self.frames[self.current]

crystalwindow/assets.py

@@ -0,0 +1,30 @@
+import os
+from tkinter import PhotoImage
+
+ASSETS = {}
+
+def load_image(path, size=None):
+    if not os.path.exists(path):
+        raise FileNotFoundError(f"Image not found: {path}")
+    img = PhotoImage(file=path)
+    ASSETS[path] = img
+    return img
+
+def load_folder_images(folder, nested=True):
+    result = {}
+    for item in os.listdir(folder):
+        full_path = os.path.join(folder, item)
+        if os.path.isdir(full_path) and nested:
+            result[item] = load_folder_images(full_path, nested=True)
+        elif item.lower().endswith((".png", ".gif")):  # Tk supports PNG/GIF
+            result[item] = load_image(full_path)
+    return result
+
+def load_music(path):
+    """No-op: Tkinter does not handle music. Placeholder for compatibility."""
+    print(f"[assets] Music loading not supported in this current crystalwindow ver sorry! ~Crystal: {path}")
+    return None
+
+def play_music(loop=-1):
+    """No-op: placeholder."""
+    print("[assets] Music playback not supported in this current crystalwindow ver sorry! ~Crystal")

crystalwindow/collision.py

@@ -0,0 +1,15 @@
+def check_collision(sprite, tiles):
+    for t in tiles:
+        if sprite.rect.colliderect(t.rect):
+            return True
+    return False
+
+def resolve_collision(sprite, tiles, dy):
+    sprite.rect.y += dy
+    collided = [t for t in tiles if sprite.rect.colliderect(t.rect)]
+    for t in collided:
+        if dy > 0:
+            sprite.rect.bottom = t.rect.top
+        elif dy < 0:
+            sprite.rect.top = t.rect.bottom
+    sprite.y = sprite.rect.y

crystalwindow/draw_helpers.py

@@ -0,0 +1,23 @@
+from .window import Window
+
+def gradient_rect(win, rect, color_start, color_end, vertical=True):
+    x,y,w,h = rect
+    for i in range(h if vertical else w):
+        t = i/(h if vertical else w)
+        r = int(color_start[0]*(1-t) + color_end[0]*t)
+        g = int(color_start[1]*(1-t) + color_end[1]*t)
+        b = int(color_start[2]*(1-t) + color_end[2]*t)
+        if vertical:
+            win.draw_rect((r,g,b), (x,y+i,w,1))
+        else:
+            win.draw_rect((r,g,b), (x+i,y,1,h))
+
+class CameraShake:
+    def __init__(self, intensity=5):
+        self.intensity = intensity
+        self.offset = (0,0)
+
+    def update(self):
+        import random
+        self.offset = (random.randint(-self.intensity,self.intensity),
+                       random.randint(-self.intensity,self.intensity))

crystalwindow/draw_rects.py

@@ -0,0 +1,36 @@
+from crystalwindow import *
+
+class DrawHelper:
+    def rect(self, win, x, y, w, h, color):
+        win.draw_rect(color, (x, y, w, h))
+        return self
+
+    def square(self, win, x, y, size, color):
+        win.draw_rect(color, (x, y, size, size))
+        return self
+
+    def circle(self, win, x, y, radius, color):
+        win.draw_circle(color, (x, y), radius)
+        return self
+
+    def triangle(self, win, points, color):
+        flat_points = [coord for pt in points for coord in pt]
+        win.canvas.create_polygon(flat_points, fill=win._to_hex(color))
+        return self
+
+    def text(self, win, text, font="Arial", size=16, x=0, y=0, color=(255,255,255), bold=False, cursive=False):
+        win.draw_text(text, font=font, size=size, pos=(x, y), color=color, bold=bold, italic=cursive)
+        return self
+
+    def gradient_rect(self, win, x, y, w, h, start_color, end_color, vertical=True):
+        for i in range(h if vertical else w):
+            ratio = i / (h if vertical else w)
+            r = int(start_color[0]*(1-ratio) + end_color[0]*ratio)
+            g = int(start_color[1]*(1-ratio) + end_color[1]*ratio)
+            b = int(start_color[2]*(1-ratio) + end_color[2]*ratio)
+            color = f"#{r:02x}{g:02x}{b:02x}"
+            if vertical:
+                win.canvas.create_line(x, y+i, x+w, y+i, fill=color)
+            else:
+                win.canvas.create_line(x+i, y, x+i, y+h, fill=color)
+        return self

crystalwindow/draw_text_helper.py

@@ -0,0 +1,46 @@
+#draw_text_helper.py
+from .window import Window
+
+class DrawTextManager:
+    def __init__(self):
+        self.texts = []
+
+    def add_text(self, text, pos=(0,0), size=16, color=(255,255,255), bold=False, italic=False, duration=None):
+        """
+        text: str
+        pos: (x,y)
+        size: int
+        color: RGB tuple
+        bold: bool
+        italic: bool
+        duration: float seconds or None for permanent
+        """
+        self.texts.append({
+            "text": text,
+            "pos": pos,
+            "size": size,
+            "color": color,
+            "bold": bold,
+            "italic": italic,
+            "duration": duration,
+            "timer": 0
+        })
+
+    def update(self, dt):
+        # update timers and remove expired text
+        for t in self.texts[:]:
+            if t["duration"] is not None:
+                t["timer"] += dt
+                if t["timer"] >= t["duration"]:
+                    self.texts.remove(t)
+
+    def draw(self, win: Window):
+        for t in self.texts:
+            win.draw_text(
+                t["text"],
+                pos=t["pos"],
+                size=t["size"],
+                color=t["color"],
+                bold=t["bold"],
+                italic=t["italic"]
+            )

crystalwindow/draw_tool.py

@@ -0,0 +1,49 @@
+from .gui import hex_to_rgb
+
+class CrystalDraw:
+    def __init__(self, win, brush_color="#00aaff", brush_size=8, canvas_rect=None):
+        """
+        win: CrystalWindow instance
+        brush_color: color string or tuple
+        brush_size: int
+        canvas_rect: (x, y, w, h) optional drawing area
+        """
+        self.win = win
+        self.brush_color = hex_to_rgb(brush_color)
+        self.brush_size = brush_size
+        self.drawing = False
+        self.last_pos = None
+        self.canvas_rect = canvas_rect or (0, 0, win.width, win.height)
+
+    def set_color(self, color):
+        if isinstance(color, str):
+            self.brush_color = hex_to_rgb(color)
+        else:
+            self.brush_color = color
+
+    def set_brush_size(self, size):
+        self.brush_size = max(1, int(size))
+
+    def clear(self):
+        self.win.fill((255,255,255))
+
+    def update(self):
+        """Draw if mouse pressed."""
+        x, y, w, h = self.canvas_rect
+        mx, my = self.win.mouse_pos
+        in_bounds = x <= mx <= x+w and y <= my <= y+h
+
+        if self.win.mouse_pressed(1) and in_bounds:
+            if self.last_pos:
+                self.win.canvas.create_line(
+                    self.last_pos[0], self.last_pos[1], mx, my,
+                    fill=self._to_hex(self.brush_color),
+                    width=self.brush_size,
+                    capstyle="round", smooth=True
+                )
+            self.last_pos = (mx, my)
+        else:
+            self.last_pos = None
+
+    def _to_hex(self, color):
+        return f"#{color[0]:02x}{color[1]:02x}{color[2]:02x}"

crystalwindow/fun_helpers.py

@@ -0,0 +1,28 @@
+import random
+
+# random color helpers
+def random_color():
+    return (random.randint(0,255), random.randint(0,255), random.randint(0,255))
+
+def random_palette(n=5):
+    return [random_color() for _ in range(n)]
+
+# random name generator
+def random_name():
+    syllables = ["ka","zi","lo","ra","mi","to","na","ve"]
+    return "".join(random.choice(syllables) for _ in range(3))
+
+# tween helper
+def lerp(a, b, t):
+    return a + (b - a) * t
+
+# debug overlay
+class DebugOverlay:
+    def __init__(self):
+        self.active = True
+
+    def draw(self, win, fps=60):
+        if self.active:
+            win.draw_text(f"FPS: {fps}", pos=(10,10))
+            mx,my = win.mouse_pos
+            win.draw_text(f"Mouse: {mx},{my}", pos=(10,30))

crystalwindow/gametests/__init__.py

@@ -0,0 +1,14 @@
+"""
+CrystalWindow Example Demos
+---------------------------
+Run demos like this:
+
+    python -m CrystalWindow.examples.<demo_name>
+
+Available demos:
+    guitesting     → GUI widgets & layout demo
+    gravitytest    → Physics & gravity simulation
+    windowtesting  → Basic window + drawing
+    sandbox        → Open testbed for experiments
+"""
+__all__ = ["guitesting", "gravitytest", "windowtesting", "sandbox"]

crystalwindow/gametests/__main__.py

@@ -0,0 +1,23 @@
+# crystalWindow/examples/__main__.py
+import importlib
+
+DEMO_SCRIPTS = {
+    "guitesting": "GUI widgets & layout demo",
+    "gravitytest": "Gravity + physics test",
+    "windowtesting": "Basic window and draw test",
+    "sandbox": "Free experiment playground",
+}
+
+def list_demos():
+    print("CrystalWindow Example Demos 🧊")
+    print("--------------------------------")
+    for name, desc in DEMO_SCRIPTS.items():
+        print(f"{name:<15} - {desc}")
+    print("\nRun one with:")
+    print("  python -m cystalWindow.examples.<demo_name>\n")
+
+def main():
+    list_demos()
+
+if __name__ == "__main__":
+    main()

crystalwindow/gametests/gravitytest.py

@@ -0,0 +1,47 @@
+from crystalwindow import *
+
+# --- custom player/ball class ---
+class PlayerRect:
+    def __init__(self, x, y, w=32, h=32, color=(255,0,0)):
+        self.x = x
+        self.y = y
+        self.width = w
+        self.height = h
+        self.color = color
+        self.vel_y = 0
+
+    # draw either sprite or rect
+    def draw(self, win):
+        win.draw_rect(self.color, (self.x, self.y, self.width, self.height))
+
+# --- setup window ---
+win = Window(800, 600, "Gravity Sprite/Rect Test")
+
+# --- player as colored rect ---
+player = PlayerRect(100, 100, 50, 50, color=(0,255,0))
+
+# --- platform as rect ---
+class Platform:
+    def __init__(self, x, y, w, h, color=(100,200,100)):
+        self.x = x
+        self.y = y
+        self.width = w
+        self.height = h
+        self.color = color
+    def draw(self, win):
+        win.draw_rect(self.color, (self.x, self.y, self.width, self.height))
+
+platform = Platform(0, 500, 800, 50)
+
+# --- attach gravity ---
+player.gravity = Gravity(player, force=1, bouncy=True, bounce_strength=0.7)
+
+# --- main loop ---
+def update(win):
+    player.gravity.update(1/60, [platform])
+    win.screen.fill((20,20,50))
+    player.draw(win)
+    platform.draw(win)
+
+win.run(update)
+win.quit()

crystalwindow/gametests/guitesting.py

@@ -0,0 +1,56 @@
+from crystalwindow import *
+
+# --- Window setup ---
+win = Window(800, 600, "CrystalWindowLib Mega Sandbox")
+
+# --- GUI ---
+gui = GUIManager()
+toggle1 = Toggle((50, 50, 100, 40), value=False)
+slider1 = Slider((50, 120, 200, 30), min_val=0, max_val=100, value=50)
+
+btn1 = Button(rect=(50, 200, 150, 50), text="Click Me!", color=random_color(),
+              hover_color=random_color(), callback=lambda: print("Button clicked!"))
+lbl1 = Label((250, 50), "Hello GUI!", color=random_color(), size=24)
+
+gui.add(toggle1)
+gui.add(slider1)
+gui.add(btn1)
+gui.add(lbl1)
+
+# --- Debug Overlay ---
+debug = DebugOverlay()
+
+# --- Camera Shake ---
+shake = CameraShake(intensity=20)
+
+# --- Main loop ---
+def update(win):
+    gui.update(win)
+    gui.draw(win)
+
+    # --- draw text examples ---
+    win.draw_text("Normal Text", pos=(400, 50), size=18, color=random_color())
+    win.draw_text("Bold Text", pos=(400, 80), size=20, color=random_color(), bold=True)
+    win.draw_text("Italic Text", pos=(400, 110), size=20, color=random_color(), italic=True)
+    win.draw_text("Bold + Italic", pos=(400, 140), size=22, color=random_color(), bold=True, italic=True)
+    
+    # --- draw toggle/slider values ---
+    win.draw_text(f"Toggle: {toggle1.value}", pos=(50, 90), size=18)
+    win.draw_text(f"Slider: {int(slider1.value)}", pos=(50, 160), size=18)
+    
+    # --- draw gradient ---
+    gradient_rect(win, (50, 300, 200, 100), (255,0,0), (0,0,255))
+    
+    # --- screen shake example (move a rectangle with shake) ---
+    shake.update()
+    x_off, y_off = shake.offset
+    win.draw_rect((0,255,0), (500+x_off, 300+y_off, 100, 50))
+    
+    # --- draw random name + color ---
+    win.draw_text(f"Random Name: {random_name()}", pos=(50, 420), size=20, color=random_color())
+    
+    # --- debug overlay ---
+    debug.draw(win, fps=int(win.clock.get_fps()))
+
+win.run(update)
+win.quit()

crystalwindow/gametests/sandbox.py

@@ -0,0 +1,49 @@
+from crystalwindow import *
+
+# --- setup window ---
+win = Window(800, 600, "CrystalWindow Sandbox")
+
+# --- setup debug overlay ---
+debug = DebugOverlay()
+draw = DrawHelper()
+draw.rect(win, 100, 100, 50, 60, (255,0,0)).circle(win, 300, 200, 40, (0,255,0))
+
+
+# --- player setup ---
+player = Player((100, 400), speed=220)
+
+
+# --- gravity system ---
+gravity = Gravity(player, force=1.5)
+
+# --- GUI setup ---
+
+lbl = Label((20, 70), "CrystalWindow Sandbox Ready 🧠")
+
+gui = GUIManager()
+gui.add(lbl)
+
+# --- rect testing helper ---
+draw = DrawHelper()
+draw.add_rect((300, 500, 200, 50), (50, 200, 255))
+
+# --- text system ---
+text_draw = DrawTextManager()
+text_draw.write("Hello Crystal Sandbox!", (250, 50), (255, 255, 255))
+
+# --- main loop ---
+running = True
+while running:
+    player.update()
+    gravity.apply()
+    win.fill((20, 20, 30))
+
+    draw.render()
+    player.draw(win)
+    gui.draw(win)
+    text_draw.render()
+
+    win.flip()
+
+win.run()
+win.quit()

crystalwindow/gametests/windowtesting.py

@@ -0,0 +1,5 @@
+from crystalwindow import Window
+
+win = Window(800, 600, "Crystal Demo")
+win.run()
+win.quit()