inscript-lang 2.12.0__tar.gz → 3.0.0__tar.gz

{inscript_lang-2.12.0 → inscript_lang-3.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: inscript-lang
-Version: 2.12.0
+Version: 3.0.0
 Summary: InScript — a game-focused scripting language with 59 game modules and a bytecode VM
 Author: Shreyasi Sarkar
 License: MIT

{inscript_lang-2.12.0 → inscript_lang-3.0.0}/export_pipeline.py

@@ -42,7 +42,7 @@ MANIFEST_FILE  = "inscript.toml"
 ENTRY_DEFAULT  = os.path.join("src", "main.ins")
 BUILD_MANIFEST = "build.toml"
 
-VALID_TARGETS  = ("desktop", "web", "android", "ibc")
+VALID_TARGETS  = ("desktop", "web", "android", "ios", "ibc")
 
 # Pyodide CDN base used in web builds
 PYODIDE_CDN    = "https://cdn.jsdelivr.net/pyodide/v0.27.0/full/"
@@ -645,3 +645,114 @@ def run_build(target: str, project_dir: str = ".") -> int:
         for e in r.errors:
             print(f"[build] {e}", file=sys.stderr)
     return 0 if r.success else 1
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# v2.13.0: Target: iOS
+# ─────────────────────────────────────────────────────────────────────────────
+
+def build_ios(project_dir: str = ".") -> BuildResult:
+    """
+    Build an iOS app via BeeWare Briefcase.
+    Requires: macOS + Xcode + pip install briefcase
+
+    Output layout:
+      build/ios/
+        pyproject.toml   — Briefcase config
+        app.py           — InScript iOS entry point
+        build.toml       — build manifest
+    """
+    import time, subprocess
+    t0 = time.perf_counter()
+    errors: List[str] = []
+    artifacts: List[str] = []
+
+    manifest = _read_manifest(project_dir)
+    pkg      = manifest.get("package", {})
+    version  = pkg.get("version", "0.0.0")
+    name     = pkg.get("name", "mygame")
+    entry    = pkg.get("entry", ENTRY_DEFAULT)
+    bundle   = pkg.get("bundle", f"dev.inscript.{name}")
+
+    out_dir = os.path.join(project_dir, BUILD_DIR, "ios")
+    os.makedirs(out_dir, exist_ok=True)
+
+    bp_path = os.path.join(out_dir, "pyproject.toml")
+    with open(bp_path, "w") as f:
+        f.write(textwrap.dedent(f"""\
+            [tool.briefcase]
+            project_name = "{name}"
+            bundle       = "{bundle}"
+            version      = "{version}"
+            description  = "Built with InScript"
+            license      = "MIT"
+
+            [tool.briefcase.app.{name}]
+            formal_name  = "{name}"
+            description  = "Built with InScript"
+            sources      = ["."]
+            requires     = ["inscript-lang"]
+
+            [tool.briefcase.app.{name}.iOS]
+            requires = ["toga-iOS"]
+        """))
+    artifacts.append(bp_path)
+
+    app_py = os.path.join(out_dir, "app.py")
+    with open(app_py, "w") as f:
+        f.write(textwrap.dedent(f"""\
+            # InScript iOS entry — generated by inscript build --target ios
+            import sys
+            try:
+                import inscript
+                inscript.main(["{entry}"])
+            except Exception as e:
+                print(f"InScript launch error: {{e}}", file=sys.stderr)
+        """))
+    artifacts.append(app_py)
+
+    for sub in ("src", "assets", "scenes"):
+        s = os.path.join(project_dir, sub)
+        d = os.path.join(out_dir, sub)
+        if os.path.isdir(s):
+            if os.path.exists(d): shutil.rmtree(d)
+            shutil.copytree(s, d)
+
+    from inscript import VERSION as _IV
+    bm = _write_build_manifest(out_dir, {
+        "target": "ios", "version": version, "entry": entry,
+        "inscript_version": _IV, "bundle": bundle,
+        "artifacts": {"pyproject": "pyproject.toml", "app": "app.py"},
+        "asset_hashes": {},
+    })
+    artifacts.append(bm)
+
+    # Check platform and briefcase
+    if sys.platform != "darwin":
+        msg = "iOS builds require macOS. Current platform: " + sys.platform
+        errors.append(msg)
+        print(f"[build:ios] ⚠  {msg}")
+        elapsed = (time.perf_counter() - t0) * 1000
+        return BuildResult("ios", False, out_dir, artifacts, errors, elapsed)
+
+    briefcase_ok = shutil.which("briefcase") is not None
+    if not briefcase_ok:
+        msg = ("BeeWare Briefcase not installed. "
+               "Install: pip install briefcase  "
+               "Then: cd build/ios && briefcase create iOS && briefcase build iOS")
+        errors.append(msg)
+        print(f"[build:ios] ⚠  {msg}")
+        elapsed = (time.perf_counter() - t0) * 1000
+        return BuildResult("ios", False, out_dir, artifacts, errors, elapsed)
+
+    try:
+        subprocess.run([sys.executable, "-m", "briefcase", "create", "iOS"],
+                       cwd=out_dir, check=True)
+        subprocess.run([sys.executable, "-m", "briefcase", "build", "iOS"],
+                       cwd=out_dir, check=True)
+        print(f"[build:ios] ✅ iOS app built → {out_dir}")
+    except subprocess.CalledProcessError as e:
+        errors.append(f"briefcase failed: {e}")
+
+    elapsed = (time.perf_counter() - t0) * 1000
+    return BuildResult("ios", len(errors) == 0, out_dir, artifacts, errors, elapsed)

{inscript_lang-2.12.0 → inscript_lang-3.0.0}/inscript.py

@@ -24,7 +24,7 @@ from errors   import (InScriptError, LexerError, ParseError,
                        SemanticError, InScriptRuntimeError,
                        MultiError, InScriptWarning)
 
-VERSION = "2.12.0"
+VERSION = "3.0.0"
 
 MANIFEST_FILENAME = "inscript.toml"
 LOCK_FILENAME     = "inscript.lock"
@@ -2752,6 +2752,17 @@ Examples:
                         help="v2.12.0: Start Electron bridge JSON-RPC server")
     parser.add_argument("--bridge-port", type=int, default=8765,
                         help="v2.12.0: Port for --studio-bridge (default: 8765)")
+    # v3.0.0: Studio + Visual Scripting
+    parser.add_argument("--studio", action="store_true",
+                        help="v3.0.0: Launch InScript Studio web IDE in browser")
+    parser.add_argument("--studio-port", type=int, default=8080,
+                        help="v3.0.0: Port for Studio web app (default: 8080)")
+    parser.add_argument("--visual-compile", metavar="FILE",
+                        help="v3.0.0: Compile a .vins visual script to .ins source")
+    parser.add_argument("--vins-output", metavar="FILE",
+                        help="v3.0.0: Output path for --visual-compile (default: <input>.ins)")
+    parser.add_argument("--vins-template", metavar="NAME",
+                        help="v3.0.0: Generate a .vins template for visual scripting")
     parser.add_argument("--lsp", action="store_true",
                         help="Start the Language Server (requires: pip install pygls)")
     parser.add_argument("--game", action="store_true",
@@ -3067,6 +3078,57 @@ Examples:
             bridge.stop()
         return 0
 
+    # ── v3.0.0 Studio + Visual Scripting ──────────────────────────────────
+    if getattr(args, 'studio', False):
+        import time as _time
+        studio_port = getattr(args, 'studio_port', 8080)
+        bridge_port = getattr(args, 'bridge_port', 8765)
+        proj_dir    = getattr(args, 'project_dir', '.') or '.'
+        from studio_app import StudioApp
+        app_s = StudioApp(proj_dir, studio_port=studio_port, bridge_port=bridge_port)
+        app_s.start()
+        url = app_s.url
+        print(f"[InScript Studio] ✅  Running at {url}")
+        print(f"[InScript Studio] Project: {os.path.abspath(proj_dir)}")
+        print(f"[InScript Studio] Ctrl+C to stop")
+        # Open browser
+        try:
+            import webbrowser as _wb
+            _wb.open(url)
+        except Exception:
+            pass
+        try:
+            while True: _time.sleep(1)
+        except KeyboardInterrupt:
+            app_s.stop()
+            print(f"[InScript Studio] Stopped.")
+        return 0
+
+    if getattr(args, 'visual_compile', None) is not None:
+        from visual_script import compile_file
+        vins_path = args.visual_compile
+        out_path  = getattr(args, 'vins_output', None)
+        if not os.path.isfile(vins_path):
+            print(f"[visual] File not found: {vins_path}", file=sys.stderr); return 1
+        try:
+            result_path = compile_file(vins_path, out_path)
+            print(f"[visual] Written to: {result_path}")
+        except Exception as _ve:
+            print(f"[visual] Compile error: {_ve}", file=sys.stderr); return 1
+        return 0
+
+    if getattr(args, 'vins_template', None) is not None:
+        import json as _j
+        from visual_script import make_template
+        name     = args.vins_template
+        out_path = f"{name}.vins"
+        tmpl     = make_template(name)
+        with open(out_path, "w") as f:
+            _j.dump(tmpl, f, indent=2)
+        print(f"[visual] Template written to {out_path}")
+        print(f"[visual] Compile with: inscript --visual-compile {out_path}")
+        return 0
+
     # v1.9.1: --no-typecheck is deprecated — emit a warning and honour it
     if getattr(args, 'no_typecheck', False):
         print(

{inscript_lang-2.12.0 → inscript_lang-3.0.0}/inscript_lang.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: inscript-lang
-Version: 2.12.0
+Version: 3.0.0
 Summary: InScript — a game-focused scripting language with 59 game modules and a bytecode VM
 Author: Shreyasi Sarkar
 License: MIT

{inscript_lang-2.12.0 → inscript_lang-3.0.0}/setup.py

@@ -57,6 +57,7 @@ setup(
         # ── v2.7.0+ runtime modules ───────────────────────────────────────────
         "scene_tree", "hot_reload", "export_pipeline",
         "studio_bridge", "inscript_studio_api", "studio_readiness",
+        "visual_script", "studio_app", "vins_editor",
     ],
     package_data     = {"": ["examples/*.ins", "lsp/*.py", "*.md"]},
     install_requires = [],

{inscript_lang-2.12.0 → inscript_lang-3.0.0}/stdlib.py

@@ -1163,3 +1163,46 @@ try:
     import stdlib_assets  # noqa: F401
 except Exception as _e4:
     import sys; print(f'[stdlib_assets load error] {_e4}', file=sys.stderr)
+
+# ── Studio IPC (v3.0.0): allows subprocess games to publish scene state ──────
+try:
+    from studio_bridge import _IPC_STATE_FILE, _ipc_write_scene
+
+    def _studio_publish_scene(scene_manager_or_dict=None):
+        """
+        Called from .ins: import "studio_ipc" as ipc; ipc.publish_scene()
+        Writes current scene state to the IPC file so Studio can inspect it.
+        """
+        import json as _j
+        data = {"nodes": [], "count": 0, "source": "ipc"}
+        if scene_manager_or_dict is not None:
+            try:
+                from scene_tree import SceneManager, SceneTree
+                if hasattr(scene_manager_or_dict, 'current'):
+                    sm = scene_manager_or_dict
+                    if sm.current:
+                        nodes = []
+                        def _walk(inst, parent=None):
+                            nodes.append({
+                                "name": inst.name,
+                                "blueprint": inst.blueprint.name,
+                                "parent": parent,
+                                "children": [c.name for c in inst.get_children()],
+                                "props": {k: str(v) for k, v in inst._props.items()
+                                          if not callable(v)},
+                            })
+                            for child in inst.get_children():
+                                _walk(child, inst.name)
+                        _walk(sm.current.root)
+                        data = {"nodes": nodes, "count": len(nodes), "source": "ipc"}
+            except Exception:
+                pass
+        _ipc_write_scene(data)
+
+    from stdlib import register_module as _rm
+    _rm("studio_ipc", {
+        "publish_scene": _studio_publish_scene,
+        "ipc_file":      _IPC_STATE_FILE,
+    })
+except Exception as _se:
+    pass

{inscript_lang-2.12.0 → inscript_lang-3.0.0}/stdlib_game.py

@@ -1121,6 +1121,36 @@ class _InputManager:
         self._key_state = {}  # key -> (pressed_this_frame, held, released_this_frame)
         self._mouse_x = 0.0; self._mouse_y = 0.0
         self._mouse_buttons = {}
+        # v2.13.0: headless emulation — inject key/mouse state without pygame
+        self._emulated_keys:    dict  = {}   # key_name -> bool (held)
+        self._emulated_mouse:   tuple = (0.0, 0.0)
+        self._emulated_buttons: dict  = {}
+        self._headless          = False  # set True when pygame unavailable
+
+    def _try_pygame(self) -> bool:
+        try:
+            import pygame
+            return pygame.get_init()
+        except Exception:
+            return False
+
+    # v2.13.0: headless injection API
+    def emulate_key(self, key: str, held: bool = True):
+        """Inject a key state for headless/Studio preview mode."""
+        self._emulated_keys[key.lower()] = bool(held)
+        self._headless = True
+
+    def emulate_mouse(self, x: float, y: float, buttons: dict | None = None):
+        """Inject mouse position and button state."""
+        self._emulated_mouse   = (float(x), float(y))
+        self._emulated_buttons = buttons or {}
+        self._headless = True
+
+    def clear_emulation(self):
+        """Clear all emulated input state."""
+        self._emulated_keys.clear()
+        self._emulated_buttons.clear()
+        self._headless = False
 
     def map(self, action, keys=None, axes=None, gamepad=None, gamepad_axis=None):
         self._actions[action] = {
@@ -1129,6 +1159,9 @@ class _InputManager:
         }
 
     def _is_key_down(self, key):
+        # v2.13.0: headless emulation takes priority over pygame
+        if self._headless or self._emulated_keys:
+            return self._emulated_keys.get(key.lower(), False)
         try:
             import pygame
             kmap = {
@@ -1169,12 +1202,19 @@ class _InputManager:
         return max(-1.0, min(1.0, value))
 
     def mouse_pos(self):
+        # v2.13.0: headless emulation
+        if self._headless or self._emulated_mouse != (0.0, 0.0):
+            x, y = self._emulated_mouse
+            return {"x": float(x), "y": float(y)}
         try:
             import pygame; x, y = pygame.mouse.get_pos(); return {"x": float(x), "y": float(y)}
         except Exception:
             return {"x": self._mouse_x, "y": self._mouse_y}
 
     def mouse_pressed(self, button=0):
+        # v2.13.0: headless emulation
+        if self._headless or self._emulated_buttons:
+            return self._emulated_buttons.get(int(button), False)
         try:
             import pygame; return bool(pygame.mouse.get_pressed()[int(button)])
         except Exception: