melon-lua 3.4.0__py3-none-any.whl

melon_lua/backend/print_backend.py

@@ -0,0 +1,63 @@
+"""print / warn / error_log — backed by PrintApiModule.
+
+Real game: LuaConsoleBuffer + logOwner. Each call writes to console AND
+CustomDebug log. Here we just append to world.console_buffer.
+
+Lua contract (from ApiReference):
+    print(...)        -- args joined by tab
+    warn(...)         -- same
+    error_log(...)    -- same
+
+lupa registers Python callables via g["print"] = fn. We need to accept
+varargs and join them tab-separated like Lua's stock print.
+"""
+from typing import Any, Callable, Optional
+
+
+def _to_str(v: Any) -> str:
+    if v is None:
+        return "nil"
+    if isinstance(v, bool):
+        return "true" if v else "false"
+    s = str(v)
+    # lupa exposes Lua tables as _LuaTable wrappers with .values() etc.
+    if hasattr(v, "keys"):
+        try:
+            d = {k: v[k] for k in v.keys()}
+            return str(d)
+        except Exception:
+            pass
+    return s
+
+
+def register_print_backend(
+    lua, g, world,
+    on_log: Optional[Callable[[str, str], None]] = None,
+    error_log_fn: Optional[Callable[[str], None]] = None,
+):
+    def _print(*args) -> int:
+        msg = "\t".join(_to_str(a) for a in args)
+        world.console_buffer.append(("print", msg))
+        if on_log:
+            on_log("print", msg)
+        return 0
+
+    def _warn(*args) -> int:
+        msg = "\t".join(_to_str(a) for a in args)
+        world.console_buffer.append(("warn", msg))
+        if on_log:
+            on_log("warn", msg)
+        return 0
+
+    def _error_log(*args) -> int:
+        msg = "\t".join(_to_str(a) for a in args)
+        world.console_buffer.append(("error", msg))
+        if on_log:
+            on_log("error", msg)
+        elif error_log_fn:
+            error_log_fn(msg)
+        return 0
+
+    g["print"] = _print
+    g["warn"] = _warn
+    g["error_log"] = _error_log

melon_lua/backend/spawn_backend.py

@@ -0,0 +1,116 @@
+"""spawn — object creation (21 methods).
+
+spawn.create* returns requestId immediately; entities materialize on spawn_queue.flush()
+(end of tick / after OnInit), then OnSpawned via preamble __dispatch_spawn.
+"""
+from typing import Optional, Callable
+
+from ..world import WorldContext
+
+
+def _format_items(lua, items_dict, sep=None):
+    arr = [f"{k}|{v}" for k, v in items_dict.items()]
+    if sep is None:
+        return lua.table_from(arr)
+    return sep.join(arr)
+
+
+def register_spawn_backend(
+    lua,
+    g,
+    world: WorldContext,
+    queue_spawn_result: Optional[Callable[[int, list], None]] = None,
+):
+    del queue_spawn_result
+    q = world.spawn_queue
+    spawn = lua.table_from({})
+
+    def get_items():
+        return _format_items(lua, world.spawn_catalog)
+
+    def get_items_string(sep=", "):
+        return _format_items(lua, world.spawn_catalog, sep)
+
+    def get_item_count():
+        return len(world.spawn_catalog)
+
+    def get_saves():
+        return _format_items(lua, world.spawn_saves)
+
+    def get_saves_string(sep=", "):
+        return _format_items(lua, world.spawn_saves, sep)
+
+    def get_save_count():
+        return len(world.spawn_saves)
+
+    def get_resource_saves():
+        return _format_items(lua, world.spawn_resource_saves)
+
+    def get_resource_saves_string(sep=", "):
+        return _format_items(lua, world.spawn_resource_saves, sep)
+
+    def get_resource_save_count():
+        return len(world.spawn_resource_saves)
+
+    def get_mods():
+        return _format_items(lua, world.spawn_mods)
+
+    def get_mods_string(sep=", "):
+        return _format_items(lua, world.spawn_mods, sep)
+
+    def get_mod_count():
+        return len(world.spawn_mods)
+
+    def create(alias, x, y):
+        return q.enqueue_create(alias, x, y)
+
+    def create_with_angle(alias, x, y, angle):
+        return q.enqueue_create(alias, x, y, angle=angle)
+
+    def clone(entity_id, x, y):
+        return q.enqueue_clone(entity_id, x, y, temp=False)
+
+    def clone_temp(entity_id, x, y):
+        return q.enqueue_clone(entity_id, x, y, temp=True)
+
+    def create_save(name, x, y):
+        return q.enqueue_save(name, x, y)
+
+    def create_mod(name, x, y):
+        return q.enqueue_mod(name, x, y)
+
+    def destroy(entity_id):
+        world.remove_entity(entity_id)
+        return 0
+
+    def get_name_by_alias(alias):
+        return world.spawn_catalog.get(str(alias), "")
+
+    def exists_by_alias(alias):
+        return 1 if str(alias) in world.spawn_catalog else 0
+
+    for name, fn in {
+        "getItems": get_items,
+        "getItemsString": get_items_string,
+        "getItemCount": get_item_count,
+        "getSaves": get_saves,
+        "getSavesString": get_saves_string,
+        "getSaveCount": get_save_count,
+        "getResourceSaves": get_resource_saves,
+        "getResourceSavesString": get_resource_saves_string,
+        "getResourceSaveCount": get_resource_save_count,
+        "getMods": get_mods,
+        "getModsString": get_mods_string,
+        "getModCount": get_mod_count,
+        "create": create,
+        "createWithAngle": create_with_angle,
+        "clone": clone,
+        "cloneTemp": clone_temp,
+        "createSave": create_save,
+        "createMod": create_mod,
+        "destroy": destroy,
+        "getNameByAlias": get_name_by_alias,
+        "existsByAlias": exists_by_alias,
+    }.items():
+        spawn[name] = fn
+    g["spawn"] = spawn

melon_lua/backend/uicontrol_backend.py

@@ -0,0 +1,110 @@
+"""uicontrol — runtime UIControl panels (12 methods).
+
+Source: UIControlApiModule.cs + Example_ApiReference_en.lua:DemoUIControl.
+Per-entity UI elements stored in world.chip_metadata["uicontrol:<id>"].
+"""
+from typing import Any
+from ..world import WorldContext
+
+
+def _ui(world: WorldContext, eid: Any) -> dict:
+    try:
+        eid = int(eid)
+    except (TypeError, ValueError):
+        return {}
+    return world.chip_metadata.get(f"uicontrol:{eid}", {})
+
+
+def _elements_to_array(lua, elements):
+    return lua.table_from([f"{e['name']}|{e['type']}|{e['id']}" for e in elements])
+
+
+def register_uicontrol_backend(lua, g, world: WorldContext):
+    ui = lua.table_from({})
+
+    def has_ui_control(eid):
+        return 1 if _ui(world, eid) else 0
+
+    def get_elements(eid):
+        m = _ui(world, eid)
+        return _elements_to_array(lua, m.get("elements", []))
+
+    def find_element(eid, name):
+        m = _ui(world, eid)
+        for el in m.get("elements", []):
+            if el["name"] == str(name):
+                return el["id"]
+        return None
+
+    def get_elements_by_type(eid, type_name):
+        m = _ui(world, eid)
+        matches = [el for el in m.get("elements", []) if el["type"] == str(type_name)]
+        return lua.table_from([el["id"] for el in matches])
+
+    def _gates_array(lua, m, element_id, key):
+        el = next((e for e in m.get("elements", []) if e["id"] == element_id), None)
+        if not el: return lua.table_from([])
+        return lua.table_from([f"{g}|{t}" for g, t in el.get(key, {}).items()])
+
+    def get_input_gates(eid, element_id):
+        m = _ui(world, eid)
+        return _gates_array(lua, m, element_id, "inputs")
+
+    def get_output_gates(eid, element_id):
+        m = _ui(world, eid)
+        return _gates_array(lua, m, element_id, "outputs")
+
+    def get_value(eid, element_id, gate_name):
+        m = _ui(world, eid)
+        el = next((e for e in m.get("elements", []) if e["id"] == element_id), None)
+        if not el: return None
+        return el.get("values", {}).get(gate_name)
+
+    def set_value(eid, element_id, gate_name, value):
+        m = _ui(world, eid)
+        el = next((e for e in m.get("elements", []) if e["id"] == element_id), None)
+        if not el: return 0
+        if gate_name in el.get("wired", set()): return 0
+        el.setdefault("values", {})[gate_name] = value
+        return 1
+
+    def has_wire(eid, element_id, gate_name):
+        m = _ui(world, eid)
+        el = next((e for e in m.get("elements", []) if e["id"] == element_id), None)
+        if not el: return 0
+        return 1 if gate_name in el.get("wired", set()) else 0
+
+    def get_anchors(eid, element_id):
+        m = _ui(world, eid)
+        el = next((e for e in m.get("elements", []) if e["id"] == element_id), None)
+        if not el: return 0.0, 0.0, 0.0, 0.0
+        a = el.get("anchors", (0, 0, 1, 1))
+        return a[0], a[1], a[2], a[3]
+
+    def get_anchored_position(eid, element_id):
+        m = _ui(world, eid)
+        el = next((e for e in m.get("elements", []) if e["id"] == element_id), None)
+        if not el: return 0.0, 0.0
+        p = el.get("anchored_pos", (0.0, 0.0))
+        return p[0], p[1]
+
+    def set_anchored_position(eid, element_id, x, y):
+        m = _ui(world, eid)
+        el = next((e for e in m.get("elements", []) if e["id"] == element_id), None)
+        if not el: return 0
+        el["anchored_pos"] = (float(x), float(y))
+        return 1
+
+    for name, fn in {
+        "hasUIControl": has_ui_control,
+        "getElements": get_elements, "findElement": find_element,
+        "getElementsByType": get_elements_by_type,
+        "getInputGates": get_input_gates, "getOutputGates": get_output_gates,
+        "getValue": get_value, "setValue": set_value,
+        "hasWire": has_wire,
+        "getAnchors": get_anchors,
+        "getAnchoredPosition": get_anchored_position,
+        "setAnchoredPosition": set_anchored_position,
+    }.items():
+        ui[name] = fn
+    g["uicontrol"] = ui

melon_lua/backend/variables_backend.py

@@ -0,0 +1,38 @@
+"""variables — chip-level state storage.
+
+Source: LuaVariablesApiModule.cs + Example_ApiReference_en.lua:DemoVariables.
+Type is locked once the variable exists (Number stays Number, etc).
+Variables.Set returns 1.0 on success, 0.0 on type mismatch / error.
+"""
+from typing import Any
+from ..world import WorldContext
+
+
+def _infer_type(v: Any) -> str:
+    if isinstance(v, bool): return "Boolean"
+    if isinstance(v, int): return "Integer"
+    if isinstance(v, float): return "Number"
+    if isinstance(v, str): return "String"
+    return "Any"
+
+
+def register_variables_backend(lua, g, world: WorldContext):
+    var = lua.table_from({})
+
+    def Set(key, value):
+        key = str(key)
+        existing_type = world.chip_variable_types.get(key)
+        new_type = _infer_type(value)
+        if existing_type and existing_type != new_type:
+            return 0.0  # type mismatch
+        world.chip_variables[key] = value
+        world.chip_variable_types[key] = new_type
+        return 1.0
+
+    def Get(key):
+        key = str(key)
+        return world.chip_variables.get(key)
+
+    var["Set"] = Set
+    var["Get"] = Get
+    g["variables"] = var

melon_lua/backend/world_backend.py

@@ -0,0 +1,56 @@
+"""world — world control (11 methods).
+
+Source: WorldApiModule.cs + Example_ApiReference_en.lua:DemoWorld.
+load/reset reload the scene in the real game (destroys the Lua VM);
+here we no-op them since we own the world.
+"""
+from ..world import WorldContext
+
+
+def register_world_backend(lua, g, world: WorldContext):
+    w = lua.table_from({})
+
+    def is_session_active():
+        return 1 if world.session_active else 0
+    def start_session():
+        world.session_active = True
+    def end_session():
+        world.session_active = False
+    def save():
+        # Real game: persist world state. Sandbox: noop.
+        return 0
+    def load():
+        return 0
+    def reset():
+        # Clear entities (but keep chip entity, if any)
+        keep = {k: v for k, v in world.entities.items()
+                if not v.alive or k < 1}
+        world.entities.clear()
+        world.entities.update(keep)
+        return 0
+    def clear_corpses():
+        # In real game corpses are dead entities. We have no death state.
+        return 0
+    def clear_decals():
+        return 0
+    def clear_gibs():
+        return 0
+    def clear_living():
+        # Remove all alive entities
+        ids = [eid for eid, e in world.entities.items() if e.alive]
+        for eid in ids:
+            world.remove_entity(eid)
+        return 0
+    def radio_signal(channel):
+        return 0.0
+
+    for name, fn in {
+        "isSessionActive": is_session_active,
+        "startSession": start_session, "endSession": end_session,
+        "save": save, "load": load, "reset": reset,
+        "clearCorpses": clear_corpses, "clearDecals": clear_decals,
+        "clearGibs": clear_gibs, "clearLiving": clear_living,
+        "radioSignal": radio_signal,
+    }.items():
+        w[name] = fn
+    g["world"] = w

melon_lua/catalog.py

@@ -0,0 +1,99 @@
+"""Spawn catalog + physics profiles (495 objects, keyed by objectId and name).
+
+Data: melon_lua/data/object_physics_by_id.json (from lua-triage build).
+"""
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any, Optional
+
+_DATA_PATH = Path(__file__).resolve().parent / "data" / "object_physics_by_id.json"
+
+_by_oid: Optional[dict[str, dict]] = None
+_by_name: Optional[dict[str, dict]] = None
+_stats: Optional[dict] = None
+
+
+def _load() -> None:
+    global _by_oid, _by_name, _stats
+    if _by_oid is not None:
+        return
+    _by_oid, _by_name, _stats = {}, {}, {}
+    if not _DATA_PATH.is_file():
+        return
+    try:
+        raw = json.loads(_DATA_PATH.read_text(encoding="utf-8"))
+        _by_oid = raw.get("byObjectId") or {}
+        _by_name = raw.get("byName") or {}
+        _stats = raw.get("stats") or {}
+    except Exception:
+        pass
+
+
+def catalog_stats() -> dict[str, Any]:
+    _load()
+    return dict(_stats or {})
+
+
+def get_profile_by_object_id(object_id: int) -> Optional[dict[str, Any]]:
+    _load()
+    return (_by_oid or {}).get(str(int(object_id)))
+
+
+def get_profile_by_name(name: str) -> Optional[dict[str, Any]]:
+    _load()
+    if not name:
+        return None
+    return (_by_name or {}).get(name)
+
+
+def resolve_spawn_name(alias_or_name: str) -> str:
+    """Map catalog alias / display name / numeric objectId string → gameObjectName."""
+    _load()
+    key = str(alias_or_name).strip()
+    if key.isdigit():
+        prof = get_profile_by_object_id(int(key))
+        if prof and prof.get("name"):
+            return str(prof["name"])
+    prof = get_profile_by_name(key)
+    if prof:
+        return str(prof.get("name") or key)
+    return key
+
+
+def object_id_for_name(name: str) -> Optional[int]:
+    prof = get_profile_by_name(name)
+    if not prof:
+        return None
+    oid = prof.get("objectId")
+    return int(oid) if oid is not None else None
+
+
+def list_spawnables() -> list[dict[str, Any]]:
+    """All entries with a non-empty gameObjectName (for SDK / tools)."""
+    _load()
+    out: list[dict[str, Any]] = []
+    for prof in (_by_name or {}).values():
+        n = prof.get("name") or ""
+        if not n:
+            continue
+        oid = prof.get("objectId")
+        w = prof.get("aabbWidth")
+        h = prof.get("aabbHeight")
+        if w is None and prof.get("aabb"):
+            w = prof["aabb"].get("width")
+        if h is None and prof.get("aabb"):
+            h = prof["aabb"].get("height")
+        out.append(
+            {
+                "objectId": oid,
+                "name": n,
+                "width": w,
+                "height": h,
+                "mass": (prof.get("rigidbody") or {}).get("mass"),
+                "source": prof.get("source", ""),
+            }
+        )
+    out.sort(key=lambda x: (x.get("objectId") is None, x.get("objectId") or 0))
+    return out