ZoneBuilder/Source/Plugins/BuilderModes/ErrorChecks/CheckClosedSectors.cs

185 lines
5.8 KiB
C#

#region ================== Copyright (c) 2009 Boris Iwanski
/*
* Copyright (c) 2009 Boris Iwanski
* This program is released under GNU General Public License
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
*/
#endregion
#region ================== Namespaces
using System.Collections.Generic;
using CodeImp.DoomBuilder.Map;
using System.Threading;
#endregion
namespace CodeImp.DoomBuilder.BuilderModes
{
[ErrorChecker("Check invalid sectors", true, 300)]
public class CheckClosedSectors : ErrorChecker
{
#region ================== Constants
private const int PROGRESS_STEP = 40;
#endregion
#region ================== Constructor / Destructor
// Constructor
public CheckClosedSectors()
{
// Total progress is done when all sectors are checked
SetTotalProgress(General.Map.Map.Sectors.Count / PROGRESS_STEP);
}
#endregion
#region ================== Methods
// This runs the check
public override void Run()
{
int progress = 0;
int stepprogress = 0;
// This is a simple yet effective way to check if a sector is closed.
// Each sidedef that belongs to a sector is checked out. The lines vertices
// are used as the key in a Dictionary. While going through all the
// sidedefs the values associated to the keys are set with a bitwise OR.
//
// The idea for this method was taken from the way DEU checks for closed
// sectors
//
// The starting vertex of the side gets its 1 bit set, the ending vertex
// of the side gets its 2 bit set.
// The resulting dictionary will have 1, 2 or 3 as values (unlike the DEU
// version 0 will not appear here, since we only look at sides that belong
// to the current sector).
// Values 1 and 2 mean that a line they belong to has no side belonging to
// the current sector, thereby making the sector unclosed.
// A value of 3 usually means all lines belonging to that vertex have at least
// one side referencing the current sector. There are (rare) cases where this
// is not true, so a second check is done for all "opposite" vertices of the
// vertices with values 1 and 2: if the opposite vertex has a value of 3, but
// the line between the two vertices has no side referencing the current sector,
// then this falsely good vertex is added to the holes, too
// Go for all the sectors
foreach(Sector s in General.Map.Map.Sectors)
{
List<Vertex> foundholes = new List<Vertex>();
Dictionary<Vertex, int> vertices = new Dictionary<Vertex, int>();
// look at each side that belongs to the current sector
foreach(Sidedef sd in s.Sidedefs)
{
// Add the lines starting vertex to the Dictionary if it's not yet present
if(!vertices.ContainsKey(sd.Line.Start))
{
vertices.Add(sd.Line.Start, 0);
}
// Add the lines ending vertex to the Dictionary if it's not yet present
if(!vertices.ContainsKey(sd.Line.End))
{
vertices.Add(sd.Line.End, 0);
}
// enable the 1 bit of the start vertex and the 2 bit of the end vertex of the side
// This is from the sides point of view, where the side is always the "right" of line,
// so start and end are flipped depending if the current side is the front of the
// line or not
if(sd.IsFront)
{
vertices[sd.Line.Start] |= 1;
vertices[sd.Line.End] |= 2;
}
else
{
vertices[sd.Line.End] |= 1;
vertices[sd.Line.Start] |= 2;
}
}
// look at all the vertices
foreach(KeyValuePair<Vertex, int> kvp in vertices)
{
// only look at bad vertices
if(kvp.Value != 3)
{
// add the current vertex to the holes list
if(!foundholes.Contains(kvp.Key))
{
foundholes.Add(kvp.Key);
}
// this checks if any vertices slipped past the first test
// look at all lines that share the current vertex
foreach(Linedef cl in kvp.Key.Linedefs)
{
// the line does not has its front or back side referencing the current sector
if(!((cl.Front != null && cl.Front.Sector == s) || (cl.Back != null && cl.Back.Sector == s)))
{
// if the opposite vertex of our current vertex is marked good something must be wrong,
// since the above check tells us that the line bewtween the vertices has no side referencing
// the current sector. So add the falsely marked vertex to the holes list
if(vertices.ContainsKey(cl.Start) && vertices[cl.Start] == 3 && !foundholes.Contains(cl.Start))
{
foundholes.Add(cl.Start);
}
if(vertices.ContainsKey(cl.End) && vertices[cl.End] == 3 && !foundholes.Contains(cl.End))
{
foundholes.Add(cl.End);
}
}
}
}
}
// Add report when holes have been found
if(foundholes.Count > 0)
{
SubmitResult(new ResultSectorUnclosed(s, foundholes));
}
//mxd. Add report when sector has less than 3 sidedefs
else if(s.Sidedefs.Count < 3 || s.BBox.IsEmpty)
{
SubmitResult(new ResultSectorInvalid(s));
}
//mxd. Add report when sector has less than 3 linedefs
else
{
HashSet<Linedef> lines = new HashSet<Linedef>();
foreach(Sidedef side in s.Sidedefs)
if(side.Line != null && !lines.Contains(side.Line)) lines.Add(side.Line);
if(lines.Count < 3) SubmitResult(new ResultSectorInvalid(s));
}
// Handle thread interruption
try { Thread.Sleep(0); }
catch(ThreadInterruptedException) { return; }
// We are making progress!
if((++progress / PROGRESS_STEP) > stepprogress)
{
stepprogress = (progress / PROGRESS_STEP);
AddProgress(1);
}
}
}
#endregion
}
}