Snap da sentinel like hitlag

- Added a hitlag cap of 18 frames (can be decreased to 12 if it's too much)
- Hitlag amount can't be reduced, only increased
- Hitlag added is the same between both objects, instead of being different between the two
- Objects in hitlag can be interacted with again with TryMove (I was too nervous of it but it's fine in Snap lol)
- Rebalanced the damage hitlag lengths to make it feel relatively the same with all of the above considered

src/k_kart.c

@@ -3021,74 +3021,65 @@ angle_t K_MomentumAngle(mobj_t *mo)
 	}
 }
 
+void K_AddHitLag(mobj_t *mo, INT32 tics)
+{
+	if (mo == NULL || P_MobjWasRemoved(mo))
+	{
+		return;
+	}
+
+	if (mo->player != NULL && P_IsLocalPlayer(mo->player))
+	{
+		// temporary :)
+		CONS_Printf("tics: %d\n", tics);
+	}
+
+	mo->hitlag += tics;
+	mo->hitlag = min(mo->hitlag, MAXHITLAGTICS);
+}
+
 void K_SetHitLagForObjects(mobj_t *mo1, mobj_t *mo2, INT32 tics)
 {
-	boolean mo1valid = (mo1 && !P_MobjWasRemoved(mo1));
-	boolean mo2valid = (mo2 && !P_MobjWasRemoved(mo2));
-
-	INT32 tics1 = tics;
-	INT32 tics2 = tics;
+	INT32 finalTics = tics;
 
 	if (tics <= 0)
 	{
 		return;
 	}
 
-	if (mo1valid == true && mo2valid == true)
+	if ((mo1 && !P_MobjWasRemoved(mo1)) == true && (mo2 && !P_MobjWasRemoved(mo2)) == true)
 	{
-		const INT32 mintics = tics;
-		const fixed_t ticaddfactor = mapobjectscale * 8;
+		const fixed_t speedTicFactor = (mapobjectscale * 8);
+		const INT32 angleTicFactor = ANGLE_22h;
 
 		const fixed_t mo1speed = FixedHypot(FixedHypot(mo1->momx, mo1->momy), mo1->momz);
 		const fixed_t mo2speed = FixedHypot(FixedHypot(mo2->momx, mo2->momy), mo2->momz);
-		const fixed_t speeddiff = mo2speed - mo1speed;
+		const fixed_t speedDiff = abs(mo2speed - mo1speed);
 
-		const fixed_t scalediff = mo2->scale - mo1->scale;
+		const fixed_t scaleDiff = abs(mo2->scale - mo1->scale);
 
-		const angle_t mo1angle = K_MomentumAngle(mo1);
-		const angle_t mo2angle = K_MomentumAngle(mo2);
+		angle_t mo1angle = K_MomentumAngle(mo1);
+		angle_t mo2angle = K_MomentumAngle(mo2);
+		INT32 angleDiff = 0;
 
-		angle_t anglediff = mo1angle - mo2angle;
-		fixed_t anglemul = FRACUNIT;
-
-		if (anglediff > ANGLE_180)
+		if (mo1speed > 0 && mo2speed > 0)
 		{
-			anglediff = InvAngle(anglediff);
+			// If either object is completely not moving, their speed doesn't matter.
+			angleDiff = AngleDelta(mo1angle, mo2angle);
 		}
 
-		anglemul = FRACUNIT + (AngleFixed(anglediff) / 180); // x1.0 at 0, x1.5 at 90, x2.0 at 180
+		// Add extra "damage" based on what was happening to the objects on impact.
+		finalTics += (FixedMul(speedDiff, FRACUNIT + scaleDiff) / speedTicFactor) + (angleDiff / angleTicFactor);
 
-		/*
-		CONS_Printf("anglemul: %f\n", FIXED_TO_FLOAT(anglemul));
-		CONS_Printf("speeddiff: %f\n", FIXED_TO_FLOAT(speeddiff));
-		CONS_Printf("scalediff: %f\n", FIXED_TO_FLOAT(scalediff));
-		*/
-
-		tics1 += FixedMul(speeddiff, FixedMul(anglemul, FRACUNIT + scalediff)) / ticaddfactor;
-		tics2 += FixedMul(-speeddiff, FixedMul(anglemul, FRACUNIT - scalediff)) / ticaddfactor;
-
-		if (tics1 < mintics)
+		// This shouldn't happen anymore, but just in case something funky happens.
+		if (finalTics < tics)
 		{
-			tics1 = mintics;
-		}
-
-		if (tics2 < mintics)
-		{
-			tics2 = mintics;
+			finalTics = tics;
 		}
 	}
 
-	//CONS_Printf("tics1: %d, tics2: %d\n", tics1, tics2);
-
-	if (mo1valid == true)
-	{
-		mo1->hitlag = max(tics1, mo1->hitlag);
-	}
-
-	if (mo2valid == true)
-	{
-		mo2->hitlag = max(tics2, mo2->hitlag);
-	}
+	K_AddHitLag(mo1, finalTics);
+	K_AddHitLag(mo2, finalTics);
 }
 
 void K_DoInstashield(player_t *player)

src/k_kart.h

@@ -19,6 +19,7 @@ Make sure this matches the actual number of states
 */
 #define KART_NUMINVSPARKLESANIM 12
 
+#define MAXHITLAGTICS 18 //12
 
 player_t *K_GetItemBoxPlayer(mobj_t *mobj);
 angle_t K_ReflectAngle(angle_t angle, angle_t against, fixed_t maxspeed, fixed_t yourspeed);
@@ -55,6 +56,7 @@ void K_KartPlayerHUDUpdate(player_t *player);
 void K_KartPlayerThink(player_t *player, ticcmd_t *cmd);
 void K_KartPlayerAfterThink(player_t *player);
 angle_t K_MomentumAngle(mobj_t *mo);
+void K_AddHitLag(mobj_t *mo, INT32 tics);
 void K_SetHitLagForObjects(mobj_t *mo1, mobj_t *mo2, INT32 tics);
 void K_DoInstashield(player_t *player);
 void K_BattleAwardHit(player_t *player, player_t *victim, mobj_t *inflictor, UINT8 bumpersRemoved);

src/p_inter.c

@@ -960,7 +960,7 @@ void P_KillMobj(mobj_t *target, mobj_t *inflictor, mobj_t *source, UINT8 damaget
 	if (LUAh_MobjDeath(target, inflictor, source, damagetype) || P_MobjWasRemoved(target))
 		return;
 
-	//K_SetHitLagForObjects(target, inflictor, 15);
+	//K_SetHitLagForObjects(target, inflictor, MAXHITLAGTICS);
 
 	// SRB2kart
 	// I wish I knew a better way to do this
@@ -1737,7 +1737,7 @@ static boolean P_KillPlayer(player_t *player, mobj_t *inflictor, mobj_t *source,
 	}
 
 	K_DropEmeraldsFromPlayer(player, player->emeralds);
-	K_SetHitLagForObjects(player->mo, inflictor, 15);
+	K_SetHitLagForObjects(player->mo, inflictor, MAXHITLAGTICS);
 
 	player->carry = CR_NONE;
 
@@ -1797,7 +1797,7 @@ boolean P_DamageMobj(mobj_t *target, mobj_t *inflictor, mobj_t *source, INT32 da
 	player_t *player;
 	boolean force = false;
 
-	INT32 laglength = 10;
+	INT32 laglength = 6;
 	INT32 kinvextend = 0;
 
 	if (objectplacing)
@@ -1816,7 +1816,7 @@ boolean P_DamageMobj(mobj_t *target, mobj_t *inflictor, mobj_t *source, INT32 da
 	if (((damagetype & DMG_TYPEMASK) == DMG_STING)
 	|| ((inflictor && !P_MobjWasRemoved(inflictor)) && inflictor->type == MT_BANANA && inflictor->health <= 1))
 	{
-		laglength = 5;
+		laglength = 2;
 	}
 
 	// Everything above here can't be forced.

src/p_map.c

@@ -2408,11 +2408,13 @@ boolean P_TryMove(mobj_t *thing, fixed_t x, fixed_t y, boolean allowdropoff)
 	if (radius < mapobjectscale)
 		radius = mapobjectscale;
 
+#if 0
 	if (thing->hitlag > 0)
 	{
 		// Do not move during hitlag
 		return false;
 	}
+#endif
 
 	do {
 		if (thing->flags & MF_NOCLIP) {