Make pusher/rider contact robust against float rounding (#963, #700)

Three changes to SV_PushMove/SV_PushEntity:

1. Pusher positions are evaluated analytically from an anchor captured
   when the leg's velocity was set, instead of accumulating
   velocity*movetime rounding every tick. Position error stays at a
   couple of ulps regardless of leg length and the final partial step
   lands on the leg destination. QC-side changes to origin, velocity or
   ltime re-anchor the trajectory, degrading to the old incremental
   behavior for that stretch.

2. Riders are carried to a target re-derived from the pusher's new
   origin each tick rather than integrating the same move in parallel at
   a different float magnitude, so the relative offset stays bounded.

3. Marginal interpenetration is no longer fatal: a rider that a blocked
   verdict finds an epsilon inside the pusher gets nudged out (up and
   along the push direction, up to 2*DIST_EPSILON) before the move is
   failed - and this now runs before the corpse path, which used to
   permanently zero the bbox of items over a rounding error. A move
   trace that starts solid inside the entity's groundentity pusher
   un-embeds and retraces instead of gliding through the brush, which
   was how items fell through elevators.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: Axel-Reactor

Quake/pr_edict.c

@@ -81,6 +81,7 @@ edict_t *ED_Alloc (void)
 		assert (e->free);
 		memset (&e->v, 0, qcvm->progs->entityfields * 4);
 		e->free = false;
+		e->push_anchor_valid = false; // don't inherit a pusher trajectory anchor from the edict's previous life
 
 		// pop HEAD
 		qcvm->free_list.head_index = (qcvm->free_list.head_index + 1) % MAX_EDICTS;

Quake/progs.h

@@ -70,6 +70,17 @@ typedef struct edict_s
 	vec3_t		   predthinkpos; /* expected edict origin once its nextthink arrives (sv_smoothplatformlerps) */
 	float		   lastthink;	 /* time when predthinkpos was updated, or 0 if not valid (sv_smoothplatformlerps) */
 
+	/* pusher trajectory anchor (SV_PushMove): position is evaluated analytically from the
+	   origin/ltime captured when the current leg's velocity was set, instead of accumulating
+	   velocity*movetime rounding every tick. last* hold what SV_PushMove wrote last, so any
+	   QC-side change to origin or ltime is detected and re-anchors the trajectory. */
+	vec3_t	 push_anchor_origin;
+	vec3_t	 push_anchor_velocity;
+	vec3_t	 push_anchor_lastorigin;
+	float	 push_anchor_ltime;
+	float	 push_anchor_lastltime;
+	qboolean push_anchor_valid;
+
 	float	 freetime; /* sv.time when the object was freed */
 	qboolean free;
 

Quake/sv_phys.c

@@ -57,6 +57,13 @@ qboolean sv_analyticphysics_frame = true; // sv_analyticphysics latched per SV_P
 
 #define MOVE_EPSILON 0.01
 
+// Upper bound on how deep contact noise can put an entity inside the surface it
+// rests on: the collision trace places contacts up to DIST_EPSILON off the plane,
+// and coordinate rounding at map scale adds at most 2^-10. A sweep started this
+// far above the resting position is therefore guaranteed to begin outside the
+// ground surface; any overlap that survives it is real interpenetration.
+#define PUSH_CONTACT_EPSILON (2 * DIST_EPSILON)
+
 static void SV_Physics_Toss (edict_t *ent);
 
 // For usage by SV_PushMove, allocate at max possible size,
@@ -659,27 +666,64 @@ PUSHMOVE
 ===============================================================================
 */
 
+cvar_t sv_gameplayfix_elevators = {"sv_gameplayfix_elevators", "2", CVAR_ARCHIVE}; // 0=off; 1=clients only; 2=all entities
+
+static qboolean SV_GameplayFixElevators (edict_t *ent)
+{
+	return sv_gameplayfix_elevators.value >= 2.f || (sv_gameplayfix_elevators.value && NUM_FOR_EDICT (ent) <= svs.maxclients);
+}
+
+static trace_t SV_PushEntityMove (edict_t *ent, vec3_t start, vec3_t end)
+{
+	if (ent->v.movetype == MOVETYPE_FLYMISSILE)
+		return SV_Move (start, ent->v.mins, ent->v.maxs, end, MOVE_MISSILE, ent);
+	else if (ent->v.solid == SOLID_TRIGGER || ent->v.solid == SOLID_NOT)
+		// only clip against bmodels
+		return SV_Move (start, ent->v.mins, ent->v.maxs, end, MOVE_NOMONSTERS, ent);
+	else
+		return SV_Move (start, ent->v.mins, ent->v.maxs, end, MOVE_NORMAL, ent);
+}
+
 /*
 ============
-SV_PushEntity
+SV_PushEntityTo
 
 Does not change the entities velocity at all
 ============
 */
-static trace_t SV_PushEntity (edict_t *ent, vec3_t push)
+static trace_t SV_PushEntityTo (edict_t *ent, vec3_t end)
 {
 	trace_t trace;
-	vec3_t	end;
 
-	VectorAdd (ent->v.origin, push, end);
+	trace = SV_PushEntityMove (ent, ent->v.origin, end);
+
+	// a move that starts inside a solid registers no impact against it, so the
+	// entity would glide through the brush and fall out the far side. Against
+	// the pusher the entity rests on such an overlap is contact noise, bounded
+	// by PUSH_CONTACT_EPSILON: a single sweep against the pusher from that far
+	// above is guaranteed to start outside and stops at the exact contact
+	// coordinate. Place the entity there and redo the move so it collides
+	// normally; if even the sweep start is inside, the overlap is real and
+	// vanilla behavior applies.
+	if (trace.startsolid && ent->v.groundentity && SV_GameplayFixElevators (ent))
+	{
+		edict_t *ground = PROG_TO_EDICT (ent->v.groundentity);
+		if (ground != qcvm->edicts && !ground->free && ground->v.movetype == MOVETYPE_PUSH && ground->v.solid == SOLID_BSP &&
+			SV_ClipMoveToEntity (ground, ent->v.origin, ent->v.mins, ent->v.maxs, ent->v.origin, CONTENTMASK_ANYSOLID).startsolid)
+		{
+			vec3_t	above;
+			trace_t exit;
 
-	if (ent->v.movetype == MOVETYPE_FLYMISSILE)
-		trace = SV_Move (ent->v.origin, ent->v.mins, ent->v.maxs, end, MOVE_MISSILE, ent);
-	else if (ent->v.solid == SOLID_TRIGGER || ent->v.solid == SOLID_NOT)
-		// only clip against bmodels
-		trace = SV_Move (ent->v.origin, ent->v.mins, ent->v.maxs, end, MOVE_NOMONSTERS, ent);
-	else
-		trace = SV_Move (ent->v.origin, ent->v.mins, ent->v.maxs, end, MOVE_NORMAL, ent);
+			VectorCopy (ent->v.origin, above);
+			above[2] += PUSH_CONTACT_EPSILON;
+			exit = SV_ClipMoveToEntity (ground, above, ent->v.mins, ent->v.maxs, ent->v.origin, CONTENTMASK_ANYSOLID);
+			if (!exit.startsolid && exit.fraction < 1)
+			{
+				VectorCopy (exit.endpos, ent->v.origin);
+				trace = SV_PushEntityMove (ent, ent->v.origin, end);
+			}
+		}
+	}
 
 	if (trace.ent)
 		assert_always (!trace.ent->free);
@@ -696,12 +740,26 @@ static trace_t SV_PushEntity (edict_t *ent, vec3_t push)
 	return trace;
 }
 
+/*
+============
+SV_PushEntity
+
+Does not change the entities velocity at all
+============
+*/
+static trace_t SV_PushEntity (edict_t *ent, vec3_t push)
+{
+	vec3_t end;
+
+	VectorAdd (ent->v.origin, push, end);
+	return SV_PushEntityTo (ent, end);
+}
+
 /*
 ============
 SV_PushMove
 ============
 */
-cvar_t sv_gameplayfix_elevators = {"sv_gameplayfix_elevators", "2", CVAR_ARCHIVE}; // 0=off; 1=clients only; 2=all entities
 
 static void SV_PushMove (edict_t *pusher, float movetime)
 {
@@ -724,9 +782,29 @@ static void SV_PushMove (edict_t *pusher, float movetime)
 		return;
 	}
 
+	// evaluate the new position analytically from the anchor captured when this
+	// leg's velocity was set: position error stays at a couple of ulps regardless
+	// of leg length and the final partial step lands on the leg destination,
+	// instead of accumulating velocity*movetime rounding every tick. The last*
+	// mismatch cases (QC touched origin or ltime, or a blocked move was reverted)
+	// re-anchor at the current state, which degrades to the vanilla incremental
+	// behavior for that stretch.
+	if (!pusher->push_anchor_valid || !VectorCompare (pusher->v.velocity, pusher->push_anchor_velocity) ||
+		!VectorCompare (pusher->v.origin, pusher->push_anchor_lastorigin) || pusher->v.ltime != pusher->push_anchor_lastltime)
+	{
+		VectorCopy (pusher->v.origin, pusher->push_anchor_origin);
+		VectorCopy (pusher->v.velocity, pusher->push_anchor_velocity);
+		pusher->push_anchor_ltime = pusher->v.ltime;
+		pusher->push_anchor_valid = true;
+	}
+
+	const float newltime = pusher->v.ltime + movetime;
+	vec3_t		neworigin;
+
 	for (i = 0; i < 3; i++)
 	{
-		move[i] = pusher->v.velocity[i] * movetime;
+		neworigin[i] = pusher->push_anchor_origin[i] + pusher->push_anchor_velocity[i] * (newltime - pusher->push_anchor_ltime);
+		move[i] = neworigin[i] - pusher->v.origin[i];
 		mins[i] = pusher->v.absmin[i] + move[i];
 		maxs[i] = pusher->v.absmax[i] + move[i];
 		// the grid query must span the whole sweep: riders rest on the pre-move
@@ -739,8 +817,10 @@ static void SV_PushMove (edict_t *pusher, float movetime)
 
 	// move the pusher to it's final position
 
-	VectorAdd (pusher->v.origin, move, pusher->v.origin);
-	pusher->v.ltime += movetime;
+	VectorCopy (neworigin, pusher->v.origin);
+	pusher->v.ltime = newltime;
+	VectorCopy (neworigin, pusher->push_anchor_lastorigin);
+	pusher->push_anchor_lastltime = newltime;
 	SV_LinkEdict (pusher, false);
 
 	// see if any solid entities are inside the final position
@@ -835,9 +915,17 @@ static void SV_PushMove (edict_t *pusher, float movetime)
 			|| solid_backup == SOLID_BBOX	   // normally boxes
 			|| solid_backup == SOLID_SLIDEBOX) // normally monsters
 		{
+			// carry the entity to a target re-derived from the pusher's new
+			// origin: the relative offset stays bounded instead of drifting
+			// apart when both origins integrate the same move in parallel at
+			// different float magnitudes
+			vec3_t dest;
+			for (i = 0; i < 3; i++)
+				dest[i] = pusher->v.origin[i] + (entorig[i] - pushorig[i]);
+
 			// try moving the contacted entity
 			pusher->v.solid = SOLID_NOT;
-			SV_PushEntity (check, move);
+			SV_PushEntityTo (check, dest);
 
 			// if it is still inside the pusher, block
 			if (pusher->v.skin < 0)
@@ -858,28 +946,54 @@ static void SV_PushMove (edict_t *pusher, float movetime)
 			if (check->v.mins[0] == check->v.maxs[0])
 				continue;
 
+			// with the offset-preserving carry above, every rider contact keeps
+			// the move trace's DIST_EPSILON gap except one: the ground contact,
+			// which gravity re-closes to exactly zero every tick. Rounding can
+			// therefore only put a rider inside the pusher through that contact,
+			// along +z, no deeper than PUSH_CONTACT_EPSILON. Recover the exact
+			// contact coordinate with a single sweep from that far above, which
+			// the bound guarantees starts outside. This must run before the
+			// corpse path below, or items (SOLID_TRIGGER) get their bbox zeroed
+			// over a rounding error; anything still solid after the sweep is a
+			// genuine squeeze and crushes as before.
+			if (riding && block == pusher && SV_GameplayFixElevators (check))
+			{
+				vec3_t	pushedorg, above;
+				trace_t settle;
+
+				VectorCopy (check->v.origin, pushedorg);
+				VectorCopy (check->v.origin, above);
+				above[2] += PUSH_CONTACT_EPSILON;
+				settle = SV_PushEntityMove (check, above, pushedorg);
+				if (!settle.startsolid)
+				{
+					VectorCopy (settle.endpos, check->v.origin);
+					if (!SV_TestEntityPosition (check))
+					{
+						SV_LinkEdict (check, false);
+						continue;
+					}
+					VectorCopy (pushedorg, check->v.origin);
+				}
+			}
+
 			if (check->v.solid == SOLID_NOT || check->v.solid == SOLID_TRIGGER)
 			{ // corpse
 				check->v.mins[0] = check->v.mins[1] = 0;
 				VectorCopy (check->v.mins, check->v.maxs);
 				continue;
 			}
 
-			// try moving the entity up a bit if it's blocked by the pusher while also standing on it
-			if (riding && block == pusher &&
-				(sv_gameplayfix_elevators.value >= 2.f || (sv_gameplayfix_elevators.value && NUM_FOR_EDICT (check) <= svs.maxclients)))
-			{
-				check->v.origin[2] += DIST_EPSILON;
-				if (!SV_TestEntityPosition (check))
-					continue;
-			}
-
 			VectorCopy (entorig, check->v.origin);
 			SV_LinkEdict (check, true);
 
 			VectorCopy (pushorig, pusher->v.origin);
 			SV_LinkEdict (pusher, false);
 			pusher->v.ltime -= movetime;
+			// the reverted ltime no longer matches push_anchor_lastltime, so the
+			// next attempt re-anchors here and retries incrementally until the
+			// obstacle is gone
+			VectorCopy (pushorig, pusher->push_anchor_lastorigin);
 
 			// if the pusher has a "blocked" function, call it
 			// otherwise, just stay in place until the obstacle is gone