crystalwindow 4.8__tar.gz → 5.0__tar.gz

{crystalwindow-4.8/crystalwindow.egg-info → crystalwindow-5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: crystalwindow
-Version: 4.8
+Version: 5.0
 Summary: A Tkinter powered window + GUI toolkit made by Crystal (ME)! Easier apps, smoother UI and all-in-one helpers!, Gui, Buttons, FileHelper, Sprites, Animations, Colors, Math, Gravity, Camera, 3D and more!
 Home-page: https://pypi.org/project/crystalwindow/
 Author: CrystalBallyHereXD

{crystalwindow-4.8 → crystalwindow-5.0}/crystalwindow/__init__.py

@@ -44,7 +44,7 @@ from .draw_text_helper import DrawTextManager
 from .draw_tool import CrystalDraw
 
 # === Misc Helpers ===
-from .fun_helpers import random_name, DebugOverlay, random_color, random_palette, lerp, random_number
+from .fun_helpers import random_name, DebugOverlay, random_color, random_palette, lerp, random_number, random_pos, random_bool, random_choice_weighted, difference
 from .camera import Camera
 from .color_handler import Colors, Color
 from .websearch import SearchResult, WebBrowse
@@ -52,6 +52,11 @@ from .websearch import SearchResult, WebBrowse
 # === 3D Engine ===
 from .crystal3d import CW3DShape, CW3D
 
+# === Chatting/VPN Engine =====
+from .chatvpn import ChatVPN, ChatVPNServer
+
+# ==== Message Bus ====
+from .messagebus import send_message, view_message, clear_messages
 
 __all__ = [
     # --- Core ---
@@ -88,9 +93,14 @@ __all__ = [
 
     # --- Misc ---
     "random_name", "DebugOverlay", "Camera", "Colors", "Color",
-    "random_palette", "lerp", "SearchResult", "WebBrowse", "random_number",
+    "random_palette", "lerp", "SearchResult", "WebBrowse", "random_number", "random_pos", "random_bool", "random_choice_weighted", "difference",
 
     # --- 3D ---
     "CW3DShape", "CW3D",
 
+    # --- ChatVPN ---
+    "ChatVPN", "ChatVPNServer",
+
+    # --- Message Bus ---
+    "send_message", "view_message", "clear_messages",
 ]

crystalwindow-5.0/crystalwindow/camera.py

@@ -0,0 +1,42 @@
+class Camera:
+    def __init__(self, target, speed=0.1):
+        self.target = target  # sprite or obj w/ x,y
+        self.offset_x = 0
+        self.offset_y = 0
+        self.speed = speed  # smoothness
+
+    def update(self, win_width, win_height, dt):
+        # camera aims for target center
+        target_x = self.target.x - win_width // 2
+        target_y = self.target.y - win_height // 2
+
+        # smooth lerp follow
+        self.offset_x += (target_x - self.offset_x) * self.speed
+        self.offset_y += (target_y - self.offset_y) * self.speed
+
+        if hasattr(self, "shake"):
+            self.shake.update(dt)
+
+    def apply(self, obj):
+        # shift object's draw position by camera offset
+        sx, sy = (0, 0)
+        if hasattr(self, "shake"):
+            sx, sy = self.shake.offset
+
+        return (
+            obj.x -self.offset_x + sx,
+            obj.y -self.offset_y + sy
+        )    
+
+    def shake_scrn(self, intensity=5, secs=1):
+        # the shake screen effect shakes the screen for an ammount of time/secs
+        from .draw_helpers import CameraShake
+        self.shake = CameraShake(intensity, secs)
+
+    def move_to(self, x, y):
+        self.offset_x = x
+        self.offset_y = y
+
+    def reset_pos(self):
+        self.offset_x = 0
+        self.offset_y = 0

crystalwindow-5.0/crystalwindow/chatvpn.py

@@ -0,0 +1,82 @@
+import socket
+import threading
+import json
+
+
+# ====================================================
+# ChatVPN SERVER  (built into this file)
+# ====================================================
+class ChatVPNServer:
+    def __init__(self, host="0.0.0.0", port=9001):
+        self.host = host
+        self.port = port
+        self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+        self.sock.bind((self.host, self.port))
+        self.clients = set()
+        self.running = False
+
+    def start(self):
+        if self.running:
+            return
+        self.running = True
+        print(f"[ChatVPN-Server] running on {self.host}:{self.port}")
+        threading.Thread(target=self._loop, daemon=True).start()
+
+    def _loop(self):
+        while self.running:
+            data, addr = self.sock.recvfrom(4096)
+
+            if addr not in self.clients:
+                self.clients.add(addr)
+                print(f"[ChatVPN-Server] new client: {addr}")
+
+            for c in self.clients:
+                if c != addr:
+                    self.sock.sendto(data, c)
+
+    def stop(self):
+        self.running = False
+        self.sock.close()
+        print("[ChatVPN-Server] stopped.")
+
+
+# ====================================================
+# ChatVPN CLIENT
+# ====================================================
+class ChatVPN:
+    def __init__(self, server_ip: str, port: int = 9001):
+        self.server = (server_ip, port)
+        self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+        self.running = False
+        self._on_msg = None
+
+    def start(self):
+        if self.running:
+            return
+        self.running = True
+        threading.Thread(target=self._recv_loop, daemon=True).start()
+        print(f"[ChatVPN-Client] connected to {self.server}")
+
+    def send(self, text: str):
+        packet = json.dumps({"type": "text", "data": text}).encode()
+        self.sock.sendto(packet, self.server)
+
+    def on_msg(self, func):
+        self._on_msg = func
+
+    def _recv_loop(self):
+        while self.running:
+            try:
+                data, _ = self.sock.recvfrom(4096)
+            except OSError:
+                break
+
+            try:
+                obj = json.loads(data.decode())
+                msg = obj.get("data", "")
+            except:
+                msg = data.decode()
+
+            if self._on_msg:
+                self._on_msg(msg)
+

{crystalwindow-4.8 → crystalwindow-5.0}/crystalwindow/clock.py

@@ -45,6 +45,7 @@ class Clock:
 
         # FPS
         self.target_fps = target_fps
+        self.timer = CountdownTimer()
         self.min_frame_time = 1 / target_fps if target_fps else 0
         self.frame_times = deque(maxlen=smooth_fps)
 
@@ -77,9 +78,6 @@ class Clock:
         self.delta = raw_delta
         self.frame_times.append(raw_delta)
 
-        # Scheduler update
-        self.scheduler.run_pending()
-
         return self.delta
 
     def get_fps(self):
@@ -145,3 +143,13 @@ class Clock:
     def timestamp(self):
         """High-precision monotonic timestamp."""
         return time.perf_counter()
+    
+    #TIMER
+    def start_timer(self, seconds: float):
+        self.timer.start(seconds)
+
+    def timer_ended(self):
+        return self.timer.is_finished()
+
+    def timer_remaining(self):
+        return self.timer.get_remaining()

{crystalwindow-4.8 → crystalwindow-5.0}/crystalwindow/draw_helpers.py

@@ -13,11 +13,18 @@ def gradient_rect(win, rect, color_start, color_end, vertical=True):
             win.draw_rect((r,g,b), (x+i,y,1,h))
 
 class CameraShake:
-    def __init__(self, intensity=5):
+    def __init__(self, intensity=5, duration=1):
         self.intensity = intensity
-        self.offset = (0,0)
+        self.time_left = duration
+        self.offset = (0, 0)
 
-    def update(self):
+    def update(self, dt):
         import random
-        self.offset = (random.randint(-self.intensity,self.intensity),
-                       random.randint(-self.intensity,self.intensity))
+        if self.time_left > 0:
+            self.time_left -= dt
+            self.offset = (
+                random.randint(-self.intensity, self.intensity),
+                random.randint(-self.intensity, self.intensity)
+            )
+        else:
+            self.offset = (0, 0)

crystalwindow-5.0/crystalwindow/fun_helpers.py

@@ -0,0 +1,197 @@
+import random
+import time
+
+# ============================================================
+# RANDOM 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)]
+
+def random_pastel():
+    return (
+        random.randint(150, 255),
+        random.randint(150, 255),
+        random.randint(150, 255)
+    )
+
+def random_bool(chance=0.5):
+    return random.random() < chance
+
+def random_number(min_val, max_val):
+    return random.randint(min_val, max_val)
+
+def random_pos(w, h):
+    return (
+        random.randint(0, w),
+        random.randint(0, h)
+    )
+
+def random_choice_weighted(items, weights):
+    return random.choices(items, weights=weights, k=1)[0]
+
+
+# ============================================================
+# NAME / TEXT HELPERS
+# ============================================================
+
+def random_name(syllables=3):
+    pool = ["ka","zi","lo","ra","mi","to","na","ve","xo","qu"]
+    return "".join(random.choice(pool) for _ in range(syllables))
+
+
+# ============================================================
+# DIFFERENCE TELLER
+# ============================================================
+class difference:
+    @staticmethod
+    def tell(obj1, obj2):
+        diffs = {}
+
+        for attr in vars(obj1):
+            if hasattr(obj2, attr):
+                v1 = getattr(obj1, attr)
+                v2 = getattr(obj2, attr)
+
+                if v1 != v2:
+                    diffs[attr] = difference._distance(v1, v2)
+
+        return diffs
+
+    @staticmethod
+    def _distance(a, b):
+        if isinstance(a, (int, float)) and isinstance(b, (int, float)):
+            return abs(b - a)
+
+        if isinstance(a, tuple) and isinstance(b, tuple):
+            return sum(abs(b[i] - a[i]) for i in range(min(len(a), len(b))))
+
+        return 1
+
+    @staticmethod
+    def _get_name(obj):
+        # priority: explicit name attr
+        if hasattr(obj, "name"):
+            return obj.name
+
+        # fallback: class name
+        return obj.__class__.__name__
+
+    @staticmethod
+    def score(obj1, obj2):
+        name1 = difference._get_name(obj1)
+        name2 = difference._get_name(obj2)
+
+        diffs = difference.tell(obj1, obj2)
+
+        if not diffs:
+            print(f"The Difference of '{name1}' and '{name2}' are: 0%")
+            return 0
+
+        max_score = len(diffs) * 100
+        raw_score = sum(min(v, 100) for v in diffs.values())
+        percent = int((raw_score / max_score) * 100)
+
+        print(f"The Difference of '{name1}' and '{name2}' are: {percent}%")
+        return percent
+
+
+# ============================================================
+# MATH / TWEEN HELPERS
+# ============================================================
+
+def lerp(a, b, t):
+    return a + (b - a) * t
+
+def clamp(val, minv=0, maxv=255):
+    return max(minv, min(maxv, val))
+
+def clamp01(t):
+    return max(0.0, min(1.0, t))
+
+def smoothstep(a, b, t):
+    t = clamp01(t)
+    t = t * t * (3 - 2 * t)
+    return a + (b - a) * t
+
+def approach(current, target, speed):
+    if current < target:
+        return min(current + speed, target)
+    return max(current - speed, target)
+
+def sign(x):
+    return -1 if x < 0 else (1 if x > 0 else 0)
+
+
+# ============================================================
+# COLOR MODIFIERS
+# ============================================================
+
+def lighten(color, amount=30):
+    r, g, b = color
+    return (
+        clamp(r + amount),
+        clamp(g + amount),
+        clamp(b + amount)
+    )
+
+def darken(color, amount=30):
+    r, g, b = color
+    return (
+        clamp(r - amount),
+        clamp(g - amount),
+        clamp(b - amount)
+    )
+
+
+# ============================================================
+# TIME HELPERS
+# ============================================================
+
+def timer_passed(start_time, duration):
+    return (time.perf_counter() - start_time) >= duration
+
+
+# ============================================================
+# DEBUG OVERLAY
+# ============================================================
+
+class DebugOverlay:
+    def __init__(self):
+        self.active = True
+        self.lines = []
+
+    def toggle(self):
+        self.active = not self.active
+
+    def log(self, text):
+        self.lines.append(str(text))
+        if len(self.lines) > 6:
+            self.lines.pop(0)
+
+    def clear(self):
+        self.lines.clear()
+
+    def draw(self, win, fps=0):
+        if not self.active:
+            return
+
+        y = 10
+        win.draw_text(f"FPS: {int(fps)}", pos=(10, y))
+        y += 20
+
+        if hasattr(win, "mouse_pos"):
+            mx, my = win.mouse_pos
+            win.draw_text(f"Mouse: {mx},{my}", pos=(10, y))
+            y += 20
+
+        for line in self.lines:
+            win.draw_text(line, pos=(10, y))
+            y += 18

crystalwindow-5.0/crystalwindow/messagebus.py

@@ -0,0 +1,33 @@
+# crystalwindow/messagebus.py
+
+class MessageBus:
+    def __init__(self):
+        self._queue = []
+
+    def send(self, name: str, data=None):
+        self._queue.append({
+            "name": name,
+            "data": data
+        })
+
+    def poll(self, name: str):
+        for msg in self._queue:
+            if msg["name"] == name:
+                self._queue.remove(msg)
+                return msg["data"]
+        return None
+
+    def clear(self):
+        self._queue.clear()
+
+
+_bus = MessageBus()
+
+def send_message(name: str, data=None):
+    _bus.send(name, data)
+
+def view_message(name: str):
+    return _bus.poll(name)
+
+def clear_messages():
+    _bus.clear()

{crystalwindow-4.8 → crystalwindow-5.0}/crystalwindow/objects.py

@@ -71,21 +71,21 @@ class Player(Sprite):
         spd = self.speed * dt * 60
 
         # movement
-        if win.is_key_pressed("left"):
+        if win.key_pressed("left"):
             self.x -= spd
             self.flip_x = True
             moving = True
 
-        if win.is_key_pressed("right"):
+        if win.key_pressed("right"):
             self.x += spd
             self.flip_x = False
             moving = True
 
-        if win.is_key_pressed("up"):
+        if win.key_pressed("up"):
             self.y -= spd
             moving = True
 
-        if win.is_key_pressed("down"):
+        if win.key_pressed("down"):
             self.y += spd
             moving = True
 

{crystalwindow-4.8 → crystalwindow-5.0/crystalwindow.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: crystalwindow
-Version: 4.8
+Version: 5.0
 Summary: A Tkinter powered window + GUI toolkit made by Crystal (ME)! Easier apps, smoother UI and all-in-one helpers!, Gui, Buttons, FileHelper, Sprites, Animations, Colors, Math, Gravity, Camera, 3D and more!
 Home-page: https://pypi.org/project/crystalwindow/
 Author: CrystalBallyHereXD

{crystalwindow-4.8 → crystalwindow-5.0}/crystalwindow.egg-info/SOURCES.txt

@@ -8,6 +8,7 @@ crystalwindow/ai.py
 crystalwindow/animation.py
 crystalwindow/assets.py
 crystalwindow/camera.py
+crystalwindow/chatvpn.py
 crystalwindow/clock.py
 crystalwindow/collision.py
 crystalwindow/color_handler.py
@@ -21,6 +22,7 @@ crystalwindow/gravity.py
 crystalwindow/gui.py
 crystalwindow/gui_ext.py
 crystalwindow/math.py
+crystalwindow/messagebus.py
 crystalwindow/objects.py
 crystalwindow/sprites.py
 crystalwindow/tilemap.py

{crystalwindow-4.8 → crystalwindow-5.0}/setup.py

@@ -7,7 +7,7 @@ with open("README.md", encoding="utf-8") as f:
 
 setup(
     name="crystalwindow",
-    version="4.8",  # Force metadata refresh
+    version="5.0",  # Force metadata refresh
     packages=find_packages(include=["crystalwindow", "crystalwindow.*"]),
 
     include_package_data=True,  # include package_data files

crystalwindow-4.8/crystalwindow/camera.py

@@ -1,19 +0,0 @@
-class Camera:
-    def __init__(self, target, speed=0.1):
-        self.target = target  # sprite or obj w/ x,y
-        self.offset_x = 0
-        self.offset_y = 0
-        self.speed = speed  # smoothness
-
-    def update(self, win_width, win_height):
-        # camera aims for target center
-        target_x = self.target.x - win_width // 2
-        target_y = self.target.y - win_height // 2
-
-        # smooth lerp follow
-        self.offset_x += (target_x - self.offset_x) * self.speed
-        self.offset_y += (target_y - self.offset_y) * self.speed
-
-    def apply(self, obj):
-        # shift object's draw position by camera offset
-        return obj.x - self.offset_x, obj.y - self.offset_y

crystalwindow-4.8/crystalwindow/fun_helpers.py

@@ -1,32 +0,0 @@
-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))
-
-#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
-
-# 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))