class game.data

HackingMiniGame_Record

game.data.HackingMiniGame_Record

0 properties
48 functions

Extends game.data.TweakDBRecord IScriptable ISerializable

Properties

None.

Functions

void AllowedTraps(out WeakHandle<game.data.Trap_Record>[] outList) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamedataHackingMiniGame_Record",
    "AllowedTraps",
    (HackingMiniGame_Record_AllowedTraps x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct HackingMiniGame_Record_AllowedTraps(
    game.data.HackingMiniGame_Record self,
    WeakHandle<game.data.Trap_Record>[] outList
);

int GetAllowedTrapsCount() RTTI

Generated hook

re.Hooks.Place(
    "gamedataHackingMiniGame_Record",
    "GetAllowedTrapsCount",
    (HackingMiniGame_Record_GetAllowedTrapsCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HackingMiniGame_Record_GetAllowedTrapsCount(
    game.data.HackingMiniGame_Record self
);

WeakHandle<game.data.Trap_Record> GetAllowedTrapsItem(int index) RTTI

game.data.Trap_Record? GetAllowedTrapsItemHandle(int index) RTTI

Generated hook

re.Hooks.Place(
    "gamedataHackingMiniGame_Record",
    "GetAllowedTrapsItemHandle",
    (HackingMiniGame_Record_GetAllowedTrapsItemHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.Trap_Record>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HackingMiniGame_Record_GetAllowedTrapsItemHandle(
    game.data.HackingMiniGame_Record self,
    int index
);

bool AllowedTrapsContains(WeakHandle<game.data.Trap_Record> item) RTTI

Generated hook

re.Hooks.Place(
    "gamedataHackingMiniGame_Record",
    "AllowedTrapsContains",
    (HackingMiniGame_Record_AllowedTrapsContains x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HackingMiniGame_Record_AllowedTrapsContains(
    game.data.HackingMiniGame_Record self,
    WeakHandle<game.data.Trap_Record> item
);

List PredefinedNetworkPrograms() RTTI

int GetPredefinedNetworkProgramsCount() RTTI

Generated hook

re.Hooks.Place(
    "gamedataHackingMiniGame_Record",
    "GetPredefinedNetworkProgramsCount",
    (HackingMiniGame_Record_GetPredefinedNetworkProgramsCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HackingMiniGame_Record_GetPredefinedNetworkProgramsCount(
    game.data.HackingMiniGame_Record self
);

string GetPredefinedNetworkProgramsItem(int index) RTTI

Generated hook

re.Hooks.Place(
    "gamedataHackingMiniGame_Record",
    "GetPredefinedNetworkProgramsItem",
    (HackingMiniGame_Record_GetPredefinedNetworkProgramsItem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Str>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HackingMiniGame_Record_GetPredefinedNetworkProgramsItem(
    game.data.HackingMiniGame_Record self,
    int index
);

bool PredefinedNetworkProgramsContains(string item) RTTI

Generated hook

re.Hooks.Place(
    "gamedataHackingMiniGame_Record",
    "PredefinedNetworkProgramsContains",
    (HackingMiniGame_Record_PredefinedNetworkProgramsContains x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HackingMiniGame_Record_PredefinedNetworkProgramsContains(
    game.data.HackingMiniGame_Record self,
    string item
);

List PredefinedBasicAccess() RTTI

int GetPredefinedBasicAccessCount() RTTI

Generated hook

re.Hooks.Place(
    "gamedataHackingMiniGame_Record",
    "GetPredefinedBasicAccessCount",
    (HackingMiniGame_Record_GetPredefinedBasicAccessCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HackingMiniGame_Record_GetPredefinedBasicAccessCount(
    game.data.HackingMiniGame_Record self
);

string GetPredefinedBasicAccessItem(int index) RTTI

Generated hook

re.Hooks.Place(
    "gamedataHackingMiniGame_Record",
    "GetPredefinedBasicAccessItem",
    (HackingMiniGame_Record_GetPredefinedBasicAccessItem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Str>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HackingMiniGame_Record_GetPredefinedBasicAccessItem(
    game.data.HackingMiniGame_Record self,
    int index
);

bool PredefinedBasicAccessContains(string item) RTTI

Generated hook

re.Hooks.Place(
    "gamedataHackingMiniGame_Record",
    "PredefinedBasicAccessContains",
    (HackingMiniGame_Record_PredefinedBasicAccessContains x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HackingMiniGame_Record_PredefinedBasicAccessContains(
    game.data.HackingMiniGame_Record self,
    string item
);

List PredefinedEnemyPrograms() RTTI

int GetPredefinedEnemyProgramsCount() RTTI

Generated hook

re.Hooks.Place(
    "gamedataHackingMiniGame_Record",
    "GetPredefinedEnemyProgramsCount",
    (HackingMiniGame_Record_GetPredefinedEnemyProgramsCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HackingMiniGame_Record_GetPredefinedEnemyProgramsCount(
    game.data.HackingMiniGame_Record self
);

string GetPredefinedEnemyProgramsItem(int index) RTTI

Generated hook

re.Hooks.Place(
    "gamedataHackingMiniGame_Record",
    "GetPredefinedEnemyProgramsItem",
    (HackingMiniGame_Record_GetPredefinedEnemyProgramsItem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Str>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HackingMiniGame_Record_GetPredefinedEnemyProgramsItem(
    game.data.HackingMiniGame_Record self,
    int index
);

bool PredefinedEnemyProgramsContains(string item) RTTI

Generated hook

re.Hooks.Place(
    "gamedataHackingMiniGame_Record",
    "PredefinedEnemyProgramsContains",
    (HackingMiniGame_Record_PredefinedEnemyProgramsContains x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HackingMiniGame_Record_PredefinedEnemyProgramsContains(
    game.data.HackingMiniGame_Record self,
    string item
);

List Symbols() RTTI

int GetSymbolsCount() RTTI

Generated hook

re.Hooks.Place(
    "gamedataHackingMiniGame_Record",
    "GetSymbolsCount",
    (HackingMiniGame_Record_GetSymbolsCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HackingMiniGame_Record_GetSymbolsCount(
    game.data.HackingMiniGame_Record self
);

string GetSymbolsItem(int index) RTTI

Generated hook

re.Hooks.Place(
    "gamedataHackingMiniGame_Record",
    "GetSymbolsItem",
    (HackingMiniGame_Record_GetSymbolsItem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Str>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HackingMiniGame_Record_GetSymbolsItem(
    game.data.HackingMiniGame_Record self,
    int index
);

bool SymbolsContains(string item) RTTI

Generated hook

re.Hooks.Place(
    "gamedataHackingMiniGame_Record",
    "SymbolsContains",
    (HackingMiniGame_Record_SymbolsContains x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HackingMiniGame_Record_SymbolsContains(
    game.data.HackingMiniGame_Record self,
    string item
);

List PredefinedGrid() RTTI

int GetPredefinedGridCount() RTTI

Generated hook

re.Hooks.Place(
    "gamedataHackingMiniGame_Record",
    "GetPredefinedGridCount",
    (HackingMiniGame_Record_GetPredefinedGridCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HackingMiniGame_Record_GetPredefinedGridCount(
    game.data.HackingMiniGame_Record self
);

string GetPredefinedGridItem(int index) RTTI

Generated hook

re.Hooks.Place(
    "gamedataHackingMiniGame_Record",
    "GetPredefinedGridItem",
    (HackingMiniGame_Record_GetPredefinedGridItem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Str>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HackingMiniGame_Record_GetPredefinedGridItem(
    game.data.HackingMiniGame_Record self,
    int index
);

bool PredefinedGridContains(string item) RTTI

Generated hook

re.Hooks.Place(
    "gamedataHackingMiniGame_Record",
    "PredefinedGridContains",
    (HackingMiniGame_Record_PredefinedGridContains x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HackingMiniGame_Record_PredefinedGridContains(
    game.data.HackingMiniGame_Record self,
    string item
);

List PredefinedCyberdeckPrograms() RTTI

int GetPredefinedCyberdeckProgramsCount() RTTI

Generated hook

re.Hooks.Place(
    "gamedataHackingMiniGame_Record",
    "GetPredefinedCyberdeckProgramsCount",
    (HackingMiniGame_Record_GetPredefinedCyberdeckProgramsCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HackingMiniGame_Record_GetPredefinedCyberdeckProgramsCount(
    game.data.HackingMiniGame_Record self
);

string GetPredefinedCyberdeckProgramsItem(int index) RTTI

Generated hook

re.Hooks.Place(
    "gamedataHackingMiniGame_Record",
    "GetPredefinedCyberdeckProgramsItem",
    (HackingMiniGame_Record_GetPredefinedCyberdeckProgramsItem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Str>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HackingMiniGame_Record_GetPredefinedCyberdeckProgramsItem(
    game.data.HackingMiniGame_Record self,
    int index
);

bool PredefinedCyberdeckProgramsContains(string item) RTTI

Generated hook

re.Hooks.Place(
    "gamedataHackingMiniGame_Record",
    "PredefinedCyberdeckProgramsContains",
    (HackingMiniGame_Record_PredefinedCyberdeckProgramsContains x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HackingMiniGame_Record_PredefinedCyberdeckProgramsContains(
    game.data.HackingMiniGame_Record self,
    string item
);

List SymbolProbabilities() RTTI

int GetSymbolProbabilitiesCount() RTTI

Generated hook

re.Hooks.Place(
    "gamedataHackingMiniGame_Record",
    "GetSymbolProbabilitiesCount",
    (HackingMiniGame_Record_GetSymbolProbabilitiesCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HackingMiniGame_Record_GetSymbolProbabilitiesCount(
    game.data.HackingMiniGame_Record self
);

string GetSymbolProbabilitiesItem(int index) RTTI

Generated hook

re.Hooks.Place(
    "gamedataHackingMiniGame_Record",
    "GetSymbolProbabilitiesItem",
    (HackingMiniGame_Record_GetSymbolProbabilitiesItem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Str>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HackingMiniGame_Record_GetSymbolProbabilitiesItem(
    game.data.HackingMiniGame_Record self,
    int index
);

bool SymbolProbabilitiesContains(string item) RTTI

Generated hook

re.Hooks.Place(
    "gamedataHackingMiniGame_Record",
    "SymbolProbabilitiesContains",
    (HackingMiniGame_Record_SymbolProbabilitiesContains x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HackingMiniGame_Record_SymbolProbabilitiesContains(
    game.data.HackingMiniGame_Record self,
    string item
);

List SymbolProbabilitiesAlternative() RTTI

int GetSymbolProbabilitiesAlternativeCount() RTTI

Generated hook

re.Hooks.Place(
    "gamedataHackingMiniGame_Record",
    "GetSymbolProbabilitiesAlternativeCount",
    (HackingMiniGame_Record_GetSymbolProbabilitiesAlternativeCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HackingMiniGame_Record_GetSymbolProbabilitiesAlternativeCount(
    game.data.HackingMiniGame_Record self
);

string GetSymbolProbabilitiesAlternativeItem(int index) RTTI

Generated hook

re.Hooks.Place(
    "gamedataHackingMiniGame_Record",
    "GetSymbolProbabilitiesAlternativeItem",
    (HackingMiniGame_Record_GetSymbolProbabilitiesAlternativeItem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Str>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HackingMiniGame_Record_GetSymbolProbabilitiesAlternativeItem(
    game.data.HackingMiniGame_Record self,
    int index
);

bool SymbolProbabilitiesAlternativeContains(string item) RTTI

Generated hook

re.Hooks.Place(
    "gamedataHackingMiniGame_Record",
    "SymbolProbabilitiesAlternativeContains",
    (HackingMiniGame_Record_SymbolProbabilitiesAlternativeContains x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HackingMiniGame_Record_SymbolProbabilitiesAlternativeContains(
    game.data.HackingMiniGame_Record self,
    string item
);

int NetworkLevel() RTTI

Generated hook

re.Hooks.Place(
    "gamedataHackingMiniGame_Record",
    "NetworkLevel",
    (HackingMiniGame_Record_NetworkLevel x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HackingMiniGame_Record_NetworkLevel(
    game.data.HackingMiniGame_Record self
);

int EnemyNetrunnerLevel() RTTI

Generated hook

re.Hooks.Place(
    "gamedataHackingMiniGame_Record",
    "EnemyNetrunnerLevel",
    (HackingMiniGame_Record_EnemyNetrunnerLevel x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HackingMiniGame_Record_EnemyNetrunnerLevel(
    game.data.HackingMiniGame_Record self
);

int Dimension() RTTI

Generated hook

re.Hooks.Place(
    "gamedataHackingMiniGame_Record",
    "Dimension",
    (HackingMiniGame_Record_Dimension x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HackingMiniGame_Record_Dimension(
    game.data.HackingMiniGame_Record self
);

int GameType() RTTI

Generated hook

re.Hooks.Place(
    "gamedataHackingMiniGame_Record",
    "GameType",
    (HackingMiniGame_Record_GameType x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HackingMiniGame_Record_GameType(
    game.data.HackingMiniGame_Record self
);

int InitialTimer() RTTI

Generated hook

re.Hooks.Place(
    "gamedataHackingMiniGame_Record",
    "InitialTimer",
    (HackingMiniGame_Record_InitialTimer x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HackingMiniGame_Record_InitialTimer(
    game.data.HackingMiniGame_Record self
);

int BufferModifier() RTTI

Generated hook

re.Hooks.Place(
    "gamedataHackingMiniGame_Record",
    "BufferModifier",
    (HackingMiniGame_Record_BufferModifier x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HackingMiniGame_Record_BufferModifier(
    game.data.HackingMiniGame_Record self
);

int HiddenCellsProbability() RTTI

Generated hook

re.Hooks.Place(
    "gamedataHackingMiniGame_Record",
    "HiddenCellsProbability",
    (HackingMiniGame_Record_HiddenCellsProbability x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HackingMiniGame_Record_HiddenCellsProbability(
    game.data.HackingMiniGame_Record self
);

bool HasEnemyNetrunner() RTTI

Generated hook

re.Hooks.Place(
    "gamedataHackingMiniGame_Record",
    "HasEnemyNetrunner",
    (HackingMiniGame_Record_HasEnemyNetrunner x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HackingMiniGame_Record_HasEnemyNetrunner(
    game.data.HackingMiniGame_Record self
);

bool HasHiddenCells() RTTI

Generated hook

re.Hooks.Place(
    "gamedataHackingMiniGame_Record",
    "HasHiddenCells",
    (HackingMiniGame_Record_HasHiddenCells x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HackingMiniGame_Record_HasHiddenCells(
    game.data.HackingMiniGame_Record self
);

bool HasInitialTimer() RTTI

Generated hook

re.Hooks.Place(
    "gamedataHackingMiniGame_Record",
    "HasInitialTimer",
    (HackingMiniGame_Record_HasInitialTimer x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HackingMiniGame_Record_HasInitialTimer(
    game.data.HackingMiniGame_Record self
);

bool Officer() RTTI

Generated hook

re.Hooks.Place(
    "gamedataHackingMiniGame_Record",
    "Officer",
    (HackingMiniGame_Record_Officer x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct HackingMiniGame_Record_Officer(
    game.data.HackingMiniGame_Record self
);