u/itsk2049

My Batocera arcade cabinet in our living room runs attract mode when unoccupied. To blend with our holiday decor, I created seasonal game lists that for it, similar to Plex’s seasonal collections.

I surface two seasonal pools into EmulationStation on the right dates and hide them when the season ended using a custom shell scripts.

Fall: The Halloween pool goes visible from Sep 15 to Oct 31, featuring 52 games across 13 systems. It includes lesser Castlevania ports, Friday the 13th NES, Splatterhouse, Bram Stoker’s Dracula, Frankenstein and Dracula shovelware, Zombies Ate My Neighbors, A Nightmare on Elm Street, Nosferatu SNES, Werewolf: The Last Warrior, and more.

Winter: The Christmas pool comes up from Nov 1 to Jan 1, featuring 23 games. It includes every Home Alone variant (NES, SNES, GB, MD, GG), Christmas NiGHTS into Dreams, Daze Before Christmas, Elf Bowling 1+2, and Santa Claus Saves The Earth.

Jan 2 through Sep 14, both pools are hidden, and the cabinet returns to its curated baseline.

The total install is a Python script, a shell script, two text files of ROM paths, and a 10-line append to custom.sh. Lists are easy to extend. Adding a 4th of July or Thanksgiving pool is cp halloween.txt thanksgiving.txt, edit, and add a row to the date map.

#!/bin/sh
# Output: off | halloween | christmas

MM=$(date +%m); MM=${MM#0}
DD=$(date +%d); DD=${DD#0}
KEY=$((MM * 100 + DD))

# Halloween: 9/15 (915) through 10/31 (1031)
if [ "$KEY" -ge 915 ] && [ "$KEY" -le 1031 ]; then
    echo halloween; exit 0
fi

# Christmas: 11/1 through 12/31, plus 1/1
if [ "$KEY" -ge 1101 ] || [ "$KEY" -eq 101 ]; then
    echo christmas; exit 0
fi

echo off

The flipper edits hidden flags in each affected system’s gamelist.xml, taking one of the three states. It’s idempotent, atomic, and only kills ES when actual diffs occur. Re-running with the same state is a no-op.

import os, re, subprocess
from pathlib import Path

ROMS = Path("/userdata/roms")
GAME_BLOCK_RE = re.compile(r"(<game\b[^>]*>)(.*?)(</game>)", re.S)
PATH_RE = re.compile(r"<path>([^<]+)</path>")
HIDDEN_RE = re.compile(r"<hidden>(true|false)</hidden>")

def patch_block(inner: str, want_hidden: bool) -> tuple[str, bool]:
    target = "true" if want_hidden else "false"
    m = HIDDEN_RE.search(inner)
    if m:
        if m.group(1) == target:
            return inner, False
        return inner[:m.start()] + f"<hidden>{target}</hidden>" + inner[m.end():], True
    if not want_hidden:
        return inner, False  # absent == visible (default)
    stripped = inner.rstrip()
    return stripped + f"\n\t\t<hidden>{target}</hidden>" + inner[len(stripped):], True

# active = paths in the target season's list
# inactive = paths in any OTHER season's list
# games not on either list are untouched (byte-identical)
def apply(system: str, target: str, lists: dict[str, set[str]]) -> int:
    gl = ROMS / system / "gamelist.xml"
    text = gl.read_text(encoding="utf-8")
    active = lists.get(target, set())
    inactive = {p for k, v in lists.items() for p in v if k != target}
    out, last, changes = [], 0, 0
    for m in GAME_BLOCK_RE.finditer(text):
        out.append(text[last:m.start()])
        open_t, inner, close_t = m.group(1), m.group(2), m.group(3)
        pm = PATH_RE.search(inner)
        if pm:
            rom = f"{system}/{pm.group(1).lstrip('./')}"
            if rom in active:
                inner, changed = patch_block(inner, want_hidden=False)
                changes += int(changed)
            elif rom in inactive:
                inner, changed = patch_block(inner, want_hidden=True)
                changes += int(changed)
        out.append(open_t + inner + close_t)
        last = m.end()
    out.append(text[last:])
    new_text = "".join(out)
    if new_text != text:
        tmp = gl.with_suffix(gl.suffix + ".tmp")
        with tmp.open("w") as f:
            f.write(new_text); f.flush(); os.fsync(f.fileno())
        tmp.replace(gl)
    return changes

# ...after editing every system's gamelist...
def sigkill_es():
    pids = subprocess.run(["pgrep", "-f", "^emulationstation "],
                          capture_output=True, text=True).stdout.split()
    for pid in pids:
        subprocess.run(["kill", "-9", pid])
    # emulationstation-standalone wrapper respawns ES

Loop in custom.sh calls the schedule script, compares to a state file, runs the flipper only when they diverge:

(
  while true; do
    DESIRED=$(/userdata/system/holiday-rotation/desired-state.sh)
    CURRENT=$(cat /userdata/system/holiday-rotation/state 2>/dev/null || echo "")
    if [ "$DESIRED" != "$CURRENT" ]; then
      /userdata/system/holiday-rotation/flip.py "$DESIRED" \
        >> /userdata/system/logs/holiday-rotation.log 2>&1
    fi
    sleep 43200
  done
) &

Today the cabinet is at off, looks like its normal curated self. On Sep 15 the loop will see desired=halloween, current=off, run the flipper, and 52 Halloween games quietly join the visible library. Nov 1 flips to Christmas. Jan 2 back to baseline.