UCharacterMovementComponent

Current acceleration vector (with magnitude).

When falling, amount of lateral movement control available to the character.

When falling, multiplier applied to AirControl when lateral velocity is less than AirControlBoostVelocityThreshold.

When falling, if lateral velocity magnitude is less than this value, AirControl is multiplied by AirControlBoostMultiplier.

Modifier to applied to values such as acceleration and max speed due to analog input.

Velocity extracted from RootMotionParams when there is anim root motion active.

This is the most recent async state from simulated. Only safe for access on physics thread.

Moving actor's group mask

Remaining time of avoidance velocity lock

Forced avoidance velocity, used when AvoidanceLockTimer is > 0

No default value, for now it's assumed to be valid if GetAvoidanceManager() returns non-NULL.

De facto default value 0.5 (due to that being the default in the avoidance registration function), indicates RVO behavior.

Whether we always force floor checks for stationary Characters while walking.

Apply gravity while the character is actively jumping (e.g. holding the jump key).

Whether we're stepping off a moving platform (and should trust the client somewhat when landing).

If true, Character can walk off a ledge.

If true, Character can walk off a ledge when crouching.

Instantly stop when in flying mode and no acceleration is being applied.

If true, crouching should keep the base of the capsule in place by lowering the center of the shrunken capsule.

Flag set in pre-physics update to indicate that based movement should be updated post-physics

True to update CharacterOwner and UpdatedComponent after movement ends

If enabled, the player will interact with physics objects when walking into them.

If true, high-level movement updates will be wrapped in a movement scope that accumulates updates and defers a bulk of the work until the end.

Optional scoped movement update to combine moves for cheaper performance on the server when the client sends two moves in one packet.

Set this to true if riding on a moving base that you know is clear from non-moving world obstructions.

Ignores size of acceleration component, and forces max acceleration to drive character at full velocity.

Force the Character in MOVE_Walking to do a check for a valid floor even if he hasn't moved.

Was velocity requested by path following?

Whether the character ignores changes in rotation of the base it is standing on.

If true, we should ignore server location difference checks for client error on this movement component.

If true, impart the base component's tangential components of angular velocity when jumping or falling off it.

If true, impart the base actor's X velocity when falling off it (which includes jumping)

If true, impart the base actor's Y velocity when falling off it (which includes jumping)

If true, impart the base actor's Z velocity when falling off it (which includes jumping)

Set on clients when server's movement mode is NavWalking

Used by movement code to determine if a change in position is based on normal movement or a teleport.

Remember if the client was previously falling so we can tell when they've just landed.

Remember if the server was previously falling so we can tell when they've just landed.

Whether we were just walking on something, used to help with transitions off moving objects.

If true, walking movement always maintains horizontal velocity when moving up ramps, which causes movement up ramps to be faster parallel to the ramp surface.

True during movement update.

Flag used on the server to determine whether to always replicate ReplicatedServerLastTransformUpdateTimeStamp to clients.

Flag indicating the client correction was larger than NetworkLargeClientCorrectionThreshold.

True when the networked movement mode has been replicated.

Whether we skip prediction on frames where a proxy receives a network update.

Signals that smoothed position/rotation has reached target, and no more smoothing is necessary until a future update.

True when a network replication update is received for simulated proxies.

If true, event NotifyJumpApex() to CharacterOwner's controller when at apex of jump.

If true, rotate the Character toward the direction of acceleration, using RotationRate as the rate of rotation change.

Used to prevent reentry of JumpOff()

Use both WorldStatic and WorldDynamic channels for NavWalking geometry conforming

Whether to raycast to underlying geometry to better conform navmesh-walking characters

If enabled, the PushForceFactor is applied per kg mass of the affected object.

If enabled, the PushForce location is moved using PushForcePointZOffsetFactor.

Lateral deceleration when falling and not applying acceleration.

Deceleration when flying and not applying acceleration.

Deceleration when swimming and not applying acceleration.

Deceleration when walking and not applying acceleration.

Friction (drag) coefficient applied when braking (whenever Acceleration = 0, or if character is exceeding max speed); actual value used is this multiplied by BrakingFrictionFactor.

Factor used to multiply actual value of friction used when braking.

Time substepping when applying braking friction.

Should use acceleration for path following? If true, acceleration is applied when path following to reach the target velocity.

Was acceleration requested to be always max speed?

If true, movement will be performed even if there is no Controller for the Character owner.

If enabled, the applied push force will try to get the physics object to the same velocity than the player, not faster.

If true, and server does not detect client position error, server will copy the client movement location/velocity/etc after simulating the move.

If true, the capsule needs to be shrunk on this simulated proxy, to avoid replication rounding putting us in geometry.

Whether or not the character should sweep for collision geometry while walking.

True if the UpdatedComponent was moved outside of this CharacterMovementComponent since the last move its starting location for this update doesn't match its ending position for the previous update.

If enabled, the TouchForceFactor is applied per kg mass of the affected object.

Water buoyancy. A ratio (1.0 = neutral buoyancy, 0.0 = no buoyancy)

If true, smoothly rotate the Character toward the Controller's desired rotation (typically Controller->ControlRotation), using RotationRate as the rate of rotation change.

Performs floor checks as if the character is using a shape with a flat base.

If set, component will use RVO avoidance. This only runs on the server.

If set, PostProcessAvoidanceVelocity will be called

If true, BrakingFriction will be used to slow the character to a stop (when there is no Acceleration).

If true, try to crouch (or keep crouching) on next update.

Used to safely leave NavWalking movement mode

Was avoidance updated in this frame?

True when SimulatedProxies are simulating RootMotion

Last known location projected on navmesh, used by NavWalking mode

Last valid projected hit result from raycast to geometry from navmesh

Character movement component belongs to

Collision half-height when crouching (component scale is applied separately)

Information about the floor the Character is standing on (updated only during walking movement).

Root Motion Group containing active root motion sources being applied to movement

Current custom sub-mode if MovementMode is set to Custom.

Left over velocity when leaving a moving base. Helps with airborne root motion.

Default movement mode when not in water. Used at player startup or when teleported.

Default movement mode when in water. Used at player startup or when teleported.

What to update CharacterOwner and UpdatedComponent after movement ends

Friction to apply to lateral air movement when falling.

When applying a root motion override while falling off a moving object, this controls how long it takes to lose half the former base's velocity (in seconds).

Custom gravity scale. Gravity is multiplied by this amount for the character.

Setting that affects movement control.

Will avoid other agents if they are in one of specified groups

Will NOT avoid other agents if they are in one of specified groups, higher priority than GroupsToAvoid

Initial impulse force to apply when the player bounces into a blocking physics object.

Fraction of JumpZVelocity to use when automatically "jumping off" of a base actor that's not allowed to be a base for a character.

When exiting water, jump if control pitch angle is this high or above.

Initial velocity (instantaneous vertical acceleration) when jumping.

Remember last server movement base bone so we can detect mounts/dismounts and respond accordingly.

Used for throttling "stuck in geometry" logging.

Clock time on the server of the last timestamp reset.

Location after last PerformMovement or SimulateMovement update.

Rotation after last PerformMovement or SimulateMovement update.

Velocity after last PerformMovement or SimulateMovement update.

Used in determining if pawn is going off ledge.

Similar setting as NetworkSimulatedSmoothLocationTime but only used on Listen servers.

Similar setting as NetworkSimulatedSmoothRotationTime but only used on Listen servers.

Mass of pawn (for when momentum is imparted to it).

Max Acceleration (rate of change of velocity)

The maximum speed when using Custom movement mode.

Max distance we allow simulated proxies to depenetrate when moving out of anything but Pawns.

Max distance we allow simulated proxies to depenetrate when moving out of anything but Pawns.

Max distance we are allowed to depenetrate when moving out of other Pawns.

Max distance we allow simulated proxies to depenetrate when moving out of other Pawns.

The maximum flying speed.

Max number of attempts per simulation to attempt to exactly reach the jump apex when falling movement reaches the top of the arc.

Maximum step height for getting out of water

How loosely the client can follow the server location during this fall.

Max number of iterations used for each discrete simulation step.

Max time delta for each discrete simulation step.

Maximum height character can step up

The maximum swimming speed.

Maximum force applied to touched physics objects. If < 0.0f, there is no maximum.

The maximum ground speed when walking. Also determines maximum lateral speed when falling.

The maximum ground speed when walking and crouched.

The ground speed that we should accelerate up to when walking at minimum analog stick tilt

Minimum time between client TimeStamp resets.

Minimum Force applied to touched physics objects. If < 0.0f, there is no minimum.

Actor's current movement mode (walking, falling, etc).

Scale of the total capsule height to use for projection from navmesh to underlying geometry in the downward direction.

Scale of the total capsule height to use for projection from navmesh to underlying geometry in the upward direction.

Speed at which to interpolate agent navmesh offset between traces.

How often we should raycast to project from navmesh to underlying geometry

Ignore small differences in ground height between server and client data during NavWalking mode

Shrink simulated proxy capsule half height by this amount, to account for network rounding that may cause encroachment.

Shrink simulated proxy capsule radius by this amount, to account for network rounding that may cause encroachment.

If client error is larger than this, sets bNetworkLargeClientCorrection to reduce delay between client adjustments.

Maximum distance character is allowed to lag behind server location when interpolating between updates.

Minimum time on the server between acknowledging good client moves.

Minimum time on the server between sending client adjustments when client has exceeded allowable position error.

Minimum time on the server between sending client adjustments when client has exceeded allowable position error by a large amount (NetworkLargeClientCorrectionDistance).

Maximum distance beyond which character is teleported to the new server location without any smoothing.

How long to take to smoothly interpolate from the old pawn position on the client to the corrected one sent by the server.

How long to take to smoothly interpolate from the old pawn rotation on the client to the corrected one sent by the server.

Smoothing mode for simulated proxies in network game.

Used to limit number of jump apex attempts per tick.

Saved location of object we are standing on, for UpdateBasedMovement() to determine if base moved in the last frame, and therefore pawn needs an update.

Saved location of object we are standing on, for UpdateBasedMovement() to determine if base moved in the last frame, and therefore pawn needs an update.

Z velocity applied when pawn tries to get out of water

Accumulated force to be added next tick.

Accumulated impulse to be added next tick.

Temporarily holds launch velocity when pawn is to be launched so it happens at end of movement.

When perching on a ledge, add this additional distance to MaxStepHeight when determining how high above a walkable floor we can perch.

Don't allow the character to perch on the edge of a surface if the contact is this close to the edge of the capsule.

Post-physics tick function for this character

Pre-physics tick function for this character

Delegate for modifying root motion post conversion from component space to world space.

Delegate for modifying root motion pre conversion from component space to world space.

Force to apply when the player collides with a blocking physics object.

Z-Offset for the position the force is applied to.

Force per kg applied constantly to all overlapping components.

Velocity requested by path following.

Animation root motion (special case for now)Root Motion movement params.

Change in rotation per second, used when UseControllerDesiredRotation or OrientRotationToMovement are true.

Timestamp of last client adjustment sent. See NetworkMinTimeBetweenClientAdjustments.

Timestamp of last client adjustment sent. See NetworkMinTimeBetweenClientAdjustments.

Timestamp when location or rotation last changed during an update. Only valid on the server.

Force applied to objects we stand on (due to Mass and Gravity) is scaled by this amount.

Used when throttling "stuck in geometry" logging, to output the number of events we skipped if throttling.

Force to apply to physics objects that are touched by the player.

Default UObject constructor.

Prepare root motion to be passed on to physics thread

Add force to character.

Add impulse to character.

Adjust distance from floor, trying to maintain a slight offset from the floor when walking (based on CurrentFloor).

Adjust the size of the capsule on simulated proxies, to avoid overlaps due to replication rounding.

Applies momentum accumulated through AddImpulse() and AddForce(), then clears those forces.

Apply outputs from async sim.

Applies downward force when walking on top of physics objects.

Apply physics forces to the impacted component, if bEnablePhysicsInteraction is true.

Applies repulsion force to all touched components.

Use velocity requested by path following to compute a requested acceleration and speed.

Apply a RootMotionSource to current root motion

Applies root motion from root motion sources to velocity (override and additive)

Slows towards stop.

Increase air control if conditions of AirControlBoostMultiplier and AirControlBoostVelocityThreshold are met.

Calculate velocity from anim root motion.

Calculate RVO avoidance and apply it to current velocity

Updates Velocity and Acceleration based on the current state, applying the effects of friction and acceleration or deceleration.

Internal function to call OnMovementUpdated delegate on CharacterOwner.

Call the appropriate replicated ServerMove() function to send a client player move to the server.

On the client, calls the ServerMovePacked_ClientSend() function with packed movement data.

Returns true if current movement state allows an attempt at jumping. Used by Character::CanJump().

Returns true if the character is allowed to crouch in the current state.

Return true if it is OK to delay sending this player movement to the server, in order to conserve bandwidth.

Returns true if we can step up on the actor in the given FHitResult.

Returns whether this pawn is currently allowed to walk off ledges

Called when the collision capsule touches another primitive component

Check if pawn is falling

Returns true if there is a suitable floor SideStep from current position.

Check if swimming pawn just ran into edge of the pool and should jump out.

Clears forces accumulated through AddImpulse() and AddForce(), and also pending launch velocity.

If no client adjustment is needed after processing received ServerMove(), ack the good move so client can remove it from SavedMoves

If no client adjustment is needed after processing received ServerMove(), ack the good move so client can remove it from SavedMoves

Replicate position correction to client, associated with a timestamped servermove.

Replicate position correction to client, associated with a timestamped servermove.

Replicate position correction to client when using root motion for movement.

Replicate position correction to client when using root motion for movement.

Replicate root motion source correction to client when using root motion for movement.

Replicate root motion source correction to client when using root motion for movement.

On the client, handles the move response from the server after it has been received and unpacked in MoveResponsePacked_ClientReceive.

If bUpdatePosition is true, then replay any unacked moves.

Bandwidth saving version, when velocity is zeroed

Bandwidth saving version, when velocity is zeroed

Computes the analog input modifier based on current input vector and/or acceleration.

Compute distance to the floor from bottom sphere of capsule and store the result in OutFloorResult.

Compute a vector of movement, given a delta and a hit result of the surface we are on.

Compute a target rotation based on current movement.

Compute the sweep result of the smaller capsule with radius specified by GetValidPerchRadius(), and return true if the sweep contacts a valid walkable normal within InMaxFloorDist of InHit.ImpactPoint.

Constrain components of root motion velocity that may not be appropriate given the current movement mode (e.g. when falling Z may be ignored).

Enforce constraints on input given current state.

Updates acceleration and perform movement, called from the TickComponent on the authoritative side for controlled characters, or on the client for characters without a controller when either playing root motion or bRunPhysicsWithNoController is true.

Takes component space root motion and converts it to world space.

Converts received server IDs in a root motion group to local IDs

Checks if new capsule size fits (no encroachment), and call CharacterOwner->OnStartCrouch() if successful.

Reduces former base velocity according to FormerBaseVelocityDecayHalfLife

Make movement impossible (sets movement mode to MOVE_None).

Draw important variables on canvas.

Perform jump.

Prepare inputs for asynchronous simulation on physics thread

Performs trace for ProjectLocationFromNavMesh

Sweeps a vertical trace to find the floor for the capsule at the given location.

Project a location to navmesh to find adjusted height.

Get as close to waterline as possible, staying on same side as currently.

Sweep against the world and return the first blocking hit.

Force a client adjustment. Resets ServerLastClientAdjustmentTime.

Force a client update by making it appear on the server that the client hasn't updated in a long time.

Get the air control to use during falling movement.

Returns modifier [0..1] based on the magnitude of the last input vector, which is used to modify the acceleration and max speed during movement.

Can be overridden to choose to jump based on character velocity, base actor dimensions, etc.

Get the Character that owns UpdatedComponent.

Determine minimum delay between sending client updates to the server.

Returns the collision half-height when crouching (component scale is applied separately)

Returns current acceleration, computed from input vector each update.

Current move data being processed or handled.

Returns how far to rotate character during the time interval DeltaTime.

Get the lateral acceleration to use during falling movement.

Get current GroundMovementMode value.

If we have a movement base, get the velocity that should be imparted by that base, usually when jumping off of it.

Returns the location at the end of the last tick.

Returns the rotation Quat at the end of the last tick.

Returns the rotation at the end of the last tick.

Returns the velocity at the end of the last tick.

Returns maximum acceleration for the current state.

Returns maximum deceleration for the current state when braking (ie when there is no acceleration).

Compute the max jump height based on the JumpZVelocity velocity and gravity.

Compute the max jump height based on the JumpZVelocity velocity and gravity.

Returns maximum acceleration for the current state.

Return PrimitiveComponent we are based on (standing and walking on).

Returns MovementMode string

Get the struct used for server response RPC serialization.

Get Navigation data for the Character. Returns null if there is no associated nav data.

Get the struct used for client to server move RPC serialization.

Generate a random angle in degrees that is approximately equal between client and server.

Get the collision shape for the Pawn owner, possibly reduced in size depending on ShrinkMode.

Get the capsule extent for the Pawn owner, possibly reduced in size depending on ShrinkMode.

Returns The distance from the edge of the capsule within which we don't allow the character to perch on the edge of a surface.

Get a RootMotionSource from current root motion by name

Get a RootMotionSource from current root motion by ID

END IRVOAvoidanceInterface a shortcut function to be called instead of GetRVOAvoidanceUID when callee knows it's dealing with a char movement comp

Get the value of ServerLastTransformUpdateTimeStamp.

Compute remaining time step given remaining time and current iterations.

When moving the character, we should inform physics as to whether we are teleporting.

Returns the radius within which we can stand on the edge of a surface without falling (if this is a walkable surface).

Get the max angle in degrees of a walkable surface for the character.

Get the Z component of the normal of the steepest walkable surface for the character.

Handle a pending launch during an update. Returns true if the launch was triggered.

Limit the slide vector when falling if the resulting slide might boost the character faster upwards.

Allow custom handling when character hits a wall while swimming.

Trigger OnWalkingOffLedge event on CharacterOwner.

Returns true if we have Root Motion from animation to use in PerformMovement() physics.

Returns true if we have Root Motion from any source to use in PerformMovement() physics.

Return true if we have a valid CharacterOwner and UpdatedComponent.

Determine how deep in water the character is immersed.

Internal const check for client timestamp validity without side-effects.

Returns true if currently performing a movement update.

Verify that the supplied hit result is a valid landing spot when falling.

Return true if the hit result should be considered a walkable surface for the character.

Returns true if the character is in the 'Walking' movement mode.

Return true if the 2D distance to the impact point is inside the edge tolerance (CapsuleRadius minus a small rejection threshold).

Force this pawn to bounce off its current base, which isn't an acceptable base for it.

Jump onto shore from water

Compute distance to the floor from bottom sphere of capsule and store the result in FloorResult.

Sweeps a vertical trace to find the floor for the capsule at the given location.

Get the max angle in degrees of a walkable surface for the character.

Get the Z component of the normal of the steepest walkable surface for the character.

Queue a pending launch with velocity LaunchVel.

Limits the air control to use during falling movement, given an impact while falling.

Adjusts velocity when walking so that Z velocity is zero.

Call SaveBaseLocation() if not deferring updates (bDeferUpdateBasedMovement is false).

Update or defer updating of position based on Base movement

Move along the floor, using CurrentFloor and ComputeGroundMovementDelta() to get a movement direction.

Process a move at the given time stamp, given the compressed flags representing various events that occurred (ie jump).

On the client, receives a packed move response from the server, unpacks it by serializing into the MoveResponseContainer from GetMoveResponseDataContainer(), and passes the data container to ClientHandleMoveResponse().

Sends a move response from the server to the client (through character to avoid component RPC overhead), eventually calling MoveResponsePacked_ClientReceive() on the client.

Moves along the given movement direction using simple movement rules based on the current movement mode (usually used by simulated proxies).

Compute new falling velocity from given velocity and gravity.

Called if bNotifyApex is true and character has just passed the apex of its jump.

Notification that the character is stuck in geometry. Only called during walking movement.

END DEPRECATED movement RPCs.

Called by UCharacterMovementComponent::VerifyClientTimeStamp() when a client timestamp reset has been detected and is valid.

Called after MovementMode has changed.

Event triggered at the end of a movement update.

Called during ApplyRootMotionSource call, useful for project-specific alerts for "something is about to be altering our movement"

Called by UCharacterMovementComponent::ProcessClientTimeStampForTimeDiscrepancy() (on server) when the time from client moves significantly differs from the server time, indicating potential time manipulation by clients (speed hacks, significant network issues, client performance problems)

Event triggered when we are moving on a base but we are not able to move the full DeltaPosition because something has blocked us.

If ShouldPerformAirControlForPathFollowing() returns true, it will update Velocity and Acceleration to air control in the desired Direction for character using path following.

Movement functions broken out based on owner's network Role.

@note Movement update functions should only be called through StartNewPhysics()

Handle falling movement.

@note Movement update functions should only be called through StartNewPhysics()

Perform rotation over deltaTime

@note Movement update functions should only be called through StartNewPhysics()

@note Movement update functions should only be called through StartNewPhysics()

@note Movement update functions should only be called through StartNewPhysics()

Tick function called after physics (sync scene) has finished simulation, before cloth

Allows modifing avoidance velocity, called when bUseRVOPostProcess is set

Tick function called before physics

Processes client timestamps from ServerMoves, detects and protects against time discrepancy between client-reported times and server time Called by UCharacterMovementComponent::VerifyClientTimeStamp() for valid timestamps.

Handle landing against Hit surface over remaingTime and iterations, calling SetPostLandedPhysics() and starting the new movement mode.

Attempts to better align navmesh walking characters with underlying geometry (sometimes navmesh can differ quite significantly from geometry).

Register async callback with physics system.

Remove a RootMotionSource from current root motion by name

Remove a RootMotionSource from current root motion by ID

======================================================================== Here's how player movement prediction, replication and correction works in network games:

Restores Velocity to LastPreAdditiveVelocity during Root Motion Phys*() function calls

Revert to previous position OldLocation, return to being based on OldBase.

Round acceleration, for better consistency and lower bandwidth in networked games.

Update OldBaseLocation and OldBaseQuat if there is a valid movement base, and store the relative location/rotation if necessary.

Scale input acceleration, based on movement acceleration rate.

Check for Server-Client disagreement in position or other movement state important enough to trigger a client correction.

Check position error within ServerCheckClientError().

BEGIN DEPRECATED movement RPCs. Use the Packed versions above instead.

Handle movement data after it's unpacked from the ServerMovePacked_ServerReceive() call.

BEGIN DEPRECATED movement RPCs. Use the Packed versions above instead.

Check timestamps, generate a delta time, and pass through movement params to MoveAutonomous.

BEGIN DEPRECATED movement RPCs. Use the Packed versions above instead.

Replicated function sent by client to server - contains client movement and view info for two moves.

Replicated function sent by client to server - contains client movement and view info for two moves.

Replicated function sent by client to server - contains client movement and view info for two moves.

Replicated function sent by client to server - contains client movement and view info for two moves.

Replicated function sent by client to server - contains client movement and view info for two moves.

Replicated function sent by client to server - contains client movement and view info for two moves.

Have the server check if the client is outside an error tolerance, and queue a client adjustment if so.

Resending an (important) old move. Process it if not already processed.

Resending an (important) old move. Process it if not already processed.

Resending an (important) old move. Process it if not already processed.

The actual network RPCs for character movement are passed to ACharacter, which wrap to the _Implementation call here, to avoid Component RPC overhead.

On the server, receives packed move data from the Character RPC, unpacks them into the FCharacterNetworkMoveDataContainer returned from GetNetworkMoveDataContainer(), and passes the data container to ServerMove_HandleMoveData().

On the server, sends a packed move response to the client.

If ServerCheckClientError() does not find an error, this determines if the server should also copy the client's movement params rather than keep the server sim result.

Change avoidance state and registers in RVO manager if needed

Lock avoidance velocity

Update the base of the character, which is the PrimitiveComponent we are standing on.

Update the base of the character, using the given floor result if it is walkable, or null if not.

Sets collision half-height when crouching and updates dependent computations

Used internally to set the FCharacterNetworkMoveData currently being processed, either being serialized or replayed on the client, or being received and processed on the server.

Set movement mode to the default based on the current physics volume.

Set movement mode to use when returning to walking movement (either MOVE_Walking or MOVE_NavWalking).

Change movement mode.

Set custom struct used for server response RPC serialization.

Switch collision settings for NavWalking mode (ignore world collisions)

Set custom struct used for client to server move RPC serialization.

Use new physics after landing. Defaults to swimming if in water, walking otherwise.

Set the max angle in degrees of a walkable surface for the character. Also computes WalkableFloorZ.

Set the Z component of the normal of the steepest walkable surface for the character.

On the server if we know we are having our replication rate throttled, this method checks if important replicated properties have changed that should cause us to return to the normal replication rate.

Whether Character should go into falling mode when walking and changing position, based on an old and new floor result (both of which are considered walkable).