class game.data

Minigame_Def_Record

game.data.Minigame_Def_Record

0 properties
43 functions

Extends game.data.TweakDBRecord IScriptable ISerializable

Properties

None.

Functions

WeakHandle<game.data.MiniGame_Trap_Record> DefaultTrap() RTTI

game.data.MiniGame_Trap_Record? DefaultTrapHandle() RTTI

Generated hook

re.Hooks.Place(
    "gamedataMinigame_Def_Record",
    "DefaultTrapHandle",
    (Minigame_Def_Record_DefaultTrapHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.MiniGame_Trap_Record>();
    }
);

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

void OverrideProgramsList(out WeakHandle<game.data.Program_Record>[] outList) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamedataMinigame_Def_Record",
    "OverrideProgramsList",
    (Minigame_Def_Record_OverrideProgramsList x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Minigame_Def_Record_OverrideProgramsList(
    game.data.Minigame_Def_Record self,
    WeakHandle<game.data.Program_Record>[] outList
);

int GetOverrideProgramsListCount() RTTI

Generated hook

re.Hooks.Place(
    "gamedataMinigame_Def_Record",
    "GetOverrideProgramsListCount",
    (Minigame_Def_Record_GetOverrideProgramsListCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

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

WeakHandle<game.data.Program_Record> GetOverrideProgramsListItem(int index) RTTI

game.data.Program_Record? GetOverrideProgramsListItemHandle(int index) RTTI

Generated hook

re.Hooks.Place(
    "gamedataMinigame_Def_Record",
    "GetOverrideProgramsListItemHandle",
    (Minigame_Def_Record_GetOverrideProgramsListItemHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.Program_Record>();
    }
);

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

bool OverrideProgramsListContains(WeakHandle<game.data.Program_Record> item) RTTI

Generated hook

re.Hooks.Place(
    "gamedataMinigame_Def_Record",
    "OverrideProgramsListContains",
    (Minigame_Def_Record_OverrideProgramsListContains x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Minigame_Def_Record_OverrideProgramsListContains(
    game.data.Minigame_Def_Record self,
    WeakHandle<game.data.Program_Record> item
);

void AdditionalProgramsList(out WeakHandle<game.data.Program_Record>[] outList) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamedataMinigame_Def_Record",
    "AdditionalProgramsList",
    (Minigame_Def_Record_AdditionalProgramsList x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Minigame_Def_Record_AdditionalProgramsList(
    game.data.Minigame_Def_Record self,
    WeakHandle<game.data.Program_Record>[] outList
);

int GetAdditionalProgramsListCount() RTTI

Generated hook

re.Hooks.Place(
    "gamedataMinigame_Def_Record",
    "GetAdditionalProgramsListCount",
    (Minigame_Def_Record_GetAdditionalProgramsListCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

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

WeakHandle<game.data.Program_Record> GetAdditionalProgramsListItem(int index) RTTI

game.data.Program_Record? GetAdditionalProgramsListItemHandle(int index) RTTI

Generated hook

re.Hooks.Place(
    "gamedataMinigame_Def_Record",
    "GetAdditionalProgramsListItemHandle",
    (Minigame_Def_Record_GetAdditionalProgramsListItemHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.Program_Record>();
    }
);

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

bool AdditionalProgramsListContains(WeakHandle<game.data.Program_Record> item) RTTI

Generated hook

re.Hooks.Place(
    "gamedataMinigame_Def_Record",
    "AdditionalProgramsListContains",
    (Minigame_Def_Record_AdditionalProgramsListContains x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Minigame_Def_Record_AdditionalProgramsListContains(
    game.data.Minigame_Def_Record self,
    WeakHandle<game.data.Program_Record> item
);

void ForbiddenProgramsList(out WeakHandle<game.data.Program_Record>[] outList) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamedataMinigame_Def_Record",
    "ForbiddenProgramsList",
    (Minigame_Def_Record_ForbiddenProgramsList x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Minigame_Def_Record_ForbiddenProgramsList(
    game.data.Minigame_Def_Record self,
    WeakHandle<game.data.Program_Record>[] outList
);

int GetForbiddenProgramsListCount() RTTI

Generated hook

re.Hooks.Place(
    "gamedataMinigame_Def_Record",
    "GetForbiddenProgramsListCount",
    (Minigame_Def_Record_GetForbiddenProgramsListCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

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

WeakHandle<game.data.Program_Record> GetForbiddenProgramsListItem(int index) RTTI

game.data.Program_Record? GetForbiddenProgramsListItemHandle(int index) RTTI

Generated hook

re.Hooks.Place(
    "gamedataMinigame_Def_Record",
    "GetForbiddenProgramsListItemHandle",
    (Minigame_Def_Record_GetForbiddenProgramsListItemHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.Program_Record>();
    }
);

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

bool ForbiddenProgramsListContains(WeakHandle<game.data.Program_Record> item) RTTI

Generated hook

re.Hooks.Place(
    "gamedataMinigame_Def_Record",
    "ForbiddenProgramsListContains",
    (Minigame_Def_Record_ForbiddenProgramsListContains x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Minigame_Def_Record_ForbiddenProgramsListContains(
    game.data.Minigame_Def_Record self,
    WeakHandle<game.data.Program_Record> item
);

void GridTraps(out WeakHandle<game.data.RowTraps_Record>[] outList) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamedataMinigame_Def_Record",
    "GridTraps",
    (Minigame_Def_Record_GridTraps x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Minigame_Def_Record_GridTraps(
    game.data.Minigame_Def_Record self,
    WeakHandle<game.data.RowTraps_Record>[] outList
);

int GetGridTrapsCount() RTTI

Generated hook

re.Hooks.Place(
    "gamedataMinigame_Def_Record",
    "GetGridTrapsCount",
    (Minigame_Def_Record_GetGridTrapsCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

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

WeakHandle<game.data.RowTraps_Record> GetGridTrapsItem(int index) RTTI

game.data.RowTraps_Record? GetGridTrapsItemHandle(int index) RTTI

Generated hook

re.Hooks.Place(
    "gamedataMinigame_Def_Record",
    "GetGridTrapsItemHandle",
    (Minigame_Def_Record_GetGridTrapsItemHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.RowTraps_Record>();
    }
);

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

bool GridTrapsContains(WeakHandle<game.data.RowTraps_Record> item) RTTI

Generated hook

re.Hooks.Place(
    "gamedataMinigame_Def_Record",
    "GridTrapsContains",
    (Minigame_Def_Record_GridTrapsContains x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Minigame_Def_Record_GridTrapsContains(
    game.data.Minigame_Def_Record self,
    WeakHandle<game.data.RowTraps_Record> item
);

void GridSymbols(out WeakHandle<game.data.RowSymbols_Record>[] outList) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamedataMinigame_Def_Record",
    "GridSymbols",
    (Minigame_Def_Record_GridSymbols x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Minigame_Def_Record_GridSymbols(
    game.data.Minigame_Def_Record self,
    WeakHandle<game.data.RowSymbols_Record>[] outList
);

int GetGridSymbolsCount() RTTI

Generated hook

re.Hooks.Place(
    "gamedataMinigame_Def_Record",
    "GetGridSymbolsCount",
    (Minigame_Def_Record_GetGridSymbolsCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

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

WeakHandle<game.data.RowSymbols_Record> GetGridSymbolsItem(int index) RTTI

game.data.RowSymbols_Record? GetGridSymbolsItemHandle(int index) RTTI

Generated hook

re.Hooks.Place(
    "gamedataMinigame_Def_Record",
    "GetGridSymbolsItemHandle",
    (Minigame_Def_Record_GetGridSymbolsItemHandle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.RowSymbols_Record>();
    }
);

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

bool GridSymbolsContains(WeakHandle<game.data.RowSymbols_Record> item) RTTI

Generated hook

re.Hooks.Place(
    "gamedataMinigame_Def_Record",
    "GridSymbolsContains",
    (Minigame_Def_Record_GridSymbolsContains x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Minigame_Def_Record_GridSymbolsContains(
    game.data.Minigame_Def_Record self,
    WeakHandle<game.data.RowSymbols_Record> item
);

CName BufferFullExitText() RTTI

Generated hook

re.Hooks.Place(
    "gamedataMinigame_Def_Record",
    "BufferFullExitText",
    (Minigame_Def_Record_BufferFullExitText x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.CName>();
    }
);

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

CName TimeOutExitText() RTTI

Generated hook

re.Hooks.Place(
    "gamedataMinigame_Def_Record",
    "TimeOutExitText",
    (Minigame_Def_Record_TimeOutExitText x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.CName>();
    }
);

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

CName GenericExitText() RTTI

Generated hook

re.Hooks.Place(
    "gamedataMinigame_Def_Record",
    "GenericExitText",
    (Minigame_Def_Record_GenericExitText x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.CName>();
    }
);

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

CName SuccessExitText() RTTI

Generated hook

re.Hooks.Place(
    "gamedataMinigame_Def_Record",
    "SuccessExitText",
    (Minigame_Def_Record_SuccessExitText x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.CName>();
    }
);

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

CName GreatSuccessExitText() RTTI

Generated hook

re.Hooks.Place(
    "gamedataMinigame_Def_Record",
    "GreatSuccessExitText",
    (Minigame_Def_Record_GreatSuccessExitText x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.CName>();
    }
);

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

CName FailExitText() RTTI

Generated hook

re.Hooks.Place(
    "gamedataMinigame_Def_Record",
    "FailExitText",
    (Minigame_Def_Record_FailExitText x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.CName>();
    }
);

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

CName CanceledExitText() RTTI

Generated hook

re.Hooks.Place(
    "gamedataMinigame_Def_Record",
    "CanceledExitText",
    (Minigame_Def_Record_CanceledExitText x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.CName>();
    }
);

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

float ExtraDifficulty() RTTI

Generated hook

re.Hooks.Place(
    "gamedataMinigame_Def_Record",
    "ExtraDifficulty",
    (Minigame_Def_Record_ExtraDifficulty x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

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

int GridSize() RTTI

Generated hook

re.Hooks.Place(
    "gamedataMinigame_Def_Record",
    "GridSize",
    (Minigame_Def_Record_GridSize x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

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

float OverlapProbability() RTTI

Generated hook

re.Hooks.Place(
    "gamedataMinigame_Def_Record",
    "OverlapProbability",
    (Minigame_Def_Record_OverlapProbability x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

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

float TrapsProbability() RTTI

Generated hook

re.Hooks.Place(
    "gamedataMinigame_Def_Record",
    "TrapsProbability",
    (Minigame_Def_Record_TrapsProbability x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

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

float TimeLimit() RTTI

Generated hook

re.Hooks.Place(
    "gamedataMinigame_Def_Record",
    "TimeLimit",
    (Minigame_Def_Record_TimeLimit x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

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

int BufferSize() RTTI

Generated hook

re.Hooks.Place(
    "gamedataMinigame_Def_Record",
    "BufferSize",
    (Minigame_Def_Record_BufferSize x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

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

bool UseProgression() RTTI

Generated hook

re.Hooks.Place(
    "gamedataMinigame_Def_Record",
    "UseProgression",
    (Minigame_Def_Record_UseProgression x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

bool SaveSeed() RTTI

Generated hook

re.Hooks.Place(
    "gamedataMinigame_Def_Record",
    "SaveSeed",
    (Minigame_Def_Record_SaveSeed x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

bool NoTraps() RTTI

Generated hook

re.Hooks.Place(
    "gamedataMinigame_Def_Record",
    "NoTraps",
    (Minigame_Def_Record_NoTraps x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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