class game.map.pins

StealthMappin

game.map.pins.StealthMappin

0 properties
66 functions

Extends game.map.pins.RuntimeMappin game.map.pins.IMappin game.map.pins.IVisualObject IScriptable ISerializable

Properties

None.

Functions

WeakHandle<game.Object> GetGameObject() RTTI

float GetDetectionProgress() RTTI

Generated hook

re.Hooks.Place(
    "gamemappinsStealthMappin",
    "GetDetectionProgress",
    (StealthMappin_GetDetectionProgress x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct StealthMappin_GetDetectionProgress(
    game.map.pins.StealthMappin self
);

void GetPrevDetectionProgress() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamemappinsStealthMappin",
    "GetPrevDetectionProgress",
    (StealthMappin_GetPrevDetectionProgress x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct StealthMappin_GetPrevDetectionProgress(
    game.map.pins.StealthMappin self
);

bool DetectionProgressIncreases() RTTI

Generated hook

re.Hooks.Place(
    "gamemappinsStealthMappin",
    "DetectionProgressIncreases",
    (StealthMappin_DetectionProgressIncreases x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct StealthMappin_DetectionProgressIncreases(
    game.map.pins.StealthMappin self
);

bool DetectionProgressDecreases() RTTI

Generated hook

re.Hooks.Place(
    "gamemappinsStealthMappin",
    "DetectionProgressDecreases",
    (StealthMappin_DetectionProgressDecreases x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct StealthMappin_DetectionProgressDecreases(
    game.map.pins.StealthMappin self
);

bool WasDetectionAboveZero() RTTI

Generated hook

re.Hooks.Place(
    "gamemappinsStealthMappin",
    "WasDetectionAboveZero",
    (StealthMappin_WasDetectionAboveZero x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct StealthMappin_WasDetectionAboveZero(
    game.map.pins.StealthMappin self
);

float GetThreatAccuracy() RTTI

Generated hook

re.Hooks.Place(
    "gamemappinsStealthMappin",
    "GetThreatAccuracy",
    (StealthMappin_GetThreatAccuracy x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct StealthMappin_GetThreatAccuracy(
    game.map.pins.StealthMappin self
);

void GetPrevThreatAccuracy() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamemappinsStealthMappin",
    "GetPrevThreatAccuracy",
    (StealthMappin_GetPrevThreatAccuracy x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct StealthMappin_GetPrevThreatAccuracy(
    game.map.pins.StealthMappin self
);

bool ThreatAccuracyIncreases() RTTI

Generated hook

re.Hooks.Place(
    "gamemappinsStealthMappin",
    "ThreatAccuracyIncreases",
    (StealthMappin_ThreatAccuracyIncreases x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct StealthMappin_ThreatAccuracyIncreases(
    game.map.pins.StealthMappin self
);

bool ThreatAccuracyDecreases() RTTI

Generated hook

re.Hooks.Place(
    "gamemappinsStealthMappin",
    "ThreatAccuracyDecreases",
    (StealthMappin_ThreatAccuracyDecreases x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct StealthMappin_ThreatAccuracyDecreases(
    game.map.pins.StealthMappin self
);

EAIAttitude GetAttitudeTowardsPlayer() RTTI

Generated hook

re.Hooks.Place(
    "gamemappinsStealthMappin",
    "GetAttitudeTowardsPlayer",
    (StealthMappin_GetAttitudeTowardsPlayer x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.EAIAttitude>();
    }
);

[Msgpack.Gen]
public readonly partial record struct StealthMappin_GetAttitudeTowardsPlayer(
    game.map.pins.StealthMappin self
);

game.map.pins.SenseCone GetSenseCone() RTTI

Generated hook

re.Hooks.Place(
    "gamemappinsStealthMappin",
    "GetSenseCone",
    (StealthMappin_GetSenseCone x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.map.pins.SenseCone>();
    }
);

[Msgpack.Gen]
public readonly partial record struct StealthMappin_GetSenseCone(
    game.map.pins.StealthMappin self
);

bool IsAlive() RTTI

Generated hook

re.Hooks.Place(
    "gamemappinsStealthMappin",
    "IsAlive",
    (StealthMappin_IsAlive x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct StealthMappin_IsAlive(
    game.map.pins.StealthMappin self
);

bool IsAggressive() RTTI

Generated hook

re.Hooks.Place(
    "gamemappinsStealthMappin",
    "IsAggressive",
    (StealthMappin_IsAggressive x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct StealthMappin_IsAggressive(
    game.map.pins.StealthMappin self
);

bool IsScanned() RTTI

Generated hook

re.Hooks.Place(
    "gamemappinsStealthMappin",
    "IsScanned",
    (StealthMappin_IsScanned x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct StealthMappin_IsScanned(
    game.map.pins.StealthMappin self
);

bool IsTarget() RTTI

Generated hook

re.Hooks.Place(
    "gamemappinsStealthMappin",
    "IsTarget",
    (StealthMappin_IsTarget x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct StealthMappin_IsTarget(
    game.map.pins.StealthMappin self
);

bool IsTagged() RTTI

Generated hook

re.Hooks.Place(
    "gamemappinsStealthMappin",
    "IsTagged",
    (StealthMappin_IsTagged x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct StealthMappin_IsTagged(
    game.map.pins.StealthMappin self
);

bool IsPrevention() RTTI

Generated hook

re.Hooks.Place(
    "gamemappinsStealthMappin",
    "IsPrevention",
    (StealthMappin_IsPrevention x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct StealthMappin_IsPrevention(
    game.map.pins.StealthMappin self
);

bool IsCrowdNPC() RTTI

Generated hook

re.Hooks.Place(
    "gamemappinsStealthMappin",
    "IsCrowdNPC",
    (StealthMappin_IsCrowdNPC x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct StealthMappin_IsCrowdNPC(
    game.map.pins.StealthMappin self
);

bool IsCombatNPC() RTTI

Generated hook

re.Hooks.Place(
    "gamemappinsStealthMappin",
    "IsCombatNPC",
    (StealthMappin_IsCombatNPC x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct StealthMappin_IsCombatNPC(
    game.map.pins.StealthMappin self
);

bool IsUsingSenseCone() RTTI

Generated hook

re.Hooks.Place(
    "gamemappinsStealthMappin",
    "IsUsingSenseCone",
    (StealthMappin_IsUsingSenseCone x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct StealthMappin_IsUsingSenseCone(
    game.map.pins.StealthMappin self
);

bool HasItems() RTTI

Generated hook

re.Hooks.Place(
    "gamemappinsStealthMappin",
    "HasItems",
    (StealthMappin_HasItems x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct StealthMappin_HasItems(
    game.map.pins.StealthMappin self
);

void UpdateSenseCone() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamemappinsStealthMappin",
    "UpdateSenseCone",
    (StealthMappin_UpdateSenseCone x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct StealthMappin_UpdateSenseCone(
    game.map.pins.StealthMappin self
);

game.data.NPCRarity GetRarity() RTTI

Generated hook

re.Hooks.Place(
    "gamemappinsStealthMappin",
    "GetRarity",
    (StealthMappin_GetRarity x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.NPCRarity>();
    }
);

[Msgpack.Gen]
public readonly partial record struct StealthMappin_GetRarity(
    game.map.pins.StealthMappin self
);

game.data.NPCHighLevelState GetHighLevelState() RTTI

Generated hook

re.Hooks.Place(
    "gamemappinsStealthMappin",
    "GetHighLevelState",
    (StealthMappin_GetHighLevelState x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.NPCHighLevelState>();
    }
);

[Msgpack.Gen]
public readonly partial record struct StealthMappin_GetHighLevelState(
    game.map.pins.StealthMappin self
);

void SetVisibleOnMinimap(bool isVisible) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamemappinsStealthMappin",
    "SetVisibleOnMinimap",
    (StealthMappin_SetVisibleOnMinimap x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct StealthMappin_SetVisibleOnMinimap(
    game.map.pins.StealthMappin self,
    bool isVisible
);

void SetVisibleIn3D(bool isVisible) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamemappinsStealthMappin",
    "SetVisibleIn3D",
    (StealthMappin_SetVisibleIn3D x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct StealthMappin_SetVisibleIn3D(
    game.map.pins.StealthMappin self,
    bool isVisible
);

void UnregisterMappin() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamemappinsStealthMappin",
    "UnregisterMappin",
    (StealthMappin_UnregisterMappin x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct StealthMappin_UnregisterMappin(
    game.map.pins.StealthMappin self
);

void UpdateCombatantState(bool isCombatant) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamemappinsStealthMappin",
    "UpdateCombatantState",
    (StealthMappin_UpdateCombatantState x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct StealthMappin_UpdateCombatantState(
    game.map.pins.StealthMappin self,
    bool isCombatant
);

uint GetNumberOfShotAttempts() RTTI

Generated hook

re.Hooks.Place(
    "gamemappinsStealthMappin",
    "GetNumberOfShotAttempts",
    (StealthMappin_GetNumberOfShotAttempts x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Uint>();
    }
);

[Msgpack.Gen]
public readonly partial record struct StealthMappin_GetNumberOfShotAttempts(
    game.map.pins.StealthMappin self
);

bool GetIsDetectionGrowing() RTTI

Generated hook

re.Hooks.Place(
    "gamemappinsStealthMappin",
    "GetIsDetectionGrowing",
    (StealthMappin_GetIsDetectionGrowing x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct StealthMappin_GetIsDetectionGrowing(
    game.map.pins.StealthMappin self
);

bool HasBeenSeen() RTTI

Generated hook

re.Hooks.Place(
    "gamemappinsStealthMappin",
    "HasBeenSeen",
    (StealthMappin_HasBeenSeen x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct StealthMappin_HasBeenSeen(
    game.map.pins.StealthMappin self
);

void SetIsPulsing(bool isPulsing) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamemappinsStealthMappin",
    "SetIsPulsing",
    (StealthMappin_SetIsPulsing x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct StealthMappin_SetIsPulsing(
    game.map.pins.StealthMappin self,
    bool isPulsing
);

bool CanSeePlayer() RTTI

Generated hook

re.Hooks.Place(
    "gamemappinsStealthMappin",
    "CanSeePlayer",
    (StealthMappin_CanSeePlayer x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct StealthMappin_CanSeePlayer(
    game.map.pins.StealthMappin self
);

bool IsHighlighted() RTTI

Generated hook

re.Hooks.Place(
    "gamemappinsStealthMappin",
    "IsHighlighted",
    (StealthMappin_IsHighlighted x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct StealthMappin_IsHighlighted(
    game.map.pins.StealthMappin self
);

void SetStealthAwarenessState(game.EnemyStealthAwarenessState state) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamemappinsStealthMappin",
    "SetStealthAwarenessState",
    (StealthMappin_SetStealthAwarenessState x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct StealthMappin_SetStealthAwarenessState(
    game.map.pins.StealthMappin self,
    game.EnemyStealthAwarenessState state
);

game.EnemyStealthAwarenessState GetStealthAwarenessState() RTTI

Generated hook

re.Hooks.Place(
    "gamemappinsStealthMappin",
    "GetStealthAwarenessState",
    (StealthMappin_GetStealthAwarenessState x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.EnemyStealthAwarenessState>();
    }
);

[Msgpack.Gen]
public readonly partial record struct StealthMappin_GetStealthAwarenessState(
    game.map.pins.StealthMappin self
);

bool IsSquadInCombat() RTTI

Generated hook

re.Hooks.Place(
    "gamemappinsStealthMappin",
    "IsSquadInCombat",
    (StealthMappin_IsSquadInCombat x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct StealthMappin_IsSquadInCombat(
    game.map.pins.StealthMappin self
);

uint GetNumberOfCombatants() RTTI

Generated hook

re.Hooks.Place(
    "gamemappinsStealthMappin",
    "GetNumberOfCombatants",
    (StealthMappin_GetNumberOfCombatants x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Uint>();
    }
);

[Msgpack.Gen]
public readonly partial record struct StealthMappin_GetNumberOfCombatants(
    game.map.pins.StealthMappin self
);

uint GetHighestLootQuality() RTTI

Generated hook

re.Hooks.Place(
    "gamemappinsStealthMappin",
    "GetHighestLootQuality",
    (StealthMappin_GetHighestLootQuality x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Uint>();
    }
);

[Msgpack.Gen]
public readonly partial record struct StealthMappin_GetHighestLootQuality(
    game.map.pins.StealthMappin self
);

bool IsNetrunner() RTTI

Generated hook

re.Hooks.Place(
    "gamemappinsStealthMappin",
    "IsNetrunner",
    (StealthMappin_IsNetrunner x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct StealthMappin_IsNetrunner(
    game.map.pins.StealthMappin self
);

bool IsDevice() RTTI

Generated hook

re.Hooks.Place(
    "gamemappinsStealthMappin",
    "IsDevice",
    (StealthMappin_IsDevice x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct StealthMappin_IsDevice(
    game.map.pins.StealthMappin self
);

bool IsPlayerInHostileZone() RTTI

Generated hook

re.Hooks.Place(
    "gamemappinsStealthMappin",
    "IsPlayerInHostileZone",
    (StealthMappin_IsPlayerInHostileZone x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct StealthMappin_IsPlayerInHostileZone(
    game.map.pins.StealthMappin self
);

bool WillReprimand() RTTI

Generated hook

re.Hooks.Place(
    "gamemappinsStealthMappin",
    "WillReprimand",
    (StealthMappin_WillReprimand x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct StealthMappin_WillReprimand(
    game.map.pins.StealthMappin self
);

bool IsHiddenByQuestOnMinimap() RTTI

Generated hook

re.Hooks.Place(
    "gamemappinsStealthMappin",
    "IsHiddenByQuestOnMinimap",
    (StealthMappin_IsHiddenByQuestOnMinimap x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct StealthMappin_IsHiddenByQuestOnMinimap(
    game.map.pins.StealthMappin self
);

bool IsHiddenByQuestIn3D() RTTI

Generated hook

re.Hooks.Place(
    "gamemappinsStealthMappin",
    "IsHiddenByQuestIn3D",
    (StealthMappin_IsHiddenByQuestIn3D x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct StealthMappin_IsHiddenByQuestIn3D(
    game.map.pins.StealthMappin self
);

game.ReprimandMappinAnimationState GetReprimandAnimationState() RTTI

Generated hook

re.Hooks.Place(
    "gamemappinsStealthMappin",
    "GetReprimandAnimationState",
    (StealthMappin_GetReprimandAnimationState x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.ReprimandMappinAnimationState>();
    }
);

[Msgpack.Gen]
public readonly partial record struct StealthMappin_GetReprimandAnimationState(
    game.map.pins.StealthMappin self
);

uint GetNPCLevel() RTTI

Generated hook

re.Hooks.Place(
    "gamemappinsStealthMappin",
    "GetNPCLevel",
    (StealthMappin_GetNPCLevel x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Uint>();
    }
);

[Msgpack.Gen]
public readonly partial record struct StealthMappin_GetNPCLevel(
    game.map.pins.StealthMappin self
);

game.data.ArchetypeType GetArchetype() RTTI

Generated hook

re.Hooks.Place(
    "gamemappinsStealthMappin",
    "GetArchetype",
    (StealthMappin_GetArchetype x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.ArchetypeType>();
    }
);

[Msgpack.Gen]
public readonly partial record struct StealthMappin_GetArchetype(
    game.map.pins.StealthMappin self
);

float GetStatusEffectCurrentPriority() RTTI

Generated hook

re.Hooks.Place(
    "gamemappinsStealthMappin",
    "GetStatusEffectCurrentPriority",
    (StealthMappin_GetStatusEffectCurrentPriority x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct StealthMappin_GetStatusEffectCurrentPriority(
    game.map.pins.StealthMappin self
);

float GetStatusEffectTimeRemaining() RTTI

Generated hook

re.Hooks.Place(
    "gamemappinsStealthMappin",
    "GetStatusEffectTimeRemaining",
    (StealthMappin_GetStatusEffectTimeRemaining x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct StealthMappin_GetStatusEffectTimeRemaining(
    game.map.pins.StealthMappin self
);

string GetStatusEffectIconPath() RTTI

Generated hook

re.Hooks.Place(
    "gamemappinsStealthMappin",
    "GetStatusEffectIconPath",
    (StealthMappin_GetStatusEffectIconPath x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Str>();
    }
);

[Msgpack.Gen]
public readonly partial record struct StealthMappin_GetStatusEffectIconPath(
    game.map.pins.StealthMappin self
);

void UpdateObjectMarkerVisibility(bool canHaveObjectMarker, bool isVisible) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamemappinsStealthMappin",
    "UpdateObjectMarkerVisibility",
    (StealthMappin_UpdateObjectMarkerVisibility x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct StealthMappin_UpdateObjectMarkerVisibility(
    game.map.pins.StealthMappin self,
    bool canHaveObjectMarker,
    bool isVisible
);

bool IsFriendlyFromHack() RTTI

Generated hook

re.Hooks.Place(
    "gamemappinsStealthMappin",
    "IsFriendlyFromHack",
    (StealthMappin_IsFriendlyFromHack x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct StealthMappin_IsFriendlyFromHack(
    game.map.pins.StealthMappin self
);

bool HasHackingStatusEffect() RTTI

Generated hook

re.Hooks.Place(
    "gamemappinsStealthMappin",
    "HasHackingStatusEffect",
    (StealthMappin_HasHackingStatusEffect x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct StealthMappin_HasHackingStatusEffect(
    game.map.pins.StealthMappin self
);

bool GetObjectMarkersEnabled() RTTI

Generated hook

re.Hooks.Place(
    "gamemappinsStealthMappin",
    "GetObjectMarkersEnabled",
    (StealthMappin_GetObjectMarkersEnabled x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct StealthMappin_GetObjectMarkersEnabled(
    game.map.pins.StealthMappin self
);

bool GetNameplateEnabled() RTTI

Generated hook

re.Hooks.Place(
    "gamemappinsStealthMappin",
    "GetNameplateEnabled",
    (StealthMappin_GetNameplateEnabled x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct StealthMappin_GetNameplateEnabled(
    game.map.pins.StealthMappin self
);

bool HideUIDetection() RTTI

Generated hook

re.Hooks.Place(
    "gamemappinsStealthMappin",
    "HideUIDetection",
    (StealthMappin_HideUIDetection x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct StealthMappin_HideUIDetection(
    game.map.pins.StealthMappin self
);

bool IsPlayerInterestingFromSecuritySystemPOV() RTTI

Generated hook

re.Hooks.Place(
    "gamemappinsStealthMappin",
    "IsPlayerInterestingFromSecuritySystemPOV",
    (StealthMappin_IsPlayerInterestingFromSecuritySystemPOV x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct StealthMappin_IsPlayerInterestingFromSecuritySystemPOV(
    game.map.pins.StealthMappin self
);

void UpdateObjectMarkerThreshold(float threshold) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamemappinsStealthMappin",
    "UpdateObjectMarkerThreshold",
    (StealthMappin_UpdateObjectMarkerThreshold x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct StealthMappin_UpdateObjectMarkerThreshold(
    game.map.pins.StealthMappin self,
    float threshold
);

void UpdateCombatToAwareThreshold(float threshold) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamemappinsStealthMappin",
    "UpdateCombatToAwareThreshold",
    (StealthMappin_UpdateCombatToAwareThreshold x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct StealthMappin_UpdateCombatToAwareThreshold(
    game.map.pins.StealthMappin self,
    float threshold
);

void UpdateSenseConeAvailable(bool available) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamemappinsStealthMappin",
    "UpdateSenseConeAvailable",
    (StealthMappin_UpdateSenseConeAvailable x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct StealthMappin_UpdateSenseConeAvailable(
    game.map.pins.StealthMappin self,
    bool available
);

bool IsPlayerWanted() RTTI

Generated hook

re.Hooks.Place(
    "gamemappinsStealthMappin",
    "IsPlayerWanted",
    (StealthMappin_IsPlayerWanted x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct StealthMappin_IsPlayerWanted(
    game.map.pins.StealthMappin self
);

bool IsInCombat() RTTI

Generated hook

re.Hooks.Place(
    "gamemappinsStealthMappin",
    "IsInCombat",
    (StealthMappin_IsInCombat x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct StealthMappin_IsInCombat(
    game.map.pins.StealthMappin self
);

bool HasLootProcessed() RTTI

Generated hook

re.Hooks.Place(
    "gamemappinsStealthMappin",
    "HasLootProcessed",
    (StealthMappin_HasLootProcessed x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct StealthMappin_HasLootProcessed(
    game.map.pins.StealthMappin self
);

bool GetSkipIntroAnim() RTTI

Generated hook

re.Hooks.Place(
    "gamemappinsStealthMappin",
    "GetSkipIntroAnim",
    (StealthMappin_GetSkipIntroAnim x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct StealthMappin_GetSkipIntroAnim(
    game.map.pins.StealthMappin self
);