melon-lua 3.4.0__tar.gz → 3.5.0__tar.gz

{melon_lua-3.4.0 → melon_lua-3.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: melon-lua
-Version: 3.4.0
+Version: 3.5.0
 Summary: 甜瓜游乐场 Lua 芯片执行器模拟 - Melon Playground Lua chip sandbox
 Author: melonapk
 License: MIT

{melon_lua-3.4.0 → melon_lua-3.5.0}/melon_lua/__init__.py

@@ -35,7 +35,7 @@ from .uicontrol_builder import (
     POINTER, TOGGLE, SCREEN, CUSTOM_ICON, JOYSTICK,
 )
 
-__version__ = "3.4.0"
+__version__ = "3.5.0"
 
 __all__ = [
     "MelonScriptRunner",

{melon_lua-3.4.0 → melon_lua-3.5.0}/melon_lua/melsave_builder.py

@@ -202,6 +202,13 @@ def _load_item_template(object_id: int) -> dict | None:
               Path(__file__).parent.parent / "temp" / "objectid_templates"):
         p = d / f"{object_id}.json"
         if p.exists():
+            if d != _ITEM_TEMPLATE_DIR:
+                import warnings
+                warnings.warn(
+                    f"item template loaded from dev fallback {p}; "
+                    f"this path does not exist in pip-installed distributions",
+                    stacklevel=3,
+                )
             with open(p, "r", encoding="utf-8") as f:
                 return json.load(f)
     return None
@@ -721,15 +728,20 @@ class MelsaveBuilder:
         """Write the .melsave ZIP file.
 
         Args:
-            out_path: Output file path.
+            out_path: Output file path (relative paths resolve against the
+                Python process CWD — pass an absolute path for predictability).
             write_icon: If True and icon is set, include Icon entry.
+
+        Returns:
+            Resolved absolute path of the written file.
         """
         meta = copy.deepcopy(self._meta)
         if not meta.get("UniqueId"):
             meta["UniqueId"] = str(uuid.uuid4())
         data = self.build_data()
         icon = self._icon if write_icon else None
-        return write_melsave(out_path, data, meta, icon)
+        p = write_melsave(out_path, data, meta, icon)
+        return Path(p).resolve()
 
 
 # Re-export for convenience

{melon_lua-3.4.0 → melon_lua-3.5.0}/melon_lua/melsave_writer.py

@@ -666,11 +666,16 @@ def write_world_to_melsave(
     out_path: str | Path,
     *,
     write_icon: bool = True,
+    extra_containers: list[dict] | None = None,
 ) -> Path:
     """Build a diff from world, patch original Data, and write a new .melsave.
 
     Gate wires from ``world.gate_wires`` are merged into the patched
     ``constraints`` lists (mechanic connections coexist with physical ropes).
+
+    Args:
+        extra_containers: Raw saveObjects dicts to append as new containers
+            (e.g. Lua chips added via MelsaveSession.add_lua_chip()).
     """
     diff = build_diff_from_world(world, original_doc)
     original_path = original_doc.path
@@ -682,6 +687,11 @@ def write_world_to_melsave(
     except Exception:
         original_data = {"saveObjectContainers": []}
     patched = patch_save_data(original_data, diff)
+    # Append session-added chip containers (Lua chips added via add_lua_chip).
+    if extra_containers:
+        containers = patched.setdefault("saveObjectContainers", [])
+        for so in extra_containers:
+            containers.append({"saveObjects": so, "saveObjectChildren": []})
     # Merge gate wires into the patched constraints lists.
     gate_wires = getattr(world, "gate_wires", None)
     if gate_wires is not None and len(gate_wires) > 0:

{melon_lua-3.4.0 → melon_lua-3.5.0}/melon_lua/session.py

@@ -29,6 +29,9 @@ from .melsave_writer import write_world_to_melsave, build_diff_from_world
 from .world import WorldContext
 from .runner import MelonScriptRunner
 
+# Packaged empty world template — minimal valid save with zero objects.
+_EMPTY_TEMPLATE = Path(__file__).parent / "data" / "empty.melsave"
+
 
 class MelsaveSession:
     """One session = one save file + one world + one chip runner.
@@ -39,11 +42,15 @@ class MelsaveSession:
 
     def __init__(
         self,
-        melsave_path: str | Path,
+        melsave_path: str | Path | None = None,
         *,
         tps: float = 20.0,
         quiet: bool = True,
     ):
+        if melsave_path is None:
+            # Bare constructor -> load the packaged empty world template so
+            # the "create session then operate" intuitive path works.
+            melsave_path = _EMPTY_TEMPLATE
         self.melsave_path = Path(melsave_path)
         self.tps = float(tps)
         self._quiet = bool(quiet)
@@ -51,6 +58,22 @@ class MelsaveSession:
         self._world: Optional[WorldContext] = None
         self._runner: Optional[MelonScriptRunner] = None
         self._loaded = False
+        # Chips added in-session that should persist on save_as(). Each entry
+        # is a raw saveObjects dict (Lua chip container). They are appended to
+        # the patched saveObjectContainers on write-back.
+        self._pending_chips: list[dict] = []
+        # Track which chip container (by index into _pending_chips) the last
+        # run_chip() compiled, so the source can be synced before save.
+        self._active_chip_idx: Optional[int] = None
+
+    @classmethod
+    def create_empty(cls, **kw: Any) -> "MelsaveSession":
+        """Create a session backed by an empty world.
+
+        Equivalent to ``MelsaveSession()`` (which now defaults to the packaged
+        empty template), but makes intent explicit at call sites.
+        """
+        return cls(None, **kw)
 
     # ===== Lifecycle =====
 
@@ -103,6 +126,42 @@ class MelsaveSession:
 
     # ===== Chip execution =====
 
+    def add_lua_chip(
+        self,
+        source: str,
+        *,
+        x: float = 0.0,
+        y: float = 0.0,
+        inputs: list[dict] | None = None,
+        outputs: list[dict] | None = None,
+        variables: list[dict] | None = None,
+        tps: int = 30,
+        priority: int = 0,
+        title: str = "",
+    ) -> int:
+        """Add a Lua chip container to the session (persisted on save_as).
+
+        Creates a saveObjects entry for a Lua chip (objectId=507707712) with
+        the given source and gates, and tracks it so ``save_as()`` includes it
+        in the exported melsave. Also marks it as the active chip so subsequent
+        ``run_chip()`` calls (without ``container_idx``) will sync source changes.
+
+        Returns the index of the chip in ``self._pending_chips`` (also the
+        container index it will occupy after existing containers).
+        """
+        self._require_loaded()
+        assert self._doc is not None
+        from .melsave_builder import _build_chip_save_objects
+        base = len(self._doc.objects)
+        so = _build_chip_save_objects(
+            source, x, y,
+            inputs=inputs, outputs=outputs, variables=variables,
+            tps=tps, priority=priority, title=title,
+        )
+        self._pending_chips.append(so)
+        self._active_chip_idx = len(self._pending_chips) - 1
+        return self._active_chip_idx
+
     def run_chip(
         self,
         source: str,
@@ -110,17 +169,28 @@ class MelsaveSession:
         ticks: int = 1,
         inputs: Optional[dict] = None,
         chunk_name: str = "@session_chip.lua",
+        container_idx: Optional[int] = None,
     ) -> dict:
         """Compile a Lua chip and run it for `ticks` ticks. Returns last tick result.
 
         If ticks == 0, only compiles + calls OnInit (no OnTick). If ticks >= 1,
         OnInit is called first, then OnTick runs `ticks` times.
+
+        Args:
+            container_idx: If given, sync the source back into that pending
+                chip container so it persists on save_as(). Chips created via
+                add_lua_chip() auto-sync; pass the index returned by it to
+                keep edits live.
         """
         self._require_loaded()
         r = self._runner
         assert r is not None
         if not r.compile(source, chunk_name=chunk_name):
             return {"error": r.last_error or "compile failed", "outputs": {}}
+        # Sync source into pending chip container for persistence
+        idx = container_idx if container_idx is not None else self._active_chip_idx
+        if idx is not None and 0 <= idx < len(self._pending_chips):
+            self._sync_chip_source(idx, source)
         r.call_on_init()
         if ticks <= 0:
             return {"error": None, "outputs": r.get_outputs()}
@@ -130,6 +200,14 @@ class MelsaveSession:
         r.run_loop(ticks=ticks, inputs_provider=provider)
         return {"error": r.last_error, "outputs": r.get_outputs()}
 
+    def _sync_chip_source(self, idx: int, source: str) -> None:
+        """Update the lua_chip_source metadata of a pending chip container."""
+        so = self._pending_chips[idx]
+        for sm in so.get("saveMetaDatas", []):
+            if sm.get("key") == "lua_chip_source":
+                sm["stringValue"] = source
+                return
+
     def compile_only(self, source: str, chunk_name: str = "@session_chip.lua") -> bool:
         """Compile a chip without running. Returns True on success."""
         self._require_loaded()
@@ -360,16 +438,26 @@ class MelsaveSession:
         *,
         write_icon: bool = True,
     ) -> Path:
-        """Diff the live world against the original save and write a new .melsave."""
+        """Diff the live world against the original save and write a new .melsave.
+
+        Lua chips added via ``add_lua_chip()`` are appended as new containers.
+        Source edits from ``run_chip()`` are synced back into the chip's
+        ``lua_chip_source`` metadata so the exported save is runnable on the
+        real device.
+
+        Returns the resolved absolute path of the written file.
+        """
         self._require_loaded()
         assert self._world is not None
         assert self._doc is not None
-        return write_world_to_melsave(
+        p = write_world_to_melsave(
             self._world,
             self._doc,
             out_path,
             write_icon=write_icon,
+            extra_containers=list(self._pending_chips) if self._pending_chips else None,
         )
+        return Path(p).resolve()
 
     # ===== Logs / errors =====
 

{melon_lua-3.4.0 → melon_lua-3.5.0}/melon_lua.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: melon-lua
-Version: 3.4.0
+Version: 3.5.0
 Summary: 甜瓜游乐场 Lua 芯片执行器模拟 - Melon Playground Lua chip sandbox
 Author: melonapk
 License: MIT

{melon_lua-3.4.0 → melon_lua-3.5.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "melon-lua"
-version = "3.4.0"
+version = "3.5.0"
 description = "甜瓜游乐场 Lua 芯片执行器模拟 - Melon Playground Lua chip sandbox"
 readme = "README.md"
 license = { text = "MIT" }