class

NetworkSystem

27 properties
198 functions

Extends game.ScriptableSystem game.IScriptableSystem IScriptable ISerializable

Properties

Property	Type	Offset
`networkLinks`	`SNetworkLinkData[]`	`0x0`	scripted
`networkRevealTargets`	`ent.EntityID[]`	`0x10`	scripted
`networkRevealTargetsLastSession`	`ent.EntityID[]`	`0x20`	scripted
`sessionStarted`	`bool`	`0x30`	scripted
`visionModeChangedCallback`	`red.CallbackObject?`	`0x38`	scripted
`focusModeToggleCallback`	`red.CallbackObject?`	`0x48`	scripted
`playerSpawnCallback`	`uint`	`0x58`	scripted
`currentPlayerTargetCallbackID`	`red.CallbackObject?`	`0x60`	scripted
`lastTargetSlaveID`	`ent.EntityID`	`0x70`	scripted
`lastTargetMasterID`	`ent.EntityID`	`0x78`	scripted
`unregisterLinksRequestDelay`	`game.DelayID`	`0x80`	scripted
`focusModeActive`	`bool`	`0x88`	scripted
`lastBeamResource`	`game.FxResource`	`0x90`	scripted
`pingNetworkEffect`	`game.EffectInstance?`	`0x98`	scripted
`pingCachedData`	`PingCachedData?`	`0xA8`	scripted
`lastPingSourceID`	`ent.EntityID`	`0xB8`	scripted
`activePings`	`PingCachedData?[]`	`0xC0`	scripted
`pingedSquads`	`CName[]`	`0xD0`	scripted
`pingLinksCounter`	`int`	`0xE0`	scripted
`networkPresetTBDID`	`TDBID`	`0xE4`	scripted
`networkPresetRecord`	`WeakHandle<game.data.NetworkPingingParameteres_Record>`	`0xF0`	scripted
`backdoors`	`game.PersistentID[]`	`0x100`	scripted
`revealedBackdoorsCount`	`int`	`0x110`	scripted
`debugCashedPingFxResource`	`game.FxResource`	`0x118`	scripted
`debugQueryNumber`	`int`	`0x120`	scripted
`activateLinksDelayID`	`game.DelayID`	`0x124`	scripted
`deactivateLinksDelayID`	`game.DelayID`	`0x12C`	scripted

Functions

void ActivateNetworkLinkByTask(int linkIndex) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NetworkSystem",
    "ActivateNetworkLinkByTask;Int32",
    (NetworkSystem_ActivateNetworkLinkByTask x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_ActivateNetworkLinkByTask(
    NetworkSystem self,
    int linkIndex
);

void ActivateNetworkLinkTask(game.ScriptTaskData data) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NetworkSystem",
    "ActivateNetworkLinkTask;ScriptTaskData",
    (NetworkSystem_ActivateNetworkLinkTask x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_ActivateNetworkLinkTask(
    NetworkSystem self,
    game.ScriptTaskData? data
);

void DeactivateNetworkLinkByTask(int linkIndex, bool instant) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NetworkSystem",
    "DeactivateNetworkLinkByTask;Int32Bool",
    (NetworkSystem_DeactivateNetworkLinkByTask x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_DeactivateNetworkLinkByTask(
    NetworkSystem self,
    int linkIndex,
    bool instant
);

void DeactivateNetworkLinkTask(game.ScriptTaskData data) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NetworkSystem",
    "DeactivateNetworkLinkTask;ScriptTaskData",
    (NetworkSystem_DeactivateNetworkLinkTask x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_DeactivateNetworkLinkTask(
    NetworkSystem self,
    game.ScriptTaskData? data
);

void OnAttach() overrideRTTI

Generated hook

re.Hooks.PlaceVoid(
    "NetworkSystem",
    "OnAttach;",
    (NetworkSystem_OnAttach x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_OnAttach(
    NetworkSystem self
);

void OnDetach() overrideRTTI

Generated hook

re.Hooks.PlaceVoid(
    "NetworkSystem",
    "OnDetach;",
    (NetworkSystem_OnDetach x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_OnDetach(
    NetworkSystem self
);

game.IBlackboard? GetPlayerStateMachineBlackboard(WeakHandle<game.Object> playerPuppet) RTTI

Generated hook

re.Hooks.Place(
    "NetworkSystem",
    "GetPlayerStateMachineBlackboard;GameObject",
    (NetworkSystem_GetPlayerStateMachineBlackboard x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.IBlackboard>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_GetPlayerStateMachineBlackboard(
    NetworkSystem self,
    WeakHandle<game.Object> playerPuppet
);

void OnPlayerSpawnedCallback(game.Object playerPuppet) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NetworkSystem",
    "OnPlayerSpawnedCallback;GameObject",
    (NetworkSystem_OnPlayerSpawnedCallback x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_OnPlayerSpawnedCallback(
    NetworkSystem self,
    game.Object? playerPuppet
);

void RegisterPlayerSpawnedCallback() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NetworkSystem",
    "RegisterPlayerSpawnedCallback;",
    (NetworkSystem_RegisterPlayerSpawnedCallback x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_RegisterPlayerSpawnedCallback(
    NetworkSystem self
);

void RegisterVisionModeCallback(game.Object player) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NetworkSystem",
    "RegisterVisionModeCallback;GameObject",
    (NetworkSystem_RegisterVisionModeCallback x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_RegisterVisionModeCallback(
    NetworkSystem self,
    game.Object? player
);

void RegisterFocusModeCallback() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NetworkSystem",
    "RegisterFocusModeCallback;",
    (NetworkSystem_RegisterFocusModeCallback x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_RegisterFocusModeCallback(
    NetworkSystem self
);

void RegisterPlayerTargetCallback() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NetworkSystem",
    "RegisterPlayerTargetCallback;",
    (NetworkSystem_RegisterPlayerTargetCallback x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_RegisterPlayerTargetCallback(
    NetworkSystem self
);

void UnregisterVisionModeCallback() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NetworkSystem",
    "UnregisterVisionModeCallback;",
    (NetworkSystem_UnregisterVisionModeCallback x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_UnregisterVisionModeCallback(
    NetworkSystem self
);

void UnregisterFocusModeCallback() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NetworkSystem",
    "UnregisterFocusModeCallback;",
    (NetworkSystem_UnregisterFocusModeCallback x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_UnregisterFocusModeCallback(
    NetworkSystem self
);

void UnregisterPlayerTargetCallback() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NetworkSystem",
    "UnregisterPlayerTargetCallback;",
    (NetworkSystem_UnregisterPlayerTargetCallback x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_UnregisterPlayerTargetCallback(
    NetworkSystem self
);

void UnregisterPlayerSpawnedCallback() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NetworkSystem",
    "UnregisterPlayerSpawnedCallback;",
    (NetworkSystem_UnregisterPlayerSpawnedCallback x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_UnregisterPlayerSpawnedCallback(
    NetworkSystem self
);

void AddNetworkLink(SNetworkLinkData linkData) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NetworkSystem",
    "AddNetworkLink;SNetworkLinkData",
    (NetworkSystem_AddNetworkLink x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_AddNetworkLink(
    NetworkSystem self,
    SNetworkLinkData linkData
);

EPriority DeterminNetworkLinkPriority(SNetworkLinkData linkData) RTTI

Generated hook

re.Hooks.Place(
    "NetworkSystem",
    "DeterminNetworkLinkPriority;script_ref<SNetworkLinkData>",
    (NetworkSystem_DeterminNetworkLinkPriority x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.EPriority>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_DeterminNetworkLinkPriority(
    NetworkSystem self,
    SNetworkLinkData linkData
);

void RemoveNetworkLinksByID(ent.EntityID ID) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NetworkSystem",
    "RemoveNetworkLinksByID;EntityID",
    (NetworkSystem_RemoveNetworkLinksByID x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_RemoveNetworkLinksByID(
    NetworkSystem self,
    ent.EntityID ID
);

void RemoveNetworkLinksBetweenTwoEntitities(ent.EntityID firstID, ent.EntityID secondID, bool onlyRemoveWeakLink) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NetworkSystem",
    "RemoveNetworkLinksBetweenTwoEntitities;EntityIDEntityIDBool",
    (NetworkSystem_RemoveNetworkLinksBetweenTwoEntitities x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_RemoveNetworkLinksBetweenTwoEntitities(
    NetworkSystem self,
    ent.EntityID firstID,
    ent.EntityID secondID,
    bool onlyRemoveWeakLink
);

void RemoveNetworkLinkByData(SNetworkLinkData linkData) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NetworkSystem",
    "RemoveNetworkLinkByData;script_ref<SNetworkLinkData>",
    (NetworkSystem_RemoveNetworkLinkByData x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_RemoveNetworkLinkByData(
    NetworkSystem self,
    SNetworkLinkData linkData
);

void RemoveNetworkLinkByType(ELinkType linkType) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NetworkSystem",
    "RemoveNetworkLinkByType;ELinkType",
    (NetworkSystem_RemoveNetworkLinkByType x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_RemoveNetworkLinkByType(
    NetworkSystem self,
    ELinkType linkType
);

void RemoveNetworkLinkByIdAndType(ELinkType linkType, ent.EntityID ID) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NetworkSystem",
    "RemoveNetworkLinkByIdAndType;ELinkTypeEntityID",
    (NetworkSystem_RemoveNetworkLinkByIdAndType x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_RemoveNetworkLinkByIdAndType(
    NetworkSystem self,
    ELinkType linkType,
    ent.EntityID ID
);

void RemoveNetworkLink(int index, bool instant) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NetworkSystem",
    "RemoveNetworkLink;Int32Bool",
    (NetworkSystem_RemoveNetworkLink x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_RemoveNetworkLink(
    NetworkSystem self,
    int index,
    bool instant
);

game.DelayID UnregisterNetworkLinkWithDelay(SNetworkLinkData linkData) RTTI

Generated hook

re.Hooks.Place(
    "NetworkSystem",
    "UnregisterNetworkLinkWithDelay;script_ref<SNetworkLinkData>",
    (NetworkSystem_UnregisterNetworkLinkWithDelay x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.DelayID>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_UnregisterNetworkLinkWithDelay(
    NetworkSystem self,
    SNetworkLinkData linkData
);

void RegisterNetworkLinkWithDelay(SNetworkLinkData linkData, float delay) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NetworkSystem",
    "RegisterNetworkLinkWithDelay;script_ref<SNetworkLinkData>Float",
    (NetworkSystem_RegisterNetworkLinkWithDelay x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_RegisterNetworkLinkWithDelay(
    NetworkSystem self,
    SNetworkLinkData linkData,
    float delay
);

bool HasNetworkLink(SNetworkLinkData linkData, out int index) RTTI

Generated hook

re.Hooks.Place(
    "NetworkSystem",
    "HasNetworkLink;script_ref<SNetworkLinkData>Int32",
    (NetworkSystem_HasNetworkLink x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_HasNetworkLink(
    NetworkSystem self,
    SNetworkLinkData linkData,
    int index
);

bool HasNetworkLink(SNetworkLinkData linkData) RTTI

Generated hook

re.Hooks.Place(
    "NetworkSystem",
    "HasNetworkLink;script_ref<SNetworkLinkData>",
    (NetworkSystem_HasNetworkLink2 x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_HasNetworkLink2(
    NetworkSystem self,
    SNetworkLinkData linkData
);

void UpdateNetworkLinkData(SNetworkLinkData linkData, int indexToUpdate) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NetworkSystem",
    "UpdateNetworkLinkData;SNetworkLinkDataInt32",
    (NetworkSystem_UpdateNetworkLinkData x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_UpdateNetworkLinkData(
    NetworkSystem self,
    SNetworkLinkData linkData,
    int indexToUpdate
);

void CancelNetworkLinkDelay(SNetworkLinkData linkData) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NetworkSystem",
    "CancelNetworkLinkDelay;script_ref<SNetworkLinkData>",
    (NetworkSystem_CancelNetworkLinkDelay x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_CancelNetworkLinkDelay(
    NetworkSystem self,
    SNetworkLinkData linkData
);

bool CompareLinks(SNetworkLinkData linkData1, SNetworkLinkData linkData2) RTTI

Generated hook

re.Hooks.Place(
    "NetworkSystem",
    "CompareLinks;script_ref<SNetworkLinkData>script_ref<SNetworkLinkData>",
    (NetworkSystem_CompareLinks x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_CompareLinks(
    NetworkSystem self,
    SNetworkLinkData linkData1,
    SNetworkLinkData linkData2
);

bool CompareLinksData(SNetworkLinkData linkData1, SNetworkLinkData linkData2) RTTI

Generated hook

re.Hooks.Place(
    "NetworkSystem",
    "CompareLinksData;script_ref<SNetworkLinkData>script_ref<SNetworkLinkData>",
    (NetworkSystem_CompareLinksData x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_CompareLinksData(
    NetworkSystem self,
    SNetworkLinkData linkData1,
    SNetworkLinkData linkData2
);

bool HasNetworkLinkWithHigherPriority(SNetworkLinkData linkData) RTTI

Generated hook

re.Hooks.Place(
    "NetworkSystem",
    "HasNetworkLinkWithHigherPriority;script_ref<SNetworkLinkData>",
    (NetworkSystem_HasNetworkLinkWithHigherPriority x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_HasNetworkLinkWithHigherPriority(
    NetworkSystem self,
    SNetworkLinkData linkData
);

bool HasNetworkLink(ent.EntityID ID) RTTI

Generated hook

re.Hooks.Place(
    "NetworkSystem",
    "HasNetworkLink;EntityID",
    (NetworkSystem_HasNetworkLink3 x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_HasNetworkLink3(
    NetworkSystem self,
    ent.EntityID ID
);

bool HasNetworkLink(ent.EntityID ID, bool ignorePingLinks) RTTI

Generated hook

re.Hooks.Place(
    "NetworkSystem",
    "HasNetworkLink;EntityIDBool",
    (NetworkSystem_HasNetworkLink4 x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_HasNetworkLink4(
    NetworkSystem self,
    ent.EntityID ID,
    bool ignorePingLinks
);

bool HasNetworkLink(ent.EntityID masterID, ent.EntityID slaveID, ELinkType linkType) RTTI

Generated hook

re.Hooks.Place(
    "NetworkSystem",
    "HasNetworkLink;EntityIDEntityIDELinkType",
    (NetworkSystem_HasNetworkLink5 x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_HasNetworkLink5(
    NetworkSystem self,
    ent.EntityID masterID,
    ent.EntityID slaveID,
    ELinkType linkType
);

bool HasAnyActiveNetworkLink(ent.EntityID ID) RTTI

Generated hook

re.Hooks.Place(
    "NetworkSystem",
    "HasAnyActiveNetworkLink;EntityID",
    (NetworkSystem_HasAnyActiveNetworkLink x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_HasAnyActiveNetworkLink(
    NetworkSystem self,
    ent.EntityID ID
);

game.FxInstance? GetNetworkBeam(SNetworkLinkData linkData) RTTI

Generated hook

re.Hooks.Place(
    "NetworkSystem",
    "GetNetworkBeam;script_ref<SNetworkLinkData>",
    (NetworkSystem_GetNetworkBeam x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.FxInstance>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_GetNetworkBeam(
    NetworkSystem self,
    SNetworkLinkData linkData
);

void OnNewBackdoorDeviceRequest(NewBackdoorDeviceRequest request) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NetworkSystem",
    "OnNewBackdoorDeviceRequest;NewBackdoorDeviceRequest",
    (NetworkSystem_OnNewBackdoorDeviceRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_OnNewBackdoorDeviceRequest(
    NetworkSystem self,
    NewBackdoorDeviceRequest? request
);

void OnMarkBackdoorAsRevealedRequest(MarkBackdoorAsRevealedRequest request) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NetworkSystem",
    "OnMarkBackdoorAsRevealedRequest;MarkBackdoorAsRevealedRequest",
    (NetworkSystem_OnMarkBackdoorAsRevealedRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_OnMarkBackdoorAsRevealedRequest(
    NetworkSystem self,
    MarkBackdoorAsRevealedRequest? request
);

void OnUnregisterAllNetworkLinksRequest(UnregisterAllNetworkLinksRequest request) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NetworkSystem",
    "OnUnregisterAllNetworkLinksRequest;UnregisterAllNetworkLinksRequest",
    (NetworkSystem_OnUnregisterAllNetworkLinksRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_OnUnregisterAllNetworkLinksRequest(
    NetworkSystem self,
    UnregisterAllNetworkLinksRequest? request
);

void OnDeactivateAllNetworkLinksRequest(DeactivateAllNetworkLinksRequest request) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NetworkSystem",
    "OnDeactivateAllNetworkLinksRequest;DeactivateAllNetworkLinksRequest",
    (NetworkSystem_OnDeactivateAllNetworkLinksRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_OnDeactivateAllNetworkLinksRequest(
    NetworkSystem self,
    DeactivateAllNetworkLinksRequest? request
);

void KillAllNetworkBeams() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NetworkSystem",
    "KillAllNetworkBeams;",
    (NetworkSystem_KillAllNetworkBeams x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_KillAllNetworkBeams(
    NetworkSystem self
);

void ResolveNetworkSystemCleanupDelay() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NetworkSystem",
    "ResolveNetworkSystemCleanupDelay;",
    (NetworkSystem_ResolveNetworkSystemCleanupDelay x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_ResolveNetworkSystemCleanupDelay(
    NetworkSystem self
);

void CleanNetwork() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NetworkSystem",
    "CleanNetwork;",
    (NetworkSystem_CleanNetwork x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_CleanNetwork(
    NetworkSystem self
);

void RemoveAllNetworkLinks() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NetworkSystem",
    "RemoveAllNetworkLinks;",
    (NetworkSystem_RemoveAllNetworkLinks x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_RemoveAllNetworkLinks(
    NetworkSystem self
);

void OnUnregisterNetworkLinksByIDRequest(UnregisterNetworkLinksByIDRequest request) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NetworkSystem",
    "OnUnregisterNetworkLinksByIDRequest;UnregisterNetworkLinksByIDRequest",
    (NetworkSystem_OnUnregisterNetworkLinksByIDRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_OnUnregisterNetworkLinksByIDRequest(
    NetworkSystem self,
    UnregisterNetworkLinksByIDRequest? request
);

void OnUnregisterNetworkLinksByIdAndTypeRequest(UnregisterNetworkLinksByIdAndTypeRequest request) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NetworkSystem",
    "OnUnregisterNetworkLinksByIdAndTypeRequest;UnregisterNetworkLinksByIdAndTypeRequest",
    (NetworkSystem_OnUnregisterNetworkLinksByIdAndTypeRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_OnUnregisterNetworkLinksByIdAndTypeRequest(
    NetworkSystem self,
    UnregisterNetworkLinksByIdAndTypeRequest? request
);

void OnUnregisterNetworkLinkRequest(UnregisterNetworkLinkRequest request) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NetworkSystem",
    "OnUnregisterNetworkLinkRequest;UnregisterNetworkLinkRequest",
    (NetworkSystem_OnUnregisterNetworkLinkRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_OnUnregisterNetworkLinkRequest(
    NetworkSystem self,
    UnregisterNetworkLinkRequest? request
);

void OnUnregisterNetworkLinkBetweenTwoEntitiesRequest(UnregisterNetworkLinkBetweenTwoEntitiesRequest request) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NetworkSystem",
    "OnUnregisterNetworkLinkBetweenTwoEntitiesRequest;UnregisterNetworkLinkBetweenTwoEntitiesRequest",
    (NetworkSystem_OnUnregisterNetworkLinkBetweenTwoEntitiesRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_OnUnregisterNetworkLinkBetweenTwoEntitiesRequest(
    NetworkSystem self,
    UnregisterNetworkLinkBetweenTwoEntitiesRequest? request
);

void KillNetworkBeamsByID(ent.EntityID ID) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NetworkSystem",
    "KillNetworkBeamsByID;EntityID",
    (NetworkSystem_KillNetworkBeamsByID x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_KillNetworkBeamsByID(
    NetworkSystem self,
    ent.EntityID ID
);

void KillNetworkBeamByIndex(int index) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NetworkSystem",
    "KillNetworkBeamByIndex;Int32",
    (NetworkSystem_KillNetworkBeamByIndex x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_KillNetworkBeamByIndex(
    NetworkSystem self,
    int index
);

void KillNetworkBeamsByID(ent.EntityID slaveID, ent.EntityID masterID) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NetworkSystem",
    "KillNetworkBeamsByID;EntityIDEntityID",
    (NetworkSystem_KillNetworkBeamsByID2 x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_KillNetworkBeamsByID2(
    NetworkSystem self,
    ent.EntityID slaveID,
    ent.EntityID masterID
);

void KillNetworkBeamByData(SNetworkLinkData linkData) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NetworkSystem",
    "KillNetworkBeamByData;script_ref<SNetworkLinkData>",
    (NetworkSystem_KillNetworkBeamByData x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_KillNetworkBeamByData(
    NetworkSystem self,
    SNetworkLinkData linkData
);

void KillNetworkBeam(int index, bool instant) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NetworkSystem",
    "KillNetworkBeam;Int32Bool",
    (NetworkSystem_KillNetworkBeam x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_KillNetworkBeam(
    NetworkSystem self,
    int index,
    bool instant
);

void OnRegisterNetworkLinkRequest(RegisterNetworkLinkRequest request) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NetworkSystem",
    "OnRegisterNetworkLinkRequest;RegisterNetworkLinkRequest",
    (NetworkSystem_OnRegisterNetworkLinkRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_OnRegisterNetworkLinkRequest(
    NetworkSystem self,
    RegisterNetworkLinkRequest? request
);

void RegisterNetworkLink(SNetworkLinkData linkData) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NetworkSystem",
    "RegisterNetworkLink;SNetworkLinkData",
    (NetworkSystem_RegisterNetworkLink x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_RegisterNetworkLink(
    NetworkSystem self,
    SNetworkLinkData linkData
);

void OnUpdateNetworkVisualisationRequest(UpdateNetworkVisualisationRequest request) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NetworkSystem",
    "OnUpdateNetworkVisualisationRequest;UpdateNetworkVisualisationRequest",
    (NetworkSystem_OnUpdateNetworkVisualisationRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_OnUpdateNetworkVisualisationRequest(
    NetworkSystem self,
    UpdateNetworkVisualisationRequest? request
);

void UpdateNetworkVisualisation() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NetworkSystem",
    "UpdateNetworkVisualisation;",
    (NetworkSystem_UpdateNetworkVisualisation x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_UpdateNetworkVisualisation(
    NetworkSystem self
);

void OnActivateNetworkLinksRequest(ActivateLinksRequest request) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NetworkSystem",
    "OnActivateNetworkLinksRequest;ActivateLinksRequest",
    (NetworkSystem_OnActivateNetworkLinksRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_OnActivateNetworkLinksRequest(
    NetworkSystem self,
    ActivateLinksRequest? request
);

void ActivateNetworkLinks(int[] toActivate) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NetworkSystem",
    "ActivateNetworkLinks;script_ref<array<Int32>>",
    (NetworkSystem_ActivateNetworkLinks x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_ActivateNetworkLinks(
    NetworkSystem self,
    int[] toActivate
);

void OnDeactivateLinksRequest(DeactivateLinksRequest request) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NetworkSystem",
    "OnDeactivateLinksRequest;DeactivateLinksRequest",
    (NetworkSystem_OnDeactivateLinksRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_OnDeactivateLinksRequest(
    NetworkSystem self,
    DeactivateLinksRequest? request
);

void DeactivateNetworkLinks(int[] toDeactivate, bool hasContext) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NetworkSystem",
    "DeactivateNetworkLinks;script_ref<array<Int32>>Bool",
    (NetworkSystem_DeactivateNetworkLinks x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_DeactivateNetworkLinks(
    NetworkSystem self,
    int[] toDeactivate,
    bool hasContext
);

bool DeterminNetworkLinkVisibility(int linkIndex) RTTI

Generated hook

re.Hooks.Place(
    "NetworkSystem",
    "DeterminNetworkLinkVisibility;Int32",
    (NetworkSystem_DeterminNetworkLinkVisibility x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_DeterminNetworkLinkVisibility(
    NetworkSystem self,
    int linkIndex
);

void ActivateNetworkLinkByIndex(int linkIndex) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NetworkSystem",
    "ActivateNetworkLinkByIndex;Int32",
    (NetworkSystem_ActivateNetworkLinkByIndex x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_ActivateNetworkLinkByIndex(
    NetworkSystem self,
    int linkIndex
);

bool DrawNetworkBeamByIndex(int linkIndex) RTTI

Generated hook

re.Hooks.Place(
    "NetworkSystem",
    "DrawNetworkBeamByIndex;Int32",
    (NetworkSystem_DrawNetworkBeamByIndex x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_DrawNetworkBeamByIndex(
    NetworkSystem self,
    int linkIndex
);

void ResolveConnectionHighlight(bool enable, SNetworkLinkData linkData) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NetworkSystem",
    "ResolveConnectionHighlight;Boolscript_ref<SNetworkLinkData>",
    (NetworkSystem_ResolveConnectionHighlight x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_ResolveConnectionHighlight(
    NetworkSystem self,
    bool enable,
    SNetworkLinkData linkData
);

void SendConnectionHighlightEvent(bool enable, ent.EntityID target, ent.EntityID source, SNetworkLinkData linkData) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NetworkSystem",
    "SendConnectionHighlightEvent;BoolEntityIDEntityIDscript_ref<SNetworkLinkData>",
    (NetworkSystem_SendConnectionHighlightEvent x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_SendConnectionHighlightEvent(
    NetworkSystem self,
    bool enable,
    ent.EntityID target,
    ent.EntityID source,
    SNetworkLinkData linkData
);

void OnEvaluateVisionModeRequest(EvaluateVisionModeRequest request) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NetworkSystem",
    "OnEvaluateVisionModeRequest;EvaluateVisionModeRequest",
    (NetworkSystem_OnEvaluateVisionModeRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_OnEvaluateVisionModeRequest(
    NetworkSystem self,
    EvaluateVisionModeRequest? request
);

bool OnVisionModeChanged(int value) RTTI

Generated hook

re.Hooks.Place(
    "NetworkSystem",
    "OnVisionModeChanged",
    (NetworkSystem_OnVisionModeChanged x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_OnVisionModeChanged(
    NetworkSystem self,
    int value
);

void EvaluateVisionMode(game.VisionModeType visionType) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NetworkSystem",
    "EvaluateVisionMode;gameVisionModeType",
    (NetworkSystem_EvaluateVisionMode x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_EvaluateVisionMode(
    NetworkSystem self,
    game.VisionModeType visionType
);

bool OnFocusModeToggle(bool value) RTTI

Generated hook

re.Hooks.Place(
    "NetworkSystem",
    "OnFocusModeToggle",
    (NetworkSystem_OnFocusModeToggle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_OnFocusModeToggle(
    NetworkSystem self,
    bool value
);

bool OnPlayerTargetChanged(ent.EntityID value) RTTI

Generated hook

re.Hooks.Place(
    "NetworkSystem",
    "OnPlayerTargetChanged",
    (NetworkSystem_OnPlayerTargetChanged x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_OnPlayerTargetChanged(
    NetworkSystem self,
    ent.EntityID value
);

bool EvaluatelastTargets(ent.EntityID newTarget) RTTI

Generated hook

re.Hooks.Place(
    "NetworkSystem",
    "EvaluatelastTargets;EntityID",
    (NetworkSystem_EvaluatelastTargets x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_EvaluatelastTargets(
    NetworkSystem self,
    ent.EntityID newTarget
);

ENetworkRelation GetNetworkRelation(ent.EntityID sourceID, ent.EntityID targetID) RTTI

Generated hook

re.Hooks.Place(
    "NetworkSystem",
    "GetNetworkRelation;EntityIDEntityID",
    (NetworkSystem_GetNetworkRelation x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.ENetworkRelation>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_GetNetworkRelation(
    NetworkSystem self,
    ent.EntityID sourceID,
    ent.EntityID targetID
);

void EvaluateLastSlaveTarget(ent.EntityID masterID) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NetworkSystem",
    "EvaluateLastSlaveTarget;EntityID",
    (NetworkSystem_EvaluateLastSlaveTarget x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_EvaluateLastSlaveTarget(
    NetworkSystem self,
    ent.EntityID masterID
);

void EvaluateLastMasterTarget(ent.EntityID slaveID) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NetworkSystem",
    "EvaluateLastMasterTarget;EntityID",
    (NetworkSystem_EvaluateLastMasterTarget x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_EvaluateLastMasterTarget(
    NetworkSystem self,
    ent.EntityID slaveID
);

bool IsMaster(ent.EntityID targetEntityID) RTTI

Generated hook

re.Hooks.Place(
    "NetworkSystem",
    "IsMaster;EntityID",
    (NetworkSystem_IsMaster x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_IsMaster(
    NetworkSystem self,
    ent.EntityID targetEntityID
);

bool IsLastSlaveTarget(ent.EntityID entityID) RTTI

Generated hook

re.Hooks.Place(
    "NetworkSystem",
    "IsLastSlaveTarget;EntityID",
    (NetworkSystem_IsLastSlaveTarget x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_IsLastSlaveTarget(
    NetworkSystem self,
    ent.EntityID entityID
);

bool IsLastMasterTarget(ent.EntityID entityID) RTTI

Generated hook

re.Hooks.Place(
    "NetworkSystem",
    "IsLastMasterTarget;EntityID",
    (NetworkSystem_IsLastMasterTarget x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_IsLastMasterTarget(
    NetworkSystem self,
    ent.EntityID entityID
);

bool IsCurrentTarget(ent.EntityID entityID) RTTI

Generated hook

re.Hooks.Place(
    "NetworkSystem",
    "IsCurrentTarget;EntityID",
    (NetworkSystem_IsCurrentTarget x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_IsCurrentTarget(
    NetworkSystem self,
    ent.EntityID entityID
);

bool IsCurrentTargetValid() RTTI

Generated hook

re.Hooks.Place(
    "NetworkSystem",
    "IsCurrentTargetValid;",
    (NetworkSystem_IsCurrentTargetValid x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_IsCurrentTargetValid(
    NetworkSystem self
);

bool IsCurrentTargetValidInNetwork() RTTI

Generated hook

re.Hooks.Place(
    "NetworkSystem",
    "IsCurrentTargetValidInNetwork;",
    (NetworkSystem_IsCurrentTargetValidInNetwork x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_IsCurrentTargetValidInNetwork(
    NetworkSystem self
);

bool IsInNetwork(ent.EntityID id) RTTI

Generated hook

re.Hooks.Place(
    "NetworkSystem",
    "IsInNetwork;EntityID",
    (NetworkSystem_IsInNetwork x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_IsInNetwork(
    NetworkSystem self,
    ent.EntityID id
);

bool IsSlaveInNetwork(ent.EntityID id) RTTI

Generated hook

re.Hooks.Place(
    "NetworkSystem",
    "IsSlaveInNetwork;EntityID",
    (NetworkSystem_IsSlaveInNetwork x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_IsSlaveInNetwork(
    NetworkSystem self,
    ent.EntityID id
);

ent.EntityID[] GetAllSlavesOfMaster(ent.EntityID masterID) RTTI

bool IsMasterInNetwork(ent.EntityID id) RTTI

Generated hook

re.Hooks.Place(
    "NetworkSystem",
    "IsMasterInNetwork;EntityID",
    (NetworkSystem_IsMasterInNetwork x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_IsMasterInNetwork(
    NetworkSystem self,
    ent.EntityID id
);

ent.EntityID[] GetAllMastersOfSlave(ent.EntityID slaveID) RTTI

ent.EntityID GetCurrentTargetID() RTTI

Generated hook

re.Hooks.Place(
    "NetworkSystem",
    "GetCurrentTargetID;",
    (NetworkSystem_GetCurrentTargetID x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.ent.EntityID>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_GetCurrentTargetID(
    NetworkSystem self
);

WeakHandle<game.Object> GetCurrentTarget() RTTI
WeakHandle<game.Object> GetObjectFromID(ent.EntityID entityID) RTTI

bool IsTagged(ent.EntityID id) RTTI

Generated hook

re.Hooks.Place(
    "NetworkSystem",
    "IsTagged;EntityID",
    (NetworkSystem_IsTagged x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_IsTagged(
    NetworkSystem self,
    ent.EntityID id
);

void OnRegisterPingLinkRequest(RegisterPingNetworkLinkRequest request) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NetworkSystem",
    "OnRegisterPingLinkRequest;RegisterPingNetworkLinkRequest",
    (NetworkSystem_OnRegisterPingLinkRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_OnRegisterPingLinkRequest(
    NetworkSystem self,
    RegisterPingNetworkLinkRequest? request
);

void KillSingleOldestFreeLink() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NetworkSystem",
    "KillSingleOldestFreeLink;",
    (NetworkSystem_KillSingleOldestFreeLink x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_KillSingleOldestFreeLink(
    NetworkSystem self
);

void KillSingleOldestFreeLinkWitoutRevealPing() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NetworkSystem",
    "KillSingleOldestFreeLinkWitoutRevealPing;",
    (NetworkSystem_KillSingleOldestFreeLinkWitoutRevealPing x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_KillSingleOldestFreeLinkWitoutRevealPing(
    NetworkSystem self
);

bool IsFreeLinkLimitReached(SNetworkLinkData linkData) RTTI

Generated hook

re.Hooks.Place(
    "NetworkSystem",
    "IsFreeLinkLimitReached;script_ref<SNetworkLinkData>",
    (NetworkSystem_IsFreeLinkLimitReached x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_IsFreeLinkLimitReached(
    NetworkSystem self,
    SNetworkLinkData linkData
);

void OnStartPingingNetworkRequest(StartPingingNetworkRequest request) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NetworkSystem",
    "OnStartPingingNetworkRequest;StartPingingNetworkRequest",
    (NetworkSystem_OnStartPingingNetworkRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_OnStartPingingNetworkRequest(
    NetworkSystem self,
    StartPingingNetworkRequest? request
);

void OnStopingingNetworkRequest(StopPingingNetworkRequest request) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NetworkSystem",
    "OnStopingingNetworkRequest;StopPingingNetworkRequest",
    (NetworkSystem_OnStopingingNetworkRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_OnStopingingNetworkRequest(
    NetworkSystem self,
    StopPingingNetworkRequest? request
);

void AddActivePing(game.Object source, EPingType pingType, float duration, ELinkType linkType, bool revealNetworkAtEnd, game.FxResource fxResource, TDBID virtualNetworkShapeID)

RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NetworkSystem",
    "AddActivePing;GameObjectEPingTypeFloatELinkTypeBoolFxResourceTweakDBID",
    (NetworkSystem_AddActivePing x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_AddActivePing(
    NetworkSystem self,
    game.Object? source,
    EPingType pingType,
    float duration,
    ELinkType linkType,
    bool revealNetworkAtEnd,
    game.FxResource fxResource,
    TDBID virtualNetworkShapeID
);

void CreateVirtualNetwork(PingCachedData sourcePing) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NetworkSystem",
    "CreateVirtualNetwork;PingCachedData",
    (NetworkSystem_CreateVirtualNetwork x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_CreateVirtualNetwork(
    NetworkSystem self,
    PingCachedData? sourcePing
);

bool IsVirtualNetworkWithinDistanceLimit(PingCachedData sourcePing) RTTI

Generated hook

re.Hooks.Place(
    "NetworkSystem",
    "IsVirtualNetworkWithinDistanceLimit;PingCachedData",
    (NetworkSystem_IsVirtualNetworkWithinDistanceLimit x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_IsVirtualNetworkWithinDistanceLimit(
    NetworkSystem self,
    PingCachedData? sourcePing
);

void CreateVirtualLinksForPing1(PingCachedData ping) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NetworkSystem",
    "CreateVirtualLinksForPing1;PingCachedData",
    (NetworkSystem_CreateVirtualLinksForPing1 x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_CreateVirtualLinksForPing1(
    NetworkSystem self,
    PingCachedData? ping
);

void CreateVirtualLinksForPing(PingCachedData ping) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NetworkSystem",
    "CreateVirtualLinksForPing;PingCachedData",
    (NetworkSystem_CreateVirtualLinksForPing x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_CreateVirtualLinksForPing(
    NetworkSystem self,
    PingCachedData? ping
);

void CreateForksForVirtualLink1(SNetworkLinkData linkData, PingCachedData ping, Vector4 sphereCentre, float radius, Vector4 direction, Vector4[] vertices)

RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NetworkSystem",
    "CreateForksForVirtualLink1;SNetworkLinkDataPingCachedDataVector4FloatVector4script_ref<array<Vector4>>",
    (NetworkSystem_CreateForksForVirtualLink1 x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_CreateForksForVirtualLink1(
    NetworkSystem self,
    SNetworkLinkData linkData,
    PingCachedData? ping,
    Vector4 sphereCentre,
    float radius,
    Vector4 direction,
    List<Vector4> vertices
);

void CreateForksForVirtualLink1(SNetworkLinkData linkData, PingCachedData ping, Vector4 sphereCentre, float radius, Vector4 direction, Vector4 connectionPoint)

RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NetworkSystem",
    "CreateForksForVirtualLink1;SNetworkLinkDataPingCachedDataVector4FloatVector4Vector4",
    (NetworkSystem_CreateForksForVirtualLink12 x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_CreateForksForVirtualLink12(
    NetworkSystem self,
    SNetworkLinkData linkData,
    PingCachedData? ping,
    Vector4 sphereCentre,
    float radius,
    Vector4 direction,
    Vector4 connectionPoint
);

void CreateForksForVirtualLink(SNetworkLinkData linkData, PingCachedData ping, Vector4 sphereCentre, float radius, int slice)

RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NetworkSystem",
    "CreateForksForVirtualLink;SNetworkLinkDataPingCachedDataVector4FloatInt32",
    (NetworkSystem_CreateForksForVirtualLink x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_CreateForksForVirtualLink(
    NetworkSystem self,
    SNetworkLinkData linkData,
    PingCachedData? ping,
    Vector4 sphereCentre,
    float radius,
    int slice
);

void RemoveActivePing(int index) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NetworkSystem",
    "RemoveActivePing;Int32",
    (NetworkSystem_RemoveActivePing x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_RemoveActivePing(
    NetworkSystem self,
    int index
);

void RemoveActivePingBySource(ent.EntityID sourceID) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NetworkSystem",
    "RemoveActivePingBySource;EntityID",
    (NetworkSystem_RemoveActivePingBySource x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_RemoveActivePingBySource(
    NetworkSystem self,
    ent.EntityID sourceID
);

void RemoveAllActivePings() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NetworkSystem",
    "RemoveAllActivePings;",
    (NetworkSystem_RemoveAllActivePings x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_RemoveAllActivePings(
    NetworkSystem self
);

void RemoveAllActiveFakePings() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NetworkSystem",
    "RemoveAllActiveFakePings;",
    (NetworkSystem_RemoveAllActiveFakePings x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_RemoveAllActiveFakePings(
    NetworkSystem self
);

void RemoveAllPingLinks() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NetworkSystem",
    "RemoveAllPingLinks;",
    (NetworkSystem_RemoveAllPingLinks x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_RemoveAllPingLinks(
    NetworkSystem self
);

void RemoveAllPingLinksByType(ELinkType linkType) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NetworkSystem",
    "RemoveAllPingLinksByType;ELinkType",
    (NetworkSystem_RemoveAllPingLinksByType x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_RemoveAllPingLinksByType(
    NetworkSystem self,
    ELinkType linkType
);

void RemovePingLinksBySourceAndType(ELinkType linkType, ent.EntityID sourceID) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NetworkSystem",
    "RemovePingLinksBySourceAndType;ELinkTypeEntityID",
    (NetworkSystem_RemovePingLinksBySourceAndType x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_RemovePingLinksBySourceAndType(
    NetworkSystem self,
    ELinkType linkType,
    ent.EntityID sourceID
);

void RemovePingLinksBySource(ent.EntityID sourceID, bool intant) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NetworkSystem",
    "RemovePingLinksBySource;EntityIDBool",
    (NetworkSystem_RemovePingLinksBySource x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_RemovePingLinksBySource(
    NetworkSystem self,
    ent.EntityID sourceID,
    bool intant
);

void RemovePingLinksBySourceAndFxResource(ent.EntityID sourceID, game.FxResource fxResource, bool intant) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NetworkSystem",
    "RemovePingLinksBySourceAndFxResource;EntityIDFxResourceBool",
    (NetworkSystem_RemovePingLinksBySourceAndFxResource x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_RemovePingLinksBySourceAndFxResource(
    NetworkSystem self,
    ent.EntityID sourceID,
    game.FxResource fxResource,
    bool intant
);

void RemovePingLinksByFxResource(game.FxResource fxResource, bool intant) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NetworkSystem",
    "RemovePingLinksByFxResource;FxResourceBool",
    (NetworkSystem_RemovePingLinksByFxResource x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_RemovePingLinksByFxResource(
    NetworkSystem self,
    game.FxResource fxResource,
    bool intant
);

void RemoveActivePingBySourceAndType(ent.EntityID sourceID, EPingType pingType) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NetworkSystem",
    "RemoveActivePingBySourceAndType;EntityIDEPingType",
    (NetworkSystem_RemoveActivePingBySourceAndType x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_RemoveActivePingBySourceAndType(
    NetworkSystem self,
    ent.EntityID sourceID,
    EPingType pingType
);

bool HasActivePing(ent.EntityID sourceID) RTTI

Generated hook

re.Hooks.Place(
    "NetworkSystem",
    "HasActivePing;EntityID",
    (NetworkSystem_HasActivePing x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_HasActivePing(
    NetworkSystem self,
    ent.EntityID sourceID
);

PingCachedData? GetActivePing(ent.EntityID sourceID) RTTI

Generated hook

re.Hooks.Place(
    "NetworkSystem",
    "GetActivePing;EntityID",
    (NetworkSystem_GetActivePing x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.PingCachedData>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_GetActivePing(
    NetworkSystem self,
    ent.EntityID sourceID
);

ent.EntityID GetInitialPingSourceID() RTTI

Generated hook

re.Hooks.Place(
    "NetworkSystem",
    "GetInitialPingSourceID;",
    (NetworkSystem_GetInitialPingSourceID x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.ent.EntityID>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_GetInitialPingSourceID(
    NetworkSystem self
);

WeakHandle<game.Object> GetInitialPingSource() RTTI

EPingType GetPingType(ent.EntityID sourceID) RTTI

Generated hook

re.Hooks.Place(
    "NetworkSystem",
    "GetPingType;EntityID",
    (NetworkSystem_GetPingType x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.EPingType>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_GetPingType(
    NetworkSystem self,
    ent.EntityID sourceID
);

bool HasAnyActivePing() RTTI

Generated hook

re.Hooks.Place(
    "NetworkSystem",
    "HasAnyActivePing;",
    (NetworkSystem_HasAnyActivePing x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_HasAnyActivePing(
    NetworkSystem self
);

bool HasAnyActivePingWithRevealNetwork() RTTI

Generated hook

re.Hooks.Place(
    "NetworkSystem",
    "HasAnyActivePingWithRevealNetwork;",
    (NetworkSystem_HasAnyActivePingWithRevealNetwork x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_HasAnyActivePingWithRevealNetwork(
    NetworkSystem self
);

bool HasActivePingWithRevealNetwork(ent.EntityID sourceID) RTTI

Generated hook

re.Hooks.Place(
    "NetworkSystem",
    "HasActivePingWithRevealNetwork;EntityID",
    (NetworkSystem_HasActivePingWithRevealNetwork x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_HasActivePingWithRevealNetwork(
    NetworkSystem self,
    ent.EntityID sourceID
);

PingCachedData? GetLastActivePingWithRevealNetwork() RTTI

Generated hook

re.Hooks.Place(
    "NetworkSystem",
    "GetLastActivePingWithRevealNetwork;",
    (NetworkSystem_GetLastActivePingWithRevealNetwork x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.PingCachedData>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_GetLastActivePingWithRevealNetwork(
    NetworkSystem self
);

void IncreasePingLinbksCounter() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NetworkSystem",
    "IncreasePingLinbksCounter;",
    (NetworkSystem_IncreasePingLinbksCounter x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_IncreasePingLinbksCounter(
    NetworkSystem self
);

void DecreasePingLinbksCounter() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NetworkSystem",
    "DecreasePingLinbksCounter;",
    (NetworkSystem_DecreasePingLinbksCounter x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_DecreasePingLinbksCounter(
    NetworkSystem self
);

bool IsPingLinksLimitReached() RTTI

Generated hook

re.Hooks.Place(
    "NetworkSystem",
    "IsPingLinksLimitReached;",
    (NetworkSystem_IsPingLinksLimitReached x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_IsPingLinksLimitReached(
    NetworkSystem self
);

bool IsActivePingsLimitReached() RTTI

Generated hook

re.Hooks.Place(
    "NetworkSystem",
    "IsActivePingsLimitReached;",
    (NetworkSystem_IsActivePingsLimitReached x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_IsActivePingsLimitReached(
    NetworkSystem self
);

void OnAddPingedSquadRequest(AddPingedSquadRequest request) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NetworkSystem",
    "OnAddPingedSquadRequest;AddPingedSquadRequest",
    (NetworkSystem_OnAddPingedSquadRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_OnAddPingedSquadRequest(
    NetworkSystem self,
    AddPingedSquadRequest? request
);

void AddPingedSquad(CName squadName) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NetworkSystem",
    "AddPingedSquad;CName",
    (NetworkSystem_AddPingedSquad x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_AddPingedSquad(
    NetworkSystem self,
    CName squadName
);

void OnRemovePingedSquadRequest(RemovePingedSquadRequest request) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NetworkSystem",
    "OnRemovePingedSquadRequest;RemovePingedSquadRequest",
    (NetworkSystem_OnRemovePingedSquadRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_OnRemovePingedSquadRequest(
    NetworkSystem self,
    RemovePingedSquadRequest? request
);

void RemovePingedSquad(CName squadName) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NetworkSystem",
    "RemovePingedSquad;CName",
    (NetworkSystem_RemovePingedSquad x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_RemovePingedSquad(
    NetworkSystem self,
    CName squadName
);

void OnClearPingedSquadRequest(ClearPingedSquadRequest request) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NetworkSystem",
    "OnClearPingedSquadRequest;ClearPingedSquadRequest",
    (NetworkSystem_OnClearPingedSquadRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_OnClearPingedSquadRequest(
    NetworkSystem self,
    ClearPingedSquadRequest? request
);

void ClearPingedSquads() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NetworkSystem",
    "ClearPingedSquads;",
    (NetworkSystem_ClearPingedSquads x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_ClearPingedSquads(
    NetworkSystem self
);

bool IsSquadMarkedWithPing(CName squadName) RTTI

Generated hook

re.Hooks.Place(
    "NetworkSystem",
    "IsSquadMarkedWithPing;CName",
    (NetworkSystem_IsSquadMarkedWithPing x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_IsSquadMarkedWithPing(
    NetworkSystem self,
    CName squadName
);

bool HasDiffrentParentsThanTargets(ent.EntityID sourceID, ent.EntityID[] targets) RTTI

Generated hook

re.Hooks.Place(
    "NetworkSystem",
    "HasDiffrentParentsThanTargets;EntityIDscript_ref<array<EntityID>>",
    (NetworkSystem_HasDiffrentParentsThanTargets x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_HasDiffrentParentsThanTargets(
    NetworkSystem self,
    ent.EntityID sourceID,
    List<ent.EntityID> targets
);

bool HasDiffrentChildrenThanTargets(ent.EntityID sourceID, ent.EntityID[] targets) RTTI

Generated hook

re.Hooks.Place(
    "NetworkSystem",
    "HasDiffrentChildrenThanTargets;EntityIDscript_ref<array<EntityID>>",
    (NetworkSystem_HasDiffrentChildrenThanTargets x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_HasDiffrentChildrenThanTargets(
    NetworkSystem self,
    ent.EntityID sourceID,
    List<ent.EntityID> targets
);

void ResolveNetworkRevealTarget(SNetworkLinkData linkData) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NetworkSystem",
    "ResolveNetworkRevealTarget;script_ref<SNetworkLinkData>",
    (NetworkSystem_ResolveNetworkRevealTarget x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_ResolveNetworkRevealTarget(
    NetworkSystem self,
    SNetworkLinkData linkData
);

void AddNetworkRevealTarget(ent.EntityID target) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NetworkSystem",
    "AddNetworkRevealTarget;EntityID",
    (NetworkSystem_AddNetworkRevealTarget x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_AddNetworkRevealTarget(
    NetworkSystem self,
    ent.EntityID target
);

void RemoveNetworkRevealTarget(int index) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NetworkSystem",
    "RemoveNetworkRevealTarget;Int32",
    (NetworkSystem_RemoveNetworkRevealTarget x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_RemoveNetworkRevealTarget(
    NetworkSystem self,
    int index
);

void RevealNetworkOnCachedTarget(ent.EntityID[] targets) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NetworkSystem",
    "RevealNetworkOnCachedTarget;script_ref<array<EntityID>>",
    (NetworkSystem_RevealNetworkOnCachedTarget x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_RevealNetworkOnCachedTarget(
    NetworkSystem self,
    List<ent.EntityID> targets
);

void RevealEntireNetworkOnTarget(ent.EntityID target) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NetworkSystem",
    "RevealEntireNetworkOnTarget;EntityID",
    (NetworkSystem_RevealEntireNetworkOnTarget x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_RevealEntireNetworkOnTarget(
    NetworkSystem self,
    ent.EntityID target
);

void OnRevealNetworkRequestRequest(RevealNetworkRequestRequest request) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NetworkSystem",
    "OnRevealNetworkRequestRequest;RevealNetworkRequestRequest",
    (NetworkSystem_OnRevealNetworkRequestRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_OnRevealNetworkRequestRequest(
    NetworkSystem self,
    RevealNetworkRequestRequest? request
);

void SendRevealNetworkEvent(ent.EntityID target, float? delay) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NetworkSystem",
    "SendRevealNetworkEvent;EntityIDFloat",
    (NetworkSystem_SendRevealNetworkEvent x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_SendRevealNetworkEvent(
    NetworkSystem self,
    ent.EntityID target,
    float? delay
);

void SendRevealNetworkGridRequest(ent.EntityID target) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NetworkSystem",
    "SendRevealNetworkGridRequest;EntityID",
    (NetworkSystem_SendRevealNetworkGridRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_SendRevealNetworkGridRequest(
    NetworkSystem self,
    ent.EntityID target
);

bool IsIdValid(ent.EntityID id) RTTI

Generated hook

re.Hooks.Place(
    "NetworkSystem",
    "IsIdValid;EntityID",
    (NetworkSystem_IsIdValid x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_IsIdValid(
    NetworkSystem self,
    ent.EntityID id
);

WeakHandle<game.data.VirtualNetwork_Record> GetVirtualNetworkRecord() RTTI

Vector4 GetVirtualNetworkSegmentMarker(WeakHandle<game.data.VirtualNetwork_Record> virtualNetworkRecord) RTTI

Generated hook

re.Hooks.Place(
    "NetworkSystem",
    "GetVirtualNetworkSegmentMarker;VirtualNetwork_Record",
    (NetworkSystem_GetVirtualNetworkSegmentMarker x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Vector4>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_GetVirtualNetworkSegmentMarker(
    NetworkSystem self,
    WeakHandle<game.data.VirtualNetwork_Record> virtualNetworkRecord
);

int GetMaxNumberOfSegmentsForVirtualNetwork(WeakHandle<game.data.VirtualNetwork_Record> virtualNetworkRecord) RTTI

Generated hook

re.Hooks.Place(
    "NetworkSystem",
    "GetMaxNumberOfSegmentsForVirtualNetwork;VirtualNetwork_Record",
    (NetworkSystem_GetMaxNumberOfSegmentsForVirtualNetwork x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_GetMaxNumberOfSegmentsForVirtualNetwork(
    NetworkSystem self,
    WeakHandle<game.data.VirtualNetwork_Record> virtualNetworkRecord
);

float GetPingRange() RTTI

Generated hook

re.Hooks.Place(
    "NetworkSystem",
    "GetPingRange;",
    (NetworkSystem_GetPingRange x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_GetPingRange(
    NetworkSystem self
);

float GetSpacePingDuration() RTTI

Generated hook

re.Hooks.Place(
    "NetworkSystem",
    "GetSpacePingDuration;",
    (NetworkSystem_GetSpacePingDuration x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_GetSpacePingDuration(
    NetworkSystem self
);

float GetSpacePingAppearModifier() RTTI

Generated hook

re.Hooks.Place(
    "NetworkSystem",
    "GetSpacePingAppearModifier;",
    (NetworkSystem_GetSpacePingAppearModifier x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_GetSpacePingAppearModifier(
    NetworkSystem self
);

float GetNetworkReavealDuration() RTTI

Generated hook

re.Hooks.Place(
    "NetworkSystem",
    "GetNetworkReavealDuration;",
    (NetworkSystem_GetNetworkReavealDuration x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_GetNetworkReavealDuration(
    NetworkSystem self
);

bool ShouldNetworkElementsPersistAfterFocus() RTTI

Generated hook

re.Hooks.Place(
    "NetworkSystem",
    "ShouldNetworkElementsPersistAfterFocus;",
    (NetworkSystem_ShouldNetworkElementsPersistAfterFocus x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_ShouldNetworkElementsPersistAfterFocus(
    NetworkSystem self
);

bool ShouldForceInstantBeamKill() RTTI

Generated hook

re.Hooks.Place(
    "NetworkSystem",
    "ShouldForceInstantBeamKill;",
    (NetworkSystem_ShouldForceInstantBeamKill x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_ShouldForceInstantBeamKill(
    NetworkSystem self
);

float GetRevealMasterAfterLeavingFocusDuration() RTTI

Generated hook

re.Hooks.Place(
    "NetworkSystem",
    "GetRevealMasterAfterLeavingFocusDuration;",
    (NetworkSystem_GetRevealMasterAfterLeavingFocusDuration x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_GetRevealMasterAfterLeavingFocusDuration(
    NetworkSystem self
);

float GetRevealLinksAfterLeavingFocusDuration() RTTI

Generated hook

re.Hooks.Place(
    "NetworkSystem",
    "GetRevealLinksAfterLeavingFocusDuration;",
    (NetworkSystem_GetRevealLinksAfterLeavingFocusDuration x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_GetRevealLinksAfterLeavingFocusDuration(
    NetworkSystem self
);

float GetPingRevealDuration() RTTI

Generated hook

re.Hooks.Place(
    "NetworkSystem",
    "GetPingRevealDuration;",
    (NetworkSystem_GetPingRevealDuration x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_GetPingRevealDuration(
    NetworkSystem self
);

int GetAmmountOfPingDurationIntervals() RTTI

Generated hook

re.Hooks.Place(
    "NetworkSystem",
    "GetAmmountOfPingDurationIntervals;",
    (NetworkSystem_GetAmmountOfPingDurationIntervals x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_GetAmmountOfPingDurationIntervals(
    NetworkSystem self
);

int GetMaxFreePingLinks() RTTI

Generated hook

re.Hooks.Place(
    "NetworkSystem",
    "GetMaxFreePingLinks;",
    (NetworkSystem_GetMaxFreePingLinks x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_GetMaxFreePingLinks(
    NetworkSystem self
);

float GetVirtualLinkAngleTollerance() RTTI

Generated hook

re.Hooks.Place(
    "NetworkSystem",
    "GetVirtualLinkAngleTollerance;",
    (NetworkSystem_GetVirtualLinkAngleTollerance x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_GetVirtualLinkAngleTollerance(
    NetworkSystem self
);

float GetVirtualLinkForkAngleTollerance() RTTI

Generated hook

re.Hooks.Place(
    "NetworkSystem",
    "GetVirtualLinkForkAngleTollerance;",
    (NetworkSystem_GetVirtualLinkForkAngleTollerance x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_GetVirtualLinkForkAngleTollerance(
    NetworkSystem self
);

bool ShouldRevealMasterOnPulse() RTTI

Generated hook

re.Hooks.Place(
    "NetworkSystem",
    "ShouldRevealMasterOnPulse;",
    (NetworkSystem_ShouldRevealMasterOnPulse x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_ShouldRevealMasterOnPulse(
    NetworkSystem self
);

bool ShouldRevealSlaveOnPulse() RTTI

Generated hook

re.Hooks.Place(
    "NetworkSystem",
    "ShouldRevealSlaveOnPulse;",
    (NetworkSystem_ShouldRevealSlaveOnPulse x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_ShouldRevealSlaveOnPulse(
    NetworkSystem self
);

bool SuppressPingIfBackdoorsFound() RTTI

Generated hook

re.Hooks.Place(
    "NetworkSystem",
    "SuppressPingIfBackdoorsFound;",
    (NetworkSystem_SuppressPingIfBackdoorsFound x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_SuppressPingIfBackdoorsFound(
    NetworkSystem self
);

bool AllowSimultanousPinging() RTTI

Generated hook

re.Hooks.Place(
    "NetworkSystem",
    "AllowSimultanousPinging;",
    (NetworkSystem_AllowSimultanousPinging x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_AllowSimultanousPinging(
    NetworkSystem self
);

bool ShouldRevealNetworkAfterPulse() RTTI

Generated hook

re.Hooks.Place(
    "NetworkSystem",
    "ShouldRevealNetworkAfterPulse;",
    (NetworkSystem_ShouldRevealNetworkAfterPulse x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_ShouldRevealNetworkAfterPulse(
    NetworkSystem self
);

bool ShouldUsePulseOnPing() RTTI

Generated hook

re.Hooks.Place(
    "NetworkSystem",
    "ShouldUsePulseOnPing;",
    (NetworkSystem_ShouldUsePulseOnPing x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_ShouldUsePulseOnPing(
    NetworkSystem self
);

float GetPulseRange() RTTI

Generated hook

re.Hooks.Place(
    "NetworkSystem",
    "GetPulseRange;",
    (NetworkSystem_GetPulseRange x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_GetPulseRange(
    NetworkSystem self
);

bool ShouldPulsRealObject() RTTI

Generated hook

re.Hooks.Place(
    "NetworkSystem",
    "ShouldPulsRealObject;",
    (NetworkSystem_ShouldPulsRealObject x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_ShouldPulsRealObject(
    NetworkSystem self
);

bool ShouldShowLinksOnMaster() RTTI

Generated hook

re.Hooks.Place(
    "NetworkSystem",
    "ShouldShowLinksOnMaster;",
    (NetworkSystem_ShouldShowLinksOnMaster x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_ShouldShowLinksOnMaster(
    NetworkSystem self
);

bool QuickHacksExposedByDefault() RTTI

Generated hook

re.Hooks.Place(
    "NetworkSystem",
    "QuickHacksExposedByDefault;",
    (NetworkSystem_QuickHacksExposedByDefault x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_QuickHacksExposedByDefault(
    NetworkSystem self
);

bool ShouldShowOnlyTargetQuickHacks() RTTI

Generated hook

re.Hooks.Place(
    "NetworkSystem",
    "ShouldShowOnlyTargetQuickHacks;",
    (NetworkSystem_ShouldShowOnlyTargetQuickHacks x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_ShouldShowOnlyTargetQuickHacks(
    NetworkSystem self
);

WeakHandle<game.data.NetworkPingingParameteres_Record> GetPingPresetRecord() RTTI

void SetupPingPresetRecord() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "NetworkSystem",
    "SetupPingPresetRecord;",
    (NetworkSystem_SetupPingPresetRecord x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_SetupPingPresetRecord(
    NetworkSystem self
);

ent.EntityID GetLastPingSourceID() RTTI

Generated hook

re.Hooks.Place(
    "NetworkSystem",
    "GetLastPingSourceID;",
    (NetworkSystem_GetLastPingSourceID x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.ent.EntityID>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_GetLastPingSourceID(
    NetworkSystem self
);

Vector4 FindBestMatchingVertice(Vector4 point, Vector4 direction, float angle, float radius, Vector4 excludeVertice, Vector4[] vertices)

RTTI

Generated hook

re.Hooks.Place(
    "NetworkSystem",
    "FindBestMatchingVertice;Vector4Vector4FloatFloatVector4script_ref<array<Vector4>>",
    (NetworkSystem_FindBestMatchingVertice x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Vector4>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_FindBestMatchingVertice(
    NetworkSystem self,
    Vector4 point,
    Vector4 direction,
    float angle,
    float radius,
    Vector4 excludeVertice,
    List<Vector4> vertices
);

Vector4 GetRandomPoint(Vector4 direction, float radius, float angle) RTTI

Generated hook

re.Hooks.Place(
    "NetworkSystem",
    "GetRandomPoint;Vector4FloatFloat",
    (NetworkSystem_GetRandomPoint x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Vector4>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_GetRandomPoint(
    NetworkSystem self,
    Vector4 direction,
    float radius,
    float angle
);

Vector4 GetRandomPointOnSphere(Vector4 sphereCentre, float radius, int slice) RTTI

Generated hook

re.Hooks.Place(
    "NetworkSystem",
    "GetRandomPointOnSphere;Vector4FloatInt32",
    (NetworkSystem_GetRandomPointOnSphere x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Vector4>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_GetRandomPointOnSphere(
    NetworkSystem self,
    Vector4 sphereCentre,
    float radius,
    int slice
);

Vector4 GetRandomPointOnSphere(Vector4 sphereCentre, float radius) RTTI

Generated hook

re.Hooks.Place(
    "NetworkSystem",
    "GetRandomPointOnSphere;Vector4Float",
    (NetworkSystem_GetRandomPointOnSphere2 x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Vector4>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_GetRandomPointOnSphere2(
    NetworkSystem self,
    Vector4 sphereCentre,
    float radius
);

Vector4 GetRandomPointOnSphereQuadrant0() RTTI

Generated hook

re.Hooks.Place(
    "NetworkSystem",
    "GetRandomPointOnSphereQuadrant0;",
    (NetworkSystem_GetRandomPointOnSphereQuadrant0 x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Vector4>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_GetRandomPointOnSphereQuadrant0(
    NetworkSystem self
);

Vector4 GetRandomPointOnSphereInFacingQuadrant(Vector4 sphereCenter, float radius, Vector4 facePoint) RTTI

Generated hook

re.Hooks.Place(
    "NetworkSystem",
    "GetRandomPointOnSphereInFacingQuadrant;Vector4FloatVector4",
    (NetworkSystem_GetRandomPointOnSphereInFacingQuadrant x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Vector4>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_GetRandomPointOnSphereInFacingQuadrant(
    NetworkSystem self,
    Vector4 sphereCenter,
    float radius,
    Vector4 facePoint
);

HUDManager? GetHudManager() RTTI

Generated hook

re.Hooks.Place(
    "NetworkSystem",
    "GetHudManager;",
    (NetworkSystem_GetHudManager x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.HUDManager>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_GetHudManager(
    NetworkSystem self
);

static int GetMaxLinksRegisteredAtOnce() staticRTTI global

Generated hook

re.Hooks.Place(
    "NetworkSystem",
    "NetworkSystem::GetMaxLinksRegisteredAtOnce;",
    (NetworkSystem_GetMaxLinksRegisteredAtOnce x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_GetMaxLinksRegisteredAtOnce();

static int GetMaxLinksDeactivatedAtOnce() staticRTTI global

Generated hook

re.Hooks.Place(
    "NetworkSystem",
    "NetworkSystem::GetMaxLinksDeactivatedAtOnce;",
    (NetworkSystem_GetMaxLinksDeactivatedAtOnce x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_GetMaxLinksDeactivatedAtOnce();

static int GetVirtualLinkDepth() staticRTTI global

Generated hook

re.Hooks.Place(
    "NetworkSystem",
    "NetworkSystem::GetVirtualLinkDepth;",
    (NetworkSystem_GetVirtualLinkDepth x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_GetVirtualLinkDepth();

static int GetMaximumNumberOfFreeLinksPerTarget() staticRTTI global

Generated hook

re.Hooks.Place(
    "NetworkSystem",
    "NetworkSystem::GetMaximumNumberOfFreeLinksPerTarget;",
    (NetworkSystem_GetMaximumNumberOfFreeLinksPerTarget x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_GetMaximumNumberOfFreeLinksPerTarget();

static int GetMaxLinksDrawnAtOnce() staticRTTI global

Generated hook

re.Hooks.Place(
    "NetworkSystem",
    "NetworkSystem::GetMaxLinksDrawnAtOnce;",
    (NetworkSystem_GetMaxLinksDrawnAtOnce x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_GetMaxLinksDrawnAtOnce();

static int GetMaxLinksDrawnInTotal() staticRTTI global

Generated hook

re.Hooks.Place(
    "NetworkSystem",
    "NetworkSystem::GetMaxLinksDrawnInTotal;",
    (NetworkSystem_GetMaxLinksDrawnInTotal x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_GetMaxLinksDrawnInTotal();

static void SendEvaluateVisionModeRequest(ScriptGameInstance instance, game.VisionModeType mode) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "NetworkSystem",
    "NetworkSystem::SendEvaluateVisionModeRequest;GameInstancegameVisionModeType",
    (NetworkSystem_SendEvaluateVisionModeRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_SendEvaluateVisionModeRequest(
    ScriptGameInstance instance,
    game.VisionModeType mode
);

static int GetMaximumNumberOfActivePings() staticRTTI global

Generated hook

re.Hooks.Place(
    "NetworkSystem",
    "NetworkSystem::GetMaximumNumberOfActivePings;",
    (NetworkSystem_GetMaximumNumberOfActivePings x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_GetMaximumNumberOfActivePings();

static int GetMaxAmountOfVirtualLinkForks() staticRTTI global

Generated hook

re.Hooks.Place(
    "NetworkSystem",
    "NetworkSystem::GetMaxAmountOfVirtualLinkForks;",
    (NetworkSystem_GetMaxAmountOfVirtualLinkForks x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_GetMaxAmountOfVirtualLinkForks();

static int GetNumberOfVirtualLinksPerObject() staticRTTI global

Generated hook

re.Hooks.Place(
    "NetworkSystem",
    "NetworkSystem::GetNumberOfVirtualLinksPerObject;",
    (NetworkSystem_GetNumberOfVirtualLinksPerObject x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_GetNumberOfVirtualLinksPerObject();

static bool QuickHacksExposedByDefault(ScriptGameInstance game) staticRTTI global

Generated hook

re.Hooks.Place(
    "NetworkSystem",
    "NetworkSystem::QuickHacksExposedByDefault;GameInstance",
    (NetworkSystem_QuickHacksExposedByDefault2 x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_QuickHacksExposedByDefault2(
    ScriptGameInstance game
);

static bool ShouldShowOnlyTargetQuickHacks(ScriptGameInstance game) staticRTTI global

Generated hook

re.Hooks.Place(
    "NetworkSystem",
    "NetworkSystem::ShouldShowOnlyTargetQuickHacks;GameInstance",
    (NetworkSystem_ShouldShowOnlyTargetQuickHacks2 x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_ShouldShowOnlyTargetQuickHacks2(
    ScriptGameInstance game
);

static float GetVirtualLinksSphereRadius() staticRTTI global

Generated hook

re.Hooks.Place(
    "NetworkSystem",
    "NetworkSystem::GetVirtualLinksSphereRadius;",
    (NetworkSystem_GetVirtualLinksSphereRadius x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct NetworkSystem_GetVirtualLinksSphereRadius();