thirdpartymirrors/RingRacers
1
0
Fork 0
mirror of https://github.com/KartKrewDev/RingRacers.git synced 2026-02-04 04:36:21 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Please god just fucking work

Browse source
This commit is contained in:
AJ Martinez 2023-02-24 20:04:36 -07:00
parent 7c08634f7e
commit 432be46a2f
5 changed files with 10 additions and 102 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
src/d_clisrv.c
View file

@ -1333,6 +1333,7 @@ static void CL_ReloadReceivedSavegame(void)
for (i = 0; i <= r_splitscreen; i++)
{
P_ForceLocalAngle(&players[displayplayers[i]], players[displayplayers[i]].angleturn);
//P_ForceLocalAngle(&players[displayplayers[i]], players[displayplayers[i]].cmd.angle);
}
for (i = 0; i < MAXSPLITSCREENPLAYERS; i++)
@ -3648,6 +3649,7 @@ static void Got_AddPlayer(UINT8 **p, INT32 playernum)
}
P_ForceLocalAngle(newplayer, newplayer->angleturn);
//P_ForceLocalAngle(newplayer, newplayer->cmd.angle);
D_SendPlayerConfig(splitscreenplayer);
addedtogame = true;

2
src/g_demo.c
View file

@ -593,7 +593,7 @@ void G_WriteDemoTiccmd(ticcmd_t *cmd, INT32 playernum)
if (cmd->angle != oldcmd[playernum].angle)
{
WRITEINT16(demobuf.p,cmd->angle);
oldcmd[playernum].turning = cmd->angle;
oldcmd[playernum].angle = cmd->angle;
ziptic |= ZT_ANGLE;
}

64
src/g_game.c
View file

@ -1080,80 +1080,24 @@ INT32 localaiming[MAXSPLITSCREENPLAYERS];
angle_t localangle[MAXSPLITSCREENPLAYERS];
INT32 localsteering[MAXSPLITSCREENPLAYERS];
INT32 localdrift[MAXSPLITSCREENPLAYERS];
INT32 localdriftend[MAXSPLITSCREENPLAYERS];
INT32 localdelta[MAXSPLITSCREENPLAYERS];
INT32 localstoredeltas[MAXSPLITSCREENPLAYERS][TICCMD_LATENCYMASK + 1];
UINT8 locallatency[MAXSPLITSCREENPLAYERS][TICRATE];
UINT8 localtic;
void G_ResetAnglePrediction(player_t *player)
{
UINT16 i, j;
for (i = 0; i <= r_splitscreen; i++)
{
if (&players[displayplayers[i]] == player)
{
localdelta[i] = 0;
for (j = 0; j < TICCMD_LATENCYMASK; j++)
{
localstoredeltas[i][j] = 0;
}
break;
}
}
}
// Turning was removed from G_BuildTiccmd to prevent easy client hacking.
// This brings back the camera prediction that was lost.
static void G_DoAnglePrediction(ticcmd_t *cmd, INT32 realtics, UINT8 ssplayer, player_t *player)
{
angle_t angleChange = 0;
angle_t destAngle = player->angleturn;
angle_t diff = 0;
localtic = cmd->latency;
while (realtics > 0)
{
pflags_t oldflags = player->pflags;
localsteering[ssplayer - 1] = K_UpdateSteeringValue(localsteering[ssplayer - 1], cmd->turning);
angleChange = K_GetKartTurnValue(player, localsteering[ssplayer - 1]) << TICCMD_REDUCE;
player->pflags = oldflags;
// Store the angle we applied to this tic, so we can revert it later.
// If we trust the camera to do all of the work, then it can get out of sync fast.
localstoredeltas[ssplayer - 1][cmd->latency] += angleChange;
localdelta[ssplayer - 1] += angleChange;
realtics--;
}
// We COULD set it to destAngle directly...
// but this causes incredible jittering when the prediction turns out to be wrong. So we ease into it.
// Slight increased camera lag in all scenarios > Mostly lagless camera but with jittering
destAngle = player->angleturn + localdelta[ssplayer - 1];
diff = destAngle - localangle[ssplayer - 1];
/*
if (diff > ANGLE_180)
{
diff = InvAngle(InvAngle(diff) / 2);
}
else
{
diff /= 2;
}
localangle[ssplayer - 1] += diff;
*/
// In case of angle debugging, break glass
localangle[ssplayer - 1] = destAngle;
localangle[ssplayer - 1] += angleChange;
//player->angleturn = localangle[ssplayer - 1];
}
void G_BuildTiccmd(ticcmd_t *cmd, INT32 realtics, UINT8 ssplayer)
@ -1189,6 +1133,8 @@ void G_BuildTiccmd(ticcmd_t *cmd, INT32 realtics, UINT8 ssplayer)
break;
}
cmd->angle = localangle[forplayer] >> TICCMD_REDUCE;
// why build a ticcmd if we're paused?
// Or, for that matter, if we're being reborn.
if (paused || P_AutoPause() || (gamestate == GS_LEVEL && player->playerstate == PST_REBORN))
@ -1292,8 +1238,6 @@ void G_BuildTiccmd(ticcmd_t *cmd, INT32 realtics, UINT8 ssplayer)
cmd->throwdir -= (joystickvector.yaxis * KART_FULLTURN) / JOYAXISRANGE;
}
}
cmd->angle = localangle[forplayer] >> TICCMD_REDUCE;
// drift
if (G_PlayerInputDown(forplayer, gc_drift, 0))

5
src/g_game.h
View file

@ -101,7 +101,6 @@ extern consvar_t cv_resume;
const char *G_BuildMapName(INT32 map);
INT32 G_MapNumber(const char *mapname);
void G_ResetAnglePrediction(player_t *player);
void G_BuildTiccmd(ticcmd_t *cmd, INT32 realtics, UINT8 ssplayer);
// copy ticcmd_t to and fro the normal way
@ -116,10 +115,6 @@ INT16 G_SoftwareClipAimingPitch(INT32 *aiming);
extern angle_t localangle[MAXSPLITSCREENPLAYERS];
extern INT32 localaiming[MAXSPLITSCREENPLAYERS]; // should be an angle_t but signed
extern INT32 localsteering[MAXSPLITSCREENPLAYERS];
extern INT32 localdelta[MAXSPLITSCREENPLAYERS];
extern INT32 localstoredeltas[MAXSPLITSCREENPLAYERS][TICCMD_LATENCYMASK + 1];
extern UINT8 locallatency[MAXSPLITSCREENPLAYERS][TICRATE];
extern UINT8 localtic;
INT32 G_PlayerInputAnalog(UINT8 p, INT32 gc, UINT8 menuPlayers);
boolean G_PlayerInputDown(UINT8 p, INT32 gc, UINT8 menuPlayers);

39
src/p_user.c
View file

@ -2120,7 +2120,6 @@ static void P_3dMovement(player_t *player)
static void P_UpdatePlayerAngle(player_t *player)
{
angle_t angleChange = ANGLE_MAX;
UINT8 maxlatency;
UINT8 p = UINT8_MAX;
UINT8 i;
@ -2147,7 +2146,7 @@ static void P_UpdatePlayerAngle(player_t *player)
//CONS_Printf("%u, steering by %u but we want %u, MTL %d %u, MTR %d %u\n", targetAngle, angleChange, targetDelta, steeringLeft, maxTurnLeft, steeringRight, maxTurnRight);
if (targetDelta == angleChange)
if (targetDelta == angleChange || player->pflags & PF_DRIFTEND)
{
//CONS_Printf("Facing correct, thank god\n");
}
@ -2180,42 +2179,10 @@ static void P_UpdatePlayerAngle(player_t *player)
}
else
{
/*
// During standard play, our latency can vary by up to 1 tic in either direction, even on a stable connection.
// This probably comes from differences in ticcmd dispatch vs consumption rate. Probably.
// Uncorrected, this 2-tic "wobble" causes camera corrections to sometimes be skipped or batched.
// So just use the highest recent value for the furthest possible search.
// We unset the correction after applying, anyway.
locallatency[p][leveltime%TICRATE] = maxlatency = player->cmd.latency;
for (i = 0; i < TICRATE; i++)
{
maxlatency = max(locallatency[p][i], maxlatency);
}
UINT8 lateTic = ((leveltime - maxlatency) & TICCMD_LATENCYMASK);
UINT8 clearTic = ((localtic + 1) & TICCMD_LATENCYMASK);
*/
/*
player->angleturn += angleChange;
player->mo->angle = player->angleturn;
*/
player->mo->angle += angleChange;
/*
// Undo the ticcmd's old emulated angle,
// now that we added the actual game logic angle.
while (lateTic != clearTic)
{
localdelta[p] -= localstoredeltas[p][lateTic];
localstoredeltas[p][lateTic] = 0;
lateTic = (lateTic - 1) & TICCMD_LATENCYMASK;
}
*/
// player->mo->angle += angleChange;
}
if (!cv_allowmlook.value || player->spectator == false)
@ -4523,7 +4490,7 @@ void P_ForceLocalAngle(player_t *player, angle_t angle)
if (player == &players[displayplayers[i]])
{
localangle[i] = angle;
G_ResetAnglePrediction(player);
break;
}
}