thirdpartymirrors/RingRacers
1
0
Fork 0
mirror of https://github.com/KartKrewDev/RingRacers.git synced 2026-05-10 19:01:50 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Turning code overhaul

Browse source 
Packet drops are still broken, but at least netgames are playable now.
This commit is contained in:
Sally Coolatta 2020-09-22 00:35:44 -04:00
parent da47d0c437
commit 99a1bacb81
18 changed files with 158 additions and 272 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

33
src/d_clisrv.c
View file

@ -426,7 +426,7 @@ static void D_Clearticcmd(tic_t tic)
D_FreeTextcmd(tic); D_FreeTextcmd(tic);
for (i = 0; i < MAXPLAYERS; i++) for (i = 0; i < MAXPLAYERS; i++)
netcmds[tic%TICQUEUE][i].angleturn = 0; netcmds[tic%TICQUEUE][i].flags = 0;
DEBFILE(va("clear tic %5u (%2u)\n", tic, tic%TICQUEUE)); DEBFILE(va("clear tic %5u (%2u)\n", tic, tic%TICQUEUE));
} }
@ -527,9 +527,7 @@ static inline void resynch_write_player(resynch_pak *rsp, const size_t i)
rsp->pflags = (UINT32)LONG(players[i].pflags); //pflags_t rsp->pflags = (UINT32)LONG(players[i].pflags); //pflags_t
rsp->panim = (UINT8)players[i].panim; //panim_t rsp->panim = (UINT8)players[i].panim; //panim_t
rsp->angleturn = (INT16)SHORT(players[i].angleturn); rsp->angleturn = (angle_t)LONG(players[i].angleturn);
rsp->oldrelangleturn = (INT16)SHORT(players[i].oldrelangleturn);
rsp->aiming = (angle_t)LONG(players[i].aiming); rsp->aiming = (angle_t)LONG(players[i].aiming);
for (j = 0; j < NUMPOWERS; ++j) for (j = 0; j < NUMPOWERS; ++j)
@ -673,9 +671,7 @@ static void resynch_read_player(resynch_pak *rsp)
players[i].pflags = (UINT32)LONG(rsp->pflags); //pflags_t players[i].pflags = (UINT32)LONG(rsp->pflags); //pflags_t
players[i].panim = (UINT8)rsp->panim; //panim_t players[i].panim = (UINT8)rsp->panim; //panim_t
players[i].angleturn = (INT16)SHORT(rsp->angleturn); players[i].angleturn = (angle_t)LONG(rsp->angleturn);
players[i].oldrelangleturn = (INT16)SHORT(rsp->oldrelangleturn);
players[i].aiming = (angle_t)LONG(rsp->aiming); players[i].aiming = (angle_t)LONG(rsp->aiming);
for (j = 0; j < NUMPOWERS; ++j) for (j = 0; j < NUMPOWERS; ++j)
@ -3675,8 +3671,7 @@ static void Got_AddPlayer(UINT8 **p, INT32 playernum)
DEBFILE("spawning me\n"); DEBFILE("spawning me\n");
} }
ticcmd_oldangleturn[splitscreenplayer] = newplayer->oldrelangleturn; P_ForceLocalAngle(newplayer, newplayer->angleturn);
P_ForceLocalAngle(newplayer, (angle_t)(newplayer->angleturn << 16));
D_SendPlayerConfig(); D_SendPlayerConfig();
addedtogame = true; addedtogame = true;
@ -4485,7 +4480,7 @@ static void HandlePacketFromAwayNode(SINT8 node)
static boolean CheckForSpeedHacks(UINT8 p) static boolean CheckForSpeedHacks(UINT8 p)
{ {
if (netcmds[maketic%TICQUEUE][p].forwardmove > MAXPLMOVE || netcmds[maketic%TICQUEUE][p].forwardmove < -MAXPLMOVE if (netcmds[maketic%TICQUEUE][p].forwardmove > MAXPLMOVE || netcmds[maketic%TICQUEUE][p].forwardmove < -MAXPLMOVE
|| netcmds[maketic%TICQUEUE][p].driftturn > KART_FULLTURN || netcmds[maketic%TICQUEUE][p].driftturn < -KART_FULLTURN) || netcmds[maketic%TICQUEUE][p].turning > KART_FULLTURN || netcmds[maketic%TICQUEUE][p].turning < -KART_FULLTURN)
{ {
CONS_Alert(CONS_WARNING, M_GetText("Illegal movement value received from node %d\n"), playernode[p]); CONS_Alert(CONS_WARNING, M_GetText("Illegal movement value received from node %d\n"), playernode[p]);
//D_Clearticcmd(k); //D_Clearticcmd(k);
@ -5445,22 +5440,22 @@ static void Local_Maketic(INT32 realtics)
// translate inputs (keyboard/mouse/joystick) into game controls // translate inputs (keyboard/mouse/joystick) into game controls
G_BuildTiccmd(&localcmds[0], realtics, 1); G_BuildTiccmd(&localcmds[0], realtics, 1);
localcmds[0].angleturn |= TICCMD_RECEIVED; localcmds[0].flags |= TICCMD_RECEIVED;
if (splitscreen) if (splitscreen)
{ {
G_BuildTiccmd(&localcmds[1], realtics, 2); G_BuildTiccmd(&localcmds[1], realtics, 2);
localcmds[1].angleturn |= TICCMD_RECEIVED; localcmds[1].flags |= TICCMD_RECEIVED;
if (splitscreen > 1) if (splitscreen > 1)
{ {
G_BuildTiccmd(&localcmds[2], realtics, 3); G_BuildTiccmd(&localcmds[2], realtics, 3);
localcmds[2].angleturn |= TICCMD_RECEIVED; localcmds[2].flags |= TICCMD_RECEIVED;
if (splitscreen > 2) if (splitscreen > 2)
{ {
G_BuildTiccmd(&localcmds[3], realtics, 4); G_BuildTiccmd(&localcmds[3], realtics, 4);
localcmds[3].angleturn |= TICCMD_RECEIVED; localcmds[3].flags |= TICCMD_RECEIVED;
} }
} }
} }
@ -5483,25 +5478,23 @@ static void SV_Maketic(void)
} }
// We didn't receive this tic // We didn't receive this tic
if ((netcmds[maketic % TICQUEUE][i].angleturn & TICCMD_RECEIVED) == 0) if ((netcmds[maketic % TICQUEUE][i].flags & TICCMD_RECEIVED) == 0)
{ {
ticcmd_t * ticcmd = &netcmds[(maketic ) % BACKUPTICS][i]; ticcmd_t * ticcmd = &netcmds[(maketic ) % BACKUPTICS][i];
ticcmd_t *prevticcmd = &netcmds[(maketic - 1) % BACKUPTICS][i]; ticcmd_t *prevticcmd = &netcmds[(maketic - 1) % BACKUPTICS][i];
if (players[i].quittime) if (players[i].quittime)
{ {
// Copy the angle/aiming from the previous tic // empty inputs but consider recieved
// and empty the other inputs
memset(ticcmd, 0, sizeof(netcmds[0][0])); memset(ticcmd, 0, sizeof(netcmds[0][0]));
ticcmd->angleturn = prevticcmd->angleturn | TICCMD_RECEIVED; ticcmd->flags = prevticcmd->flags | TICCMD_RECEIVED;
ticcmd->aiming = prevticcmd->aiming;
} }
else else
{ {
DEBFILE(va("MISS tic%4d for player %d\n", maketic, i)); DEBFILE(va("MISS tic%4d for player %d\n", maketic, i));
// Copy the input from the previous tic // Copy the input from the previous tic
*ticcmd = *prevticcmd; *ticcmd = *prevticcmd;
ticcmd->angleturn &= ~TICCMD_RECEIVED; ticcmd->flags &= ~TICCMD_RECEIVED;
} }
} }
} }

4
src/d_clisrv.h
View file

@ -208,9 +208,7 @@ typedef struct
UINT32 pflags; // pflags_t UINT32 pflags; // pflags_t
UINT8 panim; // panim_t UINT8 panim; // panim_t
INT16 angleturn; angle_t angleturn;
INT16 oldrelangleturn;
angle_t aiming; angle_t aiming;
UINT16 powers[NUMPOWERS]; UINT16 powers[NUMPOWERS];

5
src/d_player.h
View file

@ -486,8 +486,7 @@ typedef struct player_s
angle_t viewrollangle; angle_t viewrollangle;
INT16 angleturn; angle_t angleturn;
INT16 oldrelangleturn;
// Mouse aiming, where the guy is looking at! // Mouse aiming, where the guy is looking at!
// It is updated with cmd->aiming. // It is updated with cmd->aiming.
@ -505,8 +504,6 @@ typedef struct player_s
// SRB2kart stuff // SRB2kart stuff
INT32 kartstuff[NUMKARTSTUFF]; INT32 kartstuff[NUMKARTSTUFF];
INT32 karthud[NUMKARTHUD]; INT32 karthud[NUMKARTHUD];
INT16 lturn_max[MAXPREDICTTICS]; // What's the expected turn value for full-left for a number of frames back (to account for netgame latency)?
INT16 rturn_max[MAXPREDICTTICS]; // Ditto but for full-right
UINT32 distancetofinish; UINT32 distancetofinish;
waypoint_t *nextwaypoint; waypoint_t *nextwaypoint;
respawnvars_t respawn; // Respawn info respawnvars_t respawn; // Respawn info

12
src/d_ticcmd.h
View file

@ -27,7 +27,7 @@
typedef enum typedef enum
{ {
BT_ACCELERATE = 1, // Accelerate BT_ACCELERATE = 1, // Accelerate
BT_DRIFT = 1<<2, // Drift (direction is cmd->driftturn) BT_DRIFT = 1<<2, // Drift (direction is cmd->turning)
BT_BRAKE = 1<<3, // Brake BT_BRAKE = 1<<3, // Brake
BT_ATTACK = 1<<4, // Use Item BT_ATTACK = 1<<4, // Use Item
BT_FORWARD = 1<<5, // Aim Item Forward BT_FORWARD = 1<<5, // Aim Item Forward
@ -49,9 +49,11 @@ typedef enum
// Mainly movements/button commands per game tick, // Mainly movements/button commands per game tick,
// plus a checksum for internal state consistency. // plus a checksum for internal state consistency.
// bits in angleturn // ticcmd turning bits
#define TICCMD_REDUCE 16
// ticcmd flags
#define TICCMD_RECEIVED 1 #define TICCMD_RECEIVED 1
#define TICCMD_XY 2
#if defined(_MSC_VER) #if defined(_MSC_VER)
#pragma pack(1) #pragma pack(1)
@ -60,11 +62,11 @@ typedef enum
typedef struct typedef struct
{ {
SINT8 forwardmove; // -MAXPLMOVE to MAXPLMOVE (50) SINT8 forwardmove; // -MAXPLMOVE to MAXPLMOVE (50)
INT16 angleturn; // <<16 for angle delta - saved as 1 byte into demos INT16 turning; // Turn speed
INT16 aiming; // vertical aiming, see G_BuildTicCmd INT16 aiming; // vertical aiming, see G_BuildTicCmd
UINT16 buttons; UINT16 buttons;
INT16 driftturn; // SRB2Kart: Used for getting drift turn speed
UINT8 latency; // Netgames: how many tics ago was this ticcmd generated from this player's end? UINT8 latency; // Netgames: how many tics ago was this ticcmd generated from this player's end?
UINT8 flags;
} ATTRPACK ticcmd_t; } ATTRPACK ticcmd_t;
#if defined(_MSC_VER) #if defined(_MSC_VER)

43
src/g_demo.c
View file

@ -123,11 +123,11 @@ demoghost *ghosts = NULL;
// For demos // For demos
#define ZT_FWD 0x01 #define ZT_FWD 0x01
#define ZT_SIDE 0x02 #define ZT_SIDE 0x02
#define ZT_ANGLE 0x04 #define ZT_TURNING 0x04
#define ZT_BUTTONS 0x08 #define ZT_BUTTONS 0x08
#define ZT_AIMING 0x10 #define ZT_AIMING 0x10
#define ZT_DRIFT 0x20 #define ZT_LATENCY 0x20
#define ZT_LATENCY 0x40 #define ZT_FLAGS 0x40
#define DEMOMARKER 0x80 // demoend #define DEMOMARKER 0x80 // demoend
UINT8 demo_extradata[MAXPLAYERS]; UINT8 demo_extradata[MAXPLAYERS];
@ -483,19 +483,18 @@ void G_ReadDemoTiccmd(ticcmd_t *cmd, INT32 playernum)
if (ziptic & ZT_FWD) if (ziptic & ZT_FWD)
oldcmd[playernum].forwardmove = READSINT8(demo_p); oldcmd[playernum].forwardmove = READSINT8(demo_p);
if (ziptic & ZT_ANGLE) if (ziptic & ZT_TURNING)
oldcmd[playernum].angleturn = READINT16(demo_p); oldcmd[playernum].turning = READINT16(demo_p);
if (ziptic & ZT_BUTTONS) if (ziptic & ZT_BUTTONS)
oldcmd[playernum].buttons = READUINT16(demo_p); oldcmd[playernum].buttons = READUINT16(demo_p);
if (ziptic & ZT_AIMING) if (ziptic & ZT_AIMING)
oldcmd[playernum].aiming = READINT16(demo_p); oldcmd[playernum].aiming = READINT16(demo_p);
if (ziptic & ZT_DRIFT)
oldcmd[playernum].driftturn = READINT16(demo_p);
if (ziptic & ZT_LATENCY) if (ziptic & ZT_LATENCY)
oldcmd[playernum].latency = READUINT8(demo_p); oldcmd[playernum].latency = READUINT8(demo_p);
if (ziptic & ZT_FLAGS)
oldcmd[playernum].latency = READUINT8(demo_p);
G_CopyTiccmd(cmd, &oldcmd[playernum], 1); G_CopyTiccmd(cmd, &oldcmd[playernum], 1);
players[playernum].angleturn = cmd->angleturn;
if (!(demoflags & DF_GHOST) && *demo_p == DEMOMARKER) if (!(demoflags & DF_GHOST) && *demo_p == DEMOMARKER)
{ {
@ -522,11 +521,11 @@ void G_WriteDemoTiccmd(ticcmd_t *cmd, INT32 playernum)
ziptic |= ZT_FWD; ziptic |= ZT_FWD;
} }
if (cmd->angleturn != oldcmd[playernum].angleturn) if (cmd->turning != oldcmd[playernum].turning)
{ {
WRITEINT16(demo_p,cmd->angleturn); WRITEINT16(demo_p,cmd->turning);
oldcmd[playernum].angleturn = cmd->angleturn; oldcmd[playernum].turning = cmd->turning;
ziptic |= ZT_ANGLE; ziptic |= ZT_TURNING;
} }
if (cmd->buttons != oldcmd[playernum].buttons) if (cmd->buttons != oldcmd[playernum].buttons)
@ -543,13 +542,6 @@ void G_WriteDemoTiccmd(ticcmd_t *cmd, INT32 playernum)
ziptic |= ZT_AIMING; ziptic |= ZT_AIMING;
} }
if (cmd->driftturn != oldcmd[playernum].driftturn)
{
WRITEINT16(demo_p,cmd->driftturn);
oldcmd[playernum].driftturn = cmd->driftturn;
ziptic |= ZT_DRIFT;
}
if (cmd->latency != oldcmd[playernum].latency) if (cmd->latency != oldcmd[playernum].latency)
{ {
WRITEUINT8(demo_p,cmd->latency); WRITEUINT8(demo_p,cmd->latency);
@ -557,6 +549,13 @@ void G_WriteDemoTiccmd(ticcmd_t *cmd, INT32 playernum)
ziptic |= ZT_LATENCY; ziptic |= ZT_LATENCY;
} }
if (cmd->flags != oldcmd[playernum].flags)
{
WRITEUINT8(demo_p,cmd->flags);
oldcmd[playernum].flags = cmd->flags;
ziptic |= ZT_FLAGS;
}
*ziptic_p = ziptic; *ziptic_p = ziptic;
// attention here for the ticcmd size! // attention here for the ticcmd size!
@ -1086,16 +1085,16 @@ void G_GhostTicker(void)
if (ziptic & ZT_FWD) if (ziptic & ZT_FWD)
g->p++; g->p++;
if (ziptic & ZT_ANGLE) if (ziptic & ZT_TURNING)
g->p += 2; g->p += 2;
if (ziptic & ZT_BUTTONS) if (ziptic & ZT_BUTTONS)
g->p += 2; g->p += 2;
if (ziptic & ZT_AIMING) if (ziptic & ZT_AIMING)
g->p += 2; g->p += 2;
if (ziptic & ZT_DRIFT)
g->p += 2;
if (ziptic & ZT_LATENCY) if (ziptic & ZT_LATENCY)
g->p += 1; g->p += 1;
if (ziptic & ZT_FLAGS)
g->p += 1;
// Grab ghost data. // Grab ghost data.
ziptic = READUINT8(g->p); ziptic = READUINT8(g->p);

98
src/g_game.c
View file

@ -853,15 +853,11 @@ static void G_HandleAxisDeadZone(UINT8 splitnum, joystickvector2_t *joystickvect
INT32 localaiming[MAXSPLITSCREENPLAYERS]; INT32 localaiming[MAXSPLITSCREENPLAYERS];
angle_t localangle[MAXSPLITSCREENPLAYERS]; angle_t localangle[MAXSPLITSCREENPLAYERS];
static INT32 forwardmove = 50<<FRACBITS>>16; static INT32 angleturn[2] = {KART_FULLTURN, KART_FULLTURN / 4}; // + slow turn
static INT32 angleturn[3] = {KART_FULLTURN/2, KART_FULLTURN, KART_FULLTURN/4}; // + slow turn
INT16 ticcmd_oldangleturn[MAXSPLITSCREENPLAYERS];
void G_BuildTiccmd(ticcmd_t *cmd, INT32 realtics, UINT8 ssplayer) void G_BuildTiccmd(ticcmd_t *cmd, INT32 realtics, UINT8 ssplayer)
{ {
const UINT8 forplayer = ssplayer-1; const UINT8 forplayer = ssplayer-1;
const INT32 speed = 1;
const INT32 lookaxis = cv_lookaxis[forplayer].value; const INT32 lookaxis = cv_lookaxis[forplayer].value;
const boolean invertmouse = cv_invertmouse.value; const boolean invertmouse = cv_invertmouse.value;
@ -881,7 +877,6 @@ void G_BuildTiccmd(ticcmd_t *cmd, INT32 realtics, UINT8 ssplayer)
player_t *player = &players[g_localplayers[forplayer]]; player_t *player = &players[g_localplayers[forplayer]];
camera_t *thiscam = &camera[forplayer]; camera_t *thiscam = &camera[forplayer];
angle_t *myangle = &localangle[forplayer];
INT32 *laim = &localaiming[forplayer]; INT32 *laim = &localaiming[forplayer];
INT32 *th = &turnheld[forplayer]; INT32 *th = &turnheld[forplayer];
boolean *kbl = &keyboard_look[forplayer]; boolean *kbl = &keyboard_look[forplayer];
@ -913,7 +908,6 @@ void G_BuildTiccmd(ticcmd_t *cmd, INT32 realtics, UINT8 ssplayer)
// Kart, don't build a ticcmd if someone is resynching or the server is stopped too so we don't fly off course in bad conditions // Kart, don't build a ticcmd if someone is resynching or the server is stopped too so we don't fly off course in bad conditions
if (paused || P_AutoPause() || (gamestate == GS_LEVEL && player->playerstate == PST_REBORN) || hu_resynching) if (paused || P_AutoPause() || (gamestate == GS_LEVEL && player->playerstate == PST_REBORN) || hu_resynching)
{ {
cmd->angleturn = ticcmd_oldangleturn[forplayer];
cmd->aiming = G_ClipAimingPitch(laim); cmd->aiming = G_ClipAimingPitch(laim);
return; return;
} }
@ -954,36 +948,31 @@ void G_BuildTiccmd(ticcmd_t *cmd, INT32 realtics, UINT8 ssplayer)
*th = 0; *th = 0;
if (*th < SLOWTURNTICS) if (*th < SLOWTURNTICS)
tspeed = 2; // slow turn tspeed = 1; // slow turn
else else
tspeed = speed; tspeed = 0;
cmd->driftturn = 0; cmd->turning = 0;
// let movement keys cancel each other out // let movement keys cancel each other out
if (turnright && !(turnleft)) if (turnright && !(turnleft))
{ {
cmd->angleturn = (INT16)(cmd->angleturn - (angleturn[tspeed])); cmd->turning = (INT16)(cmd->turning - (angleturn[tspeed]));
cmd->driftturn = (INT16)(cmd->driftturn - (angleturn[tspeed]));
} }
else if (turnleft && !(turnright)) else if (turnleft && !(turnright))
{ {
cmd->angleturn = (INT16)(cmd->angleturn + (angleturn[tspeed])); cmd->turning = (INT16)(cmd->turning + (angleturn[tspeed]));
cmd->driftturn = (INT16)(cmd->driftturn + (angleturn[tspeed]));
} }
if (analogjoystickmove && joystickvector.xaxis != 0) if (analogjoystickmove && joystickvector.xaxis != 0)
{ {
// JOYAXISRANGE should be 1023 (divide by 1024) cmd->turning = (INT16)(cmd->turning - (((joystickvector.xaxis * angleturn[0]) >> 10)));
cmd->angleturn = (INT16)(cmd->angleturn - (((joystickvector.xaxis * angleturn[1]) >> 10))); // ANALOG!
cmd->driftturn = (INT16)(cmd->driftturn - (((joystickvector.xaxis * angleturn[1]) >> 10)));
} }
// Specator mouse turning // Specator mouse turning
if (player->spectator) if (player->spectator)
{ {
cmd->angleturn = (INT16)(cmd->angleturn - ((mousex*(encoremode ? -1 : 1)*8))); cmd->turning = (INT16)(cmd->turning - ((mousex*(encoremode ? -1 : 1)*8)));
cmd->driftturn = (INT16)(cmd->driftturn - ((mousex*(encoremode ? -1 : 1)*8)));
} }
if (player->spectator || objectplacing) // SRB2Kart: spectators need special controls if (player->spectator || objectplacing) // SRB2Kart: spectators need special controls
@ -996,9 +985,9 @@ void G_BuildTiccmd(ticcmd_t *cmd, INT32 realtics, UINT8 ssplayer)
cmd->buttons |= BT_BRAKE; cmd->buttons |= BT_BRAKE;
axis = PlayerJoyAxis(ssplayer, AXISAIM); axis = PlayerJoyAxis(ssplayer, AXISAIM);
if (PlayerInputDown(ssplayer, gc_aimforward) || (usejoystick && axis < 0)) if (PlayerInputDown(ssplayer, gc_aimforward) || (usejoystick && axis < 0))
forward += forwardmove; forward += MAXPLMOVE;
if (PlayerInputDown(ssplayer, gc_aimbackward) || (usejoystick && axis > 0)) if (PlayerInputDown(ssplayer, gc_aimbackward) || (usejoystick && axis > 0))
forward -= forwardmove; forward -= MAXPLMOVE;
} }
else else
{ {
@ -1007,13 +996,13 @@ void G_BuildTiccmd(ticcmd_t *cmd, INT32 realtics, UINT8 ssplayer)
if (PlayerInputDown(ssplayer, gc_accelerate) || (gamepadjoystickmove && axis > 0) || player->kartstuff[k_sneakertimer]) if (PlayerInputDown(ssplayer, gc_accelerate) || (gamepadjoystickmove && axis > 0) || player->kartstuff[k_sneakertimer])
{ {
cmd->buttons |= BT_ACCELERATE; cmd->buttons |= BT_ACCELERATE;
forward = forwardmove; // 50 forward = MAXPLMOVE; // 50
} }
else if (analogjoystickmove && axis > 0) else if (analogjoystickmove && axis > 0)
{ {
cmd->buttons |= BT_ACCELERATE; cmd->buttons |= BT_ACCELERATE;
// JOYAXISRANGE is supposed to be 1023 (divide by 1024) // JOYAXISRANGE is supposed to be 1023 (divide by 1024)
forward += ((axis * forwardmove) >> 10); forward += ((axis * MAXPLMOVE) >> 10);
} }
axis = PlayerJoyAxis(ssplayer, AXISBRAKE); axis = PlayerJoyAxis(ssplayer, AXISBRAKE);
@ -1021,14 +1010,14 @@ void G_BuildTiccmd(ticcmd_t *cmd, INT32 realtics, UINT8 ssplayer)
{ {
cmd->buttons |= BT_BRAKE; cmd->buttons |= BT_BRAKE;
if (cmd->buttons & BT_ACCELERATE || cmd->forwardmove <= 0) if (cmd->buttons & BT_ACCELERATE || cmd->forwardmove <= 0)
forward -= forwardmove; forward -= MAXPLMOVE;
} }
else if (analogjoystickmove && axis > 0) else if (analogjoystickmove && axis > 0)
{ {
cmd->buttons |= BT_BRAKE; cmd->buttons |= BT_BRAKE;
// JOYAXISRANGE is supposed to be 1023 (divide by 1024) // JOYAXISRANGE is supposed to be 1023 (divide by 1024)
if (cmd->buttons & BT_ACCELERATE || cmd->forwardmove <= 0) if (cmd->buttons & BT_ACCELERATE || cmd->forwardmove <= 0)
forward -= ((axis * forwardmove) >> 10); forward -= ((axis * MAXPLMOVE) >> 10);
} }
// But forward/backward IS used for aiming. // But forward/backward IS used for aiming.
@ -1124,35 +1113,8 @@ void G_BuildTiccmd(ticcmd_t *cmd, INT32 realtics, UINT8 ssplayer)
cmd->forwardmove += (SINT8)forward; cmd->forwardmove += (SINT8)forward;
if (cmd->forwardmove > MAXPLMOVE)
cmd->forwardmove = MAXPLMOVE;
else if (cmd->forwardmove < -MAXPLMOVE)
cmd->forwardmove = -MAXPLMOVE;
//{ SRB2kart - Drift support
// Not grouped with the rest of turn stuff because it needs to know what buttons you're pressing for rubber-burn turn
// limit turning to angleturn[1] to stop mouselook letting you look too fast
if (cmd->angleturn > (angleturn[1]))
cmd->angleturn = (angleturn[1]);
else if (cmd->angleturn < (-angleturn[1]))
cmd->angleturn = (-angleturn[1]);
if (cmd->driftturn > (angleturn[1]))
cmd->driftturn = (angleturn[1]);
else if (cmd->driftturn < (-angleturn[1]))
cmd->driftturn = (-angleturn[1]);
if (player->mo)
cmd->angleturn = K_GetKartTurnValue(player, cmd->angleturn);
cmd->angleturn *= realtics;
if (!hu_stopped)
{
*myangle += (cmd->angleturn<<16);
}
cmd->latency = modeattacking ? 0 : (leveltime & 0xFF); // Send leveltime when this tic was generated to the server for control lag calculations cmd->latency = modeattacking ? 0 : (leveltime & 0xFF); // Send leveltime when this tic was generated to the server for control lag calculations
cmd->flags = 0;
/* Lua: Allow this hook to overwrite ticcmd. /* Lua: Allow this hook to overwrite ticcmd.
We check if we're actually in a level because for some reason this Hook would run in menus and on the titlescreen otherwise. We check if we're actually in a level because for some reason this Hook would run in menus and on the titlescreen otherwise.
@ -1167,7 +1129,17 @@ void G_BuildTiccmd(ticcmd_t *cmd, INT32 realtics, UINT8 ssplayer)
if (gamestate == GS_LEVEL) if (gamestate == GS_LEVEL)
LUAh_PlayerCmd(player, cmd); LUAh_PlayerCmd(player, cmd);
//Reset away view if a command is given. if (cmd->forwardmove > MAXPLMOVE)
cmd->forwardmove = MAXPLMOVE;
else if (cmd->forwardmove < -MAXPLMOVE)
cmd->forwardmove = -MAXPLMOVE;
if (cmd->turning > (angleturn[0]))
cmd->turning = (angleturn[0]);
else if (cmd->turning < (-angleturn[0]))
cmd->turning = (-angleturn[0]);
// Reset away view if a command is given.
if ((cmd->forwardmove || cmd->buttons) if ((cmd->forwardmove || cmd->buttons)
&& !r_splitscreen && displayplayers[0] != consoleplayer && ssplayer == 1) && !r_splitscreen && displayplayers[0] != consoleplayer && ssplayer == 1)
{ {
@ -1176,9 +1148,6 @@ void G_BuildTiccmd(ticcmd_t *cmd, INT32 realtics, UINT8 ssplayer)
LUAh_ViewpointSwitch(player, &players[consoleplayer], true); LUAh_ViewpointSwitch(player, &players[consoleplayer], true);
displayplayers[0] = consoleplayer; displayplayers[0] = consoleplayer;
} }
cmd->angleturn = (INT16)(cmd->angleturn + ticcmd_oldangleturn[forplayer]);
ticcmd_oldangleturn[forplayer] = cmd->angleturn;
} }
ticcmd_t *G_CopyTiccmd(ticcmd_t* dest, const ticcmd_t* src, const size_t n) ticcmd_t *G_CopyTiccmd(ticcmd_t* dest, const ticcmd_t* src, const size_t n)
@ -1192,11 +1161,11 @@ ticcmd_t *G_MoveTiccmd(ticcmd_t* dest, const ticcmd_t* src, const size_t n)
for (i = 0; i < n; i++) for (i = 0; i < n; i++)
{ {
dest[i].forwardmove = src[i].forwardmove; dest[i].forwardmove = src[i].forwardmove;
dest[i].angleturn = SHORT(src[i].angleturn); dest[i].turning = (INT16)SHORT(src[i].turning);
dest[i].aiming = (INT16)SHORT(src[i].aiming); dest[i].aiming = (INT16)SHORT(src[i].aiming);
dest[i].buttons = (UINT16)SHORT(src[i].buttons); dest[i].buttons = (UINT16)SHORT(src[i].buttons);
dest[i].driftturn = SHORT(src[i].driftturn);
dest[i].latency = src[i].latency; dest[i].latency = src[i].latency;
dest[i].flags = src[i].flags;
} }
return dest; return dest;
} }
@ -1878,7 +1847,7 @@ void G_Ticker(boolean run)
G_CopyTiccmd(cmd, &netcmds[buf][i], 1); G_CopyTiccmd(cmd, &netcmds[buf][i], 1);
// Use the leveltime sent in the player's ticcmd to determine control lag // Use the leveltime sent in the player's ticcmd to determine control lag
if (modeattacking || K_PlayerUsesBotMovement(&players[i])) if (K_PlayerUsesBotMovement(&players[i]))
{ {
// Never has lag // Never has lag
cmd->latency = 0; cmd->latency = 0;
@ -1888,10 +1857,6 @@ void G_Ticker(boolean run)
//@TODO add a cvar to allow setting this max //@TODO add a cvar to allow setting this max
cmd->latency = min(((leveltime & 0xFF) - cmd->latency) & 0xFF, MAXPREDICTTICS-1); cmd->latency = min(((leveltime & 0xFF) - cmd->latency) & 0xFF, MAXPREDICTTICS-1);
} }
players[i].angleturn += players[i].cmd.angleturn - players[i].oldrelangleturn;
players[i].oldrelangleturn = players[i].cmd.angleturn;
players[i].cmd.angleturn = players[i].angleturn;
} }
} }
} }
@ -2089,8 +2054,7 @@ void G_PlayerReborn(INT32 player, boolean betweenmaps)
UINT8 botdifficulty; UINT8 botdifficulty;
INT16 rings; INT16 rings;
INT16 playerangleturn; angle_t playerangleturn;
INT16 oldrelangleturn;
UINT8 botdiffincrease; UINT8 botdiffincrease;
boolean botrival; boolean botrival;
@ -2126,7 +2090,6 @@ void G_PlayerReborn(INT32 player, boolean betweenmaps)
pflags = (players[player].pflags & (PF_WANTSTOJOIN|PF_GAMETYPEOVER)); pflags = (players[player].pflags & (PF_WANTSTOJOIN|PF_GAMETYPEOVER));
playerangleturn = players[player].angleturn; playerangleturn = players[player].angleturn;
oldrelangleturn = players[player].oldrelangleturn;
// As long as we're not in multiplayer, carry over cheatcodes from map to map // As long as we're not in multiplayer, carry over cheatcodes from map to map
if (!(netgame || multiplayer)) if (!(netgame || multiplayer))
@ -2227,7 +2190,6 @@ void G_PlayerReborn(INT32 player, boolean betweenmaps)
p->splitscreenindex = splitscreenindex; p->splitscreenindex = splitscreenindex;
p->spectator = spectator; p->spectator = spectator;
p->angleturn = playerangleturn; p->angleturn = playerangleturn;
p->oldrelangleturn = oldrelangleturn;
// save player config truth reborn // save player config truth reborn
p->skincolor = skincolor; p->skincolor = skincolor;

1
src/g_game.h
View file

@ -82,7 +82,6 @@ extern consvar_t cv_resume;
// build an internal map name MAPxx from map number // build an internal map name MAPxx from map number
const char *G_BuildMapName(INT32 map); const char *G_BuildMapName(INT32 map);
extern INT16 ticcmd_oldangleturn[MAXSPLITSCREENPLAYERS];
void G_BuildTiccmd(ticcmd_t *cmd, INT32 realtics, UINT8 ssplayer); void G_BuildTiccmd(ticcmd_t *cmd, INT32 realtics, UINT8 ssplayer);
// copy ticcmd_t to and fro the normal way // copy ticcmd_t to and fro the normal way

8
src/k_bot.c
View file

@ -28,8 +28,6 @@
#include "r_things.h" // numskins #include "r_things.h" // numskins
static INT16 bot_oldangleturn[MAXPLAYERS];
/*-------------------------------------------------- /*--------------------------------------------------
boolean K_AddBot(UINT8 skin, UINT8 difficulty, UINT8 *p) boolean K_AddBot(UINT8 skin, UINT8 difficulty, UINT8 *p)
@ -864,8 +862,7 @@ void K_BuildBotTiccmd(player_t *player, ticcmd_t *cmd)
if (abs(player->botvars.turnconfirm) >= BOTTURNCONFIRM) if (abs(player->botvars.turnconfirm) >= BOTTURNCONFIRM)
{ {
// You're commiting to your turn, you're allowed! // You're commiting to your turn, you're allowed!
cmd->driftturn = turnamt; cmd->turning = turnamt;
cmd->angleturn += K_GetKartTurnValue(player, turnamt);
} }
} }
@ -874,8 +871,5 @@ void K_BuildBotTiccmd(player_t *player, ticcmd_t *cmd)
{ {
Z_Free(predict); Z_Free(predict);
} }
cmd->angleturn = (INT16)(cmd->angleturn + bot_oldangleturn[player - players]);
bot_oldangleturn[player - players] = cmd->angleturn;
} }

18
src/k_hud.c
View file

@ -3394,13 +3394,13 @@ static void K_drawKartFirstPerson(void)
splitflags |= (stplyr->mo->frame & FF_TRANSMASK); splitflags |= (stplyr->mo->frame & FF_TRANSMASK);
} }
if (cmd->driftturn > 400) // strong left turn if (cmd->turning > 400) // strong left turn
target = 2; target = 2;
else if (cmd->driftturn < -400) // strong right turn else if (cmd->turning < -400) // strong right turn
target = -2; target = -2;
else if (cmd->driftturn > 0) // weak left turn else if (cmd->turning > 0) // weak left turn
target = 1; target = 1;
else if (cmd->driftturn < 0) // weak right turn else if (cmd->turning < 0) // weak right turn
target = -1; target = -1;
else // forward else // forward
target = 0; target = 0;
@ -3423,8 +3423,8 @@ static void K_drawKartFirstPerson(void)
x <<= FRACBITS; x <<= FRACBITS;
y <<= FRACBITS; y <<= FRACBITS;
if (tn != cmd->driftturn/50) if (tn != cmd->turning/50)
tn -= (tn - (cmd->driftturn/50))/8; tn -= (tn - (cmd->turning/50))/8;
if (dr != stplyr->kartstuff[k_drift]*16) if (dr != stplyr->kartstuff[k_drift]*16)
dr -= (dr - (stplyr->kartstuff[k_drift]*16))/8; dr -= (dr - (stplyr->kartstuff[k_drift]*16))/8;
@ -3546,14 +3546,14 @@ static void K_drawInput(void)
y -= 1; y -= 1;
if (!cmd->driftturn) // no turn if (!cmd->turning) // no turn
target = 0; target = 0;
else // turning of multiple strengths! else // turning of multiple strengths!
{ {
target = ((abs(cmd->driftturn) - 1)/125)+1; target = ((abs(cmd->turning) - 1)/125)+1;
if (target > 4) if (target > 4)
target = 4; target = 4;
if (cmd->driftturn < 0) if (cmd->turning < 0)
target = -target; target = -target;
} }

38
src/k_kart.c
View file

@ -1712,11 +1712,11 @@ void K_KartMoveAnimation(player_t *player)
ticcmd_t *cmd = &player->cmd; ticcmd_t *cmd = &player->cmd;
const boolean spinningwheels = ((cmd->buttons & BT_ACCELERATE) || (onground && player->speed > 0)); const boolean spinningwheels = ((cmd->buttons & BT_ACCELERATE) || (onground && player->speed > 0));
if (cmd->driftturn < -minturn) if (cmd->turning < -minturn)
{ {
turndir = -1; turndir = -1;
} }
else if (cmd->driftturn > minturn) else if (cmd->turning > minturn)
{ {
turndir = 1; turndir = 1;
} }
@ -3029,8 +3029,8 @@ static void K_SpawnDriftSparks(player_t *player)
} }
} }
if ((player->kartstuff[k_drift] > 0 && player->cmd.driftturn > 0) // Inward drifts if ((player->kartstuff[k_drift] > 0 && player->cmd.turning > 0) // Inward drifts
|| (player->kartstuff[k_drift] < 0 && player->cmd.driftturn < 0)) || (player->kartstuff[k_drift] < 0 && player->cmd.turning < 0))
{ {
if ((player->kartstuff[k_drift] < 0 && (i & 1)) if ((player->kartstuff[k_drift] < 0 && (i & 1))
|| (player->kartstuff[k_drift] > 0 && !(i & 1))) || (player->kartstuff[k_drift] > 0 && !(i & 1)))
@ -3043,8 +3043,8 @@ static void K_SpawnDriftSparks(player_t *player)
size--; size--;
} }
} }
else if ((player->kartstuff[k_drift] > 0 && player->cmd.driftturn < 0) // Outward drifts else if ((player->kartstuff[k_drift] > 0 && player->cmd.turning < 0) // Outward drifts
|| (player->kartstuff[k_drift] < 0 && player->cmd.driftturn > 0)) || (player->kartstuff[k_drift] < 0 && player->cmd.turning > 0))
{ {
if ((player->kartstuff[k_drift] < 0 && (i & 1)) if ((player->kartstuff[k_drift] < 0 && (i & 1))
|| (player->kartstuff[k_drift] > 0 && !(i & 1))) || (player->kartstuff[k_drift] > 0 && !(i & 1)))
@ -6401,14 +6401,14 @@ static void K_KartDrift(player_t *player, boolean onground)
} }
// Drifting: left or right? // Drifting: left or right?
if ((player->cmd.driftturn > 0) && player->speed > minspeed && player->kartstuff[k_jmp] == 1 if ((player->cmd.turning > 0) && player->speed > minspeed && player->kartstuff[k_jmp] == 1
&& (player->kartstuff[k_drift] == 0 || player->kartstuff[k_driftend] == 1)) // && player->kartstuff[k_drift] != 1) && (player->kartstuff[k_drift] == 0 || player->kartstuff[k_driftend] == 1)) // && player->kartstuff[k_drift] != 1)
{ {
// Starting left drift // Starting left drift
player->kartstuff[k_drift] = 1; player->kartstuff[k_drift] = 1;
player->kartstuff[k_driftend] = player->kartstuff[k_driftcharge] = 0; player->kartstuff[k_driftend] = player->kartstuff[k_driftcharge] = 0;
} }
else if ((player->cmd.driftturn < 0) && player->speed > minspeed && player->kartstuff[k_jmp] == 1 else if ((player->cmd.turning < 0) && player->speed > minspeed && player->kartstuff[k_jmp] == 1
&& (player->kartstuff[k_drift] == 0 || player->kartstuff[k_driftend] == 1)) // && player->kartstuff[k_drift] != -1) && (player->kartstuff[k_drift] == 0 || player->kartstuff[k_driftend] == 1)) // && player->kartstuff[k_drift] != -1)
{ {
// Starting right drift // Starting right drift
@ -6453,10 +6453,10 @@ static void K_KartDrift(player_t *player, boolean onground)
if (player->kartstuff[k_drift] > 5) if (player->kartstuff[k_drift] > 5)
player->kartstuff[k_drift] = 5; player->kartstuff[k_drift] = 5;
if (player->cmd.driftturn > 0) // Inward if (player->cmd.turning > 0) // Inward
driftadditive += abs(player->cmd.driftturn)/100; driftadditive += abs(player->cmd.turning)/100;
if (player->cmd.driftturn < 0) // Outward if (player->cmd.turning < 0) // Outward
driftadditive -= abs(player->cmd.driftturn)/75; driftadditive -= abs(player->cmd.turning)/75;
} }
else if (player->kartstuff[k_drift] <= -1) // Drifting to the right else if (player->kartstuff[k_drift] <= -1) // Drifting to the right
{ {
@ -6464,10 +6464,10 @@ static void K_KartDrift(player_t *player, boolean onground)
if (player->kartstuff[k_drift] < -5) if (player->kartstuff[k_drift] < -5)
player->kartstuff[k_drift] = -5; player->kartstuff[k_drift] = -5;
if (player->cmd.driftturn < 0) // Inward if (player->cmd.turning < 0) // Inward
driftadditive += abs(player->cmd.driftturn)/100; driftadditive += abs(player->cmd.turning)/100;
if (player->cmd.driftturn > 0) // Outward if (player->cmd.turning > 0) // Outward
driftadditive -= abs(player->cmd.driftturn)/75; driftadditive -= abs(player->cmd.turning)/75;
} }
// Disable drift-sparks until you're going fast enough // Disable drift-sparks until you're going fast enough
@ -6531,9 +6531,9 @@ static void K_KartDrift(player_t *player, boolean onground)
} }
if ((player->kartstuff[k_handleboost] == 0) if ((player->kartstuff[k_handleboost] == 0)
|| (!player->cmd.driftturn) || (!player->cmd.turning)
|| (!player->kartstuff[k_aizdriftstrat]) || (!player->kartstuff[k_aizdriftstrat])
|| (player->cmd.driftturn > 0) != (player->kartstuff[k_aizdriftstrat] > 0)) || (player->cmd.turning > 0) != (player->kartstuff[k_aizdriftstrat] > 0))
{ {
if (!player->kartstuff[k_drift]) if (!player->kartstuff[k_drift])
player->kartstuff[k_aizdriftstrat] = 0; player->kartstuff[k_aizdriftstrat] = 0;
@ -6747,7 +6747,7 @@ static void K_KartSpindash(player_t *player)
if (player->speed < 6*mapobjectscale && player->powers[pw_flashing] == 0) if (player->speed < 6*mapobjectscale && player->powers[pw_flashing] == 0)
{ {
if (cmd->driftturn != 0 && leveltime % 8 == 0) if (cmd->turning != 0 && leveltime % 8 == 0)
S_StartSound(player->mo, sfx_ruburn); S_StartSound(player->mo, sfx_ruburn);
if ((cmd->buttons & (BT_DRIFT|BT_BRAKE)) == (BT_DRIFT|BT_BRAKE)) if ((cmd->buttons & (BT_DRIFT|BT_BRAKE)) == (BT_DRIFT|BT_BRAKE))

19
src/lua_playerlib.c
View file

@ -816,6 +816,7 @@ static int kartstuff_len(lua_State *L)
} }
#define NOFIELD luaL_error(L, LUA_QL("ticcmd_t") " has no field named " LUA_QS, field) #define NOFIELD luaL_error(L, LUA_QL("ticcmd_t") " has no field named " LUA_QS, field)
#define NOSET luaL_error(L, LUA_QL("ticcmd_t") " field " LUA_QS " cannot be set.", field)
static int ticcmd_get(lua_State *L) static int ticcmd_get(lua_State *L)
{ {
@ -826,16 +827,16 @@ static int ticcmd_get(lua_State *L)
if (fastcmp(field,"forwardmove")) if (fastcmp(field,"forwardmove"))
lua_pushinteger(L, cmd->forwardmove); lua_pushinteger(L, cmd->forwardmove);
else if (fastcmp(field,"angleturn")) else if (fastcmp(field,"turning"))
lua_pushinteger(L, cmd->angleturn); lua_pushinteger(L, cmd->turning);
else if (fastcmp(field,"aiming")) else if (fastcmp(field,"aiming"))
lua_pushinteger(L, cmd->aiming); lua_pushinteger(L, cmd->aiming);
else if (fastcmp(field,"buttons")) else if (fastcmp(field,"buttons"))
lua_pushinteger(L, cmd->buttons); lua_pushinteger(L, cmd->buttons);
else if (fastcmp(field,"driftturn"))
lua_pushinteger(L, cmd->driftturn);
else if (fastcmp(field,"latency")) else if (fastcmp(field,"latency"))
lua_pushinteger(L, cmd->latency); lua_pushinteger(L, cmd->latency);
else if (fastcmp(field,"flags"))
lua_pushinteger(L, cmd->flags);
else else
return NOFIELD; return NOFIELD;
@ -854,14 +855,16 @@ static int ticcmd_set(lua_State *L)
if (fastcmp(field,"forwardmove")) if (fastcmp(field,"forwardmove"))
cmd->forwardmove = (SINT8)luaL_checkinteger(L, 3); cmd->forwardmove = (SINT8)luaL_checkinteger(L, 3);
else if (fastcmp(field,"angleturn")) else if (fastcmp(field,"turning"))
cmd->angleturn = (INT16)luaL_checkinteger(L, 3); cmd->turning = (INT16)luaL_checkinteger(L, 3);
else if (fastcmp(field,"aiming")) else if (fastcmp(field,"aiming"))
cmd->aiming = (INT16)luaL_checkinteger(L, 3); cmd->aiming = (INT16)luaL_checkinteger(L, 3);
else if (fastcmp(field,"buttons")) else if (fastcmp(field,"buttons"))
cmd->buttons = (UINT16)luaL_checkinteger(L, 3); cmd->buttons = (UINT16)luaL_checkinteger(L, 3);
else if (fastcmp(field,"driftturn")) else if (fastcmp(field,"latency"))
cmd->driftturn = (INT16)luaL_checkinteger(L, 3); return NOSET;
else if (fastcmp(field,"flags"))
return NOSET;
else else
return NOFIELD; return NOFIELD;

4
src/m_cheat.c
View file

@ -1033,10 +1033,10 @@ void OP_ObjectplaceMovement(player_t *player)
{ {
ticcmd_t *cmd = &player->cmd; ticcmd_t *cmd = &player->cmd;
player->drawangle = player->mo->angle = (cmd->angleturn<<16 /* not FRACBITS */); player->drawangle = player->mo->angle = player->angleturn;
ticruned++; ticruned++;
if (!(cmd->angleturn & TICCMD_RECEIVED)) if (!(cmd->flags & TICCMD_RECEIVED))
ticmiss++; ticmiss++;
if (cmd->buttons & BT_ACCELERATE) if (cmd->buttons & BT_ACCELERATE)

18
src/p_mobj.c
View file

@ -5890,7 +5890,7 @@ static void P_TracerAngleThink(mobj_t *mobj)
// mobj->cvmem - Failure timer // mobj->cvmem - Failure timer
if (mobj->player) if (mobj->player)
looking = ( mobj->player->cmd.angleturn << 16 );/* fixes CS_LMAOGALOG */ looking = mobj->player->angleturn;
else else
looking = mobj->angle; looking = mobj->angle;
@ -7662,7 +7662,7 @@ static boolean P_MobjRegularThink(mobj_t *mobj)
break; break;
} }
if (abs(player->cmd.driftturn) > 100) if (abs(player->cmd.turning) > 100)
{ {
INT32 lastsign = 0; INT32 lastsign = 0;
if (mobj->lastlook > 0) if (mobj->lastlook > 0)
@ -7670,15 +7670,15 @@ static boolean P_MobjRegularThink(mobj_t *mobj)
else if (mobj->lastlook < 0) else if (mobj->lastlook < 0)
lastsign = -1; lastsign = -1;
if ((player->cmd.driftturn > 0 && lastsign < 0) if ((player->cmd.turning > 0 && lastsign < 0)
|| (player->cmd.driftturn < 0 && lastsign > 0)) || (player->cmd.turning < 0 && lastsign > 0))
{ {
mobj->movecount += (TICRATE/2); mobj->movecount += (TICRATE/2);
mobj->threshold = 16*lastsign; mobj->threshold = 16*lastsign;
S_StartSound(mobj, sfx_s1ab); S_StartSound(mobj, sfx_s1ab);
} }
mobj->lastlook = player->cmd.driftturn; mobj->lastlook = player->cmd.turning;
} }
mobj->movecount++; mobj->movecount++;
@ -7818,7 +7818,7 @@ static boolean P_MobjRegularThink(mobj_t *mobj)
break; break;
} }
if (abs(player->cmd.driftturn) > 100) if (abs(player->cmd.turning) > 100)
{ {
INT32 lastsign = 0; INT32 lastsign = 0;
if (mobj->lastlook > 0) if (mobj->lastlook > 0)
@ -7826,15 +7826,15 @@ static boolean P_MobjRegularThink(mobj_t *mobj)
else if (mobj->lastlook < 0) else if (mobj->lastlook < 0)
lastsign = -1; lastsign = -1;
if ((player->cmd.driftturn > 0 && lastsign < 0) if ((player->cmd.turning > 0 && lastsign < 0)
|| (player->cmd.driftturn < 0 && lastsign > 0)) || (player->cmd.turning < 0 && lastsign > 0))
{ {
mobj->movecount += (TICRATE/2); mobj->movecount += (TICRATE/2);
mobj->cvmem = 8*lastsign; mobj->cvmem = 8*lastsign;
S_StartSound(mobj, sfx_s3k7a); S_StartSound(mobj, sfx_s3k7a);
} }
mobj->lastlook = player->cmd.driftturn; mobj->lastlook = player->cmd.turning;
} }
mobj->movecount++; mobj->movecount++;

2
src/p_polyobj.c
View file

@ -1153,7 +1153,7 @@ static void Polyobj_rotateThings(polyobj_t *po, vector2_t origin, angle_t delta,
if (turnthings == 2 || (turnthings == 1 && !mo->player)) { if (turnthings == 2 || (turnthings == 1 && !mo->player)) {
mo->angle += delta; mo->angle += delta;
if (mo->player) if (mo->player)
P_SetPlayerAngle(mo->player, (angle_t)(mo->player->angleturn << 16) + delta); P_SetPlayerAngle(mo->player, mo->player->angleturn + delta);
} }
} }
} }

18
src/p_saveg.c
View file

@ -102,8 +102,7 @@ static void P_NetArchivePlayers(void)
// no longer send ticcmds, player name, skin, or color // no longer send ticcmds, player name, skin, or color
WRITEINT16(save_p, players[i].angleturn); WRITEANGLE(save_p, players[i].angleturn);
WRITEINT16(save_p, players[i].oldrelangleturn);
WRITEANGLE(save_p, players[i].aiming); WRITEANGLE(save_p, players[i].aiming);
WRITEANGLE(save_p, players[i].drawangle); WRITEANGLE(save_p, players[i].drawangle);
WRITEANGLE(save_p, players[i].viewrollangle); WRITEANGLE(save_p, players[i].viewrollangle);
@ -251,12 +250,6 @@ static void P_NetArchivePlayers(void)
for (j = 0; j < NUMKARTSTUFF; j++) for (j = 0; j < NUMKARTSTUFF; j++)
WRITEINT32(save_p, players[i].kartstuff[j]); WRITEINT32(save_p, players[i].kartstuff[j]);
for (j = 0; j < MAXPREDICTTICS; j++)
{
WRITEINT16(save_p, players[i].lturn_max[j]);
WRITEINT16(save_p, players[i].rturn_max[j]);
}
WRITEUINT32(save_p, players[i].distancetofinish); WRITEUINT32(save_p, players[i].distancetofinish);
WRITEUINT32(save_p, K_GetWaypointHeapIndex(players[i].nextwaypoint)); WRITEUINT32(save_p, K_GetWaypointHeapIndex(players[i].nextwaypoint));
WRITEUINT32(save_p, players[i].airtime); WRITEUINT32(save_p, players[i].airtime);
@ -302,8 +295,7 @@ static void P_NetUnArchivePlayers(void)
// sending player names, skin and color should not be necessary at all! // sending player names, skin and color should not be necessary at all!
// (that data is handled in the server config now) // (that data is handled in the server config now)
players[i].angleturn = READINT16(save_p); players[i].angleturn = READANGLE(save_p);
players[i].oldrelangleturn = READINT16(save_p);
players[i].aiming = READANGLE(save_p); players[i].aiming = READANGLE(save_p);
players[i].drawangle = READANGLE(save_p); players[i].drawangle = READANGLE(save_p);
players[i].viewrollangle = READANGLE(save_p); players[i].viewrollangle = READANGLE(save_p);
@ -443,12 +435,6 @@ static void P_NetUnArchivePlayers(void)
for (j = 0; j < NUMKARTSTUFF; j++) for (j = 0; j < NUMKARTSTUFF; j++)
players[i].kartstuff[j] = READINT32(save_p); players[i].kartstuff[j] = READINT32(save_p);
for (j = 0; j < MAXPREDICTTICS; j++)
{
players[i].lturn_max[j] = READINT16(save_p);
players[i].rturn_max[j] = READINT16(save_p);
}
players[i].distancetofinish = READUINT32(save_p); players[i].distancetofinish = READUINT32(save_p);
players[i].nextwaypoint = (waypoint_t *)(size_t)READUINT32(save_p); players[i].nextwaypoint = (waypoint_t *)(size_t)READUINT32(save_p);
players[i].airtime = READUINT32(save_p); players[i].airtime = READUINT32(save_p);

2
src/p_spec.c
View file

@ -8695,7 +8695,7 @@ void T_Pusher(pusher_t *p)
if (!demo.playback) if (!demo.playback)
{ {
angle_t angle = thing->player->angleturn << 16; angle_t angle = thing->player->angleturn;
if (thing->angle - angle > ANGLE_180) if (thing->angle - angle > ANGLE_180)
P_SetPlayerAngle(thing->player, angle - (angle - thing->angle) / 8); P_SetPlayerAngle(thing->player, angle - (angle - thing->angle) / 8);
else else

4
src/p_tick.c
View file

@ -722,10 +722,6 @@ void P_PreTicker(INT32 frames)
// (and disrupt demo recording and other things !!) // (and disrupt demo recording and other things !!)
memcpy(&temptic, &players[i].cmd, sizeof(ticcmd_t)); memcpy(&temptic, &players[i].cmd, sizeof(ticcmd_t));
memset(&players[i].cmd, 0, sizeof(ticcmd_t)); memset(&players[i].cmd, 0, sizeof(ticcmd_t));
// correct angle on spawn...
players[i].angleturn += temptic.angleturn - players[i].oldrelangleturn;
players[i].oldrelangleturn = temptic.angleturn;
players[i].cmd.angleturn = players[i].angleturn;
P_PlayerThink(&players[i]); P_PlayerThink(&players[i]);

103
src/p_user.c
View file

@ -2062,10 +2062,10 @@ static void P_SpectatorMovement(player_t *player)
{ {
ticcmd_t *cmd = &player->cmd; ticcmd_t *cmd = &player->cmd;
player->mo->angle = (cmd->angleturn<<16 /* not FRACBITS */); player->mo->angle = player->angleturn;
ticruned++; ticruned++;
if (!(cmd->angleturn & TICCMD_RECEIVED)) if (!(cmd->flags & TICCMD_RECEIVED))
ticmiss++; ticmiss++;
if (cmd->buttons & BT_ACCELERATE) if (cmd->buttons & BT_ACCELERATE)
@ -2133,52 +2133,13 @@ void P_MovePlayer(player_t *player)
// MOVEMENT CODE // // MOVEMENT CODE //
////////////////////// //////////////////////
{ player->mo->angle = player->angleturn;
INT16 angle_diff, max_left_turn, max_right_turn;
boolean add_delta = true;
// Kart: store the current turn range for later use ticruned++;
player->lturn_max[leveltime%MAXPREDICTTICS] = K_GetKartTurnValue(player, KART_FULLTURN)+1; if (!(cmd->flags & TICCMD_RECEIVED))
player->rturn_max[leveltime%MAXPREDICTTICS] = K_GetKartTurnValue(player, -KART_FULLTURN)-1; ticmiss++;
if (leveltime >= introtime) P_3dMovement(player);
{
// KART: Don't directly apply angleturn! It may have been either A) forged by a malicious client, or B) not be a smooth turn due to a player dropping frames.
// Instead, turn the player only up to the amount they're supposed to turn accounting for latency. Allow exactly 1 extra turn unit to try to keep old replays synced.
angle_diff = cmd->angleturn - (player->mo->angle>>16);
max_left_turn = player->lturn_max[(leveltime + MAXPREDICTTICS - cmd->latency) % MAXPREDICTTICS];
max_right_turn = player->rturn_max[(leveltime + MAXPREDICTTICS - cmd->latency) % MAXPREDICTTICS];
//CONS_Printf("----------------\nangle diff: %d - turning options: %d to %d - ", angle_diff, max_left_turn, max_right_turn);
if (angle_diff > max_left_turn)
angle_diff = max_left_turn;
else if (angle_diff < max_right_turn)
angle_diff = max_right_turn;
else
{
// Try to keep normal turning as accurate to 1.0.1 as possible to reduce replay desyncs.
player->mo->angle = cmd->angleturn<<16;
add_delta = false;
}
//CONS_Printf("applied turn: %d\n", angle_diff);
if (add_delta) {
player->mo->angle += angle_diff<<16;
player->mo->angle &= ~0xFFFF; // Try to keep the turning somewhat similar to how it was before?
//CONS_Printf("leftover turn (%s): %5d or %4d%%\n",
// player_names[player-players],
// (INT16) (cmd->angleturn - (player->mo->angle>>16)),
// (INT16) (cmd->angleturn - (player->mo->angle>>16)) * 100 / (angle_diff ? angle_diff : 1));
}
}
ticruned++;
if ((cmd->angleturn & TICCMD_RECEIVED) == 0)
ticmiss++;
P_3dMovement(player);
}
// Kart frames // Kart frames
if (player->kartstuff[k_squishedtimer] > 0) if (player->kartstuff[k_squishedtimer] > 0)
@ -2772,8 +2733,7 @@ fixed_t t_cam_rotate[MAXSPLITSCREENPLAYERS] = {-42,-42,-42,-42};
// we then throw that ticcmd garbage in the camera and make it move // we then throw that ticcmd garbage in the camera and make it move
// redefine this // redefine this
static fixed_t forwardmove = MAXPLMOVE<<FRACBITS>>16; static fixed_t angleturn[2] = {KART_FULLTURN, KART_FULLTURN/4}; // + slow turn
static fixed_t angleturn[3] = {KART_FULLTURN/2, KART_FULLTURN, KART_FULLTURN/4}; // + slow turn
static ticcmd_t cameracmd; static ticcmd_t cameracmd;
@ -2788,7 +2748,6 @@ void P_InitCameraCmd(void)
static ticcmd_t *P_CameraCmd(camera_t *cam) static ticcmd_t *P_CameraCmd(camera_t *cam)
{ {
INT32 laim, th, tspeed, forward, axis; //i INT32 laim, th, tspeed, forward, axis; //i
const INT32 speed = 1;
// these ones used for multiple conditions // these ones used for multiple conditions
boolean turnleft, turnright, mouseaiming; boolean turnleft, turnright, mouseaiming;
boolean invertmouse, lookaxis, usejoystick, kbl; boolean invertmouse, lookaxis, usejoystick, kbl;
@ -2809,7 +2768,7 @@ static ticcmd_t *P_CameraCmd(camera_t *cam)
G_CopyTiccmd(cmd, I_BaseTiccmd(), 1); // empty, or external driver G_CopyTiccmd(cmd, I_BaseTiccmd(), 1); // empty, or external driver
cmd->angleturn = (INT16)(lang >> 16); //cmd->turning = (INT16)(lang >> 16);
cmd->aiming = G_ClipAimingPitch(&laim); cmd->aiming = G_ClipAimingPitch(&laim);
mouseaiming = true; mouseaiming = true;
@ -2845,21 +2804,23 @@ static ticcmd_t *P_CameraCmd(camera_t *cam)
th = 0; th = 0;
if (th < SLOWTURNTICS) if (th < SLOWTURNTICS)
tspeed = 2; // slow turn tspeed = 1; // slow turn
else else
tspeed = speed; tspeed = 0;
cmd->turning = 0;
// let movement keys cancel each other out // let movement keys cancel each other out
if (turnright && !(turnleft)) if (turnright && !(turnleft))
{ {
cmd->angleturn = (INT16)(cmd->angleturn - (angleturn[tspeed])); cmd->turning = (INT16)(cmd->turning - (angleturn[tspeed]));
} }
else if (turnleft && !(turnright)) else if (turnleft && !(turnright))
{ {
cmd->angleturn = (INT16)(cmd->angleturn + (angleturn[tspeed])); cmd->turning = (INT16)(cmd->turning + (angleturn[tspeed]));
} }
cmd->angleturn = (INT16)(cmd->angleturn - ((mousex*(encoremode ? -1 : 1)*8))); cmd->turning = (INT16)(cmd->turning - ((mousex*(encoremode ? -1 : 1)*8)));
axis = PlayerJoyAxis(1, AXISMOVE); axis = PlayerJoyAxis(1, AXISMOVE);
if (PlayerInputDown(1, gc_accelerate) || (usejoystick && axis > 0)) if (PlayerInputDown(1, gc_accelerate) || (usejoystick && axis > 0))
@ -2869,9 +2830,9 @@ static ticcmd_t *P_CameraCmd(camera_t *cam)
cmd->buttons |= BT_BRAKE; cmd->buttons |= BT_BRAKE;
axis = PlayerJoyAxis(1, AXISAIM); axis = PlayerJoyAxis(1, AXISAIM);
if (PlayerInputDown(1, gc_aimforward) || (usejoystick && axis < 0)) if (PlayerInputDown(1, gc_aimforward) || (usejoystick && axis < 0))
forward += forwardmove; forward += MAXPLMOVE;
if (PlayerInputDown(1, gc_aimbackward) || (usejoystick && axis > 0)) if (PlayerInputDown(1, gc_aimbackward) || (usejoystick && axis > 0))
forward -= forwardmove; forward -= MAXPLMOVE;
// fire with any button/key // fire with any button/key
axis = PlayerJoyAxis(1, AXISFIRE); axis = PlayerJoyAxis(1, AXISFIRE);
@ -2919,7 +2880,7 @@ static ticcmd_t *P_CameraCmd(camera_t *cam)
else if (cmd->forwardmove < -MAXPLMOVE) else if (cmd->forwardmove < -MAXPLMOVE)
cmd->forwardmove = -MAXPLMOVE; cmd->forwardmove = -MAXPLMOVE;
lang += (cmd->angleturn<<16); lang += (cmd->turning << TICCMD_REDUCE);
democam.localangle = lang; democam.localangle = lang;
democam.localaiming = laim; democam.localaiming = laim;
@ -2945,7 +2906,7 @@ void P_DemoCameraMovement(camera_t *cam)
cmd = P_CameraCmd(cam); cmd = P_CameraCmd(cam);
cam->aiming = cmd->aiming<<FRACBITS; cam->aiming = cmd->aiming<<FRACBITS;
cam->angle = cmd->angleturn<<16; //cam->angle = cmd->angleturn << TICCMD_REDUCE;
// camera movement: // camera movement:
@ -4273,6 +4234,12 @@ void P_PlayerThink(player_t *player)
cmd = &player->cmd; cmd = &player->cmd;
{
angle_t angleChange = K_GetKartTurnValue(player, cmd->turning) << TICCMD_REDUCE;
player->angleturn += angleChange;
P_SetLocalAngle(player, P_GetLocalAngle(player) + angleChange);
}
// SRB2kart // SRB2kart
// Save the dir the player is holding // Save the dir the player is holding
// to allow items to be thrown forward or backward. // to allow items to be thrown forward or backward.
@ -4699,27 +4666,17 @@ void P_PlayerAfterThink(player_t *player)
void P_SetPlayerAngle(player_t *player, angle_t angle) void P_SetPlayerAngle(player_t *player, angle_t angle)
{ {
INT16 delta = (INT16)(angle >> 16) - player->angleturn; angle_t delta = angle - player->angleturn;
P_ForceLocalAngle(player, P_GetLocalAngle(player) + (delta << 16)); P_ForceLocalAngle(player, P_GetLocalAngle(player) + delta);
player->angleturn += delta; player->angleturn += delta;
} }
void P_SetLocalAngle(player_t *player, angle_t angle) void P_SetLocalAngle(player_t *player, angle_t angle)
{ {
INT16 delta = (INT16)((angle - P_GetLocalAngle(player)) >> 16); angle_t delta = (angle - P_GetLocalAngle(player));
UINT8 i;
P_ForceLocalAngle(player, P_GetLocalAngle(player) + (angle_t)(delta << 16)); P_ForceLocalAngle(player, P_GetLocalAngle(player) + delta);
for (i = 0; i <= splitscreen; i++)
{
if (player == &players[g_localplayers[i]])
{
ticcmd_oldangleturn[i] += delta;
break;
}
}
} }
angle_t P_GetLocalAngle(player_t *player) angle_t P_GetLocalAngle(player_t *player)