melon-lua 5.2.4__tar.gz → 5.2.5__tar.gz

{melon_lua-5.2.4 → melon_lua-5.2.5}/PKG-INFO

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

{melon_lua-5.2.4 → melon_lua-5.2.5}/melon_lua/__init__.py

@@ -36,7 +36,7 @@ from .uicontrol_builder import (
     POINTER, TOGGLE, SCREEN, CUSTOM_ICON, JOYSTICK,
 )
 
-__version__ = "5.2.4"
+__version__ = "5.2.5"
 
 __all__ = [
     "MelonScriptRunner",

melon_lua-5.2.5/melon_lua/mechanics/__init__.py

@@ -0,0 +1,20 @@
+"""Runtime mechanic simulations (Radar, etc.) for sandbox ticks."""
+from .radar import (
+    RADAR_OBJECT_ID,
+    parse_radar_config,
+    query_radar_hits,
+    simulate_radars,
+)
+from .gate_propagate import (
+    build_chip_inputs_from_wires,
+    merge_inputs,
+)
+
+__all__ = [
+    "RADAR_OBJECT_ID",
+    "parse_radar_config",
+    "query_radar_hits",
+    "simulate_radars",
+    "build_chip_inputs_from_wires",
+    "merge_inputs",
+]

melon_lua-5.2.5/melon_lua/mechanics/gate_propagate.py

@@ -0,0 +1,205 @@
+"""Resolve mechanic gate wires into MelonScriptRunner input buckets."""
+from __future__ import annotations
+
+import json
+from typing import Any, Optional
+
+# Gate DataType → runner input bucket
+_DT_BUCKET = {
+    1: "entity",
+    2: "num",
+    4: "string",
+    8: "vec",
+    32: "int",
+    128: "array_num",
+    256: "array_string",
+    512: "array_vec",
+    1024: "array_entity",
+}
+
+_EMPTY_BUCKETS = (
+    "num", "int", "string", "vec", "color", "entity",
+    "array_num", "array_string", "array_vec", "array_entity",
+)
+
+
+def empty_inputs() -> dict[str, dict[str, Any]]:
+    return {k: {} for k in _EMPTY_BUCKETS}
+
+
+def _parse_gates(raw: Any) -> list[dict]:
+    if not raw:
+        return []
+    try:
+        gates = json.loads(raw) if isinstance(raw, str) else list(raw)
+    except (TypeError, json.JSONDecodeError):
+        return []
+    return [g for g in gates if isinstance(g, dict)]
+
+
+def chip_input_schema_from_container(so: dict) -> dict[str, str]:
+    """Map chip input gate Key/DataName → runner bucket name."""
+    schema: dict[str, str] = {}
+    # Prefer lua_chip_inputs meta (LuaValue.Type) when present
+    for md in so.get("saveMetaDatas") or []:
+        if not isinstance(md, dict) or md.get("key") != "lua_chip_inputs":
+            continue
+        sv = md.get("stringValue") or "[]"
+        try:
+            items = json.loads(sv)
+        except (TypeError, json.JSONDecodeError):
+            items = []
+        if not isinstance(items, list):
+            continue
+        # LuaValue.Type: 1 num, 2 int, 3 string, 4 vec, 5 color, 6 entity, 7 array
+        # Array subtype is not always stored — use name heuristics + mechanic DataType
+        for it in items:
+            if not isinstance(it, dict):
+                continue
+            name = str(it.get("Name") or it.get("name") or "")
+            if not name:
+                continue
+            lt = int(it.get("Type") or it.get("type") or 0)
+            if lt == 1:
+                schema[name] = "num"
+            elif lt == 2:
+                schema[name] = "int"
+            elif lt == 3:
+                schema[name] = "string"
+            elif lt == 4:
+                schema[name] = "vec"
+            elif lt == 5:
+                schema[name] = "color"
+            elif lt == 6:
+                schema[name] = "entity"
+            elif lt == 7:
+                # default array_entity for common sensor wiring names
+                nlow = name.lower()
+                if "string" in nlow or "str" in nlow:
+                    schema[name] = "array_string"
+                elif "num" in nlow or "float" in nlow:
+                    schema[name] = "array_num"
+                elif "vec" in nlow or "color" in nlow or "pixel" in nlow:
+                    schema[name] = "array_vec"
+                else:
+                    schema[name] = "array_entity"
+    # mechanicSerializedInputs DataType overrides / fills gaps
+    md = so.get("mechanicData")
+    if isinstance(md, list) and md and isinstance(md[0], dict):
+        for g in _parse_gates(md[0].get("mechanicSerializedInputs")):
+            key = str(g.get("Key") or "")
+            dname = str(g.get("DataName") or "")
+            bucket = _DT_BUCKET.get(int(g.get("DataType") or 0))
+            if not bucket:
+                continue
+            if key:
+                schema[key] = bucket
+            if dname:
+                schema[dname] = bucket
+    return schema
+
+
+def _lookup_output(values: dict[str, Any], gate_name: str) -> Any:
+    if gate_name in values:
+        return values[gate_name]
+    # case-insensitive / strip
+    gl = gate_name.lower().strip()
+    for k, v in values.items():
+        if str(k).lower().strip() == gl:
+            return v
+    return None
+
+
+def build_chip_inputs_from_wires(
+    world: Any,
+    doc_raw: dict | None,
+    chip_container_idx: int,
+    *,
+    chip_so: Optional[dict] = None,
+) -> dict[str, dict[str, Any]]:
+    """Follow gate wires into ``chip_container_idx`` and fill input buckets."""
+    inputs = empty_inputs()
+    if chip_so is None and isinstance(doc_raw, dict):
+        containers = doc_raw.get("saveObjectContainers") or []
+        if 0 <= chip_container_idx < len(containers):
+            c = containers[chip_container_idx]
+            if isinstance(c, dict):
+                chip_so = c.get("saveObjects") or {}
+    schema = chip_input_schema_from_container(chip_so or {})
+    gate_vals = getattr(world, "gate_output_values", None) or {}
+    wires = []
+    if hasattr(world, "gate_wires") and world.gate_wires is not None:
+        wires = world.gate_wires.list_all()
+
+    for w in wires:
+        if int(w.target_idx) != int(chip_container_idx):
+            continue
+        src_vals = gate_vals.get(int(w.source_idx)) or {}
+        val = _lookup_output(src_vals, str(w.output_gate))
+        if val is None:
+            continue
+        in_name = str(w.input_gate)
+        bucket = schema.get(in_name) or schema.get(in_name.lower())
+        if bucket is None:
+            # infer from value shape
+            if isinstance(val, list):
+                if val and isinstance(val[0], (int, float)) and not isinstance(val[0], bool):
+                    bucket = "array_entity"
+                else:
+                    bucket = "array_entity"
+            elif isinstance(val, (int, float)) and not isinstance(val, bool):
+                # entity gates often 0/id
+                if in_name.lower() in ("entity", "target", "detector", "hit entity"):
+                    bucket = "entity"
+                else:
+                    bucket = "num"
+            elif isinstance(val, str):
+                bucket = "string"
+            else:
+                continue
+        if bucket not in inputs:
+            continue
+        # entity ids as int; arrays as list of int
+        if bucket == "entity":
+            try:
+                inputs[bucket][in_name] = int(val) if val not in (None, "", False) else 0  # type: ignore[arg-type]
+            except (TypeError, ValueError):
+                inputs[bucket][in_name] = 0
+        elif bucket == "array_entity":
+            if isinstance(val, list):
+                ids: list[int] = []
+                for x in val:
+                    try:
+                        ids.append(int(x))
+                    except (TypeError, ValueError):
+                        continue
+                inputs[bucket][in_name] = ids
+            else:
+                inputs[bucket][in_name] = []
+        elif bucket in ("array_num", "array_string", "array_vec"):
+            inputs[bucket][in_name] = list(val) if isinstance(val, list) else []
+        else:
+            inputs[bucket][in_name] = val
+    return inputs
+
+
+def merge_inputs(
+    auto: Optional[dict[str, dict[str, Any]]],
+    override: Optional[dict[str, dict[str, Any]]],
+) -> Optional[dict[str, dict[str, Any]]]:
+    """Merge override on top of auto (override wins per gate name)."""
+    if not auto and not override:
+        return None
+    if not auto:
+        return override
+    if not override:
+        return auto
+    out = empty_inputs()
+    for k in _EMPTY_BUCKETS:
+        out[k] = dict(auto.get(k) or {})
+        out[k].update(override.get(k) or {})
+    # also pass through any extra top-level keys from override
+    for k, v in override.items():
+        if k not in out and isinstance(v, dict):
+            out[k] = dict(v)
+    return out

melon_lua-5.2.5/melon_lua/mechanics/radar.py

@@ -0,0 +1,251 @@
+"""Area Radar (objectId 892993856) runtime simulation.
+
+Mirrors device behaviour enough for chip wiring:
+- activation gate / activationInput
+- sizeX/sizeY (width/height) + shift
+- Radar_selected_entities objectId filter (empty = detect nothing)
+- outputs: entity array, entity, trigger, activation
+
+Geometry: axis-aligned detection box at radar position + shift
+(rotated by radar angle). Entity centers are tested against the box.
+"""
+from __future__ import annotations
+
+import json
+import math
+from typing import Any, Optional
+
+RADAR_OBJECT_ID = 892993856
+_SELECTED_KEY = "Radar_selected_entities"
+
+
+def _gate_value_float(gate: dict, default: float = 0.0) -> float:
+    gd = gate.get("GateData")
+    if isinstance(gd, str) and gd:
+        try:
+            data = json.loads(gd)
+            if isinstance(data, dict) and "Value" in data:
+                return float(data["Value"])
+        except (TypeError, ValueError, json.JSONDecodeError):
+            pass
+    return float(default)
+
+
+def _parse_input_gates(so: dict) -> dict[str, float]:
+    """Map Key/DataName → float Value from mechanicSerializedInputs."""
+    out: dict[str, float] = {}
+    md = so.get("mechanicData")
+    if not isinstance(md, list) or not md:
+        return out
+    raw = md[0].get("mechanicSerializedInputs") if isinstance(md[0], dict) else None
+    if not raw:
+        return out
+    try:
+        gates = json.loads(raw) if isinstance(raw, str) else list(raw)
+    except (TypeError, json.JSONDecodeError):
+        return out
+    for g in gates:
+        if not isinstance(g, dict):
+            continue
+        val = _gate_value_float(g, 0.0)
+        key = g.get("Key")
+        name = g.get("DataName")
+        if key:
+            out[str(key)] = val
+        if name:
+            out[str(name)] = val
+    return out
+
+
+def parse_selected_object_ids(so: dict) -> set[str]:
+    """Parse Radar_selected_entities stringValue → set of id strings.
+
+    Empty / missing / \"[]\" → empty set (device: detect nothing).
+    """
+    metas = so.get("saveMetaDatas")
+    if not isinstance(metas, list):
+        return set()
+    for md in metas:
+        if not isinstance(md, dict) or md.get("key") != _SELECTED_KEY:
+            continue
+        sv = md.get("stringValue") or "[]"
+        try:
+            arr = json.loads(sv)
+        except (TypeError, json.JSONDecodeError):
+            return set()
+        if not isinstance(arr, list):
+            return set()
+        return {str(x) for x in arr}
+    return set()
+
+
+def parse_radar_config(so: dict) -> dict[str, Any]:
+    """Read radar parameters from a saveObjects dict."""
+    gates = _parse_input_gates(so)
+    md0: dict = {}
+    md = so.get("mechanicData")
+    if isinstance(md, list) and md and isinstance(md[0], dict):
+        md0 = md[0]
+    raw_fps = md0.get("floatParameters")
+    fps: list[Any] = list(raw_fps) if isinstance(raw_fps, list) else []
+    # floatParameters: [?, shiftX?, shiftY?, ?, sizeX, sizeY] per template/docs
+    size_x = gates.get("sizeX", gates.get("width"))
+    size_y = gates.get("sizeY", gates.get("height"))
+    if size_x is None and len(fps) > 4:
+        size_x = float(fps[4])
+    if size_y is None and len(fps) > 5:
+        size_y = float(fps[5])
+    if size_x is None:
+        size_x = 1.0
+    if size_y is None:
+        size_y = 1.0
+    shift_x = gates.get("shiftX", gates.get("shift x"))
+    shift_y = gates.get("shiftY", gates.get("shift y"))
+    if shift_x is None and len(fps) > 1:
+        shift_x = float(fps[1])
+    if shift_y is None and len(fps) > 2:
+        shift_y = float(fps[2])
+    if shift_x is None:
+        shift_x = 0.0
+    if shift_y is None:
+        shift_y = 0.0
+    act = gates.get("activation")
+    if act is None:
+        act = float(md0.get("activationInput", so.get("activationInput", 1.0)) or 0.0)
+    return {
+        "activation": float(act),
+        "width": float(size_x),
+        "height": float(size_y),
+        "shift_x": float(shift_x),
+        "shift_y": float(shift_y),
+        "selected_ids": parse_selected_object_ids(so),
+    }
+
+
+def query_radar_hits(
+    world: Any,
+    radar: Any,
+    *,
+    width: float,
+    height: float,
+    shift_x: float = 0.0,
+    shift_y: float = 0.0,
+    selected_object_ids: Optional[set[str]] = None,
+    exclude_self: bool = True,
+) -> list[int]:
+    """Return runtime entity_ids whose centers lie inside the radar area."""
+    if width <= 0.0 or height <= 0.0:
+        return []
+    if selected_object_ids is not None and len(selected_object_ids) == 0:
+        return []
+
+    ang = math.radians(float(getattr(radar, "angle", 0.0) or 0.0))
+    c, s = math.cos(ang), math.sin(ang)
+    # shift in radar local space → world
+    cx = float(radar.position_x) + shift_x * c - shift_y * s
+    cy = float(radar.position_y) + shift_x * s + shift_y * c
+    half_w = width * 0.5
+    half_h = height * 0.5
+    # inverse rotate world → radar local for AABB test
+    inv_c, inv_s = c, -s
+
+    hits: list[int] = []
+    for eid, e in world.entities.items():
+        if not getattr(e, "alive", True):
+            continue
+        if exclude_self and eid == radar.entity_id:
+            continue
+        if selected_object_ids is not None:
+            oid = e.object_id
+            if oid is None:
+                continue
+            if str(int(oid)) not in selected_object_ids and str(oid) not in selected_object_ids:
+                continue
+        dx = float(e.position_x) - cx
+        dy = float(e.position_y) - cy
+        lx = dx * inv_c - dy * inv_s
+        ly = dx * inv_s + dy * inv_c
+        if abs(lx) <= half_w and abs(ly) <= half_h:
+            hits.append(int(eid))
+    hits.sort()
+    return hits
+
+
+def simulate_radars(world: Any, doc_raw: dict | None = None) -> dict[int, dict[str, Any]]:
+    """Update all Radar entities; store outputs on world.gate_output_values.
+
+    Returns mapping container_idx → output gate dict.
+    Requires entities tagged with custom_data['container_idx'] (set at spawn).
+    """
+    if not hasattr(world, "gate_output_values") or world.gate_output_values is None:
+        world.gate_output_values = {}
+
+    # container_idx → saveObjects (for live parameter re-read)
+    so_by_idx: dict[int, dict] = {}
+    if isinstance(doc_raw, dict):
+        containers = doc_raw.get("saveObjectContainers") or []
+        for i, c in enumerate(containers):
+            if not isinstance(c, dict):
+                continue
+            so = c.get("saveObjects")
+            if isinstance(so, dict) and int(so.get("objectId", 0) or 0) == RADAR_OBJECT_ID:
+                so_by_idx[i] = so
+
+    results: dict[int, dict[str, Any]] = {}
+    for e in list(world.entities.values()):
+        if not getattr(e, "alive", True):
+            continue
+        if int(e.object_id or 0) != RADAR_OBJECT_ID:
+            continue
+        cidx = e.custom_data.get("container_idx")
+        if cidx is None:
+            continue
+        cidx = int(cidx)
+        so = so_by_idx.get(cidx)
+        if so is not None:
+            cfg = parse_radar_config(so)
+        else:
+            # runtime-only radar: default select-all from package data if present
+            cfg = {
+                "activation": float(getattr(e, "activation_input", 1.0) or 1.0),
+                "width": float(e.custom_data.get("radar_width", 1.0)),
+                "height": float(e.custom_data.get("radar_height", 1.0)),
+                "shift_x": float(e.custom_data.get("radar_shift_x", 0.0)),
+                "shift_y": float(e.custom_data.get("radar_shift_y", 0.0)),
+                "selected_ids": e.custom_data.get("radar_selected_ids"),
+            }
+            if cfg["selected_ids"] is None:
+                try:
+                    from ..melsave_builder import _radar_select_all_ids
+                    cfg["selected_ids"] = set(_radar_select_all_ids())
+                except Exception:
+                    cfg["selected_ids"] = set()
+
+        act = float(cfg["activation"])
+        if act < 0.5:
+            hits: list[int] = []
+        else:
+            selected = cfg.get("selected_ids")
+            if selected is not None and not isinstance(selected, set):
+                selected = set(str(x) for x in selected)
+            hits = query_radar_hits(
+                world,
+                e,
+                width=float(cfg["width"]),
+                height=float(cfg["height"]),
+                shift_x=float(cfg["shift_x"]),
+                shift_y=float(cfg["shift_y"]),
+                selected_object_ids=selected,
+            )
+
+        first = int(hits[0]) if hits else 0
+        outs = {
+            "entity array": hits,
+            "entity": first,
+            "trigger": 1.0 if hits else 0.0,
+            "activation": act,
+        }
+        world.gate_output_values[cidx] = outs
+        # also by common DataName aliases
+        results[cidx] = outs
+    return results

{melon_lua-5.2.4 → melon_lua-5.2.5}/melon_lua/runner.py

@@ -181,11 +181,50 @@ class MelonScriptRunner:
             inputs_tbl[cat] = sub_tbl
         self._g["inputs"] = inputs_tbl
 
-        # Always-fresh outputs table
-        outputs_tbl = self._lua.table_from({})
-        for cat in sub_categories:
-            outputs_tbl[cat] = self._lua.table_from({})
-        self._g["outputs"] = outputs_tbl
+        # Always-fresh outputs table with runtime type checks to match C# engine behavior
+        self._lua.execute("""
+            local sub_categories = {
+                "num", "int", "string", "vec", "color", "entity",
+                "array_num", "array_string", "array_vec", "array_entity"
+            }
+            local outputs = {}
+            local function check_type(cat, val)
+                if val == nil then return end
+                local t = type(val)
+                if t == "function" or t == "thread" or t == "userdata" then
+                    error("Type mismatch: cannot assign " .. t .. " to outputs." .. cat, 3)
+                end
+                if cat == "num" or cat == "int" or cat == "entity" then
+                    if t == "table" then
+                        error("Type mismatch: cannot assign table to outputs." .. cat, 3)
+                    end
+                elseif cat == "string" then
+                    if t == "table" then
+                        error("Type mismatch: cannot assign table to outputs." .. cat, 3)
+                    end
+                elseif cat == "vec" or cat == "color" or cat:find("array_") then
+                    if t ~= "table" then
+                        error("Type mismatch: expected table for outputs." .. cat .. ", got " .. t, 3)
+                    end
+                end
+            end
+
+            for _, cat in ipairs(sub_categories) do
+                local tbl = {}
+                local mt = {
+                    __newindex = function(t, k, v)
+                        check_type(cat, v)
+                        rawset(t, k, v)
+                    end
+                }
+                setmetatable(tbl, mt)
+                outputs[cat] = tbl
+            end
+            __outputs_global_temp = outputs
+        """)
+        self._g["outputs"] = self._g["__outputs_global_temp"]
+        self._g["__outputs_global_temp"] = None
+
 
     def get_outputs(self) -> dict[str, dict[str, Any]]:
         """Return outputs as a plain Python dict."""

{melon_lua-5.2.4 → melon_lua-5.2.5}/melon_lua/session.py

@@ -932,6 +932,38 @@ class MelsaveSession:
     # Runtime mode: snapshot / diff
     # ==================================================================
 
+    def workspace_debug(self, code: str, ticks: int = 10, tick_callback=None):
+        self._require_runtime()
+        frames = []
+        for i in range(ticks):
+            self._world.tick(1.0 / float(self.tps))
+            state = self._get_light_state()
+            frames.append({
+                "tick": i,
+                "outputs": state["outputs"],
+                "variables": state["variables"],
+                "entity_count": state["entity_count"]
+            })
+            if tick_callback:
+                tick_callback(frames[-1])
+        return frames
+
+    def get_state(self) -> dict:
+        self._require_runtime()
+        return {
+            "tick": self._world.current_tick,
+            "outputs": self._runner.get_outputs() if self._runner else {},
+            "variables": dict(self._world.chip_variables),
+            "entity_count": sum(1 for e in self._world.entities.values() if getattr(e, "alive", True))
+        }
+
+    def _get_light_state(self):
+        return {
+            "outputs": self._runner.get_outputs() if self._runner else {},
+            "variables": dict(self._world.chip_variables),
+            "entity_count": sum(1 for e in self._world.entities.values() if getattr(e, "alive", True))
+        }
+
     def snapshot(self) -> dict:
         """Return a serializable snapshot of the current world state."""
         self._require_runtime()

{melon_lua-5.2.4 → melon_lua-5.2.5}/melon_lua.egg-info/PKG-INFO

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

{melon_lua-5.2.4 → melon_lua-5.2.5}/melon_lua.egg-info/SOURCES.txt

@@ -976,6 +976,9 @@ melon_lua/data/sprites_pack/images/0454_RectEndlessOceanDockingHatch.png
 melon_lua/data/sprites_pack/images/0454_RectEndlessOceanDockingHatch_plastic.png
 melon_lua/data/sprites_pack/images/0455_GlassDomeBlue.png
 melon_lua/data/sprites_pack/images/0455_GlassDomeBlue_plastic.png
+melon_lua/mechanics/__init__.py
+melon_lua/mechanics/gate_propagate.py
+melon_lua/mechanics/radar.py
 melon_lua/vpcompile/__init__.py
 melon_lua/vpcompile/codegen.py
 melon_lua/vpcompile/compile.py

{melon_lua-5.2.4 → melon_lua-5.2.5}/pyproject.toml

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