A cooperative adventure mode changes more than the number of characters on screen. It changes who commands a creature, who owns a reward, which player decides a battle outcome, and what happens when someone leaves. Define those rules before asking AI to add networking or a second campaign flow.

This guide uses the invented Mossway Trail as a teaching example. No actual co-op mode, network session, or playtest is claimed. The aim is to connect a new mode to the companion and battle systems that already work.
Choose the kind of cooperation first
Decide whether the first version is local shared-screen play, online play, or turn-based asynchronous cooperation. These choices have different boundaries. Local play needs player-specific input, camera framing, and split-screen or shared-screen rules. Online play also needs a connection model, state ownership, latency behavior, and a disconnect plan. Avoid implementing all forms at once.
Then write down the adventure contract. How many players can join? Does each bring a roster? Can a player control another person's companion? Are battles simultaneous or turn-based? Which events can change the story or a permanent collection? What happens to the host's session if a guest disconnects? Answer those questions in the brief so the AI doesn't invent game rules while it edits code.
Keep companion ownership clear
Bonding and command are central to monster-taming play. Preserve those meanings when co-op begins. If each player brings a roster, the interface should show which player commands each creature. If the team shares a roster, decide who selects the action and how conflicts are resolved. Do not let two input sources issue different commands to the same companion during one turn.
Separate a creature's durable owner from its temporary party role. A guest may bring a companion into a session without transferring ownership or writing it into the host's permanent save. If the story includes capture, friendship, or training, specify whether those events affect the guest's collection, the host's world, both, or only the session.
Use the existing battle entry point where possible. The co-op session can provide two player actors and a party arrangement; the current combat rules can still decide valid commands, turn order, damage, and battle completion. A second combat implementation may drift from solo rules and double the work of balancing future updates.

Keep session rewards separate from campaign saves
During a session, track temporary choices and rewards separately from permanent progress. A useful first version might record session discoveries and companion actions in memory, then let the host confirm which rewards enter the campaign when the party returns to camp. If the design needs an immediate save, define exactly whose profile is changed and how a repeated event avoids granting the same reward twice.
Never assume that “shared adventure” means “shared save.” The guest may need to return to their own world with their own companion roster intact. The host may own the map state, quest completion, or local inventory. Write a small table of state ownership before implementing a synchronization layer.
| State | Possible owner | Question to resolve |
|---|---|---|
| Creature roster | Each player or host | Who can issue commands and keep the creature? |
| Battle state | Session authority | Who resolves a turn or capture attempt? |
| Story flags | Host, each profile, or session | Does the guest's own story change? |
| Rewards | Session then profile | When are rewards committed and how are duplicates prevented? |
For online play, choose authority deliberately
If the chosen mode is online, decide which peer owns important state: battle results, capture success, inventory changes, and story rewards. Godot's stable high-level multiplayer documentation describes RPCs and authority, and warns that network features do not automatically secure gameplay logic. It recommends treating client input as untrusted and validating important decisions. This is Godot-specific guidance; use the networking model and security documentation for the project's own engine and service.
Don't send a final outcome from a client and assume it is true. Send an intent such as “use this companion action,” then let the chosen authority validate that the creature belongs to the player, the action is available, and the turn permits it. This does not eliminate latency or cheating concerns; it gives the project an explicit source of truth to test.
Plan a guest disconnect before adding persistent rewards. Can the host continue alone? Does the session pause? Can the same guest rejoin? If rejoin is out of scope, end the session cleanly and explain which temporary progress is kept. A fictional reconnect screen or simulation should never be described as a tested network flow.
Ask AI for one vertical slice
Give the assistant a narrow task: add one co-op trail using the existing companion roster and battle rules; preserve solo mode and campaign saves; define player and companion ownership; list the state that changes during the session; and do not grant permanent rewards until the stated resolution point. Ask for a file-level plan before editing.
For an online version, include the chosen authority model, supported player count, join and leave behavior, and messages that need validation. Ask the assistant to report which state stays local, which state is synchronized, and what happens if a peer disconnects during a battle. Review the patch for duplicated battle logic and writes to the wrong profile.

Verify join, command, battle, and reward paths
Test the actual mode on the target build. Proposed cases below are a plan, not evidence from Mossway Trail.
| Case | Action | What to verify |
|---|---|---|
| Solo regression | Start the original solo adventure | Companion bonds, commands, and saves remain intact |
| Join session | Add the second player through the supported flow | Roster, input, camera, and ownership are clear |
| Shared battle | Issue actions from both players | Turn rules and authority resolve one consistent result |
| Capture or bond | Trigger a creature-affinity event if supported | Owner and save destination follow the design |
| Guest leaves | Disconnect at a safe point and during a battle | Session behavior and temporary progress are deliberate |
| Reward commit | Return to camp and reload each profile | No lost or duplicate rewards; solo saves remain separate |
Record engine and build version, host/client roles, network conditions if online, roster, steps, and observed outcomes. Compare the original solo path before and after the patch. A local mock can validate layout and rule explanations, but it cannot prove network synchronization or multiplayer save behavior.
Frequently asked questions
Should a co-op adventure mode be local or online?
Choose based on the project and release target. Local co-op avoids network synchronization but changes camera and input requirements; online play adds connection, authority, latency, and disconnect handling that need their own scope. Make this limit explicit so scope does not expand during implementation.
How should players share monster companions in co-op?
Decide whether each player brings a roster, commands a shared team, or alternates control by turn. Preserve the existing bond and command rules, and make ownership clear before a battle starts. Ensure the selected roster rule is visible to both players.
Should co-op rewards change the solo campaign save?
Keep session rewards separate from persistent solo progress until the design defines how they merge. If a reward affects a shared save, avoid duplicate grants and test guest and host outcomes explicitly. Use one resolution rule and document the save owner for each reward.
What does network authority mean for a co-op battle?
It identifies which peer is allowed to decide or apply important state. Godot's high-level multiplayer docs warn that networking does not automatically secure gameplay; validate important actions and avoid trusting client-reported results blindly. Match authority rules to the engine and the mode you are building.
What should I test before keeping a co-op mode?
Test player join and leave, companion selection, battle turns, capture or bond events, rewards, save ownership, and reconnection if supported. Record the actual build and session conditions; a mock lobby is not a multiplayer test. Include the actual device and connection setup in the test notes.
Start with one cooperative trail
One trail with clear ownership, one shared encounter, and a defined reward boundary is easier to review than a new multiplayer campaign. Keep solo mode as a regression path. Extend the co-op rules only after the real build proves the party can join, command companions, resolve the battle, and return without corrupting either profile.
For a separate browser-playable prototype idea, try SEELE AI Game Maker. This is for a separate prototype, not an existing game's multiplayer conversion.


