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

crystalwindow/window.py

@@ -1,8 +1,9 @@
 # === Window Management (tkinter version) ===
+import random
 import tkinter as tk
-import base64, io, os, sys, contextlib, time
-from .websearch import WebSearch
+import base64, io, os, sys, contextlib, time, math
 
+from pyscreeze import center
 
 # === Boot ===
 main_file = os.path.basename(sys.argv[0])
@@ -20,6 +21,35 @@ def decode_logo():
     except Exception:
         return None
 
+class _CameraShake:
+    def __init__(self):
+        self.active = False
+        self.intensity = 5
+        self.end_time = 0
+        self.offset = (0, 0)
+
+    def start(self, intensity, duration):
+        import time, random
+        self.active = True
+        self.intensity = intensity
+        self.end_time = time.time() + duration
+
+    def update(self):
+        import time, random
+        if not self.active:
+            self.offset = (0, 0)
+            return
+
+        if time.time() > self.end_time:
+            self.active = False
+            self.offset = (0, 0)
+            return
+
+        self.offset = (
+            random.randint(-self.intensity, self.intensity),
+            random.randint(-self.intensity, self.intensity)
+        )
+
 
 class Window:
     # === Keymap to simplify key usage ===
@@ -114,13 +144,17 @@ class Window:
         self.keys = {}
         self.mouse_pos = (0, 0)
         self._mouse_pressed = (False, False, False)
+        self.cam_x = 0
+        self.cam_y = 0
+        self.shake_timer = 0
+        self.shake_strength = 0
+
+        self.camerashake = _CameraShake()
         self._bg_color = (20, 20, 50)
         self.draw_calls = []
         self._key_last = {}  # new dict to store last press time per key
         self._key_cooldown = 0.00001  # seconds, tweak for faster/slower input
 
-        WebSearch.register_cw_tab(self)
-
         # === Event bindings ===
         self.root.bind("<KeyPress>", self._on_keydown)
         self.root.bind("<KeyRelease>", self._on_keyup)
@@ -128,6 +162,15 @@ class Window:
         self.root.bind("<ButtonPress>", self._on_mousedown)
         self.root.bind("<ButtonRelease>", self._on_mouseup)
 
+    def _apply_camera_shake(self):
+        if self.shake_timer > 0:
+            self.shake_timer -= 1
+            self.cam_x = random.randint(-self.shake_strength, self.shake_strength)
+            self.cam_y = random.randint(-self.shake_strength, self.shake_strength)
+        else:
+            self.cam_x = 0
+            self.cam_y = 0
+
     # === Input ===
     def _on_keydown(self, event):
         self.keys[event.keysym] = True
@@ -169,6 +212,56 @@ class Window:
         return self._mouse_pressed[button - 1]
     def add_tab(self, title, widget):
         self.tabs.addTab(widget, title)
+
+    # ====================================
+    # Im gonna joke on the viewers here for a sec lmao
+    # ====================================
+    def f_crash(self, msg="oh no bruh... program ded 💀"):
+        """start fake crash mode lol"""
+        import tkinter as tk
+
+        if hasattr(self, "_fcrash_window"):
+            return  # already running
+
+        self._fcrash_window = tk.Toplevel(self.root)
+        self._fcrash_window.title("Fatal Error")
+        self._fcrash_window.geometry("400x200")
+        self._fcrash_window.configure(bg="#101010")
+        self._fcrash_window.attributes("-topmost", True)
+
+        tk.Label(
+            self._fcrash_window,
+            text=msg,
+            fg="red",
+            bg="#101010",
+            font=("Consolas", 14, "bold")
+        ).pack(pady=20)
+
+        tk.Label(
+            self._fcrash_window,
+            text="System meltdown imminent...",
+            fg="white",
+            bg="#101010",
+            font=("Consolas", 11)
+        ).pack()
+
+        # disable user clicking main window
+        self.root.attributes("-disabled", True)
+
+    def end_fcrash(self):
+        """end fake crash prank"""
+        if hasattr(self, "_fcrash_window"):
+            self._fcrash_window.destroy()
+            del self._fcrash_window
+
+        # re-enable main window
+        self.root.attributes("-disabled", False)
+
+    # An actuall fucking Real crash that bricks your system sorry bud
+    def crash(self, msg="REAL CRASH: u messed up bruh"):
+        """actual crash (safe)."""
+        raise RuntimeError(msg)
+
     # === Drawing ===
     def fill(self, color):
         """Fill background with a color"""
@@ -186,20 +279,345 @@ class Window:
         self.canvas.delete("all")
         self.canvas.configure(bg=fill_color)
 
+    # ------------------------------------------------------
+    # INTERNAL: color / texture resolver
+    # ------------------------------------------------------
+    def _resolve_color_or_texture(self, color):
+        """
+        Returns (mode, value)
+        mode = "rgb", "hex", "fallback", "texture"
+        """
+        # Texture?
+        try:
+            from PIL.ImageTk import PhotoImage as PILPhoto
+            import tkinter
+            if isinstance(color, (tkinter.PhotoImage, PILPhoto)):
+                return ("texture", color)
+        except:
+            pass
+
+        # Fallback dict
+        if isinstance(color, dict) and color.get("fallback"):
+            r, g, b = color["color"]
+            return ("rgb", f"#{r:02x}{g:02x}{b:02x}")
+
+        # Hex
+        if isinstance(color, str) and color.startswith("#"):
+            return ("hex", color)
+
+        # Color instance
+        try:
+            if hasattr(color, "to_tuple"):
+                r, g, b, *_ = color.to_tuple()
+                return ("rgb", f"#{r:02x}{g:02x}{b:02x}")
+        except:
+            pass
+
+        # RGB tuple
+        if isinstance(color, (tuple, list)) and len(color) >= 3:
+            r, g, b = color[0], color[1], color[2]
+            return ("rgb", f"#{r:02x}{g:02x}{b:02x}")
+
+        return ("rgb", "#ffffff")
+
+
+    # ------------------------------------------------------
+    # DRAW RECTANGLE
+    # ------------------------------------------------------
     def draw_rect(self, color, rect):
+        mode, value = self._resolve_color_or_texture(color)
         x, y, w, h = rect
-        self.draw_calls.append(("rect", color, x, y, w, h))
 
-    def draw_circle(self, color, pos, radius):
-        x, y = pos
-        self.draw_calls.append(("circle", color, x, y, radius))
+        if mode == "texture":
+            from PIL import Image, ImageTk
+            try:
+                pil = ImageTk.getimage(value).resize((w, h))
+            except:
+                return
+            tk_tex = ImageTk.PhotoImage(pil)
+            if not hasattr(self, "_tex_cache"): self._tex_cache = []
+            self._tex_cache.append(tk_tex)
+            self.canvas.create_image(x, y, image=tk_tex, anchor="nw")
+        else:
+            self.canvas.create_rectangle(
+                x, y, x+w, y+h,
+                fill=value, outline=""
+            )
+
+
+    # ------------------------------------------------------
+    # DRAW LINE
+    # ------------------------------------------------------
+    def draw_line(self, p1, p2, color, width=2):
+        mode, value = self._resolve_color_or_texture(color)
+
+        if mode != "texture":
+            self.canvas.create_line(
+                p1[0], p1[1], p2[0], p2[1],
+                fill=value, width=width
+            )
+            return
+
+        # Texture line
+        from PIL import Image, ImageDraw, ImageTk
+        x1, y1 = p1
+        x2, y2 = p2
+
+        minx, maxx = int(min(x1, x2)), int(max(x1, x2))
+        miny, maxy = int(min(y1, y2)), int(max(y1, y2))
+
+        w = max(2, maxx - minx)
+        h = max(2, maxy - miny)
+
+        mask = Image.new("L", (w, h), 0)
+        m = ImageDraw.Draw(mask)
+        m.line([(x1-minx, y1-miny), (x2-minx, y2-miny)], fill=255, width=width)
+
+        tex = ImageTk.getimage(value).resize((w, h))
+        tex.putalpha(mask)
+
+        tk_img = ImageTk.PhotoImage(tex)
+        if not hasattr(self, "_line_tex"): self._line_tex = []
+        self._line_tex.append(tk_img)
+
+        self.canvas.create_image(minx, miny, image=tk_img, anchor="nw")
+
+    # ------------------------------------------------------
+    # DRAW CIRCLE  ——— FIXED SIGNATURE
+    # ------------------------------------------------------
+    def draw_circle(self, color, center, radius, width=0):
+        mode, value = self._resolve_color_or_texture(color)
 
-    def draw_text(self, text, font="Arial", size=16, color=(255, 255, 255), pos=(0, 0), **kwargs):
-        fill = f"#{color[0]:02x}{color[1]:02x}{color[2]:02x}"
-        self.canvas.create_text(pos[0], pos[1], text=text, fill=fill, font=(font, size), anchor="nw", **kwargs)
+        # safe unpacking
+        cx, cy = center[:2]
+
+        if mode != "texture":
+            self.canvas.create_oval(
+                cx - radius, cy - radius,
+                cx + radius, cy + radius,
+                fill=value if width == 0 else "",
+                outline=value if width > 0 else "",
+                width=width
+            )
+            return
 
+        # textured circle
+        from PIL import Image, ImageDraw, ImageTk
+        d = int(radius * 2)
+
+        mask = Image.new("L", (d, d), 0)
+        m = ImageDraw.Draw(mask)
+        m.ellipse((0, 0, d, d), fill=255)
+
+        tex = ImageTk.getimage(value).resize((d, d))
+        tex.putalpha(mask)
+
+        tk_img = ImageTk.PhotoImage(tex)
+        if not hasattr(self, "_circ_tex"):
+            self._circ_tex = []
+        self._circ_tex.append(tk_img)
+
+        self.canvas.create_image(cx - radius, cy - radius, image=tk_img, anchor="nw")
+
+    # ------------------------------------------------------
+    # DRAW POLYGON (FILL)
+    # ------------------------------------------------------
+    def draw_polygon(self, color, points):
+        mode, value = self._resolve_color_or_texture(color)
+
+        if mode != "texture":
+            self.canvas.create_polygon(points, fill=value, outline="")
+            return
+
+        from PIL import Image, ImageDraw, ImageTk
+        xs, ys = zip(*points)
+        minx, maxx = min(xs), max(xs)
+        miny, maxy = min(ys), max(ys)
+
+        w = int(maxx - minx)
+        h = int(maxy - miny)
+        if w < 2 or h < 2: return
+
+        mask = Image.new("L", (w, h), 0)
+        m = ImageDraw.Draw(mask)
+        m.polygon([(x-minx, y-miny) for x, y in points], fill=255)
+
+        tex = ImageTk.getimage(value).resize((w, h))
+        tex.putalpha(mask)
+
+        tk_img = ImageTk.PhotoImage(tex)
+        if not hasattr(self, "_poly_tex"): self._poly_tex = []
+        self._poly_tex.append(tk_img)
+
+        self.canvas.create_image(minx, miny, image=tk_img, anchor="nw")
+
+
+    # ------------------------------------------------------
+    # DRAW POLYGON OUTLINE
+    # ------------------------------------------------------
+    def draw_polygon_outline(self, color, points, width=2):
+        mode, value = self._resolve_color_or_texture(color)
+
+        if mode != "texture":
+            self.canvas.create_polygon(points, outline=value, width=width, fill="")
+            return
+
+        from PIL import Image, ImageDraw, ImageTk
+        xs, ys = zip(*points)
+        minx, maxx = min(xs), max(xs)
+        miny, maxy = min(ys), max(ys)
+
+        w = int(maxx - minx)
+        h = int(maxy - miny)
+
+        mask = Image.new("L", (w, h), 0)
+        m = ImageDraw.Draw(mask)
+        m.line([(x-minx, y-miny) for x, y in points] +
+               [(points[0][0]-minx, points[0][1]-miny)],
+               fill=255, width=width)
+
+        tex = ImageTk.getimage(value).resize((w, h))
+        tex.putalpha(mask)
+
+        tk_img = ImageTk.PhotoImage(tex)
+        if not hasattr(self, "_poly_oline_tex"): self._poly_oline_tex = []
+        self._poly_oline_tex.append(tk_img)
+
+        self.canvas.create_image(minx, miny, image=tk_img, anchor="nw")
+
+
+    # ------------------------------------------------------
+    # DRAW STAR
+    # ------------------------------------------------------
+    def draw_star(self, color, center, outer_radius, inner_radius=None,
+                  points=5, stroke=None, stroke_width=2):
+
+        if inner_radius is None:
+            inner_radius = outer_radius * 0.5
+
+        cx, cy = center
+        step = math.pi / points
+        ang = -math.pi / 2
+        verts = []
+
+        for i in range(points * 2):
+            r = outer_radius if i % 2 == 0 else inner_radius
+            verts.append((cx + math.cos(ang) * r,
+                          cy + math.sin(ang) * r))
+            ang += step
+
+        self.draw_polygon(color, verts)
+        if stroke:
+            self.draw_polygon_outline(stroke, verts, stroke_width)
+
+    # ------------------------------------------------------
+    # DRAW TEXT — SAFE, FIXED, TKINTER-PROOF
+    # ------------------------------------------------------
+    def draw_text(self, text, font="Arial", size=16, color=(255, 255, 255), pos=(0, 0), **kwargs):
+        # extract style kwargs safely (DO NOT send them to tkinter)
+        bold = kwargs.pop("bold", False)
+        italic = kwargs.pop("italic", False)
+
+        # scale
+        scaled_size = size
+
+        # resolve color or texture
+        mode, value = self._resolve_color_or_texture(color)
+
+        # build font style string
+        style = ""
+        if bold:
+            style += "bold "
+        if italic:
+            style += "italic"
+        style = style.strip()
+
+        # tkinter font tuple
+        if style:
+            font_tuple = (font, scaled_size, style)
+        else:
+            font_tuple = (font, scaled_size)
+
+        # ---------------- NORMAL COLOR TEXT ----------------
+        if mode != "texture":
+            fill = f"#{color[0]:02x}{color[1]:02x}{color[2]:02x}"
+
+            # HARD DELETE unsupported kwargs (just in case)
+            kwargs.pop("bold", None)
+            kwargs.pop("italic", None)
+
+            # allowed kwargs ONLY
+            ALLOWED = {"anchor", "justify", "tags"}
+            safe_kwargs = {k: v for k, v in kwargs.items() if k in ALLOWED}
+
+            self.canvas.create_text(
+                pos[0], pos[1],
+                text=text,
+                fill=fill,
+                font=font_tuple,
+                anchor="nw",
+                **safe_kwargs
+            )
+            return
+
+        # ---------------- TEXTURED TEXT ----------------
+        from PIL import Image, ImageDraw, ImageFont, ImageTk
+
+        # try load font with style
+        try:
+            fnt = ImageFont.truetype(font + ".ttf", scaled_size)
+        except:
+            fnt = ImageFont.load_default()
+
+        # measure text
+        temp = Image.new("L", (1, 1), 0)
+        d = ImageDraw.Draw(temp)
+
+        try:
+            bbox = d.textbbox((0, 0), text, font=fnt)
+            tw = bbox[2] - bbox[0]
+            th = bbox[3] - bbox[1]
+        except:
+            tw, th = d.textsize(text, font=fnt)
+
+        pad = int(size * 0.25)
+        tw += pad
+        th += pad
+
+        # alpha mask for texture
+        mask = Image.new("L", (tw, th), 0)
+        m = ImageDraw.Draw(mask)
+        m.text((pad//2, pad//2), text, font=fnt, fill=255)
+
+        # texture
+        tex = ImageTk.getimage(value).resize((tw, th))
+        tex.putalpha(mask)
+
+        tk_img = ImageTk.PhotoImage(tex)
+        if not hasattr(self, "_text_tex"):
+            self._text_tex = []
+        self._text_tex.append(tk_img)
+
+        self.canvas.create_image(
+            pos[0], pos[1],
+            image=tk_img,
+            anchor="nw"
+        )
+
+    # ------------------------------------------------------
+    # DRAW TEXT LATER (Queued) — CLEAN KWARGS BEFORE SAVE
+    # ------------------------------------------------------
     def draw_text_later(self, *args, **kwargs):
-        self.draw_calls.append(("text", args, kwargs))
+        # remove style keys NOW so they never come back
+        kwargs.pop("bold", None)
+        kwargs.pop("italic", None)
+
+        # allowed kwargs ONLY (same list as draw_text)
+        ALLOWED = {"anchor", "justify", "tags"}
+        clean_kwargs = {k: v for k, v in kwargs.items() if k in ALLOWED}
+
+        self.draw_calls.append(("text", args, clean_kwargs))
+
 
     # === Update + Loop ===
     def run(self, update_func=None, bg=(20, 20, 50)):

{crystalwindow-4.5.dist-info → crystalwindow-4.7.dist-info}/METADATA

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: crystalwindow
-Version: 4.5
-Summary: A Tkinter powered window + GUI toolkit made by Crystal (MEEEEEE)! Easier apps, smoother UI and all-in-one helpers!
+Version: 4.7
+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
 Author-email: mavilla.519@gmail.com
@@ -16,6 +16,9 @@ Classifier: License :: OSI Approved :: MIT License
 Requires-Python: >=3.6
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: requests
+Requires-Dist: packaging
+Requires-Dist: pillow
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier
@@ -25,6 +28,7 @@ Dynamic: home-page
 Dynamic: keywords
 Dynamic: license-file
 Dynamic: project-url
+Dynamic: requires-dist
 Dynamic: requires-python
 Dynamic: summary
 

crystalwindow-4.7.dist-info/RECORD

@@ -0,0 +1,43 @@
+crystalwindow/FileHelper.py,sha256=U20iwND4jX1y91TOK46e8MPH8xyw7GOrZ697nPEnOPk,10706
+crystalwindow/__init__.py,sha256=GQxj4yLpnp53i3rc7X_DY_KbYTQFr1Op8qX4-_R_RrA,2510
+crystalwindow/ai.py,sha256=YIt6dNe1QljSAlNECCVa3DMUSIqQEJRIAAbQpYqFNNo,11525
+crystalwindow/animation.py,sha256=zHjrdBXQeyNaLAuaGPldJueX05OZ5j31YR8NizmR0uQ,427
+crystalwindow/assets.py,sha256=8MxPSk7W5YcBnKDh6KcLdg34uxmACf_m6feSYFCWHqA,11405
+crystalwindow/camera.py,sha256=tbn4X-jxMIszAUg3Iu-89gJN5nij0mjPMEzGotcLbJI,712
+crystalwindow/clock.py,sha256=JjpLOWaZlVtLd1KfvaMn5Gx5iOqyuy6oLnHaM22axKY,4827
+crystalwindow/collision.py,sha256=hpkHTp_KparghVK-itp_rxuYdd2GbQMxICHlUBv0rSw,472
+crystalwindow/color_handler.py,sha256=K3LipCPOjYt1NemeT-hNWf886LL59QgRN8ifHOi7-0M,3255
+crystalwindow/crystal3d.py,sha256=8n42S71NZWgBgYwP8ZWfobXFeWvNrhJY80YGK-PzI8s,5375
+crystalwindow/draw_helpers.py,sha256=HqjI5fTbdnA55g4LKYEuMUdIjrWaBm2U8RmeUXjcQGw,821
+crystalwindow/draw_rects.py,sha256=o7siET3y35N2LPeNBGe8QhsQbOH8J-xF6fOUz07rymU,1484
+crystalwindow/draw_text_helper.py,sha256=qv5fFCuTCKWeGDk9Z_ZpOzrTFP8YYwlgQrrorwrq9Hg,1298
+crystalwindow/draw_tool.py,sha256=1YYEqjmgt4HpV3S15sTjCSmcqgHup4fD8gskTkxU0t4,1638
+crystalwindow/fun_helpers.py,sha256=x-OF5dlMlHgvXjtT7Om8RvzKWgizSwnzeaM0_W3-SKQ,870
+crystalwindow/gravity.py,sha256=pZJykZzO-mKVBPsZRP55nnlvUoYQfR29wPgJcI4IbBs,2904
+crystalwindow/gui.py,sha256=Ipu3BKA6euwQJ75oq7L9V7jbbZHGawwTQjv-KEH_owE,5286
+crystalwindow/gui_ext.py,sha256=JctpNPr7gtGdro3csyUo9ft3FFArj3JhkVlgKF0lyME,3407
+crystalwindow/math.py,sha256=slOY3KQZ99VDMUMxsSJabMyRtJcwVzEyxR2RoXspHho,963
+crystalwindow/objects.py,sha256=VCEvRrzPv-bWCiVw63rMF67KYluP6FKySgDOvOiN8QU,5413
+crystalwindow/sprites.py,sha256=IADCQetFDQoat3qGpKkH93TdtqqgldfHl4N0HKX1Ajc,7480
+crystalwindow/tilemap.py,sha256=J6u3K3n-tEFyAqVc6eBGxnG0qVeGQeE0aMc-WLapydQ,328
+crystalwindow/ver_warner.py,sha256=qEN3ulc1NixBy15FFx2R3Zu0DhyJTVJwiESGAPwpynM,3373
+crystalwindow/websearch.py,sha256=ZaG4rO2TRxJVv1QRYv8vcSKx1fCf5OqqhEGNns99-KU,5159
+crystalwindow/window.py,sha256=qfz0e8dhLH0ZfoqjswFu20NJqh3Ln6rhaZ3v626Uewk,31849
+crystalwindow/Icons/default_icon.png,sha256=Loq27Pxb8Wb3Sz-XwtNF1RmlLNxR4TcfOWfK-1lWcII,7724
+crystalwindow/Icons/file_icons.png,sha256=kqjvz3gMaIbepW4XGrLZOjDYu-yhFbVxjvylS-0RO4U,5659
+crystalwindow/docs/getting_started.md,sha256=e_XEhJk8eatS22MX0nRX7hQNkYkwN9both1ObabZSTw,5759
+crystalwindow/docs/index.md,sha256=bd14uLWtRSeRBm28zngGyfGDI1J6bJRvHkQLDpYwgOE,747
+crystalwindow/gametests/3dsquare.py,sha256=MM_RRx1mz_NeBhTAoNomzn_IAbbN4ZnQZWA9VAFL8mY,821
+crystalwindow/gametests/__init__.py,sha256=TRwhDl8aO3Wdqu_DXi9qT35CqF86AIyLqOSAkjNMJFY,240
+crystalwindow/gametests/__main__.py,sha256=93R7DXHRK7GPsMrZB526pkWCrKJ728E1G4wCbHk3kP0,751
+crystalwindow/gametests/gravitytest.py,sha256=OzhdaUtjSaVgWeSqYmtWLCP_9RIrkkMg_oHfrWTEUzs,3393
+crystalwindow/gametests/guitesting.py,sha256=7MAlFkH9cLsGeS3B5oaYWOwB1k1ek9aosqSL_UhYZgY,1919
+crystalwindow/gametests/sandbox.py,sha256=Oo2tU2N0y3BPVa6T5vs_h9N6islhQrjSrr_78XLut5I,1007
+crystalwindow/gametests/squaremove.py,sha256=ei6DMnvcgpOhmxbGv-Yqmx5EqiZjKbVlZhI7YbT2hY8,643
+crystalwindow/gametests/testtttagain.py,sha256=oIhK9MGgMVly_W2lRwD9Hn9WyPdd8JnX2HGrLTGZdxY,373
+crystalwindow/gametests/windowtesting.py,sha256=_9X6wnV1-_X_PtNS-0zu-k209NtFIwAc4vpxLPp7V2o,97
+crystalwindow-4.7.dist-info/licenses/LICENSE,sha256=Gt5cJRchdNt0guxyQMHKsATN5PM5mjuDhdO6Gzs9qQc,1096
+crystalwindow-4.7.dist-info/METADATA,sha256=T0kgPlByhRHl1pND0oNPapnesZKSvu9B4Urvb4tkEvo,7523
+crystalwindow-4.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+crystalwindow-4.7.dist-info/top_level.txt,sha256=PeQSld4b19XWT-zvbYkvE2Xg8sakIMbDzSzSdOSRN8o,14
+crystalwindow-4.7.dist-info/RECORD,,

crystalwindow/cw_client.py

@@ -1,95 +0,0 @@
-# cw_client.py
-# pip install websockets
-import asyncio
-import websockets
-import json
-import threading
-import time
-
-class CWClient:
-    """
-    Lightweight client wrapper. Usage:
-      c = CWClient("MyName", "ws://host:8765")
-      c.on_event = lambda ev: print("ev", ev)
-      c.start()
-      c.move(x,y)
-      c.chat("hi")
-    """
-    def __init__(self, pid, uri="ws://127.0.0.1:8765"):
-        self.pid = pid
-        self.uri = uri
-        self._send_q = asyncio.Queue()
-        self.on_event = None   # callback for incoming events: fn(dict)
-        self._running = False
-        self._loop_thread = None
-
-    async def _run(self):
-        try:
-            async with websockets.connect(self.uri) as ws:
-                # send join
-                await ws.send(json.dumps({"type":"join","id":self.pid}))
-                self._running = True
-                sender_task = asyncio.create_task(self._sender(ws))
-                try:
-                    async for raw in ws:
-                        try:
-                            data = json.loads(raw)
-                        except:
-                            continue
-                        if self.on_event:
-                            # run callback in same thread (safe)
-                            try:
-                                self.on_event(data)
-                            except Exception as cb_e:
-                                # swallow callback errors
-                                print("on_event callback error:", cb_e)
-                finally:
-                    sender_task.cancel()
-        except Exception as e:
-            # notify user on connection lost
-            if self.on_event:
-                try:
-                    self.on_event({"type":"sys","msg":f"connection_lost:{e}"})
-                except:
-                    pass
-        finally:
-            self._running = False
-
-    async def _sender(self, ws):
-        while True:
-            try:
-                obj = await self._send_q.get()
-                await ws.send(json.dumps(obj))
-            except Exception:
-                break
-
-    def start(self):
-        if self._loop_thread and self._loop_thread.is_alive():
-            return
-        def target():
-            asyncio.run(self._run())
-        self._loop_thread = threading.Thread(target=target, daemon=True)
-        self._loop_thread.start()
-        # give a bit of time to connect
-        time.sleep(0.05)
-
-    def send(self, obj):
-        # enqueue safely from any thread
-        async def push():
-            await self._send_q.put(obj)
-        try:
-            loop = asyncio.get_running_loop()
-            # if main thread has a loop, schedule
-            asyncio.run_coroutine_threadsafe(push(), loop)
-        except RuntimeError:
-            # no running loop in this thread: create a tiny loop to push
-            def run_push():
-                asyncio.run(push())
-            threading.Thread(target=run_push, daemon=True).start()
-
-    # convenience APIs
-    def move(self, x, y):
-        self.send({"type":"move","id":self.pid,"x":int(x),"y":int(y)})
-
-    def chat(self, msg):
-        self.send({"type":"chat","id":self.pid,"msg":str(msg)})