thirdpartymirrors/RingRacers
1
0
Fork 0
mirror of https://github.com/KartKrewDev/RingRacers.git synced 2025-10-30 08:01:28 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Merge branch 'master' into bot-updates

Browse source
This commit is contained in:
Sally Coolatta 2021-02-07 15:49:28 -05:00
commit 0d1e98c7b9
18 changed files with 823 additions and 133 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

8
src/d_clisrv.c
View file

@ -616,6 +616,8 @@ static inline void resynch_write_player(resynch_pak *rsp, const size_t i)
rsp->kartstuff[j] = LONG(players[i].kartstuff[j]);
rsp->airtime = (tic_t)LONG(players[i].airtime);
rsp->driftInput = players[i].driftInput;
rsp->trickpanel = (UINT8)players[i].trickpanel;
rsp->trickdelay = (boolean)players[i].trickdelay;
rsp->trickmomx = (fixed_t)LONG(players[i].trickmomx);
@ -631,6 +633,8 @@ static inline void resynch_write_player(resynch_pak *rsp, const size_t i)
rsp->tumbleLastBounce = players[i].tumbleLastBounce;
rsp->tumbleSound = players[i].tumbleSound;
rsp->glanceDir = players[i].glanceDir;
// respawnvars_t
rsp->respawn_state = players[i].respawn.state;
rsp->respawn_pointx = (fixed_t)LONG(players[i].respawn.pointx);
@ -774,6 +778,8 @@ static void resynch_read_player(resynch_pak *rsp)
players[i].kartstuff[j] = LONG(rsp->kartstuff[j]);
players[i].airtime = (tic_t)LONG(rsp->airtime);
players[i].driftInput = (boolean)rsp->driftInput;
players[i].trickpanel = (UINT8)rsp->trickpanel;
players[i].trickdelay = (boolean)rsp->trickdelay;
players[i].trickmomx = (fixed_t)LONG(rsp->trickmomx);
@ -789,6 +795,8 @@ static void resynch_read_player(resynch_pak *rsp)
players[i].tumbleLastBounce = (boolean)rsp->tumbleLastBounce;
players[i].tumbleSound = (boolean)rsp->tumbleSound;
players[i].glanceDir = (SINT8)rsp->glanceDir;
// respawnvars_t
players[i].respawn.state = rsp->respawn_state;
players[i].respawn.pointx = (fixed_t)LONG(rsp->respawn_pointx);

3
src/d_clisrv.h
View file

@ -280,6 +280,7 @@ typedef struct
// SRB2kart
INT32 kartstuff[NUMKARTSTUFF];
tic_t airtime;
boolean driftInput;
UINT8 trickpanel;
boolean trickdelay;
fixed_t trickmomx;
@ -295,6 +296,8 @@ typedef struct
boolean tumbleLastBounce;
boolean tumbleSound;
SINT8 glanceDir;
// respawnvars_t
UINT8 respawn_state;
fixed_t respawn_pointx;

22
src/d_player.h
View file

@ -115,19 +115,11 @@ typedef enum
{
// Are animation frames playing?
PA_ETC=0,
PA_IDLE,
PA_EDGE,
PA_WALK,
PA_RUN,
PA_DASH,
PA_PAIN,
PA_ROLL,
PA_JUMP,
PA_SPRING,
PA_FALL,
PA_ABILITY,
PA_ABILITY2,
PA_RIDE
PA_STILL,
PA_SLOW,
PA_FAST,
PA_DRIFT,
PA_HURT
} panim_t;
//
@ -527,10 +519,12 @@ typedef struct player_s
// SRB2kart stuff
INT32 kartstuff[NUMKARTSTUFF];
INT32 karthud[NUMKARTHUD];
UINT32 distancetofinish;
waypoint_t *nextwaypoint;
respawnvars_t respawn; // Respawn info
tic_t airtime; // Keep track of how long you've been in the air
boolean driftInput; // Whenever or not try drifting.
UINT8 trickpanel; // Trick panel state
boolean trickdelay; // Prevent tricks until control stick is neutral
@ -577,6 +571,8 @@ typedef struct player_s
boolean tumbleLastBounce;
boolean tumbleSound;
SINT8 glanceDir; // Direction the player is trying to look backwards in
//
UINT32 charflags; // Extra abilities/settings for skins (combinable stuff)

57
src/dehacked.c
View file

@ -5211,12 +5211,24 @@ static const char *const STATE_LIST[] = { // array length left dynamic for sanit
"S_KART_STILL",
"S_KART_STILL_L",
"S_KART_STILL_R",
"S_KART_STILL_GLANCE_L",
"S_KART_STILL_GLANCE_R",
"S_KART_STILL_LOOK_L",
"S_KART_STILL_LOOK_R",
"S_KART_SLOW",
"S_KART_SLOW_L",
"S_KART_SLOW_R",
"S_KART_SLOW_GLANCE_L",
"S_KART_SLOW_GLANCE_R",
"S_KART_SLOW_LOOK_L",
"S_KART_SLOW_LOOK_R",
"S_KART_FAST",
"S_KART_FAST_L",
"S_KART_FAST_R",
"S_KART_FAST_GLANCE_L",
"S_KART_FAST_GLANCE_R",
"S_KART_FAST_LOOK_L",
"S_KART_FAST_LOOK_R",
"S_KART_DRIFT_L",
"S_KART_DRIFT_L_OUT",
"S_KART_DRIFT_L_IN",
@ -5224,12 +5236,18 @@ static const char *const STATE_LIST[] = { // array length left dynamic for sanit
"S_KART_DRIFT_R_OUT",
"S_KART_DRIFT_R_IN",
"S_KART_SPINOUT",
"S_KART_SQUISH",
"S_KART_DEAD",
"S_KART_SIGN",
// technically the player goes here but it's an infinite tic state
"S_OBJPLACE_DUMMY",
"S_KART_LEFTOVER",
"S_KART_LEFTOVER_NOTIRES",
"S_KART_TIRE1",
"S_KART_TIRE2",
// Blue Crawla
"S_POSS_STND",
"S_POSS_RUN1",
@ -9414,6 +9432,22 @@ static const char *const STATE_LIST[] = { // array length left dynamic for sanit
"S_FINISHBEAMEND1",
"S_FINISHBEAMEND2",
// Funny Spike
"S_DEBTSPIKE1",
"S_DEBTSPIKE2",
"S_DEBTSPIKE3",
"S_DEBTSPIKE4",
"S_DEBTSPIKE5",
"S_DEBTSPIKE6",
"S_DEBTSPIKE7",
"S_DEBTSPIKE8",
"S_DEBTSPIKE9",
"S_DEBTSPIKEA",
"S_DEBTSPIKEB",
"S_DEBTSPIKEC",
"S_DEBTSPIKED",
"S_DEBTSPIKEE",
#ifdef SEENAMES
"S_NAMECHECK",
#endif
@ -9428,6 +9462,8 @@ static const char *const MOBJTYPE_LIST[] = { // array length left dynamic for s
"MT_THOK", // Thok! mobj
"MT_PLAYER",
"MT_KART_LEFTOVER",
"MT_KART_TIRE",
// Enemies
"MT_BLUECRAWLA", // Crawla (Blue)
@ -9553,6 +9589,7 @@ static const char *const MOBJTYPE_LIST[] = { // array length left dynamic for s
// Collectible Items
"MT_RING",
"MT_FLINGRING", // Lost ring
"MT_DEBTSPIKE", // Ring debt funny spike
"MT_BLUESPHERE", // Blue sphere for special stages
"MT_FLINGBLUESPHERE", // Lost blue sphere
"MT_BOMBSPHERE",
@ -11450,19 +11487,11 @@ struct {
// Player animation (panim_t)
{"PA_ETC",PA_ETC},
{"PA_IDLE",PA_IDLE},
{"PA_EDGE",PA_EDGE},
{"PA_WALK",PA_WALK},
{"PA_RUN",PA_RUN},
{"PA_DASH",PA_DASH},
{"PA_PAIN",PA_PAIN},
{"PA_ROLL",PA_ROLL},
{"PA_JUMP",PA_JUMP},
{"PA_SPRING",PA_SPRING},
{"PA_FALL",PA_FALL},
{"PA_ABILITY",PA_ABILITY},
{"PA_ABILITY2",PA_ABILITY2},
{"PA_RIDE",PA_RIDE},
{"PA_STILL",PA_STILL},
{"PA_SLOW",PA_SLOW},
{"PA_FAST",PA_FAST},
{"PA_DRIFT",PA_DRIFT},
{"PA_HURT",PA_HURT},
// Value for infinite lives
{"INFLIVES",INFLIVES},

2
src/g_game.c
View file

@ -2261,7 +2261,7 @@ void G_PlayerReborn(INT32 player, boolean betweenmaps)
p->pflags |= PF_JUMPDOWN;
p->playerstate = PST_LIVE;
p->panim = PA_IDLE; // standing animation
p->panim = PA_STILL; // standing animation
// Check to make sure their color didn't change somehow...
if (G_GametypeHasTeams())

150
src/info.c
View file

@ -32,6 +32,8 @@ char sprnames[NUMSPRITES + 1][5] =
"THOK", // Thok! mobj
"PLAY",
"KART",
"TIRE",
// Enemies
"POSS", // Crawla (Blue)
@ -131,6 +133,7 @@ char sprnames[NUMSPRITES + 1][5] =
// Collectible Items
"RING",
"DEBT",
"TRNG", // Team Rings
"TOKE", // Special Stage Token
"RFLG", // Red CTF Flag
@ -748,12 +751,23 @@ char sprnames[NUMSPRITES + 1][5] =
char spr2names[NUMPLAYERSPRITES][5] =
{
"STIN", "STIL", "STIR", // Still
"STGL", "STGR", // Still (glance back)
"STLL", "STLR", // Still (look back)
"SLWN", "SLWL", "SLWR", // Slow driving
"SLGL", "SLGR", // Slow (glance back)
"SLLL", "SLLR", // Slow (look back)
"FSTN", "FSTL", "FSTR", // Fast driving
"FSGL", "FSGR", // Fast (glance back)
"FSLL", "FSLR", // Fast (look back)
"DRLN", "DRLO", "DRLI", // Drifting left
"DRRN", "DRRO", "DRRI", // Drifting right
"SPIN", // Spinout
"SQSH", // Squish
"DEAD", // Dead
"SIGN", // Finish signpost
"XTRA", // Three Faces of Darkness
};
@ -763,14 +777,26 @@ playersprite_t spr2defaults[NUMPLAYERSPRITES] = {
0, // SPR2_STIN
SPR2_STIN, // SPR2_STIL
SPR2_STIN, // SPR2_STIR
SPR2_STIN, // SPR2_STGL
SPR2_STIN, // SPR2_STGR
SPR2_STGL, // SPR2_STLL
SPR2_STGR, // SPR2_STLR
0, // SPR2_SLWN
SPR2_SLWN, // SPR2_SLWL
SPR2_SLWN, // SPR2_SLWR
SPR2_SLWN, // SPR2_SLGL
SPR2_SLWN, // SPR2_SLGR
SPR2_SLGL, // SPR2_SLLL
SPR2_SLGR, // SPR2_SLLR
0, // SPR2_FSTN
SPR2_FSTN, // SPR2_FSTL
SPR2_FSTN, // SPR2_FSTR
SPR2_FSTN, // SPR2_FSGL
SPR2_FSTN, // SPR2_FSGR
SPR2_FSGL, // SPR2_FSLL
SPR2_FSGR, // SPR2_FSLR
0, // SPR2_DRLN
SPR2_DRLN, // SPR2_DRLO
@ -781,9 +807,10 @@ playersprite_t spr2defaults[NUMPLAYERSPRITES] = {
SPR2_DRRN, // SPR2_DRRI
0, // SPR2_SPIN
SPR2_SPIN, // SPR2_SQSH
0, // SPR2_DEAD
0, // SPR2_SIGN
0, // SPR2_XTRA
};
// Doesn't work with g++, needs actionf_p1 (don't modify this comment)
@ -814,12 +841,24 @@ state_t states[NUMSTATES] =
{SPR_PLAY, SPR2_STIN, 1, {NULL}, 0, 0, S_KART_STILL}, // S_KART_STILL
{SPR_PLAY, SPR2_STIL, 1, {NULL}, 0, 0, S_KART_STILL_L}, // S_KART_STILL_L
{SPR_PLAY, SPR2_STIR, 1, {NULL}, 0, 0, S_KART_STILL_R}, // S_KART_STILL_R
{SPR_PLAY, SPR2_STGL, 1, {NULL}, 0, 0, S_KART_STILL_GLANCE_L}, // S_KART_STILL_GLANCE_L
{SPR_PLAY, SPR2_STGR, 1, {NULL}, 0, 0, S_KART_STILL_GLANCE_R}, // S_KART_STILL_GLANCE_R
{SPR_PLAY, SPR2_STLL, 1, {NULL}, 0, 0, S_KART_STILL_LOOK_L}, // S_KART_STILL_LOOK_L
{SPR_PLAY, SPR2_STLR, 1, {NULL}, 0, 0, S_KART_STILL_LOOK_R}, // S_KART_STILL_LOOK_R
{SPR_PLAY, SPR2_SLWN, 1, {NULL}, 0, 0, S_KART_SLOW}, // S_KART_SLOW
{SPR_PLAY, SPR2_SLWL, 1, {NULL}, 0, 0, S_KART_SLOW_L}, // S_KART_SLOW_L
{SPR_PLAY, SPR2_SLWR, 1, {NULL}, 0, 0, S_KART_SLOW_R}, // S_KART_SLOW_R
{SPR_PLAY, SPR2_SLGL, 1, {NULL}, 0, 0, S_KART_SLOW_GLANCE_L}, // S_KART_SLOW_GLANCE_L
{SPR_PLAY, SPR2_SLGR, 1, {NULL}, 0, 0, S_KART_SLOW_GLANCE_R}, // S_KART_SLOW_GLANCE_R
{SPR_PLAY, SPR2_SLLL, 1, {NULL}, 0, 0, S_KART_SLOW_LOOK_L}, // S_KART_SLOW_LOOK_L
{SPR_PLAY, SPR2_SLLR, 1, {NULL}, 0, 0, S_KART_SLOW_LOOK_R}, // S_KART_SLOW_LOOK_R
{SPR_PLAY, SPR2_FSTN, 1, {NULL}, 0, 0, S_KART_FAST}, // S_KART_FAST
{SPR_PLAY, SPR2_FSTL, 1, {NULL}, 0, 0, S_KART_FAST_L}, // S_KART_FAST_L
{SPR_PLAY, SPR2_FSTR, 1, {NULL}, 0, 0, S_KART_FAST_R}, // S_KART_FAST_R
{SPR_PLAY, SPR2_FSGL, 1, {NULL}, 0, 0, S_KART_FAST_GLANCE_L}, // S_KART_FAST_GLANCE_L
{SPR_PLAY, SPR2_FSGR, 1, {NULL}, 0, 0, S_KART_FAST_GLANCE_R}, // S_KART_FAST_GLANCE_R
{SPR_PLAY, SPR2_FSLL, 1, {NULL}, 0, 0, S_KART_FAST_LOOK_L}, // S_KART_FAST_LOOK_L
{SPR_PLAY, SPR2_FSLR, 1, {NULL}, 0, 0, S_KART_FAST_LOOK_R}, // S_KART_FAST_LOOK_R
{SPR_PLAY, SPR2_DRLN, 1, {NULL}, 0, 0, S_KART_DRIFT_L}, // S_KART_DRIFT_L
{SPR_PLAY, SPR2_DRLO, 1, {NULL}, 0, 0, S_KART_DRIFT_L_OUT}, // S_KART_DRIFT_L_OUT
{SPR_PLAY, SPR2_DRLI, 1, {NULL}, 0, 0, S_KART_DRIFT_L_IN}, // S_KART_DRIFT_L_IN
@ -827,11 +866,17 @@ state_t states[NUMSTATES] =
{SPR_PLAY, SPR2_DRRO, 1, {NULL}, 0, 0, S_KART_DRIFT_R_OUT}, // S_KART_DRIFT_R_OUT
{SPR_PLAY, SPR2_DRRI, 1, {NULL}, 0, 0, S_KART_DRIFT_R_IN}, // S_KART_DRIFT_R_IN
{SPR_PLAY, SPR2_SPIN|FF_ANIMATE, 350, {NULL}, 0, 1, S_KART_STILL}, // S_KART_SPINOUT
{SPR_PLAY, SPR2_SQSH|FF_ANIMATE, 350, {NULL}, 0, 1, S_KART_STILL}, // S_KART_SQUISH
{SPR_PLAY, SPR2_DEAD, 3, {NULL}, 0, 0, S_KART_DEAD}, // S_KART_DEAD
{SPR_PLAY, SPR2_SIGN|FF_PAPERSPRITE, 1, {NULL}, 0, 0, S_KART_SIGN}, // S_KART_SIGN
{SPR_NULL, 0, -1, {NULL}, 0, 0, S_OBJPLACE_DUMMY}, // S_OBJPLACE_DUMMY
{SPR_KART, 0, -1, {NULL}, 0, 0, S_NULL}, // S_KART_LEFTOVER
{SPR_KART, 1, -1, {NULL}, 0, 0, S_NULL}, // S_KART_LEFTOVER_NOTIRES
{SPR_TIRE, 0, -1, {NULL}, 0, 0, S_NULL}, // S_KART_TIRE1
{SPR_TIRE, 1, -1, {NULL}, 0, 0, S_NULL}, // S_KART_TIRE2
// Blue Crawla
{SPR_POSS, 0, 5, {A_Look}, 0, 0, S_POSS_STND}, // S_POSS_STND
{SPR_POSS, 0, 3, {A_Chase}, 0, 0, S_POSS_RUN2}, // S_POSS_RUN1
@ -5126,6 +5171,22 @@ state_t states[NUMSTATES] =
{SPR_FLBM, FF_PAPERSPRITE|5, 1, {NULL}, 0, 0, S_NULL}, // S_FINISHBEAMEND1
{SPR_FLBM, FF_PAPERSPRITE|6, 1, {NULL}, 0, 0, S_NULL}, // S_FINISHBEAMEND2
// Funny Spike
{SPR_DEBT, 0|FF_FULLBRIGHT, 1, {NULL}, 0, 0, S_DEBTSPIKE2}, // S_DEBTSPIKE1
{SPR_DEBT, 7|FF_FULLBRIGHT, 1, {NULL}, 0, 0, S_DEBTSPIKE3}, // S_DEBTSPIKE2
{SPR_DEBT, 1|FF_FULLBRIGHT, 1, {NULL}, 0, 0, S_DEBTSPIKE4}, // S_DEBTSPIKE3
{SPR_DEBT, 7|FF_FULLBRIGHT, 1, {NULL}, 0, 0, S_DEBTSPIKE5}, // S_DEBTSPIKE4
{SPR_DEBT, 2|FF_FULLBRIGHT, 1, {NULL}, 0, 0, S_DEBTSPIKE6}, // S_DEBTSPIKE5
{SPR_DEBT, 7|FF_FULLBRIGHT, 1, {NULL}, 0, 0, S_DEBTSPIKE7}, // S_DEBTSPIKE6
{SPR_DEBT, 3|FF_FULLBRIGHT, 1, {NULL}, 0, 0, S_DEBTSPIKE8}, // S_DEBTSPIKE7
{SPR_DEBT, 7|FF_FULLBRIGHT, 1, {NULL}, 0, 0, S_DEBTSPIKE9}, // S_DEBTSPIKE8
{SPR_DEBT, 4|FF_FULLBRIGHT, 1, {NULL}, 0, 0, S_DEBTSPIKEA}, // S_DEBTSPIKE9
{SPR_DEBT, 7|FF_FULLBRIGHT, 1, {NULL}, 0, 0, S_DEBTSPIKEB}, // S_DEBTSPIKEA
{SPR_DEBT, 5|FF_FULLBRIGHT, 1, {NULL}, 0, 0, S_DEBTSPIKEC}, // S_DEBTSPIKEB
{SPR_DEBT, 7|FF_FULLBRIGHT, 1, {NULL}, 0, 0, S_DEBTSPIKED}, // S_DEBTSPIKEC
{SPR_DEBT, 6|FF_FULLBRIGHT, 1, {NULL}, 0, 0, S_DEBTSPIKEE}, // S_DEBTSPIKED
{SPR_DEBT, 7|FF_FULLBRIGHT, 1, {NULL}, 0, 0, S_DEBTSPIKE1}, // S_DEBTSPIKEE
#ifdef SEENAMES
{SPR_NULL, 0, 1, {NULL}, 0, 0, S_NULL}, // S_NAMECHECK
#endif
@ -5227,7 +5288,7 @@ mobjinfo_t mobjinfo[NUMMOBJTYPES] =
sfx_None, // painsound
S_NULL, // meleestate
S_NULL, // missilestate
S_KART_SPINOUT, // deathstate
S_KART_DEAD, // deathstate
S_NULL, // xdeathstate
sfx_None, // deathsound
1, // speed
@ -5241,6 +5302,60 @@ mobjinfo_t mobjinfo[NUMMOBJTYPES] =
(statenum_t)MT_THOK // raisestate
},
{ // MT_KART_LEFTOVER
4095, // doomednum
S_KART_LEFTOVER, // spawnstate
2, // spawnhealth
S_NULL, // seestate
sfx_None, // seesound
0, // reactiontime
sfx_None, // attacksound
S_NULL, // painstate
0, // painchance
sfx_None, // painsound
S_NULL, // meleestate
S_NULL, // missilestate
S_NULL, // deathstate
S_NULL, // xdeathstate
sfx_None, // deathsound
1, // speed
16*FRACUNIT, // radius
48*FRACUNIT, // height
-1, // display offset
1000, // mass
0, // damage
sfx_None, // activesound
MF_SOLID|MF_DONTENCOREMAP, // flags
S_NULL // raisestate
},
{ // MT_KART_TIRE
-1, // doomednum
S_KART_TIRE1, // spawnstate
1, // spawnhealth
S_NULL, // seestate
sfx_None, // seesound
0, // reactiontime
sfx_None, // attacksound
S_NULL, // painstate
0, // painchance
sfx_None, // painsound
S_NULL, // meleestate
S_NULL, // missilestate
S_NULL, // deathstate
S_NULL, // xdeathstate
sfx_None, // deathsound
1, // speed
6*FRACUNIT, // radius
12*FRACUNIT, // height
-1, // display offset
1000, // mass
0, // damage
sfx_None, // activesound
MF_DONTENCOREMAP, // flags
S_NULL // raisestate
},
{ // MT_BLUECRAWLA
100, // doomednum
S_POSS_STND, // spawnstate
@ -8022,6 +8137,33 @@ mobjinfo_t mobjinfo[NUMMOBJTYPES] =
S_NULL // raisestate
},
{ // MT_DEBTSPIKE
-1, // doomednum
S_DEBTSPIKE1, // spawnstate
1000, // spawnhealth
S_NULL, // seestate
sfx_None, // seesound
MT_FLINGRING, // reactiontime
sfx_None, // attacksound
S_NULL, // painstate
MT_RING, // painchance
sfx_None, // painsound
S_NULL, // meleestate
S_NULL, // missilestate
S_SPRK1, // deathstate
S_NULL, // xdeathstate
sfx_itemup, // deathsound
38*FRACUNIT, // speed
24*FRACUNIT, // radius
48*FRACUNIT, // height
0, // display offset
100, // mass
0, // damage
sfx_None, // activesound
MF_DONTENCOREMAP, // flags
S_NULL // raisestate
},
{ // MT_BLUESPHERE
-1, // doomednum
S_BLUESPHERE_SPAWN, // spawnstate

46
src/info.h
View file

@ -303,6 +303,8 @@ typedef enum sprite
SPR_THOK, // Thok! mobj
SPR_PLAY,
SPR_KART,
SPR_TIRE,
// Enemies
SPR_POSS, // Crawla (Blue)
@ -402,6 +404,7 @@ typedef enum sprite
// Collectible Items
SPR_RING,
SPR_DEBT,
SPR_TRNG, // Team Rings
SPR_TOKE, // Special Stage Token
SPR_RFLG, // Red CTF Flag
@ -1026,12 +1029,15 @@ typedef enum sprite
typedef enum playersprite
{
SPR2_STIN = 0, SPR2_STIL, SPR2_STIR,
SPR2_STGL, SPR2_STGR, SPR2_STLL, SPR2_STLR,
SPR2_SLWN, SPR2_SLWL, SPR2_SLWR,
SPR2_SLGL, SPR2_SLGR, SPR2_SLLL, SPR2_SLLR,
SPR2_FSTN, SPR2_FSTL, SPR2_FSTR,
SPR2_FSGL, SPR2_FSGR, SPR2_FSLL, SPR2_FSLR,
SPR2_DRLN, SPR2_DRLO, SPR2_DRLI,
SPR2_DRRN, SPR2_DRRO, SPR2_DRRI,
SPR2_SPIN,
SPR2_SQSH,
SPR2_DEAD,
SPR2_SIGN,
SPR2_XTRA,
SPR2_FIRSTFREESLOT,
@ -1059,12 +1065,24 @@ typedef enum state
S_KART_STILL,
S_KART_STILL_L,
S_KART_STILL_R,
S_KART_STILL_GLANCE_L,
S_KART_STILL_GLANCE_R,
S_KART_STILL_LOOK_L,
S_KART_STILL_LOOK_R,
S_KART_SLOW,
S_KART_SLOW_L,
S_KART_SLOW_R,
S_KART_SLOW_GLANCE_L,
S_KART_SLOW_GLANCE_R,
S_KART_SLOW_LOOK_L,
S_KART_SLOW_LOOK_R,
S_KART_FAST,
S_KART_FAST_L,
S_KART_FAST_R,
S_KART_FAST_GLANCE_L,
S_KART_FAST_GLANCE_R,
S_KART_FAST_LOOK_L,
S_KART_FAST_LOOK_R,
S_KART_DRIFT_L,
S_KART_DRIFT_L_OUT,
S_KART_DRIFT_L_IN,
@ -1072,12 +1090,18 @@ typedef enum state
S_KART_DRIFT_R_OUT,
S_KART_DRIFT_R_IN,
S_KART_SPINOUT,
S_KART_SQUISH,
S_KART_DEAD,
S_KART_SIGN,
// technically the player goes here but it's an infinite tic state
S_OBJPLACE_DUMMY,
S_KART_LEFTOVER,
S_KART_LEFTOVER_NOTIRES,
S_KART_TIRE1,
S_KART_TIRE2,
// Blue Crawla
S_POSS_STND,
S_POSS_RUN1,
@ -5281,6 +5305,21 @@ typedef enum state
S_FINISHBEAMEND1,
S_FINISHBEAMEND2,
S_DEBTSPIKE1,
S_DEBTSPIKE2,
S_DEBTSPIKE3,
S_DEBTSPIKE4,
S_DEBTSPIKE5,
S_DEBTSPIKE6,
S_DEBTSPIKE7,
S_DEBTSPIKE8,
S_DEBTSPIKE9,
S_DEBTSPIKEA,
S_DEBTSPIKEB,
S_DEBTSPIKEC,
S_DEBTSPIKED,
S_DEBTSPIKEE,
#ifdef SEENAMES
S_NAMECHECK,
#endif
@ -5315,6 +5354,8 @@ typedef enum mobj_type
MT_THOK, // Thok! mobj
MT_PLAYER,
MT_KART_LEFTOVER,
MT_KART_TIRE,
// Enemies
MT_BLUECRAWLA, // Crawla (Blue)
@ -5440,6 +5481,7 @@ typedef enum mobj_type
// Collectible Items
MT_RING,
MT_FLINGRING, // Lost ring
MT_DEBTSPIKE, // Ring debt funny spike
MT_BLUESPHERE, // Blue sphere for special stages
MT_FLINGBLUESPHERE, // Lost blue sphere
MT_BOMBSPHERE,

5
src/k_hud.c
View file

@ -2425,6 +2425,7 @@ static void K_drawKartPlayerCheck(void)
UINT8 cnum = 0;
UINT8 i;
INT32 splitflags = V_SNAPTOBOTTOM|V_SPLITSCREEN;
fixed_t y = CHEK_Y * FRACUNIT;
if (stplyr == NULL || stplyr->mo == NULL || P_MobjWasRemoved(stplyr->mo))
{
@ -2443,6 +2444,8 @@ static void K_drawKartPlayerCheck(void)
if (r_splitscreen)
{
y /= 2;
for (i = 1; i <= r_splitscreen; i++)
{
if (stplyr == &players[displayplayers[i]])
@ -2515,7 +2518,7 @@ static void K_drawKartPlayerCheck(void)
K_ObjectTracking(&x, NULL, &c, thiscam->angle + ANGLE_180, 0, &v, cnum);
colormap = R_GetTranslationColormap(TC_DEFAULT, checkplayer->mo->color, GTC_CACHE);
V_DrawFixedPatch(x, CHEK_Y * FRACUNIT, FRACUNIT, V_HUDTRANS|V_SPLITSCREEN|splitflags, kp_check[pnum], colormap);
V_DrawFixedPatch(x, y, FRACUNIT, V_HUDTRANS|V_SPLITSCREEN|splitflags, kp_check[pnum], colormap);
}
}

342
src/k_kart.c
View file

@ -1010,6 +1010,14 @@ fixed_t K_GetMobjWeight(mobj_t *mobj, mobj_t *against)
break;
weight = K_PlayerWeight(mobj, against);
break;
case MT_KART_LEFTOVER:
weight = 5*FRACUNIT/2;
if (mobj->extravalue1 > 0)
{
weight = mobj->extravalue1 * (FRACUNIT >> 1);
}
break;
case MT_BUBBLESHIELD:
weight = K_PlayerWeight(mobj->target, against);
break;
@ -1726,6 +1734,102 @@ void K_SpawnDriftBoostClipSpark(mobj_t *clip)
spark->momy = clip->momx/2;
}
static SINT8 K_GlanceAtPlayers(player_t *glancePlayer)
{
const fixed_t maxdistance = FixedMul(1280 * mapobjectscale, K_GetKartGameSpeedScalar(gamespeed));
const angle_t blindSpotSize = ANG10; // ANG5
UINT8 i;
SINT8 glanceDir = 0;
SINT8 lastValidGlance = 0;
// See if there's any players coming up behind us.
// If so, your character will glance at 'em.
for (i = 0; i < MAXPLAYERS; i++)
{
player_t *p;
angle_t back;
angle_t diff;
fixed_t distance;
SINT8 dir = -1;
if (!playeringame[i])
{
// Invalid player
continue;
}
p = &players[i];
if (p == glancePlayer)
{
// FOOL! Don't glance at yerself!
continue;
}
if (!p->mo || P_MobjWasRemoved(p->mo))
{
// Invalid mobj
continue;
}
if (p->spectator || p->kartstuff[k_hyudorotimer] > 0)
{
// Not playing / invisible
continue;
}
distance = R_PointToDist2(glancePlayer->mo->x, glancePlayer->mo->y, p->mo->x, p->mo->y);
if (distance > maxdistance)
{
continue;
}
back = glancePlayer->mo->angle + ANGLE_180;
diff = R_PointToAngle2(glancePlayer->mo->x, glancePlayer->mo->y, p->mo->x, p->mo->y) - back;
if (diff > ANGLE_180)
{
diff = InvAngle(diff);
dir = -dir;
}
if (diff > ANGLE_90)
{
// Not behind the player
continue;
}
if (diff < blindSpotSize)
{
// Small blindspot directly behind your back, gives the impression of smoothly turning.
continue;
}
if (P_CheckSight(glancePlayer->mo, p->mo) == true)
{
// Not blocked by a wall, we can glance at 'em!
// Adds, so that if there's more targets on one of your sides, it'll glance on that side.
glanceDir += dir;
// That poses a limitation if there's an equal number of targets on both sides...
// In that case, we'll pick the last chosen glance direction.
lastValidGlance = dir;
}
}
if (glanceDir > 0)
{
return 1;
}
else if (glanceDir < 0)
{
return -1;
}
return lastValidGlance;
}
/** \brief Handles the state changing for moving players, moved here to eliminate duplicate code
\param player player data
@ -1735,7 +1839,6 @@ void K_SpawnDriftBoostClipSpark(mobj_t *clip)
void K_KartMoveAnimation(player_t *player)
{
const INT16 minturn = KART_FULLTURN/8;
SINT8 turndir = 0;
const fixed_t fastspeed = (K_GetKartSpeed(player, false) * 17) / 20; // 85%
const fixed_t speedthreshold = player->mo->scale / 8;
@ -1743,7 +1846,12 @@ void K_KartMoveAnimation(player_t *player)
const boolean onground = P_IsObjectOnGround(player->mo);
ticcmd_t *cmd = &player->cmd;
const boolean spinningwheels = ((cmd->buttons & BT_ACCELERATE) || (onground && player->speed > 0));
const boolean spinningwheels = (((cmd->buttons & BT_ACCELERATE) == BT_ACCELERATE) || (onground && player->speed > 0));
const boolean lookback = ((cmd->buttons & BT_LOOKBACK) == BT_LOOKBACK);
SINT8 turndir = 0;
SINT8 destGlanceDir = 0;
SINT8 drift = player->kartstuff[k_drift];
if (cmd->turning < -minturn)
{
@ -1754,20 +1862,89 @@ void K_KartMoveAnimation(player_t *player)
turndir = 1;
}
if (lookback == true && drift == 0)
{
// Prioritize looking back frames over turning
turndir = 0;
}
if (turndir == 0 && drift == 0)
{
// Only try glancing if you're driving straight.
// This avoids all-players loops when we don't need it.
destGlanceDir = K_GlanceAtPlayers(player);
if (lookback == true)
{
if (destGlanceDir == 0)
{
if (player->glanceDir != 0)
{
// Keep to the side you were already on.
if (player->glanceDir < 0)
{
destGlanceDir = -1;
}
else
{
destGlanceDir = 1;
}
}
else
{
// Look to your right by default
destGlanceDir = -1;
}
}
else
{
// Looking back AND glancing? Amplify the look!
destGlanceDir *= 2;
}
}
else if (K_GetForwardMove(player) < 0 && destGlanceDir == 0)
{
// Reversing -- like looking back, but doesn't stack on the other glances.
if (player->glanceDir != 0)
{
// Keep to the side you were already on.
if (player->glanceDir < 0)
{
destGlanceDir = -1;
}
else
{
destGlanceDir = 1;
}
}
else
{
// Look to your right by default
destGlanceDir = -1;
}
}
}
else
{
// Not glancing
destGlanceDir = 0;
player->glanceDir = 0;
}
#define SetState(sn) \
if (player->mo->state != &states[sn]) \
P_SetPlayerMobjState(player->mo, sn)
if (!onground)
if (onground == false)
{
// Only use certain frames in the air, to make it look like your tires are spinning fruitlessly!
if (player->kartstuff[k_drift] > 0)
if (drift > 0)
{
// Neutral drift
SetState(S_KART_DRIFT_L);
}
else if (player->kartstuff[k_drift] > 0)
else if (drift < 0)
{
// Neutral drift
SetState(S_KART_DRIFT_R);
@ -1782,22 +1959,41 @@ void K_KartMoveAnimation(player_t *player)
{
SetState(S_KART_FAST_L);
}
else if (turndir == 0)
else
{
SetState(S_KART_FAST);
switch (player->glanceDir)
{
case -2:
SetState(S_KART_FAST_LOOK_R);
break;
case 2:
SetState(S_KART_FAST_LOOK_L);
break;
case -1:
SetState(S_KART_FAST_GLANCE_R);
break;
case 1:
SetState(S_KART_FAST_GLANCE_L);
break;
default:
SetState(S_KART_FAST);
break;
}
}
}
if (!spinningwheels)
{
// TODO: These should prooobably be different SPR2s
// Just a quick hack to prevent needing to do that :V
// TODO: The "tires still in the air" states should have it's own SPR2s.
// This was a quick hack to get the same functionality with less work,
// but it's really dunderheaded & isn't customizable at all.
player->mo->frame = (player->mo->frame & ~FF_FRAMEMASK);
player->mo->tics++; // Makes it properly use frame 0
}
}
else
{
if (player->kartstuff[k_drift] > 0)
if (drift > 0)
{
// Drifting LEFT!
@ -1817,7 +2013,7 @@ void K_KartMoveAnimation(player_t *player)
SetState(S_KART_DRIFT_L);
}
}
else if (player->kartstuff[k_drift] < 0)
else if (drift < 0)
{
// Drifting RIGHT!
@ -1853,7 +2049,24 @@ void K_KartMoveAnimation(player_t *player)
}
else
{
SetState(S_KART_FAST);
switch (player->glanceDir)
{
case -2:
SetState(S_KART_FAST_LOOK_R);
break;
case 2:
SetState(S_KART_FAST_LOOK_L);
break;
case -1:
SetState(S_KART_FAST_GLANCE_R);
break;
case 1:
SetState(S_KART_FAST_GLANCE_L);
break;
default:
SetState(S_KART_FAST);
break;
}
}
}
else
@ -1872,7 +2085,24 @@ void K_KartMoveAnimation(player_t *player)
}
else
{
SetState(S_KART_SLOW);
switch (player->glanceDir)
{
case -2:
SetState(S_KART_SLOW_LOOK_R);
break;
case 2:
SetState(S_KART_SLOW_LOOK_L);
break;
case -1:
SetState(S_KART_SLOW_GLANCE_R);
break;
case 1:
SetState(S_KART_SLOW_GLANCE_L);
break;
default:
SetState(S_KART_SLOW);
break;
}
}
}
else
@ -1889,7 +2119,24 @@ void K_KartMoveAnimation(player_t *player)
}
else
{
SetState(S_KART_STILL);
switch (player->glanceDir)
{
case -2:
SetState(S_KART_STILL_LOOK_R);
break;
case 2:
SetState(S_KART_STILL_LOOK_L);
break;
case -1:
SetState(S_KART_STILL_GLANCE_R);
break;
case 1:
SetState(S_KART_STILL_GLANCE_L);
break;
default:
SetState(S_KART_STILL);
break;
}
}
}
}
@ -1898,6 +2145,16 @@ void K_KartMoveAnimation(player_t *player)
#undef SetState
// Update your glance value to smooth it out.
if (player->glanceDir > destGlanceDir)
{
player->glanceDir--;
}
else if (player->glanceDir < destGlanceDir)
{
player->glanceDir++;
}
// Update lastspeed value -- we use to display slow driving frames instead of fast driving when slowing down.
player->lastspeed = player->speed;
}
@ -2030,6 +2287,13 @@ boolean K_ApplyOffroad(player_t *player)
return true;
}
boolean K_SlopeResistance(player_t *player)
{
if (player->kartstuff[k_invincibilitytimer] || player->kartstuff[k_sneakertimer] || player->kartstuff[k_tiregrease])
return true;
return false;
}
static fixed_t K_FlameShieldDashVar(INT32 val)
{
// 1 second = 75% + 50% top speed
@ -2048,7 +2312,7 @@ fixed_t K_GetSpindashChargeSpeed(player_t *player)
// more speed for higher weight & speed
// Tails = +6.25%, Fang = +20.31%, Mighty = +20.31%, Metal = +25%
// (can be higher than this value when overcharged)
return (player->kartspeed + player->kartweight) * (FRACUNIT/64);
return (player->kartspeed + player->kartweight) * (FRACUNIT/32);
}
@ -2124,11 +2388,12 @@ static void K_GetKartBoostPower(player_t *player)
if (player->kartstuff[k_spindashboost]) // Spindash boost
{
const fixed_t MAXCHARGESPEED = K_GetSpindashChargeSpeed(player);
const fixed_t exponent = FixedMul(player->kartstuff[k_spindashspeed], player->kartstuff[k_spindashspeed]);
// character & charge dependent
ADDBOOST(
FixedMul(MAXCHARGESPEED, player->kartstuff[k_spindashspeed]), // + 0 to K_GetSpindashChargeSpeed()% top speed
(4*FRACUNIT) + (36*player->kartstuff[k_spindashspeed]), // + 400% to 4000% acceleration
FixedMul(MAXCHARGESPEED, exponent), // + 0 to K_GetSpindashChargeSpeed()% top speed
(40 * exponent), // + 0% to 4000% acceleration
0 // + 0% handling
);
}
@ -2616,8 +2881,10 @@ static void K_HandleTumbleSound(player_t *player)
}
}
void K_ExplodePlayer(player_t *player, mobj_t *inflictor, mobj_t *source) // A bit of a hack, we just throw the player up higher here and extend their spinout timer
INT32 K_ExplodePlayer(player_t *player, mobj_t *inflictor, mobj_t *source) // A bit of a hack, we just throw the player up higher here and extend their spinout timer
{
INT32 ringburst = 10;
(void)source;
player->mo->momz = 18*mapobjectscale*P_MobjFlip(player->mo); // please stop forgetting mobjflip checks!!!!
@ -2632,6 +2899,7 @@ void K_ExplodePlayer(player_t *player, mobj_t *inflictor, mobj_t *source) // A b
{
player->kartstuff[k_spinouttimer] = ((5*player->kartstuff[k_spinouttimer])/2)+1;
player->mo->momz *= 2;
ringburst = 20;
}
}
@ -2642,6 +2910,8 @@ void K_ExplodePlayer(player_t *player, mobj_t *inflictor, mobj_t *source) // A b
if (P_IsDisplayPlayer(player))
P_StartQuake(64<<FRACBITS, 5);
return ringburst;
}
// This kind of wipeout happens with no rings -- doesn't remove a bumper, has no invulnerability, and is much shorter.
@ -6135,9 +6405,18 @@ void K_KartPlayerThink(player_t *player, ticcmd_t *cmd)
}
if (cmd->buttons & BT_DRIFT)
player->kartstuff[k_jmp] = 1;
{
// Only allow drifting while NOT trying to do an spindash input.
if ((cmd->buttons & BT_EBRAKEMASK) != BT_EBRAKEMASK)
{
player->driftInput = true;
}
// else, keep the previous value, because it might be brake-drifting.
}
else
player->kartstuff[k_jmp] = 0;
{
player->driftInput = false;
}
// Roulette Code
K_KartItemRoulette(player, cmd);
@ -6742,13 +7021,15 @@ void K_SpawnDriftBoostExplosion(player_t *player, int stage)
static void K_KartDrift(player_t *player, boolean onground)
{
fixed_t minspeed = (10 * player->mo->scale);
INT32 dsone = K_GetKartDriftSparkValue(player);
INT32 dstwo = dsone*2;
INT32 dsthree = dstwo*2;
const fixed_t minspeed = (10 * player->mo->scale);
const INT32 dsone = K_GetKartDriftSparkValue(player);
const INT32 dstwo = dsone*2;
const INT32 dsthree = dstwo*2;
// Drifting is actually straffing + automatic turning.
// Holding the Jump button will enable drifting.
// (This comment is extremely funny)
// Drift Release (Moved here so you can't "chain" drifts)
if (player->kartstuff[k_drift] != -5 && player->kartstuff[k_drift] != 5)
@ -6809,21 +7090,21 @@ static void K_KartDrift(player_t *player, boolean onground)
}
// Drifting: left or right?
if ((player->cmd.turning > 0) && player->speed > minspeed && player->kartstuff[k_jmp] == 1
if ((player->cmd.turning > 0) && player->speed > minspeed && player->driftInput == true
&& (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.turning < 0) && player->speed > minspeed && player->kartstuff[k_jmp] == 1
else if ((player->cmd.turning < 0) && player->speed > minspeed && player->driftInput == true
&& (player->kartstuff[k_drift] == 0 || player->kartstuff[k_driftend] == 1)) // && player->kartstuff[k_drift] != -1)
{
// Starting right drift
player->kartstuff[k_drift] = -1;
player->kartstuff[k_driftend] = player->kartstuff[k_driftcharge] = 0;
}
else if (player->kartstuff[k_jmp] == 0) // || player->kartstuff[k_turndir] == 0)
else if (player->driftInput == false) // || player->kartstuff[k_turndir] == 0)
{
// drift is not being performed so if we're just finishing set driftend and decrement counters
if (player->kartstuff[k_drift] > 0)
@ -6847,7 +7128,7 @@ static void K_KartDrift(player_t *player, boolean onground)
player->kartstuff[k_aizdriftstrat] = player->kartstuff[k_brakedrift] = 0;
player->kartstuff[k_getsparks] = 0;
}
else if (player->kartstuff[k_jmp] == 1 && player->kartstuff[k_drift] != 0)
else if (player->driftInput == true && player->kartstuff[k_drift] != 0)
{
// Incease/decrease the drift value to continue drifting in that direction
fixed_t driftadditive = 24;
@ -7199,6 +7480,11 @@ static void K_KartSpindash(player_t *player)
ticcmd_t *cmd = &player->cmd;
boolean spawnWind = (leveltime % 2 == 0);
if (player->mo->hitlag > 0 || P_PlayerInPain(player))
{
player->kartstuff[k_spindash] = 0;
}
if (player->kartstuff[k_spindash] > 0 && (cmd->buttons & (BT_DRIFT|BT_BRAKE)) != (BT_DRIFT|BT_BRAKE))
{
player->kartstuff[k_spindashspeed] = (player->kartstuff[k_spindash] * FRACUNIT) / MAXCHARGETIME;

3
src/k_kart.h
View file

@ -45,7 +45,7 @@ void K_DoInstashield(player_t *player);
void K_BattleAwardHit(player_t *player, player_t *victim, mobj_t *inflictor, UINT8 bumpersRemoved);
void K_SpinPlayer(player_t *player, mobj_t *inflictor, mobj_t *source, INT32 type);
void K_TumblePlayer(player_t *player, mobj_t *inflictor, mobj_t *source);
void K_ExplodePlayer(player_t *player, mobj_t *inflictor, mobj_t *source);
INT32 K_ExplodePlayer(player_t *player, mobj_t *inflictor, mobj_t *source);
void K_DebtStingPlayer(player_t *player, mobj_t *source);
void K_HandleBumperChanges(player_t *player, UINT8 prevBumpers);
void K_DestroyBumpers(player_t *player, UINT8 amount);
@ -82,6 +82,7 @@ void K_StripItems(player_t *player);
void K_StripOther(player_t *player);
void K_MomentumToFacing(player_t *player);
boolean K_ApplyOffroad(player_t *player);
boolean K_SlopeResistance(player_t *player);
INT16 K_GetSpindashChargeTime(player_t *player);
fixed_t K_GetSpindashChargeSpeed(player_t *player);
fixed_t K_GetKartSpeedFromStat(UINT8 kartspeed);

4
src/k_respawn.c
View file

@ -122,9 +122,9 @@ void K_DoIngameRespawn(player_t *player)
// If player was tumbling, set variables so that they don't tumble like crazy after they're done respawning
if (player->tumbleBounces > 0)
{
player->tumbleBounces = TUMBLEBOUNCES-1; // Max # of bounces-1 (so you still tumble once)
player->tumbleBounces = TUMBLEBOUNCES-1; // Max # of bounces-1 (so you still tumble once)
player->tumbleLastBounce = false; // Still force them to bounce at least once for the funny
players->tumbleHeight = 20; // force tumble height
players->tumbleHeight = 20; // force tumble height
}
P_ResetPlayer(player);

4
src/lua_baselib.c
View file

@ -3440,8 +3440,8 @@ static int lib_kExplodePlayer(lua_State *L)
inflictor = *((mobj_t **)luaL_checkudata(L, 2, META_MOBJ));
if (!lua_isnone(L, 3) && lua_isuserdata(L, 3))
source = *((mobj_t **)luaL_checkudata(L, 3, META_MOBJ));
K_ExplodePlayer(player, inflictor, source);
return 0;
lua_pushinteger(L, K_ExplodePlayer(player, inflictor, source));
return 1;
}
static int lib_kTakeBumpersFromPlayer(lua_State *L)

8
src/lua_playerlib.c
View file

@ -218,6 +218,8 @@ static int player_get(lua_State *L)
LUA_PushUserdata(L, plr->karthud, META_KARTHUD);
else if (fastcmp(field,"airtime"))
lua_pushinteger(L, plr->airtime);
else if (fastcmp(field,"driftInput"))
lua_pushboolean(L, plr->driftInput);
else if (fastcmp(field,"tumbleBounces"))
lua_pushinteger(L, plr->tumbleBounces);
else if (fastcmp(field,"tumbleHeight"))
@ -226,6 +228,8 @@ static int player_get(lua_State *L)
lua_pushboolean(L, plr->tumbleLastBounce);
else if (fastcmp(field,"tumbleSound"))
lua_pushboolean(L, plr->tumbleSound);
else if (fastcmp(field,"glanceDir"))
lua_pushinteger(L, plr->glanceDir);
else if (fastcmp(field,"trickpanel"))
lua_pushinteger(L, plr->trickpanel);
else if (fastcmp(field,"trickdelay"))
@ -527,6 +531,8 @@ static int player_set(lua_State *L)
return NOSET;
else if (fastcmp(field,"airtime"))
plr->airtime = (tic_t)luaL_checkinteger(L, 3);
else if (fastcmp(field,"driftInput"))
plr->driftInput = luaL_checkboolean(L, 3);
else if (fastcmp(field,"tumbleBounces"))
plr->tumbleBounces = (UINT8)luaL_checkinteger(L, 3);
else if (fastcmp(field,"tumbleHeight"))
@ -535,6 +541,8 @@ static int player_set(lua_State *L)
plr->tumbleLastBounce = luaL_checkboolean(L, 3);
else if (fastcmp(field,"tumbleSound"))
plr->tumbleSound = luaL_checkboolean(L, 3);
else if (fastcmp(field,"glanceDir"))
plr->glanceDir = (SINT8)luaL_checkinteger(L, 3);
else if (fastcmp(field,"trickpanel"))
plr->trickpanel = luaL_checkinteger(L, 3);
else if (fastcmp(field,"trickdelay"))

150
src/p_inter.c
View file

@ -1371,13 +1371,47 @@ void P_KillMobj(mobj_t *target, mobj_t *inflictor, mobj_t *source, UINT8 damaget
case MT_PLAYER:
{
angle_t flingAngle;
mobj_t *kart;
target->fuse = TICRATE*3; // timer before mobj disappears from view (even if not an actual player)
target->momx = target->momy = target->momz = 0;
if (target->player && target->player->pflags & PF_GAMETYPEOVER)
break;
kart = P_SpawnMobjFromMobj(target, 0, 0, 0, MT_KART_LEFTOVER);
if (kart && !P_MobjWasRemoved(kart))
{
kart->angle = target->angle;
kart->color = target->color;
kart->hitlag = target->hitlag;
P_SetObjectMomZ(kart, 6*FRACUNIT, false);
kart->extravalue1 = target->player->kartweight;
}
if (source && !P_MobjWasRemoved(source))
{
flingAngle = R_PointToAngle2(
source->x - source->momx, source->y - source->momy,
target->x, target->y
);
}
else
{
flingAngle = target->angle + ANGLE_180;
if (P_RandomByte() & 1)
{
flingAngle -= ANGLE_45;
}
else
{
flingAngle += ANGLE_45;
}
}
P_InstaThrust(target, flingAngle, 14 * target->scale);
P_SetObjectMomZ(target, 14*FRACUNIT, false);
P_PlayDeathSound(target);
}
break;
@ -2012,10 +2046,11 @@ boolean P_DamageMobj(mobj_t *target, mobj_t *inflictor, mobj_t *source, INT32 da
break;
case DMG_TUMBLE:
K_TumblePlayer(player, inflictor, source);
ringburst = 10;
break;
case DMG_EXPLODE:
case DMG_KARMA:
K_ExplodePlayer(player, inflictor, source);
ringburst = K_ExplodePlayer(player, inflictor, source);
break;
case DMG_WIPEOUT:
if (P_IsDisplayPlayer(player))
@ -2100,6 +2135,59 @@ boolean P_DamageMobj(mobj_t *target, mobj_t *inflictor, mobj_t *source, INT32 da
return true;
}
static void P_FlingBurst
( player_t *player,
angle_t fa,
fixed_t z,
mobjtype_t objType,
tic_t objFuse,
fixed_t objScale,
INT32 i)
{
mobj_t *mo;
fixed_t ns;
fixed_t momxy = 5<<FRACBITS, momz = 12<<FRACBITS; // base horizonal/vertical thrusts
INT32 mx = (i + 1) >> 1;
z = player->mo->z;
if (player->mo->eflags & MFE_VERTICALFLIP)
z += player->mo->height - mobjinfo[objType].height;
mo = P_SpawnMobj(player->mo->x, player->mo->y, z, objType);
mo->threshold = 10; // not useful for spikes
mo->fuse = objFuse;
P_SetTarget(&mo->target, player->mo);
mo->destscale = objScale;
P_SetScale(mo, objScale);
/*
0: 0
1: 1 = (1+1)/2 = 1
2: 1 = (2+1)/2 = 1
3: 2 = (3+1)/2 = 2
4: 2 = (4+1)/2 = 2
5: 3 = (4+1)/2 = 2
*/
// Angle / height offset changes every other ring
momxy -= mx * FRACUNIT;
momz += mx * (2<<FRACBITS);
if (i & 1)
fa += ANGLE_180;
ns = FixedMul(momxy, player->mo->scale);
mo->momx = (mo->target->momx/2) + FixedMul(FINECOSINE(fa>>ANGLETOFINESHIFT), ns);
mo->momy = (mo->target->momy/2) + FixedMul(FINESINE(fa>>ANGLETOFINESHIFT), ns);
ns = FixedMul(momz, player->mo->scale);
P_SetObjectMomZ(mo, (mo->target->momz/2) + ns, false);
if (player->mo->eflags & MFE_VERTICALFLIP)
mo->momz *= -1;
}
/** Spills an injured player's rings.
*
* \param player The player who is losing rings.
@ -2109,12 +2197,10 @@ boolean P_DamageMobj(mobj_t *target, mobj_t *inflictor, mobj_t *source, INT32 da
*/
void P_PlayerRingBurst(player_t *player, INT32 num_rings)
{
INT32 num_fling_rings;
INT32 i;
mobj_t *mo;
angle_t fa;
fixed_t ns;
fixed_t z;
fixed_t momxy = 5<<FRACBITS, momz = 12<<FRACBITS; // base horizonal/vertical thrusts
// Rings shouldn't be in Battle!
if (gametyperules & GTR_SPHERES)
@ -2134,52 +2220,26 @@ void P_PlayerRingBurst(player_t *player, INT32 num_rings)
else if (num_rings <= 0)
return;
// Cap the maximum loss automatically to 2 in ring debt
if (player->rings <= 0 && num_rings > 2)
num_rings = 2;
num_fling_rings = min(num_rings, player->rings);
P_GivePlayerRings(player, -num_rings);
// determine first angle
fa = player->mo->angle + ((P_RandomByte() & 1) ? -ANGLE_90 : ANGLE_90);
for (i = 0; i < num_rings; i++)
z = player->mo->z;
if (player->mo->eflags & MFE_VERTICALFLIP)
z += player->mo->height - mobjinfo[MT_RING].height;
for (i = 0; i < num_fling_rings; i++)
{
INT32 objType = mobjinfo[MT_RING].reactiontime;
P_FlingBurst(player, fa, z,
MT_FLINGRING, 60*TICRATE, player->mo->scale, i);
}
z = player->mo->z;
if (player->mo->eflags & MFE_VERTICALFLIP)
z += player->mo->height - mobjinfo[objType].height;
mo = P_SpawnMobj(player->mo->x, player->mo->y, z, objType);
mo->threshold = 10;
mo->fuse = 60*TICRATE;
P_SetTarget(&mo->target, player->mo);
mo->destscale = player->mo->scale;
P_SetScale(mo, player->mo->scale);
// Angle / height offset changes every other ring
if (i != 0)
{
if (i & 1)
{
momxy -= FRACUNIT;
momz += 2<<FRACBITS;
}
fa += ANGLE_180;
}
ns = FixedMul(momxy, mo->scale);
mo->momx = (mo->target->momx/2) + FixedMul(FINECOSINE(fa>>ANGLETOFINESHIFT), ns);
mo->momy = (mo->target->momy/2) + FixedMul(FINESINE(fa>>ANGLETOFINESHIFT), ns);
ns = FixedMul(momz, mo->scale);
P_SetObjectMomZ(mo, (mo->target->momz/2) + ns, false);
if (player->mo->eflags & MFE_VERTICALFLIP)
mo->momz *= -1;
while (i < num_rings)
{
P_FlingBurst(player, fa, z,
MT_DEBTSPIKE, 90, 3 * player->mo->scale / 2, i++);
}
}

15
src/p_map.c
View file

@ -1399,6 +1399,21 @@ static boolean PIT_CheckThing(mobj_t *thing)
return false;
}
else if (thing->type == MT_KART_LEFTOVER)
{
// see if it went over / under
if (tmthing->z > thing->z + thing->height)
return true; // overhead
if (tmthing->z + tmthing->height < thing->z)
return true; // underneath
if (P_IsObjectOnGround(thing) && tmthing->momz < 0)
K_KartBouncing(tmthing, thing, true, false);
else
K_KartBouncing(tmthing, thing, false, false);
return false;
}
else if (thing->flags & MF_SOLID)
{
// see if it went over / under

123
src/p_mobj.c
View file

@ -221,17 +221,29 @@ boolean P_SetPlayerMobjState(mobj_t *mobj, statenum_t state)
case S_KART_STILL:
case S_KART_STILL_L:
case S_KART_STILL_R:
player->panim = PA_IDLE;
case S_KART_STILL_GLANCE_L:
case S_KART_STILL_GLANCE_R:
case S_KART_STILL_LOOK_L:
case S_KART_STILL_LOOK_R:
player->panim = PA_STILL;
break;
case S_KART_SLOW:
case S_KART_SLOW_L:
case S_KART_SLOW_R:
player->panim = PA_WALK;
case S_KART_SLOW_GLANCE_L:
case S_KART_SLOW_GLANCE_R:
case S_KART_SLOW_LOOK_L:
case S_KART_SLOW_LOOK_R:
player->panim = PA_SLOW;
break;
case S_KART_FAST:
case S_KART_FAST_L:
case S_KART_FAST_R:
player->panim = PA_RUN;
case S_KART_FAST_GLANCE_L:
case S_KART_FAST_GLANCE_R:
case S_KART_FAST_LOOK_L:
case S_KART_FAST_LOOK_R:
player->panim = PA_FAST;
break;
case S_KART_DRIFT_L:
case S_KART_DRIFT_L_OUT:
@ -239,11 +251,11 @@ boolean P_SetPlayerMobjState(mobj_t *mobj, statenum_t state)
case S_KART_DRIFT_R:
case S_KART_DRIFT_R_OUT:
case S_KART_DRIFT_R_IN:
player->panim = PA_DASH;
player->panim = PA_DRIFT;
break;
case S_KART_SPINOUT:
case S_KART_SQUISH:
player->panim = PA_PAIN;
case S_KART_DEAD:
player->panim = PA_HURT;
break;
default:
player->panim = PA_ETC;
@ -1300,7 +1312,7 @@ static void P_XYFriction(mobj_t *mo, fixed_t oldx, fixed_t oldy)
&& !(player->mo->standingslope && (!(player->mo->standingslope->flags & SL_NOPHYSICS)) /*&& (abs(player->mo->standingslope->zdelta) >= FRACUNIT/2)*/))
{
// if in a walking frame, stop moving
if (player->panim == PA_WALK)
if (player->panim == PA_SLOW)
{
P_SetPlayerMobjState(mo, S_KART_STILL);
}
@ -2280,6 +2292,11 @@ boolean P_ZMovement(mobj_t *mo)
else
mo->flags2 ^= MFD_DONTDRAW;
}
else if (mo->type == MT_DEBTSPIKE)
{
mom.x = mom.y = 0;
mom.z = -mom.z/2;
}
else if (mo->flags & MF_MISSILE)
{
if (!(mo->flags & MF_NOCLIP))
@ -2334,6 +2351,68 @@ boolean P_ZMovement(mobj_t *mo)
if (mo->flags2 & MF2_SKULLFLY) // the skull slammed into something
mom.z = -mom.z;
else if (mo->type == MT_KART_LEFTOVER)
{
if (mo->health > 1)
{
const fixed_t tireOffset = 32;
const angle_t aOffset = ANGLE_22h;
UINT8 i;
angle_t tireAngle;
mobj_t *tire;
// Spawn tires!
mo->health = 1;
P_SetMobjState(mo, S_KART_LEFTOVER_NOTIRES);
// Front tires
tireAngle = mo->angle - aOffset;
for (i = 0; i < 2; i++)
{
tire = P_SpawnMobjFromMobj(
mo,
tireOffset * FINECOSINE(tireAngle >> ANGLETOFINESHIFT),
tireOffset * FINESINE(tireAngle >> ANGLETOFINESHIFT),
0,
MT_KART_TIRE
);
tire->angle = mo->angle;
tire->fuse = 3*TICRATE;
P_InstaThrust(tire, tireAngle, 4 * mo->scale);
P_SetObjectMomZ(tire, 4*FRACUNIT, false);
tireAngle += (aOffset * 2);
}
// Back tires
tireAngle = (mo->angle + ANGLE_180) - aOffset;
for (i = 0; i < 2; i++)
{
tire = P_SpawnMobjFromMobj(
mo,
tireOffset * FINECOSINE(tireAngle >> ANGLETOFINESHIFT),
tireOffset * FINESINE(tireAngle >> ANGLETOFINESHIFT),
0,
MT_KART_TIRE
);
tire->angle = mo->angle;
tire->fuse = 3*TICRATE;
P_InstaThrust(tire, tireAngle, 4 * mo->scale);
P_SetObjectMomZ(tire, 4*FRACUNIT, false);
P_SetMobjState(tire, S_KART_TIRE2);
tireAngle += (aOffset * 2);
}
}
}
else if (mo->type == MT_KART_TIRE)
{
mom.z = -mom.z;
}
else if (mo->type == MT_BIGTUMBLEWEED
|| mo->type == MT_LITTLETUMBLEWEED
|| mo->type == MT_CANNONBALLDECOR
@ -2633,7 +2712,7 @@ void P_PlayerZMovement(mobj_t *mo)
mo->z = mo->floorz;
// Get up if you fell.
if (mo->player->panim == PA_PAIN && mo->player->kartstuff[k_spinouttimer] == 0 && mo->player->tumbleBounces == 0)
if (mo->player->panim == PA_HURT && mo->player->kartstuff[k_spinouttimer] == 0 && mo->player->tumbleBounces == 0)
P_SetPlayerMobjState(mo, S_KART_STILL);
if (!mo->standingslope && (mo->eflags & MFE_VERTICALFLIP ? tmceilingslope : tmfloorslope)) {
@ -5867,8 +5946,11 @@ static boolean P_MobjDeadThink(mobj_t *mobj)
{ // Go away.
/// \todo Actually go ahead and remove mobj completely, and fix any bugs and crashes doing this creates. Chasecam should stop moving, and F12 should never return to it.
mobj->momz = 0;
if (mobj->player)
{
mobj->drawflags |= MFD_DONTDRAW;
}
else // safe to remove, nobody's going to complain!
{
P_RemoveMobj(mobj);
@ -5877,16 +5959,6 @@ static boolean P_MobjDeadThink(mobj_t *mobj)
}
else // Apply gravity to fall downwards.
{
if (mobj->player && !(mobj->fuse % 8) && (mobj->player->charflags & SF_MACHINE))
{
fixed_t r = mobj->radius >> FRACBITS;
mobj_t *explosion = P_SpawnMobj(
mobj->x + (P_RandomRange(r, -r) << FRACBITS),
mobj->y + (P_RandomRange(r, -r) << FRACBITS),
mobj->z + (P_RandomKey(mobj->height >> FRACBITS) << FRACBITS),
MT_SONIC3KBOSSEXPLODE);
S_StartSound(explosion, sfx_s3kb4);
}
P_SetObjectMomZ(mobj, -2*FRACUNIT/3, true);
}
break;
@ -9079,6 +9151,7 @@ static void P_DefaultMobjShadowScale(mobj_t *thing)
switch (thing->type)
{
case MT_PLAYER:
case MT_KART_LEFTOVER:
case MT_SMALLMACE:
case MT_BIGMACE:
case MT_PUMA:
@ -9124,6 +9197,7 @@ static void P_DefaultMobjShadowScale(mobj_t *thing)
thing->shadowscale = FRACUNIT;
break;
case MT_RING:
case MT_DEBTSPIKE:
case MT_FLOATINGITEM:
case MT_BLUESPHERE:
case MT_EMERALD:
@ -9371,6 +9445,19 @@ mobj_t *P_SpawnMobj(fixed_t x, fixed_t y, fixed_t z, mobjtype_t type)
mobj->color = (P_RandomChance(FRACUNIT/2) ? SKINCOLOR_RED : SKINCOLOR_AQUAMARINE);
break;
case MT_BALLOON:
{
static const UINT8 BALLOONCOLORS[] = {
// Carnival Night balloon colors
SKINCOLOR_KETCHUP,
SKINCOLOR_SAPPHIRE,
SKINCOLOR_TANGERINE,
SKINCOLOR_JET
};
mobj->color = BALLOONCOLORS[P_RandomKey(sizeof(BALLOONCOLORS))];
}
break;
case MT_KART_LEFTOVER:
mobj->color = SKINCOLOR_RED;
break;
case MT_EGGROBO1:

10
src/p_saveg.c
View file

@ -255,7 +255,10 @@ static void P_NetArchivePlayers(void)
WRITEUINT32(save_p, players[i].distancetofinish);
WRITEUINT32(save_p, K_GetWaypointHeapIndex(players[i].nextwaypoint));
WRITEUINT32(save_p, players[i].airtime);
WRITEUINT8(save_p, players[i].driftInput);
WRITEUINT8(save_p, players[i].trickpanel);
WRITEUINT8(save_p, players[i].trickdelay);
WRITEUINT32(save_p, players[i].trickmomx);
@ -271,6 +274,8 @@ static void P_NetArchivePlayers(void)
WRITEUINT8(save_p, players[i].tumbleLastBounce);
WRITEUINT8(save_p, players[i].tumbleSound);
WRITESINT8(save_p, players[i].glanceDir);
// respawnvars_t
WRITEUINT8(save_p, players[i].respawn.state);
WRITEUINT32(save_p, K_GetWaypointHeapIndex(players[i].respawn.wp));
@ -455,7 +460,10 @@ static void P_NetUnArchivePlayers(void)
players[i].distancetofinish = READUINT32(save_p);
players[i].nextwaypoint = (waypoint_t *)(size_t)READUINT32(save_p);
players[i].airtime = READUINT32(save_p);
players[i].driftInput = (boolean)READUINT8(save_p);
players[i].trickpanel = READUINT8(save_p);
players[i].trickdelay = READUINT8(save_p);
players[i].trickmomx = READUINT32(save_p);
@ -471,6 +479,8 @@ static void P_NetUnArchivePlayers(void)
players[i].tumbleLastBounce = (boolean)READUINT8(save_p);
players[i].tumbleSound = (boolean)READUINT8(save_p);
players[i].glanceDir = READSINT8(save_p);
// respawnvars_t
players[i].respawn.state = READUINT8(save_p);
players[i].respawn.wp = (waypoint_t *)(size_t)READUINT32(save_p);

4
src/p_user.c
View file

@ -1851,7 +1851,7 @@ static void P_3dMovement(player_t *player)
totalthrust.x = totalthrust.y = 0; // I forget if this is needed
totalthrust.z = FRACUNIT*P_MobjFlip(player->mo)/3; // A bit of extra push-back on slopes
if (player->kartstuff[k_sneakertimer] > 0)
if (K_SlopeResistance(player) == true)
{
totalthrust.z = -(totalthrust.z);
}
@ -3070,7 +3070,7 @@ boolean P_MoveChaseCamera(player_t *player, camera_t *thiscam, boolean resetcall
mo = player->mo;
if (mo->hitlag > 0)
if (mo->hitlag > 0 || player->playerstate == PST_DEAD)
{
// Do not move the camera while in hitlag!
// The camera zooming out after you got hit makes it hard to focus on the vibration.