emulators.dolphin.Dolphin

RomM platform key, dolphin.

On; with the ROM cache enabled, launch boots a local copy of the ROM.

Human-readable name shown in the UI.

On; activate empties the save subtrees this session owns.

Dolphin's user directory, which the save subtrees hang off.

StateSaves, GC and Wii, the directories the save archive carries.

Bootable disc formats, best first.

True, states are saved over the hotkey and loaded at boot or by hotkey.

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

Where Dolphin writes .sNN files.

The Dolphin log the broker exposes.

GC on a GameCube session, None on any other.

Set up the process state and the launch sequence counter that fences deferred loads.

The whole GC/ tree, or None for Wii (NAND, no physical card).

Returns the tree rather than one region's Card A folder: Dolphin buckets a GCI folder card by the disc's region (GC/<region>/Card A), and a library can mix regions, so syncing has to carry all of them rather than guessing one.

Move each GCI of a pushed card into <region>/Card A, the only place the folder card reads.

Players pack a card however their own Dolphin keeps it: loose GCIs, a bare Card A folder, or the whole GC folder with its name on top. All of those used to land a level off and boot to an empty card. A wrapper such as GC/ is dropped, and a misplaced GCI goes to the region its game code names. The extension is matched without regard to case, as Dolphin's own folder scan does.

Every member may always stay at the name it was packed under, so a move is taken only when its destination is free of every other member, packed or moved, and a member losing out stays put. Two members can then never land on one file, which matters because anything refused here aborts RomM's claim and locks the player out of the game rather than starting it on an empty card. A GCI or card image left where Dolphin will not read it is logged and reported back.

Resolve a RomM path to the disc image to boot.

A file is taken as is. A directory is searched one level deep for the best candidate by _pick_rom_file.

Run one xdotool command against the session display.

Find the window this launch's Dolphin renders the game into.

Picked by title rather than by taking the first match, because the main window and any dialog carry the same class, and a hotkey sent at either of those does nothing. Then confirmed by pid: a window left behind by the previous emulator process carries the same class and the same kind of title, and would swallow the save hotkey for a session that has already moved on.

Focus the render window and send key through XTEST.

Activating first is what makes this survive the player clicking back into the page: XTEST delivers to whatever holds focus, so a key sent at an unfocused Dolphin goes to the desktop instead.

Stop any running instance, seed the pad bindings, and start dolphin-emu.

The binary comes from env DOLPHIN_BIN (default dolphin-emu). With resume_slot set and the working slot holding a state for this disc, the state is loaded at boot with -s; with the slot empty or holding another game's state, a deferred thread waits for RomM's push and loads it over the hotkey.

Wait for a pushed state to arrive, then load it over the hotkey.

Gives the file RESUME_LOAD_WAIT to appear, then RESUME_LOAD_SETTLE for the window to be ready. The state has to belong to the ROM that booted, the same test the -s resume makes, since this path also runs for a launch whose slot held another game's state. Abandons itself whenever seq no longer matches the current launch, so a superseded launch never gets a stray load.

Save a state into the broker's slot over the hotkey and wait for it to land.

slot is what RomM asked for and is ignored: this saves into STATE_SLOT and the caller reads the effective slot back off state_slot.

Load the broker's slot over the hotkey and confirm Dolphin read the state back.

The hotkey is silent on an empty slot, so an absent file has to be caught here or the caller reads a no-op as success. A hotkey that was sent is no proof either: Dolphin drops one that lands before the core is running and says nothing about it, so the state's access time is backdated first and the load only counts once a read has moved it. Where that read leaves no trace, on a noatime mount or when the marker could not be stamped, the undo buffer Dolphin rewrites as part of a load is what confirms it; an unconfirmable load is reported as a failure rather than taken on trust, since the caller would otherwise hand the player a session still sitting where it was. The deserialize the load starts is unobservable, and LOAD_SETTLE covers it rather than handing the caller a session mid-restore.

Return the newest state file in the broker's slot, or None when it holds nothing.

Empty the save subtrees this session owns before the archive restore.

A state is named for the game it was taken from, and the game id only comes off the running disc, so a leftover cannot be told apart from the state of the game about to boot. Anything still here belongs to a session that has already exited and whose states RomM holds.

The GC cards and the Wii NAND go the same way, and for a stronger reason: they are the player's actual progress, nothing in a .gci or a NAND title directory names whose session wrote it, and the restore only writes the members the incoming archive carries. A card or a NAND save the last player left would otherwise be readable by this one and ship back out in their dump.

Map a pushed state's filename to where it may be written.

With the slot already holding a state, a pushed name has to match it; otherwise the game id is taken on trust, bounded to a <game>.s<slot> basename in the state dir.

The push route also holds the state's header to the session's game, through check_state_bytes.

Declare what Dolphin takes: GCIs on GameCube, NAND title saves on Wii, and one state.

The platform picks the spec, as it does memory_card_subtree; any other platform takes nothing. A GCI is taken as a save or a memcard: players think of one as a save. The state rides the archive and resumes through save.resume_slot.

Place one declared member: a state in the slot, a Wii save in the NAND, a GCI in its card.

Refuse an imported GCI when the archive already carries a GameCube card.

A folder card holds every title's saves, and an archive carries one card: its own GC members, or imported GCIs, never both. RomM is to strip the archived card, and warn the player, before it sends a replacement.

A GCI that clashes with another member is left to the shared one-member-per-destination check, which has already refused it, so it is not refused twice.

Refuse a pushed state whose header names another game than the session's.

A Dolphin state opens with the game id of the disc it was taken from. A header with no id, or a session with none, is taken on trust.

Read the session's game id off the disc, or take RomM's when the format hides it.

Delete the undo-load-state buffer before the save archive is built.

Dolphin rewrites this on every state load, so it lands in the dump as a second full-size copy of a state RomM is already storing, for the sake of an undo hotkey a streaming session has no way to press. A failure to remove it is logged, not raised.

Save a state if asked, stop the emulator, and clear what the archive must not carry.

The undo buffer and any stranded access-time probe both live in the state directory the exit archive is built from, and neither is save data, so both go before the dump runs.

Invalidate any in-flight deferred state load before the kill.