class

CityLightSystem

10 properties
43 functions

Extends game.ScriptableSystem game.IScriptableSystem IScriptable ISerializable

Properties

Property	Type	Offset
`timeSystemCallbacks`	`TimetableCallbackData?[]`	`0x0`	scripted
`fuses`	`FuseData[]`	`0x10`	scripted
`state`	`ECLSForcedState`	`0x20`	scripted
`forcedStateSource`	`CName`	`0x28`	scripted
`forcedStatesStack`	`ForcedStateData[]`	`0x30`	scripted
`weatherListener`	`CLSWeatherListener?`	`0x40`	scripted
`turnOffLisenerID`	`CName`	`0x50`	scripted
`turnOnLisenerID`	`CName`	`0x58`	scripted
`resetLisenerID`	`CName`	`0x60`	scripted
`weatherCallbackId`	`uint`	`0x68`	scripted

Functions

void OnAttach() overrideRTTI

Generated hook

re.Hooks.PlaceVoid(
    "CityLightSystem",
    "OnAttach;",
    (CityLightSystem_OnAttach x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct CityLightSystem_OnAttach(
    CityLightSystem self
);

void OnDetach() overrideRTTI

Generated hook

re.Hooks.PlaceVoid(
    "CityLightSystem",
    "OnDetach;",
    (CityLightSystem_OnDetach x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct CityLightSystem_OnDetach(
    CityLightSystem self
);

void OnRestored(int saveVersion, int gameVersion) overrideRTTI

Generated hook

re.Hooks.PlaceVoid(
    "CityLightSystem",
    "OnRestored;Int32Int32",
    (CityLightSystem_OnRestored x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct CityLightSystem_OnRestored(
    CityLightSystem self,
    int saveVersion,
    int gameVersion
);

void OnTimeTableCallbackRequest(TimeTableCallbackRequest request) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "CityLightSystem",
    "OnTimeTableCallbackRequest;TimeTableCallbackRequest",
    (CityLightSystem_OnTimeTableCallbackRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct CityLightSystem_OnTimeTableCallbackRequest(
    CityLightSystem self,
    TimeTableCallbackRequest? request
);

void OnRegisterTimetableRequest(RegisterTimetableRequest request) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "CityLightSystem",
    "OnRegisterTimetableRequest;RegisterTimetableRequest",
    (CityLightSystem_OnRegisterTimetableRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct CityLightSystem_OnRegisterTimetableRequest(
    CityLightSystem self,
    RegisterTimetableRequest? request
);

void OnForceCLSStateRequest(ForceCLSStateRequest request) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "CityLightSystem",
    "OnForceCLSStateRequest;ForceCLSStateRequest",
    (CityLightSystem_OnForceCLSStateRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct CityLightSystem_OnForceCLSStateRequest(
    CityLightSystem self,
    ForceCLSStateRequest? request
);

void UpdateCLSForcedState() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "CityLightSystem",
    "UpdateCLSForcedState;",
    (CityLightSystem_UpdateCLSForcedState x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct CityLightSystem_UpdateCLSForcedState(
    CityLightSystem self
);

bool AddForcedStateRequest(ECLSForcedState state, CName sourceName, EPriority priority, bool savable) RTTI

Generated hook

re.Hooks.Place(
    "CityLightSystem",
    "AddForcedStateRequest;ECLSForcedStateCNameEPriorityBool",
    (CityLightSystem_AddForcedStateRequest x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct CityLightSystem_AddForcedStateRequest(
    CityLightSystem self,
    ECLSForcedState state,
    CName sourceName,
    EPriority priority,
    bool savable
);

bool RemoveForcedStateRequestForSource(CName sourceName) RTTI

Generated hook

re.Hooks.Place(
    "CityLightSystem",
    "RemoveForcedStateRequestForSource;CName",
    (CityLightSystem_RemoveForcedStateRequestForSource x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct CityLightSystem_RemoveForcedStateRequestForSource(
    CityLightSystem self,
    CName sourceName
);

void ResolveForcedStatesStackOnLoad() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "CityLightSystem",
    "ResolveForcedStatesStackOnLoad;",
    (CityLightSystem_ResolveForcedStatesStackOnLoad x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct CityLightSystem_ResolveForcedStatesStackOnLoad(
    CityLightSystem self
);

void EvaluateForcedStatesStack() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "CityLightSystem",
    "EvaluateForcedStatesStack;",
    (CityLightSystem_EvaluateForcedStatesStack x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct CityLightSystem_EvaluateForcedStatesStack(
    CityLightSystem self
);

bool IsForcedRequestSavable(ForcedStateData data) RTTI

Generated hook

re.Hooks.Place(
    "CityLightSystem",
    "IsForcedRequestSavable;ForcedStateData",
    (CityLightSystem_IsForcedRequestSavable x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct CityLightSystem_IsForcedRequestSavable(
    CityLightSystem self,
    ForcedStateData data
);

void RegisterTimetableCallback(TimetableCallbackData callbackData) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "CityLightSystem",
    "RegisterTimetableCallback;TimetableCallbackData",
    (CityLightSystem_RegisterTimetableCallback x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct CityLightSystem_RegisterTimetableCallback(
    CityLightSystem self,
    TimetableCallbackData? callbackData
);

void NotifyRecipientsOnRegistration(TimetableCallbackData callbackData) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "CityLightSystem",
    "NotifyRecipientsOnRegistration;TimetableCallbackData",
    (CityLightSystem_NotifyRecipientsOnRegistration x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct CityLightSystem_NotifyRecipientsOnRegistration(
    CityLightSystem self,
    TimetableCallbackData? callbackData
);

void NotifyRecipients(TimetableCallbackData callbackData) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "CityLightSystem",
    "NotifyRecipients;TimetableCallbackData",
    (CityLightSystem_NotifyRecipients x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct CityLightSystem_NotifyRecipients(
    CityLightSystem self,
    TimetableCallbackData? callbackData
);

void SendNotificationToRecipients(RecipientData[] recipients, GameTime time) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "CityLightSystem",
    "SendNotificationToRecipients;script_ref<array<RecipientData>>GameTime",
    (CityLightSystem_SendNotificationToRecipients x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct CityLightSystem_SendNotificationToRecipients(
    CityLightSystem self,
    RecipientData[] recipients,
    GameTime time
);

void SendNotificationByRequest(RecipientData[] recipients, GameTime time) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "CityLightSystem",
    "SendNotificationByRequest;script_ref<array<RecipientData>>GameTime",
    (CityLightSystem_SendNotificationByRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct CityLightSystem_SendNotificationByRequest(
    CityLightSystem self,
    RecipientData[] recipients,
    GameTime time
);

void OnNotifyRecipientsrequest(NotifyRecipientsRequest request) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "CityLightSystem",
    "OnNotifyRecipientsrequest;NotifyRecipientsRequest",
    (CityLightSystem_OnNotifyRecipientsrequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct CityLightSystem_OnNotifyRecipientsrequest(
    CityLightSystem self,
    NotifyRecipientsRequest? request
);

void SendDeviceTimetableEvent(RecipientData data) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "CityLightSystem",
    "SendDeviceTimetableEvent;RecipientData",
    (CityLightSystem_SendDeviceTimetableEvent x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct CityLightSystem_SendDeviceTimetableEvent(
    CityLightSystem self,
    RecipientData data
);

void SendForceStateDeviceTimetableEvent(FuseData fuse, ECLSForcedState state) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "CityLightSystem",
    "SendForceStateDeviceTimetableEvent;script_ref<FuseData>ECLSForcedState",
    (CityLightSystem_SendForceStateDeviceTimetableEvent x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct CityLightSystem_SendForceStateDeviceTimetableEvent(
    CityLightSystem self,
    FuseData fuse,
    ECLSForcedState state
);

void AddTimeTableCallbacks(PSOwnerData requesterData, SDeviceTimetableEntry[] timeTable, int? lights) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "CityLightSystem",
    "AddTimeTableCallbacks;PSOwnerDatascript_ref<array<SDeviceTimetableEntry>>Int32",
    (CityLightSystem_AddTimeTableCallbacks x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct CityLightSystem_AddTimeTableCallbacks(
    CityLightSystem self,
    PSOwnerData requesterData,
    SDeviceTimetableEntry[] timeTable,
    int? lights
);

TimetableCallbackData? GetTimeTableCallback(SSimpleGameTime time) RTTI

Generated hook

re.Hooks.Place(
    "CityLightSystem",
    "GetTimeTableCallback;SSimpleGameTime",
    (CityLightSystem_GetTimeTableCallback x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.TimetableCallbackData>();
    }
);

[Msgpack.Gen]
public readonly partial record struct CityLightSystem_GetTimeTableCallback(
    CityLightSystem self,
    SSimpleGameTime time
);

int AddFuse(PSOwnerData requesterData, SDeviceTimetableEntry[] timeTable, int? lights) RTTI

Generated hook

re.Hooks.Place(
    "CityLightSystem",
    "AddFuse;PSOwnerDatascript_ref<array<SDeviceTimetableEntry>>Int32",
    (CityLightSystem_AddFuse x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct CityLightSystem_AddFuse(
    CityLightSystem self,
    PSOwnerData requesterData,
    SDeviceTimetableEntry[] timeTable,
    int? lights
);

bool HasFuse(PSOwnerData requesterData, out int id) RTTI

Generated hook

re.Hooks.Place(
    "CityLightSystem",
    "HasFuse;PSOwnerDataInt32",
    (CityLightSystem_HasFuse x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct CityLightSystem_HasFuse(
    CityLightSystem self,
    PSOwnerData requesterData,
    int id
);

int GetFuseID(PSOwnerData requesterData) RTTI

Generated hook

re.Hooks.Place(
    "CityLightSystem",
    "GetFuseID;PSOwnerData",
    (CityLightSystem_GetFuseID x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct CityLightSystem_GetFuseID(
    CityLightSystem self,
    PSOwnerData requesterData
);

int GetFuseID(game.PersistentID id) RTTI

Generated hook

re.Hooks.Place(
    "CityLightSystem",
    "GetFuseID;PersistentID",
    (CityLightSystem_GetFuseID2 x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct CityLightSystem_GetFuseID2(
    CityLightSystem self,
    game.PersistentID id
);

bool GetFuse(int fuseID, FuseData fuseData) RTTI

Generated hook

re.Hooks.Place(
    "CityLightSystem",
    "GetFuse;Int32script_ref<FuseData>",
    (CityLightSystem_GetFuse x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct CityLightSystem_GetFuse(
    CityLightSystem self,
    int fuseID,
    FuseData fuseData
);

bool IsTimeTheSame(SSimpleGameTime time1, SSimpleGameTime time2) RTTI

Generated hook

re.Hooks.Place(
    "CityLightSystem",
    "IsTimeTheSame;SSimpleGameTimeSSimpleGameTime",
    (CityLightSystem_IsTimeTheSame x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct CityLightSystem_IsTimeTheSame(
    CityLightSystem self,
    SSimpleGameTime time1,
    SSimpleGameTime time2
);

GameTime GetCurrentTime() RTTI

Generated hook

re.Hooks.Place(
    "CityLightSystem",
    "GetCurrentTime;",
    (CityLightSystem_GetCurrentTime x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.GameTime>();
    }
);

[Msgpack.Gen]
public readonly partial record struct CityLightSystem_GetCurrentTime(
    CityLightSystem self
);

bool ShouldNotifyRecipient(RecipientData recipient, GameTime callbackTime) RTTI

Generated hook

re.Hooks.Place(
    "CityLightSystem",
    "ShouldNotifyRecipient;RecipientDataGameTime",
    (CityLightSystem_ShouldNotifyRecipient x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct CityLightSystem_ShouldNotifyRecipient(
    CityLightSystem self,
    RecipientData recipient,
    GameTime callbackTime
);

bool GetActiveTimeTableEntry(FuseData fuse, out SDeviceTimetableEntry entry) RTTI

Generated hook

re.Hooks.Place(
    "CityLightSystem",
    "GetActiveTimeTableEntry;script_ref<FuseData>SDeviceTimetableEntry",
    (CityLightSystem_GetActiveTimeTableEntry x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct CityLightSystem_GetActiveTimeTableEntry(
    CityLightSystem self,
    FuseData fuse,
    SDeviceTimetableEntry entry
);

int GetActiveTimeTableEntryID(FuseData fuse) RTTI

Generated hook

re.Hooks.Place(
    "CityLightSystem",
    "GetActiveTimeTableEntryID;script_ref<FuseData>",
    (CityLightSystem_GetActiveTimeTableEntryID x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct CityLightSystem_GetActiveTimeTableEntryID(
    CityLightSystem self,
    FuseData fuse
);

EDeviceStatus GetFuseStateByID(game.PersistentID id) RTTI

Generated hook

re.Hooks.Place(
    "CityLightSystem",
    "GetFuseStateByID;PersistentID",
    (CityLightSystem_GetFuseStateByID x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.EDeviceStatus>();
    }
);

[Msgpack.Gen]
public readonly partial record struct CityLightSystem_GetFuseStateByID(
    CityLightSystem self,
    game.PersistentID id
);

ECLSForcedState GetState() RTTI

Generated hook

re.Hooks.Place(
    "CityLightSystem",
    "GetState;",
    (CityLightSystem_GetState x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.ECLSForcedState>();
    }
);

[Msgpack.Gen]
public readonly partial record struct CityLightSystem_GetState(
    CityLightSystem self
);

int GetFusesCount() RTTI

Generated hook

re.Hooks.Place(
    "CityLightSystem",
    "GetFusesCount;",
    (CityLightSystem_GetFusesCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct CityLightSystem_GetFusesCount(
    CityLightSystem self
);

int GetLightsCount() RTTI

Generated hook

re.Hooks.Place(
    "CityLightSystem",
    "GetLightsCount;",
    (CityLightSystem_GetLightsCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct CityLightSystem_GetLightsCount(
    CityLightSystem self
);

TimetableCallbackData?[] GetCallbacks() RTTI

void OnDebugButtonClicked(game.SDOClickedRequest request) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "CityLightSystem",
    "OnDebugButtonClicked;SDOClickedRequest",
    (CityLightSystem_OnDebugButtonClicked x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct CityLightSystem_OnDebugButtonClicked(
    CityLightSystem self,
    game.SDOClickedRequest? request
);

void UninitializeDebugButtons() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "CityLightSystem",
    "UninitializeDebugButtons;",
    (CityLightSystem_UninitializeDebugButtons x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct CityLightSystem_UninitializeDebugButtons(
    CityLightSystem self
);

void InitializeDebugButtons() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "CityLightSystem",
    "InitializeDebugButtons;",
    (CityLightSystem_InitializeDebugButtons x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct CityLightSystem_InitializeDebugButtons(
    CityLightSystem self
);

void ShowDebug_state() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "CityLightSystem",
    "ShowDebug_state;",
    (CityLightSystem_ShowDebug_state x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct CityLightSystem_ShowDebug_state(
    CityLightSystem self
);

void ShowDebug_fuses(FuseData[] fuses) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "CityLightSystem",
    "ShowDebug_fuses;script_ref<array<FuseData>>",
    (CityLightSystem_ShowDebug_fuses x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct CityLightSystem_ShowDebug_fuses(
    CityLightSystem self,
    FuseData[] fuses
);

static int GetMaxNotificationsPerFrame() staticRTTI global

Generated hook

re.Hooks.Place(
    "CityLightSystem",
    "CityLightSystem::GetMaxNotificationsPerFrame;",
    (CityLightSystem_GetMaxNotificationsPerFrame x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

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