Merge branch 'Saturn-Testing' into Saturn-Next
This commit is contained in:
commit
b883e4e4fe
23 files changed
+396
-4167
No files matched your search
@@ -21,9 +21,6 @@ CXXFLAGS+= -Wno-aggregate-return
|
||||
|
||||
# -W -Wno-unused
|
||||
|
||||
ifdef GCC150
|
||||
opts+=-std=gnu17
|
||||
endif
|
||||
WFLAGS:=-Wall -Wno-trigraphs
|
||||
ifndef GCC295
|
||||
#WFLAGS+=-Wno-packed
|
||||
|
||||
+2
-2
@@ -1051,7 +1051,7 @@ void G_ConsGhostTic(INT32 playernum)
|
||||
mobj = NULL;
|
||||
for (th = thinkercap.next; th != &thinkercap; th = th->next)
|
||||
{
|
||||
if (th->function.acp1 != (actionf_p1)P_MobjThinker)
|
||||
if (th->function != (actionf_p1)P_MobjThinker)
|
||||
continue;
|
||||
mobj = (mobj_t *)th;
|
||||
if (mobj->type == (mobjtype_t)type && mobj->x == x && mobj->y == y && mobj->z == z)
|
||||
@@ -3701,7 +3701,7 @@ void G_DoPlayMetal(void)
|
||||
// find metal sonic
|
||||
for (th = thinkercap.next; th != &thinkercap; th = th->next)
|
||||
{
|
||||
if (th->function.acp1 != (actionf_p1)P_MobjThinker)
|
||||
if (th->function != (actionf_p1)P_MobjThinker)
|
||||
continue;
|
||||
|
||||
mo = (mobj_t *)th;
|
||||
|
||||
-3938
File diff suppressed because it is too large.
Load diff
@@ -21,8 +21,6 @@ extern "C" {
|
||||
#include "hw_data.h"
|
||||
#include "hw_gl.h"
|
||||
|
||||
extern boolean currently_batching;
|
||||
|
||||
typedef struct
|
||||
{
|
||||
FSurfaceInfo surf;// surf also has its own polyflags for some reason, but it seems unused
|
||||
|
||||
+39
-12
@@ -132,7 +132,17 @@ static void HWR_AddTransparentFloor(lumpnum_t lumpnum, extrasubsector_t *xsub, b
|
||||
static void HWR_AddTransparentWall(FOutVector *wallVerts, FSurfaceInfo *pSurf, INT32 texnum, boolean noencore, FBITFIELD blend, boolean fogwall, INT32 lightlevel, extracolormap_t *wallcolormap);
|
||||
static void HWR_AddTransparentPolyobjectFloor(lumpnum_t lumpnum, polyobj_t *polysector, boolean isceiling, fixed_t fixedheight, INT32 lightlevel, INT32 alpha, sector_t *FOFSector, FBITFIELD blend, extracolormap_t *planecolormap);
|
||||
|
||||
static void HWR_AddSprites(sector_t *sec);
|
||||
namespace
|
||||
{
|
||||
enum class AddSpritesType
|
||||
{
|
||||
kNoLimitDist,
|
||||
kLimitDist,
|
||||
};
|
||||
|
||||
template<AddSpritesType> static void HWR_AddSprites(sector_t *);
|
||||
}
|
||||
|
||||
static void HWR_ProjectSprite(mobj_t *thing);
|
||||
static void HWR_AddPrecipitationSprites(void);
|
||||
static void HWR_ProjectPrecipitationSprite(precipmobj_t *thing);
|
||||
@@ -3166,7 +3176,10 @@ doaddline:
|
||||
{
|
||||
// draw sprites first, coz they are clipped to the solidsegs of
|
||||
// subsectors more 'in front'
|
||||
HWR_AddSprites(gl_frontsector);
|
||||
if (cv_drawdist.value || current_bsp_culling_distance)
|
||||
HWR_AddSprites<AddSpritesType::kLimitDist>(gl_frontsector);
|
||||
else
|
||||
HWR_AddSprites<AddSpritesType::kNoLimitDist>(gl_frontsector);
|
||||
|
||||
//Hurdler: at this point validcount must be the same, but is not because
|
||||
// gl_frontsector doesn't point anymore to sub->sector due to
|
||||
@@ -3519,6 +3532,8 @@ static void HWR_DrawSpriteShadow(gl_vissprite_t *spr, patch_t *gpatch, GLPatch_t
|
||||
}
|
||||
}
|
||||
|
||||
#define std_R_QuickCamDist(x, y) std::max(abs(((x)>>FRACBITS) - (viewx>>FRACBITS)), abs(((y)>>FRACBITS) - (viewy>>FRACBITS)))
|
||||
|
||||
// This is expecting a pointer to an array containing 4 wallVerts for a sprite
|
||||
static void HWR_RotateSpritePolyToAim(gl_vissprite_t *spr, FOutVector *wallVerts, const boolean precip, const boolean papersprite)
|
||||
{
|
||||
@@ -4528,6 +4543,10 @@ static void HWR_DrawSprites(void)
|
||||
// HWR_AddSprites
|
||||
// During BSP traversal, this adds sprites by sector.
|
||||
// --------------------------------------------------------------------------
|
||||
|
||||
namespace
|
||||
{
|
||||
template <AddSpritesType Type>
|
||||
static void HWR_AddSprites(sector_t *sec)
|
||||
{
|
||||
mobj_t *thing;
|
||||
@@ -4543,22 +4562,29 @@ static void HWR_AddSprites(sector_t *sec)
|
||||
// Well, now it will be done.
|
||||
sec->validcount = validcount;
|
||||
|
||||
limit_dist = cv_drawdist.value;
|
||||
|
||||
if (current_bsp_culling_distance)
|
||||
if constexpr (Type == AddSpritesType::kLimitDist)
|
||||
{
|
||||
// Use the smaller setting
|
||||
if (limit_dist)
|
||||
limit_dist = std::min(current_bsp_culling_distance/mapobjectscale, limit_dist);
|
||||
else
|
||||
limit_dist = current_bsp_culling_distance/mapobjectscale;
|
||||
limit_dist = cv_drawdist.value;
|
||||
|
||||
if (current_bsp_culling_distance)
|
||||
{
|
||||
// Use the smaller setting
|
||||
if (limit_dist)
|
||||
limit_dist = std::min(current_bsp_culling_distance/mapobjectscale, limit_dist);
|
||||
else
|
||||
limit_dist = current_bsp_culling_distance/mapobjectscale;
|
||||
}
|
||||
}
|
||||
|
||||
// Handle all things in sector.
|
||||
for (thing = sec->thinglist; thing; thing = thing->snext)
|
||||
{
|
||||
if (!R_ThingWithinDist(thing, limit_dist))
|
||||
continue;
|
||||
// reduce branching in this rather tight loop
|
||||
if constexpr (Type == AddSpritesType::kLimitDist)
|
||||
{
|
||||
if (!R_ThingWithinDist(thing, limit_dist))
|
||||
continue;
|
||||
}
|
||||
|
||||
if (!R_ThingVisible(thing))
|
||||
continue;
|
||||
@@ -4566,6 +4592,7 @@ static void HWR_AddSprites(sector_t *sec)
|
||||
HWR_ProjectSprite(thing);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// --------------------------------------------------------------------------
|
||||
// HWR_AddPrecipitationSprites
|
||||
|
||||
@@ -2031,8 +2031,7 @@ void GL_SetTexture(GLMipmap_t *pTexInfo)
|
||||
{
|
||||
if (pTexInfo->downloaded != tex_downloaded)
|
||||
{
|
||||
if (!currently_batching)
|
||||
pglBindTexture(GL_TEXTURE_2D, pTexInfo->downloaded);
|
||||
pglBindTexture(GL_TEXTURE_2D, pTexInfo->downloaded);
|
||||
tex_downloaded = pTexInfo->downloaded;
|
||||
}
|
||||
}
|
||||
|
||||
+10
-2
@@ -110,13 +110,21 @@ HMS_on_read (char *s, size_t _1, size_t n, void *userdata)
|
||||
|
||||
buffer = userdata;
|
||||
|
||||
if (n >= (size_t)( buffer->end - buffer->needle ))
|
||||
while (n >= (size_t)( buffer->end - buffer->needle ))
|
||||
{
|
||||
/* resize to next multiple of buffer size */
|
||||
blocks = ( n / DEFAULT_BUFFER_SIZE + 1 );
|
||||
buffer->end += ( blocks * DEFAULT_BUFFER_SIZE );
|
||||
|
||||
buffer->buffer = realloc(buffer->buffer, buffer->end);
|
||||
void *tmp = realloc(buffer->buffer, buffer->end);
|
||||
if (tmp == NULL)
|
||||
{
|
||||
// not enough memory to read it, bail
|
||||
free(buffer->buffer);
|
||||
buffer->buffer = NULL;
|
||||
return 0;
|
||||
}
|
||||
buffer->buffer = tmp;
|
||||
}
|
||||
|
||||
memcpy(&buffer->buffer[buffer->needle], s, n);
|
||||
|
||||
+89
-42
@@ -551,26 +551,41 @@ void K_RainbowColormap(UINT8 *dest_colormap, UINT8 skincolor)
|
||||
*/
|
||||
void K_GenerateKartColormap(UINT8 *dest_colormap, INT32 skinnum, UINT8 color, boolean local)
|
||||
{
|
||||
INT32 i;
|
||||
INT32 starttranscolor;
|
||||
INT32 i, starttranscolor;
|
||||
|
||||
// Handle a couple of simple special cases
|
||||
if (skinnum == TC_BOSS
|
||||
|| skinnum == TC_ALLWHITE
|
||||
|| skinnum == TC_METALSONIC
|
||||
|| skinnum == TC_BLINK
|
||||
|| color == SKINCOLOR_NONE)
|
||||
if (skinnum < TC_DEFAULT)
|
||||
{
|
||||
for (i = 0; i < NUM_PALETTE_ENTRIES; i++)
|
||||
switch (skinnum)
|
||||
{
|
||||
if (skinnum == TC_ALLWHITE)
|
||||
dest_colormap[i] = 0;
|
||||
else if (skinnum == TC_BLINK)
|
||||
dest_colormap[i] = colortranslations[color][3];
|
||||
else
|
||||
dest_colormap[i] = (UINT8)i;
|
||||
case TC_ALLWHITE:
|
||||
memset(dest_colormap, 0, NUM_PALETTE_ENTRIES * sizeof(UINT8));
|
||||
return;
|
||||
case TC_RAINBOW:
|
||||
if (color >= MAXTRANSLATIONS)
|
||||
I_Error("Invalid skin color #%hu.", (UINT16)color);
|
||||
if (color != SKINCOLOR_NONE)
|
||||
{
|
||||
K_RainbowColormap(dest_colormap, color);
|
||||
return;
|
||||
}
|
||||
break;
|
||||
case TC_BLINK:
|
||||
if (color >= MAXTRANSLATIONS)
|
||||
I_Error("Invalid skin color #%hu.", (UINT16)color);
|
||||
if (color != SKINCOLOR_NONE)
|
||||
{
|
||||
memset(dest_colormap, colortranslations[color][3], NUM_PALETTE_ENTRIES * sizeof(UINT8));
|
||||
return;
|
||||
}
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
for (i = 0; i < NUM_PALETTE_ENTRIES; i++)
|
||||
dest_colormap[i] = (UINT8)i;
|
||||
|
||||
// White!
|
||||
if (skinnum == TC_BOSS)
|
||||
dest_colormap[31] = 0;
|
||||
@@ -579,14 +594,25 @@ void K_GenerateKartColormap(UINT8 *dest_colormap, INT32 skinnum, UINT8 color, bo
|
||||
|
||||
return;
|
||||
}
|
||||
else if (skinnum == TC_RAINBOW)
|
||||
else if (color == SKINCOLOR_NONE)
|
||||
{
|
||||
K_RainbowColormap(dest_colormap, color);
|
||||
for (i = 0; i < NUM_PALETTE_ENTRIES; i++)
|
||||
dest_colormap[i] = (UINT8)i;
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
if (color >= MAXTRANSLATIONS)
|
||||
I_Error("Invalid skin color #%hu.", (UINT16)color);
|
||||
|
||||
if (skinnum < 0 && skinnum > TC_DEFAULT)
|
||||
I_Error("Invalid translation colormap index %d.", skinnum);
|
||||
|
||||
starttranscolor = (skinnum != TC_DEFAULT) ? K_GetSkinArray(local)[skinnum].starttranscolor : DEFAULT_STARTTRANSCOLOR;
|
||||
|
||||
if (starttranscolor >= NUM_PALETTE_ENTRIES)
|
||||
I_Error("Invalid startcolor #%d.", starttranscolor);
|
||||
|
||||
// Fill in the entries of the palette that are fixed
|
||||
for (i = 0; i < starttranscolor; i++)
|
||||
dest_colormap[i] = (UINT8)i;
|
||||
@@ -1586,7 +1612,7 @@ static UINT8 K_CheckOffroadCollide(mobj_t *mo)
|
||||
|
||||
// we will do essentially the same checks as above instead of bothering with top/bottom height of the FOF.
|
||||
// Reminder that an FOF's floor is its bottom, silly!
|
||||
if ( ((s2->flags & SF_FLIPSPECIAL_FLOOR) && mo->z == cel) // "floor" check
|
||||
if ( ((s2->flags & SF_FLIPSPECIAL_FLOOR) && mo->z == cel) // "floor" check
|
||||
|| ((s2->flags & SF_FLIPSPECIAL_CEILING) && (mo->z + mo->height) == flr) ) // "ceiling" check.
|
||||
|
||||
for (i = 2; i < 5; i++) // check for sector special
|
||||
@@ -1670,10 +1696,10 @@ static void K_SpawnDashDustRelease(player_t *player)
|
||||
I_Assert(player->mo != NULL);
|
||||
I_Assert(!P_MobjWasRemoved(player->mo));
|
||||
|
||||
if (!P_IsObjectOnGround(player->mo))
|
||||
if (!player->speed && !player->kartstuff[k_startboost])
|
||||
return;
|
||||
|
||||
if (!player->speed && !player->kartstuff[k_startboost])
|
||||
if (!P_IsObjectOnGround(player->mo))
|
||||
return;
|
||||
|
||||
travelangle = player->mo->angle;
|
||||
@@ -1903,11 +1929,11 @@ static void K_PlayGenericCombatSound(mobj_t *source, mobj_t *other, sfxenum_t sf
|
||||
|
||||
boolean alwaysHear = false;
|
||||
|
||||
if (other != NULL && P_MobjWasRemoved(other) == false && other->player != NULL)
|
||||
if (cv_kartvoices.value && !P_MobjWasRemoved(other) && other->player != NULL)
|
||||
{
|
||||
alwaysHear = P_IsDisplayPlayer(other->player);
|
||||
|
||||
if (cv_kartvoices.value)
|
||||
S_StartSound(alwaysHear ? NULL : source, skin->soundsid[S_sfx[sfx_id].skinsound]);
|
||||
}
|
||||
|
||||
K_RegularVoiceTimers(source->player);
|
||||
}
|
||||
@@ -1929,7 +1955,7 @@ void K_PlayAttackTaunt(mobj_t *source)
|
||||
void K_PlayBoostTaunt(mobj_t *source)
|
||||
{
|
||||
sfxenum_t pick = P_RandomKey(2); // Gotta roll the RNG every time this is called for sync reasons
|
||||
boolean tasteful = (!source->player || !source->player->kartstuff[k_tauntvoices]);
|
||||
const boolean tasteful = (!source->player || !source->player->kartstuff[k_tauntvoices]);
|
||||
|
||||
if (cv_kartvoices.value && (tasteful || cv_kartvoices.value == 2))
|
||||
S_StartSound(source, sfx_kbost1+pick);
|
||||
@@ -1942,8 +1968,6 @@ void K_PlayBoostTaunt(mobj_t *source)
|
||||
|
||||
void K_PlayOvertakeSound(mobj_t *source)
|
||||
{
|
||||
boolean tasteful = (!source->player || !source->player->kartstuff[k_voices]);
|
||||
|
||||
if (!G_RaceGametype()) // Only in race
|
||||
return;
|
||||
|
||||
@@ -1951,6 +1975,8 @@ void K_PlayOvertakeSound(mobj_t *source)
|
||||
if (leveltime < starttime+(10*TICRATE))
|
||||
return;
|
||||
|
||||
const boolean tasteful = (!source->player || !source->player->kartstuff[k_voices]);
|
||||
|
||||
if (cv_kartvoices.value && (tasteful || cv_kartvoices.value == 2))
|
||||
S_StartSound(source, sfx_kslow);
|
||||
|
||||
@@ -2186,6 +2212,7 @@ fixed_t K_GetKartSpeed(player_t *player, boolean doboostpower)
|
||||
|
||||
if (doboostpower)
|
||||
return FixedMul(finalspeed, player->kartstuff[k_boostpower]+player->kartstuff[k_speedboost]);
|
||||
|
||||
return finalspeed;
|
||||
}
|
||||
|
||||
@@ -2222,10 +2249,14 @@ fixed_t K_3dKartMovement(player_t *player, boolean onground, fixed_t forwardmove
|
||||
{
|
||||
fixed_t accelmax = 4000;
|
||||
fixed_t newspeed, oldspeed, finalspeed;
|
||||
fixed_t p_speed = K_GetKartSpeed(player, true);
|
||||
fixed_t p_accel = K_GetKartAccel(player);
|
||||
fixed_t p_speed, p_accel;
|
||||
|
||||
if (!onground) return 0; // If the player isn't on the ground, there is no change in speed
|
||||
// If the player isn't on the ground, there is no change in speed
|
||||
if (!onground)
|
||||
return 0;
|
||||
|
||||
p_speed = K_GetKartSpeed(player, true);
|
||||
p_accel = K_GetKartAccel(player);
|
||||
|
||||
// ACCELCODE!!!1!11!
|
||||
oldspeed = R_PointToDist2(0, 0, player->rmomx, player->rmomy); // FixedMul(P_AproxDistance(player->rmomx, player->rmomy), player->mo->scale);
|
||||
@@ -2329,6 +2360,7 @@ void K_SpinPlayer(player_t *player, mobj_t *source, INT32 type, mobj_t *inflicto
|
||||
|
||||
if (P_MobjWasRemoved(player->mo))
|
||||
return; // mobj was removed (in theory that shouldn't happen)
|
||||
|
||||
if (shouldForce == 1)
|
||||
force = true;
|
||||
else if (shouldForce == 2)
|
||||
@@ -2469,8 +2501,10 @@ void K_SquishPlayer(player_t *player, mobj_t *source, mobj_t *inflictor)
|
||||
// PS: Inflictor is unused for all purposes here and is actually only ever relevant to Lua. It may be nil too.
|
||||
boolean force = false; // Used to check if Lua ShouldSquish should get us damaged reguardless of flashtics or heck knows what.
|
||||
UINT8 shouldForce = LUA_HookShouldSquish(player, inflictor, source);
|
||||
|
||||
if (P_MobjWasRemoved(player->mo))
|
||||
return; // mobj was removed (in theory that shouldn't happen)
|
||||
|
||||
if (shouldForce == 1)
|
||||
force = true;
|
||||
else if (shouldForce == 2)
|
||||
@@ -2583,6 +2617,7 @@ void K_ExplodePlayer(player_t *player, mobj_t *source, mobj_t *inflictor) // A b
|
||||
|
||||
if (P_MobjWasRemoved(player->mo))
|
||||
return; // mobj was removed (in theory that shouldn't happen)
|
||||
|
||||
if (shouldForce == 1)
|
||||
force = true;
|
||||
else if (shouldForce == 2)
|
||||
@@ -2668,6 +2703,7 @@ void K_ExplodePlayer(player_t *player, mobj_t *source, mobj_t *inflictor) // A b
|
||||
player->powers[pw_flashing] = K_GetKartFlashing(player);
|
||||
|
||||
upgoer = (18*mapobjectscale*P_MobjFlip(player->mo));
|
||||
|
||||
if (player->mo->eflags & MFE_UNDERWATER)
|
||||
upgoer = (117 * upgoer) / 200;
|
||||
|
||||
@@ -3603,7 +3639,6 @@ void K_SpawnWipeoutTrail(mobj_t *mo, boolean translucent)
|
||||
void K_DriftDustHandling(mobj_t *spawner)
|
||||
{
|
||||
angle_t anglediff;
|
||||
const INT16 spawnrange = spawner->radius>>FRACBITS;
|
||||
|
||||
if (!P_IsObjectOnGround(spawner) || leveltime % 2 != 0)
|
||||
return;
|
||||
@@ -3640,6 +3675,8 @@ void K_DriftDustHandling(mobj_t *spawner)
|
||||
if (anglediff > ANGLE_180)
|
||||
anglediff = InvAngle(anglediff);
|
||||
|
||||
const INT16 spawnrange = spawner->radius>>FRACBITS;
|
||||
|
||||
if (anglediff > ANG10*4) // Trying to turn further than 40 degrees
|
||||
{
|
||||
fixed_t spawnx = P_RandomRange(-spawnrange, spawnrange)<<FRACBITS;
|
||||
@@ -3899,9 +3936,8 @@ static mobj_t *K_ThrowKartItem(player_t *player, boolean missile, mobjtype_t map
|
||||
|
||||
void K_PuntMine(mobj_t *thismine, mobj_t *punter)
|
||||
{
|
||||
angle_t fa = R_PointToAngle2(0, 0, punter->momx, punter->momy) >> ANGLETOFINESHIFT;
|
||||
fixed_t z = 30*mapobjectscale + punter->momz;
|
||||
fixed_t spd;
|
||||
angle_t fa;
|
||||
fixed_t z, spd;
|
||||
mobj_t *mine;
|
||||
|
||||
if (P_MobjWasRemoved(thismine))
|
||||
@@ -3936,6 +3972,9 @@ void K_PuntMine(mobj_t *thismine, mobj_t *punter)
|
||||
if (P_MobjWasRemoved(mine))
|
||||
return;
|
||||
|
||||
fa = R_PointToAngle2(0, 0, punter->momx, punter->momy) >> ANGLETOFINESHIFT;
|
||||
z = 30*mapobjectscale + punter->momz;
|
||||
|
||||
spd = K_GetProjectileSpeed();
|
||||
|
||||
mine->flags |= MF_NOCLIPTHING;
|
||||
@@ -4147,8 +4186,10 @@ static void K_DoShrink(player_t *user)
|
||||
{
|
||||
if (!playeringame[i] || players[i].spectator || !players[i].mo)
|
||||
continue;
|
||||
|
||||
if (&players[i] == user)
|
||||
continue;
|
||||
|
||||
if (players[i].kartstuff[k_position] < user->kartstuff[k_position])
|
||||
{
|
||||
//P_FlashPal(&players[i], PAL_NUKE, 10);
|
||||
@@ -5033,6 +5074,7 @@ player_t *K_FindJawzTarget(mobj_t *actor, player_t *source)
|
||||
|
||||
// Find the angle, see who's got the best.
|
||||
thisang = actor->angle - R_PointToAngle2(actor->x, actor->y, player->mo->x, player->mo->y);
|
||||
|
||||
if (thisang > ANGLE_180)
|
||||
thisang = InvAngle(thisang);
|
||||
|
||||
@@ -5229,10 +5271,11 @@ static void K_UpdateEngineSounds(player_t *player, ticcmd_t *cmd)
|
||||
static void K_UpdateInvincibilitySounds(player_t *player)
|
||||
{
|
||||
INT32 sfxnum = sfx_None;
|
||||
const boolean localplayer = P_IsLocalPlayer(player);
|
||||
|
||||
if (player->mo->health > 0)
|
||||
{
|
||||
const boolean localplayer = P_IsLocalPlayer(player);
|
||||
|
||||
if (player->kartstuff[k_growshrinktimer] > 0 && (!localplayer || cv_growmusic.value == 2)) // Prioritize Grow
|
||||
sfxnum = cv_kartinvinsfx.value ? sfx_alarmg : sfx_kgrow;
|
||||
else if (player->kartstuff[k_invincibilitytimer] > 0 && (!localplayer || cv_supermusic.value == 2))
|
||||
@@ -5772,7 +5815,7 @@ boolean K_CheckPlayersRespawnColliding(INT32 playernum, fixed_t x, fixed_t y)
|
||||
static INT16 K_GetKartDriftValue(player_t *player, fixed_t countersteer)
|
||||
{
|
||||
INT16 basedrift, driftangle;
|
||||
fixed_t driftweight = player->kartweight*14; // 12
|
||||
fixed_t driftweight;
|
||||
|
||||
// If they aren't drifting or on the ground this doesn't apply
|
||||
if (player->kartstuff[k_drift] == 0 || !P_IsObjectOnGround(player->mo))
|
||||
@@ -5783,6 +5826,8 @@ static INT16 K_GetKartDriftValue(player_t *player, fixed_t countersteer)
|
||||
return -266*player->kartstuff[k_drift]; // Drift has ended and we are tweaking their angle back a bit
|
||||
}
|
||||
|
||||
driftweight = player->kartweight*14; // 12
|
||||
|
||||
//basedrift = 90*player->kartstuff[k_drift]; // 450
|
||||
//basedrift = 93*player->kartstuff[k_drift] - driftweight*3*player->kartstuff[k_drift]/10; // 447 - 303
|
||||
basedrift = 83*player->kartstuff[k_drift] - (driftweight - 14)*player->kartstuff[k_drift]/5; // 415 - 303
|
||||
@@ -5793,6 +5838,9 @@ static INT16 K_GetKartDriftValue(player_t *player, fixed_t countersteer)
|
||||
|
||||
INT16 K_GetKartTurnValue(player_t *player, INT16 turnvalue)
|
||||
{
|
||||
fixed_t p_topspeed, p_curspeed, p_maxspeed;
|
||||
fixed_t adjustangle;
|
||||
|
||||
if (player->spectator)
|
||||
return turnvalue;
|
||||
|
||||
@@ -5811,10 +5859,10 @@ INT16 K_GetKartTurnValue(player_t *player, INT16 turnvalue)
|
||||
return turnvalue;
|
||||
}
|
||||
|
||||
fixed_t p_topspeed = K_GetKartSpeed(player, false);
|
||||
fixed_t p_curspeed = min(player->speed, p_topspeed * 2);
|
||||
fixed_t p_maxspeed = p_topspeed * 3;
|
||||
fixed_t adjustangle = FixedDiv((p_maxspeed>>16) - (p_curspeed>>16), (p_maxspeed>>16) + player->kartweight);
|
||||
p_topspeed = K_GetKartSpeed(player, false);
|
||||
p_curspeed = min(player->speed, p_topspeed * 2);
|
||||
p_maxspeed = p_topspeed * 3;
|
||||
adjustangle = FixedDiv((p_maxspeed>>16) - (p_curspeed>>16), (p_maxspeed>>16) + player->kartweight);
|
||||
|
||||
turnvalue = FixedMul(turnvalue, adjustangle); // Weight has a small effect on turning
|
||||
|
||||
@@ -6216,7 +6264,7 @@ void K_MoveKartPlayer(player_t *player, boolean onground)
|
||||
|
||||
K_KartUpdatePosition(player);
|
||||
|
||||
if (!player->exiting)
|
||||
if (LIKELY(!player->exiting))
|
||||
{
|
||||
if (player->kartstuff[k_oldposition] < player->kartstuff[k_position]) // But first, if you lost a place,
|
||||
{
|
||||
@@ -6796,10 +6844,9 @@ void K_MoveKartPlayer(player_t *player, boolean onground)
|
||||
|
||||
K_KartDrift(player, onground);
|
||||
|
||||
if ((!player->kartstuff[k_aizdriftstrat]) || (!P_IsObjectOnGround(player->mo)) || (player->kartstuff[k_drift]))
|
||||
if (player->sliproll && ((!player->kartstuff[k_aizdriftstrat]) || (!P_IsObjectOnGround(player->mo)) || (player->kartstuff[k_drift])))
|
||||
{
|
||||
if (player->sliproll && (player->sliproll > 0))
|
||||
player->sliproll -= (4*ANG1);
|
||||
player->sliproll -= (4*ANG1);
|
||||
}
|
||||
|
||||
// funneh Saturn sprite stuff
|
||||
|
||||
+5
-5
@@ -574,10 +574,10 @@ static menuitem_t MP_PlayerSetupMenu[] =
|
||||
#ifndef NONET
|
||||
static menuitem_t MP_ConnectMenu[] =
|
||||
{
|
||||
{IT_STRING | IT_KEYHANDLER, NULL, "", M_HandleServerSearch,0},
|
||||
{IT_STRING | IT_CVAR, NULL, "Sort By", &cv_serversort, 16},
|
||||
{IT_STRING | IT_KEYHANDLER, NULL, "Page", M_HandleServerPage, 24},
|
||||
{IT_STRING | IT_CALL, NULL, "Refresh", M_Refresh, 32},
|
||||
{IT_STRING | IT_CVAR, NULL, "Sort By", &cv_serversort, 0},
|
||||
{IT_STRING | IT_KEYHANDLER, NULL, "Page", M_HandleServerPage, 8},
|
||||
{IT_STRING | IT_CALL, NULL, "Refresh", M_Refresh, 16},
|
||||
{IT_STRING | IT_KEYHANDLER, NULL, "", M_HandleServerSearch,25},
|
||||
|
||||
{IT_STRING | IT_SPACE, NULL, "", M_Connect, 48},
|
||||
{IT_STRING | IT_SPACE, NULL, "", M_Connect, 60},
|
||||
@@ -593,10 +593,10 @@ static menuitem_t MP_ConnectMenu[] =
|
||||
|
||||
enum
|
||||
{
|
||||
mp_connect_search,
|
||||
mp_connect_sort,
|
||||
mp_connect_page,
|
||||
mp_connect_refresh,
|
||||
mp_connect_search,
|
||||
FIRSTSERVERLINE
|
||||
};
|
||||
#endif
|
||||
|
||||
@@ -2294,6 +2294,51 @@ void M_MkdirEach(const char *path, int start, int mode)
|
||||
M_MkdirEachUntil(path, start, -1, mode);
|
||||
}
|
||||
|
||||
// Hashes some message using FNV-1a
|
||||
#define FNV1A_OFFSET_BASIS 0x811C9DC5
|
||||
#define FNV1A_PRIME 0x01000193
|
||||
|
||||
UINT32 FNV1a_Hash(const char *message, size_t size)
|
||||
{
|
||||
UINT32 hash = FNV1A_OFFSET_BASIS;
|
||||
|
||||
for (size_t i = 0; i < size; i++)
|
||||
{
|
||||
hash ^= message[i];
|
||||
hash *= FNV1A_PRIME;
|
||||
}
|
||||
|
||||
return hash;
|
||||
}
|
||||
|
||||
UINT32 FNV1a_HashString(const char *message)
|
||||
{
|
||||
UINT32 hash = FNV1A_OFFSET_BASIS;
|
||||
|
||||
while (*message)
|
||||
{
|
||||
hash ^= *message;
|
||||
hash *= FNV1A_PRIME;
|
||||
message++;
|
||||
}
|
||||
|
||||
return hash;
|
||||
}
|
||||
|
||||
UINT32 FNV1a_HashLowercaseString(const char *message)
|
||||
{
|
||||
UINT32 hash = FNV1A_OFFSET_BASIS;
|
||||
|
||||
while (*message)
|
||||
{
|
||||
hash ^= tolower(*message);
|
||||
hash *= FNV1A_PRIME;
|
||||
message++;
|
||||
}
|
||||
|
||||
return hash;
|
||||
}
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
} // extern "C"
|
||||
|
||||
@@ -124,6 +124,11 @@ const char * M_Ftrim (double);
|
||||
// counting bits, for weapon ammo code, usually
|
||||
FUNCMATH UINT8 M_CountBits(UINT32 num, UINT8 size);
|
||||
|
||||
// Hashes some message using FNV-1a
|
||||
UINT32 FNV1a_Hash(const char *message, size_t size);
|
||||
UINT32 FNV1a_HashString(const char *message);
|
||||
UINT32 FNV1a_HashLowercaseString(const char *message);
|
||||
|
||||
#include "w_wad.h"
|
||||
extern char configfile[MAX_WADPATH];
|
||||
|
||||
|
||||
+2
-2
@@ -250,7 +250,7 @@ boolean P_Move(mobj_t *actor, fixed_t speed)
|
||||
I_Assert(movedir < NUMDIRS);
|
||||
|
||||
tryx = actor->x + FixedMul(speed*xspeed[movedir], actor->scale);
|
||||
if (twodlevel || actor->flags2 & MF2_TWOD)
|
||||
if (UNLIKELY(twodlevel || actor->flags2 & MF2_TWOD))
|
||||
tryy = actor->y;
|
||||
else
|
||||
tryy = actor->y + FixedMul(speed*yspeed[movedir], actor->scale);
|
||||
@@ -4387,7 +4387,7 @@ void A_MouseThink(void *thing)
|
||||
|| (actor->eflags & MFE_VERTICALFLIP && actor->z + actor->height == actor->ceilingz))
|
||||
&& !actor->reactiontime)
|
||||
{
|
||||
if (twodlevel || actor->flags2 & MF2_TWOD)
|
||||
if (UNLIKELY(twodlevel || actor->flags2 & MF2_TWOD))
|
||||
{
|
||||
if (P_RandomChance(FRACUNIT/2))
|
||||
actor->angle += ANGLE_180;
|
||||
|
||||
+14
-13
@@ -587,7 +587,7 @@ void P_TouchSpecialThing(mobj_t *special, mobj_t *toucher, boolean heightcheck)
|
||||
special->momx = special->momy = special->momz = 0;
|
||||
P_GivePlayerRings(player, 1);
|
||||
|
||||
if ((maptol & TOL_NIGHTS) && special->type != MT_FLINGRING)
|
||||
if (UNLIKELY((maptol & TOL_NIGHTS) && special->type != MT_FLINGRING))
|
||||
P_DoNightsScore(player);
|
||||
break;
|
||||
|
||||
@@ -599,7 +599,7 @@ void P_TouchSpecialThing(mobj_t *special, mobj_t *toucher, boolean heightcheck)
|
||||
special->momx = special->momy = 0;
|
||||
P_GivePlayerRings(player, 1);
|
||||
|
||||
if ((maptol & TOL_NIGHTS) && special->type != MT_FLINGCOIN)
|
||||
if (UNLIKELY((maptol & TOL_NIGHTS) && special->type != MT_FLINGCOIN))
|
||||
P_DoNightsScore(player);
|
||||
break;
|
||||
case MT_BLUEBALL:
|
||||
@@ -615,7 +615,7 @@ void P_TouchSpecialThing(mobj_t *special, mobj_t *toucher, boolean heightcheck)
|
||||
else
|
||||
special->scalespeed = 4*FRACUNIT/5;
|
||||
|
||||
if (maptol & TOL_NIGHTS)
|
||||
if (UNLIKELY(maptol & TOL_NIGHTS))
|
||||
P_DoNightsScore(player);
|
||||
break;
|
||||
case MT_AUTOPICKUP:
|
||||
@@ -832,6 +832,7 @@ void P_TouchSpecialThing(mobj_t *special, mobj_t *toucher, boolean heightcheck)
|
||||
if (player->bumpertime < TICRATE/4)
|
||||
{
|
||||
S_StartSound(toucher, special->info->seesound);
|
||||
|
||||
if (player->pflags & PF_NIGHTSMODE)
|
||||
{
|
||||
player->bumpertime = TICRATE/2;
|
||||
@@ -1226,9 +1227,9 @@ void P_TouchSpecialThing(mobj_t *special, mobj_t *toucher, boolean heightcheck)
|
||||
return; // SRB2kart - don't need bubbles mucking with the player
|
||||
if ((player->powers[pw_shield] & SH_NOSTACK) == SH_ELEMENTAL)
|
||||
return;
|
||||
if (maptol & TOL_NIGHTS)
|
||||
if (UNLIKELY(maptol & TOL_NIGHTS))
|
||||
return;
|
||||
if (mariomode)
|
||||
if (UNLIKELY(mariomode))
|
||||
return;
|
||||
else if (toucher->eflags & MFE_VERTICALFLIP)
|
||||
{
|
||||
@@ -2352,11 +2353,11 @@ boolean P_DamageMobj(mobj_t *target, mobj_t *inflictor, mobj_t *source, INT32 da
|
||||
if (player->exiting)
|
||||
return false;
|
||||
|
||||
if (!(target->player->pflags & (PF_NIGHTSMODE|PF_NIGHTSFALL)) && (maptol & TOL_NIGHTS))
|
||||
if (UNLIKELY(!(target->player->pflags & (PF_NIGHTSMODE|PF_NIGHTSFALL)) && (maptol & TOL_NIGHTS)))
|
||||
return false;
|
||||
}
|
||||
|
||||
if (player->pflags & PF_NIGHTSMODE) // NiGHTS damage handling
|
||||
if (UNLIKELY(player->pflags & PF_NIGHTSMODE)) // NiGHTS damage handling
|
||||
{
|
||||
if (!force)
|
||||
{
|
||||
@@ -2601,7 +2602,7 @@ void P_PlayerRingBurst(player_t *player, INT32 num_rings)
|
||||
ns = FixedMul(((i*FRACUNIT)/16)+2*FRACUNIT, mo->scale);
|
||||
mo->momx = FixedMul(FINECOSINE(fa),ns);
|
||||
|
||||
if (!(twodlevel || (player->mo->flags2 & MF2_TWOD)))
|
||||
if (LIKELY(!(twodlevel || (player->mo->flags2 & MF2_TWOD))))
|
||||
mo->momy = FixedMul(FINESINE(fa),ns);
|
||||
|
||||
P_SetObjectMomZ(mo, 8*FRACUNIT, false);
|
||||
@@ -2625,7 +2626,7 @@ void P_PlayerRingBurst(player_t *player, INT32 num_rings)
|
||||
ns = FixedMul(momxy, mo->scale);
|
||||
mo->momx = FixedMul(FINECOSINE(fa),ns);
|
||||
|
||||
if (!(twodlevel || (player->mo->flags2 & MF2_TWOD)))
|
||||
if (LIKELY(!(twodlevel || (player->mo->flags2 & MF2_TWOD))))
|
||||
mo->momy = FixedMul(FINESINE(fa),ns);
|
||||
|
||||
ns = momz;
|
||||
@@ -2732,7 +2733,7 @@ void P_PlayerWeaponPanelBurst(player_t *player)
|
||||
ns = FixedMul(3*FRACUNIT, mo->scale);
|
||||
mo->momx = FixedMul(FINECOSINE(fa),ns);
|
||||
|
||||
if (!(twodlevel || (player->mo->flags2 & MF2_TWOD)))
|
||||
if (LIKELY(!(twodlevel || (player->mo->flags2 & MF2_TWOD))))
|
||||
mo->momy = FixedMul(FINESINE(fa),ns);
|
||||
|
||||
P_SetObjectMomZ(mo, 4*FRACUNIT, false);
|
||||
@@ -2816,7 +2817,7 @@ void P_PlayerWeaponAmmoBurst(player_t *player)
|
||||
ns = FixedMul(2*FRACUNIT, mo->scale);
|
||||
mo->momx = FixedMul(FINECOSINE(fa), ns);
|
||||
|
||||
if (!(twodlevel || (player->mo->flags2 & MF2_TWOD)))
|
||||
if (LIKELY(!(twodlevel || (player->mo->flags2 & MF2_TWOD))))
|
||||
mo->momy = FixedMul(FINESINE(fa),ns);
|
||||
|
||||
P_SetObjectMomZ(mo, 3*FRACUNIT, false);
|
||||
@@ -2932,7 +2933,7 @@ void P_PlayerEmeraldBurst(player_t *player, boolean toss)
|
||||
|
||||
momx = FixedMul(FINECOSINE(fa), ns);
|
||||
|
||||
if (!(twodlevel || (player->mo->flags2 & MF2_TWOD)))
|
||||
if (LIKELY(!(twodlevel || (player->mo->flags2 & MF2_TWOD))))
|
||||
momy = FixedMul(FINESINE(fa),ns);
|
||||
else
|
||||
momy = 0;
|
||||
@@ -2989,7 +2990,7 @@ void P_PlayerFlagBurst(player_t *player, boolean toss)
|
||||
{
|
||||
angle_t fa = P_RandomByte()*FINEANGLES/256;
|
||||
flag->momx = FixedMul(FINECOSINE(fa), FixedMul(6*FRACUNIT, player->mo->scale));
|
||||
if (!(twodlevel || (player->mo->flags2 & MF2_TWOD)))
|
||||
if (LIKELY(!(twodlevel || (player->mo->flags2 & MF2_TWOD))))
|
||||
flag->momy = FixedMul(FINESINE(fa), FixedMul(6*FRACUNIT, player->mo->scale));
|
||||
}
|
||||
|
||||
|
||||
+5
-5
@@ -140,7 +140,7 @@ boolean P_DoSpring(mobj_t *spring, mobj_t *object)
|
||||
if (object->player && object->player->spectator)
|
||||
return false;
|
||||
|
||||
if (object->player && (object->player->pflags & PF_NIGHTSMODE))
|
||||
if (UNLIKELY(object->player && (object->player->pflags & PF_NIGHTSMODE)))
|
||||
{
|
||||
/*Someone want to make these work like bumpers?*/
|
||||
return false;
|
||||
@@ -335,7 +335,7 @@ static boolean PIT_CheckThing(mobj_t *thing)
|
||||
#ifdef SEENAMES
|
||||
// Do name checks all the way up here
|
||||
// So that NOTHING ELSE can see MT_NAMECHECK because it is client-side.
|
||||
if (tmthing->type == MT_NAMECHECK)
|
||||
if (UNLIKELY(tmthing->type == MT_NAMECHECK))
|
||||
{
|
||||
// Ignore things that aren't players, ignore spectators, ignore yourself.
|
||||
// (also don't bother to check that tmthing->target->player is non-NULL because we're not actually using it here.)
|
||||
@@ -361,8 +361,8 @@ static boolean PIT_CheckThing(mobj_t *thing)
|
||||
return true;
|
||||
|
||||
// Don't collide with your buddies while NiGHTS-flying.
|
||||
if (tmthing->player && thing->player && (maptol & TOL_NIGHTS)
|
||||
&& ((tmthing->player->pflags & PF_NIGHTSMODE) || (thing->player->pflags & PF_NIGHTSMODE)))
|
||||
if (UNLIKELY(tmthing->player && thing->player && (maptol & TOL_NIGHTS)
|
||||
&& ((tmthing->player->pflags & PF_NIGHTSMODE) || (thing->player->pflags & PF_NIGHTSMODE))))
|
||||
return true;
|
||||
|
||||
blockdist = thing->radius + tmthing->radius;
|
||||
@@ -3183,7 +3183,7 @@ stairstep:
|
||||
|
||||
P_HitSlideLine(bestslideline); // clip the moves
|
||||
|
||||
if ((twodlevel || (mo->flags2 & MF2_TWOD)) && mo->player)
|
||||
if (UNLIKELY((twodlevel || (mo->flags2 & MF2_TWOD)) && mo->player))
|
||||
{
|
||||
mo->momx = tmxmove;
|
||||
tmymove = 0;
|
||||
|
||||
+50
-38
@@ -371,7 +371,7 @@ static boolean P_SetPrecipMobjState(precipmobj_t *mobj, statenum_t state)
|
||||
//
|
||||
boolean P_WeaponOrPanel(mobjtype_t type)
|
||||
{
|
||||
if (type >= MT_BOUNCERING && type <= MT_GRENADEPICKUP)
|
||||
if (UNLIKELY(type >= MT_BOUNCERING && type <= MT_GRENADEPICKUP)) // doubt those get used at all in kart tbh
|
||||
return true;
|
||||
|
||||
return false;
|
||||
@@ -461,6 +461,7 @@ void P_ExplodeMissile(mobj_t *mo)
|
||||
boolean P_InsideANonSolidFFloor(mobj_t *mobj, ffloor_t *rover)
|
||||
{
|
||||
fixed_t topheight, bottomheight;
|
||||
|
||||
if (!(rover->flags & FF_EXISTS))
|
||||
return false;
|
||||
|
||||
@@ -891,7 +892,7 @@ static void P_PlayerFlip(mobj_t *mo)
|
||||
G_GhostAddFlip((INT32) (mo->player - players));
|
||||
// Flip aiming to match!
|
||||
|
||||
if (mo->player->pflags & PF_NIGHTSMODE) // NiGHTS doesn't use flipcam
|
||||
if (UNLIKELY(mo->player->pflags & PF_NIGHTSMODE)) // NiGHTS doesn't use flipcam
|
||||
{
|
||||
if (mo->tracer)
|
||||
mo->tracer->eflags ^= MFE_VERTICALFLIP;
|
||||
@@ -989,7 +990,7 @@ fixed_t P_GetMobjGravity(mobj_t *mo)
|
||||
//|| (mo->player->charability == CA_FLY && (mo->player->powers[pw_tailsfly]
|
||||
// || (mo->state >= &states[S_PLAY_SPC1] && mo->state <= &states[S_PLAY_SPC4]))))
|
||||
// gravityadd = gravityadd/3; // less gravity while flying/gliding
|
||||
if (mo->player->climbing || (mo->player->pflags & PF_NIGHTSMODE))
|
||||
if (UNLIKELY(mo->player->climbing || (mo->player->pflags & PF_NIGHTSMODE)))
|
||||
return 0;
|
||||
|
||||
if (!(mo->flags2 & MF2_OBJECTFLIP) != !(mo->player->powers[pw_gravityboots])) // negated to turn numeric into bool - would be double negated, but not needed if both would be
|
||||
@@ -1607,7 +1608,7 @@ void P_XYMovement(mobj_t *mo)
|
||||
// Check the gravity status.
|
||||
P_CheckGravity(mo, false);
|
||||
|
||||
if (player && !moved && player->pflags & PF_NIGHTSMODE && mo->target)
|
||||
if (UNLIKELY(player && !moved && player->pflags & PF_NIGHTSMODE && mo->target))
|
||||
{
|
||||
angle_t fa;
|
||||
|
||||
@@ -1652,7 +1653,7 @@ void P_XYMovement(mobj_t *mo)
|
||||
if (player && player->homing) // no friction for homing
|
||||
return;
|
||||
|
||||
if (player && player->pflags & PF_NIGHTSMODE)
|
||||
if (UNLIKELY(player && player->pflags & PF_NIGHTSMODE))
|
||||
return; // no friction for NiGHTS players
|
||||
|
||||
if ((mo->type == MT_BIGTUMBLEWEED || mo->type == MT_LITTLETUMBLEWEED)
|
||||
@@ -1735,9 +1736,6 @@ static void P_AdjustMobjFloorZ_FFloors(mobj_t *mo, sector_t *sector, UINT8 motyp
|
||||
if (!(rover->flags & FF_EXISTS))
|
||||
continue;
|
||||
|
||||
topheight = P_GetFOFTopZ(mo, sector, rover, mo->x, mo->y, NULL);
|
||||
bottomheight = P_GetFOFBottomZ(mo, sector, rover, mo->x, mo->y, NULL);
|
||||
|
||||
if (mo->player && P_CheckSolidLava(mo, rover)) // only the player should be affected
|
||||
;
|
||||
else if (motype != 0 && rover->flags & FF_SWIMMABLE) // "scenery" only
|
||||
@@ -1747,6 +1745,10 @@ static void P_AdjustMobjFloorZ_FFloors(mobj_t *mo, sector_t *sector, UINT8 motyp
|
||||
else if (!((rover->flags & FF_BLOCKPLAYER && mo->player) // solid to players?
|
||||
|| (rover->flags & FF_BLOCKOTHERS && !mo->player))) // solid to others?
|
||||
continue;
|
||||
|
||||
topheight = P_GetFOFTopZ(mo, sector, rover, mo->x, mo->y, NULL);
|
||||
bottomheight = P_GetFOFBottomZ(mo, sector, rover, mo->x, mo->y, NULL);
|
||||
|
||||
if (rover->flags & FF_QUICKSAND)
|
||||
{
|
||||
switch (motype)
|
||||
@@ -1770,6 +1772,7 @@ static void P_AdjustMobjFloorZ_FFloors(mobj_t *mo, sector_t *sector, UINT8 motyp
|
||||
|
||||
delta1 = mo->z - (bottomheight + ((topheight - bottomheight)/2));
|
||||
delta2 = thingtop - (bottomheight + ((topheight - bottomheight)/2));
|
||||
|
||||
if (topheight > mo->floorz && abs(delta1) < abs(delta2)
|
||||
&& !(rover->flags & FF_REVERSEPLATFORM)
|
||||
&& ((P_MobjFlip(mo)*mo->momz >= 0) || (!(rover->flags & FF_PLATFORM)))) // In reverse gravity, only clip for FOFs that are intangible from their bottom (the "top" you're falling through) if you're coming from above ("below" in your frame of reference)
|
||||
@@ -1803,7 +1806,7 @@ static void P_AdjustMobjFloorZ_PolyObjs(mobj_t *mo, subsector_t *subsec)
|
||||
|
||||
thingtop = mo->z + mo->height;
|
||||
|
||||
while(po)
|
||||
while (po)
|
||||
{
|
||||
if (!P_MobjInsidePolyobj(po, mo) || !(po->flags & POF_SOLID))
|
||||
{
|
||||
@@ -1855,6 +1858,7 @@ static void P_RingZMovement(mobj_t *mo)
|
||||
mo->momz += mo->pmomz;
|
||||
mo->eflags &= ~MFE_APPLYPMOMZ;
|
||||
}
|
||||
|
||||
mo->z += mo->momz;
|
||||
|
||||
// clip movement
|
||||
@@ -1925,6 +1929,7 @@ static boolean P_ZMovement(mobj_t *mo)
|
||||
mo->momz += mo->pmomz;
|
||||
mo->eflags &= ~MFE_APPLYPMOMZ;
|
||||
}
|
||||
|
||||
mo->z += mo->momz;
|
||||
|
||||
if (mo->standingslope)
|
||||
@@ -2209,7 +2214,7 @@ static boolean P_ZMovement(mobj_t *mo)
|
||||
|| mo->type == MT_CANNONBALLDECOR
|
||||
|| mo->type == MT_FALLINGROCK)
|
||||
{
|
||||
if (maptol & TOL_NIGHTS)
|
||||
if (UNLIKELY(maptol & TOL_NIGHTS))
|
||||
mom.z = -FixedDiv(mom.z, 10*FRACUNIT);
|
||||
else
|
||||
mom.z = -FixedMul(mom.z, FixedDiv(17*FRACUNIT,20*FRACUNIT));
|
||||
@@ -2349,9 +2354,9 @@ static boolean P_ZMovement(mobj_t *mo)
|
||||
mo->momz = -mo->momz;
|
||||
else
|
||||
// Flags bounce
|
||||
if (mo->type == MT_REDFLAG || mo->type == MT_BLUEFLAG)
|
||||
if (UNLIKELY(mo->type == MT_REDFLAG || mo->type == MT_BLUEFLAG))
|
||||
{
|
||||
if (maptol & TOL_NIGHTS)
|
||||
if (UNLIKELY(maptol & TOL_NIGHTS))
|
||||
mo->momz = -FixedDiv(mo->momz, 10*FRACUNIT);
|
||||
else
|
||||
mo->momz = -FixedMul(mo->momz, FixedDiv(17*FRACUNIT,20*FRACUNIT));
|
||||
@@ -2418,7 +2423,7 @@ static void P_PlayerZMovement(mobj_t *mo)
|
||||
else
|
||||
mo->z = mo->floorz;
|
||||
|
||||
if (mo->player->pflags & PF_NIGHTSMODE)
|
||||
if (UNLIKELY(mo->player->pflags & PF_NIGHTSMODE))
|
||||
{
|
||||
// bounce off floor if you were flying towards it
|
||||
if ((mo->eflags & MFE_VERTICALFLIP && mo->player->flyangle > 0 && mo->player->flyangle < 180)
|
||||
@@ -2608,7 +2613,7 @@ nightsdone:
|
||||
else
|
||||
mo->z = mo->ceilingz - mo->height;
|
||||
|
||||
if (mo->player->pflags & PF_NIGHTSMODE)
|
||||
if (UNLIKELY(mo->player->pflags & PF_NIGHTSMODE))
|
||||
{
|
||||
// bounce off ceiling if you were flying towards it
|
||||
if ((mo->eflags & MFE_VERTICALFLIP && mo->player->flyangle > 180 && mo->player->flyangle <= 359)
|
||||
@@ -2653,7 +2658,7 @@ nightsdone:
|
||||
}
|
||||
|
||||
// hit the ceiling
|
||||
if (mariomode)
|
||||
if (UNLIKELY(mariomode))
|
||||
S_StartSound(mo, sfx_mario1);
|
||||
|
||||
if (!mo->player->climbing)
|
||||
@@ -3114,8 +3119,6 @@ static boolean P_CameraCheckHeat(camera_t *thiscam)
|
||||
if (!thiscam || !thiscam->subsector)
|
||||
return false;
|
||||
|
||||
halfheight = thiscam->z + (thiscam->height >> 1);
|
||||
|
||||
// see if we are in water
|
||||
sector = thiscam->subsector->sector;
|
||||
|
||||
@@ -3126,6 +3129,8 @@ static boolean P_CameraCheckHeat(camera_t *thiscam)
|
||||
{
|
||||
ffloor_t *rover;
|
||||
|
||||
halfheight = thiscam->z + (thiscam->height >> 1);
|
||||
|
||||
for (rover = sector->ffloors; rover; rover = rover->next)
|
||||
{
|
||||
if (!(rover->flags & FF_EXISTS))
|
||||
@@ -3152,8 +3157,6 @@ static boolean P_CameraCheckWater(camera_t *thiscam)
|
||||
if (!thiscam || !thiscam->subsector)
|
||||
return false;
|
||||
|
||||
halfheight = thiscam->z + (thiscam->height >> 1);
|
||||
|
||||
// see if we are in water
|
||||
sector = thiscam->subsector->sector;
|
||||
|
||||
@@ -3161,6 +3164,8 @@ static boolean P_CameraCheckWater(camera_t *thiscam)
|
||||
{
|
||||
ffloor_t *rover;
|
||||
|
||||
halfheight = thiscam->z + (thiscam->height >> 1);
|
||||
|
||||
for (rover = sector->ffloors; rover; rover = rover->next)
|
||||
{
|
||||
if (!(rover->flags & FF_EXISTS) || !(rover->flags & FF_SWIMMABLE) || rover->flags & FF_BLOCKOTHERS)
|
||||
@@ -3489,15 +3494,18 @@ static void P_PlayerMobjThinker(mobj_t *mobj)
|
||||
}
|
||||
else
|
||||
{
|
||||
if (!(mobj->player->pflags & PF_NIGHTSMODE)) // "jumping" is used for drilling
|
||||
if (LIKELY(!(mobj->player->pflags & PF_NIGHTSMODE))) // "jumping" is used for drilling
|
||||
mobj->player->jumping = 0;
|
||||
|
||||
mobj->player->pflags &= ~PF_JUMPED;
|
||||
|
||||
if (mobj->player->secondjump || mobj->player->powers[pw_tailsfly])
|
||||
{
|
||||
mobj->player->secondjump = 0;
|
||||
mobj->player->powers[pw_tailsfly] = 0;
|
||||
P_SetPlayerMobjState(mobj, S_KART_WALK1); // SRB2kart - was S_PLAY_RUN1
|
||||
}
|
||||
|
||||
mobj->eflags &= ~MFE_JUSTHITFLOOR;
|
||||
}
|
||||
|
||||
@@ -5403,8 +5411,6 @@ static void P_GimmeAxisXYPos(mobj_t *closestaxis, degenmobj_t *mobj)
|
||||
|
||||
static void P_MoveHoop(mobj_t *mobj)
|
||||
{
|
||||
const fixed_t fuse = (mobj->fuse*mobj->extravalue2);
|
||||
const angle_t fa = mobj->movedir*(FINEANGLES/mobj->extravalue1);
|
||||
TVector v;
|
||||
TVector *res;
|
||||
fixed_t finalx, finaly, finalz;
|
||||
@@ -5414,6 +5420,9 @@ static void P_MoveHoop(mobj_t *mobj)
|
||||
if (!mobj->target) /// \todo DEBUG ME! Target was P_RemoveMobj'd at some point, and therefore no longer valid!
|
||||
return;
|
||||
|
||||
const fixed_t fuse = (mobj->fuse*mobj->extravalue2);
|
||||
const angle_t fa = mobj->movedir*(FINEANGLES/mobj->extravalue1);
|
||||
|
||||
x = mobj->target->x;
|
||||
y = mobj->target->y;
|
||||
z = mobj->target->z+mobj->target->height/2;
|
||||
@@ -8967,7 +8976,7 @@ void P_MobjThinker(mobj_t *mobj)
|
||||
I_Assert(mobj != NULL);
|
||||
I_Assert(!P_MobjWasRemoved(mobj));
|
||||
|
||||
if (mobj->flags & MF_NOTHINK)
|
||||
if (UNLIKELY(mobj->flags & MF_NOTHINK))
|
||||
return;
|
||||
|
||||
// Remove dead target/tracer.
|
||||
@@ -8986,11 +8995,12 @@ void P_MobjThinker(mobj_t *mobj)
|
||||
|
||||
tmfloorthing = tmhitthing = NULL;
|
||||
|
||||
const sector_t *sec1 = mobj->subsector ? mobj->subsector->sector : NULL;
|
||||
|
||||
// 970 allows ANY mobj to trigger a linedef exec
|
||||
if (UNLIKELY(!mobj->islocal && sec1 && GETSECSPECIAL(sec1->special, 2) == 8)) // BEWARE: islocal does not exist in vanilla
|
||||
{
|
||||
sector_t *sec2;
|
||||
|
||||
sec2 = P_ThingOnSpecial3DFloor(mobj);
|
||||
if (sec2 && GETSECSPECIAL(sec2->special, 2) == 1)
|
||||
P_LinedefExecute(sec2->tag, mobj, sec2);
|
||||
@@ -9104,7 +9114,7 @@ void P_MobjThinker(mobj_t *mobj)
|
||||
|| mobj->type == MT_FLINGEMERALD
|
||||
|| mobj->type == MT_BIGTUMBLEWEED
|
||||
|| mobj->type == MT_LITTLETUMBLEWEED
|
||||
|| mobj->type == MT_CANNONBALLDECOR
|
||||
|| mobj->type == MT_CANNONBALLDECOR)
|
||||
|| mobj->type == MT_FALLINGROCK)
|
||||
{
|
||||
P_TryMove(mobj, mobj->x, mobj->y, true); // Sets mo->standingslope correctly
|
||||
@@ -9195,6 +9205,9 @@ void P_PushableThinker(mobj_t *mobj)
|
||||
I_Assert(mobj != NULL);
|
||||
I_Assert(!P_MobjWasRemoved(mobj));
|
||||
|
||||
if (!mobj)
|
||||
return;
|
||||
|
||||
sec = mobj->subsector->sector;
|
||||
|
||||
if (GETSECSPECIAL(sec->special, 2) == 1 && mobj->z == sec->floorheight)
|
||||
@@ -9211,9 +9224,6 @@ void P_PushableThinker(mobj_t *mobj)
|
||||
if (mobj->flags & MF_PUSHABLE && !(mobj->momx || mobj->momy))
|
||||
P_TryMove(mobj, mobj->x, mobj->y, true);
|
||||
|
||||
if (!mobj)
|
||||
return;
|
||||
|
||||
if (mobj->fuse == 1) // it would explode in the MobjThinker code
|
||||
{
|
||||
mobj_t *spawnmo;
|
||||
@@ -9982,6 +9992,7 @@ static precipmobj_t *P_SpawnPrecipMobj(fixed_t x, fixed_t y, fixed_t z, mobjtype
|
||||
else
|
||||
{
|
||||
const INT32 special = GETSECSPECIAL(mobj->subsector->sector->special, 1);
|
||||
|
||||
if (special == 7 || special == 6 || mobj->subsector->sector->floorpic == skyflatnum)
|
||||
mobj->precipflags |= PCF_PIT;
|
||||
}
|
||||
@@ -10313,9 +10324,11 @@ void P_PrecipitationEffects(void)
|
||||
P_SpawnLightningFlash(ss); // Spawn a quick flash thinker
|
||||
}
|
||||
|
||||
const mobj_t *pmo = players[displayplayers[0]].mo;
|
||||
|
||||
// Local effects from here on out!
|
||||
// If we're not in game fully yet, we don't worry about them.
|
||||
if (!playeringame[displayplayers[0]] || !players[displayplayers[0]].mo)
|
||||
if (!playeringame[displayplayers[0]] || !pmo)
|
||||
return;
|
||||
|
||||
if (sound_disabled)
|
||||
@@ -10324,7 +10337,7 @@ void P_PrecipitationEffects(void)
|
||||
if (!sounds_rain && !sounds_thunder)
|
||||
return; // no need to calculate volume at ALL
|
||||
|
||||
if (players[displayplayers[0]].mo->subsector->sector->ceilingpic == skyflatnum)
|
||||
if (pmo->subsector->sector->ceilingpic == skyflatnum)
|
||||
volume = 255; // Sky above? We get it full blast.
|
||||
else
|
||||
{
|
||||
@@ -10335,7 +10348,7 @@ void P_PrecipitationEffects(void)
|
||||
// Essentially check in a 1024 unit radius of the player for an outdoor area.
|
||||
#define RADIUSSTEP (64*FRACUNIT)
|
||||
#define SEARCHRADIUS (16*RADIUSSTEP)
|
||||
yl = yh = players[displayplayers[0]].mo->y;
|
||||
yl = yh = pmo->y;
|
||||
yl -= SEARCHRADIUS;
|
||||
while (yl < INT32_MIN)
|
||||
yl += RADIUSSTEP;
|
||||
@@ -10343,7 +10356,7 @@ void P_PrecipitationEffects(void)
|
||||
while (yh > INT32_MAX)
|
||||
yh -= RADIUSSTEP;
|
||||
|
||||
xl = xh = players[displayplayers[0]].mo->x;
|
||||
xl = xh = pmo->x;
|
||||
xl -= SEARCHRADIUS;
|
||||
while (xl < INT32_MIN)
|
||||
xl += RADIUSSTEP;
|
||||
@@ -10359,20 +10372,19 @@ void P_PrecipitationEffects(void)
|
||||
if (R_PointInSubsectorFast((fixed_t)x, (fixed_t)y)->sector->ceilingpic != skyflatnum) // Found the outdoors!
|
||||
continue;
|
||||
|
||||
newdist = S_CalculateSoundDistance(players[displayplayers[0]].mo->x, players[displayplayers[0]].mo->y, 0, (fixed_t)x, (fixed_t)y, 0);
|
||||
newdist = S_CalculateSoundDistance(pmo->x, pmo->y, 0, (fixed_t)x, (fixed_t)y, 0);
|
||||
|
||||
if (newdist < closedist)
|
||||
closedist = newdist;
|
||||
}
|
||||
|
||||
volume = 255 - (closedist>>(FRACBITS+2));
|
||||
volume = CLAMP(volume, 0, 255);
|
||||
}
|
||||
#undef RADIUSSTEP
|
||||
|
||||
volume = CLAMP(volume, 0, 255);
|
||||
|
||||
if (sounds_rain)
|
||||
S_StartSoundAtVolume(players[displayplayers[0]].mo, sfx_rainin, volume);
|
||||
S_StartSoundAtVolume(pmo, sfx_rainin, volume);
|
||||
|
||||
if (!sounds_thunder)
|
||||
return;
|
||||
@@ -10380,7 +10392,7 @@ void P_PrecipitationEffects(void)
|
||||
if (effects_lightning && lightningStrike && volume)
|
||||
{
|
||||
// Large, close thunder sounds to go with our lightning.
|
||||
S_StartSoundAtVolume(players[displayplayers[0]].mo, sfx_litng1 + M_RandomKey(4), volume);
|
||||
S_StartSoundAtVolume(pmo, sfx_litng1 + M_RandomKey(4), volume);
|
||||
}
|
||||
else if (thunderchance < 20)
|
||||
{
|
||||
@@ -10388,7 +10400,7 @@ void P_PrecipitationEffects(void)
|
||||
if (volume < 80)
|
||||
volume = 80;
|
||||
|
||||
S_StartSoundAtVolume(players[displayplayers[0]].mo, sfx_athun1 + M_RandomKey(2), volume);
|
||||
S_StartSoundAtVolume(pmo, sfx_athun1 + M_RandomKey(2), volume);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
+3
-1
@@ -2573,6 +2573,7 @@ static void P_InitMinimapInfo(void)
|
||||
lumpnum_t lumpnum;
|
||||
fixed_t a;
|
||||
fixed_t b;
|
||||
|
||||
node_t *bsp = &nodes[numnodes-1];
|
||||
|
||||
minimapinfo.minimap_pic = NULL;
|
||||
@@ -3353,7 +3354,8 @@ UINT16 P_PartialAddWadFile(const char *wadfilename, boolean local)
|
||||
|
||||
// Only exists to make sure there's no way to overwrite partadd_stage externally
|
||||
// unless you really push yourself.
|
||||
SINT8 P_PartialAddGetStage(void) {
|
||||
SINT8 P_PartialAddGetStage(void)
|
||||
{
|
||||
return partadd_stage;
|
||||
}
|
||||
|
||||
|
||||
+3
-3
@@ -3913,7 +3913,7 @@ DoneSection2:
|
||||
|
||||
player->kartstuff[k_lapanimation] = 80;
|
||||
|
||||
if (player->pflags & PF_NIGHTSMODE)
|
||||
if (UNLIKELY(player->pflags & PF_NIGHTSMODE))
|
||||
player->drillmeter += 48*20;
|
||||
|
||||
if (netgame && player->laps >= (UINT8)cv_numlaps.value)
|
||||
@@ -7103,7 +7103,7 @@ static inline boolean PIT_PushThing(mobj_t *thing)
|
||||
return false;
|
||||
|
||||
// Allow this to affect pushable objects at some point?
|
||||
if (thing->player && (!(thing->flags & (MF_NOGRAVITY | MF_NOCLIP)) || thing->player->pflags & PF_NIGHTSMODE))
|
||||
if (thing->player && (!(thing->flags & (MF_NOGRAVITY | MF_NOCLIP)) || UNLIKELY(thing->player->pflags & PF_NIGHTSMODE)))
|
||||
{
|
||||
INT32 dist;
|
||||
INT32 speed;
|
||||
@@ -7134,7 +7134,7 @@ static inline boolean PIT_PushThing(mobj_t *thing)
|
||||
// Written with bits and pieces of P_HomingAttack
|
||||
if ((speed > 0) && (P_CheckSight(thing, tmpusher->source)))
|
||||
{
|
||||
if (!(thing->player->pflags & PF_NIGHTSMODE))
|
||||
if (LIKELY(!(thing->player->pflags & PF_NIGHTSMODE)))
|
||||
{
|
||||
// only push wrt Z if health & 1 (mapthing has ambush flag)
|
||||
if (tmpusher->source->health & 1)
|
||||
|
||||
+12
-11
@@ -190,7 +190,7 @@ void Command_CountMobjs_f(void)
|
||||
void P_InitThinkers(void)
|
||||
{
|
||||
thinkercap.prev = thinkercap.next = &thinkercap;
|
||||
precipcap.prev = precipcap.next = &precipcap;
|
||||
precipcap.prev = precipcap.next = &precipcap;
|
||||
waypointcap = NULL;
|
||||
}
|
||||
|
||||
@@ -735,8 +735,10 @@ void P_Ticker(boolean run)
|
||||
PS_START_TIMING(ps_playerthink_time);
|
||||
for (i = 0; i < MAXPLAYERS; i++)
|
||||
{
|
||||
if (playeringame[i] && !P_MobjWasRemoved(players[i].mo))
|
||||
P_PlayerThink(&players[i]);
|
||||
if (!playeringame[i] || P_MobjWasRemoved(players[i].mo))
|
||||
continue;
|
||||
|
||||
P_PlayerThink(&players[i]);
|
||||
}
|
||||
PS_STOP_TIMING(ps_playerthink_time);
|
||||
}
|
||||
@@ -757,8 +759,10 @@ void P_Ticker(boolean run)
|
||||
// Run any "after all the other thinkers" stuff
|
||||
for (i = 0; i < MAXPLAYERS; i++)
|
||||
{
|
||||
if (playeringame[i] && !P_MobjWasRemoved(players[i].mo))
|
||||
P_PlayerAfterThink(&players[i]);
|
||||
if (!playeringame[i] || P_MobjWasRemoved(players[i].mo))
|
||||
continue;
|
||||
|
||||
P_PlayerAfterThink(&players[i]);
|
||||
}
|
||||
|
||||
// Apply rumble to local players
|
||||
@@ -837,12 +841,12 @@ void P_Ticker(boolean run)
|
||||
|
||||
if (demo.recording)
|
||||
{
|
||||
INT32 axis = JoyAxis(AXISLOOKBACK, 1);
|
||||
|
||||
G_WriteAllGhostTics();
|
||||
|
||||
if (cv_recordmultiplayerdemos.value)
|
||||
{
|
||||
const INT32 axis = JoyAxis(AXISLOOKBACK, 1);
|
||||
|
||||
if (demo.savemode == DSM_NOTSAVING || demo.savemode == DSM_WILLAUTOSAVE)
|
||||
if (demo.savebutton && demo.savebutton + 3*TICRATE < leveltime && (InputDown(gc_lookback, 1) || (cv_usejoystick[0].value && axis > 0)))
|
||||
demo.savemode = DSM_TITLEENTRY;
|
||||
@@ -958,10 +962,7 @@ void P_PreTicker(INT32 frames)
|
||||
// Run any "after all the other thinkers" stuff
|
||||
for (i = 0; i < MAXPLAYERS; i++)
|
||||
{
|
||||
if (!playeringame[i])
|
||||
continue;
|
||||
|
||||
if (P_MobjWasRemoved(players[i].mo))
|
||||
if (!playeringame[i] || P_MobjWasRemoved(players[i].mo))
|
||||
continue;
|
||||
|
||||
P_PlayerAfterThink(&players[i]);
|
||||
|
||||
+34
-32
@@ -73,7 +73,7 @@ void P_Thrust(mobj_t *mo, angle_t angle, fixed_t move)
|
||||
|
||||
mo->momx += FixedMul(move, FINECOSINE(angle));
|
||||
|
||||
if (!(twodlevel || (mo->flags2 & MF2_TWOD)))
|
||||
if (LIKELY(!(twodlevel || (mo->flags2 & MF2_TWOD))))
|
||||
mo->momy += FixedMul(move, FINESINE(angle));
|
||||
}
|
||||
|
||||
@@ -90,7 +90,7 @@ void P_InstaThrust(mobj_t *mo, angle_t angle, fixed_t move)
|
||||
|
||||
mo->momx = FixedMul(move, FINECOSINE(angle));
|
||||
|
||||
if (!(twodlevel || (mo->flags2 & MF2_TWOD)))
|
||||
if (LIKELY(!(twodlevel || (mo->flags2 & MF2_TWOD))))
|
||||
mo->momy = FixedMul(move,FINESINE(angle));
|
||||
}
|
||||
|
||||
@@ -498,9 +498,9 @@ void P_PlayLivesJingle(player_t *player)
|
||||
if (player && !P_IsLocalPlayer(player))
|
||||
return;
|
||||
|
||||
if (use1upSound)
|
||||
if (UNLIKELY(use1upSound))
|
||||
S_StartSound(NULL, sfx_oneup);
|
||||
else if (mariomode)
|
||||
else if (UNLIKELY(mariomode))
|
||||
S_StartSound(NULL, sfx_marioa);
|
||||
else
|
||||
{
|
||||
@@ -528,7 +528,7 @@ void P_PlayRinglossSound(mobj_t *source, mobj_t *damager)
|
||||
S_StartSound(NULL, sfx);
|
||||
}
|
||||
else
|
||||
S_StartSound(source, (mariomode) ? sfx_mario8 : sfx_khurt1 + key);
|
||||
S_StartSound(source, UNLIKELY(mariomode) ? sfx_mario8 : sfx_khurt1 + key);
|
||||
}
|
||||
else
|
||||
S_StartSound(source, sfx_slip);
|
||||
@@ -1287,13 +1287,14 @@ boolean P_InQuicksand(mobj_t *mo) // Returns true if you are in quicksand
|
||||
{
|
||||
sector_t *sector = mo->subsector->sector;
|
||||
fixed_t topheight, bottomheight;
|
||||
|
||||
fixed_t flipoffset = ((mo->eflags & MFE_VERTICALFLIP) ? (mo->height/2) : 0);
|
||||
fixed_t flipoffset;
|
||||
|
||||
if (sector->ffloors)
|
||||
{
|
||||
ffloor_t *rover;
|
||||
|
||||
flipoffset = ((mo->eflags & MFE_VERTICALFLIP) ? (mo->height/2) : 0);
|
||||
|
||||
for (rover = sector->ffloors; rover; rover = rover->next)
|
||||
{
|
||||
if (!(rover->flags & FF_EXISTS))
|
||||
@@ -1682,6 +1683,7 @@ static void P_DoBubbleBreath(player_t *player)
|
||||
bubble = P_SpawnMobj(player->mo->x, player->mo->y, zh, MT_SMALLBUBBLE);
|
||||
else if (P_RandomChance(3*FRACUNIT/256))
|
||||
bubble = P_SpawnMobj(player->mo->x, player->mo->y, zh, MT_MEDIUMBUBBLE);
|
||||
|
||||
if (bubble)
|
||||
{
|
||||
bubble->threshold = 42;
|
||||
@@ -1689,8 +1691,8 @@ static void P_DoBubbleBreath(player_t *player)
|
||||
P_SetScale(bubble, bubble->destscale);
|
||||
}
|
||||
|
||||
if (player->pflags & PF_NIGHTSMODE) // NiGHTS Super doesn't spawn flight bubbles
|
||||
return;
|
||||
//if (player->pflags & PF_NIGHTSMODE) // NiGHTS Super doesn't spawn flight bubbles
|
||||
//return;
|
||||
}
|
||||
|
||||
//
|
||||
@@ -2159,7 +2161,7 @@ static void P_MovePlayer(player_t *player)
|
||||
}
|
||||
// note: don't unset stasis here
|
||||
|
||||
if (!player->spectator && G_TagGametype())
|
||||
if (UNLIKELY(!player->spectator && G_TagGametype()))
|
||||
{
|
||||
// If we have stasis already here, it's because it's forced on us
|
||||
// by a linedef executor or what have you
|
||||
@@ -2219,7 +2221,7 @@ static void P_MovePlayer(player_t *player)
|
||||
player->lturn_max[leveltime%MAXPREDICTTICS] = player->rturn_max[leveltime%MAXPREDICTTICS] = 0;
|
||||
}
|
||||
|
||||
if (leveltime >= starttime)
|
||||
if (LIKELY(leveltime >= starttime))
|
||||
{
|
||||
// KART: Don't directly apply angleturn! It may have been either A) forged by a malicious client, or B) not be a smooth turn due to a player dropping frames.
|
||||
// Instead, turn the player only up to the amount they're supposed to turn accounting for latency. Allow exactly 1 extra turn unit to try to keep old replays synced.
|
||||
@@ -2258,7 +2260,7 @@ static void P_MovePlayer(player_t *player)
|
||||
P_3dMovement(player);
|
||||
}
|
||||
|
||||
if (maptol & TOL_2D)
|
||||
if (UNLIKELY(maptol & TOL_2D)) // psure this doesent even work at all
|
||||
runspd = FixedMul(runspd, 2*FRACUNIT/3);
|
||||
|
||||
/////////////////////////
|
||||
@@ -2319,10 +2321,10 @@ static void P_MovePlayer(player_t *player)
|
||||
|
||||
// Drifting sound
|
||||
// Start looping the sound now.
|
||||
if (leveltime % 50 == 0 && onground && player->kartstuff[k_drift] != 0)
|
||||
if (onground && leveltime % 50 == 0 && player->kartstuff[k_drift] != 0)
|
||||
S_StartSound(player->mo, sfx_drift);
|
||||
// Leveltime being 50 might take a while at times. We'll start it up once, isntantly.
|
||||
else if (!S_SoundPlaying(player->mo, sfx_drift) && onground && player->kartstuff[k_drift] != 0)
|
||||
else if (onground && !S_SoundPlaying(player->mo, sfx_drift) && player->kartstuff[k_drift] != 0)
|
||||
S_StartSound(player->mo, sfx_drift);
|
||||
// Ok, we'll stop now.
|
||||
else if (player->kartstuff[k_drift] == 0 || !onground)
|
||||
@@ -2347,7 +2349,7 @@ static void P_MovePlayer(player_t *player)
|
||||
P_SetPlayerMobjState(player->mo, S_KART_STND1); // SRB2kart - was S_PLAY_STND
|
||||
}
|
||||
|
||||
if (player->gotflag) // If you can't glide, then why the heck would you be gliding?
|
||||
if (UNLIKELY(player->gotflag)) // If you can't glide, then why the heck would you be gliding?
|
||||
{
|
||||
player->pflags &= ~PF_GLIDING;
|
||||
player->glidetime = 0;
|
||||
@@ -2708,8 +2710,8 @@ boolean P_LookForEnemies(player_t *player)
|
||||
player->mo->z-mo->z) > FixedMul(RING_DIST, player->mo->scale))
|
||||
continue; // out of range
|
||||
|
||||
if ((twodlevel || player->mo->flags2 & MF2_TWOD)
|
||||
&& abs(player->mo->y-mo->y) > player->mo->radius)
|
||||
if (UNLIKELY((twodlevel || player->mo->flags2 & MF2_TWOD)
|
||||
&& abs(player->mo->y-mo->y) > player->mo->radius))
|
||||
continue; // not in your 2d plane
|
||||
|
||||
if (mo->type == MT_PLAYER) // Don't chase after other players!
|
||||
@@ -4081,7 +4083,7 @@ boolean P_SpectatorJoinGame(player_t *player)
|
||||
// Team changing in Team Match and CTF
|
||||
// Pressing fire assigns you to a team that needs players if allowed.
|
||||
// Partial code reproduction from p_tick.c autobalance code.
|
||||
else if (G_GametypeHasTeams())
|
||||
else if (UNLIKELY(G_GametypeHasTeams()))
|
||||
{
|
||||
INT32 changeto = 0;
|
||||
INT32 z, numplayersred = 0, numplayersblue = 0;
|
||||
@@ -4323,10 +4325,10 @@ static INT32 Quaketilt(player_t *player)
|
||||
if (abs(delta) > ANGLE_90)
|
||||
delta = (INT32)(( moma + ANGLE_180 ) - player->mo->angle );
|
||||
|
||||
const boolean sliptiding = player->kartstuff[k_drift] ? 0 : player->kartstuff[k_aizdriftstrat];
|
||||
|
||||
if (P_IsObjectOnGround(player->mo))
|
||||
{
|
||||
const boolean sliptiding = player->kartstuff[k_drift] ? 0 : player->kartstuff[k_aizdriftstrat];
|
||||
|
||||
if (sliptiding)
|
||||
{
|
||||
tilt = ANGLE_45;
|
||||
@@ -4479,8 +4481,8 @@ void P_PlayerThink(player_t *player)
|
||||
{
|
||||
seenplayer = NULL;
|
||||
|
||||
if (cv_seenames.value && cv_allowseenames.value &&
|
||||
!(G_TagGametype() && (player->pflags & PF_TAGIT)))
|
||||
if (UNLIKELY(cv_seenames.value && cv_allowseenames.value &&
|
||||
!(G_TagGametype() && (player->pflags & PF_TAGIT))))
|
||||
{
|
||||
mobj_t *mo = P_SpawnNameFinder(player->mo, MT_NAMECHECK);
|
||||
|
||||
@@ -4769,8 +4771,8 @@ void P_PlayerThink(player_t *player)
|
||||
}
|
||||
|
||||
// Even if not NiGHTS, pull in nearby objects when walking around as John Q. Elliot.
|
||||
if (!objectplacing && !((netgame || multiplayer) && player->spectator)
|
||||
&& maptol & TOL_NIGHTS && (!(player->pflags & PF_NIGHTSMODE) || player->powers[pw_nights_helper]))
|
||||
if (UNLIKELY(!objectplacing && !((netgame || multiplayer) && player->spectator)
|
||||
&& maptol & TOL_NIGHTS && (!(player->pflags & PF_NIGHTSMODE) || player->powers[pw_nights_helper])))
|
||||
{
|
||||
thinker_t *th;
|
||||
mobj_t *mo2;
|
||||
@@ -4835,7 +4837,7 @@ void P_PlayerThink(player_t *player)
|
||||
player->pflags &= ~PF_FULLSTASIS;
|
||||
|
||||
if (player->onconveyor == 1)
|
||||
player->cmomy = player->cmomx = 0;
|
||||
player->cmomy = player->cmomx = 0;
|
||||
|
||||
P_DoBubbleBreath(player); // Spawn Sonic's bubbles
|
||||
P_CheckInvincibilityTimer(player); // Spawn Invincibility Sparkles
|
||||
@@ -4872,7 +4874,7 @@ void P_PlayerThink(player_t *player)
|
||||
#endif
|
||||
|
||||
// check for use
|
||||
if (!(player->pflags & PF_NIGHTSMODE))
|
||||
if (LIKELY(!(player->pflags & PF_NIGHTSMODE)))
|
||||
{
|
||||
if (cmd->buttons & BT_BRAKE)
|
||||
player->pflags |= PF_USEDOWN;
|
||||
@@ -5044,6 +5046,11 @@ void P_PlayerAfterThink(player_t *player)
|
||||
P_PlayerInSpecialSector(player);
|
||||
#endif
|
||||
|
||||
if (player->playerstate == PST_DEAD)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
for (i = 0; i <= splitscreen; i++)
|
||||
{
|
||||
if (player == &players[displayplayers[i]])
|
||||
@@ -5053,12 +5060,7 @@ void P_PlayerAfterThink(player_t *player)
|
||||
}
|
||||
}
|
||||
|
||||
if (player->playerstate == PST_DEAD)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
if (player->pflags & PF_NIGHTSMODE)
|
||||
if (UNLIKELY(player->pflags & PF_NIGHTSMODE))
|
||||
{
|
||||
player->powers[pw_gravityboots] = 0;
|
||||
}
|
||||
|
||||
+2
-2
@@ -607,7 +607,7 @@ void S_StartSound(const void *origin, sfxenum_t sfx_id)
|
||||
if (S_SoundDisabled())
|
||||
return;
|
||||
|
||||
if (mariomode) // Sounds change in Mario mode!
|
||||
if (UNLIKELY(mariomode)) // Sounds change in Mario mode!
|
||||
{
|
||||
switch (sfx_id)
|
||||
{
|
||||
@@ -630,7 +630,7 @@ void S_StartSound(const void *origin, sfxenum_t sfx_id)
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (maptol & TOL_XMAS) // Some sounds change for xmas
|
||||
if (UNLIKELY(maptol & TOL_XMAS)) // Some sounds change for xmas
|
||||
{
|
||||
switch (sfx_id)
|
||||
{
|
||||
|
||||
+14
-5
@@ -1806,13 +1806,22 @@ void I_SleepDuration(precise_t duration)
|
||||
{
|
||||
#if defined(__linux__) || defined(__FreeBSD__) || defined(__HAIKU__)
|
||||
UINT64 precision = I_GetPrecisePrecision();
|
||||
struct timespec ts = {
|
||||
precise_t dest = I_GetPreciseTime() + duration;
|
||||
precise_t slack = (precision / 5000); // 0.2 ms slack
|
||||
if (duration > slack)
|
||||
{
|
||||
duration -= slack;
|
||||
struct timespec ts = {
|
||||
.tv_sec = static_cast<__time_t>(duration / precision),
|
||||
.tv_nsec = static_cast<__syscall_slong_t>(duration * 1000000000 / precision % 1000000000),
|
||||
};
|
||||
int status;
|
||||
do status = clock_nanosleep(CLOCK_MONOTONIC, 0, &ts, &ts);
|
||||
while (status == EINTR);
|
||||
};
|
||||
int status;
|
||||
do status = clock_nanosleep(CLOCK_MONOTONIC, 0, &ts, &ts);
|
||||
while (status == EINTR);
|
||||
}
|
||||
|
||||
// busy-wait the rest
|
||||
while (((INT64)dest - (INT64)I_GetPreciseTime()) > 0);
|
||||
#elif defined (MIN_SLEEP_DURATION_MS)
|
||||
UINT64 precision = I_GetPrecisePrecision();
|
||||
INT32 sleepvalue = cv_sleep.value;
|
||||
|
||||
+48
-46
@@ -338,6 +338,11 @@ static void W_InvalidateLumpnumCache(void)
|
||||
memset(lumpnumcache, 0, sizeof (lumpnumcache));
|
||||
}
|
||||
|
||||
UINT32 W_HashLumpName(const char *name)
|
||||
{
|
||||
return FNV1a_HashLowercaseString(name);
|
||||
}
|
||||
|
||||
/** Detect a file type.
|
||||
* \todo Actually detect the wad/pkzip headers and whatnot, instead of just checking the extensions.
|
||||
*/
|
||||
@@ -362,11 +367,24 @@ static lumpinfo_t* ResGetLumpsStandalone (FILE* handle, UINT16* numlumps, const
|
||||
fseek(handle, 0, SEEK_END);
|
||||
lumpinfo->size = ftell(handle);
|
||||
fseek(handle, 0, SEEK_SET);
|
||||
strlcpy(lumpinfo->name, lumpname, 9);
|
||||
|
||||
// Allocate the lump's full and long name.
|
||||
lumpinfo->fullname = Z_StrDup(lumpname);
|
||||
lumpinfo->longname = Z_StrDup(lumpname);
|
||||
strlcpy(lumpinfo->name, lumpname, sizeof(lumpinfo->name));
|
||||
lumpinfo->namelength = strlen(lumpinfo->name);
|
||||
lumpinfo->hash.name = W_HashLumpName(lumpname);
|
||||
|
||||
// Allocate the lump's long name.
|
||||
lumpinfo->longname = Z_Malloc((lumpinfo->namelength + 1) * sizeof(char), PU_STATIC, NULL);
|
||||
strcpy(lumpinfo->longname, lumpname);
|
||||
lumpinfo->longname[lumpinfo->namelength] = '\0';
|
||||
lumpinfo->longnamelength = lumpinfo->namelength;
|
||||
lumpinfo->hash.longname = lumpinfo->hash.name;
|
||||
|
||||
// Allocate the lump's full name.
|
||||
lumpinfo->fullname = Z_Malloc((lumpinfo->namelength + 1) * sizeof(char), PU_STATIC, NULL);
|
||||
strcpy(lumpinfo->fullname, lumpname);
|
||||
lumpinfo->fullname[lumpinfo->namelength] = '\0';
|
||||
lumpinfo->fullnamelength = lumpinfo->namelength;
|
||||
lumpinfo->hash.fullname = lumpinfo->hash.name;
|
||||
|
||||
*numlumps = 1;
|
||||
return lumpinfo;
|
||||
@@ -454,16 +472,22 @@ static lumpinfo_t* ResGetLumpsWad (FILE* handle, UINT16* nlmp, const char* filen
|
||||
lump_p->compression = CM_NOCOMPRESSION;
|
||||
memset(lump_p->name, 0x00, 9);
|
||||
strncpy(lump_p->name, fileinfo->name, 8);
|
||||
lump_p->namelength = strlen(lump_p->name);
|
||||
lump_p->hash.name = W_HashLumpName(lump_p->name);
|
||||
|
||||
// Allocate the lump's long name.
|
||||
lump_p->longname = Z_Malloc(9 * sizeof(char), PU_STATIC, NULL);
|
||||
strncpy(lump_p->longname, fileinfo->name, 8);
|
||||
lump_p->longname[8] = '\0';
|
||||
lump_p->longnamelength = lump_p->namelength;
|
||||
lump_p->hash.longname = lump_p->hash.name;
|
||||
|
||||
// Allocate the lump's full name.
|
||||
lump_p->fullname = Z_Malloc(9 * sizeof(char), PU_STATIC, NULL);
|
||||
strncpy(lump_p->fullname, fileinfo->name, 8);
|
||||
lump_p->fullname[8] = '\0';
|
||||
lump_p->fullnamelength = lump_p->namelength;
|
||||
lump_p->hash.fullname = lump_p->hash.name;
|
||||
}
|
||||
free(fileinfov);
|
||||
*nlmp = numlumps;
|
||||
@@ -656,12 +680,18 @@ static lumpinfo_t* ResGetLumpsZip (FILE* handle, UINT16* nlmp)
|
||||
|
||||
memset(lump_p->name, '\0', 9); // Making sure they're initialized to 0. Is it necessary?
|
||||
strncpy(lump_p->name, trimname, min(8, dotpos - trimname));
|
||||
lump_p->namelength = strlen(lump_p->name);
|
||||
lump_p->hash.name = W_HashLumpName(lump_p->name);
|
||||
|
||||
lump_p->longname = Z_Calloc(dotpos - trimname + 1, PU_STATIC, NULL);
|
||||
strlcpy(lump_p->longname, trimname, dotpos - trimname + 1);
|
||||
lump_p->longnamelength = strlen(lump_p->longname);
|
||||
lump_p->hash.longname = W_HashLumpName(lump_p->longname);
|
||||
|
||||
lump_p->fullname = (char*)(Z_Calloc(SHORT(zentry->namelen) + 1, PU_STATIC, NULL));
|
||||
strncpy(lump_p->fullname, fullname, SHORT(zentry->namelen));
|
||||
lump_p->fullnamelength = zentry->namelen;
|
||||
lump_p->hash.fullname = W_HashLumpName(lump_p->fullname);
|
||||
|
||||
switch(SHORT(zentry->compression))
|
||||
{
|
||||
@@ -976,6 +1006,8 @@ UINT16 W_CheckNumForNamePwad(const char *name, UINT16 wad, UINT16 startlump)
|
||||
{
|
||||
UINT16 i;
|
||||
static char uname[9];
|
||||
UINT32 hash;
|
||||
size_t namelen;
|
||||
|
||||
if (!TestValidLump(wad,0))
|
||||
return INT16_MAX;
|
||||
@@ -983,6 +1015,8 @@ UINT16 W_CheckNumForNamePwad(const char *name, UINT16 wad, UINT16 startlump)
|
||||
memset(uname, 0, sizeof uname);
|
||||
strncpy(uname, name, sizeof(uname)-1);
|
||||
strupr(uname);
|
||||
namelen = strlen(uname);
|
||||
hash = W_HashLumpName(uname);
|
||||
|
||||
//
|
||||
// scan forward
|
||||
@@ -993,7 +1027,9 @@ UINT16 W_CheckNumForNamePwad(const char *name, UINT16 wad, UINT16 startlump)
|
||||
{
|
||||
lumpinfo_t *lump_p = wadfiles[wad]->lumpinfo + startlump;
|
||||
for (i = startlump; i < wadfiles[wad]->numlumps; i++, lump_p++)
|
||||
if (memcmp(lump_p->name, uname, sizeof(uname) - 1) == 0)
|
||||
if (lump_p->namelength == namelen
|
||||
&& lump_p->hash.name == hash
|
||||
&& !memcmp(lump_p->name, uname, sizeof(uname) - 1))
|
||||
return i;
|
||||
}
|
||||
|
||||
@@ -1010,13 +1046,12 @@ UINT16 W_CheckNumForNamePwad(const char *name, UINT16 wad, UINT16 startlump)
|
||||
UINT16 W_CheckNumForLongNamePwad(const char *name, UINT16 wad, UINT16 startlump)
|
||||
{
|
||||
UINT16 i;
|
||||
static char uname[256 + 1];
|
||||
|
||||
if (!TestValidLump(wad,0))
|
||||
return INT16_MAX;
|
||||
|
||||
strlcpy(uname, name, sizeof uname);
|
||||
strupr(uname);
|
||||
size_t namelen = strlen(name);
|
||||
UINT32 hash = W_HashLumpName(name);
|
||||
|
||||
//
|
||||
// scan forward
|
||||
@@ -1027,7 +1062,9 @@ UINT16 W_CheckNumForLongNamePwad(const char *name, UINT16 wad, UINT16 startlump)
|
||||
{
|
||||
lumpinfo_t *lump_p = wadfiles[wad]->lumpinfo + startlump;
|
||||
for (i = startlump; i < wadfiles[wad]->numlumps; i++, lump_p++)
|
||||
if (!strcmp(lump_p->longname, uname))
|
||||
if (lump_p->longnamelength == namelen
|
||||
&& lump_p->hash.longname == hash
|
||||
&& !stricmp(lump_p->longname, name))
|
||||
return i;
|
||||
}
|
||||
|
||||
@@ -1058,10 +1095,10 @@ UINT16 W_CheckNumForFolderStartPK3(const char *name, UINT16 wad, UINT16 startlum
|
||||
/* SLADE is special and puts a single directory entry. Skip that. */
|
||||
if (strlen(lump_p->fullname) == name_length)
|
||||
i++;
|
||||
break;
|
||||
return i;
|
||||
}
|
||||
}
|
||||
return i;
|
||||
return INT16_MAX;
|
||||
}
|
||||
|
||||
// In a PK3 type of resource file, it looks for the next lumpinfo entry that doesn't share the specified pathfile.
|
||||
@@ -1201,41 +1238,6 @@ lumpnum_t W_CheckNumForLongName(const char *name)
|
||||
}
|
||||
}
|
||||
|
||||
// Look for valid map data through all added files in descendant order.
|
||||
// Get a map marker for WADs, and a standalone WAD file lump inside PK3s.
|
||||
// TODO: Make it search through cache first, maybe...?
|
||||
lumpnum_t W_CheckNumForMap(const char *name)
|
||||
{
|
||||
UINT16 lumpNum, end;
|
||||
UINT32 i;
|
||||
for (i = numwadfiles - 1; i < numwadfiles; i--)
|
||||
{
|
||||
if (wadfiles[i]->type == RET_WAD)
|
||||
{
|
||||
for (lumpNum = 0; lumpNum < wadfiles[i]->numlumps; lumpNum++)
|
||||
if (!strncmp(name, (wadfiles[i]->lumpinfo + lumpNum)->name, 8))
|
||||
return (i<<16) + lumpNum;
|
||||
}
|
||||
else if (wadfiles[i]->type == RET_PK3)
|
||||
{
|
||||
lumpNum = W_CheckNumForFolderStartPK3("maps/", i, 0);
|
||||
if (lumpNum != INT16_MAX)
|
||||
end = W_CheckNumForFolderEndPK3("maps/", i, lumpNum);
|
||||
else
|
||||
continue;
|
||||
// Now look for the specified map.
|
||||
for (; lumpNum < end; lumpNum++)
|
||||
if (!strnicmp(name, (wadfiles[i]->lumpinfo + lumpNum)->name, 8))
|
||||
{
|
||||
const char *extension = strrchr(wadfiles[i]->lumpinfo[lumpNum].fullname, '.');
|
||||
if (!(extension && stricmp(extension, ".wad")))
|
||||
return (i<<16) + lumpNum;
|
||||
}
|
||||
}
|
||||
}
|
||||
return LUMPERROR;
|
||||
}
|
||||
|
||||
//
|
||||
// W_GetNumForName
|
||||
//
|
||||
|
||||
+13
-1
@@ -75,8 +75,19 @@ typedef struct
|
||||
char name[9]; // filelump_t name[] e.g. "LongEntr"
|
||||
char *longname; // e.g. "LongEntryName"
|
||||
char *fullname; // e.g. "Folder/Subfolder/LongEntryName.extension"
|
||||
|
||||
size_t namelength; // length of name
|
||||
size_t longnamelength; // length of longname
|
||||
size_t fullnamelength; // length of fullname
|
||||
|
||||
size_t size; // real (uncompressed) size
|
||||
compmethod compression; // lump compression method
|
||||
|
||||
struct {
|
||||
UINT32 name; // hash of name
|
||||
UINT32 longname; // hash of longname
|
||||
UINT32 fullname; // hash of fullname
|
||||
} hash;
|
||||
} lumpinfo_t;
|
||||
|
||||
// =========================================================================
|
||||
@@ -167,6 +178,8 @@ INT32 W_AddAutoloadedLocalFiles(char **filenames);
|
||||
|
||||
#define W_FileHasFolders(wadfile) ((wadfile)->type == RET_PK3)
|
||||
|
||||
UINT32 W_HashLumpName(const char *name);
|
||||
|
||||
const char *W_CheckNameForNumPwad(UINT16 wad, UINT16 lump);
|
||||
const char *W_CheckNameForNum(lumpnum_t lumpnum);
|
||||
|
||||
@@ -180,7 +193,6 @@ UINT16 W_CheckNumForFullNamePK3(const char *name, UINT16 wad, UINT16 startlump);
|
||||
UINT16 W_CheckNumForFolderStartPK3(const char *name, UINT16 wad, UINT16 startlump);
|
||||
UINT16 W_CheckNumForFolderEndPK3(const char *name, UINT16 wad, UINT16 startlump);
|
||||
|
||||
lumpnum_t W_CheckNumForMap(const char *name);
|
||||
lumpnum_t W_CheckNumForName(const char *name);
|
||||
lumpnum_t W_CheckNumForLongName(const char *name);
|
||||
lumpnum_t W_GetNumForName(const char *name); // like W_CheckNumForName but I_Error on LUMPERROR
|
||||
|
||||
Reference in new issue
Block a user