diff --git a/src/r_bsp.cpp b/src/r_bsp.cpp
index 2b2cbc5da..240b41733 100644
--- a/src/r_bsp.cpp
+++ b/src/r_bsp.cpp
@@ -1075,9 +1075,9 @@ static void R_Subsector(size_t num)
 		ceilingplane = NULL;
 
 	numffloors = 0;
-	ffloor[numffloors].slope = NULL;
-	ffloor[numffloors].plane = NULL;
-	ffloor[numffloors].polyobj = NULL;
+	visffloor[numffloors].slope = NULL;
+	visffloor[numffloors].plane = NULL;
+	visffloor[numffloors].polyobj = NULL;
 	if (frontsector->ffloors)
 	{
 		fixed_t heightcheck, planecenterz;
@@ -1107,8 +1107,8 @@ static void R_Subsector(size_t num)
 				}
 			}
 
-			ffloor[numffloors].plane = NULL;
-			ffloor[numffloors].polyobj = NULL;
+			visffloor[numffloors].plane = NULL;
+			visffloor[numffloors].polyobj = NULL;
 
 			heightcheck = P_GetFFloorBottomZAt(rover, viewx, viewy);
 
@@ -1129,7 +1129,7 @@ static void R_Subsector(size_t num)
 				light = R_GetPlaneLight(frontsector, planecenterz,
 					viewz < heightcheck);
 
-				ffloor[numffloors].plane = R_FindPlane(
+				visffloor[numffloors].plane = R_FindPlane(
 					*rover->bottomheight, *rover->bottompic,
 					*frontsector->lightlist[light].lightlevel, *rover->bottomxoffs,
 					*rover->bottomyoffs, *rover->bottomangle, *frontsector->lightlist[light].extra_colormap, rover, NULL, *rover->b_slope,
@@ -1138,20 +1138,20 @@ static void R_Subsector(size_t num)
 					true, frontsector, damage
 				);
 
-				ffloor[numffloors].slope = *rover->b_slope;
+				visffloor[numffloors].slope = *rover->b_slope;
 
 				// Tell the renderer this sector has slopes in it.
-				if (ffloor[numffloors].slope)
+				if (visffloor[numffloors].slope)
 					frontsector->hasslope = true;
 
-				ffloor[numffloors].height = heightcheck;
-				ffloor[numffloors].ffloor = rover;
+				visffloor[numffloors].height = heightcheck;
+				visffloor[numffloors].ffloor = rover;
 				numffloors++;
 			}
 			if (numffloors >= MAXFFLOORS)
 				break;
-			ffloor[numffloors].plane = NULL;
-			ffloor[numffloors].polyobj = NULL;
+			visffloor[numffloors].plane = NULL;
+			visffloor[numffloors].polyobj = NULL;
 
 			heightcheck = P_GetFFloorTopZAt(rover, viewx, viewy);
 
@@ -1171,7 +1171,7 @@ static void R_Subsector(size_t num)
 
 				light = R_GetPlaneLight(frontsector, planecenterz, viewz < heightcheck);
 
-				ffloor[numffloors].plane = R_FindPlane(
+				visffloor[numffloors].plane = R_FindPlane(
 					*rover->topheight, *rover->toppic,
 					*frontsector->lightlist[light].lightlevel, *rover->topxoffs, *rover->topyoffs, *rover->topangle,
 					*frontsector->lightlist[light].extra_colormap, rover, NULL, *rover->t_slope,
@@ -1180,14 +1180,14 @@ static void R_Subsector(size_t num)
 					false, frontsector, damage
 				);
 
-				ffloor[numffloors].slope = *rover->t_slope;
+				visffloor[numffloors].slope = *rover->t_slope;
 
 				// Tell the renderer this sector has slopes in it.
-				if (ffloor[numffloors].slope)
+				if (visffloor[numffloors].slope)
 					frontsector->hasslope = true;
 
-				ffloor[numffloors].height = heightcheck;
-				ffloor[numffloors].ffloor = rover;
+				visffloor[numffloors].height = heightcheck;
+				visffloor[numffloors].ffloor = rover;
 				numffloors++;
 			}
 		}
@@ -1215,7 +1215,7 @@ static void R_Subsector(size_t num)
 			}
 
 			polysec = po->lines[0]->backsector;
-			ffloor[numffloors].plane = NULL;
+			visffloor[numffloors].plane = NULL;
 
 			if (polysec->floorheight <= ceilingcenterz
 				&& polysec->floorheight >= floorcenterz
@@ -1223,7 +1223,7 @@ static void R_Subsector(size_t num)
 			{
 				light = R_GetPlaneLight(frontsector, polysec->floorheight, viewz < polysec->floorheight);
 
-				ffloor[numffloors].plane = R_FindPlane(
+				visffloor[numffloors].plane = R_FindPlane(
 					polysec->floorheight, polysec->floorpic,
 					(light == -1 ? frontsector->lightlevel : *frontsector->lightlist[light].lightlevel), polysec->floor_xoffs, polysec->floor_yoffs,
 					polysec->floorpic_angle-po->angle,
@@ -1234,18 +1234,18 @@ static void R_Subsector(size_t num)
 					true, frontsector, poly_bottom_damage()
 				);
 
-				ffloor[numffloors].height = polysec->floorheight;
-				ffloor[numffloors].polyobj = po;
-				ffloor[numffloors].slope = NULL;
-				//ffloor[numffloors].ffloor = rover;
-				po->visplane = ffloor[numffloors].plane;
+				visffloor[numffloors].height = polysec->floorheight;
+				visffloor[numffloors].polyobj = po;
+				visffloor[numffloors].slope = NULL;
+				//visffloor[numffloors].ffloor = rover;
+				po->visplane = visffloor[numffloors].plane;
 				numffloors++;
 			}
 
 			if (numffloors >= MAXFFLOORS)
 				break;
 
-			ffloor[numffloors].plane = NULL;
+			visffloor[numffloors].plane = NULL;
 
 			if (polysec->ceilingheight >= floorcenterz
 				&& polysec->ceilingheight <= ceilingcenterz
@@ -1253,7 +1253,7 @@ static void R_Subsector(size_t num)
 			{
 				light = R_GetPlaneLight(frontsector, polysec->floorheight, viewz < polysec->floorheight);
 
-				ffloor[numffloors].plane = R_FindPlane(
+				visffloor[numffloors].plane = R_FindPlane(
 					polysec->ceilingheight, polysec->ceilingpic,
 					(light == -1 ? frontsector->lightlevel : *frontsector->lightlist[light].lightlevel), polysec->ceiling_xoffs, polysec->ceiling_yoffs, polysec->ceilingpic_angle-po->angle,
 					(light == -1 ? frontsector->extra_colormap : *frontsector->lightlist[light].extra_colormap), NULL, po,
@@ -1263,11 +1263,11 @@ static void R_Subsector(size_t num)
 					false, frontsector, poly_top_damage()
 				);
 
-				ffloor[numffloors].polyobj = po;
-				ffloor[numffloors].height = polysec->ceilingheight;
-				ffloor[numffloors].slope = NULL;
-				//ffloor[numffloors].ffloor = rover;
-				po->visplane = ffloor[numffloors].plane;
+				visffloor[numffloors].polyobj = po;
+				visffloor[numffloors].height = polysec->ceilingheight;
+				visffloor[numffloors].slope = NULL;
+				//visffloor[numffloors].ffloor = rover;
+				po->visplane = visffloor[numffloors].plane;
 				numffloors++;
 			}
 
diff --git a/src/r_debug.cpp b/src/r_debug.cpp
index e11739ff0..a1cc6f091 100644
--- a/src/r_debug.cpp
+++ b/src/r_debug.cpp
@@ -1,4 +1,4 @@
-// RING RACERS
+// BLANKART
 //-----------------------------------------------------------------------------
 // Copyright (C) 2023 by James Robert Roman.
 //
diff --git a/src/r_plane.cpp b/src/r_plane.cpp
index d758e3138..95f6dbd9f 100644
--- a/src/r_plane.cpp
+++ b/src/r_plane.cpp
@@ -59,7 +59,7 @@ static visplane_t **freehead = &freetail;
 visplane_t *floorplane = NULL;
 visplane_t *ceilingplane = NULL;
 
-visffloor_t ffloor[MAXFFLOORS] ={};
+visffloor_t visffloor[MAXFFLOORS] ={};
 INT32 numffloors = 0;
 
 //SoM: 3/23/2000: Boom visplane hashing routine.
@@ -273,7 +273,7 @@ void R_ClearFFloorClips(void)
 	// opening / clipping determination
 	for (p = 0; p < MAXFFLOORS; p++)
 	{
-		visffloor_t *fffloor = &ffloor[p];
+		visffloor_t *fffloor = &visffloor[p];
 		std::fill(fffloor->f_clip, fffloor->f_clip + viewwidth, static_cast<INT16>(viewheight));
 		std::fill(fffloor->c_clip, fffloor->c_clip + viewwidth, static_cast<INT16>(-1));
 	}
diff --git a/src/r_plane.h b/src/r_plane.h
index 5c321abea..b2d8a1ff7 100644
--- a/src/r_plane.h
+++ b/src/r_plane.h
@@ -127,7 +127,7 @@ struct visffloor_t
 	polyobj_t *polyobj;
 };
 
-extern visffloor_t ffloor[MAXFFLOORS];
+extern visffloor_t visffloor[MAXFFLOORS];
 extern INT32 numffloors;
 
 #ifdef __cplusplus
diff --git a/src/r_segs.cpp b/src/r_segs.cpp
index 7d770d0dd..f5c0bc7fc 100644
--- a/src/r_segs.cpp
+++ b/src/r_segs.cpp
@@ -1426,13 +1426,13 @@ static void R_RenderSegLoop (drawcolumndata_t* dc)
 
 			for (i = 0; i < numffloors; i++)
 			{
-				if (ffloor[i].polyobj && (!curline->polyseg || ffloor[i].polyobj != curline->polyseg))
+				if (visffloor[i].polyobj && (!curline->polyseg || visffloor[i].polyobj != curline->polyseg))
 					continue;
 
-				if (ffloor[i].height < viewz)
+				if (visffloor[i].height < viewz)
 				{
-					INT32 top_w = (ffloor[i].f_frac >> HEIGHTBITS) + 1;
-					INT32 bottom_w = ffloor[i].f_clip[rw_x];
+					INT32 top_w = (visffloor[i].f_frac >> HEIGHTBITS) + 1;
+					INT32 bottom_w = visffloor[i].f_clip[rw_x];
 
 					if (top_w < top)
 						top_w = top;
@@ -1441,10 +1441,10 @@ static void R_RenderSegLoop (drawcolumndata_t* dc)
 						bottom_w = bottom;
 
 					// Polyobject-specific hack to fix plane leaking -Red
-					if (ffloor[i].polyobj && top_w >= bottom_w)
+					if (visffloor[i].polyobj && top_w >= bottom_w)
 					{
-						ffloor[i].plane->top[rw_x] = 0xFFFF;
-						ffloor[i].plane->bottom[rw_x] = 0x0000; // fix for sky plane drawing crashes - Monster Iestyn 25/05/18
+						visffloor[i].plane->top[rw_x] = 0xFFFF;
+						visffloor[i].plane->bottom[rw_x] = 0x0000; // fix for sky plane drawing crashes - Monster Iestyn 25/05/18
 					}
 					else
 					{
@@ -1453,12 +1453,12 @@ static void R_RenderSegLoop (drawcolumndata_t* dc)
 							fftop = (INT16)top_w;
 							ffbottom = (INT16)bottom_w;
 
-							ffloor[i].plane->top[rw_x] = fftop;
-							ffloor[i].plane->bottom[rw_x] = ffbottom;
+							visffloor[i].plane->top[rw_x] = fftop;
+							visffloor[i].plane->bottom[rw_x] = ffbottom;
 
 							// Lactozilla: Cull part of the column by the 3D floor if it can't be seen
 							// "bottom" is the top pixel of the floor column
-							if (ffbottom >= bottom-1 && R_FFloorCanClip(&ffloor[i]) && !curline->polyseg)
+							if (ffbottom >= bottom-1 && R_FFloorCanClip(&visffloor[i]) && !curline->polyseg)
 							{
 								rw_floormarked = true;
 								floorclip[rw_x] = fftop;
@@ -1477,10 +1477,10 @@ static void R_RenderSegLoop (drawcolumndata_t* dc)
 						}
 					}
 				}
-				else if (ffloor[i].height > viewz)
+				else if (visffloor[i].height > viewz)
 				{
-					INT32 top_w = ffloor[i].c_clip[rw_x] + 1;
-					INT32 bottom_w = (ffloor[i].f_frac >> HEIGHTBITS);
+					INT32 top_w = visffloor[i].c_clip[rw_x] + 1;
+					INT32 bottom_w = (visffloor[i].f_frac >> HEIGHTBITS);
 
 					if (top_w < top)
 						top_w = top;
@@ -1489,10 +1489,10 @@ static void R_RenderSegLoop (drawcolumndata_t* dc)
 						bottom_w = bottom;
 
 					// Polyobject-specific hack to fix plane leaking -Red
-					if (ffloor[i].polyobj && top_w >= bottom_w)
+					if (visffloor[i].polyobj && top_w >= bottom_w)
 					{
-						ffloor[i].plane->top[rw_x] = 0xFFFF;
-						ffloor[i].plane->bottom[rw_x] = 0x0000; // fix for sky plane drawing crashes - Monster Iestyn 25/05/18
+						visffloor[i].plane->top[rw_x] = 0xFFFF;
+						visffloor[i].plane->bottom[rw_x] = 0x0000; // fix for sky plane drawing crashes - Monster Iestyn 25/05/18
 					}
 					else
 					{
@@ -1501,12 +1501,12 @@ static void R_RenderSegLoop (drawcolumndata_t* dc)
 							fftop = (INT16)top_w;
 							ffbottom = (INT16)bottom_w;
 
-							ffloor[i].plane->top[rw_x] = fftop;
-							ffloor[i].plane->bottom[rw_x] = ffbottom;
+							visffloor[i].plane->top[rw_x] = fftop;
+							visffloor[i].plane->bottom[rw_x] = ffbottom;
 
 							// Lactozilla: Cull part of the column by the 3D floor if it can't be seen
 							// "top" is the height of the ceiling column
-							if (fftop <= top+1 && R_FFloorCanClip(&ffloor[i]) && !curline->polyseg)
+							if (fftop <= top+1 && R_FFloorCanClip(&visffloor[i]) && !curline->polyseg)
 							{
 								rw_ceilingmarked = true;
 								ceilingclip[rw_x] = ffbottom;
@@ -1733,19 +1733,19 @@ static void R_RenderSegLoop (drawcolumndata_t* dc)
 
 		for (i = 0; i < numffloors; i++)
 		{
-			if (curline->polyseg && (ffloor[i].polyobj != curline->polyseg))
+			if (curline->polyseg && (visffloor[i].polyobj != curline->polyseg))
 				continue;
 
-			ffloor[i].f_frac += ffloor[i].f_step;
+			visffloor[i].f_frac += visffloor[i].f_step;
 		}
 
 		for (i = 0; i < numbackffloors; i++)
 		{
-			if (curline->polyseg && (ffloor[i].polyobj != curline->polyseg))
+			if (curline->polyseg && (visffloor[i].polyobj != curline->polyseg))
 				continue;
 
-			ffloor[i].f_clip[rw_x] = ffloor[i].c_clip[rw_x] = (INT16)((ffloor[i].b_frac >> HEIGHTBITS) & 0xFFFF);
-			ffloor[i].b_frac += ffloor[i].b_step;
+			visffloor[i].f_clip[rw_x] = visffloor[i].c_clip[rw_x] = (INT16)((visffloor[i].b_frac >> HEIGHTBITS) & 0xFFFF);
+			visffloor[i].b_frac += visffloor[i].b_step;
 		}
 
 		rw_scale += rw_scalestep;
@@ -2032,11 +2032,11 @@ void R_StoreWallRange(INT32 start, INT32 stop)
 	{
 		for (i = 0; i < numffloors; i++)
 		{
-			if (ffloor[i].polyobj && (!ds_p->curline->polyseg || ffloor[i].polyobj != ds_p->curline->polyseg))
+			if (visffloor[i].polyobj && (!ds_p->curline->polyseg || visffloor[i].polyobj != ds_p->curline->polyseg))
 				continue;
 
-			ffloor[i].f_pos       = P_GetZAt(ffloor[i].slope, segleft .x, segleft .y, ffloor[i].height) - viewz;
-			ffloor[i].f_pos_slope = P_GetZAt(ffloor[i].slope, segright.x, segright.y, ffloor[i].height) - viewz;
+			visffloor[i].f_pos       = P_GetZAt(visffloor[i].slope, segleft .x, segleft .y, visffloor[i].height) - viewz;
+			visffloor[i].f_pos_slope = P_GetZAt(visffloor[i].slope, segright.x, segright.y, visffloor[i].height) - viewz;
 		}
 	}
 
@@ -2816,18 +2816,18 @@ void R_StoreWallRange(INT32 start, INT32 stop)
 	{
 		for (i = 0; i < numffloors; i++)
 		{
-			ffloor[i].f_pos >>= 4;
-			ffloor[i].f_pos_slope >>= 4;
+			visffloor[i].f_pos >>= 4;
+			visffloor[i].f_pos_slope >>= 4;
 			if (linedef->special == HORIZONSPECIAL) // Horizon lines extend FOFs in contact with them too.
 			{
-				ffloor[i].f_step = 0;
-				ffloor[i].f_frac = (centeryfrac>>4);
+				visffloor[i].f_step = 0;
+				visffloor[i].f_frac = (centeryfrac>>4);
 				topfrac++; // Prevent 1px HOM
 			}
 			else
 			{
-				ffloor[i].f_frac = (centeryfrac>>4) - FixedMul(ffloor[i].f_pos, rw_scale);
-				ffloor[i].f_step = ((centeryfrac>>4) - FixedMul(ffloor[i].f_pos_slope, ds_p->scale2) - ffloor[i].f_frac)/(range);
+				visffloor[i].f_frac = (centeryfrac>>4) - FixedMul(visffloor[i].f_pos, rw_scale);
+				visffloor[i].f_step = ((centeryfrac>>4) - FixedMul(visffloor[i].f_pos_slope, ds_p->scale2) - visffloor[i].f_frac)/(range);
 			}
 		}
 	}
@@ -2891,14 +2891,14 @@ void R_StoreWallRange(INT32 start, INT32 stop)
 					    ((viewz < planevistest && (rover->fofflags & FOF_BOTHPLANES || !(rover->fofflags & FOF_INVERTPLANES))) ||
 					     (viewz > planevistest && (rover->fofflags & FOF_BOTHPLANES || rover->fofflags & FOF_INVERTPLANES))))
 					{
-						//ffloor[i].slope = *rover->b_slope;
-						ffloor[i].b_pos = roverleft;
-						ffloor[i].b_pos_slope = roverright;
-						ffloor[i].b_pos >>= 4;
-						ffloor[i].b_pos_slope >>= 4;
-						ffloor[i].b_frac = (centeryfrac >> 4) - FixedMul(ffloor[i].b_pos, rw_scale);
-						ffloor[i].b_step = (centeryfrac >> 4) - FixedMul(ffloor[i].b_pos_slope, ds_p->scale2);
-						ffloor[i].b_step = (ffloor[i].b_step-ffloor[i].b_frac)/(range);
+						//visffloor[i].slope = *rover->b_slope;
+						visffloor[i].b_pos = roverleft;
+						visffloor[i].b_pos_slope = roverright;
+						visffloor[i].b_pos >>= 4;
+						visffloor[i].b_pos_slope >>= 4;
+						visffloor[i].b_frac = (centeryfrac >> 4) - FixedMul(visffloor[i].b_pos, rw_scale);
+						visffloor[i].b_step = (centeryfrac >> 4) - FixedMul(visffloor[i].b_pos_slope, ds_p->scale2);
+						visffloor[i].b_step = (visffloor[i].b_step-visffloor[i].b_frac)/(range);
 						i++;
 					}
 
@@ -2914,14 +2914,14 @@ void R_StoreWallRange(INT32 start, INT32 stop)
 					    ((viewz > planevistest && (rover->fofflags & FOF_BOTHPLANES || !(rover->fofflags & FOF_INVERTPLANES))) ||
 					     (viewz < planevistest && (rover->fofflags & FOF_BOTHPLANES || rover->fofflags & FOF_INVERTPLANES))))
 					{
-						//ffloor[i].slope = *rover->t_slope;
-						ffloor[i].b_pos = roverleft;
-						ffloor[i].b_pos_slope = roverright;
-						ffloor[i].b_pos >>= 4;
-						ffloor[i].b_pos_slope >>= 4;
-						ffloor[i].b_frac = (centeryfrac >> 4) - FixedMul(ffloor[i].b_pos, rw_scale);
-						ffloor[i].b_step = (centeryfrac >> 4) - FixedMul(ffloor[i].b_pos_slope, ds_p->scale2);
-						ffloor[i].b_step = (ffloor[i].b_step-ffloor[i].b_frac)/(range);
+						//visffloor[i].slope = *rover->t_slope;
+						visffloor[i].b_pos = roverleft;
+						visffloor[i].b_pos_slope = roverright;
+						visffloor[i].b_pos >>= 4;
+						visffloor[i].b_pos_slope >>= 4;
+						visffloor[i].b_frac = (centeryfrac >> 4) - FixedMul(visffloor[i].b_pos, rw_scale);
+						visffloor[i].b_step = (centeryfrac >> 4) - FixedMul(visffloor[i].b_pos_slope, ds_p->scale2);
+						visffloor[i].b_step = (visffloor[i].b_step-visffloor[i].b_frac)/(range);
 						i++;
 					}
 				}
@@ -2948,14 +2948,14 @@ void R_StoreWallRange(INT32 start, INT32 stop)
 					    ((viewz < planevistest && (rover->fofflags & FOF_BOTHPLANES || !(rover->fofflags & FOF_INVERTPLANES))) ||
 					     (viewz > planevistest && (rover->fofflags & FOF_BOTHPLANES || rover->fofflags & FOF_INVERTPLANES))))
 					{
-						//ffloor[i].slope = *rover->b_slope;
-						ffloor[i].b_pos = roverleft;
-						ffloor[i].b_pos_slope = roverright;
-						ffloor[i].b_pos >>= 4;
-						ffloor[i].b_pos_slope >>= 4;
-						ffloor[i].b_frac = (centeryfrac >> 4) - FixedMul(ffloor[i].b_pos, rw_scale);
-						ffloor[i].b_step = (centeryfrac >> 4) - FixedMul(ffloor[i].b_pos_slope, ds_p->scale2);
-						ffloor[i].b_step = (ffloor[i].b_step-ffloor[i].b_frac)/(range);
+						//visffloor[i].slope = *rover->b_slope;
+						visffloor[i].b_pos = roverleft;
+						visffloor[i].b_pos_slope = roverright;
+						visffloor[i].b_pos >>= 4;
+						visffloor[i].b_pos_slope >>= 4;
+						visffloor[i].b_frac = (centeryfrac >> 4) - FixedMul(visffloor[i].b_pos, rw_scale);
+						visffloor[i].b_step = (centeryfrac >> 4) - FixedMul(visffloor[i].b_pos_slope, ds_p->scale2);
+						visffloor[i].b_step = (visffloor[i].b_step-visffloor[i].b_frac)/(range);
 						i++;
 					}
 
@@ -2971,53 +2971,53 @@ void R_StoreWallRange(INT32 start, INT32 stop)
 					    ((viewz > planevistest && (rover->fofflags & FOF_BOTHPLANES || !(rover->fofflags & FOF_INVERTPLANES))) ||
 					     (viewz < planevistest && (rover->fofflags & FOF_BOTHPLANES || rover->fofflags & FOF_INVERTPLANES))))
 					{
-						//ffloor[i].slope = *rover->t_slope;
-						ffloor[i].b_pos = roverleft;
-						ffloor[i].b_pos_slope = roverright;
-						ffloor[i].b_pos >>= 4;
-						ffloor[i].b_pos_slope >>= 4;
-						ffloor[i].b_frac = (centeryfrac >> 4) - FixedMul(ffloor[i].b_pos, rw_scale);
-						ffloor[i].b_step = (centeryfrac >> 4) - FixedMul(ffloor[i].b_pos_slope, ds_p->scale2);
-						ffloor[i].b_step = (ffloor[i].b_step-ffloor[i].b_frac)/(range);
+						//visffloor[i].slope = *rover->t_slope;
+						visffloor[i].b_pos = roverleft;
+						visffloor[i].b_pos_slope = roverright;
+						visffloor[i].b_pos >>= 4;
+						visffloor[i].b_pos_slope >>= 4;
+						visffloor[i].b_frac = (centeryfrac >> 4) - FixedMul(visffloor[i].b_pos, rw_scale);
+						visffloor[i].b_step = (centeryfrac >> 4) - FixedMul(visffloor[i].b_pos_slope, ds_p->scale2);
+						visffloor[i].b_step = (visffloor[i].b_step-visffloor[i].b_frac)/(range);
 						i++;
 					}
 				}
 			}
 			if (curline->polyseg && frontsector && (curline->polyseg->flags & POF_RENDERPLANES))
 			{
-				while (i < numffloors && ffloor[i].polyobj != curline->polyseg) i++;
+				while (i < numffloors && visffloor[i].polyobj != curline->polyseg) i++;
 				if (i < numffloors && backsector->floorheight <= frontsector->ceilingheight &&
 					backsector->floorheight >= frontsector->floorheight &&
 					(viewz < backsector->floorheight))
 				{
-					if (ffloor[i].plane->minx > ds_p->x1)
-						ffloor[i].plane->minx = ds_p->x1;
+					if (visffloor[i].plane->minx > ds_p->x1)
+						visffloor[i].plane->minx = ds_p->x1;
 
-					if (ffloor[i].plane->maxx < ds_p->x2)
-						ffloor[i].plane->maxx = ds_p->x2;
+					if (visffloor[i].plane->maxx < ds_p->x2)
+						visffloor[i].plane->maxx = ds_p->x2;
 
-					ffloor[i].slope = NULL;
-					ffloor[i].b_pos = backsector->floorheight;
-					ffloor[i].b_pos = (ffloor[i].b_pos - viewz) >> 4;
-					ffloor[i].b_step = FixedMul(-rw_scalestep, ffloor[i].b_pos);
-					ffloor[i].b_frac = (centeryfrac >> 4) - FixedMul(ffloor[i].b_pos, rw_scale);
+					visffloor[i].slope = NULL;
+					visffloor[i].b_pos = backsector->floorheight;
+					visffloor[i].b_pos = (visffloor[i].b_pos - viewz) >> 4;
+					visffloor[i].b_step = FixedMul(-rw_scalestep, visffloor[i].b_pos);
+					visffloor[i].b_frac = (centeryfrac >> 4) - FixedMul(visffloor[i].b_pos, rw_scale);
 					i++;
 				}
 				if (i < numffloors && backsector->ceilingheight >= frontsector->floorheight &&
 					backsector->ceilingheight <= frontsector->ceilingheight &&
 					(viewz > backsector->ceilingheight))
 				{
-					if (ffloor[i].plane->minx > ds_p->x1)
-						ffloor[i].plane->minx = ds_p->x1;
+					if (visffloor[i].plane->minx > ds_p->x1)
+						visffloor[i].plane->minx = ds_p->x1;
 
-					if (ffloor[i].plane->maxx < ds_p->x2)
-						ffloor[i].plane->maxx = ds_p->x2;
+					if (visffloor[i].plane->maxx < ds_p->x2)
+						visffloor[i].plane->maxx = ds_p->x2;
 
-					ffloor[i].slope = NULL;
-					ffloor[i].b_pos = backsector->ceilingheight;
-					ffloor[i].b_pos = (ffloor[i].b_pos - viewz) >> 4;
-					ffloor[i].b_step = FixedMul(-rw_scalestep, ffloor[i].b_pos);
-					ffloor[i].b_frac = (centeryfrac >> 4) - FixedMul(ffloor[i].b_pos, rw_scale);
+					visffloor[i].slope = NULL;
+					visffloor[i].b_pos = backsector->ceilingheight;
+					visffloor[i].b_pos = (visffloor[i].b_pos - viewz) >> 4;
+					visffloor[i].b_step = FixedMul(-rw_scalestep, visffloor[i].b_pos);
+					visffloor[i].b_frac = (centeryfrac >> 4) - FixedMul(visffloor[i].b_pos, rw_scale);
 					i++;
 				}
 			}
@@ -3063,8 +3063,8 @@ void R_StoreWallRange(INT32 start, INT32 stop)
 
 			for (i = 0; i < numffloors; i++)
 			{
-				ds_p->ffloorplanes[i] = ffloor[i].plane =
-					R_CheckPlane(ffloor[i].plane, rw_x, rw_stopx - 1);
+				ds_p->ffloorplanes[i] = visffloor[i].plane =
+					R_CheckPlane(visffloor[i].plane, rw_x, rw_stopx - 1);
 			}
 
 			firstseg = ds_p;
@@ -3072,20 +3072,20 @@ void R_StoreWallRange(INT32 start, INT32 stop)
 		else
 		{
 			for (i = 0; i < numffloors; i++)
-				R_ExpandPlane(ffloor[i].plane, rw_x, rw_stopx - 1);
+				R_ExpandPlane(visffloor[i].plane, rw_x, rw_stopx - 1);
 		}
 		// FIXME hack to fix planes disappearing when a seg goes behind the camera. This NEEDS to be changed to be done properly. -Red
 		if (curline->polyseg)
 		{
 			for (i = 0; i < numffloors; i++)
 			{
-				if (!ffloor[i].polyobj || ffloor[i].polyobj != curline->polyseg)
+				if (!visffloor[i].polyobj || visffloor[i].polyobj != curline->polyseg)
 					continue;
-				if (ffloor[i].plane->minx > rw_x)
-					ffloor[i].plane->minx = rw_x;
+				if (visffloor[i].plane->minx > rw_x)
+					visffloor[i].plane->minx = rw_x;
 
-				if (ffloor[i].plane->maxx < rw_stopx - 1)
-					ffloor[i].plane->maxx = rw_stopx - 1;
+				if (visffloor[i].plane->maxx < rw_stopx - 1)
+					visffloor[i].plane->maxx = rw_stopx - 1;
 			}
 		}
 	}