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

@@ -659,27 +659,63 @@ 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 end)
+{
+	if (ent->v.movetype == MOVETYPE_FLYMISSILE)
+		return 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
+		return SV_Move (ent->v.origin, ent->v.mins, ent->v.maxs, end, MOVE_NOMONSTERS, ent);
+	else
+		return SV_Move (ent->v.origin, 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, end);
 
-	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);
+	// 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. That can
+	// happen against the pusher the entity rests on when float rounding at the
+	// contact leaves it an epsilon deep after a carry; un-embed and redo the
+	// move so it collides normally.
+	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)
+		{
+			int step;
+			for (step = 1; step <= 4; step++)
+			{
+				vec3_t org;
+				VectorCopy (ent->v.origin, org);
+				org[2] += step * DIST_EPSILON;
+				if (!SV_ClipMoveToEntity (ground, org, ent->v.mins, ent->v.maxs, org, CONTENTMASK_ANYSOLID).startsolid)
+				{
+					VectorCopy (org, ent->v.origin);
+					trace = SV_PushEntityMove (ent, end);
+					break;
+				}
+			}
+		}
+	}
 
 	if (trace.ent)
 		assert_always (!trace.ent->free);
@@ -696,12 +732,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 +774,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 +809,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 +907,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 +938,65 @@ static void SV_PushMove (edict_t *pusher, float movetime)
 			if (check->v.mins[0] == check->v.maxs[0])
 				continue;
 
+			// a rider that ends up marginally inside the pusher (float rounding
+			// at the contact) is not a real squeeze: try epsilon nudges up and
+			// along the push direction before failing the move. This must run
+			// before the corpse path below, or items (SOLID_TRIGGER) get their
+			// bbox zeroed over a rounding error. Genuine squeezes embed far
+			// deeper than these nudges and still crush.
+			if (riding && block == pusher && SV_GameplayFixElevators (check))
+			{
+				vec3_t	 pushedorg, movedir;
+				int		 attempt;
+				qboolean cleared = false;
+
+				VectorCopy (check->v.origin, pushedorg);
+				VectorCopy (move, movedir);
+				VectorNormalize (movedir);
+
+				for (attempt = 0; attempt < 6 && !cleared; attempt++)
+				{
+					const float scale = (attempt < 3) ? DIST_EPSILON : 2.f * DIST_EPSILON;
+					vec3_t		nudge = {0.f, 0.f, 0.f};
+
+					if (attempt % 3 == 0)
+						nudge[2] = scale;
+					else if (attempt % 3 == 1)
+						VectorScale (movedir, scale, nudge);
+					else
+					{
+						VectorScale (movedir, scale, nudge);
+						nudge[2] += scale;
+					}
+
+					VectorAdd (pushedorg, nudge, check->v.origin);
+					cleared = !SV_TestEntityPosition (check);
+				}
+				if (cleared)
+				{
+					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