From 505e2db2c42a406021e52472cbd983ce92ef3b60 Mon Sep 17 00:00:00 2001 From: James R Date: Thu, 17 Mar 2022 20:31:46 -0700 Subject: [PATCH 01/24] Add Hyudoro states --- src/deh_tables.c | 6 +++++ src/info.c | 57 ++++++++++++++++++++++++++++++++++++++++++++++++ src/info.h | 7 ++++++ 3 files changed, 70 insertions(+) diff --git a/src/deh_tables.c b/src/deh_tables.c index 8bdae717d..7266303da 100644 --- a/src/deh_tables.c +++ b/src/deh_tables.c @@ -3973,6 +3973,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", @@ -5544,6 +5547,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/info.c b/src/info.c index 9ebc1bf4c..00463602f 100644 --- a/src/info.c +++ b/src/info.c @@ -569,6 +569,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 @@ -4529,6 +4530,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 @@ -24521,6 +24524,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 + 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_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 71da066b8..a7e869bd9 100644 --- a/src/info.h +++ b/src/info.h @@ -1117,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 @@ -4953,6 +4954,9 @@ typedef enum state S_FLAMESHIELDLINE3, S_FLAMESHIELDFLASH, + // Caked-Up Booty-Sheet Ghost + S_HYUDORO, + // The legend S_SINK, S_SINK_SHIELD, @@ -6561,6 +6565,9 @@ typedef enum mobj_type MT_FLAMESHIELDPAPER, MT_BUBBLESHIELDTRAP, + MT_HYUDORO, + MT_HYUDORO_CENTER, + MT_SINK, // Kitchen Sink Stuff MT_SINK_SHIELD, MT_SINKTRAIL, From cd9777f0cbf6142694edb99960c8611c3b1fd12a Mon Sep 17 00:00:00 2001 From: James R Date: Tue, 22 Mar 2022 17:46:36 -0700 Subject: [PATCH 02/24] MT_GHOST: dont flicker tracer's DONTDRAW flags --- src/p_mobj.c | 11 ++++++++--- 1 file changed, 8 insertions(+), 3 deletions(-) diff --git a/src/p_mobj.c b/src/p_mobj.c index 3a4cd1751..0dc5ec131 100644 --- a/src/p_mobj.c +++ b/src/p_mobj.c @@ -9207,14 +9207,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; } } } From 61399981a2d7c87eab71f1ee8a3ebd4f5185399b Mon Sep 17 00:00:00 2001 From: James R Date: Tue, 22 Mar 2022 17:47:29 -0700 Subject: [PATCH 03/24] MT_SHADOW + SPR_NONE, teleports to tracer and renders only a shadow --- src/deh_tables.c | 3 ++- src/info.c | 29 +++++++++++++++++++++++++++++ src/info.h | 4 +++- src/p_mobj.c | 9 +++++++++ 4 files changed, 43 insertions(+), 2 deletions(-) diff --git a/src/deh_tables.c b/src/deh_tables.c index 7266303da..b7aaf262d 100644 --- a/src/deh_tables.c +++ b/src/deh_tables.c @@ -369,8 +369,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", @@ -4705,6 +4705,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", diff --git a/src/info.c b/src/info.c index 00463602f..8680bc9c7 100644 --- a/src/info.c +++ b/src/info.c @@ -28,6 +28,7 @@ char sprnames[NUMSPRITES + 1][5] = { "NULL", // invisible object + "NONE", // invisible but still rendered "UNKN", "THOK", // Thok! mobj @@ -850,6 +851,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 @@ -5364,6 +5366,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 diff --git a/src/info.h b/src/info.h index a7e869bd9..e3257fdeb 100644 --- a/src/info.h +++ b/src/info.h @@ -576,6 +576,7 @@ extern boolean actionsoverridden[NUMACTIONS]; typedef enum sprite { SPR_NULL, // invisible object + SPR_NONE, // invisible but still rendered SPR_UNKN, SPR_THOK, // Thok! mobj @@ -1351,8 +1352,8 @@ typedef enum state S_XDEATHSTATE, S_RAISESTATE, - // Thok S_THOK, + S_SHADOW, S_KART_STILL, S_KART_STILL_L, @@ -5723,6 +5724,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, diff --git a/src/p_mobj.c b/src/p_mobj.c index 0dc5ec131..05d802b02 100644 --- a/src/p_mobj.c +++ b/src/p_mobj.c @@ -5307,6 +5307,15 @@ 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); + } + break; case MT_BOSSJUNK: mobj->renderflags ^= RF_DONTDRAW; break; From 910ebe9d0fafb041c71b19b3b8abe6c63dd583e7 Mon Sep 17 00:00:00 2001 From: James R Date: Fri, 29 Apr 2022 22:01:51 -0700 Subject: [PATCH 04/24] Add objects subdirectory For game object-specific code --- src/CMakeLists.txt | 1 + src/Makefile | 1 + 2 files changed, 2 insertions(+) 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 9659a4994..ffec6a4cf 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))) From c6e7fe2d298bc4841c25d519838f14fc60db9a1e Mon Sep 17 00:00:00 2001 From: James R Date: Fri, 29 Apr 2022 22:02:22 -0700 Subject: [PATCH 05/24] Hyudoro object code --- src/d_player.h | 1 + src/info.c | 6 +- src/k_kart.c | 7 +- src/objects/Sourcefile | 1 + src/objects/hyudoro.c | 402 +++++++++++++++++++++++++++++++++++++++++ src/p_inter.c | 5 + src/p_mobj.c | 16 +- 7 files changed, 432 insertions(+), 6 deletions(-) create mode 100644 src/objects/Sourcefile create mode 100644 src/objects/hyudoro.c diff --git a/src/d_player.h b/src/d_player.h index 55c2857d5..c72944268 100644 --- a/src/d_player.h +++ b/src/d_player.h @@ -465,6 +465,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 diff --git a/src/info.c b/src/info.c index 8680bc9c7..136ef3cb8 100644 --- a/src/info.c +++ b/src/info.c @@ -24570,13 +24570,13 @@ mobjinfo_t mobjinfo[NUMMOBJTYPES] = S_NULL, // xdeathstate sfx_None, // deathsound 0, // speed - 64*FRACUNIT, // radius - 32*FRACUNIT, // height + 32*FRACUNIT, // radius + 24*FRACUNIT, // height 0, // display offset 0, // mass 0, // damage sfx_None, // activesound - MF_NOGRAVITY|MF_DONTENCOREMAP, // flags + MF_SPECIAL|MF_NOCLIP|MF_NOGRAVITY|MF_DONTENCOREMAP, // flags S_NULL // raisestate }, diff --git a/src/k_kart.c b/src/k_kart.c index 412f3bdc3..8ac2ccc22 100644 --- a/src/k_kart.c +++ b/src/k_kart.c @@ -36,6 +36,7 @@ #include "k_hud.h" #include "k_terrain.h" #include "k_director.h" +#include "k_objects.h" // SOME IMPORTANT VARIABLES DEFINED IN DOOMDEF.H: // gamespeed is cc (0 for easy, 1 for normal, 2 for hard) @@ -5178,6 +5179,7 @@ static void K_FlameDashLeftoverSmoke(mobj_t *src) } } +#if 0 static void K_DoHyudoroSteal(player_t *player) { INT32 i, numplayers = 0; @@ -5255,6 +5257,7 @@ static void K_DoHyudoroSteal(player_t *player) S_StartSound(NULL, sfx_s3k92); } } +#endif void K_DoSneaker(player_t *player, INT32 type) { @@ -9563,7 +9566,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: 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..35c3680df --- /dev/null +++ b/src/objects/hyudoro.c @@ -0,0 +1,402 @@ +#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 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); + + K_ChangePlayerItem(player, + hyudoro_itemtype(hyu), + 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 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); + + player->hyudorotimer = hyudorotime; + player->stealingtimer = hyudorotime; + + hyudoro_mode(hyu) = HYU_RETURN; + hyudoro_itemtype(hyu) = player->itemtype; + hyudoro_itemcount(hyu) = player->itemamount; + + K_ChangePlayerItem(player, KITEM_NONE, 0); + + P_SetTarget(&hyudoro_target(hyu), + hyudoro_center_master(center)); + + if (center) + P_RemoveMobj(center); + + hyu->renderflags &= ~(RF_DONTDRAW); + + return true; +} + +static boolean +hyudoro_return_hit_player +( mobj_t * hyu, + mobj_t * toucher) +{ + player_t *player = toucher->player; + + if (toucher != hyudoro_target(hyu)) + return false; + + // If the player already has an item, just hover beside + // them until they use/lose it. + if (player->itemamount || player->itemroulette) + { + hyudoro_mode(hyu) = HYU_HOVER; + append_hyudoro(&player->hoverhyudoro, hyu); + } + else + { + deliver_item(hyu); + } + + 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); + 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_inter.c b/src/p_inter.c index aceb8336c..d73828916 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) diff --git a/src/p_mobj.c b/src/p_mobj.c index 05d802b02..f23047371 100644 --- a/src/p_mobj.c +++ b/src/p_mobj.c @@ -42,6 +42,7 @@ #include "k_respawn.h" #include "k_bot.h" #include "k_terrain.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); @@ -6559,8 +6560,8 @@ static boolean P_MobjRegularThink(mobj_t *mobj) } else if (P_IsObjectOnGround(mobj)) { - mobj->momx = 1; - mobj->momy = 0; + //mobj->momx = 1; + //mobj->momy = 0; mobj->flags &= ~MF_NOCLIPTHING; mobj->flags |= MF_NOGRAVITY; } @@ -7717,6 +7718,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) { @@ -9671,6 +9682,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: From 39ff9ce383e010492f736a287d96d949a40b1286 Mon Sep 17 00:00:00 2001 From: James R Date: Fri, 29 Apr 2022 23:43:25 -0700 Subject: [PATCH 06/24] Remove orphaned MT_SHADOW --- src/p_mobj.c | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/src/p_mobj.c b/src/p_mobj.c index f23047371..8d727c308 100644 --- a/src/p_mobj.c +++ b/src/p_mobj.c @@ -5316,6 +5316,11 @@ static void P_MobjSceneryThink(mobj_t *mobj) mobj->tracer->y, mobj->tracer->z); } + else + { + P_RemoveMobj(mobj); + return; + } break; case MT_BOSSJUNK: mobj->renderflags ^= RF_DONTDRAW; From 3e8d50a44ae5d3d5d6d1c00ffb5cad1968619bf4 Mon Sep 17 00:00:00 2001 From: James R Date: Sat, 30 Apr 2022 00:25:42 -0700 Subject: [PATCH 07/24] Fix/finish hyudoro return delivery - Fix item detection, matches paper sprite pickups - Stacked hyudoros deliver item once player is not holding --- src/objects/hyudoro.c | 101 +++++++++++++++++++++++++++++++++++++----- 1 file changed, 90 insertions(+), 11 deletions(-) diff --git a/src/objects/hyudoro.c b/src/objects/hyudoro.c index 35c3680df..b4778c8c5 100644 --- a/src/objects/hyudoro.c +++ b/src/objects/hyudoro.c @@ -83,6 +83,14 @@ get_hyudoro_master (mobj_t *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, @@ -193,9 +201,12 @@ deliver_item (mobj_t *hyu) P_SetTarget(&hyudoro_target(hyu), NULL); - K_ChangePlayerItem(player, - hyudoro_itemtype(hyu), - hyudoro_itemcount(hyu)); + if (player) + { + K_ChangePlayerItem(player, + hyudoro_itemtype(hyu), + player->itemamount + hyudoro_itemcount(hyu)); + } S_StartSound(target, sfx_itpick); @@ -227,6 +238,33 @@ append_hyudoro *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, @@ -273,31 +311,69 @@ hyudoro_patrol_hit_player 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) { - player_t *player = toucher->player; - if (toucher != hyudoro_target(hyu)) return false; // If the player already has an item, just hover beside // them until they use/lose it. - if (player->itemamount || player->itemroulette) + if (!award_immediately(hyu)) { hyudoro_mode(hyu) = HYU_HOVER; - append_hyudoro(&player->hoverhyudoro, hyu); - } - else - { - deliver_item(hyu); + 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) { @@ -370,7 +446,10 @@ Obj_HyudoroThink (mobj_t *hyu) case HYU_HOVER: if (hyudoro_target(hyu)) + { project_hyudoro_hover(hyu); + hyudoro_hover_await_stack(hyu); + } break; } } From 8fd251b54c7feee6cff375d899ec221b05bf7fdf Mon Sep 17 00:00:00 2001 From: James R Date: Sun, 1 May 2022 13:36:01 -0700 Subject: [PATCH 08/24] Revert wrongly committed code --- src/p_mobj.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/p_mobj.c b/src/p_mobj.c index 8d727c308..54ea94703 100644 --- a/src/p_mobj.c +++ b/src/p_mobj.c @@ -6565,8 +6565,8 @@ static boolean P_MobjRegularThink(mobj_t *mobj) } else if (P_IsObjectOnGround(mobj)) { - //mobj->momx = 1; - //mobj->momy = 0; + mobj->momx = 1; + mobj->momy = 0; mobj->flags &= ~MF_NOCLIPTHING; mobj->flags |= MF_NOGRAVITY; } From 2196ccef62136e517a3f2c8bb04c02d4f0b33ef1 Mon Sep 17 00:00:00 2001 From: James R Date: Sun, 1 May 2022 13:36:17 -0700 Subject: [PATCH 09/24] Add k_objects.h --- src/k_objects.h | 11 +++++++++++ 1 file changed, 11 insertions(+) create mode 100644 src/k_objects.h 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*/ From 38ab22f02272ccb498920302edfeed96ac218ec5 Mon Sep 17 00:00:00 2001 From: James R Date: Sun, 1 May 2022 14:04:25 -0700 Subject: [PATCH 10/24] Netsave player.hoverhyudoro --- src/p_saveg.c | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) diff --git a/src/p_saveg.c b/src/p_saveg.c index 18cef0e94..f6acde09e 100644 --- a/src/p_saveg.c +++ b/src/p_saveg.c @@ -62,6 +62,7 @@ typedef enum FOLLOWER = 0x04, SKYBOXVIEW = 0x08, SKYBOXCENTER = 0x10, + HOVERHYUDORO = 0x20, } player_saveflags; static inline void P_ArchivePlayer(void) @@ -195,6 +196,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) @@ -209,6 +213,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); @@ -474,6 +481,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); @@ -4213,6 +4223,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); + } } } } From 64b8da086f1fe4a52761f9ed45355230b34bed81 Mon Sep 17 00:00:00 2001 From: James R Date: Sun, 1 May 2022 14:39:19 -0700 Subject: [PATCH 11/24] Readjust race item odds for Hyudoro --- src/k_kart.c | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/k_kart.c b/src/k_kart.c index 8ac2ccc22..1f0c0047b 100644 --- a/src/k_kart.c +++ b/src/k_kart.c @@ -352,21 +352,21 @@ 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 /*Thunder Shield*/ { 1, 2, 0, 0, 0, 0, 0, 0 }, // Thunder 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*/ { 2, 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 From 2de756d0772f076b00765e3cf21d90b314102953 Mon Sep 17 00:00:00 2001 From: James R Date: Sun, 1 May 2022 18:31:17 -0700 Subject: [PATCH 12/24] Fix typo --- src/objects/hyudoro.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/objects/hyudoro.c b/src/objects/hyudoro.c index b4778c8c5..e8fc14de3 100644 --- a/src/objects/hyudoro.c +++ b/src/objects/hyudoro.c @@ -363,7 +363,7 @@ hyudoro_hover_await_stack (mobj_t *hyu) return false; // First in stack goes first - if (hyu == player->hoverhyudoro) + if (hyu != player->hoverhyudoro) return false; if (!award_immediately(hyu)) From 543928b5bbc14b027cc0c920db946cbbf22b6293 Mon Sep 17 00:00:00 2001 From: Sally Coolatta Date: Sun, 22 May 2022 21:04:52 -0400 Subject: [PATCH 13/24] Adjust Hyuu frequency --- src/k_kart.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/k_kart.c b/src/k_kart.c index b2fa1b627..08bd77101 100644 --- a/src/k_kart.c +++ b/src/k_kart.c @@ -367,11 +367,11 @@ static INT32 K_KartItemOddsRace[NUMKARTRESULTS-1][8] = /*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*/ { 2, 0, 0, 0, 0, 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 From c8718b25ffd38b947b1bb404021c3b3fb3d2d121 Mon Sep 17 00:00:00 2001 From: Sally Coolatta Date: Sun, 22 May 2022 21:14:02 -0400 Subject: [PATCH 14/24] REMOVE hyubgone + all of the other bullshit we did to try and make it show up less --- src/doomstat.h | 1 - src/g_game.c | 1 - src/k_kart.c | 11 +---------- src/lua_script.c | 5 ----- src/p_saveg.c | 2 -- src/p_setup.c | 1 - src/p_tick.c | 2 -- 7 files changed, 1 insertion(+), 22 deletions(-) diff --git a/src/doomstat.h b/src/doomstat.h index 163bfee96..8c2671c96 100644 --- a/src/doomstat.h +++ b/src/doomstat.h @@ -685,7 +685,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/g_game.c b/src/g_game.c index 21467e592..6eae4df17 100644 --- a/src/g_game.c +++ b/src/g_game.c @@ -314,7 +314,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 diff --git a/src/k_kart.c b/src/k_kart.c index 08bd77101..a1f9ac788 100644 --- a/src/k_kart.c +++ b/src/k_kart.c @@ -458,9 +458,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; @@ -682,6 +679,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: @@ -742,13 +740,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; } 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/p_saveg.c b/src/p_saveg.c index 8b4604c8a..3cb65e7a7 100644 --- a/src/p_saveg.c +++ b/src/p_saveg.c @@ -4505,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++) @@ -4655,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 c1da43eef..2f23d6c1f 100644 --- a/src/p_setup.c +++ b/src/p_setup.c @@ -4405,7 +4405,6 @@ boolean P_LoadLevel(boolean fromnetsave, boolean reloadinggamestate) wantedcalcdelay = wantedfrequency*2; indirectitemcooldown = 0; - hyubgone = 0; mapreset = 0; for (i = 0; i < MAXPLAYERS; i++) diff --git a/src/p_tick.c b/src/p_tick.c index c7dae9030..843461db6 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(); From 0ce466e7efacd1e97971ae1fb2bee9f6e6390a9d Mon Sep 17 00:00:00 2001 From: Sally Coolatta Date: Sun, 22 May 2022 21:34:24 -0400 Subject: [PATCH 15/24] Some asserts in hyu code Instead of letting it crash due to a NULL subsector later, let it crash earlier so I can see what is happening... --- src/objects/hyudoro.c | 54 +++++++++++++++++++++++++++++++++++++------ 1 file changed, 47 insertions(+), 7 deletions(-) diff --git a/src/objects/hyudoro.c b/src/objects/hyudoro.c index e8fc14de3..b5ece9157 100644 --- a/src/objects/hyudoro.c +++ b/src/objects/hyudoro.c @@ -37,21 +37,55 @@ K_ChangePlayerItem #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) + +static mobj_t * +hyudoro_next (mobj_t *o) +{ + I_Assert(o != NULL && P_MobjWasRemoved(o) == false); + I_Assert(o->tracer != NULL && P_MobjWasRemoved(o->tracer) == false); + + return o->tracer; +} + #define hyudoro_stackpos(o) ((o)->reactiontime) -// cannot be combined -#define hyudoro_center(o) ((o)->target) -#define hyudoro_target(o) ((o)->target) +// these next two functions cannot be combined +static mobj_t * +hyudoro_center (mobj_t *o) +{ + I_Assert(o != NULL && P_MobjWasRemoved(o) == false); + I_Assert(o->target != NULL && P_MobjWasRemoved(o->target) == false); + + return o->target; +} + +static mobj_t * +hyudoro_target (mobj_t *o) +{ + I_Assert(o != NULL && P_MobjWasRemoved(o) == false); + I_Assert(o->target != NULL && P_MobjWasRemoved(o->target) == false); + + return o->target; +} #define hyudoro_center_max_radius(o) ((o)->threshold) -#define hyudoro_center_master(o) ((o)->target) + +static mobj_t * +hyudoro_center_master (mobj_t *o) +{ + I_Assert(o != NULL && P_MobjWasRemoved(o) == false); + I_Assert(o->target != NULL && P_MobjWasRemoved(o->target) == false); + + return o->target; +} static angle_t trace_angle (mobj_t *hyu) { mobj_t *center = hyu->target; + I_Assert(center != NULL && P_MobjWasRemoved(center) == false); + if (hyu->x != center->x || hyu->y != center->y) { return R_PointToAngle2( @@ -66,13 +100,15 @@ get_look_angle (mobj_t *thing) { player_t *player = thing->player; + I_Assert(player != NULL); + return player ? player->angleturn : thing->angle; } static boolean is_hyudoro (mobj_t *thing) { - return thing && thing->type == MT_HYUDORO; + return thing != NULL && P_MobjWasRemoved(thing) == false && thing->type == MT_HYUDORO; } static mobj_t * @@ -80,6 +116,8 @@ get_hyudoro_master (mobj_t *hyu) { mobj_t *center = hyudoro_center(hyu); + I_Assert(center != NULL && P_MobjWasRemoved(center) == false); + return center ? hyudoro_center_master(center) : NULL; } @@ -97,6 +135,8 @@ sine_bob angle_t a, fixed_t sineofs) { + I_Assert(hyu != NULL && P_MobjWasRemoved(hyu) == false); + hyu->sprzoff = FixedMul(hyu->height, sineofs + FINESINE(a >> ANGLETOFINESHIFT)); } @@ -180,7 +220,7 @@ move_to_player (mobj_t *hyu) angle_t angle; - if (!target) + if (target == NULL || P_MobjWasRemoved(target) == true) return; angle = R_PointToAngle2( From 5ef78cbc16b795a90ce04fe032e2650af8d817f7 Mon Sep 17 00:00:00 2001 From: Sally Coolatta Date: Sun, 22 May 2022 21:41:40 -0400 Subject: [PATCH 16/24] EVEN MORE (also removed the define replacements since didn't work) --- src/objects/hyudoro.c | 69 +++++++++++++++++++------------------------ src/p_mobj.c | 2 ++ 2 files changed, 32 insertions(+), 39 deletions(-) diff --git a/src/objects/hyudoro.c b/src/objects/hyudoro.c index b5ece9157..d72a597c4 100644 --- a/src/objects/hyudoro.c +++ b/src/objects/hyudoro.c @@ -37,47 +37,15 @@ K_ChangePlayerItem #define hyudoro_itemtype(o) ((o)->movefactor) #define hyudoro_itemcount(o) ((o)->movecount) #define hyudoro_hover_stack(o) ((o)->threshold) - -static mobj_t * -hyudoro_next (mobj_t *o) -{ - I_Assert(o != NULL && P_MobjWasRemoved(o) == false); - I_Assert(o->tracer != NULL && P_MobjWasRemoved(o->tracer) == false); - - return o->tracer; -} - +#define hyudoro_next(o) ((o)->tracer) #define hyudoro_stackpos(o) ((o)->reactiontime) -// these next two functions cannot be combined -static mobj_t * -hyudoro_center (mobj_t *o) -{ - I_Assert(o != NULL && P_MobjWasRemoved(o) == false); - I_Assert(o->target != NULL && P_MobjWasRemoved(o->target) == false); - - return o->target; -} - -static mobj_t * -hyudoro_target (mobj_t *o) -{ - I_Assert(o != NULL && P_MobjWasRemoved(o) == false); - I_Assert(o->target != NULL && P_MobjWasRemoved(o->target) == false); - - return o->target; -} +// cannot be combined +#define hyudoro_center(o) ((o)->target) +#define hyudoro_target(o) ((o)->target) #define hyudoro_center_max_radius(o) ((o)->threshold) - -static mobj_t * -hyudoro_center_master (mobj_t *o) -{ - I_Assert(o != NULL && P_MobjWasRemoved(o) == false); - I_Assert(o->target != NULL && P_MobjWasRemoved(o->target) == false); - - return o->target; -} +#define hyudoro_center_master(o) ((o)->target) static angle_t trace_angle (mobj_t *hyu) @@ -126,6 +94,8 @@ get_hyudoro_target_player (mobj_t *hyu) { mobj_t *target = hyudoro_target(hyu); + I_Assert(target != NULL && P_MobjWasRemoved(target) == false); + return target ? target->player : NULL; } @@ -220,6 +190,8 @@ move_to_player (mobj_t *hyu) angle_t angle; + I_Assert(hyu != NULL && P_MobjWasRemoved(hyu) == false); + if (target == NULL || P_MobjWasRemoved(target) == true) return; @@ -239,6 +211,10 @@ deliver_item (mobj_t *hyu) mobj_t *target = hyudoro_target(hyu); player_t *player = target->player; + I_Assert(hyu != NULL && P_MobjWasRemoved(hyu) == false); + I_Assert(target != NULL && P_MobjWasRemoved(target) == false); + I_Assert(player != NULL); + P_SetTarget(&hyudoro_target(hyu), NULL); if (player) @@ -268,6 +244,8 @@ append_hyudoro { INT32 lastpos = 0; + I_Assert(hyu != NULL && P_MobjWasRemoved(hyu) == false); + while (is_hyudoro(*head)) { lastpos = hyudoro_stackpos(*head); @@ -314,7 +292,11 @@ hyudoro_patrol_hit_player mobj_t *center = hyudoro_center(hyu); - if (!player) + I_Assert(hyu != NULL && P_MobjWasRemoved(hyu) == false); + I_Assert(toucher != NULL && P_MobjWasRemoved(toucher) == false); + I_Assert(center != NULL && P_MobjWasRemoved(center) == false); + + if (player == NULL) return false; // Cannot hit its master @@ -356,6 +338,8 @@ award_immediately (mobj_t *hyu) { player_t *player = get_hyudoro_target_player(hyu); + I_Assert(hyu != NULL && P_MobjWasRemoved(hyu) == false); + if (player) { if (player->itemamount && @@ -380,6 +364,9 @@ hyudoro_return_hit_player ( mobj_t * hyu, mobj_t * toucher) { + I_Assert(hyu != NULL && P_MobjWasRemoved(hyu) == false); + I_Assert(toucher != NULL && P_MobjWasRemoved(toucher) == false); + if (toucher != hyudoro_target(hyu)) return false; @@ -399,7 +386,9 @@ hyudoro_hover_await_stack (mobj_t *hyu) { player_t *player = get_hyudoro_target_player(hyu); - if (!player) + I_Assert(hyu != NULL && P_MobjWasRemoved(hyu) == false); + + if (player == NULL) return false; // First in stack goes first @@ -453,6 +442,8 @@ Obj_HyudoroDeploy (mobj_t *master) void Obj_HyudoroThink (mobj_t *hyu) { + I_Assert(hyu != NULL && P_MobjWasRemoved(hyu) == false); + // Might get set from clipping slopes hyu->momz = 0; diff --git a/src/p_mobj.c b/src/p_mobj.c index 009241c62..64d0f616c 100644 --- a/src/p_mobj.c +++ b/src/p_mobj.c @@ -13464,6 +13464,8 @@ mobj_t *P_SpawnMobjFromMobj(mobj_t *mobj, fixed_t xofs, fixed_t yofs, fixed_t zo { mobj_t *newmobj; + I_Assert(mobj != NULL && P_MobjWasRemoved(mobj) == false); + xofs = FixedMul(xofs, mobj->scale); yofs = FixedMul(yofs, mobj->scale); zofs = FixedMul(zofs, mobj->scale); From 098304bd996fdae56cd9862b60c5eb54ceb41008 Mon Sep 17 00:00:00 2001 From: Sally Coolatta Date: Sun, 22 May 2022 22:00:54 -0400 Subject: [PATCH 17/24] Allow hyu thru tripwire --- src/k_kart.c | 1 + 1 file changed, 1 insertion(+) diff --git a/src/k_kart.c b/src/k_kart.c index a1f9ac788..7a1d23bf6 100644 --- a/src/k_kart.c +++ b/src/k_kart.c @@ -2908,6 +2908,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; From 61d61dcf25ecfb8860e868482cad298555a2b63e Mon Sep 17 00:00:00 2001 From: Sally Coolatta Date: Sun, 22 May 2022 22:02:21 -0400 Subject: [PATCH 18/24] Revert "EVEN MORE" This reverts commit 5ef78cbc16b795a90ce04fe032e2650af8d817f7. --- src/objects/hyudoro.c | 69 ++++++++++++++++++++++++------------------- src/p_mobj.c | 2 -- 2 files changed, 39 insertions(+), 32 deletions(-) diff --git a/src/objects/hyudoro.c b/src/objects/hyudoro.c index d72a597c4..b5ece9157 100644 --- a/src/objects/hyudoro.c +++ b/src/objects/hyudoro.c @@ -37,15 +37,47 @@ K_ChangePlayerItem #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) + +static mobj_t * +hyudoro_next (mobj_t *o) +{ + I_Assert(o != NULL && P_MobjWasRemoved(o) == false); + I_Assert(o->tracer != NULL && P_MobjWasRemoved(o->tracer) == false); + + return o->tracer; +} + #define hyudoro_stackpos(o) ((o)->reactiontime) -// cannot be combined -#define hyudoro_center(o) ((o)->target) -#define hyudoro_target(o) ((o)->target) +// these next two functions cannot be combined +static mobj_t * +hyudoro_center (mobj_t *o) +{ + I_Assert(o != NULL && P_MobjWasRemoved(o) == false); + I_Assert(o->target != NULL && P_MobjWasRemoved(o->target) == false); + + return o->target; +} + +static mobj_t * +hyudoro_target (mobj_t *o) +{ + I_Assert(o != NULL && P_MobjWasRemoved(o) == false); + I_Assert(o->target != NULL && P_MobjWasRemoved(o->target) == false); + + return o->target; +} #define hyudoro_center_max_radius(o) ((o)->threshold) -#define hyudoro_center_master(o) ((o)->target) + +static mobj_t * +hyudoro_center_master (mobj_t *o) +{ + I_Assert(o != NULL && P_MobjWasRemoved(o) == false); + I_Assert(o->target != NULL && P_MobjWasRemoved(o->target) == false); + + return o->target; +} static angle_t trace_angle (mobj_t *hyu) @@ -94,8 +126,6 @@ get_hyudoro_target_player (mobj_t *hyu) { mobj_t *target = hyudoro_target(hyu); - I_Assert(target != NULL && P_MobjWasRemoved(target) == false); - return target ? target->player : NULL; } @@ -190,8 +220,6 @@ move_to_player (mobj_t *hyu) angle_t angle; - I_Assert(hyu != NULL && P_MobjWasRemoved(hyu) == false); - if (target == NULL || P_MobjWasRemoved(target) == true) return; @@ -211,10 +239,6 @@ deliver_item (mobj_t *hyu) mobj_t *target = hyudoro_target(hyu); player_t *player = target->player; - I_Assert(hyu != NULL && P_MobjWasRemoved(hyu) == false); - I_Assert(target != NULL && P_MobjWasRemoved(target) == false); - I_Assert(player != NULL); - P_SetTarget(&hyudoro_target(hyu), NULL); if (player) @@ -244,8 +268,6 @@ append_hyudoro { INT32 lastpos = 0; - I_Assert(hyu != NULL && P_MobjWasRemoved(hyu) == false); - while (is_hyudoro(*head)) { lastpos = hyudoro_stackpos(*head); @@ -292,11 +314,7 @@ hyudoro_patrol_hit_player mobj_t *center = hyudoro_center(hyu); - I_Assert(hyu != NULL && P_MobjWasRemoved(hyu) == false); - I_Assert(toucher != NULL && P_MobjWasRemoved(toucher) == false); - I_Assert(center != NULL && P_MobjWasRemoved(center) == false); - - if (player == NULL) + if (!player) return false; // Cannot hit its master @@ -338,8 +356,6 @@ award_immediately (mobj_t *hyu) { player_t *player = get_hyudoro_target_player(hyu); - I_Assert(hyu != NULL && P_MobjWasRemoved(hyu) == false); - if (player) { if (player->itemamount && @@ -364,9 +380,6 @@ hyudoro_return_hit_player ( mobj_t * hyu, mobj_t * toucher) { - I_Assert(hyu != NULL && P_MobjWasRemoved(hyu) == false); - I_Assert(toucher != NULL && P_MobjWasRemoved(toucher) == false); - if (toucher != hyudoro_target(hyu)) return false; @@ -386,9 +399,7 @@ hyudoro_hover_await_stack (mobj_t *hyu) { player_t *player = get_hyudoro_target_player(hyu); - I_Assert(hyu != NULL && P_MobjWasRemoved(hyu) == false); - - if (player == NULL) + if (!player) return false; // First in stack goes first @@ -442,8 +453,6 @@ Obj_HyudoroDeploy (mobj_t *master) void Obj_HyudoroThink (mobj_t *hyu) { - I_Assert(hyu != NULL && P_MobjWasRemoved(hyu) == false); - // Might get set from clipping slopes hyu->momz = 0; diff --git a/src/p_mobj.c b/src/p_mobj.c index 64d0f616c..009241c62 100644 --- a/src/p_mobj.c +++ b/src/p_mobj.c @@ -13464,8 +13464,6 @@ mobj_t *P_SpawnMobjFromMobj(mobj_t *mobj, fixed_t xofs, fixed_t yofs, fixed_t zo { mobj_t *newmobj; - I_Assert(mobj != NULL && P_MobjWasRemoved(mobj) == false); - xofs = FixedMul(xofs, mobj->scale); yofs = FixedMul(yofs, mobj->scale); zofs = FixedMul(zofs, mobj->scale); From 800dcc6302f303e33a318f9e74c21515ffad1243 Mon Sep 17 00:00:00 2001 From: Sally Coolatta Date: Sun, 22 May 2022 22:02:31 -0400 Subject: [PATCH 19/24] Revert "Some asserts in hyu code" This reverts commit 0ce466e7efacd1e97971ae1fb2bee9f6e6390a9d. --- src/objects/hyudoro.c | 54 ++++++------------------------------------- 1 file changed, 7 insertions(+), 47 deletions(-) diff --git a/src/objects/hyudoro.c b/src/objects/hyudoro.c index b5ece9157..e8fc14de3 100644 --- a/src/objects/hyudoro.c +++ b/src/objects/hyudoro.c @@ -37,55 +37,21 @@ K_ChangePlayerItem #define hyudoro_itemtype(o) ((o)->movefactor) #define hyudoro_itemcount(o) ((o)->movecount) #define hyudoro_hover_stack(o) ((o)->threshold) - -static mobj_t * -hyudoro_next (mobj_t *o) -{ - I_Assert(o != NULL && P_MobjWasRemoved(o) == false); - I_Assert(o->tracer != NULL && P_MobjWasRemoved(o->tracer) == false); - - return o->tracer; -} - +#define hyudoro_next(o) ((o)->tracer) #define hyudoro_stackpos(o) ((o)->reactiontime) -// these next two functions cannot be combined -static mobj_t * -hyudoro_center (mobj_t *o) -{ - I_Assert(o != NULL && P_MobjWasRemoved(o) == false); - I_Assert(o->target != NULL && P_MobjWasRemoved(o->target) == false); - - return o->target; -} - -static mobj_t * -hyudoro_target (mobj_t *o) -{ - I_Assert(o != NULL && P_MobjWasRemoved(o) == false); - I_Assert(o->target != NULL && P_MobjWasRemoved(o->target) == false); - - return o->target; -} +// cannot be combined +#define hyudoro_center(o) ((o)->target) +#define hyudoro_target(o) ((o)->target) #define hyudoro_center_max_radius(o) ((o)->threshold) - -static mobj_t * -hyudoro_center_master (mobj_t *o) -{ - I_Assert(o != NULL && P_MobjWasRemoved(o) == false); - I_Assert(o->target != NULL && P_MobjWasRemoved(o->target) == false); - - return o->target; -} +#define hyudoro_center_master(o) ((o)->target) static angle_t trace_angle (mobj_t *hyu) { mobj_t *center = hyu->target; - I_Assert(center != NULL && P_MobjWasRemoved(center) == false); - if (hyu->x != center->x || hyu->y != center->y) { return R_PointToAngle2( @@ -100,15 +66,13 @@ get_look_angle (mobj_t *thing) { player_t *player = thing->player; - I_Assert(player != NULL); - return player ? player->angleturn : thing->angle; } static boolean is_hyudoro (mobj_t *thing) { - return thing != NULL && P_MobjWasRemoved(thing) == false && thing->type == MT_HYUDORO; + return thing && thing->type == MT_HYUDORO; } static mobj_t * @@ -116,8 +80,6 @@ get_hyudoro_master (mobj_t *hyu) { mobj_t *center = hyudoro_center(hyu); - I_Assert(center != NULL && P_MobjWasRemoved(center) == false); - return center ? hyudoro_center_master(center) : NULL; } @@ -135,8 +97,6 @@ sine_bob angle_t a, fixed_t sineofs) { - I_Assert(hyu != NULL && P_MobjWasRemoved(hyu) == false); - hyu->sprzoff = FixedMul(hyu->height, sineofs + FINESINE(a >> ANGLETOFINESHIFT)); } @@ -220,7 +180,7 @@ move_to_player (mobj_t *hyu) angle_t angle; - if (target == NULL || P_MobjWasRemoved(target) == true) + if (!target) return; angle = R_PointToAngle2( From a12c88c5e213519422dcef33be3f81dabfe0dec6 Mon Sep 17 00:00:00 2001 From: James R Date: Sun, 22 May 2022 19:19:41 -0700 Subject: [PATCH 20/24] Strip items after stealing with Hyudoro --- src/objects/hyudoro.c | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/objects/hyudoro.c b/src/objects/hyudoro.c index e8fc14de3..af0241fe3 100644 --- a/src/objects/hyudoro.c +++ b/src/objects/hyudoro.c @@ -291,14 +291,14 @@ hyudoro_patrol_hit_player K_AddHitLag(toucher, TICRATE/2, true); - player->hyudorotimer = hyudorotime; - player->stealingtimer = hyudorotime; - hyudoro_mode(hyu) = HYU_RETURN; hyudoro_itemtype(hyu) = player->itemtype; hyudoro_itemcount(hyu) = player->itemamount; - K_ChangePlayerItem(player, KITEM_NONE, 0); + K_StripItems(player); + + player->hyudorotimer = hyudorotime; + player->stealingtimer = hyudorotime; P_SetTarget(&hyudoro_target(hyu), hyudoro_center_master(center)); From 17d007d418fd7b4955413b40ab72224b8340f747 Mon Sep 17 00:00:00 2001 From: toaster Date: Mon, 23 May 2022 22:04:14 +0100 Subject: [PATCH 21/24] * Restore player colour and colorization correctly when the Eggman Mark concludes its effect. * Allow colorisation types to not completely crowd each other out. * For example, it's possible for invincibility + grow to flicker Invincibility, Eggman mark, and grow colours if the conditions for each type of flash are true on different frames! --- src/d_netcmd.c | 3 +-- src/k_kart.c | 65 ++++++++++++++++++++++++++++++++++++-------------- src/k_kart.h | 1 + src/p_inter.c | 3 +-- src/p_user.c | 6 ++--- src/r_skins.c | 12 ++++------ 6 files changed, 57 insertions(+), 33 deletions(-) diff --git a/src/d_netcmd.c b/src/d_netcmd.c index c9a030ab8..84412fd3c 100644 --- a/src/d_netcmd.c +++ b/src/d_netcmd.c @@ -1447,8 +1447,7 @@ 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) diff --git a/src/k_kart.c b/src/k_kart.c index 81374d9c6..9c75d7003 100644 --- a/src/k_kart.c +++ b/src/k_kart.c @@ -3548,8 +3548,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; @@ -7571,6 +7570,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 @@ -7650,37 +7652,45 @@ void K_KartPlayerThink(player_t *player, ticcmd_t *cmd) 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; @@ -7691,45 +7701,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; @@ -7744,6 +7766,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); @@ -8859,6 +8886,8 @@ void K_StripOther(player_t *player) { player->eggmanexplode = 0; player->eggmanblame = -1; + + K_KartResetPlayerColor(player); } } diff --git a/src/k_kart.h b/src/k_kart.h index 20c8cd33f..de1a8ca47 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); diff --git a/src/p_inter.c b/src/p_inter.c index 8a4d6754c..806a34994 100644 --- a/src/p_inter.c +++ b/src/p_inter.c @@ -1767,8 +1767,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); diff --git a/src/p_user.c b/src/p_user.c index dbf716925..81f903830 100644 --- a/src/p_user.c +++ b/src/p_user.c @@ -1691,8 +1691,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); @@ -2679,8 +2678,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); } diff --git a/src/r_skins.c b/src/r_skins.c index ba7ed0811..b95a63089 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 @@ -285,7 +288,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 +314,7 @@ void SetPlayerSkinByNum(INT32 playernum, INT32 skinnum) } player->skincolor = newcolor = skin->prefcolor; + K_KartResetPlayerColor(player); } #endif @@ -323,12 +327,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 } From d053d5f8ba7c4166155d11ef784dfec029539a01 Mon Sep 17 00:00:00 2001 From: Sally Coolatta Date: Mon, 23 May 2022 17:37:29 -0400 Subject: [PATCH 22/24] Fix blockmap WILD inconsistency when it's not PIT_CheckThing An optimized error check was put into P_BlockThingsIterator for tmthing, but this meant that anything that was not using or even setting this variable (the supermajority of them) would exit after finding 1 thing in each block. To keep this error check & keep it optimized, the PIT_ functions were expanded to three options instead of two: BMIT_CONTINUE lets the search continue. If used as the last mobj, it will return true when the iterator finishes. BMIT_ABORT ends the search and forces the iterator to return false. BMIT_STOP ends the search and forces the iterator to return true. --- src/k_botsearch.c | 52 +++---- src/k_collide.c | 52 +++---- src/k_kart.c | 24 +-- src/p_enemy.c | 22 +-- src/p_local.h | 2 +- src/p_map.c | 383 +++++++++++++++++++++++----------------------- src/p_maputl.c | 62 +++++--- src/p_maputl.h | 11 +- src/p_spec.c | 10 +- 9 files changed, 324 insertions(+), 294 deletions(-) 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_kart.c b/src/k_kart.c index 81374d9c6..183d16a5f 100644 --- a/src/k_kart.c +++ b/src/k_kart.c @@ -7062,57 +7062,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)) @@ -7139,7 +7139,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. diff --git a/src/p_enemy.c b/src/p_enemy.c index 65f00e116..cf28c31d6 100644 --- a/src/p_enemy.c +++ b/src/p_enemy.c @@ -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_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..a64f9d761 100644 --- a/src/p_map.c +++ b/src/p_map.c @@ -523,17 +523,20 @@ 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; + if (tmthing == NULL || P_MobjWasRemoved(tmthing) == true) + return BMIT_STOP; // func just popped our tmthing, cannot continue. + // don't clip against self if (thing == tmthing) - return true; + return BMIT_CONTINUE; // Ignore... things. if (!tmthing || !thing || P_MobjWasRemoved(thing)) - return true; + return BMIT_CONTINUE; I_Assert(!P_MobjWasRemoved(tmthing)); I_Assert(!P_MobjWasRemoved(thing)); @@ -541,19 +544,19 @@ static boolean PIT_CheckThing(mobj_t *thing) // 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 +583,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 +612,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 +629,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 +664,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 +681,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 +697,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 +705,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 +720,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 +771,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 +786,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 +806,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 +820,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 +975,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 +988,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 +1083,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 +1145,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 +1179,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 +1196,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 +1208,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 +1217,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 +1255,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 +1275,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 +1347,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 +1396,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 +1409,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 +1440,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 +1453,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 +1473,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 +1508,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 +1533,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 +1562,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 +1583,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 +1619,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 +1679,7 @@ static boolean PIT_CheckLine(line_t *ld) add_spechit(ld); } - return true; + return BMIT_CONTINUE; } // ========================================================================= @@ -2322,32 +2325,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 +2399,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 +3955,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 +3979,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 +4626,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 +4657,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 +4692,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_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. From b9ee6d1f4e974fe7f51b2b23bf5db42b7feb76b5 Mon Sep 17 00:00:00 2001 From: toaster Date: Mon, 23 May 2022 23:57:18 +0100 Subject: [PATCH 23/24] * Show version/DEVELOP info on the title screen, not the top-level menu (necessary in advance of new-menus). * Add TESTER/HOSTTESTER information to `version` command and title screen DEVELOP info. --- src/d_netcmd.c | 6 +++++- src/f_finale.c | 32 ++++++++++++++++++++++++++++++++ src/m_menu.c | 20 -------------------- 3 files changed, 37 insertions(+), 21 deletions(-) diff --git a/src/d_netcmd.c b/src/d_netcmd.c index c9a030ab8..d7e3a5149 100644 --- a/src/d_netcmd.c +++ b/src/d_netcmd.c @@ -4364,7 +4364,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 diff --git a/src/f_finale.c b/src/f_finale.c index c6596e378..52f2556f4 100644 --- a/src/f_finale.c +++ b/src/f_finale.c @@ -1998,6 +1998,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/m_menu.c b/src/m_menu.c index 8255e5f35..9a446f8c3 100644 --- a/src/m_menu.c +++ b/src/m_menu.c @@ -3119,26 +3119,6 @@ void M_Drawer(void) M_GetGametypeColor(); currentMenu->drawroutine(); // call current menu Draw routine } - - // Draw version down in corner - // ... but only in the MAIN MENU. I'm a picky bastard. - if (currentMenu == &MainDef) - { - if (customversionstring[0] != '\0') - { - V_DrawThinString(vid.dupx, vid.height - 20*vid.dupy, V_NOSCALESTART|V_TRANSLUCENT, "Mod version:"); - V_DrawThinString(vid.dupx, vid.height - 10*vid.dupy, V_NOSCALESTART|V_TRANSLUCENT|V_ALLOWLOWERCASE, customversionstring); - } - else - { -#ifdef DEVELOP // Development -- show revision / branch info - V_DrawThinString(vid.dupx, vid.height - 20*vid.dupy, V_NOSCALESTART|V_TRANSLUCENT|V_ALLOWLOWERCASE, compbranch); - V_DrawThinString(vid.dupx, vid.height - 10*vid.dupy, V_NOSCALESTART|V_TRANSLUCENT|V_ALLOWLOWERCASE, comprevision); -#else // Regular build - V_DrawThinString(vid.dupx, vid.height - 10*vid.dupy, V_NOSCALESTART|V_TRANSLUCENT|V_ALLOWLOWERCASE, va("%s", VERSIONSTRING)); -#endif - } - } } // focus lost notification goes on top of everything, even the former everything From 052e72c4096eceae6a65f9053e50ce17728b79bb Mon Sep 17 00:00:00 2001 From: Sally Coolatta Date: Mon, 23 May 2022 19:20:21 -0400 Subject: [PATCH 24/24] PIT_CheckThing valid checks more consistent --- src/p_map.c | 11 ++++------- 1 file changed, 4 insertions(+), 7 deletions(-) diff --git a/src/p_map.c b/src/p_map.c index a64f9d761..473ded5fe 100644 --- a/src/p_map.c +++ b/src/p_map.c @@ -530,17 +530,14 @@ static BlockItReturn_t PIT_CheckThing(mobj_t *thing) if (tmthing == NULL || P_MobjWasRemoved(tmthing) == true) return BMIT_STOP; // func just popped our tmthing, cannot continue. + // Ignore... things. + if (thing == NULL || P_MobjWasRemoved(thing) == true) + return BMIT_CONTINUE; + // don't clip against self if (thing == tmthing) return BMIT_CONTINUE; - // Ignore... things. - if (!tmthing || !thing || P_MobjWasRemoved(thing)) - return BMIT_CONTINUE; - - I_Assert(!P_MobjWasRemoved(tmthing)); - I_Assert(!P_MobjWasRemoved(thing)); - // Ignore spectators if ((tmthing->player && tmthing->player->spectator) || (thing->player && thing->player->spectator))