castletool 0.2.2__tar.gz → 0.3.0__tar.gz

{castletool-0.2.2 → castletool-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: castletool
-Version: 0.2.2
+Version: 0.3.0
 Summary: Interactive Castle deck editor for injecting images/GIFs and MIDI into Castle blueprint JSON files.
 Author-email: Your Name <your.email@example.com>
 Classifier: Programming Language :: Python :: 3

{castletool-0.2.2 → castletool-0.3.0}/castletool/castletool.py

@@ -9,14 +9,21 @@ import bisect
 import copy
 import io
 import json
+import math
 import os
 import platform
+import re
 import shutil
 import subprocess
 import sys
+import urllib.request
 import uuid
+import xml.etree.ElementTree as ET
 from pathlib import Path
 
+CURRENT_VERSION = "0.3.0"
+PYPI_URL = "https://pypi.org/pypi/castletool/json"
+
 # ── optional deps ────────────────────────────────────────────────────────────
 try:
     from PIL import Image
@@ -30,21 +37,6 @@ try:
 except ImportError:
     HAS_MIDO = False
 
-try:
-    from prompt_toolkit import prompt as pt_prompt
-    from prompt_toolkit.completion import PathCompleter
-    from prompt_toolkit.styles import Style
-    HAS_PT = True
-except ImportError:
-    HAS_PT = False
-
-HAS_FZF = shutil.which("fzf") is not None
-
-try:
-    from svg_to_castle import svg_to_path_data, build_drawing2_vector
-    HAS_SVG = True
-except ImportError:
-    HAS_SVG = False
 HAS_FFMPEG = shutil.which("ffmpeg") is not None
 
 # ── helpers ──────────────────────────────────────────────────────────────────
@@ -71,8 +63,14 @@ def ask(prompt, default=None):
     return val if val else (default or "")
 
 def yn(prompt, default="y"):
+    hint = "Y/n" if default == "y" else "y/N"
     while True:
-        ans = ask(prompt + " (y/n)", default=default).lower()
+        try:
+            ans = input(f"{BOLD}{prompt} ({hint}){RESET} ").strip().lower()
+        except (EOFError, KeyboardInterrupt):
+            p(); sys.exit(0)
+        if ans == "":
+            return default == "y"
         if ans in ("y", "n"):
             return ans == "y"
         p("Please enter y or n.")
@@ -89,60 +87,14 @@ def choose(prompt, options):
             return options[int(raw) - 1]
         p("Invalid choice.")
 
-def fzf_pick_file(start_dir: Path) -> str | None:
-    """Open fzf to fuzzy-find a file under start_dir. Returns path string or None."""
-    try:
-        # find all files under start_dir, pipe into fzf
-        find = subprocess.run(
-            ["find", str(start_dir), "-type", "f"],
-            capture_output=True, text=True
-        )
-        fzf = subprocess.run(
-            ["fzf", "--prompt", "Select file> ", "--height", "40%",
-             "--layout", "reverse", "--border"],
-            input=find.stdout,
-            capture_output=True, text=True
-        )
-        result = fzf.stdout.strip()
-        return result if result else None
-    except Exception:
-        return None
-
-
 def ask_path(prompt, default=None, search_dir: Path | None = None):
-    """
-    File path input. Priority:
-      1. fzf fuzzy picker (if fzf installed)
-      2. prompt_toolkit tab-complete (if installed)
-      3. plain input fallback
-    """
+    """Plain file path input."""
     suffix = f" [{default}]" if default is not None else ""
     pb(prompt + suffix)
-
-    if HAS_FZF:
-        start = search_dir or Path.cwd()
-        ps(f"Opening fzf in {start} — type to fuzzy search, Enter to select, Esc to type manually.")
-        picked = fzf_pick_file(start)
-        if picked:
-            ps(f"Selected: {picked}")
-            return picked
-        pw("fzf cancelled, falling back to manual input.")
-
-    if HAS_PT:
-        try:
-            from prompt_toolkit.formatted_text import FormattedText
-            val = pt_prompt(
-                FormattedText([("bold", "Path: ")]),
-                completer=PathCompleter(expanduser=True),
-                complete_while_typing=False,
-            ).strip()
-        except (EOFError, KeyboardInterrupt):
-            p(); sys.exit(0)
-    else:
-        try:
-            val = input(f"{BOLD}Path: {RESET}").strip()
-        except (EOFError, KeyboardInterrupt):
-            p(); sys.exit(0)
+    try:
+        val = input(f"{BOLD}Path: {RESET}").strip()
+    except (EOFError, KeyboardInterrupt):
+        p(); sys.exit(0)
     return val if val else (default or "")
 
 
@@ -157,17 +109,82 @@ def resolve_path(raw: str) -> Path:
 def is_termux() -> bool:
     return "com.termux" in str(Path.home()) or os.environ.get("TERMUX_VERSION") is not None
 
-def check_storage_setup() -> bool:
-    return (Path.home() / "storage").exists()
+# ── update check ─────────────────────────────────────────────────────────────
 
-def setup_termux_storage():
-    p()
-    pw("It looks like you do not have storage set up.")
-    if yn("Would you like to set it up now?"):
-        pb("Running 'termux-setup-storage'...")
-        subprocess.run(["termux-setup-storage"])
-        ps("Setup complete! You may need to restart the script.")
-        sys.exit(0)
+def _version_tuple(v: str) -> tuple:
+    parts = []
+    for x in v.split("."):
+        num = "".join(ch for ch in x if ch.isdigit())
+        parts.append(int(num) if num else 0)
+    return tuple(parts)
+
+def get_installed_version() -> str:
+    try:
+        from importlib.metadata import version, PackageNotFoundError
+        try:
+            return version("castletool")
+        except PackageNotFoundError:
+            return CURRENT_VERSION
+    except ImportError:
+        return CURRENT_VERSION
+
+def check_for_update():
+    """Best-effort check against PyPI. Never blocks or errors on failure."""
+    current = get_installed_version()
+    try:
+        with urllib.request.urlopen(PYPI_URL, timeout=3) as resp:
+            latest = json.loads(resp.read())["info"]["version"]
+    except Exception:
+        return
+
+    if _version_tuple(latest) > _version_tuple(current):
+        pw(f"A newer version is available: {latest} (you have {current})")
+        if yn("Install it now?"):
+            subprocess.run([sys.executable, "-m", "pip", "install",
+                             "--quiet", "--upgrade", "castletool"])
+            ps("Updated! Please restart Castletool.")
+            sys.exit(0)
+        p()
+
+# ── dependency auto-install ──────────────────────────────────────────────────
+
+def ensure_dependencies():
+    """Best-effort auto-install of missing dependencies."""
+    global HAS_PIL, HAS_MIDO, HAS_FFMPEG, Image, mido
+
+    pip_missing = []
+    if not HAS_PIL:  pip_missing.append("Pillow")
+    if not HAS_MIDO: pip_missing.append("mido")
+
+    if pip_missing:
+        pb(f"Installing {', '.join(pip_missing)}...")
+        subprocess.run([sys.executable, "-m", "pip", "install", "--quiet", *pip_missing])
+
+    if not HAS_FFMPEG:
+        pb("Installing ffmpeg...")
+        if is_termux():
+            subprocess.run(["pkg", "install", "-y", "ffmpeg"])
+        elif shutil.which("apt-get"):
+            subprocess.run(["sudo", "apt-get", "install", "-y", "ffmpeg"])
+        elif shutil.which("brew"):
+            subprocess.run(["brew", "install", "ffmpeg"])
+        else:
+            pw("Could not auto-install ffmpeg. Please install it manually.")
+
+    if pip_missing or not HAS_FFMPEG:
+        try:
+            from PIL import Image as _Image
+            Image = _Image
+            HAS_PIL = True
+        except ImportError:
+            HAS_PIL = False
+        try:
+            import mido as _mido
+            mido = _mido
+            HAS_MIDO = True
+        except ImportError:
+            HAS_MIDO = False
+        HAS_FFMPEG = shutil.which("ffmpeg") is not None
 
 # ── deck / card / blueprint discovery ────────────────────────────────────────
 
@@ -190,24 +207,23 @@ def find_blueprints(card: Path) -> list[Path]:
 
 # ── image/gif → Drawing2 ─────────────────────────────────────────────────────
 
-def load_image_frames(path: Path, size: int):
+def load_image_frames(path: Path, width: int, height: int):
     img = Image.open(path)
-    resample = Image.NEAREST if size > max(img.size) else Image.LANCZOS
 
     # Normal image
     if not getattr(img, "is_animated", False):
-        frame = img.convert("RGBA").resize((size, size), resample)
+        frame = img.convert("RGBA").resize((width, height), Image.NEAREST)
         buf = io.BytesIO()
         frame.save(buf, format="PNG")
         return [buf.getvalue()], 1.0
 
-    # Animated GIF
+    # Animated GIF/WEBP
     frames = []
     durations = []
 
     try:
         while True:
-            frame = img.convert("RGBA").resize((size, size), resample)
+            frame = img.convert("RGBA").resize((width, height), Image.NEAREST)
             buf = io.BytesIO()
             frame.save(buf, format="PNG")
             frames.append(buf.getvalue())
@@ -221,8 +237,8 @@ def load_image_frames(path: Path, size: int):
 
     return frames, fps
 
-def probe_video_size(path: Path) -> int:
-    """Return max(width, height) of a video file via ffprobe."""
+def probe_video_dimensions(path: Path) -> tuple[int, int]:
+    """Return (width, height) of a video file via ffprobe."""
     probe = subprocess.run(
         ["ffprobe", "-v", "error", "-select_streams", "v:0",
          "-show_entries", "stream=width,height",
@@ -232,12 +248,12 @@ def probe_video_size(path: Path) -> int:
     raw = probe.stdout.strip()
     try:
         w, h = raw.split("x")
-        return max(int(w), int(h))
+        return int(w), int(h)
     except Exception:
-        return 64
+        return 64, 64
 
 
-def extract_mp4_frames(path: Path, size: int, every_n: int = 1) -> tuple[list[bytes], float]:
+def extract_mp4_frames(path: Path, width: int, height: int, every_n: int = 1) -> tuple[list[bytes], float]:
     """Extract frames from MP4 using ffmpeg. Returns (png_frames, fps)."""
     if not HAS_FFMPEG:
         pe("ffmpeg not found. Install with: pkg install ffmpeg")
@@ -259,13 +275,12 @@ def extract_mp4_frames(path: Path, size: int, every_n: int = 1) -> tuple[list[by
 
     effective_fps = fps / every_n
 
-    src_size = probe_video_size(path)
-    scale_flags = "neighbor" if size > src_size else "bicubic"
-
-    # Extract frames as PNG via pipe
+    # Extract frames as PNG via pipe. width/height already share the source's
+    # aspect ratio (scaled), so a plain nearest-neighbor scale is exact — no
+    # padding/cropping needed.
     result = subprocess.run(
         ["ffmpeg", "-i", str(path),
-         "-vf", f"select='not(mod(n\\,{every_n}))',scale={size}:{size}:force_original_aspect_ratio=decrease:flags={scale_flags},pad={size}:{size}:(ow-iw)/2:(oh-ih)/2",
+         "-vf", f"select='not(mod(n\\,{every_n}))',scale={width}:{height}:flags=neighbor",
          "-vsync", "vfr",
          "-f", "image2pipe", "-vcodec", "png", "-"],
         capture_output=True
@@ -303,24 +318,22 @@ def quantize_frame(png_bytes: bytes, colors: int) -> bytes:
     result.save(buf, format="PNG", optimize=True)
     return buf.getvalue()
 
-import base64
-import math
-
 def build_drawing2(
     frames: list[bytes],
     fps: float,
-    size: int,
+    width: int,
+    height: int,
     play_mode: str = "loop"
 ) -> dict:
     # Empirical scale formula
-    scale = max(1, round(size / 20))
+    scale = max(1, round(max(width, height) / 20))
 
-    half = size / 2
+    half_w, half_h = width / 2, height / 2
     bounds = {
-        "minX": -half,
-        "maxX": half,
-        "minY": -half,
-        "maxY": half,
+        "minX": -half_w,
+        "maxX": half_w,
+        "minY": -half_h,
+        "maxY": half_h,
 }
 
     castle_frames = [{
@@ -368,8 +381,8 @@ def build_drawing2(
 
         "physicsBodyData": {
             "shapes": [{
-                "p1": {"x": half / scale, "y": half / scale},
-                "p2": {"x": -half / scale, "y": -half / scale},
+                "p1": {"x": half_w / scale, "y": half_h / scale},
+                "p2": {"x": -half_w / scale, "y": -half_h / scale},
                 "p3": {"x": 0, "y": 0},
                 "radius": 0,
                 "x": 0,
@@ -384,6 +397,433 @@ def build_drawing2(
         "disabled": False,
         } 
 
+# ── svg → Drawing2 (vector) ──────────────────────────────────────────────────
+# Merged from svg_to_castle.py: flattens all SVG paths to straight line
+# segments (s:1, f:false). Bezier curves are sampled at `steps` intervals.
+
+# Castle coordinate scale: SVG px → Castle units
+# fillPixelsPerUnit = 25.6 by default
+SVG_DEFAULT_PPU = 25.6
+SVG_NS = "http://www.w3.org/2000/svg"
+
+
+def _svg_lerp(a, b, t): return a + (b - a) * t
+
+def _svg_quadratic_point(p0, p1, p2, t):
+    x = (1-t)**2*p0[0] + 2*(1-t)*t*p1[0] + t**2*p2[0]
+    y = (1-t)**2*p0[1] + 2*(1-t)*t*p1[1] + t**2*p2[1]
+    return (x, y)
+
+def _svg_cubic_point(p0, p1, p2, p3, t):
+    x = (1-t)**3*p0[0] + 3*(1-t)**2*t*p1[0] + 3*(1-t)*t**2*p2[0] + t**3*p3[0]
+    y = (1-t)**3*p0[1] + 3*(1-t)**2*t*p1[1] + 3*(1-t)*t**2*p2[1] + t**3*p3[1]
+    return (x, y)
+
+
+def _svg_arc_to_lines(x1, y1, rx, ry, x_rot, large, sweep, x2, y2, steps):
+    """Convert SVG arc to polyline points."""
+    if x1 == x2 and y1 == y2:
+        return []
+    if rx == 0 or ry == 0:
+        return [(x1, y1), (x2, y2)]
+
+    phi = math.radians(x_rot)
+    cos_phi, sin_phi = math.cos(phi), math.sin(phi)
+
+    dx, dy = (x1 - x2) / 2, (y1 - y2) / 2
+    x1p =  cos_phi * dx + sin_phi * dy
+    y1p = -sin_phi * dx + cos_phi * dy
+
+    rx, ry = abs(rx), abs(ry)
+    x1p2, y1p2, rx2, ry2 = x1p**2, y1p**2, rx**2, ry**2
+    lam = x1p2/rx2 + y1p2/ry2
+    if lam > 1:
+        sq = math.sqrt(lam)
+        rx, ry = sq * rx, sq * ry
+        rx2, ry2 = rx**2, ry**2
+
+    num = max(0, rx2*ry2 - rx2*y1p2 - ry2*x1p2)
+    den = rx2*y1p2 + ry2*x1p2
+    sq = math.sqrt(num / den) if den else 0
+    if large == sweep:
+        sq = -sq
+
+    cxp =  sq * rx * y1p / ry
+    cyp = -sq * ry * x1p / rx
+
+    cx = cos_phi*cxp - sin_phi*cyp + (x1+x2)/2
+    cy = sin_phi*cxp + cos_phi*cyp + (y1+y2)/2
+
+    def angle(ux, uy, vx, vy):
+        n = math.sqrt(ux**2+uy**2) * math.sqrt(vx**2+vy**2)
+        if n == 0: return 0
+        c = max(-1, min(1, (ux*vx+uy*vy)/n))
+        a = math.acos(c)
+        if ux*vy - uy*vx < 0: a = -a
+        return a
+
+    theta1 = angle(1, 0, (x1p-cxp)/rx, (y1p-cyp)/ry)
+    dtheta = angle((x1p-cxp)/rx, (y1p-cyp)/ry, (-x1p-cxp)/rx, (-y1p-cyp)/ry)
+
+    if not sweep and dtheta > 0: dtheta -= 2*math.pi
+    if sweep and dtheta < 0: dtheta += 2*math.pi
+
+    pts = []
+    for i in range(steps + 1):
+        t = i / steps
+        theta = theta1 + t * dtheta
+        x = cos_phi*rx*math.cos(theta) - sin_phi*ry*math.sin(theta) + cx
+        y = sin_phi*rx*math.cos(theta) + cos_phi*ry*math.sin(theta) + cy
+        pts.append((x, y))
+    return pts
+
+
+def _svg_parse_numbers(s: str) -> list[float]:
+    return [float(x) for x in re.findall(r'[-+]?(?:\d+\.?\d*|\.\d+)(?:[eE][-+]?\d+)?', s)]
+
+
+def _svg_path_to_polylines(d: str, steps: int = 16) -> list[list[tuple]]:
+    """
+    Parse SVG path 'd' attribute, return list of polylines.
+    Each polyline is a list of (x, y) tuples.
+    Beziers are sampled at 'steps' intervals.
+    """
+    tokens = re.findall(r'[MmZzLlHhVvCcSsQqTtAa]|[-+]?(?:\d+\.?\d*|\.\d+)(?:[eE][-+]?\d+)?', d)
+    cmd = None
+    pos = (0.0, 0.0)
+    start = (0.0, 0.0)
+    last_ctrl = None
+    polylines = []
+    current = []
+
+    def flush():
+        nonlocal current
+        if len(current) >= 2:
+            polylines.append(current)
+        current = []
+
+    i = 0
+    while i < len(tokens):
+        t = tokens[i]
+        if re.match(r'[MmZzLlHhVvCcSsQqTtAa]', t):
+            cmd = t
+            i += 1
+            if cmd in ('Z', 'z'):
+                if current and current[-1] != start:
+                    current.append(start)
+                flush()
+                pos = start
+                cmd = None
+            continue
+
+        if cmd in ('Z', 'z'):
+            if current and current[-1] != start:
+                current.append(start)
+            flush()
+            pos = start
+            cmd = None
+            continue
+
+        nparams = {
+            'M':2,'m':2,'L':2,'l':2,'H':1,'h':1,'V':1,'v':1,
+            'C':6,'c':6,'S':4,'s':4,'Q':4,'q':4,'T':2,'t':2,
+            'A':7,'a':7,
+        }.get(cmd, 0)
+
+        if nparams == 0:
+            i += 1
+            continue
+
+        args = []
+        while len(args) < nparams and i < len(tokens):
+            tok = tokens[i]
+            if re.match(r'[MmZzLlHhVvCcSsQqTtAa]', tok):
+                break
+            args.append(float(tok))
+            i += 1
+
+        if len(args) < nparams:
+            continue
+
+        rel = cmd.islower()
+        base = pos if rel else (0.0, 0.0)
+
+        if cmd in ('M', 'm'):
+            flush()
+            nx, ny = base[0]+args[0], base[1]+args[1]
+            pos = (nx, ny)
+            start = pos
+            current = [pos]
+            last_ctrl = None
+            cmd = 'l' if rel else 'L'
+
+        elif cmd in ('L', 'l'):
+            nx, ny = base[0]+args[0], base[1]+args[1]
+            pos = (nx, ny)
+            current.append(pos)
+            last_ctrl = None
+
+        elif cmd in ('H', 'h'):
+            nx = (pos[0] if rel else 0) + args[0]
+            pos = (nx, pos[1])
+            current.append(pos)
+            last_ctrl = None
+
+        elif cmd in ('V', 'v'):
+            ny = (pos[1] if rel else 0) + args[0]
+            pos = (pos[0], ny)
+            current.append(pos)
+            last_ctrl = None
+
+        elif cmd in ('C', 'c'):
+            p1 = (base[0]+args[0], base[1]+args[1])
+            p2 = (base[0]+args[2], base[1]+args[3])
+            p3 = (base[0]+args[4], base[1]+args[5])
+            for s in range(1, steps+1):
+                current.append(_svg_cubic_point(pos, p1, p2, p3, s/steps))
+            last_ctrl = p2
+            pos = p3
+
+        elif cmd in ('S', 's'):
+            p1 = (2*pos[0]-last_ctrl[0], 2*pos[1]-last_ctrl[1]) if last_ctrl else pos
+            p2 = (base[0]+args[0], base[1]+args[1])
+            p3 = (base[0]+args[2], base[1]+args[3])
+            for s in range(1, steps+1):
+                current.append(_svg_cubic_point(pos, p1, p2, p3, s/steps))
+            last_ctrl = p2
+            pos = p3
+
+        elif cmd in ('Q', 'q'):
+            p1 = (base[0]+args[0], base[1]+args[1])
+            p2 = (base[0]+args[2], base[1]+args[3])
+            for s in range(1, steps+1):
+                current.append(_svg_quadratic_point(pos, p1, p2, s/steps))
+            last_ctrl = p1
+            pos = p2
+
+        elif cmd in ('T', 't'):
+            p1 = (2*pos[0]-last_ctrl[0], 2*pos[1]-last_ctrl[1]) if last_ctrl else pos
+            p2 = (base[0]+args[0], base[1]+args[1])
+            for s in range(1, steps+1):
+                current.append(_svg_quadratic_point(pos, p1, p2, s/steps))
+            last_ctrl = p1
+            pos = p2
+
+        elif cmd in ('A', 'a'):
+            rx,ry,xr = args[0],args[1],args[2]
+            large,sweep = int(args[3]),int(args[4])
+            ex,ey = base[0]+args[5], base[1]+args[6]
+            pts = _svg_arc_to_lines(pos[0],pos[1],rx,ry,xr,large,sweep,ex,ey,steps)
+            if pts:
+                current.extend(pts[1:])
+            last_ctrl = None
+            pos = (ex, ey)
+
+    flush()
+    return polylines
+
+
+SVG_COLORS = {
+    "black":(0,0,0),"white":(1,1,1),"red":(1,0,0),"green":(0,0.502,0),
+    "blue":(0,0,1),"yellow":(1,1,0),"cyan":(0,1,1),"magenta":(1,0,1),
+    "gray":(0.502,0.502,0.502),"grey":(0.502,0.502,0.502),
+    "none":None,
+}
+
+def parse_svg_color(s: str, opacity: float = 1.0):
+    if not s or s == "none": return None
+    s = s.strip().lower()
+    if s in SVG_COLORS:
+        c = SVG_COLORS[s]
+        return [*c, opacity] if c else None
+    if s.startswith("#"):
+        h = s[1:]
+        if len(h) == 3: h = h[0]*2+h[1]*2+h[2]*2
+        r,g,b = int(h[0:2],16)/255, int(h[2:4],16)/255, int(h[4:6],16)/255
+        return [r, g, b, opacity]
+    m = re.match(r'rgb\((\d+),\s*(\d+),\s*(\d+)\)', s)
+    if m:
+        return [int(m.group(i))/255 for i in (1,2,3)] + [opacity]
+    return [0, 0, 0, opacity]
+
+
+def svg_to_path_data(svg_path, steps: int = 16, scale: float = 1.0,
+                     ppu: float = SVG_DEFAULT_PPU, color=None):
+    """
+    Parse an SVG file and return a Castle pathDataList and framesBounds.
+    scale: multiplier applied to Castle units (1.0 = default)
+    ppu: pixels per unit (default 25.6)
+    color: override color [r,g,b,a], None = use SVG colors
+    """
+    tree = ET.parse(svg_path)
+    root = tree.getroot()
+
+    def tag(el): return el.tag.split('}')[-1] if '}' in el.tag else el.tag
+
+    vb = root.get("viewBox")
+    if vb:
+        parts = _svg_parse_numbers(vb)
+        vb_x, vb_y, vb_w, vb_h = parts
+    else:
+        vb_x, vb_y = 0, 0
+        vb_w = float(root.get("width", 100))
+        vb_h = float(root.get("height", 100))
+
+    # SVG Y is flipped vs Castle Y
+    def to_castle_raw(x, y):
+        return (x / ppu * scale, -(y / ppu) * scale)
+
+    _cx_offset = [0.0]
+    _cy_offset = [0.0]
+
+    def to_castle(x, y):
+        rx, ry = to_castle_raw(x, y)
+        return (rx - _cx_offset[0], ry - _cy_offset[0])
+
+    path_data = []
+    default_color = color or [0, 0, 0, 1]
+    all_xs, all_ys = [], []
+
+    def get_color(el):
+        if color: return color
+        stroke = el.get("stroke") or el.get("style", "")
+        m = re.search(r'stroke\s*:\s*([^;]+)', stroke)
+        stroke_val = m.group(1).strip() if m else (el.get("stroke") or "black")
+        op_m = re.search(r'stroke-opacity\s*:\s*([^;]+)', el.get("style",""))
+        opacity = float(op_m.group(1)) if op_m else float(el.get("stroke-opacity", 1))
+        c = parse_svg_color(stroke_val, opacity)
+        return c if c else default_color
+
+    def process_element(el):
+        t = tag(el)
+        c = get_color(el)
+
+        polylines = []
+
+        if t == "path":
+            d = el.get("d", "")
+            polylines = _svg_path_to_polylines(d, steps)
+
+        elif t == "line":
+            x1,y1 = float(el.get("x1",0)), float(el.get("y1",0))
+            x2,y2 = float(el.get("x2",0)), float(el.get("y2",0))
+            polylines = [[(x1,y1),(x2,y2)]]
+
+        elif t == "polyline" or t == "polygon":
+            pts_raw = _svg_parse_numbers(el.get("points",""))
+            pts = [(pts_raw[i],pts_raw[i+1]) for i in range(0,len(pts_raw)-1,2)]
+            if t == "polygon" and pts: pts.append(pts[0])
+            polylines = [pts]
+
+        elif t == "rect":
+            x,y = float(el.get("x",0)), float(el.get("y",0))
+            w,h = float(el.get("width",0)), float(el.get("height",0))
+            polylines = [[(x,y),(x+w,y),(x+w,y+h),(x,y+h),(x,y)]]
+
+        elif t == "circle":
+            cx2,cy2,r = float(el.get("cx",0)),float(el.get("cy",0)),float(el.get("r",1))
+            pts = [(cx2+r*math.cos(2*math.pi*i/steps),
+                    cy2+r*math.sin(2*math.pi*i/steps)) for i in range(steps+1)]
+            polylines = [pts]
+
+        elif t == "ellipse":
+            cx2,cy2 = float(el.get("cx",0)),float(el.get("cy",0))
+            rx2,ry2 = float(el.get("rx",1)),float(el.get("ry",1))
+            pts = [(cx2+rx2*math.cos(2*math.pi*i/steps),
+                    cy2+ry2*math.sin(2*math.pi*i/steps)) for i in range(steps+1)]
+            polylines = [pts]
+
+        for poly in polylines:
+            if len(poly) < 2: continue
+            castle_pts = [to_castle(x, y) for x, y in poly]
+            for j in range(len(castle_pts)-1):
+                x1,y1 = castle_pts[j]
+                x2,y2 = castle_pts[j+1]
+                path_data.append({
+                    "p": [round(x1,5), round(y1,5), round(x2,5), round(y2,5)],
+                    "s": 1,
+                    "f": False,
+                    "c": [round(v,5) for v in c],
+                })
+                all_xs.extend([x1, x2])
+                all_ys.extend([y1, y2])
+
+        for child in el:
+            process_element(child)
+
+    process_element(root)
+
+    if not all_xs:
+        return path_data, {"minX":-5,"maxX":5,"minY":-5,"maxY":5}, {"minX":-32,"maxX":32,"minY":-32,"maxY":32}
+
+    mid_x = (min(all_xs) + max(all_xs)) / 2
+    mid_y = (min(all_ys) + max(all_ys)) / 2
+    for seg in path_data:
+        seg["p"][0] = round(seg["p"][0] - mid_x, 5)
+        seg["p"][1] = round(seg["p"][1] - mid_y, 5)
+        seg["p"][2] = round(seg["p"][2] - mid_x, 5)
+        seg["p"][3] = round(seg["p"][3] - mid_y, 5)
+    all_xs = [x - mid_x for x in all_xs]
+    all_ys = [y - mid_y for y in all_ys]
+
+    bounds = {
+        "minX": round(min(all_xs), 5),
+        "maxX": round(max(all_xs), 5),
+        "minY": round(min(all_ys), 5),
+        "maxY": round(max(all_ys), 5),
+    }
+
+    fill_bounds = {
+        "minX": round(min(all_xs) * ppu / scale),
+        "maxX": round(max(all_xs) * ppu / scale),
+        "minY": round(-max(all_ys) * ppu / scale),
+        "maxY": round(-min(all_ys) * ppu / scale),
+    }
+
+    return path_data, bounds, fill_bounds
+
+
+def build_drawing2_vector(path_data, bounds, fill_bounds,
+                           scale=10, ppu=SVG_DEFAULT_PPU) -> dict:
+    frame = {
+        "isLinked": False,
+        "pathDataList": path_data,
+        "fillImageBounds": fill_bounds,
+        "avatarX": 0, "avatarY": 0, "avatarRadius": 5,
+    }
+    return {
+        "initialFrame": 1, "currentFrame": 1,
+        "framesPerSecond": 4,
+        "playMode": "still",
+        "loopStartFrame": -1, "loopEndFrame": -1,
+        "opacity": 1,
+        "hash": str(abs(hash(str(path_data))))[:19],
+        "playing": False, "loop": False,
+        "drawData": {
+            "color": [1,1,1,1], "lineColor": [0,0,0,1],
+            "gridSize": 0.71428, "scale": scale, "version": 3,
+            "fillPixelsPerUnit": ppu,
+            "numTotalLayers": 1,
+            "framesBounds": [bounds],
+            "colors": [], "selectedFrame": 1,
+            "layers": [{
+                "title": "Layer 1", "id": "layer1",
+                "isVisible": True, "isBitmap": False, "isAvatar": False,
+                "frames": [frame],
+            }],
+        },
+        "physicsBodyData": {
+            "shapes": [{
+                "p1": {"x": 5, "y": 5}, "p2": {"x": -5, "y": -5},
+                "p3": {"x": 0, "y": 0}, "radius": 0, "x": 0, "y": 0,
+                "type": "rectangle",
+            }],
+            "scale": scale, "version": 2, "zeroShapesInV1": False,
+        },
+        "disabled": False,
+    }
+
+
 # ── midi → Music ─────────────────────────────────────────────────────────────
 
 def beat_key(b): return f"{b:.6f}"
@@ -467,7 +907,7 @@ def collect_midi_tracks(mid) -> list[list[tuple[float,int]]]:
     return result
 
 def build_music(midi_path: Path, beats_per_bar: int = 4) -> dict:
-    mid = mido.MidiFile(midi_path)
+    mid = mido.MidiFile(midi_path, clip=True)
     midi_tracks = collect_midi_tracks(mid)
     patterns, castle_tracks = {}, []
     for t_idx, events in enumerate(midi_tracks):
@@ -512,46 +952,27 @@ def build_music(midi_path: Path, beats_per_bar: int = 4) -> dict:
 
 def main():
     p()
-    pb("═══════════════════════════════════")
-    pb("       Castle Blueprint Tool       ")
-    pb("═══════════════════════════════════")
+    pb("═══════════════")
+    pb("   Castletool   ")
+    pb("═══════════════")
     p()
 
-    # ── check deps ──
-    missing = []
-    if not HAS_PIL:   missing.append("Pillow        (pip install Pillow)")
-    if not HAS_MIDO:  missing.append("mido          (pip install mido)")
-    if not HAS_PT:    missing.append("prompt_toolkit (pip install prompt_toolkit)  — enables tab-complete for file paths")
-    if not HAS_FZF:
-        print(f"  {DIM}tip: install fzf for fuzzy file finding   (pkg install fzf){RESET}")
-    if not HAS_FFMPEG:
-        print(f"  {DIM}tip: install ffmpeg for MP4/video support  (pkg install ffmpeg){RESET}")
-    if missing:
-        pw("Missing optional dependencies (only needed for relevant features):")
-        for m in missing: print(f"   • {m}")
-        p()
-
-    # ── android warning ──
-    termux = is_termux()
-    if termux:
-        pw("Android/Termux detected. Use ~/storage/... paths for files.")
-        if not check_storage_setup():
-            setup_termux_storage()
-        p()
+    check_for_update()
+    ensure_dependencies()
+    p()
 
     # ── select deck ──
     home = Path.cwd()
     decks = find_decks(home)
     if not decks:
-        pe("No Castle decks found in the current directory.")
-        pe("Run 'castle get-deck <id> <folder>' first.")
+        pe("No decks were found. Are you in the right directory?")
         sys.exit(1)
 
     deck_names = [d.name for d in decks]
     pb(f"Detected decks: {', '.join(deck_names)}")
     if len(decks) == 1:
         deck = decks[0]
-        ps(f"Only one deck ({deck.name}), auto-selecting.")
+        ps(f"Auto selecting {deck.name}")
     else:
         chosen = choose("Select the deck you would like to modify:", deck_names)
         deck = home / chosen
@@ -565,7 +986,7 @@ def main():
     card_names = [c.name for c in cards]
     if len(cards) == 1:
         card = cards[0]
-        ps(f"Only one card ({card.name}), auto-selecting.")
+        ps(f"Auto selecting {card.name}")
     else:
         chosen = choose("Select the card you would like to edit:", card_names)
         card = deck / "cards" / chosen
@@ -579,7 +1000,7 @@ def main():
     bp_names = [b.name for b in blueprints]
     if len(blueprints) == 1:
         bp_path = blueprints[0]
-        ps(f"Only one blueprint ({bp_path.name}), auto-selecting.")
+        ps(f"Auto selecting {bp_path.name}")
     else:
         chosen = choose("Select the blueprint you would like to edit:", bp_names)
         bp_path = card / "scene" / "blueprints" / chosen
@@ -606,41 +1027,35 @@ def main():
             pe(f"File not found: {img_path}")
 
         ext = img_path.suffix.lower()
-        is_anim = ext in (".gif", ".mp4", ".mov", ".webm", ".avi")
+        is_anim = ext in (".gif", ".webp", ".mp4", ".mov", ".webm", ".avi")
         is_video = ext in (".mp4", ".mov", ".webm", ".avi")
         is_vector = ext in (".svg",)
         file_size = img_path.stat().st_size
 
+        # native size + scale
         p()
+        width, every, quantize = None, 1, 0
         if not is_vector:
-            pw("Make sure this file is formatted correctly. You can verify by importing it in the Castle app.")
-            pw("If it's corrupt and you ignore this, the card may become corrupted.")
-            if not yn("Continue?"):
-                sys.exit(0)
-
-        # size
-        p()
-        resize = (not is_vector) and yn("Would you like to resize this image?", default="n")
-        size, every, quantize = None, 1, 0
-        if not is_vector:
-            if resize:
-                while True:
-                    raw = ask("Enter size (e.g. 64x64 or just 64)", default="64x64")
-                    raw = raw.strip().lower().replace("x", " ").split()
-                    try:
-                        size = int(raw[0])
-                        break
-                    except:
-                        pe("Invalid size.")
+            if is_video:
+                if not HAS_FFMPEG:
+                    pe("ffmpeg is required for video files. Install with: pkg install ffmpeg")
+                    sys.exit(1)
+                native_w, native_h = probe_video_dimensions(img_path)
             else:
-                if is_video:
-                    if not HAS_FFMPEG:
-                        pe("ffmpeg is required for video files. Install with: pkg install ffmpeg")
-                        sys.exit(1)
-                    size = probe_video_size(img_path)
-                else:
-                    with Image.open(img_path) as _img:
-                        size = max(_img.size)
+                with Image.open(img_path) as _img:
+                    native_w, native_h = _img.size
+
+            raw = ask("Scale (1 = full resolution, 0.5 = half, 2 = double)", default="1")
+            try:
+                img_scale = float(raw)
+                if img_scale <= 0:
+                    raise ValueError
+            except ValueError:
+                pw("Invalid scale, using 1.")
+                img_scale = 1.0
+
+            width = max(1, round(native_w * img_scale))
+            height = max(1, round(native_h * img_scale))
 
             # frame skip for animations
             if is_anim:
@@ -657,7 +1072,7 @@ def main():
             p()
             if file_size > 500_000:
                 pw(f"This file is abnormally large ({file_size//1024}KB). Quantizing is recommended.")
-            if yn("Would you like to quantize this image? (reduces file size, usually no visible difference at ≥256 colors)", default="y" if file_size > 500_000 else "n"):
+            if yn("Would you like to quantize this image? (reduces file size)", default="y" if file_size > 500_000 else "n"):
                 while True:
                     raw = ask("Select number of colors", default="256")
                     if raw.isdigit() and 1 <= int(raw) <= 256:
@@ -667,9 +1082,6 @@ def main():
 
         p()
         if is_vector:
-            if not HAS_SVG:
-                pe("svg_to_castle.py not found — place it in the same folder as castle_tool.py")
-                sys.exit(1)
             pb(f"Loading SVG: {img_path.name}")
             svg_scale = 1.0
             if yn("Would you like to scale the SVG output?", default="n"):
@@ -698,9 +1110,9 @@ def main():
                 if not HAS_FFMPEG:
                     pe("ffmpeg is required for video files. Install with: pkg install ffmpeg")
                     sys.exit(1)
-                frames, fps = extract_mp4_frames(img_path, size, every_n=every)
+                frames, fps = extract_mp4_frames(img_path, width, height, every_n=every)
             else:
-                frames, fps = load_image_frames(img_path, size)
+                frames, fps = load_image_frames(img_path, width, height)
                 if every > 1:
                     frames = frames[::every]
                     fps = fps / every
@@ -710,8 +1122,8 @@ def main():
                 frames = [quantize_frame(f, quantize) for f in frames]
 
             play_mode = "loop" if is_anim else "still"
-            drawing2 = build_drawing2(frames, fps, size)
-            ps(f"Image ready: {len(frames)} frame(s), {fps} FPS, {size}×{size}px")
+            drawing2 = build_drawing2(frames, fps, width, height, play_mode)
+            ps(f"Image ready: {len(frames)} frame(s), {fps} FPS, {width}×{height}px")
 
     # ── midi? ──
     music = None
@@ -746,16 +1158,8 @@ def main():
         pw("Nothing to do. Exiting.")
         sys.exit(0)
 
-    # ── confirm overwrite ──
-    p()
-    what = []
-    if drawing2: what.append("image/animation (Drawing2)")
-    if music:    what.append("music (Music)")
-    pw(f"This will overwrite {' and '.join(what)} in:\n   {bp_path}")
-    if not yn("Are you sure you want to modify this blueprint?"):
-        sys.exit(0)
-
     # ── inject ──
+    p()
     if drawing2:
         actor["actorBlueprint"]["components"]["Drawing2"] = drawing2
     if music:
@@ -763,17 +1167,19 @@ def main():
 
     with open(bp_path, "w", encoding="utf-8") as f:
         json.dump(actor, f, indent=2)
-    ps(f"Blueprint written to {bp_path}")
 
     # ── save ──
     p()
     if yn("Would you like to save this deck now?"):
         result = subprocess.run(["castle", "save-deck", str(deck)],
                                 capture_output=True, text=True)
+        combined = (result.stdout + result.stderr).lower()
         if result.returncode == 0:
             ps("Saved!")
             for line in result.stdout.strip().splitlines():
                 print(f"   {line}")
+        elif "memory access out of bounds" in combined:
+            pe("Your file is too large!")
         else:
             pe("Save failed:")
             print(result.stdout)

{castletool-0.2.2 → castletool-0.3.0}/castletool.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: castletool
-Version: 0.2.2
+Version: 0.3.0
 Summary: Interactive Castle deck editor for injecting images/GIFs and MIDI into Castle blueprint JSON files.
 Author-email: Your Name <your.email@example.com>
 Classifier: Programming Language :: Python :: 3

{castletool-0.2.2 → castletool-0.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "castletool"
-version = "0.2.2"
+version = "0.3.0"
 description = "Interactive Castle deck editor for injecting images/GIFs and MIDI into Castle blueprint JSON files."
 authors = [
     { name = "Your Name", email = "your.email@example.com" }