emulators.scummvm.Scummvm

Registry key, scummvm.

Human-readable name shown in the UI.

ScummVM's data directory, which the save subtree hangs off.

saves, holding the game's saves and the working slot alike.

Empty, because states are not in a subtree of their own.

On; activate empties the save directory.

True, over the Global Main Menu.

The one slot the broker works in, echoed back as the effective slot.

Where ScummVM writes every save.

The ScummVM output the broker exposes.

Seconds SIGTERM gets, which ScummVM spends flushing its config.

What resolve_rom_file picked: the folder launch registers, or an archive it extracts first.

The target the running game booted under, and every save is named after.

Kept after the process stops: the state routes are read once the game is already gone, and they have no other way to name its files.

Bumped per launch, so a deferred resume can tell it has been superseded.

The .scummvm marker file some libraries use; a game is a folder.

Start with no game folder, no target, and no launch behind it.

Resolve a RomM path to the game folder to register, or the archive to extract.

Kept cheap: the detection pass that can actually answer "is there a game in here" takes seconds, and extracting an archive can take longer, so both run in launch. A folder that holds files is accepted here and only a folder ScummVM detects nothing in fails, later, as a launch failure.

Accept an archived game for launch to extract.

Run one xdotool command against the session display.

The X window this launch's ScummVM renders into.

Matched on this process's own pid, so a window left behind by an earlier session cannot swallow the macro. The last id wins: xdotool lists in creation order and ScummVM's game window is created after the transient ones.

Give win_id the input focus before keys are sent at it.

The menu key and the button hotkey go through XTEST, which delivers to whatever holds focus, so a key sent at an unfocused game lands on the desktop instead.

Open the Global Main Menu with the pinned menu key.

One unmodified key, bound to the global keymap in the ini before the launch: see MENU_KEY for why neither ScummVM's own C+F5 nor the engine-level F5 can be relied on here.

Type text into the focused window.

type rather than key: the GMM's button hotkeys follow the GUI translation and can be Cyrillic, Greek or Hebrew, and only type synthesizes the keysym whatever the X keyboard layout is.

Send several keys to win_id in one xdotool call.

One call rather than one per key: each costs a process spawn, and the chooser walk sends one key per slot.

Poll the working slot until this save's write settles, or deadline passes.

The first change is not the finished save. The caller stops ScummVM as soon as this returns and the broker zips the save directory right after, so returning on the first differing stat sends SIGTERM into a write still in progress and ships whatever landed to RomM as the player's progress. A write therefore only counts once the slot differs from before, holds at least one non-empty file, and has held every size and mtime still for STATE_STABLE.

Register the game, pin the ini, and boot ScummVM on its target.

The folder is registered with --add and the target read back out of the ini; a folder ScummVM detects nothing in is a launch failure, since there is nothing to boot. With resume_slot set and the working slot already holding this target's save, the state loads at boot through --save-slot; otherwise a deferred thread waits for RomM's push and loads it over the menu.

An archived game is extracted into the cache first (or its earlier extraction reused), and the game folder inside it is what gets registered.

Raises

• RuntimeError: When no ROM folder was resolved, an archive could not be extracted, or ScummVM detects no game in it.
• RegisteredElsewhere: When another copy of the game holds its target.

Keep the game window the size of the display, for as long as it runs.

Resizing once at launch is not enough: the display is sized by the streaming client, so a game that starts before a browser has connected is grown to whatever the last session left behind and then sits in the top left corner of a screen that changed under it. The same happens mid-session when a viewer resizes their browser. So this follows the display instead of photographing it, and exits when the launch is superseded or the game is gone.

Purely cosmetic, so every failure is logged and swallowed: a game running at its own size is worth more than a launch reported as broken.

The display's current size as a (width, height) pair of digits.

Wait for a pushed state to arrive, then load it through the menu.

Gives the file RESUME_LOAD_WAIT to turn up and then the game RESUME_LOAD_SETTLE to be far enough into its startup to answer the menu. Abandons itself as soon as seq no longer matches the current launch, so a superseded launch never gets a stray load.

Save the running game into the broker's slot through the GMM.

slot is what RomM asked for and is ignored: the save lands in STATE_SLOT and the caller reads the effective slot back off state_slot. The chooser opens with its list focused and nothing selected, so the first Down lands on slot 0 and slot N needs N+1 of them; the list index is the slot number because empty slots still take a row. In save mode the first Return starts editing the slot's description and the second commits it, which is also the save.

Load the broker's slot into the running game through the GMM.

In load mode the list is not editable, so a single Return activates the selected slot and the GMM closes itself.

The working slot's save file for the booted target, or None when empty.

Empty the save directory before a new session boots.

The target only exists once a game has been registered and booted, so at activate time a leftover cannot be told apart from the save of the game about to start. Anything still here belongs to a session that has already exited and whose saves RomM holds; the incoming archive restores whatever should be here.

The whole directory goes, not just the broker's slot. ScummVM names a save <target>.<NNN> for the slot the player chose in the game's own menu, and nothing in that name says whose session wrote it, so clearing only the broker's slot leaves every save the last player made from inside the game readable by this one and swept into their dump.

Where a pushed state called filename belongs.

The name is rewritten onto the booted target and the broker's slot: ScummVM finds a save by name alone, so a state captured under another target (a multilingual folder registers one per language) has to be renamed or the engine will not see it. The suffix form the state arrived in is kept, since which of the two an engine writes is the engine's business.

Classify an archive member for the manifest.

ScummVM has no state format of its own, so the working slot's file is a save like every other and only its name says otherwise. Naming the target as well as the slot is what keeps another game's save in the same slot from being filed as this session's state.

Declare what ScummVM takes: save files, and one of them as the state.

Saves and states share saves/, so the two kinds have the same shapes. The state rides the archive and resumes through save.resume_slot, which boots the game with --save-slot.

Place one declared member: a save, or the state.

Refuse a state that shares the working slot with a save the archive carries.

check_plan counts the archive's own states by save_file_kind, which answers save for everything until a game has booted. So a v1 save in the working slot under the target's name goes uncounted there, and would be restored on top of the state, or beside it under the other spelling.

Read the target the folder is registered under, for the session's identity.

Look up the target registered for rom, without registering it.

Only a lookup: a launch that ran no preflight reads this in a worker thread, and registering can take up to two minutes. The identity is informational, so an unregistered folder reads as no identity.

Save through the menu if asked, then stop ScummVM.