WIP: Support >60Hz (2nd try)

neo/d3xp/Actor.cpp

@@ -1668,6 +1668,9 @@ bool idActor::StartRagdoll( void ) {
 		return true;
 	}
 
+	// dezo2, modified entity mass (must be here, mass is zeroed in StartFromCurrentPose)
+	float mass_mod = GetPhysics()->GetMass() * idMath::Pow( gameLocal.gameTicScale, 2.0f );
+
 	// disable the monster bounding box
 	GetPhysics()->DisableClip();
 
@@ -1702,6 +1705,9 @@ bool idActor::StartRagdoll( void ) {
 
 	RemoveAttachments();
 
+	// dezo2, use modified entity mass to reduce ragdoll movement at high FPS
+	GetPhysics()->SetMass( mass_mod );
+
 	return true;
 }
 

neo/d3xp/Game_local.cpp

@@ -205,6 +205,10 @@ idGameLocal::idGameLocal
 */
 idGameLocal::idGameLocal() {
 	Clear();
+	// DG: some sane default values until the proper values are set by SetGameHz()
+	msec = gameMsec = 16;
+	gameHz = 60;
+	gameTicScale = 1.0f;
 }
 
 /*
@@ -626,6 +630,7 @@ void idGameLocal::SaveGame( idFile *f ) {
 	savegame.WriteInt( time );
 
 #ifdef _D3XP
+	savegame.WriteInt( gameMsec ); // DG: added with INTERNAL_SAVEGAME_VERSION 2
 	savegame.WriteInt( msec );
 #endif
 
@@ -1535,7 +1540,15 @@ bool idGameLocal::InitFromSaveGame( const char *mapName, idRenderWorld *renderWo
 	savegame.ReadInt( time );
 
 #ifdef _D3XP
+	int savedGameMsec = 16;
+	if( savegame.GetInternalSavegameVersion() > 1 ) {
+		savegame.ReadInt( savedGameMsec );
+	}
+	float gameMsecScale = float(gameMsec) / float(savedGameMsec);
+
 	savegame.ReadInt( msec );
+	// DG: the saved msec must be scaled, in case com_gameHz has a different value now
+	msec *= gameMsecScale;
 #endif
 
 	savegame.ReadInt( vacuumAreaNum );
@@ -1558,12 +1571,15 @@ bool idGameLocal::InitFromSaveGame( const char *mapName, idRenderWorld *renderWo
 
 	fast.Restore( &savegame );
 	slow.Restore( &savegame );
+	fast.msec *= gameMsecScale; // DG: the saved value must be scaled, in case com_gameHz has a different value now
+	slow.msec *= gameMsecScale; //     same here
 
 	int blah;
 	savegame.ReadInt( blah );
 	slowmoState = (slowmoState_t)blah;
 
 	savegame.ReadFloat( slowmoMsec );
+	slowmoMsec *= gameMsecScale; // DG: the saved value must be scaled, in case com_gameHz has a different value now
 	savegame.ReadBool( quickSlowmoReset );
 
 	if ( slowmoState == SLOWMO_STATE_OFF ) {
@@ -2425,11 +2441,11 @@ void idGameLocal::SortActiveEntityList( void ) {
 idGameLocal::RunTimeGroup2
 ================
 */
-void idGameLocal::RunTimeGroup2() {
+void idGameLocal::RunTimeGroup2( int msec_fast ) {  // dezo2: add argument for high-fps support
 	idEntity *ent;
 	int num = 0;
 
-	fast.Increment();
+	fast.Increment( msec_fast );
 	fast.Get( time, previousTime, msec, framenum, realClientTime );
 
 	for( ent = activeEntities.Next(); ent != NULL; ent = ent->activeNode.Next() ) {
@@ -2445,6 +2461,13 @@ void idGameLocal::RunTimeGroup2() {
 }
 #endif
 
+// DG: returns number of milliseconds for this frame, based on gameLocal.gameHz
+//     either 1000/gameHz or 1000/gameHz + 1, so the frametimes of gameHz frames add up to 1000ms
+static int CalcMSec( long long framenum ) {
+	long long divisor = 100LL * gameLocal.gameHz;
+	return int( (framenum * 100000LL) / divisor - ((framenum-1) * 100000LL) / divisor );
+}
+
 /*
 ================
 idGameLocal::RunFrame
@@ -2488,6 +2511,12 @@ gameReturn_t idGameLocal::RunFrame(const usercmd_t* clientCmds) {
 		// update the game time
 		framenum++;
 		previousTime = time;
+		// dezo2/DG: for high-fps support, calculate the frametime msec every frame
+		//           the length actually varies between 1000/gameHz and (1000/gameHz) + 1
+		//           so the sum of gameHz frames is 1000 (while still keeping integer frametimes)
+		int msec_fast = CalcMSec( framenum );
+		if ( slowmoState == SLOWMO_STATE_OFF )
+			msec = msec_fast;
 		time += msec;
 		realClientTime = time;
 
@@ -2585,7 +2614,7 @@ gameReturn_t idGameLocal::RunFrame(const usercmd_t* clientCmds) {
 		}
 
 #ifdef _D3XP
-		RunTimeGroup2();
+		RunTimeGroup2( msec_fast );  // dezo2: pass msec_fast for better high-fps support
 #endif
 
 		// remove any entities that have stopped thinking
@@ -4913,10 +4942,10 @@ void idGameLocal::ComputeSlowMsec() {
 
 	// do any necessary ramping
 	if ( slowmoState == SLOWMO_STATE_RAMPUP ) {
-		delta = 4 - slowmoMsec;
+		delta = gameMsec * 0.25f - slowmoMsec; // DG: adjust to support com_gameHz
 
 		if ( fabs( delta ) < g_slowmoStepRate.GetFloat() ) {
-			slowmoMsec = 4;
+			slowmoMsec = gameMsec * 0.25f; // DG: adjust to support com_gameHz (was 4 = 16/4)
 			slowmoState = SLOWMO_STATE_ON;
 		}
 		else {
@@ -4928,10 +4957,10 @@ void idGameLocal::ComputeSlowMsec() {
 		}
 	}
 	else if ( slowmoState == SLOWMO_STATE_RAMPDOWN ) {
-		delta = 16 - slowmoMsec;
+		delta = gameMsec - slowmoMsec; // DG: adjust to support com_gameHz
 
 		if ( fabs( delta ) < g_slowmoStepRate.GetFloat() ) {
-			slowmoMsec = 16;
+			slowmoMsec = gameMsec; // DG: adjust to support com_gameHz
 			slowmoState = SLOWMO_STATE_OFF;
 			if ( gameSoundWorld ) {
 				gameSoundWorld->SetSlowmo( false );
@@ -5043,3 +5072,24 @@ idGameLocal::GetMapLoadingGUI
 ===============
 */
 void idGameLocal::GetMapLoadingGUI( char gui[ MAX_STRING_CHARS ] ) { }
+
+// DG: Added for configurable framerate
+void idGameLocal::SetGameHz( float hz, float frametime, float ticScaleFactor )
+{
+	gameHz = hz;
+	int oldGameMsec = gameMsec;
+	gameMsec = frametime;
+	gameTicScale = ticScaleFactor;
+
+	if ( slowmoState == SLOWMO_STATE_OFF ) {
+		// if slowmo is off, msec, slowmoMsec and slow/fast.msec should all be set to gameMsec
+		msec = slowmoMsec = slow.msec = fast.msec = gameMsec;
+	} else {
+		// otherwise the msec values must be scaled accordingly
+		float gameMsecScale = frametime / float(oldGameMsec);
+		msec *= gameMsecScale;
+		slowmoMsec *= gameMsecScale;
+		fast.msec *= gameMsecScale;
+		slow.msec *= gameMsecScale;
+	}
+}

neo/d3xp/Game_local.h

@@ -233,7 +233,7 @@ struct timeState_t {
 	void				Get( int& t, int& pt, int& ms, int& f, int& rct )	{ t = time; pt = previousTime; ms = msec; f = framenum; rct = realClientTime; };
 	void				Save( idSaveGame *savefile ) const	{ savefile->WriteInt( time ); savefile->WriteInt( previousTime ); savefile->WriteInt( msec ); savefile->WriteInt( framenum ); savefile->WriteInt( realClientTime ); }
 	void				Restore( idRestoreGame *savefile )	{ savefile->ReadInt( time ); savefile->ReadInt( previousTime ); savefile->ReadInt( msec ); savefile->ReadInt( framenum ); savefile->ReadInt( realClientTime ); }
-	void				Increment()											{ framenum++; previousTime = time; time += msec; realClientTime = time; };
+	void				Increment(int _msec)				{ framenum++; previousTime = time; msec = _msec; time += msec; realClientTime = time; };  // dezo2: update msec
 };
 
 enum slowmoState_t {
@@ -300,6 +300,11 @@ class idGameLocal : public idGame {
 	int						time;					// in msec
 	int						msec;					// time since last update in milliseconds
 
+	// DG: added for configurable framerate
+	int						gameMsec;				// length of one frame/tic in milliseconds - TODO: make float?
+	int						gameHz;					// current gameHz value (tic-rate, FPS)
+	float					gameTicScale;			// gameHz/60 factor to multiply delays in tics (that assume 60fps) with
+
 	int						vacuumAreaNum;			// -1 if level doesn't have any outside areas
 
 	gameType_t				gameType;
@@ -341,7 +346,7 @@ class idGameLocal : public idGame {
 	virtual void			GetBestGameType( const char* map, const char* gametype, char buf[ MAX_STRING_CHARS ] );
 
 	void					ComputeSlowMsec();
-	void					RunTimeGroup2();
+	void					RunTimeGroup2( int msec_fast );  // dezo2: add argument for high-fps support
 
 	void					ResetSlowTimeVars();
 	void					QuickSlowmoReset();
@@ -397,6 +402,9 @@ class idGameLocal : public idGame {
 
 	virtual void				GetMapLoadingGUI( char gui[ MAX_STRING_CHARS ] );
 
+	// DG: Added for configurable framerate
+	virtual void			SetGameHz( float hz, float frametime, float ticScaleFactor );
+
 	// ---------------------- Public idGameLocal Interface -------------------
 
 	void					Printf( const char *fmt, ... ) const id_attribute((format(printf,2,3)));
@@ -512,7 +520,7 @@ class idGameLocal : public idGame {
 
 private:
 	const static int		INITIAL_SPAWN_COUNT = 1;
-	const static int		INTERNAL_SAVEGAME_VERSION = 1; // DG: added this for >= 1305 savegames
+	const static int		INTERNAL_SAVEGAME_VERSION = 2; // DG: added this for >= 1305 savegames
 
 	idStr					mapFileName;			// name of the map, empty string if no map loaded
 	idMapFile *				mapFile;				// will be NULL during the game unless in-game editing is used

neo/d3xp/Player.cpp

@@ -2152,7 +2152,7 @@ void idPlayer::Save( idSaveGame *savefile ) const {
 	savefile->WriteInt( numProjectileHits );
 
 	savefile->WriteBool( airless );
-	savefile->WriteInt( airTics );
+	savefile->WriteInt( (int)airTics );
 	savefile->WriteInt( lastAirDamage );
 
 	savefile->WriteBool( gibDeath );
@@ -2420,7 +2420,11 @@ void idPlayer::Restore( idRestoreGame *savefile ) {
 	savefile->ReadInt( numProjectileHits );
 
 	savefile->ReadBool( airless );
-	savefile->ReadInt( airTics );
+	// DG: I made made airTics float for high-fps (where we have fractions of 60Hz tics),
+	//     but for saving ints should still suffice (and this preserves savegame compat)
+	int iairTics;
+	savefile->ReadInt( iairTics );
+	airTics = iairTics;
 	savefile->ReadInt( lastAirDamage );
 
 	savefile->ReadBool( gibDeath );
@@ -3231,9 +3235,14 @@ void idPlayer::DrawHUD( idUserInterface *_hud ) {
 			if ( weapon.GetEntity()->GetGrabberState() == 1 || weapon.GetEntity()->GetGrabberState() == 2 ) {
 				cursor->SetStateString( "grabbercursor", "1" );
 				cursor->SetStateString( "combatcursor", "0" );
+				cursor->SetStateBool("scaleto43", false);   // dezo2, unscaled
+				cursor->StateChanged(gameLocal.realClientTime);   // dezo2, set state
 			} else {
 				cursor->SetStateString( "grabbercursor", "0" );
 				cursor->SetStateString( "combatcursor", "1" );
+				cursor->SetStateBool("scaleto43", true);   // dezo2, scaled
+				cursor->StateChanged(gameLocal.realClientTime);   // dezo2, set state
+
 			}
 #endif
 
@@ -3511,12 +3520,12 @@ bool idPlayer::Give( const char *statname, const char *value ) {
 		}
 
 	} else if ( !idStr::Icmp( statname, "air" ) ) {
-		if ( airTics >= pm_airTics.GetInteger() ) {
+		if ( airTics >= pm_airTics.GetFloat() ) { // DG: airTics are floats now for high-fps support
 			return false;
 		}
-		airTics += atoi( value ) / 100.0 * pm_airTics.GetInteger();
-		if ( airTics > pm_airTics.GetInteger() ) {
-			airTics = pm_airTics.GetInteger();
+		airTics += atoi( value ) / 100.0 * pm_airTics.GetFloat();
+		if ( airTics > pm_airTics.GetFloat() ) {
+			airTics = pm_airTics.GetFloat();
 		}
 #ifdef _D3XP
 	} else if ( !idStr::Icmp( statname, "enviroTime" ) ) {
@@ -6105,7 +6114,8 @@ void idPlayer::UpdateAir( void ) {
 				hud->HandleNamedEvent( "noAir" );
 			}
 		}
-		airTics--;
+		// DG: was airTics--, but airTics assume 60Hz tics and we support other ticrates now (com_gameHz)
+		airTics -= 1.0f / gameLocal.gameTicScale;
 		if ( airTics < 0 ) {
 			airTics = 0;
 			// check for damage
@@ -6125,16 +6135,16 @@ void idPlayer::UpdateAir( void ) {
 				hud->HandleNamedEvent( "Air" );
 			}
 		}
-		airTics+=2;	// regain twice as fast as lose
-		if ( airTics > pm_airTics.GetInteger() ) {
-			airTics = pm_airTics.GetInteger();
+		airTics += 2.0f / gameLocal.gameTicScale; // regain twice as fast as lose - DG: scale for com_gameHz
+		if ( airTics > pm_airTics.GetFloat() ) {
+			airTics = pm_airTics.GetFloat();
 		}
 	}
 
 	airless = newAirless;
 
 	if ( hud ) {
-		hud->SetStateInt( "player_air", 100 * airTics / pm_airTics.GetInteger() );
+		hud->SetStateInt( "player_air", 100 * (airTics / pm_airTics.GetFloat()) );
 	}
 }
 
@@ -7107,8 +7117,12 @@ void idPlayer::Move( void ) {
 		if ( spectating ) {
 			SetEyeHeight( newEyeOffset );
 		} else {
+			// DG: make this framerate-independent, code suggested by tyuah8 on Github
+			// https://en.wikipedia.org/wiki/Exponential_smoothing#Time_constant
+			const float tau = -16.0f / idMath::Log( pm_crouchrate.GetFloat() );
+			const float a = 1.0f - idMath::Exp( -gameLocal.gameMsec / tau );
 			// smooth out duck height changes
-			SetEyeHeight( EyeHeight() * pm_crouchrate.GetFloat() + newEyeOffset * ( 1.0f - pm_crouchrate.GetFloat() ) );
+			SetEyeHeight( EyeHeight() * (1.0f - a) + newEyeOffset * a );
 		}
 	}
 
@@ -7648,7 +7662,7 @@ bool idPlayer::CanGive( const char *statname, const char *value ) {
 		return true;
 
 	} else if ( !idStr::Icmp( statname, "air" ) ) {
-		if ( airTics >= pm_airTics.GetInteger() ) {
+		if ( airTics >= pm_airTics.GetFloat() ) {
 			return false;
 		}
 		return true;

neo/d3xp/Player.h

@@ -659,7 +659,8 @@ class idPlayer : public idActor {
 	int						numProjectileHits;		// number of hits on mobs
 
 	bool					airless;
-	int						airTics;				// set to pm_airTics at start, drops in vacuum
+	// DG: Note: airTics are tics at 60Hz, so no real tics (unless com_gameHz happens to be 60)
+	float					airTics;				// set to pm_airTics at start, drops in vacuum
 	int						lastAirDamage;
 
 	bool					gibDeath;

neo/d3xp/ai/AI.cpp

@@ -2984,8 +2984,15 @@ void idAI::AdjustFlyingAngles( void ) {
 		}
 	}
 
-	fly_roll = fly_roll * 0.95f + roll * 0.05f;
-	fly_pitch = fly_pitch * 0.95f + pitch * 0.05f;
+	// DG: make this framerate-independent, code suggested by tyuah8 on Github
+	// https://en.wikipedia.org/wiki/Exponential_smoothing#Time_constant
+	static const float tau = -16.0f / idMath::Log( 0.95f );
+	// TODO: use gameLocal.gameMsec instead, so it's not affected by slow motion?
+	//       enemies turning slower in slowmo seems logical, but the original code
+	//       just increased every tic and thus was independent of slowmo
+	const float a = 1.0f - idMath::Exp( -gameLocal.msec / tau );
+	fly_roll  = fly_roll  * (1.0f - a) + roll  * a;
+	fly_pitch = fly_pitch * (1.0f - a) + pitch * a;
 
 	if ( flyTiltJoint != INVALID_JOINT ) {
 		animator.SetJointAxis( flyTiltJoint, JOINTMOD_WORLD, idAngles( fly_pitch, 0.0f, fly_roll ).ToMat3() );

neo/d3xp/physics/Force_Drag.cpp

@@ -33,6 +33,8 @@ If you have questions concerning this license or the applicable additional terms
 
 #include "physics/Force_Drag.h"
 
+#include "Game_local.h"
+
 CLASS_DECLARATION( idForce, idForce_Drag )
 END_CLASS
 

neo/d3xp/physics/Force_Grab.cpp

@@ -92,7 +92,23 @@ idForce_Grab::Init
 */
 void idForce_Grab::Init( float damping ) {
 	if ( damping >= 0.0f && damping < 1.0f ) {
-		this->damping = damping;
+		/* DG: in Evaluate(), the linear velocity (or actually momentum) of this->physics
+		 *     is multiplied with damping (0.5 by default) each frame.
+		 *     So how quickly the velocity is reduced per second depended on the framerate,
+		 *     and at higher framerates the grabbed item is slowed down too much and
+		 *     because of that sometimes even drops on the floor (gravity stronger than
+		 *     the force dragging it towards the player, or something like that).
+		 *     To fix that, damping must be adjusted depending on the framerate.
+		 *     The fixed code below is the result of this math (figuring out fixeddamping;
+		 *     note that here a^b means pow(a, b)):
+		 *       // we want velocity multiplied with damping 60 times per second to have the
+		 *       // same value as velocity multiplied with fixeddamping gameHz times per second
+		 *       velocity * damping^60 = velocity * fixeddamping^gameHz
+		 *    <=> damping^60 = fixeddamping^gameHz                // divided by velocity
+		 *    <=> gameHz-th-root-of( damping^60 ) = fixeddamping  // took gameHz-th root
+		 *    <=> fixeddamping = damping^( 60/gameHz )            // n-th-root-of(x^m) == x^(m/n)
+		 */
+		this->damping = idMath::Pow( damping, 60.0f/gameLocal.gameHz );
 	}
 }