class game

RPGManager

game.RPGManager

0 properties
220 functions

Extends IScriptable ISerializable

Properties

None.

Functions

static WeakHandle<game.ItemData> GetItemData(ScriptGameInstance gi, game.Object owner, game.ItemID itemID) staticRTTI

static game.data.Quality GetInnerItemDataQuality(game.InnerItemData itemData) staticRTTI

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "GetInnerItemDataQuality",
    (RPGManager_GetInnerItemDataQuality x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.Quality>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_GetInnerItemDataQuality(
    game.InnerItemData itemData
);

static game.data.Quality GetItemDataQuality(WeakHandle<game.ItemData> itemData) staticRTTI

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "GetItemDataQuality",
    (RPGManager_GetItemDataQuality x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.Quality>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_GetItemDataQuality(
    WeakHandle<game.ItemData> itemData
);

static game.data.Quality GetFloatItemQuality(float qualityStat) staticRTTI

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "GetFloatItemQuality",
    (RPGManager_GetFloatItemQuality x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.Quality>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_GetFloatItemQuality(
    float qualityStat
);

static bool IsInnerItemDataIconic(game.InnerItemData itemData) staticRTTI

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "IsInnerItemDataIconic",
    (RPGManager_IsInnerItemDataIconic x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_IsInnerItemDataIconic(
    game.InnerItemData itemData
);

static bool IsItemDataIconic(WeakHandle<game.ItemData> itemData) staticRTTI

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "IsItemDataIconic",
    (RPGManager_IsItemDataIconic x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_IsItemDataIconic(
    WeakHandle<game.ItemData> itemData
);

static bool IsItemBroken(game.ItemData itemData) staticRTTI

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "IsItemBroken",
    (RPGManager_IsItemBroken x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_IsItemBroken(
    game.ItemData? itemData
);

static bool ShouldFlipNegativeValue(WeakHandle<game.data.Stat_Record> record) staticRTTI

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "ShouldFlipNegativeValue",
    (RPGManager_ShouldFlipNegativeValue x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_ShouldFlipNegativeValue(
    WeakHandle<game.data.Stat_Record> record
);

static bool ShouldSlotBeAvailable(WeakHandle<game.Object> owner, game.ItemID item, WeakHandle<game.data.AttachmentSlot_Record> attachmentSlotRecord)

staticRTTI

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "ShouldSlotBeAvailable",
    (RPGManager_ShouldSlotBeAvailable x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_ShouldSlotBeAvailable(
    WeakHandle<game.Object> owner,
    game.ItemID item,
    WeakHandle<game.data.AttachmentSlot_Record> attachmentSlotRecord
);

static bool IsSlotAvailable(WeakHandle<game.ItemData> itemData, WeakHandle<game.data.AttachmentSlot_Record> attachmentSlotRecord)

staticRTTI

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "IsSlotAvailable",
    (RPGManager_IsSlotAvailable x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_IsSlotAvailable(
    WeakHandle<game.ItemData> itemData,
    WeakHandle<game.data.AttachmentSlot_Record> attachmentSlotRecord
);

static float CalculateStatModifiers(WeakHandle<game.data.StatModifier_Record>[] modifiers, ScriptGameInstance context, WeakHandle<game.Object> root, game.StatsObjectID targetID, game.StatsObjectID? instigator, game.StatsObjectID? itemStatsID)

staticRTTI

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "CalculateStatModifiers",
    (RPGManager_CalculateStatModifiers x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_CalculateStatModifiers(
    WeakHandle<game.data.StatModifier_Record>[] modifiers,
    ScriptGameInstance context,
    WeakHandle<game.Object> root,
    game.StatsObjectID targetID,
    game.StatsObjectID? instigator,
    game.StatsObjectID? itemStatsID
);

static float CalculateAdditiveModifiers(WeakHandle<game.data.StatModifier_Record>[] modifiers, ScriptGameInstance context, WeakHandle<game.Object> root, game.StatsObjectID targetID, game.StatsObjectID? instigator, game.StatsObjectID? itemStatsID)

staticRTTI

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "CalculateAdditiveModifiers",
    (RPGManager_CalculateAdditiveModifiers x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_CalculateAdditiveModifiers(
    WeakHandle<game.data.StatModifier_Record>[] modifiers,
    ScriptGameInstance context,
    WeakHandle<game.Object> root,
    game.StatsObjectID targetID,
    game.StatsObjectID? instigator,
    game.StatsObjectID? itemStatsID
);

static float CalculateMultiplierModifiers(WeakHandle<game.data.StatModifier_Record>[] modifiers, ScriptGameInstance context, WeakHandle<game.Object> root, game.StatsObjectID targetID, game.StatsObjectID? instigator, game.StatsObjectID? itemStatsID)

staticRTTI

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "CalculateMultiplierModifiers",
    (RPGManager_CalculateMultiplierModifiers x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_CalculateMultiplierModifiers(
    WeakHandle<game.data.StatModifier_Record>[] modifiers,
    ScriptGameInstance context,
    WeakHandle<game.Object> root,
    game.StatsObjectID targetID,
    game.StatsObjectID? instigator,
    game.StatsObjectID? itemStatsID
);

static float CalculateAdditiveMultiplierModifiers(WeakHandle<game.data.StatModifier_Record>[] modifiers, ScriptGameInstance context, WeakHandle<game.Object> root, game.StatsObjectID targetID, game.StatsObjectID? instigator, game.StatsObjectID? itemStatsID)

staticRTTI

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "CalculateAdditiveMultiplierModifiers",
    (RPGManager_CalculateAdditiveMultiplierModifiers x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_CalculateAdditiveMultiplierModifiers(
    WeakHandle<game.data.StatModifier_Record>[] modifiers,
    ScriptGameInstance context,
    WeakHandle<game.Object> root,
    game.StatsObjectID targetID,
    game.StatsObjectID? instigator,
    game.StatsObjectID? itemStatsID
);

static float CalculateStatModifier(WeakHandle<game.data.StatModifier_Record> modifier, ScriptGameInstance context, WeakHandle<game.Object> root, game.StatsObjectID targetID, game.StatsObjectID? instigator, game.StatsObjectID? itemStatsID)

staticRTTI

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "CalculateStatModifier",
    (RPGManager_CalculateStatModifier x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_CalculateStatModifier(
    WeakHandle<game.data.StatModifier_Record> modifier,
    ScriptGameInstance context,
    WeakHandle<game.Object> root,
    game.StatsObjectID targetID,
    game.StatsObjectID? instigator,
    game.StatsObjectID? itemStatsID
);

static float CalculateConstantModifier(WeakHandle<game.data.ConstantStatModifier_Record> modifier) staticRTTI

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "CalculateConstantModifier",
    (RPGManager_CalculateConstantModifier x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_CalculateConstantModifier(
    WeakHandle<game.data.ConstantStatModifier_Record> modifier
);

static float CalculateRandomModifier(WeakHandle<game.data.RandomStatModifier_Record> modifier) staticRTTI

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "CalculateRandomModifier",
    (RPGManager_CalculateRandomModifier x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_CalculateRandomModifier(
    WeakHandle<game.data.RandomStatModifier_Record> modifier
);

static float CalculateCurveModifier(WeakHandle<game.data.CurveStatModifier_Record> modifier, ScriptGameInstance context, WeakHandle<game.Object> root, game.StatsObjectID targetID, game.StatsObjectID? instigator, game.StatsObjectID? itemStatsID)

staticRTTI

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "CalculateCurveModifier",
    (RPGManager_CalculateCurveModifier x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_CalculateCurveModifier(
    WeakHandle<game.data.CurveStatModifier_Record> modifier,
    ScriptGameInstance context,
    WeakHandle<game.Object> root,
    game.StatsObjectID targetID,
    game.StatsObjectID? instigator,
    game.StatsObjectID? itemStatsID
);

static float CalculateCombinedModifier(WeakHandle<game.data.CombinedStatModifier_Record> modifier, ScriptGameInstance context, WeakHandle<game.Object> root, game.StatsObjectID targetID, game.StatsObjectID? instigator, game.StatsObjectID? itemStatsID)

staticRTTI

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "CalculateCombinedModifier",
    (RPGManager_CalculateCombinedModifier x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_CalculateCombinedModifier(
    WeakHandle<game.data.CombinedStatModifier_Record> modifier,
    ScriptGameInstance context,
    WeakHandle<game.Object> root,
    game.StatsObjectID targetID,
    game.StatsObjectID? instigator,
    game.StatsObjectID? itemStatsID
);

static game.StatsObjectID GetRefObjectID(CName refObjectName, ScriptGameInstance context, WeakHandle<game.Object> root, game.StatsObjectID targetID, game.StatsObjectID? instigator, game.StatsObjectID? itemStatsID)

staticRTTI

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "GetRefObjectID",
    (RPGManager_GetRefObjectID x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.StatsObjectID>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_GetRefObjectID(
    CName refObjectName,
    ScriptGameInstance context,
    WeakHandle<game.Object> root,
    game.StatsObjectID targetID,
    game.StatsObjectID? instigator,
    game.StatsObjectID? itemStatsID
);

static void ApplyAbilityArray(WeakHandle<game.Object> owner, WeakHandle<game.data.GameplayAbility_Record>[] abilities) staticRTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameRPGManager",
    "ApplyAbilityArray",
    (RPGManager_ApplyAbilityArray x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_ApplyAbilityArray(
    WeakHandle<game.Object> owner,
    WeakHandle<game.data.GameplayAbility_Record>[] abilities
);

static int CalculateBuyPrice(ScriptGameInstance context, WeakHandle<game.Object> vendor, game.ItemID itemID, float multiplier)

staticRTTI

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "CalculateBuyPrice",
    (RPGManager_CalculateBuyPrice x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_CalculateBuyPrice(
    ScriptGameInstance context,
    WeakHandle<game.Object> vendor,
    game.ItemID itemID,
    float multiplier
);

static int CalculateSellPrice(ScriptGameInstance context, WeakHandle<game.Object> vendor, game.ItemID itemID) staticRTTI

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "CalculateSellPrice",
    (RPGManager_CalculateSellPrice x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_CalculateSellPrice(
    ScriptGameInstance context,
    WeakHandle<game.Object> vendor,
    game.ItemID itemID
);

static int CalculateSellPriceItemData(ScriptGameInstance context, WeakHandle<game.Object> vendor, game.ItemData itemData)

staticRTTI

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "CalculateSellPriceItemData",
    (RPGManager_CalculateSellPriceItemData x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_CalculateSellPriceItemData(
    ScriptGameInstance context,
    WeakHandle<game.Object> vendor,
    game.ItemData? itemData
);

static void GetQualityBasedOnPowerLevel() staticRTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameRPGManager",
    "GetQualityBasedOnPowerLevel",
    (RPGManager_GetQualityBasedOnPowerLevel x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

static game.EPowerDifferential CalculatePowerDifferential(WeakHandle<game.Object> target) staticRTTI

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "CalculatePowerDifferential",
    (RPGManager_CalculatePowerDifferential x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.EPowerDifferential>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_CalculatePowerDifferential(
    WeakHandle<game.Object> target
);

static game.ItemID GetItemFromInventory(game.Object objectt, TDBID item) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::GetItemFromInventory;GameObjectTweakDBID",
    (RPGManager_GetItemFromInventory x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.ItemID>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_GetItemFromInventory(
    game.Object? objectt,
    TDBID item
);

static bool IsRicochetChanceEnabled(ScriptGameInstance gi, game.Object owner, game.ItemID itemID) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::IsRicochetChanceEnabled;GameInstanceGameObjectItemID",
    (RPGManager_IsRicochetChanceEnabled x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_IsRicochetChanceEnabled(
    ScriptGameInstance gi,
    game.Object? owner,
    game.ItemID itemID
);

static void AwardExperienceFromDeflect(game.events.HitEvent hitEvent) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "gameRPGManager",
    "gameRPGManager::AwardExperienceFromDeflect;gameHitEvent",
    (RPGManager_AwardExperienceFromDeflect x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_AwardExperienceFromDeflect(
    game.events.HitEvent? hitEvent
);

static bool IsClothingMod(game.ItemID itemID) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::IsClothingMod;ItemID",
    (RPGManager_IsClothingMod x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_IsClothingMod(
    game.ItemID itemID
);

static void AwardXP(ScriptGameInstance gi, float amount, game.data.ProficiencyType type) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "gameRPGManager",
    "gameRPGManager::AwardXP;GameInstanceFloatgamedataProficiencyType",
    (RPGManager_AwardXP x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_AwardXP(
    ScriptGameInstance gi,
    float amount,
    game.data.ProficiencyType type
);

static bool CheckPrereq(WeakHandle<game.data.IPrereq_Record> prereqRecord, WeakHandle<game.Object> target, game.StatsObjectID referenceStatsID)

staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::CheckPrereq;IPrereq_RecordGameObjectStatsObjectID",
    (RPGManager_CheckPrereq x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_CheckPrereq(
    WeakHandle<game.data.IPrereq_Record> prereqRecord,
    WeakHandle<game.Object> target,
    game.StatsObjectID referenceStatsID
);

static bool ForceEquipStrongArms(PlayerPuppet player, bool instantStatChange) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::ForceEquipStrongArms;PlayerPuppetBool",
    (RPGManager_ForceEquipStrongArms x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_ForceEquipStrongArms(
    PlayerPuppet? player,
    bool instantStatChange
);

static bool ForceUnequipStrongArms(PlayerPuppet player) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::ForceUnequipStrongArms;PlayerPuppet",
    (RPGManager_ForceUnequipStrongArms x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_ForceUnequipStrongArms(
    PlayerPuppet? player
);

static bool IsItemCyberware(game.ItemID itemID) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::IsItemCyberware;ItemID",
    (RPGManager_IsItemCyberware x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_IsItemCyberware(
    game.ItemID itemID
);

static bool HasStatFlag(WeakHandle<game.Object> owner, game.data.StatType flag) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::HasStatFlag;GameObjectgamedataStatType",
    (RPGManager_HasStatFlag x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_HasStatFlag(
    WeakHandle<game.Object> owner,
    game.data.StatType flag
);

static int CheckDifficultyToPerkLevel(game.data.PerkType perk, EGameplayChallengeLevel difficulty, ent.EntityID id) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::CheckDifficultyToPerkLevel;gamedataPerkTypeEGameplayChallengeLevelEntityID",
    (RPGManager_CheckDifficultyToPerkLevel x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_CheckDifficultyToPerkLevel(
    game.data.PerkType perk,
    EGameplayChallengeLevel difficulty,
    ent.EntityID id
);

static bool IsItemGadget(game.ItemID itemID) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::IsItemGadget;ItemID",
    (RPGManager_IsItemGadget x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_IsItemGadget(
    game.ItemID itemID
);

static void ForceEquipItemOnPlayer(game.Object puppet, TDBID itemTDBID, bool addToInv) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "gameRPGManager",
    "gameRPGManager::ForceEquipItemOnPlayer;GameObjectTweakDBIDBool",
    (RPGManager_ForceEquipItemOnPlayer x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_ForceEquipItemOnPlayer(
    game.Object? puppet,
    TDBID itemTDBID,
    bool addToInv
);

static bool IsDamageStat(game.data.StatType stat) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::IsDamageStat;gamedataStatType",
    (RPGManager_IsDamageStat x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_IsDamageStat(
    game.data.StatType stat
);

static float CalculateStatModifiers(float addValue, float multValue, float addMultValue, WeakHandle<game.data.StatModifier_Record>[] modifiers, ScriptGameInstance context, WeakHandle<game.Object> root, game.StatsObjectID targetID, game.StatsObjectID instigator, game.StatsObjectID itemStatsID)

staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::CalculateStatModifiers;FloatFloatFloatscript_ref<array<StatModifier_Record>>GameInstanceGameObjectStatsObjectIDStatsObjectIDStatsObjectID",
    (RPGManager_CalculateStatModifiers2 x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_CalculateStatModifiers2(
    float addValue,
    float multValue,
    float addMultValue,
    WeakHandle<game.data.StatModifier_Record>[] modifiers,
    ScriptGameInstance context,
    WeakHandle<game.Object> root,
    game.StatsObjectID targetID,
    game.StatsObjectID instigator,
    game.StatsObjectID itemStatsID
);

static void RemoveGLP(WeakHandle<game.Object> owner, WeakHandle<game.data.GameplayLogicPackage_Record> package) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "gameRPGManager",
    "gameRPGManager::RemoveGLP;GameObjectGameplayLogicPackage_Record",
    (RPGManager_RemoveGLP x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_RemoveGLP(
    WeakHandle<game.Object> owner,
    WeakHandle<game.data.GameplayLogicPackage_Record> package
);

static bool IsScopeAttachment(game.ItemID itemID) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::IsScopeAttachment;ItemID",
    (RPGManager_IsScopeAttachment x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_IsScopeAttachment(
    game.ItemID itemID
);

static TDBID GetCyberwareUpgradeShardID(game.data.Quality quality) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::GetCyberwareUpgradeShardID;gamedataQuality",
    (RPGManager_GetCyberwareUpgradeShardID x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.TDBID>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_GetCyberwareUpgradeShardID(
    game.data.Quality quality
);

static bool CanPlayerCraftFromInventory(WeakHandle<game.Object> obj) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::CanPlayerCraftFromInventory;GameObject",
    (RPGManager_CanPlayerCraftFromInventory x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_CanPlayerCraftFromInventory(
    WeakHandle<game.Object> obj
);

static void InjectStatModifierToItem(ScriptGameInstance gi, game.ItemData itemData, game.StatModifierData_Deprecated modifier)

staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "gameRPGManager",
    "gameRPGManager::InjectStatModifierToItem;GameInstancegameItemDatagameStatModifierData",
    (RPGManager_InjectStatModifierToItem x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_InjectStatModifierToItem(
    ScriptGameInstance gi,
    game.ItemData? itemData,
    game.StatModifierData_Deprecated? modifier
);

static game.StatTotalValue[] GetHighestResistances(game.Object obj) staticRTTI global

static game.data.Quality ConvertPlayerLevelToCyberwareQuality(float playerLevel, bool includeAboveLegendary) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::ConvertPlayerLevelToCyberwareQuality;FloatBool",
    (RPGManager_ConvertPlayerLevelToCyberwareQuality x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.Quality>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_ConvertPlayerLevelToCyberwareQuality(
    float playerLevel,
    bool includeAboveLegendary
);

static bool IsItemClothing(game.ItemID itemID) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::IsItemClothing;ItemID",
    (RPGManager_IsItemClothing x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_IsItemClothing(
    game.ItemID itemID
);

static void CreateReplaceEquipmentRequest(game.Object owner, game.ItemID equippedItemID, game.ItemID upgradeItemID, game.ItemID partItemID)

staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "gameRPGManager",
    "gameRPGManager::CreateReplaceEquipmentRequest;GameObjectItemIDItemIDItemID",
    (RPGManager_CreateReplaceEquipmentRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_CreateReplaceEquipmentRequest(
    game.Object? owner,
    game.ItemID equippedItemID,
    game.ItemID upgradeItemID,
    game.ItemID partItemID
);

static bool IsItemCrafted(ScriptGameInstance gi, game.ItemID itemId) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::IsItemCrafted;GameInstanceItemID",
    (RPGManager_IsItemCrafted x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_IsItemCrafted(
    ScriptGameInstance gi,
    game.ItemID itemId
);

static void GiveReward(ScriptGameInstance gi, TDBID rewardID, game.StatsObjectID target, float moneyMultiplier) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "gameRPGManager",
    "gameRPGManager::GiveReward;GameInstanceTweakDBIDStatsObjectIDFloat",
    (RPGManager_GiveReward x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_GiveReward(
    ScriptGameInstance gi,
    TDBID rewardID,
    game.StatsObjectID target,
    float moneyMultiplier
);

static int GetBluelineBuildCheckValue(game.Object player, game.data.ContentAssignment_Record contentAssignment, EGameplayChallengeLevel difficulty)

staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::GetBluelineBuildCheckValue;GameObjectContentAssignment_RecordEGameplayChallengeLevel",
    (RPGManager_GetBluelineBuildCheckValue x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_GetBluelineBuildCheckValue(
    game.Object? player,
    game.data.ContentAssignment_Record? contentAssignment,
    EGameplayChallengeLevel difficulty
);

static int GetCheckValue(ScriptGameInstance gi, float powerLevel, EGameplayChallengeLevel difficulty) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::GetCheckValue;GameInstanceFloatEGameplayChallengeLevel",
    (RPGManager_GetCheckValue x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_GetCheckValue(
    ScriptGameInstance gi,
    float powerLevel,
    EGameplayChallengeLevel difficulty
);

static TDBID GetWeaponAmmoTDBID(game.ItemID weaponID) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::GetWeaponAmmoTDBID;ItemID",
    (RPGManager_GetWeaponAmmoTDBID x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.TDBID>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_GetWeaponAmmoTDBID(
    game.ItemID weaponID
);

static game.data.DamageType GetDominatingDamageType(ScriptGameInstance gi, WeakHandle<game.ItemData> itemData) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::GetDominatingDamageType;GameInstancegameItemData",
    (RPGManager_GetDominatingDamageType x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.DamageType>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_GetDominatingDamageType(
    ScriptGameInstance gi,
    WeakHandle<game.ItemData> itemData
);

static bool IsItemProgram(game.ItemID itemID) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::IsItemProgram;ItemID",
    (RPGManager_IsItemProgram x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_IsItemProgram(
    game.ItemID itemID
);

static float CalculateMinorActivityReward(ScriptGameInstance gi, float experienceValue) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::CalculateMinorActivityReward;GameInstanceFloat",
    (RPGManager_CalculateMinorActivityReward x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_CalculateMinorActivityReward(
    ScriptGameInstance gi,
    float experienceValue
);

static bool CyberwareHasUpgrade(ScriptGameInstance game, game.ItemID itemID, game.data.Quality currentQuality, game.data.Quality desiredQuality, out game.data.Item_Record upgradeItemRecord)

staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::CyberwareHasUpgrade;GameInstanceItemIDgamedataQualitygamedataQualityItem_Record",
    (RPGManager_CyberwareHasUpgrade x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_CyberwareHasUpgrade(
    ScriptGameInstance game,
    game.ItemID itemID,
    game.data.Quality currentQuality,
    game.data.Quality desiredQuality,
    game.data.Item_Record? upgradeItemRecord
);

static void ForceItemTier(WeakHandle<game.Object> obj, WeakHandle<game.ItemData> itemData, CName forcedQuality) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "gameRPGManager",
    "gameRPGManager::ForceItemTier;GameObjectgameItemDataCName",
    (RPGManager_ForceItemTier x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_ForceItemTier(
    WeakHandle<game.Object> obj,
    WeakHandle<game.ItemData> itemData,
    CName forcedQuality
);

static void RemoveAbilityGroup(WeakHandle<game.Object> owner, WeakHandle<game.data.GameplayAbilityGroup_Record> group) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "gameRPGManager",
    "gameRPGManager::RemoveAbilityGroup;GameObjectGameplayAbilityGroup_Record",
    (RPGManager_RemoveAbilityGroup x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_RemoveAbilityGroup(
    WeakHandle<game.Object> owner,
    WeakHandle<game.data.GameplayAbilityGroup_Record> group
);

static bool IsClothingMod(game.data.ItemType type) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::IsClothingMod;gamedataItemType",
    (RPGManager_IsClothingMod2 x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_IsClothingMod2(
    game.data.ItemType type
);

static bool CanPartBeUnequipped(game.InventoryItemData data, TDBID slotId) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::CanPartBeUnequipped;InventoryItemDataTweakDBID",
    (RPGManager_CanPartBeUnequipped x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_CanPartBeUnequipped(
    game.InventoryItemData data,
    TDBID slotId
);

static game.data.NewPerk_Record? GetNewPerkRecord(game.data.NewPerkType type) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::GetNewPerkRecord;gamedataNewPerkType",
    (RPGManager_GetNewPerkRecord x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.NewPerk_Record>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_GetNewPerkRecord(
    game.data.NewPerkType type
);

static void ApplyAbilityGroup(WeakHandle<game.Object> owner, WeakHandle<game.data.GameplayAbilityGroup_Record> group) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "gameRPGManager",
    "gameRPGManager::ApplyAbilityGroup;GameObjectGameplayAbilityGroup_Record",
    (RPGManager_ApplyAbilityGroup x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_ApplyAbilityGroup(
    WeakHandle<game.Object> owner,
    WeakHandle<game.data.GameplayAbilityGroup_Record> group
);

static int GetBuildScore(game.Object player, game.data.PlayerBuild_Record buildToCheck) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::GetBuildScore;GameObjectPlayerBuild_Record",
    (RPGManager_GetBuildScore x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_GetBuildScore(
    game.Object? player,
    game.data.PlayerBuild_Record? buildToCheck
);

static game.StatModifierData_Deprecated? CreateCurveModifier(game.data.CurveStatModifier_Record statRecord) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::CreateCurveModifier;CurveStatModifier_Record",
    (RPGManager_CreateCurveModifier x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.StatModifierData_Deprecated>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_CreateCurveModifier(
    game.data.CurveStatModifier_Record? statRecord
);

static bool IsWeaponMod(game.ItemID itemID) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::IsWeaponMod;ItemID",
    (RPGManager_IsWeaponMod x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_IsWeaponMod(
    game.ItemID itemID
);

static bool IsWeaponMelee(game.data.ItemType type) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::IsWeaponMelee;gamedataItemType",
    (RPGManager_IsWeaponMelee x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_IsWeaponMelee(
    game.data.ItemType type
);

static game.StatTotalValue[] GetLowestResistances(game.Object obj) staticRTTI global

static bool IsItemSingleInstance(WeakHandle<game.ItemData> itemData) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::IsItemSingleInstance;gameItemData",
    (RPGManager_IsItemSingleInstance x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_IsItemSingleInstance(
    WeakHandle<game.ItemData> itemData
);

static bool IsItemIconic(WeakHandle<game.ItemData> itemData) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::IsItemIconic;gameItemData",
    (RPGManager_IsItemIconic x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_IsItemIconic(
    WeakHandle<game.ItemData> itemData
);

static bool IsInventoryEmpty(WeakHandle<game.Object> objectt) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::IsInventoryEmpty;GameObject",
    (RPGManager_IsInventoryEmpty x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_IsInventoryEmpty(
    WeakHandle<game.Object> objectt
);

static void SendPhotoModeItemUnlockRequest(ScriptGameInstance gi, WeakHandle<game.data.PhotoModeItem_Record> photoModeItm)

staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "gameRPGManager",
    "gameRPGManager::SendPhotoModeItemUnlockRequest;GameInstancePhotoModeItem_Record",
    (RPGManager_SendPhotoModeItemUnlockRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_SendPhotoModeItemUnlockRequest(
    ScriptGameInstance gi,
    WeakHandle<game.data.PhotoModeItem_Record> photoModeItm
);

static bool IsItemIconic(game.InnerItemData itemData) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::IsItemIconic;InnerItemData",
    (RPGManager_IsItemIconic2 x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_IsItemIconic2(
    game.InnerItemData itemData
);

static game.Attack_GameEffect? PrepareGameEffectAttack(ScriptGameInstance gi, game.Object instigator, game.Object source, TDBID attackName, Vector4 position, SHitFlag[] hitFlags, game.Object target, float tickRateOverride)

staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::PrepareGameEffectAttack;GameInstanceGameObjectGameObjectTweakDBIDVector4array<SHitFlag>GameObjectFloat",
    (RPGManager_PrepareGameEffectAttack x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.Attack_GameEffect>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_PrepareGameEffectAttack(
    ScriptGameInstance gi,
    game.Object? instigator,
    game.Object? source,
    TDBID attackName,
    Vector4 position,
    SHitFlag[] hitFlags,
    game.Object? target,
    float tickRateOverride
);

static bool ShouldShowCWChoice(game.Object owner, WeakHandle<UIInventoryItem> itemData) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::ShouldShowCWChoice;GameObjectUIInventoryItem",
    (RPGManager_ShouldShowCWChoice x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_ShouldShowCWChoice(
    game.Object? owner,
    WeakHandle<UIInventoryItem> itemData
);

static game.StatTotalValue[] GetMinStats(game.Object obj, game.data.StatType[] stats) staticRTTI global

static RipperdocTokenPopupData? GetCyberwareUpgradeData(game.Object owner, WeakHandle<UIInventoryItem> itemData, game.data.Item_Record upgradeItemRecord, CyberwareUpgradeCostData costData, uint seed, WeakHandle<UIInventoryScriptableSystem> inventorySystem, bool useMultichoice)

staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::GetCyberwareUpgradeData;GameObjectUIInventoryItemItem_RecordCyberwareUpgradeCostDataUint32UIInventoryScriptableSystemBool",
    (RPGManager_GetCyberwareUpgradeData x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.RipperdocTokenPopupData>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_GetCyberwareUpgradeData(
    game.Object? owner,
    WeakHandle<UIInventoryItem> itemData,
    game.data.Item_Record? upgradeItemRecord,
    CyberwareUpgradeCostData costData,
    uint seed,
    WeakHandle<UIInventoryScriptableSystem> inventorySystem,
    bool useMultichoice
);

static game.data.Quality GetItemQuality(float qualityStat) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::GetItemQuality;Float",
    (RPGManager_GetItemQuality x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.Quality>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_GetItemQuality(
    float qualityStat
);

static game.data.StatType GetResistanceTypeFromDamageType(game.data.DamageType damageType) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::GetResistanceTypeFromDamageType;gamedataDamageType",
    (RPGManager_GetResistanceTypeFromDamageType x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.StatType>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_GetResistanceTypeFromDamageType(
    game.data.DamageType damageType
);

static game.data.WeaponEvolution GetWeaponEvolution(game.ItemID itemID) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::GetWeaponEvolution;ItemID",
    (RPGManager_GetWeaponEvolution x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.WeaponEvolution>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_GetWeaponEvolution(
    game.ItemID itemID
);

static int CheckDifficultyToStatValue(ScriptGameInstance gi, game.data.StatType skill, EGameplayChallengeLevel difficulty, ent.EntityID id)

staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::CheckDifficultyToStatValue;GameInstancegamedataStatTypeEGameplayChallengeLevelEntityID",
    (RPGManager_CheckDifficultyToStatValue x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_CheckDifficultyToStatValue(
    ScriptGameInstance gi,
    game.data.StatType skill,
    EGameplayChallengeLevel difficulty,
    ent.EntityID id
);

static int GetLevelPercentage(game.Object objectt) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::GetLevelPercentage;GameObject",
    (RPGManager_GetLevelPercentage x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

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

static game.data.Quality ConvertQualityToNonPlusQuality(game.data.Quality quality) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::ConvertQualityToNonPlusQuality;gamedataQuality",
    (RPGManager_ConvertQualityToNonPlusQuality x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.Quality>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_ConvertQualityToNonPlusQuality(
    game.data.Quality quality
);

static game.EPowerDifferential CalculatePowerDifferential(int level) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::CalculatePowerDifferential;Int32",
    (RPGManager_CalculatePowerDifferential2 x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.EPowerDifferential>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_CalculatePowerDifferential2(
    int level
);

static void ToggleLootHighlight(WeakHandle<game.Object> obj, bool enable) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "gameRPGManager",
    "gameRPGManager::ToggleLootHighlight;GameObjectBool",
    (RPGManager_ToggleLootHighlight x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_ToggleLootHighlight(
    WeakHandle<game.Object> obj,
    bool enable
);

static bool IsNonModifableSlot(TDBID slot) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::IsNonModifableSlot;TweakDBID",
    (RPGManager_IsNonModifableSlot x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_IsNonModifableSlot(
    TDBID slot
);

static void ApplyGLP(WeakHandle<game.Object> owner, WeakHandle<game.data.GameplayLogicPackage_Record> package) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "gameRPGManager",
    "gameRPGManager::ApplyGLP;GameObjectGameplayLogicPackage_Record",
    (RPGManager_ApplyGLP x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_ApplyGLP(
    WeakHandle<game.Object> owner,
    WeakHandle<game.data.GameplayLogicPackage_Record> package
);

static void HealPuppetAfterQuickhack(ScriptGameInstance gi, game.Object executor) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "gameRPGManager",
    "gameRPGManager::HealPuppetAfterQuickhack;GameInstanceGameObject",
    (RPGManager_HealPuppetAfterQuickhack x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_HealPuppetAfterQuickhack(
    ScriptGameInstance gi,
    game.Object? executor
);

static bool ConsumeItem(WeakHandle<game.Object> obj, game.interactions.ChoiceEvent evt) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::ConsumeItem;GameObjectInteractionChoiceEvent",
    (RPGManager_ConsumeItem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_ConsumeItem(
    WeakHandle<game.Object> obj,
    game.interactions.ChoiceEvent? evt
);

static TDBID[] GetModsSlotIDs(game.data.ItemType type) staticRTTI global
static WeakHandle<game.data.ObjectAction_Record>[] GetItemActions(game.ItemID itemID) staticRTTI global
static TDBID[] GetPlayerQuickHackList(WeakHandle<PlayerPuppet> player) staticRTTI global

static game.data.Quality GetItemQuality(WeakHandle<game.ItemData> itemData) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::GetItemQuality;gameItemData",
    (RPGManager_GetItemQuality2 x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.Quality>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_GetItemQuality2(
    WeakHandle<game.ItemData> itemData
);

static game.data.StatPrereq_Record?[] GetNestedPrereqs(WeakHandle<game.data.IPrereq_Record>[] prereqs) staticRTTI global

static bool IsItemWeapon(game.ItemID itemID) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::IsItemWeapon;ItemID",
    (RPGManager_IsItemWeapon x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_IsItemWeapon(
    game.ItemID itemID
);

static game.data.Quality GetItemTierForUpgrades(WeakHandle<game.ItemData> itemData) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::GetItemTierForUpgrades;gameItemData",
    (RPGManager_GetItemTierForUpgrades x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.Quality>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_GetItemTierForUpgrades(
    WeakHandle<game.ItemData> itemData
);

static void RemoveEffectorsArray(WeakHandle<game.Object> owner, WeakHandle<game.data.Effector_Record>[] arr) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "gameRPGManager",
    "gameRPGManager::RemoveEffectorsArray;GameObjectscript_ref<array<Effector_Record>>",
    (RPGManager_RemoveEffectorsArray x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_RemoveEffectorsArray(
    WeakHandle<game.Object> owner,
    WeakHandle<game.data.Effector_Record>[] arr
);

static bool HasItem(WeakHandle<game.Object> obj, TDBID id) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::HasItem;GameObjectTweakDBID",
    (RPGManager_HasItem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_HasItem(
    WeakHandle<game.Object> obj,
    TDBID id
);

static void ToggleHolsteredArmAppearance(game.Object puppet, bool setHoleInArm) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "gameRPGManager",
    "gameRPGManager::ToggleHolsteredArmAppearance;GameObjectBool",
    (RPGManager_ToggleHolsteredArmAppearance x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_ToggleHolsteredArmAppearance(
    game.Object? puppet,
    bool setHoleInArm
);

static bool IsItemMisc(game.ItemID itemID) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::IsItemMisc;ItemID",
    (RPGManager_IsItemMisc x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_IsItemMisc(
    game.ItemID itemID
);

static game.data.Quality GetItemQuality(game.InnerItemData itemData) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::GetItemQuality;InnerItemData",
    (RPGManager_GetItemQuality3 x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.Quality>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_GetItemQuality3(
    game.InnerItemData itemData
);

static TDBID GetAttachmentSlotID(string slot) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::GetAttachmentSlotID;script_ref<String>",
    (RPGManager_GetAttachmentSlotID x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.TDBID>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_GetAttachmentSlotID(
    string slot
);

static bool ForceUnequipPersonalLink(PlayerPuppet player) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::ForceUnequipPersonalLink;PlayerPuppet",
    (RPGManager_ForceUnequipPersonalLink x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_ForceUnequipPersonalLink(
    PlayerPuppet? player
);

static int GetCyberwareUpgradeShardCount(game.Object owner, game.data.Quality quality) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::GetCyberwareUpgradeShardCount;GameObjectgamedataQuality",
    (RPGManager_GetCyberwareUpgradeShardCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_GetCyberwareUpgradeShardCount(
    game.Object? owner,
    game.data.Quality quality
);

static int GetCyberwareUpgradeCost(game.data.Item_Record itemRecord) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::GetCyberwareUpgradeCost;Item_Record",
    (RPGManager_GetCyberwareUpgradeCost x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_GetCyberwareUpgradeCost(
    game.data.Item_Record? itemRecord
);

static ScannerStatDetails GetScannerResistanceDetails(game.Object obj, game.data.StatType statType, game.Object player) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::GetScannerResistanceDetails;GameObjectgamedataStatTypeGameObject",
    (RPGManager_GetScannerResistanceDetails x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.ScannerStatDetails>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_GetScannerResistanceDetails(
    game.Object? obj,
    game.data.StatType statType,
    game.Object? player
);

static game.data.Trait_Record? GetTraitRecord(game.data.TraitType type) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::GetTraitRecord;gamedataTraitType",
    (RPGManager_GetTraitRecord x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.Trait_Record>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_GetTraitRecord(
    game.data.TraitType type
);

static void ReturnRetrievableWeaponMods(WeakHandle<game.ItemData> itemData, WeakHandle<game.Object> owner) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "gameRPGManager",
    "gameRPGManager::ReturnRetrievableWeaponMods;gameItemDataGameObject",
    (RPGManager_ReturnRetrievableWeaponMods x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_ReturnRetrievableWeaponMods(
    WeakHandle<game.ItemData> itemData,
    WeakHandle<game.Object> owner
);

static string GetAmmoCount(game.Object owner, game.ItemID itemID) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::GetAmmoCount;GameObjectItemID",
    (RPGManager_GetAmmoCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Str>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_GetAmmoCount(
    game.Object? owner,
    game.ItemID itemID
);

static int GetAmmoCountValue(game.Object owner, game.ItemID itemID) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::GetAmmoCountValue;GameObjectItemID",
    (RPGManager_GetAmmoCountValue x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_GetAmmoCountValue(
    game.Object? owner,
    game.ItemID itemID
);

static TDBID GetRandomizedHealingConsumable(WeakHandle<ScriptedPuppet> puppet) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::GetRandomizedHealingConsumable;ScriptedPuppet",
    (RPGManager_GetRandomizedHealingConsumable x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.TDBID>();
    }
);

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

static bool IsItemEffectivelyIdentical(game.ItemID itemID1, game.ItemID itemID2) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::IsItemEffectivelyIdentical;ItemIDItemID",
    (RPGManager_IsItemEffectivelyIdentical x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_IsItemEffectivelyIdentical(
    game.ItemID itemID1,
    game.ItemID itemID2
);

static void AwardExperienceFromDamage(game.events.HitEvent hitEvent, float damagePercentage) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "gameRPGManager",
    "gameRPGManager::AwardExperienceFromDamage;gameHitEventFloat",
    (RPGManager_AwardExperienceFromDamage x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_AwardExperienceFromDamage(
    game.events.HitEvent? hitEvent,
    float damagePercentage
);

static bool DoesPlayerHaveQuickHack(WeakHandle<PlayerPuppet> player, TDBID quickHackTweak) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::DoesPlayerHaveQuickHack;PlayerPuppetTweakDBID",
    (RPGManager_DoesPlayerHaveQuickHack x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_DoesPlayerHaveQuickHack(
    WeakHandle<PlayerPuppet> player,
    TDBID quickHackTweak
);

static bool ForceEquipPersonalLink(PlayerPuppet player) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::ForceEquipPersonalLink;PlayerPuppet",
    (RPGManager_ForceEquipPersonalLink x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_ForceEquipPersonalLink(
    PlayerPuppet? player
);

static game.StatModifierData_Deprecated? CreateStatModifierUsingCurve(game.data.StatType statType, game.StatModifierType modType, game.data.StatType refStat, CName curveName, CName columnName)

staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::CreateStatModifierUsingCurve;gamedataStatTypegameStatModifierTypegamedataStatTypeCNameCName",
    (RPGManager_CreateStatModifierUsingCurve x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.StatModifierData_Deprecated>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_CreateStatModifierUsingCurve(
    game.data.StatType statType,
    game.StatModifierType modType,
    game.data.StatType refStat,
    CName curveName,
    CName columnName
);

static void SetDroppedWeaponQuality(WeakHandle<ScriptedPuppet> npc, WeakHandle<game.ItemData> itemData) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "gameRPGManager",
    "gameRPGManager::SetDroppedWeaponQuality;ScriptedPuppetgameItemData",
    (RPGManager_SetDroppedWeaponQuality x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_SetDroppedWeaponQuality(
    WeakHandle<ScriptedPuppet> npc,
    WeakHandle<game.ItemData> itemData
);

static bool CanItemBeDisassembled(ScriptGameInstance gameInstance, game.ItemID itemID) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::CanItemBeDisassembled;GameInstanceItemID",
    (RPGManager_CanItemBeDisassembled x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_CanItemBeDisassembled(
    ScriptGameInstance gameInstance,
    game.ItemID itemID
);

static game.StatTotalValue[] GetMaxStats(game.Object obj, game.data.StatType[] stats) staticRTTI global

static float GetItemWeight(game.ItemData itemData) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::GetItemWeight;gameItemData",
    (RPGManager_GetItemWeight x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_GetItemWeight(
    game.ItemData? itemData
);

static float GetAvailableSlotsForQuality(WeakHandle<game.ItemData> itemData, game.data.Quality quality) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::GetAvailableSlotsForQuality;gameItemDatagamedataQuality",
    (RPGManager_GetAvailableSlotsForQuality x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_GetAvailableSlotsForQuality(
    WeakHandle<game.ItemData> itemData,
    game.data.Quality quality
);

static game.data.ItemCategory GetItemCategory(game.ItemID itemID) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::GetItemCategory;ItemID",
    (RPGManager_GetItemCategory x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.ItemCategory>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_GetItemCategory(
    game.ItemID itemID
);

static int GetCombinedItemQualityValue(ScriptGameInstance game, game.ItemID itemID) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::GetCombinedItemQualityValue;GameInstanceItemID",
    (RPGManager_GetCombinedItemQualityValue x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_GetCombinedItemQualityValue(
    ScriptGameInstance game,
    game.ItemID itemID
);

static void ProcessOnLootedPackages(WeakHandle<game.Object> owner, game.ItemID itemID) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "gameRPGManager",
    "gameRPGManager::ProcessOnLootedPackages;GameObjectItemID",
    (RPGManager_ProcessOnLootedPackages x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_ProcessOnLootedPackages(
    WeakHandle<game.Object> owner,
    game.ItemID itemID
);

static float GetItemPlus(game.ItemData itemData) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::GetItemPlus;gameItemData",
    (RPGManager_GetItemPlus x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_GetItemPlus(
    game.ItemData? itemData
);

static void ApplyGLPArray(WeakHandle<game.Object> owner, WeakHandle<game.data.GameplayLogicPackage_Record>[] arr, bool ignoreAppliedPackages, int withAnimationWrapperOverrides)

staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "gameRPGManager",
    "gameRPGManager::ApplyGLPArray;GameObjectscript_ref<array<GameplayLogicPackage_Record>>BoolInt32",
    (RPGManager_ApplyGLPArray x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_ApplyGLPArray(
    WeakHandle<game.Object> owner,
    WeakHandle<game.data.GameplayLogicPackage_Record>[] arr,
    bool ignoreAppliedPackages,
    int withAnimationWrapperOverrides
);

static void GiveScavengeReward(ScriptGameInstance gi, TDBID rewardID, ent.EntityID scavengeTargetEntityID) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "gameRPGManager",
    "gameRPGManager::GiveScavengeReward;GameInstanceTweakDBIDEntityID",
    (RPGManager_GiveScavengeReward x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_GiveScavengeReward(
    ScriptGameInstance gi,
    TDBID rewardID,
    ent.EntityID scavengeTargetEntityID
);

static bool CheckPerkPrereqs(game.ItemData itemData, game.Object owner, string perkRequiredName) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::CheckPerkPrereqs;gameItemDataGameObjectscript_ref<String>",
    (RPGManager_CheckPerkPrereqs x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_CheckPerkPrereqs(
    game.ItemData? itemData,
    game.Object? owner,
    string perkRequiredName
);

static void ProcessReadAction(game.interactions.ChoiceEvent choice) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "gameRPGManager",
    "gameRPGManager::ProcessReadAction;InteractionChoiceEvent",
    (RPGManager_ProcessReadAction x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_ProcessReadAction(
    game.interactions.ChoiceEvent? choice
);

static void TogglePersonalLinkAppearance(game.Object puppet) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "gameRPGManager",
    "gameRPGManager::TogglePersonalLinkAppearance;GameObject",
    (RPGManager_TogglePersonalLinkAppearance x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

static void RemoveDuplicatedHacks(WeakHandle<game.data.ObjectAction_Record>[] deck, WeakHandle<game.data.ObjectAction_Record>[] splinter)

staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "gameRPGManager",
    "gameRPGManager::RemoveDuplicatedHacks;script_ref<array<ObjectAction_Record>>script_ref<array<ObjectAction_Record>>",
    (RPGManager_RemoveDuplicatedHacks x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_RemoveDuplicatedHacks(
    WeakHandle<game.data.ObjectAction_Record>[] deck,
    WeakHandle<game.data.ObjectAction_Record>[] splinter
);

static void RemoveAbility(WeakHandle<game.Object> owner, WeakHandle<game.data.GameplayAbility_Record> ability) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "gameRPGManager",
    "gameRPGManager::RemoveAbility;GameObjectGameplayAbility_Record",
    (RPGManager_RemoveAbility x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_RemoveAbility(
    WeakHandle<game.Object> owner,
    WeakHandle<game.data.GameplayAbility_Record> ability
);

static bool IsMuzzleAttachment(game.data.ItemType type) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::IsMuzzleAttachment;gamedataItemType",
    (RPGManager_IsMuzzleAttachment x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_IsMuzzleAttachment(
    game.data.ItemType type
);

static TDBID GetRandomizedGadget(WeakHandle<ScriptedPuppet> puppet) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::GetRandomizedGadget;ScriptedPuppet",
    (RPGManager_GetRandomizedGadget x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.TDBID>();
    }
);

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

static game.StatModifierData_Deprecated? CreateCombinedStatModifier(game.data.StatType statType, game.StatModifierType modType, game.data.StatType refStat, game.CombinedStatOperation opSymbol, float value, game.StatObjectsRelation refObject)

staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::CreateCombinedStatModifier;gamedataStatTypegameStatModifierTypegamedataStatTypegameCombinedStatOperationFloatgameStatObjectsRelation",
    (RPGManager_CreateCombinedStatModifier x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.StatModifierData_Deprecated>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_CreateCombinedStatModifier(
    game.data.StatType statType,
    game.StatModifierType modType,
    game.data.StatType refStat,
    game.CombinedStatOperation opSymbol,
    float value,
    game.StatObjectsRelation refObject
);

static void AwardExperienceFromQuickhack(WeakHandle<PlayerPuppet> player, float cost, ent.EntityID target, game.data.HackCategory category)

staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "gameRPGManager",
    "gameRPGManager::AwardExperienceFromQuickhack;PlayerPuppetFloatEntityIDgamedataHackCategory",
    (RPGManager_AwardExperienceFromQuickhack x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_AwardExperienceFromQuickhack(
    WeakHandle<PlayerPuppet> player,
    float cost,
    ent.EntityID target,
    game.data.HackCategory category
);

static game.StatModifierData_Deprecated? CreateStatModifier(game.data.StatType statType, game.StatModifierType modType, float value)

staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::CreateStatModifier;gamedataStatTypegameStatModifierTypeFloat",
    (RPGManager_CreateStatModifier x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.StatModifierData_Deprecated>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_CreateStatModifier(
    game.data.StatType statType,
    game.StatModifierType modType,
    float value
);

static bool CanDownloadFunds(ScriptGameInstance gi, game.ItemID itemID) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::CanDownloadFunds;GameInstanceItemID",
    (RPGManager_CanDownloadFunds x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_CanDownloadFunds(
    ScriptGameInstance gi,
    game.ItemID itemID
);

static void DropManyItems(ScriptGameInstance gameInstance, WeakHandle<game.Object> obj, game.ItemModParams[] items) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "gameRPGManager",
    "gameRPGManager::DropManyItems;GameInstanceGameObjectscript_ref<array<ItemModParams>>",
    (RPGManager_DropManyItems x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_DropManyItems(
    ScriptGameInstance gameInstance,
    WeakHandle<game.Object> obj,
    game.ItemModParams[] items
);

static game.data.AttributeData_Record? GetAttributeDataRecord(game.data.AttributeDataType type) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::GetAttributeDataRecord;gamedataAttributeDataType",
    (RPGManager_GetAttributeDataRecord x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.AttributeData_Record>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_GetAttributeDataRecord(
    game.data.AttributeDataType type
);

static void ApplyAbility(WeakHandle<game.Object> owner, WeakHandle<game.data.GameplayAbility_Record> ability) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "gameRPGManager",
    "gameRPGManager::ApplyAbility;GameObjectGameplayAbility_Record",
    (RPGManager_ApplyAbility x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_ApplyAbility(
    WeakHandle<game.Object> owner,
    WeakHandle<game.data.GameplayAbility_Record> ability
);

static float ItemQualityNameToValue(CName q) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::ItemQualityNameToValue;CName",
    (RPGManager_ItemQualityNameToValue x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_ItemQualityNameToValue(
    CName q
);

static bool IsWeaponMod(game.data.ItemType type) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::IsWeaponMod;gamedataItemType",
    (RPGManager_IsWeaponMod2 x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_IsWeaponMod2(
    game.data.ItemType type
);

static game.data.Quality GetItemQualityFromRecord(game.data.Item_Record itemRecord) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::GetItemQualityFromRecord;Item_Record",
    (RPGManager_GetItemQualityFromRecord x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.Quality>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_GetItemQualityFromRecord(
    game.data.Item_Record? itemRecord
);

static game.data.Quality GetBumpedQuality(game.data.Quality quality) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::GetBumpedQuality;gamedataQuality",
    (RPGManager_GetBumpedQuality x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.Quality>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_GetBumpedQuality(
    game.data.Quality quality
);

static game.data.Quality GetItemTierForUpgrades(float tierStat) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::GetItemTierForUpgrades;Float",
    (RPGManager_GetItemTierForUpgrades2 x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.Quality>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_GetItemTierForUpgrades2(
    float tierStat
);

static game.SItemStackRequirementData GetFirstUnmetEquipRequirement(game.Object owner, game.SItemStackRequirementData[] equipRequirements)

staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::GetFirstUnmetEquipRequirement;GameObjectscript_ref<array<SItemStackRequirementData>>",
    (RPGManager_GetFirstUnmetEquipRequirement x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.SItemStackRequirementData>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_GetFirstUnmetEquipRequirement(
    game.Object? owner,
    game.SItemStackRequirementData[] equipRequirements
);

static bool IsItemMaxTier(WeakHandle<game.ItemData> itemData) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::IsItemMaxTier;gameItemData",
    (RPGManager_IsItemMaxTier x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_IsItemMaxTier(
    WeakHandle<game.ItemData> itemData
);

static bool ExtractItemsOfEquipArea(game.data.EquipmentArea type, WeakHandle<game.ItemData>[] input, WeakHandle<game.ItemData>[] output)

staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::ExtractItemsOfEquipArea;gamedataEquipmentAreascript_ref<array<gameItemData>>script_ref<array<gameItemData>>",
    (RPGManager_ExtractItemsOfEquipArea x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_ExtractItemsOfEquipArea(
    game.data.EquipmentArea type,
    WeakHandle<game.ItemData>[] input,
    WeakHandle<game.ItemData>[] output
);

static float GetItemStackWeight(WeakHandle<game.Object> owner, WeakHandle<game.ItemData> itemData) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::GetItemStackWeight;GameObjectgameItemData",
    (RPGManager_GetItemStackWeight x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_GetItemStackWeight(
    WeakHandle<game.Object> owner,
    WeakHandle<game.ItemData> itemData
);

static bool HasSmartLinkRequirement(game.ItemData itemData) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::HasSmartLinkRequirement;gameItemData",
    (RPGManager_HasSmartLinkRequirement x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_HasSmartLinkRequirement(
    game.ItemData? itemData
);

static bool CanItemBeDropped(game.Object puppet, game.ItemData itemData) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::CanItemBeDropped;GameObjectgameItemData",
    (RPGManager_CanItemBeDropped x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_CanItemBeDropped(
    game.Object? puppet,
    game.ItemData? itemData
);

static void AwardExperienceInstantly(WeakHandle<PlayerPuppet> player, int amount, game.data.ProficiencyType type) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "gameRPGManager",
    "gameRPGManager::AwardExperienceInstantly;PlayerPuppetInt32gamedataProficiencyType",
    (RPGManager_AwardExperienceInstantly x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_AwardExperienceInstantly(
    WeakHandle<PlayerPuppet> player,
    int amount,
    game.data.ProficiencyType type
);

static void RemoveStatModifierGroups(WeakHandle<game.Object> owner, WeakHandle<game.data.StatModifierGroup_Record>[] arr)

staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "gameRPGManager",
    "gameRPGManager::RemoveStatModifierGroups;GameObjectscript_ref<array<StatModifierGroup_Record>>",
    (RPGManager_RemoveStatModifierGroups x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_RemoveStatModifierGroups(
    WeakHandle<game.Object> owner,
    WeakHandle<game.data.StatModifierGroup_Record>[] arr
);

static game.StatTotalValue[] GetStatValues(game.Object obj, game.data.StatType[] stats) staticRTTI global
static WeakHandle<game.ItemData> GetCyberwareUpgradeShardItemData(game.Object owner, game.data.Quality quality) staticRTTI global
static PlayerQuickhackData[] GetPlayerQuickHackListWithQuality(WeakHandle<PlayerPuppet> player) staticRTTI global

static void GiveReward(ScriptGameInstance gi, TDBID rewardID, int amount, game.StatsObjectID target, float moneyMultiplier)

staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "gameRPGManager",
    "gameRPGManager::GiveReward;GameInstanceTweakDBIDInt32StatsObjectIDFloat",
    (RPGManager_GiveReward2 x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_GiveReward2(
    ScriptGameInstance gi,
    TDBID rewardID,
    int amount,
    game.StatsObjectID target,
    float moneyMultiplier
);

static game.data.StatType[] ResistancesList() staticRTTI global

static bool IsTechPierceEnabled(ScriptGameInstance gi, game.Object owner, game.ItemID itemID) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::IsTechPierceEnabled;GameInstanceGameObjectItemID",
    (RPGManager_IsTechPierceEnabled x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_IsTechPierceEnabled(
    ScriptGameInstance gi,
    game.Object? owner,
    game.ItemID itemID
);

static game.data.Proficiency_Record? GetProficiencyRecord(game.data.ProficiencyType type) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::GetProficiencyRecord;gamedataProficiencyType",
    (RPGManager_GetProficiencyRecord x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.Proficiency_Record>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_GetProficiencyRecord(
    game.data.ProficiencyType type
);

static game.data.Quality GetNextItemQuality(WeakHandle<game.ItemData> itemData) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::GetNextItemQuality;gameItemData",
    (RPGManager_GetNextItemQuality x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.Quality>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_GetNextItemQuality(
    WeakHandle<game.ItemData> itemData
);

static bool CanUpgradeCyberware(game.Object owner, game.ItemID itemID, bool isEquipped, game.data.Quality selectedQuality, out game.data.Quality upgradeItemQuality, out game.data.Item_Record upgradeItemRecord, out CyberwareUpgradeCostData costData, bool updateOutputOnFailure)

staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::CanUpgradeCyberware;GameObjectItemIDBoolgamedataQualitygamedataQualityItem_RecordCyberwareUpgradeCostDataBool",
    (RPGManager_CanUpgradeCyberware x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_CanUpgradeCyberware(
    game.Object? owner,
    game.ItemID itemID,
    bool isEquipped,
    game.data.Quality selectedQuality,
    game.data.Quality upgradeItemQuality,
    game.data.Item_Record? upgradeItemRecord,
    CyberwareUpgradeCostData costData,
    bool updateOutputOnFailure
);

static bool IsItemEquipped(WeakHandle<game.Object> owner, game.ItemID itemID) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::IsItemEquipped;GameObjectItemID",
    (RPGManager_IsItemEquipped x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_IsItemEquipped(
    WeakHandle<game.Object> owner,
    game.ItemID itemID
);

static void ForceUnequipItemFromPlayer(game.Object puppet, TDBID slotTDBID, bool removeItem) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "gameRPGManager",
    "gameRPGManager::ForceUnequipItemFromPlayer;GameObjectTweakDBIDBool",
    (RPGManager_ForceUnequipItemFromPlayer x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_ForceUnequipItemFromPlayer(
    game.Object? puppet,
    TDBID slotTDBID,
    bool removeItem
);

static float CalculateStreetStoryReward(ScriptGameInstance gi, float experienceValue) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::CalculateStreetStoryReward;GameInstanceFloat",
    (RPGManager_CalculateStreetStoryReward x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_CalculateStreetStoryReward(
    ScriptGameInstance gi,
    float experienceValue
);

static game.SItemStackRequirementData[] GetEquipRequirements(game.Object owner, game.ItemData itemData) staticRTTI global

static float GetPowerLevelFromContentAssignment(ScriptGameInstance gi, TDBID contentAssignmentID) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::GetPowerLevelFromContentAssignment;GameInstanceTweakDBID",
    (RPGManager_GetPowerLevelFromContentAssignment x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_GetPowerLevelFromContentAssignment(
    ScriptGameInstance gi,
    TDBID contentAssignmentID
);

static game.data.Item_Record? GetCraftingMaterialRecord(game.data.Quality quality, bool isQuickhack) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::GetCraftingMaterialRecord;gamedataQualityBool",
    (RPGManager_GetCraftingMaterialRecord x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.Item_Record>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_GetCraftingMaterialRecord(
    game.data.Quality quality,
    bool isQuickhack
);

static int ConvertQualityToCombinedValue(game.data.Quality quality) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::ConvertQualityToCombinedValue;gamedataQuality",
    (RPGManager_ConvertQualityToCombinedValue x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_ConvertQualityToCombinedValue(
    game.data.Quality quality
);

static void DecrementQuickHackBlackboard(ScriptGameInstance gameInstance, TDBID actionID) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "gameRPGManager",
    "gameRPGManager::DecrementQuickHackBlackboard;GameInstanceTweakDBID",
    (RPGManager_DecrementQuickHackBlackboard x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_DecrementQuickHackBlackboard(
    ScriptGameInstance gameInstance,
    TDBID actionID
);

static game.SItemStackRequirementData GetVendorWareRequirement(ScriptGameInstance game, WeakHandle<game.data.VendorWare_Record> record, game.StatsObjectID itemStatsID)

staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::GetVendorWareRequirement;GameInstanceVendorWare_RecordStatsObjectID",
    (RPGManager_GetVendorWareRequirement x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.SItemStackRequirementData>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_GetVendorWareRequirement(
    ScriptGameInstance game,
    WeakHandle<game.data.VendorWare_Record> record,
    game.StatsObjectID itemStatsID
);

static float ItemQualityEnumToValue(game.data.Quality q) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::ItemQualityEnumToValue;gamedataQuality",
    (RPGManager_ItemQualityEnumToValue x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_ItemQualityEnumToValue(
    game.data.Quality q
);

static game.data.Item_Record? GetMonoWireQuickhackRecord(game.weapon.Object weaponObject) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::GetMonoWireQuickhackRecord;WeaponObject",
    (RPGManager_GetMonoWireQuickhackRecord x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.Item_Record>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_GetMonoWireQuickhackRecord(
    game.weapon.Object? weaponObject
);

static TDBID[] GetAttachmentSlotIDs() staticRTTI global
static ItemAttachments[] GetRetrievableAttachments(WeakHandle<game.ItemData> itemData) staticRTTI global

static void ApplyEffectorsArray(WeakHandle<game.Object> owner, WeakHandle<game.data.Effector_Record>[] arr) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "gameRPGManager",
    "gameRPGManager::ApplyEffectorsArray;GameObjectscript_ref<array<Effector_Record>>",
    (RPGManager_ApplyEffectorsArray x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_ApplyEffectorsArray(
    WeakHandle<game.Object> owner,
    WeakHandle<game.data.Effector_Record>[] arr
);

static QuickhackData? GetMonoWireQuickHackData(PlayerPuppet playerOwner, ScriptedPuppet targetScriptedPuppet, game.weapon.Object weaponObject)

staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::GetMonoWireQuickHackData;PlayerPuppetScriptedPuppetWeaponObject",
    (RPGManager_GetMonoWireQuickHackData x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.QuickhackData>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_GetMonoWireQuickHackData(
    PlayerPuppet? playerOwner,
    ScriptedPuppet? targetScriptedPuppet,
    game.weapon.Object? weaponObject
);

static void RemoveDuplicatedHacks(PlayerQuickhackData[] commands) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "gameRPGManager",
    "gameRPGManager::RemoveDuplicatedHacks;script_ref<array<PlayerQuickhackData>>",
    (RPGManager_RemoveDuplicatedHacks2 x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_RemoveDuplicatedHacks2(
    PlayerQuickhackData[] commands
);

static bool CyberwareHasSideUpgrade(game.ItemID itemID, out game.data.Item_Record sideUpgradeItemRecord) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::CyberwareHasSideUpgrade;ItemIDItem_Record",
    (RPGManager_CyberwareHasSideUpgrade x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_CyberwareHasSideUpgrade(
    game.ItemID itemID,
    game.data.Item_Record? sideUpgradeItemRecord
);

static float CalculateEP1Reward(ScriptGameInstance gi, float experienceValue, float playerLevel) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::CalculateEP1Reward;GameInstanceFloatFloat",
    (RPGManager_CalculateEP1Reward x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_CalculateEP1Reward(
    ScriptGameInstance gi,
    float experienceValue,
    float playerLevel
);

static bool IsItemAdaptiveStemCells(TDBID itemID) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::IsItemAdaptiveStemCells;TweakDBID",
    (RPGManager_IsItemAdaptiveStemCells x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_IsItemAdaptiveStemCells(
    TDBID itemID
);

static float GetRarityMultiplier(WeakHandle<NPCPuppet> puppet, CName curveName) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::GetRarityMultiplier;NPCPuppetCName",
    (RPGManager_GetRarityMultiplier x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_GetRarityMultiplier(
    WeakHandle<NPCPuppet> puppet,
    CName curveName
);

static bool CheckPrereqs(WeakHandle<game.data.IPrereq_Record>[] prereqs, WeakHandle<game.Object> target, game.StatsObjectID referenceStatsID)

staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::CheckPrereqs;script_ref<array<IPrereq_Record>>GameObjectStatsObjectID",
    (RPGManager_CheckPrereqs x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_CheckPrereqs(
    WeakHandle<game.data.IPrereq_Record>[] prereqs,
    WeakHandle<game.Object> target,
    game.StatsObjectID referenceStatsID
);

static CName SetQualityBasedOnLevel(WeakHandle<game.Object> objectt) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::SetQualityBasedOnLevel;GameObject",
    (RPGManager_SetQualityBasedOnLevel x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.CName>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_SetQualityBasedOnLevel(
    WeakHandle<game.Object> objectt
);

static bool CanItemBeDisassembled(ScriptGameInstance gameInstance, WeakHandle<game.ItemData> itemData) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::CanItemBeDisassembled;GameInstancegameItemData",
    (RPGManager_CanItemBeDisassembled2 x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_CanItemBeDisassembled2(
    ScriptGameInstance gameInstance,
    WeakHandle<game.ItemData> itemData
);

static QuickhackData? CreateSimpleQuickhackData(PlayerPuppet playerOwner, ScriptedPuppet targetScriptedPuppet, game.data.ObjectAction_Record quickhackActionRecord)

staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::CreateSimpleQuickhackData;PlayerPuppetScriptedPuppetObjectAction_Record",
    (RPGManager_CreateSimpleQuickhackData x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.QuickhackData>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_CreateSimpleQuickhackData(
    PlayerPuppet? playerOwner,
    ScriptedPuppet? targetScriptedPuppet,
    game.data.ObjectAction_Record? quickhackActionRecord
);

static game.ItemData? GetCyberwareUpgradeItemDataWithOffset(game.Object owner, game.data.Item_Record upgradeItemRecord, TDBID statsShardTDBID, uint seed, int offset)

staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::GetCyberwareUpgradeItemDataWithOffset;GameObjectItem_RecordTweakDBIDUint32Int32",
    (RPGManager_GetCyberwareUpgradeItemDataWithOffset x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.ItemData>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_GetCyberwareUpgradeItemDataWithOffset(
    game.Object? owner,
    game.data.Item_Record? upgradeItemRecord,
    TDBID statsShardTDBID,
    uint seed,
    int offset
);

static float GetItemTierFromName(CName tierName) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::GetItemTierFromName;CName",
    (RPGManager_GetItemTierFromName x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_GetItemTierFromName(
    CName tierName
);

static void IncrementQuickHackBlackboard(ScriptGameInstance gameInstance, TDBID actionID) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "gameRPGManager",
    "gameRPGManager::IncrementQuickHackBlackboard;GameInstanceTweakDBID",
    (RPGManager_IncrementQuickHackBlackboard x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_IncrementQuickHackBlackboard(
    ScriptGameInstance gameInstance,
    TDBID actionID
);

static void ApplyStatModifierGroups(WeakHandle<game.Object> owner, WeakHandle<game.data.StatModifierGroup_Record>[] arr) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "gameRPGManager",
    "gameRPGManager::ApplyStatModifierGroups;GameObjectscript_ref<array<StatModifierGroup_Record>>",
    (RPGManager_ApplyStatModifierGroups x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_ApplyStatModifierGroups(
    WeakHandle<game.Object> owner,
    WeakHandle<game.data.StatModifierGroup_Record>[] arr
);

static game.data.Item_Record? GetItemRecord(game.ItemID itemID) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::GetItemRecord;ItemID",
    (RPGManager_GetItemRecord x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.Item_Record>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_GetItemRecord(
    game.ItemID itemID
);

static int ConvertQualityToItemPlusValue(game.data.Quality quality) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::ConvertQualityToItemPlusValue;gamedataQuality",
    (RPGManager_ConvertQualityToItemPlusValue x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_ConvertQualityToItemPlusValue(
    game.data.Quality quality
);

static void AwardExperienceFromResourceSpent(WeakHandle<PlayerPuppet> player, float value, game.data.StatPoolType type, game.events.HitEvent hitEvent)

staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "gameRPGManager",
    "gameRPGManager::AwardExperienceFromResourceSpent;PlayerPuppetFloatgamedataStatPoolTypegameHitEvent",
    (RPGManager_AwardExperienceFromResourceSpent x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_AwardExperienceFromResourceSpent(
    WeakHandle<PlayerPuppet> player,
    float value,
    game.data.StatPoolType type,
    game.events.HitEvent? hitEvent
);

static game.data.Stat_Record? GetStatRecord(game.data.StatType type) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::GetStatRecord;gamedataStatType",
    (RPGManager_GetStatRecord x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.Stat_Record>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_GetStatRecord(
    game.data.StatType type
);

static void SendAddAchievementRequest(ScriptGameInstance gi, game.data.Achievement achievement, WeakHandle<game.data.Achievement_Record> achievementRecord)

staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "gameRPGManager",
    "gameRPGManager::SendAddAchievementRequest;GameInstancegamedataAchievementAchievement_Record",
    (RPGManager_SendAddAchievementRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_SendAddAchievementRequest(
    ScriptGameInstance gi,
    game.data.Achievement achievement,
    WeakHandle<game.data.Achievement_Record> achievementRecord
);

static bool IsScopeAttachment(game.data.ItemType type) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::IsScopeAttachment;gamedataItemType",
    (RPGManager_IsScopeAttachment2 x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_IsScopeAttachment2(
    game.data.ItemType type
);

static float GetStatValueFromObject(ScriptGameInstance gi, WeakHandle<game.Object> objectt, game.data.StatType stat) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::GetStatValueFromObject;GameInstanceGameObjectgamedataStatType",
    (RPGManager_GetStatValueFromObject x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_GetStatValueFromObject(
    ScriptGameInstance gi,
    WeakHandle<game.Object> objectt,
    game.data.StatType stat
);

static game.data.ItemType GetItemType(game.ItemID itemID) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::GetItemType;ItemID",
    (RPGManager_GetItemType x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.GameDataItemType>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_GetItemType(
    game.ItemID itemID
);

static float GetPlayerCurrentHealthPercent(ScriptGameInstance gi) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::GetPlayerCurrentHealthPercent;GameInstance",
    (RPGManager_GetPlayerCurrentHealthPercent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_GetPlayerCurrentHealthPercent(
    ScriptGameInstance gi
);

static bool IsItemTypeCyberwareWeapon(game.data.ItemType type) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::IsItemTypeCyberwareWeapon;gamedataItemType",
    (RPGManager_IsItemTypeCyberwareWeapon x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_IsItemTypeCyberwareWeapon(
    game.data.ItemType type
);

static void InjectStatModifier(ScriptGameInstance gi, game.Object obj, game.StatModifierData_Deprecated modifier) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "gameRPGManager",
    "gameRPGManager::InjectStatModifier;GameInstanceGameObjectgameStatModifierData",
    (RPGManager_InjectStatModifier x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_InjectStatModifier(
    ScriptGameInstance gi,
    game.Object? obj,
    game.StatModifierData_Deprecated? modifier
);

static bool HasItem(WeakHandle<game.Object> obj, game.ItemID id) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::HasItem;GameObjectItemID",
    (RPGManager_HasItem2 x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_HasItem2(
    WeakHandle<game.Object> obj,
    game.ItemID id
);

static bool CanPlayerUpgradeFromInventory(WeakHandle<game.Object> obj) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::CanPlayerUpgradeFromInventory;GameObject",
    (RPGManager_CanPlayerUpgradeFromInventory x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_CanPlayerUpgradeFromInventory(
    WeakHandle<game.Object> obj
);

static int GetPlayerNextLevelBasedOnRandomQuality(game.data.Quality quality) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::GetPlayerNextLevelBasedOnRandomQuality;gamedataQuality",
    (RPGManager_GetPlayerNextLevelBasedOnRandomQuality x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_GetPlayerNextLevelBasedOnRandomQuality(
    game.data.Quality quality
);

static game.StatModifierData_Deprecated? StatRecordToModifier(game.data.StatModifier_Record statRecord) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::StatRecordToModifier;StatModifier_Record",
    (RPGManager_StatRecordToModifier x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.StatModifierData_Deprecated>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_StatRecordToModifier(
    game.data.StatModifier_Record? statRecord
);

static game.data.Quality ConvertCombinedValueToQuality(int combinedValue) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::ConvertCombinedValueToQuality;Int32",
    (RPGManager_ConvertCombinedValueToQuality x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.Quality>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_ConvertCombinedValueToQuality(
    int combinedValue
);

static int GetCharacterWeakspotCount(game.Puppet puppet) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::GetCharacterWeakspotCount;gamePuppet",
    (RPGManager_GetCharacterWeakspotCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_GetCharacterWeakspotCount(
    game.Puppet? puppet
);

static bool HasDownloadFundsAction(game.ItemID itemID) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::HasDownloadFundsAction;ItemID",
    (RPGManager_HasDownloadFundsAction x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_HasDownloadFundsAction(
    game.ItemID itemID
);

static bool IsItemCrafted(WeakHandle<game.ItemData> itemData) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::IsItemCrafted;gameItemData",
    (RPGManager_IsItemCrafted2 x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_IsItemCrafted2(
    WeakHandle<game.ItemData> itemData
);

static bool BreakItem(ScriptGameInstance gi, game.Object owner, game.ItemID itemID) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::BreakItem;GameInstanceGameObjectItemID",
    (RPGManager_BreakItem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_BreakItem(
    ScriptGameInstance gi,
    game.Object? owner,
    game.ItemID itemID
);

static float CalculateThreatValue(game.Object obj) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::CalculateThreatValue;GameObject",
    (RPGManager_CalculateThreatValue x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

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

static void AwardExperienceFromLocomotion(WeakHandle<PlayerPuppet> player, float amount) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "gameRPGManager",
    "gameRPGManager::AwardExperienceFromLocomotion;PlayerPuppetFloat",
    (RPGManager_AwardExperienceFromLocomotion x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_AwardExperienceFromLocomotion(
    WeakHandle<PlayerPuppet> player,
    float amount
);

static bool IsItemMaxLevel(WeakHandle<game.ItemData> itemData) staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::IsItemMaxLevel;gameItemData",
    (RPGManager_IsItemMaxLevel x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_IsItemMaxLevel(
    WeakHandle<game.ItemData> itemData
);

static void HandleBuyShardPopupClosed(game.Object owner, game.ItemID equippedItemId, RipperdocTokenPopupCloseData resultData)

staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "gameRPGManager",
    "gameRPGManager::HandleBuyShardPopupClosed;GameObjectItemIDRipperdocTokenPopupCloseData",
    (RPGManager_HandleBuyShardPopupClosed x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_HandleBuyShardPopupClosed(
    game.Object? owner,
    game.ItemID equippedItemId,
    RipperdocTokenPopupCloseData? resultData
);

static int GetBluelinePaymentValue(game.Object player, game.data.ContentAssignment_Record contentAssignment, EGameplayChallengeLevel difficulty)

staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::GetBluelinePaymentValue;GameObjectContentAssignment_RecordEGameplayChallengeLevel",
    (RPGManager_GetBluelinePaymentValue x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_GetBluelinePaymentValue(
    game.Object? player,
    game.data.ContentAssignment_Record? contentAssignment,
    EGameplayChallengeLevel difficulty
);

static WeakHandle<game.data.Stat_Record>[] GetListOfRandomStatsFromEvolutionType(game.data.WeaponEvolution evolution) staticRTTI global

static bool CanAffordAndPerformCyberwareUpgrade(game.Object owner, game.data.Quality currentQuality, game.data.Item_Record upgradeItemRecord, out CyberwareUpgradeCostData costData)

staticRTTI global

Generated hook

re.Hooks.Place(
    "gameRPGManager",
    "gameRPGManager::CanAffordAndPerformCyberwareUpgrade;GameObjectgamedataQualityItem_RecordCyberwareUpgradeCostData",
    (RPGManager_CanAffordAndPerformCyberwareUpgrade x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct RPGManager_CanAffordAndPerformCyberwareUpgrade(
    game.Object? owner,
    game.data.Quality currentQuality,
    game.data.Item_Record? upgradeItemRecord,
    CyberwareUpgradeCostData costData
);