Cover reference¶

The cover core component and its two movement adapters. Add AC_CoverSystem_Mover to a Mover pawn or AC_CoverSystem_CMC to a Character pawn: both inherit every setting of AC_CoverSystem_Base.

How to read these tables

Settings are the values you tune: select the component in your pawn Blueprint (or open the asset) and look in the Details panel under the category shown. Runtime state is written by the system while it runs; read it, do not set it. Functions marked pure have no execution pins. The descriptions are the same as the Details panel tooltips. Default is the class default; where a sample pawn sets a different value on its component, the description says so ().

AC_CoverSystem_Base¶

/GASPALS/Systems/CoverSystem/AC_CoverSystem_Base · parent ActorComponent

Settings¶

Cover > Aim¶

Variable	Type	Default	Description
Enable Cover Aim `bEnableCoverAim`	Boolean	`true`	Aim from cover: aiming (WantsToAim) in cover steps out to the best aim position instead of leaving cover. Off: aiming leaves cover as before.
Cover Aim Keep Standing `bCoverAimKeepStanding`	Boolean	`true`	Low cover: once standing to aim over the wall (Over), stay standing while the target can still be hit from there, and only crouch back into cover (InPlace) when the cover spot can hit it, never side-step to an edge. Off: the order cover, edge, stand is re-applied every time.
Cover Aim Muzzle Height Stand `CoverAimMuzzleHeightStand`	Float	`145`	Aim from cover: muzzle height (cm above the capsule bottom) used for line-of-fire traces while standing. Adjust for very short or tall characters.
Cover Aim Muzzle Height Crouch `CoverAimMuzzleHeightCrouch`	Float	`95`	Aim from cover: muzzle height (cm above the capsule bottom) used for line-of-fire traces while crouched.
Cover Aim Hit Tolerance `CoverAimHitTolerance`	Float	`30`	Line of fire: a hit this close (cm) to the aim point still counts as a clear shot (the target itself).
Cover Aim Cover Depth `CoverAimCoverDepth`	Float	`80`	A hit of the aim ray within this depth (cm) behind the cover face counts as the cover in use (wall thickness): aiming at your own cover means aiming past it.
Cover Aim Min Pose Time `CoverAimMinPoseTime`	Float	`0.25`	Aim from cover: minimum time (seconds) in an aim pose before it can change to another one.
Cover Aim Blocked Delay `CoverAimBlockedDelay`	Float	`0.15`	Seconds the current pose must be blocked before the pawn moves to a more exposed pose. Ignores short blocks such as the aim sweeping past an obstacle edge.
Cover Aim Return Delay `CoverAimReturnDelay`	Float	`0.3`	Seconds a safer pose must stay clearly valid before the pawn switches back to it.
Cover Aim Return Margin `CoverAimReturnMargin`	Float	`10`	Clearance (cm) a safer pose needs before the pawn switches back to it: a sphere of this radius must pass the first CoverAimReturnMarginReach of its shot. Stops flicker when a shot grazes the wall top or end.
Cover Aim Return Margin Reach `CoverAimReturnMarginReach`	Float	`300`	Length (cm) of the shot, from the muzzle, checked with the CoverAimReturnMargin sphere: the part near the cover where grazing matters. Beyond it a plain line test is used, so ground targets do not block the return.
Cover Aim Edge Clearance `CoverAimEdgeClearance`	Float	`20`	Aim from cover: extra distance (cm) past the edge, beyond the capsule radius, when stepping out to aim around it.
Cover Aim Slow Radius `CoverAimSlowRadius`	Float	`30`	Aim from cover: steering input slows down inside this distance (cm) to the target point.
Cover Aim Arrive Tolerance `CoverAimArriveTolerance`	Float	`4`	Aim from cover: the step-out and return stop within this distance (cm) along the wall.
Cover Aim Return Timeout `CoverAimReturnTimeout`	Float	`1`	Aim from cover: after releasing aim, the lock ends after this time (seconds) even if the pawn could not get back to the return point.
Cover Aim Debug `bCoverAimDebug`	Boolean	`false`	Debug: print every aim pose change on screen and to the log ("Cover aim: Old > New") and draw the aim target.

Cover > CornerTurn¶

Variable	Type	Default	Description
Corner Turn Hold Time `CornerTurnHoldTime`	Float	`0.3`	Sticky cover: how long (s) the player holds toward an edge before the character turns around the corner.
Corner Turn Angle `CornerTurnAngle`	Float	`100`	Sticky cover: largest corner angle (degrees between the two wall normals) the character turns around.
Corner Turn Min Width `CornerTurnMinWidth`	Float	`50`	Sticky cover: how deep (cm) the wall around a corner must be to turn around it. Thinner ends (e.g. a thin wall) stop at the edge.
Corner Remap Release Time `CornerRemapReleaseTime`	Float	`0.15`	Seconds the player must release or change the held direction before the corner input remap stops. Ignores single frames without input, so chained corner turns keep going.

Cover > CoverRun¶

Variable	Type	Default	Description
Cover Run Range `CoverRunRange`	Float	`1500`	Cover run: how far (cm) the cover under the camera crosshair (or the wall straight ahead) can be for the cover button to run to it. Cover within StickyCoverReach is taken directly.
Cover Run Max Time `CoverRunMaxTime`	Float	`2`	Cover run: extra seconds allowed on top of the path length at 5 m/s before the run is cancelled (e.g. when blocked on the way).
Cover Run Path Tolerance `CoverRunPathTolerance`	Float	`60`	Cover run: distance (cm) at which the next navmesh path point is followed.
Cover Run Arrive Distance `CoverRunArriveDistance`	Float	`80`	Cover run: on the last path leg, distance (cm) from the stand point (60 cm in front of the wall) at which the character snaps into sticky cover.
Cover Run Arrive Speed `CoverRunArriveSpeed`	Float	`150`	Speed (cm/s) the cover run slows down to when it reaches CoverRunArriveDistance and takes sticky cover, so the character does not slide along the wall.
Cover Run Brake Decel `CoverRunBrakeDecel`	Float	`700`	Deceleration (cm/s2) the cover run plans with on its last leg: the run input is scaled down so the speed reaches CoverRunArriveSpeed at CoverRunArriveDistance. Keep it below what the pawn can brake (Mover StoppingDeceleration, CMC braking).

Cover > Detection¶

Variable	Type	Default	Description
Cover Enter Distance `CoverEnterDistance`	Float	`80`	How far from the character (cm) a wall can be to take cover when moving into it.
Cover Enter Input Dot `CoverEnterInputDot`	Float	`0.3`	How directly the move input must point into the wall to take cover (dot product: 0 = anything toward the wall, 1 = straight into it).
Cover Hold Distance `CoverHoldDistance`	Float	`50`	Max distance (cm) between the character and the wall for cover to be kept. Must be larger than the Cover mode TargetWallDistance.
Cover Trace Radius `CoverTraceRadius`	Float	`12`	Radius (cm) of the sphere traces used to find cover.
High Cover Height `HighCoverHeight`	Float	`60`	Height (cm) above the character origin that is checked for wall; if there is none, the cover counts as low cover. Low cover needs a crouching character (or sticky cover on the Mover): standing characters do not take it automatically, and standing up in soft low cover leaves it.
Edge Probe Offset `EdgeProbeOffset`	Float	`45`	Sideways distance (cm) of the edge, look-ahead and corner probes from the character.
Max Cover Turn Angle `MaxCoverTurnAngle`	Float	`90`	Largest change in wall direction (degrees) the character follows while moving along cover. Bends are followed automatically; corners (e.g. 90 on a table) only while the camera looks at the cover. Sharper changes release cover.

Cover > Exit¶

Variable	Type	Default	Description
Cover Exit Input Dot `CoverExitInputDot`	Float	`0.7`	How directly the move input must point away from the wall to start leaving cover (dot product; 0.7 = more than 45 degrees away). Lower values leave cover more easily but can drop cover while strafing around corners.
Cover Exit Delay `CoverExitDelay`	Float	`0.15`	Seconds the player must keep pushing away from the wall before cover is released.
Sticky Exit Input Dot `StickyExitInputDot`	Float	`0.9`	How directly the input must point away from the wall to leave sticky cover (dot product; higher = more deliberate).
Sticky Exit Delay `StickyExitDelay`	Float	`0.35`	Seconds the player must keep pulling away before sticky cover is released.

Cover > Facing¶

Variable	Type	Default	Description
Facing Stand Auto `Facing_StandAuto`	E_CoverFacingStyle	`ShoulderToWall`	Facing while standing in automatic (soft) cover: FaceWall (towards the wall, offset by the shoulder angles), ShoulderToWall (along the wall, in the last move direction) or BackToWall.
Facing Stand Sticky `Facing_StandSticky`	E_CoverFacingStyle	`BackToWall`	Facing while standing in sticky cover: FaceWall (towards the wall, offset by the shoulder angles), ShoulderToWall (along the wall, in the last move direction) or BackToWall.
Facing Crouch Auto `Facing_CrouchAuto`	E_CoverFacingStyle	`FaceWall`	Facing while crouched in automatic (soft) cover: FaceWall (towards the wall, offset by the shoulder angles), ShoulderToWall (along the wall, in the last move direction) or BackToWall.
Facing Crouch Sticky `Facing_CrouchSticky`	E_CoverFacingStyle	`ShoulderToWall`	Facing while crouched in sticky cover: FaceWall (towards the wall, offset by the shoulder angles), ShoulderToWall (along the wall, in the last move direction) or BackToWall.
Character Rotation Right Shoulder `CharacterRotationRightShoulder`	Float	`25`	Yaw offset in degrees added to the wall-facing direction while the camera is on the right shoulder (FaceWall style, and the CMC mesh rotation).
Character Rotation Left Shoulder `CharacterRotationLeftShoulder`	Float	`-25`	Yaw offset in degrees added to the wall-facing direction while the camera is on the left shoulder (FaceWall style, and the CMC mesh rotation).

Cover > FirstPerson¶

Variable	Type	Default	Description
First Person Sticky Cover `FirstPersonStickyCover`	E_CoverFirstPersonSticky	`SwitchToThirdPerson`	Sticky cover while the camera is in first person: SwitchToThirdPerson (camera goes to third person in sticky cover and back when it ends) or Disabled (no sticky cover in first person).
First Person Auto Cover `FirstPersonAutoCover`	E_CoverFirstPersonAuto	`MovementOnly`	Auto (soft) cover while the camera is in first person: MovementOnly (wall hug and edges, the body follows the camera) or Disabled (no auto cover in first person).

Cover > General¶

Variable	Type	Default	Description
Enable Cover `bEnableCover`	Boolean	`true`	Master switch. When off, the character never takes cover.
Enable Auto Cover `bEnableAutoCover`	Boolean	`true`	Auto cover: take cover by moving into a wall (or crouching in front of it). When off, only the cover button (sticky cover) takes cover. Needs bEnableCover.
Enable Sticky Cover `bEnableStickyCover`	Boolean	`true`	Sticky cover: the cover button (IA_Cover) snaps into cover under the crosshair, runs to far cover (cover run) and upgrades auto cover to sticky. When off, the button does nothing and the crosshair does not target cover. Needs bEnableCover.
Engage Rule `EngageRule`	E_CoverEngageRule	`Automatic`	When cover can be taken: Automatic (walk into a wall) or WhileCrouched (only while crouching).
Move Into Cover `bMoveIntoCover`	Boolean	`true`	When on, the character is moved against the wall when it takes cover (pulled to TargetWallDistance; the Mover through the Cover movement mode, the CMC through ShapeCoverMoveInput). When off, it is simply in cover when close enough and out of cover when too far, without being moved. Sticky cover always pulls in.
Auto Crouch Low Cover `bAutoCrouchLowCover`	Boolean	`true`	Crouch automatically behind low cover.
Enable Debug `bEnableDebug`	Boolean	`false`	Reserved for drawing the cover traces. Currently unused: the old CMC cover trace that read it was replaced by the shared sensor.

Cover > Marker¶

Variable	Type	Default	Description
Show Cover Marker `bShowCoverMarker`	Boolean	`true`	Show the Division-style marker on the targeted cover (local player only). The crosshair still turns green when this is off.

Cover > Movement¶

Variable	Type	Default	Description
Wall Distance Stand Auto `WallDistance_StandAuto`	Float	`0`	Gap (cm) between the capsule and the cover wall in soft (auto) cover while standing. 0 = touching the wall. The wall spring holds it, pushing out at up to WallPushSpeed and pulling in at up to MaxWallPullSpeed; tolerance WallPullDeadZone. Keep the gap plus the capsule radius under CoverHoldDistance.
Wall Distance Stand Sticky `WallDistance_StandSticky`	Float	`0`	Gap (cm) between the capsule and the cover wall in sticky cover while standing. 0 = touching the wall. Pulled in at up to StickyPullSpeed, pushed out at up to WallPushSpeed.
Wall Distance Crouch Auto `WallDistance_CrouchAuto`	Float	`0`	Gap (cm) between the capsule and the cover wall in soft (auto) cover while crouched. 0 = touching the wall. Raise it if a crouched pose clips into the wall.
Wall Distance Crouch Sticky `WallDistance_CrouchSticky`	Float	`0`	Gap (cm) between the capsule and the cover wall in sticky cover while crouched (sticky low cover crouches automatically). 0 = touching the wall.
Wall Spring Strength `WallSpringStrength`	Float	`8`	Strength of the spring that holds the character at the wall distance: pull speed (cm/s) per cm of distance error.
Wall Pull Dead Zone `WallPullDeadZone`	Float	`2`	Distance in cm around TargetWallDistance where the wall spring does nothing, so the character settles instead of creeping back and forth (Mover Cover mode and CMC).
Max Wall Pull Speed `MaxWallPullSpeed`	Float	`200`	Fastest speed (cm/s) at which soft cover pulls the character toward the wall (when bMoveIntoCover is on).
Wall Push Speed `WallPushSpeed`	Float	`100`	Max speed (cm/s) the wall spring pushes the pawn away from the wall when it is closer than its WallDistance gap. 0 = never push (the pawn stays wherever it touched the wall).
Sticky Pull Speed `StickyPullSpeed`	Float	`600`	Fastest speed (cm/s) at which sticky cover pulls the character toward the wall.
Stop at Edges `bStopAtEdges`	Boolean	`false`	Soft cover also stops at the ends of the wall. Sticky cover always stops at edges.

Cover > Pose¶

Variable	Type	Default	Description
Cover Lower Max Stand `CoverLower_MaxStand`	Float	`10`	Most the pelvis is lowered (cm) when standing in cover. The amount adapts to the cover height: just enough to keep the top of the capsule CoverLower_HeadClearance under the cover top; 0 behind cover taller than the pawn.
Cover Lower Max Crouch `CoverLower_MaxCrouch`	Float	`15`	Most the pelvis is lowered (cm) when crouched in cover (typically behind low cover). Adapts to the cover height like CoverLower_MaxStand.
Cover Lower Head Clearance `CoverLower_HeadClearance`	Float	`5`	How far (cm) under the cover top the top of the capsule should be after lowering. Higher = ducks deeper (up to the max).

Cover > Sticky¶

Variable	Type	Default	Description
Sticky Cover Reach `StickyCoverReach`	Float	`250`	How far (cm) along the camera direction the cover button searches for a wall; also how far sticky cover holds on to the wall while pulling the character in.
Sticky Tap Time `StickyTapTime`	Float	`0.25`	Cover button: presses shorter than this (s) count as a tap. A tap in sticky cover leaves it; in cover, a cover run to other cover only starts once the button is held longer.

Cover > Traversal¶

Variable	Type	Default	Description
Vault Facing Dot `VaultFacingDot`	Float	`0.9`	Space in cover while not facing the wall this closely (dot product; 0.9 = within about 25 degrees) first turns the character to face the wall, then starts the traversal.
Vault Facing Timeout `VaultFacingTimeout`	Float	`0.75`	Longest time (seconds) the character spends turning toward the wall before the traversal is tried anyway.

Runtime state (9 variables)

Variable	Type	Default	Description
Parent Pawn `ParentPawn`	Pawn ref		Set by InitializeSystem: the pawn that owns this cover component. Internal; read by the CMC and Mover cover components.
Is Character in Cover `bIsCharacterInCover`	Boolean	`false`	Output: true while the character is in cover. Read by the character for animation (Get_PropertiesForAnimation). Not meant to be set by hand.
Sticky Cover `bStickyCover`	Boolean	`false`	Internal state: true while in sticky cover.
Cover State `CoverState`	S_MoverCustomInputs_Cover		Internal state: the cover result sent to the Mover every frame (normal, point, in cover, low cover, edges).
Cover Normal `CoverNormal`	Vector	`(0, 0, 0)`	Output: current wall normal (flattened, pointing away from the wall). Not meant to be set by hand.
Cover Target Aimed `bCoverTargetAimed`	Boolean	`false`	Output: true when the last FindCoverTarget found a cover point along the crosshair aim (not only near the character). Drives the crosshair colour and the cover marker.
Cover Run Active `bCoverRunActive`	Boolean	`false`	Output: true while the character sprints toward cover (cover run). Read by the character in ProduceInput to force the Sprint gait. Not meant to be set by hand.
Cover Run Crouch Block `bCoverRunCrouchBlock`	Boolean	`false`	Output: true during a cover run and shortly after it (unless in cover). Read by the character in ProduceInput to block crouching, so the sprint never turns into a slide. Not meant to be set by hand.
Cover Marker `CoverMarker`	WidgetComponent ref		Runtime: the world-space cover marker widget component, created on demand by GetCoverMarker.

Functions¶

Function	Inputs	Outputs	Description
`CanCoverAimPoseHit` (pure)	Pose (E_CoverAimPose), AimPoint (Vector), Radius (Float)	bCanHit (Boolean)	True when the pose is available and its muzzle has a clear line of fire to AimPoint (TestCoverAimLineOfFire with Radius).
`CanStartCoverAim` (pure)		bCanStart (Boolean)	True when an aim lock can start: aim is requested while in cover, outside a corner turn and a cover run.
`FindCoverAimPose` (pure)	AimDirection (Vector), AimPoint (Vector), Radius (Float)	Pose (E_CoverAimPose)	The least exposed pose that can hit AimPoint, in this order: InPlace (stay in cover), the edge the aim points to, the other edge, Over (stand up). None when no pose can. Radius > 0 asks for a clear margin around the shot.
`FindCoverAimWallEnd`	Side (Float)	Distance (Float)	Distance along the wall from the return point to the wall end on Side (-1 left, +1 right): a line trace 5 cm behind the wall face, from EdgeProbeOffset+40 past the pawn back toward it. No end within reach returns EdgeProbeOffset; an inside corner (the probe starts in the perpendicular wall) counts as no end.
`FinishCoverAim`		bForceCrouch (Boolean), CoverInputs (S_MoverCustomInputs_Cover)	Cover outputs while the aim lock is active: writes CoverState from the frozen snapshot, with the stepped-out edge cleared so neither movement (Mover input or CMC shaping) stops at it. Low-cover force crouch stays on except when standing to aim over it.
`GetCoverAimCameraState` (pure)	bLowCover (Boolean), EdgeSide (Float)	bAimLowCover (Boolean), AimEdgeSide (Float)	Camera hook (end of GetCoverCameraState): no low-cover camera offset while aiming, and the shoulder side taken from the stepped-out edge.
`GetCoverAimDirection` (pure)		AimDirection (Vector), AimPoint (Vector), AimForward (Vector), bFixedCamera (Boolean)	Aim of the player camera: planar aim direction, crosshair point, 3D camera forward and whether the camera is fixed (top-down, side-scroller). AI pawns and pawns without a camera system use the base aim rotation.
`GetCoverAimEdgeDistance`	Side (Float)	Distance (Float), bOpen (Boolean)	Distance along the wall from the return point to the wall end on Side (FindCoverAimWallEnd) and whether the step out past it is open (IsCoverAimStepOpen). Impure so its two outputs come from one measurement; called once per side in StartCoverAim.
`GetCoverAimEdgeOrder` (pure)	AimDirection (Vector)	First (E_CoverAimPose), Second (E_CoverAimPose)	The edge the aim points toward (First) and the other edge (Second).
`GetCoverAimEdgeProbe` (pure)	Side (Float)	Start (Vector), End (Vector)	Probe line for the wall end on Side: starts EdgeProbeOffset + 40 past the return point along the wall, 5 cm behind the wall face, and runs back toward the pawn for twice EdgeProbeOffset + 40.
`GetCoverAimFacing` (pure)	Facing (Vector)	AimFacing (Vector)	Facing while aiming from cover: the planar aim direction. Returns Facing unchanged when not aiming from cover.
`GetCoverAimFallbackPose` (pure)		Pose (E_CoverAimPose)	Pose used when no pose can hit the target as the aim starts: Over in low cover, InPlace in high cover.
`GetCoverAimMoveInput`	MoveInput (Vector)	AimMoveInput (Vector)	Move input while the aim lock is on (end of RemapCoverMoveInput): watches for exit input (UpdateCoverAimExitRequest) and steers along the wall to the pose location (GetCoverAimSteering). Passes MoveInput through when not locked.
`GetCoverAimMuzzle` (pure)	Pose (E_CoverAimPose)	Muzzle (Vector)	Muzzle stand-in for a pose: the pose location, CoverAimMuzzleHeightStand above the floor when standing (Over, or the aim started standing), CoverAimMuzzleHeightCrouch otherwise.
`GetCoverAimPoseLocation` (pure)	Pose (E_CoverAimPose)	Location (Vector)	Where the pawn stands for a pose: the return point, or for an edge pose the point just past the wall end (edge distance + capsule radius + CoverAimEdgeClearance).
`GetCoverAimPoseRank` (pure)	Pose (E_CoverAimPose)	Rank (Integer)	Exposure rank for comparing poses: InPlace 0, edges 1, Over 2, None 3.
`GetCoverAimPoseSide` (pure)	Pose (E_CoverAimPose)	Side (Float)	-1 for EdgeLeft, +1 for EdgeRight, 0 for the poses that stay at the cover spot.
`GetCoverAimStartPoint` (pure)		Point (Vector)	Return point for a new aim: the previous one when the pawn is still within 2x CoverAimArriveTolerance of it (it came back from the last aim), so repeated aims do not creep along the wall; otherwise the current location.
`GetCoverAimStartPose` (pure)	BestPose (E_CoverAimPose)	Pose (E_CoverAimPose)	First pose of an aim: BestPose, or GetCoverAimFallbackPose when no pose can hit the target.
`GetCoverAimSteering` (pure)		MoveInput (Vector)	Move input along the wall toward the current pose location: full speed beyond CoverAimSlowRadius, slowing to 25% near it, zero within CoverAimArriveTolerance. The cover movement keeps the wall distance.
`GetCoverAimTarget` (pure)	AimForward (Vector), AimPoint (Vector), bFixedCamera (Boolean)	Target (Vector)	The world point the aim pose has to hit. Camera-independent so the pose cannot feed back into it: a ray along AimForward from standing eye height above the cover spot. When that ray hits your own cover (IsOnCoverAimWall), the target is whatever lies behind it: aiming at your cover means aiming past it. Fixed cameras (top-down, side-scroller) use the cursor point (AimPoint).
`GetCoverAimWallAxes` (pure)		WallNormal (Vector), Tangent (Vector)	Flattened wall normal and wall tangent of the frozen cover snapshot. Tangent = cross(Z, -normal): +Tangent points to the right edge, -Tangent to the left edge.
`IsCoverAimPoseAvailable` (pure)	Pose (E_CoverAimPose)	bAvailable (Boolean)	True when the cover allows the pose: InPlace always, Over in low cover only, an edge pose when the snapshot is at that edge and the step-out path is open.
`IsCoverAimPoseSafer` (pure)	Candidate (E_CoverAimPose), Current (E_CoverAimPose)	bSafer (Boolean)	True when Candidate is less exposed than Current. With bCoverAimKeepStanding, a pawn standing in Over only goes back to InPlace, never to an edge.
`IsCoverAimRequested` (pure)		bRequested (Boolean)	True when the player wants to aim from cover: bEnableCoverAim is on, the aim input is held and the pawn may move.
`IsCoverAimReturned` (pure)		bReturned (Boolean)	True when the pawn is back at its cover spot along the wall (within CoverAimArriveTolerance), and crouched again when the aim started crouched.
`IsCoverAimStepOpen` (pure)	Side (Float), Distance (Float)	bOpen (Boolean)	True when the pawn can step out past the wall end on Side: traces at capsule height and 40 cm lower along the wall, out to Distance + capsule diameter + CoverAimEdgeClearance.
`IsCoverAiming` (pure)		ReturnValue (Boolean)	True while aiming from cover (CoverAimPose is not None). Local owner only; not replicated.
`IsCoverCrouchBlocked` (pure)		ReturnValue (Boolean)	Crouch is blocked: during a cover run (and its grace time), or while standing up to aim over low cover. Pawns use it for their crouch input.
`IsOnCoverAimWall` (pure)	Point (Vector)	bOnCover (Boolean)	True when Point lies on the cover being used: between 10 cm in front of the wall face and CoverAimCoverDepth behind it (face and top of the wall).
`SelectCoverAimPose`	AimDirection (Vector), AimPoint (Vector), DeltaSeconds (Float)		Picks CoverAimPose for the target each frame while aiming: the first pose of the aim (GetCoverAimStartPose), then keeps a pose that can hit, going back to a safer one when clearly possible (UpdateCoverAimSaferPose), or leaves a blocked one (UpdateCoverAimBlockedPose).
`StartCoverAim`			Starts the aim lock: freezes the cover state (CoverAimSnapshot) and the return point, remembers the crouch state and measures both edges once.
`StopCoverAim`			Ends the aim lock and clears the pose.
`SwitchCoverAimPose`	NewPose (E_CoverAimPose)		Changes the aim pose: sets CoverAimPose and restarts the pose timers (CoverAimPoseTimer, CoverAimSaferTimer). Every pose change goes through here.
`TestCoverAimLineOfFire` (pure)	Muzzle (Vector), AimPoint (Vector), Radius (Float)	bClear (Boolean)	True when Muzzle has a clear shot at AimPoint: nothing blocks the line, or the first hit is within CoverAimHitTolerance of the aim point. With Radius > 0 the first CoverAimReturnMarginReach of the shot must also clear a sphere of that radius.
`UpdateCoverAim`	DeltaSeconds (Float)	bLocked (Boolean)	Aim from cover, called from EvaluateCover every frame: starts the lock when aiming in cover (CanStartCoverAim, StartCoverAim); while locked stops when cover is lost, leaves cover on exit input, picks the pose while aiming (SelectCoverAimPose, target from GetCoverAimTarget) and walks back after release (UpdateCoverAimReturn). Returns whether the lock is on.
`UpdateCoverAimBlockedPose`	BestPose (E_CoverAimPose), DeltaSeconds (Float)		The current pose cannot hit the target: count CoverAimBlockedTimer and switch to BestPose once the pose has been blocked for CoverAimBlockedDelay (and held CoverAimMinPoseTime). Short blocks, like the aim sweeping past an obstacle edge, are ignored.
`UpdateCoverAimExitRequest`	MoveInput (Vector)		While aiming in cover, input away from the wall (CoverExitInputDot) requests leaving cover (bCoverAimExitRequested); UpdateCoverAim acts on it.
`UpdateCoverAimReturn`	DeltaSeconds (Float)		Aim released: the pawn walks back to the return point (GetCoverAimMoveInput), and the lock ends once it is there (IsCoverAimReturned) or after CoverAimReturnTimeout.
`UpdateCoverAimSaferPose`	SaferPose (E_CoverAimPose), DeltaSeconds (Float)		The current pose can hit the target: switch back to SaferPose once it has been safer (IsCoverAimPoseSafer, found with the CoverAimReturnMargin clearance) for CoverAimReturnDelay.
`GetCoverCameraState` (pure)		bLowCoverCamera (Boolean), EdgeSide (Float)	Cover camera state for the camera director (local player). bLowCoverCamera: in low cover. EdgeSide: -1 / +1 when a cover edge is within reach on the left / right of the screen (both edges: the side last moved to), 0 otherwise.
`UpdateCornerTurn`	MoveInput (Vector), DeltaSeconds (Float)		Sticky cover: turns the character around a wall corner once the player holds toward an edge for CornerTurnHoldTime and a side wall within CornerTurnAngle and CornerTurnMinWidth is found.
`FindCoverTarget`		bTargetFound (Boolean)	Looks along the crosshair or camera ray, within cover run range, for cover to run to and stores the run target. Returns whether one was found.
`RemapCoverMoveInput`	MoveInput (Vector)	RemappedInput (Vector)	Remaps the move input in sticky cover: corner turn remap, steering to the cover run target at a braking speed, then the aim steering. Returns the input for the movement code.
`StartCoverRun`		bRunStarted (Boolean)	Starts a cover run to the found cover: builds a navmesh path (straight line without navmesh), sets the time limit and turns bCoverRunActive on. Returns whether it started.
`UpdateCoverRun`	Location (Vector), DeltaSeconds (Float), bBlocked (Boolean)		Per frame during a cover run: follows the path to the target cover, cancels on button release, timeout or blocked cover, and takes the cover on arrival.
`GetCoverOrientationIntent`	CurrentIntent (Vector)	bInCover (Boolean), Intent (Vector)	Facing hook for the movement code: in cover returns the facing from the Facing settings (toward the wall, along it or back to it), the aim direction when aiming, or the wall while a vault turn is pending. Out of cover it returns CurrentIntent.
`IsAutoCoverAllowed` (pure)		bAllowed (Boolean)	False in first person when FirstPersonAutoCover is Disabled (no soft cover from walking into walls).
`IsFirstPersonCamera` (pure)		bFirstPerson (Boolean)	True when the owner AC_CameraSystem is in FirstPerson (false without a camera system).
`IsStickyCoverAllowed` (pure)		bAllowed (Boolean)	False in first person when FirstPersonStickyCover is Disabled (the cover button then does nothing).
`UpdateFirstPersonCoverCamera`			Sticky cover in first person: switch the camera to third person (FirstPersonStickyCover = SwitchToThirdPerson), and back to first person when sticky cover ends if we switched it. Owner only, called from EvaluateCover.
`UsesCoverFacing` (pure)		bCoverFacing (Boolean)	False in first-person auto cover (MovementOnly): the body follows the camera instead of the cover facing. Sticky cover in first person switches to third person, so it keeps the cover facing.
`InitializeSystem`	ParentPawn (Pawn ref)		Stores the owning pawn. Called once by the pawn; the Mover and CMC components extend it.
`GetCoverMarker`		Marker (WidgetComponent ref)	Returns the world-space cover marker (a Widget Component showing W_CoverMarker). Creates it on the pawn the first time it is needed: hidden, absolute transform, no collision, no shadow.
`UpdateCoverTargetMarker`		bTargeted (Boolean)	Local player, called by the camera system crosshair every tick. Looks for a cover target along the crosshair (FindCoverTarget) and shows the marker on that wall while it is aimed or a cover run is heading to it. Returns true when a cover target is aimed, which turns the crosshair green.
`GetCoverWallDistance` (pure)	bCrouched (Boolean), bSticky (Boolean)	Distance (Float)	Distance (cm) from the cover wall plane to the pawn center that the wall spring holds: the WallDistance_{Stand,Crouch}{Auto,Sticky} gap picked by crouch and sticky state, plus the pawn capsule radius. Read by the Mover cover mode (AdjustDesiredMove) and the CMC adapter (ShapeCoverMoveInput).
`GetCoverFacingDirection` (pure)		Direction (Vector)	Pawn hook: the direction the character visibly faces (Mover: actor forward; CMC: the mesh, which the CMC cover rotates). Used to wait for the turn to the wall before a vault.
`IsCoverCrouching` (pure)		bCrouching (Boolean)	Pawn hook: true while the owning pawn is crouched. Override in the pawn-specific cover component (Mover / CMC).
`IsCoverMovementAllowed` (pure)		bAllowed (Boolean)	Pawn hook: true while the pawn moves in a mode where cover is allowed (on the ground or already in cover). Override in the pawn-specific cover component (Mover / CMC).
`GetCoverLowerAmount`	bCrouched (Boolean)	Lower (Float)	How far (cm) CR_Humanoid_CoverLower lowers the pelvis in cover: enough to bring the top of the capsule CoverLower_HeadClearance under the cover top (GetCoverTopHeight), capped by CoverLower_MaxStand / CoverLower_MaxCrouch. 0 out of cover and when standing behind low cover (aiming over it). Called by the character ABPs (Update_CoverLower) on every machine.
`GetCoverTopHeight`		Height (Float)	Height (cm above the pawn floor) of the top of the cover wall in CoverState: one line trace down from 300 cm, 10 cm inside the wall. 300 when nothing is hit (the wall is at least that tall, or thinner than 10 cm).
`CanEnterSoftCover`	Location (Vector), Normal (Vector)	bAllowed (Boolean)	Pure: true when automatic cover can be taken at Location: the character is crouching or the wall reaches HighCoverHeight, and auto cover is allowed in this camera.
`EvaluateCover`	MoveInput (Vector), DeltaSeconds (Float)	bForceCrouch (Boolean), CoverInputs (S_MoverCustomInputs_Cover)	Per-frame cover evaluation on the owner: updates the cover button, crouch edge and aim lock, then corner turn and cover run, and enters, keeps or leaves cover. Returns force-crouch and the cover state for the movement code.
`FinishCover`	bKeep (Boolean), Point (Vector), Normal (Vector), MoveInput (Vector)	bForceCrouch (Boolean), CoverInputs (S_MoverCustomInputs_Cover)	Builds the cover state output for the frame. Keeping cover: probes the wall at the character and both sides to set the high-cover and edge flags. Otherwise returns the out-of-cover state. Also returns force-crouch for low cover.
`ResolveCoverSurface`	Location (Vector), MoveInput (Vector)	bHit (Boolean), Point (Vector), Normal (Vector)	Re-traces the wall while in cover (center, leading side and camera-forward probes) and picks the cover point and normal to follow. Bends up to MaxCoverTurnAngle are followed.
`TraceWall`	Start (Vector), Direction (Vector), Distance (Float)	bHit (Boolean), Point (Vector), Normal (Vector)	Pure: sphere trace (CoverTraceRadius) from Start along Direction for Distance. Returns whether a wall was hit, the impact point and the flattened wall normal.
`UpdateCrouchEdge`			Tracks crouch changes: sets bWasCrouching and bJustCrouched (true for the frame crouching started).
`EnterStickyCover`	Point (Vector), Normal (Vector)		Starts sticky cover on the wall at Point and Normal: ends any cover run, sets bStickyCover, resets the exit timer and writes the cover state.
`ExitCover`			Leaves sticky cover: clears bStickyCover and the cover state and starts a 0.5 s re-entry cooldown.
`HandleStickyToggle`	Location (Vector), DeltaSeconds (Float)		Per frame on the owner: counts the cover button hold time and applies toggle requests (enter, upgrade to sticky), then searches for a cover target while held and starts a cover run or snaps to cover under the crosshair.
`ReleaseStickyCover`			Cover button released: clears bCoverButtonHeld, which cancels a cover run, and flags the release for HandleStickyToggle.
`RequestStickyCover`			Cover button pressed: requests a sticky cover toggle when sticky cover is enabled and allowed in this camera, and marks the button as held.
`RequestCoverVault`		bDeferred (Boolean)	Jump pressed in cover: when the character does not face the wall closely enough (VaultFacingDot) it starts turning to the wall first and returns true. Returns false when the vault can start directly.
`UpdateCoverVault`	DeltaSeconds (Float)		Per frame while a vault turn is pending: counts the turn time and calls OnCoverVaultReady once the character faces the wall or VaultFacingTimeout passes. Cancels when cover is lost.

Events¶

OnCoverVaultReady (event dispatcher): Dispatcher called when the character faces the wall (or the facing timeout passed) after a vault from cover was requested; the pawn then starts the traversal.

AC_CoverSystem_Mover¶

/GASPALS/Systems/CoverSystem/AC_CoverSystem_Mover · parent AC_CoverSystem_Base_C

Settings¶

Variable	Type	Default	Description
Cover Mode Name `CoverModeName`	Name	`Cover`	Name of the Cover movement mode registered on the CharacterMover.
Ground Mode Name `GroundModeName`	Name	`Walking`	Name of the ground (walking) movement mode that cover is entered from.

Functions¶

Function	Inputs	Outputs	Description
`UpdateMoverCoverState`
`IsCoverCrouching` (pure)		bCrouching (Boolean)
`IsCoverMovementAllowed` (pure)		bAllowed (Boolean)

AC_CoverSystem_CMC¶

/GASPALS/Systems/CoverSystem/AC_CoverSystem_CMC · parent AC_CoverSystem_Base_C

Settings¶

Cover > CMC¶

Variable	Type	Default	Description
Forced Crouch Delay `ForcedCrouchDelay`	Float	`0.1`	Seconds the low-cover forced crouch must persist before the CMC character crouches. Filters one-frame low-cover readings so the capsule does not pop.

Cover > Facing¶

Variable	Type	Default	Description
Character Rotation Interp Speed `CharacterRotationInterpSpeed`	Float	`4`	How fast the CMC character mesh rotates to the cover facing (RInterpTo speed).

Functions¶

Function	Inputs	Outputs	Description
`ApplyRemoteCoverState`			CMC: non-owners. Copies the replicated cover state, facing intent and cover run flags into the runtime variables used by animation, gait and facing.
`SendCoverState`	DeltaSeconds (Float)		CMC: owner only. Sends the cover state, facing intent and cover run flags to the server every 0.05 s through ServerUpdateCover (unreliable).
`ShapeCoverMoveInput`	MoveInput (Vector)	ShapedInput (Vector)	CMC: owner-side wall hug. Projects the move input along the wall, stops at edges (sticky cover or StopAtEdges) and adds the spring pull toward TargetWallDistance, like BP_MovementMode_Cover does for the Mover.
`UpdateCoverCMC`	DeltaSeconds (Float)		CMC: per-frame cover update, called by the pawn from PreCMCTick (before the Character Movement Component ticks). The owner evaluates cover and reshapes the pending move input; other machines apply the replicated cover state. Then updates the mesh facing.
`UpdateCoverCrouch`	bForceCrouch (Boolean), DeltaSeconds (Float)		CMC: owner only. Crouches or uncrouches the character to match the crouch input or the forced crouch of low cover, unless a cover run blocks crouching.
`UpdateCoverFacingCMC`	DeltaSeconds (Float)		CMC: all machines. Turns the mesh toward the cover facing intent while in cover, then back to its default yaw (-90) after leaving cover.
`GetCoverFacingDirection` (pure)		Direction (Vector)
`InitializeSystem`	ParentPawn (Pawn ref)
`IsCoverCrouching` (pure)		bCrouching (Boolean)
`IsCoverMovementAllowed` (pure)		bAllowed (Boolean)

Events¶

ServerUpdateCover: Server RPC.

BP_MovementMode_Cover¶

/GASPALS/Blueprints/MovementModes/BP_MovementMode_Cover · parent BP_MovementMode_Walking_C

Functions¶

Function	Inputs	Outputs	Description
`AdjustDesiredMove`	StartState (MoverTickStartData), DeltaSeconds (Float), DesiredVelocity (Vector)	AdjustedVelocity (Vector)

BP_MovementTransition_Cover¶

/GASPALS/Blueprints/MovementModes/BP_MovementTransition_Cover · parent BaseMovementModeTransition

Settings¶

Variable	Type	Default	Description
Cover Mode Name `CoverModeName`	Name	`Cover`	Movement mode to switch to while the cover input says the character is in cover.
Ground Mode Name `GroundModeName`	Name	`Walking`	Movement mode to switch back to when the character leaves cover.

Functions¶

Function	Inputs	Outputs	Description
`Evaluate`	Params (SimulationTickParams)	ReturnValue (TransitionEvalResult)