stjr/Kart-Public
0
0
Fork 0
mirror of https://git.do.srb2.org/KartKrew/Kart-Public.git synced 2025-01-27 19:50:51 +00:00
Code Issues Projects Releases Packages Wiki Activity

Lots of cmd restructuring.

Browse source 
- cmd->driftturn exists now, for figuring out how far you're turning. Added to prevent analog sticks from being able to get drift sparks faster.
- Feather bounce strafing moved to use cmd->sidemove, which means it also supports analog now.
- Braking now waits a few tics for you to be stopped for a few tics before it lets you go in reverse, as per Sev's request.
- Removed a lot of unused/redundant/commented out control code, and reorganized some of the existing code.
This commit is contained in:
TehRealSalt 2018-06-05 17:12:42 -04:00
parent 173d780ab7
commit d3793cb19c
8 changed files with 131 additions and 360 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
src/d_player.h
View file

@ -260,6 +260,7 @@ typedef enum
k_boostcharge, // Charge-up for boosting at the start of the race, or when Lakitu drops you k_boostcharge, // Charge-up for boosting at the start of the race, or when Lakitu drops you
k_jmp, // In Mario Kart, letting go of the jump button stops the drift k_jmp, // In Mario Kart, letting go of the jump button stops the drift
k_offroad, // In Super Mario Kart, going offroad has lee-way of about 1 second before you start losing speed k_offroad, // In Super Mario Kart, going offroad has lee-way of about 1 second before you start losing speed
k_brakestop, // Wait until you've made a complete stop for a few tics before letting brake go in reverse.
k_itemroulette, // Used for the roulette when deciding what item to give you (was "pw_kartitem") k_itemroulette, // Used for the roulette when deciding what item to give you (was "pw_kartitem")
k_roulettetype, // Used for the roulette, for deciding type (currently only used for Battle, to give you better items from Karma items) k_roulettetype, // Used for the roulette, for deciding type (currently only used for Battle, to give you better items from Karma items)

10
src/d_ticcmd.h
View file

@ -25,18 +25,13 @@
typedef enum typedef enum
{ {
BT_ACCELERATE = 1, // Accelerate BT_ACCELERATE = 1, // Accelerate
BT_DRIFT = 1<<2, // Drift (direction is cmd->angleturn) BT_DRIFT = 1<<2, // Drift (direction is cmd->driftturn)
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
BT_BACKWARD = 1<<6, // Aim Item Backward BT_BACKWARD = 1<<6, // Aim Item Backward
//BT_SPECTATE = 1<<7, // Toggle Spectate
// Want more button space? Help get rid of this hack :V // free: 1<<7 to 1<<12
BT_DRIFTLEFT = 1<<7, // Drift left hack
BT_DRIFTRIGHT = 1<<8, // Drift right hack
// free: 1<<9 to 1<<12
// Lua garbage // Lua garbage
BT_CUSTOM1 = 1<<13, BT_CUSTOM1 = 1<<13,
@ -64,6 +59,7 @@ typedef struct
INT16 angleturn; // <<16 for angle delta - saved as 1 byte into demos INT16 angleturn; // <<16 for angle delta - saved as 1 byte into demos
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
} ATTRPACK ticcmd_t; } ATTRPACK ticcmd_t;
#if defined(_MSC_VER) #if defined(_MSC_VER)

3
src/dehacked.c
View file

@ -8031,9 +8031,6 @@ struct {
{"BT_ATTACK",BT_ATTACK}, {"BT_ATTACK",BT_ATTACK},
{"BT_FORWARD",BT_FORWARD}, {"BT_FORWARD",BT_FORWARD},
{"BT_BACKWARD",BT_BACKWARD}, {"BT_BACKWARD",BT_BACKWARD},
//{"BT_SPECTATE",BT_SPECTATE},
{"BT_DRIFTLEFT",BT_DRIFTLEFT},
{"BT_DRIFTRIGHT",BT_DRIFTRIGHT},
{"BT_CUSTOM1",BT_CUSTOM1}, // Lua customizable {"BT_CUSTOM1",BT_CUSTOM1}, // Lua customizable
{"BT_CUSTOM2",BT_CUSTOM2}, // Lua customizable {"BT_CUSTOM2",BT_CUSTOM2}, // Lua customizable
{"BT_CUSTOM3",BT_CUSTOM3}, // Lua customizable {"BT_CUSTOM3",BT_CUSTOM3}, // Lua customizable

184
src/g_game.c
View file

@ -1150,16 +1150,15 @@ angle_t localangle, localangle2, localangle3, localangle4;
boolean camspin, camspin2, camspin3, camspin4; boolean camspin, camspin2, camspin3, camspin4;
static fixed_t forwardmove[2] = {25<<FRACBITS>>16, 50<<FRACBITS>>16}; static fixed_t forwardmove[2] = {25<<FRACBITS>>16, 50<<FRACBITS>>16};
static fixed_t sidemove[2] = {25<<FRACBITS>>16, 50<<FRACBITS>>16}; // faster! static fixed_t sidemove[2] = {2<<FRACBITS>>16, 4<<FRACBITS>>16};
static fixed_t angleturn[3] = {400, 800, 200}; // + slow turn static fixed_t angleturn[3] = {400, 800, 200}; // + slow turn
void G_BuildTiccmd(ticcmd_t *cmd, INT32 realtics, UINT8 ssplayer) void G_BuildTiccmd(ticcmd_t *cmd, INT32 realtics, UINT8 ssplayer)
{ {
boolean forcestrafe = false;
INT32 laim, th, tspeed, forward, side, axis; //i INT32 laim, th, tspeed, forward, side, axis; //i
const INT32 speed = 1; const INT32 speed = 1;
// these ones used for multiple conditions // these ones used for multiple conditions
boolean turnleft, turnright, invertmouse, mouseaiming, lookaxis, analog, analogjoystickmove, gamepadjoystickmove, kbl, rd; boolean turnleft, turnright, invertmouse, mouseaiming, lookaxis, analogjoystickmove, gamepadjoystickmove, kbl, rd;
player_t *player; player_t *player;
camera_t *thiscam; camera_t *thiscam;
angle_t lang; angle_t lang;
@ -1231,7 +1230,6 @@ void G_BuildTiccmd(ticcmd_t *cmd, INT32 realtics, UINT8 ssplayer)
lookaxis = cv_lookaxis2.value; lookaxis = cv_lookaxis2.value;
analogjoystickmove = cv_usejoystick2.value && !Joystick2.bGamepadStyle; analogjoystickmove = cv_usejoystick2.value && !Joystick2.bGamepadStyle;
gamepadjoystickmove = cv_usejoystick2.value && Joystick2.bGamepadStyle; gamepadjoystickmove = cv_usejoystick2.value && Joystick2.bGamepadStyle;
analog = cv_analog2.value;
break; break;
case 3: case 3:
mouseaiming = false; mouseaiming = false;
@ -1239,7 +1237,6 @@ void G_BuildTiccmd(ticcmd_t *cmd, INT32 realtics, UINT8 ssplayer)
lookaxis = cv_lookaxis3.value; lookaxis = cv_lookaxis3.value;
analogjoystickmove = cv_usejoystick3.value && !Joystick3.bGamepadStyle; analogjoystickmove = cv_usejoystick3.value && !Joystick3.bGamepadStyle;
gamepadjoystickmove = cv_usejoystick3.value && Joystick3.bGamepadStyle; gamepadjoystickmove = cv_usejoystick3.value && Joystick3.bGamepadStyle;
analog = cv_analog3.value;
break; break;
case 4: case 4:
mouseaiming = false; mouseaiming = false;
@ -1247,7 +1244,6 @@ void G_BuildTiccmd(ticcmd_t *cmd, INT32 realtics, UINT8 ssplayer)
lookaxis = cv_lookaxis4.value; lookaxis = cv_lookaxis4.value;
analogjoystickmove = cv_usejoystick4.value && !Joystick4.bGamepadStyle; analogjoystickmove = cv_usejoystick4.value && !Joystick4.bGamepadStyle;
gamepadjoystickmove = cv_usejoystick4.value && Joystick4.bGamepadStyle; gamepadjoystickmove = cv_usejoystick4.value && Joystick4.bGamepadStyle;
analog = cv_analog4.value;
break; break;
case 1: case 1:
default: default:
@ -1256,7 +1252,6 @@ void G_BuildTiccmd(ticcmd_t *cmd, INT32 realtics, UINT8 ssplayer)
lookaxis = cv_lookaxis.value; lookaxis = cv_lookaxis.value;
analogjoystickmove = cv_usejoystick.value && !Joystick.bGamepadStyle; analogjoystickmove = cv_usejoystick.value && !Joystick.bGamepadStyle;
gamepadjoystickmove = cv_usejoystick.value && Joystick.bGamepadStyle; gamepadjoystickmove = cv_usejoystick.value && Joystick.bGamepadStyle;
analog = cv_analog.value;
break; break;
} }
@ -1292,49 +1287,66 @@ void G_BuildTiccmd(ticcmd_t *cmd, INT32 realtics, UINT8 ssplayer)
else else
tspeed = speed; tspeed = speed;
cmd->driftturn = 0;
// let movement keys cancel each other out // let movement keys cancel each other out
if (analog) // Analog if (turnright && !(turnleft))
{ {
if (turnright) cmd->angleturn = (INT16)(cmd->angleturn - angleturn[tspeed]);
cmd->angleturn = (INT16)(cmd->angleturn - angleturn[tspeed]); cmd->driftturn = (INT16)(cmd->driftturn - angleturn[tspeed]);
if (turnleft) }
cmd->angleturn = (INT16)(cmd->angleturn + angleturn[tspeed]); else if (turnleft && !(turnright))
{
cmd->angleturn = (INT16)(cmd->angleturn + angleturn[tspeed]);
cmd->driftturn = (INT16)(cmd->driftturn + angleturn[tspeed]);
} }
if (analog || twodlevel if (analogjoystickmove && axis != 0)
|| (player->mo && (player->mo->flags2 & MF2_TWOD)) {
|| (!demoplayback && (player->climbing // JOYAXISRANGE should be 1023 (divide by 1024)
|| (player->pflags & PF_NIGHTSMODE) cmd->angleturn = (INT16)(cmd->angleturn - ((axis * angleturn[1]) >> 10)); // ANALOG!
|| (player->pflags & PF_SLIDING) cmd->driftturn = (INT16)(cmd->driftturn - ((axis * angleturn[1]) >> 10));
|| (player->pflags & PF_FORCESTRAFE)))) // Analog }
forcestrafe = true;
if (forcestrafe) // Analog // Specator mouse turning
if (player->spectator)
{
cmd->angleturn = (INT16)(cmd->angleturn - (mousex*(mirrormode ? -1 : 1)*8));
cmd->driftturn = (INT16)(cmd->driftturn - (mousex*(mirrormode ? -1 : 1)*8));
}
// Bounce pad strafing
if (!demoplayback && ((player->pflags & PF_FORCESTRAFE) || (player->kartstuff[k_feather] & 2)))
{ {
if (turnright) if (turnright)
side += sidemove[speed]; side += sidemove[1];
if (turnleft) if (turnleft)
side -= sidemove[speed]; side -= sidemove[1];
if (analogjoystickmove && axis != 0) if (analogjoystickmove && axis != 0)
{ {
// JOYAXISRANGE is supposed to be 1023 (divide by 1024) // JOYAXISRANGE is supposed to be 1023 (divide by 1024)
side += ((axis * sidemove[1]) >> 10); side += ((axis * sidemove[0]) >> 10);
} }
} }
else
{
if (turnright && !(turnleft))
cmd->angleturn = (INT16)(cmd->angleturn - angleturn[tspeed]);
else if (turnleft && !(turnright))
cmd->angleturn = (INT16)(cmd->angleturn + angleturn[tspeed]);
if (analogjoystickmove && axis != 0) //{ SRB2kart - Drift support
{ // limit turning to angleturn[1] to stop mouselook letting you look too fast
// JOYAXISRANGE should be 1023 (divide by 1024) if (cmd->angleturn > angleturn[1])
cmd->angleturn = (INT16)(cmd->angleturn - ((axis * angleturn[1]) >> 10)); // ANALOG! 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);
// SRB2kart - no additional angle if not moving
if ((player->mo && player->speed > 0) || (leveltime > 140 && cmd->buttons & BT_ACCELERATE && cmd->buttons & BT_BRAKE) || (player->spectator || objectplacing))
lang += (cmd->angleturn<<16);
if (player->spectator || objectplacing) // SRB2Kart: spectators need special controls if (player->spectator || objectplacing) // SRB2Kart: spectators need special controls
{ {
@ -1392,7 +1404,7 @@ void G_BuildTiccmd(ticcmd_t *cmd, INT32 realtics, UINT8 ssplayer)
if (InputDown(gc_fire, ssplayer) || (cv_usejoystick.value && axis > 0)) if (InputDown(gc_fire, ssplayer) || (cv_usejoystick.value && axis > 0))
cmd->buttons |= BT_ATTACK; cmd->buttons |= BT_ATTACK;
// drift button // drift with any button/key
axis = JoyAxis(AXISDRIFT, ssplayer); axis = JoyAxis(AXISDRIFT, ssplayer);
if (InputDown(gc_drift, ssplayer) || (cv_usejoystick.value && axis > 0)) if (InputDown(gc_drift, ssplayer) || (cv_usejoystick.value && axis > 0))
cmd->buttons |= BT_DRIFT; cmd->buttons |= BT_DRIFT;
@ -1405,6 +1417,7 @@ void G_BuildTiccmd(ticcmd_t *cmd, INT32 realtics, UINT8 ssplayer)
if (InputDown(gc_custom3, ssplayer)) if (InputDown(gc_custom3, ssplayer))
cmd->buttons |= BT_CUSTOM3; cmd->buttons |= BT_CUSTOM3;
// Reset camera
if (InputDown(gc_camreset, ssplayer)) if (InputDown(gc_camreset, ssplayer))
{ {
if (thiscam->chase && !rd) if (thiscam->chase && !rd)
@ -1414,7 +1427,7 @@ void G_BuildTiccmd(ticcmd_t *cmd, INT32 realtics, UINT8 ssplayer)
else else
rd = false; rd = false;
// player aiming shit, ahhhh... // spectator aiming shit, ahhhh...
{ {
INT32 player_invert = invertmouse ? -1 : 1; INT32 player_invert = invertmouse ? -1 : 1;
INT32 screen_invert = INT32 screen_invert =
@ -1463,15 +1476,13 @@ void G_BuildTiccmd(ticcmd_t *cmd, INT32 realtics, UINT8 ssplayer)
cmd->aiming = G_ClipAimingPitch(&laim); cmd->aiming = G_ClipAimingPitch(&laim);
} }
if (player->spectator)
cmd->angleturn = (INT16)(cmd->angleturn - (mousex*(mirrormode ? -1 : 1)*8));
mousex = mousey = mlooky = 0; mousex = mousey = mlooky = 0;
if (forward > MAXPLMOVE) if (forward > MAXPLMOVE)
forward = MAXPLMOVE; forward = MAXPLMOVE;
else if (forward < -MAXPLMOVE) else if (forward < -MAXPLMOVE)
forward = -MAXPLMOVE; forward = -MAXPLMOVE;
if (side > MAXPLMOVE) if (side > MAXPLMOVE)
side = MAXPLMOVE; side = MAXPLMOVE;
else if (side < -MAXPLMOVE) else if (side < -MAXPLMOVE)
@ -1479,86 +1490,20 @@ void G_BuildTiccmd(ticcmd_t *cmd, INT32 realtics, UINT8 ssplayer)
// No additional acceleration when moving forward/backward and strafing simultaneously. // No additional acceleration when moving forward/backward and strafing simultaneously.
// do this AFTER we cap to MAXPLMOVE so people can't find ways to cheese around this. // do this AFTER we cap to MAXPLMOVE so people can't find ways to cheese around this.
if (!forcestrafe && forward && side) // SRB2Kart: We don't need this; we WANT bounce strafing to plain stack on top of normal movement.
/*if (!bouncestrafe && forward && side)
{ {
forward = FixedMul(forward, 3*FRACUNIT/4); forward = FixedMul(forward, 3*FRACUNIT/4);
side = FixedMul(side, 3*FRACUNIT/4); side = FixedMul(side, 3*FRACUNIT/4);
} }*/
//Silly hack to make 2d mode *somewhat* playable with no chasecam. if (forward || side)
if ((twodlevel || (player->mo && player->mo->flags2 & MF2_TWOD)) && !thiscam->chase)
{
INT32 temp = forward;
forward = side;
side = temp;
}
if (cmd->buttons & BT_BRAKE && !forward) // Sal: If you're not accelerating, but going forward, then you should just lose your momentum. Request from Sev
{
cmd->forwardmove = (SINT8)(cmd->forwardmove / 2);
cmd->sidemove = (SINT8)(cmd->sidemove / 2);
}
else
{ {
cmd->forwardmove = (SINT8)(cmd->forwardmove + forward); cmd->forwardmove = (SINT8)(cmd->forwardmove + forward);
if (mirrormode) cmd->sidemove = (SINT8)(cmd->sidemove + side);
cmd->sidemove = (SINT8)(cmd->sidemove - side);
else
cmd->sidemove = (SINT8)(cmd->sidemove + side);
} }
if (ssplayer == 2 && player->bot == 1) { cmd->angleturn = (INT16)(lang >> 16);
if (!player->powers[pw_tailsfly] && (cmd->forwardmove || cmd->sidemove || cmd->buttons))
{
player->bot = 2; // A player-controlled bot. Returns to AI when it respawns.
//CV_SetValue(&cv_analog2, true);
}
else
{
G_CopyTiccmd(cmd, I_BaseTiccmd2(), 1); // empty, or external driver
B_BuildTiccmd(player, cmd);
}
}
//{ SRB2kart - Drift support
axis = JoyAxis(AXISTURN, ssplayer);
if (mirrormode)
axis = -axis;
// TODO: Remove this hack please :(
if (cmd->angleturn > 0) // Drifting to the left
cmd->buttons |= BT_DRIFTLEFT;
else
cmd->buttons &= ~BT_DRIFTLEFT;
if (cmd->angleturn < 0) // Drifting to the right
cmd->buttons |= BT_DRIFTRIGHT;
else
cmd->buttons &= ~BT_DRIFTRIGHT;
//}
if (analog) {
cmd->angleturn = (INT16)(thiscam->angle >> 16);
if (player->awayviewtics)
cmd->angleturn = (INT16)(player->awayviewmobj->angle >> 16);
}
else
{
// 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 (player->mo)
cmd->angleturn = K_GetKartTurnValue(player, cmd->angleturn);
// SRB2kart - no additional angle if not moving
if ((player->mo && player->speed > 0) || (leveltime > 140 && cmd->buttons & BT_ACCELERATE && cmd->buttons & BT_BRAKE) || (player->spectator || objectplacing))
lang += (cmd->angleturn<<16);
cmd->angleturn = (INT16)(lang >> 16);
}
if (!hu_stopped) if (!hu_stopped)
{ {
@ -4197,6 +4142,7 @@ char *G_BuildMapTitle(INT32 mapnum)
#define ZT_ANGLE 0x04 #define ZT_ANGLE 0x04
#define ZT_BUTTONS 0x08 #define ZT_BUTTONS 0x08
#define ZT_AIMING 0x10 #define ZT_AIMING 0x10
#define ZT_DRIFT 0x20
#define DEMOMARKER 0x80 // demoend #define DEMOMARKER 0x80 // demoend
static ticcmd_t oldcmd; static ticcmd_t oldcmd;
@ -4254,6 +4200,7 @@ ticcmd_t *G_MoveTiccmd(ticcmd_t* dest, const ticcmd_t* src, const size_t n)
dest[i].angleturn = SHORT(src[i].angleturn); dest[i].angleturn = SHORT(src[i].angleturn);
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 = (INT16)SHORT(src[i].driftturn);
} }
return dest; return dest;
} }
@ -4277,6 +4224,8 @@ void G_ReadDemoTiccmd(ticcmd_t *cmd, INT32 playernum)
oldcmd.buttons = (oldcmd.buttons & (BT_FORWARD|BT_BACKWARD)) | (READUINT16(demo_p) & ~(BT_FORWARD|BT_BACKWARD)); oldcmd.buttons = (oldcmd.buttons & (BT_FORWARD|BT_BACKWARD)) | (READUINT16(demo_p) & ~(BT_FORWARD|BT_BACKWARD));
if (ziptic & ZT_AIMING) if (ziptic & ZT_AIMING)
oldcmd.aiming = READINT16(demo_p); oldcmd.aiming = READINT16(demo_p);
if (ziptic & ZT_DRIFT)
oldcmd.driftturn = READINT16(demo_p);
G_CopyTiccmd(cmd, &oldcmd, 1); G_CopyTiccmd(cmd, &oldcmd, 1);
@ -4333,6 +4282,13 @@ void G_WriteDemoTiccmd(ticcmd_t *cmd, INT32 playernum)
ziptic |= ZT_AIMING; ziptic |= ZT_AIMING;
} }
if (cmd->driftturn != oldcmd.driftturn)
{
WRITEINT16(demo_p,cmd->driftturn);
oldcmd.driftturn = cmd->driftturn;
ziptic |= ZT_DRIFT;
}
*ziptic_p = ziptic; *ziptic_p = ziptic;
// attention here for the ticcmd size! // attention here for the ticcmd size!
@ -4705,6 +4661,8 @@ void G_GhostTicker(void)
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;
// Grab ghost data. // Grab ghost data.
ziptic = READUINT8(g->p); ziptic = READUINT8(g->p);

67
src/k_kart.c
View file

@ -947,11 +947,11 @@ void K_KartMoveAnimation(player_t *player)
// Standing frames - S_KART_STND1 S_KART_STND1_L S_KART_STND1_R // Standing frames - S_KART_STND1 S_KART_STND1_L S_KART_STND1_R
if (player->speed == 0) if (player->speed == 0)
{ {
if (cmd->buttons & BT_DRIFTRIGHT && !(player->mo->state >= &states[S_KART_STND1_R] && player->mo->state <= &states[S_KART_STND2_R])) if (cmd->driftturn < 0 && !(player->mo->state >= &states[S_KART_STND1_R] && player->mo->state <= &states[S_KART_STND2_R]))
P_SetPlayerMobjState(player->mo, S_KART_STND1_R); P_SetPlayerMobjState(player->mo, S_KART_STND1_R);
else if (cmd->buttons & BT_DRIFTLEFT && !(player->mo->state >= &states[S_KART_STND1_L] && player->mo->state <= &states[S_KART_STND2_L])) else if (cmd->driftturn > 0 && !(player->mo->state >= &states[S_KART_STND1_L] && player->mo->state <= &states[S_KART_STND2_L]))
P_SetPlayerMobjState(player->mo, S_KART_STND1_L); P_SetPlayerMobjState(player->mo, S_KART_STND1_L);
else if (!(cmd->buttons & BT_DRIFTRIGHT || cmd->buttons & BT_DRIFTLEFT) && !(player->mo->state >= &states[S_KART_STND1] && player->mo->state <= &states[S_KART_STND2])) else if (cmd->driftturn == 0 && !(player->mo->state >= &states[S_KART_STND1] && player->mo->state <= &states[S_KART_STND2]))
P_SetPlayerMobjState(player->mo, S_KART_STND1); P_SetPlayerMobjState(player->mo, S_KART_STND1);
} }
// Drifting Left - S_KART_DRIFT1_L // Drifting Left - S_KART_DRIFT1_L
@ -969,21 +969,21 @@ void K_KartMoveAnimation(player_t *player)
// Run frames - S_KART_RUN1 S_KART_RUN1_L S_KART_RUN1_R // Run frames - S_KART_RUN1 S_KART_RUN1_L S_KART_RUN1_R
else if (player->speed > FixedMul(player->runspeed, player->mo->scale)) else if (player->speed > FixedMul(player->runspeed, player->mo->scale))
{ {
if (cmd->buttons & BT_DRIFTRIGHT && !(player->mo->state >= &states[S_KART_RUN1_R] && player->mo->state <= &states[S_KART_RUN2_R])) if (cmd->driftturn < 0 && !(player->mo->state >= &states[S_KART_RUN1_R] && player->mo->state <= &states[S_KART_RUN2_R]))
P_SetPlayerMobjState(player->mo, S_KART_RUN1_R); P_SetPlayerMobjState(player->mo, S_KART_RUN1_R);
else if (cmd->buttons & BT_DRIFTLEFT && !(player->mo->state >= &states[S_KART_RUN1_L] && player->mo->state <= &states[S_KART_RUN2_L])) else if (cmd->driftturn > 0 && !(player->mo->state >= &states[S_KART_RUN1_L] && player->mo->state <= &states[S_KART_RUN2_L]))
P_SetPlayerMobjState(player->mo, S_KART_RUN1_L); P_SetPlayerMobjState(player->mo, S_KART_RUN1_L);
else if (!(cmd->buttons & BT_DRIFTRIGHT || cmd->buttons & BT_DRIFTLEFT) && !(player->mo->state >= &states[S_KART_RUN1] && player->mo->state <= &states[S_KART_RUN2])) else if (cmd->driftturn == 0 && !(player->mo->state >= &states[S_KART_RUN1] && player->mo->state <= &states[S_KART_RUN2]))
P_SetPlayerMobjState(player->mo, S_KART_RUN1); P_SetPlayerMobjState(player->mo, S_KART_RUN1);
} }
// Walk frames - S_KART_WALK1 S_KART_WALK1_L S_KART_WALK1_R // Walk frames - S_KART_WALK1 S_KART_WALK1_L S_KART_WALK1_R
else if (player->speed <= FixedMul(player->runspeed, player->mo->scale)) else if (player->speed <= FixedMul(player->runspeed, player->mo->scale))
{ {
if (cmd->buttons & BT_DRIFTRIGHT && !(player->mo->state >= &states[S_KART_WALK1_R] && player->mo->state <= &states[S_KART_WALK2_R])) if (cmd->driftturn < 0 && !(player->mo->state >= &states[S_KART_WALK1_R] && player->mo->state <= &states[S_KART_WALK2_R]))
P_SetPlayerMobjState(player->mo, S_KART_WALK1_R); P_SetPlayerMobjState(player->mo, S_KART_WALK1_R);
else if (cmd->buttons & BT_DRIFTLEFT && !(player->mo->state >= &states[S_KART_WALK1_L] && player->mo->state <= &states[S_KART_WALK2_L])) else if (cmd->driftturn > 0 && !(player->mo->state >= &states[S_KART_WALK1_L] && player->mo->state <= &states[S_KART_WALK2_L]))
P_SetPlayerMobjState(player->mo, S_KART_WALK1_L); P_SetPlayerMobjState(player->mo, S_KART_WALK1_L);
else if (!(cmd->buttons & BT_DRIFTRIGHT || cmd->buttons & BT_DRIFTLEFT) && !(player->mo->state >= &states[S_KART_WALK1] && player->mo->state <= &states[S_KART_WALK2])) else if (cmd->driftturn == 0 && !(player->mo->state >= &states[S_KART_WALK1] && player->mo->state <= &states[S_KART_WALK2]))
P_SetPlayerMobjState(player->mo, S_KART_WALK1); P_SetPlayerMobjState(player->mo, S_KART_WALK1);
} }
} }
@ -1344,6 +1344,15 @@ fixed_t K_3dKartMovement(player_t *player, boolean onground, fixed_t forwardmove
if (!onground) return 0; // If the player isn't on the ground, there is no change in speed if (!onground) return 0; // If the player isn't on the ground, there is no change in speed
if (forwardmove <= 0 && player->kartstuff[k_brakestop] < 6) // Don't start reversing with brakes until you've made a stop first
{
if (player->speed < 8*FRACUNIT)
player->kartstuff[k_brakestop]++;
return 0;
}
else if (forwardmove > 0)
player->kartstuff[k_brakestop] = 0;
// ACCELCODE!!!1!11! // ACCELCODE!!!1!11!
oldspeed = R_PointToDist2(0, 0, player->rmomx, player->rmomy); // FixedMul(P_AproxDistance(player->rmomx, player->rmomy), player->mo->scale); oldspeed = R_PointToDist2(0, 0, player->rmomx, player->rmomy); // FixedMul(P_AproxDistance(player->rmomx, player->rmomy), player->mo->scale);
newspeed = FixedDiv(FixedDiv(FixedMul(oldspeed, accelmax - p_accel) + FixedMul(p_speed, p_accel), accelmax), ORIG_FRICTION); newspeed = FixedDiv(FixedDiv(FixedMul(oldspeed, accelmax - p_accel) + FixedMul(p_speed, p_accel), accelmax), ORIG_FRICTION);
@ -2423,7 +2432,7 @@ static void K_KartDrift(player_t *player, boolean onground)
kartspeed = 1; kartspeed = 1;
// IF YOU CHANGE THESE: MAKE SURE YOU UPDATE THE SAME VALUES IN p_mobjc, "case MT_DRIFT:" // IF YOU CHANGE THESE: MAKE SURE YOU UPDATE THE SAME VALUES IN p_mobjc, "case MT_DRIFT:"
dsone = 26*4 + kartspeed*2 + (9 - player->kartweight); dsone = (26*4 + kartspeed*2 + (9 - player->kartweight))*8;
dstwo = dsone*2; dstwo = dsone*2;
// Drifting is actually straffing + automatic turning. // Drifting is actually straffing + automatic turning.
@ -2457,7 +2466,7 @@ static void K_KartDrift(player_t *player, boolean onground)
} }
// Drifting: left or right? // Drifting: left or right?
if ((player->cmd.buttons & BT_DRIFTLEFT) && player->speed > FixedMul(10<<16, player->mo->scale) && player->kartstuff[k_jmp] == 1 if ((player->cmd.driftturn > 0) && player->speed > FixedMul(10<<16, player->mo->scale) && 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
@ -2465,7 +2474,7 @@ static void K_KartDrift(player_t *player, boolean onground)
player->kartstuff[k_driftend] = 0; player->kartstuff[k_driftend] = 0;
player->kartstuff[k_driftcharge] = 0; player->kartstuff[k_driftcharge] = 0;
} }
else if ((player->cmd.buttons & BT_DRIFTRIGHT) && player->speed > FixedMul(10<<16, player->mo->scale) && player->kartstuff[k_jmp] == 1 else if ((player->cmd.driftturn < 0) && player->speed > FixedMul(10<<16, player->mo->scale) && 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
@ -2494,7 +2503,7 @@ static void K_KartDrift(player_t *player, boolean onground)
if (player->kartstuff[k_spinouttimer] == 0 && player->kartstuff[k_jmp] == 1 && onground if (player->kartstuff[k_spinouttimer] == 0 && player->kartstuff[k_jmp] == 1 && onground
&& player->kartstuff[k_drift] != 0) && player->kartstuff[k_drift] != 0)
{ {
fixed_t driftadditive = 3; fixed_t driftadditive = 24;
if (player->kartstuff[k_drift] >= 1) // Drifting to the left if (player->kartstuff[k_drift] >= 1) // Drifting to the left
{ {
@ -2502,10 +2511,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.buttons & BT_DRIFTLEFT) // Inward if (player->cmd.driftturn > 0) // Inward
driftadditive++; driftadditive += (player->cmd.driftturn/800)/8;
if (player->cmd.buttons & BT_DRIFTRIGHT) // Outward if (player->cmd.driftturn < 0) // Outward
driftadditive--; driftadditive -= (player->cmd.driftturn/800)/8;
} }
else if (player->kartstuff[k_drift] <= -1) // Drifting to the right else if (player->kartstuff[k_drift] <= -1) // Drifting to the right
{ {
@ -2513,10 +2522,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.buttons & BT_DRIFTRIGHT) // Inward if (player->cmd.driftturn < 0) // Inward
driftadditive++; driftadditive += (player->cmd.driftturn/800)/4;
if (player->cmd.buttons & BT_DRIFTLEFT) // Outward if (player->cmd.driftturn > 0) // Outward
driftadditive--; driftadditive -= (player->cmd.driftturn/800)/4;
} }
// This spawns the drift sparks // This spawns the drift sparks
@ -3325,24 +3334,10 @@ void K_MoveKartPlayer(player_t *player, boolean onground)
K_KartDrift(player, onground); K_KartDrift(player, onground);
// Feather strafing
if (player->kartstuff[k_feather] & 2)
{
fixed_t strafe = 0;
fixed_t strength = FRACUNIT/32;
if (cmd->buttons & BT_DRIFTLEFT)
strafe--;
if (cmd->buttons & BT_DRIFTRIGHT)
strafe++;
strength += FixedDiv(player->speed, K_GetKartSpeed(player, true));
P_Thrust(player->mo, player->mo->angle-ANGLE_90, strafe*strength);
}
// Quick Turning // Quick Turning
// You can't turn your kart when you're not moving. // You can't turn your kart when you're not moving.
// So now it's time to burn some rubber! // So now it's time to burn some rubber!
if (player->speed < 2 && leveltime > 140 && cmd->buttons & BT_ACCELERATE && cmd->buttons & BT_BRAKE if (player->speed < 2 && leveltime > 140 && cmd->buttons & BT_ACCELERATE && cmd->buttons & BT_BRAKE && cmd->driftturn != 0)
&& ((cmd->buttons & BT_DRIFTLEFT) || (cmd->buttons & BT_DRIFTRIGHT)))
{ {
if (leveltime % 20 == 0) if (leveltime % 20 == 0)
S_StartSound(player->mo, sfx_mkslid); S_StartSound(player->mo, sfx_mkslid);

4
src/lua_playerlib.c
View file

@ -733,6 +733,8 @@ static int ticcmd_get(lua_State *L)
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 else
return NOFIELD; return NOFIELD;
@ -759,6 +761,8 @@ static int ticcmd_set(lua_State *L)
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"))
cmd->driftturn = (INT16)luaL_checkinteger(L, 3);
else else
return NOFIELD; return NOFIELD;

8
src/p_mobj.c
View file

@ -2891,6 +2891,12 @@ static void P_PlayerZMovement(mobj_t *mo)
mo->momx = mo->momx/2; mo->momx = mo->momx/2;
mo->momy = mo->momy/2; mo->momy = mo->momy/2;
} }
if (mo->player->cmd.buttons & BT_BRAKE && !(mo->player->cmd.forwardmove)) // FURTHER slowdown if you're braking.
{
mo->momx = mo->momx/2;
mo->momy = mo->momy/2;
}
} }
if (mo->health) if (mo->health)
@ -6559,7 +6565,7 @@ void P_MobjThinker(mobj_t *mobj)
if (G_BattleGametype() && mobj->target->player->kartstuff[k_balloon] <= 0) if (G_BattleGametype() && mobj->target->player->kartstuff[k_balloon] <= 0)
kartspeed = 1; kartspeed = 1;
dsone = 26*4 + kartspeed*2 + (9 - mobj->target->player->kartweight); dsone = (26*4 + kartspeed*2 + (9 - mobj->target->player->kartweight))*8;
dstwo = dsone*2; dstwo = dsone*2;
if (mobj->target->player->kartstuff[k_driftcharge] < dsone) if (mobj->target->player->kartstuff[k_driftcharge] < dsone)

214
src/p_user.c
View file

@ -4684,7 +4684,6 @@ static void P_3dMovement(player_t *player)
angle_t movepushangle, movepushsideangle; // Analog angle_t movepushangle, movepushsideangle; // Analog
//INT32 topspeed, acceleration, thrustfactor; //INT32 topspeed, acceleration, thrustfactor;
fixed_t movepushforward = 0, movepushside = 0; fixed_t movepushforward = 0, movepushside = 0;
INT32 mforward = 0, mbackward = 0;
angle_t dangle; // replaces old quadrants bits angle_t dangle; // replaces old quadrants bits
//boolean dangleflip = false; // SRB2kart - toaster //boolean dangleflip = false; // SRB2kart - toaster
//fixed_t normalspd = FixedMul(player->normalspeed, player->mo->scale); //fixed_t normalspd = FixedMul(player->normalspeed, player->mo->scale);
@ -4772,12 +4771,6 @@ static void P_3dMovement(player_t *player)
//dangleflip = true; //dangleflip = true;
} }
// now use it to determine direction!
if (dangle <= ANGLE_45) // angles 0-45 or 315-360
mforward = 1; // going forwards
else if (dangle >= ANGLE_135) // angles 135-225
mbackward = 1; // going backwards
// anything else will leave both at 0, so no need to do anything else // anything else will leave both at 0, so no need to do anything else
//{ SRB2kart 220217 - Toaster Code for misplaced thrust //{ SRB2kart 220217 - Toaster Code for misplaced thrust
@ -4803,104 +4796,13 @@ static void P_3dMovement(player_t *player)
cmd->forwardmove = 0; cmd->forwardmove = 0;
// Do not let the player control movement if not onground. // Do not let the player control movement if not onground.
onground = P_IsObjectOnGround(player->mo); // SRB2Kart: feather and speed bumps are supposed to control like you're on the ground
onground = (P_IsObjectOnGround(player->mo) || (player->kartstuff[k_feather] & 2));
// SRB2Kart: shhhhhhh don't question me, feather and speed bumps are supposed to control like you're on the ground :p
if (player->kartstuff[k_feather] & 2)
onground = true;
player->aiming = cmd->aiming<<FRACBITS; player->aiming = cmd->aiming<<FRACBITS;
// Set the player speeds.
/*if (player->pflags & PF_SLIDING)
{
normalspd = FixedMul(36<<FRACBITS, player->mo->scale);
thrustfactor = 5;
acceleration = 96 + (FixedDiv(player->speed, player->mo->scale)>>FRACBITS) * 40;
topspeed = normalspd;
}
else if (player->bot)
{ // Bot steals player 1's stats
normalspd = FixedMul(players[consoleplayer].normalspeed, player->mo->scale);
thrustfactor = players[consoleplayer].thrustfactor;
acceleration = players[consoleplayer].accelstart + (FixedDiv(player->speed, player->mo->scale)>>FRACBITS) * players[consoleplayer].acceleration;
if (player->powers[pw_tailsfly])
topspeed = normalspd/2;
else if (player->mo->eflags & (MFE_UNDERWATER|MFE_GOOWATER))
{
topspeed = normalspd/2;
acceleration = 2*acceleration/3;
}
else
topspeed = normalspd;
}
else if (player->powers[pw_super] || player->powers[pw_sneakers] || player->kartstuff[k_startimer] || player->kartstuff[k_mushroomtimer])
{
if (player->powers[pw_sneakers] && (player->kartstuff[k_growshrinktimer] > 0 || player->kartstuff[k_mushroomtimer] > 0 || player->kartstuff[k_startimer] > 0))
thrustfactor = player->thrustfactor*3;
else
thrustfactor = player->thrustfactor*2;
acceleration = player->accelstart/2 + (FixedDiv(player->speed, player->mo->scale)>>FRACBITS) * player->acceleration/2;
if (player->powers[pw_tailsfly])
topspeed = normalspd;
else if (player->mo->eflags & (MFE_UNDERWATER|MFE_GOOWATER))
{
topspeed = normalspd;
acceleration = 2*acceleration/3;
}
if (cmd->forwardmove < 0)
topspeed = 5<<16;
else
topspeed = (normalspd * 3)/2; //> 60<<16 ? 60<<16 : normalspd * 2;
}
else
{
thrustfactor = player->thrustfactor;
acceleration = player->accelstart + (FixedDiv(player->speed, player->mo->scale)>>FRACBITS) * player->acceleration;
if (player->powers[pw_tailsfly])
topspeed = normalspd/2;
else if (player->mo->eflags & (MFE_UNDERWATER|MFE_GOOWATER))
{
topspeed = normalspd/2;
acceleration = 2*acceleration/3;
}
if (cmd->forwardmove < 0)
topspeed = 5<<16;
else
topspeed = normalspd;
}
// Better maneuverability while flying
//if(player->powers[pw_tailsfly])
//{
// thrustfactor = player->thrustfactor*2;
// acceleration = player->accelstart + (FixedDiv(player->speed, player->mo->scale)>>FRACBITS) * player->acceleration;
//}
if (player->mo->movefactor != FRACUNIT) // Friction-scaled acceleration...
acceleration = FixedMul(acceleration<<FRACBITS, player->mo->movefactor)>>FRACBITS;
*/
// Forward movement // Forward movement
if (player->climbing) if (!(player->exiting || (P_PlayerInPain(player) && !onground)))
{
if (cmd->forwardmove)
{
P_SetObjectMomZ(player->mo, FixedDiv(cmd->forwardmove*FRACUNIT, 10*FRACUNIT), false);
if (player->powers[pw_super] && ALL7EMERALDS(player->powers[pw_emeralds]))
player->mo->momz *= 2;
}
}
else if (!analogmove
//&& cmd->forwardmove != 0
&& !(player->pflags & PF_GLIDING || player->exiting
|| (P_PlayerInPain(player) && !onground)))
{ {
//movepushforward = cmd->forwardmove * (thrustfactor * acceleration); //movepushforward = cmd->forwardmove * (thrustfactor * acceleration);
movepushforward = K_3dKartMovement(player, onground, cmd->forwardmove); movepushforward = K_3dKartMovement(player, onground, cmd->forwardmove);
@ -4909,25 +4811,14 @@ static void P_3dMovement(player_t *player)
if (!onground) if (!onground)
movepushforward >>= 2; // proper air movement movepushforward >>= 2; // proper air movement
// Allow a bit of movement while spinning
if (player->pflags & PF_SPINNING)
{
if ((mforward && cmd->forwardmove > 0) || (mbackward && cmd->forwardmove < 0))
movepushforward = 0;
else if (!(player->pflags & PF_STARTDASH))
movepushforward = FixedDiv(movepushforward, 16*FRACUNIT);
else
movepushforward = 0;
}
// don't need to account for scale here with kart accel code // don't need to account for scale here with kart accel code
//movepushforward = FixedMul(movepushforward, player->mo->scale); //movepushforward = FixedMul(movepushforward, player->mo->scale);
if (player->mo->movefactor != FRACUNIT) // Friction-scaled acceleration... if (player->mo->movefactor != FRACUNIT) // Friction-scaled acceleration...
movepushforward = FixedMul(movepushforward, player->mo->movefactor); movepushforward = FixedMul(movepushforward, player->mo->movefactor);
//if (mforward && cmd->forwardmove < 0) // SRB2kart - braking isn't instant if (cmd->buttons & BT_BRAKE && !cmd->forwardmove) // SRB2kart - braking isn't instant
// movepushforward /= 32; movepushforward /= 64;
#ifdef ESLOPE #ifdef ESLOPE
totalthrust.x += P_ReturnThrustX(player->mo, movepushangle, movepushforward); totalthrust.x += P_ReturnThrustX(player->mo, movepushangle, movepushforward);
@ -4940,91 +4831,14 @@ static void P_3dMovement(player_t *player)
{ {
K_MomentumToFacing(player); K_MomentumToFacing(player);
} }
// Sideways movement // Sideways movement
if (player->climbing) if (cmd->sidemove != 0 && !(player->exiting || (P_PlayerInPain(player))))
{ {
if (player->powers[pw_super] && ALL7EMERALDS(player->powers[pw_emeralds]))
P_InstaThrust(player->mo, player->mo->angle-ANGLE_90, FixedMul(FixedDiv(cmd->sidemove*FRACUNIT, 5*FRACUNIT), player->mo->scale));
else
P_InstaThrust(player->mo, player->mo->angle-ANGLE_90, FixedMul(FixedDiv(cmd->sidemove*FRACUNIT, 10*FRACUNIT), player->mo->scale));
}
// Analog movement control
else if (analogmove)
{
if (!(player->pflags & PF_GLIDING || player->exiting || P_PlayerInPain(player)))
{
angle_t controldirection;
// Calculate the angle at which the controls are pointing
// to figure out the proper mforward and mbackward.
// (Why was it so complicated before? ~Red)
controldirection = R_PointToAngle2(0, 0, cmd->forwardmove*FRACUNIT, -cmd->sidemove*FRACUNIT)+movepushangle;
//movepushforward = max(abs(cmd->sidemove), abs(cmd->forwardmove)) * (thrustfactor * acceleration);
movepushforward = K_3dKartMovement(player, onground, max(abs(cmd->sidemove), abs(cmd->forwardmove)));
// allow very small movement while in air for gameplay
if (!onground)
movepushforward >>= 2; // proper air movement
// Allow a bit of movement while spinning
if (player->pflags & PF_SPINNING)
{
// Stupid little movement prohibitor hack
// that REALLY shouldn't belong in analog code.
if ((mforward && cmd->forwardmove > 0) || (mbackward && cmd->forwardmove < 0))
movepushforward = 0;
else if (!(player->pflags & PF_STARTDASH))
movepushforward = FixedDiv(movepushforward, 16*FRACUNIT);
else
movepushforward = 0;
}
movepushsideangle = controldirection;
// don't need to account for scale here with kart accel code
//movepushforward = FixedMul(movepushforward, player->mo->scale);
//if (mforward && cmd->forwardmove < 0) // SRB2kart - braking isn't instant
// movepushforward /= 32;
#ifdef ESLOPE
totalthrust.x += P_ReturnThrustX(player->mo, controldirection, movepushforward);
totalthrust.y += P_ReturnThrustY(player->mo, controldirection, movepushforward);
#else
P_Thrust(player->mo, controldirection, movepushforward);
#endif
}
}
else if (cmd->sidemove && !(player->pflags & PF_GLIDING) && !player->exiting && !P_PlayerInPain(player))
{
//movepushside = cmd->sidemove * (thrustfactor * acceleration);
if (cmd->sidemove > 0) if (cmd->sidemove > 0)
movepushside = K_3dKartMovement(player, onground, 50); movepushside = (cmd->sidemove * FRACUNIT/128) + FixedDiv(player->speed, K_GetKartSpeed(player, true));
else else
movepushside = -(K_3dKartMovement(player, onground, 50)); movepushside = (cmd->sidemove * FRACUNIT/128) - FixedDiv(player->speed, K_GetKartSpeed(player, true));
if (!onground)
{
movepushside >>= 2;
// Reduce movepushslide even more if over "max" flight speed
if (player->powers[pw_tailsfly] && player->speed > K_GetKartSpeed(player, true)) //topspeed)
movepushside >>= 2;
}
// Allow a bit of movement while spinning
if (player->pflags & PF_SPINNING)
{
if (!(player->pflags & PF_STARTDASH))
movepushside = FixedDiv(movepushside,16*FRACUNIT);
else
movepushside = 0;
}
// Finally move the player now that his speed/direction has been decided.
// don't need to account for scale here with kart accel code
//movepushside = FixedMul(movepushside, player->mo->scale);
#ifdef ESLOPE #ifdef ESLOPE
totalthrust.x += P_ReturnThrustX(player->mo, movepushsideangle, movepushside); totalthrust.x += P_ReturnThrustX(player->mo, movepushsideangle, movepushside);
@ -6496,13 +6310,13 @@ void P_ElementalFireTrail(player_t *player)
} }
} }
static void P_SkidStuff(player_t *player) /*static void P_SkidStuff(player_t *player)
{ {
fixed_t pmx = player->rmomx + player->cmomx; fixed_t pmx = player->rmomx + player->cmomx;
fixed_t pmy = player->rmomy + player->cmomy; fixed_t pmy = player->rmomy + player->cmomy;
// Knuckles glides into the dirt. // Knuckles glides into the dirt.
/* // SRB2kart - don't need // SRB2kart - don't need
if (player->pflags & PF_GLIDING && player->skidtime) if (player->pflags & PF_GLIDING && player->skidtime)
{ {
// Fell off a ledge... // Fell off a ledge...
@ -6540,7 +6354,7 @@ static void P_SkidStuff(player_t *player)
} }
} }
// Skidding! // Skidding!
else*/if (onground && !(player->mo->eflags & MFE_GOOWATER) && !(player->pflags & (PF_JUMPED|PF_SPINNING|PF_SLIDING)) && !(player->charflags & SF_NOSKID)) elseif (onground && !(player->mo->eflags & MFE_GOOWATER) && !(player->pflags & (PF_JUMPED|PF_SPINNING|PF_SLIDING)) && !(player->charflags & SF_NOSKID))
{ {
if (player->skidtime) if (player->skidtime)
{ {
@ -6587,7 +6401,7 @@ static void P_SkidStuff(player_t *player)
S_StopSound(player->mo); S_StopSound(player->mo);
} }
} }
} }*/
// //
// P_MovePlayer // P_MovePlayer
@ -6762,7 +6576,7 @@ static void P_MovePlayer(player_t *player)
if (maptol & TOL_2D) if (maptol & TOL_2D)
runspd = FixedMul(runspd, 2*FRACUNIT/3); runspd = FixedMul(runspd, 2*FRACUNIT/3);
P_SkidStuff(player); //P_SkidStuff(player);
///////////////////////// /////////////////////////
// MOVEMENT ANIMATIONS // // MOVEMENT ANIMATIONS //