Merge branch 'thinkerlists-fix' into 'master'
Thinkerlists fix Closes #161 See merge request STJr/SRB2Internal!253
This commit is contained in:
1 parent
e11fec1408
commit
3957c04a9b
24 files changed
+1008
-457
No files matched your search
+3
-5
@@ -4778,13 +4778,11 @@ static INT16 Consistancy(void)
|
||||
ret += P_GetRandSeed();
|
||||
|
||||
#ifdef MOBJCONSISTANCY
|
||||
if (!thlist[THINK_MOBJ].next)
|
||||
{
|
||||
DEBFILE(va("Consistancy = %u\n", ret));
|
||||
return ret;
|
||||
}
|
||||
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
|
||||
{
|
||||
if (th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
|
||||
continue;
|
||||
|
||||
mo = (mobj_t *)th;
|
||||
|
||||
if (mo->flags & (MF_SPECIAL | MF_SOLID | MF_PUSHABLE | MF_BOSS | MF_MISSILE | MF_SPRING | MF_MONITOR | MF_FIRE | MF_ENEMY | MF_PAIN | MF_STICKY))
|
||||
|
||||
+2
-1
@@ -5377,7 +5377,8 @@ static void Command_Archivetest_f(void)
|
||||
// assign mobjnum
|
||||
i = 1;
|
||||
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
|
||||
((mobj_t *)th)->mobjnum = i++;
|
||||
if (th->function.acp1 != (actionf_p1)P_RemoveThinkerDelayed)
|
||||
((mobj_t *)th)->mobjnum = i++;
|
||||
|
||||
// allocate buffer
|
||||
buf = save_p = ZZ_Alloc(1024);
|
||||
|
||||
+10
-3
@@ -3098,6 +3098,9 @@ void G_ChangePlayerReferences(mobj_t *oldmo, mobj_t *newmo)
|
||||
// scan all thinkers
|
||||
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
|
||||
{
|
||||
if (th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
|
||||
continue;
|
||||
|
||||
mo2 = (mobj_t *)th;
|
||||
|
||||
if (!(mo2->flags & MF_MISSILE))
|
||||
@@ -5541,12 +5544,13 @@ void G_ConsGhostTic(INT32 playernum)
|
||||
mobj = NULL;
|
||||
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
|
||||
{
|
||||
if (th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
|
||||
continue;
|
||||
mobj = (mobj_t *)th;
|
||||
if (mobj->type == (mobjtype_t)type && mobj->x == x && mobj->y == y && mobj->z == z)
|
||||
break;
|
||||
mobj = NULL; // wasn't this one, keep searching.
|
||||
}
|
||||
if (mobj && mobj->health != health) // Wasn't damaged?! This is desync! Fix it!
|
||||
if (th != &thlist[THINK_MOBJ] && mobj->health != health) // Wasn't damaged?! This is desync! Fix it!
|
||||
{
|
||||
if (demosynced)
|
||||
CONS_Alert(CONS_WARNING, M_GetText("Demo playback has desynced!\n"));
|
||||
@@ -7970,11 +7974,14 @@ void G_DoPlayMetal(void)
|
||||
// find metal sonic
|
||||
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
|
||||
{
|
||||
if (th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
|
||||
continue;
|
||||
|
||||
mo = (mobj_t *)th;
|
||||
if (mo->type == MT_METALSONIC_RACE)
|
||||
break;
|
||||
}
|
||||
if (!mo)
|
||||
if (th == &thlist[THINK_MOBJ])
|
||||
{
|
||||
CONS_Alert(CONS_ERROR, M_GetText("Failed to find bot entity.\n"));
|
||||
Z_Free(metalbuffer);
|
||||
|
||||
+62
-31
@@ -755,6 +755,14 @@ void HWR_WallLighting(FOutVector *wlVerts)
|
||||
FSurfaceInfo Surf;
|
||||
float dist_p2d, d[4], s;
|
||||
|
||||
if (!dynlights->mo[j])
|
||||
continue;
|
||||
if (P_MobjWasRemoved(dynlights->mo[j]))
|
||||
{
|
||||
P_SetTarget(&dynlights->mo[j], NULL);
|
||||
continue;
|
||||
}
|
||||
|
||||
// check bounding box first
|
||||
if (SphereTouchBBox3D(&wlVerts[2], &wlVerts[0], &LIGHT_POS(j), DL_RADIUS(j))==false)
|
||||
continue;
|
||||
@@ -805,8 +813,6 @@ void HWR_WallLighting(FOutVector *wlVerts)
|
||||
#ifdef DL_HIGH_QUALITY
|
||||
Surf.FlatColor.s.alpha = (UINT8)((1-dist_p2d/DL_SQRRADIUS(j))*Surf.FlatColor.s.alpha);
|
||||
#endif
|
||||
if (!dynlights->mo[j]->state)
|
||||
return;
|
||||
// next state is null so fade out with alpha
|
||||
if (dynlights->mo[j]->state->nextstate == S_NULL)
|
||||
Surf.FlatColor.s.alpha = (UINT8)(((float)dynlights->mo[j]->tics/(float)dynlights->mo[j]->state->tics)*Surf.FlatColor.s.alpha);
|
||||
@@ -837,6 +843,14 @@ void HWR_PlaneLighting(FOutVector *clVerts, int nrClipVerts)
|
||||
FSurfaceInfo Surf;
|
||||
float dist_p2d, s;
|
||||
|
||||
if (!dynlights->mo[j])
|
||||
continue;
|
||||
if (P_MobjWasRemoved(dynlights->mo[j]))
|
||||
{
|
||||
P_SetTarget(&dynlights->mo[j], NULL);
|
||||
continue;
|
||||
}
|
||||
|
||||
// BP: The kickass Optimization: check if light touch bounding box
|
||||
if (SphereTouchBBox3D(&p1, &p2, &dynlights->position[j], DL_RADIUS(j))==false)
|
||||
continue;
|
||||
@@ -868,8 +882,6 @@ void HWR_PlaneLighting(FOutVector *clVerts, int nrClipVerts)
|
||||
#ifdef DL_HIGH_QUALITY
|
||||
Surf.FlatColor.s.alpha = (unsigned char)((1 - dist_p2d/DL_SQRRADIUS(j))*Surf.FlatColor.s.alpha);
|
||||
#endif
|
||||
if (!dynlights->mo[j]->state)
|
||||
return;
|
||||
// next state is null so fade out with alpha
|
||||
if ((dynlights->mo[j]->state->nextstate == S_NULL))
|
||||
Surf.FlatColor.s.alpha = (unsigned char)(((float)dynlights->mo[j]->tics/(float)dynlights->mo[j]->state->tics)*Surf.FlatColor.s.alpha);
|
||||
@@ -1000,6 +1012,14 @@ void HWR_DrawCoronas(void)
|
||||
if (!(p_lspr->type & CORONA_SPR))
|
||||
continue;
|
||||
|
||||
if (!dynlights->mo[j])
|
||||
continue;
|
||||
if (P_MobjWasRemoved(dynlights->mo[j]))
|
||||
{
|
||||
P_SetTarget(&dynlights->mo[j], NULL);
|
||||
continue;
|
||||
}
|
||||
|
||||
transform(&cx,&cy,&cz);
|
||||
|
||||
// more realistique corona !
|
||||
@@ -1061,7 +1081,8 @@ void HWR_DrawCoronas(void)
|
||||
// --------------------------------------------------------------------------
|
||||
void HWR_ResetLights(void)
|
||||
{
|
||||
dynlights->nb = 0;
|
||||
while (dynlights->nb)
|
||||
P_SetTarget(&dynlights->mo[--dynlights->nb], NULL);
|
||||
}
|
||||
|
||||
// --------------------------------------------------------------------------
|
||||
@@ -1092,24 +1113,25 @@ void HWR_DL_AddLight(gr_vissprite_t *spr, GLPatch_t *patch)
|
||||
return;
|
||||
#endif
|
||||
|
||||
if (dynlights->nb >= DL_MAX_LIGHT)
|
||||
return;
|
||||
|
||||
// check if sprite contain dynamic light
|
||||
p_lspr = t_lspr[spr->mobj->sprite];
|
||||
if ((p_lspr->type&DYNLIGHT_SPR)
|
||||
&& ((p_lspr->type != LIGHT_SPR) || cv_grstaticlighting.value)
|
||||
&& (dynlights->nb < DL_MAX_LIGHT)
|
||||
if (!(p_lspr->type & DYNLIGHT_SPR))
|
||||
return;
|
||||
if ((p_lspr->type != LIGHT_SPR) || cv_grstaticlighting.value)
|
||||
return;
|
||||
|
||||
&& spr->mobj->state)
|
||||
{
|
||||
LIGHT_POS(dynlights->nb).x = FIXED_TO_FLOAT(spr->mobj->x);
|
||||
LIGHT_POS(dynlights->nb).y = FIXED_TO_FLOAT(spr->mobj->z)+FIXED_TO_FLOAT(spr->mobj->height>>1)+p_lspr->light_yoffset;
|
||||
LIGHT_POS(dynlights->nb).z = FIXED_TO_FLOAT(spr->mobj->y);
|
||||
LIGHT_POS(dynlights->nb).x = FIXED_TO_FLOAT(spr->mobj->x);
|
||||
LIGHT_POS(dynlights->nb).y = FIXED_TO_FLOAT(spr->mobj->z)+FIXED_TO_FLOAT(spr->mobj->height>>1)+p_lspr->light_yoffset;
|
||||
LIGHT_POS(dynlights->nb).z = FIXED_TO_FLOAT(spr->mobj->y);
|
||||
|
||||
P_SetTarget(&dynlights->mo[dynlights->nb], spr->mobj);
|
||||
P_SetTarget(&dynlights->mo[dynlights->nb], spr->mobj);
|
||||
|
||||
dynlights->p_lspr[dynlights->nb] = p_lspr;
|
||||
dynlights->p_lspr[dynlights->nb] = p_lspr;
|
||||
|
||||
dynlights->nb++;
|
||||
}
|
||||
dynlights->nb++;
|
||||
}
|
||||
|
||||
static GLPatch_t lightmappatch;
|
||||
@@ -1263,6 +1285,14 @@ static void HWR_CheckSubsector(size_t num, fixed_t *bbox)
|
||||
// if (CircleTouchBBox(&p1, &p2, &LIGHT_POS(lightnum), DL_RADIUS(lightnum))==false)
|
||||
// continue;
|
||||
|
||||
if (!dynlights->mo[lightnum])
|
||||
continue;
|
||||
if (P_MobjWasRemoved(dynlights->mo[lightnum]))
|
||||
{
|
||||
P_SetTarget(&dynlights->mo[lightnum], NULL);
|
||||
continue;
|
||||
}
|
||||
|
||||
count = sub->numlines; // how many linedefs
|
||||
line = &segs[sub->firstline]; // first line seg
|
||||
while (count--)
|
||||
@@ -1280,18 +1310,20 @@ static void HWR_CheckSubsector(size_t num, fixed_t *bbox)
|
||||
// --------------------------------------------------------------------------
|
||||
static void HWR_AddMobjLights(mobj_t *thing)
|
||||
{
|
||||
if (t_lspr[thing->sprite]->type & CORONA_SPR)
|
||||
{
|
||||
LIGHT_POS(dynlights->nb).x = FIXED_TO_FLOAT(thing->x);
|
||||
LIGHT_POS(dynlights->nb).y = FIXED_TO_FLOAT(thing->z) + t_lspr[thing->sprite]->light_yoffset;
|
||||
LIGHT_POS(dynlights->nb).z = FIXED_TO_FLOAT(thing->y);
|
||||
if (dynlights->nb >= DL_MAX_LIGHT)
|
||||
return;
|
||||
if (!(t_lspr[thing->sprite]->type & CORONA_SPR))
|
||||
return;
|
||||
|
||||
dynlights->p_lspr[dynlights->nb] = t_lspr[thing->sprite];
|
||||
LIGHT_POS(dynlights->nb).x = FIXED_TO_FLOAT(thing->x);
|
||||
LIGHT_POS(dynlights->nb).y = FIXED_TO_FLOAT(thing->z) + t_lspr[thing->sprite]->light_yoffset;
|
||||
LIGHT_POS(dynlights->nb).z = FIXED_TO_FLOAT(thing->y);
|
||||
|
||||
dynlights->nb++;
|
||||
if (dynlights->nb > DL_MAX_LIGHT)
|
||||
dynlights->nb = DL_MAX_LIGHT;
|
||||
}
|
||||
P_SetTarget(&dynlights->mo[dynlights->nb], thing);
|
||||
|
||||
dynlights->p_lspr[dynlights->nb] = t_lspr[thing->sprite];
|
||||
|
||||
dynlights->nb++;
|
||||
}
|
||||
|
||||
//Hurdler: The goal of this function is to walk through all the bsp starting
|
||||
@@ -1318,7 +1350,8 @@ static void HWR_SearchLightsInMobjs(void)
|
||||
|
||||
// search in the list of thinkers
|
||||
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
|
||||
HWR_AddMobjLights((mobj_t *)th);
|
||||
if (th->function.acp1 != (actionf_p1)P_RemoveThinkerDelayed)
|
||||
HWR_AddMobjLights((mobj_t *)th);
|
||||
}
|
||||
#endif
|
||||
|
||||
@@ -1330,7 +1363,7 @@ void HWR_CreateStaticLightmaps(int bspnum)
|
||||
#ifdef STATICLIGHT
|
||||
CONS_Debug(DBG_RENDER, "HWR_CreateStaticLightmaps\n");
|
||||
|
||||
dynlights->nb = 0;
|
||||
HWR_ResetLights();
|
||||
|
||||
// First: Searching for lights
|
||||
// BP: if i was you, I will make it in create mobj since mobj can be create
|
||||
@@ -1341,8 +1374,6 @@ void HWR_CreateStaticLightmaps(int bspnum)
|
||||
// Second: Build all lightmap for walls covered by lights
|
||||
validcount++; // to be sure
|
||||
HWR_ComputeLightMapsInBSPNode(bspnum, NULL);
|
||||
|
||||
dynlights->nb = 0;
|
||||
#else
|
||||
(void)bspnum;
|
||||
#endif
|
||||
|
||||
@@ -54,10 +54,12 @@ static UINT8 lib_searchBlockmap_Objects(lua_State *L, INT32 x, INT32 y, mobj_t *
|
||||
CONS_Alert(CONS_WARNING,"%s\n",lua_tostring(gL, -1));
|
||||
lua_pop(gL, 1);
|
||||
blockfuncerror = true;
|
||||
P_SetTarget(&bnext, NULL);
|
||||
return 0; // *shrugs*
|
||||
}
|
||||
if (!lua_isnil(gL, -1))
|
||||
{ // if nil, continue
|
||||
P_SetTarget(&bnext, NULL);
|
||||
if (lua_toboolean(gL, -1))
|
||||
return 2; // stop whole search
|
||||
else
|
||||
|
||||
+10
-1
@@ -260,10 +260,19 @@ static int mobj_get(lua_State *L)
|
||||
// bprev -- same deal as sprev above, but for the blockmap.
|
||||
return UNIMPLEMENTED;
|
||||
case mobj_hnext:
|
||||
if (mo->hnext && P_MobjWasRemoved(mo->hnext))
|
||||
{ // don't put invalid mobj back into Lua.
|
||||
P_SetTarget(&mo->hnext, NULL);
|
||||
return 0;
|
||||
}
|
||||
LUA_PushUserdata(L, mo->hnext, META_MOBJ);
|
||||
break;
|
||||
case mobj_hprev:
|
||||
// implimented differently from sprev and bprev because SSNTails.
|
||||
if (mo->hprev && P_MobjWasRemoved(mo->hprev))
|
||||
{ // don't put invalid mobj back into Lua.
|
||||
P_SetTarget(&mo->hprev, NULL);
|
||||
return 0;
|
||||
}
|
||||
LUA_PushUserdata(L, mo->hprev, META_MOBJ);
|
||||
break;
|
||||
case mobj_type:
|
||||
|
||||
+32
-2
@@ -405,6 +405,26 @@ static int player_set(lua_State *L)
|
||||
//
|
||||
else if (fastcmp(field,"charflags"))
|
||||
plr->charflags = (UINT32)luaL_checkinteger(L, 3);
|
||||
else if (fastcmp(field,"thokitem"))
|
||||
plr->thokitem = luaL_checkinteger(L, 3);
|
||||
else if (fastcmp(field,"spinitem"))
|
||||
plr->spinitem = luaL_checkinteger(L, 3);
|
||||
else if (fastcmp(field,"revitem"))
|
||||
plr->revitem = luaL_checkinteger(L, 3);
|
||||
else if (fastcmp(field,"followitem"))
|
||||
plr->followitem = luaL_checkinteger(L, 3);
|
||||
else if (fastcmp(field,"actionspd"))
|
||||
plr->actionspd = (INT32)luaL_checkinteger(L, 3);
|
||||
else if (fastcmp(field,"mindash"))
|
||||
plr->mindash = (INT32)luaL_checkinteger(L, 3);
|
||||
else if (fastcmp(field,"maxdash"))
|
||||
plr->maxdash = (INT32)luaL_checkinteger(L, 3);
|
||||
else if (fastcmp(field,"jumpfactor"))
|
||||
plr->jumpfactor = (INT32)luaL_checkinteger(L, 3);
|
||||
else if (fastcmp(field,"height"))
|
||||
plr->height = luaL_checkfixed(L, 3);
|
||||
else if (fastcmp(field,"spinheight"))
|
||||
plr->spinheight = luaL_checkfixed(L, 3);
|
||||
else if (fastcmp(field,"lives"))
|
||||
plr->lives = (SINT8)luaL_checkinteger(L, 3);
|
||||
else if (fastcmp(field,"continues"))
|
||||
@@ -476,9 +496,19 @@ static int player_set(lua_State *L)
|
||||
else if (fastcmp(field,"old_angle_pos"))
|
||||
plr->old_angle_pos = luaL_checkangle(L, 3);
|
||||
else if (fastcmp(field,"axis1"))
|
||||
P_SetTarget(&plr->axis1, *((mobj_t **)luaL_checkudata(L, 3, META_MOBJ)));
|
||||
{
|
||||
mobj_t *mo = NULL;
|
||||
if (!lua_isnil(L, 3))
|
||||
mo = *((mobj_t **)luaL_checkudata(L, 3, META_MOBJ));
|
||||
P_SetTarget(&plr->axis1, mo);
|
||||
}
|
||||
else if (fastcmp(field,"axis2"))
|
||||
P_SetTarget(&plr->axis2, *((mobj_t **)luaL_checkudata(L, 3, META_MOBJ)));
|
||||
{
|
||||
mobj_t *mo = NULL;
|
||||
if (!lua_isnil(L, 3))
|
||||
mo = *((mobj_t **)luaL_checkudata(L, 3, META_MOBJ));
|
||||
P_SetTarget(&plr->axis2, mo);
|
||||
}
|
||||
else if (fastcmp(field,"bumpertime"))
|
||||
plr->bumpertime = (tic_t)luaL_checkinteger(L, 3);
|
||||
else if (fastcmp(field,"flyangle"))
|
||||
|
||||
+18
-13
@@ -1027,14 +1027,16 @@ void LUA_Archive(void)
|
||||
}
|
||||
|
||||
//if (gamestate == GS_LEVEL)
|
||||
for (i = 0; i < NUM_THINKERLISTS; i++)
|
||||
for (th = thlist[i].next; th != &thlist[i]; th = th->next)
|
||||
if (th->function.acp1 == (actionf_p1)P_MobjThinker)
|
||||
{
|
||||
// archive function will determine when to skip mobjs,
|
||||
// and write mobjnum in otherwise.
|
||||
ArchiveExtVars(th, "mobj");
|
||||
}
|
||||
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
|
||||
{
|
||||
if (th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
|
||||
continue;
|
||||
|
||||
// archive function will determine when to skip mobjs,
|
||||
// and write mobjnum in otherwise.
|
||||
ArchiveExtVars(th, "mobj");
|
||||
}
|
||||
|
||||
WRITEUINT32(save_p, UINT32_MAX); // end of mobjs marker, replaces mobjnum.
|
||||
|
||||
LUAh_NetArchiveHook(NetArchive); // call the NetArchive hook in archive mode
|
||||
@@ -1062,11 +1064,14 @@ void LUA_UnArchive(void)
|
||||
|
||||
do {
|
||||
mobjnum = READUINT32(save_p); // read a mobjnum
|
||||
for (i = 0; i < NUM_THINKERLISTS; i++)
|
||||
for (th = thlist[i].next; th != &thlist[i]; th = th->next)
|
||||
if (th->function.acp1 == (actionf_p1)P_MobjThinker
|
||||
&& ((mobj_t *)th)->mobjnum == mobjnum) // find matching mobj
|
||||
UnArchiveExtVars(th); // apply variables
|
||||
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
|
||||
{
|
||||
if (th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
|
||||
continue;
|
||||
if (((mobj_t *)th)->mobjnum != mobjnum) // find matching mobj
|
||||
continue;
|
||||
UnArchiveExtVars(th); // apply variables
|
||||
}
|
||||
} while(mobjnum != UINT32_MAX); // repeat until end of mobjs marker.
|
||||
|
||||
LUAh_NetArchiveHook(NetUnArchive); // call the NetArchive hook in unarchive mode
|
||||
|
||||
+6
-2
@@ -914,10 +914,14 @@ static mapthing_t *OP_CreateNewMapThing(player_t *player, UINT16 type, boolean c
|
||||
|
||||
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
|
||||
{
|
||||
if (th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
|
||||
continue;
|
||||
|
||||
mo = (mobj_t *)th;
|
||||
// get offset from mt, which points to old mapthings, then add new location
|
||||
if (mo->spawnpoint)
|
||||
mo->spawnpoint = (mo->spawnpoint - mt) + mapthings;
|
||||
if (!mo->spawnpoint)
|
||||
continue;
|
||||
mo->spawnpoint = (mo->spawnpoint - mt) + mapthings;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
+42
-13
@@ -2149,7 +2149,7 @@ void A_Boss1Laser(mobj_t *actor)
|
||||
if (z - floorz < mobjinfo[MT_EGGMOBILE_FIRE].height>>1)
|
||||
{
|
||||
point = P_SpawnMobj(x, y, floorz+1, MT_EGGMOBILE_FIRE);
|
||||
point->target = actor;
|
||||
P_SetTarget(&point->target, actor);
|
||||
point->destscale = 3*FRACUNIT;
|
||||
point->scalespeed = FRACUNIT>>2;
|
||||
point->fuse = TICRATE;
|
||||
@@ -2530,10 +2530,11 @@ void A_1upThinker(mobj_t *actor)
|
||||
|
||||
if (closestplayer == -1 || skins[players[closestplayer].skin].spritedef.numframes <= states[S_PLAY_BOX1].frame)
|
||||
{ // Closest player not found (no players in game?? may be empty dedicated server!), or does not have correct sprite.
|
||||
actor->frame = 0;
|
||||
if (actor->tracer) {
|
||||
P_RemoveMobj(actor->tracer);
|
||||
actor->tracer = NULL;
|
||||
if (actor->tracer)
|
||||
{
|
||||
mobj_t *tracer = actor->tracer;
|
||||
P_SetTarget(&actor->tracer, NULL);
|
||||
P_RemoveMobj(tracer);
|
||||
}
|
||||
return;
|
||||
}
|
||||
@@ -2747,6 +2748,9 @@ void A_BossDeath(mobj_t *mo)
|
||||
// if all bosses are dead
|
||||
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
|
||||
{
|
||||
if (th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
|
||||
continue;
|
||||
|
||||
mo2 = (mobj_t *)th;
|
||||
if (mo2 != mo && (mo2->flags & MF_BOSS) && mo2->health > 0)
|
||||
goto bossjustdie; // other boss not dead - just go straight to dying!
|
||||
@@ -2799,12 +2803,12 @@ bossjustdie:
|
||||
|
||||
P_SetTarget(&mo->target, NULL);
|
||||
|
||||
// Flee! Flee! Find a point to escape to! If none, just shoot upward!
|
||||
// scan the thinkers to find the runaway point
|
||||
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
|
||||
{
|
||||
if (th->function.acp1 != (actionf_p1)P_MobjThinker)
|
||||
continue;
|
||||
// Flee! Flee! Find a point to escape to! If none, just shoot upward!
|
||||
// scan the thinkers to find the runaway point
|
||||
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
|
||||
{
|
||||
if (th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
|
||||
continue;
|
||||
|
||||
mo2 = (mobj_t *)th;
|
||||
|
||||
@@ -5436,6 +5440,9 @@ void A_RingExplode(mobj_t *actor)
|
||||
|
||||
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
|
||||
{
|
||||
if (th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
|
||||
continue;
|
||||
|
||||
mo2 = (mobj_t *)th;
|
||||
|
||||
if (mo2 == actor) // Don't explode yourself! Endless loop!
|
||||
@@ -6532,7 +6539,7 @@ void A_Boss2PogoTarget(mobj_t *actor)
|
||||
if (actor->info->missilestate) // spawn the pogo stick collision box
|
||||
{
|
||||
mobj_t *pogo = P_SpawnMobj(actor->x, actor->y, actor->z - mobjinfo[actor->info->missilestate].height, (mobjtype_t)actor->info->missilestate);
|
||||
pogo->target = actor;
|
||||
P_SetTarget(&pogo->target, actor);
|
||||
}
|
||||
|
||||
actor->reactiontime = 1;
|
||||
@@ -7072,6 +7079,19 @@ void A_Boss3Path(mobj_t *actor)
|
||||
mo2 = (mobj_t *)th;
|
||||
if (mo2->type == MT_BOSS3WAYPOINT && mo2->spawnpoint && mo2->spawnpoint->angle == actor->threshold)
|
||||
{
|
||||
if (th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
|
||||
continue;
|
||||
|
||||
mo2 = (mobj_t *)th;
|
||||
if (mo2->type != MT_BOSS3WAYPOINT)
|
||||
continue;
|
||||
if (!mo2->spawnpoint)
|
||||
continue;
|
||||
if (mo2->spawnpoint->angle != actor->threshold)
|
||||
continue;
|
||||
if (mo2->spawnpoint->extrainfo != actor->cusval)
|
||||
continue;
|
||||
|
||||
P_SetTarget(&actor->target, mo2);
|
||||
break;
|
||||
}
|
||||
@@ -7456,6 +7476,9 @@ void A_FindTarget(mobj_t *actor)
|
||||
// scan the thinkers
|
||||
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
|
||||
{
|
||||
if (th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
|
||||
continue;
|
||||
|
||||
mo2 = (mobj_t *)th;
|
||||
|
||||
if (mo2->type == (mobjtype_t)locvar1)
|
||||
@@ -7518,6 +7541,9 @@ void A_FindTracer(mobj_t *actor)
|
||||
// scan the thinkers
|
||||
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
|
||||
{
|
||||
if (th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
|
||||
continue;
|
||||
|
||||
mo2 = (mobj_t *)th;
|
||||
|
||||
if (mo2->type == (mobjtype_t)locvar1)
|
||||
@@ -8078,6 +8104,9 @@ void A_RemoteAction(mobj_t *actor)
|
||||
// scan the thinkers
|
||||
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
|
||||
{
|
||||
if (th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
|
||||
continue;
|
||||
|
||||
mo2 = (mobj_t *)th;
|
||||
|
||||
if (mo2->type == (mobjtype_t)locvar1)
|
||||
@@ -9118,7 +9147,7 @@ void A_CheckThingCount(mobj_t *actor)
|
||||
|
||||
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
|
||||
{
|
||||
if (th->function.acp1 != (actionf_p1)P_MobjThinker)
|
||||
if (th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
|
||||
continue;
|
||||
|
||||
mo2 = (mobj_t *)th;
|
||||
|
||||
+18
-10
@@ -1974,17 +1974,25 @@ void T_ThwompSector(levelspecthink_t *thwomp)
|
||||
// scan the thinkers to find players!
|
||||
if (!rover || (rover->flags & FF_EXISTS))
|
||||
{
|
||||
// scan the thinkers to find players!
|
||||
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
|
||||
UINT8 i;
|
||||
// scan the players to find victims!
|
||||
for (i = 0; i < MAXPLAYERS; i++)
|
||||
{
|
||||
mo = (mobj_t *)th;
|
||||
if (mo->type == MT_PLAYER && mo->health && mo->player && !mo->player->spectator
|
||||
&& mo->z <= thwomp->sector->ceilingheight
|
||||
&& P_AproxDistance(thwompx - mo->x, thwompy - mo->y) <= 96*FRACUNIT)
|
||||
{
|
||||
thwomp->direction = -1;
|
||||
break;
|
||||
}
|
||||
if (!playeringame[i])
|
||||
continue;
|
||||
if (players[i].spectator)
|
||||
continue;
|
||||
if (!players[i].mo)
|
||||
continue;
|
||||
if (!players[i].mo->health)
|
||||
continue;
|
||||
if (players[i].mo->z > thwomp->sector->ceilingheight)
|
||||
continue;
|
||||
if (P_AproxDistance(thwompx - players[i].mo->x, thwompy - players[i].mo->y) > 96 * FRACUNIT)
|
||||
continue;
|
||||
|
||||
thwomp->direction = -1;
|
||||
break;
|
||||
}
|
||||
}*/
|
||||
|
||||
|
||||
@@ -949,6 +949,60 @@ void P_TouchSpecialThing(mobj_t *special, mobj_t *toucher, boolean heightcheck)
|
||||
if (toucher->tracer && toucher->tracer->target
|
||||
&& toucher->tracer->target->type == MT_GOTEMERALD)
|
||||
{
|
||||
mobj_t *orbittarget = special->target ? special->target : special;
|
||||
mobj_t *hnext = orbittarget->hnext, *anchorpoint = NULL, *anchorpoint2 = NULL;
|
||||
mobj_t *mo2;
|
||||
thinker_t *th;
|
||||
|
||||
// The player might have two Ideyas: toucher->tracer and toucher->tracer->hnext
|
||||
// so handle their anchorpoints accordingly.
|
||||
// scan the thinkers to find the corresponding anchorpoint
|
||||
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
|
||||
{
|
||||
if (th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
|
||||
continue;
|
||||
|
||||
mo2 = (mobj_t *)th;
|
||||
|
||||
if (mo2->type != MT_IDEYAANCHOR)
|
||||
continue;
|
||||
|
||||
if (mo2->health == toucher->tracer->health) // do ideya numberes match?
|
||||
anchorpoint = mo2;
|
||||
else if (toucher->tracer->hnext && mo2->health == toucher->tracer->hnext->health)
|
||||
anchorpoint2 = mo2;
|
||||
|
||||
if ((!toucher->tracer->hnext && anchorpoint)
|
||||
|| (toucher->tracer->hnext && anchorpoint && anchorpoint2))
|
||||
break;
|
||||
}
|
||||
|
||||
if (anchorpoint)
|
||||
{
|
||||
toucher->tracer->flags |= MF_GRENADEBOUNCE; // custom radius factors
|
||||
toucher->tracer->threshold = 8 << 20; // X factor 0, Y factor 0, Z factor 8
|
||||
}
|
||||
|
||||
if (anchorpoint2)
|
||||
{
|
||||
toucher->tracer->hnext->flags |= MF_GRENADEBOUNCE; // custom radius factors
|
||||
toucher->tracer->hnext->threshold = 8 << 20; // X factor 0, Y factor 0, Z factor 8
|
||||
}
|
||||
|
||||
P_SetTarget(&orbittarget->hnext, toucher->tracer);
|
||||
if (!orbittarget->hnext->hnext)
|
||||
P_SetTarget(&orbittarget->hnext->hnext, hnext); // Buffalo buffalo Buffalo buffalo buffalo buffalo Buffalo buffalo.
|
||||
else
|
||||
P_SetTarget(&orbittarget->hnext->hnext->target, anchorpoint2 ? anchorpoint2 : orbittarget);
|
||||
P_SetTarget(&orbittarget->hnext->target, anchorpoint ? anchorpoint : orbittarget);
|
||||
P_SetTarget(&toucher->tracer, NULL);
|
||||
|
||||
if (hnext)
|
||||
{
|
||||
orbittarget->hnext->extravalue1 = (angle_t)(hnext->extravalue1 - 72*ANG1);
|
||||
if (orbittarget->hnext->extravalue1 > hnext->extravalue1)
|
||||
orbittarget->hnext->extravalue1 -= (72*ANG1)/orbittarget->hnext->extravalue1;
|
||||
}
|
||||
}
|
||||
else // Make sure that SOMEONE has the emerald, at least!
|
||||
{
|
||||
@@ -998,6 +1052,9 @@ void P_TouchSpecialThing(mobj_t *special, mobj_t *toucher, boolean heightcheck)
|
||||
// scan the remaining thinkers
|
||||
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
|
||||
{
|
||||
if (th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
|
||||
continue;
|
||||
|
||||
mo2 = (mobj_t *)th;
|
||||
|
||||
if (mo2 == special)
|
||||
@@ -1045,6 +1102,9 @@ void P_TouchSpecialThing(mobj_t *special, mobj_t *toucher, boolean heightcheck)
|
||||
// in from the paraloop. Isn't this just so efficient?
|
||||
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
|
||||
{
|
||||
if (th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
|
||||
continue;
|
||||
|
||||
mo2 = (mobj_t *)th;
|
||||
|
||||
if (P_AproxDistance(P_AproxDistance(mo2->x - x, mo2->y - y), mo2->z - z) > gatherradius)
|
||||
@@ -1411,6 +1471,9 @@ void P_TouchSpecialThing(mobj_t *special, mobj_t *toucher, boolean heightcheck)
|
||||
// scan the remaining thinkers to find koopa
|
||||
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
|
||||
{
|
||||
if (th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
|
||||
continue;
|
||||
|
||||
mo2 = (mobj_t *)th;
|
||||
if (mo2->type == MT_KOOPA)
|
||||
{
|
||||
|
||||
+2
-2
@@ -60,8 +60,8 @@
|
||||
#define mariomode (maptol & TOL_MARIO)
|
||||
#define twodlevel (maptol & TOL_2D)
|
||||
|
||||
typedef enum{
|
||||
THINK_LIMBO,
|
||||
typedef enum
|
||||
{
|
||||
THINK_POLYOBJ,
|
||||
THINK_MAIN,
|
||||
THINK_MOBJ,
|
||||
|
||||
@@ -1093,7 +1093,10 @@ boolean P_BlockThingsIterator(INT32 x, INT32 y, boolean (*func)(mobj_t *))
|
||||
{
|
||||
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))
|
||||
{
|
||||
P_SetTarget(&bnext, NULL);
|
||||
return false;
|
||||
}
|
||||
if (P_MobjWasRemoved(tmthing) // func just popped our tmthing, cannot continue.
|
||||
|| (bnext && P_MobjWasRemoved(bnext))) // func just broke blockmap chain, cannot continue.
|
||||
{
|
||||
|
||||
+74
-50
@@ -423,6 +423,9 @@ boolean P_WeaponOrPanel(mobjtype_t type)
|
||||
|
||||
for (think = thlist[THINK_MOBJ].next; think != &thlist[THINK_MOBJ]; think = think->next)
|
||||
{
|
||||
if (think->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
|
||||
continue;
|
||||
|
||||
mo = (mobj_t *)think;
|
||||
|
||||
if (mo->type == MT_EMERALDSPAWN)
|
||||
@@ -3497,6 +3500,9 @@ void P_DestroyRobots(void)
|
||||
|
||||
for (think = thlist[THINK_MOBJ].next; think != &thlist[THINK_MOBJ]; think = think->next)
|
||||
{
|
||||
if (think->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
|
||||
continue;
|
||||
|
||||
mo = (mobj_t *)think;
|
||||
if (mo->health <= 0 || !(mo->flags & MF_ENEMY || mo->flags & MF_BOSS))
|
||||
continue; // not a valid enemy
|
||||
@@ -4301,6 +4307,9 @@ static void P_Boss3Thinker(mobj_t *mobj)
|
||||
// this can happen if the boss was hurt earlier than expected
|
||||
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
|
||||
{
|
||||
if (th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
|
||||
continue;
|
||||
|
||||
mo2 = (mobj_t *)th;
|
||||
if (mo2->type == (mobjtype_t)mobj->info->mass && mo2->tracer == mobj)
|
||||
{
|
||||
@@ -4392,7 +4401,20 @@ static void P_Boss3Thinker(mobj_t *mobj)
|
||||
mo2 = (mobj_t *)th;
|
||||
if (mo2->type == MT_BOSS3WAYPOINT && mo2->spawnpoint && mo2->spawnpoint->angle == mobj->threshold)
|
||||
{
|
||||
P_SetTarget(&mobj->target, mo2);
|
||||
if (th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
|
||||
continue;
|
||||
|
||||
mo2 = (mobj_t *)th;
|
||||
if (mo2->type != MT_BOSS3WAYPOINT)
|
||||
continue;
|
||||
if (!mo2->spawnpoint)
|
||||
continue;
|
||||
if (mo2->spawnpoint->angle != mobj->threshold)
|
||||
continue;
|
||||
if (mo2->spawnpoint->extrainfo != mobj->cusval)
|
||||
continue;
|
||||
|
||||
P_SetTarget(&mobj->tracer, mo2);
|
||||
break;
|
||||
}
|
||||
}
|
||||
@@ -4631,8 +4653,8 @@ static void P_Boss4Thinker(mobj_t *mobj)
|
||||
P_SetTarget(&seg->target, mobj);
|
||||
for (i = 0; i < 9; i++)
|
||||
{
|
||||
seg->hnext = P_SpawnMobj(mobj->x, mobj->y, z, MT_EGGMOBILE4_MACE);
|
||||
seg->hnext->hprev = seg;
|
||||
P_SetTarget(&seg->hnext, P_SpawnMobj(mobj->x, mobj->y, z, MT_EGGMOBILE4_MACE));
|
||||
P_SetTarget(&seg->hnext->hprev, seg);
|
||||
seg = seg->hnext;
|
||||
}
|
||||
}
|
||||
@@ -5007,6 +5029,9 @@ static void P_Boss7Thinker(mobj_t *mobj)
|
||||
// Find waypoint he is closest to
|
||||
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
|
||||
{
|
||||
if (th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
|
||||
continue;
|
||||
|
||||
mo2 = (mobj_t *)th;
|
||||
if (mo2->type == MT_BOSS3WAYPOINT && mo2->spawnpoint)
|
||||
{
|
||||
@@ -5059,6 +5084,9 @@ static void P_Boss7Thinker(mobj_t *mobj)
|
||||
// the waypoint to use
|
||||
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
|
||||
{
|
||||
if (th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
|
||||
continue;
|
||||
|
||||
mo2 = (mobj_t *)th;
|
||||
if (mo2->type == MT_BOSS3WAYPOINT && mo2->spawnpoint && (mo2->spawnpoint->options & 7) == waypointNum)
|
||||
{
|
||||
@@ -5179,14 +5207,17 @@ static void P_Boss9Thinker(mobj_t *mobj)
|
||||
// Build a hoop linked list of 'em!
|
||||
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
|
||||
{
|
||||
if (th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
|
||||
continue;
|
||||
|
||||
mo2 = (mobj_t *)th;
|
||||
if (mo2->type == MT_BOSS9GATHERPOINT)
|
||||
{
|
||||
if (last)
|
||||
last->hnext = mo2;
|
||||
P_SetTarget(&last->hnext, mo2);
|
||||
else
|
||||
mobj->hnext = mo2;
|
||||
mo2->hprev = last;
|
||||
P_SetTarget(&mobj->hnext, mo2);
|
||||
P_SetTarget(&mo2->hprev, last);
|
||||
last = mo2;
|
||||
}
|
||||
}
|
||||
@@ -5610,6 +5641,9 @@ mobj_t *P_GetClosestAxis(mobj_t *source)
|
||||
// scan the thinkers to find the closest axis point
|
||||
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
|
||||
{
|
||||
if (th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
|
||||
continue;
|
||||
|
||||
mo2 = (mobj_t *)th;
|
||||
|
||||
if (mo2->type == MT_AXIS)
|
||||
@@ -6135,12 +6169,14 @@ static void P_RemoveOverlay(mobj_t *thing)
|
||||
{
|
||||
mobj_t *mo;
|
||||
for (mo = overlaycap; mo; mo = mo->hnext)
|
||||
if (mo->hnext == thing)
|
||||
{
|
||||
P_SetTarget(&mo->hnext, thing->hnext);
|
||||
P_SetTarget(&thing->hnext, NULL);
|
||||
return;
|
||||
}
|
||||
{
|
||||
if (mo->hnext != thing)
|
||||
continue;
|
||||
|
||||
P_SetTarget(&mo->hnext, thing->hnext);
|
||||
P_SetTarget(&thing->hnext, NULL);
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
void P_RunShadows(void)
|
||||
@@ -9989,7 +10025,7 @@ mobj_t *P_SpawnMobj(fixed_t x, fixed_t y, fixed_t z, mobjtype_t type)
|
||||
}
|
||||
|
||||
if (!(mobj->flags & MF_NOTHINK))
|
||||
P_AddThinker(&mobj->thinker);
|
||||
P_AddThinker(THINK_MOBJ, &mobj->thinker);
|
||||
|
||||
// Call action functions when the state is set
|
||||
if (st->action.acp1 && (mobj->flags & MF_RUNSPAWNFUNC))
|
||||
@@ -10305,37 +10341,28 @@ void P_RemoveMobj(mobj_t *mobj)
|
||||
}
|
||||
}
|
||||
|
||||
// free block
|
||||
// DBG: set everything in mobj_t to 0xFF instead of leaving it. debug memory error.
|
||||
if (mobj->flags & MF_NOTHINK && !mobj->thinker.next)
|
||||
#ifdef SCRAMBLE_REMOVED
|
||||
// Invalidate mobj_t data to cause crashes if accessed!
|
||||
memset((UINT8 *)mobj + sizeof(thinker_t), 0xff, sizeof(mobj_t) - sizeof(thinker_t));
|
||||
#endif
|
||||
|
||||
// free block
|
||||
if (!mobj->thinker.next)
|
||||
{ // Uh-oh, the mobj doesn't think, P_RemoveThinker would never go through!
|
||||
INT32 prevreferences;
|
||||
if (!mobj->thinker.references)
|
||||
{
|
||||
#ifdef SCRAMBLE_REMOVED
|
||||
// Invalidate mobj_t data to cause crashes if accessed!
|
||||
memset(mobj, 0xff, sizeof(mobj_t));
|
||||
#endif
|
||||
Z_Free(mobj); // No refrences? Can be removed immediately! :D
|
||||
}
|
||||
else
|
||||
{ // Add thinker just to delay removing it until refrences are gone.
|
||||
mobj->flags &= ~MF_NOTHINK;
|
||||
P_AddThinker(THINK_MOBJ, (thinker_t *)mobj);
|
||||
#ifdef SCRAMBLE_REMOVED
|
||||
// Invalidate mobj_t data to cause crashes if accessed!
|
||||
memset((UINT8 *)mobj + sizeof(thinker_t), 0xff, sizeof(mobj_t) - sizeof(thinker_t));
|
||||
#endif
|
||||
P_RemoveThinker((thinker_t *)mobj);
|
||||
Z_Free(mobj); // No refrrences? Can be removed immediately! :D
|
||||
return;
|
||||
}
|
||||
|
||||
prevreferences = mobj->thinker.references;
|
||||
P_AddThinker(THINK_MOBJ, (thinker_t *)mobj);
|
||||
mobj->thinker.references = prevreferences;
|
||||
}
|
||||
else
|
||||
{
|
||||
#ifdef SCRAMBLE_REMOVED
|
||||
// Invalidate mobj_t data to cause crashes if accessed!
|
||||
memset((UINT8 *)mobj + sizeof(thinker_t), 0xff, sizeof(mobj_t) - sizeof(thinker_t));
|
||||
#endif
|
||||
P_RemoveThinker((thinker_t *)mobj);
|
||||
}
|
||||
|
||||
P_RemoveThinker((thinker_t *)mobj);
|
||||
}
|
||||
|
||||
// This does not need to be added to Lua.
|
||||
@@ -10593,7 +10620,7 @@ void P_RespawnSpecials(void)
|
||||
{
|
||||
thinker_t *th;
|
||||
|
||||
for (th = thinkercap.next; th != &thinkercap; th = th->next)
|
||||
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
|
||||
{
|
||||
mobj_t *box;
|
||||
mobj_t *newmobj;
|
||||
@@ -11745,6 +11772,9 @@ ML_NOCLIMB : Direction not controllable
|
||||
// See if other starposts exist in this level that have the same value.
|
||||
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
|
||||
{
|
||||
if (th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
|
||||
continue;
|
||||
|
||||
mo2 = (mobj_t *)th;
|
||||
|
||||
if (mo2 == mobj)
|
||||
@@ -12020,7 +12050,7 @@ void P_SpawnHoopsAndRings(mapthing_t *mthing)
|
||||
//mobj->hprev->hnext = mobj;
|
||||
}
|
||||
else
|
||||
mobj->hprev = mobj->hnext = NULL;
|
||||
P_SetTarget(&mobj->hprev, P_SetTarget(&mobj->hnext, NULL));
|
||||
|
||||
nextmobj = mobj;
|
||||
}
|
||||
@@ -12046,11 +12076,9 @@ void P_SpawnHoopsAndRings(mapthing_t *mthing)
|
||||
mobj->z -= mobj->height/2;
|
||||
|
||||
// Link all the collision sprites together.
|
||||
mobj->hnext = NULL;
|
||||
P_SetTarget(&mobj->hnext, NULL);
|
||||
P_SetTarget(&mobj->hprev, nextmobj);
|
||||
P_SetTarget(&mobj->hprev->hnext, mobj);
|
||||
//mobj->hprev = nextmobj;
|
||||
//mobj->hprev->hnext = mobj;
|
||||
|
||||
nextmobj = mobj;
|
||||
}
|
||||
@@ -12075,11 +12103,9 @@ void P_SpawnHoopsAndRings(mapthing_t *mthing)
|
||||
mobj->z -= mobj->height/2;
|
||||
|
||||
// Link all the collision sprites together.
|
||||
mobj->hnext = NULL;
|
||||
P_SetTarget(&mobj->hnext, NULL);
|
||||
P_SetTarget(&mobj->hprev, nextmobj);
|
||||
P_SetTarget(&mobj->hprev->hnext, mobj);
|
||||
//mobj->hprev = nextmobj;
|
||||
//mobj->hprev->hnext = mobj;
|
||||
|
||||
nextmobj = mobj;
|
||||
}
|
||||
@@ -12168,7 +12194,7 @@ void P_SpawnHoopsAndRings(mapthing_t *mthing)
|
||||
//mobj->hprev->hnext = mobj;
|
||||
}
|
||||
else
|
||||
mobj->hprev = mobj->hnext = NULL;
|
||||
P_SetTarget(&mobj->hprev, P_SetTarget(&mobj->hnext, NULL));
|
||||
|
||||
nextmobj = mobj;
|
||||
}
|
||||
@@ -12205,11 +12231,9 @@ void P_SpawnHoopsAndRings(mapthing_t *mthing)
|
||||
mobj->z -= mobj->height/2;
|
||||
|
||||
// Link all the collision sprites together.
|
||||
mobj->hnext = NULL;
|
||||
P_SetTarget(&mobj->hnext, NULL);
|
||||
P_SetTarget(&mobj->hprev, nextmobj);
|
||||
P_SetTarget(&mobj->hprev->hnext, mobj);
|
||||
//mobj->hprev = nextmobj;
|
||||
//mobj->hprev->hnext = mobj;
|
||||
|
||||
nextmobj = mobj;
|
||||
}
|
||||
|
||||
+96
-75
@@ -1496,6 +1496,9 @@ void Polyobj_InitLevel(void)
|
||||
// the mobj_t pointers on a queue for use below.
|
||||
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
|
||||
{
|
||||
if (th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
|
||||
continue;
|
||||
|
||||
mobj_t *mo = (mobj_t *)th;
|
||||
|
||||
if (mo->info->doomednum == POLYOBJ_SPAWN_DOOMEDNUM ||
|
||||
@@ -1797,6 +1800,9 @@ void T_PolyObjWaypoint(polywaypoint_t *th)
|
||||
// We redo this each tic to make savegame compatibility easier.
|
||||
for (wp = thlist[THINK_MOBJ].next; wp != &thlist[THINK_MOBJ]; wp = wp->next)
|
||||
{
|
||||
if (wp->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
|
||||
continue;
|
||||
|
||||
mo2 = (mobj_t *)wp;
|
||||
|
||||
if (mo2->type != MT_TUBEWAYPOINT)
|
||||
@@ -1875,28 +1881,31 @@ void T_PolyObjWaypoint(polywaypoint_t *th)
|
||||
// Find next waypoint
|
||||
for (wp = thlist[THINK_MOBJ].next; wp != &thlist[THINK_MOBJ]; wp = wp->next)
|
||||
{
|
||||
if (wp->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
|
||||
continue;
|
||||
|
||||
mo2 = (mobj_t *)wp;
|
||||
|
||||
if (mo2->type != MT_TUBEWAYPOINT)
|
||||
continue;
|
||||
|
||||
if (mo2->threshold == th->sequence)
|
||||
if (mo2->threshold != th->sequence)
|
||||
continue;
|
||||
|
||||
if (th->direction == -1)
|
||||
{
|
||||
if (th->direction == -1)
|
||||
if (mo2->health == target->health - 1)
|
||||
{
|
||||
if (mo2->health == target->health - 1)
|
||||
{
|
||||
waypoint = mo2;
|
||||
break;
|
||||
}
|
||||
waypoint = mo2;
|
||||
break;
|
||||
}
|
||||
else
|
||||
}
|
||||
else
|
||||
{
|
||||
if (mo2->health == target->health + 1)
|
||||
{
|
||||
if (mo2->health == target->health + 1)
|
||||
{
|
||||
waypoint = mo2;
|
||||
break;
|
||||
}
|
||||
waypoint = mo2;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1911,27 +1920,30 @@ void T_PolyObjWaypoint(polywaypoint_t *th)
|
||||
|
||||
for (wp = thlist[THINK_MOBJ].next; wp != &thlist[THINK_MOBJ]; wp = wp->next)
|
||||
{
|
||||
if (wp->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
|
||||
continue;
|
||||
|
||||
mo2 = (mobj_t *)wp;
|
||||
|
||||
if (mo2->type != MT_TUBEWAYPOINT)
|
||||
continue;
|
||||
|
||||
if (mo2->threshold == th->sequence)
|
||||
if (mo2->threshold != th->sequence)
|
||||
continue;
|
||||
|
||||
if (th->direction == -1)
|
||||
{
|
||||
if (th->direction == -1)
|
||||
if (waypoint == NULL)
|
||||
waypoint = mo2;
|
||||
else if (mo2->health > waypoint->health)
|
||||
waypoint = mo2;
|
||||
}
|
||||
else
|
||||
{
|
||||
if (mo2->health == 0)
|
||||
{
|
||||
if (waypoint == NULL)
|
||||
waypoint = mo2;
|
||||
else if (mo2->health > waypoint->health)
|
||||
waypoint = mo2;
|
||||
}
|
||||
else
|
||||
{
|
||||
if (mo2->health == 0)
|
||||
{
|
||||
waypoint = mo2;
|
||||
break;
|
||||
}
|
||||
waypoint = mo2;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1945,28 +1957,31 @@ void T_PolyObjWaypoint(polywaypoint_t *th)
|
||||
|
||||
for (wp = thlist[THINK_MOBJ].next; wp != &thlist[THINK_MOBJ]; wp = wp->next)
|
||||
{
|
||||
if (wp->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
|
||||
continue;
|
||||
|
||||
mo2 = (mobj_t *)wp;
|
||||
|
||||
if (mo2->type != MT_TUBEWAYPOINT)
|
||||
continue;
|
||||
|
||||
if (mo2->threshold == th->sequence)
|
||||
if (mo2->threshold != th->sequence)
|
||||
continue;
|
||||
|
||||
if (th->direction == -1)
|
||||
{
|
||||
if (th->direction == -1)
|
||||
if (mo2->health == target->health - 1)
|
||||
{
|
||||
if (mo2->health == target->health - 1)
|
||||
{
|
||||
waypoint = mo2;
|
||||
break;
|
||||
}
|
||||
waypoint = mo2;
|
||||
break;
|
||||
}
|
||||
else
|
||||
}
|
||||
else
|
||||
{
|
||||
if (mo2->health == target->health + 1)
|
||||
{
|
||||
if (mo2->health == target->health + 1)
|
||||
{
|
||||
waypoint = mo2;
|
||||
break;
|
||||
}
|
||||
waypoint = mo2;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -2454,36 +2469,39 @@ INT32 EV_DoPolyObjWaypoint(polywaypointdata_t *pwdata)
|
||||
// Find the first waypoint we need to use
|
||||
for (wp = thlist[THINK_MOBJ].next; wp != &thlist[THINK_MOBJ]; wp = wp->next)
|
||||
{
|
||||
if (wp->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
|
||||
continue;
|
||||
|
||||
mo2 = (mobj_t *)wp;
|
||||
|
||||
if (mo2->type != MT_TUBEWAYPOINT)
|
||||
continue;
|
||||
|
||||
if (mo2->threshold == th->sequence)
|
||||
if (mo2->threshold != th->sequence)
|
||||
continue;
|
||||
|
||||
if (th->direction == -1) // highest waypoint #
|
||||
{
|
||||
if (th->direction == -1) // highest waypoint #
|
||||
if (mo2->health == 0)
|
||||
last = mo2;
|
||||
else
|
||||
{
|
||||
if (mo2->health == 0)
|
||||
last = mo2;
|
||||
else
|
||||
{
|
||||
if (first == NULL)
|
||||
first = mo2;
|
||||
else if (mo2->health > first->health)
|
||||
first = mo2;
|
||||
}
|
||||
}
|
||||
else // waypoint 0
|
||||
{
|
||||
if (mo2->health == 0)
|
||||
if (first == NULL)
|
||||
first = mo2;
|
||||
else
|
||||
{
|
||||
if (last == NULL)
|
||||
last = mo2;
|
||||
else if (mo2->health > last->health)
|
||||
last = mo2;
|
||||
}
|
||||
else if (mo2->health > first->health)
|
||||
first = mo2;
|
||||
}
|
||||
}
|
||||
else // waypoint 0
|
||||
{
|
||||
if (mo2->health == 0)
|
||||
first = mo2;
|
||||
else
|
||||
{
|
||||
if (last == NULL)
|
||||
last = mo2;
|
||||
else if (mo2->health > last->health)
|
||||
last = mo2;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -2522,28 +2540,31 @@ INT32 EV_DoPolyObjWaypoint(polywaypointdata_t *pwdata)
|
||||
target = first;
|
||||
/*for (wp = thlist[THINK_MOBJ].next; wp != &thlist[THINK_MOBJ]; wp = wp->next)
|
||||
{
|
||||
if (wp->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
|
||||
continue;
|
||||
|
||||
mo2 = (mobj_t *)wp;
|
||||
|
||||
if (mo2->type != MT_TUBEWAYPOINT)
|
||||
continue;
|
||||
|
||||
if (mo2->threshold == th->sequence)
|
||||
if (mo2->threshold != th->sequence)
|
||||
continue;
|
||||
|
||||
if (th->direction == -1) // highest waypoint #
|
||||
{
|
||||
if (th->direction == -1) // highest waypoint #
|
||||
if (mo2->health == first->health - 1)
|
||||
{
|
||||
if (mo2->health == first->health - 1)
|
||||
{
|
||||
target = mo2;
|
||||
break;
|
||||
}
|
||||
target = mo2;
|
||||
break;
|
||||
}
|
||||
else // waypoint 0
|
||||
}
|
||||
else // waypoint 0
|
||||
{
|
||||
if (mo2->health == first->health + 1)
|
||||
{
|
||||
if (mo2->health == first->health + 1)
|
||||
{
|
||||
target = mo2;
|
||||
break;
|
||||
}
|
||||
target = mo2;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}*/
|
||||
|
||||
+32
-19
@@ -1698,7 +1698,6 @@ static void P_NetArchiveThinkers(void)
|
||||
for (i = 0; i < NUM_THINKERLISTS; i++)
|
||||
{
|
||||
UINT32 numsaved = 0;
|
||||
|
||||
// save off the current thinkers
|
||||
for (th = thlist[i].next; th != &thlist[i]; th = th->next)
|
||||
{
|
||||
@@ -1892,12 +1891,12 @@ static void P_NetArchiveThinkers(void)
|
||||
}
|
||||
#endif
|
||||
#ifdef PARANOIA
|
||||
else if (th->function.acv != P_RemoveThinkerDelayed) // wait garbage collection
|
||||
else if (th->function.acp1 != P_RemoveThinkerDelayed) // wait garbage collection
|
||||
I_Error("unknown thinker type %p", th->function.acp1);
|
||||
#endif
|
||||
}
|
||||
|
||||
CONS_Debug(DBG_NETPLAY, "%u thinkers saved\n", numsaved);
|
||||
CONS_Debug(DBG_NETPLAY, "%u thinkers saved in list %d\n", numsaved, i);
|
||||
|
||||
WRITEUINT8(save_p, tc_end);
|
||||
}
|
||||
@@ -1914,9 +1913,14 @@ mobj_t *P_FindNewPosition(UINT32 oldposition)
|
||||
|
||||
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
|
||||
{
|
||||
if (th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
|
||||
continue;
|
||||
|
||||
mobj = (mobj_t *)th;
|
||||
if (mobj->mobjnum == oldposition)
|
||||
return mobj;
|
||||
if (mobj->mobjnum != oldposition)
|
||||
continue;
|
||||
|
||||
return mobj;
|
||||
}
|
||||
CONS_Debug(DBG_GAMELOGIC, "mobj not found\n");
|
||||
return NULL;
|
||||
@@ -2884,22 +2888,22 @@ static void P_NetUnArchiveThinkers(void)
|
||||
P_AddThinker(i, th);
|
||||
}
|
||||
|
||||
CONS_Debug(DBG_NETPLAY, "%u thinkers loaded\n", numloaded);
|
||||
CONS_Debug(DBG_NETPLAY, "%u thinkers loaded in list %d\n", numloaded, i);
|
||||
}
|
||||
|
||||
if (restoreNum)
|
||||
if (restoreNum)
|
||||
{
|
||||
executor_t *delay = NULL;
|
||||
UINT32 mobjnum;
|
||||
for (currentthinker = thlist[i].next; currentthinker != &thlist[i];
|
||||
currentthinker = currentthinker->next)
|
||||
{
|
||||
executor_t *delay = NULL;
|
||||
UINT32 mobjnum;
|
||||
for (currentthinker = thlist[i].next; currentthinker != &thlist[i];
|
||||
currentthinker = currentthinker->next)
|
||||
{
|
||||
if (currentthinker->function.acp1 == (actionf_p1)T_ExecutorDelay)
|
||||
{
|
||||
delay = (void *)currentthinker;
|
||||
if ((mobjnum = (UINT32)(size_t)delay->caller))
|
||||
delay->caller = P_FindNewPosition(mobjnum);
|
||||
}
|
||||
}
|
||||
if (currentthinker->function.acp1 != (actionf_p1)T_ExecutorDelay)
|
||||
continue;
|
||||
delay = (void *)currentthinker;
|
||||
if (!(mobjnum = (UINT32)(size_t)delay->caller))
|
||||
continue;
|
||||
delay->caller = P_FindNewPosition(mobjnum);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -3010,6 +3014,9 @@ static inline void P_FinishMobjs(void)
|
||||
for (currentthinker = thlist[THINK_MOBJ].next; currentthinker != &thlist[THINK_MOBJ];
|
||||
currentthinker = currentthinker->next)
|
||||
{
|
||||
if (currentthinker->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
|
||||
continue;
|
||||
|
||||
mobj = (mobj_t *)currentthinker;
|
||||
mobj->info = &mobjinfo[mobj->type];
|
||||
}
|
||||
@@ -3025,6 +3032,9 @@ static void P_RelinkPointers(void)
|
||||
for (currentthinker = thlist[THINK_MOBJ].next; currentthinker != &thlist[THINK_MOBJ];
|
||||
currentthinker = currentthinker->next)
|
||||
{
|
||||
if (currentthinker->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
|
||||
continue;
|
||||
|
||||
mobj = (mobj_t *)currentthinker;
|
||||
|
||||
if (mobj->type == MT_HOOP || mobj->type == MT_HOOPCOLLIDE || mobj->type == MT_HOOPCENTER)
|
||||
@@ -3457,6 +3467,9 @@ void P_SaveNetGame(void)
|
||||
//if (gamestate == GS_LEVEL)
|
||||
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
|
||||
{
|
||||
if (th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
|
||||
continue;
|
||||
|
||||
mobj = (mobj_t *)th;
|
||||
if (mobj->type == MT_HOOP || mobj->type == MT_HOOPCOLLIDE || mobj->type == MT_HOOPCENTER)
|
||||
continue;
|
||||
|
||||
+6
-5
@@ -835,6 +835,9 @@ void P_ReloadRings(void)
|
||||
// scan the thinkers to find rings/spheres/hoops to unset
|
||||
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
|
||||
{
|
||||
if (th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
|
||||
continue;
|
||||
|
||||
mo = (mobj_t *)th;
|
||||
|
||||
if (mo->type == MT_HOOPCENTER)
|
||||
@@ -2408,15 +2411,13 @@ static void P_LevelInitStuff(void)
|
||||
void P_LoadThingsOnly(void)
|
||||
{
|
||||
// Search through all the thinkers.
|
||||
mobj_t *mo;
|
||||
thinker_t *think;
|
||||
|
||||
for (think = thlist[THINK_MOBJ].next; think != &thlist[THINK_MOBJ]; think = think->next)
|
||||
{
|
||||
mo = (mobj_t *)think;
|
||||
|
||||
if (mo)
|
||||
P_RemoveMobj(mo);
|
||||
if (think->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
|
||||
continue;
|
||||
P_RemoveMobj((mobj_t *)think);
|
||||
}
|
||||
|
||||
P_LevelInitStuff();
|
||||
|
||||
+52
-26
@@ -2058,7 +2058,7 @@ void P_SwitchWeather(INT32 weathernum)
|
||||
thinker_t *think;
|
||||
precipmobj_t *precipmobj;
|
||||
|
||||
for (think = thlist[THINK_MAIN].next; think != &thlist[THINK_MAIN]; think = think->next)
|
||||
for (think = thlist[THINK_PRECIP].next; think != &thlist[THINK_PRECIP]; think = think->next)
|
||||
{
|
||||
if (think->function.acp1 != (actionf_p1)P_NullPrecipThinker)
|
||||
continue; // not a precipmobj thinker
|
||||
@@ -2074,7 +2074,7 @@ void P_SwitchWeather(INT32 weathernum)
|
||||
precipmobj_t *precipmobj;
|
||||
state_t *st;
|
||||
|
||||
for (think = thlist[THINK_MAIN].next; think != &thlist[THINK_MAIN]; think = think->next)
|
||||
for (think = thlist[THINK_PRECIP].next; think != &thlist[THINK_PRECIP]; think = think->next)
|
||||
{
|
||||
if (think->function.acp1 != (actionf_p1)P_NullPrecipThinker)
|
||||
continue; // not a precipmobj thinker
|
||||
@@ -3275,6 +3275,9 @@ void P_SetupSignExit(player_t *player)
|
||||
// spin all signposts in the level then.
|
||||
for (think = thlist[THINK_MOBJ].next; think != &thlist[THINK_MOBJ]; think = think->next)
|
||||
{
|
||||
if (think->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
|
||||
continue;
|
||||
|
||||
thing = (mobj_t *)think;
|
||||
if (thing->type != MT_SIGN)
|
||||
continue;
|
||||
@@ -3317,20 +3320,18 @@ boolean P_IsFlagAtBase(mobjtype_t flag)
|
||||
{
|
||||
thinker_t *think;
|
||||
mobj_t *mo;
|
||||
INT32 specialnum = 0;
|
||||
INT32 specialnum = (flag == MT_REDFLAG) ? 3 : 4;
|
||||
|
||||
for (think = thlist[THINK_MOBJ].next; think != &thlist[THINK_MOBJ]; think = think->next)
|
||||
{
|
||||
if (think->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
|
||||
continue;
|
||||
|
||||
mo = (mobj_t *)think;
|
||||
|
||||
if (mo->type != flag)
|
||||
continue;
|
||||
|
||||
if (mo->type == MT_REDFLAG)
|
||||
specialnum = 3;
|
||||
else if (mo->type == MT_BLUEFLAG)
|
||||
specialnum = 4;
|
||||
|
||||
if (GETSECSPECIAL(mo->subsector->sector->special, 4) == specialnum)
|
||||
return true;
|
||||
else if (mo->subsector->sector->ffloors) // Check the 3D floors
|
||||
@@ -3345,9 +3346,11 @@ boolean P_IsFlagAtBase(mobjtype_t flag)
|
||||
if (GETSECSPECIAL(rover->master->frontsector->special, 4) != specialnum)
|
||||
continue;
|
||||
|
||||
if (mo->z <= P_GetSpecialTopZ(mo, sectors + rover->secnum, mo->subsector->sector)
|
||||
&& mo->z >= P_GetSpecialBottomZ(mo, sectors + rover->secnum, mo->subsector->sector))
|
||||
return true;
|
||||
if (!(mo->z <= P_GetSpecialTopZ(mo, sectors + rover->secnum, mo->subsector->sector)
|
||||
&& mo->z >= P_GetSpecialBottomZ(mo, sectors + rover->secnum, mo->subsector->sector)))
|
||||
continue;
|
||||
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -3759,9 +3762,12 @@ void P_ProcessSpecialSector(player_t *player, sector_t *sector, sector_t *rovers
|
||||
// The chimps are my friends.. heeheeheheehehee..... - LouisJM
|
||||
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
|
||||
{
|
||||
if (th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
|
||||
continue;
|
||||
mo2 = (mobj_t *)th;
|
||||
if (mo2->type == MT_EGGTRAP)
|
||||
P_KillMobj(mo2, NULL, player->mo);
|
||||
if (mo2->type != MT_EGGTRAP)
|
||||
continue;
|
||||
P_KillMobj(mo2, NULL, player->mo, 0);
|
||||
}
|
||||
|
||||
// clear the special so you can't push the button twice.
|
||||
@@ -4093,14 +4099,20 @@ DoneSection2:
|
||||
// to find the first waypoint
|
||||
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
|
||||
{
|
||||
if (th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
|
||||
continue;
|
||||
|
||||
mo2 = (mobj_t *)th;
|
||||
|
||||
if (mo2->type == MT_TUBEWAYPOINT && mo2->threshold == sequence
|
||||
&& mo2->health == 0)
|
||||
{
|
||||
waypoint = mo2;
|
||||
break;
|
||||
}
|
||||
if (mo2->type != MT_TUBEWAYPOINT)
|
||||
continue;
|
||||
if (mo2->threshold != sequence)
|
||||
continue;
|
||||
if (mo2->health != 0)
|
||||
continue;
|
||||
|
||||
waypoint = mo2;
|
||||
break;
|
||||
}
|
||||
|
||||
if (!waypoint)
|
||||
@@ -4166,15 +4178,20 @@ DoneSection2:
|
||||
// to find the last waypoint
|
||||
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
|
||||
{
|
||||
if (th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
|
||||
continue;
|
||||
|
||||
mo2 = (mobj_t *)th;
|
||||
|
||||
if (mo2->type == MT_TUBEWAYPOINT && mo2->threshold == sequence)
|
||||
{
|
||||
if (!waypoint)
|
||||
waypoint = mo2;
|
||||
else if (mo2->health > waypoint->health)
|
||||
waypoint = mo2;
|
||||
}
|
||||
if (mo2->type != MT_TUBEWAYPOINT)
|
||||
continue;
|
||||
if (mo2->threshold != sequence)
|
||||
continue;
|
||||
|
||||
if (!waypoint)
|
||||
waypoint = mo2;
|
||||
else if (mo2->health > waypoint->health)
|
||||
waypoint = mo2;
|
||||
}
|
||||
|
||||
if (!waypoint)
|
||||
@@ -4378,6 +4395,9 @@ DoneSection2:
|
||||
// to find the first waypoint
|
||||
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
|
||||
{
|
||||
if (th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
|
||||
continue;
|
||||
|
||||
mo2 = (mobj_t *)th;
|
||||
|
||||
if (mo2->type != MT_TUBEWAYPOINT)
|
||||
@@ -4413,6 +4433,9 @@ DoneSection2:
|
||||
// Find waypoint before this one (waypointlow)
|
||||
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
|
||||
{
|
||||
if (th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
|
||||
continue;
|
||||
|
||||
mo2 = (mobj_t *)th;
|
||||
|
||||
if (mo2->type != MT_TUBEWAYPOINT)
|
||||
@@ -4437,6 +4460,9 @@ DoneSection2:
|
||||
// Find waypoint after this one (waypointhigh)
|
||||
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
|
||||
{
|
||||
if (th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
|
||||
continue;
|
||||
|
||||
mo2 = (mobj_t *)th;
|
||||
|
||||
if (mo2->type != MT_TUBEWAYPOINT)
|
||||
|
||||
+53
-33
@@ -46,6 +46,9 @@ void Command_Numthinkers_f(void)
|
||||
INT32 count = 0;
|
||||
actionf_p1 action;
|
||||
thinker_t *think;
|
||||
thinklistnum_t start = 0;
|
||||
thinklistnum_t end = NUM_THINKERLISTS - 1;
|
||||
thinklistnum_t i;
|
||||
|
||||
if (gamestate != GS_LEVEL)
|
||||
{
|
||||
@@ -72,6 +75,7 @@ void Command_Numthinkers_f(void)
|
||||
switch (num)
|
||||
{
|
||||
case 1:
|
||||
start = end = THINK_MOBJ;
|
||||
action = (actionf_p1)P_MobjThinker;
|
||||
CONS_Printf(M_GetText("Number of %s: "), "P_MobjThinker");
|
||||
break;
|
||||
@@ -84,14 +88,17 @@ void Command_Numthinkers_f(void)
|
||||
CONS_Printf(M_GetText("Number of %s: "), "P_SnowThinker");
|
||||
break;*/
|
||||
case 2:
|
||||
start = end = THINK_PRECIP;
|
||||
action = (actionf_p1)P_NullPrecipThinker;
|
||||
CONS_Printf(M_GetText("Number of %s: "), "P_NullPrecipThinker");
|
||||
break;
|
||||
case 3:
|
||||
start = end = THINK_MAIN;
|
||||
action = (actionf_p1)T_Friction;
|
||||
CONS_Printf(M_GetText("Number of %s: "), "T_Friction");
|
||||
break;
|
||||
case 4:
|
||||
start = end = THINK_MAIN;
|
||||
action = (actionf_p1)T_Pusher;
|
||||
CONS_Printf(M_GetText("Number of %s: "), "T_Pusher");
|
||||
break;
|
||||
@@ -104,12 +111,15 @@ void Command_Numthinkers_f(void)
|
||||
return;
|
||||
}
|
||||
|
||||
for (think = thlist[THINK_MAIN].next; think != &thlist[THINK_MAIN]; think = think->next)
|
||||
for (i = start; i <= end; i++)
|
||||
{
|
||||
if (think->function.acp1 != action)
|
||||
continue;
|
||||
for (think = thlist[i].next; think != &thlist[i]; think = think->next)
|
||||
{
|
||||
if (think->function.acp1 != action)
|
||||
continue;
|
||||
|
||||
count++;
|
||||
count++;
|
||||
}
|
||||
}
|
||||
|
||||
CONS_Printf("%d\n", count);
|
||||
@@ -143,6 +153,9 @@ void Command_CountMobjs_f(void)
|
||||
|
||||
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
|
||||
{
|
||||
if (th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
|
||||
continue;
|
||||
|
||||
if (((mobj_t *)th)->type == i)
|
||||
count++;
|
||||
}
|
||||
@@ -160,6 +173,9 @@ void Command_CountMobjs_f(void)
|
||||
|
||||
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
|
||||
{
|
||||
if (th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
|
||||
continue;
|
||||
|
||||
if (((mobj_t *)th)->type == i)
|
||||
count++;
|
||||
}
|
||||
@@ -182,6 +198,10 @@ void P_InitThinkers(void)
|
||||
// Adds a new thinker at the end of the list.
|
||||
void P_AddThinker(const thinklistnum_t n, thinker_t *thinker)
|
||||
{
|
||||
#ifdef PARANOIA
|
||||
I_Assert(n >= 0 && n < NUM_THINKERLISTS);
|
||||
#endif
|
||||
|
||||
thlist[n].prev->next = thinker;
|
||||
thinker->next = &thlist[n];
|
||||
thinker->prev = thlist[n].prev;
|
||||
@@ -208,22 +228,33 @@ static thinker_t *currentthinker;
|
||||
// remove it, and set currentthinker to one node preceeding it, so
|
||||
// that the next step in P_RunThinkers() will get its successor.
|
||||
//
|
||||
void P_RemoveThinkerDelayed(void *pthinker)
|
||||
void P_RemoveThinkerDelayed(thinker_t *thinker)
|
||||
{
|
||||
thinker_t *thinker = pthinker;
|
||||
if (!thinker->references)
|
||||
thinker_t *next;
|
||||
#ifdef PARANOIA
|
||||
#define BEENAROUNDBIT (0x40000000) // has to be sufficiently high that it's unlikely to happen in regular gameplay. If you change this, pay attention to the bit pattern of INT32_MIN.
|
||||
if (thinker->references & ~BEENAROUNDBIT)
|
||||
{
|
||||
{
|
||||
/* Remove from main thinker list */
|
||||
thinker_t *next = thinker->next;
|
||||
/* Note that currentthinker is guaranteed to point to us,
|
||||
* and since we're freeing our memory, we had better change that. So
|
||||
* point it to thinker->prev, so the iterator will correctly move on to
|
||||
* thinker->prev->next = thinker->next */
|
||||
(next->prev = currentthinker = thinker->prev)->next = next;
|
||||
}
|
||||
Z_Free(thinker);
|
||||
if (thinker->references & BEENAROUNDBIT) // Usually gets cleared up in one frame; what's going on here, then?
|
||||
CONS_Printf("Number of potentially faulty references: %d\n", (thinker->references & ~BEENAROUNDBIT));
|
||||
thinker->references |= BEENAROUNDBIT;
|
||||
return;
|
||||
}
|
||||
#undef BEENAROUNDBIT
|
||||
#else
|
||||
if (thinker->references)
|
||||
return;
|
||||
#endif
|
||||
|
||||
/* Remove from main thinker list */
|
||||
next = thinker->next;
|
||||
/* Note that currentthinker is guaranteed to point to us,
|
||||
* and since we're freeing our memory, we had better change that. So
|
||||
* point it to thinker->prev, so the iterator will correctly move on to
|
||||
* thinker->prev->next = thinker->next */
|
||||
(next->prev = currentthinker = thinker->prev)->next = next;
|
||||
|
||||
Z_Free(thinker);
|
||||
}
|
||||
|
||||
//
|
||||
@@ -240,23 +271,10 @@ void P_RemoveThinkerDelayed(void *pthinker)
|
||||
//
|
||||
void P_RemoveThinker(thinker_t *thinker)
|
||||
{
|
||||
thinker_t *next = thinker->next;
|
||||
#ifdef HAVE_BLUA
|
||||
LUA_InvalidateUserdata(thinker);
|
||||
#endif
|
||||
thinker->function.acp1 = P_RemoveThinkerDelayed;
|
||||
|
||||
if (currentthinker == thinker)
|
||||
currentthinker = thinker->prev;
|
||||
|
||||
// Remove thinker from its current list.
|
||||
(next->prev = thinker->prev)->next = next;
|
||||
|
||||
// Now add it to the limbo list
|
||||
thlist[THINK_LIMBO].prev->next = thinker;
|
||||
thinker->next = &thlist[THINK_LIMBO];
|
||||
thinker->prev = thlist[THINK_LIMBO].prev;
|
||||
thlist[THINK_LIMBO].prev = thinker;
|
||||
thinker->function.acp1 = (actionf_p1)P_RemoveThinkerDelayed;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -309,8 +327,10 @@ static inline void P_RunThinkers(void)
|
||||
{
|
||||
for (currentthinker = thlist[i].next; currentthinker != &thlist[i]; currentthinker = currentthinker->next)
|
||||
{
|
||||
if (currentthinker->function.acp1)
|
||||
currentthinker->function.acp1(currentthinker);
|
||||
#ifdef PARANOIA
|
||||
I_Assert(currentthinker->function.acp1 != NULL)
|
||||
#endif
|
||||
currentthinker->function.acp1(currentthinker);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
+1
-1
@@ -27,7 +27,7 @@ void Command_CountMobjs_f(void);
|
||||
void P_Ticker(boolean run);
|
||||
void P_PreTicker(INT32 frames);
|
||||
void P_DoTeamscrambling(void);
|
||||
void P_RemoveThinkerDelayed(void *pthinker); //killed
|
||||
void P_RemoveThinkerDelayed(thinker_t *thinker); //killed
|
||||
mobj_t *P_SetTarget(mobj_t **mo, mobj_t *target); // killough 11/98
|
||||
|
||||
#endif
|
||||
+402
-151
@@ -358,9 +358,16 @@ void P_ResetScore(player_t *player)
|
||||
// to find the egg capsule with the lowest mare
|
||||
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
|
||||
{
|
||||
if (th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
|
||||
continue;
|
||||
|
||||
mo2 = (mobj_t *)th;
|
||||
|
||||
if (mo2->type == MT_EGGCAPSULE && mo2->health > 0)
|
||||
if (mo2->type != MT_EGGCAPSULE)
|
||||
continue;
|
||||
if (mo2->health <= 0)
|
||||
continue;
|
||||
|
||||
{
|
||||
const UINT8 threshold = (UINT8)mo2->threshold;
|
||||
if (mare == 255)
|
||||
@@ -456,29 +463,32 @@ UINT8 P_FindHighestLap(void)
|
||||
// to find the closest axis point
|
||||
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
|
||||
{
|
||||
if (th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
|
||||
continue;
|
||||
|
||||
mo2 = (mobj_t *)th;
|
||||
|
||||
if (mo2->type == MT_AXIS)
|
||||
{
|
||||
if (mo2->threshold == mare)
|
||||
{
|
||||
if (closestaxis == NULL)
|
||||
{
|
||||
closestaxis = mo2;
|
||||
lowestaxisnum = mo2->health;
|
||||
dist2 = R_PointToDist2(player->mo->x, player->mo->y, mo2->x, mo2->y)-mo2->radius;
|
||||
}
|
||||
else if (mo2->health < lowestaxisnum)
|
||||
{
|
||||
dist1 = R_PointToDist2(player->mo->x, player->mo->y, mo2->x, mo2->y)-mo2->radius;
|
||||
if (mo2->type != MT_AXIS)
|
||||
continue;
|
||||
|
||||
if (dist1 < dist2)
|
||||
{
|
||||
closestaxis = mo2;
|
||||
lowestaxisnum = mo2->health;
|
||||
dist2 = dist1;
|
||||
}
|
||||
}
|
||||
if (mo2->threshold != mare)
|
||||
continue;
|
||||
|
||||
if (closestaxis == NULL)
|
||||
{
|
||||
closestaxis = mo2;
|
||||
lowestaxisnum = mo2->health;
|
||||
dist2 = R_PointToDist2(player->mo->x, player->mo->y, mo2->x, mo2->y) - mo2->radius;
|
||||
}
|
||||
else if (mo2->health < lowestaxisnum)
|
||||
{
|
||||
dist1 = R_PointToDist2(player->mo->x, player->mo->y, mo2->x, mo2->y) - mo2->radius;
|
||||
|
||||
if (dist1 < dist2)
|
||||
{
|
||||
closestaxis = mo2;
|
||||
lowestaxisnum = mo2->health;
|
||||
dist2 = dist1;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -504,17 +514,22 @@ static mobj_t *P_FindAxis(INT32 mare, INT32 axisnum)
|
||||
// to find the closest axis point
|
||||
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
|
||||
{
|
||||
if (th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
|
||||
continue;
|
||||
|
||||
mo2 = (mobj_t *)th;
|
||||
|
||||
// Axis things are only at beginning of list.
|
||||
if (!(mo2->flags2 & MF2_AXIS))
|
||||
return NULL;
|
||||
|
||||
if (mo2->type == MT_AXIS)
|
||||
{
|
||||
if (mo2->health == axisnum && mo2->threshold == mare)
|
||||
return mo2;
|
||||
}
|
||||
if (mo2->type != MT_AXIS)
|
||||
continue;
|
||||
if (mo2->health != axisnum)
|
||||
continue;
|
||||
if (mo2->threshold != mare)
|
||||
continue;
|
||||
return mo2;
|
||||
}
|
||||
|
||||
return NULL;
|
||||
@@ -534,17 +549,22 @@ static mobj_t *P_FindAxisTransfer(INT32 mare, INT32 axisnum, mobjtype_t type)
|
||||
// to find the closest axis point
|
||||
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
|
||||
{
|
||||
if (th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
|
||||
continue;
|
||||
|
||||
mo2 = (mobj_t *)th;
|
||||
|
||||
// Axis things are only at beginning of list.
|
||||
if (!(mo2->flags2 & MF2_AXIS))
|
||||
return NULL;
|
||||
|
||||
if (mo2->type == type)
|
||||
{
|
||||
if (mo2->health == axisnum && mo2->threshold == mare)
|
||||
return mo2;
|
||||
}
|
||||
if (mo2->type != type)
|
||||
continue;
|
||||
if (mo2->health != axisnum)
|
||||
continue;
|
||||
if (mo2->threshold != mare)
|
||||
continue;
|
||||
return mo2;
|
||||
}
|
||||
|
||||
return NULL;
|
||||
@@ -570,27 +590,31 @@ void P_TransferToAxis(player_t *player, INT32 axisnum)
|
||||
// to find the closest axis point
|
||||
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
|
||||
{
|
||||
if (th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
|
||||
continue;
|
||||
|
||||
mo2 = (mobj_t *)th;
|
||||
|
||||
if (mo2->type == MT_AXIS)
|
||||
{
|
||||
if (mo2->health == axisnum && mo2->threshold == mare)
|
||||
{
|
||||
if (closestaxis == NULL)
|
||||
{
|
||||
closestaxis = mo2;
|
||||
dist2 = R_PointToDist2(player->mo->x, player->mo->y, mo2->x, mo2->y)-mo2->radius;
|
||||
}
|
||||
else
|
||||
{
|
||||
dist1 = R_PointToDist2(player->mo->x, player->mo->y, mo2->x, mo2->y)-mo2->radius;
|
||||
if (mo2->type != MT_AXIS)
|
||||
continue;
|
||||
if (mo2->health != axisnum)
|
||||
continue;
|
||||
if (mo2->threshold != mare)
|
||||
continue;
|
||||
|
||||
if (dist1 < dist2)
|
||||
{
|
||||
closestaxis = mo2;
|
||||
dist2 = dist1;
|
||||
}
|
||||
}
|
||||
if (closestaxis == NULL)
|
||||
{
|
||||
closestaxis = mo2;
|
||||
dist2 = R_PointToDist2(player->mo->x, player->mo->y, mo2->x, mo2->y) - mo2->radius;
|
||||
}
|
||||
else
|
||||
{
|
||||
dist1 = R_PointToDist2(player->mo->x, player->mo->y, mo2->x, mo2->y) - mo2->radius;
|
||||
|
||||
if (dist1 < dist2)
|
||||
{
|
||||
closestaxis = mo2;
|
||||
dist2 = dist1;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -666,6 +690,9 @@ static void P_DeNightserizePlayer(player_t *player)
|
||||
// Check to see if the player should be killed.
|
||||
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
|
||||
{
|
||||
if (th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
|
||||
continue;
|
||||
|
||||
mo2 = (mobj_t *)th;
|
||||
if (!(mo2->type == MT_NIGHTSDRONE))
|
||||
continue;
|
||||
@@ -1577,6 +1604,9 @@ void P_SpawnShieldOrb(player_t *player)
|
||||
// blaze through the thinkers to see if an orb already exists!
|
||||
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
|
||||
{
|
||||
if (th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
|
||||
continue;
|
||||
|
||||
shieldobj = (mobj_t *)th;
|
||||
|
||||
if (shieldobj->type == orbtype && shieldobj->target == player->mo)
|
||||
@@ -3272,7 +3302,8 @@ static void P_DoTeeter(player_t *player) // SRB2kart - unused.
|
||||
if (teeter) // only bother with objects as a last resort if you were already teetering
|
||||
{
|
||||
mobj_t *oldtmthing = tmthing;
|
||||
tmthing = teeterer = player->mo;
|
||||
teeterer = player->mo;
|
||||
P_SetTarget(&tmthing, teeterer);
|
||||
teeterxl = teeterxh = player->mo->x;
|
||||
teeteryl = teeteryh = player->mo->y;
|
||||
couldteeter = false;
|
||||
@@ -3286,7 +3317,7 @@ static void P_DoTeeter(player_t *player) // SRB2kart - unused.
|
||||
}
|
||||
teeterdone:
|
||||
teeter = solidteeter;
|
||||
tmthing = oldtmthing; // restore old tmthing, goodness knows what the game does with this before mobj thinkers
|
||||
P_SetTarget(&tmthing, oldtmthing); // restore old tmthing, goodness knows what the game does with this before mobj thinkers
|
||||
}
|
||||
}
|
||||
if (teeter)
|
||||
@@ -3599,11 +3630,177 @@ static void P_DoSpinDash(player_t *player, ticcmd_t *cmd) // SRB2kart - unused.
|
||||
#endif
|
||||
) && !(player->pflags & PF_USEDOWN) && !(player->pflags & PF_SPINNING))
|
||||
{
|
||||
player->pflags |= PF_SPINNING;
|
||||
//P_SetPlayerMobjState(player->mo, S_PLAY_ATK1);
|
||||
if (!player->spectator)
|
||||
S_StartSound(player->mo, sfx_spin);
|
||||
player->pflags |= PF_USEDOWN;
|
||||
case CA2_SPINDASH: // Spinning and Spindashing
|
||||
// Start revving
|
||||
if ((cmd->buttons & BT_USE) && player->speed < FixedMul(5<<FRACBITS, player->mo->scale)
|
||||
&& !player->mo->momz && onground && !(player->pflags & (PF_USEDOWN|PF_SPINNING))
|
||||
&& canstand)
|
||||
{
|
||||
player->mo->momx = player->cmomx;
|
||||
player->mo->momy = player->cmomy;
|
||||
player->pflags |= (PF_USEDOWN|PF_STARTDASH|PF_SPINNING);
|
||||
player->dashspeed = player->mindash;
|
||||
P_SetPlayerMobjState(player->mo, S_PLAY_SPINDASH);
|
||||
if (!player->spectator)
|
||||
S_StartSound(player->mo, sfx_s3kab); // Make the rev sound! Previously sfx_spndsh.
|
||||
}
|
||||
// Revving
|
||||
else if ((cmd->buttons & BT_USE) && (player->pflags & PF_STARTDASH))
|
||||
{
|
||||
if (player->dashspeed < player->maxdash)
|
||||
{
|
||||
#define chargecalculation (6*(player->dashspeed - player->mindash))/(player->maxdash - player->mindash)
|
||||
fixed_t soundcalculation = chargecalculation;
|
||||
player->dashspeed += FRACUNIT;
|
||||
if (!player->spectator && soundcalculation != chargecalculation)
|
||||
S_StartSound(player->mo, sfx_s3kab); // Make the rev sound! Previously sfx_spndsh.
|
||||
#undef chargecalculation
|
||||
}
|
||||
if (player->revitem && !(leveltime % 5)) // Now spawn the color thok circle.
|
||||
{
|
||||
P_SpawnSpinMobj(player, player->revitem);
|
||||
if (demorecording)
|
||||
G_GhostAddRev();
|
||||
}
|
||||
}
|
||||
|
||||
// If not moving up or down, and travelling faster than a speed of five while not holding
|
||||
// down the spin button and not spinning.
|
||||
// AKA Just go into a spin on the ground, you idiot. ;)
|
||||
else if ((cmd->buttons & BT_USE || ((twodlevel || (player->mo->flags2 & MF2_TWOD)) && cmd->forwardmove < -20))
|
||||
&& !player->climbing && !player->mo->momz && onground && (player->speed > FixedMul(5<<FRACBITS, player->mo->scale)
|
||||
|| !canstand) && !(player->pflags & (PF_USEDOWN|PF_SPINNING)))
|
||||
{
|
||||
player->pflags |= (PF_USEDOWN|PF_SPINNING);
|
||||
P_SetPlayerMobjState(player->mo, S_PLAY_ROLL);
|
||||
if (!player->spectator)
|
||||
S_StartSound(player->mo, sfx_spin);
|
||||
}
|
||||
else
|
||||
// Catapult the player from a spindash rev!
|
||||
if (onground && !(player->pflags & PF_USEDOWN) && (player->pflags & PF_STARTDASH) && (player->pflags & PF_SPINNING))
|
||||
{
|
||||
player->pflags &= ~PF_STARTDASH;
|
||||
if (player->powers[pw_carry] == CR_BRAKGOOP)
|
||||
player->dashspeed = 0;
|
||||
|
||||
if (!((gametype == GT_RACE || gametype == GT_COMPETITION) && leveltime < 4*TICRATE))
|
||||
{
|
||||
if (player->dashspeed)
|
||||
{
|
||||
P_SetPlayerMobjState(player->mo, S_PLAY_ROLL);
|
||||
P_InstaThrust(player->mo, player->mo->angle, (player->speed = FixedMul(player->dashspeed, player->mo->scale))); // catapult forward ho!!
|
||||
}
|
||||
else
|
||||
{
|
||||
P_SetPlayerMobjState(player->mo, S_PLAY_STND);
|
||||
player->pflags &= ~PF_SPINNING;
|
||||
}
|
||||
|
||||
if (!player->spectator)
|
||||
S_StartSound(player->mo, sfx_zoom);
|
||||
}
|
||||
|
||||
player->dashspeed = 0;
|
||||
}
|
||||
break;
|
||||
case CA2_GUNSLINGER:
|
||||
if (!player->mo->momz && onground && !player->weapondelay && canstand)
|
||||
{
|
||||
if (player->speed > FixedMul(10<<FRACBITS, player->mo->scale))
|
||||
{}
|
||||
else
|
||||
{
|
||||
mobj_t *lockon = P_LookForEnemies(player, false, true);
|
||||
if (lockon)
|
||||
{
|
||||
if (P_IsLocalPlayer(player)) // Only display it on your own view.
|
||||
{
|
||||
mobj_t *visual = P_SpawnMobj(lockon->x, lockon->y, lockon->z, MT_LOCKON); // positioning, flip handled in P_SceneryThinker
|
||||
P_SetTarget(&visual->target, lockon);
|
||||
}
|
||||
}
|
||||
if ((cmd->buttons & BT_USE) && !(player->pflags & PF_USEDOWN))
|
||||
{
|
||||
mobj_t *bullet;
|
||||
|
||||
P_SetPlayerMobjState(player->mo, S_PLAY_FIRE);
|
||||
|
||||
#define zpos(posmo) (posmo->z + (posmo->height - mobjinfo[player->revitem].height)/2)
|
||||
if (lockon)
|
||||
{
|
||||
player->mo->angle = R_PointToAngle2(player->mo->x, player->mo->y, lockon->x, lockon->y);
|
||||
bullet = P_SpawnPointMissile(player->mo, lockon->x, lockon->y, zpos(lockon), player->revitem, player->mo->x, player->mo->y, zpos(player->mo));
|
||||
if (!demoplayback || P_AnalogMove(player))
|
||||
{
|
||||
if (player == &players[consoleplayer])
|
||||
localangle = player->mo->angle;
|
||||
else if (player == &players[secondarydisplayplayer])
|
||||
localangle2 = player->mo->angle;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
bullet = P_SpawnPointMissile(player->mo, player->mo->x + P_ReturnThrustX(NULL, player->mo->angle, FRACUNIT), player->mo->y + P_ReturnThrustY(NULL, player->mo->angle, FRACUNIT), zpos(player->mo), player->revitem, player->mo->x, player->mo->y, zpos(player->mo));
|
||||
if (bullet)
|
||||
{
|
||||
bullet->flags &= ~MF_NOGRAVITY;
|
||||
bullet->momx >>= 1;
|
||||
bullet->momy >>= 1;
|
||||
}
|
||||
}
|
||||
player->drawangle = player->mo->angle;
|
||||
#undef zpos
|
||||
|
||||
P_SetTarget(&player->mo->tracer, NULL);
|
||||
player->mo->momx >>= 1;
|
||||
player->mo->momy >>= 1;
|
||||
player->pflags |= PF_USEDOWN;
|
||||
P_SetWeaponDelay(player, TICRATE/2);
|
||||
}
|
||||
}
|
||||
}
|
||||
break;
|
||||
case CA2_MELEE: // Melee attack
|
||||
if (player->panim != PA_ABILITY2 && (cmd->buttons & BT_USE)
|
||||
&& !player->mo->momz && onground && !(player->pflags & PF_USEDOWN)
|
||||
&& canstand)
|
||||
{
|
||||
P_ResetPlayer(player);
|
||||
player->pflags |= PF_THOKKED;
|
||||
#if 0
|
||||
if ((player->charability == CA_TWINSPIN) && (player->speed > FixedMul(player->runspeed, player->mo->scale)))
|
||||
{
|
||||
P_DoJump(player, false);
|
||||
player->pflags &= ~PF_STARTJUMP;
|
||||
player->mo->momz = FixedMul(player->mo->momz, 3*FRACUNIT/2); // NOT 1.5 times the jump height, but 2.25 times.
|
||||
P_SetPlayerMobjState(player->mo, S_PLAY_TWINSPIN);
|
||||
S_StartSound(player->mo, sfx_s3k8b);
|
||||
}
|
||||
else
|
||||
#endif
|
||||
{
|
||||
player->mo->z += P_MobjFlip(player->mo);
|
||||
P_SetObjectMomZ(player->mo, player->mindash, false);
|
||||
if (player->mo->eflags & MFE_UNDERWATER)
|
||||
player->mo->momz >>= 1;
|
||||
#if 0
|
||||
if (FixedMul(player->speed, FINECOSINE(((player->mo->angle - R_PointToAngle2(0, 0, player->rmomx, player->rmomy)) >> ANGLETOFINESHIFT) & FINEMASK)) < FixedMul(player->maxdash, player->mo->scale))
|
||||
#else
|
||||
if (player->speed < FixedMul(player->maxdash, player->mo->scale))
|
||||
#endif
|
||||
{
|
||||
player->drawangle = player->mo->angle;
|
||||
P_InstaThrust(player->mo, player->mo->angle, FixedMul(player->maxdash, player->mo->scale));
|
||||
}
|
||||
player->mo->momx += player->cmomx;
|
||||
player->mo->momy += player->cmomy;
|
||||
P_SetPlayerMobjState(player->mo, S_PLAY_MELEE);
|
||||
S_StartSound(player->mo, sfx_s3k42);
|
||||
}
|
||||
player->pflags |= PF_USEDOWN;
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -3687,6 +3884,9 @@ void P_Telekinesis(player_t *player, fixed_t thrust, fixed_t range)
|
||||
|
||||
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
|
||||
{
|
||||
if (th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
|
||||
continue;
|
||||
|
||||
mo2 = (mobj_t *)th;
|
||||
|
||||
if (mo2 == player->mo)
|
||||
@@ -4366,29 +4566,32 @@ static void P_NightsTransferPoints(player_t *player, fixed_t xspeed, fixed_t rad
|
||||
// Find next waypoint
|
||||
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
|
||||
{
|
||||
if (th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
|
||||
continue;
|
||||
|
||||
mo2 = (mobj_t *)th;
|
||||
|
||||
// Axis things are only at beginning of list.
|
||||
if (!(mo2->flags2 & MF2_AXIS))
|
||||
break;
|
||||
if (!(mo2->type == MT_AXISTRANSFER || mo2->type == MT_AXISTRANSFERLINE))
|
||||
continue;
|
||||
if (mo2->threshold != sequence)
|
||||
continue;
|
||||
|
||||
if ((mo2->type == MT_AXISTRANSFER || mo2->type == MT_AXISTRANSFERLINE)
|
||||
&& mo2->threshold == sequence)
|
||||
if (player->pflags & PF_TRANSFERTOCLOSEST)
|
||||
{
|
||||
if (player->pflags & PF_TRANSFERTOCLOSEST)
|
||||
{
|
||||
if (mo2->health == player->axis1->health)
|
||||
transfer1 = mo2;
|
||||
else if (mo2->health == player->axis2->health)
|
||||
transfer2 = mo2;
|
||||
}
|
||||
else
|
||||
{
|
||||
if (mo2->health == player->mo->target->health)
|
||||
transfer1 = mo2;
|
||||
else if (mo2->health == player->mo->target->health + 1)
|
||||
transfer2 = mo2;
|
||||
}
|
||||
if (mo2->health == player->axis1->health)
|
||||
transfer1 = mo2;
|
||||
else if (mo2->health == player->axis2->health)
|
||||
transfer2 = mo2;
|
||||
}
|
||||
else
|
||||
{
|
||||
if (mo2->health == player->mo->target->health)
|
||||
transfer1 = mo2;
|
||||
else if (mo2->health == player->mo->target->health + 1)
|
||||
transfer2 = mo2;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -4399,24 +4602,28 @@ static void P_NightsTransferPoints(player_t *player, fixed_t xspeed, fixed_t rad
|
||||
{
|
||||
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
|
||||
{
|
||||
if (th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
|
||||
continue;
|
||||
|
||||
mo2 = (mobj_t *)th;
|
||||
|
||||
// Axis things are only at beginning of list.
|
||||
if (!(mo2->flags2 & MF2_AXIS))
|
||||
break;
|
||||
if (!(mo2->type == MT_AXISTRANSFER || mo2->type == MT_AXISTRANSFERLINE))
|
||||
continue;
|
||||
if (mo2->threshold != sequence)
|
||||
continue;
|
||||
|
||||
if (mo2->threshold == sequence && (mo2->type == MT_AXISTRANSFER || mo2->type == MT_AXISTRANSFERLINE))
|
||||
if (!transfer1)
|
||||
{
|
||||
if (!transfer1)
|
||||
{
|
||||
transfer1 = mo2;
|
||||
transfer1last = true;
|
||||
}
|
||||
else if (mo2->health > transfer1->health)
|
||||
{
|
||||
transfer1 = mo2;
|
||||
transfer1last = true;
|
||||
}
|
||||
transfer1 = mo2;
|
||||
transfer1last = true;
|
||||
}
|
||||
else if (mo2->health > transfer1->health)
|
||||
{
|
||||
transfer1 = mo2;
|
||||
transfer1last = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -4424,24 +4631,28 @@ static void P_NightsTransferPoints(player_t *player, fixed_t xspeed, fixed_t rad
|
||||
{
|
||||
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
|
||||
{
|
||||
if (th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
|
||||
continue;
|
||||
|
||||
mo2 = (mobj_t *)th;
|
||||
|
||||
// Axis things are only at beginning of list.
|
||||
if (!(mo2->flags2 & MF2_AXIS))
|
||||
break;
|
||||
if (!(mo2->type == MT_AXISTRANSFER || mo2->type == MT_AXISTRANSFERLINE))
|
||||
continue;
|
||||
if (mo2->threshold != sequence)
|
||||
continue;
|
||||
|
||||
if (mo2->threshold == sequence && (mo2->type == MT_AXISTRANSFER || mo2->type == MT_AXISTRANSFERLINE))
|
||||
if (!transfer2)
|
||||
{
|
||||
if (!transfer2)
|
||||
{
|
||||
transfer2 = mo2;
|
||||
transfer2last = true;
|
||||
}
|
||||
else if (mo2->health > transfer2->health)
|
||||
{
|
||||
transfer2 = mo2;
|
||||
transfer2last = true;
|
||||
}
|
||||
transfer2 = mo2;
|
||||
transfer2last = true;
|
||||
}
|
||||
else if (mo2->health > transfer2->health)
|
||||
{
|
||||
transfer2 = mo2;
|
||||
transfer2last = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -4968,31 +5179,32 @@ static void P_NiGHTSMovement(player_t *player)
|
||||
// to find the closest axis point
|
||||
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
|
||||
{
|
||||
if (th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
|
||||
continue;
|
||||
|
||||
mo2 = (mobj_t *)th;
|
||||
|
||||
if (mo2->type == MT_AXIS)
|
||||
{
|
||||
if (mo2->threshold == player->mare)
|
||||
{
|
||||
if (closestaxis == NULL)
|
||||
{
|
||||
closestaxis = mo2;
|
||||
dist2 = R_PointToDist2(newx, newy, mo2->x, mo2->y)-mo2->radius;
|
||||
}
|
||||
else
|
||||
{
|
||||
dist1 = R_PointToDist2(newx, newy, mo2->x, mo2->y)-mo2->radius;
|
||||
if (mo2->type != MT_AXIS)
|
||||
continue;
|
||||
if (mo2->threshold != player->mare)
|
||||
continue;
|
||||
|
||||
if (dist1 < dist2)
|
||||
{
|
||||
closestaxis = mo2;
|
||||
dist2 = dist1;
|
||||
}
|
||||
}
|
||||
if (closestaxis == NULL)
|
||||
{
|
||||
closestaxis = mo2;
|
||||
dist2 = R_PointToDist2(newx, newy, mo2->x, mo2->y) - mo2->radius;
|
||||
}
|
||||
else
|
||||
{
|
||||
dist1 = R_PointToDist2(newx, newy, mo2->x, mo2->y) - mo2->radius;
|
||||
|
||||
if (dist1 < dist2)
|
||||
{
|
||||
closestaxis = mo2;
|
||||
dist2 = dist1;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
P_SetTarget(&player->mo->target, closestaxis);
|
||||
}
|
||||
|
||||
@@ -5684,6 +5896,9 @@ static void P_MovePlayer(player_t *player)
|
||||
|
||||
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
|
||||
{
|
||||
if (th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
|
||||
continue;
|
||||
|
||||
mo2 = (mobj_t *)th;
|
||||
|
||||
if (mo2->type == MT_EGGCAPSULE
|
||||
@@ -6240,7 +6455,20 @@ static void P_MovePlayer(player_t *player)
|
||||
/* // SRB2kart - what's a shield? Never heard of it. Never happened. Nope.
|
||||
if (cmd->buttons & BT_BRAKE) // Spin button effects
|
||||
{
|
||||
if (player->pflags & PF_JUMPED) // If the player is jumping
|
||||
mobj_t *lockon = NULL;
|
||||
if (!player->powers[pw_super] && player->powers[pw_shield] == SH_ATTRACT && !(player->pflags & PF_THOKKED))
|
||||
{
|
||||
if ((lockon = P_LookForEnemies(player, false, false)))
|
||||
{
|
||||
if (P_IsLocalPlayer(player)) // Only display it on your own view.
|
||||
{
|
||||
mobj_t *visual = P_SpawnMobj(lockon->x, lockon->y, lockon->z, MT_LOCKON); // positioning, flip handled in P_SceneryThinker
|
||||
P_SetTarget(&visual->target, lockon);
|
||||
P_SetMobjStateNF(visual, visual->info->spawnstate+1);
|
||||
}
|
||||
}
|
||||
}
|
||||
if (cmd->buttons & BT_USE) // Spin button effects
|
||||
{
|
||||
if (!(player->pflags & PF_USEDOWN)) // If the player is not holding down BT_BRAKE
|
||||
{
|
||||
@@ -6498,20 +6726,25 @@ static void P_DoZoomTube(player_t *player)
|
||||
// Find next waypoint
|
||||
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
|
||||
{
|
||||
if (th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
|
||||
continue;
|
||||
|
||||
mo2 = (mobj_t *)th;
|
||||
|
||||
if (mo2->type != MT_TUBEWAYPOINT)
|
||||
continue;
|
||||
|
||||
if (mo2->threshold == sequence)
|
||||
{
|
||||
if ((reverse && mo2->health == player->mo->tracer->health - 1)
|
||||
|| (!reverse && mo2->health == player->mo->tracer->health + 1))
|
||||
{
|
||||
waypoint = mo2;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (mo2->threshold != sequence)
|
||||
continue;
|
||||
|
||||
if (reverse && mo2->health != player->mo->tracer->health - 1)
|
||||
continue;
|
||||
|
||||
if (!reverse && mo2->health != player->mo->tracer->health + 1)
|
||||
continue;
|
||||
|
||||
waypoint = mo2;
|
||||
break;
|
||||
}
|
||||
|
||||
if (waypoint)
|
||||
@@ -6637,19 +6870,22 @@ static void P_DoRopeHang(player_t *player) // SRB2kart - unused.
|
||||
// Find next waypoint
|
||||
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
|
||||
{
|
||||
if (th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
|
||||
continue;
|
||||
|
||||
mo2 = (mobj_t *)th;
|
||||
|
||||
if (mo2->type != MT_TUBEWAYPOINT)
|
||||
continue;
|
||||
|
||||
if (mo2->threshold == sequence)
|
||||
{
|
||||
if (mo2->health == player->mo->tracer->health + 1)
|
||||
{
|
||||
waypoint = mo2;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (mo2->threshold != sequence)
|
||||
continue;
|
||||
|
||||
if (mo2->health != player->mo->tracer->health + 1)
|
||||
continue;
|
||||
|
||||
waypoint = mo2;
|
||||
break;
|
||||
}
|
||||
|
||||
if (!(player->mo->tracer->flags & MF_SLIDEME) && !waypoint)
|
||||
@@ -6659,19 +6895,22 @@ static void P_DoRopeHang(player_t *player) // SRB2kart - unused.
|
||||
// Wrap around back to first waypoint
|
||||
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
|
||||
{
|
||||
if (th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
|
||||
continue;
|
||||
|
||||
mo2 = (mobj_t *)th;
|
||||
|
||||
if (mo2->type != MT_TUBEWAYPOINT)
|
||||
continue;
|
||||
|
||||
if (mo2->threshold == sequence)
|
||||
{
|
||||
if (mo2->health == 0)
|
||||
{
|
||||
waypoint = mo2;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (mo2->threshold != sequence)
|
||||
continue;
|
||||
|
||||
if (mo2->health != 0)
|
||||
continue;
|
||||
|
||||
waypoint = mo2;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -6722,22 +6961,22 @@ static void P_DoRopeHang(player_t *player) // SRB2kart - unused.
|
||||
static void P_NukeAllPlayers(player_t *player)
|
||||
{
|
||||
mobj_t *mo;
|
||||
thinker_t *think;
|
||||
UINT8 i;
|
||||
|
||||
for (think = thlist[THINK_MOBJ].next; think != &thlist[THINK_MOBJ]; think = think->next)
|
||||
for (i = 0; i < MAXPLAYERS; i++)
|
||||
{
|
||||
mo = (mobj_t *)think;
|
||||
|
||||
if (!mo->player)
|
||||
if (!playeringame[i])
|
||||
continue;
|
||||
if (players[i].spectator)
|
||||
continue;
|
||||
if (!players[i].mo)
|
||||
continue;
|
||||
if (players[i].mo == player->mo)
|
||||
continue;
|
||||
if (players[i].mo->health <= 0)
|
||||
continue;
|
||||
|
||||
if (mo->health <= 0) // dead
|
||||
continue;
|
||||
|
||||
if (mo == player->mo)
|
||||
continue;
|
||||
|
||||
P_DamageMobj(mo, player->mo, player->mo, 1);
|
||||
P_DamageMobj(players[i].mo, player->mo, player->mo, 1, 0);
|
||||
}
|
||||
|
||||
CONS_Printf(M_GetText("%s caused a world of pain.\n"), player_names[player-players]);
|
||||
@@ -6773,6 +7012,9 @@ void P_NukeEnemies(mobj_t *inflictor, mobj_t *source, fixed_t radius)
|
||||
|
||||
for (think = thlist[THINK_MOBJ].next; think != &thlist[THINK_MOBJ]; think = think->next)
|
||||
{
|
||||
if (think->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
|
||||
continue;
|
||||
|
||||
mo = (mobj_t *)think;
|
||||
|
||||
if (!(mo->flags & MF_SHOOTABLE) && !(mo->type == MT_EGGGUARD || mo->type == MT_MINUS
|
||||
@@ -6850,6 +7092,9 @@ boolean P_LookForEnemies(player_t *player)
|
||||
|
||||
for (think = thlist[THINK_MOBJ].next; think != &thlist[THINK_MOBJ]; think = think->next)
|
||||
{
|
||||
if (think->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
|
||||
continue;
|
||||
|
||||
mo = (mobj_t *)think;
|
||||
if (!(mo->flags & (MF_ENEMY|MF_BOSS|MF_MONITOR|MF_SPRING)))
|
||||
continue; // not a valid enemy
|
||||
@@ -6972,6 +7217,9 @@ void P_FindEmerald(void)
|
||||
// to find all emeralds
|
||||
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
|
||||
{
|
||||
if (th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
|
||||
continue;
|
||||
|
||||
mo2 = (mobj_t *)th;
|
||||
if (mo2->type == MT_EMERHUNT)
|
||||
{
|
||||
@@ -8297,6 +8545,9 @@ void P_PlayerThink(player_t *player)
|
||||
|
||||
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
|
||||
{
|
||||
if (th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
|
||||
continue;
|
||||
|
||||
mo2 = (mobj_t *)th;
|
||||
|
||||
if (!(mo2->type == MT_NIGHTSWING || mo2->type == MT_RING || mo2->type == MT_COIN
|
||||
|
||||
+2
-1
@@ -1654,7 +1654,8 @@ void R_PrecacheLevel(void)
|
||||
if (spritepresent == NULL) I_Error("%s: Out of memory looking up sprites", "R_PrecacheLevel");
|
||||
|
||||
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
|
||||
spritepresent[((mobj_t *)th)->sprite] = 1;
|
||||
if (th->function.acp1 != (actionf_p1)P_RemoveThinkerDelayed)
|
||||
spritepresent[((mobj_t *)th)->sprite] = 1;
|
||||
|
||||
spritememory = 0;
|
||||
for (i = 0; i < numsprites; i++)
|
||||
|
||||
+17
-13
@@ -1764,27 +1764,31 @@ static void ST_doItemFinderIconsAndSound(void) // SRB2kart - unused.
|
||||
// Scan thinkers to find emblem mobj with these ids
|
||||
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
|
||||
{
|
||||
if (th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
|
||||
continue;
|
||||
|
||||
mo2 = (mobj_t *)th;
|
||||
|
||||
if (mo2->type == MT_EMBLEM)
|
||||
if (mo2->type != MT_EMBLEM)
|
||||
continue;
|
||||
|
||||
if (!(mo2->flags & MF_SPECIAL))
|
||||
continue;
|
||||
|
||||
for (i = 0; i < stemblems; ++i)
|
||||
{
|
||||
if (!(mo2->flags & MF_SPECIAL))
|
||||
continue;
|
||||
|
||||
for (i = 0; i < stemblems; ++i)
|
||||
if (mo2->health == emblems[i] + 1)
|
||||
{
|
||||
if (mo2->health == emblems[i]+1)
|
||||
{
|
||||
soffset = (i * 20) - ((stemblems-1) * 10);
|
||||
soffset = (i * 20) - ((stemblems - 1) * 10);
|
||||
|
||||
newinterval = ST_drawEmeraldHuntIcon(mo2, itemhoming, soffset);
|
||||
if (newinterval && (!interval || newinterval < interval))
|
||||
interval = newinterval;
|
||||
newinterval = ST_drawEmeraldHuntIcon(mo2, itemhoming, soffset);
|
||||
if (newinterval && (!interval || newinterval < interval))
|
||||
interval = newinterval;
|
||||
|
||||
break;
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
if (!(P_AutoPause() || paused) && interval > 0 && leveltime && leveltime % interval == 0)
|
||||
|
||||
Reference in new issue
Block a user