What not to hook: functions co-op relies on

In short

Fine on every function in the tables:

• redscript @wrapMethod that calls wrappedMethod(...) on every path;
• CET Observe / ObserveBefore / ObserveAfter;
• CET Override that calls the original (its last argument) every time;
• a native detour that calls the original every time;
• Codeware callbacks, event listeners, reading state.

Not fine on a function in the tables (co-op breaks there, see the area's line in the table):

• redscript @replaceMethod, @replaceGlobal;
• @wrapMethod that never calls wrappedMethod, or calls it only sometimes;
• @addMethod on a subclass that overrides a function NightCoop wraps in the base class, without calling super;
• CET Override that does not call the original;
• a native detour that returns without calling the original, a byte patch inside the function, a replaced vtable slot.

If your mod has to replace one of them:

1. Ask NightCoop: hookCoopUses (C), NightCoopSdk.HookCoopUses(cls, fn) (redscript, CET). A non-zero answer — co-op relies on it now: keep the original running while NightCoop is in a session (where() / InSession()).
2. Declare it: hookDeclare / NightCoopSdk.HookDeclare(id, cls, fn, flags) (passport flag NCSDK_MOD_USES_HOOKS). The player then gets the same warning as for the overlaps NightCoop finds itself, and your mod's name is in it.
3. Remember that in a session the class PlayerPuppet is also the partners' bodies: a @wrapMethod(PlayerPuppet) runs for them too. Check NightCoopSdk.EntityIsMine(entity) (C: entityIsMine) before you treat a PlayerPuppet as the local V.

How NightCoop hooks — and why the order matters

Script functions. NightCoop puts its guard in front of the function's body after redscript has compiled everything: in front of your @replaceMethod body and of all @wrapMethod wrappers. So a guard survives a replacement; what does not survive:

• a redirect (NightCoop sends one call inside the game's body to itself, e.g. the police chase car of a guest is asked of the host): it needs the game's call in the body. Under @replaceMethod the redirect goes into your body only if you kept that call; otherwise it is not placed (NightCoop names your mod in its log when it found your .reds). Under @wrapMethod NightCoop follows the chain of wrappers to the copy that holds the game's body and puts the redirect there. If one of the wrappers never calls wrappedMethod, the game's body is unreachable: the redirect is not placed;
• what the game's body did that co-op relies on when the guard lets the call through.

CET. Observe and Override swap the function for a native one of CET's; the original body (with NightCoop's guard, if NightCoop came first) moves to CET's copy. Then:

• CET came after NightCoop: Observe calls the copy — NightCoop's guard runs. Override runs NightCoop's guard only when the Lua function calls its last argument;
• CET came first: the function is native now, NightCoop's script hooks cannot be put on it at all. CET mods usually hook in onInit, when the player first appears; most of NightCoop's script hooks are placed earlier, at the first game frame — but those placed later (on a switch, at session start, with retries) can come after.

Natives. NightCoop detours through RED4ext. A hook another module puts on the same entry later sits above NightCoop's and runs first; one put earlier sits below. Each hook runs the next one only if it calls the original.

What NightCoop finds itself

All of it goes to NightCoop's log (hooks: …), one line per overlap; overlaps that can break co-op also give one note on the screen with the mods' names; the full list — red4ext/plugins/NightCoop/logs/nightcoop-hooks.txt. Switch: hook_overlap.

What NightCoop cannot find

These overlaps break co-op the same way, but NightCoop has no way to see them. They are only on this page.

1. @replaceMethod leaves no trace in the running game — the body is simply another. NightCoop knows of it only from the .reds text, so it misses:
   • .reds files that another RED4ext plugin adds to the compilation from any other folder;
   • REDmod script mods (mods/<mod>/scripts/**/*.script): the game's own compiler replaces whole script files;
   • a precompiled final.redscripts shipped by a mod;
   • and it cannot evaluate @if(...): an annotation inside a conditional block is reported as if it were compiled.
2. CET hooks whose names are built at run time (variables, tables, string concatenation, a helper library that calls Override for you): NightCoop sees that a function it hooks became native, but cannot say which mod did it.
3. Whether a hook calls the original. NightCoop never knows whether a CET Override calls its last argument, whether a native detour calls the original, or whether a @wrapMethod calls wrappedMethod on every path (it sees only that the call is in the body somewhere).
4. Native hooks off the entry: a byte patch inside a function (PhotoMode-EX patches PhotoModeSystem_ProcessAttribute), a replaced vtable slot, an import table patch. NightCoop checks only the entries of the functions it detours itself.
5. Functions NightCoop calls but does not hook. NightCoop reads and drives the game through many functions it does not hook (the radio through PocketRadio and VehicleObject.GetCurrentRadioIndex, teleports, spawns, facts, the time system). A mod that replaces one changes what NightCoop gets back; NightCoop compares only with the functions it hooks.
6. The way to a hooked function. A replaced caller that no longer calls a function NightCoop hooks means NightCoop's hook never runs. NightCoop does not follow call graphs.
7. Hooks put later. A mod that hooks on a hotkey or from a menu later is noticed at the next world load at the latest.
8. Script reloads. After a redscript hot reload or CET "reload all mods", NightCoop notices that its hooks are gone, but does not put them back: restart the game.
9. Data, not functions. TweakDB records, ArchiveXL resources and saved settings are not hooks; NightCoop's mods check compares only the files both players have. See Data co-op relies on.
10. Keys outside the two files: the game's Controls menu (user settings), keys a RED4ext plugin reads itself.

Data co-op relies on

Changing these records (TweakXL, CET TweakDB:SetFlat, ArchiveXL) is not seen by NightCoop's checks:

What NightCoop changes on purpose

Your mod may notice these; they are deliberate, so the shared world stays one:

• TimeDilationHelper.SetTimeDilationWithProfile (slow motion of the world) is off in co-op: one player's slow motion would slow everybody. Only the player's own Sandevistan tempo is shown to partners;
• photo mode does not freeze the world, pause its audio or stop quest timers (photo_live);
• the pause menu does not pause the world unless every player is in a menu; a guest's time skip goes through the host;
• loads of a save inside a session go through the session rules;
• a guest gets the host's weather, quest facts, journal and police;
• partners' bodies are PlayerPuppets, and many PlayerPuppet functions answer differently for them (see the player table).

Declaring your hooks (SDK)

C (NightCoop with hookDeclare; check NCSDK_HAS(api, hookDeclare)):

/* passport: info.flags |= NCSDK_MOD_USES_HOOKS; */
api->hookDeclare(mod, "PlayerPuppet", "OnStatusEffectApplied", 0, NCSDK_HOOK_REPLACES);
api->hookDeclare(mod, NULL, NULL, (uint64_t)myDetouredEntry, NCSDK_HOOK_WRAPS);   /* a native entry you detour */
if (api->hookCoopUses("PlayerPuppet", "OnStatusEffectApplied", 0) > 0) { /* keep the original while in a session */ }

redscript (guard it with @if(ModuleExists("NightCoop")), so the mod compiles without NightCoop):

@if(ModuleExists("NightCoop"))
private func DeclareToNightCoop() -> Void {
  NightCoopSdk.HookDeclare("author.mymod", "PlayerPuppet", "OnStatusEffectApplied", EnumInt(NightCoopSdkHookFlag.Replaces));
}

CET (sdk/cet/nightcoop_sdk.lua):

Sdk.hookDeclare("author.mymod", "PlayerPuppet", "OnStatusEffectApplied", Sdk.HOOK.REPLACES)
if Sdk.hookCoopUses("PlayerPuppet", "OnStatusEffectApplied") ~= 0 then --[[ call the original ]] end
for _, k in ipairs(Sdk.coopKeys()) do print(k.name, k.action) end

Log lines

The tables

The areas: what NightCoop does there and what breaks when the game's function is replaced. A class not listed may still matter through the functions NightCoop calls (point 5 above).

Script functions NightCoop wraps or redirects

A function marked * is hooked only in some conditions (a switch, or the other game version). "Redirect" — NightCoop sends one call inside the game's body to itself: that body must stay the game's.

player body and state

partners' bodies are PlayerPuppets in your game and NightCoop keeps their events, looks, poses and animation apart from your own V; replaced, a partner's body acts as your V (death, items, police) or looks wrong.

NPCs, AI, combat and police

every NPC is led by one player and copied to the others, senses, threats, hits and police go by the right player; replaced, NPC copies act on their own and fights differ between players.

population and crowd

the host leads the crowd for everybody; replaced, NPCs pop in or vanish where partners look.

vehicles

partners' cars are mirrors led by their owners; replaced, mirrors drive themselves, seats and hits go wrong.

quests, facts, scenes and dialogs

the host's world decides quests, facts, scenes and choices, and scenes wait for everybody; replaced, the story splits between players.

time and pause

time, pause and slow motion are the same for everybody; replaced, one player's pause or photo mode stops the others, or clocks drift apart.

saves and loading

loads and saves in a session go through the session rules; replaced, a load leaves the session broken.

menus and HUD

NightCoop's menu items, notes, map pins and vote windows live here; replaced, they are gone.

world, physics and effects

explosions, effects, loot and weather are shared; replaced, players see different worlds.

devices, doors and lifts

doors, lifts and devices are one for everybody; replaced, they differ between players.

other

co-op relies on it.

Native functions NightCoop detours

By the RED4ext address library hash (the same on 2.31 and 2.5). "May skip" — NightCoop's detour can answer without calling the original: a hook of another mod below it does not run then.

A few more native hooks go by exe offset instead of the address library hash and are not listed here.

Keys NightCoop reads

NightCoop reads these keys from the OS keyboard while its condition holds; the press is not consumed. A CET hotkey or an Input Loader binding on the same key fires together with NightCoop's action — NightCoop names such bindings in its log. Mods get this list from the SDK (keysUsed, NightCoopSdk.CoopKeys()).

Popular mods with a known overlap

NightCoop recognises these by their folder or file name and writes the line to its log.