class game

TelemetryTelemetrySystem

game.TelemetryTelemetrySystem

0 properties
49 functions

Extends game.ITelemetrySystem game.IGameSystem IScriptable ISerializable

Properties

None.

Functions

void LogPlayerDeathEvent(game.events.DeathEvent evt) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameTelemetryTelemetrySystem",
    "LogPlayerDeathEvent",
    (TelemetryTelemetrySystem_LogPlayerDeathEvent x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TelemetryTelemetrySystem_LogPlayerDeathEvent(
    game.TelemetryTelemetrySystem self,
    game.events.DeathEvent? evt
);

void LogDamageDealt(game.TelemetryDamageDealt damage) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameTelemetryTelemetrySystem",
    "LogDamageDealt",
    (TelemetryTelemetrySystem_LogDamageDealt x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TelemetryTelemetrySystem_LogDamageDealt(
    game.TelemetryTelemetrySystem self,
    game.TelemetryDamageDealt damage
);

void LogHeadshotGGP(int num) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameTelemetryTelemetrySystem",
    "LogHeadshotGGP",
    (TelemetryTelemetrySystem_LogHeadshotGGP x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TelemetryTelemetrySystem_LogHeadshotGGP(
    game.TelemetryTelemetrySystem self,
    int num
);

void LogEnemyDown(game.TelemetryEnemyDown telemetryEnemyDown) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameTelemetryTelemetrySystem",
    "LogEnemyDown",
    (TelemetryTelemetrySystem_LogEnemyDown x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TelemetryTelemetrySystem_LogEnemyDown(
    game.TelemetryTelemetrySystem self,
    game.TelemetryEnemyDown telemetryEnemyDown
);

void LogCombatGadgetUsed(WeakHandle<game.Object> owner, game.ItemID itemID) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameTelemetryTelemetrySystem",
    "LogCombatGadgetUsed",
    (TelemetryTelemetrySystem_LogCombatGadgetUsed x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

void LogActiveCyberwareUsed(WeakHandle<game.Object> owner, game.ItemID itemID) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameTelemetryTelemetrySystem",
    "LogActiveCyberwareUsed",
    (TelemetryTelemetrySystem_LogActiveCyberwareUsed x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

void LogConsumableUsed(WeakHandle<game.Object> owner, game.ItemID itemID) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameTelemetryTelemetrySystem",
    "LogConsumableUsed",
    (TelemetryTelemetrySystem_LogConsumableUsed x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

void LogSpecialMovementPerformed(game.TelemetryMovementType mvtType) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameTelemetryTelemetrySystem",
    "LogSpecialMovementPerformed",
    (TelemetryTelemetrySystem_LogSpecialMovementPerformed x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TelemetryTelemetrySystem_LogSpecialMovementPerformed(
    game.TelemetryTelemetrySystem self,
    game.TelemetryMovementType mvtType
);

void LogPlayerInDangerousArea(bool dangerous) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameTelemetryTelemetrySystem",
    "LogPlayerInDangerousArea",
    (TelemetryTelemetrySystem_LogPlayerInDangerousArea x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TelemetryTelemetrySystem_LogPlayerInDangerousArea(
    game.TelemetryTelemetrySystem self,
    bool dangerous
);

void LogNumberOfCombatants(int numberOfCombatants) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameTelemetryTelemetrySystem",
    "LogNumberOfCombatants",
    (TelemetryTelemetrySystem_LogNumberOfCombatants x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TelemetryTelemetrySystem_LogNumberOfCombatants(
    game.TelemetryTelemetrySystem self,
    int numberOfCombatants
);

void LogPlayerReachedCriticalHealth(bool healthIsCritical) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameTelemetryTelemetrySystem",
    "LogPlayerReachedCriticalHealth",
    (TelemetryTelemetrySystem_LogPlayerReachedCriticalHealth x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TelemetryTelemetrySystem_LogPlayerReachedCriticalHealth(
    game.TelemetryTelemetrySystem self,
    bool healthIsCritical
);

void LogLevelGained(game.TelemetryLevelGained evt) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameTelemetryTelemetrySystem",
    "LogLevelGained",
    (TelemetryTelemetrySystem_LogLevelGained x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TelemetryTelemetrySystem_LogLevelGained(
    game.TelemetryTelemetrySystem self,
    game.TelemetryLevelGained evt
);

void LogDistrictChanged(string districtName, bool isNew) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameTelemetryTelemetrySystem",
    "LogDistrictChanged",
    (TelemetryTelemetrySystem_LogDistrictChanged x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TelemetryTelemetrySystem_LogDistrictChanged(
    game.TelemetryTelemetrySystem self,
    string districtName,
    bool isNew
);

void LogRewardGiven(CName rewardName, TDBID rewardTDBID, int rewardMoney) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameTelemetryTelemetrySystem",
    "LogRewardGiven",
    (TelemetryTelemetrySystem_LogRewardGiven x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TelemetryTelemetrySystem_LogRewardGiven(
    game.TelemetryTelemetrySystem self,
    CName rewardName,
    TDBID rewardTDBID,
    int rewardMoney
);

void LogAttributeUpgraded(game.data.StatType attributeType, int lvl) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameTelemetryTelemetrySystem",
    "LogAttributeUpgraded",
    (TelemetryTelemetrySystem_LogAttributeUpgraded x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TelemetryTelemetrySystem_LogAttributeUpgraded(
    game.TelemetryTelemetrySystem self,
    game.data.StatType attributeType,
    int lvl
);

void LogPerkUpgraded(game.data.PerkType perkUpgraded, int lvl) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameTelemetryTelemetrySystem",
    "LogPerkUpgraded",
    (TelemetryTelemetrySystem_LogPerkUpgraded x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TelemetryTelemetrySystem_LogPerkUpgraded(
    game.TelemetryTelemetrySystem self,
    game.data.PerkType perkUpgraded,
    int lvl
);

void LogNewPerkUpgraded(game.data.NewPerkType newPerkUpgraded, int lvl, game.data.DevelopmentPointType developementPointType)

RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameTelemetryTelemetrySystem",
    "LogNewPerkUpgraded",
    (TelemetryTelemetrySystem_LogNewPerkUpgraded x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TelemetryTelemetrySystem_LogNewPerkUpgraded(
    game.TelemetryTelemetrySystem self,
    game.data.NewPerkType newPerkUpgraded,
    int lvl,
    game.data.DevelopmentPointType developementPointType
);

void LogPartInstalled(game.TelemetryInventoryItem modifiedItem, game.TelemetryInventoryItem itemPart, TDBID slotID) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameTelemetryTelemetrySystem",
    "LogPartInstalled",
    (TelemetryTelemetrySystem_LogPartInstalled x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TelemetryTelemetrySystem_LogPartInstalled(
    game.TelemetryTelemetrySystem self,
    game.TelemetryInventoryItem modifiedItem,
    game.TelemetryInventoryItem itemPart,
    TDBID slotID
);

void LogInventoryMenuClosed() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameTelemetryTelemetrySystem",
    "LogInventoryMenuClosed",
    (TelemetryTelemetrySystem_LogInventoryMenuClosed x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TelemetryTelemetrySystem_LogInventoryMenuClosed(
    game.TelemetryTelemetrySystem self
);

void LogQuickHack(game.TelemetryQuickHack telemetryQuickHack) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameTelemetryTelemetrySystem",
    "LogQuickHack",
    (TelemetryTelemetrySystem_LogQuickHack x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TelemetryTelemetrySystem_LogQuickHack(
    game.TelemetryTelemetrySystem self,
    game.TelemetryQuickHack telemetryQuickHack
);

void LogTakedown(CName takedownAction, WeakHandle<game.Object> target) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameTelemetryTelemetrySystem",
    "LogTakedown",
    (TelemetryTelemetrySystem_LogTakedown x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TelemetryTelemetrySystem_LogTakedown(
    game.TelemetryTelemetrySystem self,
    CName takedownAction,
    WeakHandle<game.Object> target
);

void LogBodyDisposed() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameTelemetryTelemetrySystem",
    "LogBodyDisposed",
    (TelemetryTelemetrySystem_LogBodyDisposed x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TelemetryTelemetrySystem_LogBodyDisposed(
    game.TelemetryTelemetrySystem self
);

void LogWeaponAttackPerformed(WeakHandle<game.weapon.Object> weapon) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameTelemetryTelemetrySystem",
    "LogWeaponAttackPerformed",
    (TelemetryTelemetrySystem_LogWeaponAttackPerformed x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TelemetryTelemetrySystem_LogWeaponAttackPerformed(
    game.TelemetryTelemetrySystem self,
    WeakHandle<game.weapon.Object> weapon
);

void LogHitDefense(game.TelemetryHitDefenseType defenseType) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameTelemetryTelemetrySystem",
    "LogHitDefense",
    (TelemetryTelemetrySystem_LogHitDefense x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TelemetryTelemetrySystem_LogHitDefense(
    game.TelemetryTelemetrySystem self,
    game.TelemetryHitDefenseType defenseType
);

void LogItemTransaction(WeakHandle<game.Object> buyer, WeakHandle<game.Object> seller, game.ItemID itemID, uint pricePerItem, uint itemQuantity, uint totalPrice)

RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameTelemetryTelemetrySystem",
    "LogItemTransaction",
    (TelemetryTelemetrySystem_LogItemTransaction x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TelemetryTelemetrySystem_LogItemTransaction(
    game.TelemetryTelemetrySystem self,
    WeakHandle<game.Object> buyer,
    WeakHandle<game.Object> seller,
    game.ItemID itemID,
    uint pricePerItem,
    uint itemQuantity,
    uint totalPrice
);

void LogVendorMenuState(TDBID vendorid, bool isOpening) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameTelemetryTelemetrySystem",
    "LogVendorMenuState",
    (TelemetryTelemetrySystem_LogVendorMenuState x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TelemetryTelemetrySystem_LogVendorMenuState(
    game.TelemetryTelemetrySystem self,
    TDBID vendorid,
    bool isOpening
);

void LogSkillbookUsed(WeakHandle<game.Object> owner, game.ItemID itemID) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameTelemetryTelemetrySystem",
    "LogSkillbookUsed",
    (TelemetryTelemetrySystem_LogSkillbookUsed x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

void LogItemAcquired(TDBID itemTDBID, string meanOfAcquisition) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameTelemetryTelemetrySystem",
    "LogItemAcquired",
    (TelemetryTelemetrySystem_LogItemAcquired x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TelemetryTelemetrySystem_LogItemAcquired(
    game.TelemetryTelemetrySystem self,
    TDBID itemTDBID,
    string meanOfAcquisition
);

void LogItemDrop(WeakHandle<game.Object> owner, game.ItemID itemID) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameTelemetryTelemetrySystem",
    "LogItemDrop",
    (TelemetryTelemetrySystem_LogItemDrop x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

void LogItemCrafting(game.TelemetryInventoryItem telemetryInventoryItem, CName craftingAction) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameTelemetryTelemetrySystem",
    "LogItemCrafting",
    (TelemetryTelemetrySystem_LogItemCrafting x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TelemetryTelemetrySystem_LogItemCrafting(
    game.TelemetryTelemetrySystem self,
    game.TelemetryInventoryItem telemetryInventoryItem,
    CName craftingAction
);

void LogItemDisassembled(WeakHandle<game.Object> owner, game.ItemID itemID) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameTelemetryTelemetrySystem",
    "LogItemDisassembled",
    (TelemetryTelemetrySystem_LogItemDisassembled x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

void LogItemReward(WeakHandle<game.Object> owner, game.ItemID itemID) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameTelemetryTelemetrySystem",
    "LogItemReward",
    (TelemetryTelemetrySystem_LogItemReward x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

void LogDamageByVehicle(game.events.HitEvent hitEvent) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameTelemetryTelemetrySystem",
    "LogDamageByVehicle",
    (TelemetryTelemetrySystem_LogDamageByVehicle x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TelemetryTelemetrySystem_LogDamageByVehicle(
    game.TelemetryTelemetrySystem self,
    game.events.HitEvent? hitEvent
);

void LogXPReward(TDBID xpRecordID, int amount, game.data.ProficiencyType type) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameTelemetryTelemetrySystem",
    "LogXPReward",
    (TelemetryTelemetrySystem_LogXPReward x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TelemetryTelemetrySystem_LogXPReward(
    game.TelemetryTelemetrySystem self,
    TDBID xpRecordID,
    int amount,
    game.data.ProficiencyType type
);

void LogDevPointsAddedFromReward(TDBID addDevPointEffectorTDBID, int amount, game.data.DevelopmentPointType type) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameTelemetryTelemetrySystem",
    "LogDevPointsAddedFromReward",
    (TelemetryTelemetrySystem_LogDevPointsAddedFromReward x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TelemetryTelemetrySystem_LogDevPointsAddedFromReward(
    game.TelemetryTelemetrySystem self,
    TDBID addDevPointEffectorTDBID,
    int amount,
    game.data.DevelopmentPointType type
);

void OnSettingsSave() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameTelemetryTelemetrySystem",
    "OnSettingsSave",
    (TelemetryTelemetrySystem_OnSettingsSave x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TelemetryTelemetrySystem_OnSettingsSave(
    game.TelemetryTelemetrySystem self
);

void LogBraindanceReset() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameTelemetryTelemetrySystem",
    "LogBraindanceReset",
    (TelemetryTelemetrySystem_LogBraindanceReset x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TelemetryTelemetrySystem_LogBraindanceReset(
    game.TelemetryTelemetrySystem self
);

void LogLastCheckpointLoaded() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameTelemetryTelemetrySystem",
    "LogLastCheckpointLoaded",
    (TelemetryTelemetrySystem_LogLastCheckpointLoaded x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TelemetryTelemetrySystem_LogLastCheckpointLoaded(
    game.TelemetryTelemetrySystem self
);

void LogPerksRemoved(int respecCost, game.data.PerkType[] perksRemoved) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameTelemetryTelemetrySystem",
    "LogPerksRemoved",
    (TelemetryTelemetrySystem_LogPerksRemoved x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TelemetryTelemetrySystem_LogPerksRemoved(
    game.TelemetryTelemetrySystem self,
    int respecCost,
    game.data.PerkType[] perksRemoved
);

void LogNewPerkRemoved(game.data.NewPerkType perkRemoved) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameTelemetryTelemetrySystem",
    "LogNewPerkRemoved",
    (TelemetryTelemetrySystem_LogNewPerkRemoved x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TelemetryTelemetrySystem_LogNewPerkRemoved(
    game.TelemetryTelemetrySystem self,
    game.data.NewPerkType perkRemoved
);

void LogPhotomodeAttributeChanged() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameTelemetryTelemetrySystem",
    "LogPhotomodeAttributeChanged",
    (TelemetryTelemetrySystem_LogPhotomodeAttributeChanged x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TelemetryTelemetrySystem_LogPhotomodeAttributeChanged(
    game.TelemetryTelemetrySystem self
);

void LogWardrobeUsed(int slotsUsed) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameTelemetryTelemetrySystem",
    "LogWardrobeUsed",
    (TelemetryTelemetrySystem_LogWardrobeUsed x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TelemetryTelemetrySystem_LogWardrobeUsed(
    game.TelemetryTelemetrySystem self,
    int slotsUsed
);

void LogEnteringOrExitingVehicle(bool isExiting) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameTelemetryTelemetrySystem",
    "LogEnteringOrExitingVehicle",
    (TelemetryTelemetrySystem_LogEnteringOrExitingVehicle x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TelemetryTelemetrySystem_LogEnteringOrExitingVehicle(
    game.TelemetryTelemetrySystem self,
    bool isExiting
);

void LogPlayerVehicleExploded() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameTelemetryTelemetrySystem",
    "LogPlayerVehicleExploded",
    (TelemetryTelemetrySystem_LogPlayerVehicleExploded x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TelemetryTelemetrySystem_LogPlayerVehicleExploded(
    game.TelemetryTelemetrySystem self
);

void LogPlayerVehicleDamageReceived(int damage) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameTelemetryTelemetrySystem",
    "LogPlayerVehicleDamageReceived",
    (TelemetryTelemetrySystem_LogPlayerVehicleDamageReceived x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TelemetryTelemetrySystem_LogPlayerVehicleDamageReceived(
    game.TelemetryTelemetrySystem self,
    int damage
);

void LogPlayerVehicleImpact() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameTelemetryTelemetrySystem",
    "LogPlayerVehicleImpact",
    (TelemetryTelemetrySystem_LogPlayerVehicleImpact x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TelemetryTelemetrySystem_LogPlayerVehicleImpact(
    game.TelemetryTelemetrySystem self
);

void LogHeatLevelChanged(uint heatLevel, string reason, uint crimescore) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameTelemetryTelemetrySystem",
    "LogHeatLevelChanged",
    (TelemetryTelemetrySystem_LogHeatLevelChanged x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TelemetryTelemetrySystem_LogHeatLevelChanged(
    game.TelemetryTelemetrySystem self,
    uint heatLevel,
    string reason,
    uint crimescore
);

static game.TelemetryInventoryItem GetTelemetryInventoryItemFromID(WeakHandle<game.Object> owner, game.ItemID itemID) staticRTTI

Generated hook

re.Hooks.Place(
    "gameTelemetryTelemetrySystem",
    "GetTelemetryInventoryItemFromID",
    (TelemetryTelemetrySystem_GetTelemetryInventoryItemFromID x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.TelemetryInventoryItem>();
    }
);

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

static game.TelemetryInventoryItem GetTelemetryInventoryItemFromdata(WeakHandle<game.ItemData> itemData) staticRTTI

Generated hook

re.Hooks.Place(
    "gameTelemetryTelemetrySystem",
    "GetTelemetryInventoryItemFromdata",
    (TelemetryTelemetrySystem_GetTelemetryInventoryItemFromdata x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.TelemetryInventoryItem>();
    }
);

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