diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index 1355c85ee..53eeb5248 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -302,6 +302,7 @@ target_compile_definitions(SRB2SDL2 PRIVATE -DCMAKECONFIG) #) add_subdirectory(sdl) +add_subdirectory(objects) if(${CMAKE_SYSTEM} MATCHES Windows) add_subdirectory(win32) diff --git a/src/Makefile b/src/Makefile index 904aa0bbe..d777cbbcc 100644 --- a/src/Makefile +++ b/src/Makefile @@ -208,6 +208,7 @@ objdir:=$(makedir)/objs sources+=\ $(call List,Sourcefile)\ $(call List,blua/Sourcefile)\ + $(call List,objects/Sourcefile)\ depends:=$(basename $(filter %.c %.s,$(sources))) objects:=$(basename $(filter %.c %.s %.nas,$(sources))) diff --git a/src/Sourcefile b/src/Sourcefile index 7eccf48b6..986b75f74 100644 --- a/src/Sourcefile +++ b/src/Sourcefile @@ -121,4 +121,5 @@ k_terrain.c k_brightmap.c k_terrain.c k_director.c +k_follower.c k_profiles.c diff --git a/src/d_clisrv.c b/src/d_clisrv.c index 35220232d..c60ecc5aa 100644 --- a/src/d_clisrv.c +++ b/src/d_clisrv.c @@ -3651,10 +3651,6 @@ boolean SV_SpawnServer(void) if (netgame && I_NetOpenSocket) { I_NetOpenSocket(); -#ifdef MASTERSERVER - if (cv_advertise.value) - RegisterServer(); -#endif } // non dedicated server just connect to itself diff --git a/src/d_netcmd.c b/src/d_netcmd.c index 9554590b5..6bf65adf6 100644 --- a/src/d_netcmd.c +++ b/src/d_netcmd.c @@ -58,6 +58,7 @@ #include "k_respawn.h" #include "k_grandprix.h" #include "k_boss.h" +#include "k_follower.h" #include "doomstat.h" #include "deh_tables.h" @@ -1450,7 +1451,7 @@ static void SendNameAndColor(UINT8 n) CV_StealthSet(&cv_followercolor[n], "Match"); // set it to "Match". I don't care about your stupidity! // so like, this is sent before we even use anything like cvars or w/e so it's possible that follower is set to a pretty yikes value, so let's fix that before we send garbage that could crash the game: - if (cv_follower[n].value > numfollowers-1 || cv_follower[n].value < -1) + if (cv_follower[n].value >= numfollowers || cv_follower[n].value < -1) CV_StealthSet(&cv_follower[n], "-1"); if (!strcmp(cv_playername[n].string, player_names[playernum]) @@ -1476,12 +1477,11 @@ static void SendNameAndColor(UINT8 n) player->skincolor = cv_playercolor[n].value; - if (player->mo && !player->dye) - player->mo->color = player->skincolor; + K_KartResetPlayerColor(player); // Update follower for local games: if (cv_follower[n].value >= -1 && cv_follower[n].value != player->followerskin) - SetFollower(playernum, cv_follower[n].value); + K_SetFollowerByNum(playernum, cv_follower[n].value); player->followercolor = cv_followercolor[n].value; @@ -1661,11 +1661,13 @@ static void Got_NameAndColor(UINT8 **cp, INT32 playernum) SetPlayerSkinByNum(playernum, skin); // set follower colour: - // Don't bother doing garbage and kicking if we receive None, this is both silly and a waste of time, this will be handled properly in P_HandleFollower. + // Don't bother doing garbage and kicking if we receive None, + // this is both silly and a waste of time, + // this will be handled properly in K_HandleFollower. p->followercolor = followercolor; // set follower - SetFollower(playernum, follower); + K_SetFollowerByNum(playernum, follower); #ifdef HAVE_DISCORDRPC if (playernum == consoleplayer) @@ -4391,7 +4393,11 @@ static void Command_Version_f(void) #endif // DEVELOP build -#ifdef DEVELOP +#if defined(TESTERS) + CONS_Printf("\x88" "TESTERS " "\x80"); +#elif defined(HOSTTESTERS) + CONS_Printf("\x82" "HOSTTESTERS " "\x80"); +#elif defined(DEVELOP) CONS_Printf("\x87" "DEVELOP " "\x80"); #endif @@ -5344,7 +5350,7 @@ static void Follower_OnChange(void) return; } - num = R_FollowerAvailable(str); + num = K_FollowerAvailable(str); if (num == -1) // that's an error. CONS_Alert(CONS_WARNING, M_GetText("Follower '%s' not found\n"), str); @@ -5398,7 +5404,7 @@ static void Follower2_OnChange(void) return; } - num = R_FollowerAvailable(str); + num = K_FollowerAvailable(str); if (num == -1) // that's an error. CONS_Alert(CONS_WARNING, M_GetText("Follower '%s' not found\n"), str); @@ -5449,7 +5455,7 @@ static void Follower3_OnChange(void) return; } - num = R_FollowerAvailable(str); + num = K_FollowerAvailable(str); if (num == -1) // that's an error. CONS_Alert(CONS_WARNING, M_GetText("Follower '%s' not found\n"), str); @@ -5500,7 +5506,7 @@ static void Follower4_OnChange(void) return; } - num = R_FollowerAvailable(str); + num = K_FollowerAvailable(str); if (num == -1) // that's an error. CONS_Alert(CONS_WARNING, M_GetText("Follower '%s' not found\n"), str); diff --git a/src/d_player.h b/src/d_player.h index a1247e8fe..89472e927 100644 --- a/src/d_player.h +++ b/src/d_player.h @@ -328,7 +328,6 @@ typedef struct player_s skybox_t skybox; angle_t viewrollangle; - angle_t old_viewrollangle; // camera tilt // TODO: expose to lua angle_t tilt; @@ -403,7 +402,7 @@ typedef struct player_s UINT8 justbumped; // Prevent players from endlessly bumping into each other UINT8 tumbleBounces; UINT16 tumbleHeight; // In *mobjscaled* fracunits, or mfu, not raw fu - boolean justDI; // Directional Influence ended, true until letting go of turn + UINT8 justDI; // Turn-lockout timer to briefly prevent unintended turning after DI, resets when actionable or no input boolean flipDI; // Bananas flip the DI direction. Was a bug, but it made bananas much more interesting. SINT8 drift; // (-5 to 5) - Drifting Left or Right, plus a bigger counter = sharper turn @@ -470,6 +469,7 @@ typedef struct player_s UINT16 hyudorotimer; // Duration of the Hyudoro offroad effect itself SINT8 stealingtimer; // if >0 you are stealing, if <0 you are being stolen from + mobj_t *hoverhyudoro; // First hyudoro hovering next to player UINT16 sneakertimer; // Duration of a Sneaker Boost (from Sneakers or level boosters) UINT8 numsneakers; // Number of stacked sneaker effects @@ -487,6 +487,9 @@ typedef struct player_s SINT8 lastjawztarget; // (-1 to 15) - Last person you target with jawz, for playing the target switch sfx UINT8 jawztargetdelay; // (0 to 5) - Delay for Jawz target switching, to make it less twitchy + UINT8 confirmInflictor; // Player ID that dealt damage to you + UINT8 confirmInflictorDelay; // Delay before playing the sound + UINT8 trickpanel; // Trick panel state UINT8 tricktime; // Increases while you're tricking. You can't input any trick until it's reached a certain threshold fixed_t trickboostpower; // Save the rough speed multiplier. Used for upwards tricks. diff --git a/src/d_ticcmd.h b/src/d_ticcmd.h index 637f3fc71..4cf1e7c97 100644 --- a/src/d_ticcmd.h +++ b/src/d_ticcmd.h @@ -51,6 +51,9 @@ typedef enum // ticcmd turning bits #define TICCMD_REDUCE 16 +// ticcmd latency mask +#define TICCMD_LATENCYMASK 0xFF + // ticcmd flags #define TICCMD_RECEIVED 1 #define TICCMD_TYPING 2/* chat window or console open */ diff --git a/src/deh_soc.c b/src/deh_soc.c index 525b7e1d2..a656a465a 100644 --- a/src/deh_soc.c +++ b/src/deh_soc.c @@ -49,6 +49,7 @@ // SRB2Kart #include "filesrch.h" // refreshdirmenu +#include "k_follower.h" // Loops through every constant and operation in word and performs its calculations, returning the final value. fixed_t get_number(const char *word) @@ -3435,16 +3436,18 @@ void readfollower(MYFILE *f) s = Z_Malloc(MAXLINELEN, PU_STATIC, NULL); // Ready the default variables for followers. We will overwrite them as we go! We won't set the name or states RIGHT HERE as this is handled down instead. + followers[numfollowers].mode = FOLLOWERMODE_FLOAT; followers[numfollowers].scale = FRACUNIT; - followers[numfollowers].bubblescale = 0; // No bubble by default - followers[numfollowers].atangle = 230; - followers[numfollowers].dist = 32; // changed from 16 to 32 to better account for ogl models - followers[numfollowers].height = 16; - followers[numfollowers].zoffs = 32; - followers[numfollowers].horzlag = 2; - followers[numfollowers].vertlag = 6; + followers[numfollowers].bubblescale = 0; // No bubble by default + followers[numfollowers].atangle = FixedAngle(230 * FRACUNIT); + followers[numfollowers].dist = 32*FRACUNIT; // changed from 16 to 32 to better account for ogl models + followers[numfollowers].height = 16*FRACUNIT; + followers[numfollowers].zoffs = 32*FRACUNIT; + followers[numfollowers].horzlag = 3*FRACUNIT; + followers[numfollowers].vertlag = 6*FRACUNIT; + followers[numfollowers].anglelag = 8*FRACUNIT; followers[numfollowers].bobspeed = TICRATE*2; - followers[numfollowers].bobamp = 4; + followers[numfollowers].bobamp = 4*FRACUNIT; followers[numfollowers].hitconfirmtime = TICRATE; followers[numfollowers].defaultcolor = SKINCOLOR_GREEN; strcpy(followers[numfollowers].icon, "M_NORANK"); @@ -3486,50 +3489,65 @@ void readfollower(MYFILE *f) strcpy(followers[numfollowers].icon, word2); nameset = true; } + else if (fastcmp(word, "MODE")) + { + if (word2) + strupr(word2); + + if (fastcmp(word2, "FLOAT") || fastcmp(word2, "DEFAULT")) + followers[numfollowers].mode = FOLLOWERMODE_FLOAT; + else if (fastcmp(word2, "GROUND")) + followers[numfollowers].mode = FOLLOWERMODE_GROUND; + else + deh_warning("Follower %d: unknown follower mode '%s'", numfollowers, word2); + } else if (fastcmp(word, "DEFAULTCOLOR")) { - followers[numfollowers].defaultcolor = (UINT16)get_number(word2); + followers[numfollowers].defaultcolor = get_number(word2); } - else if (fastcmp(word, "SCALE")) { - followers[numfollowers].scale = get_number(word2); + followers[numfollowers].scale = (fixed_t)get_number(word2); } else if (fastcmp(word, "BUBBLESCALE")) { - followers[numfollowers].bubblescale = get_number(word2); + followers[numfollowers].bubblescale = (fixed_t)get_number(word2); } else if (fastcmp(word, "ATANGLE")) { - followers[numfollowers].atangle = (INT32)atoi(word2); + followers[numfollowers].atangle = (angle_t)(get_number(word2) * ANG1); } else if (fastcmp(word, "HORZLAG")) { - followers[numfollowers].horzlag = (INT32)atoi(word2); + followers[numfollowers].horzlag = (fixed_t)get_number(word2); } else if (fastcmp(word, "VERTLAG")) { - followers[numfollowers].vertlag = (INT32)atoi(word2); + followers[numfollowers].vertlag = (fixed_t)get_number(word2); + } + else if (fastcmp(word, "ANGLELAG")) + { + followers[numfollowers].anglelag = (fixed_t)get_number(word2); } else if (fastcmp(word, "BOBSPEED")) { - followers[numfollowers].bobspeed = (INT32)atoi(word2); + followers[numfollowers].bobspeed = (tic_t)get_number(word2); } else if (fastcmp(word, "BOBAMP")) { - followers[numfollowers].bobamp = (INT32)atoi(word2); + followers[numfollowers].bobamp = (fixed_t)get_number(word2); } else if (fastcmp(word, "ZOFFSET") || (fastcmp(word, "ZOFFS"))) { - followers[numfollowers].zoffs = (INT32)atoi(word2); + followers[numfollowers].zoffs = (fixed_t)get_number(word2); } else if (fastcmp(word, "DISTANCE") || (fastcmp(word, "DIST"))) { - followers[numfollowers].dist = (INT32)atoi(word2); + followers[numfollowers].dist = (fixed_t)get_number(word2); } else if (fastcmp(word, "HEIGHT")) { - followers[numfollowers].height = (INT32)atoi(word2); + followers[numfollowers].height = (fixed_t)get_number(word2); } else if (fastcmp(word, "IDLESTATE")) { @@ -3570,16 +3588,19 @@ void readfollower(MYFILE *f) } else if (fastcmp(word, "HITTIME") || (fastcmp(word, "HITCONFIRMTIME"))) { - followers[numfollowers].hitconfirmtime = (INT32)atoi(word2); + followers[numfollowers].hitconfirmtime = (tic_t)get_number(word2); } else + { deh_warning("Follower %d: unknown word '%s'", numfollowers, word); + } } } while (!myfeof(f)); // finish when the line is empty - if (!nameset) // well this is problematic. + if (!nameset) { - strcpy(followers[numfollowers].name, va("Follower%d", numfollowers)); // this is lazy, so what + // well this is problematic. + strcpy(followers[numfollowers].name, va("Follower%d", numfollowers)); // this is lazy, so what } // set skin name (this is just the follower's name in lowercases): @@ -3589,7 +3610,7 @@ void readfollower(MYFILE *f) // lower testname for skin checks... strlwr(testname); - res = R_FollowerAvailable(testname); + res = K_FollowerAvailable(testname); if (res > -1) // yikes, someone else has stolen our name already { INT32 startlen = strlen(testname); @@ -3612,33 +3633,41 @@ void readfollower(MYFILE *f) // fallbacks for variables // Print a warning if the variable is on a weird value and set it back to the minimum available if that's the case. + + if (followers[numfollowers].mode < FOLLOWERMODE_FLOAT || followers[numfollowers].mode >= FOLLOWERMODE__MAX) + { + followers[numfollowers].mode = FOLLOWERMODE_FLOAT; + deh_warning("Follower '%s': Value for 'mode' should be between %d and %d.", dname, FOLLOWERMODE_FLOAT, FOLLOWERMODE__MAX-1); + } + #define FALLBACK(field, field2, threshold, set) \ -if (followers[numfollowers].field < threshold) \ +if ((signed)followers[numfollowers].field < threshold) \ { \ followers[numfollowers].field = set; \ - deh_warning("Follower '%s': Value for '%s' is too low! Minimum should be %d. Value was overwritten to %d.", dname, field2, set, set); \ + deh_warning("Follower '%s': Value for '%s' is too low! Minimum should be %d. Value was overwritten to %d.", dname, field2, threshold, set); \ } \ FALLBACK(dist, "DIST", 0, 0); FALLBACK(height, "HEIGHT", 1, 1); FALLBACK(zoffs, "ZOFFS", 0, 0); - FALLBACK(horzlag, "HORZLAG", 1, 1); - FALLBACK(vertlag, "VERTLAG", 1, 1); + FALLBACK(horzlag, "HORZLAG", FRACUNIT, FRACUNIT); + FALLBACK(vertlag, "VERTLAG", FRACUNIT, FRACUNIT); + FALLBACK(anglelag, "ANGLELAG", FRACUNIT, FRACUNIT); FALLBACK(bobamp, "BOBAMP", 0, 0); FALLBACK(bobspeed, "BOBSPEED", 0, 0); FALLBACK(hitconfirmtime, "HITCONFIRMTIME", 1, 1); FALLBACK(scale, "SCALE", 1, 1); // No null/negative scale FALLBACK(bubblescale, "BUBBLESCALE", 0, 0); // No negative scale +#undef FALLBACK + // Special case for color I suppose - if (followers[numfollowers].defaultcolor > numskincolors-1) + if (followers[numfollowers].defaultcolor > (unsigned)(numskincolors-1)) { followers[numfollowers].defaultcolor = SKINCOLOR_GREEN; deh_warning("Follower \'%s\': Value for 'color' should be between 1 and %d.\n", dname, numskincolors-1); } -#undef FALLBACK - // also check if we forgot states. If we did, we will set any missing state to the follower's idlestate. // Print a warning in case we don't have a fallback and set the state to S_INVISIBLE (rather than S_NULL) if unavailable. @@ -3659,7 +3688,7 @@ if (!followers[numfollowers].field) \ #undef NOSTATE CONS_Printf("Added follower '%s'\n", dname); - numfollowers++; // add 1 follower + numfollowers++; // add 1 follower Z_Free(s); } diff --git a/src/deh_tables.c b/src/deh_tables.c index c378d7acb..1e0bca769 100644 --- a/src/deh_tables.c +++ b/src/deh_tables.c @@ -368,8 +368,8 @@ const char *const STATE_LIST[] = { // array length left dynamic for sanity testi "S_XDEATHSTATE", "S_RAISESTATE", - // Thok "S_THOK", + "S_SHADOW", // SRB2kart Frames "S_KART_STILL", @@ -3745,6 +3745,9 @@ const char *const STATE_LIST[] = { // array length left dynamic for sanity testi "S_FLAMESHIELDLINE3", "S_FLAMESHIELDFLASH", + // Caked-Up Booty-Sheet Ghost + "S_HYUDORO", + // The legend "S_SINK", "S_SINK_SHIELD", @@ -4493,6 +4496,7 @@ const char *const MOBJTYPE_LIST[] = { // array length left dynamic for sanity t "MT_UNKNOWN", "MT_THOK", // Thok! mobj + "MT_SHADOW", // Linkdraw Shadow (for invisible objects) "MT_PLAYER", "MT_KART_LEFTOVER", "MT_KART_TIRE", @@ -5315,6 +5319,9 @@ const char *const MOBJTYPE_LIST[] = { // array length left dynamic for sanity t "MT_FLAMESHIELDPAPER", "MT_BUBBLESHIELDTRAP", + "MT_HYUDORO", + "MT_HYUDORO_CENTER", + "MT_SINK", // Kitchen Sink Stuff "MT_SINK_SHIELD", "MT_SINKTRAIL", diff --git a/src/doomdef.h b/src/doomdef.h index 070544900..fe29374f3 100644 --- a/src/doomdef.h +++ b/src/doomdef.h @@ -207,7 +207,7 @@ extern char logfilename[1024]; #define MAXSPLITSCREENPLAYERS 4 // Max number of players on a single computer #define MAXGAMEPADS (MAXSPLITSCREENPLAYERS * 2) // Number of gamepads we'll be allowing -#define MAXSKINS 128 +#define MAXSKINS UINT8_MAX #define COLORRAMPSIZE 16 #define MAXCOLORNAME 32 diff --git a/src/doomstat.h b/src/doomstat.h index 581803088..42760d3bc 100644 --- a/src/doomstat.h +++ b/src/doomstat.h @@ -684,7 +684,6 @@ extern boolean comeback; extern SINT8 battlewanted[4]; extern tic_t wantedcalcdelay; extern tic_t indirectitemcooldown; -extern tic_t hyubgone; extern tic_t mapreset; extern boolean thwompsactive; extern UINT8 lastLowestLap; diff --git a/src/f_finale.c b/src/f_finale.c index 40665a15a..77227550b 100644 --- a/src/f_finale.c +++ b/src/f_finale.c @@ -1993,6 +1993,38 @@ void F_TitleScreenDrawer(void) V_DrawFixedPatch(0, 0, FRACUNIT, 0, kts_bumper, NULL); V_DrawFixedPatch(0, 0, FRACUNIT, 0, kts_copyright, NULL); + + // An adapted thing from old menus - most games have version info on the title screen now... + { + INT32 texty = vid.height - 10*vid.dupy; +#define addtext(f, str) {\ + V_DrawThinString(vid.dupx, texty, V_NOSCALESTART|f, str);\ + texty -= 10*vid.dupy;\ +} + if (customversionstring[0] != '\0') + { + addtext(V_ALLOWLOWERCASE, customversionstring); + addtext(0, "Mod version:"); + } + else + { +// Development -- show revision / branch info +#if defined(TESTERS) + addtext(V_ALLOWLOWERCASE|V_SKYMAP, "Tester client"); + addtext(V_ALLOWLOWERCASE|V_TRANSLUCENT, va("%s", compdate)); +#elif defined(HOSTTESTERS) + addtext(V_ALLOWLOWERCASE|V_REDMAP, "Netgame host for testers"); + addtext(V_ALLOWLOWERCASE|V_TRANSLUCENT, va("%s", compdate)); +#elif defined(DEVELOP) + addtext(V_ALLOWLOWERCASE|V_TRANSLUCENT, comprevision); + addtext(V_ALLOWLOWERCASE|V_TRANSLUCENT, compbranch); +#else // Regular build + addtext(V_ALLOWLOWERCASE|V_TRANSLUCENT, va("%s", VERSIONSTRING)); +#endif + } +#undef addtext + } + break; } diff --git a/src/g_demo.c b/src/g_demo.c index bbcf7cc46..6ed353906 100644 --- a/src/g_demo.c +++ b/src/g_demo.c @@ -51,6 +51,7 @@ #include "k_respawn.h" #include "k_bot.h" #include "k_color.h" +#include "k_follower.h" static CV_PossibleValue_t recordmultiplayerdemos_cons_t[] = {{0, "Disabled"}, {1, "Manual Save"}, {2, "Auto Save"}, {0, NULL}}; consvar_t cv_recordmultiplayerdemos = CVAR_INIT ("netdemo_record", "Manual Save", CV_SAVE, recordmultiplayerdemos_cons_t, NULL); @@ -300,7 +301,7 @@ void G_ReadDemoExtraData(void) // Set our follower M_Memcpy(name, demo_p, 16); demo_p += 16; - SetPlayerFollower(p, name); + K_SetFollowerByName(p, name); // Follower's color M_Memcpy(name, demo_p, 16); @@ -3057,7 +3058,7 @@ void G_DoPlayDemo(char *defdemoname) // Follower M_Memcpy(follower, demo_p, 16); demo_p += 16; - SetPlayerFollower(p, follower); + K_SetFollowerByName(p, follower); // Follower colour M_Memcpy(color, demo_p, 16); diff --git a/src/g_game.c b/src/g_game.c index c5aac6a78..ab5d0a84a 100644 --- a/src/g_game.c +++ b/src/g_game.c @@ -313,7 +313,6 @@ SINT8 pickedvote; // What vote the host rolls SINT8 battlewanted[4]; // WANTED players in battle, worth x2 points tic_t wantedcalcdelay; // Time before it recalculates WANTED tic_t indirectitemcooldown; // Cooldown before any more Shrink, SPB, or any other item that works indirectly is awarded -tic_t hyubgone; // Cooldown before hyudoro is allowed to be rerolled tic_t mapreset; // Map reset delay when enough players have joined an empty game boolean thwompsactive; // Thwomps activate on lap 2 UINT8 lastLowestLap; // Last lowest lap, for activating race lap executors @@ -887,6 +886,78 @@ static void G_HandleAxisDeadZone(UINT8 splitnum, joystickvector2_t *joystickvect INT32 localaiming[MAXSPLITSCREENPLAYERS]; angle_t localangle[MAXSPLITSCREENPLAYERS]; +INT32 localsteering[MAXSPLITSCREENPLAYERS]; +INT32 localdelta[MAXSPLITSCREENPLAYERS]; +INT32 localstoredeltas[MAXSPLITSCREENPLAYERS][TICCMD_LATENCYMASK + 1]; +UINT8 localtic; + +void G_ResetAnglePrediction(player_t *player) +{ + UINT16 i, j; + + for (i = 0; i <= r_splitscreen; i++) + { + if (&players[displayplayers[i]] == player) + { + localdelta[i] = 0; + for (j = 0; j < TICCMD_LATENCYMASK; j++) + { + localstoredeltas[i][j] = 0; + } + break; + } + } +} + +// Turning was removed from G_BuildTiccmd to prevent easy client hacking. +// This brings back the camera prediction that was lost. +static void G_DoAnglePrediction(ticcmd_t *cmd, INT32 realtics, UINT8 ssplayer, player_t *player) +{ + angle_t angleChange = 0; + angle_t destAngle = player->angleturn; + angle_t diff = 0; + + localtic = cmd->latency; + + if (player->pflags & PF_DRIFTEND) + { + // Otherwise, your angle slingshots off to the side violently... + G_ResetAnglePrediction(player); + } + else + { + while (realtics > 0) + { + localsteering[ssplayer - 1] = K_UpdateSteeringValue(localsteering[ssplayer - 1], cmd->turning); + angleChange = K_GetKartTurnValue(player, localsteering[ssplayer - 1]) << TICCMD_REDUCE; + + // Store the angle we applied to this tic, so we can revert it later. + // If we trust the camera to do all of the work, then it can get out of sync fast. + localstoredeltas[ssplayer - 1][cmd->latency] += angleChange; + localdelta[ssplayer - 1] += angleChange; + + realtics--; + } + } + + // We COULD set it to destAngle directly... + // but this causes incredible jittering when the prediction turns out to be wrong. So we ease into it. + // Slight increased camera lag in all scenarios > Mostly lagless camera but with jittering + destAngle = player->angleturn + localdelta[ssplayer - 1]; + diff = destAngle - localangle[ssplayer - 1]; + + if (diff > ANGLE_180) + { + diff = InvAngle(InvAngle(diff) / 2); + } + else + { + diff /= 2; + } + + localangle[ssplayer - 1] += diff; +} + void G_BuildTiccmd(ticcmd_t *cmd, INT32 realtics, UINT8 ssplayer) { const UINT8 forplayer = ssplayer-1; @@ -900,8 +971,6 @@ void G_BuildTiccmd(ticcmd_t *cmd, INT32 realtics, UINT8 ssplayer) //boolean *rd = &resetdown[forplayer]; //const boolean mouseaiming = player->spectator; - (void)realtics; - if (demo.playback) return; // Is there any reason this can't just be I_BaseTiccmd? @@ -1104,7 +1173,7 @@ aftercmdinput: // Send leveltime when this tic was generated to the server for control lag calculations. // Only do this when in a level. Also do this after the hook, so that it can't overwrite this. - cmd->latency = (leveltime & 0xFF); + cmd->latency = (leveltime & TICCMD_LATENCYMASK); } if (cmd->forwardmove > MAXPLMOVE) @@ -1122,6 +1191,8 @@ aftercmdinput: else if (cmd->throwdir < -KART_FULLTURN) cmd->throwdir = -KART_FULLTURN; + G_DoAnglePrediction(cmd, realtics, ssplayer, player); + // Reset away view if a command is given. if ((cmd->forwardmove || cmd->buttons) && !r_splitscreen && displayplayers[0] != consoleplayer && ssplayer == 1) @@ -1877,7 +1948,7 @@ void G_Ticker(boolean run) else { //@TODO add a cvar to allow setting this max - cmd->latency = min(((leveltime & 0xFF) - cmd->latency) & 0xFF, MAXPREDICTTICS-1); + cmd->latency = min(((leveltime & TICCMD_LATENCYMASK) - cmd->latency) & TICCMD_LATENCYMASK, MAXPREDICTTICS-1); } } } diff --git a/src/g_game.h b/src/g_game.h index b0f0f972e..a6406932a 100644 --- a/src/g_game.h +++ b/src/g_game.h @@ -83,6 +83,7 @@ extern consvar_t cv_resume; // build an internal map name MAPxx from map number const char *G_BuildMapName(INT32 map); +void G_ResetAnglePrediction(player_t *player); void G_BuildTiccmd(ticcmd_t *cmd, INT32 realtics, UINT8 ssplayer); // copy ticcmd_t to and fro the normal way @@ -96,6 +97,10 @@ INT16 G_SoftwareClipAimingPitch(INT32 *aiming); extern angle_t localangle[MAXSPLITSCREENPLAYERS]; extern INT32 localaiming[MAXSPLITSCREENPLAYERS]; // should be an angle_t but signed +extern INT32 localsteering[MAXSPLITSCREENPLAYERS]; +extern INT32 localdelta[MAXSPLITSCREENPLAYERS]; +extern INT32 localstoredeltas[MAXSPLITSCREENPLAYERS][TICCMD_LATENCYMASK + 1]; +extern UINT8 localtic; INT32 G_PlayerInputAnalog(UINT8 p, INT32 gc, UINT8 menuPlayers); boolean G_PlayerInputDown(UINT8 p, INT32 gc, UINT8 menuPlayers); diff --git a/src/info.c b/src/info.c index 3cb1f8f77..754530837 100644 --- a/src/info.c +++ b/src/info.c @@ -29,6 +29,7 @@ char sprnames[NUMSPRITES + 1][5] = { "NULL", // invisible object + "NONE", // invisible but still rendered "UNKN", "THOK", // Thok! mobj @@ -570,6 +571,7 @@ char sprnames[NUMSPRITES + 1][5] = "FLMP", // Flame Shield paper sprites "FLML", // Flame Shield speed lines "FLMF", // Flame Shield flash + "HYUU", // Hyudoro "SINK", // Kitchen Sink "SITR", // Kitchen Sink Trail "KBLN", // Battle Mode Bumper @@ -856,6 +858,7 @@ state_t states[NUMSTATES] = {SPR_UNKN, FF_FULLBRIGHT, -1, {A_InfoState}, 6, 0, S_NULL}, // S_RAISESTATE {SPR_THOK, FF_TRANS50, 8, {NULL}, 0, 0, S_NULL}, // S_THOK + {SPR_NONE, 0, -1, {NULL}, 0, 0, S_NULL}, // S_SHADOW // Player {SPR_PLAY, SPR2_STIN, 1, {NULL}, 0, 0, S_KART_STILL}, // S_KART_STILL @@ -4300,6 +4303,8 @@ state_t states[NUMSTATES] = {SPR_FLML, FF_FULLBRIGHT|FF_PAPERSPRITE|FF_ANIMATE|14, 7, {NULL}, 6, 1, S_NULL}, // S_FLAMESHIELDLINE3 {SPR_FLMF, FF_FULLBRIGHT, 2, {NULL}, 0, 0, S_NULL}, // S_FLAMESHIELDFLASH + {SPR_HYUU, FF_FULLBRIGHT, -1, {NULL}, 0, 0, S_NULL}, // S_HYUDORO + {SPR_SINK, 0, 1, {A_SmokeTrailer}, MT_SINKTRAIL, 0, S_SINK}, // S_SINK {SPR_SINK, 0|FF_TRANS80|FF_FULLBRIGHT, -1, {NULL}, 0, 0, S_SINK_SHIELD}, // S_SINK_SHIELD {SPR_SITR, 0, 1, {NULL}, 0, 0, S_SINKTRAIL2}, // S_SINKTRAIL1 @@ -5154,6 +5159,33 @@ mobjinfo_t mobjinfo[NUMMOBJTYPES] = S_NULL // raisestate }, + { // MT_SHADOW + -1, // doomednum + S_SHADOW, // spawnstate + 1000, // spawnhealth + S_NULL, // seestate + sfx_None, // seesound + 8, // 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 + 8, // speed + 32*FRACUNIT, // radius + 64*FRACUNIT, // height + -1, // display offset + 16, // mass + 0, // damage + sfx_None, // activesound + MF_NOBLOCKMAP|MF_NOCLIP|MF_NOCLIPHEIGHT|MF_NOGRAVITY|MF_SCENERY|MF_DONTENCOREMAP, // flags + S_NULL // raisestate + }, + { // MT_PLAYER -1, // doomednum S_KART_STILL, // spawnstate @@ -23881,6 +23913,60 @@ mobjinfo_t mobjinfo[NUMMOBJTYPES] = S_NULL // raisestate }, + { // MT_HYUDORO + -1, // doomednum + S_HYUDORO, // spawnstate + 1000, // spawnhealth + S_NULL, // seestate + sfx_None, // seesound + 8, // 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 + 0, // speed + 32*FRACUNIT, // radius + 24*FRACUNIT, // height + 0, // display offset + 0, // mass + 0, // damage + sfx_None, // activesound + MF_SPECIAL|MF_NOCLIP|MF_NOGRAVITY|MF_DONTENCOREMAP, // flags + S_NULL // raisestate + }, + + { // MT_HYUDORO_CENTER + -1, // doomednum + S_INVISIBLE, // spawnstate + 1000, // spawnhealth + S_NULL, // seestate + sfx_None, // seesound + 8, // 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 + 0, // speed + 64*FRACUNIT, // radius + 32*FRACUNIT, // height + 0, // display offset + 0, // mass + 0, // damage + sfx_None, // activesound + MF_NOGRAVITY|MF_DONTENCOREMAP, // flags + S_NULL // raisestate + }, + { // MT_SINK -1, // doomednum S_SINK, // spawnstate diff --git a/src/info.h b/src/info.h index 8520b89e3..54aa9eaec 100644 --- a/src/info.h +++ b/src/info.h @@ -575,6 +575,7 @@ extern boolean actionsoverridden[NUMACTIONS]; typedef enum sprite { SPR_NULL, // invisible object + SPR_NONE, // invisible but still rendered SPR_UNKN, SPR_THOK, // Thok! mobj @@ -1116,6 +1117,7 @@ typedef enum sprite SPR_FLMP, // Flame Shield paper sprites SPR_FLML, // Flame Shield speed lines SPR_FLMF, // Flame Shield flash + SPR_HYUU, // Hyudoro SPR_SINK, // Kitchen Sink SPR_SITR, // Kitchen Sink Trail SPR_KBLN, // Battle Mode Bumper @@ -1355,8 +1357,8 @@ typedef enum state S_XDEATHSTATE, S_RAISESTATE, - // Thok S_THOK, + S_SHADOW, S_KART_STILL, S_KART_STILL_L, @@ -4731,6 +4733,9 @@ typedef enum state S_FLAMESHIELDLINE3, S_FLAMESHIELDFLASH, + // Caked-Up Booty-Sheet Ghost + S_HYUDORO, + // The legend S_SINK, S_SINK_SHIELD, @@ -5516,6 +5521,7 @@ typedef enum mobj_type MT_UNKNOWN, MT_THOK, // Thok! mobj + MT_SHADOW, // Linkdraw Shadow (for invisible objects) MT_PLAYER, MT_KART_LEFTOVER, MT_KART_TIRE, @@ -6338,6 +6344,9 @@ typedef enum mobj_type MT_FLAMESHIELDPAPER, MT_BUBBLESHIELDTRAP, + MT_HYUDORO, + MT_HYUDORO_CENTER, + MT_SINK, // Kitchen Sink Stuff MT_SINK_SHIELD, MT_SINKTRAIL, diff --git a/src/k_battle.c b/src/k_battle.c index e64fc5a9a..14ecfabf5 100644 --- a/src/k_battle.c +++ b/src/k_battle.c @@ -672,12 +672,11 @@ void K_RunBattleOvertime(void) if (battleovertime.radius > 0) { - const fixed_t pi = (22 * FRACUNIT) / 7; // loose approximation, this doesn't need to be incredibly precise const INT32 orbs = 32; const angle_t angoff = ANGLE_MAX / orbs; const UINT8 spriteSpacing = 128; - fixed_t circumference = FixedMul(pi, battleovertime.radius * 2); + fixed_t circumference = FixedMul(M_PI_FIXED, battleovertime.radius * 2); fixed_t scale = max(circumference / spriteSpacing / orbs, mapobjectscale); fixed_t size = FixedMul(mobjinfo[MT_OVERTIME_PARTICLE].radius, scale); diff --git a/src/k_botitem.c b/src/k_botitem.c index 465c45adb..48ed6283c 100644 --- a/src/k_botitem.c +++ b/src/k_botitem.c @@ -1308,7 +1308,7 @@ void K_BotItemUsage(player_t *player, ticcmd_t *cmd, INT16 turnamt) K_BotItemGenericOrbitShield(player, cmd); } else if (player->position != 1) // Hold onto orbiting items when in 1st :) - /* FALL-THRU */ + /* FALLTHRU */ case KITEM_BALLHOG: { K_BotItemOrbinaut(player, cmd); diff --git a/src/k_botsearch.c b/src/k_botsearch.c index 07935d79c..b62b55852 100644 --- a/src/k_botsearch.c +++ b/src/k_botsearch.c @@ -51,7 +51,7 @@ struct globalsmuggle } globalsmuggle; /*-------------------------------------------------- - static boolean K_FindEggboxes(mobj_t *thing) + static BlockItReturn_t K_FindEggboxes(mobj_t *thing) Blockmap search function. Increments the random items and egg boxes counters. @@ -60,27 +60,27 @@ struct globalsmuggle thing - Object passed in from iteration. Return:- - true continues searching, false ends the search early. + BlockItReturn_t enum, see its definition for more information. --------------------------------------------------*/ -static boolean K_FindEggboxes(mobj_t *thing) +static BlockItReturn_t K_FindEggboxes(mobj_t *thing) { fixed_t dist; if (thing->type != MT_RANDOMITEM && thing->type != MT_EGGMANITEM) { - return true; + return BMIT_CONTINUE; } if (!thing->health) { - return true; + return BMIT_CONTINUE; } dist = P_AproxDistance(thing->x - globalsmuggle.eggboxx, thing->y - globalsmuggle.eggboxy); if (dist > globalsmuggle.distancetocheck) { - return true; + return BMIT_CONTINUE; } if (thing->type == MT_RANDOMITEM) @@ -92,7 +92,7 @@ static boolean K_FindEggboxes(mobj_t *thing) globalsmuggle.eggboxes++; } - return true; + return BMIT_CONTINUE; } /*-------------------------------------------------- @@ -347,7 +347,7 @@ static boolean K_PlayerAttackSteer(mobj_t *thing, UINT8 side, UINT8 weight, bool } /*-------------------------------------------------- - static boolean K_FindObjectsForNudging(mobj_t *thing) + static BlockItReturn_t K_FindObjectsForNudging(mobj_t *thing) Blockmap search function. Finds objects around the bot to steer towards/away from. @@ -356,9 +356,9 @@ static boolean K_PlayerAttackSteer(mobj_t *thing, UINT8 side, UINT8 weight, bool thing - Object passed in from iteration. Return:- - true continues searching, false ends the search early. + BlockItReturn_t enum, see its definition for more information. --------------------------------------------------*/ -static boolean K_FindObjectsForNudging(mobj_t *thing) +static BlockItReturn_t K_FindObjectsForNudging(mobj_t *thing) { INT16 anglediff; fixed_t fulldist; @@ -367,29 +367,29 @@ static boolean K_FindObjectsForNudging(mobj_t *thing) if (!globalsmuggle.botmo || P_MobjWasRemoved(globalsmuggle.botmo) || !globalsmuggle.botmo->player) { - return false; + return BMIT_ABORT; } if (thing->health <= 0) { - return true; + return BMIT_CONTINUE; } if (globalsmuggle.botmo == thing) { - return true; + return BMIT_CONTINUE; } fulldist = R_PointToDist2(globalsmuggle.botmo->x, globalsmuggle.botmo->y, thing->x, thing->y) - thing->radius; if (fulldist > globalsmuggle.distancetocheck) { - return true; + return BMIT_CONTINUE; } if (P_CheckSight(globalsmuggle.botmo, thing) == false) { - return true; + return BMIT_CONTINUE; } predictangle = R_PointToAngle2(globalsmuggle.botmo->x, globalsmuggle.botmo->y, globalsmuggle.predict->x, globalsmuggle.predict->y); @@ -607,7 +607,7 @@ static boolean K_FindObjectsForNudging(mobj_t *thing) break; } - return true; + return BMIT_CONTINUE; } /*-------------------------------------------------- @@ -776,7 +776,7 @@ void K_NudgePredictionTowardsObjects(botprediction_t *predict, player_t *player) } /*-------------------------------------------------- - static boolean K_FindPlayersToBully(mobj_t *thing) + static BlockItReturn_t K_FindPlayersToBully(mobj_t *thing) Blockmap search function. Finds players around the bot to bump. @@ -785,9 +785,9 @@ void K_NudgePredictionTowardsObjects(botprediction_t *predict, player_t *player) thing - Object passed in from iteration. Return:- - true continues searching, false ends the search early. + BlockItReturn_t enum, see its definition for more information. --------------------------------------------------*/ -static boolean K_FindPlayersToBully(mobj_t *thing) +static BlockItReturn_t K_FindPlayersToBully(mobj_t *thing) { INT16 anglediff; fixed_t fulldist; @@ -796,34 +796,34 @@ static boolean K_FindPlayersToBully(mobj_t *thing) if (!globalsmuggle.botmo || P_MobjWasRemoved(globalsmuggle.botmo) || !globalsmuggle.botmo->player) { - return false; + return BMIT_ABORT; } if (thing->health <= 0) { - return true; + return BMIT_CONTINUE; } if (!thing->player) { - return true; + return BMIT_CONTINUE; } if (globalsmuggle.botmo == thing) { - return true; + return BMIT_CONTINUE; } fulldist = R_PointToDist2(globalsmuggle.botmo->x, globalsmuggle.botmo->y, thing->x, thing->y) - thing->radius; if (fulldist > globalsmuggle.distancetocheck) { - return true; + return BMIT_CONTINUE; } if (P_CheckSight(globalsmuggle.botmo, thing) == false) { - return true; + return BMIT_CONTINUE; } ourangle = globalsmuggle.botmo->angle; @@ -860,7 +860,7 @@ static boolean K_FindPlayersToBully(mobj_t *thing) globalsmuggle.annoymo = thing; } - return true; + return BMIT_CONTINUE; } /*-------------------------------------------------- diff --git a/src/k_collide.c b/src/k_collide.c index 92c4bd7fd..306c01dd8 100644 --- a/src/k_collide.c +++ b/src/k_collide.c @@ -323,26 +323,26 @@ static inline boolean PIT_SSMineChecks(mobj_t *thing) return false; } -static inline boolean PIT_SSMineSearch(mobj_t *thing) +static inline BlockItReturn_t PIT_SSMineSearch(mobj_t *thing) { if (grenade == NULL || P_MobjWasRemoved(grenade)) - return false; // There's the possibility these can chain react onto themselves after they've already died if there are enough all in one spot + return BMIT_ABORT; // There's the possibility these can chain react onto themselves after they've already died if there are enough all in one spot if (grenade->flags2 & MF2_DEBRIS) // don't explode twice - return false; + return BMIT_ABORT; if (thing->type != MT_PLAYER) // Don't explode for anything but an actual player. - return true; + return BMIT_CONTINUE; if (thing == grenade->target && grenade->threshold != 0) // Don't blow up at your owner instantly. - return true; + return BMIT_CONTINUE; if (PIT_SSMineChecks(thing) == true) - return true; + return BMIT_CONTINUE; // Explode! P_SetMobjState(grenade, grenade->info->deathstate); - return false; + return BMIT_ABORT; } void K_DoMineSearch(mobj_t *actor, fixed_t size) @@ -364,21 +364,21 @@ void K_DoMineSearch(mobj_t *actor, fixed_t size) P_BlockThingsIterator(bx, by, PIT_SSMineSearch); } -static inline boolean PIT_SSMineExplode(mobj_t *thing) +static inline BlockItReturn_t PIT_SSMineExplode(mobj_t *thing) { if (grenade == NULL || P_MobjWasRemoved(grenade)) - return false; // There's the possibility these can chain react onto themselves after they've already died if there are enough all in one spot + return BMIT_ABORT; // There's the possibility these can chain react onto themselves after they've already died if there are enough all in one spot #if 0 if (grenade->flags2 & MF2_DEBRIS) // don't explode twice - return false; + return BMIT_ABORT; #endif if (PIT_SSMineChecks(thing) == true) - return true; + return BMIT_CONTINUE; P_DamageMobj(thing, grenade, grenade->target, 1, (explodespin ? DMG_NORMAL : DMG_EXPLODE)); - return true; + return BMIT_CONTINUE; } void K_MineExplodeAttack(mobj_t *actor, fixed_t size, boolean spin) @@ -667,60 +667,54 @@ boolean K_DropTargetCollide(mobj_t *t1, mobj_t *t2) static mobj_t *lightningSource; static fixed_t lightningDist; -static inline boolean PIT_LightningShieldAttack(mobj_t *thing) +static inline BlockItReturn_t PIT_LightningShieldAttack(mobj_t *thing) { if (lightningSource == NULL || P_MobjWasRemoved(lightningSource)) { // Invalid? - return false; + return BMIT_ABORT; } if (thing == lightningSource) { // Don't explode yourself!! - return true; + return BMIT_CONTINUE; } if (thing->health <= 0) { // Dead - return true; + return BMIT_CONTINUE; } if (!(thing->flags & MF_SHOOTABLE) || (thing->flags & MF_SCENERY)) { // Not shootable - return true; + return BMIT_CONTINUE; } if (thing->player && thing->player->spectator) { // Spectator - return true; - } - - if ((lightningSource->eflags & MFE_VERTICALFLIP) - ? (thing->z > lightningSource->z + lightningSource->height) - : (thing->z + thing->height < lightningSource->z)) - { - // Underneath - return true; + return BMIT_CONTINUE; } if (P_AproxDistance(thing->x - lightningSource->x, thing->y - lightningSource->y) > lightningDist + thing->radius) { // Too far away - return true; + return BMIT_CONTINUE; } +#if 0 if (P_CheckSight(lightningSource, thing) == false) { // Not in sight - return true; + return BMIT_CONTINUE; } +#endif P_DamageMobj(thing, lightningSource, lightningSource, 1, DMG_NORMAL|DMG_CANTHURTSELF|DMG_WOMBO); - return true; + return BMIT_CONTINUE; } void K_LightningShieldAttack(mobj_t *actor, fixed_t size) diff --git a/src/k_follower.c b/src/k_follower.c new file mode 100644 index 000000000..d9a402e11 --- /dev/null +++ b/src/k_follower.c @@ -0,0 +1,567 @@ + +#include "k_follower.h" + +#include "k_kart.h" + +#include "doomtype.h" +#include "doomdef.h" +#include "g_game.h" +#include "g_demo.h" +#include "r_main.h" +#include "r_skins.h" +#include "p_local.h" +#include "p_mobj.h" + +INT32 numfollowers = 0; +follower_t followers[MAXSKINS]; + +CV_PossibleValue_t Followercolor_cons_t[MAXSKINCOLORS+3]; // +3 to account for "Match", "Opposite" & NULL + +/*-------------------------------------------------- + INT32 K_FollowerAvailable(const char *name) + + See header file for description. +--------------------------------------------------*/ +INT32 K_FollowerAvailable(const char *name) +{ + INT32 i; + + for (i = 0; i < numfollowers; i++) + { + if (stricmp(followers[i].skinname, name) == 0) + return i; + } + + return -1; +} + +/*-------------------------------------------------- + boolean K_SetFollowerByName(INT32 playernum, const char *skinname) + + See header file for description. +--------------------------------------------------*/ +boolean K_SetFollowerByName(INT32 playernum, const char *skinname) +{ + INT32 i; + player_t *player = &players[playernum]; + + if (stricmp("None", skinname) == 0) + { + K_SetFollowerByNum(playernum, -1); // reminder that -1 is nothing + return true; + } + + for (i = 0; i < numfollowers; i++) + { + // search in the skin list + if (stricmp(followers[i].skinname, skinname) == 0) + { + K_SetFollowerByNum(playernum, i); + return true; + } + } + + if (P_IsLocalPlayer(player)) + { + CONS_Alert(CONS_WARNING, M_GetText("Follower '%s' not found.\n"), skinname); + } + else if (server || IsPlayerAdmin(consoleplayer)) + { + CONS_Alert(CONS_WARNING, M_GetText("Player %d (%s) follower '%s' not found\n"), playernum, player_names[playernum], skinname); + } + + K_SetFollowerByNum(playernum, -1); // reminder that -1 is nothing + return false; +} + +/*-------------------------------------------------- + void K_SetFollowerByNum(INT32 playernum, INT32 skinnum) + + See header file for description. +--------------------------------------------------*/ +void K_SetFollowerByNum(INT32 playernum, INT32 skinnum) +{ + player_t *player = &players[playernum]; + mobj_t *bub; + mobj_t *tmp; + + player->followerready = true; // we are ready to perform follower related actions in the player thinker, now. + + if (skinnum >= -1 && skinnum <= numfollowers) // Make sure it exists! + { + /* + We don't spawn the follower here since it'll be easier to handle all of it in the Player thinker itself. + However, we will despawn it right here if there's any to make it easy for the player thinker to replace it or delete it. + */ + + if (player->follower && skinnum != player->followerskin) // this is also called when we change colour so don't respawn the follower unless we changed skins + { + // Remove follower's possible hnext list (bubble) + bub = player->follower->hnext; + + while (bub && !P_MobjWasRemoved(bub)) + { + tmp = bub->hnext; + P_RemoveMobj(bub); + bub = tmp; + } + + P_RemoveMobj(player->follower); + P_SetTarget(&player->follower, NULL); + } + + player->followerskin = skinnum; + + // for replays: We have changed our follower mid-game; let the game know so it can do the same in the replay! + demo_extradata[playernum] |= DXD_FOLLOWER; + return; + } + + if (P_IsLocalPlayer(player)) + { + CONS_Alert(CONS_WARNING, M_GetText("Follower %d not found\n"), skinnum); + } + else if (server || IsPlayerAdmin(consoleplayer)) + { + CONS_Alert(CONS_WARNING, "Player %d (%s) follower %d not found\n", playernum, player_names[playernum], skinnum); + } + + K_SetFollowerByNum(playernum, -1); // Not found, then set -1 (nothing) as our follower. +} + + +/*-------------------------------------------------- + static void K_SetFollowerState(mobj_t *f, statenum_t state) + + Sets a follower object's state. + This is done as a separate function to prevent running follower actions. + + Input Arguments:- + f - The follower's mobj_t. + state - The state to set. + + Return:- + None +--------------------------------------------------*/ +static void K_SetFollowerState(mobj_t *f, statenum_t state) +{ + if (f == NULL || P_MobjWasRemoved(f) == true) + { + // safety net + return; + } + + // No, do NOT set the follower to S_NULL. Set it to S_INVISIBLE. + if (state == S_NULL) + { + state = S_INVISIBLE; + f->threshold = 1; // Threshold = 1 means stop doing anything related to setting states, so that we don't get out of S_INVISIBLE + } + + // extravalue2 stores the last "first state" we used. + // because states default to idlestates, if we use an animation that uses an "ongoing" state line, don't reset it! + // this prevents it from looking very dumb + if (state == (statenum_t)f->extravalue2) + { + return; + } + + // we will save the state into extravalue2. + f->extravalue2 = state; + + P_SetMobjStateNF(f, state); + if (f->state->tics > 0) + { + f->tics++; + } +} + +/*-------------------------------------------------- + UINT16 K_GetEffectiveFollowerColor(UINT16 followercolor, UINT16 playercolor) + + See header file for description. +--------------------------------------------------*/ +UINT16 K_GetEffectiveFollowerColor(UINT16 followercolor, UINT16 playercolor) +{ + if (followercolor < numskincolors) // bog standard + return followercolor; + + if (followercolor == FOLLOWERCOLOR_OPPOSITE) // "Opposite" + return skincolors[playercolor].invcolor; + + //if (followercolor == FOLLOWERCOLOR_MATCH) -- "Match" + return playercolor; +} + +/*-------------------------------------------------- + void K_HandleFollower(player_t *player) + + See header file for description. +--------------------------------------------------*/ +void K_HandleFollower(player_t *player) +{ + follower_t fl; + angle_t an; + fixed_t zoffs; + fixed_t ourheight; + fixed_t sx, sy, sz, deltaz; + fixed_t fh = INT32_MIN, ch = INT32_MAX; + UINT16 color; + + fixed_t bubble; // bubble scale (0 if no bubble) + mobj_t *bmobj; // temp bubble mobj + + angle_t destAngle; + INT32 angleDiff; + + if (player->followerready == false) + { + // we aren't ready to perform anything follower related yet. + return; + } + + // How about making sure our follower exists and is added before trying to spawn it n' all? + if (player->followerskin >= numfollowers || player->followerskin < -1) + { + //CONS_Printf("Follower skin invlaid. Setting to -1.\n"); + player->followerskin = -1; + return; + } + + // don't do anything if we can't have a follower to begin with. + // (It gets removed under those conditions) + if (player->spectator) + { + return; + } + + if (player->followerskin < 0) + { + return; + } + + // Before we do anything, let's be sure of where we're supposed to be + fl = followers[player->followerskin]; + + an = player->mo->angle + fl.atangle; + zoffs = fl.zoffs; + bubble = fl.bubblescale; // 0 if no bubble to spawn. + + // do you like angle maths? I certainly don't... + sx = player->mo->x + player->mo->momx + FixedMul(FixedMul(player->mo->scale, fl.dist), FINECOSINE((an) >> ANGLETOFINESHIFT)); + sy = player->mo->y + player->mo->momy + FixedMul(FixedMul(player->mo->scale, fl.dist), FINESINE((an) >> ANGLETOFINESHIFT)); + + // interp info helps with stretchy fix + deltaz = (player->mo->z - player->mo->old_z); + + // for the z coordinate, don't be a doof like Steel and forget that MFE_VERTICALFLIP exists :P + sz = player->mo->z + player->mo->momz + FixedMul(player->mo->scale, zoffs * P_MobjFlip(player->mo)); + ourheight = FixedMul(fl.height, player->mo->scale); + if (player->mo->eflags & MFE_VERTICALFLIP) + { + sz += ourheight; + } + + fh = player->mo->floorz; + ch = player->mo->ceilingz - ourheight; + + switch (fl.mode) + { + case FOLLOWERMODE_GROUND: + { + if (player->mo->eflags & MFE_VERTICALFLIP) + { + sz = ch; + } + else + { + sz = fh; + } + break; + } + case FOLLOWERMODE_FLOAT: + default: + { + // finally, add a cool floating effect to the z height. + // not stolen from k_kart I swear!! + fixed_t sine = FixedMul(fl.bobamp, FINESINE(((FixedMul(4 * M_TAU_FIXED, fl.bobspeed) * leveltime) >> ANGLETOFINESHIFT) & FINEMASK)); + sz += FixedMul(player->mo->scale, sine) * P_MobjFlip(player->mo); + break; + } + } + + // Set follower colour + color = K_GetEffectiveFollowerColor(player->followercolor, player->skincolor); + + if (player->follower == NULL) // follower doesn't exist / isn't valid + { + //CONS_Printf("Spawning follower...\n"); + + // so let's spawn one! + P_SetTarget(&player->follower, P_SpawnMobj(sx, sy, sz, MT_FOLLOWER)); + K_SetFollowerState(player->follower, fl.idlestate); + P_SetTarget(&player->follower->target, player->mo); // we need that to know when we need to disappear + P_InitAngle(player->follower, player->mo->angle); + + // This is safe to only spawn it here, the follower is removed then respawned when switched. + if (bubble) + { + bmobj = P_SpawnMobj(player->follower->x, player->follower->y, player->follower->z, MT_FOLLOWERBUBBLE_FRONT); + P_SetTarget(&player->follower->hnext, bmobj); + P_SetTarget(&bmobj->target, player->follower); // Used to know if we have to despawn at some point. + + bmobj = P_SpawnMobj(player->follower->x, player->follower->y, player->follower->z, MT_FOLLOWERBUBBLE_BACK); + P_SetTarget(&player->follower->hnext->hnext, bmobj); // this seems absolutely stupid, I know, but this will make updating the momentums/flags of these a bit easier. + P_SetTarget(&bmobj->target, player->follower); // Ditto + } + + player->follower->extravalue1 = 0; // extravalue1 is used to know what "state set" to use. + /* + 0 = idle + 1 = forwards + 2 = hurt + 3 = win + 4 = lose + 5 = hitconfirm (< this one uses ->movecount as timer to know when to end, and goes back to normal states afterwards, unless hurt) + */ + } + else // follower exists, woo! + { + // Safety net (2) + + if (P_MobjWasRemoved(player->follower)) + { + P_SetTarget(&player->follower, NULL); // Remove this and respawn one, don't crash the game if Lua decides to P_RemoveMobj this thing. + return; + } + + // first of all, handle states following the same model as above: + if (player->follower->tics == 1) + { + K_SetFollowerState(player->follower, player->follower->state->nextstate); + } + + // move the follower next to us (yes, this is really basic maths but it looks pretty damn clean in practice)! + player->follower->momx = FixedDiv(sx - player->follower->x, fl.horzlag); + player->follower->momy = FixedDiv(sy - player->follower->y, fl.horzlag); + + player->follower->z += FixedDiv(deltaz, fl.vertlag); + + if (fl.mode == FOLLOWERMODE_GROUND) + { + sector_t *sec = R_PointInSubsector(sx, sy)->sector; + + fh = min(fh, P_GetFloorZ(player->follower, sec, sx, sy, NULL)); + ch = max(ch, P_GetCeilingZ(player->follower, sec, sx, sy, NULL) - ourheight); + + if (P_IsObjectOnGround(player->mo) == false) + { + // In the air, match their momentum. + player->follower->momz = player->mo->momz; + } + else + { + fixed_t fg = P_GetMobjGravity(player->mo); + fixed_t fz = P_GetMobjZMovement(player->follower); + + player->follower->momz = fz; + + // Player is on the ground ... try to get the follower + // back to the ground also if it is above it. + player->follower->momz += FixedDiv(fg * 6, fl.vertlag); // Scaled against the default value of vertlag + } + } + else + { + player->follower->momz = FixedDiv(sz - player->follower->z, fl.vertlag); + } + + if (player->mo->colorized) + { + player->follower->color = player->mo->color; + } + else + { + player->follower->color = color; + } + + player->follower->colorized = player->mo->colorized; + + P_SetScale(player->follower, FixedMul(fl.scale, player->mo->scale)); + K_GenericExtraFlagsNoZAdjust(player->follower, player->mo); // Not K_MatchGenericExtraFlag because the Z adjust it has only works properly if master & mo have the same Z height. + + // Match how the player is being drawn + player->follower->renderflags = player->mo->renderflags; + + // Make the follower invisible if we no contest'd rather than removing it. No one will notice the diff seriously. + if (player->pflags & PF_NOCONTEST) + { + player->follower->renderflags |= RF_DONTDRAW; + } + + // if we're moving let's make the angle the direction we're moving towards. This is to avoid drifting / reverse looking awkward. + if (FixedHypot(player->follower->momx, player->follower->momy) >= player->mo->scale) + { + destAngle = R_PointToAngle2(0, 0, player->follower->momx, player->follower->momy); + } + else + { + // Face the player's angle when standing still. + destAngle = player->mo->angle; + } + + // Sal: Turn the follower around when looking backwards. + if ( player->cmd.buttons & BT_LOOKBACK ) + { + destAngle += ANGLE_180; + } + + // Sal: Smoothly rotate angle to the destination value. + angleDiff = AngleDeltaSigned(destAngle, player->follower->angle); + + if (angleDiff != 0) + { + player->follower->angle += FixedDiv(angleDiff, fl.anglelag); + } + + // Ground follower slope rotation + if (fl.mode == FOLLOWERMODE_GROUND) + { + if (player->follower->z <= fh) + { + player->follower->z = fh; + if (player->follower->momz < 0) + { + player->follower->momz = 0; + } + } + else if (player->follower->z >= ch) + { + player->follower->z = ch; + if (player->follower->momz > 0) + { + player->follower->momz = 0; + } + } + + K_CalculateBananaSlope( + player->follower, + player->follower->x, player->follower->y, player->follower->z, + player->follower->radius, ourheight, + (player->mo->eflags & MFE_VERTICALFLIP), + false + ); + } + + // Finally, if the follower has bubbles, move them, set their scale, etc.... + // This is what I meant earlier by it being easier, now we can just use this weird lil loop to get the job done! + + bmobj = player->follower->hnext; // will be NULL if there's no bubble + + while (bmobj != NULL && P_MobjWasRemoved(bmobj) == false) + { + // match follower's momentums and (e)flags(2). + bmobj->momx = player->follower->momx; + bmobj->momy = player->follower->momy; + bmobj->z += FixedDiv(deltaz, fl.vertlag); + bmobj->momz = player->follower->momz; + + P_SetScale(bmobj, FixedMul(bubble, player->mo->scale)); + K_GenericExtraFlagsNoZAdjust(bmobj, player->follower); + bmobj->renderflags = player->mo->renderflags; + + if (player->follower->threshold) + { + // threshold means the follower was "despawned" with S_NULL (is actually just set to S_INVISIBLE) + P_SetMobjState(bmobj, S_INVISIBLE); // sooooo... let's do the same! + } + + // switch to other bubble layer or exit + bmobj = bmobj->hnext; + } + + if (player->follower->threshold) + { + // Threshold means the follower was "despanwed" with S_NULL. + return; + } + + // However with how the code is factored, this is just a special case of S_INVISBLE to avoid having to add other player variables. + + // handle follower animations. Could probably be better... + // hurt or dead + if (P_PlayerInPain(player) == true || player->mo->state == &states[S_KART_SPINOUT] || player->mo->health <= 0) + { + // cancel hit confirm. + player->follower->movecount = 0; + + // spin out + player->follower->angle = player->drawangle; + + if (player->follower->extravalue1 != 2) + { + player->follower->extravalue1 = 2; + K_SetFollowerState(player->follower, fl.hurtstate); + } + + if (player->mo->health <= 0) + { + // if dead, follow the player's z momentum exactly so they both look like they die at the same speed. + player->follower->momz = player->mo->momz; + } + } + else if (player->follower->movecount) + { + if (player->follower->extravalue1 != 5) + { + player->follower->extravalue1 = 5; + K_SetFollowerState(player->follower, fl.hitconfirmstate); + } + + player->follower->movecount--; + } + else if (player->speed > 10*player->mo->scale) // animation for moving fast enough + { + if (player->follower->extravalue1 != 1) + { + player->follower->extravalue1 = 1; + K_SetFollowerState(player->follower, fl.followstate); + } + } + else + { + // animations when nearly still. This includes winning and losing. + if (player->follower->extravalue1 != 0) + { + if (player->exiting) + { + // win/ loss animations + if (K_IsPlayerLosing(player)) + { + // L + if (player->follower->extravalue1 != 4) + { + player->follower->extravalue1 = 4; + K_SetFollowerState(player->follower, fl.losestate); + } + } + else + { + // W + if (player->follower->extravalue1 != 3) + { + player->follower->extravalue1 = 3; + K_SetFollowerState(player->follower, fl.winstate); + } + } + } + else + { + // normal standstill + player->follower->extravalue1 = 0; + K_SetFollowerState(player->follower, fl.idlestate); + } + } + } + } +} diff --git a/src/k_follower.h b/src/k_follower.h new file mode 100644 index 000000000..363b272bc --- /dev/null +++ b/src/k_follower.h @@ -0,0 +1,161 @@ +// DR. ROBOTNIK'S RING RACERS +//----------------------------------------------------------------------------- +// Copyright (C) 2018-2022 by "Lat'" +// Copyright (C) 2018-2022 by Kart Krew +// +// This program is free software distributed under the +// terms of the GNU General Public License, version 2. +// See the 'LICENSE' file for more details. +//----------------------------------------------------------------------------- +/// \file k_follower.h +/// \brief Code relating to the follower system + +#ifndef __K_FOLLOWER__ +#define __K_FOLLOWER__ + +#include "doomdef.h" +#include "doomstat.h" +#include "r_skins.h" + +#define FOLLOWERCOLOR_MATCH UINT16_MAX +#define FOLLOWERCOLOR_OPPOSITE (UINT16_MAX-1) + +extern CV_PossibleValue_t Followercolor_cons_t[]; // follower colours table, not a duplicate because of the "Match" option. + +typedef enum +{ + FOLLOWERMODE_FLOAT, // Default behavior, floats in the position you set it to. + FOLLOWERMODE_GROUND, // Snaps to the ground & rotates with slopes. + FOLLOWERMODE__MAX +} followermode_t; + +// +// We'll define these here because they're really just a mobj that'll follow some rules behind a player +// +typedef struct follower_s +{ + char skinname[SKINNAMESIZE+1]; // Skin Name. This is what to refer to when asking the commands anything. + char name[SKINNAMESIZE+1]; // Name. This is used for the menus. We'll just follow the same rules as skins for this. + char icon[8+1]; // Lump names are only 8 characters. (+1 for \0) + + skincolornum_t defaultcolor; // default color for menus. + followermode_t mode; // Follower behavior modifier. + + fixed_t scale; // Scale relative to the player's. + fixed_t bubblescale; // Bubble scale relative to the player scale. If not set, no bubble will spawn (default) + + // some position shenanigans: + angle_t atangle; // angle the object will be at around the player. The object itself will always face the same direction as the player. + fixed_t dist; // distance relative to the player. (In a circle) + fixed_t height; // height of the follower, this is mostly important for Z flipping. + fixed_t zoffs; // Z offset relative to the player's height. Cannot be negative. + + // movement options + + fixed_t horzlag; // Lag for X/Y displacement. Default is 3. Must be > 0 because we divide by this number. + fixed_t vertlag; // Z displacement lag. Default is 6. Must be > 0 because we divide by this number. + fixed_t anglelag; // Angle rotation lag. Default is 8. Must be > 0 because we divide by this number. + + fixed_t bobamp; // Bob amplitude. Default is 4. + tic_t bobspeed; // Arbitrary modifier for bobbing speed. Default is TICRATE*2 (70) + + // from there on out, everything is STATES to allow customization + // these are only set once when the action is performed and are then free to animate however they want. + + statenum_t idlestate; // state when the player is at a standstill + statenum_t followstate; // state when the player is moving + statenum_t hurtstate; // state when the player is being hurt + statenum_t winstate; // state when the player has won + statenum_t losestate; // state when the player has lost + statenum_t hitconfirmstate; // state for hit confirm + tic_t hitconfirmtime; // time to keep the above playing for +} follower_t; + +extern INT32 numfollowers; +extern follower_t followers[MAXSKINS]; + +/*-------------------------------------------------- + INT32 K_FollowerAvailable(const char *name) + + Check if a follower with the specified name + exists or not. + + Input Arguments:- + name - The skin name of the follower to check for. + + Return:- + The follower numerical ID of the follower, + or -1 if it doesn't exist. +--------------------------------------------------*/ + +INT32 K_FollowerAvailable(const char *name); + + +/*-------------------------------------------------- + boolean K_SetFollowerByName(INT32 playernum, const char *skinname) + + Updates a player's follower type via a named value. + Calls "K_SetFollowerByNum" internally. + + Input Arguments:- + playernum - The player ID to update + skinname - The follower's skin name + + Return:- + true if it was a valid name for a follower, + otherwise false. +--------------------------------------------------*/ + +boolean K_SetFollowerByName(INT32 playernum, const char *skinname); + + +/*-------------------------------------------------- + void K_SetFollowerByNum(INT32 playernum, INT32 skinnum) + + Updates a player's follower type via a numerical ID. + + Input Arguments:- + playernum - The player ID to update. + skinnum - The follower's skin ID + + Return:- + None +--------------------------------------------------*/ + +void K_SetFollowerByNum(INT32 playernum, INT32 skinnum); + + +/*-------------------------------------------------- + UINT16 K_GetEffectiveFollowerColor(UINT16 followercolor, UINT16 playercolor) + + Updates a player's follower pointer, and does + its positioning and animations. + + Input Arguments:- + followercolor - The raw color setting for the follower + playercolor - The player's associated colour, for reference + + Return:- + The resultant skincolor enum for the follower +--------------------------------------------------*/ + +UINT16 K_GetEffectiveFollowerColor(UINT16 followercolor, UINT16 playercolor); + + +/*-------------------------------------------------- + void K_HandleFollower(player_t *player) + + Updates a player's follower pointer, and does + its positioning and animations. + + Input Arguments:- + player - The player who we want to update the follower of. + + Return:- + None +--------------------------------------------------*/ + +void K_HandleFollower(player_t *player); + + +#endif // __K_FOLLOWER__ diff --git a/src/k_hud.c b/src/k_hud.c index 0f3ed8b7d..a3e1b8561 100644 --- a/src/k_hud.c +++ b/src/k_hud.c @@ -827,16 +827,11 @@ void K_AdjustXYWithSnap(INT32 *x, INT32 *y, UINT32 options, INT32 dupx, INT32 du } // This version of the function was prototyped in Lua by Nev3r ... a HUGE thank you goes out to them! -// TODO: This should probably support view rolling if we're adding that soon... -void K_ObjectTracking(trackingResult_t *result, vector3_t *point, UINT8 cameraNum, angle_t angleOffset) +void K_ObjectTracking(trackingResult_t *result, vector3_t *point, boolean reverse) { #define NEWTAN(x) FINETANGENT(((x + ANGLE_90) >> ANGLETOFINESHIFT) & 4095) // tan function used by Lua #define NEWCOS(x) FINECOSINE((x >> ANGLETOFINESHIFT) & FINEMASK) - camera_t *cam; - player_t *player; - - fixed_t viewpointX, viewpointY, viewpointZ; angle_t viewpointAngle, viewpointAiming, viewpointRoll; INT32 screenWidth, screenHeight; @@ -848,6 +843,8 @@ void K_ObjectTracking(trackingResult_t *result, vector3_t *point, UINT8 cameraNu fixed_t h; INT32 da; + UINT8 cameraNum = R_GetViewNumber(); + I_Assert(result != NULL); I_Assert(point != NULL); @@ -856,49 +853,21 @@ void K_ObjectTracking(trackingResult_t *result, vector3_t *point, UINT8 cameraNu result->scale = FRACUNIT; result->onScreen = false; - if (cameraNum > r_splitscreen) + // Take the view's properties as necessary. + if (reverse) { - // Invalid camera ID. - return; - } - - cam = &camera[cameraNum]; - player = &players[displayplayers[cameraNum]]; - - if (cam == NULL || player == NULL || player->mo == NULL || P_MobjWasRemoved(player->mo) == true) - { - // Shouldn't be possible? - return; - } - - // TODO: parts need interp - if (cam->chase == true && !player->spectator) - { - // Use the camera's properties. - viewpointX = R_InterpolateFixed(cam->old_x, cam->x); - viewpointY = R_InterpolateFixed(cam->old_y, cam->y); - viewpointZ = R_InterpolateFixed(cam->old_z, cam->z) - point->z; - viewpointAngle = (INT32)R_InterpolateAngle(cam->old_angle, cam->angle); - viewpointAiming = (INT32)R_InterpolateAngle(cam->old_aiming, cam->aiming); - viewpointRoll = (INT32)R_InterpolateAngle(player->old_viewrollangle, player->viewrollangle); + viewpointAngle = (INT32)(viewangle + ANGLE_180); + viewpointAiming = (INT32)InvAngle(aimingangle); + viewpointRoll = (INT32)viewroll; } else { - // Use player properties. - viewpointX = R_InterpolateFixed(player->mo->old_x, player->mo->x); - viewpointY = R_InterpolateFixed(player->mo->old_y, player->mo->y); - viewpointZ = R_InterpolateFixed(player->mo->old_z, player->mo->z) - point->z; //player->old_viewz - viewpointAngle = (INT32)R_InterpolateAngle(player->mo->old_angle, player->mo->angle); - viewpointAiming = (INT32)player->aiming; - viewpointRoll = (INT32)R_InterpolateAngle(player->old_viewrollangle, player->viewrollangle); + viewpointAngle = (INT32)viewangle; + viewpointAiming = (INT32)aimingangle; + viewpointRoll = (INT32)InvAngle(viewroll); } - viewpointAngle += (INT32)angleOffset; - - (void)viewpointRoll; // will be used later... - // Calculate screen size adjustments. - // TODO: Anyone want to make this support non-green resolutions somehow? :V screenWidth = vid.width/vid.dupx; screenHeight = vid.height/vid.dupy; @@ -919,7 +888,7 @@ void K_ObjectTracking(trackingResult_t *result, vector3_t *point, UINT8 cameraNu // Calculate FOV adjustments. fovDiff = cv_fov[cameraNum].value - baseFov; - fov = ((baseFov - fovDiff) / 2) - (player->fovadd / 2); + fov = ((baseFov - fovDiff) / 2) - (stplyr->fovadd / 2); fovTangent = NEWTAN(FixedAngle(fov)); if (r_splitscreen == 1) @@ -931,22 +900,35 @@ void K_ObjectTracking(trackingResult_t *result, vector3_t *point, UINT8 cameraNu fg = (screenWidth >> 1) * fovTangent; // Determine viewpoint factors. - h = R_PointToDist2(point->x, point->y, viewpointX, viewpointY); - da = AngleDeltaSigned(viewpointAngle, R_PointToAngle2(point->x, point->y, viewpointX, viewpointY)); + h = R_PointToDist2(point->x, point->y, viewx, viewy); + da = AngleDeltaSigned(viewpointAngle, R_PointToAngle2(point->x, point->y, viewx, viewy)); - // Set results! - result->x = screenHalfW + FixedMul(NEWTAN(da), fg); - result->y = screenHalfH + FixedMul((NEWTAN(viewpointAiming) - FixedDiv(viewpointZ, 1 + FixedMul(NEWCOS(da), h))), fg); + // Set results relative to top left! + result->x = FixedMul(NEWTAN(da), fg); + result->y = FixedMul((NEWTAN(viewpointAiming) - FixedDiv((viewz - point->z), 1 + FixedMul(NEWCOS(da), h))), fg); + + // Rotate for screen roll... + if (viewpointRoll) + { + fixed_t tempx = result->x; + viewpointRoll >>= ANGLETOFINESHIFT; + result->x = FixedMul(FINECOSINE(viewpointRoll), tempx) - FixedMul(FINESINE(viewpointRoll), result->y); + result->y = FixedMul(FINESINE(viewpointRoll), tempx) + FixedMul(FINECOSINE(viewpointRoll), result->y); + } + + // Flipped screen? + if (encoremode) + { + result->x = -result->x; + } + + // Center results. + result->x += screenHalfW; + result->y += screenHalfH; result->scale = FixedDiv(screenHalfW, h+1); - result->onScreen = ((abs(da) > ANG60) || (abs(AngleDeltaSigned(viewpointAiming, R_PointToAngle2(0, 0, h, viewpointZ))) > ANGLE_45)); - - if (encoremode) - { - // Flipped screen - result->x = (screenWidth << FRACBITS) - result->x; - } + result->onScreen = ((abs(da) > ANG60) || (abs(AngleDeltaSigned(viewpointAiming, R_PointToAngle2(0, 0, h, (viewz - point->z)))) > ANGLE_45)); // Cheap dirty hacks for some split-screen related cases if (result->x < 0 || result->x > (screenWidth << FRACBITS)) @@ -2843,7 +2825,6 @@ static void K_drawKartWanted(void) static void K_drawKartPlayerCheck(void) { const fixed_t maxdistance = FixedMul(1280 * mapobjectscale, K_GetKartGameSpeedScalar(gamespeed)); - UINT8 cnum = 0; UINT8 i; INT32 splitflags = V_SNAPTOBOTTOM|V_SPLITSCREEN; fixed_t y = CHEK_Y * FRACUNIT; @@ -2863,20 +2844,6 @@ static void K_drawKartPlayerCheck(void) return; } - if (r_splitscreen) - { - y /= 2; - - for (i = 1; i <= r_splitscreen; i++) - { - if (stplyr == &players[displayplayers[i]]) - { - cnum = i; - break; - } - } - } - for (i = 0; i < MAXPLAYERS; i++) { player_t *checkplayer = &players[i]; @@ -2935,7 +2902,7 @@ static void K_drawKartPlayerCheck(void) pnum += 2; } - K_ObjectTracking(&result, &v, cnum, ANGLE_180); + K_ObjectTracking(&result, &v, true); if (result.onScreen == true) { @@ -3010,7 +2977,7 @@ static void K_DrawTypingNotifier(fixed_t x, fixed_t y, player_t *p) } } -static void K_DrawNameTagForPlayer(fixed_t x, fixed_t y, player_t *p, UINT8 cnum) +static void K_DrawNameTagForPlayer(fixed_t x, fixed_t y, player_t *p) { const INT32 clr = skincolors[p->skincolor].chatcolor; const INT32 namelen = V_ThinStringWidth(player_names[p - players], V_6WIDTHSPACE|V_ALLOWLOWERCASE); @@ -3018,6 +2985,8 @@ static void K_DrawNameTagForPlayer(fixed_t x, fixed_t y, player_t *p, UINT8 cnum UINT8 *colormap = V_GetStringColormap(clr); INT32 barx = 0, bary = 0, barw = 0; + UINT8 cnum = R_GetViewNumber(); + // Since there's no "V_DrawFixedFill", and I don't feel like making it, // fuck it, we're gonna just V_NOSCALESTART hack it if (cnum & 1) @@ -3102,9 +3071,8 @@ static void K_DrawWeakSpot(weakspotdraw_t *ws) static void K_drawKartNameTags(void) { const fixed_t maxdistance = 8192*mapobjectscale; - camera_t *thiscam; vector3_t c; - UINT8 cnum = 0; + UINT8 cnum = R_GetViewNumber(); UINT8 tobesorted[MAXPLAYERS]; fixed_t sortdist[MAXPLAYERS]; UINT8 sortlen = 0; @@ -3120,32 +3088,9 @@ static void K_drawKartNameTags(void) return; } - if (r_splitscreen) - { - for (i = 1; i <= r_splitscreen; i++) - { - if (stplyr == &players[displayplayers[i]]) - { - cnum = i; - break; - } - } - } - - thiscam = &camera[cnum]; - - if (thiscam->chase == true) - { - c.x = R_InterpolateFixed(thiscam->old_x, thiscam->x); - c.y = R_InterpolateFixed(thiscam->old_y, thiscam->y); - c.z = R_InterpolateFixed(thiscam->old_z, thiscam->z); - } - else - { - c.x = R_InterpolateFixed(stplyr->mo->old_x, stplyr->mo->x); - c.y = R_InterpolateFixed(stplyr->mo->old_y, stplyr->mo->y); - c.z = R_InterpolateFixed(stplyr->mo->old_z, stplyr->mo->z); - } + c.x = viewx; + c.y = viewy; + c.z = viewz; // Maybe shouldn't be handling this here... but the camera info is too good. if (bossinfo.boss) @@ -3177,7 +3122,7 @@ static void K_drawKartNameTags(void) v.z += (bossinfo.weakspots[i].spot->height / 2); - K_ObjectTracking(&result, &v, cnum, 0); + K_ObjectTracking(&result, &v, false); if (result.onScreen == false) { continue; @@ -3330,7 +3275,7 @@ static void K_drawKartNameTags(void) v.z += headOffset; } - K_ObjectTracking(&result, &v, cnum, 0); + K_ObjectTracking(&result, &v, false); if (result.onScreen == true) { @@ -3365,7 +3310,7 @@ static void K_drawKartNameTags(void) { if (K_ShowPlayerNametag(ntplayer) == true) { - K_DrawNameTagForPlayer(result.x, result.y, ntplayer, cnum); + K_DrawNameTagForPlayer(result.x, result.y, ntplayer); K_DrawTypingNotifier(result.x, result.y, ntplayer); } } diff --git a/src/k_hud.h b/src/k_hud.h index fff718ef5..683425e8a 100644 --- a/src/k_hud.h +++ b/src/k_hud.h @@ -28,7 +28,7 @@ typedef struct trackingResult_s boolean onScreen; } trackingResult_t; -void K_ObjectTracking(trackingResult_t *result, vector3_t *point, UINT8 cameraNum, angle_t angleOffset); +void K_ObjectTracking(trackingResult_t *result, vector3_t *point, boolean reverse); const char *K_GetItemPatch(UINT8 item, boolean tiny); void K_LoadKartHUDGraphics(void); diff --git a/src/k_kart.c b/src/k_kart.c index bd6077a35..2038604f5 100644 --- a/src/k_kart.c +++ b/src/k_kart.c @@ -37,6 +37,8 @@ #include "k_terrain.h" #include "k_director.h" #include "k_collide.h" +#include "k_follower.h" +#include "k_objects.h" // SOME IMPORTANT VARIABLES DEFINED IN DOOMDEF.H: // gamespeed is cc (0 for easy, 1 for normal, 2 for hard) @@ -352,25 +354,25 @@ static INT32 K_KartItemOddsRace[NUMKARTRESULTS-1][8] = //P-Odds 0 1 2 3 4 5 6 7 /*Sneaker*/ { 0, 0, 2, 4, 6, 0, 0, 0 }, // Sneaker /*Rocket Sneaker*/ { 0, 0, 0, 0, 0, 2, 4, 6 }, // Rocket Sneaker - /*Invincibility*/ { 0, 0, 0, 0, 2, 4, 6, 9 }, // Invincibility - /*Banana*/ { 4, 3, 1, 0, 0, 0, 0, 0 }, // Banana + /*Invincibility*/ { 0, 0, 0, 0, 3, 4, 6, 9 }, // Invincibility + /*Banana*/ { 2, 3, 1, 0, 0, 0, 0, 0 }, // Banana /*Eggman Monitor*/ { 1, 2, 0, 0, 0, 0, 0, 0 }, // Eggman Monitor /*Orbinaut*/ { 5, 4, 2, 2, 0, 0, 0, 0 }, // Orbinaut /*Jawz*/ { 0, 3, 2, 1, 1, 0, 0, 0 }, // Jawz /*Mine*/ { 0, 2, 3, 1, 0, 0, 0, 0 }, // Mine /*Land Mine*/ { 3, 0, 0, 0, 0, 0, 0, 0 }, // Land Mine - /*Ballhog*/ { 0, 0, 2, 1, 0, 0, 0, 0 }, // Ballhog + /*Ballhog*/ { 0, 0, 2, 2, 0, 0, 0, 0 }, // Ballhog /*Self-Propelled Bomb*/ { 0, 0, 0, 0, 0, 2, 4, 0 }, // Self-Propelled Bomb /*Grow*/ { 0, 0, 0, 1, 2, 3, 0, 0 }, // Grow /*Shrink*/ { 0, 0, 0, 0, 0, 0, 2, 0 }, // Shrink /*Lightning Shield*/ { 1, 2, 0, 0, 0, 0, 0, 0 }, // Lightning Shield /*Bubble Shield*/ { 0, 1, 2, 1, 0, 0, 0, 0 }, // Bubble Shield /*Flame Shield*/ { 0, 0, 0, 0, 0, 1, 3, 5 }, // Flame Shield - /*Hyudoro*/ { 0, 0, 0, 1, 1, 0, 0, 0 }, // Hyudoro + /*Hyudoro*/ { 3, 0, 0, 0, 0, 0, 0, 0 }, // Hyudoro /*Pogo Spring*/ { 0, 0, 0, 0, 0, 0, 0, 0 }, // Pogo Spring /*Super Ring*/ { 2, 1, 1, 0, 0, 0, 0, 0 }, // Super Ring /*Kitchen Sink*/ { 0, 0, 0, 0, 0, 0, 0, 0 }, // Kitchen Sink - /*Drop Target*/ { 4, 0, 0, 0, 0, 0, 0, 0 }, // Drop Target + /*Drop Target*/ { 3, 0, 0, 0, 0, 0, 0, 0 }, // Drop Target /*Sneaker x2*/ { 0, 0, 2, 2, 1, 0, 0, 0 }, // Sneaker x2 /*Sneaker x3*/ { 0, 0, 0, 2, 6,10, 5, 0 }, // Sneaker x3 /*Banana x3*/ { 0, 1, 1, 0, 0, 0, 0, 0 }, // Banana x3 @@ -457,9 +459,6 @@ static void K_KartGetItemResult(player_t *player, SINT8 getitem) if (getitem == KITEM_SPB || getitem == KITEM_SHRINK) // Indirect items indirectitemcooldown = 20*TICRATE; - if (getitem == KITEM_HYUDORO) // Hyudoro cooldown - hyubgone = 5*TICRATE; - player->botvars.itemdelay = TICRATE; player->botvars.itemconfirm = 0; @@ -681,6 +680,7 @@ INT32 K_KartGetItemOdds( case KITEM_LANDMINE: case KITEM_DROPTARGET: case KITEM_BALLHOG: + case KITEM_HYUDORO: case KRITEM_TRIPLESNEAKER: case KRITEM_TRIPLEORBINAUT: case KRITEM_QUADORBINAUT: @@ -741,13 +741,6 @@ INT32 K_KartGetItemOdds( if (spbplace != -1) newodds = 0; break; - case KITEM_HYUDORO: - cooldownOnStart = true; - notNearEnd = true; - - if (hyubgone > 0) - newodds = 0; - break; default: break; } @@ -2799,21 +2792,35 @@ void K_PlayPainSound(mobj_t *source) K_RegularVoiceTimers(source->player); } -void K_PlayHitEmSound(mobj_t *source) +void K_PlayHitEmSound(mobj_t *source, mobj_t *victim) { + const boolean victimIsLocal = (victim != NULL && P_IsDisplayPlayer(victim->player) == true); if (source->player->follower) { follower_t fl = followers[source->player->followerskin]; - source->player->follower->movecount = fl.hitconfirmtime; // movecount is used to play the hitconfirm animation for followers. + source->player->follower->movecount = fl.hitconfirmtime; // movecount is used to play the hitconfirm animation for followers. } if (cv_kartvoices.value) - S_StartSound(source, sfx_khitem); + { + if (victimIsLocal == false) + { + S_StartSound(source, sfx_khitem); + } + } else + { S_StartSound(source, sfx_s1c9); // The only lost gameplay functionality with voices disabled + } K_RegularVoiceTimers(source->player); + + if (victim != NULL && victim->player != NULL) + { + victim->player->confirmInflictor = source->player - players; + victim->player->confirmInflictorDelay = TICRATE/2; + } } void K_PlayPowerGloatSound(mobj_t *source) @@ -2824,6 +2831,45 @@ void K_PlayPowerGloatSound(mobj_t *source) K_RegularVoiceTimers(source->player); } +static void K_HandleDelayedHitByEm(player_t *player) +{ + if (player->confirmInflictorDelay == 0) + { + return; + } + + player->confirmInflictorDelay--; + + if (player->confirmInflictorDelay == 0 + && P_IsDisplayPlayer(player) == true + && cv_kartvoices.value) + { + player_t *inflictor = NULL; + + if (player->confirmInflictor >= MAXPLAYERS) + { + return; + } + + if (!playeringame[player->confirmInflictor]) + { + return; + } + + inflictor = &players[player->confirmInflictor]; + if (inflictor == NULL || inflictor->spectator) + { + return; + } + + if (inflictor->mo != NULL && P_MobjWasRemoved(inflictor->mo) == false) + { + sfxenum_t sfx_id = ((skin_t *)inflictor->mo->skin)->soundsid[S_sfx[sfx_khitem].skinsound]; + S_StartSound(NULL, sfx_id); + } + } +} + void K_MomentumToFacing(player_t *player) { angle_t dangle = player->mo->angle - K_MomentumAngle(player->mo); @@ -2863,6 +2909,7 @@ boolean K_TripwirePassConditions(player_t *player) player->sneakertimer || player->growshrinktimer > 0 || player->flamedash || + player->hyudorotimer || player->speed > 2 * K_GetKartSpeed(player, false) ) return true; @@ -3293,7 +3340,7 @@ fixed_t K_3dKartMovement(player_t *player) angle_t K_MomentumAngle(mobj_t *mo) { - if (mo->momx || mo->momy) + if (FixedHypot(mo->momx, mo->momy) >= mo->scale) { return R_PointToAngle2(0, 0, mo->momx, mo->momy); } @@ -3495,8 +3542,7 @@ static void K_RemoveGrowShrink(player_t *player) else if (player->growshrinktimer < 0) // Play Grow noise S_StartSound(player->mo, sfx_kc5a); - if (player->invincibilitytimer == 0) - player->mo->color = player->skincolor; + K_KartResetPlayerColor(player); player->mo->scalespeed = mapobjectscale/TICRATE; player->mo->destscale = mapobjectscale; @@ -5340,6 +5386,7 @@ static void K_FlameDashLeftoverSmoke(mobj_t *src) } } +#if 0 static void K_DoHyudoroSteal(player_t *player) { INT32 i, numplayers = 0; @@ -5417,6 +5464,7 @@ static void K_DoHyudoroSteal(player_t *player) S_StartSound(NULL, sfx_s3k92); } } +#endif void K_DoSneaker(player_t *player, INT32 type) { @@ -5561,7 +5609,6 @@ static void K_DoShrink(player_t *user) void K_DoPogoSpring(mobj_t *mo, fixed_t vertispeed, UINT8 sound) { - const fixed_t vscale = mapobjectscale + (mo->scale - mapobjectscale); fixed_t thrust = 0; if (mo->player && mo->player->spectator) @@ -5602,7 +5649,7 @@ void K_DoPogoSpring(mobj_t *mo, fixed_t vertispeed, UINT8 sound) //CONS_Printf("Got boost: %d%\n", mo->player->trickboostpower*100 / FRACUNIT); } - mo->momz = FixedMul(thrust, vscale); + mo->momz = FixedMul(thrust, mapobjectscale); if (mo->eflags & MFE_UNDERWATER) { @@ -6190,7 +6237,7 @@ static fixed_t K_BananaSlopeZ(pslope_t *slope, fixed_t x, fixed_t y, fixed_t z, return P_GetZAt(slope, testx, testy, z); } -static void K_CalculateBananaSlope(mobj_t *mobj, fixed_t x, fixed_t y, fixed_t z, fixed_t radius, fixed_t height, boolean flip, boolean player) +void K_CalculateBananaSlope(mobj_t *mobj, fixed_t x, fixed_t y, fixed_t z, fixed_t radius, fixed_t height, boolean flip, boolean player) { fixed_t newz; sector_t *sec; @@ -6577,12 +6624,10 @@ static void K_MoveHeldObjects(player_t *player) targy = player->mo->y + P_ReturnThrustY(cur, cur->angle + angoffset, cur->extravalue1); { // bobbing, copy pasted from my kimokawaiii entry - const fixed_t pi = (22<mo->scale, 8 * FINESINE((((2*pi*(4*TICRATE)) * leveltime)>>ANGLETOFINESHIFT) & FINEMASK)); + fixed_t sine = FixedMul(player->mo->scale, 8 * FINESINE((((M_TAU_FIXED * (4*TICRATE)) * leveltime) >> ANGLETOFINESHIFT) & FINEMASK)); targz = (player->mo->z + (player->mo->height/2)) + sine; if (player->mo->eflags & MFE_VERTICALFLIP) targz += (player->mo->height/2 - 32*player->mo->scale)*6; - } if (cur->tracer) @@ -7009,57 +7054,57 @@ static mobj_t *attractmo; static fixed_t attractdist; static fixed_t attractzdist; -static inline boolean PIT_AttractingRings(mobj_t *thing) +static inline BlockItReturn_t PIT_AttractingRings(mobj_t *thing) { if (attractmo == NULL || P_MobjWasRemoved(attractmo) || attractmo->player == NULL) { - return false; + return BMIT_ABORT; } if (thing == NULL || P_MobjWasRemoved(thing)) { - return true; // invalid + return BMIT_CONTINUE; // invalid } if (thing == attractmo) { - return true; // invalid + return BMIT_CONTINUE; // invalid } if (!(thing->type == MT_RING || thing->type == MT_FLINGRING)) { - return true; // not a ring + return BMIT_CONTINUE; // not a ring } if (thing->health <= 0) { - return true; // dead + return BMIT_CONTINUE; // dead } if (thing->extravalue1) { - return true; // in special ring animation + return BMIT_CONTINUE; // in special ring animation } if (thing->tracer != NULL && P_MobjWasRemoved(thing->tracer) == false) { - return true; // already attracted + return BMIT_CONTINUE; // already attracted } // see if it went over / under if (attractmo->z - attractzdist > thing->z + thing->height) { - return true; // overhead + return BMIT_CONTINUE; // overhead } if (attractmo->z + attractmo->height + attractzdist < thing->z) { - return true; // underneath + return BMIT_CONTINUE; // underneath } if (P_AproxDistance(attractmo->x - thing->x, attractmo->y - thing->y) > attractdist + thing->radius) { - return true; // Too far away + return BMIT_CONTINUE; // Too far away } if (RINGTOTAL(attractmo->player) >= 20 || (attractmo->player->pflags & PF_RINGLOCK)) @@ -7086,7 +7131,7 @@ static inline boolean PIT_AttractingRings(mobj_t *thing) P_SetTarget(&thing->tracer, attractmo); } - return true; // find other rings + return BMIT_CONTINUE; // find other rings } /** Looks for rings near a player in the blockmap. @@ -7508,6 +7553,15 @@ void K_KartPlayerThink(player_t *player, ticcmd_t *cmd) if (player->instashield) player->instashield--; + if (player->justDI) + { + player->justDI--; + + // return turning if player is fully actionable, no matter when! + if (!P_PlayerInPain(player)) + player->justDI = 0; + } + if (player->eggmanexplode) { if (player->spectator || (gametype == GT_BATTLE && !player->bumpers)) @@ -7518,6 +7572,9 @@ void K_KartPlayerThink(player_t *player, ticcmd_t *cmd) if (player->eggmanexplode <= 0) { mobj_t *eggsexplode; + + K_KartResetPlayerColor(player); + //player->flashing = 0; eggsexplode = P_SpawnMobj(player->mo->x, player->mo->y, player->mo->z, MT_SPBEXPLOSION); if (player->eggmanblame >= 0 @@ -7593,39 +7650,49 @@ void K_KartPlayerThink(player_t *player, ticcmd_t *cmd) { K_SpawnBrakeVisuals(player); } + + K_HandleDelayedHitByEm(player); } -void K_KartPlayerAfterThink(player_t *player) +void K_KartResetPlayerColor(player_t *player) { + boolean forcereset = false; boolean fullbright = false; - if (player->playerstate == PST_DEAD || (player->respawn.state == RESPAWNST_MOVE)) // Ensure these are set correctly here + if (!player->mo || P_MobjWasRemoved(player->mo)) // Can't do anything + return; + + if (player->mo->health <= 0 || player->playerstate == PST_DEAD || (player->respawn.state == RESPAWNST_MOVE)) // Override everything { player->mo->colorized = (player->dye != 0); player->mo->color = player->dye ? player->dye : player->skincolor; + goto finalise; } - else if (player->eggmanexplode) // You're gonna diiiiie + + if (player->eggmanexplode) // You're gonna diiiiie { const INT32 flashtime = 4<<(player->eggmanexplode/TICRATE); if (player->eggmanexplode == 1 || (player->eggmanexplode % (flashtime/2) != 0)) { - player->mo->colorized = (player->dye != 0); - player->mo->color = player->dye ? player->dye : player->skincolor; + forcereset = true; } else if (player->eggmanexplode % flashtime == 0) { player->mo->colorized = true; player->mo->color = SKINCOLOR_BLACK; fullbright = true; + goto finalise; } else { player->mo->colorized = true; player->mo->color = SKINCOLOR_CRIMSON; fullbright = true; + goto finalise; } } - else if (player->invincibilitytimer) + + if (player->invincibilitytimer) // You're gonna kiiiiill { const tic_t defaultTime = itemtime+(2*TICRATE); tic_t flicker = 2; @@ -7636,45 +7703,57 @@ void K_KartPlayerAfterThink(player_t *player) { player->mo->color = K_RainbowColor(leveltime / 2); player->mo->colorized = true; + forcereset = false; } else { - player->mo->color = player->skincolor; - player->mo->colorized = false; - flicker += (defaultTime - player->invincibilitytimer) / TICRATE / 2; + forcereset = true; } if (leveltime % flicker == 0) { player->mo->color = SKINCOLOR_INVINCFLASH; player->mo->colorized = true; + forcereset = false; + } + + if (!forcereset) + { + goto finalise; } } - else if (player->growshrinktimer) // Ditto, for grow/shrink + + if (player->growshrinktimer) // Ditto, for grow/shrink { if (player->growshrinktimer % 5 == 0) { player->mo->colorized = true; player->mo->color = (player->growshrinktimer < 0 ? SKINCOLOR_CREAMSICLE : SKINCOLOR_PERIWINKLE); fullbright = true; + goto finalise; } - else - { - player->mo->colorized = (player->dye != 0); - player->mo->color = player->dye ? player->dye : player->skincolor; - } + + forcereset = true; } - else if (player->ringboost && (leveltime & 1)) // ring boosting + + if (player->ringboost && (leveltime & 1)) // ring boosting { player->mo->colorized = true; fullbright = true; + goto finalise; } else { player->mo->colorized = (player->dye != 0); + if (forcereset) + { + player->mo->color = player->dye ? player->dye : player->skincolor; + } } +finalise: + if (player->curshield) { fullbright = true; @@ -7689,6 +7768,11 @@ void K_KartPlayerAfterThink(player_t *player) if (!(player->mo->state->frame & FF_FULLBRIGHT)) player->mo->frame &= ~FF_FULLBRIGHT; } +} + +void K_KartPlayerAfterThink(player_t *player) +{ + K_KartResetPlayerColor(player); // Move held objects (Bananas, Orbinaut, etc) K_MoveHeldObjects(player); @@ -8178,31 +8262,34 @@ static INT16 K_GetKartDriftValue(player_t *player, fixed_t countersteer) return basedrift + (FixedMul(driftadjust * FRACUNIT, countersteer) / FRACUNIT); } -void K_UpdateSteeringValue(player_t *player, INT16 destSteering) +INT16 K_UpdateSteeringValue(INT16 inputSteering, INT16 destSteering) { // player->steering is the turning value, but with easing applied. // Keeps micro-turning from old easing, but isn't controller dependent. const INT16 amount = KART_FULLTURN/4; - INT16 diff = destSteering - player->steering; + INT16 diff = destSteering - inputSteering; + INT16 outputSteering = inputSteering; if (abs(diff) <= amount) { // Reached the intended value, set instantly. - player->steering = destSteering; + outputSteering = destSteering; } else { // Go linearly towards the value we wanted. if (diff < 0) { - player->steering -= amount; + outputSteering -= amount; } else { - player->steering += amount; + outputSteering += amount; } } + + return outputSteering; } INT16 K_GetKartTurnValue(player_t *player, INT16 turnvalue) @@ -8238,7 +8325,7 @@ INT16 K_GetKartTurnValue(player_t *player, INT16 turnvalue) return 0; } - if (player->justDI == true) + if (player->justDI > 0) { // No turning until you let go after DI-ing. return 0; @@ -8801,6 +8888,8 @@ void K_StripOther(player_t *player) { player->eggmanexplode = 0; player->eggmanblame = -1; + + K_KartResetPlayerColor(player); } } @@ -9044,7 +9133,7 @@ static void K_KartSpindashWind(mobj_t *parent) static void K_KartSpindash(player_t *player) { const INT16 MAXCHARGETIME = K_GetSpindashChargeTime(player); - ticcmd_t *cmd = &player->cmd; + UINT16 buttons = K_GetKartButtons(player); boolean spawnWind = (leveltime % 2 == 0); if (player->mo->hitlag > 0 || P_PlayerInPain(player)) @@ -9052,7 +9141,7 @@ static void K_KartSpindash(player_t *player) player->spindash = 0; } - if (player->spindash > 0 && (cmd->buttons & (BT_DRIFT|BT_BRAKE|BT_ACCELERATE)) != (BT_DRIFT|BT_BRAKE|BT_ACCELERATE)) + if (player->spindash > 0 && (buttons & (BT_DRIFT|BT_BRAKE|BT_ACCELERATE)) != (BT_DRIFT|BT_BRAKE|BT_ACCELERATE)) { player->spindashspeed = (player->spindash * FRACUNIT) / MAXCHARGETIME; player->spindashboost = TICRATE; @@ -9108,7 +9197,7 @@ static void K_KartSpindash(player_t *player) if (player->speed < 6*player->mo->scale) { - if ((cmd->buttons & (BT_DRIFT|BT_BRAKE)) == (BT_DRIFT|BT_BRAKE)) + if ((buttons & (BT_DRIFT|BT_BRAKE)) == (BT_DRIFT|BT_BRAKE)) { UINT8 ringdropframes = 2 + (player->kartspeed + player->kartweight); INT16 chargetime = MAXCHARGETIME - ++player->spindash; @@ -9973,7 +10062,9 @@ void K_MoveKartPlayer(player_t *player, boolean onground) if (ATTACK_IS_DOWN && !HOLDING_ITEM && NO_HYUDORO) { player->itemamount--; - K_DoHyudoroSteal(player); // yes. yes they do. + //K_DoHyudoroSteal(player); // yes. yes they do. + Obj_HyudoroDeploy(player->mo); + K_PlayAttackTaunt(player->mo); } break; case KITEM_POGOSPRING: @@ -10157,78 +10248,72 @@ void K_MoveKartPlayer(player_t *player, boolean onground) else if (!(player->pflags & PF_TRICKDELAY)) // don't allow tricking at the same frame you tumble obv { + INT16 aimingcompare = abs(cmd->throwdir) - abs(cmd->turning); - // "COOL" timing n shit. - if (cmd->turning || player->throwdir) + // Uses cmd->turning over steering intentionally. +#define TRICKTHRESHOLD (KART_FULLTURN/4) + if (aimingcompare < -TRICKTHRESHOLD) // side trick { + if (cmd->turning > 0) + { + P_InstaThrust(player->mo, player->mo->angle + lr, max(basespeed, speed*5/2)); + player->trickpanel = 2; + } + else + { + P_InstaThrust(player->mo, player->mo->angle - lr, max(basespeed, speed*5/2)); + player->trickpanel = 3; + } + } + else if (aimingcompare > TRICKTHRESHOLD) // forward/back trick + { + if (cmd->throwdir > 0) // back trick + { + if (player->mo->momz * P_MobjFlip(player->mo) > 0) + { + player->mo->momz = 0; + } + + P_InstaThrust(player->mo, player->mo->angle, max(basespeed, speed*3)); + player->trickpanel = 2; + } + else if (cmd->throwdir < 0) + { + boolean relative = true; + + player->mo->momx /= 3; + player->mo->momy /= 3; + + if (player->mo->momz * P_MobjFlip(player->mo) <= 0) + { + relative = false; + } + + // Calculate speed boost decay: + // Base speed boost duration is 35 tics. + // At most, lose 3/4th of your boost. + player->trickboostdecay = min(TICRATE*3/4, abs(momz/FRACUNIT)); + //CONS_Printf("decay: %d\n", player->trickboostdecay); + + P_SetObjectMomZ(player->mo, 48*FRACUNIT, relative); + player->trickpanel = 4; + } + } +#undef TRICKTHRESHOLD + + // Finalise everything. + if (player->trickpanel != 1) // just changed from 1? + { + player->mo->hitlag = TRICKLAG; + player->mo->eflags &= ~MFE_DAMAGEHITLAG; + + K_trickPanelTimingVisual(player, momz); + if (abs(momz) < FRACUNIT*99) // Let's use that as baseline for PERFECT trick. { player->karthud[khud_trickcool] = TICRATE; } } - - // Uses cmd->turning over steering intentionally. - if (cmd->turning > 0) - { - P_InstaThrust(player->mo, player->mo->angle + lr, max(basespeed, speed*5/2)); - player->trickpanel = 2; - - player->mo->hitlag = TRICKLAG; - player->mo->eflags &= ~MFE_DAMAGEHITLAG; - - K_trickPanelTimingVisual(player, momz); - } - else if (cmd->turning < 0) - { - P_InstaThrust(player->mo, player->mo->angle - lr, max(basespeed, speed*5/2)); - player->trickpanel = 3; - - player->mo->hitlag = TRICKLAG; - player->mo->eflags &= ~MFE_DAMAGEHITLAG; - - K_trickPanelTimingVisual(player, momz); - } - else if (cmd->throwdir > 0) - { - if (player->mo->momz * P_MobjFlip(player->mo) > 0) - { - player->mo->momz = 0; - } - - P_InstaThrust(player->mo, player->mo->angle, max(basespeed, speed*3)); - player->trickpanel = 2; - - player->mo->hitlag = TRICKLAG; - player->mo->eflags &= ~MFE_DAMAGEHITLAG; - - K_trickPanelTimingVisual(player, momz); - } - else if (cmd->throwdir < 0) - { - boolean relative = true; - - player->mo->momx /= 3; - player->mo->momy /= 3; - - if (player->mo->momz * P_MobjFlip(player->mo) <= 0) - { - relative = false; - } - - // Calculate speed boost decay: - // Base speed boost duration is 35 tics. - // At most, lose 3/4th of your boost. - player->trickboostdecay = min(TICRATE*3/4, abs(momz/FRACUNIT)); - //CONS_Printf("decay: %d\n", player->trickboostdecay); - - P_SetObjectMomZ(player->mo, 48*FRACUNIT, relative); - player->trickpanel = 4; - - player->mo->hitlag = TRICKLAG; - player->mo->eflags &= ~MFE_DAMAGEHITLAG; - - K_trickPanelTimingVisual(player, momz); - } } } else if (player->trickpanel == 4 && P_IsObjectOnGround(player->mo)) // Upwards trick landed! @@ -10438,7 +10523,7 @@ void K_HandleDirectionalInfluence(player_t *player) } // DI attempted!! - player->justDI = true; + player->justDI = MAXHITLAGTICS; cmd = &player->cmd; diff --git a/src/k_kart.h b/src/k_kart.h index 89f176d29..04edb3ba1 100644 --- a/src/k_kart.h +++ b/src/k_kart.h @@ -61,6 +61,7 @@ void K_SpawnInvincibilitySpeedLines(mobj_t *mo); void K_SpawnBumpEffect(mobj_t *mo); void K_KartMoveAnimation(player_t *player); void K_KartPlayerHUDUpdate(player_t *player); +void K_KartResetPlayerColor(player_t *player); void K_KartPlayerThink(player_t *player, ticcmd_t *cmd); void K_KartPlayerAfterThink(player_t *player); angle_t K_MomentumAngle(mobj_t *mo); @@ -94,11 +95,12 @@ void K_KillBananaChain(mobj_t *banana, mobj_t *inflictor, mobj_t *source); void K_UpdateHnextList(player_t *player, boolean clean); void K_DropHnextList(player_t *player, boolean keepshields); void K_RepairOrbitChain(mobj_t *orbit); +void K_CalculateBananaSlope(mobj_t *mobj, fixed_t x, fixed_t y, fixed_t z, fixed_t radius, fixed_t height, boolean flip, boolean player); player_t *K_FindJawzTarget(mobj_t *actor, player_t *source); INT32 K_GetKartRingPower(player_t *player, boolean boosted); void K_UpdateDistanceFromFinishLine(player_t *const player); boolean K_CheckPlayersRespawnColliding(INT32 playernum, fixed_t x, fixed_t y); -void K_UpdateSteeringValue(player_t *player, INT16 destSteering); +INT16 K_UpdateSteeringValue(INT16 inputSteering, INT16 destSteering); INT16 K_GetKartTurnValue(player_t *player, INT16 turnvalue); INT32 K_GetUnderwaterTurnAdjust(player_t *player); INT32 K_GetKartDriftSparkValue(player_t *player); @@ -150,7 +152,7 @@ void K_PlayAttackTaunt(mobj_t *source); void K_PlayBoostTaunt(mobj_t *source); void K_PlayOvertakeSound(mobj_t *source); void K_PlayPainSound(mobj_t *source); -void K_PlayHitEmSound(mobj_t *source); +void K_PlayHitEmSound(mobj_t *source, mobj_t *victim); void K_PlayPowerGloatSound(mobj_t *source); fixed_t K_ItemScaleForPlayer(player_t *player); diff --git a/src/k_menudraw.c b/src/k_menudraw.c index da7d99a8f..7bfbe0f3e 100644 --- a/src/k_menudraw.c +++ b/src/k_menudraw.c @@ -45,8 +45,9 @@ #include "byteptr.h" #include "st_stuff.h" #include "i_sound.h" -#include "k_kart.h" // SRB2kart -#include "k_hud.h" // SRB2kart +#include "k_kart.h" +#include "k_hud.h" +#include "k_follower.h" #include "d_player.h" // KITEM_ constants #include "doomstat.h" // MAXSPLITSCREENPLAYERS @@ -1043,7 +1044,7 @@ static void M_DrawFollowerList(setup_player_t *p, UINT8 num) } cf++; - if (cf > numfollowers-1) + if (cf >= numfollowers) cf = -1; x += 23; @@ -1071,7 +1072,7 @@ static boolean M_DrawFollowerSprite(INT16 x, INT16 y, INT32 num, INT32 addflags, followernum = num; // Don't draw if we're outta bounds. - if (followernum < 0 || followernum > numfollowers-1) + if (followernum < 0 || followernum >= numfollowers) return false; fl = followers[followernum]; @@ -1109,13 +1110,12 @@ static boolean M_DrawFollowerSprite(INT16 x, INT16 y, INT32 num, INT32 addflags, if (p != NULL) { - const fixed_t pi = (22<follower_timer)>>ANGLETOFINESHIFT) & FINEMASK); + sine = FixedMul(fl.bobamp, FINESINE(((FixedMul(4 * M_TAU_FIXED, fl.bobspeed) * p->follower_timer)>>ANGLETOFINESHIFT) & FINEMASK)); color = K_GetEffectiveFollowerColor(p->followercolor, p->color); } colormap = R_GetTranslationColormap(TC_DEFAULT, color, GTC_MENUCACHE); - V_DrawFixedPatch((x)*FRACUNIT, (y-12)*FRACUNIT+sine, fl.scale, addflags, patch, colormap); + V_DrawFixedPatch((x)*FRACUNIT, ((y-12)*FRACUNIT) + sine - fl.zoffs, fl.scale, addflags, patch, colormap); return true; } @@ -1386,7 +1386,7 @@ static void M_DrawProfileCard(INT32 x, INT32 y, boolean greyedout, profile_t *p) { UINT16 col = K_GetEffectiveFollowerColor(p->followercolor, p->color);; - UINT8 fln = R_FollowerAvailable(p->follower); + UINT8 fln = K_FollowerAvailable(p->follower); if (M_DrawCharacterSprite(x-22, y+119, skinnum, V_FLIP, colormap)) V_DrawMappedPatch(x+14, y+66, 0, faceprefix[skinnum][FACE_RANK], colormap); diff --git a/src/k_menufunc.c b/src/k_menufunc.c index 0bb66ec94..2026747c0 100644 --- a/src/k_menufunc.c +++ b/src/k_menufunc.c @@ -46,7 +46,8 @@ #include "st_stuff.h" #include "i_sound.h" #include "i_time.h" -#include "k_kart.h" // SRB2kart +#include "k_kart.h" +#include "k_follower.h" #include "d_player.h" // KITEM_ constants #include "doomstat.h" // MAXSPLITSCREENPLAYERS #include "k_grandprix.h" // MAXSPLITSCREENPLAYERS @@ -2154,7 +2155,7 @@ static void M_SetupProfileGridPos(setup_player_t *p) INT32 i; // While we're here, read follower values. - p->followern = R_FollowerAvailable(pr->follower); + p->followern = K_FollowerAvailable(pr->follower); p->followercolor = pr->followercolor; // Now position the grid for skin @@ -2769,7 +2770,7 @@ static void M_HandleChooseFollower(setup_player_t *p, UINT8 num) if (menucmd[num].dpad_lr > 0 && numfollowers) { p->followern++; - if (p->followern > numfollowers-1) + if (p->followern >= numfollowers) p->followern = -1; M_SetMenuDelay(num); diff --git a/src/k_objects.h b/src/k_objects.h new file mode 100644 index 000000000..45f9df78c --- /dev/null +++ b/src/k_objects.h @@ -0,0 +1,11 @@ +/* object-specific code */ +#ifndef k_objects_H +#define k_objects_H + +/* Hyudoro */ +void Obj_HyudoroDeploy(mobj_t *master); +void Obj_HyudoroThink(mobj_t *actor); +void Obj_HyudoroCenterThink(mobj_t *actor); +void Obj_HyudoroCollide(mobj_t *special, mobj_t *toucher); + +#endif/*k_objects_H*/ diff --git a/src/k_profiles.h b/src/k_profiles.h index c65b3aed6..53d74470e 100644 --- a/src/k_profiles.h +++ b/src/k_profiles.h @@ -20,6 +20,7 @@ #include "g_input.h" // Input related stuff #include "string.h" // strcpy etc #include "g_game.h" // game CVs +#include "k_follower.h" // followers // We have to redefine this because somehow including r_skins.h causes a redefinition of node_t since that's used for both net nodes and BSP nodes too...... // And honestly I don't wanna refactor that. diff --git a/src/lua_baselib.c b/src/lua_baselib.c index b625d9941..e5f07b0d6 100644 --- a/src/lua_baselib.c +++ b/src/lua_baselib.c @@ -3359,10 +3359,13 @@ static int lib_kPainSound(lua_State *L) static int lib_kHitEmSound(lua_State *L) { mobj_t *mobj = *((mobj_t **)luaL_checkudata(L, 1, META_MOBJ)); + mobj_t *victim = NULL; NOHUD if (!mobj->player) return luaL_error(L, "K_PlayHitEmSound: mobj_t isn't a player object."); //Nothing bad would happen if we let it run the func, but telling why it ain't doing anything is helpful. - K_PlayHitEmSound(mobj); + if (!lua_isnone(L, 2) && lua_isuserdata(L, 2)) + victim = *((mobj_t **)luaL_checkudata(L, 2, META_MOBJ)); + K_PlayHitEmSound(mobj, victim); return 0; } diff --git a/src/lua_hudlib.c b/src/lua_hudlib.c index 8245cb1e8..ad6555541 100644 --- a/src/lua_hudlib.c +++ b/src/lua_hudlib.c @@ -14,6 +14,7 @@ #include "fastcmp.h" #include "r_defs.h" #include "r_local.h" +#include "r_fps.h" #include "st_stuff.h" #include "g_game.h" #include "i_video.h" // rendermode @@ -1394,26 +1395,9 @@ void LUAh_GameHUD(player_t *stplayr, huddrawlist_h list) lua_remove(gL, -3); // pop HUD LUA_PushUserdata(gL, stplayr, META_PLAYER); - if (r_splitscreen > 2 && stplayr == &players[displayplayers[3]]) - { - LUA_PushUserdata(gL, &camera[3], META_CAMERA); - camnum = 4; - } - else if (r_splitscreen > 1 && stplayr == &players[displayplayers[2]]) - { - LUA_PushUserdata(gL, &camera[2], META_CAMERA); - camnum = 3; - } - else if (r_splitscreen && stplayr == &players[displayplayers[1]]) - { - LUA_PushUserdata(gL, &camera[1], META_CAMERA); - camnum = 2; - } - else - { - LUA_PushUserdata(gL, &camera[0], META_CAMERA); - camnum = 1; - } + camnum = R_GetViewNumber(); + LUA_PushUserdata(gL, &camera[camnum], META_CAMERA); + camnum++; // for compatibility lua_pushnil(gL); while (lua_next(gL, -5) != 0) { diff --git a/src/lua_playerlib.c b/src/lua_playerlib.c index 506d6b96a..4b2bad33d 100644 --- a/src/lua_playerlib.c +++ b/src/lua_playerlib.c @@ -239,7 +239,7 @@ static int player_get(lua_State *L) else if (fastcmp(field,"tumbleHeight")) lua_pushinteger(L, plr->tumbleHeight); else if (fastcmp(field,"justDI")) - lua_pushboolean(L, plr->justDI); + lua_pushinteger(L, plr->justDI); else if (fastcmp(field,"flipDI")) lua_pushboolean(L, plr->flipDI); else if (fastcmp(field,"drift")) @@ -356,6 +356,10 @@ static int player_get(lua_State *L) lua_pushinteger(L, plr->lastjawztarget); else if (fastcmp(field,"jawztargetdelay")) lua_pushinteger(L, plr->jawztargetdelay); + else if (fastcmp(field,"confirmInflictor")) + lua_pushinteger(L, plr->confirmInflictor); + else if (fastcmp(field,"confirmInflictorDelay")) + lua_pushinteger(L, plr->confirmInflictorDelay); else if (fastcmp(field,"glanceDir")) lua_pushinteger(L, plr->glanceDir); else if (fastcmp(field,"trickpanel")) @@ -589,7 +593,7 @@ static int player_set(lua_State *L) else if (fastcmp(field,"tumbleHeight")) plr->tumbleHeight = luaL_checkinteger(L, 3); else if (fastcmp(field,"justDI")) - plr->justDI = luaL_checkboolean(L, 3); + plr->justDI = luaL_checkinteger(L, 3); else if (fastcmp(field,"flipDI")) plr->flipDI = luaL_checkboolean(L, 3); else if (fastcmp(field,"drift")) @@ -704,6 +708,10 @@ static int player_set(lua_State *L) plr->lastjawztarget = luaL_checkinteger(L, 3); else if (fastcmp(field,"jawztargetdelay")) plr->jawztargetdelay = luaL_checkinteger(L, 3); + else if (fastcmp(field,"confirmInflictor")) + plr->confirmInflictor = luaL_checkinteger(L, 3); + else if (fastcmp(field,"confirmInflictorDelay")) + plr->confirmInflictorDelay = luaL_checkinteger(L, 3); else if (fastcmp(field,"glanceDir")) plr->glanceDir = luaL_checkinteger(L, 3); else if (fastcmp(field,"trickpanel")) diff --git a/src/lua_script.c b/src/lua_script.c index 3f919439f..8aea589db 100644 --- a/src/lua_script.c +++ b/src/lua_script.c @@ -378,9 +378,6 @@ int LUA_PushGlobals(lua_State *L, const char *word) } else if (fastcmp(word,"indirectitemcooldown")) { lua_pushinteger(L, indirectitemcooldown); return 1; - } else if (fastcmp(word,"hyubgone")) { - lua_pushinteger(L, hyubgone); - return 1; } else if (fastcmp(word,"thwompsactive")) { lua_pushboolean(L, thwompsactive); return 1; @@ -468,8 +465,6 @@ int LUA_WriteGlobals(lua_State *L, const char *word) exitcountdown = (tic_t)luaL_checkinteger(L, 2); else if (fastcmp(word,"indirectitemcooldown")) indirectitemcooldown = (tic_t)luaL_checkinteger(L, 2); - else if (fastcmp(word,"hyubgone")) - hyubgone = (tic_t)luaL_checkinteger(L, 2); else return 0; diff --git a/src/m_fixed.h b/src/m_fixed.h index 49108ab93..9f3bb2910 100644 --- a/src/m_fixed.h +++ b/src/m_fixed.h @@ -37,6 +37,8 @@ #define M_TAU_FIXED 411769 #endif +#define M_PI_FIXED (M_TAU_FIXED >> 1) + typedef INT32 fixed_t; /*! diff --git a/src/objects/Sourcefile b/src/objects/Sourcefile new file mode 100644 index 000000000..f7e4f2491 --- /dev/null +++ b/src/objects/Sourcefile @@ -0,0 +1 @@ +hyudoro.c diff --git a/src/objects/hyudoro.c b/src/objects/hyudoro.c new file mode 100644 index 000000000..af0241fe3 --- /dev/null +++ b/src/objects/hyudoro.c @@ -0,0 +1,481 @@ +#include "../doomdef.h" +#include "../doomstat.h" +#include "../info.h" +#include "../k_kart.h" +#include "../k_objects.h" +#include "../m_random.h" +#include "../p_local.h" +#include "../r_main.h" +#include "../s_sound.h" + +enum { + HYU_PATROL, + HYU_RETURN, + HYU_HOVER, +}; + +// TODO: make these general functions + +static fixed_t +K_GetSpeed (mobj_t *mobj) +{ + return FixedHypot(mobj->momx, mobj->momy); +} + +static void +K_ChangePlayerItem +( player_t * player, + INT32 itemtype, + INT32 itemamount) +{ + player->itemtype = itemtype; + player->itemamount = itemamount; + K_UnsetItemOut(player); +} + +#define hyudoro_mode(o) ((o)->extravalue1) +#define hyudoro_itemtype(o) ((o)->movefactor) +#define hyudoro_itemcount(o) ((o)->movecount) +#define hyudoro_hover_stack(o) ((o)->threshold) +#define hyudoro_next(o) ((o)->tracer) +#define hyudoro_stackpos(o) ((o)->reactiontime) + +// cannot be combined +#define hyudoro_center(o) ((o)->target) +#define hyudoro_target(o) ((o)->target) + +#define hyudoro_center_max_radius(o) ((o)->threshold) +#define hyudoro_center_master(o) ((o)->target) + +static angle_t +trace_angle (mobj_t *hyu) +{ + mobj_t *center = hyu->target; + + if (hyu->x != center->x || hyu->y != center->y) + { + return R_PointToAngle2( + center->x, center->y, hyu->x, hyu->y); + } + else + return hyu->angle; +} + +static angle_t +get_look_angle (mobj_t *thing) +{ + player_t *player = thing->player; + + return player ? player->angleturn : thing->angle; +} + +static boolean +is_hyudoro (mobj_t *thing) +{ + return thing && thing->type == MT_HYUDORO; +} + +static mobj_t * +get_hyudoro_master (mobj_t *hyu) +{ + mobj_t *center = hyudoro_center(hyu); + + return center ? hyudoro_center_master(center) : NULL; +} + +static player_t * +get_hyudoro_target_player (mobj_t *hyu) +{ + mobj_t *target = hyudoro_target(hyu); + + return target ? target->player : NULL; +} + +static void +sine_bob +( mobj_t * hyu, + angle_t a, + fixed_t sineofs) +{ + hyu->sprzoff = FixedMul(hyu->height, + sineofs + FINESINE(a >> ANGLETOFINESHIFT)); +} + +static void +project_hyudoro (mobj_t *hyu) +{ + mobj_t *center = hyudoro_center(hyu); + + angle_t angleStep = FixedMul(5 * ANG1, + FixedDiv(hyudoro_center_max_radius(center), + center->radius)); + + angle_t angle = trace_angle(hyu) + angleStep; + + fixed_t d = center->radius; + + fixed_t x = P_ReturnThrustX(center, angle, d); + fixed_t y = P_ReturnThrustY(center, angle, d); + + hyu->momx = (center->x + x) - hyu->x; + hyu->momy = (center->y + y) - hyu->y; + hyu->angle = angle + ANGLE_90; + + sine_bob(hyu, angle, FRACUNIT); +} + +static void +project_hyudoro_hover (mobj_t *hyu) +{ + const INT32 bob_speed = 64; + + mobj_t *target = hyudoro_target(hyu); + + // Turns a bit toward its target + angle_t ang = get_look_angle(target) + ANGLE_67h; + fixed_t rad = (target->radius * 2) + hyu->radius; + + fixed_t zofs = hyudoro_stackpos(hyu) * + ((target->height / 2) + (hyu->height * 2)); + + P_MoveOrigin(hyu, + target->x - P_ReturnThrustX(hyu, ang, rad), + target->y - P_ReturnThrustY(hyu, ang, rad), + target->z + (zofs * P_MobjFlip(target))); + + // Cancel momentum from HYU_RETURN. + // (And anything else! I don't trust this game!!) + hyu->momx = 0; + hyu->momy = 0; + + hyu->angle = ang; + + // copies sprite tilting + hyu->pitch = target->pitch; + hyu->roll = target->roll; + + sine_bob(hyu, + (leveltime & (bob_speed - 1)) * + (ANGLE_MAX / bob_speed), -(3*FRACUNIT/4)); +} + +static void +spawn_hyudoro_shadow (mobj_t *hyu) +{ + mobj_t *shadow = P_SpawnMobjFromMobj( + hyu, 0, 0, 0, MT_SHADOW); + + shadow->whiteshadow = true; + + shadow->shadowscale = hyu->shadowscale; + hyu->shadowscale = 0; + + P_SetTarget(&shadow->tracer, hyu); +} + +static void +move_to_player (mobj_t *hyu) +{ + mobj_t *target = hyudoro_target(hyu); + + angle_t angle; + + if (!target) + return; + + angle = R_PointToAngle2( + hyu->x, hyu->y, target->x, target->y); + + P_InstaThrust(hyu, angle, (hyu->radius / 2) + + max(hyu->radius, K_GetSpeed(target))); + + hyu->z = target->z; // stay level with target + hyu->angle = angle; +} + +static void +deliver_item (mobj_t *hyu) +{ + mobj_t *target = hyudoro_target(hyu); + player_t *player = target->player; + + P_SetTarget(&hyudoro_target(hyu), NULL); + + if (player) + { + K_ChangePlayerItem(player, + hyudoro_itemtype(hyu), + player->itemamount + hyudoro_itemcount(hyu)); + } + + S_StartSound(target, sfx_itpick); + + // Stop moving here + hyu->momx = 0; + hyu->momy = 0; + + hyu->tics = 4; + + hyu->destscale = target->scale / 4; + hyu->scalespeed = + abs(hyu->scale - hyu->destscale) / hyu->tics; +} + +static void +append_hyudoro +( mobj_t ** head, + mobj_t * hyu) +{ + INT32 lastpos = 0; + + while (is_hyudoro(*head)) + { + lastpos = hyudoro_stackpos(*head); + head = &hyudoro_next(*head); + } + + hyudoro_stackpos(hyu) = lastpos + 1; + *head = hyu; +} + +static void +pop_hyudoro (mobj_t **head) +{ + mobj_t *hyu = *head; + + INT32 lastpos; + INT32 thispos; + + if (is_hyudoro(hyu)) + { + lastpos = hyudoro_stackpos(hyu); + hyu = hyudoro_next(hyu); + + while (is_hyudoro(hyu)) + { + thispos = hyudoro_stackpos(hyu); + + hyudoro_stackpos(hyu) = lastpos; + lastpos = thispos; + + hyu = hyudoro_next(hyu); + } + } + + *head = hyu; +} + +static boolean +hyudoro_patrol_hit_player +( mobj_t * hyu, + mobj_t * toucher) +{ + player_t *player = toucher->player; + + mobj_t *center = hyudoro_center(hyu); + + if (!player) + return false; + + // Cannot hit its master + if (toucher == get_hyudoro_master(hyu)) + return false; + + // Don't punish a punished player + if (player->hyudorotimer) + return false; + + // NO ITEM? + if (!player->itemamount) + return false; + + K_AddHitLag(toucher, TICRATE/2, true); + + hyudoro_mode(hyu) = HYU_RETURN; + hyudoro_itemtype(hyu) = player->itemtype; + hyudoro_itemcount(hyu) = player->itemamount; + + K_StripItems(player); + + player->hyudorotimer = hyudorotime; + player->stealingtimer = hyudorotime; + + P_SetTarget(&hyudoro_target(hyu), + hyudoro_center_master(center)); + + if (center) + P_RemoveMobj(center); + + hyu->renderflags &= ~(RF_DONTDRAW); + + return true; +} + +static boolean +award_immediately (mobj_t *hyu) +{ + player_t *player = get_hyudoro_target_player(hyu); + + if (player) + { + if (player->itemamount && + player->itemtype != hyudoro_itemtype(hyu)) + { + return false; + } + + // Same as picking up paper items; get stacks + // immediately + if (!P_CanPickupItem(player, 3)) + return false; + } + + deliver_item(hyu); + + return true; +} + +static boolean +hyudoro_return_hit_player +( mobj_t * hyu, + mobj_t * toucher) +{ + if (toucher != hyudoro_target(hyu)) + return false; + + // If the player already has an item, just hover beside + // them until they use/lose it. + if (!award_immediately(hyu)) + { + hyudoro_mode(hyu) = HYU_HOVER; + append_hyudoro(&toucher->player->hoverhyudoro, hyu); + } + + return true; +} + +static boolean +hyudoro_hover_await_stack (mobj_t *hyu) +{ + player_t *player = get_hyudoro_target_player(hyu); + + if (!player) + return false; + + // First in stack goes first + if (hyu != player->hoverhyudoro) + return false; + + if (!award_immediately(hyu)) + return false; + + pop_hyudoro(&player->hoverhyudoro); + + return true; +} + +void +Obj_HyudoroDeploy (mobj_t *master) +{ + mobj_t *center = P_SpawnMobjFromMobj( + master, 0, 0, 0, MT_HYUDORO_CENTER); + + mobj_t *hyu = P_SpawnMobjFromMobj( + center, 0, 0, 0, MT_HYUDORO); + + // This allows a Lua override + if (!hyudoro_center_max_radius(center)) + { + hyudoro_center_max_radius(center) = + 128 * center->scale; + } + + center->radius = hyu->radius; + + P_InitAngle(hyu, master->angle); + P_SetTarget(&hyudoro_center(hyu), center); + P_SetTarget(&hyudoro_center_master(center), master); + + hyudoro_mode(hyu) = HYU_PATROL; + + // Set splitscreen player visibility + if (master->player) + { + hyu->renderflags |= RF_DONTDRAW & + ~(K_GetPlayerDontDrawFlag(master->player)); + } + + spawn_hyudoro_shadow(hyu); // this sucks btw + + S_StartSound(master, sfx_s3k92); // scary ghost noise +} + +void +Obj_HyudoroThink (mobj_t *hyu) +{ + // Might get set from clipping slopes + hyu->momz = 0; + + switch (hyudoro_mode(hyu)) + { + case HYU_PATROL: + if (hyudoro_center(hyu)) + project_hyudoro(hyu); + + if (leveltime & 1) + { + mobj_t *ghost = P_SpawnGhostMobj(hyu); + + // Flickers every frame + ghost->extravalue1 = 1; + ghost->extravalue2 = 2; + + // copy per-splitscreen-player visibility + ghost->renderflags = + (hyu->renderflags & RF_DONTDRAW); + + ghost->tics = 8; + + P_SetTarget(&ghost->tracer, hyu); + } + break; + + case HYU_RETURN: + move_to_player(hyu); + break; + + case HYU_HOVER: + if (hyudoro_target(hyu)) + { + project_hyudoro_hover(hyu); + hyudoro_hover_await_stack(hyu); + } + break; + } +} + +void +Obj_HyudoroCenterThink (mobj_t *center) +{ + fixed_t max_radius = hyudoro_center_max_radius(center); + + if (center->radius < max_radius) + center->radius += max_radius / 64; +} + +void +Obj_HyudoroCollide +( mobj_t * hyu, + mobj_t * toucher) +{ + switch (hyudoro_mode(hyu)) + { + case HYU_PATROL: + hyudoro_patrol_hit_player(hyu, toucher); + break; + + case HYU_RETURN: + hyudoro_return_hit_player(hyu, toucher); + break; + } +} diff --git a/src/p_enemy.c b/src/p_enemy.c index 65f00e116..fd8b0f4a6 100644 --- a/src/p_enemy.c +++ b/src/p_enemy.c @@ -4018,7 +4018,7 @@ void A_AttractChase(mobj_t *actor) { fixed_t dist = (4*actor->target->scale) * (16 - actor->extravalue1); - P_SetScale(actor, (actor->destscale = actor->target->scale - ((actor->target->scale/14) * actor->extravalue1))); + P_SetScale(actor, (actor->destscale = mapobjectscale - ((mapobjectscale/14) * actor->extravalue1))); actor->z = actor->target->z; K_MatchGenericExtraFlags(actor, actor->target); P_MoveOrigin(actor, @@ -4573,26 +4573,26 @@ void A_ShootBullet(mobj_t *actor) static mobj_t *minus; -static boolean PIT_MinusCarry(mobj_t *thing) +static BlockItReturn_t PIT_MinusCarry(mobj_t *thing) { if (minus->tracer) - return true; + return BMIT_CONTINUE; if (minus->type == thing->type) - return true; + return BMIT_CONTINUE; if (!(thing->flags & (MF_PUSHABLE|MF_ENEMY))) - return true; + return BMIT_CONTINUE; if (P_AproxDistance(minus->x - thing->x, minus->y - thing->y) >= minus->radius*3) - return true; + return BMIT_CONTINUE; if (abs(thing->z - minus->z) > minus->height) - return true; + return BMIT_CONTINUE; P_SetTarget(&minus->tracer, thing); - return true; + return BMIT_CONTINUE; } // Function: A_MinusDigging @@ -12145,13 +12145,13 @@ static mobj_t *barrel; static fixed_t exploderadius; static fixed_t explodethrust; -static boolean PIT_TNTExplode(mobj_t *nearby) +static BlockItReturn_t PIT_TNTExplode(mobj_t *nearby) { fixed_t dx, dy, dz; fixed_t dm; if (nearby == barrel) - return true; + return BMIT_CONTINUE; dx = nearby->x - barrel->x; dy = nearby->y - barrel->y; @@ -12159,7 +12159,7 @@ static boolean PIT_TNTExplode(mobj_t *nearby) dm = P_AproxDistance(P_AproxDistance(dx, dy), dz); if (dm >= exploderadius || !P_CheckSight(barrel, nearby)) // out of range or not visible - return true; + return BMIT_CONTINUE; if (barrel->type == nearby->type) // nearby is also a barrel { @@ -12200,7 +12200,7 @@ static boolean PIT_TNTExplode(mobj_t *nearby) } } - return true; + return BMIT_CONTINUE; } // Function: A_TNTExplode diff --git a/src/p_inter.c b/src/p_inter.c index 9e98a8808..27455872d 100644 --- a/src/p_inter.c +++ b/src/p_inter.c @@ -37,6 +37,7 @@ #include "k_boss.h" #include "k_respawn.h" #include "p_spec.h" +#include "k_objects.h" // CTF player names #define CTFTEAMCODE(pl) pl->ctfteam ? (pl->ctfteam == 1 ? "\x85" : "\x84") : "" @@ -483,6 +484,10 @@ void P_TouchSpecialThing(mobj_t *special, mobj_t *toucher, boolean heightcheck) S_StartSound(toucher, sfx_s1b2); return; + case MT_HYUDORO: + Obj_HyudoroCollide(special, toucher); + return; + case MT_RING: case MT_FLINGRING: if (special->extravalue1) @@ -1767,8 +1772,7 @@ static boolean P_KillPlayer(player_t *player, mobj_t *inflictor, mobj_t *source, player->carry = CR_NONE; - player->mo->color = player->skincolor; - player->mo->colorized = false; + K_KartResetPlayerColor(player); P_ResetPlayer(player); @@ -2002,7 +2006,7 @@ boolean P_DamageMobj(mobj_t *target, mobj_t *inflictor, mobj_t *source, INT32 da source->player->invincibilitytimer = kinvextend; } - K_PlayHitEmSound(source); + K_PlayHitEmSound(source, target); K_BattleAwardHit(source->player, player, inflictor, takeBumpers); K_TakeBumpersFromPlayer(source->player, player, takeBumpers); diff --git a/src/p_local.h b/src/p_local.h index 4940daf81..82b1d445c 100644 --- a/src/p_local.h +++ b/src/p_local.h @@ -435,7 +435,7 @@ void P_RadiusAttack(mobj_t *spot, mobj_t *source, fixed_t damagedist, UINT8 dama fixed_t P_FloorzAtPos(fixed_t x, fixed_t y, fixed_t z, fixed_t height); fixed_t P_CeilingzAtPos(fixed_t x, fixed_t y, fixed_t z, fixed_t height); -boolean PIT_PushableMoved(mobj_t *thing); +BlockItReturn_t PIT_PushableMoved(mobj_t *thing); boolean P_DoSpring(mobj_t *spring, mobj_t *object); diff --git a/src/p_map.c b/src/p_map.c index f75968169..473ded5fe 100644 --- a/src/p_map.c +++ b/src/p_map.c @@ -523,37 +523,37 @@ static void P_DoFanAndGasJet(mobj_t *spring, mobj_t *object) // // PIT_CheckThing // -static boolean PIT_CheckThing(mobj_t *thing) +static BlockItReturn_t PIT_CheckThing(mobj_t *thing) { fixed_t blockdist; - // don't clip against self - if (thing == tmthing) - return true; + if (tmthing == NULL || P_MobjWasRemoved(tmthing) == true) + return BMIT_STOP; // func just popped our tmthing, cannot continue. // Ignore... things. - if (!tmthing || !thing || P_MobjWasRemoved(thing)) - return true; + if (thing == NULL || P_MobjWasRemoved(thing) == true) + return BMIT_CONTINUE; - I_Assert(!P_MobjWasRemoved(tmthing)); - I_Assert(!P_MobjWasRemoved(thing)); + // don't clip against self + if (thing == tmthing) + return BMIT_CONTINUE; // Ignore spectators if ((tmthing->player && tmthing->player->spectator) || (thing->player && thing->player->spectator)) - return true; + return BMIT_CONTINUE; // Ignore the collision if BOTH things are in hitlag. if (thing->hitlag > 0 && tmthing->hitlag > 0) - return true; + return BMIT_CONTINUE; if ((thing->flags & MF_NOCLIPTHING) || !(thing->flags & (MF_SOLID|MF_SPECIAL|MF_PAIN|MF_SHOOTABLE|MF_SPRING))) - return true; + return BMIT_CONTINUE; blockdist = thing->radius + tmthing->radius; if (abs(thing->x - tmx) >= blockdist || abs(thing->y - tmy) >= blockdist) - return true; // didn't hit it + return BMIT_CONTINUE; // didn't hit it if (thing->flags & MF_PAPERCOLLISION) // CAUTION! Very easy to get stuck inside MF_SOLID objects. Giving the player MF_PAPERCOLLISION is a bad idea unless you know what you're doing. { @@ -580,23 +580,23 @@ static boolean PIT_CheckThing(mobj_t *thing) fixed_t tmcosradius = FixedMul(tmthing->radius, FINECOSINE(tmthing->angle>>ANGLETOFINESHIFT)); fixed_t tmsinradius = FixedMul(tmthing->radius, FINESINE(tmthing->angle>>ANGLETOFINESHIFT)); if (abs(thing->x - tmx) >= (abs(tmcosradius) + abs(cosradius)) || abs(thing->y - tmy) >= (abs(tmsinradius) + abs(sinradius))) - return true; // didn't hit it + return BMIT_CONTINUE; // didn't hit it check1 = P_PointOnLineSide(tmx - tmcosradius, tmy - tmsinradius, &junk); check2 = P_PointOnLineSide(tmx + tmcosradius, tmy + tmsinradius, &junk); check3 = P_PointOnLineSide(tmx + tmthing->momx - tmcosradius, tmy + tmthing->momy - tmsinradius, &junk); check4 = P_PointOnLineSide(tmx + tmthing->momx + tmcosradius, tmy + tmthing->momy + tmsinradius, &junk); if ((check1 == check2) && (check2 == check3) && (check3 == check4)) - return true; // the line doesn't cross between collider's start or end + return BMIT_CONTINUE; // the line doesn't cross between collider's start or end } else { if (abs(thing->x - tmx) >= (tmthing->radius + abs(cosradius)) || abs(thing->y - tmy) >= (tmthing->radius + abs(sinradius))) - return true; // didn't hit it + return BMIT_CONTINUE; // didn't hit it if ((P_PointOnLineSide(tmx - tmthing->radius, tmy - tmthing->radius, &junk) == P_PointOnLineSide(tmx + tmthing->radius, tmy + tmthing->radius, &junk)) && (P_PointOnLineSide(tmx + tmthing->radius, tmy - tmthing->radius, &junk) == P_PointOnLineSide(tmx - tmthing->radius, tmy + tmthing->radius, &junk))) - return true; // the line doesn't cross between either pair of opposite corners + return BMIT_CONTINUE; // the line doesn't cross between either pair of opposite corners } } else if (tmthing->flags & MF_PAPERCOLLISION) @@ -609,7 +609,7 @@ static boolean PIT_CheckThing(mobj_t *thing) tmsinradius = FixedMul(tmthing->radius, FINESINE(tmthing->angle>>ANGLETOFINESHIFT)); if (abs(thing->x - tmx) >= (thing->radius + abs(tmcosradius)) || abs(thing->y - tmy) >= (thing->radius + abs(tmsinradius))) - return true; // didn't hit it + return BMIT_CONTINUE; // didn't hit it v1.x = tmx - tmcosradius; v1.y = tmy - tmsinradius; @@ -626,34 +626,34 @@ static boolean PIT_CheckThing(mobj_t *thing) == P_PointOnLineSide(thing->x + thing->radius, thing->y + thing->radius, &junk)) && (P_PointOnLineSide(thing->x + thing->radius, thing->y - thing->radius, &junk) == P_PointOnLineSide(thing->x - thing->radius, thing->y + thing->radius, &junk))) - return true; // the line doesn't cross between either pair of opposite corners + return BMIT_CONTINUE; // the line doesn't cross between either pair of opposite corners } { UINT8 shouldCollide = LUAh_MobjCollide(thing, tmthing); // checks hook for thing's type if (P_MobjWasRemoved(tmthing) || P_MobjWasRemoved(thing)) - return true; // one of them was removed??? + return BMIT_CONTINUE; // one of them was removed??? if (shouldCollide == 1) - return false; // force collide + return BMIT_ABORT; // force collide else if (shouldCollide == 2) - return true; // force no collide + return BMIT_CONTINUE; // force no collide shouldCollide = LUAh_MobjMoveCollide(tmthing, thing); // checks hook for tmthing's type if (P_MobjWasRemoved(tmthing) || P_MobjWasRemoved(thing)) - return true; // one of them was removed??? + return BMIT_CONTINUE; // one of them was removed??? if (shouldCollide == 1) - return false; // force collide + return BMIT_ABORT; // force collide else if (shouldCollide == 2) - return true; // force no collide + return BMIT_CONTINUE; // force no collide } // When solid spikes move, assume they just popped up and teleport things on top of them to hurt. if (tmthing->type == MT_SPIKE && tmthing->flags & MF_SOLID) { if (thing->z > tmthing->z + tmthing->height) - return true; // overhead + return BMIT_CONTINUE; // overhead if (thing->z + thing->height < tmthing->z) - return true; // underneath + return BMIT_CONTINUE; // underneath if (tmthing->eflags & MFE_VERTICALFLIP) P_SetOrigin(thing, thing->x, thing->y, tmthing->z - thing->height - FixedMul(FRACUNIT, tmthing->scale)); @@ -661,16 +661,16 @@ static boolean PIT_CheckThing(mobj_t *thing) P_SetOrigin(thing, thing->x, thing->y, tmthing->z + tmthing->height + FixedMul(FRACUNIT, tmthing->scale)); if (thing->flags & MF_SHOOTABLE) P_DamageMobj(thing, tmthing, tmthing, 1, 0); - return true; + return BMIT_CONTINUE; } if (thing->flags & MF_PAIN) { // Player touches painful thing sitting on the floor // see if it went over / under if (thing->z > tmthing->z + tmthing->height) - return true; // overhead + return BMIT_CONTINUE; // overhead if (thing->z + thing->height < tmthing->z) - return true; // underneath + return BMIT_CONTINUE; // underneath if (tmthing->flags & MF_SHOOTABLE && thing->health > 0) { UINT32 damagetype = (thing->info->mass & 0xFF); @@ -678,15 +678,15 @@ static boolean PIT_CheckThing(mobj_t *thing) if (P_DamageMobj(tmthing, thing, thing, 1, damagetype) && (damagetype = (thing->info->mass>>8))) S_StartSound(thing, damagetype); } - return true; + return BMIT_CONTINUE; } else if (tmthing->flags & MF_PAIN && thing->player) { // Painful thing splats player in the face // see if it went over / under if (tmthing->z > thing->z + thing->height) - return true; // overhead + return BMIT_CONTINUE; // overhead if (tmthing->z + tmthing->height < thing->z) - return true; // underneath + return BMIT_CONTINUE; // underneath if (thing->flags & MF_SHOOTABLE && tmthing->health > 0) { UINT32 damagetype = (tmthing->info->mass & 0xFF); @@ -694,7 +694,7 @@ static boolean PIT_CheckThing(mobj_t *thing) if (P_DamageMobj(thing, tmthing, tmthing, 1, damagetype) && (damagetype = (tmthing->info->mass>>8))) S_StartSound(tmthing, damagetype); } - return true; + return BMIT_CONTINUE; } // check for skulls slamming into things @@ -702,13 +702,13 @@ static boolean PIT_CheckThing(mobj_t *thing) { // see if it went over / under if (tmthing->z > thing->z + thing->height) - return true; // overhead + return BMIT_CONTINUE; // overhead if (tmthing->z + tmthing->height < thing->z) - return true; // underneath + return BMIT_CONTINUE; // underneath tmthing->flags2 &= ~MF2_SKULLFLY; tmthing->momx = tmthing->momy = tmthing->momz = 0; - return false; // stop moving + return BMIT_ABORT; // stop moving } // SRB2kart 011617 - Colission[sic] code for kart items //{ @@ -717,46 +717,46 @@ static boolean PIT_CheckThing(mobj_t *thing) { // see if it went over / under if (tmthing->z > thing->z + thing->height) - return true; // overhead + return BMIT_CONTINUE; // overhead if (tmthing->z + tmthing->height < thing->z) - return true; // underneath + return BMIT_CONTINUE; // underneath - return K_SMKIceBlockCollide(tmthing, thing); + return K_SMKIceBlockCollide(tmthing, thing) ? BMIT_CONTINUE : BMIT_ABORT; } else if (thing->type == MT_SMK_ICEBLOCK) { // see if it went over / under if (tmthing->z > thing->z + thing->height) - return true; // overhead + return BMIT_CONTINUE; // overhead if (tmthing->z + tmthing->height < thing->z) - return true; // underneath + return BMIT_CONTINUE; // underneath - return K_SMKIceBlockCollide(thing, tmthing); + return K_SMKIceBlockCollide(thing, tmthing) ? BMIT_CONTINUE : BMIT_ABORT; } if (tmthing->type == MT_EGGMANITEM || tmthing->type == MT_EGGMANITEM_SHIELD) { // see if it went over / under if (tmthing->z > thing->z + thing->height) - return true; // overhead + return BMIT_CONTINUE; // overhead if (tmthing->z + tmthing->height < thing->z) - return true; // underneath + return BMIT_CONTINUE; // underneath - return K_EggItemCollide(tmthing, thing); + return K_EggItemCollide(tmthing, thing) ? BMIT_CONTINUE : BMIT_ABORT; } else if (thing->type == MT_EGGMANITEM || thing->type == MT_EGGMANITEM_SHIELD) { // see if it went over / under if (tmthing->z > thing->z + thing->height) - return true; // overhead + return BMIT_CONTINUE; // overhead if (tmthing->z + tmthing->height < thing->z) - return true; // underneath + return BMIT_CONTINUE; // underneath - return K_EggItemCollide(thing, tmthing); + return K_EggItemCollide(thing, tmthing) ? BMIT_CONTINUE : BMIT_ABORT; } if (tmthing->type == MT_RANDOMITEM) - return true; + return BMIT_CONTINUE; // Bubble Shield reflect if (((thing->type == MT_BUBBLESHIELD && thing->target->player && thing->target->player->bubbleblowup) @@ -768,11 +768,11 @@ static boolean PIT_CheckThing(mobj_t *thing) { // see if it went over / under if (tmthing->z > thing->z + thing->height) - return true; // overhead + return BMIT_CONTINUE; // overhead if (tmthing->z + tmthing->height < thing->z) - return true; // underneath + return BMIT_CONTINUE; // underneath - return K_BubbleShieldCollide(thing, tmthing); + return K_BubbleShieldCollide(thing, tmthing) ? BMIT_CONTINUE : BMIT_ABORT; } else if (((tmthing->type == MT_BUBBLESHIELD && tmthing->target->player && tmthing->target->player->bubbleblowup) || (tmthing->player && tmthing->player->bubbleblowup)) @@ -783,16 +783,16 @@ static boolean PIT_CheckThing(mobj_t *thing) { // see if it went over / under if (tmthing->z > thing->z + thing->height) - return true; // overhead + return BMIT_CONTINUE; // overhead if (tmthing->z + tmthing->height < thing->z) - return true; // underneath + return BMIT_CONTINUE; // underneath - return K_BubbleShieldCollide(tmthing, thing); + return K_BubbleShieldCollide(tmthing, thing) ? BMIT_CONTINUE : BMIT_ABORT; } // double make sure bubbles won't collide with anything else if (thing->type == MT_BUBBLESHIELD || tmthing->type == MT_BUBBLESHIELD) - return true; + return BMIT_CONTINUE; // Droptarget reflect if ((thing->type == MT_DROPTARGET || thing->type == MT_DROPTARGET_SHIELD) @@ -803,11 +803,11 @@ static boolean PIT_CheckThing(mobj_t *thing) { // see if it went over / under if (tmthing->z > thing->z + thing->height) - return true; // overhead + return BMIT_CONTINUE; // overhead if (tmthing->z + tmthing->height < thing->z) - return true; // underneath + return BMIT_CONTINUE; // underneath - return K_DropTargetCollide(thing, tmthing); + return K_DropTargetCollide(thing, tmthing) ? BMIT_CONTINUE : BMIT_ABORT; } else if ((tmthing->type == MT_DROPTARGET || tmthing->type == MT_DROPTARGET_SHIELD) && (thing->type == MT_ORBINAUT || thing->type == MT_JAWZ || thing->type == MT_JAWZ_DUD @@ -817,144 +817,144 @@ static boolean PIT_CheckThing(mobj_t *thing) { // see if it went over / under if (tmthing->z > thing->z + thing->height) - return true; // overhead + return BMIT_CONTINUE; // overhead if (tmthing->z + tmthing->height < thing->z) - return true; // underneath + return BMIT_CONTINUE; // underneath - return K_DropTargetCollide(tmthing, thing); + return K_DropTargetCollide(tmthing, thing) ? BMIT_CONTINUE : BMIT_ABORT; } // double make sure drop targets won't collide with anything else if (thing->type == MT_DROPTARGET || tmthing->type == MT_DROPTARGET || thing->type == MT_DROPTARGET_SHIELD || tmthing->type == MT_DROPTARGET_SHIELD) - return true; + return BMIT_CONTINUE; if (tmthing->type == MT_ORBINAUT || tmthing->type == MT_JAWZ || tmthing->type == MT_JAWZ_DUD || tmthing->type == MT_ORBINAUT_SHIELD || tmthing->type == MT_JAWZ_SHIELD) { // see if it went over / under if (tmthing->z > thing->z + thing->height) - return true; // overhead + return BMIT_CONTINUE; // overhead if (tmthing->z + tmthing->height < thing->z) - return true; // underneath + return BMIT_CONTINUE; // underneath - return K_OrbinautJawzCollide(tmthing, thing); + return K_OrbinautJawzCollide(tmthing, thing) ? BMIT_CONTINUE : BMIT_ABORT; } else if (thing->type == MT_ORBINAUT || thing->type == MT_JAWZ || thing->type == MT_JAWZ_DUD || thing->type == MT_ORBINAUT_SHIELD || thing->type == MT_JAWZ_SHIELD) { // see if it went over / under if (tmthing->z > thing->z + thing->height) - return true; // overhead + return BMIT_CONTINUE; // overhead if (tmthing->z + tmthing->height < thing->z) - return true; // underneath + return BMIT_CONTINUE; // underneath - return K_OrbinautJawzCollide(thing, tmthing); + return K_OrbinautJawzCollide(thing, tmthing) ? BMIT_CONTINUE : BMIT_ABORT; } if (tmthing->type == MT_BANANA || tmthing->type == MT_BANANA_SHIELD || tmthing->type == MT_BALLHOG) { // see if it went over / under if (tmthing->z > thing->z + thing->height) - return true; // overhead + return BMIT_CONTINUE; // overhead if (tmthing->z + tmthing->height < thing->z) - return true; // underneath + return BMIT_CONTINUE; // underneath - return K_BananaBallhogCollide(tmthing, thing); + return K_BananaBallhogCollide(tmthing, thing) ? BMIT_CONTINUE : BMIT_ABORT; } else if (thing->type == MT_BANANA || thing->type == MT_BANANA_SHIELD || thing->type == MT_BALLHOG) { // see if it went over / under if (tmthing->z > thing->z + thing->height) - return true; // overhead + return BMIT_CONTINUE; // overhead if (tmthing->z + tmthing->height < thing->z) - return true; // underneath + return BMIT_CONTINUE; // underneath - return K_BananaBallhogCollide(thing, tmthing); + return K_BananaBallhogCollide(thing, tmthing) ? BMIT_CONTINUE : BMIT_ABORT; } if (tmthing->type == MT_SSMINE || tmthing->type == MT_SSMINE_SHIELD) { // see if it went over / under if (tmthing->z > thing->z + thing->height) - return true; // overhead + return BMIT_CONTINUE; // overhead if (tmthing->z + tmthing->height < thing->z) - return true; // underneath + return BMIT_CONTINUE; // underneath - return K_MineCollide(tmthing, thing); + return K_MineCollide(tmthing, thing) ? BMIT_CONTINUE : BMIT_ABORT; } else if (thing->type == MT_SSMINE || thing->type == MT_SSMINE_SHIELD) { // see if it went over / under if (tmthing->z > thing->z + thing->height) - return true; // overhead + return BMIT_CONTINUE; // overhead if (tmthing->z + tmthing->height < thing->z) - return true; // underneath + return BMIT_CONTINUE; // underneath - return K_MineCollide(thing, tmthing); + return K_MineCollide(thing, tmthing) ? BMIT_CONTINUE : BMIT_ABORT; } if (tmthing->type == MT_LANDMINE) { // see if it went over / under if (tmthing->z > thing->z + thing->height) - return true; // overhead + return BMIT_CONTINUE; // overhead if (tmthing->z + tmthing->height < thing->z) - return true; // underneath + return BMIT_CONTINUE; // underneath - return K_LandMineCollide(tmthing, thing); + return K_LandMineCollide(tmthing, thing) ? BMIT_CONTINUE : BMIT_ABORT; } else if (thing->type == MT_LANDMINE) { // see if it went over / under if (tmthing->z > thing->z + thing->height) - return true; // overhead + return BMIT_CONTINUE; // overhead if (tmthing->z + tmthing->height < thing->z) - return true; // underneath + return BMIT_CONTINUE; // underneath - return K_LandMineCollide(thing, tmthing); + return K_LandMineCollide(thing, tmthing) ? BMIT_CONTINUE : BMIT_ABORT; } if (tmthing->type == MT_SINK) { // see if it went over / under if (tmthing->z > thing->z + thing->height) - return true; // overhead + return BMIT_CONTINUE; // overhead if (tmthing->z + tmthing->height < thing->z) - return true; // underneath + return BMIT_CONTINUE; // underneath - return K_KitchenSinkCollide(tmthing, thing); + return K_KitchenSinkCollide(tmthing, thing) ? BMIT_CONTINUE : BMIT_ABORT; } else if (thing->type == MT_SINK) { // see if it went over / under if (tmthing->z > thing->z + thing->height) - return true; // overhead + return BMIT_CONTINUE; // overhead if (tmthing->z + tmthing->height < thing->z) - return true; // underneath + return BMIT_CONTINUE; // underneath - return K_KitchenSinkCollide(thing, tmthing); + return K_KitchenSinkCollide(thing, tmthing) ? BMIT_CONTINUE : BMIT_ABORT; } if (tmthing->type == MT_FALLINGROCK) { // see if it went over / under if (tmthing->z > thing->z + thing->height) - return true; // overhead + return BMIT_CONTINUE; // overhead if (tmthing->z + tmthing->height < thing->z) - return true; // underneath + return BMIT_CONTINUE; // underneath - return K_FallingRockCollide(tmthing, thing); + return K_FallingRockCollide(tmthing, thing) ? BMIT_CONTINUE : BMIT_ABORT; } else if (thing->type == MT_FALLINGROCK) { // see if it went over / under if (tmthing->z > thing->z + thing->height) - return true; // overhead + return BMIT_CONTINUE; // overhead if (tmthing->z + tmthing->height < thing->z) - return true; // underneath + return BMIT_CONTINUE; // underneath - return K_FallingRockCollide(thing, tmthing); + return K_FallingRockCollide(thing, tmthing) ? BMIT_CONTINUE : BMIT_ABORT; } //} @@ -972,10 +972,10 @@ static boolean PIT_CheckThing(mobj_t *thing) if (tmznext <= thzh) { P_DoSpring(thing, tmthing); - // return true; + // return BMIT_CONTINUE; } //else if (tmz > thzh - sprarea && tmz < thzh) // Don't damage people springing up / down - return true; + return BMIT_CONTINUE; } // missiles can hit other things @@ -985,35 +985,35 @@ static boolean PIT_CheckThing(mobj_t *thing) // see if it went over / under if (tmthing->z > thing->z + thing->height) - return true; // overhead + return BMIT_CONTINUE; // overhead if (tmthing->z + tmthing->height < thing->z) - return true; // underneath + return BMIT_CONTINUE; // underneath if (tmthing->target && tmthing->target->type == thing->type) { // Don't hit same species as originator. if (thing == tmthing->target) - return true; + return BMIT_CONTINUE; if (thing->type != MT_PLAYER) { // Explode, but do no damage. // Let players missile other players. - return false; + return BMIT_ABORT; } } if (!(thing->flags & MF_SHOOTABLE)) { // didn't do any damage - return !(thing->flags & MF_SOLID); + return (thing->flags & MF_SOLID) ? BMIT_ABORT : BMIT_CONTINUE; } // damage / explode P_DamageMobj(thing, tmthing, tmthing->target, 1, damagetype); // don't traverse any more - return false; + return BMIT_ABORT; } if (thing->flags & MF_PUSHABLE && (tmthing->player || tmthing->flags & MF_PUSHABLE) @@ -1080,13 +1080,13 @@ static boolean PIT_CheckThing(mobj_t *thing) if (thing->flags & MF_SPECIAL && tmthing->player) { P_TouchSpecialThing(thing, tmthing, true); // can remove thing - return true; + return BMIT_CONTINUE; } // check again for special pickup if (tmthing->flags & MF_SPECIAL && thing->player) { P_TouchSpecialThing(tmthing, thing, true); // can remove thing - return true; + return BMIT_CONTINUE; } // Sprite Spikes! @@ -1142,7 +1142,7 @@ static boolean PIT_CheckThing(mobj_t *thing) if (playerangle > ANGLE_180) playerangle = InvAngle(playerangle); if (playerangle < ANGLE_90) - return true; // Yes, this is intentionally outside the z-height check. No standing on spikes whilst moving away from them. + return BMIT_CONTINUE; // Yes, this is intentionally outside the z-height check. No standing on spikes whilst moving away from them. } bottomz = thing->z; @@ -1176,15 +1176,15 @@ static boolean PIT_CheckThing(mobj_t *thing) if (thing->type == MT_FAN || thing->type == MT_STEAM) { P_DoFanAndGasJet(thing, tmthing); - return true; + return BMIT_CONTINUE; } else if (thing->flags & MF_SPRING) { if ( thing->z <= tmthing->z + tmthing->height && tmthing->z <= thing->z + thing->height) if (P_DoSpring(thing, tmthing)) - return false; - return true; + return BMIT_ABORT; + return BMIT_CONTINUE; } } @@ -1193,7 +1193,7 @@ static boolean PIT_CheckThing(mobj_t *thing) { if ((thing->z + thing->height >= tmthing->z) && (tmthing->z + tmthing->height >= thing->z)) - return false; + return BMIT_ABORT; } if (thing->player) @@ -1205,7 +1205,7 @@ static boolean PIT_CheckThing(mobj_t *thing) if (tmthing->player) // Is the moving/interacting object the player? { if (!tmthing->health) - return true; + return BMIT_CONTINUE; if (thing->type == MT_FAN || thing->type == MT_STEAM) P_DoFanAndGasJet(thing, tmthing); @@ -1214,27 +1214,27 @@ static boolean PIT_CheckThing(mobj_t *thing) if ( thing->z <= tmthing->z + tmthing->height && tmthing->z <= thing->z + thing->height) if (P_DoSpring(thing, tmthing)) - return false; - return true; + return BMIT_ABORT; + return BMIT_CONTINUE; } else if (thing->player) // bounce when players collide { // see if it went over / under if (tmthing->z > thing->z + thing->height) - return true; // overhead + return BMIT_CONTINUE; // overhead if (tmthing->z + tmthing->height < thing->z) - return true; // underneath + return BMIT_CONTINUE; // underneath if (thing->player->hyudorotimer || tmthing->player->hyudorotimer) { - return true; + return BMIT_CONTINUE; } if ((gametyperules & GTR_BUMPERS) && ((thing->player->bumpers && !tmthing->player->bumpers) || (tmthing->player->bumpers && !thing->player->bumpers))) { - return true; + return BMIT_CONTINUE; } // The bump has to happen last @@ -1252,18 +1252,18 @@ static boolean PIT_CheckThing(mobj_t *thing) K_PvPTouchDamage(tmthing, thing); } - return true; + return BMIT_CONTINUE; } else if (thing->type == MT_BLUEROBRA_HEAD || thing->type == MT_BLUEROBRA_JOINT) { // see if it went over / under if (tmthing->z > thing->z + thing->height) - return true; // overhead + return BMIT_CONTINUE; // overhead if (tmthing->z + tmthing->height < thing->z) - return true; // underneath + return BMIT_CONTINUE; // underneath if (!thing->health) - return true; // dead + return BMIT_CONTINUE; // dead if (tmthing->player->invincibilitytimer > 0 || tmthing->player->growshrinktimer > 0) @@ -1272,42 +1272,42 @@ static boolean PIT_CheckThing(mobj_t *thing) P_KillMobj(thing->target, tmthing, tmthing, DMG_NORMAL); else P_KillMobj(thing, tmthing, tmthing, DMG_NORMAL); - return true; + return BMIT_CONTINUE; } else { K_KartSolidBounce(tmthing, thing); - return true; + return BMIT_CONTINUE; } } else if (thing->type == MT_SMK_PIPE) { // see if it went over / under if (tmthing->z > thing->z + thing->height) - return true; // overhead + return BMIT_CONTINUE; // overhead if (tmthing->z + tmthing->height < thing->z) - return true; // underneath + return BMIT_CONTINUE; // underneath if (!thing->health) - return true; // dead + return BMIT_CONTINUE; // dead if (tmthing->player->invincibilitytimer > 0 || tmthing->player->growshrinktimer > 0) { P_KillMobj(thing, tmthing, tmthing, DMG_NORMAL); - return true; // kill + return BMIT_CONTINUE; // kill } K_KartSolidBounce(tmthing, thing); - return true; + return BMIT_CONTINUE; } else if (thing->type == MT_SMK_THWOMP) { if (!thing->health) - return true; // dead + return BMIT_CONTINUE; // dead if (!thwompsactive) - return true; // not active yet + return BMIT_CONTINUE; // not active yet if ((tmthing->z < thing->z) && (thing->z >= thing->movefactor-(256<z > thing->z + thing->height) - return true; // overhead + return BMIT_CONTINUE; // overhead if (tmthing->z + tmthing->height < thing->z) - return true; // underneath + return BMIT_CONTINUE; // underneath // kill if (tmthing->player->invincibilitytimer > 0 || tmthing->player->growshrinktimer > 0) { P_KillMobj(thing, tmthing, tmthing, DMG_NORMAL); - return true; + return BMIT_CONTINUE; } // no interaction if (tmthing->player->flashing > 0 || tmthing->player->hyudorotimer > 0 || tmthing->player->spinouttimer > 0) - return true; + return BMIT_CONTINUE; // collide if (tmthing->z < thing->z && thing->momz < 0) @@ -1344,29 +1344,29 @@ static boolean PIT_CheckThing(mobj_t *thing) } } - return true; + return BMIT_CONTINUE; } else if (thing->type == MT_KART_LEFTOVER) { // see if it went over / under if (tmthing->z > thing->z + thing->height) - return true; // overhead + return BMIT_CONTINUE; // overhead if (tmthing->z + tmthing->height < thing->z) - return true; // underneath + return BMIT_CONTINUE; // underneath K_KartBouncing(tmthing, thing); - return true; + return BMIT_CONTINUE; } else if (thing->flags & MF_SOLID) { // see if it went over / under if (tmthing->z > thing->z + thing->height) - return true; // overhead + return BMIT_CONTINUE; // overhead if (tmthing->z + tmthing->height < thing->z) - return true; // underneath + return BMIT_CONTINUE; // underneath K_KartSolidBounce(tmthing, thing); - return true; + return BMIT_CONTINUE; } } @@ -1393,7 +1393,7 @@ static boolean PIT_CheckThing(mobj_t *thing) tmfloorslope = NULL; tmfloorpic = -1; } - return true; + return BMIT_CONTINUE; } topz = thing->z - thing->scale; // FixedMul(FRACUNIT, thing->scale), but thing->scale == FRACUNIT in base scale anyways @@ -1406,7 +1406,7 @@ static boolean PIT_CheckThing(mobj_t *thing) && tmthing->z + tmthing->height < tmthing->ceilingz) { if (thing->flags & MF_GRENADEBOUNCE && (thing->flags & MF_MONITOR || thing->info->flags & MF_MONITOR)) // Gold monitor hack... - return false; + return BMIT_ABORT; tmfloorz = tmceilingz = topz; // block while in air tmceilingrover = NULL; @@ -1437,7 +1437,7 @@ static boolean PIT_CheckThing(mobj_t *thing) tmceilingslope = NULL; tmceilingpic = -1; } - return true; + return BMIT_CONTINUE; } topz = thing->z + thing->height + thing->scale; // FixedMul(FRACUNIT, thing->scale), but thing->scale == FRACUNIT in base scale anyways @@ -1450,7 +1450,7 @@ static boolean PIT_CheckThing(mobj_t *thing) && tmthing->z > tmthing->floorz) { if (thing->flags & MF_GRENADEBOUNCE && (thing->flags & MF_MONITOR || thing->info->flags & MF_MONITOR)) // Gold monitor hack... - return false; + return BMIT_ABORT; tmfloorz = tmceilingz = topz; // block while in air tmfloorrover = NULL; @@ -1470,24 +1470,24 @@ static boolean PIT_CheckThing(mobj_t *thing) } // not solid not blocked - return true; + return BMIT_CONTINUE; } // PIT_CheckCameraLine // Adjusts tmfloorz and tmceilingz as lines are contacted - FOR CAMERA ONLY -static boolean PIT_CheckCameraLine(line_t *ld) +static BlockItReturn_t PIT_CheckCameraLine(line_t *ld) { if (ld->polyobj && !(ld->polyobj->flags & POF_SOLID)) - return true; + return BMIT_CONTINUE; if (tmbbox[BOXRIGHT] <= ld->bbox[BOXLEFT] || tmbbox[BOXLEFT] >= ld->bbox[BOXRIGHT] || tmbbox[BOXTOP] <= ld->bbox[BOXBOTTOM] || tmbbox[BOXBOTTOM] >= ld->bbox[BOXTOP]) { - return true; + return BMIT_CONTINUE; } if (P_BoxOnLineSide(tmbbox, ld) != -1) - return true; + return BMIT_CONTINUE; // A line has been hit @@ -1505,8 +1505,8 @@ static boolean PIT_CheckCameraLine(line_t *ld) if (!ld->backsector) // one sided line { if (P_PointOnLineSide(mapcampointer->x, mapcampointer->y, ld)) - return true; // don't hit the back side - return false; + return BMIT_CONTINUE; // don't hit the back side + return BMIT_ABORT; } // set openrange, opentop, openbottom @@ -1530,7 +1530,7 @@ static boolean PIT_CheckCameraLine(line_t *ld) if (lowfloor < tmdropoffz) tmdropoffz = lowfloor; - return true; + return BMIT_CONTINUE; } boolean P_IsLineBlocking(const line_t *ld, const mobj_t *thing) @@ -1559,19 +1559,19 @@ boolean P_IsLineTripWire(const line_t *ld) // PIT_CheckLine // Adjusts tmfloorz and tmceilingz as lines are contacted // -static boolean PIT_CheckLine(line_t *ld) +static BlockItReturn_t PIT_CheckLine(line_t *ld) { const fixed_t thingtop = tmthing->z + tmthing->height; if (ld->polyobj && !(ld->polyobj->flags & POF_SOLID)) - return true; + return BMIT_CONTINUE; if (tmbbox[BOXRIGHT] <= ld->bbox[BOXLEFT] || tmbbox[BOXLEFT] >= ld->bbox[BOXRIGHT] || tmbbox[BOXTOP] <= ld->bbox[BOXBOTTOM] || tmbbox[BOXBOTTOM] >= ld->bbox[BOXTOP]) - return true; + return BMIT_CONTINUE; if (P_BoxOnLineSide(tmbbox, ld) != -1) - return true; + return BMIT_CONTINUE; if (tmthing->flags & MF_PAPERCOLLISION) // Caution! Turning whilst up against a wall will get you stuck. You probably shouldn't give the player this flag. { @@ -1580,7 +1580,7 @@ static boolean PIT_CheckLine(line_t *ld) sinradius = FixedMul(tmthing->radius, FINESINE(tmthing->angle>>ANGLETOFINESHIFT)); if (P_PointOnLineSide(tmx - cosradius, tmy - sinradius, ld) == P_PointOnLineSide(tmx + cosradius, tmy + sinradius, ld)) - return true; // the line doesn't cross between collider's start or end + return BMIT_CONTINUE; // the line doesn't cross between collider's start or end #ifdef PAPER_COLLISIONCORRECTION { fixed_t dist; @@ -1616,22 +1616,22 @@ static boolean PIT_CheckLine(line_t *ld) { UINT8 shouldCollide = LUAh_MobjLineCollide(tmthing, blockingline); // checks hook for thing's type if (P_MobjWasRemoved(tmthing)) - return true; // one of them was removed??? + return BMIT_CONTINUE; // one of them was removed??? if (shouldCollide == 1) - return false; // force collide + return BMIT_ABORT; // force collide else if (shouldCollide == 2) - return true; // force no collide + return BMIT_CONTINUE; // force no collide } if (!ld->backsector) // one sided line { if (P_PointOnLineSide(tmthing->x, tmthing->y, ld)) - return true; // don't hit the back side - return false; + return BMIT_CONTINUE; // don't hit the back side + return BMIT_ABORT; } if (P_IsLineBlocking(ld, tmthing)) - return false; + return BMIT_ABORT; // set openrange, opentop, openbottom P_LineOpening(ld, tmthing); @@ -1676,7 +1676,7 @@ static boolean PIT_CheckLine(line_t *ld) add_spechit(ld); } - return true; + return BMIT_CONTINUE; } // ========================================================================= @@ -2322,32 +2322,32 @@ boolean P_TryCameraMove(fixed_t x, fixed_t y, camera_t *thiscam) static mobj_t *stand; static fixed_t standx, standy; -boolean PIT_PushableMoved(mobj_t *thing) +BlockItReturn_t PIT_PushableMoved(mobj_t *thing) { fixed_t blockdist; if (!(thing->flags & MF_SOLID) || (thing->flags & MF_NOGRAVITY)) - return true; // Don't move something non-solid! + return BMIT_CONTINUE; // Don't move something non-solid! // Only pushables are supported... in 2.0. Now players can be moved too! if (!(thing->flags & MF_PUSHABLE || thing->player)) - return true; + return BMIT_CONTINUE; if (thing == stand) - return true; + return BMIT_CONTINUE; blockdist = stand->radius + thing->radius; if (abs(thing->x - stand->x) >= blockdist || abs(thing->y - stand->y) >= blockdist) - return true; // didn't hit it + return BMIT_CONTINUE; // didn't hit it if ((!(stand->eflags & MFE_VERTICALFLIP) && thing->z != stand->z + stand->height + FixedMul(FRACUNIT, stand->scale)) || ((stand->eflags & MFE_VERTICALFLIP) && thing->z + thing->height != stand->z - FixedMul(FRACUNIT, stand->scale))) - return true; // Not standing on top + return BMIT_CONTINUE; // Not standing on top if (!stand->momx && !stand->momy) - return true; + return BMIT_CONTINUE; // Move this guy! if (thing->player) @@ -2396,7 +2396,7 @@ boolean PIT_PushableMoved(mobj_t *thing) thing->momy = stand->momy; thing->momz = stand->momz; } - return true; + return BMIT_CONTINUE; } static boolean P_WaterRunning(mobj_t *thing) @@ -3952,18 +3952,18 @@ static boolean bombsightcheck; // "bombsource" is the creature // that caused the explosion at "bombspot". // -static boolean PIT_RadiusAttack(mobj_t *thing) +static BlockItReturn_t PIT_RadiusAttack(mobj_t *thing) { fixed_t dx, dy, dz, dist; if (thing == bombspot) // ignore the bomb itself (Deton fix) - return true; + return BMIT_CONTINUE; if ((bombdamagetype & DMG_CANTHURTSELF) && bombsource && thing->type == bombsource->type) // ignore the type of guys who dropped the bomb (Jetty-Syn Bomber or Skim can bomb eachother, but not themselves.) - return true; + return BMIT_CONTINUE; if ((thing->flags & (MF_MONITOR|MF_SHOOTABLE)) != MF_SHOOTABLE) - return true; + return BMIT_CONTINUE; dx = abs(thing->x - bombspot->x); dy = abs(thing->y - bombspot->y); @@ -3976,20 +3976,20 @@ static boolean PIT_RadiusAttack(mobj_t *thing) dist = 0; if (dist >= bombdamage) - return true; // out of range + return BMIT_CONTINUE; // out of range if (thing->floorz > bombspot->z && bombspot->ceilingz < thing->z) - return true; + return BMIT_CONTINUE; if (thing->ceilingz < bombspot->z && bombspot->floorz > thing->z) - return true; + return BMIT_CONTINUE; if (!bombsightcheck || P_CheckSight(thing, bombspot)) { // must be in direct path P_DamageMobj(thing, bombspot, bombsource, 1, bombdamagetype); // Tails 01-11-2001 } - return true; + return BMIT_CONTINUE; } // @@ -4623,19 +4623,19 @@ void P_DelPrecipSeclist(mprecipsecnode_t *node) // at this location, so don't bother with checking impassable or // blocking lines. -static inline boolean PIT_GetSectors(line_t *ld) +static inline BlockItReturn_t PIT_GetSectors(line_t *ld) { if (tmbbox[BOXRIGHT] <= ld->bbox[BOXLEFT] || tmbbox[BOXLEFT] >= ld->bbox[BOXRIGHT] || tmbbox[BOXTOP] <= ld->bbox[BOXBOTTOM] || tmbbox[BOXBOTTOM] >= ld->bbox[BOXTOP]) - return true; + return BMIT_CONTINUE; if (P_BoxOnLineSide(tmbbox, ld) != -1) - return true; + return BMIT_CONTINUE; if (ld->polyobj) // line belongs to a polyobject, don't add it - return true; + return BMIT_CONTINUE; // This line crosses through the object. @@ -4654,23 +4654,23 @@ static inline boolean PIT_GetSectors(line_t *ld) if (ld->backsector) sector_list = P_AddSecnode(ld->backsector, tmthing, sector_list); - return true; + return BMIT_CONTINUE; } // Tails 08-25-2002 -static inline boolean PIT_GetPrecipSectors(line_t *ld) +static inline BlockItReturn_t PIT_GetPrecipSectors(line_t *ld) { if (preciptmbbox[BOXRIGHT] <= ld->bbox[BOXLEFT] || preciptmbbox[BOXLEFT] >= ld->bbox[BOXRIGHT] || preciptmbbox[BOXTOP] <= ld->bbox[BOXBOTTOM] || preciptmbbox[BOXBOTTOM] >= ld->bbox[BOXTOP]) - return true; + return BMIT_CONTINUE; if (P_BoxOnLineSide(preciptmbbox, ld) != -1) - return true; + return BMIT_CONTINUE; if (ld->polyobj) // line belongs to a polyobject, don't add it - return true; + return BMIT_CONTINUE; // This line crosses through the object. @@ -4689,7 +4689,7 @@ static inline boolean PIT_GetPrecipSectors(line_t *ld) if (ld->backsector) precipsector_list = P_AddPrecipSecnode(ld->backsector, tmprecipthing, precipsector_list); - return true; + return BMIT_CONTINUE; } // P_CreateSecNodeList alters/creates the sector_list that shows what sectors diff --git a/src/p_maputl.c b/src/p_maputl.c index 555928a3a..37a24267c 100644 --- a/src/p_maputl.c +++ b/src/p_maputl.c @@ -1096,7 +1096,7 @@ void P_SetPrecipitationThingPosition(precipmobj_t *thing) // to P_BlockLinesIterator, then make one or more calls // to it. // -boolean P_BlockLinesIterator(INT32 x, INT32 y, boolean (*func)(line_t *)) +boolean P_BlockLinesIterator(INT32 x, INT32 y, BlockItReturn_t (*func)(line_t *)) { INT32 offset; const INT32 *list; // Big blockmap @@ -1122,11 +1122,22 @@ boolean P_BlockLinesIterator(INT32 x, INT32 y, boolean (*func)(line_t *)) for (i = 0; i < po->numLines; ++i) { + BlockItReturn_t ret = BMIT_CONTINUE; + if (po->lines[i]->validcount == validcount) // line has been checked continue; + po->lines[i]->validcount = validcount; - if (!func(po->lines[i])) + ret = func(po->lines[i]); + + if (ret == BMIT_ABORT) + { return false; + } + else if (ret == BMIT_STOP) + { + return true; + } } } plink = (polymaplink_t *)(plink->link.next); @@ -1137,15 +1148,24 @@ boolean P_BlockLinesIterator(INT32 x, INT32 y, boolean (*func)(line_t *)) // First index is really empty, so +1 it. for (list = blockmaplump + offset + 1; *list != -1; list++) { + BlockItReturn_t ret = BMIT_CONTINUE; + ld = &lines[*list]; if (ld->validcount == validcount) continue; // Line has already been checked. ld->validcount = validcount; + ret = func(ld); - if (!func(ld)) + if (ret == BMIT_ABORT) + { return false; + } + else if (ret == BMIT_STOP) + { + return true; + } } return true; // Everything was checked. } @@ -1154,7 +1174,7 @@ boolean P_BlockLinesIterator(INT32 x, INT32 y, boolean (*func)(line_t *)) // // P_BlockThingsIterator // -boolean P_BlockThingsIterator(INT32 x, INT32 y, boolean (*func)(mobj_t *)) +boolean P_BlockThingsIterator(INT32 x, INT32 y, BlockItReturn_t (*func)(mobj_t *)) { mobj_t *mobj, *bnext = NULL; @@ -1164,19 +1184,25 @@ boolean P_BlockThingsIterator(INT32 x, INT32 y, boolean (*func)(mobj_t *)) // Check interaction with the objects in the blockmap. for (mobj = blocklinks[y*bmapwidth + x]; mobj; mobj = bnext) { + BlockItReturn_t ret = BMIT_CONTINUE; + P_SetTarget(&bnext, mobj->bnext); // We want to note our reference to bnext here incase it is MF_NOTHINK and gets removed! - if (!func(mobj)) + ret = func(mobj); + + if (ret == BMIT_ABORT) { P_SetTarget(&bnext, NULL); - return false; + return false; // failure } - if (P_MobjWasRemoved(tmthing) // func just popped our tmthing, cannot continue. - || (bnext && P_MobjWasRemoved(bnext))) // func just broke blockmap chain, cannot continue. + + if ((ret == BMIT_STOP) + || (bnext && P_MobjWasRemoved(bnext))) // func just broke blockmap chain, cannot continue. { P_SetTarget(&bnext, NULL); - return true; + return true; // success } } + return true; } @@ -1220,7 +1246,7 @@ static void P_CheckIntercepts(void) // are on opposite sides of the trace. // Returns true if earlyout and a solid line hit. // -static boolean PIT_AddLineIntercepts(line_t *ld) +static BlockItReturn_t PIT_AddLineIntercepts(line_t *ld) { INT32 s1, s2; fixed_t frac; @@ -1243,18 +1269,18 @@ static boolean PIT_AddLineIntercepts(line_t *ld) } if (s1 == s2) - return true; // Line isn't crossed. + return BMIT_CONTINUE; // Line isn't crossed. // Hit the line. P_MakeDivline(ld, &dl); frac = P_InterceptVector(&trace, &dl); if (frac < 0) - return true; // Behind source. + return BMIT_CONTINUE; // Behind source. // Try to take an early out of the check. if (earlyout && frac < FRACUNIT && !ld->backsector) - return false; // stop checking + return BMIT_ABORT; // stop checking P_CheckIntercepts(); @@ -1263,13 +1289,13 @@ static boolean PIT_AddLineIntercepts(line_t *ld) intercept_p->d.line = ld; intercept_p++; - return true; // continue + return BMIT_CONTINUE; // continue } // // PIT_AddThingIntercepts // -static boolean PIT_AddThingIntercepts(mobj_t *thing) +static BlockItReturn_t PIT_AddThingIntercepts(mobj_t *thing) { fixed_t px1, py1, px2, py2, frac; INT32 s1, s2; @@ -1300,7 +1326,7 @@ static boolean PIT_AddThingIntercepts(mobj_t *thing) s2 = P_PointOnDivlineSide(px2, py2, &trace); if (s1 == s2) - return true; // Line isn't crossed. + return BMIT_CONTINUE; // Line isn't crossed. dl.x = px1; dl.y = py1; @@ -1310,7 +1336,7 @@ static boolean PIT_AddThingIntercepts(mobj_t *thing) frac = P_InterceptVector(&trace, &dl); if (frac < 0) - return true; // Behind source. + return BMIT_CONTINUE; // Behind source. P_CheckIntercepts(); @@ -1319,7 +1345,7 @@ static boolean PIT_AddThingIntercepts(mobj_t *thing) intercept_p->d.thing = thing; intercept_p++; - return true; // Keep going. + return BMIT_CONTINUE; // Keep going. } // diff --git a/src/p_maputl.h b/src/p_maputl.h index 43a7fb507..c17ad5d33 100644 --- a/src/p_maputl.h +++ b/src/p_maputl.h @@ -67,8 +67,15 @@ extern INT32 opentoppic, openbottompic; void P_LineOpening(line_t *plinedef, mobj_t *mobj); -boolean P_BlockLinesIterator(INT32 x, INT32 y, boolean(*func)(line_t *)); -boolean P_BlockThingsIterator(INT32 x, INT32 y, boolean(*func)(mobj_t *)); +typedef enum +{ + BMIT_CONTINUE, // Continue blockmap search + BMIT_STOP, // End blockmap search with success + BMIT_ABORT // End blockmap search with failure +} BlockItReturn_t; + +boolean P_BlockLinesIterator(INT32 x, INT32 y, BlockItReturn_t(*func)(line_t *)); +boolean P_BlockThingsIterator(INT32 x, INT32 y, BlockItReturn_t(*func)(mobj_t *)); #define PT_ADDLINES 1 #define PT_ADDTHINGS 2 diff --git a/src/p_mobj.c b/src/p_mobj.c index e7e825944..d35b44c73 100644 --- a/src/p_mobj.c +++ b/src/p_mobj.c @@ -44,6 +44,7 @@ #include "k_bot.h" #include "k_terrain.h" #include "k_collide.h" +#include "k_objects.h" static CV_PossibleValue_t CV_BobSpeed[] = {{0, "MIN"}, {4*FRACUNIT, "MAX"}, {0, NULL}}; consvar_t cv_movebob = CVAR_INIT ("movebob", "1.0", CV_FLOAT|CV_SAVE, CV_BobSpeed, NULL); @@ -5293,6 +5294,20 @@ static void P_MobjSceneryThink(mobj_t *mobj) switch (mobj->type) { + case MT_SHADOW: + if (mobj->tracer) + { + P_MoveOrigin(mobj, + mobj->tracer->x, + mobj->tracer->y, + mobj->tracer->z); + } + else + { + P_RemoveMobj(mobj); + return; + } + break; case MT_BOSSJUNK: mobj->renderflags ^= RF_DONTDRAW; break; @@ -7664,6 +7679,16 @@ static boolean P_MobjRegularThink(mobj_t *mobj) } break; } + case MT_HYUDORO: + { + Obj_HyudoroThink(mobj); + break; + } + case MT_HYUDORO_CENTER: + { + Obj_HyudoroCenterThink(mobj); + break; + } case MT_ROCKETSNEAKER: if (!mobj->target || !mobj->target->health) { @@ -8590,8 +8615,7 @@ static boolean P_MobjRegularThink(mobj_t *mobj) if (mobj->extravalue1) { const INT32 speed = 6*TICRATE; // longer is slower - const fixed_t pi = 22*FRACUNIT/7; // Inaccurate, but is close enough for our usage - fixed_t sine = FINESINE((((2*pi*speed) * leveltime) >> ANGLETOFINESHIFT) & FINEMASK) * flip; + fixed_t sine = FINESINE((((M_TAU_FIXED * speed) * leveltime) >> ANGLETOFINESHIFT) & FINEMASK) * flip; // Flying capsules are flipped upside-down, like S3K flip = -flip; @@ -9179,14 +9203,19 @@ void P_MobjThinker(mobj_t *mobj) { if (mobj->extravalue2 >= 2) { + UINT32 dontdraw = RF_DONTDRAW; + + if (mobj->tracer) + dontdraw &= ~(mobj->tracer->renderflags); + if (mobj->extravalue2 == 2) // I don't know why the normal logic doesn't work for this. - mobj->renderflags ^= RF_DONTDRAW; + mobj->renderflags ^= dontdraw; else { if (mobj->fuse == mobj->extravalue2) - mobj->renderflags &= ~RF_DONTDRAW; + mobj->renderflags &= ~(dontdraw); else - mobj->renderflags |= RF_DONTDRAW; + mobj->renderflags |= dontdraw; } } } @@ -9647,6 +9676,7 @@ static void P_DefaultMobjShadowScale(mobj_t *thing) case MT_SSMINE_SHIELD: case MT_LANDMINE: case MT_BALLHOG: + case MT_HYUDORO: case MT_SINK: case MT_ROCKETSNEAKER: case MT_SPB: diff --git a/src/p_saveg.c b/src/p_saveg.c index 8e7115c3f..5d1a49835 100644 --- a/src/p_saveg.c +++ b/src/p_saveg.c @@ -63,6 +63,7 @@ typedef enum FOLLOWER = 0x04, SKYBOXVIEW = 0x08, SKYBOXCENTER = 0x10, + HOVERHYUDORO = 0x20, } player_saveflags; static inline void P_ArchivePlayer(void) @@ -196,6 +197,9 @@ static void P_NetArchivePlayers(void) if (players[i].skybox.centerpoint) flags |= SKYBOXCENTER; + if (players[i].hoverhyudoro) + flags |= HOVERHYUDORO; + WRITEUINT16(save_p, flags); if (flags & SKYBOXVIEW) @@ -210,6 +214,9 @@ static void P_NetArchivePlayers(void) if (flags & FOLLOWITEM) WRITEUINT32(save_p, players[i].followmobj->mobjnum); + if (flags & HOVERHYUDORO) + WRITEUINT32(save_p, players[i].hoverhyudoro->mobjnum); + WRITEUINT32(save_p, (UINT32)players[i].followitem); WRITEUINT32(save_p, players[i].charflags); @@ -326,6 +333,9 @@ static void P_NetArchivePlayers(void) WRITESINT8(save_p, players[i].lastjawztarget); WRITEUINT8(save_p, players[i].jawztargetdelay); + WRITEUINT8(save_p, players[i].confirmInflictor); + WRITEUINT8(save_p, players[i].confirmInflictorDelay); + WRITEUINT8(save_p, players[i].trickpanel); WRITEUINT8(save_p, players[i].tricktime); WRITEUINT32(save_p, players[i].trickboostpower); @@ -482,6 +492,9 @@ static void P_NetUnArchivePlayers(void) if (flags & FOLLOWITEM) players[i].followmobj = (mobj_t *)(size_t)READUINT32(save_p); + if (flags & HOVERHYUDORO) + players[i].hoverhyudoro = (mobj_t *)(size_t)READUINT32(save_p); + players[i].followitem = (mobjtype_t)READUINT32(save_p); //SetPlayerSkinByNum(i, players[i].skin); @@ -518,7 +531,7 @@ static void P_NetUnArchivePlayers(void) players[i].tumbleBounces = READUINT8(save_p); players[i].tumbleHeight = READUINT16(save_p); - players[i].justDI = (boolean)READUINT8(save_p); + players[i].justDI = READUINT8(save_p); players[i].flipDI = (boolean)READUINT8(save_p); players[i].drift = READSINT8(save_p); @@ -599,6 +612,9 @@ static void P_NetUnArchivePlayers(void) players[i].lastjawztarget = READSINT8(save_p); players[i].jawztargetdelay = READUINT8(save_p); + players[i].confirmInflictor = READUINT8(save_p); + players[i].confirmInflictorDelay = READUINT8(save_p); + players[i].trickpanel = READUINT8(save_p); players[i].tricktime = READUINT8(save_p); players[i].trickboostpower = READUINT32(save_p); @@ -4230,6 +4246,13 @@ static void P_RelinkPointers(void) CONS_Debug(DBG_GAMELOGIC, "respawn.wp not found on %d\n", mobj->type); } } + if (mobj->player->hoverhyudoro) + { + temp = (UINT32)(size_t)mobj->player->hoverhyudoro; + mobj->player->hoverhyudoro = NULL; + if (!P_SetTarget(&mobj->player->hoverhyudoro, P_FindNewPosition(temp))) + CONS_Debug(DBG_GAMELOGIC, "hoverhyudoro not found on %d\n", mobj->type); + } } } } @@ -4482,7 +4505,6 @@ static void P_NetArchiveMisc(boolean resending) WRITEUINT32(save_p, wantedcalcdelay); WRITEUINT32(save_p, indirectitemcooldown); - WRITEUINT32(save_p, hyubgone); WRITEUINT32(save_p, mapreset); for (i = 0; i < MAXPLAYERS; i++) @@ -4632,7 +4654,6 @@ static inline boolean P_NetUnArchiveMisc(boolean reloading) wantedcalcdelay = READUINT32(save_p); indirectitemcooldown = READUINT32(save_p); - hyubgone = READUINT32(save_p); mapreset = READUINT32(save_p); for (i = 0; i < MAXPLAYERS; i++) diff --git a/src/p_setup.c b/src/p_setup.c index f6a499a99..91074cc71 100644 --- a/src/p_setup.c +++ b/src/p_setup.c @@ -4406,7 +4406,6 @@ boolean P_LoadLevel(boolean fromnetsave, boolean reloadinggamestate) wantedcalcdelay = wantedfrequency*2; indirectitemcooldown = 0; - hyubgone = 0; mapreset = 0; for (i = 0; i < MAXPLAYERS; i++) @@ -4510,6 +4509,10 @@ boolean P_LoadLevel(boolean fromnetsave, boolean reloadinggamestate) if (rendermode == render_none || reloadinggamestate) return true; + R_ResetViewInterpolation(0); + R_ResetViewInterpolation(0); + R_UpdateMobjInterpolators(); + // Title card! G_StartTitleCard(); diff --git a/src/p_spec.c b/src/p_spec.c index b6079e6cf..56e7ae455 100644 --- a/src/p_spec.c +++ b/src/p_spec.c @@ -8390,13 +8390,13 @@ static pusher_t *tmpusher; // pusher structure for blockmap searches * ::tmpusher won't need to be used. * \sa T_Pusher */ -static inline boolean PIT_PushThing(mobj_t *thing) +static inline BlockItReturn_t PIT_PushThing(mobj_t *thing) { if (thing->eflags & MFE_PUSHED) - return false; + return BMIT_ABORT; if (!tmpusher->source) - return false; + return BMIT_ABORT; // Allow this to affect pushable objects at some point? if (thing->player && !(thing->flags & (MF_NOGRAVITY | MF_NOCLIP))) @@ -8416,7 +8416,7 @@ static inline boolean PIT_PushThing(mobj_t *thing) { // Make sure the Z is in range if (thing->z < sz - tmpusher->radius || thing->z > sz + tmpusher->radius) - return false; + return BMIT_ABORT; dist = P_AproxDistance(P_AproxDistance(thing->x - sx, thing->y - sy), thing->z - sz); @@ -8482,7 +8482,7 @@ static inline boolean PIT_PushThing(mobj_t *thing) if (tmpusher->exclusive) thing->eflags |= MFE_PUSHED; - return true; + return BMIT_CONTINUE; } /** Applies a pusher to all affected objects. diff --git a/src/p_tick.c b/src/p_tick.c index a7dc0e3f1..ce45f48f3 100644 --- a/src/p_tick.c +++ b/src/p_tick.c @@ -685,8 +685,6 @@ void P_Ticker(boolean run) if (indirectitemcooldown > 0) indirectitemcooldown--; - if (hyubgone > 0) - hyubgone--; K_BossInfoTicker(); diff --git a/src/p_user.c b/src/p_user.c index c52f0d4a1..cc93fb65c 100644 --- a/src/p_user.c +++ b/src/p_user.c @@ -56,6 +56,7 @@ #include "k_boss.h" #include "k_terrain.h" // K_SpawnSplashForMobj #include "k_color.h" +#include "k_follower.h" #ifdef HW3SOUND #include "hardware/hw3sound.h" @@ -1093,6 +1094,11 @@ boolean P_IsMachineLocalPlayer(player_t *player) { UINT8 i; + if (player == NULL) + { + return false; + } + for (i = 0; i <= r_splitscreen; i++) { if (player == &players[g_localplayers[i]]) @@ -1113,6 +1119,11 @@ boolean P_IsLocalPlayer(player_t *player) { UINT8 i; + if (player == NULL) + { + return false; + } + // nobody is ever local when watching something back - you're a spectator there, even if your g_localplayers might say otherwise if (demo.playback) return false; @@ -1141,6 +1152,11 @@ boolean P_IsDisplayPlayer(player_t *player) { UINT8 i; + if (player == NULL) + { + return false; + } + for (i = 0; i <= r_splitscreen; i++) // DON'T skip P1 { if (player == &players[displayplayers[i]]) @@ -1676,8 +1692,7 @@ static void P_CheckInvincibilityTimer(player_t *player) // Resume normal music stuff. if (player->invincibilitytimer == 1) { - player->mo->color = player->skincolor; - player->mo->colorized = false; + //K_KartResetPlayerColor(player); -- this gets called every tic anyways G_GhostAddColor((INT32) (player - players), GHC_NORMAL); P_RestoreMusic(player); @@ -1988,13 +2003,46 @@ static void P_3dMovement(player_t *player) static void P_UpdatePlayerAngle(player_t *player) { angle_t angleChange = ANGLE_MAX; + UINT8 p = UINT8_MAX; UINT8 i; - K_UpdateSteeringValue(player, player->cmd.turning); + for (i = 0; i <= splitscreen; i++) + { + if (player == &players[g_localplayers[i]]) + { + p = i; + break; + } + } + + player->steering = K_UpdateSteeringValue(player->steering, player->cmd.turning); angleChange = K_GetKartTurnValue(player, player->steering) << TICCMD_REDUCE; - P_SetPlayerAngle(player, player->angleturn + angleChange); - player->mo->angle = player->angleturn; + if (p == UINT8_MAX) + { + // When F12ing players, set local angle directly. + P_SetPlayerAngle(player, player->angleturn + angleChange); + player->mo->angle = player->angleturn; + } + else + { + UINT8 lateTic = ((leveltime - player->cmd.latency) & TICCMD_LATENCYMASK); + UINT8 clearTic = ((localtic + 1) & TICCMD_LATENCYMASK); + + player->angleturn += angleChange; + player->mo->angle = player->angleturn; + + // Undo the ticcmd's old emulated angle, + // now that we added the actual game logic angle. + + while (lateTic != clearTic) + { + localdelta[p] -= localstoredeltas[p][lateTic]; + localstoredeltas[p][lateTic] = 0; + + lateTic = (lateTic - 1) & TICCMD_LATENCYMASK; + } + } if (!cv_allowmlook.value || player->spectator == false) { @@ -2006,13 +2054,9 @@ static void P_UpdatePlayerAngle(player_t *player) player->aiming = G_ClipAimingPitch((INT32 *)&player->aiming); } - for (i = 0; i <= r_splitscreen; i++) + if (p != UINT8_MAX) { - if (player == &players[displayplayers[i]]) - { - localaiming[i] = player->aiming; - break; - } + localaiming[p] = player->aiming; } } @@ -2098,7 +2142,7 @@ void P_MovePlayer(player_t *player) if (cmd->turning == 0) { - player->justDI = false; + player->justDI = 0; } // Kart frames @@ -2635,8 +2679,7 @@ static void P_DeathThink(player_t *player) if (!player->mo) return; - player->mo->colorized = false; - player->mo->color = player->skincolor; + //K_KartResetPlayerColor(player); -- called at death, don't think we need to re-establish P_CalcHeight(player); } @@ -3580,7 +3623,11 @@ boolean P_MoveChaseCamera(player_t *player, camera_t *thiscam, boolean resetcall } if (lookbackdown) + { P_MoveChaseCamera(player, thiscam, false); + R_ResetViewInterpolation(num + 1); + R_ResetViewInterpolation(num + 1); + } return (x == thiscam->x && y == thiscam->y && z == thiscam->z && angle == thiscam->aiming); @@ -3915,281 +3962,6 @@ static void P_ParabolicMove(mobj_t *mo, fixed_t x, fixed_t y, fixed_t z, fixed_t #endif -/* set follower state with our weird hacks - the reason we do this is to avoid followers ever using actions (majormods, yikes!) - without having to touch p_mobj.c. - so we give it 1more tic and change the state when tic == 1 instead of 0 - cool beans? - cool beans. -*/ -static void P_SetFollowerState(mobj_t *f, INT32 state) -{ - - if (!f || P_MobjWasRemoved(f)) - return; // safety net - - // No, do NOT set the follower to S_NULL. Set it to S_INVISIBLE. - if (state == S_NULL) - { - state = S_INVISIBLE; - f->threshold = 1; // Threshold = 1 means stop doing anything related to setting states, so that we don't get out of S_INVISIBLE - } - - // extravalue2 stores the last "first state" we used. - // because states default to idlestates, if we use an animation that uses an "ongoing" state line, don't reset it! - // this prevents it from looking very dumb - if (state == f->extravalue2) - return; - - // we will save the state into extravalue2. - f->extravalue2 = state; - - P_SetMobjStateNF(f, state); - if (f->state->tics > 0) - f->tics++; -} - -UINT16 K_GetEffectiveFollowerColor(UINT16 followercolor, UINT16 playercolor) -{ - if (followercolor < numskincolors) // bog standard - return followercolor; - if (followercolor == FOLLOWERCOLOR_OPPOSITE) // "Opposite" - return skincolors[playercolor].invcolor; - //if (followercolor == FOLLOWERCOLOR_MATCH) -- "Match" - return playercolor; -} - -// -//P_HandleFollower -// -//Handle the follower's spawning and moving along with the player. Do note that some of the stuff like the removal if a player doesn't exist anymore is handled in MT_FOLLOWER's thinker. -static void P_HandleFollower(player_t *player) -{ - follower_t fl; - angle_t an; - fixed_t zoffs; - fixed_t sx, sy, sz, deltaz; - UINT16 color; - - fixed_t bubble; // bubble scale (0 if no bubble) - mobj_t *bmobj; // temp bubble mobj - - - if (!player->followerready) - return; // we aren't ready to perform anything follower related yet. - - // How about making sure our follower exists and is added before trying to spawn it n' all? - if (player->followerskin > numfollowers-1 || player->followerskin < -1) - { - //CONS_Printf("Follower skin invlaid. Setting to -1.\n"); - player->followerskin = -1; - return; - } - - // don't do anything if we can't have a follower to begin with. (It gets removed under those conditions) - if (player->spectator) - return; - if (player->followerskin < 0) - return; - // Before we do anything, let's be sure of where we're supposed to be - fl = followers[player->followerskin]; - - an = player->mo->angle + (fl.atangle)*ANG1; // it's aproximative but it really doesn't matter in the grand scheme of things... - zoffs = (fl.zoffs)*FRACUNIT; - bubble = fl.bubblescale; // 0 if no bubble to spawn. - - // do you like angle maths? I certainly don't... - sx = player->mo->x + FixedMul((player->mo->scale*fl.dist), FINECOSINE((an)>>ANGLETOFINESHIFT)); - sy = player->mo->y + FixedMul((player->mo->scale*fl.dist), FINESINE((an)>>ANGLETOFINESHIFT)); - - // interp info helps with stretchy fix - deltaz = (player->mo->z - player->mo->old_z); - - // for the z coordinate, don't be a doof like Steel and forget that MFE_VERTICALFLIP exists :P - sz = player->mo->z + FixedMul(player->mo->scale, zoffs)*P_MobjFlip(player->mo); - if (player->mo->eflags & MFE_VERTICALFLIP) - sz += fl.height*player->mo->scale; - - // finally, add a cool floating effect to the z height. - // not stolen from k_kart I swear!! - { - const fixed_t pi = (22<>ANGLETOFINESHIFT) & FINEMASK); - sz += FixedMul(player->mo->scale, sine)*P_MobjFlip(player->mo); - } - - color = K_GetEffectiveFollowerColor(player->followercolor, player->skincolor); - - if (!player->follower) // follower doesn't exist / isn't valid - { - //CONS_Printf("Spawning follower...\n"); - // so let's spawn one! - P_SetTarget(&player->follower, P_SpawnMobj(sx, sy, sz, MT_FOLLOWER)); - P_SetFollowerState(player->follower, fl.idlestate); - P_SetTarget(&player->follower->target, player->mo); // we need that to know when we need to disappear - P_InitAngle(player->follower, player->mo->angle); - - // This is safe to only spawn it here, the follower is removed then respawned when switched. - if (bubble) - { - bmobj = P_SpawnMobj(player->follower->x, player->follower->y, player->follower->z, MT_FOLLOWERBUBBLE_FRONT); - P_SetTarget(&player->follower->hnext, bmobj); - P_SetTarget(&bmobj->target, player->follower); // Used to know if we have to despawn at some point. - - bmobj = P_SpawnMobj(player->follower->x, player->follower->y, player->follower->z, MT_FOLLOWERBUBBLE_BACK); - P_SetTarget(&player->follower->hnext->hnext, bmobj); // this seems absolutely stupid, I know, but this will make updating the momentums/flags of these a bit easier. - P_SetTarget(&bmobj->target, player->follower); // Ditto - } - - player->follower->extravalue1 = 0; // extravalue1 is used to know what "state set" to use. - /* - 0 = idle - 1 = forwards - 2 = hurt - 3 = win - 4 = lose - 5 = hitconfirm (< this one uses ->movecount as timer to know when to end, and goes back to normal states afterwards, unless hurt) - */ - } - else // follower exists, woo! - { - - // Safety net (2) - - if (P_MobjWasRemoved(player->follower)) - { - P_SetTarget(&player->follower, NULL); // Remove this and respawn one, don't crash the game if Lua decides to P_RemoveMobj this thing. - return; - } - - // first of all, handle states following the same model as above: - if (player->follower->tics == 1) - P_SetFollowerState(player->follower, player->follower->state->nextstate); - - // move the follower next to us (yes, this is really basic maths but it looks pretty damn clean in practice)! - // 02/09/2021: cast lag to int32 otherwise funny things happen since it was changed to uint32 in the struct - player->follower->momx = (sx - player->follower->x)/ (INT32)fl.horzlag; - player->follower->momy = (sy - player->follower->y)/ (INT32)fl.horzlag; - player->follower->z += (deltaz/ (INT32)fl.vertlag); - player->follower->momz = (sz - player->follower->z)/ (INT32)fl.vertlag; - player->follower->angle = player->mo->angle; - - if (player->mo->colorized) - player->follower->color = player->mo->color; - else - player->follower->color = color; - - player->follower->colorized = player->mo->colorized; - - P_SetScale(player->follower, FixedMul(fl.scale, player->mo->scale)); - K_GenericExtraFlagsNoZAdjust(player->follower, player->mo); // Not K_MatchGenericExtraFlag because the Z adjust it has only works properly if master & mo have the same Z height. - - // Match how the player is being drawn - player->follower->renderflags = player->mo->renderflags; - - // Make the follower invisible if we no contest'd rather than removing it. No one will notice the diff seriously. - if (player->pflags & PF_NOCONTEST) - player->follower->renderflags |= RF_DONTDRAW; - - // if we're moving let's make the angle the direction we're moving towards. This is to avoid drifting / reverse looking awkward. - player->follower->angle = K_MomentumAngle(player->follower); - - // Finally, if the follower has bubbles, move them, set their scale, etc.... - // This is what I meant earlier by it being easier, now we can just use this weird lil loop to get the job done! - - bmobj = player->follower->hnext; // will be NULL if there's no bubble - - while (bmobj && !P_MobjWasRemoved(bmobj)) - { - // match follower's momentums and (e)flags(2). - bmobj->momx = player->follower->momx; - bmobj->momy = player->follower->momy; - bmobj->z += (deltaz/ (INT32)fl.vertlag); - bmobj->momz = player->follower->momz; - - P_SetScale(bmobj, FixedMul(bubble, player->mo->scale)); - K_GenericExtraFlagsNoZAdjust(bmobj, player->follower); - bmobj->renderflags = player->mo->renderflags; - - if (player->follower->threshold) // threshold means the follower was "despawned" with S_NULL (is actually just set to S_INVISIBLE) - P_SetMobjState(bmobj, S_INVISIBLE); // sooooo... let's do the same! - - bmobj = bmobj->hnext; // switch to other bubble layer or exit - } - - - if (player->follower->threshold) - return; // Threshold means the follower was "despanwed" with S_NULL. - - // However with how the code is factored, this is just a special case of S_INVISBLE to avoid having to add other player variables. - - - // handle follower animations. Could probably be better... - // hurt or dead - if (player->spinouttimer || player->mo->state == &states[S_KART_SPINOUT] || player->mo->health <= 0) - { - player->follower->movecount = 0; // cancel hit confirm. - player->follower->angle = player->drawangle; // spin out - if (player->follower->extravalue1 != 2) - { - player->follower->extravalue1 = 2; - P_SetFollowerState(player->follower, fl.hurtstate); - } - if (player->mo->health <= 0) // if dead, follow the player's z momentum exactly so they both look like they die at the same speed. - player->follower->momz = player->mo->momz; - } - else if (player->follower->movecount) - { - if (player->follower->extravalue1 != 5) - { - player->follower->extravalue1 = 5; - P_SetFollowerState(player->follower, fl.hitconfirmstate); - } - player->follower->movecount--; - } - else if (player->speed > 10*player->mo->scale) // animation for moving fast enough - { - - if (player->follower->extravalue1 != 1) - { - player->follower->extravalue1 = 1; - P_SetFollowerState(player->follower, fl.followstate); - } - } - else // animations when nearly still. This includes winning and losing. - { - if (player->follower->extravalue1 != 0) - { - - if (player->exiting) // win/ loss animations - { - if (K_IsPlayerLosing(player)) // L - { - if (player->follower->extravalue1 != 4) - { - player->follower->extravalue1 = 4; - P_SetFollowerState(player->follower, fl.losestate); - } - } - else // W - { - if (player->follower->extravalue1 != 3) - { - player->follower->extravalue1 = 3; - P_SetFollowerState(player->follower, fl.winstate); - } - } - } - else // normal standstill - { - player->follower->extravalue1 = 0; - P_SetFollowerState(player->follower, fl.idlestate); - } - } - } - } -} - /* gaysed script from me, based on Golden's sprite slope roll */ // holy SHIT @@ -4307,7 +4079,6 @@ void P_PlayerThink(player_t *player) } player->old_drawangle = player->drawangle; - player->old_viewrollangle = player->viewrollangle; player->pflags &= ~PF_HITFINISHLINE; @@ -4317,9 +4088,6 @@ void P_PlayerThink(player_t *player) player->awayviewtics = 0; // reset to zero } - // Run followes here. We need them to run even when we're dead to follow through what we're doing. - P_HandleFollower(player); - if (player->flashcount) player->flashcount--; @@ -4734,11 +4502,15 @@ void P_PlayerAfterThink(player_t *player) if (player->playerstate == PST_DEAD) { + // Followers need handled while dead. + K_HandleFollower(player); + if (player->followmobj) { P_RemoveMobj(player->followmobj); P_SetTarget(&player->followmobj, NULL); } + return; } @@ -4811,6 +4583,10 @@ void P_PlayerAfterThink(player_t *player) } } } + + // Run followers in AfterThink, after the players have moved, + // so a lag value of 1 is exactly attached to the player. + K_HandleFollower(player); } void P_SetPlayerAngle(player_t *player, angle_t angle) @@ -4845,6 +4621,7 @@ void P_ForceLocalAngle(player_t *player, angle_t angle) if (player == &players[displayplayers[i]]) { localangle[i] = angle; + G_ResetAnglePrediction(player); break; } } diff --git a/src/r_data.h b/src/r_data.h index be92c094e..3c8908a59 100644 --- a/src/r_data.h +++ b/src/r_data.h @@ -40,7 +40,6 @@ extern INT16 color8to16[256]; // remap color index to highcolor extern INT16 *hicolormaps; // remap high colors to high colors.. extern CV_PossibleValue_t Color_cons_t[]; -extern CV_PossibleValue_t Followercolor_cons_t[]; // follower colours table, not a duplicate because of the "Match" option. // I/O, setting up the stuff. void R_InitTextureData(void); diff --git a/src/r_draw.c b/src/r_draw.c index d9f892423..7488ab5aa 100644 --- a/src/r_draw.c +++ b/src/r_draw.c @@ -194,7 +194,6 @@ static INT32 CacheIndexToSkin(INT32 ttc) } CV_PossibleValue_t Color_cons_t[MAXSKINCOLORS+1]; -CV_PossibleValue_t Followercolor_cons_t[MAXSKINCOLORS+3]; // +3 to account for "Match", "Opposite" & NULL #define TRANSTAB_AMTMUL10 (255.0f / 10.0f) diff --git a/src/r_fps.c b/src/r_fps.c index 6f4281687..aff481910 100644 --- a/src/r_fps.c +++ b/src/r_fps.c @@ -163,22 +163,7 @@ void R_InterpolateView(fixed_t frac) if (frac > FRACUNIT) frac = FRACUNIT; - if (viewcontext == VIEWCONTEXT_SKY1 || viewcontext == VIEWCONTEXT_PLAYER1) - { - i = 0; - } - else if (viewcontext == VIEWCONTEXT_SKY2 || viewcontext == VIEWCONTEXT_PLAYER2) - { - i = 1; - } - else if (viewcontext == VIEWCONTEXT_SKY3 || viewcontext == VIEWCONTEXT_PLAYER3) - { - i = 2; - } - else - { - i = 3; - } + i = R_GetViewNumber(); if (oldview_invalid[i] != 0) { diff --git a/src/r_fps.h b/src/r_fps.h index a91f7004e..41fc65af0 100644 --- a/src/r_fps.h +++ b/src/r_fps.h @@ -36,6 +36,10 @@ enum viewcontext_e VIEWCONTEXT_SKY4 }; +extern enum viewcontext_e viewcontext; + +#define R_GetViewNumber() ((viewcontext - VIEWCONTEXT_PLAYER1) & 3) + typedef struct { fixed_t x; fixed_t y; diff --git a/src/r_skins.c b/src/r_skins.c index ba7ed0811..ae5e0363c 100644 --- a/src/r_skins.c +++ b/src/r_skins.c @@ -27,6 +27,9 @@ #include "p_local.h" #include "dehacked.h" // get_number (for thok) #include "m_cond.h" +#if 0 +#include "k_kart.h" // K_KartResetPlayerColor +#endif #ifdef HWRENDER #include "hardware/hw_md2.h" #endif @@ -34,8 +37,6 @@ INT32 numskins = 0; skin_t skins[MAXSKINS]; -INT32 numfollowers = 0; - // FIXTHIS: don't work because it must be inistilised before the config load //#define SKINVALUES #ifdef SKINVALUES @@ -44,9 +45,6 @@ CV_PossibleValue_t skin_cons_t[MAXSKINS+1]; CV_PossibleValue_t Forceskin_cons_t[MAXSKINS+2]; -// SRB2Kart followers -follower_t followers[MAXSKINS]; - // // P_GetSkinSprite2 // For non-super players, tries each sprite2's immediate predecessor until it finds one with a number of frames or ends up at standing. @@ -285,7 +283,7 @@ void SetPlayerSkinByNum(INT32 playernum, INT32 skinnum) { player_t *player = &players[playernum]; skin_t *skin = &skins[skinnum]; - UINT16 newcolor = 0; + //UINT16 newcolor = 0; //UINT8 i; if (skinnum >= 0 && skinnum < numskins && R_SkinUsable(playernum, skinnum)) // Make sure it exists! @@ -311,6 +309,7 @@ void SetPlayerSkinByNum(INT32 playernum, INT32 skinnum) } player->skincolor = newcolor = skin->prefcolor; + K_KartResetPlayerColor(player); } #endif @@ -323,12 +322,6 @@ void SetPlayerSkinByNum(INT32 playernum, INT32 skinnum) if (player->mo) { player->mo->skin = skin; - - if (newcolor) - { - player->mo->color = newcolor; - } - P_SetScale(player->mo, player->mo->scale); P_SetPlayerMobjState(player->mo, player->mo->state-states); // Prevent visual errors when switching between skins with differing number of frames } @@ -860,97 +853,3 @@ next_token: } #undef SYMBOLCONVERT - -// SRB2Kart: Followers! -// TODO: put this stuff in its own file? - -// same thing as R_SkinAvailable, but for followers -INT32 R_FollowerAvailable(const char *name) -{ - INT32 i; - - for (i = 0; i < numfollowers; i++) - { - if (stricmp(followers[i].skinname,name)==0) - return i; - } - return -1; -} - -// same thing as SetPlayerSkin, but for followers -boolean SetPlayerFollower(INT32 playernum, const char *skinname) -{ - INT32 i; - player_t *player = &players[playernum]; - - if (stricmp("None", skinname) == 0) - { - SetFollower(playernum, -1); // reminder that -1 is nothing - return true; - } - for (i = 0; i < numfollowers; i++) - { - // search in the skin list - if (stricmp(followers[i].skinname, skinname) == 0) - { - SetFollower(playernum, i); - return true; - } - } - - if (P_IsLocalPlayer(player)) - CONS_Alert(CONS_WARNING, M_GetText("Follower '%s' not found.\n"), skinname); - else if(server || IsPlayerAdmin(consoleplayer)) - CONS_Alert(CONS_WARNING, M_GetText("Player %d (%s) follower '%s' not found\n"), playernum, player_names[playernum], skinname); - - SetFollower(playernum, -1); // reminder that -1 is nothing - return false; -} - -// SetPlayerSkinByNum, for followers -void SetFollower(INT32 playernum, INT32 skinnum) -{ - player_t *player = &players[playernum]; - mobj_t *bub; - mobj_t *tmp; - - player->followerready = true; // we are ready to perform follower related actions in the player thinker, now. - - if (skinnum >= -1 && skinnum <= numfollowers) // Make sure it exists! - { - /* - We don't spawn the follower here since it'll be easier to handle all of it in the Player thinker itself. - However, we will despawn it right here if there's any to make it easy for the player thinker to replace it or delete it. - */ - - if (player->follower && skinnum != player->followerskin) // this is also called when we change colour so don't respawn the follower unless we changed skins - { - // Remove follower's possible hnext list (bubble) - bub = player->follower->hnext; - - while (bub && !P_MobjWasRemoved(bub)) - { - tmp = bub->hnext; - P_RemoveMobj(bub); - bub = tmp; - } - - P_RemoveMobj(player->follower); - P_SetTarget(&player->follower, NULL); - } - - player->followerskin = skinnum; - - // for replays: We have changed our follower mid-game; let the game know so it can do the same in the replay! - demo_extradata[playernum] |= DXD_FOLLOWER; - - return; - } - - if (P_IsLocalPlayer(player)) - CONS_Alert(CONS_WARNING, M_GetText("Follower %d not found\n"), skinnum); - else if(server || IsPlayerAdmin(consoleplayer)) - CONS_Alert(CONS_WARNING, "Player %d (%s) follower %d not found\n", playernum, player_names[playernum], skinnum); - - SetFollower(playernum, -1); // Not found, then set -1 (nothing) as our follower. -} diff --git a/src/r_skins.h b/src/r_skins.h index 95de83788..cffd54da8 100644 --- a/src/r_skins.h +++ b/src/r_skins.h @@ -90,54 +90,4 @@ void R_AddSkins(UINT16 wadnum); UINT8 P_GetSkinSprite2(skin_t *skin, UINT8 spr2, player_t *player); -// SRB2Kart Followers - -// -// We'll define these here because they're really just a mobj that'll follow some rules behind a player -// -typedef struct follower_s -{ - char skinname[SKINNAMESIZE+1]; // Skin Name. This is what to refer to when asking the commands anything. - char name[SKINNAMESIZE+1]; // Name. This is used for the menus. We'll just follow the same rules as skins for this. - - UINT16 defaultcolor; // default color for menus. - - fixed_t scale; // Scale relative to the player's. - fixed_t bubblescale; // Bubble scale relative to the player scale. If not set, no bubble will spawn (default) - - // some position shenanigans: - INT32 atangle; // angle the object will be at around the player. The object itself will always face the same direction as the player. - INT32 dist; // distance relative to the player. (In a circle) - INT32 height; // height of the follower, this is mostly important for Z flipping. - INT32 zoffs; // Z offset relative to the player's height. Cannot be negative. - - // movement options - - UINT32 horzlag; // Lag for X/Y displacement. Default is 2. Must be > 0 because we divide by this number. - UINT32 vertlag; // not Vert from Neptunia lagging, this is for Z displacement lag Default is 6. Must be > 0 because we divide by this number. - INT32 bobamp; // Bob amplitude. Default is 4. - INT32 bobspeed; // Arbitrary modifier for bobbing speed, default is TICRATE*2 (70). - - // from there on out, everything is STATES to allow customization - // these are only set once when the action is performed and are then free to animate however they want. - - INT32 idlestate; // state when the player is at a standstill - INT32 followstate; // state when the player is moving - INT32 hurtstate; // state when the player is being hurt - INT32 winstate; // state when the player has won - INT32 losestate; // state when the player has lost - INT32 hitconfirmstate; // state for hit confirm - UINT32 hitconfirmtime; // time to keep the above playing for - - // visual - char icon[8+1]; // Lump names are only 8 characters. (+1 for \0) -} follower_t; - -extern INT32 numfollowers; -extern follower_t followers[MAXSKINS]; // again, use the same rules as skins, no reason not to. - -INT32 R_FollowerAvailable(const char *name); -boolean SetPlayerFollower(INT32 playernum,const char *skinname); -void SetFollower(INT32 playernum,INT32 skinnum); - #endif //__R_SKINS__ diff --git a/src/st_stuff.c b/src/st_stuff.c index 1303b28d2..5186518db 100644 --- a/src/st_stuff.c +++ b/src/st_stuff.c @@ -33,6 +33,7 @@ #include "p_setup.h" // NiGHTS grading #include "k_grandprix.h" // we need to know grandprix status for titlecards #include "k_boss.h" +#include "r_fps.h" //random index #include "m_random.h" @@ -1002,8 +1003,17 @@ static void ST_overlayDrawer(void) { // hu_showscores = auto hide score/time/rings when tab rankings are shown if (!(hu_showscores && (netgame || multiplayer))) + { K_drawKartHUD(); + if (renderisnewtic) + { + LUA_HUD_ClearDrawList(luahuddrawlist_game); + LUAh_GameHUD(stplyr, luahuddrawlist_game); + } + LUA_HUD_DrawList(luahuddrawlist_game); + } + if (!hu_showscores) // hide the following if TAB is held { if (cv_showviewpointtext.value) @@ -1031,16 +1041,6 @@ static void ST_overlayDrawer(void) } } - if (!(netgame || multiplayer) || !hu_showscores) - { - if (renderisnewtic) - { - LUA_HUD_ClearDrawList(luahuddrawlist_game); - LUAh_GameHUD(stplyr, luahuddrawlist_game); - } - LUA_HUD_DrawList(luahuddrawlist_game); - } - if (!hu_showscores && netgame && !mapreset) { if (stplyr->spectator && LUA_HudEnabled(hud_textspectator)) @@ -1081,32 +1081,6 @@ static void ST_overlayDrawer(void) } } } - - // Replay manual-save stuff - if (demo.recording && multiplayer && demo.savebutton && demo.savebutton + 3*TICRATE < leveltime) - { - switch (demo.savemode) - { - case DSM_NOTSAVING: - V_DrawRightAlignedThinString(BASEVIDWIDTH - 2, 2, V_HUDTRANS|V_SNAPTOTOP|V_SNAPTORIGHT|V_ALLOWLOWERCASE|((gametyperules & GTR_BUMPERS) ? V_REDMAP : V_SKYMAP), "Look Backward: Save replay"); - break; - - case DSM_WILLAUTOSAVE: - V_DrawRightAlignedThinString(BASEVIDWIDTH - 2, 2, V_HUDTRANS|V_SNAPTOTOP|V_SNAPTORIGHT|V_ALLOWLOWERCASE|((gametyperules & GTR_BUMPERS) ? V_REDMAP : V_SKYMAP), "Replay will be saved. (Look Backward: Change title)"); - break; - - case DSM_WILLSAVE: - V_DrawRightAlignedThinString(BASEVIDWIDTH - 2, 2, V_HUDTRANS|V_SNAPTOTOP|V_SNAPTORIGHT|V_ALLOWLOWERCASE|((gametyperules & GTR_BUMPERS) ? V_REDMAP : V_SKYMAP), "Replay will be saved."); - break; - - case DSM_TITLEENTRY: - ST_DrawDemoTitleEntry(); - break; - - default: // Don't render anything - break; - } - } } void ST_DrawDemoTitleEntry(void) @@ -1217,6 +1191,8 @@ void ST_Drawer(void) for (i = 0; i <= r_splitscreen; i++) { stplyr = &players[displayplayers[i]]; + R_SetViewContext(VIEWCONTEXT_PLAYER1 + i); + R_InterpolateView(rendertimefrac); // to assist with object tracking ST_overlayDrawer(); } @@ -1232,5 +1208,31 @@ void ST_Drawer(void) if (stagetitle) ST_drawTitleCard(); + // Replay manual-save stuff + if (demo.recording && multiplayer && demo.savebutton && demo.savebutton + 3*TICRATE < leveltime) + { + switch (demo.savemode) + { + case DSM_NOTSAVING: + V_DrawRightAlignedThinString(BASEVIDWIDTH - 2, 2, V_HUDTRANS|V_SNAPTOTOP|V_SNAPTORIGHT|V_ALLOWLOWERCASE|((gametyperules & GTR_BUMPERS) ? V_REDMAP : V_SKYMAP), "Look Backward: Save replay"); + break; + + case DSM_WILLAUTOSAVE: + V_DrawRightAlignedThinString(BASEVIDWIDTH - 2, 2, V_HUDTRANS|V_SNAPTOTOP|V_SNAPTORIGHT|V_ALLOWLOWERCASE|((gametyperules & GTR_BUMPERS) ? V_REDMAP : V_SKYMAP), "Replay will be saved. (Look Backward: Change title)"); + break; + + case DSM_WILLSAVE: + V_DrawRightAlignedThinString(BASEVIDWIDTH - 2, 2, V_HUDTRANS|V_SNAPTOTOP|V_SNAPTORIGHT|V_ALLOWLOWERCASE|((gametyperules & GTR_BUMPERS) ? V_REDMAP : V_SKYMAP), "Replay will be saved."); + break; + + case DSM_TITLEENTRY: + ST_DrawDemoTitleEntry(); + break; + + default: // Don't render anything + break; + } + } + ST_drawDebugInfo(); }