Openai/6952a1d0-7e3c-8003-a3f6-55806826a464

This conversation was exported from ChatGPT

gpt-5-2-thinking

User: i have a game i want to make a multiplayer mod for.

i have a game i want to make a multiplayer mod for. How can I go about doing this using AI tools?

Assistant: Making a multiplayer mod with AI tools is totally doable—but AI won’t magically solve the two hardest parts for you: re…

Making a multiplayer mod with AI tools is totally doable—but AI won’t magically solve the two hardest parts for you: reverse engineering and network architecture. What it can do is speed up the grind: code scaffolding, packet design, debugging, test bots, and documentation.

Here’s a solid, practical path (with AI baked in) that won’t waste your time.

Multiplayer mods usually fall into one of these:

Hard mode. You’re doing injection / scripting / reverse engineering. AI can help you understand your own findings, but it can’t safely or reliably replace expertise here—and some games’ EULAs make this a legal/ban risk.

If you’re in C and this is an always-online/competitive game: honestly, it’s usually a bad idea. You’ll fight anti-cheat, bans, and constant breakage.

Your goal is to learn:

• how the game simulates gameplay (tick rate, physics determinism, authoritative logic)
• what can be read/written via modding API or scripting
• how game state can be represented (entities, inventory, positions, events)

AI tool workflow that actually works:

• Feed the AI: the game’s modding docs, example mods, and any API reference you have.
• Ask it to generate: - a “state model” (what variables must sync) - a list of game events you should broadcast - a minimal multiplayer design document

If the game has existing mods: give AI those codebases and tell it to explain patterns and extension points.

You generally choose one:

- Server is the source of truth.

• Clients send inputs; server simulates and sends state updates.
• Harder to build, but way less cheating/desync.

- Easier to spin up (no dedicated server required)

• But syncing and cheating get messy fast.

- Everyone runs the same simulation; only inputs are shared.

• Great for RTS-style games if the sim is deterministic. Many modern games are not.

Where AI helps: Ask AI to design the message schema + predict desync issues + propose reconciliation strategies based on your game type (FPS, survival, RTS, etc.).

Don’t try to sync everything.

Your MVP should be:

• 2 players connect
• both appear in the same world
• movement sync works “okay”
• basic interactions (like picking up an item) sync reliably

Then expand: combat, inventory, AI enemies, world changes, etc.

AI can generate:

• packet/message definitions
• serializers/deserializers
• client/server boilerplate
• a test harness that replays recorded inputs

Two common approaches:

- Client sends: movement keys, actions, aim direction.

• Server simulates results.
• Server sends snapshots.

AI can help design:

• snapshot delta compression
• interpolation/extrapolation
• lag compensation strategies (basic ones)

- Client sends actual positions/state.

• Easier, but more desync/cheating.
• Good for prototypes or coop-only where you trust players.

These are the time sinks AI is great at:

• Protocol design: define messages cleanly (join/leave, input, snapshot, RPC)
• Serialization: JSON for early dev, then binary later
• Error handling: reconnect, timeouts, dropped packets
• Testing: make bot clients, fuzz test packet parsing
• Logging + telemetry: structured logs to hunt desyncs

Pro tip: make the AI output small, testable modules, not a 2,000-line “god file”.

Multiplayer bugs are mostly:

• timestamp drift
• authority confusion
• order-of-operations differences
• missing state on join
• nondeterministic logic

Do this and you’ll feel like a wizard:

1. Log inputs + random seeds + key state transitions on server and client
2. When desync happens, export both logs
3. Feed logs to AI and ask: “find divergence point + likely cause”

That works insanely well.

If the game is competitive/online and your mod requires injection or tampering:

• you can get users banned
• your mod can be taken down
• your mod will break constantly

If it’s a single-player game you’re turning into coop, or a game with a modding scene: you’re chilling.

- ChatGPT / Claude-style LLM: architecture, code scaffolding, debugging, docs

• Cursor / Copilot: coding speed + refactors in-editor
• Wireshark (if you’re analyzing network traffic you’re allowed to analyze)
• A real profiler/logging: structured logs are your best friend
• A simple backend: Node/Go/Python for matchmaking/lobbies (even if game server is separate)

1. Game name + platform (PC? console? engine?)

1. Does it have an official modding API?
2. Genre (FPS / survival / RTS / etc.)
3. Coop only or public matchmaking?
4. Do you want dedicated servers or host-and-play?

And I’ll map out: networking model, what to sync first, and a step-by-step build order that won’t implode halfway.

TL;DR: Use AI to accelerate planning, scaffolding, serialization, testing, and debugging—but you still need to choose a sane networking model (usually authoritative server) and build an MVP sync loop first (connect → spawn → move → interact). If the game has no modding support, expect legal/anti-cheat headaches and constant breakage.

User: its an open world 3d game.

its an open world 3d game. What should I do to get a foothold of how I might start modding the game?

Assistant: Alright, for an open-world 3D game, the fastest way to get a foothold is to stop thinking “multiplayer” for a sec and f…

Alright, for an open-world 3D game, the fastest way to get a foothold is to stop thinking “multiplayer” for a sec and focus on: “Can I reliably change anything without the game exploding?” Multiplayer comes later.

Here’s the clean “get your hands dirty” path that works for basically every 3D game modding situation.

There are three worlds:

1. Official mod support (best timeline) - Workshop/mod loader, scripting API, exposed data files, etc.
2. Unofficial but common modding - Community loaders, plugin frameworks, config patches, etc.
3. No modding support (hard mode) - You’ll be doing asset swaps, memory hooks, DLL injection, runtime patching, etc. - This is where stuff gets fragile, and anti-cheat / EULA problems show up.

Your foothold goal: figure out which world you’re in before building anything big.

Open the install directory and look for obvious tells:

Unity: UnityPlayer.dll, GameAssembly.dll, .assets, globalgamemanagers Unreal: .pak, UE4/UE5 folders, Binaries/Win64, Content

• Custom engine: less obvious, but you’ll still see big asset containers and DLLs

Also look for:

• Mods/ folder (free win)
• config files: .ini, .json, .xml, .cfg
• scripting languages: .lua, .py, .js
• asset bundles / archives (pak, bundle, arc, etc.)

AI use: paste folder listings + a couple filenames into an LLM and ask: “Based on these files, what engine/modding style is likely, and what mod entry points usually exist?”

Forget “new quests” and “multiplayer.” You want something that proves you can ship changes.

Good first mods (choose one):

• Change a config value (FOV, stamina drain, gravity, UI scale)
• Replace a texture or model
• Add a simple console command
• Hook a function and print logs
• Spawn an object/NPC (if scripting exists)

If you can do one of those reliably, you’re officially “modding the game,” not just dreaming about it.

AI use: ask the model to propose “10 minimal mods” specifically for open-world 3D games and rank them by effort + risk.

The real bottleneck early is not coding — it’s not knowing what’s happening.

Try to get at least one:

• a working log output you can read
• an in-game console
• a debug overlay (FPS, player coords, entity count, etc.)

Even if the game doesn’t have these: mod frameworks often add them.

AI use: once you have any log or error output, paste it in. LLMs are great at turning “cryptic nonsense” into “oh, it’s missing this dependency / your hook is wrong.”

Open-world games are state machines wearing a trench coat:

• player state (position, rotation, velocity, inventory)
• world state (time, weather, NPC spawns, loot containers)
• quest/state flags
• streaming/chunking (world loads in cells/regions)

Your long-term multiplayer success depends on understanding:

• what’s authoritative (what systems decide outcomes)
• what’s deterministic (what can be replayed)
• what’s purely visual (doesn’t need syncing)

AI use: make a “state map doc.” You can literally say: “Create a state model for an open-world 3D game: categorize state into player/world/NPC/quests/physics, and mark which should be synced for coop.”

Even if you don’t want to rely on others, you want to know what’s already solved:

• Is there a mod loader people use?
• Are there known file formats?
• Are there decompilers/tools commonly used?
• Are there “don’t touch this or it bricks saves” warnings?

AI use: paste snippets from forum/wiki/docs into the model and ask it to summarize:

• “What tools are recommended?”
• “What are the known limitations?”
• “What are the common beginner mistakes?”

You want:

• a clean copy of the game
• a “modded” copy
• version control for your mod code
• a reproducible install step (even if it’s just a script)

This prevents the classic modder tragedy: “I changed something three days ago and now nothing works and I hate life.”

AI use: have it generate a dev checklist + folder structure + quick scripts.

Once you can:

• spawn an object
• read player position
• change an inventory item
• hook a game event

…then you can start designing multiplayer around those hooks.

If you jump to multiplayer first, you’ll end up building a network layer for a mod that can’t even print “hello world.” Pain.

User: I have UnityPlayer.dll and GameAssembly.dll in my folder

I have UnityPlayer.dll and GameAssembly.dll in my folder

Assistant: Nice — that’s Unity specifically an IL2CPP build most of the time when you see GameAssembly.dll.

Nice — that’s Unity (specifically an IL2CPP build most of the time when you see GameAssembly.dll). Translation: modding is doable, but you’ll want to pick the right lane early so you don’t waste a week fighting the wrong tooling.

Here’s the best “foothold” path.

- If you see GameAssembly.dll + no Managed/Assembly-CSharp.dll, it’s basically IL2CPP.

• If you see a Managed/ folder with Assembly-CSharp.dll, that’s Mono (easier).

Either way, your next move is the same: get a mod loader running.

BepInEx is the “hello world” of Unity modding. It gives you:

• plugin loading
• logging console
• config system
• a place to put your code without patching game files manually

What you do with AI here: ask it to generate a minimal BepInEx plugin skeleton for your game version, plus a “toggle feature” config option and a log line so you can verify it loads.

If it’s IL2CPP, you typically use:

• BepInEx IL2CPP + Il2CppInterop (so your C# plugin can talk to IL2CPP types)

Your first win should be: launch game → see BepInEx console → see your plugin log message.

If you can’t get that, don’t move on. Everything else depends on this.

Your foothold isn’t “writing features.” It’s finding the right classes/methods to hook.

For Unity games, your bread and butter is:

• listing loaded scenes
• finding the player GameObject
• reading transform position/rotation
• finding key managers (GameManager, PlayerController, Inventory, etc.)

AI is great here if you feed it:

• a list of types/classes you found
• your log output
• your “what I’m trying to locate” (player health, inventory, etc.)

- Mono: use tools like dnSpy/ILSpy to browse Assembly-CSharp.dll (super straightforward).

• IL2CPP: you don’t have normal C# assemblies to browse the same way. You’ll use an IL2CPP dumping workflow (type/metadata dump) so you can see class names, methods, fields.

AI helps by turning the dump into:

• “these 3 classes look like player movement”
• “this method name suggests it’s called every frame”
• “hook this event instead of Update()”

Pick something tiny but real:

• print player position every second
• add a keybind that toggles god mode (even fake god mode like constantly setting health)
• speed multiplier by editing a movement variable
• spawn an object at the player position

You’re aiming for: read state → change state → verify in-game.

When you can reliably:

• locate player object
• read position/rotation/velocity
• detect inputs/actions
• create/spawn entities

…then multiplayer becomes “just” networking + reconciliation.

If you try multiplayer before you can do the above, you’ll build a gorgeous network layer that syncs nothing. (Ask me how I know. 💀)

1. Look for Managed/ folder and tell me if it exists + whether you see Assembly-CSharp.dll.

1. Try installing BepInEx and tell me if you get a console/log output.
2. Your first plugin: just logs “Loaded” on startup.

If you paste your folder structure (top-level files/folders) and whether there’s a Managed/ folder, I can tell you exactly which toolchain to use (Mono vs IL2CPP) and what your first mod should be.

TL;DR: UnityPlayer.dll + GameAssembly.dll means Unity and likely IL2CPP. Start by getting BepInEx running and a plugin that logs on launch. Then use type-dumping/inspection to find player/controller classes and build a tiny mod that reads + changes player state. Only after that should you attempt multiplayer.

User: I think it's IL2CPP because I don't have the managed folder

I think it's IL2CPP because I don't have the managed folder

Assistant: Yep — no Managed/ folder + GameAssembly.dll is basically the IL2CPP signature.

Yep — no Managed/ folder + GameAssembly.dll is basically the IL2CPP signature. That means you’re not “editing C# assemblies,” you’re injecting a plugin at runtime and interacting with IL2CPP types through an interop layer.

Here’s the clean foothold plan (IL2CPP edition), plus how to use AI without faceplanting.

For IL2CPP Unity games, the usual setup is:

• BepInEx (IL2CPP build) as the loader
• Il2CppInterop (often bundled in that ecosystem) so your C# plugin can talk to IL2CPP types
• Optional but common later: Harmony-style patching (method hooks)

Your first milestone: launch the game and see a console/log that proves BepInEx loaded.

AI use: tell the AI your BepInEx version + folder layout and ask it to generate a “hello world” plugin that logs on startup and on key press.

Your biggest early problem is: “Where is the player? What class controls movement? Where is health stored?”

So your first real mod goal should be finding objects and reading state, like:

• current scene name
• player GameObject and its Transform
• player position/rotation
• list of components on the player object

AI use: once you have logs (component names, scene names, object names), paste them in and ask:

• “Which of these components is likely movement/health/inventory?”
• “What’s the safest place to hook for this?”

With IL2CPP, you usually create a “map” of the game’s types/methods/fields via a dumper workflow (people use tools like Il2CppDumper or similar metadata dump approaches).

This is not about doing anything shady — it’s about turning “opaque native blob” into “I can see class names.”

AI use (super effective):

• Feed the AI the dumped type list (or just the relevant parts)
• Ask it to: - rank likely Player / Controller / Inventory classes - suggest which methods look like update loops / damage handlers - generate a shortlist of hooks to try first

Pick one of these (in order of sanity):

1. Keybind + log (press F1 → log player position)
2. Movement multiplier (speed/jump tweak)
3. Simple “god mode” for local testing (e.g., clamp health) — only if it’s a single-player/coop context

Avoid as a first mod:

• save file editing
• spawning networked entities
• anything that touches world streaming systems

AI use: have it write small, testable functions and a safety toggle (config + hotkey) so you can disable changes instantly.

You want:

• a clean install backup
• a modded install
• one plugin project
• logs saved to a predictable location
• a “does it load?” checklist

AI use: ask it to generate a troubleshooting checklist based on your exact folder structure and log output.

1. Install BepInEx IL2CPP and confirm it logs on launch.

1. Create a plugin that logs: - “Loaded” - current scene name - tries to find an object that looks like player (by tag/name) and prints its position
2. Start building a “type map” (dump types), then use AI to identify the likely player/controller classes.

If you paste the top-level game folder listing (just filenames/folders) and tell me whether the game is offline/coop/online with anti-cheat, I can point you to the most likely correct toolchain and what your first mod should target.

TL;DR: IL2CPP means you’ll mod via a loader (BepInEx IL2CPP) + interop, then build visibility (logs, object finding), then dump types so you can locate player/controller systems. Start with a tiny mod (read position / tweak speed) before even thinking about multiplayer.

User: If I want to make a Unity mod with BepInEx, what are some good AI tools, like MCP servers I can use to help me make thi…

If I want to make a Unity mod with BepInEx, what are some good AI tools, like MCP servers I can use to help me make this?

Assistant: Yep — for a BepInEx IL2CPP Unity mod, AI is most useful when it can see your repo, your logs, and the game’s dumped typ…

Yep — for a BepInEx (IL2CPP) Unity mod, AI is most useful when it can see your repo, your logs, and the game’s dumped types. That’s exactly what MCP servers are good at: giving your assistant “hands” (files, git, web fetch, etc.) without you copy-pasting everything.

###

What it does for you:

• Lets the AI read/write your plugin source, configs, build outputs
• Lets it read BepInEx logs (BepInEx/LogOutput.txt) and iterate fast when something breaks

Most people pair this with a coding assistant in VS Code / Cursor / Claude Desktop. (Filesystem is one of the standard “reference” servers you’ll see in MCP server lists.) GitHub

What it does for you:

• Search your repo history when you broke something
• Pull patterns from other open-source BepInEx plugins
• Generate PR-ready commits/messages and keep changes clean

The Git/GitHub servers are also common “core” MCP picks in curated MCP server lists. GitHub

What it does for you:

• Let the AI pull docs and turn them into actionable snippets
• Great for stuff like: BepInEx install quirks, IL2CPP gotchas, config formats

MCP “example servers” commonly include a fetch/web server for exactly this “grab docs → summarize → apply” workflow. Model Context Protocol

(Also: the BepInEx IL2CPP install docs mention first-run generating files + where logs live, which your AI can use to debug “it didn’t load” issues.) BepinEx Docs

What it does for you:

• Store/replay structured debug data: snapshots, events, tick times, desync markers
• Query “when did divergence start?” instead of reading 10k lines of log

There are MCP servers specifically for SQLite workflows. LobeHub

Even though you’re modding a built game, Unity MCP servers can still help because you can:

• create a tiny Unity “repro project” to test logic (serialization, interpolation, prediction)
• generate scripts/scenes fast for prototyping systems you’ll later port into the mod

There are multiple Unity MCP server projects that connect the Unity Editor to AI assistants via MCP. GitHub

If your mod includes any networking, this can save you from testing everything inside the actual game executable (aka suffering).

- VS Code + GitHub Copilot + MCP servers (VS Code has docs for using MCP servers with Copilot). Visual Studio Code

• Cursor (great at repo-wide edits; MCP is commonly used alongside it via Unity MCP projects) GitHub
• Claude Desktop / other MCP-capable clients (MCP originated from Anthropic; lots of server lists target Claude-style clients) Anthropic

1. Filesystem MCP (your mod repo + BepInEx log folder)

1. Git + GitHub MCP (so it can browse known plugin examples + your history)
2. Fetch MCP (so it can pull docs and not hallucinate APIs)
3. SQLite MCP (only if you’re doing multiplayer/complex debugging)
4. Unity MCP (only if you want fast prototyping outside the game)

If this is a game with anti-cheat / competitive online, mod injection can get accounts banned. For offline / private coop, you’re usually fine.

If you tell me what editor you’re using (VS Code / Cursor / Rider) and what you want the AI to do (generate plugin skeletons, debug logs, analyze IL2CPP dumps, design netcode), I’ll recommend a tighter MCP stack and a workflow that doesn’t turn into “tooling side-quest: the game.”

TL;DR: Best MCP servers for BepInEx modding are Filesystem + Git/GitHub + Fetch; add SQLite for multiplayer debugging, and Unity MCP only if you want rapid prototyping in the Unity Editor.

User: What about for looking at the actual game code?

What about for looking at the actual game code? are there any MCPs that can help me with that?

Assistant: Yeah — but quick reality check: with Unity IL2CPP you’re not going to “open the C game code.” You’re dealing with a nat…

Yeah — but quick reality check: with Unity IL2CPP you’re not going to “open the C# game code.” You’re dealing with a native binary (GameAssembly.dll) + metadata (global-metadata.dat). So the “actual code” you’ll see is decompiled C++-ish pseudocode, plus recovered class/method names via metadata.

Good news: there are MCP servers that plug AI into real reverse-engineering tools, which is exactly the vibe you want.

MCPs that help you inspect IL2CPP “game code”

1) Ghidra MCP servers

• GhidraMCP (plugin + MCP server) lets an AI client drive Ghidra: decompile functions, list symbols, rename stuff, follow xrefs, etc. GitHub
• There’s also pyghidra-mcp (headless) aimed at project-wide, multi-binary analysis. clearbluejar
• Another Ghidra MCP option: GhidrAssistMCP. GitHub

Why it’s good for IL2CPP: Ghidra is great at “what does this function do” and “where is this called from,” and AI can speed-run the boring parts (renaming, grouping, call-chain tracing).

2) IDA Pro MCP servers

• ida-pro-mcp bridges IDA with MCP so an AI can query and automate analysis. GitHub
• If you want automation at scale, ida-headless-mcp exists and explicitly mentions Il2CppDumper metadata import support (very relevant for Unity IL2CPP). GitHub
• Hex-Rays plugin site also lists an “ida-mcp-server” flavor. plugins.hex-rays.com

Why it’s good: IDA’s ecosystem for IL2CPP workflows is strong, and MCP automation can turn “find the player controller” from a day into an hour.

3) Binary Ninja MCP

• binary_ninja_mcp exposes Binary Ninja analysis through MCP. GitHub

Why it’s good: Binary Ninja is super scriptable and fast for iterating; MCP makes it easy to ask “show me all xrefs to this string/symbol” and get structured answers.

The Unity IL2CPP piece you still need: metadata dumping

Before any of those tools are truly useful, you usually run something like Il2CppDumper to extract type/method info from GameAssembly.dll + global-metadata.dat. GitHub

Then your AI can:

• search the dump for likely classes (Player, Controller, Inventory, etc.)
• jump to those functions in Ghidra/IDA/Binja via MCP
• build you a “hook shortlist” for BepInEx patches

If you don’t want to build a full RE MCP setup yet, the low-effort move is: Filesystem MCP + give the AI the dump outputs (type lists, method signatures). That alone gets you 70% of the value.

What MCP “helps with” in practice (the stuff that saves your sanity)

With one of the RE MCPs above, you can do things like:

• “List functions that touch health / damage”
• “Find the update loop for the player motor”
• “Show call chain from input → movement”
• “Auto-rename methods based on behavior”
• “Identify structs used for transforms / vectors” …and then translate that into BepInEx hook points.

Very important anti-footgun note

If the game is competitive online or has anti-cheat, poking the binary can get accounts banned. For offline/single-player/private co-op, you’re usually fine. Also: I can help with legit modding + analysis, but not with bypassing anti-cheat/security.

If you tell me which tool you’d rather use (Ghidra / IDA / Binary Ninja) and whether this is offline/coop/online, I’ll suggest the tightest setup + the exact “first questions” to ask the MCP so you find player movement/health fast.

TL;DR: For IL2CPP, “game code” means decompiled native code + metadata. Best MCP options are GhidraMCP/pyghidra-mcp, IDA Pro MCP (and ida-headless-mcp with Il2CppDumper import), or Binary Ninja MCP. Pair one of those with an IL2CPP dump workflow (e.g., Il2CppDumper) and Filesystem MCP, and you’ll be able to locate real hook points for BepInEx way faster.

User: okay, im using codex so it already does filesystem and can run command line tools and web.

okay, im using codex so it already does filesystem and can run command line tools and web. I think i'll set up the Ghidra MCP. What is a good getting started prompt I should give to the agent so it can properly write a plan to get started?

Assistant: Bet — here’s a “kickoff prompt” you can paste into Codex so the agent produces a legit plan not vibes, tailored to Unit…

Bet — here’s a “kickoff prompt” you can paste into Codex so the agent produces a legit plan (not vibes), tailored to Unity IL2CPP + BepInEx + Ghidra MCP.

Getting-started prompt (copy/paste)

You are my modding engineer. I’m modding a Unity IL2CPP game (UnityPlayer.dll + GameAssembly.dll, no Managed folder). I’m using BepInEx IL2CPP for runtime plugins, and I’m setting up Ghidra with an MCP server so you can drive decompilation/analysis.

Goal: Write a concrete, step-by-step plan to get from “fresh game folder” to “first working BepInEx IL2CPP plugin + identified hook points in the game code” using Ghidra MCP.

Constraints & safety:
* Assume this is for offline/private use. Do NOT provide guidance on bypassing anti-cheat or evading detection.
* Prefer reversible, low-risk steps (backups, separate modded copy, config toggles).
* Minimize brute force; prioritize a repeatable workflow.

What you can do:
* Use filesystem access and run command line tools.
* Use web only for official docs / reputable sources when needed.
* Use the Ghidra MCP to inspect binaries and produce actionable findings (function names, xrefs, call chains).

Deliverables (your output should include all of these):
1) Environment checklist: required tools, versions, and why each is needed (BepInEx IL2CPP, dotnet SDK, Ghidra, IL2CPP dumper workflow, etc.).
2) Folder strategy: clean copy vs modded copy; where logs/configs go; how to rollback.
3) “Hello world” plugin steps: exact project structure, build targets, where to place the plugin, and how to verify it loads via logs.
4) IL2CPP inspection workflow: how to locate global-metadata.dat, run an IL2CPP dump, and how to use outputs to guide RE.
5) Ghidra plan via MCP: how to import GameAssembly.dll, apply/align metadata-derived symbols (as possible), and what queries to run first.
6) A hook discovery checklist: how to identify player object/controller, movement loop, health/damage, inventory, and world streaming systems (with multiple fallback approaches).
7) “First real mod” target: recommend one tiny mod (e.g., log player position, speed multiplier) and list the exact data you need from Ghidra to implement it in BepInEx.
8) Troubleshooting playbook: top failure modes (BepInEx not loading, crashes on startup, missing metadata, Ghidra analysis issues) and how to diagnose each from logs/tool output.
9) A time-boxed plan: milestones in order, each with a verification step (e.g., “see BepInEx console line X”, “identify function Y with xrefs”, “confirm hook triggers”).

Before writing the plan, quickly inspect the game folder layout (top-level) and report what key files are present (GameAssembly.dll, UnityPlayer.dll, global-metadata.dat, etc.). If you can’t find something, give the likely locations and next search steps.

Optional “extra spicy” add-on (if you want multiplayer later)

Add this at the bottom if your endgame is coop:

Future direction: I eventually want coop multiplayer. While planning hook discovery, flag which systems are sync-critical (player transform, inputs, inventory, damage) vs local-only (VFX, UI). Do NOT design the full netcode yet—just tag likely sync points.

Why this prompt works

It forces the agent to:

• actually look at your files
• produce a workflow you can repeat
• use Ghidra MCP for specific outputs (xrefs/call chains), not “maybe try Update()?”
• keep it safe + reversible

TL;DR: Paste the big prompt above. It tells the agent exactly what to inspect, what tools to set up, what “done” looks like at each step, and how to use Ghidra MCP + IL2CPP dumps to find real hook points for your first BepInEx plugin.