class game.map.pins

MappinSystem

game.map.pins.MappinSystem

0 properties
29 functions

Extends game.map.pins.IMappinSystem game.IReplicatedGameSystem game.IGameSystem IScriptable ISerializable

Properties

None.

Functions

void ChangeMappinVariant(game.NewMappinID id, game.data.MappinVariant newVariant) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamemappinsMappinSystem",
    "ChangeMappinVariant",
    (MappinSystem_ChangeMappinVariant x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct MappinSystem_ChangeMappinVariant(
    game.map.pins.MappinSystem self,
    game.NewMappinID id,
    game.data.MappinVariant newVariant
);

void SetMappinActive(game.NewMappinID id, bool active) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamemappinsMappinSystem",
    "SetMappinActive",
    (MappinSystem_SetMappinActive x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct MappinSystem_SetMappinActive(
    game.map.pins.MappinSystem self,
    game.NewMappinID id,
    bool active
);

void SetMappinDebugCaption(game.NewMappinID id, string caption) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamemappinsMappinSystem",
    "SetMappinDebugCaption",
    (MappinSystem_SetMappinDebugCaption x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct MappinSystem_SetMappinDebugCaption(
    game.map.pins.MappinSystem self,
    game.NewMappinID id,
    string caption
);

void SetMappinPosition(game.NewMappinID id, Vector4 position) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamemappinsMappinSystem",
    "SetMappinPosition",
    (MappinSystem_SetMappinPosition x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct MappinSystem_SetMappinPosition(
    game.map.pins.MappinSystem self,
    game.NewMappinID id,
    Vector4 position
);

void SetMappinScriptData(game.NewMappinID id, game.map.pins.MappinScriptData scriptData) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamemappinsMappinSystem",
    "SetMappinScriptData",
    (MappinSystem_SetMappinScriptData x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct MappinSystem_SetMappinScriptData(
    game.map.pins.MappinSystem self,
    game.NewMappinID id,
    game.map.pins.MappinScriptData? scriptData
);

game.NewMappinID RegisterMappin(game.map.pins.MappinData data, Vector4 position) RTTI

Generated hook

re.Hooks.Place(
    "gamemappinsMappinSystem",
    "RegisterMappin",
    (MappinSystem_RegisterMappin x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.NewMappinID>();
    }
);

[Msgpack.Gen]
public readonly partial record struct MappinSystem_RegisterMappin(
    game.map.pins.MappinSystem self,
    game.map.pins.MappinData data,
    Vector4 position
);

game.NewMappinID RegisterMappinWithObject(game.map.pins.MappinData data, WeakHandle<game.Object> objectt, CName? slotName, Vector3? offset)

RTTI

Generated hook

re.Hooks.Place(
    "gamemappinsMappinSystem",
    "RegisterMappinWithObject",
    (MappinSystem_RegisterMappinWithObject x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.NewMappinID>();
    }
);

[Msgpack.Gen]
public readonly partial record struct MappinSystem_RegisterMappinWithObject(
    game.map.pins.MappinSystem self,
    game.map.pins.MappinData data,
    WeakHandle<game.Object> objectt,
    CName? slotName,
    Vector3? offset
);

game.NewMappinID RegisterGrenadeMappin(game.map.pins.MappinData data, WeakHandle<game.Object> grenadeObject) RTTI

Generated hook

re.Hooks.Place(
    "gamemappinsMappinSystem",
    "RegisterGrenadeMappin",
    (MappinSystem_RegisterGrenadeMappin x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.NewMappinID>();
    }
);

[Msgpack.Gen]
public readonly partial record struct MappinSystem_RegisterGrenadeMappin(
    game.map.pins.MappinSystem self,
    game.map.pins.MappinData data,
    WeakHandle<game.Object> grenadeObject
);

game.NewMappinID RegisterFastTravelMappin(game.map.pins.MappinData data, game.FastTravelPointData fastTravelData) RTTI

Generated hook

re.Hooks.Place(
    "gamemappinsMappinSystem",
    "RegisterFastTravelMappin",
    (MappinSystem_RegisterFastTravelMappin x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.NewMappinID>();
    }
);

[Msgpack.Gen]
public readonly partial record struct MappinSystem_RegisterFastTravelMappin(
    game.map.pins.MappinSystem self,
    game.map.pins.MappinData data,
    game.FastTravelPointData? fastTravelData
);

game.NewMappinID RegisterRemotePlayerMappin(game.map.pins.MappinData data, WeakHandle<game.Object> playerObject) RTTI

Generated hook

re.Hooks.Place(
    "gamemappinsMappinSystem",
    "RegisterRemotePlayerMappin",
    (MappinSystem_RegisterRemotePlayerMappin x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.NewMappinID>();
    }
);

[Msgpack.Gen]
public readonly partial record struct MappinSystem_RegisterRemotePlayerMappin(
    game.map.pins.MappinSystem self,
    game.map.pins.MappinData data,
    WeakHandle<game.Object> playerObject
);

game.NewMappinID RegisterVehicleMappin(game.map.pins.MappinData data, WeakHandle<game.Object> objectt, CName? slotName, Vector3? offset)

RTTI

Generated hook

re.Hooks.Place(
    "gamemappinsMappinSystem",
    "RegisterVehicleMappin",
    (MappinSystem_RegisterVehicleMappin x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.NewMappinID>();
    }
);

[Msgpack.Gen]
public readonly partial record struct MappinSystem_RegisterVehicleMappin(
    game.map.pins.MappinSystem self,
    game.map.pins.MappinData data,
    WeakHandle<game.Object> objectt,
    CName? slotName,
    Vector3? offset
);

void UnregisterMappin(game.NewMappinID id) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct MappinSystem_UnregisterMappin(
    game.map.pins.MappinSystem self,
    game.NewMappinID id
);

void GetMappinEntries(game.map.pins.MappinTargetType targetType, out game.map.pins.MappinEntry[] mappins) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamemappinsMappinSystem",
    "GetMappinEntries",
    (MappinSystem_GetMappinEntries x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct MappinSystem_GetMappinEntries(
    game.map.pins.MappinSystem self,
    game.map.pins.MappinTargetType targetType,
    game.map.pins.MappinEntry[] mappins
);

void GetMappins(game.map.pins.MappinTargetType targetType, out game.map.pins.IMappin[] mappins) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamemappinsMappinSystem",
    "GetMappins",
    (MappinSystem_GetMappins x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct MappinSystem_GetMappins(
    game.map.pins.MappinSystem self,
    game.map.pins.MappinTargetType targetType,
    game.map.pins.IMappin[] mappins
);

game.map.pins.IMappin? GetMappin(game.NewMappinID mappinId) RTTI

Generated hook

re.Hooks.Place(
    "gamemappinsMappinSystem",
    "GetMappin",
    (MappinSystem_GetMappin x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.map.pins.IMappin>();
    }
);

[Msgpack.Gen]
public readonly partial record struct MappinSystem_GetMappin(
    game.map.pins.MappinSystem self,
    game.NewMappinID mappinId
);

void OnAreaEntered(ent.AreaEnteredEvent evt) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamemappinsMappinSystem",
    "OnAreaEntered",
    (MappinSystem_OnAreaEntered x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct MappinSystem_OnAreaEntered(
    game.map.pins.MappinSystem self,
    ent.AreaEnteredEvent? evt
);

void OnAreaExited(WeakHandle<game.Object> obj, ent.EntityID triggerId) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamemappinsMappinSystem",
    "OnAreaExited",
    (MappinSystem_OnAreaExited x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct MappinSystem_OnAreaExited(
    game.map.pins.MappinSystem self,
    WeakHandle<game.Object> obj,
    ent.EntityID triggerId
);

void OnAreaTypeChanged(ent.EntityID entityID, CName areaType) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamemappinsMappinSystem",
    "OnAreaTypeChanged",
    (MappinSystem_OnAreaTypeChanged x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct MappinSystem_OnAreaTypeChanged(
    game.map.pins.MappinSystem self,
    ent.EntityID entityID,
    CName areaType
);

void UpdateCurrentLocationName(string locationName, bool isNewLocation) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamemappinsMappinSystem",
    "UpdateCurrentLocationName",
    (MappinSystem_UpdateCurrentLocationName x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct MappinSystem_UpdateCurrentLocationName(
    game.map.pins.MappinSystem self,
    string locationName,
    bool isNewLocation
);

bool GetPointOfInterestMappinSavedState(uint hash, out ushort mappinPhase, out ushort mappinVariant, out bool active) RTTI

Generated hook

re.Hooks.Place(
    "gamemappinsMappinSystem",
    "GetPointOfInterestMappinSavedState",
    (MappinSystem_GetPointOfInterestMappinSavedState x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct MappinSystem_GetPointOfInterestMappinSavedState(
    game.map.pins.MappinSystem self,
    uint hash,
    ushort mappinPhase,
    ushort mappinVariant,
    bool active
);

bool GetQuestMappinPositionsByObjective(uint objectiveHash, out Vector3[] positions) RTTI

Generated hook

re.Hooks.Place(
    "gamemappinsMappinSystem",
    "GetQuestMappinPositionsByObjective",
    (MappinSystem_GetQuestMappinPositionsByObjective x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct MappinSystem_GetQuestMappinPositionsByObjective(
    game.map.pins.MappinSystem self,
    uint objectiveHash,
    List<Vector3> positions
);

WeakHandle<game.map.pins.IMappin> GetMappinFromObjective(WeakHandle<game.JournalEntry> phaseEntry, WeakHandle<game.JournalEntry> objectiveEntry) RTTI
WeakHandle<game.map.pins.IMappin> GetMappinFromQuest(WeakHandle<game.JournalEntry> questEntry) RTTI

bool GetQuestMappinPosition(uint mappinHash, out Vector3 position) RTTI

Generated hook

re.Hooks.Place(
    "gamemappinsMappinSystem",
    "GetQuestMappinPosition",
    (MappinSystem_GetQuestMappinPosition x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct MappinSystem_GetQuestMappinPosition(
    game.map.pins.MappinSystem self,
    uint mappinHash,
    Vector3 position
);

void SetMappinTrackingAlternative(game.NewMappinID mappinID, game.NewMappinID targetMappinID) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamemappinsMappinSystem",
    "SetMappinTrackingAlternative",
    (MappinSystem_SetMappinTrackingAlternative x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct MappinSystem_SetMappinTrackingAlternative(
    game.map.pins.MappinSystem self,
    game.NewMappinID mappinID,
    game.NewMappinID targetMappinID
);

void DebugDiscoverAllPoiMappins() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamemappinsMappinSystem",
    "DebugDiscoverAllPoiMappins",
    (MappinSystem_DebugDiscoverAllPoiMappins x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

game.NewMappinID GetManuallyTrackedMappinID() RTTI

Generated hook

re.Hooks.Place(
    "gamemappinsMappinSystem",
    "GetManuallyTrackedMappinID",
    (MappinSystem_GetManuallyTrackedMappinID x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.NewMappinID>();
    }
);

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

game.NewMappinID GetDelamainTrackedMappinID() RTTI

Generated hook

re.Hooks.Place(
    "gamemappinsMappinSystem",
    "GetDelamainTrackedMappinID",
    (MappinSystem_GetDelamainTrackedMappinID x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.NewMappinID>();
    }
);

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

void UntrackMappin() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamemappinsMappinSystem",
    "UntrackMappin",
    (MappinSystem_UntrackMappin x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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