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

crystalwindow/FileHelper.py

@@ -1,3 +1,10 @@
+"""
+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
@@ -9,84 +16,127 @@ class FileHelper:
     """CrystalWindow integrated file helper with default folders & Tk dialogs."""
 
     def __init__(self, default_save_folder="saves"):
-        # auto-make folder if not found
+        """
+        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 ----
+    # -------------------------------------------------------------------------
+    # TK FILE DIALOGS
+    # -------------------------------------------------------------------------
     def ask_save_file(self, default_name="save.json",
                       filetypes=[("JSON files", "*.json"), ("All files", "*.*")]):
-        """Open a Tkinter Save dialog inside default folder."""
+        """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
+        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 inside default folder."""
+        """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
+        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 ----
+    # -------------------------------------------------------------------------
+    # TEXT FILES
+    # -------------------------------------------------------------------------
     def save_text(self, filename, content):
-        """Save plain text data to file."""
-        path = os.path.join(self.default_save_folder, filename)
+        """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 file."""
-        path = os.path.join(self.default_save_folder, filename)
-        if os.path.exists(path):
+        """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: {filename}")
+        print(f"[WARN] Text file not found: {path}")
         return None
 
-    # ---- JSON ----
+    # -------------------------------------------------------------------------
+    # JSON FILES
+    # -------------------------------------------------------------------------
     def save_json(self, filename, data):
-        """Save JSON serializable data."""
-        path = os.path.join(self.default_save_folder, filename)
+        """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 file."""
-        path = os.path.join(self.default_save_folder, filename)
-        if os.path.exists(path):
+        """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: {filename}")
+        print(f"[WARN] JSON file not found: {path}")
         return None
 
-    # ---- PICKLE ----
+    # -------------------------------------------------------------------------
+    # PICKLE FILES
+    # -------------------------------------------------------------------------
     def save_pickle(self, filename, obj):
-        """Save object using pickle (binary)."""
-        path = os.path.join(self.default_save_folder, filename)
+        """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 pickle file (binary)."""
-        path = os.path.join(self.default_save_folder, filename)
-        if os.path.exists(path):
+        """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: {filename}")
+        print(f"[WARN] Pickle file not found: {path}")
         return None
+

crystalwindow/__init__.py

@@ -1,47 +1,57 @@
 # crystalwindow/__init__.py
-# 🪞 CrystalWindow - Master import hub
+# 💎 CrystalWindow - Master Import Hub
+from .ver_warner import check_for_update
+check_for_update("crystalwindow")
 
-# --- Core systems ---
+# === 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 & Animations ---
+# === Assets & Animation ===
 from .assets import load_image, load_folder_images, load_music, play_music
 from .animation import Animation
 
-# --- Collision ---
+# === Collision ===
 from .collision import check_collision, resolve_collision
 
-# --- GUI & Extensions ---
+# === GUI & Extensions ===
 from .gui import Button, Label, GUIManager, random_color, hex_to_rgb
 from .gui_ext import Toggle, Slider
 
-# --- Drawing Helpers ---
+# === 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 ---
+# === Misc Helpers ===
 from .fun_helpers import random_name, DebugOverlay
 
 
 __all__ = [
-    # Core
-    "Window", "Sprite", "TileMap", "Player", "Gravity", "FileHelper",
-    # Assets & Animation
+    # --- Core ---
+    "Window", "Sprite", "TileMap", "Player", "Gravity", "FileHelper", "Mathematics",
+    
+    # --- Assets & Animation ---
     "load_image", "load_folder_images", "load_music", "play_music", "Animation",
-    # Collision
+    
+    # --- Collision ---
     "check_collision", "resolve_collision",
-    # GUI
+    
+    # --- GUI ---
     "Button", "Label", "GUIManager", "random_color", "hex_to_rgb",
-    # GUI Ext
+    
+    # --- GUI Extensions ---
     "Toggle", "Slider",
-    # Drawing
-    "gradient_rect", "CameraShake", "DrawHelper", "DrawTextManager",
-    # Misc
-    "random_name", "DebugOverlay"
+    
+    # --- Drawing ---
+    "gradient_rect", "CameraShake", "DrawHelper", "DrawTextManager", "CrystalDraw",
+    
+    # --- Misc ---
+    "random_name", "DebugOverlay",
 ]

crystalwindow/assets.py

@@ -1,33 +1,30 @@
-import pygame
 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 = pygame.image.load(path).convert_alpha()
-    if size:
-        img = pygame.transform.scale(img, size)
+    img = PhotoImage(file=path)
     ASSETS[path] = img
     return img
 
-def load_folder_images(folder, size=None, nested=True):
+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, size=size, nested=True)
-        elif item.lower().endswith((".png", ".jpg", ".jpeg")):
-            result[item] = load_image(full_path, size=size)
+            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):
-    if not os.path.exists(path):
-        raise FileNotFoundError(f"Music not found: {path}")
-    pygame.mixer.music.load(path)
-    ASSETS[path] = path
-    return 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):
-    pygame.mixer.music.play(loop)
+    """No-op: placeholder."""
+    print("[assets] Music playback not supported in this current crystalwindow ver sorry! ~Crystal")

crystalwindow/draw_rects.py

@@ -1,51 +1,36 @@
-import pygame as py
 from crystalwindow import *
 
 class DrawHelper:
-    def __init__(self):
-        pass
-
     def rect(self, win, x, y, w, h, color):
-        py.draw.rect(win.screen, color, (x, y, w, h))
+        win.draw_rect(color, (x, y, w, h))
         return self
 
     def square(self, win, x, y, size, color):
-        py.draw.rect(win.screen, color, (x, y, size, size))
+        win.draw_rect(color, (x, y, size, size))
         return self
 
     def circle(self, win, x, y, radius, color):
-        py.draw.circle(win.screen, color, (x, y), radius)
+        win.draw_circle(color, (x, y), radius)
         return self
 
     def triangle(self, win, points, color):
-        py.draw.polygon(win.screen, color, points)
-        return self
-
-    def texture(self, win, x, y, w, h, image):
-        if image:
-            img = py.transform.scale(image, (w, h))
-            win.screen.blit(img, (x, y))
+        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):
-        fnt = py.font.SysFont(font, size, bold=bold, italic=cursive)
-        surf = fnt.render(text, True, color)
-        win.screen.blit(surf, (x, y))
+        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):
-        if vertical:
-            for i in range(h):
-                ratio = i / h
-                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)
-                py.draw.line(win.screen, (r, g, b), (x, y+i), (x+w, y+i))
-        else:
-            for i in range(w):
-                ratio = i / 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)
-                py.draw.line(win.screen, (r, g, b), (x+i, y), (x+i, y+h))
+        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

@@ -1,3 +1,4 @@
+#draw_text_helper.py
 from .window import Window
 
 class DrawTextManager:

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/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()

crystalwindow/gui.py

@@ -1,4 +1,4 @@
-import pygame
+#gui.py
 import random
 
 # ----------------- Color Helpers -----------------
@@ -18,20 +18,25 @@ def lerp_color(c1, c2, t):
 # ----------------- GUI Elements -----------------
 class Button:
     def __init__(self, rect, text, color=(200,200,200), hover_color=(255,255,255), callback=None):
-        self.rect = pygame.Rect(rect)
+        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):
-        mouse_pos = win.mouse_pos
-        cur_color = self.hover_color if self.rect.collidepoint(mouse_pos) else self.color
+        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=(self.rect.x+5, self.rect.y+5))
+        win.draw_text(self.text, pos=(x+5, y+5))
 
     def check_click(self, win):
-        if self.rect.collidepoint(win.mouse_pos) and win.is_mouse_pressed(1):
+        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()