class game.stateMachine

GameScriptInterface

game.stateMachine.GameScriptInterface

0 properties
149 functions

Extends game.stateMachine.ScriptInterface IScriptable ISerializable

Properties

None.

Functions

bool Overlap(Vector4 primitiveDimension, Vector4 position, EulerAngles rotation, CName queryPreset, out physics.TraceResult result)

RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "Overlap",
    (GameScriptInterface_Overlap x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_Overlap(
    game.stateMachine.GameScriptInterface self,
    Vector4 primitiveDimension,
    Vector4 position,
    EulerAngles rotation,
    CName queryPreset,
    physics.TraceResult result
);

bool OverlapWithASingleGroup(Vector4 primitiveDimension, Vector4 position, EulerAngles rotation, CName queryGroup, out physics.TraceResult result)

RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "OverlapWithASingleGroup",
    (GameScriptInterface_OverlapWithASingleGroup x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_OverlapWithASingleGroup(
    game.stateMachine.GameScriptInterface self,
    Vector4 primitiveDimension,
    Vector4 position,
    EulerAngles rotation,
    CName queryGroup,
    physics.TraceResult result
);

physics.TraceResult[] OverlapMultipleHits(Vector4 primitiveDimension, Vector4 position, EulerAngles rotation, CName queryPreset) RTTI

bool LocomotionOverlapTest(Vector4 primitiveDimension, Vector4 position, EulerAngles rotation, out physics.TraceResult result)

RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "LocomotionOverlapTest",
    (GameScriptInterface_LocomotionOverlapTest x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_LocomotionOverlapTest(
    game.stateMachine.GameScriptInterface self,
    Vector4 primitiveDimension,
    Vector4 position,
    EulerAngles rotation,
    physics.TraceResult result
);

bool LocomotionOverlapTestExcludeEntity(Vector4 primitiveDimension, Vector4 position, EulerAngles rotation, ent.Entity excludedEntity, out physics.TraceResult result)

RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "LocomotionOverlapTestExcludeEntity",
    (GameScriptInterface_LocomotionOverlapTestExcludeEntity x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_LocomotionOverlapTestExcludeEntity(
    game.stateMachine.GameScriptInterface self,
    Vector4 primitiveDimension,
    Vector4 position,
    EulerAngles rotation,
    ent.Entity? excludedEntity,
    physics.TraceResult result
);

physics.TraceResult Raycast(Vector4 start, Vector4 end, CName queryPreset) RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "Raycast",
    (GameScriptInterface_Raycast x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.physics.TraceResult>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_Raycast(
    game.stateMachine.GameScriptInterface self,
    Vector4 start,
    Vector4 end,
    CName queryPreset
);

physics.TraceResult RaycastWithASingleGroup(Vector4 start, Vector4 end, CName queryGroup) RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "RaycastWithASingleGroup",
    (GameScriptInterface_RaycastWithASingleGroup x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.physics.TraceResult>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_RaycastWithASingleGroup(
    game.stateMachine.GameScriptInterface self,
    Vector4 start,
    Vector4 end,
    CName queryGroup
);

physics.TraceResult[] RaycastMultipleHits(Vector4 start, Vector4 end, CName queryPreset) RTTI

physics.TraceResult LocomotionRaycastTest(Vector4 start, Vector4 end) RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "LocomotionRaycastTest",
    (GameScriptInterface_LocomotionRaycastTest x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.physics.TraceResult>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_LocomotionRaycastTest(
    game.stateMachine.GameScriptInterface self,
    Vector4 start,
    Vector4 end
);

bool Sweep(Vector4 primitiveDimension, Vector4 position, EulerAngles rotation, Vector4 direction, float distance, CName queryPreset, bool? assumeInitialPositionClear, out physics.TraceResult result)

RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "Sweep",
    (GameScriptInterface_Sweep x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_Sweep(
    game.stateMachine.GameScriptInterface self,
    Vector4 primitiveDimension,
    Vector4 position,
    EulerAngles rotation,
    Vector4 direction,
    float distance,
    CName queryPreset,
    bool? assumeInitialPositionClear,
    physics.TraceResult result
);

bool SweepWithASingleGroup(Vector4 primitiveDimension, Vector4 position, EulerAngles rotation, Vector4 direction, float distance, CName queryGroup, bool? assumeInitialPositionClear, out physics.TraceResult result)

RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "SweepWithASingleGroup",
    (GameScriptInterface_SweepWithASingleGroup x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_SweepWithASingleGroup(
    game.stateMachine.GameScriptInterface self,
    Vector4 primitiveDimension,
    Vector4 position,
    EulerAngles rotation,
    Vector4 direction,
    float distance,
    CName queryGroup,
    bool? assumeInitialPositionClear,
    physics.TraceResult result
);

physics.TraceResult[] SweepMultipleHits(Vector4 primitiveDimension, Vector4 position, EulerAngles rotation, Vector4 direction, float distance, CName queryPreset) RTTI

bool LocomotionSweepTest(Vector4 primitiveDimension, Vector4 position, EulerAngles rotation, Vector4 direction, float distance, bool? assumeInitialPositionClear, out physics.TraceResult result)

RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "LocomotionSweepTest",
    (GameScriptInterface_LocomotionSweepTest x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_LocomotionSweepTest(
    game.stateMachine.GameScriptInterface self,
    Vector4 primitiveDimension,
    Vector4 position,
    EulerAngles rotation,
    Vector4 direction,
    float distance,
    bool? assumeInitialPositionClear,
    physics.TraceResult result
);

physics.ControllerHit[] GetCollisionReport() RTTI

bool IsOnGround() RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "IsOnGround",
    (GameScriptInterface_IsOnGround x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_IsOnGround(
    game.stateMachine.GameScriptInterface self
);

bool IsOnMovingPlatform() RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "IsOnMovingPlatform",
    (GameScriptInterface_IsOnMovingPlatform x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_IsOnMovingPlatform(
    game.stateMachine.GameScriptInterface self
);

bool CanCapsuleFit(float capsuleHeight, float capsuleRadius) RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "CanCapsuleFit",
    (GameScriptInterface_CanCapsuleFit x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_CanCapsuleFit(
    game.stateMachine.GameScriptInterface self,
    float capsuleHeight,
    float capsuleRadius
);

move.SecureFootingResult HasSecureFooting() RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "HasSecureFooting",
    (GameScriptInterface_HasSecureFooting x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.move.SecureFootingResult>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_HasSecureFooting(
    game.stateMachine.GameScriptInterface self
);

bool IsFalling() RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "IsFalling",
    (GameScriptInterface_IsFalling x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_IsFalling(
    game.stateMachine.GameScriptInterface self
);

float GetActionPrevStateTime(CName actionName) RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "GetActionPrevStateTime",
    (GameScriptInterface_GetActionPrevStateTime x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_GetActionPrevStateTime(
    game.stateMachine.GameScriptInterface self,
    CName actionName
);

float GetActionStateTime(CName actionName) RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "GetActionStateTime",
    (GameScriptInterface_GetActionStateTime x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_GetActionStateTime(
    game.stateMachine.GameScriptInterface self,
    CName actionName
);

float GetActionValue(CName actionName) RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "GetActionValue",
    (GameScriptInterface_GetActionValue x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_GetActionValue(
    game.stateMachine.GameScriptInterface self,
    CName actionName
);

bool IsActionJustPressed(CName actionName) RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "IsActionJustPressed",
    (GameScriptInterface_IsActionJustPressed x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_IsActionJustPressed(
    game.stateMachine.GameScriptInterface self,
    CName actionName
);

bool IsActionJustReleased(CName actionName) RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "IsActionJustReleased",
    (GameScriptInterface_IsActionJustReleased x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_IsActionJustReleased(
    game.stateMachine.GameScriptInterface self,
    CName actionName
);

bool IsActionJustHeld(CName actionName) RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "IsActionJustHeld",
    (GameScriptInterface_IsActionJustHeld x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_IsActionJustHeld(
    game.stateMachine.GameScriptInterface self,
    CName actionName
);

bool IsActionHeld(CName actionName) RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "IsActionHeld",
    (GameScriptInterface_IsActionHeld x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_IsActionHeld(
    game.stateMachine.GameScriptInterface self,
    CName actionName
);

bool IsActionJustTapped(CName actionName) RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "IsActionJustTapped",
    (GameScriptInterface_IsActionJustTapped x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_IsActionJustTapped(
    game.stateMachine.GameScriptInterface self,
    CName actionName
);

bool IsAxisChangeAction(CName actionName) RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "IsAxisChangeAction",
    (GameScriptInterface_IsAxisChangeAction x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_IsAxisChangeAction(
    game.stateMachine.GameScriptInterface self,
    CName actionName
);

bool IsRelativeChangeAction(CName actionName) RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "IsRelativeChangeAction",
    (GameScriptInterface_IsRelativeChangeAction x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_IsRelativeChangeAction(
    game.stateMachine.GameScriptInterface self,
    CName actionName
);

uint GetActionPressCount(CName actionName) RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "GetActionPressCount",
    (GameScriptInterface_GetActionPressCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Uint>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_GetActionPressCount(
    game.stateMachine.GameScriptInterface self,
    CName actionName
);

bool SetComponentVisibility(CName actionName, bool visibility) RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "SetComponentVisibility",
    (GameScriptInterface_SetComponentVisibility x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_SetComponentVisibility(
    game.stateMachine.GameScriptInterface self,
    CName actionName,
    bool visibility
);

bool ActivateCameraSetting(CName settingId) RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "ActivateCameraSetting",
    (GameScriptInterface_ActivateCameraSetting x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_ActivateCameraSetting(
    game.stateMachine.GameScriptInterface self,
    CName settingId
);

game.Object? GetObjectFromComponent(ent.IPlacedComponent targetingComponent) RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "GetObjectFromComponent",
    (GameScriptInterface_GetObjectFromComponent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.GameObject>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_GetObjectFromComponent(
    game.stateMachine.GameScriptInterface self,
    ent.IPlacedComponent? targetingComponent
);

Vector4 TransformInvPointFromObject(Vector4 point, game.Object? objectt) RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "TransformInvPointFromObject",
    (GameScriptInterface_TransformInvPointFromObject x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Vector4>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_TransformInvPointFromObject(
    game.stateMachine.GameScriptInterface self,
    Vector4 point,
    game.Object? objectt
);

bool SetCameraTimeDilationCurve(CName curveName) RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "SetCameraTimeDilationCurve",
    (GameScriptInterface_SetCameraTimeDilationCurve x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_SetCameraTimeDilationCurve(
    game.stateMachine.GameScriptInterface self,
    CName curveName
);

Transform GetCameraWorldTransform() RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "GetCameraWorldTransform",
    (GameScriptInterface_GetCameraWorldTransform x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Transform>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_GetCameraWorldTransform(
    game.stateMachine.GameScriptInterface self
);

bool TEMP_WeaponStopFiring() RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "TEMP_WeaponStopFiring",
    (GameScriptInterface_TEMP_WeaponStopFiring x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_TEMP_WeaponStopFiring(
    game.stateMachine.GameScriptInterface self
);

bool IsTriggerModeActive(game.data.TriggerMode triggerMode) RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "IsTriggerModeActive",
    (GameScriptInterface_IsTriggerModeActive x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_IsTriggerModeActive(
    game.stateMachine.GameScriptInterface self,
    game.data.TriggerMode triggerMode
);

game.MeleeAttackData? GetMeleeAttackData(WeakHandle<game.data.Attack_Melee_Record> attackRecord, float staminaCost, float attackSpeed)

RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "GetMeleeAttackData",
    (GameScriptInterface_GetMeleeAttackData x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.MeleeAttackData>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_GetMeleeAttackData(
    game.stateMachine.GameScriptInterface self,
    WeakHandle<game.data.Attack_Melee_Record> attackRecord,
    float staminaCost,
    float attackSpeed
);

bool SetAnimationParameterInt(CName key, int value) RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "SetAnimationParameterInt",
    (GameScriptInterface_SetAnimationParameterInt x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_SetAnimationParameterInt(
    game.stateMachine.GameScriptInterface self,
    CName key,
    int value
);

bool SetAnimationParameterFloat(CName key, float value) RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "SetAnimationParameterFloat",
    (GameScriptInterface_SetAnimationParameterFloat x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_SetAnimationParameterFloat(
    game.stateMachine.GameScriptInterface self,
    CName key,
    float value
);

bool SetAnimationParameterBool(CName key, bool value) RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "SetAnimationParameterBool",
    (GameScriptInterface_SetAnimationParameterBool x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_SetAnimationParameterBool(
    game.stateMachine.GameScriptInterface self,
    CName key,
    bool value
);

bool SetAnimationParameterVector(CName key, Vector4 value) RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "SetAnimationParameterVector",
    (GameScriptInterface_SetAnimationParameterVector x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_SetAnimationParameterVector(
    game.stateMachine.GameScriptInterface self,
    CName key,
    Vector4 value
);

bool SetAnimationParameterQuaternion(CName key, Quaternion value) RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "SetAnimationParameterQuaternion",
    (GameScriptInterface_SetAnimationParameterQuaternion x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_SetAnimationParameterQuaternion(
    game.stateMachine.GameScriptInterface self,
    CName key,
    Quaternion value
);

bool SetAnimationParameterFeature(CName key, anim.AnimFeature value, game.Object? owner) RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "SetAnimationParameterFeature",
    (GameScriptInterface_SetAnimationParameterFeature x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_SetAnimationParameterFeature(
    game.stateMachine.GameScriptInterface self,
    CName key,
    anim.AnimFeature? value,
    game.Object? owner
);

bool PushAnimationEvent(CName eventName) RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "PushAnimationEvent",
    (GameScriptInterface_PushAnimationEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_PushAnimationEvent(
    game.stateMachine.GameScriptInterface self,
    CName eventName
);

bool IsSceneAnimationActive() RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "IsSceneAnimationActive",
    (GameScriptInterface_IsSceneAnimationActive x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_IsSceneAnimationActive(
    game.stateMachine.GameScriptInterface self
);

bool IsMoveInputConsiderable() RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "IsMoveInputConsiderable",
    (GameScriptInterface_IsMoveInputConsiderable x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_IsMoveInputConsiderable(
    game.stateMachine.GameScriptInterface self
);

float GetInputHeading() RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "GetInputHeading",
    (GameScriptInterface_GetInputHeading x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_GetInputHeading(
    game.stateMachine.GameScriptInterface self
);

float GetOwnerStateVectorParameterFloat(physics.StateValue parameterType) RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "GetOwnerStateVectorParameterFloat",
    (GameScriptInterface_GetOwnerStateVectorParameterFloat x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_GetOwnerStateVectorParameterFloat(
    game.stateMachine.GameScriptInterface self,
    physics.StateValue parameterType
);

Vector4 GetOwnerStateVectorParameterVector(physics.StateValue parameterType) RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "GetOwnerStateVectorParameterVector",
    (GameScriptInterface_GetOwnerStateVectorParameterVector x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Vector4>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_GetOwnerStateVectorParameterVector(
    game.stateMachine.GameScriptInterface self,
    physics.StateValue parameterType
);

Vector4 GetOwnerMovingDirection() RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "GetOwnerMovingDirection",
    (GameScriptInterface_GetOwnerMovingDirection x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Vector4>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_GetOwnerMovingDirection(
    game.stateMachine.GameScriptInterface self
);

Vector4 GetOwnerForward() RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "GetOwnerForward",
    (GameScriptInterface_GetOwnerForward x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Vector4>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_GetOwnerForward(
    game.stateMachine.GameScriptInterface self
);

Transform GetOwnerTransform() RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "GetOwnerTransform",
    (GameScriptInterface_GetOwnerTransform x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Transform>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_GetOwnerTransform(
    game.stateMachine.GameScriptInterface self
);

bool MeetsPrerequisites(TDBID prereqName) RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "MeetsPrerequisites",
    (GameScriptInterface_MeetsPrerequisites x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_MeetsPrerequisites(
    game.stateMachine.GameScriptInterface self,
    TDBID prereqName
);

game.ItemID GetItemIdInSlot(TDBID slotName) RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "GetItemIdInSlot",
    (GameScriptInterface_GetItemIdInSlot x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.ItemID>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_GetItemIdInSlot(
    game.stateMachine.GameScriptInterface self,
    TDBID slotName
);

bool CanEquipItem(game.stateMachine.StateContextScript stateContext) RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "CanEquipItem",
    (GameScriptInterface_CanEquipItem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_CanEquipItem(
    game.stateMachine.GameScriptInterface self,
    game.stateMachine.StateContextScript? stateContext
);

bool IsMountedToObject(game.Object? objectt) RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "IsMountedToObject",
    (GameScriptInterface_IsMountedToObject x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_IsMountedToObject(
    game.stateMachine.GameScriptInterface self,
    game.Object? objectt
);

bool IsPassengerInVehicle(game.Object? child, game.Object? parent) RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "IsPassengerInVehicle",
    (GameScriptInterface_IsPassengerInVehicle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_IsPassengerInVehicle(
    game.stateMachine.GameScriptInterface self,
    game.Object? child,
    game.Object? parent
);

bool IsDriverInVehicle(game.Object? child, game.Object? parent) RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "IsDriverInVehicle",
    (GameScriptInterface_IsDriverInVehicle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_IsDriverInVehicle(
    game.stateMachine.GameScriptInterface self,
    game.Object? child,
    game.Object? parent
);

game.mounting.MountingInfo GetMountingInfo(game.Object child) RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "GetMountingInfo",
    (GameScriptInterface_GetMountingInfo x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.mounting.MountingInfo>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_GetMountingInfo(
    game.stateMachine.GameScriptInterface self,
    game.Object? child
);

game.MountingSlotRole GetRoleForSlot(game.mounting.MountingSlotId slot, game.Object parent, CName? occupantSlotComponentName)

RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "GetRoleForSlot",
    (GameScriptInterface_GetRoleForSlot x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.MountingSlotRole>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_GetRoleForSlot(
    game.stateMachine.GameScriptInterface self,
    game.mounting.MountingSlotId slot,
    game.Object? parent,
    CName? occupantSlotComponentName
);

bool GetWaterLevel(Vector4 puppetPosition, Vector4 referencePosition, out float waterLevel) RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "GetWaterLevel",
    (GameScriptInterface_GetWaterLevel x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_GetWaterLevel(
    game.stateMachine.GameScriptInterface self,
    Vector4 puppetPosition,
    Vector4 referencePosition,
    float waterLevel
);

bool IsEntityInCombat(ent.EntityID? objectId) RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "IsEntityInCombat",
    (GameScriptInterface_IsEntityInCombat x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_IsEntityInCombat(
    game.stateMachine.GameScriptInterface self,
    ent.EntityID? objectId
);

bool CanEnterInteraction(game.stateMachine.StateContextScript stateContext) RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "CanEnterInteraction",
    (GameScriptInterface_CanEnterInteraction x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_CanEnterInteraction(
    game.stateMachine.GameScriptInterface self,
    game.stateMachine.StateContextScript? stateContext
);

ScriptGameInstance GetGame() RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "GetGame",
    (GameScriptInterface_GetGame x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.ScriptGameInstance>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_GetGame(
    game.stateMachine.GameScriptInterface self
);

bool IsPlayerInBraindance() RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "IsPlayerInBraindance",
    (GameScriptInterface_IsPlayerInBraindance x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_IsPlayerInBraindance(
    game.stateMachine.GameScriptInterface self
);

bool HasStatFlag(game.data.StatType flag) RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "HasStatFlag",
    (GameScriptInterface_HasStatFlag x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_HasStatFlag(
    game.stateMachine.GameScriptInterface self,
    game.data.StatType flag
);

bool HasStatFlagOwner(game.data.StatType flag, game.Object owner) RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "HasStatFlagOwner",
    (GameScriptInterface_HasStatFlagOwner x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_HasStatFlagOwner(
    game.stateMachine.GameScriptInterface self,
    game.data.StatType flag,
    game.Object? owner
);

game.ScriptableSystem? GetScriptableSystem(CName name) RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "GetScriptableSystem",
    (GameScriptInterface_GetScriptableSystem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.ScriptableSystem>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_GetScriptableSystem(
    game.stateMachine.GameScriptInterface self,
    CName name
);

game.ActivityLogSystem? GetActivityLogSystem() RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "GetActivityLogSystem",
    (GameScriptInterface_GetActivityLogSystem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.ActivityLogSystem>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_GetActivityLogSystem(
    game.stateMachine.GameScriptInterface self
);

game.CAttitudeManager? GetAttitudeSystem() RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "GetAttitudeSystem",
    (GameScriptInterface_GetAttitudeSystem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.CAttitudeManager>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_GetAttitudeSystem(
    game.stateMachine.GameScriptInterface self
);

game.GameAudioSystem? GetAudioSystem() RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "GetAudioSystem",
    (GameScriptInterface_GetAudioSystem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.GameAudioSystem>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_GetAudioSystem(
    game.stateMachine.GameScriptInterface self
);

game.BlackboardSystem? GetBlackboardSystem() RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "GetBlackboardSystem",
    (GameScriptInterface_GetBlackboardSystem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.BlackboardSystem>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_GetBlackboardSystem(
    game.stateMachine.GameScriptInterface self
);

game.CameraSystem? GetCameraSystem() RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "GetCameraSystem",
    (GameScriptInterface_GetCameraSystem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.CameraSystem>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_GetCameraSystem(
    game.stateMachine.GameScriptInterface self
);

game.CommunitySystem? GetCommunitySystem() RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "GetCommunitySystem",
    (GameScriptInterface_GetCommunitySystem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.CommunitySystem>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_GetCommunitySystem(
    game.stateMachine.GameScriptInterface self
);

game.CompanionSystem? GetCompanionSystem() RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "GetCompanionSystem",
    (GameScriptInterface_GetCompanionSystem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.CompanionSystem>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_GetCompanionSystem(
    game.stateMachine.GameScriptInterface self
);

game.PreventionSpawnSystem? GetPreventionSpawnSystem() RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "GetPreventionSpawnSystem",
    (GameScriptInterface_GetPreventionSpawnSystem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.PreventionSpawnSystem>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_GetPreventionSpawnSystem(
    game.stateMachine.GameScriptInterface self
);

game.DynamicSpawnSystem? GetDynamicSpawnSystem() RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "GetDynamicSpawnSystem",
    (GameScriptInterface_GetDynamicSpawnSystem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.DynamicSpawnSystem>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_GetDynamicSpawnSystem(
    game.stateMachine.GameScriptInterface self
);

game.PoliceRadioSystem? GetPoliceRadioSystem() RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "GetPoliceRadioSystem",
    (GameScriptInterface_GetPoliceRadioSystem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.PoliceRadioSystem>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_GetPoliceRadioSystem(
    game.stateMachine.GameScriptInterface self
);

game.ui.GamepadLightController? GetGamepadLightController() RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "GetGamepadLightController",
    (GameScriptInterface_GetGamepadLightController x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.ui.GamepadLightController>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_GetGamepadLightController(
    game.stateMachine.GameScriptInterface self
);

AISmartCoverManager? GetCoverManager() RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "GetCoverManager",
    (GameScriptInterface_GetCoverManager x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.AISmartCoverManager>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_GetCoverManager(
    game.stateMachine.GameScriptInterface self
);

game.DebugVisualizerSystem? GetDebugVisualizerSystem() RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "GetDebugVisualizerSystem",
    (GameScriptInterface_GetDebugVisualizerSystem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.DebugVisualizerSystem>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_GetDebugVisualizerSystem(
    game.stateMachine.GameScriptInterface self
);

game.IDebugDrawHistorySystem? GetDebugDrawHistorySystem() RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "GetDebugDrawHistorySystem",
    (GameScriptInterface_GetDebugDrawHistorySystem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.GameIDebugDrawHistorySystem>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_GetDebugDrawHistorySystem(
    game.stateMachine.GameScriptInterface self
);

game.DelaySystem? GetDelaySystem() RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "GetDelaySystem",
    (GameScriptInterface_GetDelaySystem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.DelaySystem>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_GetDelaySystem(
    game.stateMachine.GameScriptInterface self
);

game.DeviceSystem? GetDeviceSystem() RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "GetDeviceSystem",
    (GameScriptInterface_GetDeviceSystem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.DeviceSystem>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_GetDeviceSystem(
    game.stateMachine.GameScriptInterface self
);

game.EntitySpawnerEventsBroadcasterImpl? GetEntitySpawnerEventsBroadcaster() RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "GetEntitySpawnerEventsBroadcaster",
    (GameScriptInterface_GetEntitySpawnerEventsBroadcaster x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.EntitySpawnerEventsBroadcasterImpl>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_GetEntitySpawnerEventsBroadcaster(
    game.stateMachine.GameScriptInterface self
);

game.EffectSystem? GetGameEffectSystem() RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "GetGameEffectSystem",
    (GameScriptInterface_GetGameEffectSystem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.EffectSystem>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_GetGameEffectSystem(
    game.stateMachine.GameScriptInterface self
);

game.SpatialQueriesSystem? GetSpatialQueriesSystem() RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "GetSpatialQueriesSystem",
    (GameScriptInterface_GetSpatialQueriesSystem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.SpatialQueriesSystem>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_GetSpatialQueriesSystem(
    game.stateMachine.GameScriptInterface self
);

game.LootManager? GetLootManager() RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "GetLootManager",
    (GameScriptInterface_GetLootManager x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.LootManager>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_GetLootManager(
    game.stateMachine.GameScriptInterface self
);

game.LocationManager? GetLocationManager() RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "GetLocationManager",
    (GameScriptInterface_GetLocationManager x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.LocationManager>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_GetLocationManager(
    game.stateMachine.GameScriptInterface self
);

game.map.pins.MappinSystem? GetMappinSystem() RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "GetMappinSystem",
    (GameScriptInterface_GetMappinSystem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.map.pins.MappinSystem>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_GetMappinSystem(
    game.stateMachine.GameScriptInterface self
);

game.ObjectPoolSystem? GetObjectPoolSystem() RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "GetObjectPoolSystem",
    (GameScriptInterface_GetObjectPoolSystem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.ObjectPoolSystem>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_GetObjectPoolSystem(
    game.stateMachine.GameScriptInterface self
);

game.PersistencySystem? GetPersistencySystem() RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "GetPersistencySystem",
    (GameScriptInterface_GetPersistencySystem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.PersistencySystem>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_GetPersistencySystem(
    game.stateMachine.GameScriptInterface self
);

cp.PlayerSystem? GetPlayerSystem() RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "GetPlayerSystem",
    (GameScriptInterface_GetPlayerSystem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.cp.CpPlayerSystem>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_GetPlayerSystem(
    game.stateMachine.GameScriptInterface self
);

game.PrereqManager? GetPrereqManager() RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "GetPrereqManager",
    (GameScriptInterface_GetPrereqManager x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.PrereqManager>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_GetPrereqManager(
    game.stateMachine.GameScriptInterface self
);

quest.QuestsSystem? GetQuestsSystem() RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "GetQuestsSystem",
    (GameScriptInterface_GetQuestsSystem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.quest.QuestsSystem>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_GetQuestsSystem(
    game.stateMachine.GameScriptInterface self
);

scn.ISceneSystem? GetSceneSystem() RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "GetSceneSystem",
    (GameScriptInterface_GetSceneSystem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.scn.ScnISceneSystem>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_GetSceneSystem(
    game.stateMachine.GameScriptInterface self
);

game.ScriptableSystemsContainer? GetScriptableSystemsContainer() RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "GetScriptableSystemsContainer",
    (GameScriptInterface_GetScriptableSystemsContainer x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.ScriptableSystemsContainer>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_GetScriptableSystemsContainer(
    game.stateMachine.GameScriptInterface self
);

game.StatPoolsSystem? GetStatPoolsSystem() RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "GetStatPoolsSystem",
    (GameScriptInterface_GetStatPoolsSystem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.StatPoolsSystem>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_GetStatPoolsSystem(
    game.stateMachine.GameScriptInterface self
);

game.StatsSystem? GetStatsSystem() RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "GetStatsSystem",
    (GameScriptInterface_GetStatsSystem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.StatsSystem>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_GetStatsSystem(
    game.stateMachine.GameScriptInterface self
);

game.StatsDataSystem? GetStatsDataSystem() RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "GetStatsDataSystem",
    (GameScriptInterface_GetStatsDataSystem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.StatsDataSystem>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_GetStatsDataSystem(
    game.stateMachine.GameScriptInterface self
);

game.StatusEffectSystem? GetStatusEffectSystem() RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "GetStatusEffectSystem",
    (GameScriptInterface_GetStatusEffectSystem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.StatusEffectSystem>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_GetStatusEffectSystem(
    game.stateMachine.GameScriptInterface self
);

game.GodModeSystem? GetGodModeSystem() RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "GetGodModeSystem",
    (GameScriptInterface_GetGodModeSystem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.GodModeSystem>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_GetGodModeSystem(
    game.stateMachine.GameScriptInterface self
);

game.EffectorSystem? GetEffectorSystem() RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "GetEffectorSystem",
    (GameScriptInterface_GetEffectorSystem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.EffectorSystem>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_GetEffectorSystem(
    game.stateMachine.GameScriptInterface self
);

game.DamageSystem? GetDamageSystem() RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "GetDamageSystem",
    (GameScriptInterface_GetDamageSystem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.DamageSystem>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_GetDamageSystem(
    game.stateMachine.GameScriptInterface self
);

game.targeting.TargetingSystem? GetTargetingSystem() RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "GetTargetingSystem",
    (GameScriptInterface_GetTargetingSystem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.targeting.TargetingSystem>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_GetTargetingSystem(
    game.stateMachine.GameScriptInterface self
);

game.TimeSystem? GetTimeSystem() RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "GetTimeSystem",
    (GameScriptInterface_GetTimeSystem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.TimeSystem>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_GetTimeSystem(
    game.stateMachine.GameScriptInterface self
);

game.TransactionSystem? GetTransactionSystem() RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "GetTransactionSystem",
    (GameScriptInterface_GetTransactionSystem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.TransactionSystem>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_GetTransactionSystem(
    game.stateMachine.GameScriptInterface self
);

game.VisionModeSystem? GetVisionModeSystem() RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "GetVisionModeSystem",
    (GameScriptInterface_GetVisionModeSystem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.VisionModeSystem>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_GetVisionModeSystem(
    game.stateMachine.GameScriptInterface self
);

game.VehicleSystem? GetVehicleSystem() RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "GetVehicleSystem",
    (GameScriptInterface_GetVehicleSystem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.VehicleSystem>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_GetVehicleSystem(
    game.stateMachine.GameScriptInterface self
);

game.WorkspotGameSystem? GetWorkspotSystem() RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "GetWorkspotSystem",
    (GameScriptInterface_GetWorkspotSystem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.WorkspotGameSystem>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_GetWorkspotSystem(
    game.stateMachine.GameScriptInterface self
);

game.InventoryManager? GetInventoryManager() RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "GetInventoryManager",
    (GameScriptInterface_GetInventoryManager x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.InventoryManager>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_GetInventoryManager(
    game.stateMachine.GameScriptInterface self
);

game.TeleportationFacility? GetTeleportationFacility() RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "GetTeleportationFacility",
    (GameScriptInterface_GetTeleportationFacility x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.TeleportationFacility>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_GetTeleportationFacility(
    game.stateMachine.GameScriptInterface self
);

game.influence.System? GetInfluenceMapSystem() RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "GetInfluenceMapSystem",
    (GameScriptInterface_GetInfluenceMapSystem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.influence.GameInfluenceSystem>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_GetInfluenceMapSystem(
    game.stateMachine.GameScriptInterface self
);

game.FxSystem? GetFxSystem() RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "GetFxSystem",
    (GameScriptInterface_GetFxSystem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.FxSystem>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_GetFxSystem(
    game.stateMachine.GameScriptInterface self
);

AIGuardAreaManager? GetRestrictMovementAreaManager() RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "GetRestrictMovementAreaManager",
    (GameScriptInterface_GetRestrictMovementAreaManager x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.AIGuardAreaManager>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_GetRestrictMovementAreaManager(
    game.stateMachine.GameScriptInterface self
);

AISafeAreaManager? GetSafeAreaManager() RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "GetSafeAreaManager",
    (GameScriptInterface_GetSafeAreaManager x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.AISafeAreaManager>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_GetSafeAreaManager(
    game.stateMachine.GameScriptInterface self
);

game.mounting.IMountingFacility? GetMountingFacility() RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "GetMountingFacility",
    (GameScriptInterface_GetMountingFacility x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.mounting.IMountingFacility>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_GetMountingFacility(
    game.stateMachine.GameScriptInterface self
);

game.GameplayLogicPackageSystem? GetGameplayLogicPackageSystem() RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "GetGameplayLogicPackageSystem",
    (GameScriptInterface_GetGameplayLogicPackageSystem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.GameplayLogicPackageSystem>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_GetGameplayLogicPackageSystem(
    game.stateMachine.GameScriptInterface self
);

game.JournalManager? GetJournalManager() RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "GetJournalManager",
    (GameScriptInterface_GetJournalManager x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.JournalManager>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_GetJournalManager(
    game.stateMachine.GameScriptInterface self
);

game.DebugCheatsSystem? GetDebugCheatsSystem() RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "GetDebugCheatsSystem",
    (GameScriptInterface_GetDebugCheatsSystem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.DebugCheatsSystem>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_GetDebugCheatsSystem(
    game.stateMachine.GameScriptInterface self
);

game.ICombatQueriesSystem? GetCombatQueriesSystem() RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "GetCombatQueriesSystem",
    (GameScriptInterface_GetCombatQueriesSystem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.ICombatQueriesSystem>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_GetCombatQueriesSystem(
    game.stateMachine.GameScriptInterface self
);

game.IGameRulesSystem? GetGameRulesSystem() RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "GetGameRulesSystem",
    (GameScriptInterface_GetGameRulesSystem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.IGameRulesSystem>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_GetGameRulesSystem(
    game.stateMachine.GameScriptInterface self
);

game.GameTagSystem? GetGameTagSystem() RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "GetGameTagSystem",
    (GameScriptInterface_GetGameTagSystem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.GameTagSystem>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_GetGameTagSystem(
    game.stateMachine.GameScriptInterface self
);

game.PingSystem? GetPingSystem() RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "GetPingSystem",
    (GameScriptInterface_GetPingSystem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.PingSystem>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_GetPingSystem(
    game.stateMachine.GameScriptInterface self
);

game.IPlayerManager? GetPlayerManagerSystem() RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "GetPlayerManagerSystem",
    (GameScriptInterface_GetPlayerManagerSystem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.IPlayerManager>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_GetPlayerManagerSystem(
    game.stateMachine.GameScriptInterface self
);

game.ScriptsDebugOverlaySystem? GetScriptsDebugOverlaySystem() RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "GetScriptsDebugOverlaySystem",
    (GameScriptInterface_GetScriptsDebugOverlaySystem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.ScriptsDebugOverlaySystem>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_GetScriptsDebugOverlaySystem(
    game.stateMachine.GameScriptInterface self
);

game.ICooldownSystem? GetCooldownSystem() RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "GetCooldownSystem",
    (GameScriptInterface_GetCooldownSystem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.ICooldownSystem>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_GetCooldownSystem(
    game.stateMachine.GameScriptInterface self
);

game.DebugPlayerBreadcrumbs? GetDebugPlayerBreadcrumbs() RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "GetDebugPlayerBreadcrumbs",
    (GameScriptInterface_GetDebugPlayerBreadcrumbs x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.DebugPlayerBreadcrumbs>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_GetDebugPlayerBreadcrumbs(
    game.stateMachine.GameScriptInterface self
);

game.interactions.CManager? GetInteractionManager() RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "GetInteractionManager",
    (GameScriptInterface_GetInteractionManager x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.interactions.CManager>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_GetInteractionManager(
    game.stateMachine.GameScriptInterface self
);

game.ui.SubtitleHandlerSystem? GetSubtitleHandlerSystem() RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "GetSubtitleHandlerSystem",
    (GameScriptInterface_GetSubtitleHandlerSystem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.ui.SubtitleHandlerSystem>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_GetSubtitleHandlerSystem(
    game.stateMachine.GameScriptInterface self
);

AINavigationSystem? GetAINavigationSystem() RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "GetAINavigationSystem",
    (GameScriptInterface_GetAINavigationSystem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.AINavigationSystem>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_GetAINavigationSystem(
    game.stateMachine.GameScriptInterface self
);

sense.CSenseManager? GetSenseManager() RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "GetSenseManager",
    (GameScriptInterface_GetSenseManager x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.sense.CSenseManager>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_GetSenseManager(
    game.stateMachine.GameScriptInterface self
);

game.ui.GameSystemUI? GetUISystem() RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "GetUISystem",
    (GameScriptInterface_GetUISystem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.ui.GameSystemUI>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_GetUISystem(
    game.stateMachine.GameScriptInterface self
);

game.AchievementSystem? GetAchievementSystem() RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "GetAchievementSystem",
    (GameScriptInterface_GetAchievementSystem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.AchievementSystem>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_GetAchievementSystem(
    game.stateMachine.GameScriptInterface self
);

game.IWatchdogSystem? GetWatchdogSystem() RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "GetWatchdogSystem",
    (GameScriptInterface_GetWatchdogSystem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.IWatchdogSystem>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_GetWatchdogSystem(
    game.stateMachine.GameScriptInterface self
);

game.LevelAssignmentSystem? GetLevelAssignmentSystem() RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "GetLevelAssignmentSystem",
    (GameScriptInterface_GetLevelAssignmentSystem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.LevelAssignmentSystem>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_GetLevelAssignmentSystem(
    game.stateMachine.GameScriptInterface self
);

game.TelemetryTelemetrySystem? GetTelemetrySystem() RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "GetTelemetrySystem",
    (GameScriptInterface_GetTelemetrySystem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.TelemetryTelemetrySystem>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_GetTelemetrySystem(
    game.stateMachine.GameScriptInterface self
);

game.PhotoModeSystem? GetPhotoModeSystem() RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "GetPhotoModeSystem",
    (GameScriptInterface_GetPhotoModeSystem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.PhotoModeSystem>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_GetPhotoModeSystem(
    game.stateMachine.GameScriptInterface self
);

game.ui.ICharacterCustomizationSystem? GetCharacterCustomizationSystem() RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "GetCharacterCustomizationSystem",
    (GameScriptInterface_GetCharacterCustomizationSystem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.ui.ICharacterCustomizationSystem>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_GetCharacterCustomizationSystem(
    game.stateMachine.GameScriptInterface self
);

game.IOnlineSystem? GetOnlineSystem() RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "GetOnlineSystem",
    (GameScriptInterface_GetOnlineSystem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.IOnlineSystem>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_GetOnlineSystem(
    game.stateMachine.GameScriptInterface self
);

void GetWardrobeSystem() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamestateMachineGameScriptInterface",
    "GetWardrobeSystem",
    (GameScriptInterface_GetWardrobeSystem x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_GetWardrobeSystem(
    game.stateMachine.GameScriptInterface self
);

void GetRazerChromaEffectsSystem() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamestateMachineGameScriptInterface",
    "GetRazerChromaEffectsSystem",
    (GameScriptInterface_GetRazerChromaEffectsSystem x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_GetRazerChromaEffectsSystem(
    game.stateMachine.GameScriptInterface self
);

void GetModdingSystem() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamestateMachineGameScriptInterface",
    "GetModdingSystem",
    (GameScriptInterface_GetModdingSystem x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_GetModdingSystem(
    game.stateMachine.GameScriptInterface self
);

game.MinimapSystem? GetMinimapSystem() RTTI

Generated hook

re.Hooks.Place(
    "gamestateMachineGameScriptInterface",
    "GetMinimapSystem",
    (GameScriptInterface_GetMinimapSystem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.MinimapSystem>();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_GetMinimapSystem(
    game.stateMachine.GameScriptInterface self
);

void RequestWeaponEquipOnServer(TDBID slotName, game.ItemID itemId) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamestateMachineGameScriptInterface",
    "RequestWeaponEquipOnServer",
    (GameScriptInterface_RequestWeaponEquipOnServer x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_RequestWeaponEquipOnServer(
    game.stateMachine.GameScriptInterface self,
    TDBID slotName,
    game.ItemID itemId
);

static void PushAnimationEventToItem(WeakHandle<game.ItemObject> item, CName eventName) staticRTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamestateMachineGameScriptInterface",
    "PushAnimationEventToItem",
    (GameScriptInterface_PushAnimationEventToItem x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_PushAnimationEventToItem(
    WeakHandle<game.ItemObject> item,
    CName eventName
);

static void CreateWaterImpulse(Vector4 position, float radius, float strength, uint numFrames) staticRTTI

Generated hook

re.Hooks.PlaceVoid(
    "gamestateMachineGameScriptInterface",
    "CreateWaterImpulse",
    (GameScriptInterface_CreateWaterImpulse x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct GameScriptInterface_CreateWaterImpulse(
    Vector4 position,
    float radius,
    float strength,
    uint numFrames
);