mtrevival 0.3.1__py3-none-any.whl

mtrevival/__init__.py

@@ -0,0 +1,3 @@
+"""Tools for reviving Monopoly Tycoon (2001)."""
+
+__version__ = "0.1.0"

mtrevival/__main__.py

@@ -0,0 +1,95 @@
+"""Command line entry point: ``python -m mtrevival``."""
+
+from __future__ import annotations
+
+import argparse
+import re
+import sys
+from pathlib import Path
+
+from . import fixpack
+
+_RESOLUTION = re.compile(r"^(\d{3,4})x(\d{3,4})$")
+
+
+def resolution(text: str) -> tuple[int, int]:
+    """argparse type for WIDTHxHEIGHT."""
+    m = _RESOLUTION.match(text.strip().lower())
+    if not m:
+        raise argparse.ArgumentTypeError(
+            "expected WIDTHxHEIGHT such as 1920x1080, got %r" % text)
+    return int(m.group(1)), int(m.group(2))
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(
+        prog="mtrevival",
+        description="Make Monopoly Tycoon (2001) run on modern Windows.")
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    def common(p: argparse.ArgumentParser) -> None:
+        p.add_argument("--game-dir", type=Path, default=None,
+                       help="install directory containing mc.exe")
+        p.add_argument("--resolution", type=resolution,
+                       default=(fixpack.DEFAULT_WIDTH, fixpack.DEFAULT_HEIGHT),
+                       metavar="WxH",
+                       help="display mode, default %dx%d; the adapter must list it"
+                            % (fixpack.DEFAULT_WIDTH, fixpack.DEFAULT_HEIGHT))
+
+    for name, help_text in (("check", "report what would be done, change nothing"),
+                            ("fix", "write config.cfg with a working adapter")):
+        p = sub.add_parser(name, help=help_text)
+        common(p)
+        p.add_argument("--windowed", action="store_true",
+                       help="run in a window instead of fullscreen (needs patch 1.2)")
+        p.add_argument("--music", action="store_true",
+                       help="restore the soundtrack: install the wmsource-shim "
+                            "for this user and write music 0")
+    common(sub.add_parser("adapters", help="list adapters and whether they fit"))
+
+    args = parser.parse_args(argv)
+    width, height = args.resolution
+    windowed = getattr(args, "windowed", False)
+    with_music = getattr(args, "music", False)
+
+    try:
+        game_dir = fixpack.find_install(args.game_dir)
+    except fixpack.FixError as error:
+        print("error: %s" % error, file=sys.stderr)
+        return 2
+
+    if args.command == "adapters":
+        adapters, source = fixpack.read_adapters(game_dir)
+        print("source: %s" % source)
+        for adapter in adapters:
+            fits = adapter.supports(width, height)
+            print("  adapter %d  %-34s modes=%-4d %s%s"
+                  % (adapter.index, adapter.description or "(unnamed)",
+                     len(adapter.modes),
+                     ("OK %dx%d" if fits else "no %dx%d") % (width, height),
+                     "  [portrait]" if adapter.is_portrait else ""))
+        return 0
+
+    plan = fixpack.build_plan(game_dir, width, height, windowed, with_music)
+    print(fixpack.describe(plan))
+
+    if args.command == "check":
+        return 0 if plan.ok else 1
+
+    try:
+        backup = fixpack.apply(plan)
+    except fixpack.FixError as error:
+        print("\nerror: %s" % error, file=sys.stderr)
+        return 1
+
+    if plan.music:
+        print("\nInstalled %s and registered it for this user." % plan.shim_target)
+    print("\nWrote %s" % plan.config_path)
+    if backup:
+        print("Backed up previous config to %s" % backup)
+    print("Launch the game with mc.exe.")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

mtrevival/d3denum.py

@@ -0,0 +1,114 @@
+"""Parser for Monopoly Tycoon's own ``D3DEnum.txt``.
+
+The game writes this file when it enumerates Direct3D 8 adapters. It is the
+authoritative record of what *the game* sees, which is what matters when
+choosing an adapter index for ``config.cfg`` — it can differ from what Windows
+reports, and a rotated display shows portrait modes here.
+
+Example of the format::
+
+    Number of display Adapters  :- 2
+
+    Adapter #0
+    nvldumd.dll
+    NVIDIA GeForce RTX 4080
+    Device Validated
+    Available Video Modes = 522
+    Vid Mode 480 X 640 X 32
+    Valid Video Modes = 46
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, field
+
+_ADAPTER = re.compile(r"^Adapter #(\d+)\s*$")
+_MODE = re.compile(r"^Vid Mode\s+(\d+)\s+X\s+(\d+)\s+X\s+(\d+)\s*$")
+_COUNT = re.compile(r"^Number of display Adapters\s*:-\s*(\d+)\s*$")
+
+
+@dataclass
+class Adapter:
+    """One Direct3D 8 adapter as the game enumerated it."""
+
+    index: int
+    description: str = ""
+    validated: bool = False
+    modes: list[tuple[int, int, int]] = field(default_factory=list)
+
+    def supports(self, width: int, height: int, bpp: int | None = None) -> bool:
+        """True if this adapter offers the given mode."""
+        for w, h, b in self.modes:
+            if w == width and h == height and (bpp is None or b == bpp):
+                return True
+        return False
+
+    @property
+    def is_portrait(self) -> bool:
+        """True if every mode is taller than it is wide (a rotated display)."""
+        return bool(self.modes) and all(h > w for w, h, _ in self.modes)
+
+
+def parse(text: str) -> list[Adapter]:
+    """Parse the contents of ``D3DEnum.txt`` into a list of adapters."""
+    adapters: list[Adapter] = []
+    current: Adapter | None = None
+    # A description is the first non-empty line after the DLL name line.
+    lines_since_header = 0
+
+    for raw in text.splitlines():
+        line = raw.strip()
+
+        m = _ADAPTER.match(line)
+        if m:
+            current = Adapter(index=int(m.group(1)))
+            adapters.append(current)
+            lines_since_header = 0
+            continue
+
+        if current is None:
+            continue
+
+        m = _MODE.match(line)
+        if m:
+            current.modes.append((int(m.group(1)), int(m.group(2)), int(m.group(3))))
+            continue
+
+        if line == "Device Validated":
+            current.validated = True
+            continue
+        if line == "Device is Not Valid":
+            current.validated = False
+            continue
+
+        if line:
+            lines_since_header += 1
+            # line 1 is the driver DLL, line 2 is the human-readable description
+            if lines_since_header == 2 and not current.description:
+                current.description = line
+
+    return adapters
+
+
+def declared_adapter_count(text: str) -> int | None:
+    """The adapter count the game printed, or None if the line is absent."""
+    for raw in text.splitlines():
+        m = _COUNT.match(raw.strip())
+        if m:
+            return int(m.group(1))
+    return None
+
+
+def choose_adapter(adapters: list[Adapter], width: int, height: int,
+                   bpp: int | None = None) -> int | None:
+    """Pick the lowest-numbered validated adapter that supports the mode.
+
+    Returns the adapter index for ``SysSetup device``, or None when no adapter
+    offers the mode. Adapter 0 is preferred when it qualifies, because that is
+    what the game uses by default and it keeps the config closest to stock.
+    """
+    for adapter in sorted(adapters, key=lambda a: a.index):
+        if adapter.validated and adapter.supports(width, height, bpp):
+            return adapter.index
+    return None

mtrevival/displays.py

@@ -0,0 +1,115 @@
+"""Windows display enumeration, used only when ``D3DEnum.txt`` is absent.
+
+``D3DEnum.txt`` is preferred because it records what the *game* sees. This
+module is the fallback for a first run, before the game has ever started.
+
+Caveat worth knowing: Direct3D 8 adapter ordering is not guaranteed to match
+``EnumDisplayDevices`` ordering. In practice both follow the desktop device
+order, with the primary display first, but a config produced from this fallback
+should be re-derived from ``D3DEnum.txt`` once the game has run once.
+"""
+
+from __future__ import annotations
+
+import ctypes
+from ctypes import wintypes
+
+from .d3denum import Adapter
+
+ENUM_CURRENT_SETTINGS = -1
+DISPLAY_DEVICE_ATTACHED_TO_DESKTOP = 0x00000001
+DISPLAY_DEVICE_PRIMARY_DEVICE = 0x00000004
+
+
+class DISPLAY_DEVICEW(ctypes.Structure):
+    _fields_ = [
+        ("cb", wintypes.DWORD),
+        ("DeviceName", wintypes.WCHAR * 32),
+        ("DeviceString", wintypes.WCHAR * 128),
+        ("StateFlags", wintypes.DWORD),
+        ("DeviceID", wintypes.WCHAR * 128),
+        ("DeviceKey", wintypes.WCHAR * 128),
+    ]
+
+
+class _POINTL(ctypes.Structure):
+    _fields_ = [("x", ctypes.c_long), ("y", ctypes.c_long)]
+
+
+class DEVMODEW(ctypes.Structure):
+    _fields_ = [
+        ("dmDeviceName", wintypes.WCHAR * 32),
+        ("dmSpecVersion", wintypes.WORD),
+        ("dmDriverVersion", wintypes.WORD),
+        ("dmSize", wintypes.WORD),
+        ("dmDriverExtra", wintypes.WORD),
+        ("dmFields", wintypes.DWORD),
+        ("dmPosition", _POINTL),
+        ("dmDisplayOrientation", wintypes.DWORD),
+        ("dmDisplayFixedOutput", wintypes.DWORD),
+        ("dmColor", ctypes.c_short),
+        ("dmDuplex", ctypes.c_short),
+        ("dmYResolution", ctypes.c_short),
+        ("dmTTOption", ctypes.c_short),
+        ("dmCollate", ctypes.c_short),
+        ("dmFormName", wintypes.WCHAR * 32),
+        ("dmLogPixels", wintypes.WORD),
+        ("dmBitsPerPel", wintypes.DWORD),
+        ("dmPelsWidth", wintypes.DWORD),
+        ("dmPelsHeight", wintypes.DWORD),
+        ("dmDisplayFlags", wintypes.DWORD),
+        ("dmDisplayFrequency", wintypes.DWORD),
+        ("dmICMMethod", wintypes.DWORD),
+        ("dmICMIntent", wintypes.DWORD),
+        ("dmMediaType", wintypes.DWORD),
+        ("dmDitherType", wintypes.DWORD),
+        ("dmReserved1", wintypes.DWORD),
+        ("dmReserved2", wintypes.DWORD),
+        ("dmPanningWidth", wintypes.DWORD),
+        ("dmPanningHeight", wintypes.DWORD),
+    ]
+
+
+def enumerate_adapters() -> list[Adapter]:
+    """Enumerate attached displays and their modes, in desktop device order."""
+    user32 = ctypes.windll.user32
+    adapters: list[Adapter] = []
+    index = 0
+    device_number = 0
+
+    while True:
+        dev = DISPLAY_DEVICEW()
+        dev.cb = ctypes.sizeof(DISPLAY_DEVICEW)
+        if not user32.EnumDisplayDevicesW(None, device_number, ctypes.byref(dev), 0):
+            break
+        device_number += 1
+        if not dev.StateFlags & DISPLAY_DEVICE_ATTACHED_TO_DESKTOP:
+            continue
+
+        adapter = Adapter(index=index, description=dev.DeviceString, validated=True)
+        index += 1
+
+        mode_number = 0
+        seen: set[tuple[int, int, int]] = set()
+        while True:
+            dm = DEVMODEW()
+            dm.dmSize = ctypes.sizeof(DEVMODEW)
+            if not user32.EnumDisplaySettingsW(dev.DeviceName, mode_number,
+                                               ctypes.byref(dm)):
+                break
+            mode_number += 1
+            entry = (int(dm.dmPelsWidth), int(dm.dmPelsHeight), int(dm.dmBitsPerPel))
+            if entry not in seen:
+                seen.add(entry)
+                adapter.modes.append(entry)
+
+        # Primary display sorts first, matching how D3D8 numbers adapters.
+        adapters.append((0 if dev.StateFlags & DISPLAY_DEVICE_PRIMARY_DEVICE else 1,
+                         adapter))
+
+    adapters.sort(key=lambda pair: pair[0])
+    result = []
+    for i, (_, adapter) in enumerate(adapters):
+        adapter.index = i
+        result.append(adapter)
+    return result

mtrevival/fixpack.py

@@ -0,0 +1,316 @@
+"""Apply the Windows 11 fixes to an installed copy of Monopoly Tycoon.
+
+Two crashes stop the 2001 game on modern Windows, both the same defect: the
+game creates an object, never checks whether it succeeded, then dereferences
+null.
+
+1. ``IDirect3D8::CreateDevice`` fails when the game asks for 640x480 exclusive
+   fullscreen on an adapter with no such mode — for example a rotated portrait
+   primary display. It then calls ``SetViewport`` on the null device.
+   Fixed by pointing ``SysSetup device`` at an adapter that has the mode.
+
+2. Opening ``gamedata\\sound\\music\\music_intro.wma`` fails because the Windows
+   Media DirectShow source filter no longer ships with Windows.
+   Avoided by ``SysSetup music 1``, which suppresses that path; fixed by
+   ``--music``, which installs a stand-in for the missing filter and writes
+   ``music 0`` (see ``music.py``).
+
+A third problem must be solved before either fix can persist: the game cannot
+write ``config.cfg`` inside Program Files under a standard user account.
+
+The same mechanism sets the resolution. Any mode the chosen adapter enumerates
+works, fullscreen or (on patch 1.2) windowed; 1920x1080 and 1280x720 windowed
+were verified on one machine.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import shutil
+from dataclasses import dataclass
+from datetime import datetime
+from pathlib import Path
+
+from . import d3denum, gameconfig, music
+
+DEFAULT_INSTALL = Path(r"C:\Program Files (x86)\Infogrames\Monopoly Tycoon")
+DEFAULT_WIDTH = gameconfig.DEFAULT_WIDTH
+DEFAULT_HEIGHT = gameconfig.DEFAULT_HEIGHT
+TARGET_BPP = 32
+
+# MD5 of mc.exe for the builds this tool has been run against. Patch 1.2
+# renamed the windowed-mode key, so the version decides which keys are honoured.
+KNOWN_BUILDS = {
+    "fd34022887dc347b664b689fedeb9a37": "1.0",
+    "5965dbb1a4be4f58fa4452df78786e63": "1.2",
+}
+WINDOWED_NEEDS = "1.2"
+
+
+class FixError(Exception):
+    """A problem that stops the fix being applied."""
+
+
+@dataclass
+class Plan:
+    """What the fix would do, before it does it."""
+
+    game_dir: Path
+    game_version: str
+    writable: bool
+    adapter: int | None
+    adapter_source: str
+    adapter_description: str
+    width: int
+    height: int
+    windowed: bool
+    config_path: Path
+    config_exists: bool
+    rendered: str
+    music: bool = False
+    shim_source: Path | None = None
+    shim_target: Path | None = None
+    reader_available: bool = True
+    run_as_admin: bool = False
+    tool_elevated: bool = False
+
+    @property
+    def ok(self) -> bool:
+        return (self.writable and self.adapter is not None
+                and not self.music_problems)
+
+    @property
+    def music_problems(self) -> list[str]:
+        """What stops ``--music`` from being applied. Empty when music is off."""
+        if not self.music:
+            return []
+        out = []
+        if self.shim_source is None:
+            out.append("%s is not bundled with this copy of mtrevival. Build it "
+                       "with tools\\wmsource-shim\\build.ps1 (needs the MSVC "
+                       "Build Tools) or install a release that includes it."
+                       % music.SHIM_NAME)
+        if not self.reader_available:
+            out.append("The WM ASF Reader (Windows Media) is not registered for "
+                       "32-bit programs. On Windows N editions install the "
+                       "Media Feature Pack, then retry.")
+        return out
+
+    @property
+    def warnings(self) -> list[str]:
+        """Things the user should know that do not stop the fix.
+
+        Only 1.0 was observed ignoring the Window key. An unrecognised build
+        gets told exactly that, not a prediction.
+        """
+        out = []
+        if self.windowed and self.game_version == "unknown":
+            out.append("Windowed mode is only verified on patch %s, and this "
+                       "mc.exe is not a build this tool recognises. The Window "
+                       "key is written; whether the game honours it is unproven."
+                       % WINDOWED_NEEDS)
+        elif self.windowed and self.game_version != WINDOWED_NEEDS:
+            out.append("Windowed mode needs patch %s; game version here is %s, "
+                       "which ignores the Window key and runs fullscreen."
+                       % (WINDOWED_NEEDS, self.game_version))
+        if self.music and self.run_as_admin:
+            out.append("mc.exe is set to run as administrator. An elevated "
+                       "process ignores per-user COM registrations, so it will "
+                       "not see the music shim and will crash with music 0. "
+                       "Clear that compatibility setting before playing.")
+        if self.music and self.tool_elevated:
+            out.append("This shell is elevated. The shim is registered for the "
+                       "account running this command; the game must run as the "
+                       "same account, not elevated. If you elevated as a "
+                       "different user, rerun this from a normal shell.")
+        return out
+
+
+def find_install(explicit: Path | None = None) -> Path:
+    """Locate the game directory, or raise FixError.
+
+    An explicitly supplied directory is never overridden by a search: writing
+    into a different install than the one the caller named would be worse than
+    failing.
+    """
+    if explicit is not None:
+        if (explicit / "mc.exe").is_file():
+            # Absolute: the path is written into the registry and must not
+            # depend on the shell's working directory.
+            return explicit.resolve()
+        raise FixError("Could not find mc.exe in %s" % explicit)
+
+    for path in (DEFAULT_INSTALL,
+                 Path(r"C:\Program Files\Infogrames\Monopoly Tycoon"),
+                 Path(r"C:\Program Files (x86)\Infogrames Interactive\Monopoly Tycoon")):
+        if (path / "mc.exe").is_file():
+            return path
+    raise FixError(
+        "Could not find mc.exe. Pass the install directory with --game-dir.")
+
+
+def game_version(game_dir: Path) -> str:
+    """'1.0', '1.2', or 'unknown', from the hash of mc.exe."""
+    digest = hashlib.md5((game_dir / "mc.exe").read_bytes()).hexdigest()
+    return KNOWN_BUILDS.get(digest, "unknown")
+
+
+def is_writable(directory: Path) -> bool:
+    """True if this account can create files in the game directory."""
+    probe = directory / ".mtrevival-write-probe"
+    try:
+        probe.touch()
+        probe.unlink()
+        return True
+    except OSError:
+        return False
+
+
+def grant_command(directory: Path) -> str:
+    """The elevated command that makes the game directory writable."""
+    return ('icacls "%s" /grant "$($env:USERNAME):(OI)(CI)M" /T' % directory)
+
+
+def read_adapters(game_dir: Path) -> tuple[list[d3denum.Adapter], str]:
+    """Adapters as the game sees them, falling back to Windows enumeration."""
+    enum_file = game_dir / "D3DEnum.txt"
+    if enum_file.is_file():
+        adapters = d3denum.parse(enum_file.read_text(errors="replace"))
+        if adapters:
+            return adapters, "D3DEnum.txt"
+    from . import displays  # imported lazily; Windows-only
+    return displays.enumerate_adapters(), "Windows display enumeration"
+
+
+def build_plan(game_dir: Path, width: int = DEFAULT_WIDTH,
+               height: int = DEFAULT_HEIGHT, windowed: bool = False,
+               with_music: bool = False) -> Plan:
+    """Work out what to do without changing anything."""
+    adapters, source = read_adapters(game_dir)
+    index = d3denum.choose_adapter(adapters, width, height, TARGET_BPP)
+    if index is None:
+        # Retry ignoring colour depth: some sources record modes without bpp.
+        index = d3denum.choose_adapter(adapters, width, height)
+
+    description = ""
+    for adapter in adapters:
+        if adapter.index == index:
+            description = adapter.description
+            break
+
+    config_path = game_dir / "config.cfg"
+    config = gameconfig.default_config(index if index is not None else 0,
+                                       width, height, windowed, with_music)
+    return Plan(
+        game_dir=game_dir,
+        game_version=game_version(game_dir),
+        writable=is_writable(game_dir),
+        adapter=index,
+        adapter_source=source,
+        adapter_description=description,
+        width=width,
+        height=height,
+        windowed=windowed,
+        config_path=config_path,
+        config_exists=config_path.is_file(),
+        rendered=config.render(),
+        music=with_music,
+        shim_source=music.bundled_shim() if with_music else None,
+        shim_target=game_dir / music.SHIM_NAME,
+        reader_available=music.reader_available() if with_music else True,
+        run_as_admin=music.run_as_admin_flagged(game_dir / "mc.exe") if with_music else False,
+        tool_elevated=music.is_elevated() if with_music else False,
+    )
+
+
+def install_music(plan: Plan) -> None:
+    """Copy the shim into the game directory and register it for this user.
+
+    The copy lives next to mc.exe rather than inside the Python package so
+    the registration survives the package being upgraded, moved, or run from
+    a temporary environment.
+    """
+    if plan.music_problems:
+        raise FixError("\n".join(plan.music_problems))
+    assert plan.shim_source is not None and plan.shim_target is not None
+    try:
+        if not (plan.shim_target.is_file()
+                and plan.shim_target.read_bytes() == plan.shim_source.read_bytes()):
+            shutil.copy2(plan.shim_source, plan.shim_target)
+    except OSError as error:
+        raise FixError("Could not copy %s into the game directory (%s). "
+                       "Close the game if it is running, then retry."
+                       % (music.SHIM_NAME, error))
+    try:
+        music.register(plan.shim_target)
+    except OSError as error:
+        raise FixError("Could not register %s for this user (%s)."
+                       % (music.SHIM_NAME, error))
+
+
+def apply(plan: Plan) -> Path | None:
+    """Write config.cfg, backing up any existing file. Returns the backup path.
+
+    With music requested, the shim is installed and registered first, so a
+    failure there leaves the previous config (and its ``music 1``) in place.
+    """
+    if not plan.writable:
+        raise FixError(
+            "The game directory is not writable by this account.\n"
+            "Run this once in an elevated PowerShell, then try again:\n\n    "
+            + grant_command(plan.game_dir))
+    if plan.adapter is None:
+        raise FixError(
+            "No display adapter offers %dx%d. Every adapter reported only other "
+            "modes — a rotated display can do this. Pick a resolution the "
+            "adapter lists (see `adapters`), rotate a display to landscape, or "
+            "attach one that supports the mode."
+            % (plan.width, plan.height))
+    if plan.music:
+        install_music(plan)
+
+    backup = None
+    if plan.config_exists:
+        stamp = datetime.now().strftime("%Y%m%d-%H%M%S")
+        backup = plan.config_path.with_suffix(".cfg.%s.bak" % stamp)
+        shutil.copy2(plan.config_path, backup)
+
+    plan.config_path.write_bytes(plan.rendered.encode("ascii"))
+    return backup
+
+
+def describe(plan: Plan) -> str:
+    """A human-readable summary of the plan."""
+    lines = [
+        "Game directory : %s" % plan.game_dir,
+        "Game version   : %s" % plan.game_version,
+        "Writable       : %s" % ("yes" if plan.writable else "NO"),
+        "Resolution     : %dx%d %s" % (plan.width, plan.height,
+                                       "windowed" if plan.windowed else "fullscreen"),
+        "Adapter source : %s" % plan.adapter_source,
+    ]
+    if plan.adapter is None:
+        lines.append("Adapter        : none supports %dx%d" % (plan.width, plan.height))
+    else:
+        lines.append("Adapter        : %d%s"
+                     % (plan.adapter,
+                        (" (%s)" % plan.adapter_description)
+                        if plan.adapter_description else ""))
+    lines.append("config.cfg     : %s"
+                 % ("exists, will be backed up" if plan.config_exists else "new"))
+    if plan.music:
+        lines.append("Music          : restore (music 0; %s -> %s, registered "
+                     "per user)" % (music.SHIM_NAME, plan.shim_target))
+    else:
+        lines.append("Music          : off (music 1); add --music to restore it")
+    for problem in plan.music_problems:
+        lines.append("PROBLEM        : %s" % problem)
+    for warning in plan.warnings:
+        lines.append("WARNING        : %s" % warning)
+    lines.append("")
+    lines.append("config.cfg to write:")
+    lines += ["    " + line for line in plan.rendered.replace("\r\n", "\n").rstrip().split("\n")]
+    if not plan.writable:
+        lines += ["", "Run this once in an elevated PowerShell first:",
+                  "    " + grant_command(plan.game_dir)]
+    return "\n".join(lines)

mtrevival/gameconfig.py

@@ -0,0 +1,97 @@
+"""Read and write Monopoly Tycoon's ``config.cfg``.
+
+The file is a list of console commands, one per line, CRLF-terminated::
+
+    SysSetup api D3D
+    SysSetup device 1
+    SysSetup width 640
+
+Verified by reading the game's process memory after it parsed a file written by
+hand: the exact bytes appeared on the heap, and ``device`` changed which adapter
+``CreateDevice`` targeted.
+
+Not every key is honoured on every code path. ``device``, ``bitdepth 32``,
+``music``, ``width``, ``height`` and (on patch 1.2) ``Window`` were observed
+taking effect; the 1.0 key ``windowed`` and ``bitdepth 16`` were observed being
+ignored. Treat any other key as unproven until you watch it work.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+# Key spellings exactly as the game's own format strings write them. The 1.0
+# keys come first in the order 1.0 writes them; the patch 1.2 keys follow, in
+# the position verified running (``Window`` after ``music``). 1.0 ignores keys
+# it does not know.
+KEY_ORDER = ["api", "device", "width", "height", "bitdepth", "texbitdepth",
+             "windowed", "Texdetail", "sound", "music", "shware", "avail",
+             "Window", "Fog", "Halos", "Multitexture", "No3d", "NoMovie"]
+
+LINE_ENDING = "\r\n"
+COMMAND = "SysSetup"
+
+DEFAULT_WIDTH = 640
+DEFAULT_HEIGHT = 480
+
+
+@dataclass
+class Config:
+    """The SysSetup settings, preserving the order they should be written in."""
+
+    values: dict[str, str]
+
+    def __getitem__(self, key: str) -> str:
+        return self.values[key]
+
+    def get(self, key: str, default: str | None = None) -> str | None:
+        return self.values.get(key, default)
+
+    def set(self, key: str, value) -> None:
+        self.values[key] = str(value)
+
+    def render(self) -> str:
+        """Serialise back to the game's format, CRLF-terminated."""
+        known = [k for k in KEY_ORDER if k in self.values]
+        extra = [k for k in self.values if k not in KEY_ORDER]
+        lines = ["%s %s %s" % (COMMAND, k, self.values[k]) for k in known + extra]
+        return LINE_ENDING.join(lines) + LINE_ENDING
+
+
+def parse(text: str) -> Config:
+    """Parse ``config.cfg`` text. Unrecognised lines are ignored."""
+    values: dict[str, str] = {}
+    for raw in text.splitlines():
+        parts = raw.strip().split(None, 2)
+        if len(parts) == 3 and parts[0].lower() == COMMAND.lower():
+            values[parts[1]] = parts[2]
+    return Config(values)
+
+
+def default_config(device: int, width: int = DEFAULT_WIDTH,
+                   height: int = DEFAULT_HEIGHT, windowed: bool = False,
+                   music: bool = False) -> Config:
+    """The configuration verified to run the game on Windows 11.
+
+    ``music 1`` suppresses the WMA playback path, which crashes because the
+    Windows Media DirectShow source filter no longer ships with Windows.
+    ``music 0`` enables it, and is only safe once the wmsource-shim is
+    registered (see ``music.py``); 1280x720 windowed with ``music 0`` was
+    verified playing on patch 1.2.
+    ``bitdepth 32`` matches the format the game actually selects; the 16-bit
+    path asks for D3DFMT_R5G6B5, which modern drivers do not offer fullscreen.
+    ``Window 1`` is only written when asked for: it is a patch 1.2 key, and a
+    stock config should stay as close to what the game itself writes as it can.
+    """
+    values = {
+        "api": "D3D",
+        "device": str(device),
+        "width": str(width),
+        "height": str(height),
+        "bitdepth": "32",
+        "texbitdepth": "16",
+        "music": "0" if music else "1",
+    }
+    if windowed:
+        values["Window"] = "1"
+    return Config(values)

mtrevival/music.py

@@ -0,0 +1,142 @@
+"""Restore the WMA soundtrack.
+
+The game plays music through a DirectShow graph whose source filter is the
+2001 "Windows Media Source Filter", CLSID ``{6B6D0800-...}`` from
+``dxmasf.dll``. Modern Windows ships neither that class nor a registration
+for it, so the game's ``CoCreateInstance`` fails and, with music enabled, the
+game dereferences the null result. ``SysSetup music 1`` only avoids the path.
+
+``wmsource-shim.dll`` (source in ``tools/wmsource-shim``) answers that CLSID
+by aggregating the filter that replaced it, the WM ASF Reader, and adapting
+the two things the game needs: a fresh reader per ``Load`` (the reader refuses
+a second one) and ``FindPin(L"Stream 1")`` mapped onto the reader's output
+pin. See ``docs/music.md``.
+
+Registration is per user, in the 32-bit view of ``HKCU\\Software\\Classes``
+(the game is a 32-bit process), so no elevation is needed and nothing outside
+the user's profile changes. An elevated process ignores per-user COM classes,
+so the game must not be run as administrator.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+LEGACY_CLSID = "{6B6D0800-9ADA-11D0-A520-00A0D10129C0}"
+ASF_READER_CLSID = "{187463A0-5BB7-11D3-ACBE-0080C75E246E}"
+SHIM_NAME = "wmsource-shim.dll"
+CLASSES = r"Software\Classes"
+DESCRIPTION = "Windows Media Source Filter (mtrevival wmsource-shim)"
+LAYERS = r"Software\Microsoft\Windows NT\CurrentVersion\AppCompatFlags\Layers"
+
+
+def bundled_shim() -> Path | None:
+    """The shim DLL shipped inside this package, or None if it was not built."""
+    path = Path(__file__).with_name("bin") / SHIM_NAME
+    return path if path.is_file() else None
+
+
+def _winreg():
+    try:
+        import winreg
+    except ImportError:  # not Windows
+        return None
+    return winreg
+
+
+def _read_value(hive_name: str, subkey: str, name: str,
+                view_32bit: bool = True) -> str | None:
+    winreg = _winreg()
+    if winreg is None:
+        return None
+    access = winreg.KEY_READ | (winreg.KEY_WOW64_32KEY if view_32bit
+                                else winreg.KEY_WOW64_64KEY)
+    try:
+        with winreg.OpenKey(getattr(winreg, hive_name), subkey, 0, access) as key:
+            value, _ = winreg.QueryValueEx(key, name)
+    except OSError:
+        return None
+    return str(value)
+
+
+def reader_available() -> bool:
+    """True if the WM ASF Reader is registered for 32-bit processes.
+
+    It is part of Windows Media, which N editions lack until the Media
+    Feature Pack is installed. Without it the shim cannot play anything.
+    """
+    subkey = r"%s\CLSID\%s\InprocServer32" % (CLASSES, ASF_READER_CLSID)
+    return _read_value("HKEY_LOCAL_MACHINE", subkey, "") is not None
+
+
+def registered_server(classes: str = CLASSES) -> str | None:
+    """Path of the DLL currently registered for the legacy CLSID, per user."""
+    subkey = r"%s\CLSID\%s\InprocServer32" % (classes, LEGACY_CLSID)
+    return _read_value("HKEY_CURRENT_USER", subkey, "")
+
+
+def register(dll: Path, classes: str = CLASSES) -> None:
+    """Register ``dll`` as the in-process server for the legacy CLSID, per user."""
+    winreg = _winreg()
+    if winreg is None:
+        raise OSError("COM registration needs Windows")
+    access = winreg.KEY_WRITE | winreg.KEY_WOW64_32KEY
+    clsid = r"%s\CLSID\%s" % (classes, LEGACY_CLSID)
+    with winreg.CreateKeyEx(winreg.HKEY_CURRENT_USER, clsid, 0, access) as key:
+        winreg.SetValueEx(key, "", 0, winreg.REG_SZ, DESCRIPTION)
+        with winreg.CreateKeyEx(key, "InprocServer32", 0, access) as server:
+            winreg.SetValueEx(server, "", 0, winreg.REG_SZ, str(dll))
+            winreg.SetValueEx(server, "ThreadingModel", 0, winreg.REG_SZ, "Both")
+
+
+def unregister(classes: str = CLASSES) -> bool:
+    """Remove the per-user registration. Returns True if there was one.
+
+    Only the two keys ``register`` creates are deleted. If something else
+    added subkeys under the CLSID, that key is left in place rather than
+    torn down blindly, and the InprocServer32 removal alone already unhooks
+    the class.
+    """
+    winreg = _winreg()
+    if winreg is None:
+        return False
+    access = winreg.KEY_WRITE | winreg.KEY_WOW64_32KEY
+    clsid = r"%s\CLSID\%s" % (classes, LEGACY_CLSID)
+    removed = False
+    for subkey in (clsid + r"\InprocServer32", clsid):
+        try:
+            winreg.DeleteKeyEx(winreg.HKEY_CURRENT_USER, subkey, access, 0)
+            removed = True
+        except FileNotFoundError:
+            pass
+        except PermissionError:  # key has other subkeys; leave it
+            break
+    return removed
+
+
+def run_as_admin_flagged(exe: Path) -> bool:
+    """True if Windows is set to run ``exe`` elevated (compatibility tab).
+
+    Elevated processes do not see per-user COM registrations, so the shim
+    would be invisible to the game and music would crash it again. The
+    Layers key is read in the 64-bit view so a 32-bit Python sees the same
+    machine-wide entry the shell wrote.
+    """
+    for hive in ("HKEY_CURRENT_USER", "HKEY_LOCAL_MACHINE"):
+        value = _read_value(hive, LAYERS, str(exe), view_32bit=False)
+        if value and "RUNASADMIN" in value.upper():
+            return True
+    return False
+
+
+def is_elevated() -> bool:
+    """True if this process runs with an elevated token.
+
+    Registration goes into the running account's HKCU. From a shell elevated
+    as a different account it would land in the wrong hive.
+    """
+    try:
+        import ctypes
+        return bool(ctypes.windll.shell32.IsUserAnAdmin())
+    except (AttributeError, OSError):
+        return False

mtrevival-0.3.1.dist-info/METADATA

@@ -0,0 +1,235 @@
+Metadata-Version: 2.4
+Name: mtrevival
+Version: 0.3.1
+Summary: Make Monopoly Tycoon (2001) run on modern Windows
+Author: Nasser Albusaidi
+License: MIT
+Project-URL: Homepage, https://github.com/NasserAlbusaidi/monopoly-tycoon-revival
+Project-URL: Issues, https://github.com/NasserAlbusaidi/monopoly-tycoon-revival/issues
+Project-URL: Changelog, https://github.com/NasserAlbusaidi/monopoly-tycoon-revival/blob/main/CHANGELOG.md
+Keywords: monopoly-tycoon,game-preservation,windows,directshow
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Games/Entertainment
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# Monopoly Tycoon Revival
+
+Make **Monopoly Tycoon** (2001, Deep Red Games / Infogrames) install and run on
+Windows 10 and 11.
+
+The game installs fine on modern Windows and then crashes on startup — usually
+right after the studio logo, sometimes before anything appears. There are two
+separate causes, both fixable in about a minute. No patched executable, no
+compatibility mode. The soundtrack needs one small COM shim registered for
+your user account; everything else is a text file.
+
+**This repository contains no game content.** You need your own copy of the game.
+
+---
+
+## Quick fix, by hand
+
+### 1. Let the game write to its own folder
+
+The game stores settings, profiles and savegames next to `mc.exe`. Under
+`C:\Program Files (x86)` a standard user account cannot write there, so the game
+silently fails to save anything — including the settings that fix the crash.
+
+Run once in an **elevated** PowerShell:
+
+```powershell
+icacls "C:\Program Files (x86)\Infogrames\Monopoly Tycoon" /grant "$($env:USERNAME):(OI)(CI)M" /T
+```
+
+### 2. Create `config.cfg`
+
+In the game folder, create a file named `config.cfg`:
+
+```
+SysSetup api D3D
+SysSetup device 1
+SysSetup width 640
+SysSetup height 480
+SysSetup bitdepth 32
+SysSetup texbitdepth 16
+SysSetup music 1
+```
+
+**`device` is the display adapter index and is specific to your machine.** Use
+`0` if your primary display is a normal landscape monitor. Use `1` (or higher)
+if your primary display is rotated to portrait, or does not offer a 640×480
+mode. The tool below works this out for you.
+
+`music 1` means music **off**. That is the safe setting without the shim
+described under [Music](#music); the game runs, silently.
+
+That is the whole fix. Launch `mc.exe`.
+
+---
+
+## Working it out automatically
+
+Requires Python 3.12 or newer. Standard library only.
+
+```
+py -m pip install mtrevival        # or: pipx install mtrevival
+mtrevival adapters                 # list adapters, show which support 640x480
+mtrevival check                    # show what would be written, change nothing
+mtrevival fix                      # write config.cfg, backing up any existing one
+
+mtrevival fix --resolution 1920x1080             # any mode the adapter lists
+mtrevival fix --resolution 1280x720 --windowed   # windowed needs patch 1.2
+mtrevival fix --music                            # restore the soundtrack
+```
+
+`py -m mtrevival …` works too. From a git checkout use `py -m pip install .`;
+the music shim then needs building (see `CONTRIBUTING.md`) or the DLL from a
+[release](https://github.com/NasserAlbusaidi/monopoly-tycoon-revival/releases).
+
+Example on a machine with a portrait primary display:
+
+```
+source: D3DEnum.txt
+  adapter 0  NVIDIA GeForce RTX 4080   modes=46   no 640x480  [portrait]
+  adapter 1  NVIDIA GeForce RTX 4080   modes=54   OK 640x480
+```
+
+`fix` never overwrites an existing `config.cfg` without copying it to a
+timestamped `.bak` first.
+
+### Music
+
+The game plays its WMA soundtrack through a DirectShow filter that Windows
+dropped years ago. `fix --music` copies `wmsource-shim.dll` (built from
+[`tools/wmsource-shim`](tools/wmsource-shim), source included) next to
+`mc.exe`, registers it **for your user only** — no elevation, nothing outside
+your profile — and writes `music 0`. The shim hands the game Windows' own
+WM ASF Reader with the two adaptations the game needs. Details, evidence and
+removal in [`docs/music.md`](docs/music.md).
+
+Do not run the game "as administrator" with music on: an elevated process
+cannot see per-user COM registrations. `fix --music` warns if that flag is set.
+
+---
+
+## What actually goes wrong
+
+Both crashes are the same defect: the game creates an object, never checks
+whether creation succeeded, and then dereferences the null pointer.
+
+### Crash 1 — access violation at `mc.exe+0x000E792E`
+
+Windows logs exception `0xC0000005`, fault offset `0x000E792E`, faulting module
+`mc.exe`. The instruction is:
+
+```asm
+004E78FE  call dword ptr [edx+0x3C]   ; IDirect3D8::CreateDevice  (vtable slot 15)
+004E7901  mov  eax, [ebp+0x44]        ; ...continues without checking the HRESULT
+004E792E  mov  ecx, [eax]             ; <-- faults, EAX = 0
+004E7932  call dword ptr [ecx+0xA0]   ; IDirect3DDevice8::SetViewport (slot 40)
+```
+
+The game requests **640×480 exclusive fullscreen** on adapter 0. Recovered
+`D3DPRESENT_PARAMETERS` from a crash dump:
+
+| Field | Value |
+|---|---|
+| BackBufferWidth / Height | 640 × 480 |
+| BackBufferFormat | 22 (`D3DFMT_X8R8G8B8`) |
+| Windowed | 0 — exclusive fullscreen |
+| returned device | **NULL** |
+
+For exclusive fullscreen, Direct3D 8 requires the width, height and format to
+match an enumerated display mode. If your primary display is rotated to
+portrait, its mode list contains `480 X 640` and **no** `640 X 480`.
+`CreateDevice` fails, and the unchecked null device is dereferenced by
+`SetViewport`.
+
+The game writes its own evidence to `D3DEnum.txt` in the install folder. Look for
+an adapter whose modes are all taller than they are wide — that is the culprit.
+
+**Fix:** point `SysSetup device` at an adapter that offers 640×480.
+
+### Crash 2 — access violation at `mc.exe+0x000A801B`
+
+```asm
+004A8007  call dword ptr [0x96E4E8]   ; MultiByteToWideChar -> filename
+004A800D  mov  eax, [ebx+0x2CE8]      ; media interface -> NULL
+004A801B  mov  edx, [eax]             ; <-- faults, EAX = 0
+004A801E  call dword ptr [edx+0xC]
+```
+
+The filename recovered from the dump is
+`gamedata\sound\music\music_intro.wma`. The game builds a DirectShow graph to
+play its WMA soundtrack and asks for the 2001 Windows Media DirectShow source
+filter by CLSID. Windows 11 keeps only a 5 KB stub of `dxmasf.dll` and no
+longer registers the class, so `CoCreateInstance` fails. `quartz.dll` and
+`devenum.dll` load; the Windows Media source does not. The interface comes
+back null and is used anyway.
+
+**Fix:** `SysSetup music 1` suppresses that path, and the game runs without
+its music. `fix --music` restores it: the filter the game asks for,
+`{6B6D0800-…}`, is answered by a shim that wraps Windows' WM ASF Reader,
+creating a fresh reader per track (the reader refuses a second `Load`) and
+mapping the game's `FindPin(L"Stream 1")` onto the reader's `Raw Audio 0`.
+The 2001 Windows Media redistributable on the CD is not touched. See
+[`docs/music.md`](docs/music.md).
+
+---
+
+## Compatibility notes
+
+- Tested on Windows 11 Pro (build 26200), NVIDIA RTX 4080, English CD.
+  Verified with game version 1.0 and again after applying the official patch
+  1.2 — the same `config.cfg` works for both. Verified on one machine only.
+- Patch 1.2 applies cleanly on Windows 11 when run **elevated**. It changes
+  `mc.exe`, three Lua scripts and the string tables, and leaves `config.cfg`
+  alone. Both crashes above are still present in the 1.2 executable. Details
+  in [`docs/patch-1.2.md`](docs/patch-1.2.md).
+- Resolution is free. `SysSetup width` / `height` accept any mode the chosen
+  adapter enumerates; 1920×1080 exclusive fullscreen and 1280×720 windowed
+  (`SysSetup Window 1`, patch 1.2 only) were verified running with a sane UI.
+  The 1.0 key `windowed` is ignored; 1.2 renamed it.
+- Music was verified on patch 1.2 (intro track by ear, all ten tracks and
+  repeated track changes in a DirectShow harness). It needs Windows Media,
+  which N editions get from the Media Feature Pack.
+- Patch 1.2 drops an empty `MTS.txt` in the game folder while it runs and
+  removes it on exit. If the game is killed, delete that file, or the next
+  launch offers Safe Mode and overwrites `config.cfg`.
+- GameSpy multiplayer is dead and out of scope.
+
+## Modding
+
+The game is unusually open for its age, and this is the reason the project
+exists. All verified:
+
+- **200 plain-text Lua scripts** in `scripts\`, across 56 namespaces —
+  `DEFAULT`, `MAPS`, `SCENARIO1`–`SCENARIO20`, `TUTORIAL1`–`TUTORIAL12`,
+  `NET0`–`NET8`. Economy tuning lives in `businesssettings.lua`,
+  `blocksettings.lua` and `commoditysettings.lua`.
+- **Saves are Lua too.** `profiles\<name>\settings.lua` contains
+  `g_ProfileOptions.BoardName = "gb"`, which selects among **19 national
+  boards** shipped on the disc (`usa`, `f`, `ger`, `aus`, `swe`, and more).
+- `parameters\*.prm` holds per-decade tuning, plus `aiparameter.prm` and
+  `consumer.prm`.
+- The shipped executable still contains debug flags (`AIDEBUG`, `DEBUGTEXT`,
+  `SHOWALLCARS`, `CHEATINGGIT`) and remnants of the developers' block and
+  building editors.
+
+See [`docs/phase-0-findings.md`](docs/phase-0-findings.md) for the full
+investigation, and
+[`docs/superpowers/specs/`](docs/superpowers/specs/) for the project design.
+
+## Licence
+
+MIT — see [LICENSE](LICENSE). This covers the tools and documentation in this
+repository only. Monopoly Tycoon itself is the property of its rights holders
+and is not distributed here.

mtrevival-0.3.1.dist-info/RECORD

@@ -0,0 +1,14 @@
+mtrevival/__init__.py,sha256=FxsriInuBdOk4p7tfnhG6mw1eqf4rMV2A53KNKjnwZY,75
+mtrevival/__main__.py,sha256=TzvOohn3m7sljHnZ7Ky9sKu2IQ7iZG81YQ7JdgLqxQQ,3611
+mtrevival/d3denum.py,sha256=9DTb-TgyhDpVa1boAiZLMsN1MVKtBRP6j3wN0Tg35aY,3791
+mtrevival/displays.py,sha256=3583xYnyRNsgdv0gE0lSa9vfoA2ODLLYIQxIUugetlc,4153
+mtrevival/fixpack.py,sha256=27au2V1WIEoBe2qwXE7CZU7GELuYgu0H65VfsvMmKi8,13226
+mtrevival/gameconfig.py,sha256=59g6gHwJaC-vcVwMOyKBh_bMZ65YfPrLNrxKbvO9sP4,3738
+mtrevival/music.py,sha256=kJT85-ZORQ_dzteazIkuP6JqUNq4ZJDEfU_jf4aH7so,5694
+mtrevival/bin/wmsource-shim.dll,sha256=kIFOZR7JrDwQ-8W0XeOSJMxMoI7uOyhLgzPIZyxtX2c,137728
+mtrevival-0.3.1.dist-info/licenses/LICENSE,sha256=ijmA-7hcYuMe431-THkzD_Yyv90qJdNAY-1OtRw6T3M,1094
+mtrevival-0.3.1.dist-info/METADATA,sha256=3ILFlQRWeo3QqX6EID8i-QRrTCox33faSWgpgNy6ZQ4,9966
+mtrevival-0.3.1.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+mtrevival-0.3.1.dist-info/entry_points.txt,sha256=iGJ7lmZzfq-eZI8anMRdIvsQTCHyUHKdVPSC8mPjSDE,54
+mtrevival-0.3.1.dist-info/top_level.txt,sha256=tkWpmmgpaXFN3k38a0F7K8Eu14QquEgd51xAAP7NNcA,10
+mtrevival-0.3.1.dist-info/RECORD,,

mtrevival-0.3.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

mtrevival-0.3.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+mtrevival = mtrevival.__main__:main

mtrevival-0.3.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Nasser Albusaidi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

mtrevival-0.3.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+mtrevival