From 3b971835eea4f4787d0c040ae78080d10c1672c2 Mon Sep 17 00:00:00 2001 From: MascaraSnake Date: Sun, 31 Jul 2022 12:04:42 +0200 Subject: [PATCH] Add Lua backwards compatibility for FOF flags --- src/deh_tables.c | 111 ++++++--- src/hardware/hw_main.c | 74 +++--- src/k_bot.c | 2 +- src/k_botsearch.c | 4 +- src/k_kart.c | 16 +- src/lua_maplib.c | 178 ++++++++++++++- src/objects/orbinaut.c | 2 +- src/p_enemy.c | 2 +- src/p_floor.c | 28 +-- src/p_map.c | 50 ++--- src/p_maputl.c | 24 +- src/p_mobj.c | 86 +++---- src/p_saveg.c | 8 +- src/p_setup.c | 72 +++--- src/p_sight.c | 18 +- src/p_spec.c | 500 ++++++++++++++++++++--------------------- src/p_spec.h | 4 +- src/p_user.c | 182 +++++++-------- src/r_bsp.c | 32 +-- src/r_defs.h | 82 +++---- src/r_draw8.c | 2 +- src/r_plane.c | 12 +- src/r_segs.c | 98 ++++---- src/r_things.c | 6 +- 24 files changed, 890 insertions(+), 703 deletions(-) diff --git a/src/deh_tables.c b/src/deh_tables.c index 06842cf28..6a799d277 100644 --- a/src/deh_tables.c +++ b/src/deh_tables.c @@ -6447,42 +6447,81 @@ struct int_const_s const INT_CONST[] = { {"SKSKPOWR",SKSKPOWR}, // Power item taunt // 3D Floor/Fake Floor/FOF/whatever flags - {"FF_EXISTS",FF_EXISTS}, ///< Always set, to check for validity. - {"FF_BLOCKPLAYER",FF_BLOCKPLAYER}, ///< Solid to player, but nothing else - {"FF_BLOCKOTHERS",FF_BLOCKOTHERS}, ///< Solid to everything but player - {"FF_SOLID",FF_SOLID}, ///< Clips things. - {"FF_RENDERSIDES",FF_RENDERSIDES}, ///< Renders the sides. - {"FF_RENDERPLANES",FF_RENDERPLANES}, ///< Renders the floor/ceiling. - {"FF_RENDERALL",FF_RENDERALL}, ///< Renders everything. - {"FF_SWIMMABLE",FF_SWIMMABLE}, ///< Is a water block. - {"FF_NOSHADE",FF_NOSHADE}, ///< Messes with the lighting? - {"FF_CUTSOLIDS",FF_CUTSOLIDS}, ///< Cuts out hidden solid pixels. - {"FF_CUTEXTRA",FF_CUTEXTRA}, ///< Cuts out hidden translucent pixels. - {"FF_CUTLEVEL",FF_CUTLEVEL}, ///< Cuts out all hidden pixels. - {"FF_CUTSPRITES",FF_CUTSPRITES}, ///< Final step in making 3D water. - {"FF_BOTHPLANES",FF_BOTHPLANES}, ///< Render inside and outside planes. - {"FF_EXTRA",FF_EXTRA}, ///< Gets cut by ::FF_CUTEXTRA. - {"FF_TRANSLUCENT",FF_TRANSLUCENT}, ///< See through! - {"FF_FOG",FF_FOG}, ///< Fog "brush." - {"FF_INVERTPLANES",FF_INVERTPLANES}, ///< Only render inside planes. - {"FF_ALLSIDES",FF_ALLSIDES}, ///< Render inside and outside sides. - {"FF_INVERTSIDES",FF_INVERTSIDES}, ///< Only render inside sides. - {"FF_DOUBLESHADOW",FF_DOUBLESHADOW}, ///< Make two lightlist entries to reset light? - {"FF_FLOATBOB",FF_FLOATBOB}, ///< Floats on water and bobs if you step on it. - {"FF_NORETURN",FF_NORETURN}, ///< Used with ::FF_CRUMBLE. Will not return to its original position after falling. - {"FF_CRUMBLE",FF_CRUMBLE}, ///< Falls 2 seconds after being stepped on, and randomly brings all touching crumbling 3dfloors down with it, providing their master sectors share the same tag (allows crumble platforms above or below, to also exist). - {"FF_GOOWATER",FF_GOOWATER}, ///< Used with ::FF_SWIMMABLE. Makes thick bouncey goop. - {"FF_MARIO",FF_MARIO}, ///< Acts like a question block when hit from underneath. Goodie spawned at top is determined by master sector. - {"FF_BUSTUP",FF_BUSTUP}, ///< You can spin through/punch this block and it will crumble! - {"FF_QUICKSAND",FF_QUICKSAND}, ///< Quicksand! - {"FF_PLATFORM",FF_PLATFORM}, ///< You can jump up through this to the top. - {"FF_REVERSEPLATFORM",FF_REVERSEPLATFORM}, ///< A fall-through floor in normal gravity, a platform in reverse gravity. - {"FF_INTANGIBLEFLATS",FF_INTANGIBLEFLATS}, ///< Both flats are intangible, but the sides are still solid. - {"FF_INTANGABLEFLATS",FF_INTANGIBLEFLATS}, ///< Both flats are intangable, but the sides are still solid. - {"FF_RIPPLE",FF_RIPPLE}, ///< Ripple the flats - {"FF_COLORMAPONLY",FF_COLORMAPONLY}, ///< Only copy the colormap, not the lightlevel - {"FF_BOUNCY",FF_BOUNCY}, ///< Bounces players - {"FF_SPLAT",FF_SPLAT}, ///< Use splat flat renderer (treat cyan pixels as invisible) + {"FOF_EXISTS",FOF_EXISTS}, ///< Always set, to check for validity. + {"FOF_BLOCKPLAYER",FOF_BLOCKPLAYER}, ///< Solid to player, but nothing else + {"FOF_BLOCKOTHERS",FOF_BLOCKOTHERS}, ///< Solid to everything but player + {"FOF_SOLID",FOF_SOLID}, ///< Clips things. + {"FOF_RENDERSIDES",FOF_RENDERSIDES}, ///< Renders the sides. + {"FOF_RENDERPLANES",FOF_RENDERPLANES}, ///< Renders the floor/ceiling. + {"FOF_RENDERALL",FOF_RENDERALL}, ///< Renders everything. + {"FOF_SWIMMABLE",FOF_SWIMMABLE}, ///< Is a water block. + {"FOF_NOSHADE",FOF_NOSHADE}, ///< Messes with the lighting? + {"FOF_CUTSOLIDS",FOF_CUTSOLIDS}, ///< Cuts out hidden solid pixels. + {"FOF_CUTEXTRA",FOF_CUTEXTRA}, ///< Cuts out hidden translucent pixels. + {"FOF_CUTLEVEL",FOF_CUTLEVEL}, ///< Cuts out all hidden pixels. + {"FOF_CUTSPRITES",FOF_CUTSPRITES}, ///< Final step in making 3D water. + {"FOF_BOTHPLANES",FOF_BOTHPLANES}, ///< Render inside and outside planes. + {"FOF_EXTRA",FOF_EXTRA}, ///< Gets cut by ::FOF_CUTEXTRA. + {"FOF_TRANSLUCENT",FOF_TRANSLUCENT}, ///< See through! + {"FOF_FOG",FOF_FOG}, ///< Fog "brush." + {"FOF_INVERTPLANES",FOF_INVERTPLANES}, ///< Only render inside planes. + {"FOF_ALLSIDES",FOF_ALLSIDES}, ///< Render inside and outside sides. + {"FOF_INVERTSIDES",FOF_INVERTSIDES}, ///< Only render inside sides. + {"FOF_DOUBLESHADOW",FOF_DOUBLESHADOW}, ///< Make two lightlist entries to reset light? + {"FOF_FLOATBOB",FOF_FLOATBOB}, ///< Floats on water and bobs if you step on it. + {"FOF_NORETURN",FOF_NORETURN}, ///< Used with ::FOF_CRUMBLE. Will not return to its original position after falling. + {"FOF_CRUMBLE",FOF_CRUMBLE}, ///< Falls 2 seconds after being stepped on, and randomly brings all touching crumbling 3dfloors down with it, providing their master sectors share the same tag (allows crumble platforms above or below, to also exist). + {"FOF_GOOWATER",FOF_GOOWATER}, ///< Used with ::FOF_SWIMMABLE. Makes thick bouncey goop. + {"FOF_MARIO",FOF_MARIO}, ///< Acts like a question block when hit from underneath. Goodie spawned at top is determined by master sector. + {"FOF_BUSTUP",FOF_BUSTUP}, ///< You can spin through/punch this block and it will crumble! + {"FOF_QUICKSAND",FOF_QUICKSAND}, ///< Quicksand! + {"FOF_PLATFORM",FOF_PLATFORM}, ///< You can jump up through this to the top. + {"FOF_REVERSEPLATFORM",FOF_REVERSEPLATFORM}, ///< A fall-through floor in normal gravity, a platform in reverse gravity. + {"FOF_INTANGIBLEFLATS",FOF_INTANGIBLEFLATS}, ///< Both flats are intangible, but the sides are still solid. + {"FOF_RIPPLE",FOF_RIPPLE}, ///< Ripple the flats + {"FOF_COLORMAPONLY",FOF_COLORMAPONLY}, ///< Only copy the colormap, not the lightlevel + {"FOF_BOUNCY",FOF_BOUNCY}, ///< Bounces players + {"FOF_SPLAT",FOF_SPLAT}, ///< Use splat flat renderer (treat cyan pixels as invisible) + + // Old FOF flags for backwards compatibility + {"FF_EXISTS",FF_OLD_EXISTS}, + {"FF_BLOCKPLAYER",FF_OLD_BLOCKPLAYER}, + {"FF_BLOCKOTHERS",FF_OLD_BLOCKOTHERS}, + {"FF_SOLID",FF_OLD_SOLID}, + {"FF_RENDERSIDES",FF_OLD_RENDERSIDES}, + {"FF_RENDERPLANES",FF_OLD_RENDERPLANES}, + {"FF_RENDERALL",FF_OLD_RENDERALL}, + {"FF_SWIMMABLE",FF_OLD_SWIMMABLE}, + {"FF_NOSHADE",FF_OLD_NOSHADE}, + {"FF_CUTSOLIDS",FF_OLD_CUTSOLIDS}, + {"FF_CUTEXTRA",FF_OLD_CUTEXTRA}, + {"FF_CUTLEVEL",FF_OLD_CUTLEVEL}, + {"FF_CUTSPRITES",FF_OLD_CUTSPRITES}, + {"FF_BOTHPLANES",FF_OLD_BOTHPLANES}, + {"FF_EXTRA",FF_OLD_EXTRA}, + {"FF_TRANSLUCENT",FF_OLD_TRANSLUCENT}, + {"FF_FOG",FF_OLD_FOG}, + {"FF_INVERTPLANES",FF_OLD_INVERTPLANES}, + {"FF_ALLSIDES",FF_OLD_ALLSIDES}, + {"FF_INVERTSIDES",FF_OLD_INVERTSIDES}, + {"FF_DOUBLESHADOW",FF_OLD_DOUBLESHADOW}, + {"FF_FLOATBOB",FF_OLD_FLOATBOB}, + {"FF_NORETURN",FF_OLD_NORETURN}, + {"FF_CRUMBLE",FF_OLD_CRUMBLE}, + {"FF_SHATTERBOTTOM",FF_OLD_SHATTERBOTTOM}, + {"FF_GOOWATER",FF_OLD_GOOWATER}, + {"FF_MARIO",FF_OLD_MARIO}, + {"FF_BUSTUP",FF_OLD_BUSTUP}, + {"FF_QUICKSAND",FF_OLD_QUICKSAND}, + {"FF_PLATFORM",FF_OLD_PLATFORM}, + {"FF_REVERSEPLATFORM",FF_OLD_REVERSEPLATFORM}, + {"FF_INTANGIBLEFLATS",FF_OLD_INTANGIBLEFLATS}, + {"FF_INTANGABLEFLATS",FF_OLD_INTANGIBLEFLATS}, + {"FF_SHATTER",FF_OLD_SHATTER}, + {"FF_SPINBUST",FF_OLD_SPINBUST}, + {"FF_STRONGBUST",FF_OLD_STRONGBUST}, + {"FF_RIPPLE",FF_OLD_RIPPLE}, + {"FF_COLORMAPONLY",FF_OLD_COLORMAPONLY}, // FOF bustable flags {"FB_PUSHABLES",FB_PUSHABLES}, diff --git a/src/hardware/hw_main.c b/src/hardware/hw_main.c index e1fd97cd1..c86635319 100644 --- a/src/hardware/hw_main.c +++ b/src/hardware/hw_main.c @@ -839,9 +839,9 @@ static void HWR_SplitWall(sector_t *sector, FOutVector *wallVerts, INT32 texnum, if (endtop < endrealbot && top < realbot) return; - if (!(list[i].flags & FF_NOSHADE)) + if (!(list[i].flags & FOF_NOSHADE)) { - if (pfloor && (pfloor->flags & FF_FOG)) + if (pfloor && (pfloor->fofflags & FOF_FOG)) { lightnum = pfloor->master->frontsector->lightlevel; colormap = pfloor->master->frontsector->extra_colormap; @@ -855,13 +855,13 @@ static void HWR_SplitWall(sector_t *sector, FOutVector *wallVerts, INT32 texnum, solid = false; - if ((sector->lightlist[i].flags & FF_CUTSOLIDS) && !(cutflag & FF_EXTRA)) + if ((sector->lightlist[i].flags & FOF_CUTSOLIDS) && !(cutflag & FOF_EXTRA)) solid = true; - else if ((sector->lightlist[i].flags & FF_CUTEXTRA) && (cutflag & FF_EXTRA)) + else if ((sector->lightlist[i].flags & FOF_CUTEXTRA) && (cutflag & FOF_EXTRA)) { - if (sector->lightlist[i].flags & FF_EXTRA) + if (sector->lightlist[i].flags & FOF_EXTRA) { - if ((sector->lightlist[i].flags & (FF_FOG|FF_SWIMMABLE)) == (cutflag & (FF_FOG|FF_SWIMMABLE))) // Only merge with your own types + if ((sector->lightlist[i].flags & (FOF_FOG|FOF_SWIMMABLE)) == (cutflag & (FOF_FOG|FOF_SWIMMABLE))) // Only merge with your own types solid = true; } else @@ -1150,7 +1150,7 @@ static void HWR_ProcessSeg(void) // Sort of like GLWall::Process in GZDoom polyflags = PF_Environment; if (gl_frontsector->numlights) - HWR_SplitWall(gl_frontsector, wallVerts, gl_toptexture, &Surf, FF_CUTLEVEL, NULL, polyflags); + HWR_SplitWall(gl_frontsector, wallVerts, gl_toptexture, &Surf, FOF_CUTLEVEL, NULL, polyflags); else if (grTex->mipmap.flags & TF_TRANSPARENT) HWR_AddTransparentWall(wallVerts, &Surf, gl_toptexture, polyflags, false, lightnum, colormap); else @@ -1223,7 +1223,7 @@ static void HWR_ProcessSeg(void) // Sort of like GLWall::Process in GZDoom polyflags = PF_Environment; if (gl_frontsector->numlights) - HWR_SplitWall(gl_frontsector, wallVerts, gl_bottomtexture, &Surf, FF_CUTLEVEL, NULL, polyflags); + HWR_SplitWall(gl_frontsector, wallVerts, gl_bottomtexture, &Surf, FOF_CUTLEVEL, NULL, polyflags); else if (grTex->mipmap.flags & TF_TRANSPARENT) HWR_AddTransparentWall(wallVerts, &Surf, gl_bottomtexture, polyflags, false, lightnum, colormap); else @@ -1430,10 +1430,10 @@ static void HWR_ProcessSeg(void) // Sort of like GLWall::Process in GZDoom if (gl_frontsector->numlights) { if (!(blendmode & PF_Masked)) - HWR_SplitWall(gl_frontsector, wallVerts, gl_midtexture, &Surf, FF_TRANSLUCENT, NULL, blendmode); // vanilla just uses PF_Masked here - if we run into any issues, maybe change to that + HWR_SplitWall(gl_frontsector, wallVerts, gl_midtexture, &Surf, FOF_TRANSLUCENT, NULL, blendmode); // vanilla just uses PF_Masked here - if we run into any issues, maybe change to that else { - HWR_SplitWall(gl_frontsector, wallVerts, gl_midtexture, &Surf, FF_CUTLEVEL, NULL, blendmode); // vanilla just uses PF_Masked here - if we run into any issues, maybe change to that + HWR_SplitWall(gl_frontsector, wallVerts, gl_midtexture, &Surf, FOF_CUTLEVEL, NULL, blendmode); // vanilla just uses PF_Masked here - if we run into any issues, maybe change to that } } else if (!(blendmode & PF_Masked)) @@ -1514,6 +1514,10 @@ static void HWR_ProcessSeg(void) // Sort of like GLWall::Process in GZDoom wallVerts[2].y = FIXED_TO_FLOAT(worldtopslope); wallVerts[1].y = FIXED_TO_FLOAT(worldbottomslope); + // I don't think that solid walls can use translucent linedef types... + if (gl_frontsector->numlights) + HWR_SplitWall(gl_frontsector, wallVerts, gl_midtexture, &Surf, FOF_CUTLEVEL, NULL, 0); + else { FBITFIELD blendmode = PF_Masked; if (grTex->mipmap.flags & TF_TRANSPARENT) @@ -1521,7 +1525,7 @@ static void HWR_ProcessSeg(void) // Sort of like GLWall::Process in GZDoom // I don't think that solid walls can use translucent linedef types... if (gl_frontsector->numlights) - HWR_SplitWall(gl_frontsector, wallVerts, gl_midtexture, &Surf, FF_CUTLEVEL, NULL, blendmode); + HWR_SplitWall(gl_frontsector, wallVerts, gl_midtexture, &Surf, FOF_CUTLEVEL, NULL, blendmode); else { if (grTex->mipmap.flags & TF_TRANSPARENT) @@ -1586,9 +1590,9 @@ static void HWR_ProcessSeg(void) // Sort of like GLWall::Process in GZDoom if (bothsides) continue; - if (!(rover->flags & FF_EXISTS) || !(rover->flags & FF_RENDERSIDES)) + if (!(rover->fofflags & FOF_EXISTS) || !(rover->fofflags & FOF_RENDERSIDES)) continue; - if (!(rover->flags & FF_ALLSIDES) && rover->flags & FF_INVERTSIDES) + if (!(rover->fofflags & FOF_ALLSIDES) && rover->fofflags & FOF_INVERTSIDES) continue; SLOPEPARAMS(*rover->t_slope, high1, highslope1, *rover->topheight) @@ -1629,7 +1633,7 @@ static void HWR_ProcessSeg(void) // Sort of like GLWall::Process in GZDoom wallVerts[2].y = FIXED_TO_FLOAT(hS); wallVerts[0].y = FIXED_TO_FLOAT(l); wallVerts[1].y = FIXED_TO_FLOAT(lS); - if (rover->flags & FF_FOG) + if (rover->fofflags & FOF_FOG) { wallVerts[3].t = wallVerts[2].t = 0; wallVerts[0].t = wallVerts[1].t = 0; @@ -1688,7 +1692,7 @@ static void HWR_ProcessSeg(void) // Sort of like GLWall::Process in GZDoom wallVerts[0].s = wallVerts[3].s = cliplow * grTex->scaleX; wallVerts[2].s = wallVerts[1].s = cliphigh * grTex->scaleX; } - if (rover->flags & FF_FOG) + if (rover->fofflags & FOF_FOG) { FBITFIELD blendmode; @@ -1700,7 +1704,7 @@ static void HWR_ProcessSeg(void) // Sort of like GLWall::Process in GZDoom Surf.PolyColor.s.alpha = HWR_FogBlockAlpha(rover->master->frontsector->lightlevel, rover->master->frontsector->extra_colormap); if (gl_frontsector->numlights) - HWR_SplitWall(gl_frontsector, wallVerts, 0, &Surf, rover->flags, rover, blendmode); + HWR_SplitWall(gl_frontsector, wallVerts, 0, &Surf, rover->fofflags, rover, blendmode); else HWR_AddTransparentWall(wallVerts, &Surf, 0, blendmode, true, lightnum, colormap); } @@ -1708,7 +1712,7 @@ static void HWR_ProcessSeg(void) // Sort of like GLWall::Process in GZDoom { FBITFIELD blendmode = PF_Masked; - if (rover->flags & FF_TRANSLUCENT) + if (rover->fofflags & FOF_TRANSLUCENT) { if (rover->alpha < 256 || rover->blend) { @@ -1718,7 +1722,7 @@ static void HWR_ProcessSeg(void) // Sort of like GLWall::Process in GZDoom } if (gl_frontsector->numlights) - HWR_SplitWall(gl_frontsector, wallVerts, texnum, &Surf, rover->flags, rover, blendmode); + HWR_SplitWall(gl_frontsector, wallVerts, texnum, &Surf, rover->fofflags, rover, blendmode); else { if (blendmode != PF_Masked) @@ -1746,9 +1750,9 @@ static void HWR_ProcessSeg(void) // Sort of like GLWall::Process in GZDoom if (bothsides) continue; - if (!(rover->flags & FF_EXISTS) || !(rover->flags & FF_RENDERSIDES)) + if (!(rover->fofflags & FOF_EXISTS) || !(rover->fofflags & FOF_RENDERSIDES)) continue; - if (!(rover->flags & FF_ALLSIDES || rover->flags & FF_INVERTSIDES)) + if (!(rover->fofflags & FOF_ALLSIDES || rover->fofflags & FOF_INVERTSIDES)) continue; SLOPEPARAMS(*rover->t_slope, high1, highslope1, *rover->topheight) @@ -1788,7 +1792,7 @@ static void HWR_ProcessSeg(void) // Sort of like GLWall::Process in GZDoom wallVerts[2].y = FIXED_TO_FLOAT(hS); wallVerts[0].y = FIXED_TO_FLOAT(l); wallVerts[1].y = FIXED_TO_FLOAT(lS); - if (rover->flags & FF_FOG) + if (rover->fofflags & FOF_FOG) { wallVerts[3].t = wallVerts[2].t = 0; wallVerts[0].t = wallVerts[1].t = 0; @@ -1814,7 +1818,7 @@ static void HWR_ProcessSeg(void) // Sort of like GLWall::Process in GZDoom wallVerts[2].s = wallVerts[1].s = cliphigh * grTex->scaleX; } - if (rover->flags & FF_FOG) + if (rover->fofflags & FOF_FOG) { FBITFIELD blendmode; @@ -1826,7 +1830,7 @@ static void HWR_ProcessSeg(void) // Sort of like GLWall::Process in GZDoom Surf.PolyColor.s.alpha = HWR_FogBlockAlpha(rover->master->frontsector->lightlevel, rover->master->frontsector->extra_colormap); if (gl_backsector->numlights) - HWR_SplitWall(gl_backsector, wallVerts, 0, &Surf, rover->flags, rover, blendmode); + HWR_SplitWall(gl_backsector, wallVerts, 0, &Surf, rover->fofflags, rover, blendmode); else HWR_AddTransparentWall(wallVerts, &Surf, 0, blendmode, true, lightnum, colormap); } @@ -1834,7 +1838,7 @@ static void HWR_ProcessSeg(void) // Sort of like GLWall::Process in GZDoom { FBITFIELD blendmode = PF_Masked; - if (rover->flags & FF_TRANSLUCENT) + if (rover->fofflags & FOF_TRANSLUCENT) { if (rover->alpha < 256 || rover->blend) { @@ -1844,7 +1848,7 @@ static void HWR_ProcessSeg(void) // Sort of like GLWall::Process in GZDoom } if (gl_backsector->numlights) - HWR_SplitWall(gl_backsector, wallVerts, texnum, &Surf, rover->flags, rover, blendmode); + HWR_SplitWall(gl_backsector, wallVerts, texnum, &Surf, rover->fofflags, rover, blendmode); else { if (blendmode != PF_Masked) @@ -3086,17 +3090,17 @@ static void HWR_Subsector(size_t num) cullHeight = P_GetFFloorBottomZAt(rover, viewx, viewy); centerHeight = P_GetFFloorBottomZAt(rover, gl_frontsector->soundorg.x, gl_frontsector->soundorg.y); - if (!(rover->flags & FF_EXISTS) || !(rover->flags & FF_RENDERPLANES)) + if (!(rover->fofflags & FOF_EXISTS) || !(rover->fofflags & FOF_RENDERPLANES)) continue; if (sub->validcount == validcount) continue; if (centerHeight <= locCeilingHeight && centerHeight >= locFloorHeight && - ((dup_viewz < cullHeight && (rover->flags & FF_BOTHPLANES || !(rover->flags & FF_INVERTPLANES))) || - (dup_viewz > cullHeight && (rover->flags & FF_BOTHPLANES || rover->flags & FF_INVERTPLANES)))) + ((dup_viewz < cullHeight && (rover->fofflags & FOF_BOTHPLANES || !(rover->fofflags & FOF_INVERTPLANES))) || + (dup_viewz > cullHeight && (rover->fofflags & FOF_BOTHPLANES || rover->fofflags & FOF_INVERTPLANES)))) { - if (rover->flags & FF_FOG) + if (rover->fofflags & FOF_FOG) { UINT8 alpha; @@ -3111,7 +3115,7 @@ static void HWR_Subsector(size_t num) alpha, rover->master->frontsector, PF_Fog|PF_NoTexture, true, rover->master->frontsector->extra_colormap); } - else if (rover->flags & FF_TRANSLUCENT + else if (rover->fofflags & FOF_TRANSLUCENT && (rover->alpha < 256 || rover->blend)) // SoM: Flags are more efficient { FBITFIELD blendmode = HWR_GetBlendModeFlag(rover->blend) | HWR_RippleBlend(gl_frontsector, rover, false); @@ -3141,10 +3145,10 @@ static void HWR_Subsector(size_t num) if (centerHeight >= locFloorHeight && centerHeight <= locCeilingHeight && - ((dup_viewz > cullHeight && (rover->flags & FF_BOTHPLANES || !(rover->flags & FF_INVERTPLANES))) || - (dup_viewz < cullHeight && (rover->flags & FF_BOTHPLANES || rover->flags & FF_INVERTPLANES)))) + ((dup_viewz > cullHeight && (rover->fofflags & FOF_BOTHPLANES || !(rover->fofflags & FOF_INVERTPLANES))) || + (dup_viewz < cullHeight && (rover->fofflags & FOF_BOTHPLANES || rover->fofflags & FOF_INVERTPLANES)))) { - if (rover->flags & FF_FOG) + if (rover->fofflags & FOF_FOG) { UINT8 alpha; @@ -3159,7 +3163,7 @@ static void HWR_Subsector(size_t num) alpha, rover->master->frontsector, PF_Fog|PF_NoTexture, true, rover->master->frontsector->extra_colormap); } - else if (rover->flags & FF_TRANSLUCENT + else if (rover->fofflags & FOF_TRANSLUCENT && (rover->alpha < 256 || rover->blend)) // SoM: Flags are more efficient { FBITFIELD blendmode = HWR_GetBlendModeFlag(rover->blend) | HWR_RippleBlend(gl_frontsector, rover, false); @@ -3922,7 +3926,7 @@ static void HWR_SplitSprite(gl_vissprite_t *spr) return; // even if we aren't changing colormap or lightlevel, we still need to continue drawing down the sprite - if (!(list[i].flags & FF_NOSHADE) && (list[i].flags & FF_CUTSPRITES)) + if (!(list[i].flags & FOF_NOSHADE) && (list[i].flags & FOF_CUTSPRITES)) { if (!lightset) { diff --git a/src/k_bot.c b/src/k_bot.c index 1c2ab4b80..30c661704 100644 --- a/src/k_bot.c +++ b/src/k_bot.c @@ -402,7 +402,7 @@ static line_t *K_FindBotController(mobj_t *mo) { sector_t *rs = NULL; - if (!(rover->flags & FF_EXISTS)) + if (!(rover->fofflags & FOF_EXISTS)) { continue; } diff --git a/src/k_botsearch.c b/src/k_botsearch.c index 52fbc19e0..2d9c9774d 100644 --- a/src/k_botsearch.c +++ b/src/k_botsearch.c @@ -189,7 +189,7 @@ boolean K_BotHatesThisSector(player_t *player, sector_t *sec, fixed_t x, fixed_t fixed_t top = INT32_MAX; fixed_t bottom = INT32_MAX; - if (!(rover->flags & FF_EXISTS)) + if (!(rover->fofflags & FOF_EXISTS)) { continue; } @@ -197,7 +197,7 @@ boolean K_BotHatesThisSector(player_t *player, sector_t *sec, fixed_t x, fixed_t top = P_GetZAt(*rover->t_slope, x, y, *rover->topheight); bottom = P_GetZAt(*rover->b_slope, x, y, *rover->bottomheight); - if (!(rover->flags & FF_BLOCKPLAYER)) + if (!(rover->fofflags & FOF_BLOCKPLAYER)) { if ((top >= player->mo->z) && (bottom <= player->mo->z + player->mo->height) && K_BotHatesThisSectorsSpecial(player, rover->master->frontsector)) diff --git a/src/k_kart.c b/src/k_kart.c index ecd04957c..f57720ed3 100644 --- a/src/k_kart.c +++ b/src/k_kart.c @@ -1882,7 +1882,7 @@ static fixed_t K_CheckOffroadCollide(mobj_t *mo) // 2: If we're here, we haven't found anything. So let's try looking for FOFs in the sectors using the same logic. for (rover = s->ffloors; rover; rover = rover->next) { - if (!(rover->flags & FF_EXISTS)) // This FOF doesn't exist anymore. + if (!(rover->fofflags & FOF_EXISTS)) // This FOF doesn't exist anymore. continue; s2 = §ors[rover->secnum]; // makes things easier for us @@ -7133,13 +7133,13 @@ void K_CalculateBananaSlope(mobj_t *mobj, fixed_t x, fixed_t y, fixed_t z, fixed fixed_t top, bottom; fixed_t d1, d2; - if (!(rover->flags & FF_EXISTS)) + if (!(rover->fofflags & FOF_EXISTS)) continue; - if ((!(((rover->flags & FF_BLOCKPLAYER && player) - || (rover->flags & FF_BLOCKOTHERS && !player)) - || (rover->flags & FF_QUICKSAND)) - || (rover->flags & FF_SWIMMABLE))) + if ((!(((rover->fofflags & FOF_BLOCKPLAYER && player) + || (rover->fofflags & FOF_BLOCKOTHERS && !player)) + || (rover->fofflags & FOF_QUICKSAND)) + || (rover->fofflags & FOF_SWIMMABLE))) continue; top = K_BananaSlopeZ(*rover->t_slope, x, y, *rover->topheight, radius, false); @@ -7147,7 +7147,7 @@ void K_CalculateBananaSlope(mobj_t *mobj, fixed_t x, fixed_t y, fixed_t z, fixed if (flip) { - if (rover->flags & FF_QUICKSAND) + if (rover->fofflags & FOF_QUICKSAND) { if (z < top && (z + height) > bottom) { @@ -7171,7 +7171,7 @@ void K_CalculateBananaSlope(mobj_t *mobj, fixed_t x, fixed_t y, fixed_t z, fixed } else { - if (rover->flags & FF_QUICKSAND) + if (rover->fofflags & FOF_QUICKSAND) { if (z < top && (z + height) > bottom) { diff --git a/src/lua_maplib.c b/src/lua_maplib.c index 925483ea3..a8baf558f 100644 --- a/src/lua_maplib.c +++ b/src/lua_maplib.c @@ -214,6 +214,7 @@ enum ffloor_e { ffloor_tslope, ffloor_bslope, ffloor_sector, + ffloor_fofflags, ffloor_flags, ffloor_master, ffloor_target, @@ -1841,6 +1842,80 @@ static int lib_numnodes(lua_State *L) // ffloor_t // ////////////// +static INT32 P_GetOldFOFFlags(ffloor_t *fflr) +{ + INT32 result = 0; + if (fflr->fofflags & FOF_EXISTS) + result |= FF_OLD_EXISTS; + if (fflr->fofflags & FOF_BLOCKPLAYER) + result |= FF_OLD_BLOCKPLAYER; + if (fflr->fofflags & FOF_BLOCKOTHERS) + result |= FF_OLD_BLOCKOTHERS; + if (fflr->fofflags & FOF_RENDERSIDES) + result |= FF_OLD_RENDERSIDES; + if (fflr->fofflags & FOF_RENDERPLANES) + result |= FF_OLD_RENDERPLANES; + if (fflr->fofflags & FOF_SWIMMABLE) + result |= FF_OLD_SWIMMABLE; + if (fflr->fofflags & FOF_NOSHADE) + result |= FF_OLD_NOSHADE; + if (fflr->fofflags & FOF_CUTSOLIDS) + result |= FF_OLD_CUTSOLIDS; + if (fflr->fofflags & FOF_CUTEXTRA) + result |= FF_OLD_CUTEXTRA; + if (fflr->fofflags & FOF_CUTSPRITES) + result |= FF_OLD_CUTSPRITES; + if (fflr->fofflags & FOF_BOTHPLANES) + result |= FF_OLD_BOTHPLANES; + if (fflr->fofflags & FOF_EXTRA) + result |= FF_OLD_EXTRA; + if (fflr->fofflags & FOF_TRANSLUCENT) + result |= FF_OLD_TRANSLUCENT; + if (fflr->fofflags & FOF_FOG) + result |= FF_OLD_FOG; + if (fflr->fofflags & FOF_INVERTPLANES) + result |= FF_OLD_INVERTPLANES; + if (fflr->fofflags & FOF_ALLSIDES) + result |= FF_OLD_ALLSIDES; + if (fflr->fofflags & FOF_INVERTSIDES) + result |= FF_OLD_INVERTSIDES; + if (fflr->fofflags & FOF_DOUBLESHADOW) + result |= FF_OLD_DOUBLESHADOW; + if (fflr->fofflags & FOF_FLOATBOB) + result |= FF_OLD_FLOATBOB; + if (fflr->fofflags & FOF_NORETURN) + result |= FF_OLD_NORETURN; + if (fflr->fofflags & FOF_CRUMBLE) + result |= FF_OLD_CRUMBLE; + if (fflr->bustflags & TMFB_ONLYBOTTOM) + result |= FF_OLD_SHATTERBOTTOM; + if (fflr->fofflags & FOF_GOOWATER) + result |= FF_OLD_GOOWATER; + if (fflr->fofflags & FOF_MARIO) + result |= FF_OLD_MARIO; + if (fflr->fofflags & FOF_BUSTUP) + result |= FF_OLD_BUSTUP; + if (fflr->fofflags & FOF_QUICKSAND) + result |= FF_OLD_QUICKSAND; + if (fflr->fofflags & FOF_PLATFORM) + result |= FF_OLD_PLATFORM; + if (fflr->fofflags & FOF_REVERSEPLATFORM) + result |= FF_OLD_REVERSEPLATFORM; + if (fflr->fofflags & FOF_INTANGIBLEFLATS) + result |= FF_OLD_INTANGIBLEFLATS; + if (fflr->busttype == BT_TOUCH) + result |= FF_OLD_SHATTER; + if (fflr->busttype == BT_SPINBUST) + result |= FF_OLD_SPINBUST; + if (fflr->busttype == BT_STRONG) + result |= FF_OLD_STRONGBUST; + if (fflr->fofflags & FF_OLD_RIPPLE) + result |= FOF_RIPPLE; + if (fflr->fofflags & FF_OLD_COLORMAPONLY) + result |= FOF_COLORMAPONLY; + return result; +} + static int ffloor_get(lua_State *L) { ffloor_t *ffloor = *((ffloor_t **)luaL_checkudata(L, 1, META_FFLOOR)); @@ -1895,8 +1970,11 @@ static int ffloor_get(lua_State *L) case ffloor_sector: LUA_PushUserdata(L, §ors[ffloor->secnum], META_SECTOR); return 1; + case ffloor_fofflags: + lua_pushinteger(L, ffloor->fofflags); + return 1; case ffloor_flags: - lua_pushinteger(L, ffloor->flags); + lua_pushinteger(L, P_GetOldFOFFlags(ffloor)); return 1; case ffloor_master: LUA_PushUserdata(L, ffloor->master, META_LINE); @@ -1938,6 +2016,88 @@ static int ffloor_get(lua_State *L) return 0; } +static void P_SetOldFOFFlags(ffloor_t *fflr, oldffloortype_e oldflags) +{ + ffloortype_e originalflags = fflr->fofflags; + fflr->fofflags = 0; + if (oldflags & FF_OLD_EXISTS) + fflr->fofflags |= FOF_EXISTS; + if (oldflags & FF_OLD_BLOCKPLAYER) + fflr->fofflags |= FOF_BLOCKPLAYER; + if (oldflags & FF_OLD_BLOCKOTHERS) + fflr->fofflags |= FOF_BLOCKOTHERS; + if (oldflags & FF_OLD_RENDERSIDES) + fflr->fofflags |= FOF_RENDERSIDES; + if (oldflags & FF_OLD_RENDERPLANES) + fflr->fofflags |= FOF_RENDERPLANES; + if (oldflags & FF_OLD_SWIMMABLE) + fflr->fofflags |= FOF_SWIMMABLE; + if (oldflags & FF_OLD_NOSHADE) + fflr->fofflags |= FOF_NOSHADE; + if (oldflags & FF_OLD_CUTSOLIDS) + fflr->fofflags |= FOF_CUTSOLIDS; + if (oldflags & FF_OLD_CUTEXTRA) + fflr->fofflags |= FOF_CUTEXTRA; + if (oldflags & FF_OLD_CUTSPRITES) + fflr->fofflags |= FOF_CUTSPRITES; + if (oldflags & FF_OLD_BOTHPLANES) + fflr->fofflags |= FOF_BOTHPLANES; + if (oldflags & FF_OLD_EXTRA) + fflr->fofflags |= FOF_EXTRA; + if (oldflags & FF_OLD_TRANSLUCENT) + fflr->fofflags |= FOF_TRANSLUCENT; + if (oldflags & FF_OLD_FOG) + fflr->fofflags |= FOF_FOG; + if (oldflags & FF_OLD_INVERTPLANES) + fflr->fofflags |= FOF_INVERTPLANES; + if (oldflags & FF_OLD_ALLSIDES) + fflr->fofflags |= FOF_ALLSIDES; + if (oldflags & FF_OLD_INVERTSIDES) + fflr->fofflags |= FOF_INVERTSIDES; + if (oldflags & FF_OLD_DOUBLESHADOW) + fflr->fofflags |= FOF_DOUBLESHADOW; + if (oldflags & FF_OLD_FLOATBOB) + fflr->fofflags |= FOF_FLOATBOB; + if (oldflags & FF_OLD_NORETURN) + fflr->fofflags |= FOF_NORETURN; + if (oldflags & FF_OLD_CRUMBLE) + fflr->fofflags |= FOF_CRUMBLE; + if (oldflags & FF_OLD_GOOWATER) + fflr->fofflags |= FOF_GOOWATER; + if (oldflags & FF_OLD_MARIO) + fflr->fofflags |= FOF_MARIO; + if (oldflags & FF_OLD_BUSTUP) + fflr->fofflags |= FOF_BUSTUP; + if (oldflags & FF_OLD_QUICKSAND) + fflr->fofflags |= FOF_QUICKSAND; + if (oldflags & FF_OLD_PLATFORM) + fflr->fofflags |= FOF_PLATFORM; + if (oldflags & FF_OLD_REVERSEPLATFORM) + fflr->fofflags |= FOF_REVERSEPLATFORM; + if (oldflags & FF_OLD_RIPPLE) + fflr->fofflags |= FOF_RIPPLE; + if (oldflags & FF_OLD_COLORMAPONLY) + fflr->fofflags |= FOF_COLORMAPONLY; + if (originalflags & FOF_BOUNCY) + fflr->fofflags |= FOF_BOUNCY; + if (originalflags & FOF_SPLAT) + fflr->fofflags |= FOF_SPLAT; + + if (oldflags & FF_OLD_SHATTER) + fflr->busttype = BT_TOUCH; + else if (oldflags & FF_OLD_SPINBUST) + fflr->busttype = BT_SPINBUST; + else if (oldflags & FF_OLD_STRONGBUST) + fflr->busttype = BT_STRONG; + else + fflr->busttype = BT_REGULAR; + + if (oldflags & FF_OLD_SHATTERBOTTOM) + fflr->bustflags |= TMFB_ONLYBOTTOM; + else + fflr->bustflags &= ~TMFB_ONLYBOTTOM; +} + static int ffloor_set(lua_State *L) { ffloor_t *ffloor = *((ffloor_t **)luaL_checkudata(L, 1, META_FFLOOR)); @@ -2002,10 +2162,20 @@ static int ffloor_set(lua_State *L) case ffloor_bottompic: *ffloor->bottompic = P_AddLevelFlatRuntime(luaL_checkstring(L, 3)); break; + case ffloor_fofflags: { + ffloortype_e oldflags = ffloor->fofflags; // store FOF's old flags + ffloor->fofflags = luaL_checkinteger(L, 3); + if (ffloor->fofflags != oldflags) + ffloor->target->moved = true; // reset target sector's lightlist + break; + } case ffloor_flags: { - ffloortype_e oldflags = ffloor->flags; // store FOF's old flags - ffloor->flags = luaL_checkinteger(L, 3); - if (ffloor->flags != oldflags) + ffloortype_e oldflags = ffloor->fofflags; // store FOF's old flags + busttype_e oldbusttype = ffloor->busttype; + ffloorbustflags_e oldbustflags = ffloor->bustflags; + oldffloortype_e newflags = luaL_checkinteger(L, 3); + P_SetOldFOFFlags(ffloor, newflags); + if (ffloor->fofflags != oldflags || ffloor->busttype != oldbusttype || ffloor->bustflags != oldbustflags) ffloor->target->moved = true; // reset target sector's lightlist break; } diff --git a/src/objects/orbinaut.c b/src/objects/orbinaut.c index 4f5d5ede6..4d5738e00 100644 --- a/src/objects/orbinaut.c +++ b/src/objects/orbinaut.c @@ -125,7 +125,7 @@ void Obj_OrbinautThink(mobj_t *th) } /* todo: UDMFify - if (P_MobjTouchingSectorSpecialFlag(th, SS)) + if (P_MobjTouchingSectorSpecialFlag(th, ?)) { K_DoPogoSpring(th, 0, 1); } diff --git a/src/p_enemy.c b/src/p_enemy.c index 3859d9335..c877528ad 100644 --- a/src/p_enemy.c +++ b/src/p_enemy.c @@ -506,7 +506,7 @@ static boolean P_WaterInSector(mobj_t *mobj, fixed_t x, fixed_t y) for (rover = sector->ffloors; rover; rover = rover->next) { - if (!(rover->flags & FF_EXISTS) || !(rover->flags & FF_SWIMMABLE)) + if (!(rover->fofflags & FOF_EXISTS) || !(rover->fofflags & FOF_SWIMMABLE)) continue; if (*rover->topheight >= mobj->floorz && *rover->topheight <= mobj->z) diff --git a/src/p_floor.c b/src/p_floor.c index be62c5786..b394ab811 100644 --- a/src/p_floor.c +++ b/src/p_floor.c @@ -554,7 +554,7 @@ static fixed_t P_SectorCheckWater(sector_t *analyzesector, for (rover = analyzesector->ffloors; rover; rover = rover->next) { - if (!(rover->flags & FF_EXISTS) || !(rover->flags & FF_SWIMMABLE) || rover->flags & FF_SOLID) + if (!(rover->fofflags & FOF_EXISTS) || !(rover->fofflags & FOF_SWIMMABLE) || rover->fofflags & FOF_SOLID) continue; // If the sector is below the water, don't bother. @@ -760,10 +760,10 @@ void T_StartCrumble(crumble_t *crumble) for (rover = sector->ffloors; rover; rover = rover->next) { - if (!(rover->flags & FF_CRUMBLE)) + if (!(rover->fofflags & FOF_CRUMBLE)) continue; - if (!(rover->flags & FF_FLOATBOB)) + if (!(rover->fofflags & FOF_FLOATBOB)) continue; if (rover->master != crumble->sourceline) @@ -772,7 +772,7 @@ void T_StartCrumble(crumble_t *crumble) rover->alpha = crumble->origalpha; if (rover->alpha == 0xff) - rover->flags &= ~FF_TRANSLUCENT; + rover->fofflags &= ~FOF_TRANSLUCENT; } } @@ -796,13 +796,13 @@ void T_StartCrumble(crumble_t *crumble) for (rover = sector->ffloors; rover; rover = rover->next) { - if (rover->flags & FF_NORETURN) + if (rover->fofflags & FOF_NORETURN) continue; - if (!(rover->flags & FF_CRUMBLE)) + if (!(rover->fofflags & FOF_CRUMBLE)) continue; - if (!(rover->flags & FF_FLOATBOB)) + if (!(rover->fofflags & FOF_FLOATBOB)) continue; if (rover->master != crumble->sourceline) @@ -810,7 +810,7 @@ void T_StartCrumble(crumble_t *crumble) if (rover->alpha == crumble->origalpha) { - rover->flags |= FF_TRANSLUCENT; + rover->fofflags |= FOF_TRANSLUCENT; rover->alpha = 0x00; } else @@ -818,7 +818,7 @@ void T_StartCrumble(crumble_t *crumble) rover->alpha = crumble->origalpha; if (rover->alpha == 0xff) - rover->flags &= ~FF_TRANSLUCENT; + rover->fofflags &= ~FOF_TRANSLUCENT; } } } @@ -1063,7 +1063,7 @@ void T_ThwompSector(thwomp_t *thwomp) // I could of used rowoffset, but the FOF actually // modifies the textures's Y offset. It doesn't with // textureoffset, so Effect 4 can be ignored as usual. - if ((thwomp->sourceline->flags & ML_SKEWTD) // FIXME: UDMF-ify + if ((thwomp->sourceline->flags & ML_SKEWTD) // FIXME: UDMFify && leveltime < (unsigned)(sides[thwomp->sourceline->sidenum[0]].textureoffset>>FRACBITS)) thwomp->direction = 0; @@ -1167,7 +1167,7 @@ void T_ThwompSector(thwomp_t *thwomp) if (res == pastdest) { - if (rover->flags & FF_EXISTS) + if (rover->fofflags & FOF_EXISTS) S_StartSound((void *)&actionsector->soundorg, thwomp->sound); thwomp->direction = 1; // start heading back up @@ -1904,7 +1904,7 @@ void EV_CrumbleChain(sector_t *sec, ffloor_t *rover) } // no longer exists (can't collide with again) - rover->flags &= ~FF_EXISTS; + rover->fofflags &= ~FOF_EXISTS; rover->master->frontsector->moved = true; P_RecalcPrecipInSector(sec); } @@ -2042,8 +2042,8 @@ void EV_MarioBlock(ffloor_t *rover, sector_t *sector, mobj_t *puncher) if (roversec->floordata || roversec->ceilingdata) return; - if (!(rover->flags & FF_SOLID)) - rover->flags |= (FF_SOLID|FF_RENDERALL|FF_CUTLEVEL); + if (!(rover->fofflags & FOF_SOLID)) + rover->fofflags |= (FOF_SOLID|FOF_RENDERALL|FOF_CUTLEVEL); // Find an item to pop out! thing = SearchMarioNode(roversec->touching_thinglist); diff --git a/src/p_map.c b/src/p_map.c index 879a6650e..96e8747b0 100644 --- a/src/p_map.c +++ b/src/p_map.c @@ -1876,13 +1876,13 @@ boolean P_CheckPosition(mobj_t *thing, fixed_t x, fixed_t y) { fixed_t topheight, bottomheight; - if (!(rover->flags & FF_EXISTS)) + if (!(rover->fofflags & FOF_EXISTS)) continue; topheight = P_GetFOFTopZ(thing, newsubsec->sector, rover, x, y, NULL); bottomheight = P_GetFOFBottomZ(thing, newsubsec->sector, rover, x, y, NULL); - if ((rover->flags & (FF_SWIMMABLE|FF_GOOWATER)) == (FF_SWIMMABLE|FF_GOOWATER) && !(thing->flags & MF_NOGRAVITY)) + if ((rover->fofflags & (FOF_SWIMMABLE|FOF_GOOWATER)) == (FOF_SWIMMABLE|FOF_GOOWATER) && !(thing->flags & MF_NOGRAVITY)) { // If you're inside goowater and slowing down fixed_t sinklevel = FixedMul(thing->info->height/6, thing->scale); @@ -1923,14 +1923,14 @@ boolean P_CheckPosition(mobj_t *thing, fixed_t x, fixed_t y) if (P_CheckSolidFFloorSurface(thing, rover)) ; - else if (thing->type == MT_SKIM && (rover->flags & FF_SWIMMABLE)) + else if (thing->type == MT_SKIM && (rover->fofflags & FOF_SWIMMABLE)) ; - else if (!((rover->flags & FF_BLOCKPLAYER && thing->player) - || (rover->flags & FF_BLOCKOTHERS && !thing->player) - || rover->flags & FF_QUICKSAND)) + else if (!((rover->fofflags & FOF_BLOCKPLAYER && thing->player) + || (rover->fofflags & FOF_BLOCKOTHERS && !thing->player) + || rover->fofflags & FOF_QUICKSAND)) continue; - if (rover->flags & FF_QUICKSAND) + if (rover->fofflags & FOF_QUICKSAND) { if (thing->z < topheight && bottomheight < thingtop) { @@ -1951,7 +1951,7 @@ boolean P_CheckPosition(mobj_t *thing, fixed_t x, fixed_t y) + ((topheight - bottomheight)/2)); if (topheight > tmfloorz && abs(delta1) < abs(delta2) - && !(rover->flags & FF_REVERSEPLATFORM)) + && !(rover->fofflags & FOF_REVERSEPLATFORM)) { tmfloorz = tmdropoffz = topheight; tmfloorrover = rover; @@ -1959,8 +1959,8 @@ boolean P_CheckPosition(mobj_t *thing, fixed_t x, fixed_t y) tmfloorpic = *rover->toppic; } if (bottomheight < tmceilingz && abs(delta1) >= abs(delta2) - && !(rover->flags & FF_PLATFORM) - && !(thing->type == MT_SKIM && (rover->flags & FF_SWIMMABLE))) + && !(rover->fofflags & FOF_PLATFORM) + && !(thing->type == MT_SKIM && (rover->fofflags & FOF_SWIMMABLE))) { tmceilingz = tmdrpoffceilz = bottomheight; tmceilingrover = rover; @@ -2183,7 +2183,7 @@ boolean P_CheckCameraPosition(fixed_t x, fixed_t y, camera_t *thiscam) for (rover = newsubsec->sector->ffloors; rover; rover = rover->next) { fixed_t topheight, bottomheight; - if (!(rover->flags & FF_BLOCKOTHERS) || !(rover->flags & FF_EXISTS) || !(rover->flags & FF_RENDERALL) || (rover->master->frontsector->flags & MSF_NOCLIPCAMERA)) + if (!(rover->fofflags & FOF_BLOCKOTHERS) || !(rover->fofflags & FOF_EXISTS) || !(rover->fofflags & FOF_RENDERALL) || (rover->master->frontsector->flags & MSF_NOCLIPCAMERA)) continue; topheight = P_CameraGetFOFTopZ(thiscam, newsubsec->sector, rover, x, y, NULL); @@ -2495,7 +2495,7 @@ BlockItReturn_t PIT_PushableMoved(mobj_t *thing) static boolean P_WaterRunning(mobj_t *thing) { ffloor_t *rover = thing->floorrover; - return rover && (rover->flags & FF_SWIMMABLE) && + return rover && (rover->fofflags & FOF_SWIMMABLE) && P_IsObjectOnGround(thing); } @@ -3076,9 +3076,9 @@ static boolean P_ThingHeightClip(mobj_t *thing) { rover = (thing->eflags & MFE_VERTICALFLIP) ? oldceilingrover : oldfloorrover; - // Match the Thing's old floorz to an FOF and check for FF_EXISTS - // If ~FF_EXISTS, don't set mobj Z. - if (!rover || ((rover->flags & FF_EXISTS) && (rover->flags & FF_SOLID))) + // Match the Thing's old floorz to an FOF and check for FOF_EXISTS + // If ~FOF_EXISTS, don't set mobj Z. + if (!rover || ((rover->fofflags & FOF_EXISTS) && (rover->fofflags & FOF_SOLID))) { hitfloor = false; if (thing->eflags & MFE_VERTICALFLIP) @@ -3511,10 +3511,10 @@ static void P_CheckLavaWall(mobj_t *mo, sector_t *sec) for (rover = sec->ffloors; rover; rover = rover->next) { - if (!(rover->flags & FF_EXISTS)) + if (!(rover->fofflags & FOF_EXISTS)) continue; - if (!(rover->flags & FF_SWIMMABLE)) + if (!(rover->fofflags & FOF_SWIMMABLE)) continue; if (rover->master->frontsector->damagetype != SD_LAVA) @@ -4217,8 +4217,8 @@ static boolean PIT_ChangeSector(mobj_t *thing, boolean realcrush) for (rover = thing->subsector->sector->ffloors; rover; rover = rover->next) { - if (!(((rover->flags & FF_BLOCKPLAYER) && thing->player) - || ((rover->flags & FF_BLOCKOTHERS) && !thing->player)) || !(rover->flags & FF_EXISTS)) + if (!(((rover->fofflags & FOF_BLOCKPLAYER) && thing->player) + || ((rover->fofflags & FOF_BLOCKOTHERS) && !thing->player)) || !(rover->fofflags & FOF_EXISTS)) continue; topheight = *rover->topheight; @@ -5012,16 +5012,16 @@ fixed_t P_FloorzAtPos(fixed_t x, fixed_t y, fixed_t z, fixed_t height) for (rover = sec->ffloors; rover; rover = rover->next) { fixed_t topheight, bottomheight; - if (!(rover->flags & FF_EXISTS)) + if (!(rover->fofflags & FOF_EXISTS)) continue; - if (!((rover->flags & FF_SOLID) || (rover->flags & FF_QUICKSAND)) || (rover->flags & FF_SWIMMABLE)) + if (!((rover->fofflags & FOF_SOLID) || (rover->fofflags & FOF_QUICKSAND)) || (rover->fofflags & FOF_SWIMMABLE)) continue; topheight = P_GetFFloorTopZAt (rover, x, y); bottomheight = P_GetFFloorBottomZAt(rover, x, y); - if (rover->flags & FF_QUICKSAND) + if (rover->fofflags & FOF_QUICKSAND) { if (z < topheight && bottomheight < thingtop) { @@ -5056,16 +5056,16 @@ fixed_t P_CeilingzAtPos(fixed_t x, fixed_t y, fixed_t z, fixed_t height) for (rover = sec->ffloors; rover; rover = rover->next) { fixed_t topheight, bottomheight; - if (!(rover->flags & FF_EXISTS)) + if (!(rover->fofflags & FOF_EXISTS)) continue; - if ((!(rover->flags & FF_SOLID || rover->flags & FF_QUICKSAND) || (rover->flags & FF_SWIMMABLE))) + if ((!(rover->fofflags & FOF_SOLID || rover->fofflags & FOF_QUICKSAND) || (rover->fofflags & FOF_SWIMMABLE))) continue; topheight = P_GetFFloorTopZAt (rover, x, y); bottomheight = P_GetFFloorBottomZAt(rover, x, y); - if (rover->flags & FF_QUICKSAND) + if (rover->fofflags & FOF_QUICKSAND) { if (thingtop > bottomheight && topheight > z) { diff --git a/src/p_maputl.c b/src/p_maputl.c index d05e2fad3..5f547773b 100644 --- a/src/p_maputl.c +++ b/src/p_maputl.c @@ -437,7 +437,7 @@ void P_CameraLineOpening(line_t *linedef) for (rover = front->ffloors; rover; rover = rover->next) { fixed_t topheight, bottomheight; - if (!(rover->flags & FF_BLOCKOTHERS) || !(rover->flags & FF_RENDERALL) || !(rover->flags & FF_EXISTS) || (rover->master->frontsector->flags & MSF_NOCLIPCAMERA)) + if (!(rover->fofflags & FOF_BLOCKOTHERS) || !(rover->fofflags & FOF_RENDERALL) || !(rover->fofflags & FOF_EXISTS) || (rover->master->frontsector->flags & MSF_NOCLIPCAMERA)) continue; topheight = P_CameraGetFOFTopZ(mapcampointer, front, rover, tmx, tmy, linedef); @@ -461,7 +461,7 @@ void P_CameraLineOpening(line_t *linedef) for (rover = back->ffloors; rover; rover = rover->next) { fixed_t topheight, bottomheight; - if (!(rover->flags & FF_BLOCKOTHERS) || !(rover->flags & FF_RENDERALL) || !(rover->flags & FF_EXISTS) || (rover->master->frontsector->flags & MSF_NOCLIPCAMERA)) + if (!(rover->fofflags & FOF_BLOCKOTHERS) || !(rover->fofflags & FOF_RENDERALL) || !(rover->fofflags & FOF_EXISTS) || (rover->master->frontsector->flags & MSF_NOCLIPCAMERA)) continue; topheight = P_CameraGetFOFTopZ(mapcampointer, back, rover, tmx, tmy, linedef); @@ -802,13 +802,13 @@ void P_LineOpening(line_t *linedef, mobj_t *mobj) for (rover = front->ffloors; rover; rover = rover->next) { fixed_t topheight, bottomheight; - if (!(rover->flags & FF_EXISTS)) + if (!(rover->fofflags & FOF_EXISTS)) continue; if (P_CheckSolidFFloorSurface(mobj, rover)) ; - else if (!((rover->flags & FF_BLOCKPLAYER && mobj->player) - || (rover->flags & FF_BLOCKOTHERS && !mobj->player))) + else if (!((rover->fofflags & FOF_BLOCKPLAYER && mobj->player) + || (rover->fofflags & FOF_BLOCKOTHERS && !mobj->player))) continue; topheight = P_GetFOFTopZ(mobj, front, rover, tmx, tmy, linedef); @@ -817,7 +817,7 @@ void P_LineOpening(line_t *linedef, mobj_t *mobj) delta1 = abs(mobj->z - (bottomheight + ((topheight - bottomheight)/2))); delta2 = abs(thingtop - (bottomheight + ((topheight - bottomheight)/2))); - if (delta1 >= delta2 && (rover->flags & FF_INTANGIBLEFLATS) != FF_PLATFORM) // thing is below FOF + if (delta1 >= delta2 && (rover->fofflags & FOF_INTANGIBLEFLATS) != FOF_PLATFORM) // thing is below FOF { if (bottomheight < open[FRONT].top) { open[FRONT].top = bottomheight; @@ -829,7 +829,7 @@ void P_LineOpening(line_t *linedef, mobj_t *mobj) highceiling = bottomheight; } - if (delta1 < delta2 && (rover->flags & FF_INTANGIBLEFLATS) != FF_REVERSEPLATFORM) // thing is above FOF + if (delta1 < delta2 && (rover->fofflags & FOF_INTANGIBLEFLATS) != FOF_REVERSEPLATFORM) // thing is above FOF { if (topheight > open[FRONT].bottom) { open[FRONT].bottom = topheight; @@ -846,13 +846,13 @@ void P_LineOpening(line_t *linedef, mobj_t *mobj) for (rover = back->ffloors; rover; rover = rover->next) { fixed_t topheight, bottomheight; - if (!(rover->flags & FF_EXISTS)) + if (!(rover->fofflags & FOF_EXISTS)) continue; if (P_CheckSolidFFloorSurface(mobj, rover)) ; - else if (!((rover->flags & FF_BLOCKPLAYER && mobj->player) - || (rover->flags & FF_BLOCKOTHERS && !mobj->player))) + else if (!((rover->fofflags & FOF_BLOCKPLAYER && mobj->player) + || (rover->fofflags & FOF_BLOCKOTHERS && !mobj->player))) continue; topheight = P_GetFOFTopZ(mobj, back, rover, tmx, tmy, linedef); @@ -861,7 +861,7 @@ void P_LineOpening(line_t *linedef, mobj_t *mobj) delta1 = abs(mobj->z - (bottomheight + ((topheight - bottomheight)/2))); delta2 = abs(thingtop - (bottomheight + ((topheight - bottomheight)/2))); - if (delta1 >= delta2 && (rover->flags & FF_INTANGIBLEFLATS) != FF_PLATFORM) // thing is below FOF + if (delta1 >= delta2 && (rover->fofflags & FOF_INTANGIBLEFLATS) != FOF_PLATFORM) // thing is below FOF { if (bottomheight < open[BACK].top) { open[BACK].top = bottomheight; @@ -873,7 +873,7 @@ void P_LineOpening(line_t *linedef, mobj_t *mobj) highceiling = bottomheight; } - if (delta1 < delta2 && (rover->flags & FF_INTANGIBLEFLATS) != FF_REVERSEPLATFORM) // thing is above FOF + if (delta1 < delta2 && (rover->fofflags & FOF_INTANGIBLEFLATS) != FOF_REVERSEPLATFORM) // thing is above FOF { if (topheight > open[BACK].bottom) { open[BACK].bottom = topheight; diff --git a/src/p_mobj.c b/src/p_mobj.c index cdddc0098..078b93fdb 100644 --- a/src/p_mobj.c +++ b/src/p_mobj.c @@ -594,11 +594,11 @@ void P_ExplodeMissile(mobj_t *mo) boolean P_InsideANonSolidFFloor(mobj_t *mobj, ffloor_t *rover) { fixed_t topheight, bottomheight; - if (!(rover->flags & FF_EXISTS)) + if (!(rover->fofflags & FOF_EXISTS)) return false; - if ((((rover->flags & FF_BLOCKPLAYER) && mobj->player) - || ((rover->flags & FF_BLOCKOTHERS) && !mobj->player))) + if ((((rover->fofflags & FOF_BLOCKPLAYER) && mobj->player) + || ((rover->fofflags & FOF_BLOCKOTHERS) && !mobj->player))) return false; topheight = P_GetFFloorTopZAt (rover, mobj->x, mobj->y); @@ -1062,10 +1062,10 @@ fixed_t P_GetMobjGravity(mobj_t *mo) for (rover = mo->subsector->sector->ffloors; rover; rover = rover->next) { - if (!(rover->flags & FF_EXISTS) || !P_InsideANonSolidFFloor(mo, rover)) // P_InsideANonSolidFFloor checks for FF_EXISTS itself, but let's not always call this function + if (!(rover->fofflags & FOF_EXISTS) || !P_InsideANonSolidFFloor(mo, rover)) // P_InsideANonSolidFFloor checks for FOF_EXISTS itself, but let's not always call this function continue; - if ((rover->flags & (FF_SWIMMABLE|FF_GOOWATER)) == (FF_SWIMMABLE|FF_GOOWATER)) + if ((rover->fofflags & (FOF_SWIMMABLE|FOF_GOOWATER)) == (FOF_SWIMMABLE|FOF_GOOWATER)) goopgravity = true; gravfactor = P_GetSectorGravityFactor(rover->master->frontsector); @@ -1408,10 +1408,10 @@ static void P_PushableCheckBustables(mobj_t *mo) for (rover = node->m_sector->ffloors; rover; rover = rover->next) { - if (!(rover->flags & FF_EXISTS)) + if (!(rover->fofflags & FOF_EXISTS)) continue; - if (!(rover->flags & FF_BUSTUP)) + if (!(rover->fofflags & FOF_BUSTUP)) continue; if (!(rover->bustflags & FB_PUSHABLES)) @@ -1947,7 +1947,7 @@ void P_AdjustMobjFloorZ_FFloors(mobj_t *mo, sector_t *sector, UINT8 motype) for (rover = sector->ffloors; rover; rover = rover->next) { - if (!(rover->flags & FF_EXISTS)) + if (!(rover->fofflags & FOF_EXISTS)) continue; topheight = P_GetFOFTopZ(mo, sector, rover, mo->x, mo->y, NULL); @@ -1955,16 +1955,16 @@ void P_AdjustMobjFloorZ_FFloors(mobj_t *mo, sector_t *sector, UINT8 motype) if (P_CheckSolidFFloorSurface(mo, rover)) // only the player should stand on lava or run on water ; - else if (motype != 0 && rover->flags & FF_SWIMMABLE) // "scenery" only + else if (motype != 0 && rover->fofflags & FOF_SWIMMABLE) // "scenery" only continue; - else if (rover->flags & FF_QUICKSAND) // quicksand + else if (rover->fofflags & FOF_QUICKSAND) // quicksand ; else if (!( // if it's not either of the following... - (rover->flags & (FF_BLOCKPLAYER|FF_MARIO) && mo->player) // ...solid to players? (mario blocks are always solid from beneath to players) - || (rover->flags & FF_BLOCKOTHERS && !mo->player) // ...solid to others? + (rover->fofflags & (FOF_BLOCKPLAYER|FOF_MARIO) && mo->player) // ...solid to players? (mario blocks are always solid from beneath to players) + || (rover->fofflags & FOF_BLOCKOTHERS && !mo->player) // ...solid to others? )) // ...don't take it into account. continue; - if (rover->flags & FF_QUICKSAND) + if (rover->fofflags & FOF_QUICKSAND) { switch (motype) { @@ -1989,15 +1989,15 @@ void P_AdjustMobjFloorZ_FFloors(mobj_t *mo, sector_t *sector, UINT8 motype) delta2 = thingtop - (bottomheight + ((topheight - bottomheight)/2)); if (topheight > mo->floorz && abs(delta1) < abs(delta2) - && (rover->flags & FF_SOLID) // Non-FF_SOLID Mario blocks are only solid from bottom - && !(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) + && (rover->fofflags & FOF_SOLID) // Non-FOF_SOLID Mario blocks are only solid from bottom + && !(rover->fofflags & FOF_REVERSEPLATFORM) + && ((P_MobjFlip(mo)*mo->momz >= 0) || (!(rover->fofflags & FOF_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) { mo->floorz = topheight; } if (bottomheight < mo->ceilingz && abs(delta1) >= abs(delta2) - && !(rover->flags & FF_PLATFORM) - && ((P_MobjFlip(mo)*mo->momz >= 0) || ((rover->flags & FF_SOLID) && !(rover->flags & FF_REVERSEPLATFORM)))) // In normal gravity, only clip for FOFs that are intangible from the top if you're coming from below + && !(rover->fofflags & FOF_PLATFORM) + && ((P_MobjFlip(mo)*mo->momz >= 0) || ((rover->fofflags & FOF_SOLID) && !(rover->fofflags & FOF_REVERSEPLATFORM)))) // In normal gravity, only clip for FOFs that are intangible from the top if you're coming from below { mo->ceilingz = bottomheight; } @@ -2125,7 +2125,7 @@ boolean P_CheckSolidLava(mobj_t *mobj, ffloor_t *rover) return false; } - if ((rover->flags & FF_SWIMMABLE) && (rover->master->frontsector->damagetype == SD_LAVA)) + if ((rover->fofflags & FOF_SWIMMABLE) && (rover->master->frontsector->damagetype == SD_LAVA)) { return true; } @@ -2688,10 +2688,10 @@ static void P_CheckMarioBlocks(mobj_t *mo) for (rover = node->m_sector->ffloors; rover; rover = rover->next) { - if (!(rover->flags & FF_EXISTS)) + if (!(rover->fofflags & FOF_EXISTS)) continue; - if (!(rover->flags & FF_MARIO)) + if (!(rover->fofflags & FOF_MARIO)) continue; if (mo->eflags & MFE_VERTICALFLIP) @@ -2700,7 +2700,7 @@ static void P_CheckMarioBlocks(mobj_t *mo) if (*rover->bottomheight != mo->ceilingz) continue; - if (rover->flags & FF_GOOWATER) // Brick block! + if (rover->fofflags & FOF_GOOWATER) // Brick block! EV_CrumbleChain(node->m_sector, rover); else // Question block! EV_MarioBlock(rover, node->m_sector, mo); @@ -3136,7 +3136,7 @@ boolean P_CanRunOnWater(mobj_t *mobj, ffloor_t *rover) return false; } - if (!(rover->flags & FF_SWIMMABLE)) + if (!(rover->fofflags & FOF_SWIMMABLE)) { // It's not even a water FOF. return false; @@ -3252,9 +3252,9 @@ void P_MobjCheckWater(mobj_t *mobj) topheight = P_GetSpecialTopZ(mobj, sectors + rover->secnum, sector); bottomheight = P_GetSpecialBottomZ(mobj, sectors + rover->secnum, sector); - if (!(rover->flags & FF_EXISTS) || !(rover->flags & FF_SWIMMABLE) - || (((rover->flags & FF_BLOCKPLAYER) && mobj->player) - || ((rover->flags & FF_BLOCKOTHERS) && !mobj->player))) + if (!(rover->fofflags & FOF_EXISTS) || !(rover->fofflags & FOF_SWIMMABLE) + || (((rover->fofflags & FOF_BLOCKPLAYER) && mobj->player) + || ((rover->fofflags & FOF_BLOCKOTHERS) && !mobj->player))) { if (topheight < top2 && topheight > thingtop) top2 = topheight; @@ -3298,7 +3298,7 @@ void P_MobjCheckWater(mobj_t *mobj) if (rover->master->frontsector->damagetype == SD_LAVA) mobj->eflags |= MFE_TOUCHLAVA; - if (rover->flags & FF_GOOWATER && !(mobj->flags & MF_NOGRAVITY)) + if (rover->fofflags & FOF_GOOWATER && !(mobj->flags & MF_NOGRAVITY)) mobj->eflags |= MFE_GOOWATER; } } @@ -3567,7 +3567,7 @@ static void P_SceneryCheckWater(mobj_t *mobj) for (rover = sector->ffloors; rover; rover = rover->next) { - if (!(rover->flags & FF_EXISTS) || !(rover->flags & FF_SWIMMABLE) || rover->flags & FF_BLOCKOTHERS) + if (!(rover->fofflags & FOF_EXISTS) || !(rover->fofflags & FOF_SWIMMABLE) || rover->fofflags & FOF_BLOCKOTHERS) continue; topheight = P_GetFFloorTopZAt (rover, mobj->x, mobj->y); @@ -3613,7 +3613,7 @@ static boolean P_CameraCheckHeat(camera_t *thiscam) for (rover = sector->ffloors; rover; rover = rover->next) { - if (!(rover->flags & FF_EXISTS)) + if (!(rover->fofflags & FOF_EXISTS)) continue; if (halfheight >= P_GetFFloorTopZAt(rover, thiscam->x, thiscam->y)) @@ -3643,7 +3643,7 @@ static boolean P_CameraCheckWater(camera_t *thiscam) for (rover = sector->ffloors; rover; rover = rover->next) { - if (!(rover->flags & FF_EXISTS) || !(rover->flags & FF_SWIMMABLE) || rover->flags & FF_BLOCKOTHERS) + if (!(rover->fofflags & FOF_EXISTS) || !(rover->fofflags & FOF_SWIMMABLE) || rover->fofflags & FOF_BLOCKOTHERS) continue; if (halfheight >= P_GetFFloorTopZAt(rover, thiscam->x, thiscam->y)) @@ -3807,10 +3807,10 @@ static void P_CheckCrumblingPlatforms(mobj_t *mobj) for (rover = node->m_sector->ffloors; rover; rover = rover->next) { - if (!(rover->flags & FF_EXISTS)) + if (!(rover->fofflags & FOF_EXISTS)) continue; - if (!(rover->flags & FF_CRUMBLE)) + if (!(rover->fofflags & FOF_CRUMBLE)) continue; if (mobj->eflags & MFE_VERTICALFLIP) @@ -3824,7 +3824,7 @@ static void P_CheckCrumblingPlatforms(mobj_t *mobj) continue; } - EV_StartCrumble(rover->master->frontsector, rover, (rover->flags & FF_FLOATBOB), mobj->player, rover->alpha, !(rover->flags & FF_NORETURN)); + EV_StartCrumble(rover->master->frontsector, rover, (rover->fofflags & FOF_FLOATBOB), mobj->player, rover->alpha, !(rover->fofflags & FOF_NORETURN)); } } } @@ -3842,10 +3842,10 @@ static boolean P_MobjTouchesSectorWithWater(mobj_t *mobj) for (rover = node->m_sector->ffloors; rover; rover = rover->next) { - if (!(rover->flags & FF_EXISTS)) + if (!(rover->fofflags & FOF_EXISTS)) continue; - if (!(rover->flags & FF_SWIMMABLE)) + if (!(rover->fofflags & FOF_SWIMMABLE)) continue; return true; @@ -3876,10 +3876,10 @@ static void P_CheckFloatbobPlatforms(mobj_t *mobj) for (rover = node->m_sector->ffloors; rover; rover = rover->next) { - if (!(rover->flags & FF_EXISTS)) + if (!(rover->fofflags & FOF_EXISTS)) continue; - if (!(rover->flags & FF_FLOATBOB)) + if (!(rover->fofflags & FOF_FLOATBOB)) continue; @@ -4006,12 +4006,12 @@ void P_CalculatePrecipFloor(precipmobj_t *mobj) for (rover = mobjsecsubsec->ffloors; rover; rover = rover->next) { // If it exists, it'll get rained on. - if (!(rover->flags & FF_EXISTS)) + if (!(rover->fofflags & FOF_EXISTS)) continue; if (precipprops[curWeather].effects & PRECIPFX_WATERPARTICLES) { - if (!(rover->flags & FF_SWIMMABLE)) + if (!(rover->fofflags & FOF_SWIMMABLE)) continue; if (setWater == false) @@ -4033,7 +4033,7 @@ void P_CalculatePrecipFloor(precipmobj_t *mobj) } else { - if (!(rover->flags & FF_BLOCKOTHERS) && !(rover->flags & FF_SWIMMABLE)) + if (!(rover->fofflags & FOF_BLOCKOTHERS) && !(rover->fofflags & FOF_SWIMMABLE)) continue; height = P_GetFFloorTopZAt(rover, mobj->x, mobj->y); @@ -10874,10 +10874,10 @@ static void P_SpawnPrecipitationAt(fixed_t basex, fixed_t basey) for (rover = precipsector->sector->ffloors; rover; rover = rover->next) { - if (!(rover->flags & FF_EXISTS)) + if (!(rover->fofflags & FOF_EXISTS)) continue; - if (!(rover->flags & FF_SWIMMABLE)) + if (!(rover->fofflags & FOF_SWIMMABLE)) continue; condition = true; @@ -12756,7 +12756,7 @@ static boolean P_SetupSpawnedMapThing(mapthing_t *mthing, mobj_t *mobj, boolean ffloor_t *rover; for (rover = sec->ffloors; rover; rover = rover->next) { - if ((rover->flags & FF_EXISTS) && (rover->flags & FF_BLOCKOTHERS)) + if ((rover->fofflags & FOF_EXISTS) && (rover->fofflags & FOF_BLOCKOTHERS)) { if (mthing->options & MTF_OBJECTFLIP) { diff --git a/src/p_saveg.c b/src/p_saveg.c index 559deb186..91960e4d2 100644 --- a/src/p_saveg.c +++ b/src/p_saveg.c @@ -1064,7 +1064,7 @@ static boolean CheckFFloorDiff(const sector_t *ss) for (rover = ss->ffloors; rover; rover = rover->next) { - if (rover->flags != rover->spawnflags + if (rover->fofflags != rover->spawnflags || rover->alpha != rover->spawnalpha) { return true; // we found an FOF that changed! @@ -1084,7 +1084,7 @@ static void ArchiveFFloors(const sector_t *ss) for (rover = ss->ffloors; rover; rover = rover->next) { fflr_diff = 0; // reset diff flags - if (rover->flags != rover->spawnflags) + if (rover->fofflags != rover->spawnflags) fflr_diff |= FD_FLAGS; if (rover->alpha != rover->spawnalpha) fflr_diff |= FD_ALPHA; @@ -1094,7 +1094,7 @@ static void ArchiveFFloors(const sector_t *ss) WRITEUINT16(save_p, j); // save ffloor "number" WRITEUINT8(save_p, fflr_diff); if (fflr_diff & FD_FLAGS) - WRITEUINT32(save_p, rover->flags); + WRITEUINT32(save_p, rover->fofflags); if (fflr_diff & FD_ALPHA) WRITEINT16(save_p, rover->alpha); } @@ -1132,7 +1132,7 @@ static void UnArchiveFFloors(const sector_t *ss) fflr_diff = READUINT8(save_p); if (fflr_diff & FD_FLAGS) - rover->flags = READUINT32(save_p); + rover->fofflags = READUINT32(save_p); if (fflr_diff & FD_ALPHA) rover->alpha = READINT16(save_p); diff --git a/src/p_setup.c b/src/p_setup.c index 696732e4e..c16751322 100644 --- a/src/p_setup.c +++ b/src/p_setup.c @@ -1923,9 +1923,9 @@ static void P_WriteTextmap(void) freetag = Tag_NextUnused(freetag); break; case 259: - if (wlines[i].args[3] & FF_QUICKSAND) + if (wlines[i].args[3] & FOF_QUICKSAND) CONS_Alert(CONS_WARNING, M_GetText("Quicksand properties of custom FOF on linedef %s cannot be converted. Use linedef type 75 instead.\n"), sizeu1(i)); - if (wlines[i].args[3] & FF_BUSTUP) + if (wlines[i].args[3] & FOF_BUSTUP) CONS_Alert(CONS_WARNING, M_GetText("Bustable properties of custom FOF on linedef %s cannot be converted. Use linedef type 74 instead.\n"), sizeu1(i)); break; case 412: @@ -3860,67 +3860,67 @@ static INT32 P_GetFOFFlags(INT32 oldflags) { INT32 result = 0; if (oldflags & FF_OLD_EXISTS) - result |= FF_EXISTS; + result |= FOF_EXISTS; if (oldflags & FF_OLD_BLOCKPLAYER) - result |= FF_BLOCKPLAYER; + result |= FOF_BLOCKPLAYER; if (oldflags & FF_OLD_BLOCKOTHERS) - result |= FF_BLOCKOTHERS; + result |= FOF_BLOCKOTHERS; if (oldflags & FF_OLD_RENDERSIDES) - result |= FF_RENDERSIDES; + result |= FOF_RENDERSIDES; if (oldflags & FF_OLD_RENDERPLANES) - result |= FF_RENDERPLANES; + result |= FOF_RENDERPLANES; if (oldflags & FF_OLD_SWIMMABLE) - result |= FF_SWIMMABLE; + result |= FOF_SWIMMABLE; if (oldflags & FF_OLD_NOSHADE) - result |= FF_NOSHADE; + result |= FOF_NOSHADE; if (oldflags & FF_OLD_CUTSOLIDS) - result |= FF_CUTSOLIDS; + result |= FOF_CUTSOLIDS; if (oldflags & FF_OLD_CUTEXTRA) - result |= FF_CUTEXTRA; + result |= FOF_CUTEXTRA; if (oldflags & FF_OLD_CUTSPRITES) - result |= FF_CUTSPRITES; + result |= FOF_CUTSPRITES; if (oldflags & FF_OLD_BOTHPLANES) - result |= FF_BOTHPLANES; + result |= FOF_BOTHPLANES; if (oldflags & FF_OLD_EXTRA) - result |= FF_EXTRA; + result |= FOF_EXTRA; if (oldflags & FF_OLD_TRANSLUCENT) - result |= FF_TRANSLUCENT; + result |= FOF_TRANSLUCENT; if (oldflags & FF_OLD_FOG) - result |= FF_FOG; + result |= FOF_FOG; if (oldflags & FF_OLD_INVERTPLANES) - result |= FF_INVERTPLANES; + result |= FOF_INVERTPLANES; if (oldflags & FF_OLD_ALLSIDES) - result |= FF_ALLSIDES; + result |= FOF_ALLSIDES; if (oldflags & FF_OLD_INVERTSIDES) - result |= FF_INVERTSIDES; + result |= FOF_INVERTSIDES; if (oldflags & FF_OLD_DOUBLESHADOW) - result |= FF_DOUBLESHADOW; + result |= FOF_DOUBLESHADOW; if (oldflags & FF_OLD_FLOATBOB) - result |= FF_FLOATBOB; + result |= FOF_FLOATBOB; if (oldflags & FF_OLD_NORETURN) - result |= FF_NORETURN; + result |= FOF_NORETURN; if (oldflags & FF_OLD_CRUMBLE) - result |= FF_CRUMBLE; + result |= FOF_CRUMBLE; if (oldflags & FF_OLD_GOOWATER) - result |= FF_GOOWATER; + result |= FOF_GOOWATER; if (oldflags & FF_OLD_MARIO) - result |= FF_MARIO; + result |= FOF_MARIO; if (oldflags & FF_OLD_BUSTUP) - result |= FF_BUSTUP; + result |= FOF_BUSTUP; if (oldflags & FF_OLD_QUICKSAND) - result |= FF_QUICKSAND; + result |= FOF_QUICKSAND; if (oldflags & FF_OLD_PLATFORM) - result |= FF_PLATFORM; + result |= FOF_PLATFORM; if (oldflags & FF_OLD_REVERSEPLATFORM) - result |= FF_REVERSEPLATFORM; + result |= FOF_REVERSEPLATFORM; if (oldflags & FF_OLD_RIPPLE) - result |= FF_RIPPLE; + result |= FOF_RIPPLE; if (oldflags & FF_OLD_COLORMAPONLY) - result |= FF_COLORMAPONLY; + result |= FOF_COLORMAPONLY; return result; } -static INT32 P_GetFOFBustflags(INT32 oldflags) +static INT32 P_GetFOFBusttype(INT32 oldflags) { if (oldflags & FF_OLD_SHATTER) return TMFB_TOUCH; @@ -4581,17 +4581,17 @@ static void P_ConvertBinaryLinedefTypes(void) lines[i].args[0] = tag; lines[i].args[3] = P_GetFOFFlags(sides[lines[i].sidenum[1]].toptexture); if (lines[i].flags & ML_EFFECT6) - lines[i].args[3] |= FF_SPLAT; - lines[i].args[4] = P_GetFOFBustflags(sides[lines[i].sidenum[1]].toptexture); + lines[i].args[3] |= FOF_SPLAT; + lines[i].args[4] = P_GetFOFBusttype(sides[lines[i].sidenum[1]].toptexture); if (sides[lines[i].sidenum[1]].toptexture & FF_OLD_SHATTERBOTTOM) lines[i].args[4] |= TMFB_ONLYBOTTOM; - if (lines[i].args[3] & FF_TRANSLUCENT) + if (lines[i].args[3] & FOF_TRANSLUCENT) { P_SetBinaryFOFAlpha(&lines[i]); //Replicate old hack: Translucent FOFs set to full opacity cut cyan pixels if (lines[i].args[1] == 256) - lines[i].args[3] |= FF_SPLAT; + lines[i].args[3] |= FOF_SPLAT; } else lines[i].args[1] = 255; diff --git a/src/p_sight.c b/src/p_sight.c index aee5798c3..4a8ccab39 100644 --- a/src/p_sight.c +++ b/src/p_sight.c @@ -309,8 +309,8 @@ static boolean P_CrossSubsector(size_t num, register los_t *los) // check front sector's FOFs first for (rover = front->ffloors; rover; rover = rover->next) { - if (!(rover->flags & FF_EXISTS) - || !(rover->flags & FF_RENDERSIDES) || rover->flags & FF_TRANSLUCENT) + if (!(rover->fofflags & FOF_EXISTS) + || !(rover->fofflags & FOF_RENDERSIDES) || (rover->fofflags & (FOF_TRANSLUCENT|FOF_FOG))) { continue; } @@ -326,8 +326,8 @@ static boolean P_CrossSubsector(size_t num, register los_t *los) // check back sector's FOFs as well for (rover = back->ffloors; rover; rover = rover->next) { - if (!(rover->flags & FF_EXISTS) - || !(rover->flags & FF_RENDERSIDES) || rover->flags & FF_TRANSLUCENT) + if (!(rover->fofflags & FOF_EXISTS) + || !(rover->fofflags & FOF_RENDERSIDES) || (rover->fofflags & (FOF_TRANSLUCENT|FOF_FOG))) { continue; } @@ -456,8 +456,8 @@ boolean P_CheckSight(mobj_t *t1, mobj_t *t2) // Allow sight through water, fog, etc. /// \todo Improve by checking fog density/translucency /// and setting a sight limit. - if (!(rover->flags & FF_EXISTS) - || !(rover->flags & FF_RENDERPLANES) /*|| (rover->flags & FF_TRANSLUCENT)*/) + if (!(rover->fofflags & FOF_EXISTS) + || !(rover->fofflags & FOF_RENDERPLANES) /*|| (rover->fofflags & (FOF_TRANSLUCENT|FOF_FOG))*/) { continue; } @@ -475,10 +475,10 @@ boolean P_CheckSight(mobj_t *t1, mobj_t *t2) return false; } - if (rover->flags & FF_SOLID) + if (rover->fofflags & FOF_SOLID) continue; // shortcut since neither mobj can be inside the 3dfloor - if (rover->flags & FF_BOTHPLANES || !(rover->flags & FF_INVERTPLANES)) + if (rover->fofflags & FOF_BOTHPLANES || !(rover->fofflags & FOF_INVERTPLANES)) { if (los.sightzstart >= topz1 && t2->z + t2->height < topz2) return false; // blocked by upper outside plane @@ -487,7 +487,7 @@ boolean P_CheckSight(mobj_t *t1, mobj_t *t2) return false; // blocked by lower outside plane } - if (rover->flags & FF_BOTHPLANES || rover->flags & FF_INVERTPLANES) + if (rover->fofflags & FOF_BOTHPLANES || rover->fofflags & FOF_INVERTPLANES) { if (los.sightzstart < topz1 && t2->z >= topz2) return false; // blocked by upper inside plane diff --git a/src/p_spec.c b/src/p_spec.c index 5e2eb4bc0..a651867ca 100644 --- a/src/p_spec.c +++ b/src/p_spec.c @@ -2884,16 +2884,16 @@ static void P_ProcessLineSpecial(line_t *line, mobj_t *mo, sector_t *callsec) { foundrover = true; - oldflags = rover->flags; + oldflags = rover->fofflags; // Abracadabra! if (line->args[2]) - rover->flags |= FF_EXISTS; + rover->fofflags |= FOF_EXISTS; else - rover->flags &= ~FF_EXISTS; + rover->fofflags &= ~FOF_EXISTS; // if flags changed, reset sector's light list - if (rover->flags != oldflags) + if (rover->fofflags != oldflags) { sec->moved = true; P_RecalcPrecipInSector(sec); @@ -2910,7 +2910,7 @@ static void P_ProcessLineSpecial(line_t *line, mobj_t *mo, sector_t *callsec) } break; - case 446: // Make block fall remotely (acts like FF_CRUMBLE) + case 446: // Make block fall remotely (acts like FOF_CRUMBLE) { INT16 sectag = (INT16)(line->args[0]); INT16 foftag = (INT16)(line->args[1]); @@ -2943,9 +2943,9 @@ static void P_ProcessLineSpecial(line_t *line, mobj_t *mo, sector_t *callsec) foundrover = true; if (line->args[2] & TMFR_CHECKFLAG) // FOF flags determine respawn ability instead? - respawn = !(rover->flags & FF_NORETURN) ^ !!(line->args[2] & TMFR_NORETURN); // TMFR_NORETURN inverts + respawn = !(rover->fofflags & FOF_NORETURN) ^ !!(line->args[2] & TMFR_NORETURN); // TMFR_NORETURN inverts - EV_StartCrumble(rover->master->frontsector, rover, (rover->flags & FF_FLOATBOB), player, rover->alpha, respawn); + EV_StartCrumble(rover->master->frontsector, rover, (rover->fofflags & FOF_FLOATBOB), player, rover->alpha, respawn); } } @@ -3143,10 +3143,10 @@ static void P_ProcessLineSpecial(line_t *line, mobj_t *mo, sector_t *callsec) // initialize its alpha to 1 // for relative alpha calc if (!(line->args[3] & TMST_DONTDOTRANSLUCENT) && // do translucent - (rover->spawnflags & FF_NOSHADE) && // do not include light blocks, which don't set FF_NOSHADE - !(rover->spawnflags & FF_RENDERSIDES) && - !(rover->spawnflags & FF_RENDERPLANES) && - !(rover->flags & FF_RENDERALL)) + (rover->spawnflags & FOF_NOSHADE) && // do not include light blocks, which don't set FOF_NOSHADE + !(rover->spawnflags & FOF_RENDERSIDES) && + !(rover->spawnflags & FOF_RENDERPLANES) && + !(rover->fofflags & FOF_RENDERALL)) rover->alpha = 1; P_RemoveFakeFloorFader(rover); @@ -3155,8 +3155,8 @@ static void P_ProcessLineSpecial(line_t *line, mobj_t *mo, sector_t *callsec) max(1, min(256, (line->args[3] & TMST_RELATIVE) ? rover->alpha + destvalue : destvalue)), 0, // set alpha immediately false, NULL, // tic-based logic - false, // do not handle FF_EXISTS - !(line->args[3] & TMST_DONTDOTRANSLUCENT), // handle FF_TRANSLUCENT + false, // do not handle FOF_EXISTS + !(line->args[3] & TMST_DONTDOTRANSLUCENT), // handle FOF_TRANSLUCENT false, // do not handle lighting false, // do not handle colormap false, // do not handle collision @@ -3216,8 +3216,8 @@ static void P_ProcessLineSpecial(line_t *line, mobj_t *mo, sector_t *callsec) speed, (line->args[4] & TMFT_TICBASED), // tic-based logic (line->args[4] & TMFT_RELATIVE), // Relative destvalue - !(line->args[4] & TMFT_DONTDOEXISTS), // do not handle FF_EXISTS - !(line->args[4] & TMFT_DONTDOTRANSLUCENT), // do not handle FF_TRANSLUCENT + !(line->args[4] & TMFT_DONTDOEXISTS), // do not handle FOF_EXISTS + !(line->args[4] & TMFT_DONTDOTRANSLUCENT), // do not handle FOF_TRANSLUCENT !(line->args[4] & TMFT_DONTDOLIGHTING), // do not handle lighting !(line->args[4] & TMFT_DONTDOCOLORMAP), // do not handle colormap !(line->args[4] & TMFT_IGNORECOLLISION), // do not handle collision @@ -3229,10 +3229,10 @@ static void P_ProcessLineSpecial(line_t *line, mobj_t *mo, sector_t *callsec) // initialize its alpha to 1 // for relative alpha calc if (!(line->args[4] & TMFT_DONTDOTRANSLUCENT) && // do translucent - (rover->spawnflags & FF_NOSHADE) && // do not include light blocks, which don't set FF_NOSHADE - !(rover->spawnflags & FF_RENDERSIDES) && - !(rover->spawnflags & FF_RENDERPLANES) && - !(rover->flags & FF_RENDERALL)) + (rover->spawnflags & FOF_NOSHADE) && // do not include light blocks, which don't set FOF_NOSHADE + !(rover->spawnflags & FOF_RENDERSIDES) && + !(rover->spawnflags & FOF_RENDERPLANES) && + !(rover->fofflags & FOF_RENDERALL)) rover->alpha = 1; P_RemoveFakeFloorFader(rover); @@ -3241,8 +3241,8 @@ static void P_ProcessLineSpecial(line_t *line, mobj_t *mo, sector_t *callsec) max(1, min(256, (line->args[4] & TMFT_RELATIVE) ? rover->alpha + destvalue : destvalue)), 0, // set alpha immediately false, NULL, // tic-based logic - !(line->args[4] & TMFT_DONTDOEXISTS), // do not handle FF_EXISTS - !(line->args[4] & TMFT_DONTDOTRANSLUCENT), // do not handle FF_TRANSLUCENT + !(line->args[4] & TMFT_DONTDOEXISTS), // do not handle FOF_EXISTS + !(line->args[4] & TMFT_DONTDOTRANSLUCENT), // do not handle FOF_TRANSLUCENT !(line->args[4] & TMFT_DONTDOLIGHTING), // do not handle lighting !(line->args[4] & TMFT_DONTDOCOLORMAP), // do not handle colormap !(line->args[4] & TMFT_IGNORECOLLISION), // do not handle collision @@ -3912,8 +3912,8 @@ boolean P_IsMobjTouching3DFloor(mobj_t *mo, ffloor_t *ffloor, sector_t *sec) fixed_t topheight = P_GetSpecialTopZ(mo, sectors + ffloor->secnum, sec); fixed_t bottomheight = P_GetSpecialBottomZ(mo, sectors + ffloor->secnum, sec); - if (((ffloor->flags & FF_BLOCKPLAYER) && mo->player) - || ((ffloor->flags & FF_BLOCKOTHERS) && !mo->player)) + if (((ffloor->fofflags & FOF_BLOCKPLAYER) && mo->player) + || ((ffloor->fofflags & FOF_BLOCKOTHERS) && !mo->player)) { // Solid 3D floor: Mobj must touch the top or bottom return P_IsMobjTouchingPlane(mo, ffloor->master->frontsector, topheight, bottomheight); @@ -3951,7 +3951,7 @@ static sector_t *P_MobjTouching3DFloorSpecial(mobj_t *mo, sector_t *sector, INT3 if (GETSECSPECIAL(rover->master->frontsector->special, section) != number) continue; - if (!(rover->flags & FF_EXISTS)) + if (!(rover->fofflags & FOF_EXISTS)) continue; if (!P_IsMobjTouching3DFloor(mo, rover, sector)) @@ -3975,7 +3975,7 @@ static sector_t *P_MobjTouching3DFloorSpecialFlag(mobj_t *mo, sector_t *sector, if (!(rover->master->frontsector->specialflags & flag)) continue; - if (!(rover->flags & FF_EXISTS)) + if (!(rover->fofflags & FOF_EXISTS)) continue; if (!P_IsMobjTouching3DFloor(mo, rover, sector)) @@ -4163,7 +4163,7 @@ static sector_t *P_CheckPlayer3DFloorTrigger(player_t *player, sector_t *sector, if (rover->master->frontsector->triggerer == TO_MOBJ) continue; - if (!(rover->flags & FF_EXISTS)) + if (!(rover->fofflags & FOF_EXISTS)) continue; if (!Tag_Find(&sourceline->tags, rover->master->frontsector->triggertag)) @@ -4723,7 +4723,7 @@ static void P_PlayerOnSpecial3DFloor(player_t *player, sector_t *sector) if (!P_SectorHasSpecial(rover->master->frontsector)) continue; - if (!(rover->flags & FF_EXISTS)) + if (!(rover->fofflags & FOF_EXISTS)) continue; if (!P_IsMobjTouching3DFloor(player->mo, rover, sector)) @@ -4831,7 +4831,7 @@ static void P_CheckMobj3DFloorTrigger(mobj_t *mo, sector_t *sec) if (rover->master->frontsector->triggerer != TO_MOBJ) continue; - if (!(rover->flags & FF_EXISTS)) + if (!(rover->fofflags & FOF_EXISTS)) continue; if (!P_IsMobjTouching3DFloor(mo, rover, sec)) @@ -5097,7 +5097,7 @@ static ffloor_t *P_AddFakeFloor(sector_t *sec, sector_t *sec2, line_t *master, I sec2->attachedsolid = Z_Malloc(sizeof (*sec2->attachedsolid) * sec2->maxattached, PU_STATIC, NULL); sec2->attached[0] = sec - sectors; sec2->numattached = 1; - sec2->attachedsolid[0] = (flags & FF_SOLID); + sec2->attachedsolid[0] = (flags & FOF_SOLID); } else { @@ -5112,7 +5112,7 @@ static ffloor_t *P_AddFakeFloor(sector_t *sec, sector_t *sec2, line_t *master, I sec2->attachedsolid = Z_Realloc(sec2->attachedsolid, sizeof (*sec2->attachedsolid) * sec2->maxattached, PU_STATIC, NULL); } sec2->attached[sec2->numattached] = sec - sectors; - sec2->attachedsolid[sec2->numattached] = (flags & FF_SOLID); + sec2->attachedsolid[sec2->numattached] = (flags & FOF_SOLID); sec2->numattached++; } @@ -5142,7 +5142,7 @@ static ffloor_t *P_AddFakeFloor(sector_t *sec, sector_t *sec2, line_t *master, I if (sec2->hasslope) sec->hasslope = true; - fflr->spawnflags = fflr->flags = flags; + fflr->spawnflags = fflr->fofflags = flags; fflr->master = master; fflr->norender = INFTICS; fflr->fadingdata = NULL; @@ -5190,10 +5190,10 @@ static ffloor_t *P_AddFakeFloor(sector_t *sec, sector_t *sec2, line_t *master, I } fflr->alpha = max(0, min(0xff, alpha)); - if (fflr->alpha < 0xff || flags & FF_SPLAT) + if (fflr->alpha < 0xff || flags & FOF_SPLAT) { - fflr->flags |= FF_TRANSLUCENT; - fflr->spawnflags = fflr->flags; + fflr->fofflags |= FOF_TRANSLUCENT; + fflr->spawnflags = fflr->fofflags; } fflr->spawnalpha = fflr->alpha; // save for netgames @@ -5217,23 +5217,23 @@ static ffloor_t *P_AddFakeFloor(sector_t *sec, sector_t *sec2, line_t *master, I break; } - if (flags & FF_QUICKSAND) + if (flags & FOF_QUICKSAND) CheckForQuicksand = true; - if (flags & FF_BUSTUP) + if (flags & FOF_BUSTUP) CheckForBustableBlocks = true; - if ((flags & FF_MARIO)) + if ((flags & FOF_MARIO)) { - if (!(flags & FF_GOOWATER)) // Don't change the textures of a brick block, just a question block + if (!(flags & FOF_GOOWATER)) // Don't change the textures of a brick block, just a question block P_AddBlockThinker(sec2, master); CheckForMarioBlocks = true; } - if ((flags & FF_CRUMBLE)) + if ((flags & FOF_CRUMBLE)) sec2->crumblestate = CRUMBLE_WAIT; - if ((flags & FF_FLOATBOB)) + if ((flags & FOF_FLOATBOB)) { P_AddFloatThinker(sec2, master->args[0], master); CheckForFloatBob = true; @@ -5577,14 +5577,14 @@ void T_LaserFlash(laserthink_t *flash) if (fflr->master != flash->sourceline) continue; - if (!(fflr->flags & FF_EXISTS)) + if (!(fflr->fofflags & FOF_EXISTS)) break; if (leveltime & 2) - //fflr->flags |= FF_RENDERALL; + //fflr->flags |= FOF_RENDERALL; fflr->alpha = 0xB0; else - //fflr->flags &= ~FF_RENDERALL; + //fflr->flags &= ~FOF_RENDERALL; fflr->alpha = 0x90; top = P_GetFFloorTopZAt (fflr, sector->soundorg.x, sector->soundorg.y); @@ -5730,8 +5730,8 @@ static void P_MakeFOFBouncy(line_t *paramline, line_t *masterline) if (rover->master != masterline) continue; - rover->flags |= FF_BOUNCY; - rover->spawnflags |= FF_BOUNCY; + rover->fofflags |= FOF_BOUNCY; + rover->spawnflags |= FOF_BOUNCY; rover->bouncestrength = (paramline->args[1]<< FRACBITS)/100; CheckForBouncySector = true; break; @@ -6093,117 +6093,117 @@ void P_SpawnSpecials(boolean fromnetsave) break; case 100: // FOF (solid) - ffloorflags = FF_EXISTS|FF_SOLID|FF_RENDERALL; + ffloorflags = FOF_EXISTS|FOF_SOLID|FOF_RENDERALL; //Appearance settings if (lines[i].args[3] & TMFA_NOPLANES) - ffloorflags &= ~FF_RENDERPLANES; + ffloorflags &= ~FOF_RENDERPLANES; if (lines[i].args[3] & TMFA_NOSIDES) - ffloorflags &= ~FF_RENDERSIDES; + ffloorflags &= ~FOF_RENDERSIDES; if (lines[i].args[3] & TMFA_INSIDES) { - if (ffloorflags & FF_RENDERPLANES) - ffloorflags |= FF_BOTHPLANES; - if (ffloorflags & FF_RENDERSIDES) - ffloorflags |= FF_ALLSIDES; + if (ffloorflags & FOF_RENDERPLANES) + ffloorflags |= FOF_BOTHPLANES; + if (ffloorflags & FOF_RENDERSIDES) + ffloorflags |= FOF_ALLSIDES; } if (lines[i].args[3] & TMFA_ONLYINSIDES) { - if (ffloorflags & FF_RENDERPLANES) - ffloorflags |= FF_INVERTPLANES; - if (ffloorflags & FF_RENDERSIDES) - ffloorflags |= FF_INVERTSIDES; + if (ffloorflags & FOF_RENDERPLANES) + ffloorflags |= FOF_INVERTPLANES; + if (ffloorflags & FOF_RENDERSIDES) + ffloorflags |= FOF_INVERTSIDES; } if (lines[i].args[3] & TMFA_NOSHADE) - ffloorflags |= FF_NOSHADE; + ffloorflags |= FOF_NOSHADE; if (lines[i].args[3] & TMFA_SPLAT) - ffloorflags |= FF_SPLAT; + ffloorflags |= FOF_SPLAT; //Tangibility settings if (lines[i].args[4] & TMFT_INTANGIBLETOP) - ffloorflags |= FF_REVERSEPLATFORM; + ffloorflags |= FOF_REVERSEPLATFORM; if (lines[i].args[4] & TMFT_INTANGIBLEBOTTOM) - ffloorflags |= FF_PLATFORM; + ffloorflags |= FOF_PLATFORM; if (lines[i].args[4] & TMFT_DONTBLOCKPLAYER) - ffloorflags &= ~FF_BLOCKPLAYER; + ffloorflags &= ~FOF_BLOCKPLAYER; if (lines[i].args[4] & TMFT_DONTBLOCKOTHERS) - ffloorflags &= ~FF_BLOCKOTHERS; + ffloorflags &= ~FOF_BLOCKOTHERS; //Cutting options - if (ffloorflags & FF_RENDERALL) + if (ffloorflags & FOF_RENDERALL) { //If translucent or player can enter it, cut inner walls if ((lines[i].args[1] < 255) || (lines[i].args[4] & TMFT_VISIBLEFROMINSIDE)) - ffloorflags |= FF_CUTEXTRA|FF_EXTRA; + ffloorflags |= FOF_CUTEXTRA|FOF_EXTRA; else - ffloorflags |= FF_CUTLEVEL; + ffloorflags |= FOF_CUTLEVEL; } P_AddFakeFloorsByLine(i, lines[i].args[1], lines[i].args[2], ffloorflags, secthinkers); break; case 120: // FOF (water) - ffloorflags = FF_EXISTS|FF_RENDERPLANES|FF_SWIMMABLE|FF_BOTHPLANES|FF_CUTEXTRA|FF_EXTRA|FF_CUTSPRITES; + ffloorflags = FOF_EXISTS|FOF_RENDERPLANES|FOF_SWIMMABLE|FOF_BOTHPLANES|FOF_CUTEXTRA|FOF_EXTRA|FOF_CUTSPRITES; if (!(lines[i].args[3] & TMFW_NOSIDES)) - ffloorflags |= FF_RENDERSIDES|FF_ALLSIDES; + ffloorflags |= FOF_RENDERSIDES|FOF_ALLSIDES; if (lines[i].args[3] & TMFW_DOUBLESHADOW) - ffloorflags |= FF_DOUBLESHADOW; + ffloorflags |= FOF_DOUBLESHADOW; if (lines[i].args[3] & TMFW_COLORMAPONLY) - ffloorflags |= FF_COLORMAPONLY; + ffloorflags |= FOF_COLORMAPONLY; if (!(lines[i].args[3] & TMFW_NORIPPLE)) - ffloorflags |= FF_RIPPLE; + ffloorflags |= FOF_RIPPLE; if (lines[i].args[3] & TMFW_GOOWATER) - ffloorflags |= FF_GOOWATER; + ffloorflags |= FOF_GOOWATER; if (lines[i].args[3] & TMFW_SPLAT) - ffloorflags |= FF_SPLAT; + ffloorflags |= FOF_SPLAT; P_AddFakeFloorsByLine(i, lines[i].args[1], lines[i].args[2], ffloorflags, secthinkers); break; case 150: // FOF (Air bobbing) - P_AddFakeFloorsByLine(i, 0xff, TMB_TRANSLUCENT, FF_EXISTS|FF_SOLID|FF_RENDERALL, secthinkers); + P_AddFakeFloorsByLine(i, 0xff, TMB_TRANSLUCENT, FOF_EXISTS|FOF_SOLID|FOF_RENDERALL, secthinkers); P_AddAirbob(lines[i].frontsector, lines[i].args[0], lines[i].args[1] << FRACBITS, !!(lines[i].args[2] & TMFB_REVERSE), !!(lines[i].args[2] & TMFB_SPINDASH), !!(lines[i].args[2] & TMFB_DYNAMIC)); break; case 160: // FOF (Water bobbing) - P_AddFakeFloorsByLine(i, 0xff, TMB_TRANSLUCENT, FF_EXISTS|FF_SOLID|FF_RENDERALL|FF_FLOATBOB, secthinkers); + P_AddFakeFloorsByLine(i, 0xff, TMB_TRANSLUCENT, FOF_EXISTS|FOF_SOLID|FOF_RENDERALL|FOF_FLOATBOB, secthinkers); break; case 170: // FOF (Crumbling) - ffloorflags = FF_EXISTS|FF_SOLID|FF_RENDERALL|FF_CRUMBLE; + ffloorflags = FOF_EXISTS|FOF_SOLID|FOF_RENDERALL|FOF_CRUMBLE; //Tangibility settings if (lines[i].args[3] & TMFT_INTANGIBLETOP) - ffloorflags |= FF_REVERSEPLATFORM; + ffloorflags |= FOF_REVERSEPLATFORM; if (lines[i].args[3] & TMFT_INTANGIBLEBOTTOM) - ffloorflags |= FF_PLATFORM; + ffloorflags |= FOF_PLATFORM; if (lines[i].args[3] & TMFT_DONTBLOCKPLAYER) - ffloorflags &= ~FF_BLOCKPLAYER; + ffloorflags &= ~FOF_BLOCKPLAYER; if (lines[i].args[3] & TMFT_DONTBLOCKOTHERS) - ffloorflags &= ~FF_BLOCKOTHERS; + ffloorflags &= ~FOF_BLOCKOTHERS; //Flags if (lines[i].args[4] & TMFC_NOSHADE) - ffloorflags |= FF_NOSHADE; + ffloorflags |= FOF_NOSHADE; if (lines[i].args[4] & TMFC_NORETURN) - ffloorflags |= FF_NORETURN; + ffloorflags |= FOF_NORETURN; if (lines[i].args[4] & TMFC_FLOATBOB) - ffloorflags |= FF_FLOATBOB; + ffloorflags |= FOF_FLOATBOB; if (lines[i].args[4] & TMFC_SPLAT) - ffloorflags |= FF_SPLAT; + ffloorflags |= FOF_SPLAT; //If translucent or player can enter it, cut inner walls if (lines[i].args[1] < 0xff || (lines[i].args[3] & TMFT_VISIBLEFROMINSIDE)) - ffloorflags |= FF_CUTEXTRA|FF_EXTRA; + ffloorflags |= FOF_CUTEXTRA|FOF_EXTRA; else - ffloorflags |= FF_CUTLEVEL; + ffloorflags |= FOF_CUTLEVEL; //If player can enter it, render insides if (lines[i].args[3] & TMFT_VISIBLEFROMINSIDE) { - if (ffloorflags & FF_RENDERPLANES) - ffloorflags |= FF_BOTHPLANES; - if (ffloorflags & FF_RENDERSIDES) - ffloorflags |= FF_ALLSIDES; + if (ffloorflags & FOF_RENDERPLANES) + ffloorflags |= FOF_BOTHPLANES; + if (ffloorflags & FOF_RENDERSIDES) + ffloorflags |= FOF_ALLSIDES; } P_AddFakeFloorsByLine(i, lines[i].args[1], lines[i].args[2], ffloorflags, secthinkers); @@ -6216,50 +6216,50 @@ void P_SpawnSpecials(boolean fromnetsave) fixed_t ceilingtop = P_FindHighestCeilingSurrounding(lines[i].frontsector); fixed_t ceilingbottom = P_FindLowestCeilingSurrounding(lines[i].frontsector); - ffloorflags = FF_EXISTS|FF_SOLID|FF_RENDERALL; + ffloorflags = FOF_EXISTS|FOF_SOLID|FOF_RENDERALL; //Appearance settings if (lines[i].args[3] & TMFA_NOPLANES) - ffloorflags &= ~FF_RENDERPLANES; + ffloorflags &= ~FOF_RENDERPLANES; if (lines[i].args[3] & TMFA_NOSIDES) - ffloorflags &= ~FF_RENDERSIDES; + ffloorflags &= ~FOF_RENDERSIDES; if (lines[i].args[3] & TMFA_INSIDES) { - if (ffloorflags & FF_RENDERPLANES) - ffloorflags |= FF_BOTHPLANES; - if (ffloorflags & FF_RENDERSIDES) - ffloorflags |= FF_ALLSIDES; + if (ffloorflags & FOF_RENDERPLANES) + ffloorflags |= FOF_BOTHPLANES; + if (ffloorflags & FOF_RENDERSIDES) + ffloorflags |= FOF_ALLSIDES; } if (lines[i].args[3] & TMFA_ONLYINSIDES) { - if (ffloorflags & FF_RENDERPLANES) - ffloorflags |= FF_INVERTPLANES; - if (ffloorflags & FF_RENDERSIDES) - ffloorflags |= FF_INVERTSIDES; + if (ffloorflags & FOF_RENDERPLANES) + ffloorflags |= FOF_INVERTPLANES; + if (ffloorflags & FOF_RENDERSIDES) + ffloorflags |= FOF_INVERTSIDES; } if (lines[i].args[3] & TMFA_NOSHADE) - ffloorflags |= FF_NOSHADE; + ffloorflags |= FOF_NOSHADE; if (lines[i].args[3] & TMFA_SPLAT) - ffloorflags |= FF_SPLAT; + ffloorflags |= FOF_SPLAT; //Tangibility settings if (lines[i].args[4] & TMFT_INTANGIBLETOP) - ffloorflags |= FF_REVERSEPLATFORM; + ffloorflags |= FOF_REVERSEPLATFORM; if (lines[i].args[4] & TMFT_INTANGIBLEBOTTOM) - ffloorflags |= FF_PLATFORM; + ffloorflags |= FOF_PLATFORM; if (lines[i].args[4] & TMFT_DONTBLOCKPLAYER) - ffloorflags &= ~FF_BLOCKPLAYER; + ffloorflags &= ~FOF_BLOCKPLAYER; if (lines[i].args[4] & TMFT_DONTBLOCKOTHERS) - ffloorflags &= ~FF_BLOCKOTHERS; + ffloorflags &= ~FOF_BLOCKOTHERS; //Cutting options - if (ffloorflags & FF_RENDERALL) + if (ffloorflags & FOF_RENDERALL) { //If translucent or player can enter it, cut inner walls if ((lines[i].args[1] < 255) || (lines[i].args[4] & TMFT_VISIBLEFROMINSIDE)) - ffloorflags |= FF_CUTEXTRA|FF_EXTRA; + ffloorflags |= FOF_CUTEXTRA|FOF_EXTRA; else - ffloorflags |= FF_CUTLEVEL; + ffloorflags |= FOF_CUTLEVEL; } P_AddFakeFloorsByLine(i, lines[i].args[1], lines[i].args[2], ffloorflags, secthinkers); @@ -6267,14 +6267,14 @@ void P_SpawnSpecials(boolean fromnetsave) break; } case 200: // Light block - ffloorflags = FF_EXISTS|FF_CUTSPRITES; + ffloorflags = FOF_EXISTS|FOF_CUTSPRITES; if (!lines[i].args[1]) - ffloorflags |= FF_DOUBLESHADOW; + ffloorflags |= FOF_DOUBLESHADOW; P_AddFakeFloorsByLine(i, 0xff, TMB_TRANSLUCENT, ffloorflags, secthinkers); break; case 202: // Fog - ffloorflags = FF_EXISTS|FF_RENDERALL|FF_FOG|FF_INVERTPLANES|FF_INVERTSIDES|FF_CUTEXTRA|FF_EXTRA|FF_DOUBLESHADOW|FF_CUTSPRITES; + ffloorflags = FOF_EXISTS|FOF_RENDERALL|FOF_FOG|FOF_INVERTPLANES|FOF_INVERTSIDES|FOF_CUTEXTRA|FOF_EXTRA|FOF_DOUBLESHADOW|FOF_CUTSPRITES; sec = sides[*lines[i].sidenum].sector - sectors; // SoM: Because it's fog, check for an extra colormap and set the fog flag... if (sectors[sec].extra_colormap) @@ -6283,45 +6283,45 @@ void P_SpawnSpecials(boolean fromnetsave) break; case 220: //Intangible - ffloorflags = FF_EXISTS|FF_RENDERALL|FF_CUTEXTRA|FF_EXTRA|FF_CUTSPRITES; + ffloorflags = FOF_EXISTS|FOF_RENDERALL|FOF_CUTEXTRA|FOF_EXTRA|FOF_CUTSPRITES; //Appearance settings if (lines[i].args[3] & TMFA_NOPLANES) - ffloorflags &= ~FF_RENDERPLANES; + ffloorflags &= ~FOF_RENDERPLANES; if (lines[i].args[3] & TMFA_NOSIDES) - ffloorflags &= ~FF_RENDERSIDES; + ffloorflags &= ~FOF_RENDERSIDES; if (!(lines[i].args[3] & TMFA_INSIDES)) { - if (ffloorflags & FF_RENDERPLANES) - ffloorflags |= FF_BOTHPLANES; - if (ffloorflags & FF_RENDERSIDES) - ffloorflags |= FF_ALLSIDES; + if (ffloorflags & FOF_RENDERPLANES) + ffloorflags |= FOF_BOTHPLANES; + if (ffloorflags & FOF_RENDERSIDES) + ffloorflags |= FOF_ALLSIDES; } if (lines[i].args[3] & TMFA_ONLYINSIDES) { - if (ffloorflags & FF_RENDERPLANES) - ffloorflags |= FF_INVERTPLANES; - if (ffloorflags & FF_RENDERSIDES) - ffloorflags |= FF_INVERTSIDES; + if (ffloorflags & FOF_RENDERPLANES) + ffloorflags |= FOF_INVERTPLANES; + if (ffloorflags & FOF_RENDERSIDES) + ffloorflags |= FOF_INVERTSIDES; } if (lines[i].args[3] & TMFA_NOSHADE) - ffloorflags |= FF_NOSHADE; + ffloorflags |= FOF_NOSHADE; if (lines[i].args[3] & TMFA_SPLAT) - ffloorflags |= FF_SPLAT; + ffloorflags |= FOF_SPLAT; P_AddFakeFloorsByLine(i, lines[i].args[1], lines[i].args[2], ffloorflags, secthinkers); break; case 223: // FOF (intangible, invisible) - for combining specials in a sector - P_AddFakeFloorsByLine(i, 0xff, TMB_TRANSLUCENT, FF_EXISTS|FF_NOSHADE, secthinkers); + P_AddFakeFloorsByLine(i, 0xff, TMB_TRANSLUCENT, FOF_EXISTS|FOF_NOSHADE, secthinkers); break; case 250: // Mario Block - ffloorflags = FF_EXISTS|FF_SOLID|FF_RENDERALL|FF_CUTLEVEL|FF_MARIO; + ffloorflags = FOF_EXISTS|FOF_SOLID|FOF_RENDERALL|FOF_CUTLEVEL|FOF_MARIO; if (lines[i].args[1] & TMFM_BRICK) - ffloorflags |= FF_GOOWATER; + ffloorflags |= FOF_GOOWATER; if (lines[i].args[1] & TMFM_INVISIBLE) - ffloorflags &= ~(FF_SOLID|FF_RENDERALL|FF_CUTLEVEL); + ffloorflags &= ~(FOF_SOLID|FOF_RENDERALL|FOF_CUTLEVEL); P_AddFakeFloorsByLine(i, 0xff, TMB_TRANSLUCENT, ffloorflags, secthinkers); break; @@ -6330,7 +6330,7 @@ void P_SpawnSpecials(boolean fromnetsave) { UINT16 sound = (lines[i].stringargs[0]) ? get_number(lines[i].stringargs[0]) : sfx_thwomp; P_AddThwompThinker(lines[i].frontsector, &lines[i], lines[i].args[1] << (FRACBITS - 3), lines[i].args[2] << (FRACBITS - 3), sound); - P_AddFakeFloorsByLine(i, 0xff, TMB_TRANSLUCENT, FF_EXISTS|FF_SOLID|FF_RENDERALL|FF_CUTLEVEL, secthinkers); + P_AddFakeFloorsByLine(i, 0xff, TMB_TRANSLUCENT, FOF_EXISTS|FOF_SOLID|FOF_RENDERALL|FOF_CUTLEVEL, secthinkers); break; } @@ -6339,7 +6339,7 @@ void P_SpawnSpecials(boolean fromnetsave) UINT8 busttype = BT_REGULAR; ffloorbustflags_e bustflags = 0; - ffloorflags = FF_EXISTS|FF_BLOCKOTHERS|FF_RENDERALL|FF_BUSTUP; + ffloorflags = FOF_EXISTS|FOF_BLOCKOTHERS|FOF_RENDERALL|FOF_BUSTUP; //Bustable type switch (lines[i].args[3]) @@ -6366,10 +6366,10 @@ void P_SpawnSpecials(boolean fromnetsave) if (lines[i].args[4] & TMFB_ONLYBOTTOM) bustflags |= FB_ONLYBOTTOM; if (lines[i].args[4] & TMFB_SPLAT) - ffloorflags |= FF_SPLAT; + ffloorflags |= FOF_SPLAT; if (busttype != BT_TOUCH || bustflags & FB_ONLYBOTTOM) - ffloorflags |= FF_BLOCKPLAYER; + ffloorflags |= FOF_BLOCKPLAYER; TAG_ITER_SECTORS(lines[i].args[0], s) { @@ -6383,9 +6383,9 @@ void P_SpawnSpecials(boolean fromnetsave) break; } case 257: // Quicksand - ffloorflags = FF_EXISTS|FF_QUICKSAND|FF_RENDERALL|FF_ALLSIDES|FF_CUTSPRITES; + ffloorflags = FOF_EXISTS|FOF_QUICKSAND|FOF_RENDERALL|FOF_ALLSIDES|FOF_CUTSPRITES; if (!(lines[i].args[1])) - ffloorflags |= FF_RIPPLE; + ffloorflags |= FOF_RIPPLE; TAG_ITER_SECTORS(lines[i].args[0], s) { @@ -6398,10 +6398,10 @@ void P_SpawnSpecials(boolean fromnetsave) break; case 258: // Laser block - ffloorflags = FF_EXISTS|FF_RENDERALL|FF_NOSHADE|FF_EXTRA|FF_CUTEXTRA|FF_TRANSLUCENT; + ffloorflags = FOF_EXISTS|FOF_RENDERALL|FOF_NOSHADE|FOF_EXTRA|FOF_CUTEXTRA|FOF_TRANSLUCENT; P_AddLaserThinker(lines[i].args[0], lines + i, !!(lines[i].args[3] & TMFL_NOBOSSES)); if (lines[i].args[3] & TMFL_SPLAT) - ffloorflags |= FF_SPLAT; + ffloorflags |= FOF_SPLAT; P_AddFakeFloorsByLine(i, lines[i].args[1], lines[i].args[2], ffloorflags, secthinkers); break; @@ -6413,12 +6413,12 @@ void P_SpawnSpecials(boolean fromnetsave) continue; if (!udmf) // Ugly backwards compatibility stuff { - if (lines[i].args[3] & FF_QUICKSAND) + if (lines[i].args[3] & FOF_QUICKSAND) { fflr->sinkspeed = abs(lines[i].dx) >> 1; fflr->friction = abs(lines[i].dy) >> 6; } - if (lines[i].args[3] & FF_BUSTUP) + if (lines[i].args[3] & FOF_BUSTUP) { switch (lines[i].args[4] % TMFB_ONLYBOTTOM) { @@ -6461,31 +6461,31 @@ void P_SpawnSpecials(boolean fromnetsave) if (dtype == 0) dtype = 1; - ffloorflags = FF_EXISTS; + ffloorflags = FOF_EXISTS; - if (dflags2 & 1) ffloorflags |= FF_NOSHADE; // Disable light effects (Means no shadowcast) - if (dflags2 & 2) ffloorflags |= FF_DOUBLESHADOW; // Restrict light inside (Means doubleshadow) + if (dflags2 & 1) ffloorflags |= FOF_NOSHADE; // Disable light effects (Means no shadowcast) + if (dflags2 & 2) ffloorflags |= FOF_DOUBLESHADOW; // Restrict light inside (Means doubleshadow) if (dflags2 & 4) isfog = true; // Fog effect (Explicitly render like a fog block) - if (dflags1 & 4) ffloorflags |= FF_BOTHPLANES|FF_ALLSIDES; // Render-inside - if (dflags1 & 16) ffloorflags |= FF_INVERTSIDES|FF_INVERTPLANES; // Invert visibility rules + if (dflags1 & 4) ffloorflags |= FOF_BOTHPLANES|FOF_ALLSIDES; // Render-inside + if (dflags1 & 16) ffloorflags |= FOF_INVERTSIDES|FOF_INVERTPLANES; // Invert visibility rules // Fog block if (isfog) - ffloorflags |= FF_RENDERALL|FF_CUTEXTRA|FF_CUTSPRITES|FF_BOTHPLANES|FF_EXTRA|FF_FOG|FF_INVERTPLANES|FF_ALLSIDES|FF_INVERTSIDES; + ffloorflags |= FOF_RENDERALL|FOF_CUTEXTRA|FOF_CUTSPRITES|FOF_BOTHPLANES|FOF_EXTRA|FOF_FOG|FOF_INVERTPLANES|FOF_ALLSIDES|FOF_INVERTSIDES; else { - ffloorflags |= FF_RENDERALL; + ffloorflags |= FOF_RENDERALL; // Solid if (dtype == 1) - ffloorflags |= FF_SOLID|FF_CUTLEVEL; + ffloorflags |= FOF_SOLID|FOF_CUTLEVEL; // Water else if (dtype == 2) - ffloorflags |= FF_SWIMMABLE|FF_CUTEXTRA|FF_CUTSPRITES|FF_EXTRA|FF_RIPPLE; + ffloorflags |= FOF_SWIMMABLE|FOF_CUTEXTRA|FOF_CUTSPRITES|FOF_EXTRA|FOF_RIPPLE; // Intangible else if (dtype == 3) - ffloorflags |= FF_CUTEXTRA|FF_CUTSPRITES|FF_EXTRA; + ffloorflags |= FOF_CUTEXTRA|FOF_CUTSPRITES|FOF_EXTRA; } // Non-opaque @@ -6495,19 +6495,19 @@ void P_SpawnSpecials(boolean fromnetsave) if (dopacity == 0) { // True invisible - if (ffloorflags & FF_NOSHADE) - ffloorflags &= ~(FF_RENDERALL|FF_CUTEXTRA|FF_CUTSPRITES|FF_EXTRA|FF_BOTHPLANES|FF_ALLSIDES|FF_CUTLEVEL); + if (ffloorflags & FOF_NOSHADE) + ffloorflags &= ~(FOF_RENDERALL|FOF_CUTEXTRA|FOF_CUTSPRITES|FOF_EXTRA|FOF_BOTHPLANES|FOF_ALLSIDES|FOF_CUTLEVEL); // Shadow block else { - ffloorflags |= FF_CUTSPRITES; - ffloorflags &= ~(FF_RENDERALL|FF_CUTEXTRA|FF_EXTRA|FF_BOTHPLANES|FF_ALLSIDES|FF_CUTLEVEL); + ffloorflags |= FOF_CUTSPRITES; + ffloorflags &= ~(FOF_RENDERALL|FOF_CUTEXTRA|FOF_EXTRA|FOF_BOTHPLANES|FOF_ALLSIDES|FOF_CUTLEVEL); } } else { - ffloorflags |= FF_TRANSLUCENT|FF_CUTEXTRA|FF_EXTRA; - ffloorflags &= ~FF_CUTLEVEL; + ffloorflags |= FOF_TRANSLUCENT|FOF_CUTEXTRA|FOF_EXTRA; + ffloorflags &= ~FOF_CUTLEVEL; } } @@ -6699,8 +6699,8 @@ void P_SpawnSpecials(boolean fromnetsave) if (rover->master != lines + l) continue; - rover->flags |= FF_BUSTUP; - rover->spawnflags |= FF_BUSTUP; + rover->fofflags |= FOF_BUSTUP; + rover->spawnflags |= FOF_BUSTUP; rover->bustflags = bustflags; rover->busttype = busttype; rover->busttag = lines[i].args[3]; @@ -6730,8 +6730,8 @@ void P_SpawnSpecials(boolean fromnetsave) if (rover->master != lines + l) continue; - rover->flags |= FF_QUICKSAND; - rover->spawnflags |= FF_QUICKSAND; + rover->fofflags |= FOF_QUICKSAND; + rover->spawnflags |= FOF_QUICKSAND; rover->sinkspeed = abs(lines[i].args[1]) << (FRACBITS - 1); rover->friction = abs(lines[i].args[2]) << (FRACBITS - 6); CheckForQuicksand = true; @@ -7001,7 +7001,7 @@ void T_Scroll(scroll_t *s) if (!rover) // This should be impossible, but don't complain if it is the case somehow continue; - if (!(rover->flags & FF_EXISTS)) // If the FOF does not "exist", we pretend that nobody's there + if (!(rover->fofflags & FOF_EXISTS)) // If the FOF does not "exist", we pretend that nobody's there continue; for (node = psec->touching_thinglist; node; node = node->m_thinglist_next) @@ -7076,7 +7076,7 @@ void T_Scroll(scroll_t *s) if (!rover) // This should be impossible, but don't complain if it is the case somehow continue; - if (!(rover->flags & FF_EXISTS)) // If the FOF does not "exist", we pretend that nobody's there + if (!(rover->fofflags & FOF_EXISTS)) // If the FOF does not "exist", we pretend that nobody's there continue; for (node = psec->touching_thinglist; node; node = node->m_thinglist_next) @@ -7315,10 +7315,10 @@ void T_Disappear(disappear_t *d) continue; if (d->exists) - rover->flags &= ~FF_EXISTS; + rover->fofflags &= ~FOF_EXISTS; else { - rover->flags |= FF_EXISTS; + rover->fofflags |= FOF_EXISTS; if (!(lines[d->sourceline].args[5])) { @@ -7403,11 +7403,11 @@ static boolean P_FadeFakeFloor(ffloor_t *rover, INT16 sourcevalue, INT16 destval // If fading an invisible FOF whose render flags we did not yet set, // initialize its alpha to 1 if (dotranslucent && - (rover->spawnflags & FF_NOSHADE) && // do not include light blocks, which don't set FF_NOSHADE - !(rover->flags & FF_FOG) && // do not include fog - !(rover->spawnflags & FF_RENDERSIDES) && - !(rover->spawnflags & FF_RENDERPLANES) && - !(rover->flags & FF_RENDERALL)) + (rover->spawnflags & FOF_NOSHADE) && // do not include light blocks, which don't set FOF_NOSHADE + !(rover->fofflags & FOF_FOG) && // do not include fog + !(rover->spawnflags & FOF_RENDERSIDES) && + !(rover->spawnflags & FOF_RENDERPLANES) && + !(rover->fofflags & FOF_RENDERALL)) rover->alpha = 1; if (fadingdata) @@ -7428,16 +7428,16 @@ static boolean P_FadeFakeFloor(ffloor_t *rover, INT16 sourcevalue, INT16 destval if (docollision) { - if (rover->spawnflags & FF_SOLID) - rover->flags &= ~FF_SOLID; - if (rover->spawnflags & FF_SWIMMABLE) - rover->flags &= ~FF_SWIMMABLE; - if (rover->spawnflags & FF_QUICKSAND) - rover->flags &= ~FF_QUICKSAND; - if (rover->spawnflags & FF_BUSTUP) - rover->flags &= ~FF_BUSTUP; - if (rover->spawnflags & FF_MARIO) - rover->flags &= ~FF_MARIO; + if (rover->spawnflags & FOF_SOLID) + rover->fofflags &= ~FOF_SOLID; + if (rover->spawnflags & FOF_SWIMMABLE) + rover->fofflags &= ~FOF_SWIMMABLE; + if (rover->spawnflags & FOF_QUICKSAND) + rover->fofflags &= ~FOF_QUICKSAND; + if (rover->spawnflags & FOF_BUSTUP) + rover->fofflags &= ~FOF_BUSTUP; + if (rover->spawnflags & FOF_MARIO) + rover->fofflags &= ~FOF_MARIO; } } else // continue fading out @@ -7463,16 +7463,16 @@ static boolean P_FadeFakeFloor(ffloor_t *rover, INT16 sourcevalue, INT16 destval if (docollision) { - if (rover->spawnflags & FF_SOLID) - rover->flags |= FF_SOLID; - if (rover->spawnflags & FF_SWIMMABLE) - rover->flags |= FF_SWIMMABLE; - if (rover->spawnflags & FF_QUICKSAND) - rover->flags |= FF_QUICKSAND; - if (rover->spawnflags & FF_BUSTUP) - rover->flags |= FF_BUSTUP; - if (rover->spawnflags & FF_MARIO) - rover->flags |= FF_MARIO; + if (rover->spawnflags & FOF_SOLID) + rover->fofflags |= FOF_SOLID; + if (rover->spawnflags & FOF_SWIMMABLE) + rover->fofflags |= FOF_SWIMMABLE; + if (rover->spawnflags & FOF_QUICKSAND) + rover->fofflags |= FOF_QUICKSAND; + if (rover->spawnflags & FOF_BUSTUP) + rover->fofflags |= FOF_BUSTUP; + if (rover->spawnflags & FOF_MARIO) + rover->fofflags |= FOF_MARIO; } } else // continue fading in @@ -7492,114 +7492,114 @@ static boolean P_FadeFakeFloor(ffloor_t *rover, INT16 sourcevalue, INT16 destval // routines common to both fade in and fade out if (!stillfading) { - if (doexists && !(rover->spawnflags & FF_BUSTUP)) + if (doexists && !(rover->spawnflags & FOF_BUSTUP)) { if (alpha <= 1) - rover->flags &= ~FF_EXISTS; + rover->fofflags &= ~FOF_EXISTS; else - rover->flags |= FF_EXISTS; + rover->fofflags |= FOF_EXISTS; // Re-render lighting at end of fade - if (dolighting && !(rover->spawnflags & FF_NOSHADE) && !(rover->flags & FF_EXISTS)) + if (dolighting && !(rover->spawnflags & FOF_NOSHADE) && !(rover->fofflags & FOF_EXISTS)) rover->target->moved = true; } - if (dotranslucent && !(rover->flags & FF_FOG)) + if (dotranslucent && !(rover->fofflags & FOF_FOG)) { if (alpha >= 256) { - if (!(rover->flags & FF_CUTSOLIDS) && - (rover->spawnflags & FF_CUTSOLIDS)) + if (!(rover->fofflags & FOF_CUTSOLIDS) && + (rover->spawnflags & FOF_CUTSOLIDS)) { - rover->flags |= FF_CUTSOLIDS; + rover->fofflags |= FOF_CUTSOLIDS; rover->target->moved = true; } - rover->flags &= ~FF_TRANSLUCENT; + rover->fofflags &= ~FOF_TRANSLUCENT; } else { - rover->flags |= FF_TRANSLUCENT; + rover->fofflags |= FOF_TRANSLUCENT; - if ((rover->flags & FF_CUTSOLIDS) && - (rover->spawnflags & FF_CUTSOLIDS)) + if ((rover->fofflags & FOF_CUTSOLIDS) && + (rover->spawnflags & FOF_CUTSOLIDS)) { - rover->flags &= ~FF_CUTSOLIDS; + rover->fofflags &= ~FOF_CUTSOLIDS; rover->target->moved = true; } } - if ((rover->spawnflags & FF_NOSHADE) && // do not include light blocks, which don't set FF_NOSHADE - !(rover->spawnflags & FF_RENDERSIDES) && - !(rover->spawnflags & FF_RENDERPLANES)) + if ((rover->spawnflags & FOF_NOSHADE) && // do not include light blocks, which don't set FOF_NOSHADE + !(rover->spawnflags & FOF_RENDERSIDES) && + !(rover->spawnflags & FOF_RENDERPLANES)) { if (rover->alpha > 1) - rover->flags |= FF_RENDERALL; + rover->fofflags |= FOF_RENDERALL; else - rover->flags &= ~FF_RENDERALL; + rover->fofflags &= ~FOF_RENDERALL; } } } else { - if (doexists && !(rover->spawnflags & FF_BUSTUP)) + if (doexists && !(rover->spawnflags & FOF_BUSTUP)) { - // Re-render lighting if we haven't yet set FF_EXISTS (beginning of fade) - if (dolighting && !(rover->spawnflags & FF_NOSHADE) && !(rover->flags & FF_EXISTS)) + // Re-render lighting if we haven't yet set FOF_EXISTS (beginning of fade) + if (dolighting && !(rover->spawnflags & FOF_NOSHADE) && !(rover->fofflags & FOF_EXISTS)) rover->target->moved = true; - rover->flags |= FF_EXISTS; + rover->fofflags |= FOF_EXISTS; } - if (dotranslucent && !(rover->flags & FF_FOG)) + if (dotranslucent && !(rover->fofflags & FOF_FOG)) { - rover->flags |= FF_TRANSLUCENT; + rover->fofflags |= FOF_TRANSLUCENT; - if ((rover->flags & FF_CUTSOLIDS) && - (rover->spawnflags & FF_CUTSOLIDS)) + if ((rover->fofflags & FOF_CUTSOLIDS) && + (rover->spawnflags & FOF_CUTSOLIDS)) { - rover->flags &= ~FF_CUTSOLIDS; + rover->fofflags &= ~FOF_CUTSOLIDS; rover->target->moved = true; } - if ((rover->spawnflags & FF_NOSHADE) && // do not include light blocks, which don't set FF_NOSHADE - !(rover->spawnflags & FF_RENDERSIDES) && - !(rover->spawnflags & FF_RENDERPLANES)) - rover->flags |= FF_RENDERALL; + if ((rover->spawnflags & FOF_NOSHADE) && // do not include light blocks, which don't set FOF_NOSHADE + !(rover->spawnflags & FOF_RENDERSIDES) && + !(rover->spawnflags & FOF_RENDERPLANES)) + rover->fofflags |= FOF_RENDERALL; } if (docollision) { if (doghostfade) // remove collision flags during fade { - if (rover->spawnflags & FF_SOLID) - rover->flags &= ~FF_SOLID; - if (rover->spawnflags & FF_SWIMMABLE) - rover->flags &= ~FF_SWIMMABLE; - if (rover->spawnflags & FF_QUICKSAND) - rover->flags &= ~FF_QUICKSAND; - if (rover->spawnflags & FF_BUSTUP) - rover->flags &= ~FF_BUSTUP; - if (rover->spawnflags & FF_MARIO) - rover->flags &= ~FF_MARIO; + if (rover->spawnflags & FOF_SOLID) + rover->fofflags &= ~FOF_SOLID; + if (rover->spawnflags & FOF_SWIMMABLE) + rover->fofflags &= ~FOF_SWIMMABLE; + if (rover->spawnflags & FOF_QUICKSAND) + rover->fofflags &= ~FOF_QUICKSAND; + if (rover->spawnflags & FOF_BUSTUP) + rover->fofflags &= ~FOF_BUSTUP; + if (rover->spawnflags & FOF_MARIO) + rover->fofflags &= ~FOF_MARIO; } else // keep collision during fade { - if (rover->spawnflags & FF_SOLID) - rover->flags |= FF_SOLID; - if (rover->spawnflags & FF_SWIMMABLE) - rover->flags |= FF_SWIMMABLE; - if (rover->spawnflags & FF_QUICKSAND) - rover->flags |= FF_QUICKSAND; - if (rover->spawnflags & FF_BUSTUP) - rover->flags |= FF_BUSTUP; - if (rover->spawnflags & FF_MARIO) - rover->flags |= FF_MARIO; + if (rover->spawnflags & FOF_SOLID) + rover->fofflags |= FOF_SOLID; + if (rover->spawnflags & FOF_SWIMMABLE) + rover->fofflags |= FOF_SWIMMABLE; + if (rover->spawnflags & FOF_QUICKSAND) + rover->fofflags |= FOF_QUICKSAND; + if (rover->spawnflags & FOF_BUSTUP) + rover->fofflags |= FOF_BUSTUP; + if (rover->spawnflags & FOF_MARIO) + rover->fofflags |= FOF_MARIO; } } } - if (!(rover->flags & FF_FOG)) // don't set FOG alpha + if (!(rover->fofflags & FOF_FOG)) // don't set FOG alpha { if (!stillfading || exactalpha) rover->alpha = alpha; @@ -7642,8 +7642,8 @@ static boolean P_FadeFakeFloor(ffloor_t *rover, INT16 sourcevalue, INT16 destval * \param speed speed to fade by * \param ticbased tic-based logic, speed = duration * \param relative Destvalue is relative to rover->alpha - * \param doexists handle FF_EXISTS - * \param dotranslucent handle FF_TRANSLUCENT + * \param doexists handle FOF_EXISTS + * \param dotranslucent handle FOF_TRANSLUCENT * \param dolighting fade FOF light * \param docollision handle interactive flags * \param doghostfade no interactive flags during fading @@ -7659,10 +7659,10 @@ static void P_AddFakeFloorFader(ffloor_t *rover, size_t sectornum, size_t ffloor // If fading an invisible FOF whose render flags we did not yet set, // initialize its alpha to 1 if (dotranslucent && - (rover->spawnflags & FF_NOSHADE) && // do not include light blocks, which don't set FF_NOSHADE - !(rover->spawnflags & FF_RENDERSIDES) && - !(rover->spawnflags & FF_RENDERPLANES) && - !(rover->flags & FF_RENDERALL)) + (rover->spawnflags & FOF_NOSHADE) && // do not include light blocks, which don't set FOF_NOSHADE + !(rover->spawnflags & FOF_RENDERSIDES) && + !(rover->spawnflags & FOF_RENDERPLANES) && + !(rover->fofflags & FOF_RENDERALL)) rover->alpha = 1; // already equal, nothing to do @@ -7703,7 +7703,7 @@ static void P_AddFakeFloorFader(ffloor_t *rover, size_t sectornum, size_t ffloor P_ResetFakeFloorFader(rover, d, false); // Set a separate thinker for shadow fading - if (dolighting && !(rover->flags & FF_NOSHADE)) + if (dolighting && !(rover->fofflags & FOF_NOSHADE)) { UINT16 lightdelta = abs(sectors[rover->secnum].spawn_lightlevel - rover->target->lightlevel); fixed_t alphapercent = min(FixedDiv(d->destvalue, rover->spawnalpha), 1*FRACUNIT); // don't make darker than spawn_lightlevel @@ -7724,7 +7724,7 @@ static void P_AddFakeFloorFader(ffloor_t *rover, size_t sectornum, size_t ffloor d->destlightlevel = -1; // Set a separate thinker for colormap fading - if (docolormap && !(rover->flags & FF_NOSHADE) && sectors[rover->secnum].spawn_extra_colormap && !sectors[rover->secnum].colormap_protected) + if (docolormap && !(rover->fofflags & FOF_NOSHADE) && sectors[rover->secnum].spawn_extra_colormap && !sectors[rover->secnum].colormap_protected) { extracolormap_t *dest_exc, *source_exc = sectors[rover->secnum].extra_colormap ? sectors[rover->secnum].extra_colormap : R_GetDefaultColormap(); @@ -7785,11 +7785,11 @@ void T_Fade(fade_t *d) d->doexists, d->dotranslucent, d->dolighting, d->docolormap, d->docollision, d->doghostfade, d->exactalpha)) { // Finalize lighting, copypasta from P_AddFakeFloorFader - if (d->dolighting && !(d->rover->flags & FF_NOSHADE) && d->destlightlevel > -1) + if (d->dolighting && !(d->rover->fofflags & FOF_NOSHADE) && d->destlightlevel > -1) sectors[d->rover->secnum].lightlevel = d->destlightlevel; // Finalize colormap - if (d->docolormap && !(d->rover->flags & FF_NOSHADE) && sectors[d->rover->secnum].spawn_extra_colormap) + if (d->docolormap && !(d->rover->fofflags & FOF_NOSHADE) && sectors[d->rover->secnum].spawn_extra_colormap) sectors[d->rover->secnum].extra_colormap = d->dest_exc; P_RemoveFakeFloorFader(d->rover); diff --git a/src/p_spec.h b/src/p_spec.h index 8578fa8ea..08aa6016b 100644 --- a/src/p_spec.h +++ b/src/p_spec.h @@ -1032,8 +1032,8 @@ typedef struct INT16 speed; ///< Speed to fade by boolean ticbased; ///< Tic-based logic toggle INT32 timer; ///< Timer for tic-based logic - boolean doexists; ///< Handle FF_EXISTS - boolean dotranslucent; ///< Handle FF_TRANSLUCENT + boolean doexists; ///< Handle FOF_EXISTS + boolean dotranslucent; ///< Handle FOF_TRANSLUCENT boolean dolighting; ///< Handle shadows and light blocks boolean docolormap; ///< Handle colormaps boolean docollision; ///< Handle interactive flags diff --git a/src/p_user.c b/src/p_user.c index e8f84d744..32ebe3098 100644 --- a/src/p_user.c +++ b/src/p_user.c @@ -979,20 +979,20 @@ boolean P_IsObjectOnGroundIn(mobj_t *mo, sector_t *sec) for (rover = sec->ffloors; rover; rover = rover->next) { // If the FOF doesn't exist, continue. - if (!(rover->flags & FF_EXISTS)) + if (!(rover->fofflags & FOF_EXISTS)) continue; // If the FOF is configured to let the object through, continue. - if (!((rover->flags & FF_BLOCKPLAYER && mo->player) - || (rover->flags & FF_BLOCKOTHERS && !mo->player))) + if (!((rover->fofflags & FOF_BLOCKPLAYER && mo->player) + || (rover->fofflags & FOF_BLOCKOTHERS && !mo->player))) continue; // If the the platform is intangible from below, continue. - if (rover->flags & FF_PLATFORM) + if (rover->fofflags & FOF_PLATFORM) continue; // If the FOF is a water block, continue. (Unnecessary check?) - if (rover->flags & FF_SWIMMABLE) + if (rover->fofflags & FOF_SWIMMABLE) continue; // Actually check if the player is on the suitable FOF. @@ -1013,20 +1013,20 @@ boolean P_IsObjectOnGroundIn(mobj_t *mo, sector_t *sec) for (rover = sec->ffloors; rover; rover = rover->next) { // If the FOF doesn't exist, continue. - if (!(rover->flags & FF_EXISTS)) + if (!(rover->fofflags & FOF_EXISTS)) continue; // If the FOF is configured to let the object through, continue. - if (!((rover->flags & FF_BLOCKPLAYER && mo->player) - || (rover->flags & FF_BLOCKOTHERS && !mo->player))) + if (!((rover->fofflags & FOF_BLOCKPLAYER && mo->player) + || (rover->fofflags & FOF_BLOCKOTHERS && !mo->player))) continue; // If the the platform is intangible from above, continue. - if (rover->flags & FF_REVERSEPLATFORM) + if (rover->fofflags & FOF_REVERSEPLATFORM) continue; // If the FOF is a water block, continue. (Unnecessary check?) - if (rover->flags & FF_SWIMMABLE) + if (rover->fofflags & FOF_SWIMMABLE) continue; // Actually check if the player is on the suitable FOF. @@ -1395,10 +1395,10 @@ boolean P_InQuicksand(mobj_t *mo) // Returns true if you are in quicksand for (rover = sector->ffloors; rover; rover = rover->next) { - if (!(rover->flags & FF_EXISTS)) + if (!(rover->fofflags & FOF_EXISTS)) continue; - if (!(rover->flags & FF_QUICKSAND)) + if (!(rover->fofflags & FOF_QUICKSAND)) continue; topheight = P_GetFFloorTopZAt (rover, mo->x, mo->y); @@ -1550,104 +1550,78 @@ static void P_CheckBouncySectors(player_t *player) for (node = player->mo->touching_sectorlist; node; node = node->m_sectorlist_next) { + ffloor_t *rover; + if (!node->m_sector) break; - if (node->m_sector->ffloors) + if (!node->m_sector->ffloors) + continue; + + for (rover = node->m_sector->ffloors; rover; rover = rover->next) { - ffloor_t *rover; - boolean top = true; fixed_t topheight, bottomheight; - for (rover = node->m_sector->ffloors; rover; rover = rover->next) + if (!(rover->fofflags & FOF_EXISTS)) + continue; // FOFs should not be bouncy if they don't even "exist" + + // Handle deprecated bouncy FOF sector type + if (!udmf && GETSECSPECIAL(rover->master->frontsector->special, 1) == 15) { - if (!(rover->flags & FF_EXISTS)) - continue; // FOFs should not be bouncy if they don't even "exist" - - if (GETSECSPECIAL(rover->master->frontsector->special, 1) != 15) - continue; // this sector type is required for FOFs to be bouncy - - topheight = P_GetFOFTopZ(player->mo, node->m_sector, rover, player->mo->x, player->mo->y, NULL); - bottomheight = P_GetFOFBottomZ(player->mo, node->m_sector, rover, player->mo->x, player->mo->y, NULL); - - if (player->mo->z > topheight) - continue; - - if (player->mo->z + player->mo->height < bottomheight) - continue; - - if (oldz < P_GetFOFTopZ(player->mo, node->m_sector, rover, oldx, oldy, NULL) - && oldz + player->mo->height > P_GetFOFBottomZ(player->mo, node->m_sector, rover, oldx, oldy, NULL)) - top = false; - - { - fixed_t linedist; - - linedist = P_AproxDistance(rover->master->v1->x-rover->master->v2->x, rover->master->v1->y-rover->master->v2->y); - - linedist = FixedDiv(linedist,100*FRACUNIT); - - if (top) - { - fixed_t newmom; - - pslope_t *slope; - if (abs(oldz - topheight) < abs(oldz + player->mo->height - bottomheight)) { // Hit top - slope = *rover->t_slope; - } else { // Hit bottom - slope = *rover->b_slope; - } - - momentum.x = player->mo->momx; - momentum.y = player->mo->momy; - momentum.z = player->mo->momz*2; - - if (slope) - P_ReverseQuantizeMomentumToSlope(&momentum, slope); - - newmom = momentum.z = -FixedMul(momentum.z,linedist)/2; - - if (abs(newmom) < (linedist*2)) - { - goto bouncydone; - } - - if (!(rover->master->flags & ML_NOTBOUNCY)) - { - if (newmom > 0) - { - if (newmom < 8*FRACUNIT) - newmom = 8*FRACUNIT; - } - else if (newmom > -8*FRACUNIT && newmom != 0) - newmom = -8*FRACUNIT; - } - - if (newmom > player->mo->height/2) - newmom = player->mo->height/2; - else if (newmom < -player->mo->height/2) - newmom = -player->mo->height/2; - - momentum.z = newmom*2; - - if (slope) - P_QuantizeMomentumToSlope(&momentum, slope); - - player->mo->momx = momentum.x; - player->mo->momy = momentum.y; - player->mo->momz = momentum.z/2; - } - else - { - player->mo->momx = -FixedMul(player->mo->momx,linedist); - player->mo->momy = -FixedMul(player->mo->momy,linedist); - } - - goto bouncydone; - } + rover->fofflags |= FOF_BOUNCY; + rover->bouncestrength = P_AproxDistance(rover->master->dx, rover->master->dy)/100; } + + if (!(rover->fofflags & FOF_BOUNCY)) + continue; + + topheight = P_GetFOFTopZ(player->mo, node->m_sector, rover, player->mo->x, player->mo->y, NULL); + bottomheight = P_GetFOFBottomZ(player->mo, node->m_sector, rover, player->mo->x, player->mo->y, NULL); + + if (player->mo->z > topheight) + continue; + + if (player->mo->z + player->mo->height < bottomheight) + continue; + + if (oldz < P_GetFOFTopZ(player->mo, node->m_sector, rover, oldx, oldy, NULL) + && oldz + player->mo->height > P_GetFOFBottomZ(player->mo, node->m_sector, rover, oldx, oldy, NULL)) + { + player->mo->momx = -FixedMul(player->mo->momx,rover->bouncestrength); + player->mo->momy = -FixedMul(player->mo->momy,rover->bouncestrength); + } + else + { + pslope_t *slope = (abs(oldz - topheight) < abs(oldz + player->mo->height - bottomheight)) ? *rover->t_slope : *rover->b_slope; + + momentum.x = player->mo->momx; + momentum.y = player->mo->momy; + momentum.z = player->mo->momz*2; + + if (slope) + P_ReverseQuantizeMomentumToSlope(&momentum, slope); + + momentum.z = -FixedMul(momentum.z,rover->bouncestrength)/2; + + if (abs(momentum.z) < (rover->bouncestrength*2)) + goto bouncydone; + + if (momentum.z > FixedMul(24*FRACUNIT, player->mo->scale)) //half of the default player height + momentum.z = FixedMul(24*FRACUNIT, player->mo->scale); + else if (momentum.z < -FixedMul(24*FRACUNIT, player->mo->scale)) + momentum.z = -FixedMul(24*FRACUNIT, player->mo->scale); + + if (slope) + P_QuantizeMomentumToSlope(&momentum, slope); + + player->mo->momx = momentum.x; + player->mo->momy = momentum.y; + player->mo->momz = momentum.z; + } + goto bouncydone; } } + bouncydone: P_UnsetThingPosition(player->mo); player->mo->x = oldx; @@ -1667,9 +1641,9 @@ static void P_CheckQuicksand(player_t *player) for (rover = player->mo->subsector->sector->ffloors; rover; rover = rover->next) { - if (!(rover->flags & FF_EXISTS)) continue; + if (!(rover->fofflags & FOF_EXISTS)) continue; - if (!(rover->flags & FF_QUICKSAND)) + if (!(rover->fofflags & FOF_QUICKSAND)) continue; topheight = P_GetFFloorTopZAt (rover, player->mo->x, player->mo->y); @@ -3540,7 +3514,7 @@ static void P_CalcPostImg(player_t *player) { size_t j; - if (!(rover->flags & FF_EXISTS)) + if (!(rover->fofflags & FOF_EXISTS)) continue; topheight = P_GetFFloorTopZAt (rover, player->mo->x, player->mo->y); @@ -3573,7 +3547,7 @@ static void P_CalcPostImg(player_t *player) for (rover = sector->ffloors; rover; rover = rover->next) { - if (!(rover->flags & FF_EXISTS) || !(rover->flags & FF_SWIMMABLE) || rover->flags & FF_BLOCKPLAYER) + if (!(rover->fofflags & FOF_EXISTS) || !(rover->fofflags & FOF_SWIMMABLE) || rover->fofflags & FOF_BLOCKPLAYER) continue; topheight = P_GetFFloorTopZAt (rover, player->mo->x, player->mo->y); diff --git a/src/r_bsp.c b/src/r_bsp.c index e051c4387..5bed2eb0d 100644 --- a/src/r_bsp.c +++ b/src/r_bsp.c @@ -70,7 +70,7 @@ boolean R_NoEncore(sector_t *sector, boolean ceiling) boolean R_IsRipplePlane(sector_t *sector, ffloor_t *rover, int ceiling) { - return rover ? (rover->flags & FF_RIPPLE) : + return rover ? (rover->fofflags & FOF_RIPPLE) : (sector->flags & (MSF_RIPPLE_FLOOR << ceiling)); } @@ -987,7 +987,7 @@ static void R_Subsector(size_t num) for (rover = frontsector->ffloors; rover && numffloors < MAXFFLOORS; rover = rover->next) { - if (!(rover->flags & FF_EXISTS) || !(rover->flags & FF_RENDERPLANES)) + if (!(rover->fofflags & FOF_EXISTS) || !(rover->fofflags & FOF_RENDERPLANES)) continue; if (frontsector->cullheight) @@ -1007,8 +1007,8 @@ static void R_Subsector(size_t num) planecenterz = P_GetFFloorBottomZAt(rover, frontsector->soundorg.x, frontsector->soundorg.y); if (planecenterz <= ceilingcenterz && planecenterz >= floorcenterz - && ((viewz < heightcheck && (rover->flags & FF_BOTHPLANES || !(rover->flags & FF_INVERTPLANES))) - || (viewz > heightcheck && (rover->flags & FF_BOTHPLANES || rover->flags & FF_INVERTPLANES)))) + && ((viewz < heightcheck && (rover->fofflags & FOF_BOTHPLANES || !(rover->fofflags & FOF_INVERTPLANES))) + || (viewz > heightcheck && (rover->fofflags & FOF_BOTHPLANES || rover->fofflags & FOF_INVERTPLANES)))) { light = R_GetPlaneLight(frontsector, planecenterz, viewz < heightcheck); @@ -1042,8 +1042,8 @@ static void R_Subsector(size_t num) planecenterz = P_GetFFloorTopZAt(rover, frontsector->soundorg.x, frontsector->soundorg.y); if (planecenterz >= floorcenterz && planecenterz <= ceilingcenterz - && ((viewz > heightcheck && (rover->flags & FF_BOTHPLANES || !(rover->flags & FF_INVERTPLANES))) - || (viewz < heightcheck && (rover->flags & FF_BOTHPLANES || rover->flags & FF_INVERTPLANES)))) + && ((viewz > heightcheck && (rover->fofflags & FOF_BOTHPLANES || !(rover->fofflags & FOF_INVERTPLANES))) + || (viewz < heightcheck && (rover->fofflags & FOF_BOTHPLANES || rover->fofflags & FOF_INVERTPLANES)))) { light = R_GetPlaneLight(frontsector, planecenterz, viewz < heightcheck); @@ -1196,11 +1196,11 @@ void R_Prep3DFloors(sector_t *sector) count = 1; for (rover = sector->ffloors; rover; rover = rover->next) { - if ((rover->flags & FF_EXISTS) && (!(rover->flags & FF_NOSHADE) - || (rover->flags & FF_CUTLEVEL) || (rover->flags & FF_CUTSPRITES))) + if ((rover->fofflags & FOF_EXISTS) && (!(rover->fofflags & FOF_NOSHADE) + || (rover->fofflags & FOF_CUTLEVEL) || (rover->fofflags & FOF_CUTSPRITES))) { count++; - if (rover->flags & FF_DOUBLESHADOW) + if (rover->fofflags & FOF_DOUBLESHADOW) count++; } } @@ -1231,8 +1231,8 @@ void R_Prep3DFloors(sector_t *sector) for (rover = sector->ffloors; rover; rover = rover->next) { rover->lastlight = 0; - if (!(rover->flags & FF_EXISTS) || (rover->flags & FF_NOSHADE - && !(rover->flags & FF_CUTLEVEL) && !(rover->flags & FF_CUTSPRITES))) + if (!(rover->fofflags & FOF_EXISTS) || (rover->fofflags & FOF_NOSHADE + && !(rover->fofflags & FOF_CUTLEVEL) && !(rover->fofflags & FOF_CUTSPRITES))) continue; heighttest = P_GetFFloorTopZAt(rover, sector->soundorg.x, sector->soundorg.y); @@ -1244,7 +1244,7 @@ void R_Prep3DFloors(sector_t *sector) bestslope = *rover->t_slope; continue; } - if (rover->flags & FF_DOUBLESHADOW) { + if (rover->fofflags & FOF_DOUBLESHADOW) { heighttest = P_GetFFloorBottomZAt(rover, sector->soundorg.x, sector->soundorg.y); if (heighttest > bestheight @@ -1265,16 +1265,16 @@ void R_Prep3DFloors(sector_t *sector) sector->lightlist[i].height = maxheight = bestheight; sector->lightlist[i].caster = best; - sector->lightlist[i].flags = best->flags; + sector->lightlist[i].flags = best->fofflags; sector->lightlist[i].slope = bestslope; sec = §ors[best->secnum]; - if (best->flags & FF_NOSHADE) + if (best->fofflags & FOF_NOSHADE) { sector->lightlist[i].lightlevel = sector->lightlist[i-1].lightlevel; sector->lightlist[i].extra_colormap = sector->lightlist[i-1].extra_colormap; } - else if (best->flags & FF_COLORMAPONLY) + else if (best->fofflags & FOF_COLORMAPONLY) { sector->lightlist[i].lightlevel = sector->lightlist[i-1].lightlevel; sector->lightlist[i].extra_colormap = &sec->extra_colormap; @@ -1285,7 +1285,7 @@ void R_Prep3DFloors(sector_t *sector) sector->lightlist[i].extra_colormap = &sec->extra_colormap; } - if (best->flags & FF_DOUBLESHADOW) + if (best->fofflags & FOF_DOUBLESHADOW) { heighttest = P_GetFFloorBottomZAt(best, sector->soundorg.x, sector->soundorg.y); if (bestheight == heighttest) ///TODO: do this in a more efficient way -Red diff --git a/src/r_defs.h b/src/r_defs.h index 4ace43014..58ba6ee9d 100644 --- a/src/r_defs.h +++ b/src/r_defs.h @@ -115,41 +115,41 @@ typedef struct */ typedef enum { - FF_EXISTS = 0x1, ///< Always set, to check for validity. - FF_BLOCKPLAYER = 0x2, ///< Solid to player, but nothing else - FF_BLOCKOTHERS = 0x4, ///< Solid to everything but player - FF_SOLID = 0x6, ///< Clips things. - FF_RENDERSIDES = 0x8, ///< Renders the sides. - FF_RENDERPLANES = 0x10, ///< Renders the floor/ceiling. - FF_RENDERALL = 0x18, ///< Renders everything. - FF_SWIMMABLE = 0x20, ///< Is a water block. - FF_NOSHADE = 0x40, ///< Messes with the lighting? - FF_CUTSOLIDS = 0x80, ///< Cuts out hidden solid pixels. - FF_CUTEXTRA = 0x100, ///< Cuts out hidden translucent pixels. - FF_CUTLEVEL = 0x180, ///< Cuts out all hidden pixels. - FF_CUTSPRITES = 0x200, ///< Final step in making 3D water. - FF_BOTHPLANES = 0x400, ///< Render inside and outside planes. - FF_EXTRA = 0x800, ///< Gets cut by ::FF_CUTEXTRA. - FF_TRANSLUCENT = 0x1000, ///< See through! - FF_FOG = 0x2000, ///< Fog "brush." - FF_INVERTPLANES = 0x4000, ///< Only render inside planes. - FF_ALLSIDES = 0x8000, ///< Render inside and outside sides. - FF_INVERTSIDES = 0x10000, ///< Only render inside sides. - FF_DOUBLESHADOW = 0x20000, ///< Make two lightlist entries to reset light? - FF_FLOATBOB = 0x40000, ///< Floats on water and bobs if you step on it. - FF_NORETURN = 0x80000, ///< Used with ::FF_CRUMBLE. Will not return to its original position after falling. - FF_CRUMBLE = 0x100000, ///< Falls 2 seconds after being stepped on, and randomly brings all touching crumbling 3dfloors down with it, providing their master sectors share the same tag (allows crumble platforms above or below, to also exist). - FF_GOOWATER = 0x200000, ///< Used with ::FF_SWIMMABLE. Makes thick bouncey goop. - FF_MARIO = 0x400000, ///< Acts like a question block when hit from underneath. Goodie spawned at top is determined by master sector. - FF_BUSTUP = 0x800000, ///< You can spin through/punch this block and it will crumble! - FF_QUICKSAND = 0x1000000, ///< Quicksand! - FF_PLATFORM = 0x2000000, ///< You can jump up through this to the top. - FF_REVERSEPLATFORM = 0x4000000, ///< A fall-through floor in normal gravity, a platform in reverse gravity. - FF_INTANGIBLEFLATS = 0x6000000, ///< Both flats are intangible, but the sides are still solid. - FF_RIPPLE = 0x8000000, ///< Ripple the flats - FF_COLORMAPONLY = 0x10000000, ///< Only copy the colormap, not the lightlevel - FF_BOUNCY = 0x20000000, ///< Bounces players - FF_SPLAT = 0x40000000, ///< Use splat flat renderer (treat cyan pixels as invisible) + FOF_EXISTS = 0x1, ///< Always set, to check for validity. + FOF_BLOCKPLAYER = 0x2, ///< Solid to player, but nothing else + FOF_BLOCKOTHERS = 0x4, ///< Solid to everything but player + FOF_SOLID = 0x6, ///< Clips things. + FOF_RENDERSIDES = 0x8, ///< Renders the sides. + FOF_RENDERPLANES = 0x10, ///< Renders the floor/ceiling. + FOF_RENDERALL = 0x18, ///< Renders everything. + FOF_SWIMMABLE = 0x20, ///< Is a water block. + FOF_NOSHADE = 0x40, ///< Messes with the lighting? + FOF_CUTSOLIDS = 0x80, ///< Cuts out hidden solid pixels. + FOF_CUTEXTRA = 0x100, ///< Cuts out hidden translucent pixels. + FOF_CUTLEVEL = 0x180, ///< Cuts out all hidden pixels. + FOF_CUTSPRITES = 0x200, ///< Final step in making 3D water. + FOF_BOTHPLANES = 0x400, ///< Render inside and outside planes. + FOF_EXTRA = 0x800, ///< Gets cut by ::FOF_CUTEXTRA. + FOF_TRANSLUCENT = 0x1000, ///< See through! + FOF_FOG = 0x2000, ///< Fog "brush." + FOF_INVERTPLANES = 0x4000, ///< Only render inside planes. + FOF_ALLSIDES = 0x8000, ///< Render inside and outside sides. + FOF_INVERTSIDES = 0x10000, ///< Only render inside sides. + FOF_DOUBLESHADOW = 0x20000, ///< Make two lightlist entries to reset light? + FOF_FLOATBOB = 0x40000, ///< Floats on water and bobs if you step on it. + FOF_NORETURN = 0x80000, ///< Used with ::FOF_CRUMBLE. Will not return to its original position after falling. + FOF_CRUMBLE = 0x100000, ///< Falls 2 seconds after being stepped on, and randomly brings all touching crumbling 3dfloors down with it, providing their master sectors share the same tag (allows crumble platforms above or below, to also exist). + FOF_GOOWATER = 0x200000, ///< Used with ::FOF_SWIMMABLE. Makes thick bouncey goop. + FOF_MARIO = 0x400000, ///< Acts like a question block when hit from underneath. Goodie spawned at top is determined by master sector. + FOF_BUSTUP = 0x800000, ///< You can spin through/punch this block and it will crumble! + FOF_QUICKSAND = 0x1000000, ///< Quicksand! + FOF_PLATFORM = 0x2000000, ///< You can jump up through this to the top. + FOF_REVERSEPLATFORM = 0x4000000, ///< A fall-through floor in normal gravity, a platform in reverse gravity. + FOF_INTANGIBLEFLATS = 0x6000000, ///< Both flats are intangible, but the sides are still solid. + FOF_RIPPLE = 0x8000000, ///< Ripple the flats + FOF_COLORMAPONLY = 0x10000000, ///< Only copy the colormap, not the lightlevel + FOF_BOUNCY = 0x20000000, ///< Bounces players + FOF_SPLAT = 0x40000000, ///< Use splat flat renderer (treat cyan pixels as invisible) } ffloortype_e; typedef enum @@ -190,7 +190,7 @@ typedef enum FF_OLD_SPINBUST = 0x10000000, FF_OLD_STRONGBUST = 0x20000000, FF_OLD_RIPPLE = 0x40000000, - FF_OLD_COLORMAPONLY = 0x80000000, + FF_OLD_COLORMAPONLY = (INT32)0x80000000, } oldffloortype_e; typedef enum @@ -228,7 +228,7 @@ typedef struct ffloor_s struct pslope_s **b_slope; size_t secnum; - ffloortype_e flags; + ffloortype_e fofflags; struct line_s *master; struct sector_s *target; @@ -241,16 +241,16 @@ typedef struct ffloor_s UINT8 blend; tic_t norender; // for culling - // Only relevant for FF_BUSTUP + // Only relevant for FOF_BUSTUP ffloorbustflags_e bustflags; UINT8 busttype; INT16 busttag; - // Only relevant for FF_QUICKSAND + // Only relevant for FOF_QUICKSAND fixed_t sinkspeed; fixed_t friction; - // Only relevant for FF_BOUNCY + // Only relevant for FOF_BOUNCY fixed_t bouncestrength; // these are saved for netgames, so do not let Lua touch these! @@ -271,7 +271,7 @@ typedef struct lightlist_s extracolormap_t **extra_colormap; // pointer-to-a-pointer, so we can react to colormap changes INT32 flags; ffloor_t *caster; - struct pslope_s *slope; // FF_DOUBLESHADOW makes me have to store this pointer here. Bluh bluh. + struct pslope_s *slope; // FOF_DOUBLESHADOW makes me have to store this pointer here. Bluh bluh. } lightlist_t; diff --git a/src/r_draw8.c b/src/r_draw8.c index 8c65cf94a..8f623286f 100644 --- a/src/r_draw8.c +++ b/src/r_draw8.c @@ -2485,7 +2485,7 @@ void R_DrawColumnShadowed_8(void) { // If the height of the light is above the column, get the colormap // anyway because the lighting of the top should be affected. - solid = dc_lightlist[i].flags & FF_CUTSOLIDS; + solid = dc_lightlist[i].flags & FOF_CUTSOLIDS; height = dc_lightlist[i].height >> LIGHTSCALESHIFT; if (solid) diff --git a/src/r_plane.c b/src/r_plane.c index 677b4e025..4472c9fc3 100644 --- a/src/r_plane.c +++ b/src/r_plane.c @@ -872,13 +872,13 @@ void R_DrawSinglePlane(visplane_t *pl) // Don't draw planes that shouldn't be drawn. for (rover = pl->ffloor->target->ffloors; rover; rover = rover->next) { - if ((pl->ffloor->flags & FF_CUTEXTRA) && (rover->flags & FF_EXTRA)) + if ((pl->ffloor->fofflags & FOF_CUTEXTRA) && (rover->fofflags & FOF_EXTRA)) { - if (pl->ffloor->flags & FF_EXTRA) + if (pl->ffloor->fofflags & FOF_EXTRA) { // The plane is from an extra 3D floor... Check the flags so // there are no undesired cuts. - if (((pl->ffloor->flags & (FF_FOG|FF_SWIMMABLE)) == (rover->flags & (FF_FOG|FF_SWIMMABLE))) + if (((pl->ffloor->fofflags & (FOF_FOG|FOF_SWIMMABLE)) == (rover->fofflags & (FOF_FOG|FOF_SWIMMABLE))) && pl->height < *rover->topheight && pl->height > *rover->bottomheight) return; @@ -886,9 +886,9 @@ void R_DrawSinglePlane(visplane_t *pl) } } - if (pl->ffloor->flags & FF_TRANSLUCENT) + if (pl->ffloor->fofflags & FOF_TRANSLUCENT) { - spanfunctype = (pl->ffloor->flags & FF_SPLAT) ? SPANDRAWFUNC_TRANSSPLAT : SPANDRAWFUNC_TRANS; + spanfunctype = (pl->ffloor->fofflags & FOF_SPLAT) ? SPANDRAWFUNC_TRANSSPLAT : SPANDRAWFUNC_TRANS; // Hacked up support for alpha value in software mode Tails 09-24-2002 // ...unhacked by toaster 04-01-2021 @@ -905,7 +905,7 @@ void R_DrawSinglePlane(visplane_t *pl) else light = LIGHTLEVELS-1; } - else if (pl->ffloor->flags & FF_FOG) + else if (pl->ffloor->fofflags & FOF_FOG) { spanfunctype = SPANDRAWFUNC_FOG; light = (pl->lightlevel >> LIGHTSEGSHIFT); diff --git a/src/r_segs.c b/src/r_segs.c index 16c61af43..c00330a4d 100644 --- a/src/r_segs.c +++ b/src/r_segs.c @@ -270,7 +270,7 @@ void R_RenderMaskedSegRange(drawseg_t *ds, INT32 x1, INT32 x2) rlight->flags = light->flags; if ((R_CheckColumnFunc(COLDRAWFUNC_FUZZY) == false) - || (rlight->flags & FF_FOG) + || (rlight->flags & FOF_FOG) || (rlight->extra_colormap && (rlight->extra_colormap->flags & CMF_FOG))) lightnum = (rlight->lightlevel >> LIGHTSEGSHIFT); else @@ -410,7 +410,7 @@ void R_RenderMaskedSegRange(drawseg_t *ds, INT32 x1, INT32 x2) { rlight = &dc_lightlist[i]; - if ((rlight->flags & FF_NOSHADE)) + if ((rlight->flags & FOF_NOSHADE)) continue; if (rlight->lightnum < 0) @@ -591,7 +591,7 @@ static boolean R_IsFFloorTranslucent(visffloor_t *pfloor) // Polyobjects have no ffloors, and they're handled in the conditional above. if (pfloor->ffloor != NULL) - return (pfloor->ffloor->flags & (FF_TRANSLUCENT|FF_FOG)); + return (pfloor->ffloor->fofflags & (FOF_TRANSLUCENT|FOF_FOG)); return false; } @@ -648,7 +648,7 @@ void R_RenderThickSideRange(drawseg_t *ds, INT32 x1, INT32 x2, ffloor_t *pfloor) bmnum = R_GetTextureBrightmap(texnum); } - if (pfloor->flags & FF_TRANSLUCENT) + if (pfloor->fofflags & FOF_TRANSLUCENT) { boolean fuzzy = true; @@ -667,7 +667,7 @@ void R_RenderThickSideRange(drawseg_t *ds, INT32 x1, INT32 x2, ffloor_t *pfloor) R_SetColumnFunc(COLDRAWFUNC_FUZZY, bmnum != 0); } } - else if (pfloor->flags & FF_FOG) + else if (pfloor->fofflags & FOF_FOG) { R_SetColumnFunc(COLDRAWFUNC_FOG, bmnum != 0); } @@ -732,7 +732,7 @@ void R_RenderThickSideRange(drawseg_t *ds, INT32 x1, INT32 x2, ffloor_t *pfloor) else rlight->heightstep = CLAMPMIN; rlight->heightstep = (rlight->heightstep-rlight->height)/(range); rlight->flags = light->flags; - if (light->flags & FF_CUTLEVEL) + if (light->flags & FOF_CUTLEVEL) { SLOPEPARAMS(*light->caster->b_slope, leftheight, rightheight, *light->caster->bottomheight) #undef SLOPEPARAMS @@ -756,12 +756,12 @@ void R_RenderThickSideRange(drawseg_t *ds, INT32 x1, INT32 x2, ffloor_t *pfloor) rlight->extra_colormap = *light->extra_colormap; // Check if the current light effects the colormap/lightlevel - if (pfloor->flags & FF_FOG) + if (pfloor->fofflags & FOF_FOG) rlight->lightnum = (pfloor->master->frontsector->lightlevel >> LIGHTSEGSHIFT); else rlight->lightnum = (rlight->lightlevel >> LIGHTSEGSHIFT); - if (pfloor->flags & FF_FOG || rlight->flags & FF_FOG || (rlight->extra_colormap && (rlight->extra_colormap->flags & CMF_FOG))) + if (pfloor->fofflags & FOF_FOG || rlight->flags & FOF_FOG || (rlight->extra_colormap && (rlight->extra_colormap->flags & CMF_FOG))) ; else if (P_ApplyLightOffset(rlight->lightnum)) rlight->lightnum += curline->lightOffset; @@ -776,7 +776,7 @@ void R_RenderThickSideRange(drawseg_t *ds, INT32 x1, INT32 x2, ffloor_t *pfloor) // Get correct light level! if ((frontsector->extra_colormap && (frontsector->extra_colormap->flags & CMF_FOG))) lightnum = (frontsector->lightlevel >> LIGHTSEGSHIFT); - else if (pfloor->flags & FF_FOG) + else if (pfloor->fofflags & FOF_FOG) lightnum = (pfloor->master->frontsector->lightlevel >> LIGHTSEGSHIFT); else if (R_CheckColumnFunc(COLDRAWFUNC_FUZZY) == true) lightnum = LIGHTLEVELS-1; @@ -784,7 +784,7 @@ void R_RenderThickSideRange(drawseg_t *ds, INT32 x1, INT32 x2, ffloor_t *pfloor) lightnum = R_FakeFlat(frontsector, &tempsec, &templight, &templight, false) ->lightlevel >> LIGHTSEGSHIFT; - if (pfloor->flags & FF_FOG || (frontsector->extra_colormap && (frontsector->extra_colormap->flags & CMF_FOG))) + if (pfloor->fofflags & FOF_FOG || (frontsector->extra_colormap && (frontsector->extra_colormap->flags & CMF_FOG))) ; else if (P_ApplyLightOffset(lightnum)) lightnum += curline->lightOffset; @@ -932,7 +932,7 @@ void R_RenderThickSideRange(drawseg_t *ds, INT32 x1, INT32 x2, ffloor_t *pfloor) { rlight = &dc_lightlist[i]; rlight->height += rlight->heightstep; - if (rlight->flags & FF_CUTLEVEL) + if (rlight->flags & FOF_CUTLEVEL) rlight->botheight += rlight->botheightstep; } } @@ -960,7 +960,7 @@ void R_RenderThickSideRange(drawseg_t *ds, INT32 x1, INT32 x2, ffloor_t *pfloor) { // Check if the current light effects the colormap/lightlevel rlight = &dc_lightlist[i]; - lighteffect = !(dc_lightlist[i].flags & FF_NOSHADE); + lighteffect = !(dc_lightlist[i].flags & FOF_NOSHADE); if (lighteffect) { lightnum = rlight->lightnum; @@ -977,7 +977,7 @@ void R_RenderThickSideRange(drawseg_t *ds, INT32 x1, INT32 x2, ffloor_t *pfloor) if (pindex >= MAXLIGHTSCALE) pindex = MAXLIGHTSCALE-1; - if (pfloor->flags & FF_FOG) + if (pfloor->fofflags & FOF_FOG) { if (pfloor->master->frontsector->extra_colormap) rlight->rcolormap = pfloor->master->frontsector->extra_colormap->colormap + (xwalllights[pindex] - colormaps); @@ -996,15 +996,15 @@ void R_RenderThickSideRange(drawseg_t *ds, INT32 x1, INT32 x2, ffloor_t *pfloor) solid = 0; // don't carry over solid-cutting flag from the previous light // Check if the current light can cut the current 3D floor. - if (rlight->flags & FF_CUTSOLIDS && !(pfloor->flags & FF_EXTRA)) + if (rlight->flags & FOF_CUTSOLIDS && !(pfloor->fofflags & FOF_EXTRA)) solid = 1; - else if (rlight->flags & FF_CUTEXTRA && pfloor->flags & FF_EXTRA) + else if (rlight->flags & FOF_CUTEXTRA && pfloor->fofflags & FOF_EXTRA) { - if (rlight->flags & FF_EXTRA) + if (rlight->flags & FOF_EXTRA) { // The light is from an extra 3D floor... Check the flags so // there are no undesired cuts. - if ((rlight->flags & (FF_FOG|FF_SWIMMABLE)) == (pfloor->flags & (FF_FOG|FF_SWIMMABLE))) + if ((rlight->flags & (FOF_FOG|FOF_SWIMMABLE)) == (pfloor->fofflags & (FOF_FOG|FOF_SWIMMABLE))) solid = 1; } else @@ -1049,7 +1049,7 @@ void R_RenderThickSideRange(drawseg_t *ds, INT32 x1, INT32 x2, ffloor_t *pfloor) { rlight = &dc_lightlist[i]; rlight->height += rlight->heightstep; - if (rlight->flags & FF_CUTLEVEL) + if (rlight->flags & FOF_CUTLEVEL) rlight->botheight += rlight->botheightstep; } continue; @@ -1095,7 +1095,7 @@ void R_RenderThickSideRange(drawseg_t *ds, INT32 x1, INT32 x2, ffloor_t *pfloor) dc_fullbright += COLORMAP_REMAPOFFSET; } - if (pfloor->flags & FF_FOG && pfloor->master->frontsector->extra_colormap) + if (pfloor->fofflags & FOF_FOG && pfloor->master->frontsector->extra_colormap) dc_colormap = pfloor->master->frontsector->extra_colormap->colormap + (dc_colormap - colormaps); else if (frontsector->extra_colormap) dc_colormap = frontsector->extra_colormap->colormap + (dc_colormap - colormaps); @@ -1548,7 +1548,7 @@ static void R_RenderSegLoop (void) for (i = 0; i < dc_numlights; i++) { dc_lightlist[i].height += dc_lightlist[i].heightstep; - if (dc_lightlist[i].flags & FF_CUTSOLIDS) + if (dc_lightlist[i].flags & FOF_CUTSOLIDS) dc_lightlist[i].botheight += dc_lightlist[i].botheightstep; } } @@ -2161,9 +2161,9 @@ void R_StoreWallRange(INT32 start, INT32 stop) i = 0; for (rover = backsector->ffloors; rover && i < MAXFFLOORS; rover = rover->next) { - if (!(rover->flags & FF_RENDERSIDES) || !(rover->flags & FF_EXISTS)) + if (!(rover->fofflags & FOF_RENDERSIDES) || !(rover->fofflags & FOF_EXISTS)) continue; - if (!(rover->flags & FF_ALLSIDES) && rover->flags & FF_INVERTSIDES) + if (!(rover->fofflags & FOF_ALLSIDES) && rover->fofflags & FOF_INVERTSIDES) continue; if (rover->norender == leveltime) @@ -2180,23 +2180,23 @@ void R_StoreWallRange(INT32 start, INT32 stop) if (r2->master == rover->master) // Skip if same control line. break; - if (!(r2->flags & FF_EXISTS) || !(r2->flags & FF_RENDERSIDES)) + if (!(r2->fofflags & FOF_EXISTS) || !(r2->fofflags & FOF_RENDERSIDES)) continue; if (r2->norender == leveltime) continue; - if (rover->flags & FF_EXTRA) + if (rover->fofflags & FOF_EXTRA) { - if (!(r2->flags & FF_CUTEXTRA)) + if (!(r2->fofflags & FOF_CUTEXTRA)) continue; - if (r2->flags & FF_EXTRA && (r2->flags & (FF_TRANSLUCENT|FF_FOG)) != (rover->flags & (FF_TRANSLUCENT|FF_FOG))) + if (r2->fofflags & FOF_EXTRA && (r2->fofflags & (FOF_TRANSLUCENT|FOF_FOG)) != (rover->fofflags & (FOF_TRANSLUCENT|FOF_FOG))) continue; } else { - if (!(r2->flags & FF_CUTSOLIDS)) + if (!(r2->fofflags & FOF_CUTSOLIDS)) continue; } @@ -2219,9 +2219,9 @@ void R_StoreWallRange(INT32 start, INT32 stop) for (rover = frontsector->ffloors; rover && i < MAXFFLOORS; rover = rover->next) { - if (!(rover->flags & FF_RENDERSIDES) || !(rover->flags & FF_EXISTS)) + if (!(rover->fofflags & FOF_RENDERSIDES) || !(rover->fofflags & FOF_EXISTS)) continue; - if (!(rover->flags & FF_ALLSIDES || rover->flags & FF_INVERTSIDES)) + if (!(rover->fofflags & FOF_ALLSIDES || rover->fofflags & FOF_INVERTSIDES)) continue; if (rover->norender == leveltime) @@ -2238,23 +2238,23 @@ void R_StoreWallRange(INT32 start, INT32 stop) if (r2->master == rover->master) // Skip if same control line. break; - if (!(r2->flags & FF_EXISTS) || !(r2->flags & FF_RENDERSIDES)) + if (!(r2->fofflags & FOF_EXISTS) || !(r2->fofflags & FOF_RENDERSIDES)) continue; if (r2->norender == leveltime) continue; - if (rover->flags & FF_EXTRA) + if (rover->fofflags & FOF_EXTRA) { - if (!(r2->flags & FF_CUTEXTRA)) + if (!(r2->fofflags & FOF_CUTEXTRA)) continue; - if (r2->flags & FF_EXTRA && (r2->flags & (FF_TRANSLUCENT|FF_FOG)) != (rover->flags & (FF_TRANSLUCENT|FF_FOG))) + if (r2->fofflags & FOF_EXTRA && (r2->fofflags & (FOF_TRANSLUCENT|FOF_FOG)) != (rover->fofflags & (FOF_TRANSLUCENT|FOF_FOG))) continue; } else { - if (!(r2->flags & FF_CUTSOLIDS)) + if (!(r2->fofflags & FOF_CUTSOLIDS)) continue; } @@ -2279,9 +2279,9 @@ void R_StoreWallRange(INT32 start, INT32 stop) { for (rover = backsector->ffloors, i = 0; rover && i < MAXFFLOORS; rover = rover->next) { - if (!(rover->flags & FF_RENDERSIDES) || !(rover->flags & FF_EXISTS)) + if (!(rover->fofflags & FOF_RENDERSIDES) || !(rover->fofflags & FOF_EXISTS)) continue; - if (!(rover->flags & FF_ALLSIDES) && rover->flags & FF_INVERTSIDES) + if (!(rover->fofflags & FOF_ALLSIDES) && rover->fofflags & FOF_INVERTSIDES) continue; if (rover->norender == leveltime) continue; @@ -2301,9 +2301,9 @@ void R_StoreWallRange(INT32 start, INT32 stop) { for (rover = frontsector->ffloors, i = 0; rover && i < MAXFFLOORS; rover = rover->next) { - if (!(rover->flags & FF_RENDERSIDES) || !(rover->flags & FF_EXISTS)) + if (!(rover->fofflags & FOF_RENDERSIDES) || !(rover->fofflags & FOF_EXISTS)) continue; - if (!(rover->flags & FF_ALLSIDES || rover->flags & FF_INVERTSIDES)) + if (!(rover->fofflags & FOF_ALLSIDES || rover->fofflags & FOF_INVERTSIDES)) continue; if (rover->norender == leveltime) continue; @@ -2523,7 +2523,7 @@ void R_StoreWallRange(INT32 start, INT32 stop) rlight->heightstep = (rlight->heightstep-rlight->height)/(range); rlight->flags = light->flags; - if (light->caster && light->caster->flags & FF_CUTSOLIDS) + if (light->caster && light->caster->fofflags & FOF_CUTSOLIDS) { leftheight = P_GetFFloorBottomZAt(light->caster, segleft.x, segleft.y); rightheight = P_GetFFloorBottomZAt(light->caster, segright.x, segright.y); @@ -2610,7 +2610,7 @@ void R_StoreWallRange(INT32 start, INT32 stop) { for (rover = backsector->ffloors; rover && i < MAXFFLOORS; rover = rover->next) { - if (!(rover->flags & FF_EXISTS) || !(rover->flags & FF_RENDERPLANES)) + if (!(rover->fofflags & FOF_EXISTS) || !(rover->fofflags & FOF_RENDERPLANES)) continue; if (rover->norender == leveltime) continue; @@ -2625,8 +2625,8 @@ void R_StoreWallRange(INT32 start, INT32 stop) if ((roverleft>>4 <= worldhigh || roverright>>4 <= worldhighslope) && (roverleft>>4 >= worldlow || roverright>>4 >= worldlowslope) && - ((viewz < planevistest && (rover->flags & FF_BOTHPLANES || !(rover->flags & FF_INVERTPLANES))) || - (viewz > planevistest && (rover->flags & FF_BOTHPLANES || rover->flags & FF_INVERTPLANES)))) + ((viewz < planevistest && (rover->fofflags & FOF_BOTHPLANES || !(rover->fofflags & FOF_INVERTPLANES))) || + (viewz > planevistest && (rover->fofflags & FOF_BOTHPLANES || rover->fofflags & FOF_INVERTPLANES)))) { //ffloor[i].slope = *rover->b_slope; ffloor[i].b_pos = roverleft; @@ -2648,8 +2648,8 @@ void R_StoreWallRange(INT32 start, INT32 stop) if ((roverleft>>4 <= worldhigh || roverright>>4 <= worldhighslope) && (roverleft>>4 >= worldlow || roverright>>4 >= worldlowslope) && - ((viewz > planevistest && (rover->flags & FF_BOTHPLANES || !(rover->flags & FF_INVERTPLANES))) || - (viewz < planevistest && (rover->flags & FF_BOTHPLANES || rover->flags & FF_INVERTPLANES)))) + ((viewz > planevistest && (rover->fofflags & FOF_BOTHPLANES || !(rover->fofflags & FOF_INVERTPLANES))) || + (viewz < planevistest && (rover->fofflags & FOF_BOTHPLANES || rover->fofflags & FOF_INVERTPLANES)))) { //ffloor[i].slope = *rover->t_slope; ffloor[i].b_pos = roverleft; @@ -2667,7 +2667,7 @@ void R_StoreWallRange(INT32 start, INT32 stop) { for (rover = frontsector->ffloors; rover && i < MAXFFLOORS; rover = rover->next) { - if (!(rover->flags & FF_EXISTS) || !(rover->flags & FF_RENDERPLANES)) + if (!(rover->fofflags & FOF_EXISTS) || !(rover->fofflags & FOF_RENDERPLANES)) continue; if (rover->norender == leveltime) continue; @@ -2682,8 +2682,8 @@ void R_StoreWallRange(INT32 start, INT32 stop) if ((roverleft>>4 <= worldhigh || roverright>>4 <= worldhighslope) && (roverleft>>4 >= worldlow || roverright>>4 >= worldlowslope) && - ((viewz < planevistest && (rover->flags & FF_BOTHPLANES || !(rover->flags & FF_INVERTPLANES))) || - (viewz > planevistest && (rover->flags & FF_BOTHPLANES || rover->flags & FF_INVERTPLANES)))) + ((viewz < planevistest && (rover->fofflags & FOF_BOTHPLANES || !(rover->fofflags & FOF_INVERTPLANES))) || + (viewz > planevistest && (rover->fofflags & FOF_BOTHPLANES || rover->fofflags & FOF_INVERTPLANES)))) { //ffloor[i].slope = *rover->b_slope; ffloor[i].b_pos = roverleft; @@ -2705,8 +2705,8 @@ void R_StoreWallRange(INT32 start, INT32 stop) if ((roverleft>>4 <= worldhigh || roverright>>4 <= worldhighslope) && (roverleft>>4 >= worldlow || roverright>>4 >= worldlowslope) && - ((viewz > planevistest && (rover->flags & FF_BOTHPLANES || !(rover->flags & FF_INVERTPLANES))) || - (viewz < planevistest && (rover->flags & FF_BOTHPLANES || rover->flags & FF_INVERTPLANES)))) + ((viewz > planevistest && (rover->fofflags & FOF_BOTHPLANES || !(rover->fofflags & FOF_INVERTPLANES))) || + (viewz < planevistest && (rover->fofflags & FOF_BOTHPLANES || rover->fofflags & FOF_INVERTPLANES)))) { //ffloor[i].slope = *rover->t_slope; ffloor[i].b_pos = roverleft; diff --git a/src/r_things.c b/src/r_things.c index b30a9139f..5b43beed2 100644 --- a/src/r_things.c +++ b/src/r_things.c @@ -1160,7 +1160,7 @@ static void R_SplitSprite(vissprite_t *sprite) { fixed_t testheight; - if (!(sector->lightlist[i].caster->flags & FF_CUTSPRITES)) + if (!(sector->lightlist[i].caster->fofflags & FOF_CUTSPRITES)) continue; testheight = P_GetLightZAt(§or->lightlist[i], sprite->gx, sprite->gy); @@ -1193,7 +1193,7 @@ static void R_SplitSprite(vissprite_t *sprite) newsprite->szt -= 8; newsprite->cut |= SC_TOP; - if (!(sector->lightlist[i].caster->flags & FF_NOSHADE)) + if (!(sector->lightlist[i].caster->fofflags & FOF_NOSHADE)) { lightnum = (*sector->lightlist[i].lightlevel >> LIGHTSEGSHIFT); @@ -1280,7 +1280,7 @@ fixed_t R_GetShadowZ( if (sector->ffloors) for (rover = sector->ffloors; rover; rover = rover->next) { - if (!(rover->flags & FF_EXISTS) || !(rover->flags & FF_RENDERPLANES) || (rover->alpha < 90 && !(rover->flags & FF_SWIMMABLE))) + if (!(rover->fofflags & FOF_EXISTS) || !(rover->fofflags & FOF_RENDERPLANES) || (rover->alpha < 90 && !(rover->fofflags & FOF_SWIMMABLE))) continue; z = isflipped ? P_GetFFloorBottomZAt(rover, interp.x, interp.y) : P_GetFFloorTopZAt(rover, interp.x, interp.y);