class game

TimeSystem

game.TimeSystem

0 properties
22 functions

Extends game.ITimeSystem game.IReplicatedGameSystem game.IGameSystem IScriptable ISerializable

Properties

None.

Functions

void SetTimeDilation(CName reason, float dilation, float? duration, CName? easeInCurve, CName? easeOutCurve, tick.ScriptTimeDilationListener? listener)

RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameTimeSystem",
    "SetTimeDilation",
    (TimeSystem_SetTimeDilation x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TimeSystem_SetTimeDilation(
    game.TimeSystem self,
    CName reason,
    float dilation,
    float? duration,
    CName? easeInCurve,
    CName? easeOutCurve,
    tick.ScriptTimeDilationListener? listener
);

void UnsetTimeDilation(CName reason, CName? easeOutCurve) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameTimeSystem",
    "UnsetTimeDilation",
    (TimeSystem_UnsetTimeDilation x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TimeSystem_UnsetTimeDilation(
    game.TimeSystem self,
    CName reason,
    CName? easeOutCurve
);

void SetIgnoreTimeDilationOnLocalPlayerZero(bool ignore) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameTimeSystem",
    "SetIgnoreTimeDilationOnLocalPlayerZero",
    (TimeSystem_SetIgnoreTimeDilationOnLocalPlayerZero x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TimeSystem_SetIgnoreTimeDilationOnLocalPlayerZero(
    game.TimeSystem self,
    bool ignore
);

void RestorePreviousIgnoreTimeDilationOnLocalPlayerZero() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameTimeSystem",
    "RestorePreviousIgnoreTimeDilationOnLocalPlayerZero",
    (TimeSystem_RestorePreviousIgnoreTimeDilationOnLocalPlayerZero x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TimeSystem_RestorePreviousIgnoreTimeDilationOnLocalPlayerZero(
    game.TimeSystem self
);

void SetTimeDilationOnLocalPlayerZero(CName reason, float dilation, float? duration, CName? easeInCurve, CName? easeOutCurve)

RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameTimeSystem",
    "SetTimeDilationOnLocalPlayerZero",
    (TimeSystem_SetTimeDilationOnLocalPlayerZero x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TimeSystem_SetTimeDilationOnLocalPlayerZero(
    game.TimeSystem self,
    CName reason,
    float dilation,
    float? duration,
    CName? easeInCurve,
    CName? easeOutCurve
);

void UnsetTimeDilationOnLocalPlayerZero(CName reason, CName? easeOutCurve) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameTimeSystem",
    "UnsetTimeDilationOnLocalPlayerZero",
    (TimeSystem_UnsetTimeDilationOnLocalPlayerZero x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TimeSystem_UnsetTimeDilationOnLocalPlayerZero(
    game.TimeSystem self,
    CName reason,
    CName? easeOutCurve
);

bool IsTimeDilationActive(CName? reason) RTTI

Generated hook

re.Hooks.Place(
    "gameTimeSystem",
    "IsTimeDilationActive",
    (TimeSystem_IsTimeDilationActive x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TimeSystem_IsTimeDilationActive(
    game.TimeSystem self,
    CName? reason
);

float GetActiveTimeDilation(CName? reason, bool? ignoreCurves) RTTI

Generated hook

re.Hooks.Place(
    "gameTimeSystem",
    "GetActiveTimeDilation",
    (TimeSystem_GetActiveTimeDilation x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TimeSystem_GetActiveTimeDilation(
    game.TimeSystem self,
    CName? reason,
    bool? ignoreCurves
);

void SetGameTimeBySeconds(int seconds) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameTimeSystem",
    "SetGameTimeBySeconds",
    (TimeSystem_SetGameTimeBySeconds x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TimeSystem_SetGameTimeBySeconds(
    game.TimeSystem self,
    int seconds
);

void SetGameTimeByHMS(int hours, int minutes, int seconds, CName? reason) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameTimeSystem",
    "SetGameTimeByHMS",
    (TimeSystem_SetGameTimeByHMS x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TimeSystem_SetGameTimeByHMS(
    game.TimeSystem self,
    int hours,
    int minutes,
    int seconds,
    CName? reason
);

void SetGameTime() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameTimeSystem",
    "SetGameTime",
    (TimeSystem_SetGameTime x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TimeSystem_SetGameTime(
    game.TimeSystem self
);

GameTime GetGameTime() RTTI

Generated hook

re.Hooks.Place(
    "gameTimeSystem",
    "GetGameTime",
    (TimeSystem_GetGameTime x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.GameTime>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TimeSystem_GetGameTime(
    game.TimeSystem self
);

EngineTime GetSimTime() RTTI

Generated hook

re.Hooks.Place(
    "gameTimeSystem",
    "GetSimTime",
    (TimeSystem_GetSimTime x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.EngineTime>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TimeSystem_GetSimTime(
    game.TimeSystem self
);

float GetGameTimeStamp() RTTI

Generated hook

re.Hooks.Place(
    "gameTimeSystem",
    "GetGameTimeStamp",
    (TimeSystem_GetGameTimeStamp x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TimeSystem_GetGameTimeStamp(
    game.TimeSystem self
);

void SetPausedState(bool paused, CName source) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameTimeSystem",
    "SetPausedState",
    (TimeSystem_SetPausedState x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TimeSystem_SetPausedState(
    game.TimeSystem self,
    bool paused,
    CName source
);

bool IsPausedState() RTTI

Generated hook

re.Hooks.Place(
    "gameTimeSystem",
    "IsPausedState",
    (TimeSystem_IsPausedState x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TimeSystem_IsPausedState(
    game.TimeSystem self
);

uint RegisterListener(WeakHandle<ent.Entity> entity, red.Event eventToDelay, GameTime expectedTime, int repeat, bool? sendOldNoifications)

RTTI

Generated hook

re.Hooks.Place(
    "gameTimeSystem",
    "RegisterListener",
    (TimeSystem_RegisterListener x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Uint>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TimeSystem_RegisterListener(
    game.TimeSystem self,
    WeakHandle<ent.Entity> entity,
    red.Event? eventToDelay,
    GameTime expectedTime,
    int repeat,
    bool? sendOldNoifications
);

uint RegisterDelayedListener(WeakHandle<ent.Entity> entity, red.Event eventToDelay, GameTime delay, int repeat, bool? sendOldNoifications)

RTTI

Generated hook

re.Hooks.Place(
    "gameTimeSystem",
    "RegisterDelayedListener",
    (TimeSystem_RegisterDelayedListener x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Uint>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TimeSystem_RegisterDelayedListener(
    game.TimeSystem self,
    WeakHandle<ent.Entity> entity,
    red.Event? eventToDelay,
    GameTime delay,
    int repeat,
    bool? sendOldNoifications
);

uint RegisterIntervalListener(WeakHandle<ent.Entity> entity, red.Event eventToDelay, GameTime expectedHour, GameTime timeout, int? repeat)

RTTI

Generated hook

re.Hooks.Place(
    "gameTimeSystem",
    "RegisterIntervalListener",
    (TimeSystem_RegisterIntervalListener x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Uint>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TimeSystem_RegisterIntervalListener(
    game.TimeSystem self,
    WeakHandle<ent.Entity> entity,
    red.Event? eventToDelay,
    GameTime expectedHour,
    GameTime timeout,
    int? repeat
);

void UnregisterListener(uint listenerID) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameTimeSystem",
    "UnregisterListener",
    (TimeSystem_UnregisterListener x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TimeSystem_UnregisterListener(
    game.TimeSystem self,
    uint listenerID
);

GameTime RealTimeSecondsToGameTime(float seconds) RTTI

Generated hook

re.Hooks.Place(
    "gameTimeSystem",
    "RealTimeSecondsToGameTime",
    (TimeSystem_RealTimeSecondsToGameTime x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.GameTime>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TimeSystem_RealTimeSecondsToGameTime(
    game.TimeSystem self,
    float seconds
);

uint RegisterScriptableSystemIntervalListener(CName systemName, game.ScriptableSystemRequest requestToDelay, GameTime expectedHour, GameTime timeout, int? repeat)

RTTI

Generated hook

re.Hooks.Place(
    "gameTimeSystem",
    "RegisterScriptableSystemIntervalListener",
    (TimeSystem_RegisterScriptableSystemIntervalListener x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Uint>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TimeSystem_RegisterScriptableSystemIntervalListener(
    game.TimeSystem self,
    CName systemName,
    game.ScriptableSystemRequest? requestToDelay,
    GameTime expectedHour,
    GameTime timeout,
    int? repeat
);