thirdpartymirrors/RingRacers
1
0
Fork 0
mirror of https://github.com/KartKrewDev/RingRacers.git synced 2026-04-26 20:11:47 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Add Lua backwards compatibility for FOF flags

Browse source
This commit is contained in:
MascaraSnake 2022-07-31 12:04:42 +02:00 • committed by Sally Coolatta
parent 890b4583fa
commit 3b971835ee
24 changed files with 890 additions and 703 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

111
src/deh_tables.c
View file

@ -6447,42 +6447,81 @@ struct int_const_s const INT_CONST[] = {
{"SKSKPOWR",SKSKPOWR}, // Power item taunt {"SKSKPOWR",SKSKPOWR}, // Power item taunt
// 3D Floor/Fake Floor/FOF/whatever flags // 3D Floor/Fake Floor/FOF/whatever flags
{"FF_EXISTS",FF_EXISTS}, ///< Always set, to check for validity. {"FOF_EXISTS",FOF_EXISTS}, ///< Always set, to check for validity.
{"FF_BLOCKPLAYER",FF_BLOCKPLAYER}, ///< Solid to player, but nothing else {"FOF_BLOCKPLAYER",FOF_BLOCKPLAYER}, ///< Solid to player, but nothing else
{"FF_BLOCKOTHERS",FF_BLOCKOTHERS}, ///< Solid to everything but player {"FOF_BLOCKOTHERS",FOF_BLOCKOTHERS}, ///< Solid to everything but player
{"FF_SOLID",FF_SOLID}, ///< Clips things. {"FOF_SOLID",FOF_SOLID}, ///< Clips things.
{"FF_RENDERSIDES",FF_RENDERSIDES}, ///< Renders the sides. {"FOF_RENDERSIDES",FOF_RENDERSIDES}, ///< Renders the sides.
{"FF_RENDERPLANES",FF_RENDERPLANES}, ///< Renders the floor/ceiling. {"FOF_RENDERPLANES",FOF_RENDERPLANES}, ///< Renders the floor/ceiling.
{"FF_RENDERALL",FF_RENDERALL}, ///< Renders everything. {"FOF_RENDERALL",FOF_RENDERALL}, ///< Renders everything.
{"FF_SWIMMABLE",FF_SWIMMABLE}, ///< Is a water block. {"FOF_SWIMMABLE",FOF_SWIMMABLE}, ///< Is a water block.
{"FF_NOSHADE",FF_NOSHADE}, ///< Messes with the lighting? {"FOF_NOSHADE",FOF_NOSHADE}, ///< Messes with the lighting?
{"FF_CUTSOLIDS",FF_CUTSOLIDS}, ///< Cuts out hidden solid pixels. {"FOF_CUTSOLIDS",FOF_CUTSOLIDS}, ///< Cuts out hidden solid pixels.
{"FF_CUTEXTRA",FF_CUTEXTRA}, ///< Cuts out hidden translucent pixels. {"FOF_CUTEXTRA",FOF_CUTEXTRA}, ///< Cuts out hidden translucent pixels.
{"FF_CUTLEVEL",FF_CUTLEVEL}, ///< Cuts out all hidden pixels. {"FOF_CUTLEVEL",FOF_CUTLEVEL}, ///< Cuts out all hidden pixels.
{"FF_CUTSPRITES",FF_CUTSPRITES}, ///< Final step in making 3D water. {"FOF_CUTSPRITES",FOF_CUTSPRITES}, ///< Final step in making 3D water.
{"FF_BOTHPLANES",FF_BOTHPLANES}, ///< Render inside and outside planes. {"FOF_BOTHPLANES",FOF_BOTHPLANES}, ///< Render inside and outside planes.
{"FF_EXTRA",FF_EXTRA}, ///< Gets cut by ::FF_CUTEXTRA. {"FOF_EXTRA",FOF_EXTRA}, ///< Gets cut by ::FOF_CUTEXTRA.
{"FF_TRANSLUCENT",FF_TRANSLUCENT}, ///< See through! {"FOF_TRANSLUCENT",FOF_TRANSLUCENT}, ///< See through!
{"FF_FOG",FF_FOG}, ///< Fog "brush." {"FOF_FOG",FOF_FOG}, ///< Fog "brush."
{"FF_INVERTPLANES",FF_INVERTPLANES}, ///< Only render inside planes. {"FOF_INVERTPLANES",FOF_INVERTPLANES}, ///< Only render inside planes.
{"FF_ALLSIDES",FF_ALLSIDES}, ///< Render inside and outside sides. {"FOF_ALLSIDES",FOF_ALLSIDES}, ///< Render inside and outside sides.
{"FF_INVERTSIDES",FF_INVERTSIDES}, ///< Only render inside sides. {"FOF_INVERTSIDES",FOF_INVERTSIDES}, ///< Only render inside sides.
{"FF_DOUBLESHADOW",FF_DOUBLESHADOW}, ///< Make two lightlist entries to reset light? {"FOF_DOUBLESHADOW",FOF_DOUBLESHADOW}, ///< Make two lightlist entries to reset light?
{"FF_FLOATBOB",FF_FLOATBOB}, ///< Floats on water and bobs if you step on it. {"FOF_FLOATBOB",FOF_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. {"FOF_NORETURN",FOF_NORETURN}, ///< Used with ::FOF_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). {"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).
{"FF_GOOWATER",FF_GOOWATER}, ///< Used with ::FF_SWIMMABLE. Makes thick bouncey goop. {"FOF_GOOWATER",FOF_GOOWATER}, ///< Used with ::FOF_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. {"FOF_MARIO",FOF_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! {"FOF_BUSTUP",FOF_BUSTUP}, ///< You can spin through/punch this block and it will crumble!
{"FF_QUICKSAND",FF_QUICKSAND}, ///< Quicksand! {"FOF_QUICKSAND",FOF_QUICKSAND}, ///< Quicksand!
{"FF_PLATFORM",FF_PLATFORM}, ///< You can jump up through this to the top. {"FOF_PLATFORM",FOF_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. {"FOF_REVERSEPLATFORM",FOF_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. {"FOF_INTANGIBLEFLATS",FOF_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. {"FOF_RIPPLE",FOF_RIPPLE}, ///< Ripple the flats
{"FF_RIPPLE",FF_RIPPLE}, ///< Ripple the flats {"FOF_COLORMAPONLY",FOF_COLORMAPONLY}, ///< Only copy the colormap, not the lightlevel
{"FF_COLORMAPONLY",FF_COLORMAPONLY}, ///< Only copy the colormap, not the lightlevel {"FOF_BOUNCY",FOF_BOUNCY}, ///< Bounces players
{"FF_BOUNCY",FF_BOUNCY}, ///< Bounces players {"FOF_SPLAT",FOF_SPLAT}, ///< Use splat flat renderer (treat cyan pixels as invisible)
{"FF_SPLAT",FF_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 // FOF bustable flags
{"FB_PUSHABLES",FB_PUSHABLES}, {"FB_PUSHABLES",FB_PUSHABLES},

74
src/hardware/hw_main.c
View file

@ -839,9 +839,9 @@ static void HWR_SplitWall(sector_t *sector, FOutVector *wallVerts, INT32 texnum,
if (endtop < endrealbot && top < realbot) if (endtop < endrealbot && top < realbot)
return; 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; lightnum = pfloor->master->frontsector->lightlevel;
colormap = pfloor->master->frontsector->extra_colormap; colormap = pfloor->master->frontsector->extra_colormap;
@ -855,13 +855,13 @@ static void HWR_SplitWall(sector_t *sector, FOutVector *wallVerts, INT32 texnum,
solid = false; solid = false;
if ((sector->lightlist[i].flags & FF_CUTSOLIDS) && !(cutflag & FF_EXTRA)) if ((sector->lightlist[i].flags & FOF_CUTSOLIDS) && !(cutflag & FOF_EXTRA))
solid = true; 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; solid = true;
} }
else else
@ -1150,7 +1150,7 @@ static void HWR_ProcessSeg(void) // Sort of like GLWall::Process in GZDoom
polyflags = PF_Environment; polyflags = PF_Environment;
if (gl_frontsector->numlights) 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) else if (grTex->mipmap.flags & TF_TRANSPARENT)
HWR_AddTransparentWall(wallVerts, &Surf, gl_toptexture, polyflags, false, lightnum, colormap); HWR_AddTransparentWall(wallVerts, &Surf, gl_toptexture, polyflags, false, lightnum, colormap);
else else
@ -1223,7 +1223,7 @@ static void HWR_ProcessSeg(void) // Sort of like GLWall::Process in GZDoom
polyflags = PF_Environment; polyflags = PF_Environment;
if (gl_frontsector->numlights) 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) else if (grTex->mipmap.flags & TF_TRANSPARENT)
HWR_AddTransparentWall(wallVerts, &Surf, gl_bottomtexture, polyflags, false, lightnum, colormap); HWR_AddTransparentWall(wallVerts, &Surf, gl_bottomtexture, polyflags, false, lightnum, colormap);
else else
@ -1430,10 +1430,10 @@ static void HWR_ProcessSeg(void) // Sort of like GLWall::Process in GZDoom
if (gl_frontsector->numlights) if (gl_frontsector->numlights)
{ {
if (!(blendmode & PF_Masked)) 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 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)) 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[2].y = FIXED_TO_FLOAT(worldtopslope);
wallVerts[1].y = FIXED_TO_FLOAT(worldbottomslope); 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; FBITFIELD blendmode = PF_Masked;
if (grTex->mipmap.flags & TF_TRANSPARENT) 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... // I don't think that solid walls can use translucent linedef types...
if (gl_frontsector->numlights) 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 else
{ {
if (grTex->mipmap.flags & TF_TRANSPARENT) 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 (bothsides) continue;
if (!(rover->flags & FF_EXISTS) || !(rover->flags & FF_RENDERSIDES)) if (!(rover->fofflags & FOF_EXISTS) || !(rover->fofflags & FOF_RENDERSIDES))
continue; continue;
if (!(rover->flags & FF_ALLSIDES) && rover->flags & FF_INVERTSIDES) if (!(rover->fofflags & FOF_ALLSIDES) && rover->fofflags & FOF_INVERTSIDES)
continue; continue;
SLOPEPARAMS(*rover->t_slope, high1, highslope1, *rover->topheight) 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[2].y = FIXED_TO_FLOAT(hS);
wallVerts[0].y = FIXED_TO_FLOAT(l); wallVerts[0].y = FIXED_TO_FLOAT(l);
wallVerts[1].y = FIXED_TO_FLOAT(lS); 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[3].t = wallVerts[2].t = 0;
wallVerts[0].t = wallVerts[1].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[0].s = wallVerts[3].s = cliplow * grTex->scaleX;
wallVerts[2].s = wallVerts[1].s = cliphigh * grTex->scaleX; wallVerts[2].s = wallVerts[1].s = cliphigh * grTex->scaleX;
} }
if (rover->flags & FF_FOG) if (rover->fofflags & FOF_FOG)
{ {
FBITFIELD blendmode; 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); Surf.PolyColor.s.alpha = HWR_FogBlockAlpha(rover->master->frontsector->lightlevel, rover->master->frontsector->extra_colormap);
if (gl_frontsector->numlights) 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 else
HWR_AddTransparentWall(wallVerts, &Surf, 0, blendmode, true, lightnum, colormap); 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; FBITFIELD blendmode = PF_Masked;
if (rover->flags & FF_TRANSLUCENT) if (rover->fofflags & FOF_TRANSLUCENT)
{ {
if (rover->alpha < 256 || rover->blend) 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) 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 else
{ {
if (blendmode != PF_Masked) if (blendmode != PF_Masked)
@ -1746,9 +1750,9 @@ static void HWR_ProcessSeg(void) // Sort of like GLWall::Process in GZDoom
if (bothsides) continue; if (bothsides) continue;
if (!(rover->flags & FF_EXISTS) || !(rover->flags & FF_RENDERSIDES)) if (!(rover->fofflags & FOF_EXISTS) || !(rover->fofflags & FOF_RENDERSIDES))
continue; continue;
if (!(rover->flags & FF_ALLSIDES || rover->flags & FF_INVERTSIDES)) if (!(rover->fofflags & FOF_ALLSIDES || rover->fofflags & FOF_INVERTSIDES))
continue; continue;
SLOPEPARAMS(*rover->t_slope, high1, highslope1, *rover->topheight) 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[2].y = FIXED_TO_FLOAT(hS);
wallVerts[0].y = FIXED_TO_FLOAT(l); wallVerts[0].y = FIXED_TO_FLOAT(l);
wallVerts[1].y = FIXED_TO_FLOAT(lS); 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[3].t = wallVerts[2].t = 0;
wallVerts[0].t = wallVerts[1].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; wallVerts[2].s = wallVerts[1].s = cliphigh * grTex->scaleX;
} }
if (rover->flags & FF_FOG) if (rover->fofflags & FOF_FOG)
{ {
FBITFIELD blendmode; 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); Surf.PolyColor.s.alpha = HWR_FogBlockAlpha(rover->master->frontsector->lightlevel, rover->master->frontsector->extra_colormap);
if (gl_backsector->numlights) 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 else
HWR_AddTransparentWall(wallVerts, &Surf, 0, blendmode, true, lightnum, colormap); 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; FBITFIELD blendmode = PF_Masked;
if (rover->flags & FF_TRANSLUCENT) if (rover->fofflags & FOF_TRANSLUCENT)
{ {
if (rover->alpha < 256 || rover->blend) 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) 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 else
{ {
if (blendmode != PF_Masked) if (blendmode != PF_Masked)
@ -3086,17 +3090,17 @@ static void HWR_Subsector(size_t num)
cullHeight = P_GetFFloorBottomZAt(rover, viewx, viewy); cullHeight = P_GetFFloorBottomZAt(rover, viewx, viewy);
centerHeight = P_GetFFloorBottomZAt(rover, gl_frontsector->soundorg.x, gl_frontsector->soundorg.y); 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; continue;
if (sub->validcount == validcount) if (sub->validcount == validcount)
continue; continue;
if (centerHeight <= locCeilingHeight && if (centerHeight <= locCeilingHeight &&
centerHeight >= locFloorHeight && centerHeight >= locFloorHeight &&
((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->flags & FF_BOTHPLANES || rover->flags & FF_INVERTPLANES)))) (dup_viewz > cullHeight && (rover->fofflags & FOF_BOTHPLANES || rover->fofflags & FOF_INVERTPLANES))))
{ {
if (rover->flags & FF_FOG) if (rover->fofflags & FOF_FOG)
{ {
UINT8 alpha; UINT8 alpha;
@ -3111,7 +3115,7 @@ static void HWR_Subsector(size_t num)
alpha, rover->master->frontsector, PF_Fog|PF_NoTexture, alpha, rover->master->frontsector, PF_Fog|PF_NoTexture,
true, rover->master->frontsector->extra_colormap); 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 && (rover->alpha < 256 || rover->blend)) // SoM: Flags are more efficient
{ {
FBITFIELD blendmode = HWR_GetBlendModeFlag(rover->blend) | HWR_RippleBlend(gl_frontsector, rover, false); 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 && if (centerHeight >= locFloorHeight &&
centerHeight <= locCeilingHeight && centerHeight <= locCeilingHeight &&
((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->flags & FF_BOTHPLANES || rover->flags & FF_INVERTPLANES)))) (dup_viewz < cullHeight && (rover->fofflags & FOF_BOTHPLANES || rover->fofflags & FOF_INVERTPLANES))))
{ {
if (rover->flags & FF_FOG) if (rover->fofflags & FOF_FOG)
{ {
UINT8 alpha; UINT8 alpha;
@ -3159,7 +3163,7 @@ static void HWR_Subsector(size_t num)
alpha, rover->master->frontsector, PF_Fog|PF_NoTexture, alpha, rover->master->frontsector, PF_Fog|PF_NoTexture,
true, rover->master->frontsector->extra_colormap); 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 && (rover->alpha < 256 || rover->blend)) // SoM: Flags are more efficient
{ {
FBITFIELD blendmode = HWR_GetBlendModeFlag(rover->blend) | HWR_RippleBlend(gl_frontsector, rover, false); 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; return;
// even if we aren't changing colormap or lightlevel, we still need to continue drawing down the sprite // 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) if (!lightset)
{ {

2
src/k_bot.c
View file

@ -402,7 +402,7 @@ static line_t *K_FindBotController(mobj_t *mo)
{ {
sector_t *rs = NULL; sector_t *rs = NULL;
if (!(rover->flags & FF_EXISTS)) if (!(rover->fofflags & FOF_EXISTS))
{ {
continue; continue;
} }

4
src/k_botsearch.c
View file

@ -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 top = INT32_MAX;
fixed_t bottom = INT32_MAX; fixed_t bottom = INT32_MAX;
if (!(rover->flags & FF_EXISTS)) if (!(rover->fofflags & FOF_EXISTS))
{ {
continue; 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); top = P_GetZAt(*rover->t_slope, x, y, *rover->topheight);
bottom = P_GetZAt(*rover->b_slope, x, y, *rover->bottomheight); 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) if ((top >= player->mo->z) && (bottom <= player->mo->z + player->mo->height)
&& K_BotHatesThisSectorsSpecial(player, rover->master->frontsector)) && K_BotHatesThisSectorsSpecial(player, rover->master->frontsector))

16
src/k_kart.c
View file

@ -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. // 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) 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; continue;
s2 = &sectors[rover->secnum]; // makes things easier for us s2 = &sectors[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 top, bottom;
fixed_t d1, d2; fixed_t d1, d2;
if (!(rover->flags & FF_EXISTS)) if (!(rover->fofflags & FOF_EXISTS))
continue; continue;
if ((!(((rover->flags & FF_BLOCKPLAYER && player) if ((!(((rover->fofflags & FOF_BLOCKPLAYER && player)
|| (rover->flags & FF_BLOCKOTHERS && !player)) || (rover->fofflags & FOF_BLOCKOTHERS && !player))
|| (rover->flags & FF_QUICKSAND)) || (rover->fofflags & FOF_QUICKSAND))
|| (rover->flags & FF_SWIMMABLE))) || (rover->fofflags & FOF_SWIMMABLE)))
continue; continue;
top = K_BananaSlopeZ(*rover->t_slope, x, y, *rover->topheight, radius, false); 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 (flip)
{ {
if (rover->flags & FF_QUICKSAND) if (rover->fofflags & FOF_QUICKSAND)
{ {
if (z < top && (z + height) > bottom) 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 else
{ {
if (rover->flags & FF_QUICKSAND) if (rover->fofflags & FOF_QUICKSAND)
{ {
if (z < top && (z + height) > bottom) if (z < top && (z + height) > bottom)
{ {

178
src/lua_maplib.c
View file

@ -214,6 +214,7 @@ enum ffloor_e {
ffloor_tslope, ffloor_tslope,
ffloor_bslope, ffloor_bslope,
ffloor_sector, ffloor_sector,
ffloor_fofflags,
ffloor_flags, ffloor_flags,
ffloor_master, ffloor_master,
ffloor_target, ffloor_target,
@ -1841,6 +1842,80 @@ static int lib_numnodes(lua_State *L)
// ffloor_t // // 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) static int ffloor_get(lua_State *L)
{ {
ffloor_t *ffloor = *((ffloor_t **)luaL_checkudata(L, 1, META_FFLOOR)); 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: case ffloor_sector:
LUA_PushUserdata(L, &sectors[ffloor->secnum], META_SECTOR); LUA_PushUserdata(L, &sectors[ffloor->secnum], META_SECTOR);
return 1; return 1;
case ffloor_fofflags:
lua_pushinteger(L, ffloor->fofflags);
return 1;
case ffloor_flags: case ffloor_flags:
lua_pushinteger(L, ffloor->flags); lua_pushinteger(L, P_GetOldFOFFlags(ffloor));
return 1; return 1;
case ffloor_master: case ffloor_master:
LUA_PushUserdata(L, ffloor->master, META_LINE); LUA_PushUserdata(L, ffloor->master, META_LINE);
@ -1938,6 +2016,88 @@ static int ffloor_get(lua_State *L)
return 0; 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) static int ffloor_set(lua_State *L)
{ {
ffloor_t *ffloor = *((ffloor_t **)luaL_checkudata(L, 1, META_FFLOOR)); 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: case ffloor_bottompic:
*ffloor->bottompic = P_AddLevelFlatRuntime(luaL_checkstring(L, 3)); *ffloor->bottompic = P_AddLevelFlatRuntime(luaL_checkstring(L, 3));
break; 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: { case ffloor_flags: {
ffloortype_e oldflags = ffloor->flags; // store FOF's old flags ffloortype_e oldflags = ffloor->fofflags; // store FOF's old flags
ffloor->flags = luaL_checkinteger(L, 3); busttype_e oldbusttype = ffloor->busttype;
if (ffloor->flags != oldflags) 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 ffloor->target->moved = true; // reset target sector's lightlist
break; break;
} }

2
src/objects/orbinaut.c
View file

@ -125,7 +125,7 @@ void Obj_OrbinautThink(mobj_t *th)
} }
/* todo: UDMFify /* todo: UDMFify
if (P_MobjTouchingSectorSpecialFlag(th, SS)) if (P_MobjTouchingSectorSpecialFlag(th, ?))
{ {
K_DoPogoSpring(th, 0, 1); K_DoPogoSpring(th, 0, 1);
} }

2
src/p_enemy.c
View file

@ -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) 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; continue;
if (*rover->topheight >= mobj->floorz && *rover->topheight <= mobj->z) if (*rover->topheight >= mobj->floorz && *rover->topheight <= mobj->z)

28
src/p_floor.c
View file

@ -554,7 +554,7 @@ static fixed_t P_SectorCheckWater(sector_t *analyzesector,
for (rover = analyzesector->ffloors; rover; rover = rover->next) 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; continue;
// If the sector is below the water, don't bother. // 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) for (rover = sector->ffloors; rover; rover = rover->next)
{ {
if (!(rover->flags & FF_CRUMBLE)) if (!(rover->fofflags & FOF_CRUMBLE))
continue; continue;
if (!(rover->flags & FF_FLOATBOB)) if (!(rover->fofflags & FOF_FLOATBOB))
continue; continue;
if (rover->master != crumble->sourceline) if (rover->master != crumble->sourceline)
@ -772,7 +772,7 @@ void T_StartCrumble(crumble_t *crumble)
rover->alpha = crumble->origalpha; rover->alpha = crumble->origalpha;
if (rover->alpha == 0xff) 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) for (rover = sector->ffloors; rover; rover = rover->next)
{ {
if (rover->flags & FF_NORETURN) if (rover->fofflags & FOF_NORETURN)
continue; continue;
if (!(rover->flags & FF_CRUMBLE)) if (!(rover->fofflags & FOF_CRUMBLE))
continue; continue;
if (!(rover->flags & FF_FLOATBOB)) if (!(rover->fofflags & FOF_FLOATBOB))
continue; continue;
if (rover->master != crumble->sourceline) if (rover->master != crumble->sourceline)
@ -810,7 +810,7 @@ void T_StartCrumble(crumble_t *crumble)
if (rover->alpha == crumble->origalpha) if (rover->alpha == crumble->origalpha)
{ {
rover->flags |= FF_TRANSLUCENT; rover->fofflags |= FOF_TRANSLUCENT;
rover->alpha = 0x00; rover->alpha = 0x00;
} }
else else
@ -818,7 +818,7 @@ void T_StartCrumble(crumble_t *crumble)
rover->alpha = crumble->origalpha; rover->alpha = crumble->origalpha;
if (rover->alpha == 0xff) 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 // I could of used rowoffset, but the FOF actually
// modifies the textures's Y offset. It doesn't with // modifies the textures's Y offset. It doesn't with
// textureoffset, so Effect 4 can be ignored as usual. // 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)) && leveltime < (unsigned)(sides[thwomp->sourceline->sidenum[0]].textureoffset>>FRACBITS))
thwomp->direction = 0; thwomp->direction = 0;
@ -1167,7 +1167,7 @@ void T_ThwompSector(thwomp_t *thwomp)
if (res == pastdest) if (res == pastdest)
{ {
if (rover->flags & FF_EXISTS) if (rover->fofflags & FOF_EXISTS)
S_StartSound((void *)&actionsector->soundorg, thwomp->sound); S_StartSound((void *)&actionsector->soundorg, thwomp->sound);
thwomp->direction = 1; // start heading back up 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) // no longer exists (can't collide with again)
rover->flags &= ~FF_EXISTS; rover->fofflags &= ~FOF_EXISTS;
rover->master->frontsector->moved = true; rover->master->frontsector->moved = true;
P_RecalcPrecipInSector(sec); P_RecalcPrecipInSector(sec);
} }
@ -2042,8 +2042,8 @@ void EV_MarioBlock(ffloor_t *rover, sector_t *sector, mobj_t *puncher)
if (roversec->floordata || roversec->ceilingdata) if (roversec->floordata || roversec->ceilingdata)
return; return;
if (!(rover->flags & FF_SOLID)) if (!(rover->fofflags & FOF_SOLID))
rover->flags |= (FF_SOLID|FF_RENDERALL|FF_CUTLEVEL); rover->fofflags |= (FOF_SOLID|FOF_RENDERALL|FOF_CUTLEVEL);
// Find an item to pop out! // Find an item to pop out!
thing = SearchMarioNode(roversec->touching_thinglist); thing = SearchMarioNode(roversec->touching_thinglist);

50
src/p_map.c
View file

@ -1876,13 +1876,13 @@ boolean P_CheckPosition(mobj_t *thing, fixed_t x, fixed_t y)
{ {
fixed_t topheight, bottomheight; fixed_t topheight, bottomheight;
if (!(rover->flags & FF_EXISTS)) if (!(rover->fofflags & FOF_EXISTS))
continue; continue;
topheight = P_GetFOFTopZ(thing, newsubsec->sector, rover, x, y, NULL); topheight = P_GetFOFTopZ(thing, newsubsec->sector, rover, x, y, NULL);
bottomheight = P_GetFOFBottomZ(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 // If you're inside goowater and slowing down
fixed_t sinklevel = FixedMul(thing->info->height/6, thing->scale); 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)) 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) else if (!((rover->fofflags & FOF_BLOCKPLAYER && thing->player)
|| (rover->flags & FF_BLOCKOTHERS && !thing->player) || (rover->fofflags & FOF_BLOCKOTHERS && !thing->player)
|| rover->flags & FF_QUICKSAND)) || rover->fofflags & FOF_QUICKSAND))
continue; continue;
if (rover->flags & FF_QUICKSAND) if (rover->fofflags & FOF_QUICKSAND)
{ {
if (thing->z < topheight && bottomheight < thingtop) 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)); + ((topheight - bottomheight)/2));
if (topheight > tmfloorz && abs(delta1) < abs(delta2) if (topheight > tmfloorz && abs(delta1) < abs(delta2)
&& !(rover->flags & FF_REVERSEPLATFORM)) && !(rover->fofflags & FOF_REVERSEPLATFORM))
{ {
tmfloorz = tmdropoffz = topheight; tmfloorz = tmdropoffz = topheight;
tmfloorrover = rover; tmfloorrover = rover;
@ -1959,8 +1959,8 @@ boolean P_CheckPosition(mobj_t *thing, fixed_t x, fixed_t y)
tmfloorpic = *rover->toppic; tmfloorpic = *rover->toppic;
} }
if (bottomheight < tmceilingz && abs(delta1) >= abs(delta2) if (bottomheight < tmceilingz && abs(delta1) >= abs(delta2)
&& !(rover->flags & FF_PLATFORM) && !(rover->fofflags & FOF_PLATFORM)
&& !(thing->type == MT_SKIM && (rover->flags & FF_SWIMMABLE))) && !(thing->type == MT_SKIM && (rover->fofflags & FOF_SWIMMABLE)))
{ {
tmceilingz = tmdrpoffceilz = bottomheight; tmceilingz = tmdrpoffceilz = bottomheight;
tmceilingrover = rover; 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) for (rover = newsubsec->sector->ffloors; rover; rover = rover->next)
{ {
fixed_t topheight, bottomheight; 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; continue;
topheight = P_CameraGetFOFTopZ(thiscam, newsubsec->sector, rover, x, y, NULL); 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) static boolean P_WaterRunning(mobj_t *thing)
{ {
ffloor_t *rover = thing->floorrover; ffloor_t *rover = thing->floorrover;
return rover && (rover->flags & FF_SWIMMABLE) && return rover && (rover->fofflags & FOF_SWIMMABLE) &&
P_IsObjectOnGround(thing); P_IsObjectOnGround(thing);
} }
@ -3076,9 +3076,9 @@ static boolean P_ThingHeightClip(mobj_t *thing)
{ {
rover = (thing->eflags & MFE_VERTICALFLIP) ? oldceilingrover : oldfloorrover; rover = (thing->eflags & MFE_VERTICALFLIP) ? oldceilingrover : oldfloorrover;
// Match the Thing's old floorz to an FOF and check for FF_EXISTS // Match the Thing's old floorz to an FOF and check for FOF_EXISTS
// If ~FF_EXISTS, don't set mobj Z. // If ~FOF_EXISTS, don't set mobj Z.
if (!rover || ((rover->flags & FF_EXISTS) && (rover->flags & FF_SOLID))) if (!rover || ((rover->fofflags & FOF_EXISTS) && (rover->fofflags & FOF_SOLID)))
{ {
hitfloor = false; hitfloor = false;
if (thing->eflags & MFE_VERTICALFLIP) 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) for (rover = sec->ffloors; rover; rover = rover->next)
{ {
if (!(rover->flags & FF_EXISTS)) if (!(rover->fofflags & FOF_EXISTS))
continue; continue;
if (!(rover->flags & FF_SWIMMABLE)) if (!(rover->fofflags & FOF_SWIMMABLE))
continue; continue;
if (rover->master->frontsector->damagetype != SD_LAVA) 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) for (rover = thing->subsector->sector->ffloors; rover; rover = rover->next)
{ {
if (!(((rover->flags & FF_BLOCKPLAYER) && thing->player) if (!(((rover->fofflags & FOF_BLOCKPLAYER) && thing->player)
|| ((rover->flags & FF_BLOCKOTHERS) && !thing->player)) || !(rover->flags & FF_EXISTS)) || ((rover->fofflags & FOF_BLOCKOTHERS) && !thing->player)) || !(rover->fofflags & FOF_EXISTS))
continue; continue;
topheight = *rover->topheight; 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) for (rover = sec->ffloors; rover; rover = rover->next)
{ {
fixed_t topheight, bottomheight; fixed_t topheight, bottomheight;
if (!(rover->flags & FF_EXISTS)) if (!(rover->fofflags & FOF_EXISTS))
continue; 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; continue;
topheight = P_GetFFloorTopZAt (rover, x, y); topheight = P_GetFFloorTopZAt (rover, x, y);
bottomheight = P_GetFFloorBottomZAt(rover, x, y); bottomheight = P_GetFFloorBottomZAt(rover, x, y);
if (rover->flags & FF_QUICKSAND) if (rover->fofflags & FOF_QUICKSAND)
{ {
if (z < topheight && bottomheight < thingtop) 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) for (rover = sec->ffloors; rover; rover = rover->next)
{ {
fixed_t topheight, bottomheight; fixed_t topheight, bottomheight;
if (!(rover->flags & FF_EXISTS)) if (!(rover->fofflags & FOF_EXISTS))
continue; 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; continue;
topheight = P_GetFFloorTopZAt (rover, x, y); topheight = P_GetFFloorTopZAt (rover, x, y);
bottomheight = P_GetFFloorBottomZAt(rover, x, y); bottomheight = P_GetFFloorBottomZAt(rover, x, y);
if (rover->flags & FF_QUICKSAND) if (rover->fofflags & FOF_QUICKSAND)
{ {
if (thingtop > bottomheight && topheight > z) if (thingtop > bottomheight && topheight > z)
{ {

24
src/p_maputl.c
View file

@ -437,7 +437,7 @@ void P_CameraLineOpening(line_t *linedef)
for (rover = front->ffloors; rover; rover = rover->next) for (rover = front->ffloors; rover; rover = rover->next)
{ {
fixed_t topheight, bottomheight; 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; continue;
topheight = P_CameraGetFOFTopZ(mapcampointer, front, rover, tmx, tmy, linedef); 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) for (rover = back->ffloors; rover; rover = rover->next)
{ {
fixed_t topheight, bottomheight; 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; continue;
topheight = P_CameraGetFOFTopZ(mapcampointer, back, rover, tmx, tmy, linedef); 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) for (rover = front->ffloors; rover; rover = rover->next)
{ {
fixed_t topheight, bottomheight; fixed_t topheight, bottomheight;
if (!(rover->flags & FF_EXISTS)) if (!(rover->fofflags & FOF_EXISTS))
continue; continue;
if (P_CheckSolidFFloorSurface(mobj, rover)) if (P_CheckSolidFFloorSurface(mobj, rover))
; ;
else if (!((rover->flags & FF_BLOCKPLAYER && mobj->player) else if (!((rover->fofflags & FOF_BLOCKPLAYER && mobj->player)
|| (rover->flags & FF_BLOCKOTHERS && !mobj->player))) || (rover->fofflags & FOF_BLOCKOTHERS && !mobj->player)))
continue; continue;
topheight = P_GetFOFTopZ(mobj, front, rover, tmx, tmy, linedef); 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))); delta1 = abs(mobj->z - (bottomheight + ((topheight - bottomheight)/2)));
delta2 = abs(thingtop - (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) { if (bottomheight < open[FRONT].top) {
open[FRONT].top = bottomheight; open[FRONT].top = bottomheight;
@ -829,7 +829,7 @@ void P_LineOpening(line_t *linedef, mobj_t *mobj)
highceiling = bottomheight; 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) { if (topheight > open[FRONT].bottom) {
open[FRONT].bottom = topheight; 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) for (rover = back->ffloors; rover; rover = rover->next)
{ {
fixed_t topheight, bottomheight; fixed_t topheight, bottomheight;
if (!(rover->flags & FF_EXISTS)) if (!(rover->fofflags & FOF_EXISTS))
continue; continue;
if (P_CheckSolidFFloorSurface(mobj, rover)) if (P_CheckSolidFFloorSurface(mobj, rover))
; ;
else if (!((rover->flags & FF_BLOCKPLAYER && mobj->player) else if (!((rover->fofflags & FOF_BLOCKPLAYER && mobj->player)
|| (rover->flags & FF_BLOCKOTHERS && !mobj->player))) || (rover->fofflags & FOF_BLOCKOTHERS && !mobj->player)))
continue; continue;
topheight = P_GetFOFTopZ(mobj, back, rover, tmx, tmy, linedef); 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))); delta1 = abs(mobj->z - (bottomheight + ((topheight - bottomheight)/2)));
delta2 = abs(thingtop - (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) { if (bottomheight < open[BACK].top) {
open[BACK].top = bottomheight; open[BACK].top = bottomheight;
@ -873,7 +873,7 @@ void P_LineOpening(line_t *linedef, mobj_t *mobj)
highceiling = bottomheight; 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) { if (topheight > open[BACK].bottom) {
open[BACK].bottom = topheight; open[BACK].bottom = topheight;

86
src/p_mobj.c
View file

@ -594,11 +594,11 @@ void P_ExplodeMissile(mobj_t *mo)
boolean P_InsideANonSolidFFloor(mobj_t *mobj, ffloor_t *rover) boolean P_InsideANonSolidFFloor(mobj_t *mobj, ffloor_t *rover)
{ {
fixed_t topheight, bottomheight; fixed_t topheight, bottomheight;
if (!(rover->flags & FF_EXISTS)) if (!(rover->fofflags & FOF_EXISTS))
return false; return false;
if ((((rover->flags & FF_BLOCKPLAYER) && mobj->player) if ((((rover->fofflags & FOF_BLOCKPLAYER) && mobj->player)
|| ((rover->flags & FF_BLOCKOTHERS) && !mobj->player))) || ((rover->fofflags & FOF_BLOCKOTHERS) && !mobj->player)))
return false; return false;
topheight = P_GetFFloorTopZAt (rover, mobj->x, mobj->y); 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) 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; 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; goopgravity = true;
gravfactor = P_GetSectorGravityFactor(rover->master->frontsector); 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) for (rover = node->m_sector->ffloors; rover; rover = rover->next)
{ {
if (!(rover->flags & FF_EXISTS)) if (!(rover->fofflags & FOF_EXISTS))
continue; continue;
if (!(rover->flags & FF_BUSTUP)) if (!(rover->fofflags & FOF_BUSTUP))
continue; continue;
if (!(rover->bustflags & FB_PUSHABLES)) 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) for (rover = sector->ffloors; rover; rover = rover->next)
{ {
if (!(rover->flags & FF_EXISTS)) if (!(rover->fofflags & FOF_EXISTS))
continue; continue;
topheight = P_GetFOFTopZ(mo, sector, rover, mo->x, mo->y, NULL); 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 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; 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... 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->fofflags & (FOF_BLOCKPLAYER|FOF_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_BLOCKOTHERS && !mo->player) // ...solid to others?
)) // ...don't take it into account. )) // ...don't take it into account.
continue; continue;
if (rover->flags & FF_QUICKSAND) if (rover->fofflags & FOF_QUICKSAND)
{ {
switch (motype) switch (motype)
{ {
@ -1989,15 +1989,15 @@ void P_AdjustMobjFloorZ_FFloors(mobj_t *mo, sector_t *sector, UINT8 motype)
delta2 = thingtop - (bottomheight + ((topheight - bottomheight)/2)); delta2 = thingtop - (bottomheight + ((topheight - bottomheight)/2));
if (topheight > mo->floorz && abs(delta1) < abs(delta2) if (topheight > mo->floorz && abs(delta1) < abs(delta2)
&& (rover->flags & FF_SOLID) // Non-FF_SOLID Mario blocks are only solid from bottom && (rover->fofflags & FOF_SOLID) // Non-FOF_SOLID Mario blocks are only solid from bottom
&& !(rover->flags & FF_REVERSEPLATFORM) && !(rover->fofflags & FOF_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) && ((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; mo->floorz = topheight;
} }
if (bottomheight < mo->ceilingz && abs(delta1) >= abs(delta2) if (bottomheight < mo->ceilingz && abs(delta1) >= abs(delta2)
&& !(rover->flags & FF_PLATFORM) && !(rover->fofflags & FOF_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 && ((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; mo->ceilingz = bottomheight;
} }
@ -2125,7 +2125,7 @@ boolean P_CheckSolidLava(mobj_t *mobj, ffloor_t *rover)
return false; 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; return true;
} }
@ -2688,10 +2688,10 @@ static void P_CheckMarioBlocks(mobj_t *mo)
for (rover = node->m_sector->ffloors; rover; rover = rover->next) for (rover = node->m_sector->ffloors; rover; rover = rover->next)
{ {
if (!(rover->flags & FF_EXISTS)) if (!(rover->fofflags & FOF_EXISTS))
continue; continue;
if (!(rover->flags & FF_MARIO)) if (!(rover->fofflags & FOF_MARIO))
continue; continue;
if (mo->eflags & MFE_VERTICALFLIP) if (mo->eflags & MFE_VERTICALFLIP)
@ -2700,7 +2700,7 @@ static void P_CheckMarioBlocks(mobj_t *mo)
if (*rover->bottomheight != mo->ceilingz) if (*rover->bottomheight != mo->ceilingz)
continue; continue;
if (rover->flags & FF_GOOWATER) // Brick block! if (rover->fofflags & FOF_GOOWATER) // Brick block!
EV_CrumbleChain(node->m_sector, rover); EV_CrumbleChain(node->m_sector, rover);
else // Question block! else // Question block!
EV_MarioBlock(rover, node->m_sector, mo); EV_MarioBlock(rover, node->m_sector, mo);
@ -3136,7 +3136,7 @@ boolean P_CanRunOnWater(mobj_t *mobj, ffloor_t *rover)
return false; return false;
} }
if (!(rover->flags & FF_SWIMMABLE)) if (!(rover->fofflags & FOF_SWIMMABLE))
{ {
// It's not even a water FOF. // It's not even a water FOF.
return false; return false;
@ -3252,9 +3252,9 @@ void P_MobjCheckWater(mobj_t *mobj)
topheight = P_GetSpecialTopZ(mobj, sectors + rover->secnum, sector); topheight = P_GetSpecialTopZ(mobj, sectors + rover->secnum, sector);
bottomheight = P_GetSpecialBottomZ(mobj, sectors + rover->secnum, sector); bottomheight = P_GetSpecialBottomZ(mobj, sectors + rover->secnum, sector);
if (!(rover->flags & FF_EXISTS) || !(rover->flags & FF_SWIMMABLE) if (!(rover->fofflags & FOF_EXISTS) || !(rover->fofflags & FOF_SWIMMABLE)
|| (((rover->flags & FF_BLOCKPLAYER) && mobj->player) || (((rover->fofflags & FOF_BLOCKPLAYER) && mobj->player)
|| ((rover->flags & FF_BLOCKOTHERS) && !mobj->player))) || ((rover->fofflags & FOF_BLOCKOTHERS) && !mobj->player)))
{ {
if (topheight < top2 && topheight > thingtop) if (topheight < top2 && topheight > thingtop)
top2 = topheight; top2 = topheight;
@ -3298,7 +3298,7 @@ void P_MobjCheckWater(mobj_t *mobj)
if (rover->master->frontsector->damagetype == SD_LAVA) if (rover->master->frontsector->damagetype == SD_LAVA)
mobj->eflags |= MFE_TOUCHLAVA; 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; mobj->eflags |= MFE_GOOWATER;
} }
} }
@ -3567,7 +3567,7 @@ static void P_SceneryCheckWater(mobj_t *mobj)
for (rover = sector->ffloors; rover; rover = rover->next) 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; continue;
topheight = P_GetFFloorTopZAt (rover, mobj->x, mobj->y); 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) for (rover = sector->ffloors; rover; rover = rover->next)
{ {
if (!(rover->flags & FF_EXISTS)) if (!(rover->fofflags & FOF_EXISTS))
continue; continue;
if (halfheight >= P_GetFFloorTopZAt(rover, thiscam->x, thiscam->y)) 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) 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; continue;
if (halfheight >= P_GetFFloorTopZAt(rover, thiscam->x, thiscam->y)) 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) for (rover = node->m_sector->ffloors; rover; rover = rover->next)
{ {
if (!(rover->flags & FF_EXISTS)) if (!(rover->fofflags & FOF_EXISTS))
continue; continue;
if (!(rover->flags & FF_CRUMBLE)) if (!(rover->fofflags & FOF_CRUMBLE))
continue; continue;
if (mobj->eflags & MFE_VERTICALFLIP) if (mobj->eflags & MFE_VERTICALFLIP)
@ -3824,7 +3824,7 @@ static void P_CheckCrumblingPlatforms(mobj_t *mobj)
continue; 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) for (rover = node->m_sector->ffloors; rover; rover = rover->next)
{ {
if (!(rover->flags & FF_EXISTS)) if (!(rover->fofflags & FOF_EXISTS))
continue; continue;
if (!(rover->flags & FF_SWIMMABLE)) if (!(rover->fofflags & FOF_SWIMMABLE))
continue; continue;
return true; return true;
@ -3876,10 +3876,10 @@ static void P_CheckFloatbobPlatforms(mobj_t *mobj)
for (rover = node->m_sector->ffloors; rover; rover = rover->next) for (rover = node->m_sector->ffloors; rover; rover = rover->next)
{ {
if (!(rover->flags & FF_EXISTS)) if (!(rover->fofflags & FOF_EXISTS))
continue; continue;
if (!(rover->flags & FF_FLOATBOB)) if (!(rover->fofflags & FOF_FLOATBOB))
continue; continue;
@ -4006,12 +4006,12 @@ void P_CalculatePrecipFloor(precipmobj_t *mobj)
for (rover = mobjsecsubsec->ffloors; rover; rover = rover->next) for (rover = mobjsecsubsec->ffloors; rover; rover = rover->next)
{ {
// If it exists, it'll get rained on. // If it exists, it'll get rained on.
if (!(rover->flags & FF_EXISTS)) if (!(rover->fofflags & FOF_EXISTS))
continue; continue;
if (precipprops[curWeather].effects & PRECIPFX_WATERPARTICLES) if (precipprops[curWeather].effects & PRECIPFX_WATERPARTICLES)
{ {
if (!(rover->flags & FF_SWIMMABLE)) if (!(rover->fofflags & FOF_SWIMMABLE))
continue; continue;
if (setWater == false) if (setWater == false)
@ -4033,7 +4033,7 @@ void P_CalculatePrecipFloor(precipmobj_t *mobj)
} }
else else
{ {
if (!(rover->flags & FF_BLOCKOTHERS) && !(rover->flags & FF_SWIMMABLE)) if (!(rover->fofflags & FOF_BLOCKOTHERS) && !(rover->fofflags & FOF_SWIMMABLE))
continue; continue;
height = P_GetFFloorTopZAt(rover, mobj->x, mobj->y); 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) for (rover = precipsector->sector->ffloors; rover; rover = rover->next)
{ {
if (!(rover->flags & FF_EXISTS)) if (!(rover->fofflags & FOF_EXISTS))
continue; continue;
if (!(rover->flags & FF_SWIMMABLE)) if (!(rover->fofflags & FOF_SWIMMABLE))
continue; continue;
condition = true; condition = true;
@ -12756,7 +12756,7 @@ static boolean P_SetupSpawnedMapThing(mapthing_t *mthing, mobj_t *mobj, boolean
ffloor_t *rover; ffloor_t *rover;
for (rover = sec->ffloors; rover; rover = rover->next) 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) if (mthing->options & MTF_OBJECTFLIP)
{ {

8
src/p_saveg.c
View file

@ -1064,7 +1064,7 @@ static boolean CheckFFloorDiff(const sector_t *ss)
for (rover = ss->ffloors; rover; rover = rover->next) for (rover = ss->ffloors; rover; rover = rover->next)
{ {
if (rover->flags != rover->spawnflags if (rover->fofflags != rover->spawnflags
|| rover->alpha != rover->spawnalpha) || rover->alpha != rover->spawnalpha)
{ {
return true; // we found an FOF that changed! 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) for (rover = ss->ffloors; rover; rover = rover->next)
{ {
fflr_diff = 0; // reset diff flags fflr_diff = 0; // reset diff flags
if (rover->flags != rover->spawnflags) if (rover->fofflags != rover->spawnflags)
fflr_diff |= FD_FLAGS; fflr_diff |= FD_FLAGS;
if (rover->alpha != rover->spawnalpha) if (rover->alpha != rover->spawnalpha)
fflr_diff |= FD_ALPHA; fflr_diff |= FD_ALPHA;
@ -1094,7 +1094,7 @@ static void ArchiveFFloors(const sector_t *ss)
WRITEUINT16(save_p, j); // save ffloor "number" WRITEUINT16(save_p, j); // save ffloor "number"
WRITEUINT8(save_p, fflr_diff); WRITEUINT8(save_p, fflr_diff);
if (fflr_diff & FD_FLAGS) if (fflr_diff & FD_FLAGS)
WRITEUINT32(save_p, rover->flags); WRITEUINT32(save_p, rover->fofflags);
if (fflr_diff & FD_ALPHA) if (fflr_diff & FD_ALPHA)
WRITEINT16(save_p, rover->alpha); WRITEINT16(save_p, rover->alpha);
} }
@ -1132,7 +1132,7 @@ static void UnArchiveFFloors(const sector_t *ss)
fflr_diff = READUINT8(save_p); fflr_diff = READUINT8(save_p);
if (fflr_diff & FD_FLAGS) if (fflr_diff & FD_FLAGS)
rover->flags = READUINT32(save_p); rover->fofflags = READUINT32(save_p);
if (fflr_diff & FD_ALPHA) if (fflr_diff & FD_ALPHA)
rover->alpha = READINT16(save_p); rover->alpha = READINT16(save_p);

72
src/p_setup.c
View file

@ -1923,9 +1923,9 @@ static void P_WriteTextmap(void)
freetag = Tag_NextUnused(freetag); freetag = Tag_NextUnused(freetag);
break; break;
case 259: 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)); 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)); 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; break;
case 412: case 412:
@ -3860,67 +3860,67 @@ static INT32 P_GetFOFFlags(INT32 oldflags)
{ {
INT32 result = 0; INT32 result = 0;
if (oldflags & FF_OLD_EXISTS) if (oldflags & FF_OLD_EXISTS)
result |= FF_EXISTS; result |= FOF_EXISTS;
if (oldflags & FF_OLD_BLOCKPLAYER) if (oldflags & FF_OLD_BLOCKPLAYER)
result |= FF_BLOCKPLAYER; result |= FOF_BLOCKPLAYER;
if (oldflags & FF_OLD_BLOCKOTHERS) if (oldflags & FF_OLD_BLOCKOTHERS)
result |= FF_BLOCKOTHERS; result |= FOF_BLOCKOTHERS;
if (oldflags & FF_OLD_RENDERSIDES) if (oldflags & FF_OLD_RENDERSIDES)
result |= FF_RENDERSIDES; result |= FOF_RENDERSIDES;
if (oldflags & FF_OLD_RENDERPLANES) if (oldflags & FF_OLD_RENDERPLANES)
result |= FF_RENDERPLANES; result |= FOF_RENDERPLANES;
if (oldflags & FF_OLD_SWIMMABLE) if (oldflags & FF_OLD_SWIMMABLE)
result |= FF_SWIMMABLE; result |= FOF_SWIMMABLE;
if (oldflags & FF_OLD_NOSHADE) if (oldflags & FF_OLD_NOSHADE)
result |= FF_NOSHADE; result |= FOF_NOSHADE;
if (oldflags & FF_OLD_CUTSOLIDS) if (oldflags & FF_OLD_CUTSOLIDS)
result |= FF_CUTSOLIDS; result |= FOF_CUTSOLIDS;
if (oldflags & FF_OLD_CUTEXTRA) if (oldflags & FF_OLD_CUTEXTRA)
result |= FF_CUTEXTRA; result |= FOF_CUTEXTRA;
if (oldflags & FF_OLD_CUTSPRITES) if (oldflags & FF_OLD_CUTSPRITES)
result |= FF_CUTSPRITES; result |= FOF_CUTSPRITES;
if (oldflags & FF_OLD_BOTHPLANES) if (oldflags & FF_OLD_BOTHPLANES)
result |= FF_BOTHPLANES; result |= FOF_BOTHPLANES;
if (oldflags & FF_OLD_EXTRA) if (oldflags & FF_OLD_EXTRA)
result |= FF_EXTRA; result |= FOF_EXTRA;
if (oldflags & FF_OLD_TRANSLUCENT) if (oldflags & FF_OLD_TRANSLUCENT)
result |= FF_TRANSLUCENT; result |= FOF_TRANSLUCENT;
if (oldflags & FF_OLD_FOG) if (oldflags & FF_OLD_FOG)
result |= FF_FOG; result |= FOF_FOG;
if (oldflags & FF_OLD_INVERTPLANES) if (oldflags & FF_OLD_INVERTPLANES)
result |= FF_INVERTPLANES; result |= FOF_INVERTPLANES;
if (oldflags & FF_OLD_ALLSIDES) if (oldflags & FF_OLD_ALLSIDES)
result |= FF_ALLSIDES; result |= FOF_ALLSIDES;
if (oldflags & FF_OLD_INVERTSIDES) if (oldflags & FF_OLD_INVERTSIDES)
result |= FF_INVERTSIDES; result |= FOF_INVERTSIDES;
if (oldflags & FF_OLD_DOUBLESHADOW) if (oldflags & FF_OLD_DOUBLESHADOW)
result |= FF_DOUBLESHADOW; result |= FOF_DOUBLESHADOW;
if (oldflags & FF_OLD_FLOATBOB) if (oldflags & FF_OLD_FLOATBOB)
result |= FF_FLOATBOB; result |= FOF_FLOATBOB;
if (oldflags & FF_OLD_NORETURN) if (oldflags & FF_OLD_NORETURN)
result |= FF_NORETURN; result |= FOF_NORETURN;
if (oldflags & FF_OLD_CRUMBLE) if (oldflags & FF_OLD_CRUMBLE)
result |= FF_CRUMBLE; result |= FOF_CRUMBLE;
if (oldflags & FF_OLD_GOOWATER) if (oldflags & FF_OLD_GOOWATER)
result |= FF_GOOWATER; result |= FOF_GOOWATER;
if (oldflags & FF_OLD_MARIO) if (oldflags & FF_OLD_MARIO)
result |= FF_MARIO; result |= FOF_MARIO;
if (oldflags & FF_OLD_BUSTUP) if (oldflags & FF_OLD_BUSTUP)
result |= FF_BUSTUP; result |= FOF_BUSTUP;
if (oldflags & FF_OLD_QUICKSAND) if (oldflags & FF_OLD_QUICKSAND)
result |= FF_QUICKSAND; result |= FOF_QUICKSAND;
if (oldflags & FF_OLD_PLATFORM) if (oldflags & FF_OLD_PLATFORM)
result |= FF_PLATFORM; result |= FOF_PLATFORM;
if (oldflags & FF_OLD_REVERSEPLATFORM) if (oldflags & FF_OLD_REVERSEPLATFORM)
result |= FF_REVERSEPLATFORM; result |= FOF_REVERSEPLATFORM;
if (oldflags & FF_OLD_RIPPLE) if (oldflags & FF_OLD_RIPPLE)
result |= FF_RIPPLE; result |= FOF_RIPPLE;
if (oldflags & FF_OLD_COLORMAPONLY) if (oldflags & FF_OLD_COLORMAPONLY)
result |= FF_COLORMAPONLY; result |= FOF_COLORMAPONLY;
return result; return result;
} }
static INT32 P_GetFOFBustflags(INT32 oldflags) static INT32 P_GetFOFBusttype(INT32 oldflags)
{ {
if (oldflags & FF_OLD_SHATTER) if (oldflags & FF_OLD_SHATTER)
return TMFB_TOUCH; return TMFB_TOUCH;
@ -4581,17 +4581,17 @@ static void P_ConvertBinaryLinedefTypes(void)
lines[i].args[0] = tag; lines[i].args[0] = tag;
lines[i].args[3] = P_GetFOFFlags(sides[lines[i].sidenum[1]].toptexture); lines[i].args[3] = P_GetFOFFlags(sides[lines[i].sidenum[1]].toptexture);
if (lines[i].flags & ML_EFFECT6) if (lines[i].flags & ML_EFFECT6)
lines[i].args[3] |= FF_SPLAT; lines[i].args[3] |= FOF_SPLAT;
lines[i].args[4] = P_GetFOFBustflags(sides[lines[i].sidenum[1]].toptexture); lines[i].args[4] = P_GetFOFBusttype(sides[lines[i].sidenum[1]].toptexture);
if (sides[lines[i].sidenum[1]].toptexture & FF_OLD_SHATTERBOTTOM) if (sides[lines[i].sidenum[1]].toptexture & FF_OLD_SHATTERBOTTOM)
lines[i].args[4] |= TMFB_ONLYBOTTOM; lines[i].args[4] |= TMFB_ONLYBOTTOM;
if (lines[i].args[3] & FF_TRANSLUCENT) if (lines[i].args[3] & FOF_TRANSLUCENT)
{ {
P_SetBinaryFOFAlpha(&lines[i]); P_SetBinaryFOFAlpha(&lines[i]);
//Replicate old hack: Translucent FOFs set to full opacity cut cyan pixels //Replicate old hack: Translucent FOFs set to full opacity cut cyan pixels
if (lines[i].args[1] == 256) if (lines[i].args[1] == 256)
lines[i].args[3] |= FF_SPLAT; lines[i].args[3] |= FOF_SPLAT;
} }
else else
lines[i].args[1] = 255; lines[i].args[1] = 255;

18
src/p_sight.c
View file

@ -309,8 +309,8 @@ static boolean P_CrossSubsector(size_t num, register los_t *los)
// check front sector's FOFs first // check front sector's FOFs first
for (rover = front->ffloors; rover; rover = rover->next) for (rover = front->ffloors; rover; rover = rover->next)
{ {
if (!(rover->flags & FF_EXISTS) if (!(rover->fofflags & FOF_EXISTS)
|| !(rover->flags & FF_RENDERSIDES) || rover->flags & FF_TRANSLUCENT) || !(rover->fofflags & FOF_RENDERSIDES) || (rover->fofflags & (FOF_TRANSLUCENT|FOF_FOG)))
{ {
continue; continue;
} }
@ -326,8 +326,8 @@ static boolean P_CrossSubsector(size_t num, register los_t *los)
// check back sector's FOFs as well // check back sector's FOFs as well
for (rover = back->ffloors; rover; rover = rover->next) for (rover = back->ffloors; rover; rover = rover->next)
{ {
if (!(rover->flags & FF_EXISTS) if (!(rover->fofflags & FOF_EXISTS)
|| !(rover->flags & FF_RENDERSIDES) || rover->flags & FF_TRANSLUCENT) || !(rover->fofflags & FOF_RENDERSIDES) || (rover->fofflags & (FOF_TRANSLUCENT|FOF_FOG)))
{ {
continue; continue;
} }
@ -456,8 +456,8 @@ boolean P_CheckSight(mobj_t *t1, mobj_t *t2)
// Allow sight through water, fog, etc. // Allow sight through water, fog, etc.
/// \todo Improve by checking fog density/translucency /// \todo Improve by checking fog density/translucency
/// and setting a sight limit. /// and setting a sight limit.
if (!(rover->flags & FF_EXISTS) if (!(rover->fofflags & FOF_EXISTS)
|| !(rover->flags & FF_RENDERPLANES) /*|| (rover->flags & FF_TRANSLUCENT)*/) || !(rover->fofflags & FOF_RENDERPLANES) /*|| (rover->fofflags & (FOF_TRANSLUCENT|FOF_FOG))*/)
{ {
continue; continue;
} }
@ -475,10 +475,10 @@ boolean P_CheckSight(mobj_t *t1, mobj_t *t2)
return false; return false;
} }
if (rover->flags & FF_SOLID) if (rover->fofflags & FOF_SOLID)
continue; // shortcut since neither mobj can be inside the 3dfloor 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) if (los.sightzstart >= topz1 && t2->z + t2->height < topz2)
return false; // blocked by upper outside plane 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 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) if (los.sightzstart < topz1 && t2->z >= topz2)
return false; // blocked by upper inside plane return false; // blocked by upper inside plane

500
src/p_spec.c
View file

File diff suppressed because it is too large Load diff

4
src/p_spec.h
View file

@ -1032,8 +1032,8 @@ typedef struct
INT16 speed; ///< Speed to fade by INT16 speed; ///< Speed to fade by
boolean ticbased; ///< Tic-based logic toggle boolean ticbased; ///< Tic-based logic toggle
INT32 timer; ///< Timer for tic-based logic INT32 timer; ///< Timer for tic-based logic
boolean doexists; ///< Handle FF_EXISTS boolean doexists; ///< Handle FOF_EXISTS
boolean dotranslucent; ///< Handle FF_TRANSLUCENT boolean dotranslucent; ///< Handle FOF_TRANSLUCENT
boolean dolighting; ///< Handle shadows and light blocks boolean dolighting; ///< Handle shadows and light blocks
boolean docolormap; ///< Handle colormaps boolean docolormap; ///< Handle colormaps
boolean docollision; ///< Handle interactive flags boolean docollision; ///< Handle interactive flags

182
src/p_user.c
View file

@ -979,20 +979,20 @@ boolean P_IsObjectOnGroundIn(mobj_t *mo, sector_t *sec)
for (rover = sec->ffloors; rover; rover = rover->next) for (rover = sec->ffloors; rover; rover = rover->next)
{ {
// If the FOF doesn't exist, continue. // If the FOF doesn't exist, continue.
if (!(rover->flags & FF_EXISTS)) if (!(rover->fofflags & FOF_EXISTS))
continue; continue;
// If the FOF is configured to let the object through, continue. // If the FOF is configured to let the object through, continue.
if (!((rover->flags & FF_BLOCKPLAYER && mo->player) if (!((rover->fofflags & FOF_BLOCKPLAYER && mo->player)
|| (rover->flags & FF_BLOCKOTHERS && !mo->player))) || (rover->fofflags & FOF_BLOCKOTHERS && !mo->player)))
continue; continue;
// If the the platform is intangible from below, continue. // If the the platform is intangible from below, continue.
if (rover->flags & FF_PLATFORM) if (rover->fofflags & FOF_PLATFORM)
continue; continue;
// If the FOF is a water block, continue. (Unnecessary check?) // If the FOF is a water block, continue. (Unnecessary check?)
if (rover->flags & FF_SWIMMABLE) if (rover->fofflags & FOF_SWIMMABLE)
continue; continue;
// Actually check if the player is on the suitable FOF. // 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) for (rover = sec->ffloors; rover; rover = rover->next)
{ {
// If the FOF doesn't exist, continue. // If the FOF doesn't exist, continue.
if (!(rover->flags & FF_EXISTS)) if (!(rover->fofflags & FOF_EXISTS))
continue; continue;
// If the FOF is configured to let the object through, continue. // If the FOF is configured to let the object through, continue.
if (!((rover->flags & FF_BLOCKPLAYER && mo->player) if (!((rover->fofflags & FOF_BLOCKPLAYER && mo->player)
|| (rover->flags & FF_BLOCKOTHERS && !mo->player))) || (rover->fofflags & FOF_BLOCKOTHERS && !mo->player)))
continue; continue;
// If the the platform is intangible from above, continue. // If the the platform is intangible from above, continue.
if (rover->flags & FF_REVERSEPLATFORM) if (rover->fofflags & FOF_REVERSEPLATFORM)
continue; continue;
// If the FOF is a water block, continue. (Unnecessary check?) // If the FOF is a water block, continue. (Unnecessary check?)
if (rover->flags & FF_SWIMMABLE) if (rover->fofflags & FOF_SWIMMABLE)
continue; continue;
// Actually check if the player is on the suitable FOF. // 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) for (rover = sector->ffloors; rover; rover = rover->next)
{ {
if (!(rover->flags & FF_EXISTS)) if (!(rover->fofflags & FOF_EXISTS))
continue; continue;
if (!(rover->flags & FF_QUICKSAND)) if (!(rover->fofflags & FOF_QUICKSAND))
continue; continue;
topheight = P_GetFFloorTopZAt (rover, mo->x, mo->y); 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) for (node = player->mo->touching_sectorlist; node; node = node->m_sectorlist_next)
{ {
ffloor_t *rover;
if (!node->m_sector) if (!node->m_sector)
break; 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; 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)) rover->fofflags |= FOF_BOUNCY;
continue; // FOFs should not be bouncy if they don't even "exist" rover->bouncestrength = P_AproxDistance(rover->master->dx, rover->master->dy)/100;
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;
}
} }
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: bouncydone:
P_UnsetThingPosition(player->mo); P_UnsetThingPosition(player->mo);
player->mo->x = oldx; 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) 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; continue;
topheight = P_GetFFloorTopZAt (rover, player->mo->x, player->mo->y); topheight = P_GetFFloorTopZAt (rover, player->mo->x, player->mo->y);
@ -3540,7 +3514,7 @@ static void P_CalcPostImg(player_t *player)
{ {
size_t j; size_t j;
if (!(rover->flags & FF_EXISTS)) if (!(rover->fofflags & FOF_EXISTS))
continue; continue;
topheight = P_GetFFloorTopZAt (rover, player->mo->x, player->mo->y); 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) 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; continue;
topheight = P_GetFFloorTopZAt (rover, player->mo->x, player->mo->y); topheight = P_GetFFloorTopZAt (rover, player->mo->x, player->mo->y);

32
src/r_bsp.c
View file

@ -70,7 +70,7 @@ boolean R_NoEncore(sector_t *sector, boolean ceiling)
boolean R_IsRipplePlane(sector_t *sector, ffloor_t *rover, int 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)); (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) 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; continue;
if (frontsector->cullheight) if (frontsector->cullheight)
@ -1007,8 +1007,8 @@ static void R_Subsector(size_t num)
planecenterz = P_GetFFloorBottomZAt(rover, frontsector->soundorg.x, frontsector->soundorg.y); planecenterz = P_GetFFloorBottomZAt(rover, frontsector->soundorg.x, frontsector->soundorg.y);
if (planecenterz <= ceilingcenterz if (planecenterz <= ceilingcenterz
&& planecenterz >= floorcenterz && planecenterz >= floorcenterz
&& ((viewz < heightcheck && (rover->flags & FF_BOTHPLANES || !(rover->flags & FF_INVERTPLANES))) && ((viewz < heightcheck && (rover->fofflags & FOF_BOTHPLANES || !(rover->fofflags & FOF_INVERTPLANES)))
|| (viewz > heightcheck && (rover->flags & FF_BOTHPLANES || rover->flags & FF_INVERTPLANES)))) || (viewz > heightcheck && (rover->fofflags & FOF_BOTHPLANES || rover->fofflags & FOF_INVERTPLANES))))
{ {
light = R_GetPlaneLight(frontsector, planecenterz, light = R_GetPlaneLight(frontsector, planecenterz,
viewz < heightcheck); viewz < heightcheck);
@ -1042,8 +1042,8 @@ static void R_Subsector(size_t num)
planecenterz = P_GetFFloorTopZAt(rover, frontsector->soundorg.x, frontsector->soundorg.y); planecenterz = P_GetFFloorTopZAt(rover, frontsector->soundorg.x, frontsector->soundorg.y);
if (planecenterz >= floorcenterz if (planecenterz >= floorcenterz
&& planecenterz <= ceilingcenterz && planecenterz <= ceilingcenterz
&& ((viewz > heightcheck && (rover->flags & FF_BOTHPLANES || !(rover->flags & FF_INVERTPLANES))) && ((viewz > heightcheck && (rover->fofflags & FOF_BOTHPLANES || !(rover->fofflags & FOF_INVERTPLANES)))
|| (viewz < heightcheck && (rover->flags & FF_BOTHPLANES || rover->flags & FF_INVERTPLANES)))) || (viewz < heightcheck && (rover->fofflags & FOF_BOTHPLANES || rover->fofflags & FOF_INVERTPLANES))))
{ {
light = R_GetPlaneLight(frontsector, planecenterz, viewz < heightcheck); light = R_GetPlaneLight(frontsector, planecenterz, viewz < heightcheck);
@ -1196,11 +1196,11 @@ void R_Prep3DFloors(sector_t *sector)
count = 1; count = 1;
for (rover = sector->ffloors; rover; rover = rover->next) for (rover = sector->ffloors; rover; rover = rover->next)
{ {
if ((rover->flags & FF_EXISTS) && (!(rover->flags & FF_NOSHADE) if ((rover->fofflags & FOF_EXISTS) && (!(rover->fofflags & FOF_NOSHADE)
|| (rover->flags & FF_CUTLEVEL) || (rover->flags & FF_CUTSPRITES))) || (rover->fofflags & FOF_CUTLEVEL) || (rover->fofflags & FOF_CUTSPRITES)))
{ {
count++; count++;
if (rover->flags & FF_DOUBLESHADOW) if (rover->fofflags & FOF_DOUBLESHADOW)
count++; count++;
} }
} }
@ -1231,8 +1231,8 @@ void R_Prep3DFloors(sector_t *sector)
for (rover = sector->ffloors; rover; rover = rover->next) for (rover = sector->ffloors; rover; rover = rover->next)
{ {
rover->lastlight = 0; rover->lastlight = 0;
if (!(rover->flags & FF_EXISTS) || (rover->flags & FF_NOSHADE if (!(rover->fofflags & FOF_EXISTS) || (rover->fofflags & FOF_NOSHADE
&& !(rover->flags & FF_CUTLEVEL) && !(rover->flags & FF_CUTSPRITES))) && !(rover->fofflags & FOF_CUTLEVEL) && !(rover->fofflags & FOF_CUTSPRITES)))
continue; continue;
heighttest = P_GetFFloorTopZAt(rover, sector->soundorg.x, sector->soundorg.y); heighttest = P_GetFFloorTopZAt(rover, sector->soundorg.x, sector->soundorg.y);
@ -1244,7 +1244,7 @@ void R_Prep3DFloors(sector_t *sector)
bestslope = *rover->t_slope; bestslope = *rover->t_slope;
continue; continue;
} }
if (rover->flags & FF_DOUBLESHADOW) { if (rover->fofflags & FOF_DOUBLESHADOW) {
heighttest = P_GetFFloorBottomZAt(rover, sector->soundorg.x, sector->soundorg.y); heighttest = P_GetFFloorBottomZAt(rover, sector->soundorg.x, sector->soundorg.y);
if (heighttest > bestheight if (heighttest > bestheight
@ -1265,16 +1265,16 @@ void R_Prep3DFloors(sector_t *sector)
sector->lightlist[i].height = maxheight = bestheight; sector->lightlist[i].height = maxheight = bestheight;
sector->lightlist[i].caster = best; sector->lightlist[i].caster = best;
sector->lightlist[i].flags = best->flags; sector->lightlist[i].flags = best->fofflags;
sector->lightlist[i].slope = bestslope; sector->lightlist[i].slope = bestslope;
sec = &sectors[best->secnum]; sec = &sectors[best->secnum];
if (best->flags & FF_NOSHADE) if (best->fofflags & FOF_NOSHADE)
{ {
sector->lightlist[i].lightlevel = sector->lightlist[i-1].lightlevel; sector->lightlist[i].lightlevel = sector->lightlist[i-1].lightlevel;
sector->lightlist[i].extra_colormap = sector->lightlist[i-1].extra_colormap; 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].lightlevel = sector->lightlist[i-1].lightlevel;
sector->lightlist[i].extra_colormap = &sec->extra_colormap; 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; 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); heighttest = P_GetFFloorBottomZAt(best, sector->soundorg.x, sector->soundorg.y);
if (bestheight == heighttest) ///TODO: do this in a more efficient way -Red if (bestheight == heighttest) ///TODO: do this in a more efficient way -Red

82
src/r_defs.h
View file

@ -115,41 +115,41 @@ typedef struct
*/ */
typedef enum typedef enum
{ {
FF_EXISTS = 0x1, ///< Always set, to check for validity. FOF_EXISTS = 0x1, ///< Always set, to check for validity.
FF_BLOCKPLAYER = 0x2, ///< Solid to player, but nothing else FOF_BLOCKPLAYER = 0x2, ///< Solid to player, but nothing else
FF_BLOCKOTHERS = 0x4, ///< Solid to everything but player FOF_BLOCKOTHERS = 0x4, ///< Solid to everything but player
FF_SOLID = 0x6, ///< Clips things. FOF_SOLID = 0x6, ///< Clips things.
FF_RENDERSIDES = 0x8, ///< Renders the sides. FOF_RENDERSIDES = 0x8, ///< Renders the sides.
FF_RENDERPLANES = 0x10, ///< Renders the floor/ceiling. FOF_RENDERPLANES = 0x10, ///< Renders the floor/ceiling.
FF_RENDERALL = 0x18, ///< Renders everything. FOF_RENDERALL = 0x18, ///< Renders everything.
FF_SWIMMABLE = 0x20, ///< Is a water block. FOF_SWIMMABLE = 0x20, ///< Is a water block.
FF_NOSHADE = 0x40, ///< Messes with the lighting? FOF_NOSHADE = 0x40, ///< Messes with the lighting?
FF_CUTSOLIDS = 0x80, ///< Cuts out hidden solid pixels. FOF_CUTSOLIDS = 0x80, ///< Cuts out hidden solid pixels.
FF_CUTEXTRA = 0x100, ///< Cuts out hidden translucent pixels. FOF_CUTEXTRA = 0x100, ///< Cuts out hidden translucent pixels.
FF_CUTLEVEL = 0x180, ///< Cuts out all hidden pixels. FOF_CUTLEVEL = 0x180, ///< Cuts out all hidden pixels.
FF_CUTSPRITES = 0x200, ///< Final step in making 3D water. FOF_CUTSPRITES = 0x200, ///< Final step in making 3D water.
FF_BOTHPLANES = 0x400, ///< Render inside and outside planes. FOF_BOTHPLANES = 0x400, ///< Render inside and outside planes.
FF_EXTRA = 0x800, ///< Gets cut by ::FF_CUTEXTRA. FOF_EXTRA = 0x800, ///< Gets cut by ::FOF_CUTEXTRA.
FF_TRANSLUCENT = 0x1000, ///< See through! FOF_TRANSLUCENT = 0x1000, ///< See through!
FF_FOG = 0x2000, ///< Fog "brush." FOF_FOG = 0x2000, ///< Fog "brush."
FF_INVERTPLANES = 0x4000, ///< Only render inside planes. FOF_INVERTPLANES = 0x4000, ///< Only render inside planes.
FF_ALLSIDES = 0x8000, ///< Render inside and outside sides. FOF_ALLSIDES = 0x8000, ///< Render inside and outside sides.
FF_INVERTSIDES = 0x10000, ///< Only render inside sides. FOF_INVERTSIDES = 0x10000, ///< Only render inside sides.
FF_DOUBLESHADOW = 0x20000, ///< Make two lightlist entries to reset light? FOF_DOUBLESHADOW = 0x20000, ///< Make two lightlist entries to reset light?
FF_FLOATBOB = 0x40000, ///< Floats on water and bobs if you step on it. FOF_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. FOF_NORETURN = 0x80000, ///< Used with ::FOF_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). 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).
FF_GOOWATER = 0x200000, ///< Used with ::FF_SWIMMABLE. Makes thick bouncey goop. FOF_GOOWATER = 0x200000, ///< Used with ::FOF_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. FOF_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! FOF_BUSTUP = 0x800000, ///< You can spin through/punch this block and it will crumble!
FF_QUICKSAND = 0x1000000, ///< Quicksand! FOF_QUICKSAND = 0x1000000, ///< Quicksand!
FF_PLATFORM = 0x2000000, ///< You can jump up through this to the top. FOF_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. FOF_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. FOF_INTANGIBLEFLATS = 0x6000000, ///< Both flats are intangible, but the sides are still solid.
FF_RIPPLE = 0x8000000, ///< Ripple the flats FOF_RIPPLE = 0x8000000, ///< Ripple the flats
FF_COLORMAPONLY = 0x10000000, ///< Only copy the colormap, not the lightlevel FOF_COLORMAPONLY = 0x10000000, ///< Only copy the colormap, not the lightlevel
FF_BOUNCY = 0x20000000, ///< Bounces players FOF_BOUNCY = 0x20000000, ///< Bounces players
FF_SPLAT = 0x40000000, ///< Use splat flat renderer (treat cyan pixels as invisible) FOF_SPLAT = 0x40000000, ///< Use splat flat renderer (treat cyan pixels as invisible)
} ffloortype_e; } ffloortype_e;
typedef enum typedef enum
@ -190,7 +190,7 @@ typedef enum
FF_OLD_SPINBUST = 0x10000000, FF_OLD_SPINBUST = 0x10000000,
FF_OLD_STRONGBUST = 0x20000000, FF_OLD_STRONGBUST = 0x20000000,
FF_OLD_RIPPLE = 0x40000000, FF_OLD_RIPPLE = 0x40000000,
FF_OLD_COLORMAPONLY = 0x80000000, FF_OLD_COLORMAPONLY = (INT32)0x80000000,
} oldffloortype_e; } oldffloortype_e;
typedef enum typedef enum
@ -228,7 +228,7 @@ typedef struct ffloor_s
struct pslope_s **b_slope; struct pslope_s **b_slope;
size_t secnum; size_t secnum;
ffloortype_e flags; ffloortype_e fofflags;
struct line_s *master; struct line_s *master;
struct sector_s *target; struct sector_s *target;
@ -241,16 +241,16 @@ typedef struct ffloor_s
UINT8 blend; UINT8 blend;
tic_t norender; // for culling tic_t norender; // for culling
// Only relevant for FF_BUSTUP // Only relevant for FOF_BUSTUP
ffloorbustflags_e bustflags; ffloorbustflags_e bustflags;
UINT8 busttype; UINT8 busttype;
INT16 busttag; INT16 busttag;
// Only relevant for FF_QUICKSAND // Only relevant for FOF_QUICKSAND
fixed_t sinkspeed; fixed_t sinkspeed;
fixed_t friction; fixed_t friction;
// Only relevant for FF_BOUNCY // Only relevant for FOF_BOUNCY
fixed_t bouncestrength; fixed_t bouncestrength;
// these are saved for netgames, so do not let Lua touch these! // 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 extracolormap_t **extra_colormap; // pointer-to-a-pointer, so we can react to colormap changes
INT32 flags; INT32 flags;
ffloor_t *caster; 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; } lightlist_t;

2
src/r_draw8.c
View file

@ -2485,7 +2485,7 @@ void R_DrawColumnShadowed_8(void)
{ {
// If the height of the light is above the column, get the colormap // If the height of the light is above the column, get the colormap
// anyway because the lighting of the top should be affected. // 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; height = dc_lightlist[i].height >> LIGHTSCALESHIFT;
if (solid) if (solid)

12
src/r_plane.c
View file

@ -872,13 +872,13 @@ void R_DrawSinglePlane(visplane_t *pl)
// Don't draw planes that shouldn't be drawn. // Don't draw planes that shouldn't be drawn.
for (rover = pl->ffloor->target->ffloors; rover; rover = rover->next) 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 // The plane is from an extra 3D floor... Check the flags so
// there are no undesired cuts. // 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->topheight
&& pl->height > *rover->bottomheight) && pl->height > *rover->bottomheight)
return; 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 // Hacked up support for alpha value in software mode Tails 09-24-2002
// ...unhacked by toaster 04-01-2021 // ...unhacked by toaster 04-01-2021
@ -905,7 +905,7 @@ void R_DrawSinglePlane(visplane_t *pl)
else else
light = LIGHTLEVELS-1; light = LIGHTLEVELS-1;
} }
else if (pl->ffloor->flags & FF_FOG) else if (pl->ffloor->fofflags & FOF_FOG)
{ {
spanfunctype = SPANDRAWFUNC_FOG; spanfunctype = SPANDRAWFUNC_FOG;
light = (pl->lightlevel >> LIGHTSEGSHIFT); light = (pl->lightlevel >> LIGHTSEGSHIFT);

98
src/r_segs.c
View file

@ -270,7 +270,7 @@ void R_RenderMaskedSegRange(drawseg_t *ds, INT32 x1, INT32 x2)
rlight->flags = light->flags; rlight->flags = light->flags;
if ((R_CheckColumnFunc(COLDRAWFUNC_FUZZY) == false) if ((R_CheckColumnFunc(COLDRAWFUNC_FUZZY) == false)
|| (rlight->flags & FF_FOG) || (rlight->flags & FOF_FOG)
|| (rlight->extra_colormap && (rlight->extra_colormap->flags & CMF_FOG))) || (rlight->extra_colormap && (rlight->extra_colormap->flags & CMF_FOG)))
lightnum = (rlight->lightlevel >> LIGHTSEGSHIFT); lightnum = (rlight->lightlevel >> LIGHTSEGSHIFT);
else else
@ -410,7 +410,7 @@ void R_RenderMaskedSegRange(drawseg_t *ds, INT32 x1, INT32 x2)
{ {
rlight = &dc_lightlist[i]; rlight = &dc_lightlist[i];
if ((rlight->flags & FF_NOSHADE)) if ((rlight->flags & FOF_NOSHADE))
continue; continue;
if (rlight->lightnum < 0) 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. // Polyobjects have no ffloors, and they're handled in the conditional above.
if (pfloor->ffloor != NULL) if (pfloor->ffloor != NULL)
return (pfloor->ffloor->flags & (FF_TRANSLUCENT|FF_FOG)); return (pfloor->ffloor->fofflags & (FOF_TRANSLUCENT|FOF_FOG));
return false; return false;
} }
@ -648,7 +648,7 @@ void R_RenderThickSideRange(drawseg_t *ds, INT32 x1, INT32 x2, ffloor_t *pfloor)
bmnum = R_GetTextureBrightmap(texnum); bmnum = R_GetTextureBrightmap(texnum);
} }
if (pfloor->flags & FF_TRANSLUCENT) if (pfloor->fofflags & FOF_TRANSLUCENT)
{ {
boolean fuzzy = true; 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); R_SetColumnFunc(COLDRAWFUNC_FUZZY, bmnum != 0);
} }
} }
else if (pfloor->flags & FF_FOG) else if (pfloor->fofflags & FOF_FOG)
{ {
R_SetColumnFunc(COLDRAWFUNC_FOG, bmnum != 0); 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; else rlight->heightstep = CLAMPMIN;
rlight->heightstep = (rlight->heightstep-rlight->height)/(range); rlight->heightstep = (rlight->heightstep-rlight->height)/(range);
rlight->flags = light->flags; rlight->flags = light->flags;
if (light->flags & FF_CUTLEVEL) if (light->flags & FOF_CUTLEVEL)
{ {
SLOPEPARAMS(*light->caster->b_slope, leftheight, rightheight, *light->caster->bottomheight) SLOPEPARAMS(*light->caster->b_slope, leftheight, rightheight, *light->caster->bottomheight)
#undef SLOPEPARAMS #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; rlight->extra_colormap = *light->extra_colormap;
// Check if the current light effects the colormap/lightlevel // 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); rlight->lightnum = (pfloor->master->frontsector->lightlevel >> LIGHTSEGSHIFT);
else else
rlight->lightnum = (rlight->lightlevel >> LIGHTSEGSHIFT); 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)) else if (P_ApplyLightOffset(rlight->lightnum))
rlight->lightnum += curline->lightOffset; 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! // Get correct light level!
if ((frontsector->extra_colormap && (frontsector->extra_colormap->flags & CMF_FOG))) if ((frontsector->extra_colormap && (frontsector->extra_colormap->flags & CMF_FOG)))
lightnum = (frontsector->lightlevel >> LIGHTSEGSHIFT); lightnum = (frontsector->lightlevel >> LIGHTSEGSHIFT);
else if (pfloor->flags & FF_FOG) else if (pfloor->fofflags & FOF_FOG)
lightnum = (pfloor->master->frontsector->lightlevel >> LIGHTSEGSHIFT); lightnum = (pfloor->master->frontsector->lightlevel >> LIGHTSEGSHIFT);
else if (R_CheckColumnFunc(COLDRAWFUNC_FUZZY) == true) else if (R_CheckColumnFunc(COLDRAWFUNC_FUZZY) == true)
lightnum = LIGHTLEVELS-1; 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) lightnum = R_FakeFlat(frontsector, &tempsec, &templight, &templight, false)
->lightlevel >> LIGHTSEGSHIFT; ->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)) else if (P_ApplyLightOffset(lightnum))
lightnum += curline->lightOffset; 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 = &dc_lightlist[i];
rlight->height += rlight->heightstep; rlight->height += rlight->heightstep;
if (rlight->flags & FF_CUTLEVEL) if (rlight->flags & FOF_CUTLEVEL)
rlight->botheight += rlight->botheightstep; 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 // Check if the current light effects the colormap/lightlevel
rlight = &dc_lightlist[i]; rlight = &dc_lightlist[i];
lighteffect = !(dc_lightlist[i].flags & FF_NOSHADE); lighteffect = !(dc_lightlist[i].flags & FOF_NOSHADE);
if (lighteffect) if (lighteffect)
{ {
lightnum = rlight->lightnum; lightnum = rlight->lightnum;
@ -977,7 +977,7 @@ void R_RenderThickSideRange(drawseg_t *ds, INT32 x1, INT32 x2, ffloor_t *pfloor)
if (pindex >= MAXLIGHTSCALE) if (pindex >= MAXLIGHTSCALE)
pindex = MAXLIGHTSCALE-1; pindex = MAXLIGHTSCALE-1;
if (pfloor->flags & FF_FOG) if (pfloor->fofflags & FOF_FOG)
{ {
if (pfloor->master->frontsector->extra_colormap) if (pfloor->master->frontsector->extra_colormap)
rlight->rcolormap = pfloor->master->frontsector->extra_colormap->colormap + (xwalllights[pindex] - colormaps); 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 solid = 0; // don't carry over solid-cutting flag from the previous light
// Check if the current light can cut the current 3D floor. // 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; 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 // The light is from an extra 3D floor... Check the flags so
// there are no undesired cuts. // 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; solid = 1;
} }
else else
@ -1049,7 +1049,7 @@ void R_RenderThickSideRange(drawseg_t *ds, INT32 x1, INT32 x2, ffloor_t *pfloor)
{ {
rlight = &dc_lightlist[i]; rlight = &dc_lightlist[i];
rlight->height += rlight->heightstep; rlight->height += rlight->heightstep;
if (rlight->flags & FF_CUTLEVEL) if (rlight->flags & FOF_CUTLEVEL)
rlight->botheight += rlight->botheightstep; rlight->botheight += rlight->botheightstep;
} }
continue; continue;
@ -1095,7 +1095,7 @@ void R_RenderThickSideRange(drawseg_t *ds, INT32 x1, INT32 x2, ffloor_t *pfloor)
dc_fullbright += COLORMAP_REMAPOFFSET; 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); dc_colormap = pfloor->master->frontsector->extra_colormap->colormap + (dc_colormap - colormaps);
else if (frontsector->extra_colormap) else if (frontsector->extra_colormap)
dc_colormap = frontsector->extra_colormap->colormap + (dc_colormap - colormaps); 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++) for (i = 0; i < dc_numlights; i++)
{ {
dc_lightlist[i].height += dc_lightlist[i].heightstep; 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; dc_lightlist[i].botheight += dc_lightlist[i].botheightstep;
} }
} }
@ -2161,9 +2161,9 @@ void R_StoreWallRange(INT32 start, INT32 stop)
i = 0; i = 0;
for (rover = backsector->ffloors; rover && i < MAXFFLOORS; rover = rover->next) 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; continue;
if (!(rover->flags & FF_ALLSIDES) && rover->flags & FF_INVERTSIDES) if (!(rover->fofflags & FOF_ALLSIDES) && rover->fofflags & FOF_INVERTSIDES)
continue; continue;
if (rover->norender == leveltime) 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. if (r2->master == rover->master) // Skip if same control line.
break; break;
if (!(r2->flags & FF_EXISTS) || !(r2->flags & FF_RENDERSIDES)) if (!(r2->fofflags & FOF_EXISTS) || !(r2->fofflags & FOF_RENDERSIDES))
continue; continue;
if (r2->norender == leveltime) if (r2->norender == leveltime)
continue; continue;
if (rover->flags & FF_EXTRA) if (rover->fofflags & FOF_EXTRA)
{ {
if (!(r2->flags & FF_CUTEXTRA)) if (!(r2->fofflags & FOF_CUTEXTRA))
continue; 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; continue;
} }
else else
{ {
if (!(r2->flags & FF_CUTSOLIDS)) if (!(r2->fofflags & FOF_CUTSOLIDS))
continue; continue;
} }
@ -2219,9 +2219,9 @@ void R_StoreWallRange(INT32 start, INT32 stop)
for (rover = frontsector->ffloors; rover && i < MAXFFLOORS; rover = rover->next) 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; continue;
if (!(rover->flags & FF_ALLSIDES || rover->flags & FF_INVERTSIDES)) if (!(rover->fofflags & FOF_ALLSIDES || rover->fofflags & FOF_INVERTSIDES))
continue; continue;
if (rover->norender == leveltime) 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. if (r2->master == rover->master) // Skip if same control line.
break; break;
if (!(r2->flags & FF_EXISTS) || !(r2->flags & FF_RENDERSIDES)) if (!(r2->fofflags & FOF_EXISTS) || !(r2->fofflags & FOF_RENDERSIDES))
continue; continue;
if (r2->norender == leveltime) if (r2->norender == leveltime)
continue; continue;
if (rover->flags & FF_EXTRA) if (rover->fofflags & FOF_EXTRA)
{ {
if (!(r2->flags & FF_CUTEXTRA)) if (!(r2->fofflags & FOF_CUTEXTRA))
continue; 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; continue;
} }
else else
{ {
if (!(r2->flags & FF_CUTSOLIDS)) if (!(r2->fofflags & FOF_CUTSOLIDS))
continue; continue;
} }
@ -2279,9 +2279,9 @@ void R_StoreWallRange(INT32 start, INT32 stop)
{ {
for (rover = backsector->ffloors, i = 0; rover && i < MAXFFLOORS; rover = rover->next) 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; continue;
if (!(rover->flags & FF_ALLSIDES) && rover->flags & FF_INVERTSIDES) if (!(rover->fofflags & FOF_ALLSIDES) && rover->fofflags & FOF_INVERTSIDES)
continue; continue;
if (rover->norender == leveltime) if (rover->norender == leveltime)
continue; continue;
@ -2301,9 +2301,9 @@ void R_StoreWallRange(INT32 start, INT32 stop)
{ {
for (rover = frontsector->ffloors, i = 0; rover && i < MAXFFLOORS; rover = rover->next) 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; continue;
if (!(rover->flags & FF_ALLSIDES || rover->flags & FF_INVERTSIDES)) if (!(rover->fofflags & FOF_ALLSIDES || rover->fofflags & FOF_INVERTSIDES))
continue; continue;
if (rover->norender == leveltime) if (rover->norender == leveltime)
continue; continue;
@ -2523,7 +2523,7 @@ void R_StoreWallRange(INT32 start, INT32 stop)
rlight->heightstep = (rlight->heightstep-rlight->height)/(range); rlight->heightstep = (rlight->heightstep-rlight->height)/(range);
rlight->flags = light->flags; 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); leftheight = P_GetFFloorBottomZAt(light->caster, segleft.x, segleft.y);
rightheight = P_GetFFloorBottomZAt(light->caster, segright.x, segright.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) 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; continue;
if (rover->norender == leveltime) if (rover->norender == leveltime)
continue; continue;
@ -2625,8 +2625,8 @@ void R_StoreWallRange(INT32 start, INT32 stop)
if ((roverleft>>4 <= worldhigh || roverright>>4 <= worldhighslope) && if ((roverleft>>4 <= worldhigh || roverright>>4 <= worldhighslope) &&
(roverleft>>4 >= worldlow || roverright>>4 >= worldlowslope) && (roverleft>>4 >= worldlow || roverright>>4 >= worldlowslope) &&
((viewz < planevistest && (rover->flags & FF_BOTHPLANES || !(rover->flags & FF_INVERTPLANES))) || ((viewz < planevistest && (rover->fofflags & FOF_BOTHPLANES || !(rover->fofflags & FOF_INVERTPLANES))) ||
(viewz > planevistest && (rover->flags & FF_BOTHPLANES || rover->flags & FF_INVERTPLANES)))) (viewz > planevistest && (rover->fofflags & FOF_BOTHPLANES || rover->fofflags & FOF_INVERTPLANES))))
{ {
//ffloor[i].slope = *rover->b_slope; //ffloor[i].slope = *rover->b_slope;
ffloor[i].b_pos = roverleft; ffloor[i].b_pos = roverleft;
@ -2648,8 +2648,8 @@ void R_StoreWallRange(INT32 start, INT32 stop)
if ((roverleft>>4 <= worldhigh || roverright>>4 <= worldhighslope) && if ((roverleft>>4 <= worldhigh || roverright>>4 <= worldhighslope) &&
(roverleft>>4 >= worldlow || roverright>>4 >= worldlowslope) && (roverleft>>4 >= worldlow || roverright>>4 >= worldlowslope) &&
((viewz > planevistest && (rover->flags & FF_BOTHPLANES || !(rover->flags & FF_INVERTPLANES))) || ((viewz > planevistest && (rover->fofflags & FOF_BOTHPLANES || !(rover->fofflags & FOF_INVERTPLANES))) ||
(viewz < planevistest && (rover->flags & FF_BOTHPLANES || rover->flags & FF_INVERTPLANES)))) (viewz < planevistest && (rover->fofflags & FOF_BOTHPLANES || rover->fofflags & FOF_INVERTPLANES))))
{ {
//ffloor[i].slope = *rover->t_slope; //ffloor[i].slope = *rover->t_slope;
ffloor[i].b_pos = roverleft; 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) 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; continue;
if (rover->norender == leveltime) if (rover->norender == leveltime)
continue; continue;
@ -2682,8 +2682,8 @@ void R_StoreWallRange(INT32 start, INT32 stop)
if ((roverleft>>4 <= worldhigh || roverright>>4 <= worldhighslope) && if ((roverleft>>4 <= worldhigh || roverright>>4 <= worldhighslope) &&
(roverleft>>4 >= worldlow || roverright>>4 >= worldlowslope) && (roverleft>>4 >= worldlow || roverright>>4 >= worldlowslope) &&
((viewz < planevistest && (rover->flags & FF_BOTHPLANES || !(rover->flags & FF_INVERTPLANES))) || ((viewz < planevistest && (rover->fofflags & FOF_BOTHPLANES || !(rover->fofflags & FOF_INVERTPLANES))) ||
(viewz > planevistest && (rover->flags & FF_BOTHPLANES || rover->flags & FF_INVERTPLANES)))) (viewz > planevistest && (rover->fofflags & FOF_BOTHPLANES || rover->fofflags & FOF_INVERTPLANES))))
{ {
//ffloor[i].slope = *rover->b_slope; //ffloor[i].slope = *rover->b_slope;
ffloor[i].b_pos = roverleft; ffloor[i].b_pos = roverleft;
@ -2705,8 +2705,8 @@ void R_StoreWallRange(INT32 start, INT32 stop)
if ((roverleft>>4 <= worldhigh || roverright>>4 <= worldhighslope) && if ((roverleft>>4 <= worldhigh || roverright>>4 <= worldhighslope) &&
(roverleft>>4 >= worldlow || roverright>>4 >= worldlowslope) && (roverleft>>4 >= worldlow || roverright>>4 >= worldlowslope) &&
((viewz > planevistest && (rover->flags & FF_BOTHPLANES || !(rover->flags & FF_INVERTPLANES))) || ((viewz > planevistest && (rover->fofflags & FOF_BOTHPLANES || !(rover->fofflags & FOF_INVERTPLANES))) ||
(viewz < planevistest && (rover->flags & FF_BOTHPLANES || rover->flags & FF_INVERTPLANES)))) (viewz < planevistest && (rover->fofflags & FOF_BOTHPLANES || rover->fofflags & FOF_INVERTPLANES))))
{ {
//ffloor[i].slope = *rover->t_slope; //ffloor[i].slope = *rover->t_slope;
ffloor[i].b_pos = roverleft; ffloor[i].b_pos = roverleft;

6
src/r_things.c
View file

@ -1160,7 +1160,7 @@ static void R_SplitSprite(vissprite_t *sprite)
{ {
fixed_t testheight; fixed_t testheight;
if (!(sector->lightlist[i].caster->flags & FF_CUTSPRITES)) if (!(sector->lightlist[i].caster->fofflags & FOF_CUTSPRITES))
continue; continue;
testheight = P_GetLightZAt(&sector->lightlist[i], sprite->gx, sprite->gy); testheight = P_GetLightZAt(&sector->lightlist[i], sprite->gx, sprite->gy);
@ -1193,7 +1193,7 @@ static void R_SplitSprite(vissprite_t *sprite)
newsprite->szt -= 8; newsprite->szt -= 8;
newsprite->cut |= SC_TOP; 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); lightnum = (*sector->lightlist[i].lightlevel >> LIGHTSEGSHIFT);
@ -1280,7 +1280,7 @@ fixed_t R_GetShadowZ(
if (sector->ffloors) if (sector->ffloors)
for (rover = sector->ffloors; rover; rover = rover->next) 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; continue;
z = isflipped ? P_GetFFloorBottomZAt(rover, interp.x, interp.y) : P_GetFFloorTopZAt(rover, interp.x, interp.y); z = isflipped ? P_GetFFloorBottomZAt(rover, interp.x, interp.y) : P_GetFFloorTopZAt(rover, interp.x, interp.y);