class

PreventionSystem

108 properties
320 functions

Extends game.ScriptableSystem game.IScriptableSystem IScriptable ISerializable

Properties

Property	Type	Offset
`districtManager`	`DistrictManager?`	`0x0`	scripted
`agentRegistry`	`PoliceAgentRegistry?`	`0x10`	scripted
`ignoreSecurityAreasByQuest`	`bool`	`0x20`	scripted
`forceEternalGreyStars`	`bool`	`0x21`	scripted
`blockOnFootSpawnByQuest`	`bool`	`0x22`	scripted
`blockVehicleSpawnByQuest`	`bool`	`0x23`	scripted
`blockReconDroneSpawnByQuest`	`bool`	`0x24`	scripted
`crimeScoreMultiplierByQuest`	`float`	`0x28`	scripted
`preventionQuestEventSources`	`CName[]`	`0x30`	scripted
`systemLockSources`	`CName[]`	`0x40`	scripted
`systemEnabled`	`bool`	`0x50`	scripted
`player`	`WeakHandle<PlayerPuppet>`	`0x58`	scripted
`preventionPreset`	`WeakHandle<game.data.DistrictPreventionData_Record>`	`0x68`	scripted
`preventionDataMatrix`	`WeakHandle<game.data.PreventionHeatDataMatrix_Record>`	`0x78`	scripted
`preventionDataTable`	`WeakHandle<game.data.PreventionHeatTable_Record>`	`0x88`	scripted
`systemLocked`	`bool`	`0x98`	scripted
`nodeEventSources`	`CName[]`	`0xA0`	scripted
`heatStage`	`EPreventionHeatStage`	`0xB0`	scripted
`heatChangeReason`	`string`	`0xB8`	scripted
`ignoreSecurityAreas`	`bool`	`0xD8`	scripted
`playerIsInSecurityArea`	`game.PersistentID[]`	`0xE0`	scripted
`playerIsInPreventionFreeArea`	`bool`	`0xF0`	scripted
`policeSecuritySystems`	`game.PersistentID[]`	`0xF8`	scripted
`agentGroupsList`	`PreventionAgents?[]`	`0x108`	scripted
`lastKnownPosition`	`Vector4`	`0x120`	scripted
`lastKnownVehicle`	`WeakHandle<vehicle.BaseObject>`	`0x130`	scripted
`districtMultiplier`	`float`	`0x140`	scripted
`shouldForceStarStateUIToActive`	`bool`	`0x144`	scripted
`lastAttackTime`	`float`	`0x148`	scripted
`lastAttackTargetIDs`	`ent.EntityID[]`	`0x150`	scripted
`viewers`	`WeakHandle<game.Object>[]`	`0x160`	scripted
`hasViewers`	`bool`	`0x170`	scripted
`starState`	`EStarState`	`0x171`	scripted
`starStateUIChanged`	`bool`	`0x175`	scripted
`isPlayerMounted`	`bool`	`0x176`	scripted
`policeKnowsPlayerLocation`	`bool`	`0x177`	scripted
`isInitialSearchState`	`bool`	`0x178`	scripted
`heatLevelChanged`	`bool`	`0x179`	scripted
`playerCrossedBufferDistance`	`bool`	`0x17A`	scripted
`crimescoreTimerDelayID`	`game.DelayID`	`0x17C`	scripted
`starStateBufferTimerDelayID`	`game.DelayID`	`0x184`	scripted
`beliefAccuracyTimerDelayID`	`game.DelayID`	`0x18C`	scripted
`blinkingStatusDelayID`	`game.DelayID`	`0x194`	scripted
`searchingStatusDelayID`	`game.DelayID`	`0x19C`	scripted
`transitionToGreyStateDelayID`	`game.DelayID`	`0x1A4`	scripted
`policemenSpawnDelayID`	`game.DelayID`	`0x1AC`	scripted
`securityAreaResetDelayID`	`game.DelayID`	`0x1B4`	scripted
`inputlockDelayID`	`game.DelayID`	`0x1BC`	scripted
`freeAreaResetDelayID`	`game.DelayID`	`0x1C4`	scripted
`securityAreaResetCheck`	`bool`	`0x1CC`	scripted
`hadOngoingSpawnRequest`	`bool`	`0x1CD`	scripted
`totalCrimeScore`	`float`	`0x1D0`	scripted
`canSpawnFallbackEarly`	`bool`	`0x1D4`	scripted
`failsafePoliceRecordT1`	`TDBID`	`0x1D8`	scripted
`failsafePoliceRecordT2`	`TDBID`	`0x1E0`	scripted
`failsafePoliceRecordT3`	`TDBID`	`0x1E8`	scripted
`blinkReasonsStack`	`CName[]`	`0x1F0`	scripted
`wantedBarBlackboard`	`WeakHandle<game.IBlackboard>`	`0x200`	scripted
`onPlayerChoiceCallID`	`red.CallbackObject?`	`0x210`	scripted
`playerAttachedCallbackID`	`uint`	`0x220`	scripted
`playerDetachedCallbackID`	`uint`	`0x224`	scripted
`playerHLSID`	`red.CallbackObject?`	`0x228`	scripted
`playerVehicleStateID`	`red.CallbackObject?`	`0x238`	scripted
`playerHLS`	`game.PSMHighLevel`	`0x248`	scripted
`playerVehicleState`	`game.PSMVehicle`	`0x24C`	scripted
`unhandledInputsReceived`	`int`	`0x250`	scripted
`preventionUnitKilledDuringLock`	`bool`	`0x254`	scripted
`previousHitTargetID`	`ent.EntityID`	`0x258`	scripted
`previousHitAttackTime`	`float`	`0x260`	scripted
`reconPhaseEnabled`	`bool`	`0x264`	scripted
`reconDeployed`	`bool`	`0x265`	scripted
`reconDestroyed`	`bool`	`0x266`	scripted
`minHeatLevel`	`EPreventionHeatStage`	`0x267`	scripted
`maxHeatLevel`	`EPreventionHeatStage`	`0x26B`	scripted
`defaultHeatLevels`	`bool`	`0x26F`	scripted
`vehicleSpawnBlockSide`	`EVehicleSpawnBlockSide`	`0x270`	scripted
`damageToPlayerMultiplier`	`float`	`0x274`	scripted
`chaseMultiplier`	`float`	`0x278`	scripted
`policeChaseBlackboard`	`WeakHandle<game.IBlackboard>`	`0x280`	scripted
`blockShootingFromVehicle`	`bool`	`0x290`	scripted
`Debug_ProcessReason`	`EPreventionDebugProcessReason`	`0x291`	scripted
`Debug_LastAttackType`	`game.data.AttackType`	`0x295`	scripted
`Debug_LastDamageDealt`	`float`	`0x29C`	scripted
`Debug_LastCrimeDistance`	`float`	`0x2A0`	scripted
`Debug_lastAVRequestedSpawnPosition`	`Vector3`	`0x2A4`	scripted
`temp_const_false`	`bool`	`0x2B0`	scripted
`preventionTickCaller`	`IntervalCaller?`	`0x2B8`	scripted
`roadblockadeRespawnTickCaller`	`IntervalCaller?`	`0x2C8`	scripted
`maxtacTicketID`	`uint`	`0x2D8`	scripted
`avSpawnPointList`	`Vector3[]`	`0x2E0`	scripted
`maxAllowedDistanceToPlayer`	`float`	`0x2F0`	scripted
`lastAVRequestedSpawnPositionsArray`	`Vector4[]`	`0x2F8`	scripted
`shouldPreventionUnitsStartRetreating`	`bool`	`0x308`	scripted
`numberOfMaxtacSquadsSpawned`	`int`	`0x30C`	scripted
`maxtacTroopBeingAliveTimeStamp`	`float`	`0x310`	scripted
`civilianVehicleDestructionCount`	`int`	`0x314`	scripted
`lastCivilianVehicleDestructionTimeStamp`	`float`	`0x318`	scripted
`civilianVehicleDestructionThreshold`	`int`	`0x31C`	scripted
`civilianVehicleDestructionTimeout`	`float`	`0x320`	scripted
`vehicleSpawnTickCaller`	`IntervalCaller?`	`0x328`	scripted
`ressuplyVehicleTicketCaller`	`IntervalCaller?`	`0x338`	scripted
`isVehicleDelayOver`	`bool`	`0x348`	scripted
`currentVehicleTicketCount`	`int`	`0x34C`	scripted
`failedVehicleSpawnAttempts`	`int`	`0x350`	scripted
`codeRedReinforcement`	`bool`	`0x354`	scripted
`lastStarChangeTimeStamp`	`float`	`0x358`	scripted
`firstStarTimeStamp`	`float`	`0x35C`	scripted
`setCallRejectionIncrement`	`bool`	`0x360`	scripted

Functions

void OnAttach() overrideRTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_OnAttach(
    PreventionSystem self
);

void OnDetach() overrideRTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_OnDetach(
    PreventionSystem self
);

void OnRestored(int saveVersion, int gameVersion) overrideRTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "OnRestored;Int32Int32",
    (PreventionSystem_OnRestored x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_OnRestored(
    PreventionSystem self,
    int saveVersion,
    int gameVersion
);

bool IsSystemEnabled() RTTI

Generated hook

re.Hooks.Place(
    "PreventionSystem",
    "IsSystemEnabled;",
    (PreventionSystem_IsSystemEnabled x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_IsSystemEnabled(
    PreventionSystem self
);

bool IsSystemLocked() RTTI

Generated hook

re.Hooks.Place(
    "PreventionSystem",
    "IsSystemLocked;",
    (PreventionSystem_IsSystemLocked x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_IsSystemLocked(
    PreventionSystem self
);

bool IsChasingPlayer() RTTI

Generated hook

re.Hooks.Place(
    "PreventionSystem",
    "IsChasingPlayer;",
    (PreventionSystem_IsChasingPlayer x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_IsChasingPlayer(
    PreventionSystem self
);

bool IsMaxTacDefeated() RTTI

Generated hook

re.Hooks.Place(
    "PreventionSystem",
    "IsMaxTacDefeated;",
    (PreventionSystem_IsMaxTacDefeated x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_IsMaxTacDefeated(
    PreventionSystem self
);

bool IsPreventionInputLocked() RTTI

Generated hook

re.Hooks.Place(
    "PreventionSystem",
    "IsPreventionInputLocked;",
    (PreventionSystem_IsPreventionInputLocked x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_IsPreventionInputLocked(
    PreventionSystem self
);

bool IsSavingLocked() overrideRTTI

Generated hook

re.Hooks.Place(
    "PreventionSystem",
    "IsSavingLocked;",
    (PreventionSystem_IsSavingLocked x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_IsSavingLocked(
    PreventionSystem self
);

float GetLastAttackTime() RTTI

Generated hook

re.Hooks.Place(
    "PreventionSystem",
    "GetLastAttackTime;",
    (PreventionSystem_GetLastAttackTime x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_GetLastAttackTime(
    PreventionSystem self
);

ent.EntityID[] GetLastAttackTargetIDs() RTTI

Vector4 GetLastKnownPlayerPosition() RTTI

Generated hook

re.Hooks.Place(
    "PreventionSystem",
    "GetLastKnownPlayerPosition;",
    (PreventionSystem_GetLastKnownPlayerPosition x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Vector4>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_GetLastKnownPlayerPosition(
    PreventionSystem self
);

WeakHandle<vehicle.BaseObject> GetLastKnownPlayerVehicle() RTTI
WeakHandle<PlayerPuppet> GetPlayer() RTTI

EPreventionHeatStage GetHeatStage() RTTI

Generated hook

re.Hooks.Place(
    "PreventionSystem",
    "GetHeatStage;",
    (PreventionSystem_GetHeatStage x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.EPreventionHeatStage>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_GetHeatStage(
    PreventionSystem self
);

EStarState GetStarState() RTTI

Generated hook

re.Hooks.Place(
    "PreventionSystem",
    "GetStarState;",
    (PreventionSystem_GetStarState x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.EStarState>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_GetStarState(
    PreventionSystem self
);

uint GetHeatStageAsInt() RTTI

Generated hook

re.Hooks.Place(
    "PreventionSystem",
    "GetHeatStageAsInt;",
    (PreventionSystem_GetHeatStageAsInt x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Uint>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_GetHeatStageAsInt(
    PreventionSystem self
);

bool IsShootingFromVehicleBlocked() RTTI

Generated hook

re.Hooks.Place(
    "PreventionSystem",
    "IsShootingFromVehicleBlocked;",
    (PreventionSystem_IsShootingFromVehicleBlocked x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_IsShootingFromVehicleBlocked(
    PreventionSystem self
);

ScriptGameInstance GetGame() RTTI

Generated hook

re.Hooks.Place(
    "PreventionSystem",
    "GetGame;",
    (PreventionSystem_GetGame x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.ScriptGameInstance>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_GetGame(
    PreventionSystem self
);

float GetDamageToPlayerMultiplier() RTTI

Generated hook

re.Hooks.Place(
    "PreventionSystem",
    "GetDamageToPlayerMultiplier;",
    (PreventionSystem_GetDamageToPlayerMultiplier x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_GetDamageToPlayerMultiplier(
    PreventionSystem self
);

bool AreTurretsActive() RTTI

Generated hook

re.Hooks.Place(
    "PreventionSystem",
    "AreTurretsActive;",
    (PreventionSystem_AreTurretsActive x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_AreTurretsActive(
    PreventionSystem self
);

WeakHandle<District> GetCurrentDistrict() RTTI

float GetLastStarChangeStartTimeStamp() RTTI

Generated hook

re.Hooks.Place(
    "PreventionSystem",
    "GetLastStarChangeStartTimeStamp;",
    (PreventionSystem_GetLastStarChangeStartTimeStamp x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_GetLastStarChangeStartTimeStamp(
    PreventionSystem self
);

float GetFirstStarTimeStamp() RTTI

Generated hook

re.Hooks.Place(
    "PreventionSystem",
    "GetFirstStarTimeStamp;",
    (PreventionSystem_GetFirstStarTimeStamp x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_GetFirstStarTimeStamp(
    PreventionSystem self
);

bool IsPlayerMounted() RTTI

Generated hook

re.Hooks.Place(
    "PreventionSystem",
    "IsPlayerMounted;",
    (PreventionSystem_IsPlayerMounted x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_IsPlayerMounted(
    PreventionSystem self
);

bool IsPlayerInQuestArea() RTTI

Generated hook

re.Hooks.Place(
    "PreventionSystem",
    "IsPlayerInQuestArea;",
    (PreventionSystem_IsPlayerInQuestArea x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_IsPlayerInQuestArea(
    PreventionSystem self
);

void SetIsPlayerMounted(bool isPlayerMounted) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "SetIsPlayerMounted;Bool",
    (PreventionSystem_SetIsPlayerMounted x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_SetIsPlayerMounted(
    PreventionSystem self,
    bool isPlayerMounted
);

float GetSoftDeescalationBlinkingStarsDuration() RTTI

Generated hook

re.Hooks.Place(
    "PreventionSystem",
    "GetSoftDeescalationBlinkingStarsDuration;",
    (PreventionSystem_GetSoftDeescalationBlinkingStarsDuration x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_GetSoftDeescalationBlinkingStarsDuration(
    PreventionSystem self
);

float GetSoftDeescalationGreyStarsDuration() RTTI

Generated hook

re.Hooks.Place(
    "PreventionSystem",
    "GetSoftDeescalationGreyStarsDuration;",
    (PreventionSystem_GetSoftDeescalationGreyStarsDuration x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_GetSoftDeescalationGreyStarsDuration(
    PreventionSystem self
);

bool IsPoliceUnawareOfThePlayerExactLocation() RTTI

Generated hook

re.Hooks.Place(
    "PreventionSystem",
    "IsPoliceUnawareOfThePlayerExactLocation;",
    (PreventionSystem_IsPoliceUnawareOfThePlayerExactLocation x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_IsPoliceUnawareOfThePlayerExactLocation(
    PreventionSystem self
);

PoliceAgentRegistry? GetAgentRegistry() RTTI

Generated hook

re.Hooks.Place(
    "PreventionSystem",
    "GetAgentRegistry;",
    (PreventionSystem_GetAgentRegistry x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.PoliceAgentRegistry>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_GetAgentRegistry(
    PreventionSystem self
);

bool ShouldWorkSpotPoliceJoinChase(ScriptedPuppet puppet) RTTI

Generated hook

re.Hooks.Place(
    "PreventionSystem",
    "ShouldWorkSpotPoliceJoinChase;ScriptedPuppet",
    (PreventionSystem_ShouldWorkSpotPoliceJoinChase x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_ShouldWorkSpotPoliceJoinChase(
    PreventionSystem self,
    ScriptedPuppet? puppet
);

bool ShouldSpawnPatrolVehicleWhenInSearch() RTTI

Generated hook

re.Hooks.Place(
    "PreventionSystem",
    "ShouldSpawnPatrolVehicleWhenInSearch;",
    (PreventionSystem_ShouldSpawnPatrolVehicleWhenInSearch x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_ShouldSpawnPatrolVehicleWhenInSearch(
    PreventionSystem self
);

void UpdateDataMatrixOnDistrictChange(WeakHandle<District> district) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "UpdateDataMatrixOnDistrictChange;District",
    (PreventionSystem_UpdateDataMatrixOnDistrictChange x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_UpdateDataMatrixOnDistrictChange(
    PreventionSystem self,
    WeakHandle<District> district
);

void GetDataTableForCurrentHeat() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "GetDataTableForCurrentHeat;",
    (PreventionSystem_GetDataTableForCurrentHeat x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_GetDataTableForCurrentHeat(
    PreventionSystem self
);

game.data.PreventionHeatTable_Record? GetDataTableForHeat(EPreventionHeatStage heatStage) RTTI

Generated hook

re.Hooks.Place(
    "PreventionSystem",
    "GetDataTableForHeat;EPreventionHeatStage",
    (PreventionSystem_GetDataTableForHeat x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.PreventionHeatTable_Record>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_GetDataTableForHeat(
    PreventionSystem self,
    EPreventionHeatStage heatStage
);

float GetPreventionInputLockTime() RTTI

Generated hook

re.Hooks.Place(
    "PreventionSystem",
    "GetPreventionInputLockTime;",
    (PreventionSystem_GetPreventionInputLockTime x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_GetPreventionInputLockTime(
    PreventionSystem self
);

int GetInputLockOverrideThreshold() RTTI

Generated hook

re.Hooks.Place(
    "PreventionSystem",
    "GetInputLockOverrideThreshold;",
    (PreventionSystem_GetInputLockOverrideThreshold x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_GetInputLockOverrideThreshold(
    PreventionSystem self
);

float GetSpawnOriginMaxDistance() RTTI

Generated hook

re.Hooks.Place(
    "PreventionSystem",
    "GetSpawnOriginMaxDistance;",
    (PreventionSystem_GetSpawnOriginMaxDistance x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_GetSpawnOriginMaxDistance(
    PreventionSystem self
);

bool GetDataTableForCurrentHeat(EPreventionHeatStage heatStage, TDBID[] characterRecords, out Vector2 spawnRange, out uint unitsCount, out float spawnInterval, out bool hasRecon)

RTTI

Generated hook

re.Hooks.Place(
    "PreventionSystem",
    "GetDataTableForCurrentHeat;EPreventionHeatStagescript_ref<array<TweakDBID>>Vector2Uint32FloatBool",
    (PreventionSystem_GetDataTableForCurrentHeat2 x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_GetDataTableForCurrentHeat2(
    PreventionSystem self,
    EPreventionHeatStage heatStage,
    TDBID[] characterRecords,
    Vector2 spawnRange,
    uint unitsCount,
    float spawnInterval,
    bool hasRecon
);

bool GetVehicleRecordFromPool(WeakHandle<game.data.PreventionVehiclePoolData_Record>[] pool, out WeakHandle<game.data.Vehicle_Record> outVehicleRecord)

RTTI

Generated hook

re.Hooks.Place(
    "PreventionSystem",
    "GetVehicleRecordFromPool;script_ref<array<PreventionVehiclePoolData_Record>>Vehicle_Record",
    (PreventionSystem_GetVehicleRecordFromPool x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_GetVehicleRecordFromPool(
    PreventionSystem self,
    WeakHandle<game.data.PreventionVehiclePoolData_Record>[] pool,
    WeakHandle<game.data.Vehicle_Record> outVehicleRecord
);

bool GetCharacterRecordsFromPool(int recordsCount, WeakHandle<game.data.PreventionUnitPoolData_Record>[] pool, TDBID[] recordIDs)

RTTI

Generated hook

re.Hooks.Place(
    "PreventionSystem",
    "GetCharacterRecordsFromPool;Int32script_ref<array<PreventionUnitPoolData_Record>>script_ref<array<TweakDBID>>",
    (PreventionSystem_GetCharacterRecordsFromPool x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_GetCharacterRecordsFromPool(
    PreventionSystem self,
    int recordsCount,
    WeakHandle<game.data.PreventionUnitPoolData_Record>[] pool,
    TDBID[] recordIDs
);

bool GetCharacterRecordFromPool(WeakHandle<game.data.PreventionUnitPoolData_Record>[] pool, out TDBID recordID) RTTI

Generated hook

re.Hooks.Place(
    "PreventionSystem",
    "GetCharacterRecordFromPool;script_ref<array<PreventionUnitPoolData_Record>>TweakDBID",
    (PreventionSystem_GetCharacterRecordFromPool x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_GetCharacterRecordFromPool(
    PreventionSystem self,
    WeakHandle<game.data.PreventionUnitPoolData_Record>[] pool,
    TDBID recordID
);

bool TryGetRoadblockDataFromHeatStage(EPreventionHeatStage heatStage, out WeakHandle<game.data.Vehicle_Record> outVehicleRecord, out Vector2 spawnDistanceRange)

RTTI

Generated hook

re.Hooks.Place(
    "PreventionSystem",
    "TryGetRoadblockDataFromHeatStage;EPreventionHeatStageVehicle_RecordVector2",
    (PreventionSystem_TryGetRoadblockDataFromHeatStage x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_TryGetRoadblockDataFromHeatStage(
    PreventionSystem self,
    EPreventionHeatStage heatStage,
    WeakHandle<game.data.Vehicle_Record> outVehicleRecord,
    Vector2 spawnDistanceRange
);

bool TryGetVehicleDataFromHeatStage(EPreventionHeatStage heatStage, out WeakHandle<game.data.Vehicle_Record> outVehicleRecord)

RTTI

Generated hook

re.Hooks.Place(
    "PreventionSystem",
    "TryGetVehicleDataFromHeatStage;EPreventionHeatStageVehicle_Record",
    (PreventionSystem_TryGetVehicleDataFromHeatStage x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_TryGetVehicleDataFromHeatStage(
    PreventionSystem self,
    EPreventionHeatStage heatStage,
    WeakHandle<game.data.Vehicle_Record> outVehicleRecord
);

WeakHandle<game.data.PreventionHeatData_Record> GetHeatData() RTTI

bool TryGetUnitDataFromVehicleRecord(WeakHandle<game.data.Vehicle_Record> vehicleRecord, int recordsCount, TDBID[] recordIDs)

RTTI

Generated hook

re.Hooks.Place(
    "PreventionSystem",
    "TryGetUnitDataFromVehicleRecord;Vehicle_RecordInt32script_ref<array<TweakDBID>>",
    (PreventionSystem_TryGetUnitDataFromVehicleRecord x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_TryGetUnitDataFromVehicleRecord(
    PreventionSystem self,
    WeakHandle<game.data.Vehicle_Record> vehicleRecord,
    int recordsCount,
    TDBID[] recordIDs
);

bool TryGetUnitDataFromHeatStage(EPreventionHeatStage heatStage, int recordsCount, TDBID[] recordIDs) RTTI

Generated hook

re.Hooks.Place(
    "PreventionSystem",
    "TryGetUnitDataFromHeatStage;EPreventionHeatStageInt32script_ref<array<TweakDBID>>",
    (PreventionSystem_TryGetUnitDataFromHeatStage x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_TryGetUnitDataFromHeatStage(
    PreventionSystem self,
    EPreventionHeatStage heatStage,
    int recordsCount,
    TDBID[] recordIDs
);

bool TryGetDistinctUnitDataFromHeatStage(TDBID[] recordIDs) RTTI

Generated hook

re.Hooks.Place(
    "PreventionSystem",
    "TryGetDistinctUnitDataFromHeatStage;script_ref<array<TweakDBID>>",
    (PreventionSystem_TryGetDistinctUnitDataFromHeatStage x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_TryGetDistinctUnitDataFromHeatStage(
    PreventionSystem self,
    TDBID[] recordIDs
);

void GetFindSpawnPointsOrigin(out Vector4 pos, out Vector4 dir) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "GetFindSpawnPointsOrigin;Vector4Vector4",
    (PreventionSystem_GetFindSpawnPointsOrigin x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_GetFindSpawnPointsOrigin(
    PreventionSystem self,
    Vector4 pos,
    Vector4 dir
);

void GetFindSpawnPointsOriginsData(Vector4[] spawnOriginsPositions) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "GetFindSpawnPointsOriginsData;script_ref<array<Vector4>>",
    (PreventionSystem_GetFindSpawnPointsOriginsData x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_GetFindSpawnPointsOriginsData(
    PreventionSystem self,
    List<Vector4> spawnOriginsPositions
);

void UpdateTotalCrimeScore(PreventionDamageRequest request) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "UpdateTotalCrimeScore;PreventionDamageRequest",
    (PreventionSystem_UpdateTotalCrimeScore x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_UpdateTotalCrimeScore(
    PreventionSystem self,
    PreventionDamageRequest? request
);

void CalculateCrimeScoreForNPC(PreventionDamageRequest request) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "CalculateCrimeScoreForNPC;PreventionDamageRequest",
    (PreventionSystem_CalculateCrimeScoreForNPC x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_CalculateCrimeScoreForNPC(
    PreventionSystem self,
    PreventionDamageRequest? request
);

void CalculateCrimeScoreForVehicle(PreventionDamageRequest request) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "CalculateCrimeScoreForVehicle;PreventionDamageRequest",
    (PreventionSystem_CalculateCrimeScoreForVehicle x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_CalculateCrimeScoreForVehicle(
    PreventionSystem self,
    PreventionDamageRequest? request
);

bool TryMarkAsAttackedByPlayer(ent.EntityID targetId) RTTI

Generated hook

re.Hooks.Place(
    "PreventionSystem",
    "TryMarkAsAttackedByPlayer;EntityID",
    (PreventionSystem_TryMarkAsAttackedByPlayer x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_TryMarkAsAttackedByPlayer(
    PreventionSystem self,
    ent.EntityID targetId
);

float GetDistrictMultiplier() RTTI

Generated hook

re.Hooks.Place(
    "PreventionSystem",
    "GetDistrictMultiplier;",
    (PreventionSystem_GetDistrictMultiplier x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_GetDistrictMultiplier(
    PreventionSystem self
);

void SetLastAttackTime(float value) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "SetLastAttackTime;Float",
    (PreventionSystem_SetLastAttackTime x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_SetLastAttackTime(
    PreventionSystem self,
    float value
);

void UpdateLastAttackTargetIDs(ent.EntityID value) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "UpdateLastAttackTargetIDs;EntityID",
    (PreventionSystem_UpdateLastAttackTargetIDs x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

void ClearLastAttackTargetIDs() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "ClearLastAttackTargetIDs;",
    (PreventionSystem_ClearLastAttackTargetIDs x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_ClearLastAttackTargetIDs(
    PreventionSystem self
);

void SetLastKnownPlayerPosition(Vector4 value) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "SetLastKnownPlayerPosition;Vector4",
    (PreventionSystem_SetLastKnownPlayerPosition x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_SetLastKnownPlayerPosition(
    PreventionSystem self,
    Vector4 value
);

void SetSystemLock(bool value) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "SetSystemLock;Bool",
    (PreventionSystem_SetSystemLock x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

void SetCrimeScoreMultiplier(float value) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "SetCrimeScoreMultiplier;Float",
    (PreventionSystem_SetCrimeScoreMultiplier x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_SetCrimeScoreMultiplier(
    PreventionSystem self,
    float value
);

void SetVehicleSpawnBlockSide(EVehicleSpawnBlockSide value) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "SetVehicleSpawnBlockSide;EVehicleSpawnBlockSide",
    (PreventionSystem_SetVehicleSpawnBlockSide x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_SetVehicleSpawnBlockSide(
    PreventionSystem self,
    EVehicleSpawnBlockSide value
);

void SetDamageToPlayerMultiplier(float value) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "SetDamageToPlayerMultiplier;Float",
    (PreventionSystem_SetDamageToPlayerMultiplier x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_SetDamageToPlayerMultiplier(
    PreventionSystem self,
    float value
);

void SetChaseMultiplier(float value) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "SetChaseMultiplier;Float",
    (PreventionSystem_SetChaseMultiplier x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_SetChaseMultiplier(
    PreventionSystem self,
    float value
);

void SetBlockVehicleSpawn(bool value) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "SetBlockVehicleSpawn;Bool",
    (PreventionSystem_SetBlockVehicleSpawn x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

void SetBlockOnFootSpawn(bool value) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "SetBlockOnFootSpawn;Bool",
    (PreventionSystem_SetBlockOnFootSpawn x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

void SetBlockShootingFromVehicle(bool value) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "SetBlockShootingFromVehicle;Bool",
    (PreventionSystem_SetBlockShootingFromVehicle x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

void SetBlockReconDroneSpawn(bool value) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "SetBlockReconDroneSpawn;Bool",
    (PreventionSystem_SetBlockReconDroneSpawn x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

void SetMinMaxResetHeatLevels(int MinLevel, int MaxLevel, bool isDefault) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "SetMinMaxResetHeatLevels;Int32Int32Bool",
    (PreventionSystem_SetMinMaxResetHeatLevels x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_SetMinMaxResetHeatLevels(
    PreventionSystem self,
    int MinLevel,
    int MaxLevel,
    bool isDefault
);

void SetStarStateUI(EStarState newState) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "SetStarStateUI;EStarState",
    (PreventionSystem_SetStarStateUI x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_SetStarStateUI(
    PreventionSystem self,
    EStarState newState
);

int GetWantedLevelFact() RTTI

Generated hook

re.Hooks.Place(
    "PreventionSystem",
    "GetWantedLevelFact;",
    (PreventionSystem_GetWantedLevelFact x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_GetWantedLevelFact(
    PreventionSystem self
);

void SetWantedLevelFact(int level) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "SetWantedLevelFact;Int32",
    (PreventionSystem_SetWantedLevelFact x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_SetWantedLevelFact(
    PreventionSystem self,
    int level
);

void SetWantedStateFact(EStarState state) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "SetWantedStateFact;EStarState",
    (PreventionSystem_SetWantedStateFact x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_SetWantedStateFact(
    PreventionSystem self,
    EStarState state
);

void SetAgentsSupport(bool hasSupport) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "SetAgentsSupport;Bool",
    (PreventionSystem_SetAgentsSupport x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_SetAgentsSupport(
    PreventionSystem self,
    bool hasSupport
);

void SetSingleAgentSupport(WeakHandle<game.PersistentState> ps, bool hasSupport) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "SetSingleAgentSupport;PersistentStateBool",
    (PreventionSystem_SetSingleAgentSupport x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_SetSingleAgentSupport(
    PreventionSystem self,
    WeakHandle<game.PersistentState> ps,
    bool hasSupport
);

bool CanPreventionReactToInput() RTTI

Generated hook

re.Hooks.Place(
    "PreventionSystem",
    "CanPreventionReactToInput;",
    (PreventionSystem_CanPreventionReactToInput x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_CanPreventionReactToInput(
    PreventionSystem self
);

void RegisterToBBCalls() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "RegisterToBBCalls;",
    (PreventionSystem_RegisterToBBCalls x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_RegisterToBBCalls(
    PreventionSystem self
);

void UnregisterBBCalls() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "UnregisterBBCalls;",
    (PreventionSystem_UnregisterBBCalls x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_UnregisterBBCalls(
    PreventionSystem self
);

void PlayerAttachedCallback(game.Object playerPuppet) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "PlayerAttachedCallback;GameObject",
    (PreventionSystem_PlayerAttachedCallback x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

void PlayerDetachedCallback(game.Object playerPuppet) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "PlayerDetachedCallback;GameObject",
    (PreventionSystem_PlayerDetachedCallback x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

bool OnPlayerHLSChange(int value) RTTI

Generated hook

re.Hooks.Place(
    "PreventionSystem",
    "OnPlayerHLSChange",
    (PreventionSystem_OnPlayerHLSChange x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

bool OnPlayerVehicleStateChange(int value) RTTI

Generated hook

re.Hooks.Place(
    "PreventionSystem",
    "OnPlayerVehicleStateChange",
    (PreventionSystem_OnPlayerVehicleStateChange x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

void StartTransitiontoGreyStateTimerRequest() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "StartTransitiontoGreyStateTimerRequest;",
    (PreventionSystem_StartTransitiontoGreyStateTimerRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_StartTransitiontoGreyStateTimerRequest(
    PreventionSystem self
);

void CancelTransitiontoGreyStateTimerRequest() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "CancelTransitiontoGreyStateTimerRequest;",
    (PreventionSystem_CancelTransitiontoGreyStateTimerRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_CancelTransitiontoGreyStateTimerRequest(
    PreventionSystem self
);

void ResetTransitiontoGreyStateTimerRequest() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "ResetTransitiontoGreyStateTimerRequest;",
    (PreventionSystem_ResetTransitiontoGreyStateTimerRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_ResetTransitiontoGreyStateTimerRequest(
    PreventionSystem self
);

void StartStateBufferTimerRequest() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "StartStateBufferTimerRequest;",
    (PreventionSystem_StartStateBufferTimerRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_StartStateBufferTimerRequest(
    PreventionSystem self
);

void CancelStateBufferTimerRequest() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "CancelStateBufferTimerRequest;",
    (PreventionSystem_CancelStateBufferTimerRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_CancelStateBufferTimerRequest(
    PreventionSystem self
);

void ResetStateBufferTimerRequest() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "ResetStateBufferTimerRequest;",
    (PreventionSystem_ResetStateBufferTimerRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_ResetStateBufferTimerRequest(
    PreventionSystem self
);

void UpdateStateBufferTimerRequest() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "UpdateStateBufferTimerRequest;",
    (PreventionSystem_UpdateStateBufferTimerRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_UpdateStateBufferTimerRequest(
    PreventionSystem self
);

void StartSearchingTimerRequest() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "StartSearchingTimerRequest;",
    (PreventionSystem_StartSearchingTimerRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_StartSearchingTimerRequest(
    PreventionSystem self
);

void CancelSearchingTimerRequest() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "CancelSearchingTimerRequest;",
    (PreventionSystem_CancelSearchingTimerRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_CancelSearchingTimerRequest(
    PreventionSystem self
);

void ResetSearchingTimerRequest() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "ResetSearchingTimerRequest;",
    (PreventionSystem_ResetSearchingTimerRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_ResetSearchingTimerRequest(
    PreventionSystem self
);

void UpdateSearchingTimerRequest() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "UpdateSearchingTimerRequest;",
    (PreventionSystem_UpdateSearchingTimerRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_UpdateSearchingTimerRequest(
    PreventionSystem self
);

void StartBlinkingTimerRequest() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "StartBlinkingTimerRequest;",
    (PreventionSystem_StartBlinkingTimerRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_StartBlinkingTimerRequest(
    PreventionSystem self
);

void StartBlinkingTimerRequest(float duration, bool lockWhileBlinking, string telemetryInfo) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "StartBlinkingTimerRequest;FloatBoolString",
    (PreventionSystem_StartBlinkingTimerRequest2 x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_StartBlinkingTimerRequest2(
    PreventionSystem self,
    float duration,
    bool lockWhileBlinking,
    string telemetryInfo
);

void CancelBlinkingTimerRequest() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "CancelBlinkingTimerRequest;",
    (PreventionSystem_CancelBlinkingTimerRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_CancelBlinkingTimerRequest(
    PreventionSystem self
);

void ResetBlinkingTimerRequest() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "ResetBlinkingTimerRequest;",
    (PreventionSystem_ResetBlinkingTimerRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_ResetBlinkingTimerRequest(
    PreventionSystem self
);

void StartCrimescoreDropTimerRequest() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "StartCrimescoreDropTimerRequest;",
    (PreventionSystem_StartCrimescoreDropTimerRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_StartCrimescoreDropTimerRequest(
    PreventionSystem self
);

void CancelCrimescoreDropTimerRequest() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "CancelCrimescoreDropTimerRequest;",
    (PreventionSystem_CancelCrimescoreDropTimerRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_CancelCrimescoreDropTimerRequest(
    PreventionSystem self
);

void ResetCrimescoreDropTimerRequest() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "ResetCrimescoreDropTimerRequest;",
    (PreventionSystem_ResetCrimescoreDropTimerRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_ResetCrimescoreDropTimerRequest(
    PreventionSystem self
);

bool CancelNPCSpawnDelay() RTTI

Generated hook

re.Hooks.Place(
    "PreventionSystem",
    "CancelNPCSpawnDelay;",
    (PreventionSystem_CancelNPCSpawnDelay x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_CancelNPCSpawnDelay(
    PreventionSystem self
);

void OnResupplyVehicleTicketsRequest(ResupplyVehicleTicketsRequest evt) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "OnResupplyVehicleTicketsRequest;ResupplyVehicleTicketsRequest",
    (PreventionSystem_OnResupplyVehicleTicketsRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_OnResupplyVehicleTicketsRequest(
    PreventionSystem self,
    ResupplyVehicleTicketsRequest? evt
);

void TryResupplyTicket() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "TryResupplyTicket;",
    (PreventionSystem_TryResupplyTicket x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_TryResupplyTicket(
    PreventionSystem self
);

void OnSpawnPoliceVehicleRequest(SpawnPoliceVehicleWithDelayRequest evt) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "OnSpawnPoliceVehicleRequest;SpawnPoliceVehicleWithDelayRequest",
    (PreventionSystem_OnSpawnPoliceVehicleRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_OnSpawnPoliceVehicleRequest(
    PreventionSystem self,
    SpawnPoliceVehicleWithDelayRequest? evt
);

void OnSpawnRoadblockRequest(SpawnRoadblockadeWithDelayRequest evt) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "OnSpawnRoadblockRequest;SpawnRoadblockadeWithDelayRequest",
    (PreventionSystem_OnSpawnRoadblockRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_OnSpawnRoadblockRequest(
    PreventionSystem self,
    SpawnRoadblockadeWithDelayRequest? evt
);

bool CanRequestAVSpawn() RTTI

Generated hook

re.Hooks.Place(
    "PreventionSystem",
    "CanRequestAVSpawn;",
    (PreventionSystem_CanRequestAVSpawn x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_CanRequestAVSpawn(
    PreventionSystem self
);

bool TryRequestVehicleSpawnWithStrategy() RTTI

Generated hook

re.Hooks.Place(
    "PreventionSystem",
    "TryRequestVehicleSpawnWithStrategy;",
    (PreventionSystem_TryRequestVehicleSpawnWithStrategy x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_TryRequestVehicleSpawnWithStrategy(
    PreventionSystem self
);

void OnPreventionStarStateBufferTimerRequest(PreventionStarStateBufferTimerRequest evt) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "OnPreventionStarStateBufferTimerRequest;PreventionStarStateBufferTimerRequest",
    (PreventionSystem_OnPreventionStarStateBufferTimerRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_OnPreventionStarStateBufferTimerRequest(
    PreventionSystem self,
    PreventionStarStateBufferTimerRequest? evt
);

void PoliceLostPlayer() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "PoliceLostPlayer;",
    (PreventionSystem_PoliceLostPlayer x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_PoliceLostPlayer(
    PreventionSystem self
);

void OnPreventionTransitionToGreyStateTimerRequest(PreventionTransitionToGreyStateTimerRequest evt) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "OnPreventionTransitionToGreyStateTimerRequest;PreventionTransitionToGreyStateTimerRequest",
    (PreventionSystem_OnPreventionTransitionToGreyStateTimerRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_OnPreventionTransitionToGreyStateTimerRequest(
    PreventionSystem self,
    PreventionTransitionToGreyStateTimerRequest? evt
);

void OnPreventionSearchingStatusRequest(PreventionSearchingStatusRequest evt) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "OnPreventionSearchingStatusRequest;PreventionSearchingStatusRequest",
    (PreventionSystem_OnPreventionSearchingStatusRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_OnPreventionSearchingStatusRequest(
    PreventionSystem self,
    PreventionSearchingStatusRequest? evt
);

void OnPreventionBlinkingStatusRequest(PreventionBlinkingStatusRequest evt) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "OnPreventionBlinkingStatusRequest;PreventionBlinkingStatusRequest",
    (PreventionSystem_OnPreventionBlinkingStatusRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_OnPreventionBlinkingStatusRequest(
    PreventionSystem self,
    PreventionBlinkingStatusRequest? evt
);

void OnPreventionForceDeescalateRequest(PreventionForceDeescalateRequest evt) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "OnPreventionForceDeescalateRequest;PreventionForceDeescalateRequest",
    (PreventionSystem_OnPreventionForceDeescalateRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_OnPreventionForceDeescalateRequest(
    PreventionSystem self,
    PreventionForceDeescalateRequest? evt
);

void OnRefreshDeescalationTimers(RefreshDeescalationTimers evt) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "OnRefreshDeescalationTimers;RefreshDeescalationTimers",
    (PreventionSystem_OnRefreshDeescalationTimers x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_OnRefreshDeescalationTimers(
    PreventionSystem self,
    RefreshDeescalationTimers? evt
);

void RequestUnitSpawn(TDBID recordID, WorldTransform spawnTransform) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "RequestUnitSpawn;TweakDBIDWorldTransform",
    (PreventionSystem_RequestUnitSpawn x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_RequestUnitSpawn(
    PreventionSystem self,
    TDBID recordID,
    WorldTransform spawnTransform
);

void RemovePreventionInputLockRequest() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "RemovePreventionInputLockRequest;",
    (PreventionSystem_RemovePreventionInputLockRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_RemovePreventionInputLockRequest(
    PreventionSystem self
);

void PreventionInputLockRequest() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "PreventionInputLockRequest;",
    (PreventionSystem_PreventionInputLockRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_PreventionInputLockRequest(
    PreventionSystem self
);

void OnUnlockPreventionInputRequest(UnlockPreventionInputRequest request) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "OnUnlockPreventionInputRequest;UnlockPreventionInputRequest",
    (PreventionSystem_OnUnlockPreventionInputRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_OnUnlockPreventionInputRequest(
    PreventionSystem self,
    UnlockPreventionInputRequest? request
);

void SendDropPointLockRequest(bool isEnabled) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "SendDropPointLockRequest;Bool",
    (PreventionSystem_SendDropPointLockRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_SendDropPointLockRequest(
    PreventionSystem self,
    bool isEnabled
);

void OnPreventionCrimeScoreZeroRequest(PreventionCrimeScoreZeroRequest request) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "OnPreventionCrimeScoreZeroRequest;PreventionCrimeScoreZeroRequest",
    (PreventionSystem_OnPreventionCrimeScoreZeroRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_OnPreventionCrimeScoreZeroRequest(
    PreventionSystem self,
    PreventionCrimeScoreZeroRequest? request
);

void OnPreventionUnitDespawnedRequest(PreventionUnitDespawnedRequest request) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "OnPreventionUnitDespawnedRequest;PreventionUnitDespawnedRequest",
    (PreventionSystem_OnPreventionUnitDespawnedRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_OnPreventionUnitDespawnedRequest(
    PreventionSystem self,
    PreventionUnitDespawnedRequest? request
);

void OnPreventionUnitSpawnedRequest(PreventionUnitSpawnedRequest request) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "OnPreventionUnitSpawnedRequest;PreventionUnitSpawnedRequest",
    (PreventionSystem_OnPreventionUnitSpawnedRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_OnPreventionUnitSpawnedRequest(
    PreventionSystem self,
    PreventionUnitSpawnedRequest? request
);

void HandleSpawnRequestSuccess(game.SpawnRequestResult result, TicketData ticketData) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "HandleSpawnRequestSuccess;SpawnRequestResultTicketData",
    (PreventionSystem_HandleSpawnRequestSuccess x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_HandleSpawnRequestSuccess(
    PreventionSystem self,
    game.SpawnRequestResult result,
    TicketData ticketData
);

void HandleRoadblockadeUnitSpawned(game.Object spawnedObject) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "HandleRoadblockadeUnitSpawned;GameObject",
    (PreventionSystem_HandleRoadblockadeUnitSpawned x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_HandleRoadblockadeUnitSpawned(
    PreventionSystem self,
    game.Object? spawnedObject
);

void HandleSpawnRequestFailure(game.SpawnRequestResult result, TicketData ticketData) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "HandleSpawnRequestFailure;SpawnRequestResultTicketData",
    (PreventionSystem_HandleSpawnRequestFailure x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_HandleSpawnRequestFailure(
    PreventionSystem self,
    game.SpawnRequestResult result,
    TicketData ticketData
);

void OnRegisterNPC(RegisterNPCRequest request) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "OnRegisterNPC;RegisterNPCRequest",
    (PreventionSystem_OnRegisterNPC x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_OnRegisterNPC(
    PreventionSystem self,
    RegisterNPCRequest? request
);

bool RegisterPreventionUnit(game.Object preventionUnit, game.DynamicVehicleType vehicleType, bool overrideExisting, vehicle.PoliceStrategy? strategy, bool? isFallback)

RTTI

Generated hook

re.Hooks.Place(
    "PreventionSystem",
    "RegisterPreventionUnit;GameObjectDynamicVehicleTypeBoolvehiclePoliceStrategyBool",
    (PreventionSystem_RegisterPreventionUnit x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_RegisterPreventionUnit(
    PreventionSystem self,
    game.Object? preventionUnit,
    game.DynamicVehicleType vehicleType,
    bool overrideExisting,
    vehicle.PoliceStrategy? strategy,
    bool? isFallback
);

void CheckLastMaxTacAlone() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "CheckLastMaxTacAlone;",
    (PreventionSystem_CheckLastMaxTacAlone x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_CheckLastMaxTacAlone(
    PreventionSystem self
);

void UnregisterPreventionUnit(ent.EntityID entityID) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "UnregisterPreventionUnit;EntityID",
    (PreventionSystem_UnregisterPreventionUnit x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

void OnPreventionEntityDestroyed(ent.EntityID destroyedEntityID) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "OnPreventionEntityDestroyed;EntityID",
    (PreventionSystem_OnPreventionEntityDestroyed x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_OnPreventionEntityDestroyed(
    PreventionSystem self,
    ent.EntityID destroyedEntityID
);

bool TrySetNPCMarkedForDespawnAI(ent.EntityID entityID, bool markedForDespawn) RTTI

Generated hook

re.Hooks.Place(
    "PreventionSystem",
    "TrySetNPCMarkedForDespawnAI;EntityIDBool",
    (PreventionSystem_TrySetNPCMarkedForDespawnAI x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_TrySetNPCMarkedForDespawnAI(
    PreventionSystem self,
    ent.EntityID entityID,
    bool markedForDespawn
);

bool TryGetNPCMarkedForDespawnAI(ent.EntityID entityID, out bool markedForDespawn) RTTI

Generated hook

re.Hooks.Place(
    "PreventionSystem",
    "TryGetNPCMarkedForDespawnAI;EntityIDBool",
    (PreventionSystem_TryGetNPCMarkedForDespawnAI x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_TryGetNPCMarkedForDespawnAI(
    PreventionSystem self,
    ent.EntityID entityID,
    bool markedForDespawn
);

void UpdateVehiclePassengerCount(ent.EntityID entityID, int passengersCount) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "UpdateVehiclePassengerCount;EntityIDInt32",
    (PreventionSystem_UpdateVehiclePassengerCount x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_UpdateVehiclePassengerCount(
    PreventionSystem self,
    ent.EntityID entityID,
    int passengersCount
);

bool IsRegistered(ent.EntityID entityID) RTTI

Generated hook

re.Hooks.Place(
    "PreventionSystem",
    "IsRegistered;EntityID",
    (PreventionSystem_IsRegistered x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

void OnPreventionTickRequest(PreventionTickRequest request) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "OnPreventionTickRequest;PreventionTickRequest",
    (PreventionSystem_OnPreventionTickRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_OnPreventionTickRequest(
    PreventionSystem self,
    PreventionTickRequest? request
);

void CheckPlayerDistanceToLKP() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "CheckPlayerDistanceToLKP;",
    (PreventionSystem_CheckPlayerDistanceToLKP x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_CheckPlayerDistanceToLKP(
    PreventionSystem self
);

void TryResolveIndefiniteStarState() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "TryResolveIndefiniteStarState;",
    (PreventionSystem_TryResolveIndefiniteStarState x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_TryResolveIndefiniteStarState(
    PreventionSystem self
);

void TryUpdateStarState() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "TryUpdateStarState;",
    (PreventionSystem_TryUpdateStarState x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_TryUpdateStarState(
    PreventionSystem self
);

void UpdateMaxTacUnits() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "UpdateMaxTacUnits;",
    (PreventionSystem_UpdateMaxTacUnits x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_UpdateMaxTacUnits(
    PreventionSystem self
);

void UpdateRoadblockadeUnits() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "UpdateRoadblockadeUnits;",
    (PreventionSystem_UpdateRoadblockadeUnits x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_UpdateRoadblockadeUnits(
    PreventionSystem self
);

void UpdateStarStateTo(EStarState state) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "UpdateStarStateTo;EStarState",
    (PreventionSystem_UpdateStarStateTo x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_UpdateStarStateTo(
    PreventionSystem self,
    EStarState state
);

void UpdateStarStateTimers(EStarState state) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "UpdateStarStateTimers;EStarState",
    (PreventionSystem_UpdateStarStateTimers x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_UpdateStarStateTimers(
    PreventionSystem self,
    EStarState state
);

void UpdateStarState() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "UpdateStarState;",
    (PreventionSystem_UpdateStarState x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_UpdateStarState(
    PreventionSystem self
);

void TryUpdateWantedLevelFact() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "TryUpdateWantedLevelFact;",
    (PreventionSystem_TryUpdateWantedLevelFact x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_TryUpdateWantedLevelFact(
    PreventionSystem self
);

void CheckPossibleSpawnPosAndRequestAVSpawn() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "CheckPossibleSpawnPosAndRequestAVSpawn;",
    (PreventionSystem_CheckPossibleSpawnPosAndRequestAVSpawn x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_CheckPossibleSpawnPosAndRequestAVSpawn(
    PreventionSystem self
);

bool CanSpawnAvAtPosition(Vector4 playerPosition, Vector4 position) RTTI

Generated hook

re.Hooks.Place(
    "PreventionSystem",
    "CanSpawnAvAtPosition;Vector4Vector4",
    (PreventionSystem_CanSpawnAvAtPosition x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_CanSpawnAvAtPosition(
    PreventionSystem self,
    Vector4 playerPosition,
    Vector4 position
);

bool ShouldPreventionUnitsRetreat() RTTI

Generated hook

re.Hooks.Place(
    "PreventionSystem",
    "ShouldPreventionUnitsRetreat;",
    (PreventionSystem_ShouldPreventionUnitsRetreat x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_ShouldPreventionUnitsRetreat(
    PreventionSystem self
);

bool IsPlayerCloseToLastCrimePosition() RTTI

Generated hook

re.Hooks.Place(
    "PreventionSystem",
    "IsPlayerCloseToLastCrimePosition;",
    (PreventionSystem_IsPlayerCloseToLastCrimePosition x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_IsPlayerCloseToLastCrimePosition(
    PreventionSystem self
);

void StartSecurityAreaResetRequest(float? resetDelay) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "StartSecurityAreaResetRequest;Float",
    (PreventionSystem_StartSecurityAreaResetRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_StartSecurityAreaResetRequest(
    PreventionSystem self,
    float? resetDelay
);

void CancelSecurityAreaResetRequest() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "CancelSecurityAreaResetRequest;",
    (PreventionSystem_CancelSecurityAreaResetRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_CancelSecurityAreaResetRequest(
    PreventionSystem self
);

void OnSecurityAreaResetRequest(SecurityAreaResetRequest request) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "OnSecurityAreaResetRequest;SecurityAreaResetRequest",
    (PreventionSystem_OnSecurityAreaResetRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_OnSecurityAreaResetRequest(
    PreventionSystem self,
    SecurityAreaResetRequest? request
);

void OnDamageInput(PreventionDamageRequest request) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "OnDamageInput;PreventionDamageRequest",
    (PreventionSystem_OnDamageInput x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_OnDamageInput(
    PreventionSystem self,
    PreventionDamageRequest? request
);

void ProcessPreventionDamageRequest(PreventionDamageRequest request) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "ProcessPreventionDamageRequest;PreventionDamageRequest",
    (PreventionSystem_ProcessPreventionDamageRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_ProcessPreventionDamageRequest(
    PreventionSystem self,
    PreventionDamageRequest? request
);

void StartPipeline(PreventionDamageRequest request) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "StartPipeline;PreventionDamageRequest",
    (PreventionSystem_StartPipeline x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_StartPipeline(
    PreventionSystem self,
    PreventionDamageRequest? request
);

void PreDamageChange() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "PreDamageChange;",
    (PreventionSystem_PreDamageChange x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_PreDamageChange(
    PreventionSystem self
);

void DamageChange() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "DamageChange;",
    (PreventionSystem_DamageChange x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_DamageChange(
    PreventionSystem self
);

void PostDamageChange(PreventionDamageRequest request) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "PostDamageChange;PreventionDamageRequest",
    (PreventionSystem_PostDamageChange x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_PostDamageChange(
    PreventionSystem self,
    PreventionDamageRequest? request
);

void HeatPipeline(string heatChangeReason) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "HeatPipeline;String",
    (PreventionSystem_HeatPipeline x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_HeatPipeline(
    PreventionSystem self,
    string heatChangeReason
);

uint ComputeTotalCrimeScoreForTelemetry(EPreventionHeatStage newHeatStageEnum) RTTI

Generated hook

re.Hooks.Place(
    "PreventionSystem",
    "ComputeTotalCrimeScoreForTelemetry;EPreventionHeatStage",
    (PreventionSystem_ComputeTotalCrimeScoreForTelemetry x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Uint>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_ComputeTotalCrimeScoreForTelemetry(
    PreventionSystem self,
    EPreventionHeatStage newHeatStageEnum
);

void ChangeHeatStage(EPreventionHeatStage newHeatStage, string heatChangeReason) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "ChangeHeatStage;EPreventionHeatStageString",
    (PreventionSystem_ChangeHeatStage x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_ChangeHeatStage(
    PreventionSystem self,
    EPreventionHeatStage newHeatStage,
    string heatChangeReason
);

void OnHeatChanged(EPreventionHeatStage previousHeat) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "OnHeatChanged;EPreventionHeatStage",
    (PreventionSystem_OnHeatChanged x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_OnHeatChanged(
    PreventionSystem self,
    EPreventionHeatStage previousHeat
);

void TryRessuplyVehicleTickets() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "TryRessuplyVehicleTickets;",
    (PreventionSystem_TryRessuplyVehicleTickets x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_TryRessuplyVehicleTickets(
    PreventionSystem self
);

void TryStartVehicleRespawn() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "TryStartVehicleRespawn;",
    (PreventionSystem_TryStartVehicleRespawn x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_TryStartVehicleRespawn(
    PreventionSystem self
);

void TryStartRoadblockRespawn() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "TryStartRoadblockRespawn;",
    (PreventionSystem_TryStartRoadblockRespawn x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_TryStartRoadblockRespawn(
    PreventionSystem self
);

void TryInitializePreventionTick() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "TryInitializePreventionTick;",
    (PreventionSystem_TryInitializePreventionTick x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_TryInitializePreventionTick(
    PreventionSystem self
);

void TutorialAddPoliceSystemFact() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "TutorialAddPoliceSystemFact;",
    (PreventionSystem_TutorialAddPoliceSystemFact x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_TutorialAddPoliceSystemFact(
    PreventionSystem self
);

void SpawnPipeline() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "SpawnPipeline;",
    (PreventionSystem_SpawnPipeline x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_SpawnPipeline(
    PreventionSystem self
);

void TrySpawnPoliceOnFootFallback() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "TrySpawnPoliceOnFootFallback;",
    (PreventionSystem_TrySpawnPoliceOnFootFallback x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_TrySpawnPoliceOnFootFallback(
    PreventionSystem self
);

int SpawnFallbackUnits(Vector3[] spawnPoints, TDBID[] characterRecords, uint unitCount) RTTI

Generated hook

re.Hooks.Place(
    "PreventionSystem",
    "SpawnFallbackUnits;array<Vector3>array<TweakDBID>Uint32",
    (PreventionSystem_SpawnFallbackUnits x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_SpawnFallbackUnits(
    PreventionSystem self,
    List<Vector3> spawnPoints,
    TDBID[] characterRecords,
    uint unitCount
);

bool SpawnUnits(Vector3[] spawnPoints, TDBID[] characterRecords, uint unitCount, out int sentRequests) RTTI

Generated hook

re.Hooks.Place(
    "PreventionSystem",
    "SpawnUnits;script_ref<array<Vector3>>script_ref<array<TweakDBID>>Uint32Int32",
    (PreventionSystem_SpawnUnits x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_SpawnUnits(
    PreventionSystem self,
    List<Vector3> spawnPoints,
    TDBID[] characterRecords,
    uint unitCount,
    int sentRequests
);

bool ReachedEngagedVehiclesLimit() RTTI

Generated hook

re.Hooks.Place(
    "PreventionSystem",
    "ReachedEngagedVehiclesLimit;",
    (PreventionSystem_ReachedEngagedVehiclesLimit x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_ReachedEngagedVehiclesLimit(
    PreventionSystem self
);

bool ReachedSupportVehiclesLimit() RTTI

Generated hook

re.Hooks.Place(
    "PreventionSystem",
    "ReachedSupportVehiclesLimit;",
    (PreventionSystem_ReachedSupportVehiclesLimit x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_ReachedSupportVehiclesLimit(
    PreventionSystem self
);

bool ReachedTotalVehiclesLimit() RTTI

Generated hook

re.Hooks.Place(
    "PreventionSystem",
    "ReachedTotalVehiclesLimit;",
    (PreventionSystem_ReachedTotalVehiclesLimit x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_ReachedTotalVehiclesLimit(
    PreventionSystem self
);

bool ShouldSpawnRoadblockade() RTTI

Generated hook

re.Hooks.Place(
    "PreventionSystem",
    "ShouldSpawnRoadblockade;",
    (PreventionSystem_ShouldSpawnRoadblockade x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_ShouldSpawnRoadblockade(
    PreventionSystem self
);

bool ReachedRoadblockLimit() RTTI

Generated hook

re.Hooks.Place(
    "PreventionSystem",
    "ReachedRoadblockLimit;",
    (PreventionSystem_ReachedRoadblockLimit x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_ReachedRoadblockLimit(
    PreventionSystem self
);

void GetNewBatchMaxTacSpawnPositions() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "GetNewBatchMaxTacSpawnPositions;",
    (PreventionSystem_GetNewBatchMaxTacSpawnPositions x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_GetNewBatchMaxTacSpawnPositions(
    PreventionSystem self
);

bool UseOffTrafficPoints() RTTI

Generated hook

re.Hooks.Place(
    "PreventionSystem",
    "UseOffTrafficPoints;",
    (PreventionSystem_UseOffTrafficPoints x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_UseOffTrafficPoints(
    PreventionSystem self
);

void TryGetAVSpawnPointsCallback(game.AVSpawnPointsRequestResult requestResult) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "TryGetAVSpawnPointsCallback;AVSpawnPointsRequestResult",
    (PreventionSystem_TryGetAVSpawnPointsCallback x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_TryGetAVSpawnPointsCallback(
    PreventionSystem self,
    game.AVSpawnPointsRequestResult requestResult
);

void RequestAVSpawnAtPosition(Vector3 position) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "RequestAVSpawnAtPosition;Vector3",
    (PreventionSystem_RequestAVSpawnAtPosition x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_RequestAVSpawnAtPosition(
    PreventionSystem self,
    Vector3 position
);

void OnRemoveRecentAvSpawnLocationFromCacheRequest(RemoveRecentAvSpawnLocationFromCacheRequest req) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "OnRemoveRecentAvSpawnLocationFromCacheRequest;RemoveRecentAvSpawnLocationFromCacheRequest",
    (PreventionSystem_OnRemoveRecentAvSpawnLocationFromCacheRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_OnRemoveRecentAvSpawnLocationFromCacheRequest(
    PreventionSystem self,
    RemoveRecentAvSpawnLocationFromCacheRequest? req
);

void SpawnRoadblockade(EPreventionHeatStage heatStage) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "SpawnRoadblockade;EPreventionHeatStage",
    (PreventionSystem_SpawnRoadblockade x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_SpawnRoadblockade(
    PreventionSystem self,
    EPreventionHeatStage heatStage
);

void UpdateStrategyPreCheckRequests() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "UpdateStrategyPreCheckRequests;",
    (PreventionSystem_UpdateStrategyPreCheckRequests x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_UpdateStrategyPreCheckRequests(
    PreventionSystem self
);

bool IsStrategyAvailable(vehicle.PoliceStrategy strategy) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_IsStrategyAvailable(
    PreventionSystem self,
    vehicle.PoliceStrategy strategy
);

bool IsDistanceRangeValid(Vector2 range) RTTI

Generated hook

re.Hooks.Place(
    "PreventionSystem",
    "IsDistanceRangeValid;Vector2",
    (PreventionSystem_IsDistanceRangeValid x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_IsDistanceRangeValid(
    PreventionSystem self,
    Vector2 range
);

Vector2 SelectRange(WeakHandle<game.data.StrategyData_Record> strategyDataRec) RTTI

Generated hook

re.Hooks.Place(
    "PreventionSystem",
    "SelectRange;StrategyData_Record",
    (PreventionSystem_SelectRange x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Vector2>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_SelectRange(
    PreventionSystem self,
    WeakHandle<game.data.StrategyData_Record> strategyDataRec
);

vehicle.BaseStrategyRequest? CreateStrategyRequest(vehicle.PoliceStrategy strategy) RTTI

Generated hook

re.Hooks.Place(
    "PreventionSystem",
    "CreateStrategyRequest;vehiclePoliceStrategy",
    (PreventionSystem_CreateStrategyRequest x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.vehicle.BaseStrategyRequest>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_CreateStrategyRequest(
    PreventionSystem self,
    vehicle.PoliceStrategy strategy
);

uint SpawnPoliceVehicle() RTTI

Generated hook

re.Hooks.Place(
    "PreventionSystem",
    "SpawnPoliceVehicle;",
    (PreventionSystem_SpawnPoliceVehicle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Uint>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_SpawnPoliceVehicle(
    PreventionSystem self
);

bool TrySpawnOnFootFallbackBasedOnRoadInfo(game.PreventionSpawnSystem system) RTTI

Generated hook

re.Hooks.Place(
    "PreventionSystem",
    "TrySpawnOnFootFallbackBasedOnRoadInfo;PreventionSpawnSystem",
    (PreventionSystem_TrySpawnOnFootFallbackBasedOnRoadInfo x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_TrySpawnOnFootFallbackBasedOnRoadInfo(
    PreventionSystem self,
    game.PreventionSpawnSystem? system
);

bool IsPursuedVehicleFast() RTTI

Generated hook

re.Hooks.Place(
    "PreventionSystem",
    "IsPursuedVehicleFast;",
    (PreventionSystem_IsPursuedVehicleFast x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_IsPursuedVehicleFast(
    PreventionSystem self
);

void DespawnAllPolice(bool useAggressiveDespawn) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "DespawnAllPolice;Bool",
    (PreventionSystem_DespawnAllPolice x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_DespawnAllPolice(
    PreventionSystem self,
    bool useAggressiveDespawn
);

void OnRefreshDistrict(RefreshDistrictRequest request) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "OnRefreshDistrict;RefreshDistrictRequest",
    (PreventionSystem_OnRefreshDistrict x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_OnRefreshDistrict(
    PreventionSystem self,
    RefreshDistrictRequest? request
);

void RestoreDefaultConfig() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "RestoreDefaultConfig;",
    (PreventionSystem_RestoreDefaultConfig x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_RestoreDefaultConfig(
    PreventionSystem self
);

void UpdateVehicles() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "UpdateVehicles;",
    (PreventionSystem_UpdateVehicles x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_UpdateVehicles(
    PreventionSystem self
);

void UpdateNPCs() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "UpdateNPCs;",
    (PreventionSystem_UpdateNPCs x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_UpdateNPCs(
    PreventionSystem self
);

void OnViewerRequest(PreventionVisibilityRequest request) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "OnViewerRequest;PreventionVisibilityRequest",
    (PreventionSystem_OnViewerRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_OnViewerRequest(
    PreventionSystem self,
    PreventionVisibilityRequest? request
);

void OnVehicleStolenRequest(PreventionVehicleStolenRequest request) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "OnVehicleStolenRequest;PreventionVehicleStolenRequest",
    (PreventionSystem_OnVehicleStolenRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_OnVehicleStolenRequest(
    PreventionSystem self,
    PreventionVehicleStolenRequest? request
);

void OnCombatStartedRequest(PreventionCombatStartedRequest request) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "OnCombatStartedRequest;PreventionCombatStartedRequest",
    (PreventionSystem_OnCombatStartedRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_OnCombatStartedRequest(
    PreventionSystem self,
    PreventionCombatStartedRequest? request
);

void OnCrimeWitnessRequest(PreventionCrimeWitnessRequest request) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "OnCrimeWitnessRequest;PreventionCrimeWitnessRequest",
    (PreventionSystem_OnCrimeWitnessRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_OnCrimeWitnessRequest(
    PreventionSystem self,
    PreventionCrimeWitnessRequest? request
);

bool UpdateViewers() RTTI

Generated hook

re.Hooks.Place(
    "PreventionSystem",
    "UpdateViewers;",
    (PreventionSystem_UpdateViewers x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_UpdateViewers(
    PreventionSystem self
);

void HasViewersChanged(bool currentViewerState) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "HasViewersChanged;Bool",
    (PreventionSystem_HasViewersChanged x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_HasViewersChanged(
    PreventionSystem self,
    bool currentViewerState
);

void OnViewersStateChanged() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "OnViewersStateChanged;",
    (PreventionSystem_OnViewersStateChanged x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_OnViewersStateChanged(
    PreventionSystem self
);

void ViewerRegister(WeakHandle<game.Object> viewer) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "ViewerRegister;GameObject",
    (PreventionSystem_ViewerRegister x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_ViewerRegister(
    PreventionSystem self,
    WeakHandle<game.Object> viewer
);

void ViewerUnRegister(WeakHandle<game.Object> viewer) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "ViewerUnRegister;GameObject",
    (PreventionSystem_ViewerUnRegister x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_ViewerUnRegister(
    PreventionSystem self,
    WeakHandle<game.Object> viewer
);

void OnRegisterRequest(PreventionRegisterRequest request) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "OnRegisterRequest;PreventionRegisterRequest",
    (PreventionSystem_OnRegisterRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_OnRegisterRequest(
    PreventionSystem self,
    PreventionRegisterRequest? request
);

void Register(CName attitudeGroup, WeakHandle<game.PersistentState> ps) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "Register;CNamePersistentState",
    (PreventionSystem_Register x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_Register(
    PreventionSystem self,
    CName attitudeGroup,
    WeakHandle<game.PersistentState> ps
);

void UnRegister(CName attitudeGroup, WeakHandle<game.PersistentState> ps) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "UnRegister;CNamePersistentState",
    (PreventionSystem_UnRegister x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_UnRegister(
    PreventionSystem self,
    CName attitudeGroup,
    WeakHandle<game.PersistentState> ps
);

void OnPreventionSecurityAreaRequest(PreventionSecurityAreaRequest request) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "OnPreventionSecurityAreaRequest;PreventionSecurityAreaRequest",
    (PreventionSystem_OnPreventionSecurityAreaRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_OnPreventionSecurityAreaRequest(
    PreventionSystem self,
    PreventionSecurityAreaRequest? request
);

void OnPreventionPoliceSecuritySystemRequest(PreventionPoliceSecuritySystemRequest request) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "OnPreventionPoliceSecuritySystemRequest;PreventionPoliceSecuritySystemRequest",
    (PreventionSystem_OnPreventionPoliceSecuritySystemRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_OnPreventionPoliceSecuritySystemRequest(
    PreventionSystem self,
    PreventionPoliceSecuritySystemRequest? request
);

bool ShouldReactionBeAggressive() RTTI

Generated hook

re.Hooks.Place(
    "PreventionSystem",
    "ShouldReactionBeAggressive;",
    (PreventionSystem_ShouldReactionBeAggressive x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_ShouldReactionBeAggressive(
    PreventionSystem self
);

void OnVehicleExplosion() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "OnVehicleExplosion;",
    (PreventionSystem_OnVehicleExplosion x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_OnVehicleExplosion(
    PreventionSystem self
);

void OnPreventionDamage(PreventionDamage evt) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "OnPreventionDamage;PreventionDamage",
    (PreventionSystem_OnPreventionDamage x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_OnPreventionDamage(
    PreventionSystem self,
    PreventionDamage? evt
);

void OnDistrictAreaEntered(game.map.pins.DistrictEnteredEvent request) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "OnDistrictAreaEntered;DistrictEnteredEvent",
    (PreventionSystem_OnDistrictAreaEntered x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_OnDistrictAreaEntered(
    PreventionSystem self,
    game.map.pins.DistrictEnteredEvent? request
);

void SyncTweakDistrictData() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "SyncTweakDistrictData;",
    (PreventionSystem_SyncTweakDistrictData x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_SyncTweakDistrictData(
    PreventionSystem self
);

void GetPreventionMatrixPresetForCurrentDistrict(WeakHandle<District> district) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "GetPreventionMatrixPresetForCurrentDistrict;District",
    (PreventionSystem_GetPreventionMatrixPresetForCurrentDistrict x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_GetPreventionMatrixPresetForCurrentDistrict(
    PreventionSystem self,
    WeakHandle<District> district
);

void GetPreventionDataForCurrentDistrict(WeakHandle<District> district) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "GetPreventionDataForCurrentDistrict;District",
    (PreventionSystem_GetPreventionDataForCurrentDistrict x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_GetPreventionDataForCurrentDistrict(
    PreventionSystem self,
    WeakHandle<District> district
);

void RestoreDefaultPreventionMatrixPreset() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "RestoreDefaultPreventionMatrixPreset;",
    (PreventionSystem_RestoreDefaultPreventionMatrixPreset x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_RestoreDefaultPreventionMatrixPreset(
    PreventionSystem self
);

void RestoreDefaultPreset() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "RestoreDefaultPreset;",
    (PreventionSystem_RestoreDefaultPreset x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_RestoreDefaultPreset(
    PreventionSystem self
);

void ChangeAgentsAttitude(EAIAttitude desiredAffiliation) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "ChangeAgentsAttitude;EAIAttitude",
    (PreventionSystem_ChangeAgentsAttitude x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_ChangeAgentsAttitude(
    PreventionSystem self,
    EAIAttitude desiredAffiliation
);

void ChangeAttitude(WeakHandle<game.Object> owner, WeakHandle<game.Object> target, EAIAttitude desiredAttitude) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "ChangeAttitude;GameObjectGameObjectEAIAttitude",
    (PreventionSystem_ChangeAttitude x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_ChangeAttitude(
    PreventionSystem self,
    WeakHandle<game.Object> owner,
    WeakHandle<game.Object> target,
    EAIAttitude desiredAttitude
);

void WakeUpAllAgents(bool wakeUp) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "WakeUpAllAgents;Bool",
    (PreventionSystem_WakeUpAllAgents x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_WakeUpAllAgents(
    PreventionSystem self,
    bool wakeUp
);

void WakeUpAgent(WeakHandle<game.PersistentState> ps, bool wakeUp) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "WakeUpAgent;PersistentStateBool",
    (PreventionSystem_WakeUpAgent x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_WakeUpAgent(
    PreventionSystem self,
    WeakHandle<game.PersistentState> ps,
    bool wakeUp
);

void ReevaluateSecurityAreaReset() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "ReevaluateSecurityAreaReset;",
    (PreventionSystem_ReevaluateSecurityAreaReset x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_ReevaluateSecurityAreaReset(
    PreventionSystem self
);

void CancelAllDelayedEvents() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "CancelAllDelayedEvents;",
    (PreventionSystem_CancelAllDelayedEvents x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_CancelAllDelayedEvents(
    PreventionSystem self
);

void CancelAllIntervalCallers() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "CancelAllIntervalCallers;",
    (PreventionSystem_CancelAllIntervalCallers x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_CancelAllIntervalCallers(
    PreventionSystem self
);

void ReevaluttatePreventionLockSources() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "ReevaluttatePreventionLockSources;",
    (PreventionSystem_ReevaluttatePreventionLockSources x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_ReevaluttatePreventionLockSources(
    PreventionSystem self
);

void OnClearPreventionSystemLocks(ClearPreventionSystemLocks evt) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "OnClearPreventionSystemLocks;ClearPreventionSystemLocks",
    (PreventionSystem_OnClearPreventionSystemLocks x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_OnClearPreventionSystemLocks(
    PreventionSystem self,
    ClearPreventionSystemLocks? evt
);

void OnTogglePreventionSystem(TogglePreventionSystem evt) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "OnTogglePreventionSystem;TogglePreventionSystem",
    (PreventionSystem_OnTogglePreventionSystem x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_OnTogglePreventionSystem(
    PreventionSystem self,
    TogglePreventionSystem? evt
);

void OnTogglePreventionCrowdSpawns(TogglePreventionCrowdSpawns evt) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "OnTogglePreventionCrowdSpawns;TogglePreventionCrowdSpawns",
    (PreventionSystem_OnTogglePreventionCrowdSpawns x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_OnTogglePreventionCrowdSpawns(
    PreventionSystem self,
    TogglePreventionCrowdSpawns? evt
);

void OnSetWantedLevel(SetWantedLevel evt) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "OnSetWantedLevel;SetWantedLevel",
    (PreventionSystem_OnSetWantedLevel x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_OnSetWantedLevel(
    PreventionSystem self,
    SetWantedLevel? evt
);

void RestoreMinimapToDefault() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "RestoreMinimapToDefault;",
    (PreventionSystem_RestoreMinimapToDefault x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_RestoreMinimapToDefault(
    PreventionSystem self
);

void PreventionMinimapOverride() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "PreventionMinimapOverride;",
    (PreventionSystem_PreventionMinimapOverride x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_PreventionMinimapOverride(
    PreventionSystem self
);

void HandleDebugEventSourceTracking(CName sourceName, bool tryRemoveLock) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "HandleDebugEventSourceTracking;CNameBool",
    (PreventionSystem_HandleDebugEventSourceTracking x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_HandleDebugEventSourceTracking(
    PreventionSystem self,
    CName sourceName,
    bool tryRemoveLock
);

void OnSetHeatCounterMultiplier(SetHeatCounterMultiplier evt) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "OnSetHeatCounterMultiplier;SetHeatCounterMultiplier",
    (PreventionSystem_OnSetHeatCounterMultiplier x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_OnSetHeatCounterMultiplier(
    PreventionSystem self,
    SetHeatCounterMultiplier? evt
);

void OnSetHeatLevelLimiter(SetHeatLevelLimiter evt) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "OnSetHeatLevelLimiter;SetHeatLevelLimiter",
    (PreventionSystem_OnSetHeatLevelLimiter x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_OnSetHeatLevelLimiter(
    PreventionSystem self,
    SetHeatLevelLimiter? evt
);

void OnSetPreventionPath(SetPreventionPath evt) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "OnSetPreventionPath;SetPreventionPath",
    (PreventionSystem_OnSetPreventionPath x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_OnSetPreventionPath(
    PreventionSystem self,
    SetPreventionPath? evt
);

void OnSetPreventionDifficulty(SetPreventionDifficulty evt) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "OnSetPreventionDifficulty;SetPreventionDifficulty",
    (PreventionSystem_OnSetPreventionDifficulty x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_OnSetPreventionDifficulty(
    PreventionSystem self,
    SetPreventionDifficulty? evt
);

void OnSetPoliceSearchArea(SetPoliceSearchArea evt) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "OnSetPoliceSearchArea;SetPoliceSearchArea",
    (PreventionSystem_OnSetPoliceSearchArea x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_OnSetPoliceSearchArea(
    PreventionSystem self,
    SetPoliceSearchArea? evt
);

void OnSetBlockShootingFromVehicle(SetBlockShootingFromVehicle evt) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "OnSetBlockShootingFromVehicle;SetBlockShootingFromVehicle",
    (PreventionSystem_OnSetBlockShootingFromVehicle x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_OnSetBlockShootingFromVehicle(
    PreventionSystem self,
    SetBlockShootingFromVehicle? evt
);

void OnTogglePreventionFreeArea(TogglePreventionFreeArea evt) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "OnTogglePreventionFreeArea;TogglePreventionFreeArea",
    (PreventionSystem_OnTogglePreventionFreeArea x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_OnTogglePreventionFreeArea(
    PreventionSystem self,
    TogglePreventionFreeArea? evt
);

void OnToggleQuestPreventionTrigger(ToggleQuestPreventionTrigger evt) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "OnToggleQuestPreventionTrigger;ToggleQuestPreventionTrigger",
    (PreventionSystem_OnToggleQuestPreventionTrigger x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_OnToggleQuestPreventionTrigger(
    PreventionSystem self,
    ToggleQuestPreventionTrigger? evt
);

void OnTogglePreventionGlobalQuestObjective(TogglePreventionGlobalQuestObjective evt) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "OnTogglePreventionGlobalQuestObjective;TogglePreventionGlobalQuestObjective",
    (PreventionSystem_OnTogglePreventionGlobalQuestObjective x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_OnTogglePreventionGlobalQuestObjective(
    PreventionSystem self,
    TogglePreventionGlobalQuestObjective? evt
);

void TogglePreventionGlobalQuestObjective_Internal(bool preventionGlobalQuestDisabled, CName eventSource) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "TogglePreventionGlobalQuestObjective_Internal;BoolCName",
    (PreventionSystem_TogglePreventionGlobalQuestObjective_Internal x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_TogglePreventionGlobalQuestObjective_Internal(
    PreventionSystem self,
    bool preventionGlobalQuestDisabled,
    CName eventSource
);

bool IsPreventionGlobalQuestObjectiveEnabled() RTTI

Generated hook

re.Hooks.Place(
    "PreventionSystem",
    "IsPreventionGlobalQuestObjectiveEnabled;",
    (PreventionSystem_IsPreventionGlobalQuestObjectiveEnabled x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_IsPreventionGlobalQuestObjectiveEnabled(
    PreventionSystem self
);

void OnToggleBlockSceneInteractions(ToggleBlockSceneInteractions evt) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "OnToggleBlockSceneInteractions;ToggleBlockSceneInteractions",
    (PreventionSystem_OnToggleBlockSceneInteractions x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_OnToggleBlockSceneInteractions(
    PreventionSystem self,
    ToggleBlockSceneInteractions? evt
);

void OnSetPoliceForcesPool(SetPoliceForcesPool evt) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "OnSetPoliceForcesPool;SetPoliceForcesPool",
    (PreventionSystem_OnSetPoliceForcesPool x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_OnSetPoliceForcesPool(
    PreventionSystem self,
    SetPoliceForcesPool? evt
);

bool IsVehicleValid(WeakHandle<vehicle.BaseObject> vehicle) RTTI

Generated hook

re.Hooks.Place(
    "PreventionSystem",
    "IsVehicleValid;VehicleObject",
    (PreventionSystem_IsVehicleValid x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

bool IsNPCValid(WeakHandle<ScriptedPuppet> puppet) RTTI

Generated hook

re.Hooks.Place(
    "PreventionSystem",
    "IsNPCValid;ScriptedPuppet",
    (PreventionSystem_IsNPCValid x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_IsNPCValid(
    PreventionSystem self,
    WeakHandle<ScriptedPuppet> puppet
);

void ReinitAll() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_ReinitAll(
    PreventionSystem self
);

bool IsAnyVehicleChasingTarget() RTTI

Generated hook

re.Hooks.Place(
    "PreventionSystem",
    "IsAnyVehicleChasingTarget;",
    (PreventionSystem_IsAnyVehicleChasingTarget x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_IsAnyVehicleChasingTarget(
    PreventionSystem self
);

void SendInternalSystem(float damageDealt, EPreventionHeatStage? heatStage) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "SendInternalSystem;FloatEPreventionHeatStage",
    (PreventionSystem_SendInternalSystem x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_SendInternalSystem(
    PreventionSystem self,
    float damageDealt,
    EPreventionHeatStage? heatStage
);

void OnPreventionConsoleInstructionRequest(PreventionConsoleInstructionRequest request) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "OnPreventionConsoleInstructionRequest;PreventionConsoleInstructionRequest",
    (PreventionSystem_OnPreventionConsoleInstructionRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_OnPreventionConsoleInstructionRequest(
    PreventionSystem self,
    PreventionConsoleInstructionRequest? request
);

void OnPreventionConsoleLockRequest(PreventionConsoleLockRequest request) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "OnPreventionConsoleLockRequest;PreventionConsoleLockRequest",
    (PreventionSystem_OnPreventionConsoleLockRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_OnPreventionConsoleLockRequest(
    PreventionSystem self,
    PreventionConsoleLockRequest? request
);

void OnPreventionMinMaxHeatLevels(PreventionMinMaxHeatLevels request) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "OnPreventionMinMaxHeatLevels;PreventionMinMaxHeatLevels",
    (PreventionSystem_OnPreventionMinMaxHeatLevels x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_OnPreventionMinMaxHeatLevels(
    PreventionSystem self,
    PreventionMinMaxHeatLevels? request
);

void RemovePlayerFromSecuritySystemBlacklist() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "RemovePlayerFromSecuritySystemBlacklist;",
    (PreventionSystem_RemovePlayerFromSecuritySystemBlacklist x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_RemovePlayerFromSecuritySystemBlacklist(
    PreventionSystem self
);

void TogglePreventionSystem(bool toggle) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "TogglePreventionSystem;Bool",
    (PreventionSystem_TogglePreventionSystem x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_TogglePreventionSystem(
    PreventionSystem self,
    bool toggle
);

void StartPreventionFreeAreaReset() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "StartPreventionFreeAreaReset;",
    (PreventionSystem_StartPreventionFreeAreaReset x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_StartPreventionFreeAreaReset(
    PreventionSystem self
);

void UpdatePreventionFreeAreas(bool isPlayerInFreeArea) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "UpdatePreventionFreeAreas;Bool",
    (PreventionSystem_UpdatePreventionFreeAreas x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_UpdatePreventionFreeAreas(
    PreventionSystem self,
    bool isPlayerInFreeArea
);

void OnTryResetPreventionFreeArea(TryResetPreventionFreeArea request) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "OnTryResetPreventionFreeArea;TryResetPreventionFreeArea",
    (PreventionSystem_OnTryResetPreventionFreeArea x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_OnTryResetPreventionFreeArea(
    PreventionSystem self,
    TryResetPreventionFreeArea? request
);

void execInstructionSafe(string heatChangeReason) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "execInstructionSafe;String",
    (PreventionSystem_execInstructionSafe x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_execInstructionSafe(
    PreventionSystem self,
    string heatChangeReason
);

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

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "StartVehicleDeescalationBehavior;VehicleObject",
    (PreventionSystem_StartVehicleDeescalationBehavior x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

void execInstructionActive(EPreventionHeatStage? heatStage) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "execInstructionActive;EPreventionHeatStage",
    (PreventionSystem_execInstructionActive x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_execInstructionActive(
    PreventionSystem self,
    EPreventionHeatStage? heatStage
);

void execInstructionOn() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "execInstructionOn;",
    (PreventionSystem_execInstructionOn x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_execInstructionOn(
    PreventionSystem self
);

void execInstructionOff() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "execInstructionOff;",
    (PreventionSystem_execInstructionOff x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_execInstructionOff(
    PreventionSystem self
);

void FillPreventionSystemDebugData(out game.PreventionSystemDebugData dataToFill) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "FillPreventionSystemDebugData;PreventionSystemDebugData",
    (PreventionSystem_FillPreventionSystemDebugData x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

int DebugGetCivilianDestroyedVehicleCount() RTTI

Generated hook

re.Hooks.Place(
    "PreventionSystem",
    "DebugGetCivilianDestroyedVehicleCount;",
    (PreventionSystem_DebugGetCivilianDestroyedVehicleCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_DebugGetCivilianDestroyedVehicleCount(
    PreventionSystem self
);

void RefreshDebug() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "RefreshDebug;",
    (PreventionSystem_RefreshDebug x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_RefreshDebug(
    PreventionSystem self
);

void RefreshDebugRemoveAllLockSources() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "RefreshDebugRemoveAllLockSources;",
    (PreventionSystem_RefreshDebugRemoveAllLockSources x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_RefreshDebugRemoveAllLockSources(
    PreventionSystem self
);

void RefreshDebugLockSources() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "RefreshDebugLockSources;",
    (PreventionSystem_RefreshDebugLockSources x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_RefreshDebugLockSources(
    PreventionSystem self
);

void RefreshDebugEventSources() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "RefreshDebugEventSources;",
    (PreventionSystem_RefreshDebugEventSources x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_RefreshDebugEventSources(
    PreventionSystem self
);

void RefreshDebugEvents() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "RefreshDebugEvents;",
    (PreventionSystem_RefreshDebugEvents x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_RefreshDebugEvents(
    PreventionSystem self
);

void RefreshDebugProcessInfo() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "RefreshDebugProcessInfo;",
    (PreventionSystem_RefreshDebugProcessInfo x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_RefreshDebugProcessInfo(
    PreventionSystem self
);

void RefreshDebugDistrictInfo() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "RefreshDebugDistrictInfo;",
    (PreventionSystem_RefreshDebugDistrictInfo x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_RefreshDebugDistrictInfo(
    PreventionSystem self
);

void RefreshDebugSecAreaInfo() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "RefreshDebugSecAreaInfo;",
    (PreventionSystem_RefreshDebugSecAreaInfo x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_RefreshDebugSecAreaInfo(
    PreventionSystem self
);

void ProcessDogtownLawAchievement() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "ProcessDogtownLawAchievement;",
    (PreventionSystem_ProcessDogtownLawAchievement x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_ProcessDogtownLawAchievement(
    PreventionSystem self
);

static void PreventionSecurityAreaEnterRequest(ScriptGameInstance context, bool playerIsIn, game.PersistentID areaID) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "PreventionSystem::PreventionSecurityAreaEnterRequest;GameInstanceBoolPersistentID",
    (PreventionSystem_PreventionSecurityAreaEnterRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_PreventionSecurityAreaEnterRequest(
    ScriptGameInstance context,
    bool playerIsIn,
    game.PersistentID areaID
);

static void StartPatrol(WeakHandle<vehicle.WheeledBaseObject> vehicle, PreventionSystem ps) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "PreventionSystem::StartPatrol;WheeledObjectPreventionSystem",
    (PreventionSystem_StartPatrol x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_StartPatrol(
    WeakHandle<vehicle.WheeledBaseObject> vehicle,
    PreventionSystem? ps
);

static void LogChaseVehicleInitBehaviorError(WeakHandle<vehicle.WheeledBaseObject> wheeledVehicleObject, vehicle.PoliceStrategy strat)

staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "PreventionSystem::LogChaseVehicleInitBehaviorError;WheeledObjectvehiclePoliceStrategy",
    (PreventionSystem_LogChaseVehicleInitBehaviorError x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_LogChaseVehicleInitBehaviorError(
    WeakHandle<vehicle.WheeledBaseObject> wheeledVehicleObject,
    vehicle.PoliceStrategy strat
);

static vehicle.BaseObject? GetLastKnownPlayerVehicle(ScriptGameInstance context) staticRTTI global

Generated hook

re.Hooks.Place(
    "PreventionSystem",
    "PreventionSystem::GetLastKnownPlayerVehicle;GameInstance",
    (PreventionSystem_GetLastKnownPlayerVehicle2 x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.vehicle.BaseObject>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_GetLastKnownPlayerVehicle2(
    ScriptGameInstance context
);

static bool QueueRequest(ScriptGameInstance context, game.ScriptableSystemRequest request, float delay) staticRTTI global

Generated hook

re.Hooks.Place(
    "PreventionSystem",
    "PreventionSystem::QueueRequest;GameInstanceScriptableSystemRequestFloat",
    (PreventionSystem_QueueRequest x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_QueueRequest(
    ScriptGameInstance context,
    game.ScriptableSystemRequest? request,
    float delay
);

static CName GetPreventionQuestDisabledGenericQuestReason() staticRTTI global

Generated hook

re.Hooks.Place(
    "PreventionSystem",
    "PreventionSystem::GetPreventionQuestDisabledGenericQuestReason;",
    (PreventionSystem_GetPreventionQuestDisabledGenericQuestReason x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.CName>();
    }
);

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

static void CreateNewDamageRequest(ScriptGameInstance context, game.Object target, game.data.AttackType attackType, float damageDealt, bool isTargetKilled)

staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "PreventionSystem::CreateNewDamageRequest;GameInstanceGameObjectgamedataAttackTypeFloatBool",
    (PreventionSystem_CreateNewDamageRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_CreateNewDamageRequest(
    ScriptGameInstance context,
    game.Object? target,
    game.data.AttackType attackType,
    float damageDealt,
    bool isTargetKilled
);

static void SetSpawnCodeRedReinforcement(ScriptGameInstance game, bool shouldSpawnReinforcement) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "PreventionSystem::SetSpawnCodeRedReinforcement;GameInstanceBool",
    (PreventionSystem_SetSpawnCodeRedReinforcement x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_SetSpawnCodeRedReinforcement(
    ScriptGameInstance game,
    bool shouldSpawnReinforcement
);

static bool VehicleRegistered(WeakHandle<vehicle.BaseObject> vehicle) staticRTTI global

Generated hook

re.Hooks.Place(
    "PreventionSystem",
    "PreventionSystem::VehicleRegistered;VehicleObject",
    (PreventionSystem_VehicleRegistered x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_VehicleRegistered(
    WeakHandle<vehicle.BaseObject> vehicle
);

static bool IsPreventionMaxTac(ScriptGameInstance context, game.Puppet owner) staticRTTI global

Generated hook

re.Hooks.Place(
    "PreventionSystem",
    "PreventionSystem::IsPreventionMaxTac;GameInstancegamePuppet",
    (PreventionSystem_IsPreventionMaxTac x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_IsPreventionMaxTac(
    ScriptGameInstance context,
    game.Puppet? owner
);

static WeakHandle<game.data.PreventionHeatTable_Record> GetPreventionHeatTableRecord(ScriptGameInstance game) staticRTTI global

static void StartRoadblockNPCAgentBehaviour(WeakHandle<ScriptedPuppet> unit) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "PreventionSystem::StartRoadblockNPCAgentBehaviour;ScriptedPuppet",
    (PreventionSystem_StartRoadblockNPCAgentBehaviour x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_StartRoadblockNPCAgentBehaviour(
    WeakHandle<ScriptedPuppet> unit
);

static void CreateNewPreventionDamageRequest(ScriptGameInstance context, game.Object target, float attackTime, game.data.AttackType attackType, float damageDealt, bool isTargetKilled)

staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "PreventionSystem::CreateNewPreventionDamageRequest;GameInstanceGameObjectFloatgamedataAttackTypeFloatBool",
    (PreventionSystem_CreateNewPreventionDamageRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_CreateNewPreventionDamageRequest(
    ScriptGameInstance context,
    game.Object? target,
    float attackTime,
    game.data.AttackType attackType,
    float damageDealt,
    bool isTargetKilled
);

static PoliceAgentRegistry? GetAgentRegistry(ScriptGameInstance context) staticRTTI global

Generated hook

re.Hooks.Place(
    "PreventionSystem",
    "PreventionSystem::GetAgentRegistry;GameInstance",
    (PreventionSystem_GetAgentRegistry2 x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.PoliceAgentRegistry>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_GetAgentRegistry2(
    ScriptGameInstance context
);

static CName GetPreventionQuestDisabledTweakContentTag() staticRTTI global

Generated hook

re.Hooks.Place(
    "PreventionSystem",
    "PreventionSystem::GetPreventionQuestDisabledTweakContentTag;",
    (PreventionSystem_GetPreventionQuestDisabledTweakContentTag x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.CName>();
    }
);

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

static bool ShouldPreventionSystemReactToCombat(WeakHandle<ScriptedPuppet> puppet) staticRTTI global

Generated hook

re.Hooks.Place(
    "PreventionSystem",
    "PreventionSystem::ShouldPreventionSystemReactToCombat;ScriptedPuppet",
    (PreventionSystem_ShouldPreventionSystemReactToCombat x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_ShouldPreventionSystemReactToCombat(
    WeakHandle<ScriptedPuppet> puppet
);

static void RegisterAsViewerToPreventionSystem(ScriptGameInstance context, game.Object requester) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "PreventionSystem::RegisterAsViewerToPreventionSystem;GameInstanceGameObject",
    (PreventionSystem_RegisterAsViewerToPreventionSystem x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_RegisterAsViewerToPreventionSystem(
    ScriptGameInstance context,
    game.Object? requester
);

static void CrimeWitnessRequestToPreventionSystem(ScriptGameInstance context, Vector4 criminalPosition) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "PreventionSystem::CrimeWitnessRequestToPreventionSystem;GameInstanceVector4",
    (PreventionSystem_CrimeWitnessRequestToPreventionSystem x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_CrimeWitnessRequestToPreventionSystem(
    ScriptGameInstance context,
    Vector4 criminalPosition
);

static void ShowMessage(ScriptGameInstance gameInstance, string message, float time) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "PreventionSystem::ShowMessage;GameInstancescript_ref<String>Float",
    (PreventionSystem_ShowMessage x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_ShowMessage(
    ScriptGameInstance gameInstance,
    string message,
    float time
);

static void UseCWMask(ScriptGameInstance game) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "PreventionSystem::UseCWMask;GameInstance",
    (PreventionSystem_UseCWMask x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

static CName GetSystemName() staticRTTI global

Generated hook

re.Hooks.Place(
    "PreventionSystem",
    "PreventionSystem::GetSystemName;",
    (PreventionSystem_GetSystemName x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.CName>();
    }
);

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

static float GetDamageToPlayerMultiplier(ScriptGameInstance game) staticRTTI global

Generated hook

re.Hooks.Place(
    "PreventionSystem",
    "PreventionSystem::GetDamageToPlayerMultiplier;GameInstance",
    (PreventionSystem_GetDamageToPlayerMultiplier2 x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

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

static void RegisterToPreventionSystem(ScriptGameInstance context, Device requester) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "PreventionSystem::RegisterToPreventionSystem;GameInstanceDevice",
    (PreventionSystem_RegisterToPreventionSystem x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_RegisterToPreventionSystem(
    ScriptGameInstance context,
    Device? requester
);

static bool CanPreventionReact(ScriptGameInstance game) staticRTTI global

Generated hook

re.Hooks.Place(
    "PreventionSystem",
    "PreventionSystem::CanPreventionReact;GameInstance",
    (PreventionSystem_CanPreventionReact x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

static CName GetPreventionQuestDisabledFactName() staticRTTI global

Generated hook

re.Hooks.Place(
    "PreventionSystem",
    "PreventionSystem::GetPreventionQuestDisabledFactName;",
    (PreventionSystem_GetPreventionQuestDisabledFactName x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.CName>();
    }
);

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

static void UnRegisterAsViewerToPreventionSystem(ScriptGameInstance context, game.Object requester) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "PreventionSystem::UnRegisterAsViewerToPreventionSystem;GameInstanceGameObject",
    (PreventionSystem_UnRegisterAsViewerToPreventionSystem x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_UnRegisterAsViewerToPreventionSystem(
    ScriptGameInstance context,
    game.Object? requester
);

static void StartActiveVehicleBehaviour(ScriptGameInstance context, WeakHandle<vehicle.WheeledBaseObject> wheeledVehicleObject)

staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "PreventionSystem::StartActiveVehicleBehaviour;GameInstanceWheeledObject",
    (PreventionSystem_StartActiveVehicleBehaviour x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_StartActiveVehicleBehaviour(
    ScriptGameInstance context,
    WeakHandle<vehicle.WheeledBaseObject> wheeledVehicleObject
);

static bool CheckNPCSpawnedType(ScriptGameInstance game, ent.EntityID entityID, game.DynamicVehicleType spawnedTypeToCheck)

staticRTTI global

Generated hook

re.Hooks.Place(
    "PreventionSystem",
    "PreventionSystem::CheckNPCSpawnedType;GameInstanceEntityIDDynamicVehicleType",
    (PreventionSystem_CheckNPCSpawnedType x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_CheckNPCSpawnedType(
    ScriptGameInstance game,
    ent.EntityID entityID,
    game.DynamicVehicleType spawnedTypeToCheck
);

static void ChasePlayer(WeakHandle<vehicle.WheeledBaseObject> vehicle) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "PreventionSystem::ChasePlayer;WheeledObject",
    (PreventionSystem_ChasePlayer x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_ChasePlayer(
    WeakHandle<vehicle.WheeledBaseObject> vehicle
);

static void CombatStartedRequestToPreventionSystem(ScriptGameInstance context, WeakHandle<game.Object> requester) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "PreventionSystem::CombatStartedRequestToPreventionSystem;GameInstanceGameObject",
    (PreventionSystem_CombatStartedRequestToPreventionSystem x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_CombatStartedRequestToPreventionSystem(
    ScriptGameInstance context,
    WeakHandle<game.Object> requester
);

static void UnRegisterToPreventionSystem(ScriptGameInstance context, Device requester) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "PreventionSystem::UnRegisterToPreventionSystem;GameInstanceDevice",
    (PreventionSystem_UnRegisterToPreventionSystem x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_UnRegisterToPreventionSystem(
    ScriptGameInstance context,
    Device? requester
);

static bool IsPlayerInAPoliceCarChase(ScriptGameInstance gameInstance) staticRTTI global

Generated hook

re.Hooks.Place(
    "PreventionSystem",
    "PreventionSystem::IsPlayerInAPoliceCarChase;GameInstance",
    (PreventionSystem_IsPlayerInAPoliceCarChase x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_IsPlayerInAPoliceCarChase(
    ScriptGameInstance gameInstance
);

static bool ShouldPreventionSystemReactToDamageDealt(WeakHandle<ScriptedPuppet> puppet) staticRTTI global

Generated hook

re.Hooks.Place(
    "PreventionSystem",
    "PreventionSystem::ShouldPreventionSystemReactToDamageDealt;ScriptedPuppet",
    (PreventionSystem_ShouldPreventionSystemReactToDamageDealt x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_ShouldPreventionSystemReactToDamageDealt(
    WeakHandle<ScriptedPuppet> puppet
);

static void NotifyPolice(game.Object owner) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "PreventionSystem::NotifyPolice;GameObject",
    (PreventionSystem_NotifyPolice x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_NotifyPolice(
    game.Object? owner
);

static void NotifyVehicleExplosion(vehicle.BaseObject veh) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "PreventionSystem::NotifyVehicleExplosion;VehicleObject",
    (PreventionSystem_NotifyVehicleExplosion x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_NotifyVehicleExplosion(
    vehicle.BaseObject? veh
);

static bool IsChasingPlayer(ScriptGameInstance game) staticRTTI global

Generated hook

re.Hooks.Place(
    "PreventionSystem",
    "PreventionSystem::IsChasingPlayer;GameInstance",
    (PreventionSystem_IsChasingPlayer2 x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

static void SetLastKnownPlayerPosition(ScriptGameInstance context, Vector4 value) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "PreventionSystem::SetLastKnownPlayerPosition;GameInstanceVector4",
    (PreventionSystem_SetLastKnownPlayerPosition2 x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_SetLastKnownPlayerPosition2(
    ScriptGameInstance context,
    Vector4 value
);

static void PreventionPoliceSecuritySystemRequest(ScriptGameInstance context, game.PersistentID securitySystemID) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "PreventionSystem::PreventionPoliceSecuritySystemRequest;GameInstancePersistentID",
    (PreventionSystem_PreventionPoliceSecuritySystemRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_PreventionPoliceSecuritySystemRequest(
    ScriptGameInstance context,
    game.PersistentID securitySystemID
);

static void SetPlayerMounted(ScriptGameInstance context, bool value) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "PreventionSystem::SetPlayerMounted;GameInstanceBool",
    (PreventionSystem_SetPlayerMounted x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_SetPlayerMounted(
    ScriptGameInstance context,
    bool value
);

static bool ShouldReactionBeAgressive(ScriptGameInstance game) staticRTTI global

Generated hook

re.Hooks.Place(
    "PreventionSystem",
    "PreventionSystem::ShouldReactionBeAgressive;GameInstance",
    (PreventionSystem_ShouldReactionBeAgressive x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

static void SetLastKnownPlayerVehicle(ScriptGameInstance context, WeakHandle<vehicle.BaseObject> value) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "PreventionSystem::SetLastKnownPlayerVehicle;GameInstanceVehicleObject",
    (PreventionSystem_SetLastKnownPlayerVehicle x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_SetLastKnownPlayerVehicle(
    ScriptGameInstance context,
    WeakHandle<vehicle.BaseObject> value
);

static void ForceStarStateToActive(ScriptGameInstance context, bool value) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "PreventionSystem",
    "PreventionSystem::ForceStarStateToActive;GameInstanceBool",
    (PreventionSystem_ForceStarStateToActive x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_ForceStarStateToActive(
    ScriptGameInstance context,
    bool value
);

static float GetDamageReactionThreshold() staticRTTI global

Generated hook

re.Hooks.Place(
    "PreventionSystem",
    "PreventionSystem::GetDamageReactionThreshold;",
    (PreventionSystem_GetDamageReactionThreshold x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

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

static bool StartDriveToPoint(WeakHandle<vehicle.WheeledBaseObject> vehicle) staticRTTI global

Generated hook

re.Hooks.Place(
    "PreventionSystem",
    "PreventionSystem::StartDriveToPoint;WheeledObject",
    (PreventionSystem_StartDriveToPoint x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_StartDriveToPoint(
    WeakHandle<vehicle.WheeledBaseObject> vehicle
);

static bool ShouldPreventionSystemReactToAttack(WeakHandle<game.Object> target, float attackTime, bool istargetDefeated) staticRTTI global

Generated hook

re.Hooks.Place(
    "PreventionSystem",
    "PreventionSystem::ShouldPreventionSystemReactToAttack;GameObjectFloatBool",
    (PreventionSystem_ShouldPreventionSystemReactToAttack x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PreventionSystem_ShouldPreventionSystemReactToAttack(
    WeakHandle<game.Object> target,
    float attackTime,
    bool istargetDefeated
);