class game

PreventionSpawnSystem

game.PreventionSpawnSystem

0 properties
50 functions

Extends game.IPreventionSpawnSystem game.IGameSystem IScriptable ISerializable

Properties

None.

Functions

void CancelSpawnRequest(uint requestID) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamePreventionSpawnSystem",
    "CancelSpawnRequest",
    (PreventionSpawnSystem_CancelSpawnRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSpawnSystem_CancelSpawnRequest(
    game.PreventionSpawnSystem self,
    uint requestID
);

void CancelAllSpawnRequests() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamePreventionSpawnSystem",
    "CancelAllSpawnRequests",
    (PreventionSpawnSystem_CancelAllSpawnRequests x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSpawnSystem_CancelAllSpawnRequests(
    game.PreventionSpawnSystem self
);

uint RequestUnitSpawn(TDBID recordID, WorldTransform spawnTransform) RTTI

Generated hook

re.Hooks.Place(
    "gamePreventionSpawnSystem",
    "RequestUnitSpawn",
    (PreventionSpawnSystem_RequestUnitSpawn x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Uint>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSpawnSystem_RequestUnitSpawn(
    game.PreventionSpawnSystem self,
    TDBID recordID,
    WorldTransform spawnTransform
);

uint RequestChaseVehicle(TDBID vehicleRecordID, TDBID[] passengersRecordIDs, vehicle.BaseStrategyRequest strategy) RTTI

Generated hook

re.Hooks.Place(
    "gamePreventionSpawnSystem",
    "RequestChaseVehicle",
    (PreventionSpawnSystem_RequestChaseVehicle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Uint>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSpawnSystem_RequestChaseVehicle(
    game.PreventionSpawnSystem self,
    TDBID vehicleRecordID,
    TDBID[] passengersRecordIDs,
    vehicle.BaseStrategyRequest? strategy
);

void SetStrategyPreCheckRequests(vehicle.BaseStrategyRequest[] preCheckRequests) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamePreventionSpawnSystem",
    "SetStrategyPreCheckRequests",
    (PreventionSpawnSystem_SetStrategyPreCheckRequests x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSpawnSystem_SetStrategyPreCheckRequests(
    game.PreventionSpawnSystem self,
    vehicle.BaseStrategyRequest[] preCheckRequests
);

void ClearStrategyPreCheckRequests() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamePreventionSpawnSystem",
    "ClearStrategyPreCheckRequests",
    (PreventionSpawnSystem_ClearStrategyPreCheckRequests x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSpawnSystem_ClearStrategyPreCheckRequests(
    game.PreventionSpawnSystem self
);

bool IsStrategyAvailable(vehicle.PoliceStrategy strategy) RTTI

Generated hook

re.Hooks.Place(
    "gamePreventionSpawnSystem",
    "IsStrategyAvailable",
    (PreventionSpawnSystem_IsStrategyAvailable x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSpawnSystem_IsStrategyAvailable(
    game.PreventionSpawnSystem self,
    vehicle.PoliceStrategy strategy
);

bool IsAnyStrategyAvailable() RTTI

Generated hook

re.Hooks.Place(
    "gamePreventionSpawnSystem",
    "IsAnyStrategyAvailable",
    (PreventionSpawnSystem_IsAnyStrategyAvailable x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSpawnSystem_IsAnyStrategyAvailable(
    game.PreventionSpawnSystem self
);

bool GetAvailableStrategies(out vehicle.PoliceStrategy[] strategies) RTTI

Generated hook

re.Hooks.Place(
    "gamePreventionSpawnSystem",
    "GetAvailableStrategies",
    (PreventionSpawnSystem_GetAvailableStrategies x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSpawnSystem_GetAvailableStrategies(
    game.PreventionSpawnSystem self,
    vehicle.PoliceStrategy[] strategies
);

vehicle.PoliceStrategy GetRandomAvailableStrategyInRange(byte minStrat, byte maxStrat) RTTI

Generated hook

re.Hooks.Place(
    "gamePreventionSpawnSystem",
    "GetRandomAvailableStrategyInRange",
    (PreventionSpawnSystem_GetRandomAvailableStrategyInRange x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.vehicle.PoliceStrategy>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSpawnSystem_GetRandomAvailableStrategyInRange(
    game.PreventionSpawnSystem self,
    byte minStrat,
    byte maxStrat
);

vehicle.PoliceStrategy GetRandomAvailableStrategy(vehicle.PoliceStrategy[] wantedStrategies) RTTI

Generated hook

re.Hooks.Place(
    "gamePreventionSpawnSystem",
    "GetRandomAvailableStrategy",
    (PreventionSpawnSystem_GetRandomAvailableStrategy x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.vehicle.PoliceStrategy>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSpawnSystem_GetRandomAvailableStrategy(
    game.PreventionSpawnSystem self,
    vehicle.PoliceStrategy[] wantedStrategies
);

void DebugTryOverrideWithForcedStrategy(out vehicle.PoliceStrategy strategy) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamePreventionSpawnSystem",
    "DebugTryOverrideWithForcedStrategy",
    (PreventionSpawnSystem_DebugTryOverrideWithForcedStrategy x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSpawnSystem_DebugTryOverrideWithForcedStrategy(
    game.PreventionSpawnSystem self,
    vehicle.PoliceStrategy strategy
);

Vector4 GetIntersectionInFrontOfPlayerPos() RTTI

Generated hook

re.Hooks.Place(
    "gamePreventionSpawnSystem",
    "GetIntersectionInFrontOfPlayerPos",
    (PreventionSpawnSystem_GetIntersectionInFrontOfPlayerPos x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Vector4>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSpawnSystem_GetIntersectionInFrontOfPlayerPos(
    game.PreventionSpawnSystem self
);

bool IsPlayerOnHighway() RTTI

Generated hook

re.Hooks.Place(
    "gamePreventionSpawnSystem",
    "IsPlayerOnHighway",
    (PreventionSpawnSystem_IsPlayerOnHighway x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSpawnSystem_IsPlayerOnHighway(
    game.PreventionSpawnSystem self
);

bool IsPlayerInDogTown() RTTI

Generated hook

re.Hooks.Place(
    "gamePreventionSpawnSystem",
    "IsPlayerInDogTown",
    (PreventionSpawnSystem_IsPlayerInDogTown x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSpawnSystem_IsPlayerInDogTown(
    game.PreventionSpawnSystem self
);

void GetNearestRoadFromPlayerInfo(out game.NearestRoadFromPlayerInfo info) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamePreventionSpawnSystem",
    "GetNearestRoadFromPlayerInfo",
    (PreventionSpawnSystem_GetNearestRoadFromPlayerInfo x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSpawnSystem_GetNearestRoadFromPlayerInfo(
    game.PreventionSpawnSystem self,
    game.NearestRoadFromPlayerInfo info
);

uint RequestRoadBlockadeSpawn(TDBID[] vehiclessRecordIDs, Vector2 spawnDistanceRange, uint numberNPCsPerCar) RTTI

Generated hook

re.Hooks.Place(
    "gamePreventionSpawnSystem",
    "RequestRoadBlockadeSpawn",
    (PreventionSpawnSystem_RequestRoadBlockadeSpawn x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Uint>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSpawnSystem_RequestRoadBlockadeSpawn(
    game.PreventionSpawnSystem self,
    TDBID[] vehiclessRecordIDs,
    Vector2 spawnDistanceRange,
    uint numberNPCsPerCar
);

uint RequestAVSpawnPoints(WeakHandle<IScriptable> scriptable, string functionName, Vector2 spawnDistanceRange, uint maxSpawnPoints, bool useOffTrafficPoints)

RTTI

Generated hook

re.Hooks.Place(
    "gamePreventionSpawnSystem",
    "RequestAVSpawnPoints",
    (PreventionSpawnSystem_RequestAVSpawnPoints x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Uint>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSpawnSystem_RequestAVSpawnPoints(
    game.PreventionSpawnSystem self,
    WeakHandle<IScriptable> scriptable,
    string functionName,
    Vector2 spawnDistanceRange,
    uint maxSpawnPoints,
    bool useOffTrafficPoints
);

uint RequestAVSpawnAtLocation(TDBID recordID, Vector3 location) RTTI

Generated hook

re.Hooks.Place(
    "gamePreventionSpawnSystem",
    "RequestAVSpawnAtLocation",
    (PreventionSpawnSystem_RequestAVSpawnAtLocation x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Uint>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSpawnSystem_RequestAVSpawnAtLocation(
    game.PreventionSpawnSystem self,
    TDBID recordID,
    Vector3 location
);

uint RequestAVSpawn(TDBID recordID, Vector2 spawnDistanceRange, bool useOffTrafficPoints) RTTI

Generated hook

re.Hooks.Place(
    "gamePreventionSpawnSystem",
    "RequestAVSpawn",
    (PreventionSpawnSystem_RequestAVSpawn x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Uint>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSpawnSystem_RequestAVSpawn(
    game.PreventionSpawnSystem self,
    TDBID recordID,
    Vector2 spawnDistanceRange,
    bool useOffTrafficPoints
);

void ReinitAll() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamePreventionSpawnSystem",
    "ReinitAll",
    (PreventionSpawnSystem_ReinitAll x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSpawnSystem_ReinitAll(
    game.PreventionSpawnSystem self
);

void RequestDespawn(ent.EntityID entityID) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamePreventionSpawnSystem",
    "RequestDespawn",
    (PreventionSpawnSystem_RequestDespawn x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSpawnSystem_RequestDespawn(
    game.PreventionSpawnSystem self,
    ent.EntityID entityID
);

void RequestDespawnVehicleAndPassengers(WeakHandle<vehicle.BaseObject> vehicle) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamePreventionSpawnSystem",
    "RequestDespawnVehicleAndPassengers",
    (PreventionSpawnSystem_RequestDespawnVehicleAndPassengers x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSpawnSystem_RequestDespawnVehicleAndPassengers(
    game.PreventionSpawnSystem self,
    WeakHandle<vehicle.BaseObject> vehicle
);

void RequestDespawnAll(bool shouldUseAggressiveDespawn) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamePreventionSpawnSystem",
    "RequestDespawnAll",
    (PreventionSpawnSystem_RequestDespawnAll x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSpawnSystem_RequestDespawnAll(
    game.PreventionSpawnSystem self,
    bool shouldUseAggressiveDespawn
);

int GetNumberOfSpawnedPreventionUnits() RTTI

Generated hook

re.Hooks.Place(
    "gamePreventionSpawnSystem",
    "GetNumberOfSpawnedPreventionUnits",
    (PreventionSpawnSystem_GetNumberOfSpawnedPreventionUnits x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSpawnSystem_GetNumberOfSpawnedPreventionUnits(
    game.PreventionSpawnSystem self
);

bool IsPreventionVehicleEnabled() RTTI

Generated hook

re.Hooks.Place(
    "gamePreventionSpawnSystem",
    "IsPreventionVehicleEnabled",
    (PreventionSpawnSystem_IsPreventionVehicleEnabled x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSpawnSystem_IsPreventionVehicleEnabled(
    game.PreventionSpawnSystem self
);

void FindPursuitPointsRangeAsync(Vector4[] spawnOriginPositions, float radiusMin, float radiusMax, uint unitCount, TDBID[] characterRecords, bool navVisCheck, NavGenAgentSize agentSize, WeakHandle<IScriptable> scriptable, string functionName)

RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamePreventionSpawnSystem",
    "FindPursuitPointsRangeAsync",
    (PreventionSpawnSystem_FindPursuitPointsRangeAsync x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSpawnSystem_FindPursuitPointsRangeAsync(
    game.PreventionSpawnSystem self,
    List<Vector4> spawnOriginPositions,
    float radiusMin,
    float radiusMax,
    uint unitCount,
    TDBID[] characterRecords,
    bool navVisCheck,
    NavGenAgentSize agentSize,
    WeakHandle<IScriptable> scriptable,
    string functionName
);

void ToggleFreeArea(NodeRef areaReference, bool enable) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamePreventionSpawnSystem",
    "ToggleFreeArea",
    (PreventionSpawnSystem_ToggleFreeArea x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSpawnSystem_ToggleFreeArea(
    game.PreventionSpawnSystem self,
    NodeRef areaReference,
    bool enable
);

void TogglePreventionQuestTrigger(NodeRef areaReference, bool enable) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamePreventionSpawnSystem",
    "TogglePreventionQuestTrigger",
    (PreventionSpawnSystem_TogglePreventionQuestTrigger x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSpawnSystem_TogglePreventionQuestTrigger(
    game.PreventionSpawnSystem self,
    NodeRef areaReference,
    bool enable
);

bool GetPreventionSystemCanSpawnInCrowd() RTTI

Generated hook

re.Hooks.Place(
    "gamePreventionSpawnSystem",
    "GetPreventionSystemCanSpawnInCrowd",
    (PreventionSpawnSystem_GetPreventionSystemCanSpawnInCrowd x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSpawnSystem_GetPreventionSystemCanSpawnInCrowd(
    game.PreventionSpawnSystem self
);

void RegisterEntityDeathCallback(WeakHandle<IScriptable> scriptable, string functionName, ent.EntityID entityID) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamePreventionSpawnSystem",
    "RegisterEntityDeathCallback",
    (PreventionSpawnSystem_RegisterEntityDeathCallback x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSpawnSystem_RegisterEntityDeathCallback(
    game.PreventionSpawnSystem self,
    WeakHandle<IScriptable> scriptable,
    string functionName,
    ent.EntityID entityID
);

void UnregisterEntityDeathCallback(WeakHandle<IScriptable> scriptable, string functionName, ent.EntityID entityID) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamePreventionSpawnSystem",
    "UnregisterEntityDeathCallback",
    (PreventionSpawnSystem_UnregisterEntityDeathCallback x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSpawnSystem_UnregisterEntityDeathCallback(
    game.PreventionSpawnSystem self,
    WeakHandle<IScriptable> scriptable,
    string functionName,
    ent.EntityID entityID
);

void TogglePreventionCrowdSpawns(bool toggle) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamePreventionSpawnSystem",
    "TogglePreventionCrowdSpawns",
    (PreventionSpawnSystem_TogglePreventionCrowdSpawns x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSpawnSystem_TogglePreventionCrowdSpawns(
    game.PreventionSpawnSystem self,
    bool toggle
);

void TogglePreventionActive(bool isActive) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamePreventionSpawnSystem",
    "TogglePreventionActive",
    (PreventionSpawnSystem_TogglePreventionActive x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSpawnSystem_TogglePreventionActive(
    game.PreventionSpawnSystem self,
    bool isActive
);

void InterruptAllActionAndCommands(WeakHandle<vehicle.BaseObject> veh) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamePreventionSpawnSystem",
    "InterruptAllActionAndCommands",
    (PreventionSpawnSystem_InterruptAllActionAndCommands x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSpawnSystem_InterruptAllActionAndCommands(
    game.PreventionSpawnSystem self,
    WeakHandle<vehicle.BaseObject> veh
);

bool IsPointInPreventionFreeArea(Vector4 point) RTTI

Generated hook

re.Hooks.Place(
    "gamePreventionSpawnSystem",
    "IsPointInPreventionFreeArea",
    (PreventionSpawnSystem_IsPointInPreventionFreeArea x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSpawnSystem_IsPointInPreventionFreeArea(
    game.PreventionSpawnSystem self,
    Vector4 point
);

bool IsEntityRegistered(ent.EntityID id) RTTI

Generated hook

re.Hooks.Place(
    "gamePreventionSpawnSystem",
    "IsEntityRegistered",
    (PreventionSpawnSystem_IsEntityRegistered x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSpawnSystem_IsEntityRegistered(
    game.PreventionSpawnSystem self,
    ent.EntityID id
);

void MarkAsDead(ent.EntityID entityID) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamePreventionSpawnSystem",
    "MarkAsDead",
    (PreventionSpawnSystem_MarkAsDead x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSpawnSystem_MarkAsDead(
    game.PreventionSpawnSystem self,
    ent.EntityID entityID
);

bool TryGetVehicleType(ent.EntityID id, out game.DynamicVehicleType vehicleType) RTTI

Generated hook

re.Hooks.Place(
    "gamePreventionSpawnSystem",
    "TryGetVehicleType",
    (PreventionSpawnSystem_TryGetVehicleType x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSpawnSystem_TryGetVehicleType(
    game.PreventionSpawnSystem self,
    ent.EntityID id,
    game.DynamicVehicleType vehicleType
);

void NotifyPlayerMounted(bool isPlayerMounted) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamePreventionSpawnSystem",
    "NotifyPlayerMounted",
    (PreventionSpawnSystem_NotifyPlayerMounted x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSpawnSystem_NotifyPlayerMounted(
    game.PreventionSpawnSystem self,
    bool isPlayerMounted
);

bool IsPlayerInSoftDeescalationTrigger() RTTI

Generated hook

re.Hooks.Place(
    "gamePreventionSpawnSystem",
    "IsPlayerInSoftDeescalationTrigger",
    (PreventionSpawnSystem_IsPlayerInSoftDeescalationTrigger x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSpawnSystem_IsPlayerInSoftDeescalationTrigger(
    game.PreventionSpawnSystem self
);

bool IsInUnmountingRange(Vector3 position) RTTI

Generated hook

re.Hooks.Place(
    "gamePreventionSpawnSystem",
    "IsInUnmountingRange",
    (PreventionSpawnSystem_IsInUnmountingRange x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSpawnSystem_IsInUnmountingRange(
    game.PreventionSpawnSystem self,
    Vector3 position
);

void SpawnRequestFinished(game.SpawnRequestResult requestResult) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamePreventionSpawnSystem",
    "SpawnRequestFinished;SpawnRequestResult",
    (PreventionSpawnSystem_SpawnRequestFinished x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSpawnSystem_SpawnRequestFinished(
    game.PreventionSpawnSystem self,
    game.SpawnRequestResult requestResult
);

void DespawnCallback(ent.EntityID entityID) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamePreventionSpawnSystem",
    "DespawnCallback;EntityID",
    (PreventionSpawnSystem_DespawnCallback x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSpawnSystem_DespawnCallback(
    game.PreventionSpawnSystem self,
    ent.EntityID entityID
);

bool TryFillPreventionSystemDebugData(out game.PreventionSystemDebugData dataToFill) RTTI

Generated hook

re.Hooks.Place(
    "gamePreventionSpawnSystem",
    "TryFillPreventionSystemDebugData;PreventionSystemDebugData",
    (PreventionSpawnSystem_TryFillPreventionSystemDebugData x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSpawnSystem_TryFillPreventionSystemDebugData(
    game.PreventionSpawnSystem self,
    game.PreventionSystemDebugData dataToFill
);

void Debug_EmulateDamageDealt(float damageAmount) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamePreventionSpawnSystem",
    "Debug_EmulateDamageDealt;Float",
    (PreventionSpawnSystem_Debug_EmulateDamageDealt x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSpawnSystem_Debug_EmulateDamageDealt(
    game.PreventionSpawnSystem self,
    float damageAmount
);

void VehicleEarlyInit(vehicle.WheeledBaseObject vehicleObject) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamePreventionSpawnSystem",
    "VehicleEarlyInit;WheeledObject",
    (PreventionSpawnSystem_VehicleEarlyInit x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSpawnSystem_VehicleEarlyInit(
    game.PreventionSpawnSystem self,
    vehicle.WheeledBaseObject? vehicleObject
);

void RoadblockadeNPCEarlyInit(game.Puppet puppet) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamePreventionSpawnSystem",
    "RoadblockadeNPCEarlyInit;gamePuppet",
    (PreventionSpawnSystem_RoadblockadeNPCEarlyInit x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSpawnSystem_RoadblockadeNPCEarlyInit(
    game.PreventionSpawnSystem self,
    game.Puppet? puppet
);

void OnEnterPreventionQuestTrigger(bool disablePreventionSystem) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamePreventionSpawnSystem",
    "OnEnterPreventionQuestTrigger;Bool",
    (PreventionSpawnSystem_OnEnterPreventionQuestTrigger x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSpawnSystem_OnEnterPreventionQuestTrigger(
    game.PreventionSpawnSystem self,
    bool disablePreventionSystem
);

vehicle.PoliceStrategy SetIfAvailable(vehicle.PoliceStrategy value) RTTI

Generated hook

re.Hooks.Place(
    "gamePreventionSpawnSystem",
    "SetIfAvailable;vehiclePoliceStrategy",
    (PreventionSpawnSystem_SetIfAvailable x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.vehicle.PoliceStrategy>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSpawnSystem_SetIfAvailable(
    game.PreventionSpawnSystem self,
    vehicle.PoliceStrategy value
);