crystalwindow 1.4.7.5__py3-none-any.whl

crystalwindow/FileHelper.py

@@ -0,0 +1,77 @@
+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"):
+        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","*.*")]):
+        root = tk.Tk()
+        root.withdraw()
+        path = filedialog.asksaveasfilename(
+            initialdir=self.default_save_folder,
+            initialfile=default_name,
+            filetypes=filetypes,
+            defaultextension=filetypes[0][1]
+        )
+        root.destroy()
+        return path
+
+    def ask_open_file(self, filetypes=[("JSON files","*.json"),("All files","*.*")]):
+        root = tk.Tk()
+        root.withdraw()
+        path = filedialog.askopenfilename(
+            initialdir=self.default_save_folder,
+            filetypes=filetypes
+        )
+        root.destroy()
+        return path
+
+    # ---- TEXT ----
+    def save_text(self, filename, content):
+        path = os.path.join(self.default_save_folder, filename)
+        with open(path, "w", encoding="utf-8") as f:
+            f.write(content)
+        return path
+
+    def load_text(self, filename):
+        path = os.path.join(self.default_save_folder, filename)
+        if os.path.exists(path):
+            with open(path, "r", encoding="utf-8") as f:
+                return f.read()
+        return None
+
+    # ---- JSON ----
+    def save_json(self, filename, data):
+        path = os.path.join(self.default_save_folder, filename)
+        with open(path, "w", encoding="utf-8") as f:
+            json.dump(data, f, indent=4)
+        return path
+
+    def load_json(self, filename):
+        path = os.path.join(self.default_save_folder, filename)
+        if os.path.exists(path):
+            with open(path, "r", encoding="utf-8") as f:
+                return json.load(f)
+        return None
+
+    # ---- PICKLE ----
+    def save_pickle(self, filename, obj):
+        path = os.path.join(self.default_save_folder, filename)
+        with open(path, "wb") as f:
+            pickle.dump(obj, f)
+        return path
+
+    def load_pickle(self, filename):
+        path = os.path.join(self.default_save_folder, filename)
+        if os.path.exists(path):
+            with open(path, "rb") as f:
+                return pickle.load(f)
+        return None

crystalwindow/__init__.py

@@ -0,0 +1,15 @@
+from .window import Window
+from .sprites import Sprite
+from .tilemap import TileMap
+from .assets import load_image, load_folder_images, load_music, play_music
+from .animation import Animation
+from .collision import check_collision, resolve_collision
+from .player import Player
+from .gui import Button, Label, GUIManager, random_color, hex_to_rgb
+from .gui_ext import Toggle, Slider
+from .fun_helpers import random_name, DebugOverlay
+from .draw_helpers import gradient_rect, CameraShake
+from .draw_text_helper import DrawTextManager
+from .gravity import Gravity
+from .draw_rects import DrawHelper
+from .FileHelper import FileHelper

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,33 @@
+import pygame
+import os
+
+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)
+    ASSETS[path] = img
+    return img
+
+def load_folder_images(folder, size=None, 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)
+    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
+
+def play_music(loop=-1):
+    pygame.mixer.music.play(loop)

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,51 @@
+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))
+        return self
+
+    def square(self, win, x, y, size, color):
+        py.draw.rect(win.screen, color, (x, y, size, size))
+        return self
+
+    def circle(self, win, x, y, radius, color):
+        py.draw.circle(win.screen, 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))
+        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))
+        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))
+        return self

crystalwindow/draw_text_helper.py

@@ -0,0 +1,45 @@
+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/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/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,64 @@
+import pygame
+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 = pygame.Rect(rect)
+        self.text = text
+        self.color = color
+        self.hover_color = hover_color
+        self.callback = callback
+
+    def draw(self, win):
+        mouse_pos = win.mouse_pos
+        cur_color = self.hover_color if self.rect.collidepoint(mouse_pos) else self.color
+        win.draw_rect(cur_color, self.rect)
+        win.draw_text(self.text, pos=(self.rect.x+5, self.rect.y+5))
+
+    def check_click(self, win):
+        if self.rect.collidepoint(win.mouse_pos) and win.is_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,62 @@
+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)):
+        self.rect = rect
+        self.value = value
+        self.color = color
+        self.hover_color = hover_color
+        self.hovered = False
+
+    def update(self, win):
+        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.is_mouse_pressed(1):
+            self.value = not self.value
+
+    def draw(self, win):
+        draw_color = self.hover_color if self.hovered else self.color
+        win.draw_rect(draw_color, self.rect)
+
+from .window import Window
+
+class Slider:
+    def __init__(self, rect, min_val=0, max_val=100, value=50, color=(150,150,150), handle_radius=10):
+        self.rect = rect  # x, y, w, h
+        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
+
+        # Start dragging if clicked on the slider track or handle
+        handle_x = x + ((self.value - self.min_val) / (self.max_val - self.min_val)) * w
+        handle_y = y + h // 2
+        if win.is_mouse_pressed(1):
+            if (x <= mx <= x + w and y <= my <= y + h) or ((mx-handle_x)**2 + (my-handle_y)**2 <= self.handle_radius**2):
+                self.dragging = True
+        else:
+            self.dragging = False
+
+        # Drag the handle
+        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)
+
+    def draw(self, win: Window):
+        x, y, w, h = self.rect
+        # draw slider track
+        win.draw_rect(self.color, (x, y + h//2 - 2, w, 4))
+        # draw handle as circle
+        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/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,25 @@
+import pygame as py
+
+class Sprite:
+    def __init__(self, image=None, x=0, y=0, w=50, h=50, color=(255,255,255)):
+        self.image = image
+        self.x = x
+        self.y = y
+        self.color = color
+
+        # optional rect if no image
+        if image:
+            self.rect = self.image.get_rect(topleft=(x, y))
+        else:
+            self.rect = py.Rect(x, y, w, h)
+
+    def draw(self, screen):
+        if self.image:
+            screen.blit(self.image, (self.x, self.y))
+        else:
+            py.draw.rect(screen, self.color, self.rect)
+
+    def move(self, dx, dy):
+        self.x += dx
+        self.y += dy
+        self.rect.topleft = (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/window.py

@@ -0,0 +1,203 @@
+import pygame
+from pygame import image
+import os
+import sys
+import contextlib
+import base64, io
+
+DEFAULT_LOGO_BASE64 = "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"
+
+class Window:
+    # friendly string -> pygame constant mapping
+    KEY_MAP = {
+        "left": pygame.K_LEFT,
+        "right": pygame.K_RIGHT,
+        "up": pygame.K_UP,
+        "down": pygame.K_DOWN,
+        "space": pygame.K_SPACE,
+        "enter": pygame.K_RETURN,
+        "backspace": pygame.K_BACKSPACE,
+        "tab": pygame.K_TAB,
+        "escape": pygame.K_ESCAPE,
+        "Rshift": pygame.K_LSHIFT,
+        "Lctrl": pygame.K_LCTRL,
+        "Rshift": pygame.K_RSHIFT,
+        "Rctrl": pygame.K_RCTRL,
+        "alt": pygame.K_LALT,
+        "keya": pygame.K_a,
+        "keyb": pygame.K_b,
+        "keyc": pygame.K_c,
+        "keyd": pygame.K_d,
+        "keye": pygame.K_e,
+        "keyf": pygame.K_f,
+        "keyg": pygame.K_g,
+        "keyh": pygame.K_h,
+        "keyi": pygame.K_i,
+        "keyj": pygame.K_j,
+        "keyk": pygame.K_k,
+        "keyl": pygame.K_l,
+        "keym": pygame.K_m,
+        "keyn": pygame.K_n,
+        "keyo": pygame.K_o,
+        "keyp": pygame.K_p,
+        "keyq": pygame.K_q,
+        "keyr": pygame.K_r,
+        "keys": pygame.K_s,
+        "keyt": pygame.K_t,
+        "keyu": pygame.K_u,
+        "keyv": pygame.K_v,
+        "keyw": pygame.K_w,
+        "keyx": pygame.K_x,
+        "keyy": pygame.K_y,
+        "keyz": pygame.K_z,
+        "0": pygame.K_0,
+        "1": pygame.K_1,
+        "2": pygame.K_2,
+        "3": pygame.K_3,
+        "4": pygame.K_4,
+        "5": pygame.K_5,
+        "6": pygame.K_6,
+        "7": pygame.K_7,
+        "8": pygame.K_8,
+        "9": pygame.K_9,
+        "f1": pygame.K_F1,
+        "f2": pygame.K_F2,
+        "f3": pygame.K_F3,
+        "f4": pygame.K_F4,
+        "f5": pygame.K_F5,
+        "f6": pygame.K_F6,
+        "f7": pygame.K_F7,
+        "f8": pygame.K_F8,
+        "f9": pygame.K_F9,
+        "f10": pygame.K_F10,
+        "f11": pygame.K_F11,
+        "f12": pygame.K_F12,
+        "insert": pygame.K_INSERT,
+        "delete": pygame.K_DELETE,
+        "home": pygame.K_HOME,
+        "end": pygame.K_END,
+        "pageup": pygame.K_PAGEUP,
+        "pagedown": pygame.K_PAGEDOWN,
+        "capslock": pygame.K_CAPSLOCK,
+        "numlock": pygame.K_NUMLOCK,
+        "scrolllock": pygame.K_SCROLLOCK,
+    }
+
+
+    def __init__(self, width=640, height=480, title="Game Window", icon=None):
+        # temporarily silence pygame print
+        with open(os.devnull, "w") as f, contextlib.redirect_stdout(f):
+            pygame.init()  # <- no more hello message
+
+        self.width = width
+        self.height = height
+        self.title = title
+        self.screen = pygame.display.set_mode((width, height))
+        pygame.display.set_caption(title)
+
+        # --- ICON HANDLING ---
+        if icon:
+            # user-provided icon logic
+            if isinstance(icon, str):
+                icon_path = icon
+                if not os.path.isabs(icon_path):
+                    icon_path = os.path.join(os.getcwd(), icon)
+                if os.path.exists(icon_path):
+                    img = pygame.image.load(icon_path).convert_alpha()
+                    pygame.display.set_icon(img)
+                else:
+                    print(f"⚠️ Icon file not found: {icon_path}")
+            else:
+                pygame.display.set_icon(icon)
+        else:
+            default_icon_path = os.path.join(os.path.dirname(__file__), "icons", "default_icon.png")
+            if os.path.exists(default_icon_path):
+                img = pygame.image.load(default_icon_path).convert_alpha()
+                pygame.display.set_icon(img)
+            else:
+                icon_bytes = base64.b64decode(DEFAULT_LOGO_BASE64)
+                icon_file = io.BytesIO(icon_bytes)
+                img = image.load(icon_file).convert_alpha()
+                pygame.display.set_icon(img)
+
+        self.clock = pygame.time.Clock()
+        self.running = True
+        self.keys = {}
+        self.mouse_pos = (0,0)
+        self.mouse_pressed = (False, False, False)
+        self.draw_calls = []
+
+    # === input helpers ===
+    def is_key_pressed(self, key):
+        # key can be pygame constant OR string from KEY_MAP
+        if isinstance(key, str):
+            key = self.KEY_MAP.get(key, None)
+            if key is None:
+                return False
+        return self.keys.get(key, False)
+
+    def is_mouse_pressed(self, button=1):
+        return self.mouse_pressed[button-1]
+
+    # === font system ===
+    def get_font(self, name="Arial", size=16, bold=False, italic=False):
+        if not hasattr(self, "font_cache"):
+            self.font_cache = {}
+        key = (name, size, bold, italic)
+        if key not in self.font_cache:
+            try:
+                font = pygame.font.SysFont(name, size, bold, italic)
+            except:
+                font = pygame.font.Font(None, size)
+            self.font_cache[key] = font
+        return self.font_cache[key]
+
+    def draw_text(self, text, font="Arial", size=16, color=(255,255,255), pos=(0,0), bold=False, italic=False):
+        f = self.get_font(font, size, bold, italic)
+        surf = f.render(text, True, color)
+        self.screen.blit(surf, pos)
+
+    # === drawing helpers ===a
+    def draw_rect(self, color, rect):
+        self.draw_calls.append(("rect", color, rect))
+
+    def draw_circle(self, color, pos, radius):
+        self.draw_calls.append(("circle", color, pos, radius))
+
+    def draw_sprite(self, sprite):
+        self.draw_calls.append(("sprite", sprite))
+
+    # === main loop ===
+    def run(self, update_func=None):
+        while self.running:
+            for event in pygame.event.get():
+                if event.type == pygame.QUIT:
+                    self.running = False
+                elif event.type == pygame.KEYDOWN:
+                    self.keys[event.key] = True
+                elif event.type == pygame.KEYUP:
+                    self.keys[event.key] = False
+                elif event.type == pygame.MOUSEBUTTONDOWN:
+                    self.mouse_pressed = pygame.mouse.get_pressed()
+                elif event.type == pygame.MOUSEBUTTONUP:
+                    self.mouse_pressed = pygame.mouse.get_pressed()
+                elif event.type == pygame.MOUSEMOTION:
+                    self.mouse_pos = event.pos
+
+            if update_func:
+                update_func(self)
+
+            self.screen.fill((20,20,50))
+            for call in self.draw_calls:
+                if call[0] == "rect":
+                    pygame.draw.rect(self.screen, call[1], call[2])
+                elif call[0] == "circle":
+                    pygame.draw.circle(self.screen, call[1], call[2], call[3])
+                elif call[0] == "sprite":
+                    call[1].draw(self.screen)
+            self.draw_calls.clear()
+
+            pygame.display.flip()
+            self.clock.tick(60)
+
+        pygame.quit()

crystalwindow-1.4.7.5.dist-info/METADATA

@@ -0,0 +1,19 @@
+Metadata-Version: 2.4
+Name: crystalwindow
+Version: 1.4.7.5
+Summary: pygame but remade, easy window/player/tile handling
+Author: CrystalBallyHereXD
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: pygame>=2.3.0
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+pygame but easier!. Made by CrystalBallyHereXD!

crystalwindow-1.4.7.5.dist-info/RECORD

@@ -0,0 +1,20 @@
+crystalwindow/FileHelper.py,sha256=o1n0_a2Fv1yhaHd0o1imJlFs_9hz4X8GAZRvxpZoBa4,2613
+crystalwindow/__init__.py,sha256=BkXswsLJo-TupGDQtaGwBvsLWf1yqkvYZhqXRoxWAyY,646
+crystalwindow/animation.py,sha256=zHjrdBXQeyNaLAuaGPldJueX05OZ5j31YR8NizmR0uQ,427
+crystalwindow/assets.py,sha256=LR2ocZ0BUxz8qZqEtx1s-WvxwY60b2OmxlzGj_Hyrao,1022
+crystalwindow/collision.py,sha256=hpkHTp_KparghVK-itp_rxuYdd2GbQMxICHlUBv0rSw,472
+crystalwindow/draw_helpers.py,sha256=HqjI5fTbdnA55g4LKYEuMUdIjrWaBm2U8RmeUXjcQGw,821
+crystalwindow/draw_rects.py,sha256=TT9CA9aSkLXq6VtApkuHEGtRHjazXj_ph2cXCwEYJQQ,1945
+crystalwindow/draw_text_helper.py,sha256=CGF2Kk39IxggzY5w-iDA4XzRwxiMDLH0LMBKIQQOO4s,1276
+crystalwindow/fun_helpers.py,sha256=fo5yTwGENltdtVIVwgITtUkvzpsImujOcqTxe8XPzR8,760
+crystalwindow/gravity.py,sha256=tMctHYubpcUJRogz4kNg3XZGDPE3605zON-4YumiVGo,2752
+crystalwindow/gui.py,sha256=ApsavaunPEKufJFIXO1vEDsJpLqUSkMoqSajYAH1swU,2101
+crystalwindow/gui_ext.py,sha256=_91W9amoum0fJ8iHTdOoD8L5bS7n-4XBs-9J5HUb5dA,2274
+crystalwindow/player.py,sha256=4wpIdUZLTlRXV8fDRQ11yVJRbx_cv8Ekpn2y7pQGgAQ,3442
+crystalwindow/sprites.py,sha256=xIVeMIDMKotaQUX4h3jXp1nyt6P5BmelRWrjFz7wAA8,696
+crystalwindow/tilemap.py,sha256=PHoKL1eWuNeHIf0w-Jh5MGdQGEgklVsxqqJOS-GNMKI,322
+crystalwindow/window.py,sha256=ecz-X_pawW11ry7TIkao8Z1txxphLPfEJpZvDel_eyQ,17370
+crystalwindow-1.4.7.5.dist-info/METADATA,sha256=RSAvZEJQZutdB1gndsaFJUgvCNLNjTs-_vzWIzZMJb4,558
+crystalwindow-1.4.7.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+crystalwindow-1.4.7.5.dist-info/top_level.txt,sha256=PeQSld4b19XWT-zvbYkvE2Xg8sakIMbDzSzSdOSRN8o,14
+crystalwindow-1.4.7.5.dist-info/RECORD,,

crystalwindow-1.4.7.5.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

crystalwindow-1.4.7.5.dist-info/top_level.txt

@@ -0,0 +1 @@
+crystalwindow