class

AccessPointControllerPS

7 properties
70 functions
1 derived class

Extends MasterControllerPS ScriptableDeviceComponentPS SharedGameplayPS game.DeviceComponentPS game.ComponentPS game.PersistentState IScriptable ISerializable

Derived

LootContainerAccessPointControllerPS

Properties

Property	Type	Offset
`rewardNotificationIcons`	`List`	`0x298`	scripted
`rewardNotificationString`	`string`	`0x2A8`	scripted
`accessPointSkillChecks`	`HackingContainer?`	`0x2C8`	scripted
`isBreached`	`bool`	`0x2D8`	scripted
`moneyAwarded`	`bool`	`0x2D9`	scripted
`isVirtual`	`bool`	`0x2DA`	scripted
`pingedSquads`	`CName[]`	`0x2E0`	scripted

Functions

bool OnInstantiated() overrideRTTI

Generated hook

re.Hooks.Place(
    "AccessPointControllerPS",
    "OnInstantiated",
    (AccessPointControllerPS_OnInstantiated x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AccessPointControllerPS_OnInstantiated(
    AccessPointControllerPS self
);

BaseSkillCheckContainer? GetSkillCheckContainerForSetup() overrideRTTI

Generated hook

re.Hooks.Place(
    "AccessPointControllerPS",
    "GetSkillCheckContainerForSetup;",
    (AccessPointControllerPS_GetSkillCheckContainerForSetup x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.BaseSkillCheckContainer>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AccessPointControllerPS_GetSkillCheckContainerForSetup(
    AccessPointControllerPS self
);

void GameAttached() overrideRTTI

Generated hook

re.Hooks.PlaceVoid(
    "AccessPointControllerPS",
    "GameAttached;",
    (AccessPointControllerPS_GameAttached x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct AccessPointControllerPS_GameAttached(
    AccessPointControllerPS self
);

bool IsVirtual() RTTI

Generated hook

re.Hooks.Place(
    "AccessPointControllerPS",
    "IsVirtual;",
    (AccessPointControllerPS_IsVirtual x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AccessPointControllerPS_IsVirtual(
    AccessPointControllerPS self
);

bool HasNetworkBackdoor() overrideRTTI

Generated hook

re.Hooks.Place(
    "AccessPointControllerPS",
    "HasNetworkBackdoor;",
    (AccessPointControllerPS_HasNetworkBackdoor x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AccessPointControllerPS_HasNetworkBackdoor(
    AccessPointControllerPS self
);

TDBID GetMinigameDefinition() overrideRTTI

Generated hook

re.Hooks.Place(
    "AccessPointControllerPS",
    "GetMinigameDefinition;",
    (AccessPointControllerPS_GetMinigameDefinition x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.TDBID>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AccessPointControllerPS_GetMinigameDefinition(
    AccessPointControllerPS self
);

AccessPointControllerPS? GetBackdoorAccessPoint() overrideRTTI

Generated hook

re.Hooks.Place(
    "AccessPointControllerPS",
    "GetBackdoorAccessPoint;",
    (AccessPointControllerPS_GetBackdoorAccessPoint x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.AccessPointControllerPS>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AccessPointControllerPS_GetBackdoorAccessPoint(
    AccessPointControllerPS self
);

ScriptableDeviceComponentPS?[] GetDevicesThatPlayerCanBreach() RTTI

bool IsAccessPointOf(game.PersistentID slaveToCheck) RTTI

Generated hook

re.Hooks.Place(
    "AccessPointControllerPS",
    "IsAccessPointOf;PersistentID",
    (AccessPointControllerPS_IsAccessPointOf x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AccessPointControllerPS_IsAccessPointOf(
    AccessPointControllerPS self,
    game.PersistentID slaveToCheck
);

bool IsConnectedToBackdoorDevice() overrideRTTI

Generated hook

re.Hooks.Place(
    "AccessPointControllerPS",
    "IsConnectedToBackdoorDevice;",
    (AccessPointControllerPS_IsConnectedToBackdoorDevice x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AccessPointControllerPS_IsConnectedToBackdoorDevice(
    AccessPointControllerPS self
);

bool ShouldRevealNetworkGrid() overrideRTTI

Generated hook

re.Hooks.Place(
    "AccessPointControllerPS",
    "ShouldRevealNetworkGrid;",
    (AccessPointControllerPS_ShouldRevealNetworkGrid x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AccessPointControllerPS_ShouldRevealNetworkGrid(
    AccessPointControllerPS self
);

bool IsMainframe() overrideRTTI

Generated hook

re.Hooks.Place(
    "AccessPointControllerPS",
    "IsMainframe;",
    (AccessPointControllerPS_IsMainframe x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AccessPointControllerPS_IsMainframe(
    AccessPointControllerPS self
);

game.device.Clearance? GetClearance() overrideRTTI

Generated hook

re.Hooks.Place(
    "AccessPointControllerPS",
    "GetClearance",
    (AccessPointControllerPS_GetClearance x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.device.Clearance>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AccessPointControllerPS_GetClearance(
    AccessPointControllerPS self
);

void SetIsBreached(bool isBreached) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "AccessPointControllerPS",
    "SetIsBreached;Bool",
    (AccessPointControllerPS_SetIsBreached x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct AccessPointControllerPS_SetIsBreached(
    AccessPointControllerPS self,
    bool isBreached
);

string GetNetworkName() overrideRTTI

Generated hook

re.Hooks.Place(
    "AccessPointControllerPS",
    "GetNetworkName;",
    (AccessPointControllerPS_GetNetworkName x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Str>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AccessPointControllerPS_GetNetworkName(
    AccessPointControllerPS self
);

int GetNetworkSizeCount() overrideRTTI

Generated hook

re.Hooks.Place(
    "AccessPointControllerPS",
    "GetNetworkSizeCount;",
    (AccessPointControllerPS_GetNetworkSizeCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AccessPointControllerPS_GetNetworkSizeCount(
    AccessPointControllerPS self
);

bool IsNetworkBreached() RTTI

Generated hook

re.Hooks.Place(
    "AccessPointControllerPS",
    "IsNetworkBreached;",
    (AccessPointControllerPS_IsNetworkBreached x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AccessPointControllerPS_IsNetworkBreached(
    AccessPointControllerPS self
);

bool IsBreached() overrideRTTI

Generated hook

re.Hooks.Place(
    "AccessPointControllerPS",
    "IsBreached;",
    (AccessPointControllerPS_IsBreached x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AccessPointControllerPS_IsBreached(
    AccessPointControllerPS self
);

void BreachConnectedDevices() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "AccessPointControllerPS",
    "BreachConnectedDevices;",
    (AccessPointControllerPS_BreachConnectedDevices x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct AccessPointControllerPS_BreachConnectedDevices(
    AccessPointControllerPS self
);

SpiderbotEnableAccessPoint? ActionSpiderbotEnableAccessPoint() RTTI

Generated hook

re.Hooks.Place(
    "AccessPointControllerPS",
    "ActionSpiderbotEnableAccessPoint;",
    (AccessPointControllerPS_ActionSpiderbotEnableAccessPoint x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.SpiderbotEnableAccessPoint>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AccessPointControllerPS_ActionSpiderbotEnableAccessPoint(
    AccessPointControllerPS self
);

RevealEnemiesProgram? ActionRevealEnemiesProgram() RTTI

Generated hook

re.Hooks.Place(
    "AccessPointControllerPS",
    "ActionRevealEnemiesProgram;",
    (AccessPointControllerPS_ActionRevealEnemiesProgram x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.RevealEnemiesProgram>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AccessPointControllerPS_ActionRevealEnemiesProgram(
    AccessPointControllerPS self
);

EntityNotificationType OnRevealEnemiesProgram(RevealEnemiesProgram evt) RTTI

Generated hook

re.Hooks.Place(
    "AccessPointControllerPS",
    "OnRevealEnemiesProgram;RevealEnemiesProgram",
    (AccessPointControllerPS_OnRevealEnemiesProgram x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.EntityNotificationType>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AccessPointControllerPS_OnRevealEnemiesProgram(
    AccessPointControllerPS self,
    RevealEnemiesProgram? evt
);

void RefreshSlaves(game.DeviceComponentPS[] devices) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "AccessPointControllerPS",
    "RefreshSlaves;script_ref<array<DeviceComponentPS>>",
    (AccessPointControllerPS_RefreshSlaves x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct AccessPointControllerPS_RefreshSlaves(
    AccessPointControllerPS self,
    game.DeviceComponentPS[] devices
);

void FilterRedundantPrograms(TDBID[] programs) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "AccessPointControllerPS",
    "FilterRedundantPrograms;script_ref<array<TweakDBID>>",
    (AccessPointControllerPS_FilterRedundantPrograms x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct AccessPointControllerPS_FilterRedundantPrograms(
    AccessPointControllerPS self,
    TDBID[] programs
);

void ProcessLoot(float baseMoney, bool craftingMaterial, float baseShardDropChance, game.TransactionSystem TS) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "AccessPointControllerPS",
    "ProcessLoot;FloatBoolFloatTransactionSystem",
    (AccessPointControllerPS_ProcessLoot x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct AccessPointControllerPS_ProcessLoot(
    AccessPointControllerPS self,
    float baseMoney,
    bool craftingMaterial,
    float baseShardDropChance,
    game.TransactionSystem? TS
);

void GetQuickhackReward(float playerLevel, game.TransactionSystem TS) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "AccessPointControllerPS",
    "GetQuickhackReward;FloatTransactionSystem",
    (AccessPointControllerPS_GetQuickhackReward x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct AccessPointControllerPS_GetQuickhackReward(
    AccessPointControllerPS self,
    float playerLevel,
    game.TransactionSystem? TS
);

TDBID[] GetPlayersUniqueHacks(game.TransactionSystem TS, TDBID[] hacksPool, game.data.Quality quality, out TDBID[] playerHacksTweak) RTTI

bool WasMoneyAwarded() RTTI

Generated hook

re.Hooks.Place(
    "AccessPointControllerPS",
    "WasMoneyAwarded;",
    (AccessPointControllerPS_WasMoneyAwarded x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AccessPointControllerPS_WasMoneyAwarded(
    AccessPointControllerPS self
);

bool ShouldRewardMoney() RTTI

Generated hook

re.Hooks.Place(
    "AccessPointControllerPS",
    "ShouldRewardMoney;",
    (AccessPointControllerPS_ShouldRewardMoney x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AccessPointControllerPS_ShouldRewardMoney(
    AccessPointControllerPS self
);

void RewardMoney(float baseMoney) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "AccessPointControllerPS",
    "RewardMoney;Float",
    (AccessPointControllerPS_RewardMoney x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct AccessPointControllerPS_RewardMoney(
    AccessPointControllerPS self,
    float baseMoney
);

EntityNotificationType OnNetworkMoneySiphoned(NetworkMoneySiphoned evt) RTTI

Generated hook

re.Hooks.Place(
    "AccessPointControllerPS",
    "OnNetworkMoneySiphoned;NetworkMoneySiphoned",
    (AccessPointControllerPS_OnNetworkMoneySiphoned x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.EntityNotificationType>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AccessPointControllerPS_OnNetworkMoneySiphoned(
    AccessPointControllerPS self,
    NetworkMoneySiphoned? evt
);

void GenerateMaterialDrops(float playerLevel, game.TransactionSystem TS) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "AccessPointControllerPS",
    "GenerateMaterialDrops;FloatTransactionSystem",
    (AccessPointControllerPS_GenerateMaterialDrops x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct AccessPointControllerPS_GenerateMaterialDrops(
    AccessPointControllerPS self,
    float playerLevel,
    game.TransactionSystem? TS
);

void AddReward(game.TransactionSystem TS, TDBID itemQueryTDBID, uint? amount) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "AccessPointControllerPS",
    "AddReward;TransactionSystemTweakDBIDUint32",
    (AccessPointControllerPS_AddReward x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct AccessPointControllerPS_AddReward(
    AccessPointControllerPS self,
    game.TransactionSystem? TS,
    TDBID itemQueryTDBID,
    uint? amount
);

void AddHackReward(game.TransactionSystem TS, TDBID itemTweakID, uint? amount) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "AccessPointControllerPS",
    "AddHackReward;TransactionSystemTweakDBIDUint32",
    (AccessPointControllerPS_AddHackReward x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct AccessPointControllerPS_AddHackReward(
    AccessPointControllerPS self,
    game.TransactionSystem? TS,
    TDBID itemTweakID,
    uint? amount
);

void CleanRewardNotification() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "AccessPointControllerPS",
    "CleanRewardNotification;",
    (AccessPointControllerPS_CleanRewardNotification x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct AccessPointControllerPS_CleanRewardNotification(
    AccessPointControllerPS self
);

void ShowRewardNotification() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "AccessPointControllerPS",
    "ShowRewardNotification;",
    (AccessPointControllerPS_ShowRewardNotification x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct AccessPointControllerPS_ShowRewardNotification(
    AccessPointControllerPS self
);

void ProcessMinigameNetworkActions(game.DeviceComponentPS device) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "AccessPointControllerPS",
    "ProcessMinigameNetworkActions;DeviceComponentPS",
    (AccessPointControllerPS_ProcessMinigameNetworkActions x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct AccessPointControllerPS_ProcessMinigameNetworkActions(
    AccessPointControllerPS self,
    game.DeviceComponentPS? device
);

game.device.Action?[] ExtractActions() RTTI

game.device.Action? GetQuestActionByName(CName actionName) overrideRTTI

Generated hook

re.Hooks.Place(
    "AccessPointControllerPS",
    "GetQuestActionByName;CName",
    (AccessPointControllerPS_GetQuestActionByName x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.device.Action>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AccessPointControllerPS_GetQuestActionByName(
    AccessPointControllerPS self,
    CName actionName
);

void GetQuestActions(out game.device.Action[] outActions, game.GetActionsContext context) overrideRTTI

Generated hook

re.Hooks.PlaceVoid(
    "AccessPointControllerPS",
    "GetQuestActions;array<DeviceAction>script_ref<GetActionsContext>",
    (AccessPointControllerPS_GetQuestActions x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct AccessPointControllerPS_GetQuestActions(
    AccessPointControllerPS self,
    game.device.Action[] outActions,
    game.GetActionsContext context
);

ResetNetworkBreachState? ActionResetNetworkBreachState() RTTI

Generated hook

re.Hooks.Place(
    "AccessPointControllerPS",
    "ActionResetNetworkBreachState;",
    (AccessPointControllerPS_ActionResetNetworkBreachState x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.ResetNetworkBreachState>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AccessPointControllerPS_ActionResetNetworkBreachState(
    AccessPointControllerPS self
);

EntityNotificationType OnResetNetworkBreachState(ResetNetworkBreachState evt) RTTI

Generated hook

re.Hooks.Place(
    "AccessPointControllerPS",
    "OnResetNetworkBreachState;ResetNetworkBreachState",
    (AccessPointControllerPS_OnResetNetworkBreachState x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.EntityNotificationType>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AccessPointControllerPS_OnResetNetworkBreachState(
    AccessPointControllerPS self,
    ResetNetworkBreachState? evt
);

bool CanCreateAnyQuickHackActions() overrideRTTI

Generated hook

re.Hooks.Place(
    "AccessPointControllerPS",
    "CanCreateAnyQuickHackActions;",
    (AccessPointControllerPS_CanCreateAnyQuickHackActions x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AccessPointControllerPS_CanCreateAnyQuickHackActions(
    AccessPointControllerPS self
);

bool CanCreateAnySpiderbotActions() overrideRTTI

Generated hook

re.Hooks.Place(
    "AccessPointControllerPS",
    "CanCreateAnySpiderbotActions;",
    (AccessPointControllerPS_CanCreateAnySpiderbotActions x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AccessPointControllerPS_CanCreateAnySpiderbotActions(
    AccessPointControllerPS self
);

void FinalizeNetrunnerDive(game.ui.HackingMinigameState state) overrideRTTI

Generated hook

re.Hooks.PlaceVoid(
    "AccessPointControllerPS",
    "FinalizeNetrunnerDive;HackingMinigameState",
    (AccessPointControllerPS_FinalizeNetrunnerDive x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct AccessPointControllerPS_FinalizeNetrunnerDive(
    AccessPointControllerPS self,
    game.ui.HackingMinigameState state
);

EntityNotificationType OnNPCBreachEvent(NPCBreachEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "AccessPointControllerPS",
    "OnNPCBreachEvent;NPCBreachEvent",
    (AccessPointControllerPS_OnNPCBreachEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.EntityNotificationType>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AccessPointControllerPS_OnNPCBreachEvent(
    AccessPointControllerPS self,
    NPCBreachEvent? evt
);

void ResolveDive(bool isRemote) overrideRTTI

Generated hook

re.Hooks.PlaceVoid(
    "AccessPointControllerPS",
    "ResolveDive;Bool",
    (AccessPointControllerPS_ResolveDive x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct AccessPointControllerPS_ResolveDive(
    AccessPointControllerPS self,
    bool isRemote
);

void SendMinigameFailedToAllNPCs() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "AccessPointControllerPS",
    "SendMinigameFailedToAllNPCs;",
    (AccessPointControllerPS_SendMinigameFailedToAllNPCs x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct AccessPointControllerPS_SendMinigameFailedToAllNPCs(
    AccessPointControllerPS self
);

EntityNotificationType OnSetExposeQuickHacks(SetExposeQuickHacks evt) overrideRTTI

Generated hook

re.Hooks.Place(
    "AccessPointControllerPS",
    "OnSetExposeQuickHacks;SetExposeQuickHacks",
    (AccessPointControllerPS_OnSetExposeQuickHacks x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.EntityNotificationType>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AccessPointControllerPS_OnSetExposeQuickHacks(
    AccessPointControllerPS self,
    SetExposeQuickHacks? evt
);

EntityNotificationType OnValidate(Validate evt) RTTI

Generated hook

re.Hooks.Place(
    "AccessPointControllerPS",
    "OnValidate;Validate",
    (AccessPointControllerPS_OnValidate x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.EntityNotificationType>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AccessPointControllerPS_OnValidate(
    AccessPointControllerPS self,
    Validate? evt
);

EntityNotificationType OnQuestRemoveQuickHacks(QuestRemoveQuickHacks evt) overrideRTTI

Generated hook

re.Hooks.Place(
    "AccessPointControllerPS",
    "OnQuestRemoveQuickHacks;QuestRemoveQuickHacks",
    (AccessPointControllerPS_OnQuestRemoveQuickHacks x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.EntityNotificationType>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AccessPointControllerPS_OnQuestRemoveQuickHacks(
    AccessPointControllerPS self,
    QuestRemoveQuickHacks? evt
);

EntityNotificationType OnQuestBreachAccessPoint(QuestBreachAccessPoint evt) overrideRTTI

Generated hook

re.Hooks.Place(
    "AccessPointControllerPS",
    "OnQuestBreachAccessPoint;QuestBreachAccessPoint",
    (AccessPointControllerPS_OnQuestBreachAccessPoint x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.EntityNotificationType>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AccessPointControllerPS_OnQuestBreachAccessPoint(
    AccessPointControllerPS self,
    QuestBreachAccessPoint? evt
);

EntityNotificationType OnSpiderbotEnableAccessPoint(SpiderbotEnableAccessPoint evt) RTTI

Generated hook

re.Hooks.Place(
    "AccessPointControllerPS",
    "OnSpiderbotEnableAccessPoint;SpiderbotEnableAccessPoint",
    (AccessPointControllerPS_OnSpiderbotEnableAccessPoint x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.EntityNotificationType>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AccessPointControllerPS_OnSpiderbotEnableAccessPoint(
    AccessPointControllerPS self,
    SpiderbotEnableAccessPoint? evt
);

void DebugBreachConnectedDevices() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "AccessPointControllerPS",
    "DebugBreachConnectedDevices;",
    (AccessPointControllerPS_DebugBreachConnectedDevices x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct AccessPointControllerPS_DebugBreachConnectedDevices(
    AccessPointControllerPS self
);

EntityNotificationType OnBreachAccessPointEvent(BreachAccessPointEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "AccessPointControllerPS",
    "OnBreachAccessPointEvent;BreachAccessPointEvent",
    (AccessPointControllerPS_OnBreachAccessPointEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.EntityNotificationType>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AccessPointControllerPS_OnBreachAccessPointEvent(
    AccessPointControllerPS self,
    BreachAccessPointEvent? evt
);

EntityNotificationType OnRefreshSlavesEvent(RefreshSlavesEvent evt) overrideRTTI

Generated hook

re.Hooks.Place(
    "AccessPointControllerPS",
    "OnRefreshSlavesEvent;RefreshSlavesEvent",
    (AccessPointControllerPS_OnRefreshSlavesEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.EntityNotificationType>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AccessPointControllerPS_OnRefreshSlavesEvent(
    AccessPointControllerPS self,
    RefreshSlavesEvent? evt
);

CommunityProxyPS?[] GetCommunityProxies() RTTI
WeakHandle<NetworkAreaControllerPS> GetNetworkArea() overrideRTTI

bool IsSpiderbotHackingConditionFullfilled() RTTI

Generated hook

re.Hooks.Place(
    "AccessPointControllerPS",
    "IsSpiderbotHackingConditionFullfilled;",
    (AccessPointControllerPS_IsSpiderbotHackingConditionFullfilled x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AccessPointControllerPS_IsSpiderbotHackingConditionFullfilled(
    AccessPointControllerPS self
);

void UploadProgram(int programID) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "AccessPointControllerPS",
    "UploadProgram;Int32",
    (AccessPointControllerPS_UploadProgram x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct AccessPointControllerPS_UploadProgram(
    AccessPointControllerPS self,
    int programID
);

void RevealDevicesGrid(bool shouldDraw, Vector4? ownerEntityPosition, game.FxResource? fxDefault, bool? isPing, float? lifetime, bool? revealSlave, bool? revealMaster, bool? ignoreRevealed)

overrideRTTI

Generated hook

re.Hooks.PlaceVoid(
    "AccessPointControllerPS",
    "RevealDevicesGrid;BoolVector4FxResourceBoolFloatBoolBoolBool",
    (AccessPointControllerPS_RevealDevicesGrid x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct AccessPointControllerPS_RevealDevicesGrid(
    AccessPointControllerPS self,
    bool shouldDraw,
    Vector4? ownerEntityPosition,
    game.FxResource? fxDefault,
    bool? isPing,
    float? lifetime,
    bool? revealSlave,
    bool? revealMaster,
    bool? ignoreRevealed
);

BackDoorDeviceBlackboardDef? GetBlackboardDef() overrideRTTI

Generated hook

re.Hooks.Place(
    "AccessPointControllerPS",
    "GetBlackboardDef;",
    (AccessPointControllerPS_GetBlackboardDef x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.BackDoorDeviceBlackboardDef>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AccessPointControllerPS_GetBlackboardDef(
    AccessPointControllerPS self
);

void CheckMasterRunnerAchievement(int minigameProgramsCompleted) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "AccessPointControllerPS",
    "CheckMasterRunnerAchievement;Int32",
    (AccessPointControllerPS_CheckMasterRunnerAchievement x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct AccessPointControllerPS_CheckMasterRunnerAchievement(
    AccessPointControllerPS self,
    int minigameProgramsCompleted
);

void PingSquad() overrideRTTI

Generated hook

re.Hooks.PlaceVoid(
    "AccessPointControllerPS",
    "PingSquad;",
    (AccessPointControllerPS_PingSquad x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct AccessPointControllerPS_PingSquad(
    AccessPointControllerPS self
);

void AddPingedSquad(CName squadName) RTTI

Generated hook

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

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

void RemovePingedSquad(CName squadName) RTTI

Generated hook

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

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

void ClearPingedSquads() RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct AccessPointControllerPS_ClearPingedSquads(
    AccessPointControllerPS self
);

bool IsSquadMarkedWithPing(CName squadName) RTTI

Generated hook

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

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

EntityNotificationType OnFillTakeOverChainBBoardEvent(FillTakeOverChainBBoardEvent evt) overrideRTTI

Generated hook

re.Hooks.Place(
    "AccessPointControllerPS",
    "OnFillTakeOverChainBBoardEvent;FillTakeOverChainBBoardEvent",
    (AccessPointControllerPS_OnFillTakeOverChainBBoardEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.EntityNotificationType>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AccessPointControllerPS_OnFillTakeOverChainBBoardEvent(
    AccessPointControllerPS self,
    FillTakeOverChainBBoardEvent? evt
);

ConnectedClassTypes CheckConnectedClassTypes() RTTI

Generated hook

re.Hooks.Place(
    "AccessPointControllerPS",
    "CheckConnectedClassTypes;",
    (AccessPointControllerPS_CheckConnectedClassTypes x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.ConnectedClassTypes>();
    }
);

[Msgpack.Gen]
public readonly partial record struct AccessPointControllerPS_CheckConnectedClassTypes(
    AccessPointControllerPS self
);