thirdpartymirrors/RingRacers
1
0
Fork 0
mirror of https://github.com/KartKrewDev/RingRacers.git synced 2026-02-20 20:41:10 +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);
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));
}
@ -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->panim = (UINT8)players[i].panim; //panim_t
rsp->angleturn = (INT16)SHORT(players[i].angleturn);
rsp->oldrelangleturn = (INT16)SHORT(players[i].oldrelangleturn);
rsp->angleturn = (angle_t)LONG(players[i].angleturn);
rsp->aiming = (angle_t)LONG(players[i].aiming);
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].panim = (UINT8)rsp->panim; //panim_t
players[i].angleturn = (INT16)SHORT(rsp->angleturn);
players[i].oldrelangleturn = (INT16)SHORT(rsp->oldrelangleturn);
players[i].angleturn = (angle_t)LONG(rsp->angleturn);
players[i].aiming = (angle_t)LONG(rsp->aiming);
for (j = 0; j < NUMPOWERS; ++j)
@ -3675,8 +3671,7 @@ static void Got_AddPlayer(UINT8 **p, INT32 playernum)
DEBFILE("spawning me\n");
}
ticcmd_oldangleturn[splitscreenplayer] = newplayer->oldrelangleturn;
P_ForceLocalAngle(newplayer, (angle_t)(newplayer->angleturn << 16));
P_ForceLocalAngle(newplayer, newplayer->angleturn);
D_SendPlayerConfig();
addedtogame = true;
@ -4485,7 +4480,7 @@ static void HandlePacketFromAwayNode(SINT8 node)
static boolean CheckForSpeedHacks(UINT8 p)
{
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]);
//D_Clearticcmd(k);
@ -5445,22 +5440,22 @@ static void Local_Maketic(INT32 realtics)
// translate inputs (keyboard/mouse/joystick) into game controls
G_BuildTiccmd(&localcmds[0], realtics, 1);
localcmds[0].angleturn |= TICCMD_RECEIVED;
localcmds[0].flags |= TICCMD_RECEIVED;
if (splitscreen)
{
G_BuildTiccmd(&localcmds[1], realtics, 2);
localcmds[1].angleturn |= TICCMD_RECEIVED;
localcmds[1].flags |= TICCMD_RECEIVED;
if (splitscreen > 1)
{
G_BuildTiccmd(&localcmds[2], realtics, 3);
localcmds[2].angleturn |= TICCMD_RECEIVED;
localcmds[2].flags |= TICCMD_RECEIVED;
if (splitscreen > 2)
{
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
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 *prevticcmd = &netcmds[(maketic - 1) % BACKUPTICS][i];
if (players[i].quittime)
{
// Copy the angle/aiming from the previous tic
// and empty the other inputs
// empty inputs but consider recieved
memset(ticcmd, 0, sizeof(netcmds[0][0]));
ticcmd->angleturn = prevticcmd->angleturn | TICCMD_RECEIVED;
ticcmd->aiming = prevticcmd->aiming;
ticcmd->flags = prevticcmd->flags | TICCMD_RECEIVED;
}
else
{
DEBFILE(va("MISS tic%4d for player %d\n", maketic, i));
// Copy the input from the previous tic
*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
UINT8 panim; // panim_t
INT16 angleturn;
INT16 oldrelangleturn;
angle_t angleturn;
angle_t aiming;
UINT16 powers[NUMPOWERS];

5
src/d_player.h
View file

@ -486,8 +486,7 @@ typedef struct player_s
angle_t viewrollangle;
INT16 angleturn;
INT16 oldrelangleturn;
angle_t angleturn;
// Mouse aiming, where the guy is looking at!
// It is updated with cmd->aiming.
@ -505,8 +504,6 @@ typedef struct player_s
// SRB2kart stuff
INT32 kartstuff[NUMKARTSTUFF];
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;
waypoint_t *nextwaypoint;
respawnvars_t respawn; // Respawn info

12
src/d_ticcmd.h
View file

@ -27,7 +27,7 @@
typedef enum
{
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_ATTACK = 1<<4, // Use Item
BT_FORWARD = 1<<5, // Aim Item Forward
@ -49,9 +49,11 @@ typedef enum
// Mainly movements/button commands per game tick,
// 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_XY 2
#if defined(_MSC_VER)
#pragma pack(1)
@ -60,11 +62,11 @@ typedef enum
typedef struct
{
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
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 flags;
} ATTRPACK ticcmd_t;
#if defined(_MSC_VER)

43
src/g_demo.c
View file

@ -123,11 +123,11 @@ demoghost *ghosts = NULL;
// For demos
#define ZT_FWD 0x01
#define ZT_SIDE 0x02
#define ZT_ANGLE 0x04
#define ZT_TURNING 0x04
#define ZT_BUTTONS 0x08
#define ZT_AIMING 0x10
#define ZT_DRIFT 0x20
#define ZT_LATENCY 0x40
#define ZT_LATENCY 0x20
#define ZT_FLAGS 0x40
#define DEMOMARKER 0x80 // demoend
UINT8 demo_extradata[MAXPLAYERS];
@ -483,19 +483,18 @@ void G_ReadDemoTiccmd(ticcmd_t *cmd, INT32 playernum)
if (ziptic & ZT_FWD)
oldcmd[playernum].forwardmove = READSINT8(demo_p);
if (ziptic & ZT_ANGLE)
oldcmd[playernum].angleturn = READINT16(demo_p);
if (ziptic & ZT_TURNING)
oldcmd[playernum].turning = READINT16(demo_p);
if (ziptic & ZT_BUTTONS)
oldcmd[playernum].buttons = READUINT16(demo_p);
if (ziptic & ZT_AIMING)
oldcmd[playernum].aiming = READINT16(demo_p);
if (ziptic & ZT_DRIFT)
oldcmd[playernum].driftturn = READINT16(demo_p);
if (ziptic & ZT_LATENCY)
oldcmd[playernum].latency = READUINT8(demo_p);
if (ziptic & ZT_FLAGS)
oldcmd[playernum].latency = READUINT8(demo_p);
G_CopyTiccmd(cmd, &oldcmd[playernum], 1);
players[playernum].angleturn = cmd->angleturn;
if (!(demoflags & DF_GHOST) && *demo_p == DEMOMARKER)
{
@ -522,11 +521,11 @@ void G_WriteDemoTiccmd(ticcmd_t *cmd, INT32 playernum)
ziptic |= ZT_FWD;
}
if (cmd->angleturn != oldcmd[playernum].angleturn)
if (cmd->turning != oldcmd[playernum].turning)
{
WRITEINT16(demo_p,cmd->angleturn);
oldcmd[playernum].angleturn = cmd->angleturn;
ziptic |= ZT_ANGLE;
WRITEINT16(demo_p,cmd->turning);
oldcmd[playernum].turning = cmd->turning;
ziptic |= ZT_TURNING;
}
if (cmd->buttons != oldcmd[playernum].buttons)
@ -543,13 +542,6 @@ void G_WriteDemoTiccmd(ticcmd_t *cmd, INT32 playernum)
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)
{
WRITEUINT8(demo_p,cmd->latency);
@ -557,6 +549,13 @@ void G_WriteDemoTiccmd(ticcmd_t *cmd, INT32 playernum)
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;
// attention here for the ticcmd size!
@ -1086,16 +1085,16 @@ void G_GhostTicker(void)
if (ziptic & ZT_FWD)
g->p++;
if (ziptic & ZT_ANGLE)
if (ziptic & ZT_TURNING)
g->p += 2;
if (ziptic & ZT_BUTTONS)
g->p += 2;
if (ziptic & ZT_AIMING)
g->p += 2;
if (ziptic & ZT_DRIFT)
g->p += 2;
if (ziptic & ZT_LATENCY)
g->p += 1;
if (ziptic & ZT_FLAGS)
g->p += 1;
// Grab ghost data.
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];
angle_t localangle[MAXSPLITSCREENPLAYERS];
static INT32 forwardmove = 50<<FRACBITS>>16;
static INT32 angleturn[3] = {KART_FULLTURN/2, KART_FULLTURN, KART_FULLTURN/4}; // + slow turn
INT16 ticcmd_oldangleturn[MAXSPLITSCREENPLAYERS];
static INT32 angleturn[2] = {KART_FULLTURN, KART_FULLTURN / 4}; // + slow turn
void G_BuildTiccmd(ticcmd_t *cmd, INT32 realtics, UINT8 ssplayer)
{
const UINT8 forplayer = ssplayer-1;
const INT32 speed = 1;
const INT32 lookaxis = cv_lookaxis[forplayer].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]];
camera_t *thiscam = &camera[forplayer];
angle_t *myangle = &localangle[forplayer];
INT32 *laim = &localaiming[forplayer];
INT32 *th = &turnheld[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
if (paused || P_AutoPause() || (gamestate == GS_LEVEL && player->playerstate == PST_REBORN) || hu_resynching)
{
cmd->angleturn = ticcmd_oldangleturn[forplayer];
cmd->aiming = G_ClipAimingPitch(laim);
return;
}
@ -954,36 +948,31 @@ void G_BuildTiccmd(ticcmd_t *cmd, INT32 realtics, UINT8 ssplayer)
*th = 0;
if (*th < SLOWTURNTICS)
tspeed = 2; // slow turn
tspeed = 1; // slow turn
else
tspeed = speed;
tspeed = 0;
cmd->driftturn = 0;
cmd->turning = 0;
// let movement keys cancel each other out
if (turnright && !(turnleft))
{
cmd->angleturn = (INT16)(cmd->angleturn - (angleturn[tspeed]));
cmd->driftturn = (INT16)(cmd->driftturn - (angleturn[tspeed]));
cmd->turning = (INT16)(cmd->turning - (angleturn[tspeed]));
}
else if (turnleft && !(turnright))
{
cmd->angleturn = (INT16)(cmd->angleturn + (angleturn[tspeed]));
cmd->driftturn = (INT16)(cmd->driftturn + (angleturn[tspeed]));
cmd->turning = (INT16)(cmd->turning + (angleturn[tspeed]));
}
if (analogjoystickmove && joystickvector.xaxis != 0)
{
// JOYAXISRANGE should be 1023 (divide by 1024)
cmd->angleturn = (INT16)(cmd->angleturn - (((joystickvector.xaxis * angleturn[1]) >> 10))); // ANALOG!
cmd->driftturn = (INT16)(cmd->driftturn - (((joystickvector.xaxis * angleturn[1]) >> 10)));
cmd->turning = (INT16)(cmd->turning - (((joystickvector.xaxis * angleturn[0]) >> 10)));
}
// Specator mouse turning
if (player->spectator)
{
cmd->angleturn = (INT16)(cmd->angleturn - ((mousex*(encoremode ? -1 : 1)*8)));
cmd->driftturn = (INT16)(cmd->driftturn - ((mousex*(encoremode ? -1 : 1)*8)));
cmd->turning = (INT16)(cmd->turning - ((mousex*(encoremode ? -1 : 1)*8)));
}
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;
axis = PlayerJoyAxis(ssplayer, AXISAIM);
if (PlayerInputDown(ssplayer, gc_aimforward) || (usejoystick && axis < 0))
forward += forwardmove;
forward += MAXPLMOVE;
if (PlayerInputDown(ssplayer, gc_aimbackward) || (usejoystick && axis > 0))
forward -= forwardmove;
forward -= MAXPLMOVE;
}
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])
{
cmd->buttons |= BT_ACCELERATE;
forward = forwardmove; // 50
forward = MAXPLMOVE; // 50
}
else if (analogjoystickmove && axis > 0)
{
cmd->buttons |= BT_ACCELERATE;
// JOYAXISRANGE is supposed to be 1023 (divide by 1024)
forward += ((axis * forwardmove) >> 10);
forward += ((axis * MAXPLMOVE) >> 10);
}
axis = PlayerJoyAxis(ssplayer, AXISBRAKE);
@ -1021,14 +1010,14 @@ void G_BuildTiccmd(ticcmd_t *cmd, INT32 realtics, UINT8 ssplayer)
{
cmd->buttons |= BT_BRAKE;
if (cmd->buttons & BT_ACCELERATE || cmd->forwardmove <= 0)
forward -= forwardmove;
forward -= MAXPLMOVE;
}
else if (analogjoystickmove && axis > 0)
{
cmd->buttons |= BT_BRAKE;
// JOYAXISRANGE is supposed to be 1023 (divide by 1024)
if (cmd->buttons & BT_ACCELERATE || cmd->forwardmove <= 0)
forward -= ((axis * forwardmove) >> 10);
forward -= ((axis * MAXPLMOVE) >> 10);
}
// 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;
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->flags = 0;
/* 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.
@ -1167,7 +1129,17 @@ void G_BuildTiccmd(ticcmd_t *cmd, INT32 realtics, UINT8 ssplayer)
if (gamestate == GS_LEVEL)
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)
&& !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);
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)
@ -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++)
{
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].buttons = (UINT16)SHORT(src[i].buttons);
dest[i].driftturn = SHORT(src[i].driftturn);
dest[i].latency = src[i].latency;
dest[i].flags = src[i].flags;
}
return dest;
}
@ -1878,7 +1847,7 @@ void G_Ticker(boolean run)
G_CopyTiccmd(cmd, &netcmds[buf][i], 1);
// 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
cmd->latency = 0;
@ -1888,10 +1857,6 @@ void G_Ticker(boolean run)
//@TODO add a cvar to allow setting this max
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;
INT16 rings;
INT16 playerangleturn;
INT16 oldrelangleturn;
angle_t playerangleturn;
UINT8 botdiffincrease;
boolean botrival;
@ -2126,7 +2090,6 @@ void G_PlayerReborn(INT32 player, boolean betweenmaps)
pflags = (players[player].pflags & (PF_WANTSTOJOIN|PF_GAMETYPEOVER));
playerangleturn = players[player].angleturn;
oldrelangleturn = players[player].oldrelangleturn;
// As long as we're not in multiplayer, carry over cheatcodes from map to map
if (!(netgame || multiplayer))
@ -2227,7 +2190,6 @@ void G_PlayerReborn(INT32 player, boolean betweenmaps)
p->splitscreenindex = splitscreenindex;
p->spectator = spectator;
p->angleturn = playerangleturn;
p->oldrelangleturn = oldrelangleturn;
// save player config truth reborn
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
const char *G_BuildMapName(INT32 map);
extern INT16 ticcmd_oldangleturn[MAXSPLITSCREENPLAYERS];
void G_BuildTiccmd(ticcmd_t *cmd, INT32 realtics, UINT8 ssplayer);
// 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
static INT16 bot_oldangleturn[MAXPLAYERS];
/*--------------------------------------------------
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)
{
// You're commiting to your turn, you're allowed!
cmd->driftturn = turnamt;
cmd->angleturn += K_GetKartTurnValue(player, turnamt);
cmd->turning = turnamt;
}
}
@ -874,8 +871,5 @@ void K_BuildBotTiccmd(player_t *player, ticcmd_t *cmd)
{
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);
}
if (cmd->driftturn > 400) // strong left turn
if (cmd->turning > 400) // strong left turn
target = 2;
else if (cmd->driftturn < -400) // strong right turn
else if (cmd->turning < -400) // strong right turn
target = -2;
else if (cmd->driftturn > 0) // weak left turn
else if (cmd->turning > 0) // weak left turn
target = 1;
else if (cmd->driftturn < 0) // weak right turn
else if (cmd->turning < 0) // weak right turn
target = -1;
else // forward
target = 0;
@ -3423,8 +3423,8 @@ static void K_drawKartFirstPerson(void)
x <<= FRACBITS;
y <<= FRACBITS;
if (tn != cmd->driftturn/50)
tn -= (tn - (cmd->driftturn/50))/8;
if (tn != cmd->turning/50)
tn -= (tn - (cmd->turning/50))/8;
if (dr != stplyr->kartstuff[k_drift]*16)
dr -= (dr - (stplyr->kartstuff[k_drift]*16))/8;
@ -3546,14 +3546,14 @@ static void K_drawInput(void)
y -= 1;
if (!cmd->driftturn) // no turn
if (!cmd->turning) // no turn
target = 0;
else // turning of multiple strengths!
{
target = ((abs(cmd->driftturn) - 1)/125)+1;
target = ((abs(cmd->turning) - 1)/125)+1;
if (target > 4)
target = 4;
if (cmd->driftturn < 0)
if (cmd->turning < 0)
target = -target;
}

38
src/k_kart.c
View file

@ -1712,11 +1712,11 @@ void K_KartMoveAnimation(player_t *player)
ticcmd_t *cmd = &player->cmd;
const boolean spinningwheels = ((cmd->buttons & BT_ACCELERATE) || (onground && player->speed > 0));
if (cmd->driftturn < -minturn)
if (cmd->turning < -minturn)
{
turndir = -1;
}
else if (cmd->driftturn > minturn)
else if (cmd->turning > minturn)
{
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
|| (player->kartstuff[k_drift] < 0 && player->cmd.driftturn < 0))
if ((player->kartstuff[k_drift] > 0 && player->cmd.turning > 0) // Inward drifts
|| (player->kartstuff[k_drift] < 0 && player->cmd.turning < 0))
{
if ((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--;
}
}
else if ((player->kartstuff[k_drift] > 0 && player->cmd.driftturn < 0) // Outward drifts
|| (player->kartstuff[k_drift] < 0 && player->cmd.driftturn > 0))
else if ((player->kartstuff[k_drift] > 0 && player->cmd.turning < 0) // Outward drifts
|| (player->kartstuff[k_drift] < 0 && player->cmd.turning > 0))
{
if ((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?
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)
{
// Starting left drift
player->kartstuff[k_drift] = 1;
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)
{
// Starting right drift
@ -6453,10 +6453,10 @@ static void K_KartDrift(player_t *player, boolean onground)
if (player->kartstuff[k_drift] > 5)
player->kartstuff[k_drift] = 5;
if (player->cmd.driftturn > 0) // Inward
driftadditive += abs(player->cmd.driftturn)/100;
if (player->cmd.driftturn < 0) // Outward
driftadditive -= abs(player->cmd.driftturn)/75;
if (player->cmd.turning > 0) // Inward
driftadditive += abs(player->cmd.turning)/100;
if (player->cmd.turning < 0) // Outward
driftadditive -= abs(player->cmd.turning)/75;
}
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)
player->kartstuff[k_drift] = -5;
if (player->cmd.driftturn < 0) // Inward
driftadditive += abs(player->cmd.driftturn)/100;
if (player->cmd.driftturn > 0) // Outward
driftadditive -= abs(player->cmd.driftturn)/75;
if (player->cmd.turning < 0) // Inward
driftadditive += abs(player->cmd.turning)/100;
if (player->cmd.turning > 0) // Outward
driftadditive -= abs(player->cmd.turning)/75;
}
// 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)
|| (!player->cmd.driftturn)
|| (!player->cmd.turning)
|| (!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])
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 (cmd->driftturn != 0 && leveltime % 8 == 0)
if (cmd->turning != 0 && leveltime % 8 == 0)
S_StartSound(player->mo, sfx_ruburn);
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 NOSET luaL_error(L, LUA_QL("ticcmd_t") " field " LUA_QS " cannot be set.", field)
static int ticcmd_get(lua_State *L)
{
@ -826,16 +827,16 @@ static int ticcmd_get(lua_State *L)
if (fastcmp(field,"forwardmove"))
lua_pushinteger(L, cmd->forwardmove);
else if (fastcmp(field,"angleturn"))
lua_pushinteger(L, cmd->angleturn);
else if (fastcmp(field,"turning"))
lua_pushinteger(L, cmd->turning);
else if (fastcmp(field,"aiming"))
lua_pushinteger(L, cmd->aiming);
else if (fastcmp(field,"buttons"))
lua_pushinteger(L, cmd->buttons);
else if (fastcmp(field,"driftturn"))
lua_pushinteger(L, cmd->driftturn);
else if (fastcmp(field,"latency"))
lua_pushinteger(L, cmd->latency);
else if (fastcmp(field,"flags"))
lua_pushinteger(L, cmd->flags);
else
return NOFIELD;
@ -854,14 +855,16 @@ static int ticcmd_set(lua_State *L)
if (fastcmp(field,"forwardmove"))
cmd->forwardmove = (SINT8)luaL_checkinteger(L, 3);
else if (fastcmp(field,"angleturn"))
cmd->angleturn = (INT16)luaL_checkinteger(L, 3);
else if (fastcmp(field,"turning"))
cmd->turning = (INT16)luaL_checkinteger(L, 3);
else if (fastcmp(field,"aiming"))
cmd->aiming = (INT16)luaL_checkinteger(L, 3);
else if (fastcmp(field,"buttons"))
cmd->buttons = (UINT16)luaL_checkinteger(L, 3);
else if (fastcmp(field,"driftturn"))
cmd->driftturn = (INT16)luaL_checkinteger(L, 3);
else if (fastcmp(field,"latency"))
return NOSET;
else if (fastcmp(field,"flags"))
return NOSET;
else
return NOFIELD;

4
src/m_cheat.c
View file

@ -1033,10 +1033,10 @@ void OP_ObjectplaceMovement(player_t *player)
{
ticcmd_t *cmd = &player->cmd;
player->drawangle = player->mo->angle = (cmd->angleturn<<16 /* not FRACBITS */);
player->drawangle = player->mo->angle = player->angleturn;
ticruned++;
if (!(cmd->angleturn & TICCMD_RECEIVED))
if (!(cmd->flags & TICCMD_RECEIVED))
ticmiss++;
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
if (mobj->player)
looking = ( mobj->player->cmd.angleturn << 16 );/* fixes CS_LMAOGALOG */
looking = mobj->player->angleturn;
else
looking = mobj->angle;
@ -7662,7 +7662,7 @@ static boolean P_MobjRegularThink(mobj_t *mobj)
break;
}
if (abs(player->cmd.driftturn) > 100)
if (abs(player->cmd.turning) > 100)
{
INT32 lastsign = 0;
if (mobj->lastlook > 0)
@ -7670,15 +7670,15 @@ static boolean P_MobjRegularThink(mobj_t *mobj)
else if (mobj->lastlook < 0)
lastsign = -1;
if ((player->cmd.driftturn > 0 && lastsign < 0)
|| (player->cmd.driftturn < 0 && lastsign > 0))
if ((player->cmd.turning > 0 && lastsign < 0)
|| (player->cmd.turning < 0 && lastsign > 0))
{
mobj->movecount += (TICRATE/2);
mobj->threshold = 16*lastsign;
S_StartSound(mobj, sfx_s1ab);
}
mobj->lastlook = player->cmd.driftturn;
mobj->lastlook = player->cmd.turning;
}
mobj->movecount++;
@ -7818,7 +7818,7 @@ static boolean P_MobjRegularThink(mobj_t *mobj)
break;
}
if (abs(player->cmd.driftturn) > 100)
if (abs(player->cmd.turning) > 100)
{
INT32 lastsign = 0;
if (mobj->lastlook > 0)
@ -7826,15 +7826,15 @@ static boolean P_MobjRegularThink(mobj_t *mobj)
else if (mobj->lastlook < 0)
lastsign = -1;
if ((player->cmd.driftturn > 0 && lastsign < 0)
|| (player->cmd.driftturn < 0 && lastsign > 0))
if ((player->cmd.turning > 0 && lastsign < 0)
|| (player->cmd.turning < 0 && lastsign > 0))
{
mobj->movecount += (TICRATE/2);
mobj->cvmem = 8*lastsign;
S_StartSound(mobj, sfx_s3k7a);
}
mobj->lastlook = player->cmd.driftturn;
mobj->lastlook = player->cmd.turning;
}
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)) {
mo->angle += delta;
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
WRITEINT16(save_p, players[i].angleturn);
WRITEINT16(save_p, players[i].oldrelangleturn);
WRITEANGLE(save_p, players[i].angleturn);
WRITEANGLE(save_p, players[i].aiming);
WRITEANGLE(save_p, players[i].drawangle);
WRITEANGLE(save_p, players[i].viewrollangle);
@ -251,12 +250,6 @@ static void P_NetArchivePlayers(void)
for (j = 0; j < NUMKARTSTUFF; 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, K_GetWaypointHeapIndex(players[i].nextwaypoint));
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!
// (that data is handled in the server config now)
players[i].angleturn = READINT16(save_p);
players[i].oldrelangleturn = READINT16(save_p);
players[i].angleturn = READANGLE(save_p);
players[i].aiming = READANGLE(save_p);
players[i].drawangle = READANGLE(save_p);
players[i].viewrollangle = READANGLE(save_p);
@ -443,12 +435,6 @@ static void P_NetUnArchivePlayers(void)
for (j = 0; j < NUMKARTSTUFF; j++)
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].nextwaypoint = (waypoint_t *)(size_t)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)
{
angle_t angle = thing->player->angleturn << 16;
angle_t angle = thing->player->angleturn;
if (thing->angle - angle > ANGLE_180)
P_SetPlayerAngle(thing->player, angle - (angle - thing->angle) / 8);
else

4
src/p_tick.c
View file

@ -722,10 +722,6 @@ void P_PreTicker(INT32 frames)
// (and disrupt demo recording and other things !!)
memcpy(&temptic, &players[i].cmd, 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]);

103
src/p_user.c
View file

@ -2062,10 +2062,10 @@ static void P_SpectatorMovement(player_t *player)
{
ticcmd_t *cmd = &player->cmd;
player->mo->angle = (cmd->angleturn<<16 /* not FRACBITS */);
player->mo->angle = player->angleturn;
ticruned++;
if (!(cmd->angleturn & TICCMD_RECEIVED))
if (!(cmd->flags & TICCMD_RECEIVED))
ticmiss++;
if (cmd->buttons & BT_ACCELERATE)
@ -2133,52 +2133,13 @@ void P_MovePlayer(player_t *player)
// MOVEMENT CODE //
//////////////////////
{
INT16 angle_diff, max_left_turn, max_right_turn;
boolean add_delta = true;
player->mo->angle = player->angleturn;
// Kart: store the current turn range for later use
player->lturn_max[leveltime%MAXPREDICTTICS] = K_GetKartTurnValue(player, KART_FULLTURN)+1;
player->rturn_max[leveltime%MAXPREDICTTICS] = K_GetKartTurnValue(player, -KART_FULLTURN)-1;
ticruned++;
if (!(cmd->flags & TICCMD_RECEIVED))
ticmiss++;
if (leveltime >= introtime)
{
// 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);
}
P_3dMovement(player);
// Kart frames
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
// redefine this
static fixed_t forwardmove = MAXPLMOVE<<FRACBITS>>16;
static fixed_t angleturn[3] = {KART_FULLTURN/2, KART_FULLTURN, KART_FULLTURN/4}; // + slow turn
static fixed_t angleturn[2] = {KART_FULLTURN, KART_FULLTURN/4}; // + slow turn
static ticcmd_t cameracmd;
@ -2788,7 +2748,6 @@ void P_InitCameraCmd(void)
static ticcmd_t *P_CameraCmd(camera_t *cam)
{
INT32 laim, th, tspeed, forward, axis; //i
const INT32 speed = 1;
// these ones used for multiple conditions
boolean turnleft, turnright, mouseaiming;
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
cmd->angleturn = (INT16)(lang >> 16);
//cmd->turning = (INT16)(lang >> 16);
cmd->aiming = G_ClipAimingPitch(&laim);
mouseaiming = true;
@ -2845,21 +2804,23 @@ static ticcmd_t *P_CameraCmd(camera_t *cam)
th = 0;
if (th < SLOWTURNTICS)
tspeed = 2; // slow turn
tspeed = 1; // slow turn
else
tspeed = speed;
tspeed = 0;
cmd->turning = 0;
// let movement keys cancel each other out
if (turnright && !(turnleft))
{
cmd->angleturn = (INT16)(cmd->angleturn - (angleturn[tspeed]));
cmd->turning = (INT16)(cmd->turning - (angleturn[tspeed]));
}
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);
if (PlayerInputDown(1, gc_accelerate) || (usejoystick && axis > 0))
@ -2869,9 +2830,9 @@ static ticcmd_t *P_CameraCmd(camera_t *cam)
cmd->buttons |= BT_BRAKE;
axis = PlayerJoyAxis(1, AXISAIM);
if (PlayerInputDown(1, gc_aimforward) || (usejoystick && axis < 0))
forward += forwardmove;
forward += MAXPLMOVE;
if (PlayerInputDown(1, gc_aimbackward) || (usejoystick && axis > 0))
forward -= forwardmove;
forward -= MAXPLMOVE;
// fire with any button/key
axis = PlayerJoyAxis(1, AXISFIRE);
@ -2919,7 +2880,7 @@ static ticcmd_t *P_CameraCmd(camera_t *cam)
else if (cmd->forwardmove < -MAXPLMOVE)
cmd->forwardmove = -MAXPLMOVE;
lang += (cmd->angleturn<<16);
lang += (cmd->turning << TICCMD_REDUCE);
democam.localangle = lang;
democam.localaiming = laim;
@ -2945,7 +2906,7 @@ void P_DemoCameraMovement(camera_t *cam)
cmd = P_CameraCmd(cam);
cam->aiming = cmd->aiming<<FRACBITS;
cam->angle = cmd->angleturn<<16;
//cam->angle = cmd->angleturn << TICCMD_REDUCE;
// camera movement:
@ -4273,6 +4234,12 @@ void P_PlayerThink(player_t *player)
cmd = &player->cmd;
{
angle_t angleChange = K_GetKartTurnValue(player, cmd->turning) << TICCMD_REDUCE;
player->angleturn += angleChange;
P_SetLocalAngle(player, P_GetLocalAngle(player) + angleChange);
}
// SRB2kart
// Save the dir the player is holding
// 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)
{
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;
}
void P_SetLocalAngle(player_t *player, angle_t angle)
{
INT16 delta = (INT16)((angle - P_GetLocalAngle(player)) >> 16);
UINT8 i;
angle_t delta = (angle - P_GetLocalAngle(player));
P_ForceLocalAngle(player, P_GetLocalAngle(player) + (angle_t)(delta << 16));
for (i = 0; i <= splitscreen; i++)
{
if (player == &players[g_localplayers[i]])
{
ticcmd_oldangleturn[i] += delta;
break;
}
}
P_ForceLocalAngle(player, P_GetLocalAngle(player) + delta);
}
angle_t P_GetLocalAngle(player_t *player)