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

crystalwindow/crystal3d.py

@@ -1,61 +1,140 @@
-import math, tkinter as tk
+import math
 
+def _lerp(a, b, t):
+    return a + (b - a) * t
+
+class CW3DShape:
+    def __init__(self, kind, color, size=1.0, thickness=2, fill=None, texture=None,
+                 points=5, inner_ratio=0.5):
+        """
+        kind: 'cube', 'triangle', 'circle', 'rectangle', 'pentagon', 'star', 'ngon'
+        color: outline color (r,g,b)
+        size: scale factor
+        thickness: line thickness
+        fill: optional fill color
+        texture: optional texture placeholder
+        points: number of points (for stars/ngons)
+        inner_ratio: for stars, inner radius ratio (0.0-1.0)
+        """
+        self.kind = kind
+        self.color = color
+        self.size = size
+        self.thickness = thickness
+        self.fill = fill
+        self.texture = texture
+
+        self.rot_x = 0
+        self.rot_y = 0
+        self.smooth = False
+        self.smooth_strength = 0.15
+        self._sx = 0
+        self._sy = 0
+
+        self.points = points
+        self.inner_ratio = inner_ratio
+
+    def spin(self, rx, ry):
+        self.rot_x += rx
+        self.rot_y += ry
+
+    def set_smooth(self, enable=True, strength=0.15):
+        self.smooth = enable
+        self.smooth_strength = strength
+
+    def _smoothed(self):
+        if not self.smooth:
+            return self.rot_x, self.rot_y
+        self._sx = _lerp(self._sx, self.rot_x, self.smooth_strength)
+        self._sy = _lerp(self._sy, self.rot_y, self.smooth_strength)
+        return self._sx, self._sy
+
+    # ----------------------------------------------------------
+    # DRAW ROUTE
+    # ----------------------------------------------------------
+    def draw(self, win):
+        w, h = win.width, win.height
+        rx, ry = self._smoothed()
+
+        if self.kind == "cube":
+            self._draw_cube(win, w, h, rx, ry)
+        elif self.kind == "triangle":
+            self._draw_triangle(win, w, h, rx, ry)
+        elif self.kind == "circle":
+            self._draw_circle(win, w, h, rx, ry)
+        elif self.kind == "rectangle":
+            self._draw_rectangle(win, w, h, rx, ry)
+        elif self.kind == "pentagon":
+            self._draw_polygon(win, w, h, 5, rx, ry)
+        elif self.kind == "star":
+            self._draw_star(win, w, h, rx, ry)
+        elif self.kind == "ngon":
+            self._draw_polygon(win, w, h, self.points, rx, ry)
+
+    # ----------------------------------------------------------
+    # GENERIC POLYGON
+    # ----------------------------------------------------------
+    def _draw_polygon(self, win, w, h, sides, rx, ry):
+        cx, cy = w//2, h//2
+        r = self.size * 80
+        verts = []
+        for i in range(sides):
+            angle = -math.pi/2 + i * 2 * math.pi / sides
+            verts.append((cx + math.cos(angle) * r, cy + math.sin(angle) * r))
+        if self.fill:
+            win.draw_polygon(verts, self.fill)
+        win.draw_polygon_outline(verts, self.color, self.thickness)
+
+    # ----------------------------------------------------------
+    # STAR
+    # ----------------------------------------------------------
+    def _draw_star(self, win, w, h, rx, ry):
+        cx, cy = w//2, h//2
+        outer_r = self.size * 80
+        inner_r = outer_r * self.inner_ratio
+        verts = []
+        step = math.pi / self.points
+        ang = -math.pi / 2
+        for i in range(self.points * 2):
+            r = outer_r if i % 2 == 0 else inner_r
+            verts.append((cx + math.cos(ang) * r, cy + math.sin(ang) * r))
+            ang += step
+        if self.fill:
+            win.draw_polygon(verts, self.fill)
+        win.draw_polygon_outline(verts, self.color, self.thickness)
+
+# ==========================================================
+# CW3D ENGINE (MANAGER)
+# ==========================================================
 class CW3D:
     def __init__(self, win):
-        self.canvas = win.canvas
-        self.angle_x = 0
-        self.angle_y = 0
-        self.zoom = 200
-        self.objects = []
-
-    def project(self, x, y, z):
-        """Simple 3D → 2D projection"""
-        scale = self.zoom / (z + 4)
-        px = self.canvas.winfo_width()/2 + x * scale
-        py = self.canvas.winfo_height()/2 + y * scale
-        return px, py
-
-    def rotate_point(self, x, y, z):
-        """Rotate around X/Y axes"""
-        y2 = y * math.cos(self.angle_x) - z * math.sin(self.angle_x)
-        z2 = y * math.sin(self.angle_x) + z * math.cos(self.angle_x)
-        x2 = x * math.cos(self.angle_y) + z2 * math.sin(self.angle_y)
-        z3 = -x * math.sin(self.angle_y) + z2 * math.cos(self.angle_y)
-        return x2, y2, z3
-
-    def add_cube(self, size=1, color="cyan"):
-        """Add a simple cube"""
-        s = size
-        points = [
-            [-s, -s, -s], [s, -s, -s],
-            [s,  s, -s], [-s,  s, -s],
-            [-s, -s,  s], [s, -s,  s],
-            [s,  s,  s], [-s,  s,  s],
-        ]
-        edges = [
-            (0,1),(1,2),(2,3),(3,0),
-            (4,5),(5,6),(6,7),(7,4),
-            (0,4),(1,5),(2,6),(3,7)
-        ]
-        self.objects.append(("cube", points, edges, color))
+        self.win = win
+        self.shapes = []
+
+    def add_cube(self, size=1.0, color=(255,255,255), thickness=2, fill=None):
+        self.shapes.append(CW3DShape("cube", color, size, thickness, fill, None))
+
+    def add_triangle(self, size=1.0, color=(255,255,255), thickness=2, fill=None):
+        self.shapes.append(CW3DShape("triangle", color, size, thickness, fill, None))
+
+    def add_circle(self, size=1.0, color=(255,255,255), thickness=2):
+        self.shapes.append(CW3DShape("circle", color, size, thickness, None, None))
+
+    def add_rectangle(self, size=1.0, color=(255,255,255), thickness=2, fill=None):
+        self.shapes.append(CW3DShape("rectangle", color, size, thickness, fill, None))
+
+    def add_pentagon(self, size=1.0, color=(255,255,255), thickness=2, fill=None):
+        self.shapes.append(CW3DShape("pentagon", color, size, thickness, fill, None))
+
+    def add_star(self, size=1.0, color=(255,255,255), thickness=2, fill=None, points=5, inner_ratio=0.5):
+        self.shapes.append(CW3DShape("star", color, size, thickness, fill, None, points, inner_ratio))
+
+    def add_ngon(self, size=1.0, points=6, color=(255,255,255), thickness=2, fill=None):
+        self.shapes.append(CW3DShape("ngon", color, size, thickness, fill, None, points))
+
+    def spin(self, rx, ry):
+        for s in self.shapes:
+            s.spin(rx, ry)
 
     def draw(self):
-        """Draw all objects"""
-        self.canvas.delete("all")
-        for obj in self.objects:
-            _, pts, edges, color = obj
-            rotated = [self.rotate_point(*p) for p in pts]
-            for a, b in edges:
-                x1, y1 = self.project(*rotated[a])
-                x2, y2 = self.project(*rotated[b])
-                self.canvas.create_line(x1, y1, x2, y2, fill=color, width=2)
-
-    def spin(self, ax=0.02, ay=0.03):
-        self.angle_x += ax
-        self.angle_y += ay
-
-    def run(self):
-        """Auto loop"""
-        self.draw()
-        self.spin()
-        self.canvas.after(16, self.run)
+        for s in self.shapes:
+            s.draw(self.win)

crystalwindow/fun_helpers.py

@@ -12,6 +12,10 @@ def random_name():
     syllables = ["ka","zi","lo","ra","mi","to","na","ve"]
     return "".join(random.choice(syllables) for _ in range(3))
 
+#Choose a random number
+def random_number(min_val, max_val):
+    return random.randint(min_val, max_val)
+
 # tween helper
 def lerp(a, b, t):
     return a + (b - a) * t

crystalwindow/gametests/3dsquare.py

@@ -1,8 +1,8 @@
-from crystalwindow import Window, CW3D, Clock
+from crystalwindow import Window, CW3DShape, Clock
 
 win = Window(800, 600, "CrystalWindow 3D Wavy Background")
 clock = Clock()
-cw3d = CW3D(win)
+cw3d = CW3DShape(win)
 cw3d.add_cube(size=1.3, color="cyan")
 
 # brightness wave vars

crystalwindow/gametests/gravitytest.py

@@ -1,26 +1,17 @@
-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
+import sys
+sys.path.insert(0, r"c:/Users/USUARIO/Desktop/crystalwindow")
 
-    # draw either sprite or rect
-    def draw(self, win):
-        win.draw_rect(self.color, (self.x, self.y, self.width, self.height))
+from crystalwindow import *
+import time
 
-# --- setup window ---
-win = Window(800, 600, "Gravity Sprite/Rect Test")
+# --- window ---
+win = Window(800, 600, "Debug Panel Test")
 
-# --- player as colored rect ---
-player = PlayerRect(100, 100, 50, 50, color=(0,255,0))
+# --- player ---
+player = Player(name="Player", pos=(0, 0), size=(32, 32), speed=4,hp=100)
+enemy = Enemy((100, 100), 50, 50, 10, 0, color=(255, 0, 0))
 
-# --- platform as rect ---
+# --- platform ---
 class Platform:
     def __init__(self, x, y, w, h, color=(100,200,100)):
         self.x = x
@@ -33,15 +24,97 @@ class Platform:
 
 platform = Platform(0, 500, 800, 50)
 
-# --- attach gravity ---
+# --- gravity ---
 player.gravity = Gravity(player, force=1, bouncy=True, bounce_strength=0.7)
 
-# --- main loop ---
+# ==========================================
+#        DEBUG PANEL SYSTEM
+# ==========================================
+gui = GUIManager()
+
+panel_open = False
+fly_mode = False
+
+# panel background (Sprite.rect)
+debug_panel = Sprite.rect((20, 20), 220, 140, color=(0,0,0))
+debug_panel.alpha = 160  # make it transparent
+
+# BUTTON CALLBACKS
+def toggle_fly():
+    global fly_mode
+    fly_mode = not fly_mode
+    fly_button.text = f"Fly: {'ON' if fly_mode else 'OFF'}"
+
+# create buttons
+fly_button = Button(rect=(35, 60, 180, 40),
+                    text="Fly: OFF",
+                    color=(150,150,150),
+                    hover_color=(200,200,200),
+                    callback=toggle_fly)
+
+gui.add(fly_button)
+
+cooldown = 0
+
+# ==========================================
+#            MAIN UPDATE
+# ==========================================
 def update(win):
-    player.gravity.update(1/60, [platform])
-    win.screen.fill((20,20,50))
+    global panel_open, fly_mode, cooldown
+
+    win.fill((20,20,50))
+
+    # PANEL TOGGLE KEY
+    if win.key_pressed("f1") and time.time() > cooldown:
+        panel_open = not panel_open
+        cooldown = time.time() + 0.25
+
+    if win.key_pressed("f") and not panel_open and time.time() > cooldown:
+        fly_mode = not fly_mode
+        cooldown = time.time() + 0.2
+
+    # -------------------------------
+    #         GAME LOGIC
+    # -------------------------------
+    if fly_mode:
+        # disable gravity
+        player.gravity.vel_y = 0
+
+        # free fly movement
+        if win.key_pressed("keyw"): player.y -= 6
+        if win.key_pressed("keys"): player.y += 6
+        if win.key_pressed("keya"): player.x -= 6
+        if win.key_pressed("keyd"): player.x += 6
+    else:
+        # normal gravity
+        player.gravity.update(1/60, [platform])
+
+        # jumping + movement
+        if win.key_pressed("keyw"): player.vel_y = -6
+        if win.key_pressed("keya"): player.x -= 10
+        if win.key_pressed("keyd"): player.x += 10
+
+    # draw world
     player.draw(win)
     platform.draw(win)
+    enemy.draw(win)
+
+    enemy.update(60)
+
+    if enemy.collide_with(player):
+        player.hp -= enemy.dmg
+    if player.dead:
+        player.respawn(win)    
+
+    win.draw_text(f"CurrentHP: {player.hp}", font="Arial", size=16, color=(255, 255, 255))
+    # -------------------------------
+    #      SHOW DEBUG PANEL
+    # -------------------------------
+    if panel_open:
+        debug_panel.draw(win)   # panel bg
+        gui.draw(win)           # buttons
+        gui.update(win)         # button callbacks
+
 
 win.run(update)
 win.quit()

crystalwindow/gametests/guitesting.py

@@ -1,5 +1,9 @@
+import sys
+sys.path.insert(0, r"c:/Users/USUARIO/Desktop/crystalwindow")
+
 from crystalwindow import *
 
+
 # --- Window setup ---
 win = Window(800, 600, "CrystalWindowLib Mega Sandbox")
 
@@ -49,8 +53,6 @@ def update(win):
     # --- 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/squaremove.py

@@ -6,7 +6,7 @@ PlayerCube = Sprite.rect((400, 300), 50, 50, color=(0,100,254))
 def gamerun(win):
     PlayerCube.draw(win)
 
-    win.draw_text("This is a crystalwindow test. (you can leave)", size=30, color=(255,255,255), pos=(25,25))
+    win.draw_text("This is a crystalwindow test. (you can leave using ESC)", size=21, color=(255,255,255), pos=(25,25))
 
     if win.key_pressed("keyw"):
         PlayerCube.y -= 10
@@ -17,5 +17,8 @@ def gamerun(win):
     if win.key_pressed("keyd"):
         PlayerCube.x += 10
 
+    if win.key_pressed("escape"):
+        win.quit()    
+
 win.run(gamerun)
 win.quit()

crystalwindow/gametests/testtttagain.py

@@ -0,0 +1,17 @@
+import sys
+sys.path.insert(0, r"c:/Users/USUARIO/Desktop/crystalwindow")
+
+from crystalwindow import *
+
+win = Window(800, 600, "Debug Panel Test")
+
+# THIS WILL FAIL TO LOAD → fallback → checkerboard
+game = load_image("SAKJDNSAOJDOSAJND;ONJSIOAJVO")
+
+player = Sprite.image(game, (100, 100))
+
+def gameruns(win):
+    player.draw(win)
+
+win.run()
+win.quit()

crystalwindow/gui.py

@@ -2,6 +2,7 @@
 import random
 import tkinter as tk
 from crystalwindow import *
+import time
 
 # ----------------- Color Helpers -----------------
 def hex_to_rgb(hex_str):
@@ -15,28 +16,96 @@ 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 = rect  # (x, y, w, h)
+    def __init__(self, rect, text,
+                 color=(200,200,200),
+                 hover_color=(255,255,255),
+                 press_color=(180,180,180),
+                 text_color=(0,0,0)):
+
+        self.rect = rect
         self.text = text
+
         self.color = color
         self.hover_color = hover_color
-        self.callback = callback
+        self.press_color = press_color
+        self.text_color = text_color
+
+        # States
         self.hovered = False
+        self._held = False
+        self._clicked = False
+        self._released = 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))
+        self._was_down = False   # mouse prev frame
+        self._cooldown = 0.05    # tiny debounce like Toggle
+        self._last_click = 0
 
-    def check_click(self, win):
+    # ======================================
+    #   UPDATE (same style as slider/toggle)
+    # ======================================
+    def update(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()
+
+        # Reset transient states
+        self._clicked = False
+        self._released = False
+
+        # Hover
+        self.hovered = (x <= mx <= x + w and y <= my <= y + h)
+
+        mouse_down = win.mouse_pressed(1)
+
+        # HELD
+        if self.hovered and mouse_down:
+            self._held = True
+        else:
+            self._held = False
+
+        # CLICKED (fires once)
+        now = time.time()
+        if self.hovered and mouse_down and not self._was_down:
+            if now - self._last_click >= self._cooldown:
+                self._clicked = True
+                self._last_click = now
+
+        # RELEASED (fires once)
+        if not mouse_down and self._was_down and self.hovered:
+            self._released = True
+
+        self._was_down = mouse_down
+
+    # ======================================
+    #   PUBLIC GETTERS
+    # ======================================
+    def clicked(self):
+        return self._clicked
+
+    def held(self):
+        return self._held
+
+    def released(self):
+        return self._released
+
+    def hovering(self):
+        return self.hovered
+
+    # ======================================
+    #   DRAW
+    # ======================================
+    def draw(self, win):
+        x, y, w, h = self.rect
+
+        # choose color by state
+        if self._held:
+            col = self.press_color
+        elif self.hovered:
+            col = self.hover_color
+        else:
+            col = self.color
+
+        win.draw_rect(col, (x, y, w, h))
+        win.draw_text(self.text, pos=(x + 5, y + 5), color=self.text_color)
 
 class Label:
     def __init__(self, pos, text, color=(255,255,255), font="Arial", size=16):
@@ -106,9 +175,10 @@ class GUIManager:
 
     def draw(self, win):
         for e in self.elements:
-            e.draw(win)
+            if hasattr(e, "draw"):
+                e.draw(win)
 
     def update(self, win):
         for e in self.elements:
-            if isinstance(e, Button):
-                e.check_click(win)
+            if hasattr(e, "update"):
+                e.update(win)