melon-lua 3.4.0__py3-none-any.whl

melon_lua/vpcompile/nodes/math_basic.py

@@ -0,0 +1,235 @@
+"""Shard A: basic scalar math NodeOperationType emitters."""
+from __future__ import annotations
+
+from ..ir import VPNode
+from ._base import NodeEmitter
+
+
+def _assign(uid: str, expr: str) -> list[str]:
+  return [f'    G["{uid}"] = {expr}']
+
+
+def _g(i: int, ins: list[str], default: str = "0") -> str:
+  return ins[i] if i < len(ins) else default
+
+
+def _is_vector(n: VPNode) -> bool:
+  """Check if node operates on vector data."""
+  gdt = n.raw.get("GateDataType")
+  if isinstance(gdt, str) and gdt.strip() == "Vector":
+      return True
+  for inp in n.inputs:
+      dt = inp.get("DataType")
+      if isinstance(dt, str) and dt.strip() == "Vector":
+          return True
+  return False
+
+
+def _vector_binop(uid: str, a: str, b: str, op: str) -> list[str]:
+  """Emit vector binary operation (a op b) component-wise."""
+  op_map = {"+": " + ", "-": " - ", "*": " * ", "/": " / "}
+  op_str = op_map.get(op, op)
+  return [
+      f"    local _va, _vb = {a}, {b}",
+      f"    local _vax = type(_va) == 'table' and (_va.x or _va[1] or 0) or _va",
+      f"    local _vay = type(_va) == 'table' and (_va.y or _va[2] or 0) or 0",
+      f"    local _vaz = type(_va) == 'table' and (_va.z or _va[3] or 0) or 0",
+      f"    local _vaw = type(_va) == 'table' and (_va.w or _va[4] or 0) or 0",
+      f"    local _vbx = type(_vb) == 'table' and (_vb.x or _vb[1] or 0) or _vb",
+      f"    local _vby = type(_vb) == 'table' and (_vb.y or _vb[2] or 0) or 0",
+      f"    local _vbz = type(_vb) == 'table' and (_vb.z or _vb[3] or 0) or 0",
+      f"    local _vbw = type(_vb) == 'table' and (_vb.w or _vb[4] or 0) or 0",
+      f'    G["{uid}"] = {{x = _vax {op_str} _vbx, y = _vay {op_str} _vby, z = _vaz {op_str} _vbz, w = _vaw {op_str} _vbw}}',
+  ]
+
+
+def emit_add(uid: str, ins: list[str], n: VPNode) -> list[str]:
+  if _is_vector(n):
+      a, b = _g(0, ins, "{x=0,y=0,z=0,w=0}"), _g(1, ins, "{x=0,y=0,z=0,w=0}")
+      return _vector_binop(uid, a, b, "+")
+  if len(ins) >= 2:
+      return _assign(uid, f"({ins[0]}) + ({ins[1]})")
+  if len(ins) == 1:
+      return _assign(uid, f"({ins[0]}) + 0")
+  return _assign(uid, "0")
+
+
+def emit_subtract(uid: str, ins: list[str], n: VPNode) -> list[str]:
+  if _is_vector(n):
+      a, b = _g(0, ins, "{x=0,y=0,z=0,w=0}"), _g(1, ins, "{x=0,y=0,z=0,w=0}")
+      return _vector_binop(uid, a, b, "-")
+  if len(ins) >= 2:
+      return _assign(uid, f"({ins[0]}) - ({ins[1]})")
+  return _assign(uid, "0")
+
+
+def emit_multiply(uid: str, ins: list[str], n: VPNode) -> list[str]:
+  if _is_vector(n):
+      a, b = _g(0, ins, "{x=0,y=0,z=0,w=0}"), _g(1, ins, "{x=0,y=0,z=0,w=0}")
+      return _vector_binop(uid, a, b, "*")
+  if len(ins) >= 2:
+      return _assign(uid, f"({ins[0]}) * ({ins[1]})")
+  return _assign(uid, "0")
+
+
+def emit_divide(uid: str, ins: list[str], n: VPNode) -> list[str]:
+  if _is_vector(n):
+      a, b = _g(0, ins, "{x=0,y=0,z=0,w=0}"), _g(1, ins, "{x=0,y=0,z=0,w=0}")
+      return [
+          f"    local _va, _vb = {a}, {b}",
+          f"    local _vax = type(_va) == 'table' and (_va.x or _va[1] or 0) or _va",
+          f"    local _vay = type(_va) == 'table' and (_va.y or _va[2] or 0) or 0",
+          f"    local _vaz = type(_va) == 'table' and (_va.z or _va[3] or 0) or 0",
+          f"    local _vaw = type(_va) == 'table' and (_va.w or _va[4] or 0) or 0",
+          f"    local _vbx = type(_vb) == 'table' and (_vb.x or _vb[1] or 0) or _vb",
+          f"    local _vby = type(_vb) == 'table' and (_vb.y or _vb[2] or 0) or 0",
+          f"    local _vbz = type(_vb) == 'table' and (_vb.z or _vb[3] or 0) or 0",
+          f"    local _vbw = type(_vb) == 'table' and (_vb.w or _vb[4] or 0) or 0",
+          f'    G["{uid}"] = {{x = _vbx ~= 0 and _vax / _vbx or 0, y = _vby ~= 0 and _vay / _vby or 0, z = _vbz ~= 0 and _vaz / _vbz or 0, w = _vbw ~= 0 and _vaw / _vbw or 0}}',
+      ]
+  if len(ins) >= 2:
+      return _assign(uid, f"(({ins[1]}) ~= 0 and ({ins[0]}) / ({ins[1]}) or 0)")
+  return _assign(uid, "0")
+
+
+def emit_negate(uid: str, ins: list[str], n: VPNode) -> list[str]:
+  if _is_vector(n):
+      v = _g(0, ins, "{x=0,y=0,z=0,w=0}")
+      return [
+          f"    local _nv = {v}",
+          f"    local _nvx = type(_nv) == 'table' and (_nv.x or _nv[1] or 0) or _nv",
+          f"    local _nvy = type(_nv) == 'table' and (_nv.y or _nv[2] or 0) or 0",
+          f"    local _nvz = type(_nv) == 'table' and (_nv.z or _nv[3] or 0) or 0",
+          f"    local _nvw = type(_nv) == 'table' and (_nv.w or _nv[4] or 0) or 0",
+          f'    G["{uid}"] = {{x = -_nvx, y = -_nvy, z = -_nvz, w = -_nvw}}',
+      ]
+  return _assign(uid, f"-({_g(0, ins)})")
+
+
+def emit_abs(uid: str, ins: list[str], _n: VPNode) -> list[str]:
+  return _assign(uid, f"math.abs({_g(0, ins)})")
+
+
+def emit_min(uid: str, ins: list[str], _n: VPNode) -> list[str]:
+  if len(ins) >= 2:
+      return _assign(uid, f"math.min(({ins[0]}), ({ins[1]}))")
+  return _assign(uid, _g(0, ins))
+
+
+def emit_max(uid: str, ins: list[str], _n: VPNode) -> list[str]:
+  if len(ins) >= 2:
+      return _assign(uid, f"math.max(({ins[0]}), ({ins[1]}))")
+  return _assign(uid, _g(0, ins))
+
+
+def emit_clamp(uid: str, ins: list[str], _n: VPNode) -> list[str]:
+  v, lo, hi = _g(0, ins), _g(1, ins), _g(2, ins)
+  return _assign(uid, f"math.max(({lo}), math.min(({hi}), ({v})))")
+
+
+def emit_clamp01(uid: str, ins: list[str], _n: VPNode) -> list[str]:
+  v = _g(0, ins)
+  return _assign(uid, f"math.max(0, math.min(1, ({v})))")
+
+
+def emit_sqr(uid: str, ins: list[str], _n: VPNode) -> list[str]:
+  x = _g(0, ins)
+  return _assign(uid, f"({x}) * ({x})")
+
+
+def emit_sqrt(uid: str, ins: list[str], _n: VPNode) -> list[str]:
+  return _assign(uid, f"math.sqrt(math.max(0, ({_g(0, ins)})))")
+
+
+def emit_pow(uid: str, ins: list[str], _n: VPNode) -> list[str]:
+  if len(ins) >= 2:
+      return _assign(uid, f"math.pow(({ins[0]}), ({ins[1]}))")
+  return _assign(uid, "1")
+
+
+def emit_mod(uid: str, ins: list[str], _n: VPNode) -> list[str]:
+  if len(ins) >= 2:
+      return _assign(uid, f"math.fmod(({ins[0]}), ({ins[1]}))")
+  return _assign(uid, "0")
+
+
+def emit_lerp(uid: str, ins: list[str], _n: VPNode) -> list[str]:
+  a, b, t = _g(0, ins), _g(1, ins), _g(2, ins)
+  return _assign(uid, f"({a}) + (({b}) - ({a})) * ({t})")
+
+
+def emit_floor(uid: str, ins: list[str], _n: VPNode) -> list[str]:
+  return _assign(uid, f"math.floor({_g(0, ins)})")
+
+
+def emit_ceil(uid: str, ins: list[str], _n: VPNode) -> list[str]:
+  return _assign(uid, f"math.ceil({_g(0, ins)})")
+
+
+def emit_round(uid: str, ins: list[str], _n: VPNode) -> list[str]:
+  return _assign(uid, f"math.floor(({_g(0, ins)}) + 0.5)")
+
+
+def emit_sign(uid: str, ins: list[str], _n: VPNode) -> list[str]:
+  x = _g(0, ins)
+  return _assign(
+      uid,
+      f"(({x}) > 0 and 1 or (({x}) < 0 and -1 or 0))",
+  )
+
+
+def emit_inverse(uid: str, ins: list[str], _n: VPNode) -> list[str]:
+  x = _g(0, ins)
+  return _assign(uid, f"(({x}) ~= 0 and 1 / ({x}) or 0)")
+
+
+def emit_percent(uid: str, ins: list[str], _n: VPNode) -> list[str]:
+  if len(ins) >= 2:
+      return _assign(
+          uid,
+          f"(({ins[1]}) ~= 0 and (({ins[0]}) / ({ins[1]})) * 100 or 0)",
+      )
+  return _assign(uid, "0")
+
+
+def emit_average(uid: str, ins: list[str], _n: VPNode) -> list[str]:
+  if len(ins) >= 2:
+      return _assign(uid, f"(({ins[0]}) + ({ins[1]})) / 2")
+  return _assign(uid, _g(0, ins))
+
+
+def emit_exp(uid: str, ins: list[str], _n: VPNode) -> list[str]:
+  return _assign(uid, f"math.exp({_g(0, ins)})")
+
+
+def emit_log(uid: str, ins: list[str], _n: VPNode) -> list[str]:
+  x = _g(0, ins)
+  return _assign(uid, f"(({x}) > 0 and math.log({x}) or 0)")
+
+
+MATH_BASIC_EMITTERS: dict[str, NodeEmitter] = {
+  "Add": emit_add,
+  "Subtract": emit_subtract,
+  "Multiply": emit_multiply,
+  "Divide": emit_divide,
+  "Negate": emit_negate,
+  "Abs": emit_abs,
+  "Min": emit_min,
+  "Max": emit_max,
+  "Clamp": emit_clamp,
+  "Clamp01": emit_clamp01,
+  "Sqr": emit_sqr,
+  "Sqrt": emit_sqrt,
+  "Pow": emit_pow,
+  "Mod": emit_mod,
+  "Lerp": emit_lerp,
+  "Floor": emit_floor,
+  "Ceil": emit_ceil,
+  "Round": emit_round,
+  "Sign": emit_sign,
+  "Inverse": emit_inverse,
+  "Percent": emit_percent,
+  "Average": emit_average,
+  "Exp": emit_exp,
+  "Log": emit_log,
+}

melon_lua/vpcompile/nodes/math_trig.py

@@ -0,0 +1,71 @@
+"""Shard B: trig / angle math."""
+from __future__ import annotations
+
+from ..ir import VPNode
+from ._base import NodeEmitter
+
+
+def _g(i: int, ins: list[str]) -> str:
+  return ins[i] if i < len(ins) else "0"
+
+
+def _assign(uid: str, expr: str) -> list[str]:
+  return [f'    G["{uid}"] = {expr}']
+
+
+def emit_acos(uid: str, ins: list[str], _n: VPNode) -> list[str]:
+  # Acos returns radians (standard math.acos behavior). RadToDeg node converts
+  # to degrees. Do NOT pre-convert here — that causes double conversion when
+  # followed by RadToDeg in the chip graph.
+  return _assign(uid, f"math.acos({_g(0, ins)})")
+
+
+def emit_rad_to_deg(uid: str, ins: list[str], _n: VPNode) -> list[str]:
+  return _assign(uid, f"({ _g(0, ins) }) * (180 / math.pi)")
+
+
+def emit_deg_to_rad(uid: str, ins: list[str], _n: VPNode) -> list[str]:
+  return _assign(uid, f"({ _g(0, ins) }) * (math.pi / 180)")
+
+
+def emit_delta_angle(uid: str, ins: list[str], _n: VPNode) -> list[str]:
+  if len(ins) >= 2:
+      return _assign(
+          uid,
+          f"(({ins[1]}) - ({ins[0]})) * (180 / math.pi)",
+      )
+  return _assign(uid, "0")
+
+
+def emit_cosine_formula_angle(uid: str, ins: list[str], _n: VPNode) -> list[str]:
+  # VP: side a,b,c -> angle at A via law of cosines; inputs: a,b,c scalars
+  if len(ins) >= 3:
+      a, b, c = ins[0], ins[1], ins[2]
+      return _assign(
+          uid,
+          f"(function() local aa,bb,cc=({a}),({b}),({c}); "
+          f"local x=(aa*aa+bb*bb-cc*cc)/(2*aa*bb); "
+          f"if x>1 then x=1 elseif x<-1 then x=-1 end; "
+          f"return math.acos(x)*(180/math.pi) end)()",
+      )
+  return _assign(uid, "0")
+
+
+def emit_cosine_formula_side(uid: str, ins: list[str], _n: VPNode) -> list[str]:
+  if len(ins) >= 3:
+      a, ang, b = ins[0], ins[1], ins[2]
+      return _assign(
+          uid,
+          f"math.sqrt(({a})^2+({b})^2-2*({a})*({b})*math.cos(({ang})*math.pi/180))",
+      )
+  return _assign(uid, "0")
+
+
+MATH_TRIG_EMITTERS: dict[str, NodeEmitter] = {
+  "Acos": emit_acos,
+  "RadToDeg": emit_rad_to_deg,
+  "DegToRad": emit_deg_to_rad,
+  "DeltaAngle": emit_delta_angle,
+  "CosineFormulaAngle": emit_cosine_formula_angle,
+  "CosineFormulaSide": emit_cosine_formula_side,
+}

melon_lua/vpcompile/nodes/vector.py

@@ -0,0 +1,101 @@
+"""Shard F: vector scalars (Magnitude etc.) + Split/Combine/Normalize."""
+from __future__ import annotations
+
+import math
+
+from ..ir import VPNode
+from ._base import NodeEmitter
+
+
+def _assign(uid: str, expr: str) -> list[str]:
+  return [f'    G["{uid}"] = {expr}']
+
+
+def _g(i: int, ins: list[str], default: str = "0") -> str:
+  return ins[i] if i < len(ins) else default
+
+
+def emit_magnitude(uid: str, ins: list[str], _n: VPNode) -> list[str]:
+  """Magnitude: Vector -> Number (sqrt(x^2+y^2+z^2+w^2), usually 2D)."""
+  v = _g(0, ins)
+  # Assume vector is {x, y, z, w} table; magnitude uses x,y for 2D
+  return [
+      f"    local _vmag = {v}",
+      f"    local _vx = type(_vmag) == 'table' and (_vmag.x or _vmag[1] or 0) or _vmag",
+      f"    local _vy = type(_vmag) == 'table' and (_vmag.y or _vmag[2] or 0) or 0",
+      f'    G["{uid}"] = math.sqrt(_vx * _vx + _vy * _vy)',
+  ]
+
+
+def emit_sqr_magnitude(uid: str, ins: list[str], _n: VPNode) -> list[str]:
+  v = _g(0, ins)
+  return [
+      f"    local _vsm = {v}",
+      f"    local _vx = type(_vsm) == 'table' and (_vsm.x or _vsm[1] or 0) or _vsm",
+      f"    local _vy = type(_vsm) == 'table' and (_vsm.y or _vsm[2] or 0) or 0",
+      f'    G["{uid}"] = _vx * _vx + _vy * _vy',
+  ]
+
+
+def emit_split(uid: str, ins: list[str], n: VPNode) -> list[str]:
+  """Split: Vector -> 4 Numbers (x, y, z, w)."""
+  v = _g(0, ins, "{x=0,y=0,z=0,w=0}")
+  outs = n.outputs or []
+  lines = [
+      f"    local _spl = {v}",
+      f"    local _splx = type(_spl) == 'table' and (_spl.x or _spl[1] or 0) or _spl",
+      f"    local _spy = type(_spl) == 'table' and (_spl.y or _spl[2] or 0) or 0",
+      f"    local _splz = type(_spl) == 'table' and (_spl.z or _spl[3] or 0) or 0",
+      f"    local _splw = type(_spl) == 'table' and (_spl.w or _spl[4] or 0) or 0",
+  ]
+  # Emit outputs based on how many outputs the node has
+  for i in range(min(4, max(1, len(outs)))):
+      comp = ("_splx", "_spy", "_splz", "_splw")[i]
+      lines.append(f'  G["{uid}_o{i}"] = {comp}')
+  # Primary output is x (first component)
+  lines.append(f'  G["{uid}"] = _splx')
+  return lines
+
+
+def emit_combine(uid: str, ins: list[str], n: VPNode) -> list[str]:
+  """Combine: 4 Numbers (x,y,z,w) -> Vector."""
+  x = _g(0, ins, "0")
+  y = _g(1, ins, "0")
+  z = _g(2, ins, "0")
+  w = _g(3, ins, "0")
+  # Use local variables to avoid field access on literals (0.x is syntax error)
+  return [
+      f"    local _cxv = {x}",
+      f"    local _cyv = {y}",
+      f"    local _czv = {z}",
+      f"    local _cwv = {w}",
+      f"    local _cx = type(_cxv) == 'table' and (_cxv.x or _cxv[1] or 0) or _cxv",
+      f"    local _cy = type(_cyv) == 'table' and (_cyv.y or _cyv[2] or 0) or _cyv",
+      f"    local _cz = type(_czv) == 'table' and (_czv.z or _czv[3] or 0) or _czv",
+      f"    local _cw = type(_cwv) == 'table' and (_cwv.w or _cwv[4] or 0) or _cwv",
+      f'    G["{uid}"] = {{x = _cx, y = _cy, z = _cz, w = _cw}}',
+  ]
+
+
+def emit_normalize(uid: str, ins: list[str], n: VPNode) -> list[str]:
+  """Normalize: Vector -> Vector (unit vector)."""
+  v = _g(0, ins, "{x=0,y=0,z=0,w=0}")
+  return [
+      f"    local _norm = {v}",
+      f"    local _nx = type(_norm) == 'table' and (_norm.x or _norm[1] or 0) or _norm",
+      f"    local _ny = type(_norm) == 'table' and (_norm.y or _norm[2] or 0) or 0",
+      f"    local _nz = type(_norm) == 'table' and (_norm.z or _norm[3] or 0) or 0",
+      f"    local _nw = type(_norm) == 'table' and (_norm.w or _norm[4] or 0) or 0",
+      f"    local _len = math.sqrt(_nx * _nx + _ny * _ny)",
+      f"    local _flen = math.max(1e-6, _len)",
+      f'    G["{uid}"] = {{x = _nx / _flen, y = _ny / _flen, z = _nz / _flen, w = _nw / _flen}}',
+  ]
+
+
+VECTOR_EMITTERS: dict[str, NodeEmitter] = {
+  "Magnitude": emit_magnitude,
+  "SqrMagnitude": emit_sqr_magnitude,
+  "Split": emit_split,
+  "Combine": emit_combine,
+  "Normalize": emit_normalize,
+}

melon_lua/vpcompile/ops.py

@@ -0,0 +1,195 @@
+"""NodeOperationType — full enum from IL2CPP NodeOperationType.cs (Melon 36.x)."""
+from __future__ import annotations
+
+# Auto-aligned with Ui.Windows.Chip.NodeOperationType (VP36)
+OP_NAME: dict[int, str] = {
+    0: "Base",
+    1: "Identity",
+    5: "Sticker",
+    256: "Root",
+    257: "Constant",
+    258: "Pi",
+    259: "E",
+    260: "Time",
+    261: "Random",
+    512: "Exit",
+    768: "Variable",
+    1280: "Split",
+    1281: "Combine",
+    1282: "Normalize",
+    1283: "Magnitude",
+    1284: "SqrMagnitude",
+    1286: "VectorCross",
+    1288: "VectorDot",
+    1290: "VectorPositive",
+    1292: "VectorRotate",
+    1294: "VectorShiftLeft",
+    1295: "VectorShiftRight",
+    1296: "VectorAngleBetween",
+    1297: "RgbToHsv",
+    1298: "HsvToRgb",
+    1537: "EntityNormal",
+    1538: "Velocity",
+    1539: "AngularVelocity",
+    1540: "EntityAngle",
+    1541: "Temperature",
+    1542: "AddForce",
+    1543: "Color",
+    1544: "LookAt",
+    1545: "AddAngularForce",
+    1546: "AddForceAtPosition",
+    1549: "EntityID",
+    1550: "IDToEntity",
+    1552: "IDIsValid",
+    1553: "WorldPositionToLocal",
+    1554: "WorldAngleToLocal",
+    1555: "LocalPositionToWorld",
+    1556: "LocalAngleToWorld",
+    1557: "Mass",
+    1558: "MassCenter",
+    1559: "Position",
+    1560: "VelocityAtPosition",
+    1561: "CanBeActivated",
+    1562: "Activate",
+    1563: "Gravity",
+    1566: "Freeze",
+    1567: "Size",
+    1569: "Ignite",
+    1570: "Extinguish",
+    1571: "Follow",
+    1574: "Collision",
+    1577: "Delete",
+    1578: "Elevation",
+    1579: "Voltage",
+    1580: "PhysicMaterial",
+    1581: "EntityName",
+    1582: "UnlocalizedEntityName",
+    1583: "Draggable",
+    1584: "RadioSignal",
+    2049: "Sin",
+    2050: "Cos",
+    2051: "Asin",
+    2052: "Acos",
+    2053: "Tan",
+    2054: "Atan",
+    2055: "Ctan",
+    2056: "Actan",
+    2057: "DegToRad",
+    2058: "RadToDeg",
+    2059: "DeltaAngle",
+    2060: "CosineFormulaSide",
+    2061: "CosineFormulaAngle",
+    2062: "PythagoreanCathetus",
+    2063: "PythagoreanSide",
+    2064: "Atan2",
+    2304: "Add",
+    2305: "Subtract",
+    2306: "Multiply",
+    2307: "Divide",
+    2308: "Exp",
+    2309: "Average",
+    2310: "Ceil",
+    2311: "Clamp",
+    2312: "Clamp01",
+    2314: "ExpPow",
+    2315: "Negate",
+    2316: "Percent",
+    2318: "Sign",
+    2319: "Floor",
+    2320: "Inverse",
+    2321: "Sqr",
+    2322: "Sqrt",
+    2323: "Log",
+    2324: "Abs",
+    2325: "Pow",
+    2326: "Round",
+    2327: "Mod",
+    2328: "Lerp",
+    2329: "Min",
+    2330: "Max",
+    2560: "And",
+    2561: "Or",
+    2562: "Nand",
+    2563: "Nor",
+    2564: "Not",
+    2565: "Xor",
+    2566: "Nxor",
+    2567: "Branch",
+    2568: "Select",
+    2816: "Equal",
+    2817: "NotEqual",
+    2818: "GreaterOrEqual",
+    2819: "LessOrEqual",
+    2820: "Greater",
+    2821: "Less",
+    2822: "InRangeInclusive",
+    2823: "InRangeExclusive",
+    3073: "BitAnd",
+    3074: "BitNot",
+    3075: "BitOr",
+    3076: "BitXor",
+    3077: "BitShiftLeft",
+    3078: "BitShiftRight",
+    3585: "StringSplit",
+    3586: "StringFind",
+    3587: "StringLength",
+    3588: "StringLowercase",
+    3589: "StringUppercase",
+    3590: "StringReverse",
+    3591: "StringRepeat",
+    3592: "StringReplace",
+    3593: "Substring",
+    3594: "StringTrim",
+    3595: "ToString",
+    3596: "ToAscii",
+    3597: "FromAscii",
+    3598: "ToNumber",
+    3599: "ToTime",
+    3600: "ToDate",
+    3801: "ArraysGet",
+    3802: "ArraysSet",
+    3803: "ArraysAdd",
+    3804: "ArraysLength",
+    3805: "ArraysRemoveAllByValue",
+    3806: "ArraysRemoveByIndex",
+    3807: "ArraysFind",
+    3808: "ArraysClear",
+    4097: "DeltaPreviousCurrent",
+    4098: "Counter",
+    4099: "Delay",
+    4100: "Accumulate",
+    4101: "PreviousFrame",
+    4102: "Trigger",
+    5001: "WorldSessionState",
+    5002: "LoadWorldSessionState",
+    5003: "SystemTime",
+    5004: "GameTimer",
+    5005: "ShowWorldInformationWindow",
+    5006: "ShowWinWindow",
+    5007: "ShowLoseWindow",
+    5008: "Timer",
+    5009: "SaveWorldSessionState",
+    5010: "ResetWorldSessionState",
+    5011: "ClearGibs",
+    5012: "ClearDecals",
+    5013: "ClearLivings",
+    5014: "ClearCorpses",
+    5015: "WorldInAppOpenShop",
+    5016: "WorldInAppVisibility",
+    5017: "GlobalVariable",
+    5018: "Currency",
+    5100: "LuaScript",
+    5632: "CameraPosition",
+    5633: "CameraZoom",
+}
+
+NAME_TO_OP: dict[str, int] = {v: k for k, v in OP_NAME.items()}
+
+# Implemented node names: melon_lua/vpcompile/nodes/ REGISTRY (see codegen.py)
+
+
+def op_name(operation_type: int, node_id: str) -> str:
+    if operation_type in OP_NAME:
+        return OP_NAME[operation_type]
+    head = (node_id or "").split(":")[0].strip()
+    return head or f"Op{operation_type}"

melon_lua/vpcompile/save_data.py

@@ -0,0 +1,20 @@
+"""Parse VP node SaveData JSON."""
+from __future__ import annotations
+
+import json
+
+from .ir import VPNode
+
+
+def constant_value(node: VPNode) -> float:
+    sd = node.save_data
+    if not sd:
+        return 0.0
+    try:
+        obj = json.loads(sd)
+        dv = obj.get("DataValue")
+        if dv is None:
+            return 0.0
+        return float(dv)
+    except (json.JSONDecodeError, TypeError, ValueError):
+        return 0.0