class

PocketRadio

13 properties
28 functions

Properties

Property	Type	Offset
`player`	`WeakHandle<PlayerPuppet>`	`0x0`	scripted
`station`	`int`	`0x10`	scripted
`selectedStation`	`int`	`0x14`	scripted
`toggledStation`	`int`	`0x18`	scripted
`restrictions`	`List`	`0x20`	scripted
`isConditionRestricted`	`bool`	`0x30`	scripted
`isUnlockDelayRestricted`	`bool`	`0x31`	scripted
`isRestrictionOverwritten`	`bool`	`0x32`	scripted
`isOn`	`bool`	`0x33`	scripted
`questContentLockListener`	`PocketRadioQuestContentLockListener?`	`0x38`	scripted
`radioPressTime`	`float`	`0x48`	scripted
`isInMetro`	`bool`	`0x4C`	scripted
`settings`	`RadioportSettingsListener?`	`0x50`	scripted

Functions

void InitializeRestrictions() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PocketRadio",
    "InitializeRestrictions;",
    (PocketRadio_InitializeRestrictions x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PocketRadio_InitializeRestrictions(
    PocketRadio self
);

void OnPlayerAttach(PlayerPuppet player) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PocketRadio",
    "OnPlayerAttach;PlayerPuppet",
    (PocketRadio_OnPlayerAttach x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PocketRadio_OnPlayerAttach(
    PocketRadio self,
    PlayerPuppet? player
);

void OnPlayerDetach(PlayerPuppet player) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PocketRadio",
    "OnPlayerDetach;PlayerPuppet",
    (PocketRadio_OnPlayerDetach x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PocketRadio_OnPlayerDetach(
    PocketRadio self,
    PlayerPuppet? player
);

bool IsMutedByVolumeSetting() RTTI

Generated hook

re.Hooks.Place(
    "PocketRadio",
    "IsMutedByVolumeSetting;",
    (PocketRadio_IsMutedByVolumeSetting x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PocketRadio_IsMutedByVolumeSetting(
    PocketRadio self
);

bool ShouldIgnoreEvents() RTTI

Generated hook

re.Hooks.Place(
    "PocketRadio",
    "ShouldIgnoreEvents;",
    (PocketRadio_ShouldIgnoreEvents x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PocketRadio_ShouldIgnoreEvents(
    PocketRadio self
);

void TurnOn(bool playSFX) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PocketRadio",
    "TurnOn;Bool",
    (PocketRadio_TurnOn x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PocketRadio_TurnOn(
    PocketRadio self,
    bool playSFX
);

void TurnOff(bool playSFX) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PocketRadio",
    "TurnOff;Bool",
    (PocketRadio_TurnOff x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PocketRadio_TurnOff(
    PocketRadio self,
    bool playSFX
);

void UpdateConditionRestricted() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PocketRadio",
    "UpdateConditionRestricted;",
    (PocketRadio_UpdateConditionRestricted x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PocketRadio_UpdateConditionRestricted(
    PocketRadio self
);

bool IsRestricted() RTTI

Generated hook

re.Hooks.Place(
    "PocketRadio",
    "IsRestricted;",
    (PocketRadio_IsRestricted x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PocketRadio_IsRestricted(
    PocketRadio self
);

bool IsRestrictionOverwritten() RTTI

Generated hook

re.Hooks.Place(
    "PocketRadio",
    "IsRestrictionOverwritten;",
    (PocketRadio_IsRestrictionOverwritten x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PocketRadio_IsRestrictionOverwritten(
    PocketRadio self
);

void HandleRestrictionStateChanged() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PocketRadio",
    "HandleRestrictionStateChanged;",
    (PocketRadio_HandleRestrictionStateChanged x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PocketRadio_HandleRestrictionStateChanged(
    PocketRadio self
);

void HandleRestriction(PocketRadioRestrictions restriction, bool restricted) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PocketRadio",
    "HandleRestriction;PocketRadioRestrictionsBool",
    (PocketRadio_HandleRestriction x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PocketRadio_HandleRestriction(
    PocketRadio self,
    PocketRadioRestrictions restriction,
    bool restricted
);

void HandleStatusEffectApplied(CName[] gameplayTags, CName tag, PocketRadioRestrictions type) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PocketRadio",
    "HandleStatusEffectApplied;script_ref<array<CName>>CNamePocketRadioRestrictions",
    (PocketRadio_HandleStatusEffectApplied x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PocketRadio_HandleStatusEffectApplied(
    PocketRadio self,
    CName[] gameplayTags,
    CName tag,
    PocketRadioRestrictions type
);

void OnStatusEffectApplied(game.events.ApplyStatusEffectEvent evt, CName[] gameplayTags) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PocketRadio",
    "OnStatusEffectApplied;ApplyStatusEffectEventscript_ref<array<CName>>",
    (PocketRadio_OnStatusEffectApplied x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PocketRadio_OnStatusEffectApplied(
    PocketRadio self,
    game.events.ApplyStatusEffectEvent? evt,
    CName[] gameplayTags
);

void HandleStatusEffectRemoved(CName[] gameplayTags, CName tag, PocketRadioRestrictions type) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PocketRadio",
    "HandleStatusEffectRemoved;script_ref<array<CName>>CNamePocketRadioRestrictions",
    (PocketRadio_HandleStatusEffectRemoved x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PocketRadio_HandleStatusEffectRemoved(
    PocketRadio self,
    CName[] gameplayTags,
    CName tag,
    PocketRadioRestrictions type
);

void OnStatusEffectRemoved(game.events.RemoveStatusEffect evt, CName[] gameplayTags) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PocketRadio",
    "OnStatusEffectRemoved;RemoveStatusEffectscript_ref<array<CName>>",
    (PocketRadio_OnStatusEffectRemoved x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PocketRadio_OnStatusEffectRemoved(
    PocketRadio self,
    game.events.RemoveStatusEffect? evt,
    CName[] gameplayTags
);

void HandleVehicleRadioEvent(VehicleRadioEvent evt) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PocketRadio",
    "HandleVehicleRadioEvent;VehicleRadioEvent",
    (PocketRadio_HandleVehicleRadioEvent x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PocketRadio_HandleVehicleRadioEvent(
    PocketRadio self,
    VehicleRadioEvent? evt
);

void HandleRadioToggleEvent(RadioToggleEvent evt) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PocketRadio",
    "HandleRadioToggleEvent;RadioToggleEvent",
    (PocketRadio_HandleRadioToggleEvent x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PocketRadio_HandleRadioToggleEvent(
    PocketRadio self,
    RadioToggleEvent? evt
);

void HandleVehicleRadioStationChanged(vehicle.RadioStationChanged evt) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PocketRadio",
    "HandleVehicleRadioStationChanged;VehicleRadioStationChanged",
    (PocketRadio_HandleVehicleRadioStationChanged x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PocketRadio_HandleVehicleRadioStationChanged(
    PocketRadio self,
    vehicle.RadioStationChanged? evt
);

void HandleVehicleMounted(WeakHandle<vehicle.BaseObject> vehicle) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PocketRadio",
    "HandleVehicleMounted;VehicleObject",
    (PocketRadio_HandleVehicleMounted x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PocketRadio_HandleVehicleMounted(
    PocketRadio self,
    WeakHandle<vehicle.BaseObject> vehicle
);

void HandleVehicleUnmounted(WeakHandle<vehicle.BaseObject> vehicle) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PocketRadio",
    "HandleVehicleUnmounted;VehicleObject",
    (PocketRadio_HandleVehicleUnmounted x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PocketRadio_HandleVehicleUnmounted(
    PocketRadio self,
    WeakHandle<vehicle.BaseObject> vehicle
);

void HandleInputAction(game.input.ScriptListenerAction action) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PocketRadio",
    "HandleInputAction;ListenerAction",
    (PocketRadio_HandleInputAction x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PocketRadio_HandleInputAction(
    PocketRadio self,
    game.input.ScriptListenerAction action
);

void HandleUIUpdate() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "PocketRadio",
    "HandleUIUpdate;",
    (PocketRadio_HandleUIUpdate x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct PocketRadio_HandleUIUpdate(
    PocketRadio self
);

bool IsActive() RTTI

Generated hook

re.Hooks.Place(
    "PocketRadio",
    "IsActive;",
    (PocketRadio_IsActive x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PocketRadio_IsActive(
    PocketRadio self
);

int GetStation() RTTI

Generated hook

re.Hooks.Place(
    "PocketRadio",
    "GetStation;",
    (PocketRadio_GetStation x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PocketRadio_GetStation(
    PocketRadio self
);

CName GetStationName() RTTI

Generated hook

re.Hooks.Place(
    "PocketRadio",
    "GetStationName;",
    (PocketRadio_GetStationName x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.CName>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PocketRadio_GetStationName(
    PocketRadio self
);

CName GetTrackName() RTTI

Generated hook

re.Hooks.Place(
    "PocketRadio",
    "GetTrackName;",
    (PocketRadio_GetTrackName x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.CName>();
    }
);

[Msgpack.Gen]
public readonly partial record struct PocketRadio_GetTrackName(
    PocketRadio self
);

static bool ConfigEnablePocketRadio() staticRTTI global

Generated hook

re.Hooks.Place(
    "PocketRadio",
    "PocketRadio::ConfigEnablePocketRadio;",
    (PocketRadio_ConfigEnablePocketRadio x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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