rpgsync 0.1.0__tar.gz → 0.2.0__tar.gz

rpgsync-0.2.0/CHANGELOG.md

@@ -0,0 +1,95 @@
+# Changelog
+
+## Versions
+
+rpgsync is released on [PyPI](https://pypi.org/project/rpgsync/) as `0.MINOR.PATCH`:
+
+- **MINOR** goes up when the scripts change: `rpgsync pull` writes a game's scripts
+  differently (another layout, other names, another way to write a command), or scripts
+  written by it may not work with the previous minor version (a DSL name renamed or
+  removed).
+- **PATCH** goes up for everything else: fixes and additions after which `rpgsync pull`
+  writes the same scripts.
+
+A game's `Scripts/pyproject.toml` depends on the version that set it up,
+`rpgsync~=0.MINOR.PATCH` (that version and its later patches), and its `Scripts/uv.lock`
+pins the exact one. [Upgrading rpgsync](README.md#upgrading-rpgsync) moves a game to a
+newer one; [Releasing](docs/development.md#releasing) makes a new one.
+
+## 0.2.0
+
+The scripts of Maniac Patch games change: `rpgsync pull` writes them differently.
+
+- Maniac Patch commands have typed, named forms: `maniac.show_string_picture(...)`,
+  `maniac.console_print(...)` & co, `maniac.get_media_option(...)` /
+  `set_media_option(...)`, `maniac.get_game_info("map_size", into=...)`, and
+  `maniac.script("line 1", "line 2", results=[...])` holding a script and its further
+  lines in one call. `write_picture` with all its parameters zero is no longer raw.
+- String variables: `database/strings.py` names them, and Control Strings are Python
+  statements on `strings` (`strings.name = "Alex"`, `+=`, `str(variables.n).rjust(4, "0")`,
+  `db_name("item", 3)`, `read_file(...)`, `.replace()`, `int()`, `len()`, `.find()`,
+  `.split(into=...)`, `.pop_line()`, `.to_file()`), and Conditional Branch compares them
+  (`if strings.name == "Alex":`, `"x" in strings[1]`).
+- Maniac options of standard commands are Python: Control Variables operands and
+  operations (`variables.x = variables.a * 2`, `sqrt()`, `sin()`, `min()`, `abs()`,
+  `lerp()`, `array_sum()`, `party[0].hp`, `game.frames`, `switches[n]`, `a if b > c else d`,
+  `variables[10:1:-1]` backwards ranges, `variables[variables.a:variables.b + 1]`), loops
+  (`for variables.i in range(1, 11):`, `while variables.hp > 0:`, `continue`,
+  `break_loop(levels=2)`), `wait(frames=...)`, `common_events[variables.n]()`,
+  `events[n].erase()` / `.restore()`, names and values from variables in `play_bgm()`,
+  `play_se()`, `face()`, `message_options(width=..., font=...)`, pixel scrolling
+  (`pan_screen_by()`, `pan_screen_to()`), `call_system_function()`,
+  `disable_system_functions()`.
+- The Maniac Patch's editor stores some standard commands with other parameters (a
+  Control Variables of one variable with 0 as last id, zero parameters more on loops,
+  faces without their trailing zeros...): rpgsync detects the layout most of a game
+  uses, writes the same Python for both, and marks a command stored the other way
+  with `# layout: maniac` / `# layout: rpg_maker`. A 2003 game's Wait without its key
+  parameter is `wait(1.0, key=None)` instead of a raw line.
+- `database/terms.py` and `database/system.py` export the Terms and the System settings
+  (generated from liblcf's schema: a field named there appears once rpgsync's schema
+  is generated again; chunks it doesn't know are kept). The Maniac Patch's System
+  fields are named: title and save scene hooks, message window font, size, spacing and
+  face layout. Skill `failure_message` 3 (Maniac's Hit Rate Calc) and `-9` in
+  `menu_commands` (Game End hidden) are documented.
+- Common events run on `"battle_start"` and `"battle_parallel"` (Maniac Patch triggers
+  6 and 7).
+- `rpgsync check`: in a game declaring `"maniac"`, `database/game_types.py` lets
+  `variables[n]` stand where the patch reads a value (`randint(1, variables.max)`);
+  without it, Maniac options of standard commands are reported as warnings.
+- `tools/gen_dbschema.py` reads the EasyRPG Editor's liblcf (`../Editor/lib/liblcf`) by
+  default.
+
+## 0.1.2
+
+- `rpgsync check --resources` names every file in its warnings, instead of the first 8 and
+  how many more: the files the database's entries use, sorted, with their number, and
+  the imported files never used. A list too long for its line goes under it, wrapped to
+  the terminal's width without cutting a name. A file used several times in one game file
+  (`Map0003.lmu`) is no longer named again in "also used at".
+- `rpgsync check --resources` reads a name DynParams builds for a command
+  (`pictures[2].show(f"w{variables.sheet}")`) whole, in that command's folder, numbers
+  from variables as digits: `Picture/w4.png` counts as used, as a name of one letter
+  then a number is no longer too short to tell, and `Picture/wall.png` doesn't. The name
+  of a command whose parameters alone DynParams rewrites is checked like any other.
+
+## 0.1.1
+
+- `rpgsync check`: the pages that one later page keeps from ever being active are
+  named in one warning, in fewer words.
+- `rpgsync check` names files relative to the current folder (`Scripts/Map0004.py:12`
+  run from the game folder), ty's problems too, so terminals and editors can open them.
+- `rpgsync check --resources`: a name ending with a space (`"Theme "`, whose file is
+  `Theme .mp3`) is found, instead of reported as not imported and its file as never used.
+- rpgsync knows CortiXCustomCrit.dll (Corti's critical hits): its `dyn.ccrit_*`
+  commands, and its `[CortiCustomCrit]` and `[CortiLog]` sections of `DynRPG.ini`.
+
+## 0.1.0
+
+First release on PyPI.
+
+- A new game's scripts depend on `rpgsync~=0.1.0` from PyPI, pinned by their `uv.lock`,
+  instead of a link to this computer's rpgsync folder.
+- A developer of rpgsync links their rpgsync folder as `Scripts/.rpgsync/rpgsync`:
+  rpgsync installs it, editable, in the scripts' environment, and leaves
+  `pyproject.toml` and `uv.lock` as they are.

{rpgsync-0.1.0 → rpgsync-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rpgsync
-Version: 0.1.0
+Version: 0.2.0
 Summary: A Python twin of your RPG Maker 2000/2003 game
 Keywords: rpg-maker,rpg-maker-2000,rpg-maker-2003,easyrpg,gamedev,dsl
 Author: Nicolas Oulianov
@@ -40,8 +40,9 @@ A Python twin of your RPG Maker 2000/2003 game.
 - Implement automated tests to verify game mechanics
 - Improve your game using the modern developer's toolkit
 
+<img width="1920" height="754" alt="rpgsync" src="https://github.com/user-attachments/assets/11a3fc5a-7884-4c7c-9aef-ee9ee54aa4bc" />
 
-## Code example
+## Example
 
 ```python
 @event(10, "Jeremy", x=15, y=38)
@@ -81,11 +82,7 @@ class Ulysse(Event):  # The other event!
         pass
 ```
 
-Every command, option and value is typed and documented in
-[`rpgsync/dsl.py`](https://github.com/oulianov/rpgsync/blob/master/rpgsync/dsl.py): your
-editor shows the docs on hover and flags wrong values (a misspelled direction, a sprite
-index above 7, ...). [Writing scripts](https://github.com/oulianov/rpgsync/blob/master/docs/scripts.md)
-explains events and pages, variables by name, the database and the map tree.
+Every command, option and value is typed and documented. The database, the map tree, the variable names, battle command events are also transformer. [Learn more here.](https://github.com/oulianov/rpgsync/blob/master/docs/scripts.md)
 
 ## Demo
 

{rpgsync-0.1.0 → rpgsync-0.2.0}/README.md

@@ -9,8 +9,9 @@ A Python twin of your RPG Maker 2000/2003 game.
 - Implement automated tests to verify game mechanics
 - Improve your game using the modern developer's toolkit
 
+<img width="1920" height="754" alt="rpgsync" src="https://github.com/user-attachments/assets/11a3fc5a-7884-4c7c-9aef-ee9ee54aa4bc" />
 
-## Code example
+## Example
 
 ```python
 @event(10, "Jeremy", x=15, y=38)
@@ -50,11 +51,7 @@ class Ulysse(Event):  # The other event!
         pass
 ```
 
-Every command, option and value is typed and documented in
-[`rpgsync/dsl.py`](https://github.com/oulianov/rpgsync/blob/master/rpgsync/dsl.py): your
-editor shows the docs on hover and flags wrong values (a misspelled direction, a sprite
-index above 7, ...). [Writing scripts](https://github.com/oulianov/rpgsync/blob/master/docs/scripts.md)
-explains events and pages, variables by name, the database and the map tree.
+Every command, option and value is typed and documented. The database, the map tree, the variable names, battle command events are also transformer. [Learn more here.](https://github.com/oulianov/rpgsync/blob/master/docs/scripts.md)
 
 ## Demo
 

{rpgsync-0.1.0 → rpgsync-0.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "rpgsync"
-version = "0.1.0"
+version = "0.2.0"
 description = "A Python twin of your RPG Maker 2000/2003 game"
 readme = "README.md"
 license = "MIT"

{rpgsync-0.1.0 → rpgsync-0.2.0}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "rpgsync"
-version = "0.1.0"
+version = "0.2.0"
 description = "A Python twin of your RPG Maker 2000/2003 game"
 readme = "README.md"
 license = "MIT"
@@ -8,7 +8,14 @@ license = "MIT"
 # through a link (the older scripts' .rpgsync/rpgsync source), and the scripts can't
 # install rpgsync.  LICENSE goes in the sdist through source-include below.
 authors = [{ name = "Nicolas Oulianov" }]
-keywords = ["rpg-maker", "rpg-maker-2000", "rpg-maker-2003", "easyrpg", "gamedev", "dsl"]
+keywords = [
+    "rpg-maker",
+    "rpg-maker-2000",
+    "rpg-maker-2003",
+    "easyrpg",
+    "gamedev",
+    "dsl",
+]
 classifiers = [
     "Development Status :: 3 - Alpha",
     "Environment :: Console",
@@ -51,15 +58,10 @@ source-include = ["LICENSE", "CHANGELOG.md"]
 
 [tool.pytest.ini_options]
 testpaths = ["tests"]
-addopts = "-n auto"  # pytest-xdist: one worker per CPU
+addopts = "-n auto"   # pytest-xdist: one worker per CPU
 
 [dependency-groups]
-dev = [
-    "pytest>=9.1.1",
-    "pytest-xdist>=3.8.0",
-    "ruff>=0.16.10",
-    "ty>=0.0.85",
-]
+dev = ["pytest>=9.1.1", "pytest-xdist>=3.8.0", "ruff>=0.16.10", "ty>=0.0.85"]
 
 [tool.ruff]
 line-length = 120

{rpgsync-0.1.0 → rpgsync-0.2.0}/rpgsync/cli.py

@@ -429,7 +429,14 @@ def _run(syncer: CliSyncer, units, prefer: str | None, initial: bool = False, fo
 
 Part = tuple[str, str]  # (text, rich style)
 
-PLURAL = {"event": "events", "common event": "common events", "troop": "troops", "map": "maps", "entry": "entries"}
+PLURAL = {
+    "event": "events",
+    "common event": "common events",
+    "troop": "troops",
+    "map": "maps",
+    "entry": "entries",
+    "field": "fields",
+}
 
 
 def _ids(ids: list[int], limit: int = 8) -> str:
@@ -460,7 +467,9 @@ def _entry_diff(old: list, new: list, what: str) -> list[Part]:
         ("removed", sorted(i for i in a.keys() - b.keys() if i > 0), "red"),
     ):
         if ids:
-            parts.append(("%s %s %s" % (PLURAL[what] if len(ids) > 1 else what, _ids(ids), label), style))
+            named = [getattr(b.get(i) or a.get(i), "name", None) for i in ids] if what == "field" else []
+            shown = ", ".join(named) if named and all(named) else _ids(ids)  # terms/system: the field names
+            parts.append(("%s %s %s" % (PLURAL[what] if len(ids) > 1 else what, shown, label), style))
     if isinstance(pa, TreeOrder) and isinstance(pb, TreeOrder):
         both = set(pa.order) & set(pb.order)  # maps added or removed are listed above
         if [m for m in pa.order if m in both] != [m for m in pb.order if m in both]:
@@ -536,7 +545,9 @@ def _status(syncer: Syncer, units: list[Unit]) -> dict[str, list[StatusLine]]:
         data = data_of[u.bin_path]
         if data is None:
             continue
-        what = {"map": "event", "common": "common event", "troop": "troop", "maptree": "map"}.get(u.kind, "entry")
+        what = u.what or {"map": "event", "common": "common event", "troop": "troop", "maptree": "map"}.get(
+            u.kind, "entry"
+        )
         py_name = u.script_label(project.script_dir)
         bin_name = os.path.relpath(u.bin_path, project.game_dir)
         if u.kind == "database":
@@ -923,7 +934,7 @@ def check(
     for found, part in _checked_units(proj, units, rules, resources, jobs):
         for kind, where, problem in found:
             color = "red" if kind == "error" else "yellow"
-            err.print(*([(where, "cyan"), ": "] if where else []), (problem, color), kind=kind)
+            err.print(*([(_here(where), "cyan"), ": "] if where else []), (problem, color), kind=kind)
             errors += kind == "error"
             warnings += kind == "warning"
         if files is not None and part is not None:
@@ -1125,7 +1136,7 @@ def _check_resources(resources: Collector, proj: Project, ui: UI, err: UI, compl
     grouped: dict[tuple[str, str], list] = {}  # (database file, folder) -> its references
     uses: dict[tuple[str, str], list] = {}  # (folder, file) -> the events using it
     for ref in found.missing:
-        if not ref.event:  # the database keeps many (default entries never shown): one line per folder
+        if not ref.event:  # the database keeps many (default entries never shown): one warning per folder
             grouped.setdefault((ref.path, ref.folder), []).append(ref)
         else:  # one line per file, at its first use
             uses.setdefault((ref.folder, resource_key(ref.name)), []).append(ref)
@@ -1133,30 +1144,51 @@ def _check_resources(resources: Collector, proj: Project, ui: UI, err: UI, compl
         ref = refs[0]
         where = "%s:%d" % (ref.path, ref.line) if ref.line else ref.path
         problem = "%s uses %s/%s, which is not imported" % (ref.what, ref.folder, ref.name)
-        if len(refs) > 1:
-            others = [
-                "%s:%d" % (os.path.basename(r.path), r.line) if r.line else os.path.basename(r.path) for r in refs[1:4]
-            ]
-            more = " and %d more" % (len(refs) - 4) if len(refs) > 4 else ""
-            problem += " (also used at %s%s)" % (", ".join(others), more)
-        err.print((where, "cyan"), ": ", (problem, "yellow"), kind="warning")
+        # its other places, each once: a game file (Map0003.lmu) has no lines
+        others = list(dict.fromkeys(os.path.basename(r.path) + (":%d" % r.line if r.line else "") for r in refs[1:]))
+        others = [o for o in others if o != os.path.basename(where)]
+        if others:
+            more = " and %d more" % (len(others) - 3) if len(others) > 3 else ""
+            problem += " (also used at %s%s)" % (", ".join(others[:3]), more)
+        err.print((_here(where), "cyan"), ": ", (problem, "yellow"), kind="warning")
     for (path, folder), refs in grouped.items():
-        where = "%s:%d" % (path, refs[0].line) if refs[0].line else path
-        names = list(dict.fromkeys(r.name for r in refs))
-        shown = ", ".join(names[:8]) + (" and %d more" % (len(names) - 8) if len(names) > 8 else "")
+        where = _here("%s:%d" % (path, refs[0].line) if refs[0].line else path)
         if len(refs) == 1:
             problem = "%s uses %s/%s, which is not imported" % (refs[0].what, folder, refs[0].name)
-        else:
-            problem = "%d entries use %s files that are not imported: %s" % (len(refs), folder, shown)
-        err.print((where, "cyan"), ": ", (problem, "yellow"), kind="warning")
+            err.print((where, "cyan"), ": ", (problem, "yellow"), kind="warning")
+            continue
+        names = sorted(dict.fromkeys(r.name for r in refs), key=str.casefold)
+        files = "%d %s file%s" % (len(names), folder, "s that are" if len(names) > 1 else " that is")
+        _print_list(err, where, "%d entries use %s not imported" % (len(refs), files), names)
     for folder, names in found.unused.items():
-        problem = "%d imported file%s never used: %s" % (len(names), "s" * (len(names) > 1), ", ".join(names))
-        err.print((folder + "/", "cyan"), ": ", (problem, "yellow"), kind="warning")
+        problem = "%d imported file%s never used" % (len(names), "s" * (len(names) > 1))
+        _print_list(err, folder + "/", problem, names)
     if found.note:
         ui.print(found.note, kind="info")
     return len(uses) + len(grouped) + len(found.unused)
 
 
+def _print_list(err: UI, where: str, problem: str, names: list[str]) -> None:
+    """A warning about files, all of them named: on its line when they fit, else under it,
+    in indented lines as wide as the terminal, a name never cut in two."""
+    listed = ", ".join(names)
+    width = err.console.width
+    if len(err.marker("warning")) + len("%s: %s: %s" % (where, problem, listed)) <= width:
+        err.print((where, "cyan"), ": ", ("%s: %s" % (problem, listed), "yellow"), kind="warning")
+        return
+    err.print((where, "cyan"), ": ", (problem + ":", "yellow"), kind="warning")
+    indent = "    "
+    row = ""
+    for i, name in enumerate(names):
+        item = name + ("," if i < len(names) - 1 else "")
+        if row and len(indent) + len(row) + 1 + len(item) > width:
+            err.print((indent + row, "yellow"))
+            row = item
+        else:
+            row = row + " " + item if row else item
+    err.print((indent + row, "yellow"))
+
+
 def _ty(script_dir: str) -> str | None:
     """The ty of the scripts folder's environment, else one on the PATH."""
     for rel in (".venv/bin/ty", ".venv/Scripts/ty.exe"):
@@ -1183,10 +1215,27 @@ def _check_types(script_dir: str, ui: UI, err: UI, paths: list[Path] | None = No
     if result.returncode == 0 or not lines:
         return 0
     for line in lines:
+        m = re.match(r"([^:\s][^:]*\.pyi?)(:\d+:\d+: .*)$", line)  # ty's paths: relative to the scripts folder
+        if m:
+            line = _here(os.path.join(script_dir, m.group(1))) + m.group(2)
         err.print((line, "red"), kind="error")
     return max(len(lines), 1)
 
 
+def _here(where: str) -> str:
+    """A place `check` names (a path, path:line, or a file of the game: RPG_RT.lmt), with
+    its path relative to the current folder when it is in it: Scripts/Map0004.py:12, run
+    from the game folder."""
+    m = re.match(r"(.+?)((?::\d+)*)$", where)
+    if m is None or not os.path.isabs(m.group(1)):
+        return where
+    try:
+        path = os.path.relpath(m.group(1))
+    except ValueError:  # on another drive (Windows)
+        return where
+    return where if path == os.pardir or path.startswith(os.pardir + os.sep) else path + m.group(2)
+
+
 def clean(
     project: ProjectArg = None,
     yes: Annotated[bool, typer.Option("--yes", "-y", help="Do not ask for confirmation.")] = False,

{rpgsync-0.1.0 → rpgsync-0.2.0}/rpgsync/commands.py

@@ -221,6 +221,10 @@ class Ctx(BaseModel):
     handles: dict[str, dict[int, str]] = Field(default_factory=dict)  # variables/switches id -> Python name
     choice_sep: str | None = None  # how the editor joined show_choices options (None: engine default)
     dynparams: bool = False  # DynPlugins/DynParams.dll: variables wherever RPG Maker takes a number
+    # most commands of the game are stored the way the Maniac Patch editor writes them
+    # (Control Variables of one variable with 0 as last id...): a statement without a
+    # `# layout:` comment is compiled that way (see rpgsync.layout)
+    maniac_layout: bool = False
 
     def enc(self, s: str, node=None) -> bytes:
         try:
@@ -561,9 +565,19 @@ def C(code, params=(), string=b"") -> Command:
 TEXT_CODES = {10110: ("text", 20110), 12410: ("comment", 22410)}
 
 
+# Maniac Patch: p4 selectors (4 bits each) of width, height, font (0 the command's text,
+# 1 strings[p7], 2 strings[variables[p7]]), font size, character and line spacing;
+# p5-p10 their values (0: unchanged)
+MSG_MANIAC = ["width", "height", "font", "font_size", "char_spacing", "line_spacing"]
+
+
 def _msg_options():
     def dec(c, ctx):
-        if len(c.params) != 4 or c.string:
+        from .maniac_ext import text_src
+        from .pyexpr import _fits, mval_src
+
+        n = len(c.params)
+        if n not in (4, 11) or (c.string and n == 4):
             return None
         kw = []
         if c.params[0]:
@@ -573,19 +587,46 @@ def _msg_options():
             kw.append(("avoid_hero", bool(c.params[2]) if c.params[2] == 1 else c.params[2]))
         if c.params[3]:
             kw.append(("continue_events", bool(c.params[3]) if c.params[3] == 1 else c.params[3]))
+        if n == 11:
+            m = c.params[4]
+            if not _fits(m, 6):
+                return None
+            for slot, name in enumerate(MSG_MANIAC):
+                mode, v = (m >> 4 * slot) & 0xF, c.params[5 + slot]
+                if name == "font":
+                    src = text_src(mode, v, ctx.dec(c.string))
+                    if src is None:
+                        return None
+                    if src != '""':
+                        kw.append((name, Raw(src=src)))
+                elif mode or v:
+                    if mode > 2:
+                        return None
+                    kw.append((name, Raw(src=mval_src(mode, v))))
         return render_call("message_options", [], kw)
 
     def enc(call, ctx):
-        a = Args(call, ["transparent", "position", "avoid_hero", "continue_events"])
-        return C(
-            10120,
-            [
-                a.int("transparent", 0),
-                a.enum("position", ["top", "middle", "bottom"], "bottom"),
-                a.int("avoid_hero", 0),
-                a.int("continue_events", 0),
-            ],
-        )
+        from .maniac_ext import text_val
+        from .pyexpr import mval_val
+
+        a = Args(call, ["transparent", "position", "avoid_hero", "continue_events"] + MSG_MANIAC)
+        p = [
+            a.int("transparent", 0),
+            a.enum("position", ["top", "middle", "bottom"], "bottom"),
+            a.int("avoid_hero", 0),
+            a.int("continue_events", 0),
+        ]
+        if not set(MSG_MANIAC) & set(a.values):
+            return C(10120, p)
+        modes, values, font = 0, [], ""
+        for slot, name in enumerate(MSG_MANIAC):
+            if name == "font":
+                mode, v, font = text_val(a.get(name, ""), "message_options(): font", call.node)
+            else:
+                mode, v = mval_val(a.get(name, 0), name, modes=3)
+            modes |= mode << 4 * slot
+            values.append(v)
+        return C(10120, p + [modes] + values, ctx.enc(font, call.node))
 
     return dec, enc
 
@@ -594,7 +635,22 @@ rich(10120, "message_options")(_msg_options())
 
 
 def _face():
+    # Maniac Patch: p3 selectors of the faceset (0 the command's text, 1 strings[p4],
+    # 2 strings[variables[p4]]) and of the index (1 variables[n], 2 variables[variables[n]]);
+    # the Maniac editor drops trailing zero parameters (rpgsync.layout)
     def dec(c, ctx):
+        from .maniac_ext import text_src
+        from .pyexpr import _fits, mval_src
+
+        if len(c.params) in (4, 5):
+            p = c.params + [0] * (5 - len(c.params))
+            if not _fits(p[3], 2) or (p[3] >> 4) > 2 or p[1] not in (0, 1) or p[2] not in (0, 1):
+                return None
+            face = text_src(p[3] & 0xF, p[4], ctx.dec(c.string))
+            if face is None:
+                return None
+            kw = [(k, True) for k, v in (("right", p[1]), ("flip", p[2])) if v]
+            return render_call("face", [Raw(src=face), Raw(src=mval_src(p[3] >> 4, p[0]))], kw)
         if not c.string:
             if not c.params:
                 return "face(None)"
@@ -612,9 +668,19 @@ def _face():
         return render_call("face", [ctx.dec(c.string), c.params[0]], kw)
 
     def enc(call, ctx):
+        from .maniac_ext import text_val
+        from .pyexpr import is_int, mval_val
+
         a = Args(call, ["faceset", "index", "right", "flip"])
         if a.get("faceset") is None and len(a.values) <= 1:
             return C(10130)
+        face, index = a.get("faceset"), a.get("index", 0)
+        if face is not None and not isinstance(face, str) or not is_int(index):
+            fmode, fvar, text = text_val(face, "face(): the faceset", call.node)
+            imode, i = mval_val(index, "face(): the index", modes=3)
+            return C(
+                10130, [i, a.int("right", 0), a.int("flip", 0), fmode | imode << 4, fvar], ctx.enc(text, call.node)
+            )
         return C(10130, [a.int("index", 0), a.int("right", 0), a.int("flip", 0)], ctx.enc(a.str("faceset"), call.node))
 
     return dec, enc
@@ -657,20 +723,42 @@ rich(10810, "teleport")(_teleport())
 
 
 def _wait():
+    # Maniac Patch: p1 256 = in frames (else tenths of seconds; 1 = until a key is
+    # pressed), p2 the selector of the value (1 variables[n], 2 variables[variables[n]])
     def dec(c, ctx):
-        n = len(c.params)
-        if n not in (1, 2) or (n == 1) != (ctx.engine == "2k"):
+        from .pyexpr import mval_src
+
+        p = c.params
+        n = len(p)
+        if n == 3 and p[2] in (1, 2) and p[1] in (0, 256):
+            unit = "frames" if p[1] == 256 else "tenths"
+            return render_call("wait", [], [(unit, Raw(src=mval_src(p[2], p[0])))])
+        if n == 2 and p[1] == 256:
+            return render_call("wait", [], [("frames", p[0])])
+        if n not in (1, 2):
             return None
         kw = []
         if n == 2 and c.params[1]:
             if c.params[1] != 1:
                 return None
             kw.append(("key", True))
+        if n == 1 and ctx.engine != "2k":
+            kw.append(("key", None))  # stored without it (RPG Maker 2000's form)
         t = c.params[0] / 10
         return render_call("wait", [Raw(src=repr(t))], kw)
 
     def enc(call, ctx):
-        a = Args(call, ["seconds", "key"])
+        from .pyexpr import mval_val
+
+        a = Args(call, ["seconds", "key", "frames", "tenths"])
+        for unit, opt in (("frames", 256), ("tenths", 0)):
+            if unit in a.values:
+                if set(a.values) != {unit}:
+                    raise CompileError("wait(%s=...) takes no other argument" % unit, call.node)
+                mode, v = mval_val(a.get(unit), unit, modes=3)
+                if mode == 0 and unit == "tenths":
+                    raise CompileError("wait(): a number of seconds is wait(seconds)", call.node)
+                return C(11410, [v, opt] + ([mode] if mode else []))
         s = a.get("seconds", 0)
         if not isinstance(s, (int, float)) or isinstance(s, bool):
             raise CompileError("wait(): seconds must be a number", call.node)
@@ -678,6 +766,8 @@ def _wait():
         if abs(tenths - s * 10) > 1e-6:
             raise CompileError("wait(): RPG Maker waits in steps of 0.1 seconds", call.node)
         p = [int(tenths)]
+        if "key" in a.values and a.get("key") is None:
+            return C(11410, p)
         if ctx.engine != "2k" or a.bool("key"):
             p.append(int(a.bool("key")))
         return C(11410, p)
@@ -717,18 +807,52 @@ for _code, _name, _args in [
 
 
 def _sound(code, name, has_fade):
+    # Maniac Patch: one more parameter with the selectors (4 bits each) of the name (0 the
+    # command's text, 1 strings[n], 2 strings[variables[n]]) and of each value (1
+    # variables[n], 2 variables[variables[n]]), then the name's string variable
     keys = (["fade"] if has_fade else []) + ["volume", "tempo", "balance"]
     defaults = ([0] if has_fade else []) + [100, 100, 50]
 
     def dec(c, ctx):
-        if len(c.params) != len(keys):
+        from .maniac_ext import text_src
+        from .pyexpr import _fits, mval_src
+
+        n = len(keys)
+        if len(c.params) == n:
+            kw = [(k, v) for k, v, d in zip(keys, c.params, defaults) if v != d]
+            return render_call(name, [ctx.dec(c.string)], kw)
+        if len(c.params) not in (n + 1, n + 2):
+            return None
+        m, var = c.params[n], c.params[n + 1] if len(c.params) == n + 2 else 0
+        if m == 0 or not _fits(m, n + 1) or (len(c.params) == n + 2) != (m & 0xF != 0):
             return None
-        kw = [(k, v) for k, v, d in zip(keys, c.params, defaults) if v != d]
-        return render_call(name, [ctx.dec(c.string)], kw)
+        sound = text_src(m & 0xF, var, ctx.dec(c.string))
+        if sound is None:
+            return None
+        kw = []
+        for slot, (k, v, d) in enumerate(zip(keys, c.params, defaults), 1):
+            mode = (m >> 4 * slot) & 0xF
+            if mode > 2:
+                return None
+            if mode or v != d:
+                kw.append((k, Raw(src=mval_src(mode, v))))
+        return render_call(name, [Raw(src=sound)], kw)
 
     def enc(call, ctx):
+        from .maniac_ext import text_val
+        from .pyexpr import mval_val
+
         a = Args(call, ["name"] + keys)
-        return C(code, [a.int(k, d) for k, d in zip(keys, defaults)], ctx.enc(a.str("name", ""), call.node))
+        sound = a.get("name", "")
+        if isinstance(sound, str) and all(isinstance(a.get(k, 0), int) for k in keys):
+            return C(code, [a.int(k, d) for k, d in zip(keys, defaults)], ctx.enc(a.str("name", ""), call.node))
+        mode, var, text = text_val(sound, "%s(): the name" % name, call.node)
+        params, modes = [], mode
+        for slot, (k, d) in enumerate(zip(keys, defaults), 1):
+            kmode, v = mval_val(a.get(k, d), k, modes=3)
+            params.append(v)
+            modes |= kmode << 4 * slot
+        return C(code, params + [modes] + ([var] if mode else []), ctx.enc(text, call.node))
 
     return dec, enc
 

{rpgsync-0.1.0 → rpgsync-0.2.0}/rpgsync/compat.py

@@ -25,7 +25,7 @@ import os
 import tomllib
 from collections.abc import Iterable, Sequence
 
-from . import dynparams, dynrpg, maniac
+from . import dynparams, dynrpg, maniac, maniac_ext
 from .commands import CODE_NAMES
 from .lcf import Command
 
@@ -118,6 +118,14 @@ def command_problems(
                 hint = ' (a %s command: add "%s" to [tool.rpgsync] patches)' % (patch, patch) if patch else ""
                 add(True, "unknown command %d%s" % (code, hint))
             continue
+        if "maniac" not in patches:
+            option = maniac_ext.maniac_option(c)
+            if option is not None:
+                add(
+                    False,
+                    '%s uses a Maniac Patch option (%s): add "maniac" to [tool.rpgsync] patches'
+                    % (describe(code), option),
+                )
         if engine == "2k":
             if code in ONLY_2K3:
                 add(True, "%s only exists in RPG Maker 2003" % describe(code))