SuperAPI AI Directory

game-modding

Coding & development

View repository

Updated 10-19 23:20

About this skill

Game modding

Build the change the user asked for, in the game they own, and prove it works where they will play it. Preserve the user's saves, settings, and install. Keep each mod in its own folder unless the project already has another layout.

Pin down the result

Restate the behaviour and quality bar before choosing a route. Past requests show what users usually mean. A request for a fix wanted the game itself to behave correctly, not a workaround. A resizable window should have scaled its content automatically, not exposed a manual zoom setting. "New weapons" meant new mechanics and effects, not recoloured existing items. Settings UI was expected to match the game's own art, fonts, and controls. A crash fix was expected to stay scoped to the mod, not change a global game setting. When a cheap tweak and real new behaviour both fit the words, build the real behaviour or explain what it costs.

Ask only when the answer changes the route, such as byte-identical versus working, which platforms, or public versus private release. When a goal is large, such as rebuilding a whole game, offer the smallest milestone that proves progress, such as reaching the main menu, and agree what will demonstrate it.

Keep a MODLOG.md beside the mod. Record the game build and file hashes, the route and why, hook sites with their original bytes, IDs, formats, failures with causes, backups, restore steps, and what was verified and how. It survives context compaction and becomes the README and handoff.

Start from the installed game

Work from the user's install, ROM, or dump, not from devblogs, wikis, or memory. Record the store, app ID, exact build, and executable hashes. Identify the engine and code type from the files; treat detector output, folder names, and extensions as hints and check the deciding fact. Routes and engines lists the tells and community routes for common engines, plus Linux and Proton specifics.

Check for anti-cheat, online modes, DRM, existing loaders, and earlier modifications. If the executable is already cracked or patched, such as a no-CD build, tell the user and keep the original behaviour as the reference. Locate saves, configs, logs, and crash dumps.

Before reversing anything, look for prior art and free information: the game's modding wiki, Nexus, Thunderstore, mod.io, Steam Workshop, GitHub decompilations and loaders, and field notes such as the universal-modder knowledge base. Check loaders' current releases and install steps on their official pages. Also look for shipped linker maps, debug builds, symbol files, script sources, or data files that are real engine output. Treat other people's notes as leads to re-verify; versions move.

When the change needs game internals, use reverse-engineering. Read the actual code and data rather than guessing.

Choose the route

Take the first route that reaches the requested behaviour: official tools or data files, an existing community loader's API, managed patching, native hooks, a ROM or assembly patch, then reimplementation. Choosing a lighter route never justifies a lighter result. Check what the executable enforces as well as what the data allows. In Age of Empires II, the data accepts a new civilisation, but the civilisation picker lists only a table hard-coded in the executable. Record the choice and the reason in MODLOG.md.

Work in a lab

Before the first modded launch, back up saves, configs, and any cloud-synced copies. Steam Cloud can sync test settings back after a local restore, so back up userdata/<id>/<appid>/remote/ as well. Use the game's save-protection or test options where they exist.

Develop and test on a copy of the game folder, and of the Wine prefix when relevant. Patch or install into the real game only after the copy works, with a byte-checked backup and a one-command restore. Keep decompiles, dumps, and extracted assets outside the mod repo. Ask before changes outside the lab, such as registry edits, display settings, Steam launch options, or system packages. Prefer user-level installs and tell the user what was added. Don't edit Steam's own config while Steam is running.

Build a slice, then widen

Take one item, mechanic, or fix all the way through to working in game before building the rest. Check bytes before patching and refuse unknown builds. Keep hooks small. Put new features behind a switch until a live check passes. Commit each working step.

For new content, study the game's own assets first: size, palette, outline, camera, frame layout, and UI style. Use game-development-asset-generation for art and sound, and research-backed-frontend-development for menus and settings screens.

Verify where the user plays

The running game is the oracle; your reading of its code is not. Lab and verification covers driving games headlessly, input under Wayland, screenshots, logs, crash dumps, and harnesses.

  • Reproduce the user's environment. Match OS, Proton or Wine version, display server, resolution, fractional scale, refresh rate, and window mode. One test at 100% scale on Xvfb missed every bug the user hit at 170% on Wayland.
  • Test every path you claim. Include transitions such as switching between fullscreen and windowed, upgrading from the previous version with existing settings, and uninstall or restore.
  • Run a vanilla control. Reproduce problems on the unmodded game before blaming or changing the mod. One crash blamed on a mod also happened in vanilla. Change one thing at a time and bisect.
  • Measure the effect, not the setting. Measure actual frame cadence, not the frame-limit value read back. Pixel-diff each graphics option, and remove options that change nothing. Compare the mod's frame-time cost with vanilla.
  • Use bridges to reach states quickly. A dev-gated command file in the mod, the engine's console or config scripts, an emulator core driven from code, or a test save can set up a scene. Still drive each user-facing path through real input at least once.
  • Inspect screenshots, recordings, and logs yourself. Show the user embedded evidence at paths without spaces.
  • Stop after three identical failures, then write down what is known and change approach.

Installed, loaded, running, and working are separate claims. Report what was verified in game, what was only built or stub-tested, and what remains untested. Never claim a path works because it compiles.

Ship

Read shipping before committing, publishing, or writing install steps. Ship code, patches, installers, and original assets; never ship game files, ROMs, extracted assets, decompiled source, or keys. Default to a private repository and ask before anything public. Follow commit-authorship and the project's branch conventions.

Limits

  • Mod only games the user owns, from their own install or dumps. Never download ROMs, ISOs, game files, leaked source, or cracked tools.
  • Stay in single-player, offline, or on servers the user controls. Never inject into clients protected by anti-cheat. Never write cheats against other players. Never bypass anti-cheat, DRM, or ownership checks; an official offline mode is fine.
  • Kill processes by exact PID or pgrep -x. Patterns in pkill -f and pgrep -f matched the agent's own shell in several sessions. Scope wineserver -k to a lab prefix with WINEPREFIX.
  • Work in a temp directory you created. Never delete by broad globs in shared locations such as /tmp.
  • Don't send input to the user's live desktop or their windows without asking. Never focus a game with an online mode while the user may be typing.