class move

Policies

move.Policies

32 properties
51 functions

Properties

Property	Type	Offset
`destination`	`Vector3`	`0x40`
`destinationTangent`	`Vector3`	`0x4C`
`startTangent`	`Vector3`	`0x58`
`targetSmartObject`	`AIObjectId`	`0x68`
`targetWorkspot`	`game.SetupWorkspotActionEvent?`	`0x78`
`targetSmartObjectHash`	`ulong`	`0x70`
`targetObject`	`WeakHandle<game.Object>`	`0x88`
`strafingTarget`	`move.StrafingTarget`	`0x98`
`useFollowSlots`	`bool`	`0xC0`
`hasLocalTargetOffset`	`bool`	`0xF8`
`localTargetOffset`	`Vector3`	`0xFC`
`desiredDistance`	`float`	`0x108`
`toleranceRadius`	`float`	`0x114`
`minMovementDistance`	`float`	`0x10C`
`strafingRotationOffset`	`float`	`0x120`
`minFollowerDistance`	`float`	`0x118`
`maxFollowerDistance`	`float`	`0x11C`
`movementType`	`move.MovementType`	`0x140`
`circlingDirection`	`move.CirclingDirection`	`0x150`
`stopOnObstacle`	`bool`	`0x154`
`avoidObstacleWithinTolerance`	`bool`	`0x155`
`useCollisionAvoidance`	`bool`	`0x156`
`useDestReservation`	`bool`	`0x157`
`inRestrictedArea`	`bool`	`0x159`
`isSpline`	`bool`	`0x168`
`startFromClosestPoint`	`bool`	`0x16A`
`ignoreNavigation`	`bool`	`0x180`
`useStart`	`bool`	`0x181`
`useStop`	`bool`	`0x182`
`isEvaluated`	`bool`	`0x184`
`useOffMeshAllowedTags`	`bool`	`0x18C`
`useOffMeshBlockedTags`	`bool`	`0x18D`

Functions

void SetDestinationPosition(Vector4 position) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "movePolicies",
    "SetDestinationPosition",
    (Policies_SetDestinationPosition x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Policies_SetDestinationPosition(
    move.Policies self,
    Vector4 position
);

void SetInvalidDestinationPosition() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "movePolicies",
    "SetInvalidDestinationPosition",
    (Policies_SetInvalidDestinationPosition x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Policies_SetInvalidDestinationPosition(
    move.Policies self
);

void SetDestinationObject(game.Object objectt) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "movePolicies",
    "SetDestinationObject",
    (Policies_SetDestinationObject x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Policies_SetDestinationObject(
    move.Policies self,
    game.Object? objectt
);

void SetDestinationCover(ulong cover) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "movePolicies",
    "SetDestinationCover",
    (Policies_SetDestinationCover x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Policies_SetDestinationCover(
    move.Policies self,
    ulong cover
);

void SetStrafingTarget(game.Object objectt) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "movePolicies",
    "SetStrafingTarget",
    (Policies_SetStrafingTarget x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Policies_SetStrafingTarget(
    move.Policies self,
    game.Object? objectt
);

void SetDestinationOrientation(Quaternion oreiantation) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "movePolicies",
    "SetDestinationOrientation",
    (Policies_SetDestinationOrientation x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Policies_SetDestinationOrientation(
    move.Policies self,
    Quaternion oreiantation
);

void SetStrafingPosition(Vector4 position) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "movePolicies",
    "SetStrafingPosition",
    (Policies_SetStrafingPosition x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Policies_SetStrafingPosition(
    move.Policies self,
    Vector4 position
);

void SetDistancePolicy(float distance, float tolerance) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "movePolicies",
    "SetDistancePolicy",
    (Policies_SetDistancePolicy x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Policies_SetDistancePolicy(
    move.Policies self,
    float distance,
    float tolerance
);

void SetMaxZDiff(float zDiff) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "movePolicies",
    "SetMaxZDiff",
    (Policies_SetMaxZDiff x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Policies_SetMaxZDiff(
    move.Policies self,
    float zDiff
);

void SetMinDistancePolicy(float minDistance) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "movePolicies",
    "SetMinDistancePolicy",
    (Policies_SetMinDistancePolicy x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Policies_SetMinDistancePolicy(
    move.Policies self,
    float minDistance
);

void SetStrafingPredictionTime(float strafingPredictionTime, float strafingPredictionVelocityMax) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "movePolicies",
    "SetStrafingPredictionTime",
    (Policies_SetStrafingPredictionTime x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Policies_SetStrafingPredictionTime(
    move.Policies self,
    float strafingPredictionTime,
    float strafingPredictionVelocityMax
);

void SetStrafingRotationOffset(float angle) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "movePolicies",
    "SetStrafingRotationOffset",
    (Policies_SetStrafingRotationOffset x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Policies_SetStrafingRotationOffset(
    move.Policies self,
    float angle
);

void SetDynamicTargetUpdateTimer(float updateTimer, float distance) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "movePolicies",
    "SetDynamicTargetUpdateTimer",
    (Policies_SetDynamicTargetUpdateTimer x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Policies_SetDynamicTargetUpdateTimer(
    move.Policies self,
    float updateTimer,
    float distance
);

void SetCirclingPolicy(move.CirclingDirection direction) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "movePolicies",
    "SetCirclingPolicy",
    (Policies_SetCirclingPolicy x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Policies_SetCirclingPolicy(
    move.Policies self,
    move.CirclingDirection direction
);

void SetStopOnObstacle(bool stopOnObstacle) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "movePolicies",
    "SetStopOnObstacle",
    (Policies_SetStopOnObstacle x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Policies_SetStopOnObstacle(
    move.Policies self,
    bool stopOnObstacle
);

void SetAvoidObstacleWithinTolerance(bool avoidWiyhinTolerance) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "movePolicies",
    "SetAvoidObstacleWithinTolerance",
    (Policies_SetAvoidObstacleWithinTolerance x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Policies_SetAvoidObstacleWithinTolerance(
    move.Policies self,
    bool avoidWiyhinTolerance
);

void SetKeepLineOfSight(move.LineOfSight los) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "movePolicies",
    "SetKeepLineOfSight",
    (Policies_SetKeepLineOfSight x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Policies_SetKeepLineOfSight(
    move.Policies self,
    move.LineOfSight los
);

void SetLineOfSightPointPreference(move.LineOfSightPointPreference preference) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "movePolicies",
    "SetLineOfSightPointPreference",
    (Policies_SetLineOfSightPointPreference x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Policies_SetLineOfSightPointPreference(
    move.Policies self,
    move.LineOfSightPointPreference preference
);

void SetUseLineOfSitePrecheck(bool precheck) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "movePolicies",
    "SetUseLineOfSitePrecheck",
    (Policies_SetUseLineOfSitePrecheck x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Policies_SetUseLineOfSitePrecheck(
    move.Policies self,
    bool precheck
);

void SetMovementType(move.MovementType movementType) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "movePolicies",
    "SetMovementType",
    (Policies_SetMovementType x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Policies_SetMovementType(
    move.Policies self,
    move.MovementType movementType
);

void SetCollisionAvoidancePolicy(bool avoidance, bool reservation) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "movePolicies",
    "SetCollisionAvoidancePolicy",
    (Policies_SetCollisionAvoidancePolicy x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Policies_SetCollisionAvoidancePolicy(
    move.Policies self,
    bool avoidance,
    bool reservation
);

void SetInRestrictedArea(bool inRestrictedArea) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "movePolicies",
    "SetInRestrictedArea",
    (Policies_SetInRestrictedArea x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Policies_SetInRestrictedArea(
    move.Policies self,
    bool inRestrictedArea
);

void SetAvoidPreventionFreeAreas(bool inRestrictedArea) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "movePolicies",
    "SetAvoidPreventionFreeAreas",
    (Policies_SetAvoidPreventionFreeAreas x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Policies_SetAvoidPreventionFreeAreas(
    move.Policies self,
    bool inRestrictedArea
);

void SetAvoidSafeArea(bool inRestrictedArea) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "movePolicies",
    "SetAvoidSafeArea",
    (Policies_SetAvoidSafeArea x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Policies_SetAvoidSafeArea(
    move.Policies self,
    bool inRestrictedArea
);

void SetUseOffMeshAllowedTags(bool useOffMeshBlockedTags) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "movePolicies",
    "SetUseOffMeshAllowedTags",
    (Policies_SetUseOffMeshAllowedTags x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Policies_SetUseOffMeshAllowedTags(
    move.Policies self,
    bool useOffMeshBlockedTags
);

void AddAllowedTag(CName tag) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "movePolicies",
    "AddAllowedTag",
    (Policies_AddAllowedTag x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Policies_AddAllowedTag(
    move.Policies self,
    CName tag
);

void SetUseOffMeshBlockedTags(bool useOffMeshAllowedTags) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "movePolicies",
    "SetUseOffMeshBlockedTags",
    (Policies_SetUseOffMeshBlockedTags x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Policies_SetUseOffMeshBlockedTags(
    move.Policies self,
    bool useOffMeshAllowedTags
);

void AddBlockedTag(CName tag) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "movePolicies",
    "AddBlockedTag",
    (Policies_AddBlockedTag x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Policies_AddBlockedTag(
    move.Policies self,
    CName tag
);

void SetAvoidThreat(bool avoidThreat) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "movePolicies",
    "SetAvoidThreat",
    (Policies_SetAvoidThreat x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Policies_SetAvoidThreat(
    move.Policies self,
    bool avoidThreat
);

void SetAvoidThreatIgnoringDirection(bool ignoreDirection) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "movePolicies",
    "SetAvoidThreatIgnoringDirection",
    (Policies_SetAvoidThreatIgnoringDirection x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Policies_SetAvoidThreatIgnoringDirection(
    move.Policies self,
    bool ignoreDirection
);

void SetGetOutOfWay(bool getOutOfWay) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "movePolicies",
    "SetGetOutOfWay",
    (Policies_SetGetOutOfWay x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Policies_SetGetOutOfWay(
    move.Policies self,
    bool getOutOfWay
);

void SetUseStartStop(bool useStart, bool useStop) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "movePolicies",
    "SetUseStartStop",
    (Policies_SetUseStartStop x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Policies_SetUseStartStop(
    move.Policies self,
    bool useStart,
    bool useStop
);

void SetIgnoreNavigation(bool ignore) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "movePolicies",
    "SetIgnoreNavigation",
    (Policies_SetIgnoreNavigation x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Policies_SetIgnoreNavigation(
    move.Policies self,
    bool ignore
);

move.MovementType GetMovementType() RTTI

Generated hook

re.Hooks.Place(
    "movePolicies",
    "GetMovementType",
    (Policies_GetMovementType x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.move.MoveMovementType>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Policies_GetMovementType(
    move.Policies self
);

void SetIdleTurnsDeadZoneAngle(float angle) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "movePolicies",
    "SetIdleTurnsDeadZoneAngle",
    (Policies_SetIdleTurnsDeadZoneAngle x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Policies_SetIdleTurnsDeadZoneAngle(
    move.Policies self,
    float angle
);

float GetIdleTurnsDeadZoneAngle() RTTI

Generated hook

re.Hooks.Place(
    "movePolicies",
    "GetIdleTurnsDeadZoneAngle",
    (Policies_GetIdleTurnsDeadZoneAngle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Policies_GetIdleTurnsDeadZoneAngle(
    move.Policies self
);

void SetUseFollowSlots(bool use) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "movePolicies",
    "SetUseFollowSlots",
    (Policies_SetUseFollowSlots x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Policies_SetUseFollowSlots(
    move.Policies self,
    bool use
);

void SetUseSymmetricAnglesScores(bool use) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "movePolicies",
    "SetUseSymmetricAnglesScores",
    (Policies_SetUseSymmetricAnglesScores x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Policies_SetUseSymmetricAnglesScores(
    move.Policies self,
    bool use
);

void SetSquadInfo(uint squadIndex, uint squadSize) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "movePolicies",
    "SetSquadInfo",
    (Policies_SetSquadInfo x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Policies_SetSquadInfo(
    move.Policies self,
    uint squadIndex,
    uint squadSize
);

void SetMaxPathLengthToDirectDistanceRatioCurve(CName curveName) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "movePolicies",
    "SetMaxPathLengthToDirectDistanceRatioCurve",
    (Policies_SetMaxPathLengthToDirectDistanceRatioCurve x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Policies_SetMaxPathLengthToDirectDistanceRatioCurve(
    move.Policies self,
    CName curveName
);

CName GetMaxPathLengthToDirectDistanceRatioCurve() RTTI

Generated hook

re.Hooks.Place(
    "movePolicies",
    "GetMaxPathLengthToDirectDistanceRatioCurve",
    (Policies_GetMaxPathLengthToDirectDistanceRatioCurve x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.CName>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Policies_GetMaxPathLengthToDirectDistanceRatioCurve(
    move.Policies self
);

void SetMaxPathLength(float length) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "movePolicies",
    "SetMaxPathLength",
    (Policies_SetMaxPathLength x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Policies_SetMaxPathLength(
    move.Policies self,
    float length
);

float GetMaxPathLength() RTTI

Generated hook

re.Hooks.Place(
    "movePolicies",
    "GetMaxPathLength",
    (Policies_GetMaxPathLength x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Policies_GetMaxPathLength(
    move.Policies self
);

void SetDebugName(CName debugName) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "movePolicies",
    "SetDebugName",
    (Policies_SetDebugName x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Policies_SetDebugName(
    move.Policies self,
    CName debugName
);

void SetTweakDBID(TDBID id) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "movePolicies",
    "SetTweakDBID",
    (Policies_SetTweakDBID x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Policies_SetTweakDBID(
    move.Policies self,
    TDBID id
);

void SetPositionProvider(ent.IPositionProvider provider) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "movePolicies",
    "SetPositionProvider",
    (Policies_SetPositionProvider x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Policies_SetPositionProvider(
    move.Policies self,
    ent.IPositionProvider? provider
);

void SetStrafingPositionProvider(ent.IPositionProvider provider) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "movePolicies",
    "SetStrafingPositionProvider",
    (Policies_SetStrafingPositionProvider x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Policies_SetStrafingPositionProvider(
    move.Policies self,
    ent.IPositionProvider? provider
);

void SetCalculateStartTangent(bool calculateTangent) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "movePolicies",
    "SetCalculateStartTangent",
    (Policies_SetCalculateStartTangent x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Policies_SetCalculateStartTangent(
    move.Policies self,
    bool calculateTangent
);

void SetLocalTargetOffset(Vector4 position) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "movePolicies",
    "SetLocalTargetOffset",
    (Policies_SetLocalTargetOffset x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Policies_SetLocalTargetOffset(
    move.Policies self,
    Vector4 position
);

void SetCostModCircle(world.NavigationScriptCostModCircle costModCircle) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "movePolicies",
    "SetCostModCircle",
    (Policies_SetCostModCircle x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Policies_SetCostModCircle(
    move.Policies self,
    world.NavigationScriptCostModCircle? costModCircle
);

static Vector4 GetInvalidPos() staticRTTI

Generated hook

re.Hooks.Place(
    "movePolicies",
    "GetInvalidPos",
    (Policies_GetInvalidPos x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Vector4>();
    }
);

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