#region ================== Copyright (c) 2007 Pascal vd Heiden
/*
* Copyright (c) 2007 Pascal vd Heiden, www.codeimp.com
* 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;
using System.Collections;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Drawing;
using System.IO;
using System.Linq;
using CodeImp.DoomBuilder.Config;
using CodeImp.DoomBuilder.Geometry;
using CodeImp.DoomBuilder.IO;
using CodeImp.DoomBuilder.Rendering;
using CodeImp.DoomBuilder.Types;
using CodeImp.DoomBuilder.Windows;
using CodeImp.DoomBuilder.VisualModes;
using CodeImp.DoomBuilder.Data;
using System.Diagnostics;
#endregion
namespace CodeImp.DoomBuilder.Map
{
///
/// Manages all geometry structures and things in a map. Also provides
/// methods to works with selections and marking elements for any purpose.
/// Note that most methods are of O(n) complexity.
///
public sealed class MapSet
{
#region ================== Constants
/// Stiching distance. This is only to get around inaccuracies. Basically,
/// geometry only stitches when exactly on top of each other.
public const float STITCH_DISTANCE = 0.005f; //mxd. 0.001f is not enough when drawing very long lines...
// Virtual sector identification
// This contains a character that is invalid in the UDMF standard, but valid
// in our parser, so that it can only be used by Doom Builder and will never
// conflict with any other valid UDMF field.
internal const string VIRTUAL_SECTOR_FIELD = "!virtual_sector";
//mxd
private const string SELECTION_GROUPS_PATH = "selectiongroups";
// Handler for tag fields
public delegate void TagHandler(MapElement element, bool actionargument, UniversalType type, ref int value, T obj);
#endregion
#region ================== Variables
// Sector indexing
private List indexholes;
private int lastsectorindex;
// Sidedef indexing for (de)serialization
private Sidedef[] sidedefindices;
// Map structures
private Vertex[] vertices;
private Linedef[] linedefs;
private Sidedef[] sidedefs;
private Sector[] sectors;
private Thing[] things;
private int numvertices;
private int numlinedefs;
private int numsidedefs;
private int numsectors;
private int numthings;
// Behavior
private int freezearrays;
private bool autoremove;
// Selected elements
private LinkedList sel_vertices;
private LinkedList sel_linedefs;
private LinkedList sel_sectors;
private LinkedList sel_things;
private SelectionType sel_type;
// Statics
private static long emptylongname;
private static UniValue virtualsectorvalue;
// Disposing
private bool isdisposed;
#endregion
#region ================== Properties
/// Returns the number of selected sectors.
public int SelectedSectorsCount { get { return sel_sectors.Count; } }
/// Returns the number of selected linedefs.
public int SelectedLinedefsCount { get { return sel_linedefs.Count; } }
/// Returns the number of selected vertices.
public int SelectedVerticessCount { get { return sel_vertices.Count; } }
/// Returns the number of selected things.
public int SelectedThingsCount { get { return sel_things.Count; } }
/// Returns a reference to the list of all vertices.
public ICollection Vertices { get { if(freezearrays == 0) return vertices; else return new MapElementCollection(ref vertices, numvertices); } }
/// Returns a reference to the list of all linedefs.
public ICollection Linedefs { get { if(freezearrays == 0) return linedefs; else return new MapElementCollection(ref linedefs, numlinedefs); } }
/// Returns a reference to the list of all sidedefs.
public ICollection Sidedefs { get { if(freezearrays == 0) return sidedefs; else return new MapElementCollection(ref sidedefs, numsidedefs); } }
/// Returns a reference to the list of all sectors.
public ICollection Sectors { get { if(freezearrays == 0) return sectors; else return new MapElementCollection(ref sectors, numsectors); } }
/// Returns a reference to the list of all things.
public ICollection Things { get { if(freezearrays == 0) return things; else return new MapElementCollection(ref things, numthings); } }
/// Indicates if the map is disposed.
public bool IsDisposed { get { return isdisposed; } }
/// Returns a reference to the list of selected vertices.
internal LinkedList SelectedVertices { get { return sel_vertices; } }
/// Returns a reference to the list of selected linedefs.
internal LinkedList SelectedLinedefs { get { return sel_linedefs; } }
/// Returns a reference to the list of selected sectors.
internal LinkedList SelectedSectors { get { return sel_sectors; } }
/// Returns a reference to the list of selected things.
internal LinkedList SelectedThings { get { return sel_things; } }
/// Returns the current type of selection.
public SelectionType SelectionType { get { return sel_type; } set { sel_type = value; } }
/// Long name to indicate "no texture". This is the long name for a single dash.
public static long EmptyLongName { get { return emptylongname; } }
/// Returns the name of the custom field that marks virtual sectors in pasted geometry.
public static string VirtualSectorField { get { return VIRTUAL_SECTOR_FIELD; } }
/// Returns the value of the custom field that marks virtual sectors in pasted geometry.
public static UniValue VirtualSectorValue { get { return virtualsectorvalue; } }
internal Sidedef[] SidedefIndices { get { return sidedefindices; } }
internal bool AutoRemove { get { return autoremove; } set { autoremove = value; } }
#endregion
#region ================== Constructor / Disposer
// Constructor for new empty map
internal MapSet()
{
// Initialize
vertices = new Vertex[0];
linedefs = new Linedef[0];
sidedefs = new Sidedef[0];
sectors = new Sector[0];
things = new Thing[0];
sel_vertices = new LinkedList();
sel_linedefs = new LinkedList();
sel_sectors = new LinkedList();
sel_things = new LinkedList();
indexholes = new List();
lastsectorindex = 0;
autoremove = true;
// We have no destructor
GC.SuppressFinalize(this);
}
// Constructor for map to deserialize
internal MapSet(MemoryStream stream)
{
// Initialize
vertices = new Vertex[0];
linedefs = new Linedef[0];
sidedefs = new Sidedef[0];
sectors = new Sector[0];
things = new Thing[0];
sel_vertices = new LinkedList();
sel_linedefs = new LinkedList();
sel_sectors = new LinkedList();
sel_things = new LinkedList();
indexholes = new List();
lastsectorindex = 0;
autoremove = true;
// Deserialize
Deserialize(stream);
// We have no destructor
GC.SuppressFinalize(this);
}
// Disposer
internal void Dispose()
{
// Not already disposed?
if(!isdisposed)
{
// Already set isdisposed so that changes can be prohibited
isdisposed = true;
BeginAddRemove();
// Dispose all things
while((things.Length > 0) && (things[0] != null))
things[0].Dispose();
// Dispose all sectors
while((sectors.Length > 0) && (sectors[0] != null))
sectors[0].Dispose();
// Dispose all sidedefs
while((sidedefs.Length > 0) && (sidedefs[0] != null))
sidedefs[0].Dispose();
// Dispose all linedefs
while((linedefs.Length > 0) && (linedefs[0] != null))
linedefs[0].Dispose();
// Dispose all vertices
while((vertices.Length > 0) && (vertices[0] != null))
vertices[0].Dispose();
// Clean up
vertices = null;
linedefs = null;
sidedefs = null;
sectors = null;
things = null;
sel_vertices = null;
sel_linedefs = null;
sel_sectors = null;
sel_things = null;
indexholes = null;
// Done
isdisposed = true;
}
}
// Static initializer
internal static void Initialize()
{
emptylongname = Lump.MakeLongName("-", false);
virtualsectorvalue = new UniValue((int)UniversalType.Integer, 0);
}
#endregion
#region ================== Management
// This begins large add/remove operations
public void BeginAddRemove()
{
freezearrays++;
}
// This allocates the arrays to a minimum size so that
// a lot of items can be created faster. This function will never
// allocate less than the current number of items.
public void SetCapacity(int nvertices, int nlinedefs, int nsidedefs, int nsectors, int nthings)
{
if(freezearrays == 0)
throw new Exception("You must call BeginAddRemove before setting the reserved capacity.");
if(numvertices < nvertices)
Array.Resize(ref vertices, nvertices);
if(numlinedefs < nlinedefs)
Array.Resize(ref linedefs, nlinedefs);
if(numsidedefs < nsidedefs)
Array.Resize(ref sidedefs, nsidedefs);
if(numsectors < nsectors)
Array.Resize(ref sectors, nsectors);
if(numthings < nthings)
Array.Resize(ref things, nthings);
}
// This ends add/remove operations and crops the arrays
public void EndAddRemove()
{
if(freezearrays > 0)
freezearrays--;
if(freezearrays == 0)
{
if(numvertices < vertices.Length)
Array.Resize(ref vertices, numvertices);
if(numlinedefs < linedefs.Length)
Array.Resize(ref linedefs, numlinedefs);
if(numsidedefs < sidedefs.Length)
Array.Resize(ref sidedefs, numsidedefs);
if(numsectors < sectors.Length)
Array.Resize(ref sectors, numsectors);
if(numthings < things.Length)
Array.Resize(ref things, numthings);
}
}
///
/// This makes a deep copy and returns the new MapSet.
///
public MapSet Clone()
{
// Create the map set
MapSet newset = new MapSet();
newset.BeginAddRemove();
newset.SetCapacity(numvertices, numlinedefs, numsidedefs, numsectors, numthings);
// Go for all vertices
foreach(Vertex v in vertices)
{
// Make new vertex
v.Clone = newset.CreateVertex(v.Position);
v.CopyPropertiesTo(v.Clone);
}
// Go for all sectors
foreach(Sector s in sectors)
{
// Make new sector
s.Clone = newset.CreateSector();
s.CopyPropertiesTo(s.Clone);
}
// Go for all linedefs
foreach(Linedef l in linedefs)
{
// Make new linedef
Linedef nl = newset.CreateLinedef(l.Start.Clone, l.End.Clone);
l.CopyPropertiesTo(nl);
// Linedef has a front side?
if(l.Front != null)
{
// Make new sidedef
Sidedef nd = newset.CreateSidedef(nl, true, l.Front.Sector.Clone);
l.Front.CopyPropertiesTo(nd);
}
// Linedef has a back side?
if(l.Back != null)
{
// Make new sidedef
Sidedef nd = newset.CreateSidedef(nl, false, l.Back.Sector.Clone);
l.Back.CopyPropertiesTo(nd);
}
}
// Go for all things
foreach(Thing t in things)
{
// Make new thing
Thing nt = newset.CreateThing();
t.CopyPropertiesTo(nt);
}
// Remove clone references
foreach(Vertex v in vertices) v.Clone = null;
foreach(Sector s in sectors) s.Clone = null;
// Return the new set
newset.EndAddRemove();
return newset;
}
// This makes a deep copy of the marked geometry and binds missing sectors to a virtual sector
internal MapSet CloneMarked()
{
Sector virtualsector = null;
// Create the map set
MapSet newset = new MapSet();
newset.BeginAddRemove();
// Get marked geometry
ICollection mvertices = GetMarkedVertices(true);
ICollection mlinedefs = GetMarkedLinedefs(true);
ICollection msectors = GetMarkedSectors(true);
ICollection mthings = GetMarkedThings(true);
newset.SetCapacity(mvertices.Count, mlinedefs.Count, numsidedefs, msectors.Count, mthings.Count);
// Go for all vertices
foreach(Vertex v in mvertices)
{
// Make new vertex
v.Clone = newset.CreateVertex(v.Position);
v.CopyPropertiesTo(v.Clone);
}
// Go for all sectors
foreach(Sector s in msectors)
{
// Make new sector
s.Clone = newset.CreateSector();
s.CopyPropertiesTo(s.Clone);
}
// Go for all linedefs
foreach(Linedef l in mlinedefs)
{
// Make new linedef
Linedef nl = newset.CreateLinedef(l.Start.Clone, l.End.Clone);
l.CopyPropertiesTo(nl);
// Linedef has a front side?
if(l.Front != null)
{
Sidedef nd;
// Sector on front side marked?
if(l.Front.Sector.Marked)
{
// Make new sidedef
nd = newset.CreateSidedef(nl, true, l.Front.Sector.Clone);
}
else
{
// Make virtual sector if needed
if(virtualsector == null)
{
virtualsector = newset.CreateSector();
l.Front.Sector.CopyPropertiesTo(virtualsector);
virtualsector.Fields.BeforeFieldsChange();
virtualsector.Fields[VIRTUAL_SECTOR_FIELD] = new UniValue(virtualsectorvalue);
}
// Make new sidedef that links to the virtual sector
nd = newset.CreateSidedef(nl, true, virtualsector);
}
l.Front.CopyPropertiesTo(nd);
}
// Linedef has a back side?
if(l.Back != null)
{
Sidedef nd;
// Sector on front side marked?
if(l.Back.Sector.Marked)
{
// Make new sidedef
nd = newset.CreateSidedef(nl, false, l.Back.Sector.Clone);
}
else
{
// Make virtual sector if needed
if(virtualsector == null)
{
virtualsector = newset.CreateSector();
l.Back.Sector.CopyPropertiesTo(virtualsector);
virtualsector.Fields.BeforeFieldsChange();
virtualsector.Fields[VIRTUAL_SECTOR_FIELD] = new UniValue(virtualsectorvalue);
}
// Make new sidedef that links to the virtual sector
nd = newset.CreateSidedef(nl, false, virtualsector);
}
l.Back.CopyPropertiesTo(nd);
}
}
// Go for all things
foreach(Thing t in mthings)
{
// Make new thing
Thing nt = newset.CreateThing();
t.CopyPropertiesTo(nt);
}
// Remove clone references
foreach(Vertex v in vertices) v.Clone = null;
foreach(Sector s in sectors) s.Clone = null;
// Return the new set
newset.EndAddRemove();
return newset;
}
/// This creates a new vertex and returns it.
public Vertex CreateVertex(Vector2D pos)
{
if(numvertices == General.Map.FormatInterface.MaxVertices)
{
General.Interface.DisplayStatus(StatusType.Warning, "Failed to complete operation: maximum number of vertices reached.");
return null;
}
// Make the vertex
Vertex v = new Vertex(this, numvertices, pos);
AddItem(v, ref vertices, numvertices, ref numvertices);
return v;
}
/// This creates a new vertex and returns it.
public Vertex CreateVertex(int index, Vector2D pos)
{
if(numvertices == General.Map.FormatInterface.MaxVertices)
{
General.Interface.DisplayStatus(StatusType.Warning, "Failed to complete operation: maximum number of vertices reached.");
return null;
}
// Make the vertex
Vertex v = new Vertex(this, index, pos);
AddItem(v, ref vertices, index, ref numvertices);
return v;
}
/// This creates a new linedef and returns it.
public Linedef CreateLinedef(Vertex start, Vertex end)
{
if(numlinedefs == General.Map.FormatInterface.MaxLinedefs)
{
General.Interface.DisplayStatus(StatusType.Warning, "Failed to complete operation: maximum number of linedefs reached.");
return null;
}
// Make the linedef
Linedef l = new Linedef(this, numlinedefs, start, end);
AddItem(l, ref linedefs, numlinedefs, ref numlinedefs);
return l;
}
/// This creates a new linedef and returns it.
public Linedef CreateLinedef(int index, Vertex start, Vertex end)
{
if(numlinedefs == General.Map.FormatInterface.MaxLinedefs)
{
General.Interface.DisplayStatus(StatusType.Warning, "Failed to complete operation: maximum number of linedefs reached.");
return null;
}
// Make the linedef
Linedef l = new Linedef(this, index, start, end);
AddItem(l, ref linedefs, index, ref numlinedefs);
return l;
}
/// This creates a new sidedef and returns it.
public Sidedef CreateSidedef(Linedef l, bool front, Sector s)
{
if(numsidedefs == int.MaxValue)
{
General.Interface.DisplayStatus(StatusType.Warning, "Failed to complete operation: maximum number of sidedefs reached.");
return null;
}
// Make the sidedef
Sidedef sd = new Sidedef(this, numsidedefs, l, front, s);
AddItem(sd, ref sidedefs, numsidedefs, ref numsidedefs);
return sd;
}
/// This creates a new sidedef and returns it.
public Sidedef CreateSidedef(int index, Linedef l, bool front, Sector s)
{
if(numsidedefs == int.MaxValue)
{
General.Interface.DisplayStatus(StatusType.Warning, "Failed to complete operation: maximum number of sidedefs reached.");
return null;
}
// Make the sidedef
Sidedef sd = new Sidedef(this, index, l, front, s);
AddItem(sd, ref sidedefs, index, ref numsidedefs);
return sd;
}
/// This creates a new sector and returns it.
public Sector CreateSector()
{
// Make the sector
return CreateSector(numsectors);
}
/// This creates a new sector and returns it.
public Sector CreateSector(int index)
{
int fixedindex;
if(numsectors == General.Map.FormatInterface.MaxSectors)
{
General.Interface.DisplayStatus(StatusType.Warning, "Failed to complete operation: maximum number of sectors reached.");
return null;
}
// Do we have any index holes we can use?
if(indexholes.Count > 0)
{
// Take one of the index holes
fixedindex = indexholes[indexholes.Count - 1];
indexholes.RemoveAt(indexholes.Count - 1);
}
else
{
// Make a new index
fixedindex = lastsectorindex++;
}
// Make the sector
return CreateSectorEx(fixedindex, index);
}
// This creates a new sector with a specific fixed index
private Sector CreateSectorEx(int fixedindex, int index)
{
if(numsectors == General.Map.FormatInterface.MaxSectors)
{
General.Interface.DisplayStatus(StatusType.Warning, "Failed to complete operation: maximum number of sectors reached.");
return null;
}
// Make the sector
Sector s = new Sector(this, index, fixedindex);
AddItem(s, ref sectors, index, ref numsectors);
return s;
}
/// This creates a new thing and returns it.
public Thing CreateThing()
{
if(numthings == General.Map.FormatInterface.MaxThings)
{
General.Interface.DisplayStatus(StatusType.Warning, "Failed to complete operation: maximum number of things reached.");
return null;
}
// Make the thing
Thing t = new Thing(this, numthings);
AddItem(t, ref things, numthings, ref numthings);
return t;
}
/// This creates a new thing and returns it.
public Thing CreateThing(int index)
{
if(numthings == General.Map.FormatInterface.MaxThings)
{
General.Interface.DisplayStatus(StatusType.Warning, "Failed to complete operation: maximum number of things reached.");
return null;
}
// Make the thing
Thing t = new Thing(this, index);
AddItem(t, ref things, index, ref numthings);
return t;
}
///
/// This creates a temporary thing. The difference to normal thing creation is that the creation will not be recorded by the undo manager.
/// This should only be used in very specific cases, like creating a temporary player start for the "test from current position" action
///
/// The new thing
internal Thing CreateTempThing()
{
if (numthings == General.Map.FormatInterface.MaxThings)
{
General.Interface.DisplayStatus(StatusType.Warning, "Failed to complete operation: maximum number of things reached.");
return null;
}
// Make the thing
Thing t = new Thing(this, numthings, false);
AddItem(t, ref things, numthings, ref numthings);
return t;
}
// This increases the size of the array to add an item
private void AddItem(T item, ref T[] array, int index, ref int counter) where T: MapElement
{
// Only resize when there are no more free entries
if(counter == array.Length)
{
if(freezearrays == 0)
Array.Resize(ref array, counter + 1);
else
Array.Resize(ref array, counter + 10);
}
// Move item at the given index if the new item is not added at the end
if(index != counter)
{
array[counter] = array[index];
array[counter].Index = counter;
}
// Add item
array[index] = item;
counter++;
}
// This adds a sector index hole
internal void AddSectorIndexHole(int index)
{
indexholes.Add(index);
}
private void RemoveItem(ref T[] array, int index, ref int counter) where T: MapElement
{
if(index == (counter - 1))
{
array[index] = null;
}
else
{
array[index] = array[counter - 1];
array[index].Index = index;
array[counter - 1] = null;
}
counter--;
if(freezearrays == 0)
Array.Resize(ref array, counter);
}
internal void RemoveVertex(int index)
{
RemoveItem(ref vertices, index, ref numvertices);
}
internal void RemoveLinedef(int index)
{
RemoveItem(ref linedefs, index, ref numlinedefs);
}
internal void RemoveSidedef(int index)
{
RemoveItem(ref sidedefs, index, ref numsidedefs);
}
internal void RemoveSector(int index)
{
RemoveItem(ref sectors, index, ref numsectors);
}
internal void RemoveThing(int index)
{
RemoveItem(ref things, index, ref numthings);
}
#endregion
#region ================== Serialization
// This serializes the MapSet
internal MemoryStream Serialize()
{
MemoryStream stream = new MemoryStream(20000000); // Yes that is about 20 MB.
SerializerStream serializer = new SerializerStream(stream);
// Index the sidedefs
int sidedefindex = 0;
foreach(Sidedef sd in sidedefs)
sd.SerializedIndex = sidedefindex++;
serializer.Begin();
// Write private data
serializer.wInt(lastsectorindex);
serializer.wInt(indexholes.Count);
foreach(int i in indexholes) serializer.wInt(i);
// Write map data
WriteVertices(serializer);
WriteSectors(serializer);
WriteLinedefs(serializer);
WriteSidedefs(serializer);
WriteThings(serializer);
serializer.End();
// Reallocate to keep only the used memory
stream.Capacity = (int)stream.Length;
return stream;
}
// This serializes things
private void WriteThings(SerializerStream stream)
{
stream.wInt(numthings);
// Go for all things
foreach(Thing t in things)
{
t.ReadWrite(stream);
}
}
// This serializes vertices
private void WriteVertices(SerializerStream stream)
{
stream.wInt(numvertices);
// Go for all vertices
int index = 0;
foreach(Vertex v in vertices)
{
v.SerializedIndex = index++;
v.ReadWrite(stream);
}
}
// This serializes linedefs
private void WriteLinedefs(SerializerStream stream)
{
stream.wInt(numlinedefs);
// Go for all lines
int index = 0;
foreach(Linedef l in linedefs)
{
l.SerializedIndex = index++;
stream.wInt(l.Start.SerializedIndex);
stream.wInt(l.End.SerializedIndex);
l.ReadWrite(stream);
}
}
// This serializes sidedefs
private void WriteSidedefs(SerializerStream stream)
{
stream.wInt(numsidedefs);
// Go for all sidedefs
foreach(Sidedef sd in sidedefs)
{
stream.wInt(sd.Line.SerializedIndex);
stream.wInt(sd.Sector.SerializedIndex);
stream.wBool(sd.IsFront);
sd.ReadWrite(stream);
}
}
// This serializes sectors
private void WriteSectors(SerializerStream stream)
{
stream.wInt(numsectors);
// Go for all sectors
int index = 0;
foreach(Sector s in sectors)
{
s.SerializedIndex = index++;
s.ReadWrite(stream);
s.Triangles.ReadWrite(stream); //mxd
}
}
#endregion
#region ================== Deserialization
// This deserializes the MapSet
internal void Deserialize(MemoryStream stream)
{
stream.Seek(0, SeekOrigin.Begin);
DeserializerStream deserializer = new DeserializerStream(stream);
deserializer.Begin();
// Read private data
int c;
deserializer.rInt(out lastsectorindex);
deserializer.rInt(out c);
indexholes = new List(c);
for(int i = 0; i < c; i++)
{
int index; deserializer.rInt(out index);
indexholes.Add(index);
}
// Read map data
Vertex[] verticesarray = ReadVertices(deserializer);
Sector[] sectorsarray = ReadSectors(deserializer);
Linedef[] linedefsarray = ReadLinedefs(deserializer, verticesarray);
ReadSidedefs(deserializer, linedefsarray, sectorsarray);
ReadThings(deserializer);
deserializer.End();
deserializer.Dispose(); //mxd
// Make table of sidedef indices
sidedefindices = new Sidedef[numsidedefs];
foreach(Sidedef sd in sidedefs)
sidedefindices[sd.SerializedIndex] = sd;
// Call PostDeserialize
foreach(Sector s in sectors)
s.PostDeserialize(this);
}
// This deserializes things
private void ReadThings(DeserializerStream stream)
{
int c; stream.rInt(out c);
// Go for all things
for(int i = 0; i < c; i++)
{
Thing t = CreateThing();
t.ReadWrite(stream);
}
}
// This deserializes vertices
private Vertex[] ReadVertices(DeserializerStream stream)
{
int c; stream.rInt(out c);
Vertex[] array = new Vertex[c];
// Go for all vertices
for(int i = 0; i < c; i++)
{
array[i] = CreateVertex(new Vector2D());
array[i].ReadWrite(stream);
}
return array;
}
// This deserializes linedefs
private Linedef[] ReadLinedefs(DeserializerStream stream, Vertex[] verticesarray)
{
int c; stream.rInt(out c);
Linedef[] array = new Linedef[c];
// Go for all lines
for(int i = 0; i < c; i++)
{
int start, end;
stream.rInt(out start);
stream.rInt(out end);
array[i] = CreateLinedef(verticesarray[start], verticesarray[end]);
array[i].ReadWrite(stream);
}
return array;
}
// This deserializes sidedefs
private void ReadSidedefs(DeserializerStream stream, Linedef[] linedefsarray, Sector[] sectorsarray)
{
int c; stream.rInt(out c);
// Go for all sidedefs
for(int i = 0; i < c; i++)
{
int lineindex, sectorindex;
bool front;
stream.rInt(out lineindex);
stream.rInt(out sectorindex);
stream.rBool(out front);
Sidedef sd = CreateSidedef(linedefsarray[lineindex], front, sectorsarray[sectorindex]);
sd.ReadWrite(stream);
}
}
// This deserializes sectors
private Sector[] ReadSectors(DeserializerStream stream)
{
int c; stream.rInt(out c);
Sector[] array = new Sector[c];
// Go for all sectors
for(int i = 0; i < c; i++)
{
array[i] = CreateSector();
array[i].ReadWrite(stream);
array[i].Triangles.ReadWrite(stream); //mxd
}
return array;
}
#endregion
#region ================== Updating
///
/// This updates the cache of all elements where needed. You must call this after making changes to the map.
///
public void Update()
{
// Update all!
Update(true, true);
}
///
/// This updates the cache of all elements where needed. It is not recommended to use this version, please use Update() instead.
///
public void Update(bool dolines, bool dosectors)
{
// Update all linedefs
if(dolines) foreach(Linedef l in linedefs) l.UpdateCache();
// Update all sectors
if(dosectors)
{
foreach(Sector s in sectors) s.Triangulate();
General.Map.CRenderer2D.Surfaces.AllocateBuffers();
foreach(Sector s in sectors) s.CreateSurfaces();
General.Map.CRenderer2D.Surfaces.UnlockBuffers();
}
}
///
/// This updates the cache of all elements that is required after a configuration or settings change.
///
public void UpdateConfiguration()
{
// Update all things
foreach(Thing t in things) t.UpdateConfiguration();
}
#endregion
#region ================== Selection
// This checks a flag in a selection type
private static bool InSelectionType(SelectionType value, SelectionType bits)
{
return (value & bits) == bits;
}
/// This converts the current selection to a different type of selection as specified.
/// Note that this function uses the markings to convert the selection.
public void ConvertSelection(SelectionType target)
{
ConvertSelection(SelectionType.All, target);
}
/// This converts the current selection to a different type of selection as specified.
/// Note that this function uses the markings to convert the selection.
public void ConvertSelection(SelectionType source, SelectionType target)
{
ClearAllMarks(false);
switch(target)
{
// Convert geometry selection to vertices only
case SelectionType.Vertices:
if(InSelectionType(source, SelectionType.Linedefs)) MarkSelectedLinedefs(true, true);
if(InSelectionType(source, SelectionType.Sectors)) General.Map.Map.MarkSelectedSectors(true, true);
ICollection verts = General.Map.Map.GetVerticesFromLinesMarks(true);
foreach(Vertex v in verts) v.Selected = true;
verts = General.Map.Map.GetVerticesFromSectorsMarks(true);
foreach(Vertex v in verts) v.Selected = true;
General.Map.Map.ClearSelectedSectors();
General.Map.Map.ClearSelectedLinedefs();
break;
// Convert geometry selection to linedefs only
case SelectionType.Linedefs:
if(InSelectionType(source, SelectionType.Vertices)) MarkSelectedVertices(true, true);
if(!InSelectionType(source, SelectionType.Linedefs)) ClearSelectedLinedefs();
ICollection lines = General.Map.Map.LinedefsFromMarkedVertices(false, true, false);
foreach(Linedef l in lines) l.Selected = true;
if(InSelectionType(source, SelectionType.Sectors))
{
foreach(Sector s in General.Map.Map.Sectors)
{
if(s.Selected)
{
foreach(Sidedef sd in s.Sidedefs)
sd.Line.Selected = true;
}
}
}
General.Map.Map.ClearSelectedSectors();
General.Map.Map.ClearSelectedVertices();
break;
// Convert geometry selection to sectors only
case SelectionType.Sectors:
if(InSelectionType(source, SelectionType.Vertices)) MarkSelectedVertices(true, true);
if(!InSelectionType(source, SelectionType.Linedefs)) ClearSelectedLinedefs();
lines = LinedefsFromMarkedVertices(false, true, false);
foreach(Linedef l in lines) l.Selected = true;
ClearMarkedSectors(true);
foreach(Linedef l in linedefs)
{
if(!l.Selected)
{
if(l.Front != null) l.Front.Sector.Marked = false;
if(l.Back != null) l.Back.Sector.Marked = false;
}
}
ClearSelectedLinedefs();
ClearSelectedVertices();
if(InSelectionType(source, SelectionType.Sectors))
{
foreach(Sector s in General.Map.Map.Sectors)
{
if(s.Selected || (s.Marked && s.Sidedefs.Count > 0))
{
s.Selected = true;
foreach(Sidedef sd in s.Sidedefs)
sd.Line.Selected = true;
}
}
}
else
{
foreach(Sector s in General.Map.Map.Sectors)
{
if(s.Marked && s.Sidedefs.Count > 0)
{
s.Selected = true;
foreach(Sidedef sd in s.Sidedefs)
sd.Line.Selected = true;
}
else
{
s.Selected = false;
}
}
}
break;
default:
throw new ArgumentException("Unsupported selection target conversion");
}
// New selection type
sel_type = target;
}
/// This clears all selected items
public void ClearAllSelected()
{
ClearSelectedVertices();
ClearSelectedThings();
ClearSelectedLinedefs();
ClearSelectedSectors();
}
/// This clears selected vertices.
public void ClearSelectedVertices()
{
sel_vertices.Clear();
foreach(Vertex v in vertices) v.Selected = false;
}
/// This clears selected things.
public void ClearSelectedThings()
{
sel_things.Clear();
foreach(Thing t in things) t.Selected = false;
}
/// This clears selected linedefs.
public void ClearSelectedLinedefs()
{
sel_linedefs.Clear();
foreach(Linedef l in linedefs) l.Selected = false;
}
/// This clears selected sectors.
public void ClearSelectedSectors()
{
sel_sectors.Clear();
foreach(Sector s in sectors) s.Selected = false;
}
/// Returns a collection of vertices that match a selected state.
public ICollection GetSelectedVertices(bool selected)
{
if(selected)
{
return new List(sel_vertices);
}
else
{
List list = new List(numvertices - sel_vertices.Count);
foreach(Vertex v in vertices) if(!v.Selected) list.Add(v);
return list;
}
}
/// Returns a collection of things that match a selected state.
public ICollection GetSelectedThings(bool selected)
{
if(selected)
{
return new List(sel_things);
}
else
{
List list = new List(numthings - sel_things.Count);
foreach(Thing t in things) if(!t.Selected) list.Add(t);
return list;
}
}
/// Returns a collection of linedefs that match a selected state.
public ICollection GetSelectedLinedefs(bool selected)
{
if(selected)
{
return new List(sel_linedefs);
}
else
{
List list = new List(numlinedefs - sel_linedefs.Count);
foreach(Linedef l in linedefs) if(!l.Selected) list.Add(l);
return list;
}
}
/// Returns a collection of sidedefs that match a selected linedefs state.
public ICollection GetSidedefsFromSelectedLinedefs(bool selected)
{
if(selected)
{
List list = new List(sel_linedefs.Count);
foreach(Linedef ld in sel_linedefs)
{
if(ld.Front != null) list.Add(ld.Front);
if(ld.Back != null) list.Add(ld.Back);
}
return list;
}
else
{
List list = new List(numlinedefs - sel_linedefs.Count);
foreach(Linedef ld in linedefs)
{
if(!ld.Selected && (ld.Front != null)) list.Add(ld.Front);
if(!ld.Selected && (ld.Back != null)) list.Add(ld.Back);
}
return list;
}
}
/// Returns a collection of sectors that match a selected state.
public ICollection GetSelectedSectors(bool selected)
{
if(selected)
{
return new List(sel_sectors);
}
else
{
List list = new List(numsectors - sel_sectors.Count);
foreach(Sector s in sectors) if(!s.Selected) list.Add(s);
return list;
}
}
/// This selects or deselectes geometry based on marked elements.
public void SelectMarkedGeometry(bool mark, bool select)
{
SelectMarkedVertices(mark, select);
SelectMarkedLinedefs(mark, select);
SelectMarkedSectors(mark, select);
SelectMarkedThings(mark, select);
}
/// This selects or deselectes geometry based on marked elements.
public void SelectMarkedVertices(bool mark, bool select)
{
foreach(Vertex v in vertices) if(v.Marked == mark) v.Selected = select;
}
/// This selects or deselectes geometry based on marked elements.
public void SelectMarkedLinedefs(bool mark, bool select)
{
foreach(Linedef l in linedefs) if(l.Marked == mark) l.Selected = select;
}
/// This selects or deselectes geometry based on marked elements.
public void SelectMarkedSectors(bool mark, bool select)
{
foreach(Sector s in sectors) if(s.Marked == mark) s.Selected = select;
}
/// This selects or deselectes geometry based on marked elements.
public void SelectMarkedThings(bool mark, bool select)
{
foreach(Thing t in things) if(t.Marked == mark) t.Selected = select;
}
#endregion
#region ================== Selection groups
/// This selects geometry by selection group index.
public void SelectVerticesByGroup(int groupmask)
{
foreach(Vertex e in vertices) e.SelectByGroup(groupmask);
}
/// This selects geometry by selection group index.
public void SelectLinedefsByGroup(int groupmask)
{
foreach(Linedef e in linedefs) e.SelectByGroup(groupmask);
}
/// This selects geometry by selection group index.
public void SelectSectorsByGroup(int groupmask)
{
foreach(Sector e in sectors) e.SelectByGroup(groupmask);
}
/// This selects geometry by selection group index.
public void SelectThingsByGroup(int groupmask)
{
foreach(Thing e in things) e.SelectByGroup(groupmask);
}
/// This adds the current selection to the specified selection group.
//mxd. switched groupmask to groupindex
public void AddSelectionToGroup(int groupindex)
{
int groupmask = 0x01 << groupindex;
foreach(Vertex e in vertices) if(e.Selected) e.AddToGroup(groupmask);
foreach(Linedef e in linedefs) if(e.Selected) e.AddToGroup(groupmask);
foreach(Sector e in sectors) if(e.Selected) e.AddToGroup(groupmask);
foreach(Thing e in things) if(e.Selected) e.AddToGroup(groupmask);
}
/// This clears specified selection group.
//mxd
public void ClearGroup(int groupmask)
{
foreach(Vertex e in vertices) e.RemoveFromGroup(groupmask);
foreach(Linedef e in linedefs) e.RemoveFromGroup(groupmask);
foreach(Sector e in sectors) e.RemoveFromGroup(groupmask);
foreach(Thing e in things) e.RemoveFromGroup(groupmask);
}
//mxd
internal GroupInfo GetGroupInfo(int groupindex)
{
int numSectors = 0;
int numLines = 0;
int numVerts = 0;
int numThings = 0;
int groupmask = 0x01 << groupindex;
foreach(Vertex e in vertices) if(e.IsInGroup(groupmask)) numVerts++; //mxd
foreach(Linedef e in linedefs) if(e.IsInGroup(groupmask)) numLines++; //mxd
foreach(Sector e in sectors) if(e.IsInGroup(groupmask)) numSectors++; //mxd
foreach(Thing e in things) if(e.IsInGroup(groupmask)) numThings++; //mxd
return new GroupInfo(groupindex + 1, numSectors, numLines, numVerts, numThings);
}
//mxd
internal void WriteSelectionGroups(Configuration cfg)
{
// Fill structure
IDictionary groups = new ListDictionary();
for(int i = 0; i < 10; i++)
{
IDictionary group = new ListDictionary();
int groupmask = 0x01 << i;
//store verts
List indices = new List();
foreach(Vertex e in vertices) if(e.IsInGroup(groupmask)) indices.Add(e.Index.ToString());
if(indices.Count > 0) group.Add("vertices", string.Join(" ", indices.ToArray()));
//store linedefs
indices.Clear();
foreach(Linedef e in linedefs) if(e.IsInGroup(groupmask)) indices.Add(e.Index.ToString());
if(indices.Count > 0) group.Add("linedefs", string.Join(" ", indices.ToArray()));
//store sectors
indices.Clear();
foreach(Sector e in sectors) if(e.IsInGroup(groupmask)) indices.Add(e.Index.ToString());
if(indices.Count > 0) group.Add("sectors", string.Join(" ", indices.ToArray()));
//store things
indices.Clear();
foreach(Thing e in things) if(e.IsInGroup(groupmask)) indices.Add(e.Index.ToString());
if(indices.Count > 0) group.Add("things", string.Join(" ", indices.ToArray()));
//add to main collection
if(group.Count > 0) groups.Add(i, group);
}
// Write to config
if(groups.Count > 0) cfg.WriteSetting(SELECTION_GROUPS_PATH, groups);
}
//mxd
internal void ReadSelectionGroups(Configuration cfg)
{
IDictionary grouplist = cfg.ReadSetting(SELECTION_GROUPS_PATH, new Hashtable());
foreach(DictionaryEntry mp in grouplist)
{
// Item is a structure?
if(mp.Value is IDictionary)
{
//get group number
int groupnum;
if(!int.TryParse(mp.Key as string, out groupnum)) continue;
int groupmask = 0x01 << General.Clamp(groupnum, 0, 10);
IDictionary groupinfo = (IDictionary)mp.Value;
if(groupinfo.Contains("vertices"))
{
string s = groupinfo["vertices"] as string;
if(!string.IsNullOrEmpty(s))
{
List indices = GetIndices(s);
foreach(int index in indices)
{
if(index > vertices.Length) continue;
vertices[index].AddToGroup(groupmask);
}
}
}
if(groupinfo.Contains("linedefs"))
{
string s = groupinfo["linedefs"] as string;
if(!string.IsNullOrEmpty(s))
{
List indices = GetIndices(s);
foreach(int index in indices)
{
if(index > linedefs.Length) continue;
linedefs[index].AddToGroup(groupmask);
}
}
}
if(groupinfo.Contains("sectors"))
{
string s = groupinfo["sectors"] as string;
if(!string.IsNullOrEmpty(s))
{
List indices = GetIndices(s);
foreach(int index in indices)
{
if(index > sectors.Length) continue;
sectors[index].AddToGroup(groupmask);
}
}
}
if(groupinfo.Contains("things"))
{
string s = groupinfo["things"] as string;
if(!string.IsNullOrEmpty(s))
{
List indices = GetIndices(s);
foreach(int index in indices)
{
if(index > things.Length) continue;
things[index].AddToGroup(groupmask);
}
}
}
}
}
}
//mxd
private static List GetIndices(string input)
{
string[] parts = input.Split(new[] {' '}, StringSplitOptions.RemoveEmptyEntries);
int index;
List result = new List(parts.Length);
foreach(string part in parts) if(int.TryParse(part, out index)) result.Add(index);
return result;
}
#endregion
#region ================== Marking
/// This clears all marks on all elements.
public void ClearAllMarks(bool mark)
{
ClearMarkedVertices(mark);
ClearMarkedThings(mark);
ClearMarkedLinedefs(mark);
ClearMarkedSectors(mark);
ClearMarkedSidedefs(mark);
}
/// This clears all marks on all vertices.
public void ClearMarkedVertices(bool mark)
{
foreach(Vertex v in vertices) v.Marked = mark;
}
/// This clears all marks on all things.
public void ClearMarkedThings(bool mark)
{
foreach(Thing t in things) t.Marked = mark;
}
/// This clears all marks on all linedefs.
public void ClearMarkedLinedefs(bool mark)
{
foreach(Linedef l in linedefs) l.Marked = mark;
}
/// This clears all marks on all sidedefs.
public void ClearMarkedSidedefs(bool mark)
{
foreach(Sidedef s in sidedefs) s.Marked = mark;
}
/// This clears all marks on all sectors.
public void ClearMarkedSectors(bool mark)
{
foreach(Sector s in sectors) s.Marked = mark;
}
/// This inverts all marks on all elements.
public void InvertAllMarks()
{
InvertMarkedVertices();
InvertMarkedThings();
InvertMarkedLinedefs();
InvertMarkedSectors();
InvertMarkedSidedefs();
}
/// This inverts all marks on all vertices.
public void InvertMarkedVertices()
{
foreach(Vertex v in vertices) v.Marked = !v.Marked;
}
/// This inverts all marks on all things.
public void InvertMarkedThings()
{
foreach(Thing t in things) t.Marked = !t.Marked;
}
/// This inverts all marks on all linedefs.
public void InvertMarkedLinedefs()
{
foreach(Linedef l in linedefs) l.Marked = !l.Marked;
}
/// This inverts all marks on all sidedefs.
public void InvertMarkedSidedefs()
{
foreach(Sidedef s in sidedefs) s.Marked = !s.Marked;
}
/// This inverts all marks on all sectors.
public void InvertMarkedSectors()
{
foreach(Sector s in sectors) s.Marked = !s.Marked;
}
/// Returns a collection of vertices that match a marked state.
public List GetMarkedVertices(bool mark)
{
List list = new List(numvertices >> 1);
foreach(Vertex v in vertices) if(v.Marked == mark) list.Add(v);
return list;
}
/// Returns a collection of things that match a marked state.
public List GetMarkedThings(bool mark)
{
List list = new List(numthings >> 1);
foreach(Thing t in things) if(t.Marked == mark) list.Add(t);
return list;
}
/// Returns a collection of linedefs that match a marked state.
public List GetMarkedLinedefs(bool mark)
{
List list = new List(numlinedefs >> 1);
foreach(Linedef l in linedefs) if(l.Marked == mark) list.Add(l);
return list;
}
/// Returns a collection of sidedefs that match a marked state.
public List GetMarkedSidedefs(bool mark)
{
List list = new List(numsidedefs >> 1);
foreach(Sidedef s in sidedefs) if(s.Marked == mark) list.Add(s);
return list;
}
/// Returns a collection of sectors that match a marked state.
public List GetMarkedSectors(bool mark)
{
List list = new List(numsectors >> 1);
foreach(Sector s in sectors) if(s.Marked == mark) list.Add(s);
return list;
}
/// This marks vertices based on selected vertices.
public void MarkSelectedVertices(bool selected, bool mark)
{
foreach(Vertex v in sel_vertices) v.Marked = mark;
}
/// This marks linedefs based on selected linedefs.
public void MarkSelectedLinedefs(bool selected, bool mark)
{
foreach(Linedef l in sel_linedefs) l.Marked = mark;
}
/// This marks sectors based on selected sectors.
public void MarkSelectedSectors(bool selected, bool mark)
{
foreach(Sector s in sel_sectors) s.Marked = mark;
}
/// This marks things based on selected things.
public void MarkSelectedThings(bool selected, bool mark)
{
foreach(Thing t in sel_things) t.Marked = mark;
}
///
/// This marks the front and back sidedefs on linedefs with the matching mark.
///
public void MarkSidedefsFromLinedefs(bool matchmark, bool setmark)
{
foreach(Linedef l in linedefs)
{
if(l.Marked == matchmark)
{
if(l.Front != null) l.Front.Marked = setmark;
if(l.Back != null) l.Back.Marked = setmark;
}
}
}
///
/// This marks the sidedefs that make up the sectors with the matching mark.
///
public void MarkSidedefsFromSectors(bool matchmark, bool setmark)
{
foreach(Sidedef sd in sidedefs)
{
if(sd.Sector.Marked == matchmark) sd.Marked = setmark;
}
}
///
/// Returns a collection of vertices that match a marked state on the linedefs.
///
public ICollection GetVerticesFromLinesMarks(bool mark)
{
List list = new List(numvertices >> 1);
foreach(Vertex v in vertices)
{
foreach(Linedef l in v.Linedefs)
{
if(l.Marked == mark)
{
list.Add(v);
break;
}
}
}
return list;
}
///
/// Returns a collection of vertices that match a marked state on the linedefs.
/// The difference with GetVerticesFromLinesMarks is that in this method
/// ALL linedefs of a vertex must match the specified marked state.
///
public ICollection GetVerticesFromAllLinesMarks(bool mark)
{
List list = new List(numvertices >> 1);
foreach(Vertex v in vertices)
{
bool qualified = true;
foreach(Linedef l in v.Linedefs)
{
if(l.Marked != mark)
{
qualified = false;
break;
}
}
if(qualified) list.Add(v);
}
return list;
}
///
/// Returns a collection of vertices that match a marked state on the linedefs.
///
public ICollection GetVerticesFromSectorsMarks(bool mark)
{
List list = new List(numvertices >> 1);
foreach(Vertex v in vertices)
{
foreach(Linedef l in v.Linedefs)
{
if(((l.Front != null) && (l.Front.Sector != null) && (l.Front.Sector.Marked == mark)) ||
((l.Back != null) && (l.Back.Sector != null) && (l.Back.Sector.Marked == mark)))
{
list.Add(v);
break;
}
}
}
return list;
}
///
/// This marks all selected geometry, including sidedefs from sectors.
/// When sidedefsfromsectors is true, then the sidedefs are marked according to the
/// marked sectors. Otherwise the sidedefs are marked according to the marked linedefs.
///
public void MarkAllSelectedGeometry(bool mark, bool linedefsfromvertices, bool verticesfromlinedefs, bool sectorsfromlinedefs, bool sidedefsfromsectors)
{
General.Map.Map.ClearAllMarks(!mark);
// Direct vertices
General.Map.Map.MarkSelectedVertices(true, mark);
// Direct linedefs
General.Map.Map.MarkSelectedLinedefs(true, mark);
// Linedefs from vertices
// We do this before "vertices from lines" because otherwise we get lines marked that we didn't select
if(linedefsfromvertices)
{
ICollection lines = General.Map.Map.LinedefsFromMarkedVertices(!mark, mark, !mark);
foreach(Linedef l in lines) l.Marked = mark;
}
// Vertices from linedefs
if(verticesfromlinedefs)
{
ICollection verts = General.Map.Map.GetVerticesFromLinesMarks(mark);
foreach(Vertex v in verts) v.Marked = mark;
}
// Mark sectors from linedefs (note: this must be the first to mark
// sectors, because this clears the sector marks!)
if(sectorsfromlinedefs)
{
General.Map.Map.ClearMarkedSectors(mark);
foreach(Linedef l in General.Map.Map.Linedefs)
{
if(!l.Selected)
{
if(l.Front != null) l.Front.Sector.Marked = !mark;
if(l.Back != null) l.Back.Sector.Marked = !mark;
}
}
}
// Direct sectors
General.Map.Map.MarkSelectedSectors(true, mark);
// Direct things
General.Map.Map.MarkSelectedThings(true, mark);
// Sidedefs from linedefs or sectors
if(sidedefsfromsectors)
General.Map.Map.MarkSidedefsFromSectors(true, mark);
else
General.Map.Map.MarkSidedefsFromLinedefs(true, mark);
}
#endregion
#region ================== Indexing
///
/// Returns the vertex at the specified index. Returns null when index is out of range. This is an O(1) operation.
///
public Vertex GetVertexByIndex(int index)
{
return index < numvertices ? vertices[index] : null;
}
///
/// Returns the linedef at the specified index. Returns null when index is out of range. This is an O(1) operation.
///
public Linedef GetLinedefByIndex(int index)
{
return index < numlinedefs ? linedefs[index] : null;
}
///
/// Returns the sidedef at the specified index. Returns null when index is out of range. This is an O(1) operation.
///
public Sidedef GetSidedefByIndex(int index)
{
return index < numsidedefs ? sidedefs[index] : null;
}
///
/// Returns the sector at the specified index. Returns null when index is out of range. This is an O(1) operation.
///
public Sector GetSectorByIndex(int index)
{
return index < numsectors ? sectors[index] : null;
}
///
/// Returns the thing at the specified index. Returns null when index is out of range. This is an O(1) operation.
///
public Thing GetThingByIndex(int index)
{
return index < numthings ? things[index] : null;
}
#endregion
#region ================== Areas
/// This creates an initial, undefined area.
public static RectangleF CreateEmptyArea()
{
return new RectangleF(float.MaxValue / 2, float.MaxValue / 2, -float.MaxValue, -float.MaxValue);
}
/// This creates an area from vertices.
public static RectangleF CreateArea(ICollection verts)
{
float l = float.MaxValue;
float t = float.MaxValue;
float r = float.MinValue;
float b = float.MinValue;
// Go for all vertices
foreach(Vertex v in verts)
{
// Adjust boundaries by vertices
if(v.Position.x < l) l = v.Position.x;
if(v.Position.x > r) r = v.Position.x;
if(v.Position.y < t) t = v.Position.y;
if(v.Position.y > b) b = v.Position.y;
}
// Return a rect
return new RectangleF(l, t, r - l, b - t);
}
/// This increases and existing area with the given vertices.
public static RectangleF IncreaseArea(RectangleF area, ICollection verts)
{
float l = area.Left;
float t = area.Top;
float r = area.Right;
float b = area.Bottom;
// Go for all vertices
foreach(Vertex v in verts)
{
// Adjust boundaries by vertices
if(v.Position.x < l) l = v.Position.x;
if(v.Position.x > r) r = v.Position.x;
if(v.Position.y < t) t = v.Position.y;
if(v.Position.y > b) b = v.Position.y;
}
// Return a rect
return new RectangleF(l, t, r - l, b - t);
}
/// This increases and existing area with the given things.
public static RectangleF IncreaseArea(RectangleF area, ICollection things)
{
float l = area.Left;
float t = area.Top;
float r = area.Right;
float b = area.Bottom;
// Go for all vertices
foreach(Thing th in things)
{
// Adjust boundaries by vertices
if(th.Position.x < l) l = th.Position.x;
if(th.Position.x > r) r = th.Position.x;
if(th.Position.y < t) t = th.Position.y;
if(th.Position.y > b) b = th.Position.y;
}
// Return a rect
return new RectangleF(l, t, r - l, b - t);
}
/// This increases and existing area with the given vertices.
public static RectangleF IncreaseArea(RectangleF area, ICollection verts)
{
float l = area.Left;
float t = area.Top;
float r = area.Right;
float b = area.Bottom;
// Go for all vertices
foreach(Vector2D v in verts)
{
// Adjust boundaries by vertices
if(v.x < l) l = v.x;
if(v.x > r) r = v.x;
if(v.y < t) t = v.y;
if(v.y > b) b = v.y;
}
// Return a rect
return new RectangleF(l, t, r - l, b - t);
}
/// This increases and existing area with the given vertex.
public static RectangleF IncreaseArea(RectangleF area, Vector2D vert)
{
float l = area.Left;
float t = area.Top;
float r = area.Right;
float b = area.Bottom;
// Adjust boundaries by vertices
if(vert.x < l) l = vert.x;
if(vert.x > r) r = vert.x;
if(vert.y < t) t = vert.y;
if(vert.y > b) b = vert.y;
// Return a rect
return new RectangleF(l, t, r - l, b - t);
}
/// This creates an area from linedefs.
public static RectangleF CreateArea(ICollection lines)
{
float l = float.MaxValue;
float t = float.MaxValue;
float r = float.MinValue;
float b = float.MinValue;
// Go for all linedefs
foreach(Linedef ld in lines)
{
// Adjust boundaries by vertices
if(ld.Start.Position.x < l) l = ld.Start.Position.x;
if(ld.Start.Position.x > r) r = ld.Start.Position.x;
if(ld.Start.Position.y < t) t = ld.Start.Position.y;
if(ld.Start.Position.y > b) b = ld.Start.Position.y;
if(ld.End.Position.x < l) l = ld.End.Position.x;
if(ld.End.Position.x > r) r = ld.End.Position.x;
if(ld.End.Position.y < t) t = ld.End.Position.y;
if(ld.End.Position.y > b) b = ld.End.Position.y;
}
// Return a rect
return new RectangleF(l, t, r - l, b - t);
}
/// This increases and existing area with the given linedefs.
public static RectangleF IncreaseArea(RectangleF area, ICollection lines) //mxd
{
float l = area.Left;
float t = area.Top;
float r = area.Right;
float b = area.Bottom;
// Go for all vertices
foreach(Linedef ld in lines)
{
// Adjust boundaries by vertices
if(ld.Start.Position.x < l) l = ld.Start.Position.x;
if(ld.Start.Position.x > r) r = ld.Start.Position.x;
if(ld.Start.Position.y < t) t = ld.Start.Position.y;
if(ld.Start.Position.y > b) b = ld.Start.Position.y;
if(ld.End.Position.x < l) l = ld.End.Position.x;
if(ld.End.Position.x > r) r = ld.End.Position.x;
if(ld.End.Position.y < t) t = ld.End.Position.y;
if(ld.End.Position.y > b) b = ld.End.Position.y;
}
// Return a rect
return new RectangleF(l, t, r - l, b - t);
}
/// This filters lines by a rectangular area.
public static HashSet FilterByArea(ICollection lines, ref RectangleF area)
{
HashSet newlines = new HashSet();
// Go for all lines
foreach(Linedef l in lines)
{
// Check the cs field bits
if((GetCSFieldBits(l.Start.Position, area) & GetCSFieldBits(l.End.Position, area)) == 0)
{
// The line could be in the area
newlines.Add(l);
}
}
// Return result
return newlines;
}
/// This returns the cohen-sutherland field bits for a vector in a rectangle area
public static int GetCSFieldBits(Vector2D v, RectangleF area)
{
int bits = 0;
if(v.y < area.Top) bits |= 0x01;
if(v.y > area.Bottom) bits |= 0x02;
if(v.x < area.Left) bits |= 0x04;
if(v.x > area.Right) bits |= 0x08;
return bits;
}
/// This filters vertices by a rectangular area.
public static ICollection FilterByArea(ICollection verts, ref RectangleF area)
{
ICollection newverts = new List(verts.Count);
// Go for all verts
foreach(Vertex v in verts)
{
// Within rect?
if((v.Position.x < area.Left) || (v.Position.x > area.Right) ||
(v.Position.y < area.Top) || (v.Position.y > area.Bottom)) continue;
// The vertex is in the area
newverts.Add(v);
}
// Return result
return newverts;
}
#endregion
#region ================== Stitching
///
/// Stitches marked geometry with non-marked geometry. Returns false when the operation failed.
///
public bool StitchGeometry() { return StitchGeometry(MergeGeometryMode.CLASSIC); } //mxd. Compatibility
public bool StitchGeometry(MergeGeometryMode mergemode)
{
// Find vertices
HashSet movingverts = new HashSet(General.Map.Map.GetMarkedVertices(true));
HashSet fixedverts = new HashSet(General.Map.Map.GetMarkedVertices(false));
// Find lines that moved during the drag
HashSet movinglines = new HashSet(LinedefsFromMarkedVertices(false, true, true));
// Find all non-moving lines
HashSet fixedlines = new HashSet(LinedefsFromMarkedVertices(true, false, false));
// Determine area in which we are editing
RectangleF editarea = CreateArea(movinglines);
editarea = IncreaseArea(editarea, movingverts);
editarea.Inflate(1.0f, 1.0f);
// Join nearby vertices
BeginAddRemove();
JoinVertices(fixedverts, movingverts, true, STITCH_DISTANCE);
EndAddRemove();
// Update cached values of lines because we need their length/angle
Update(true, false);
BeginAddRemove();
// Split moving lines with unselected vertices
General.WriteLogLine("Splitting moving lines with unselected vertices...");
ICollection nearbyfixedverts = FilterByArea(fixedverts, ref editarea);
if (!SplitLinesByVertices(movinglines, nearbyfixedverts, STITCH_DISTANCE, movinglines, mergemode))
{
EndAddRemove(); // Unfreeze arrays before returning
return false;
}
// Split non-moving lines with selected vertices
General.WriteLogLine("Splitting non-moving lines with selected vertices...");
fixedlines = FilterByArea(fixedlines, ref editarea);
fixedlines = new HashSet(fixedlines.Where(fixedline => !fixedline.IsDisposed));
if (!SplitLinesByVertices(fixedlines, movingverts, STITCH_DISTANCE, movinglines, mergemode))
{
EndAddRemove(); // Unfreeze arrays before returning
return false;
}
//mxd. Split moving lines with fixed lines
General.WriteLogLine("Splitting moving lines with fixed lines...");
if (!SplitLinesByLines(fixedlines, movinglines, mergemode))
{
EndAddRemove(); // Unfreeze arrays before returning
return false;
}
// Remove looped linedefs
General.WriteLogLine("Removing looped lines...");
RemoveLoopedLinedefs(movinglines);
// Join overlapping lines
if (!JoinOverlappingLines(movinglines))
{
EndAddRemove(); // Unfreeze arrays before returning
return false;
}
//mxd. Remove remaining new verts from dragged shape if possible
if(mergemode == MergeGeometryMode.REPLACE)
{
// Collect verts created by splitting. Can't use GetMarkedVertices here, because we are in the middle of AddRemove
HashSet tocheck = new HashSet();
foreach(Vertex v in vertices)
{
if(v != null && v.Marked && !movingverts.Contains(v)) tocheck.Add(v);
}
// Remove verts, which are not part of initially dragged verts
foreach(Vertex v in tocheck)
{
if(!v.IsDisposed && v.Linedefs.Count == 2)
{
Linedef ld1 = General.GetByIndex(v.Linedefs, 0);
Linedef ld2 = General.GetByIndex(v.Linedefs, 1);
Vertex v2 = (ld2.Start == v) ? ld2.End : ld2.Start;
if(ld1.Start == v) ld1.SetStartVertex(v2); else ld1.SetEndVertex(v2);
ld2.Dispose();
// Trash vertex
v.Dispose();
}
}
}
EndAddRemove();
// Collect changed lines... We need those in by-vertex-index order
// (otherwise SectorBuilder logic in some cases will incorrectly assign sector propertes)
List markedverts = GetMarkedVertices(true);
List changedlines = new List(markedverts.Count / 2);
HashSet changedlineshash = new HashSet();
foreach(Vertex v in markedverts)
{
foreach(Linedef l in v.Linedefs)
{
if(!changedlineshash.Contains(l))
{
changedlines.Add(l);
changedlineshash.Add(l);
}
}
}
//mxd. Correct sector references
if(mergemode != MergeGeometryMode.CLASSIC)
{
// Linedefs cache needs to be up to date...
Update(true, false);
// Fix stuff...
CorrectSectorReferences(changedlines, true);
CorrectOuterSides(new HashSet(changedlines));
// Mark only fully selected sectors
ClearMarkedSectors(false);
HashSet changedsectors = GetSectorsFromLinedefs(changedlines);
foreach(Sector s in changedsectors) s.Marked = true;
}
else
{
FlipBackwardLinedefs(changedlines);
}
return true;
}
//mxd. Shameless SLADEMap::correctSectors ripoff... Corrects/builds sectors for all lines in [lines]
private static void CorrectSectorReferences(List lines, bool existing_only)
{
//DebugConsole.Clear();
//DebugConsole.WriteLine("CorrectSectorReferences for " + lines.Count + " lines");
// Create a list of sidedefs to perform sector creation with
List edges = new List();
if(existing_only)
{
int lineCount = lines.Count;
for (int i = 0; i < lineCount; i++)
{
Linedef l = lines[i];
// Add only existing sides as edges (or front side if line has none)
if (l.Front != null || l.Back == null)
edges.Add(new LinedefSide(l, true));
if(l.Back != null)
edges.Add(new LinedefSide(l, false));
}
}
else
{
int lineCount = lines.Count;
for (int i = 0; i < lineCount; i++)
{
Linedef l = lines[i];
// Add front side
edges.Add(new LinedefSide(l, true));
// Add back side if there's a sector
if(General.Map.Map.GetSectorByCoordinates(l.GetSidePoint(false)) != null)
edges.Add(new LinedefSide(l, false));
}
}
HashSet sides_correct = new HashSet();
int edgeCount = edges.Count;
for (int i = 0; i < edgeCount; i++)
{
LinedefSide ls = edges[i];
if (ls.Front && ls.Line.Front != null)
sides_correct.Add(ls.Line.Front);
else if(!ls.Front && ls.Line.Back != null)
sides_correct.Add(ls.Line.Back);
}
//mxd. Get affected sectors
HashSet affectedsectors = new HashSet(General.Map.Map.GetSelectedSectors(true));
affectedsectors.UnionWith(General.Map.Map.GetUnselectedSectorsFromLinedefs(lines));
//mxd. Collect their sidedefs
HashSet sectorsides = new HashSet();
foreach(Sector s in affectedsectors) sectorsides.UnionWith(s.Sidedefs);
// Build sectors
SectorBuilder builder = new SectorBuilder();
List sectors_reused = new List();
for (int i = 0; i < edgeCount; i++)
{
LinedefSide ls = edges[i];
// Skip if edge is ignored
//DebugConsole.WriteLine((ls.Ignore ? "Ignoring line " : "Processing line ") + ls.Line.Index);
if (ls.Ignore) continue;
// Run sector builder on current edge
Stopwatch watch = new Stopwatch();
watch.Start();
if (!builder.TraceSector(ls.Line, ls.Front))
{
//General.ErrorLogger.Add(ErrorType.Warning, string.Format("TraceSector: took {0}ms, failed!", watch.ElapsedMilliseconds));
continue; // Don't create sector if trace failed
}
//General.ErrorLogger.Add(ErrorType.Warning, string.Format("TraceSector: took {0}ms", watch.ElapsedMilliseconds));
// Find any subsequent edges that were part of the sector created
bool has_existing_lines = false;
bool has_existing_sides = false;
//bool has_zero_sided_lines = false;
bool has_dragged_sides = false; //mxd
List edges_in_sector = new List();
foreach(LinedefSide edge in builder.SectorEdges)
{
bool line_is_ours = false;
bool side_exists = (edge.Front ? edge.Line.Front != null : edge.Line.Back != null); //mxd
if(side_exists && sectorsides.Contains(edge.Front ? edge.Line.Front : edge.Line.Back))
has_dragged_sides = true; //mxd
for (int k = 0; k < edgeCount; k++)
{
LinedefSide ls2 = edges[k];
if (ls2.Line == edge.Line)
{
line_is_ours = true;
if(ls2.Front == edge.Front)
{
edges_in_sector.Add(ls2);
break;
}
}
}
if(line_is_ours)
{
//if(edge.Line.Front == null && edge.Line.Back == null)
//has_zero_sided_lines = true;
}
else
{
has_existing_lines = true;
has_existing_sides |= side_exists; //mxd
}
}
// Pasting or moving a two-sided line into an enclosed void should NOT
// create a new sector out of the entire void.
// Heuristic: if the traced sector includes any edges that are NOT
// "ours", and NONE of those edges already exist, that sector must be
// in an enclosed void, and should not be drawn.
// However, if existing_only is false, the caller expects us to create
// new sides anyway; skip this check.
if(existing_only && has_existing_lines && !has_existing_sides && !has_dragged_sides)
continue;
// Ignore traced edges when trying to create any further sectors
foreach(LinedefSide ls3 in edges_in_sector) ls3.Ignore = true;
// Check if sector traced is already valid
if(builder.IsValidSector()) continue;
// Check if we traced over an existing sector (or part of one)
Sector sector = builder.FindExistingSector(sides_correct);
if(sector != null)
{
// Check if it's already been (re)used
bool reused = false;
foreach(Sector s in sectors_reused)
{
if(s == sector)
{
reused = true;
break;
}
}
// If we can reuse the sector, do so
if(!reused)
sectors_reused.Add(sector);
else
sector = null;
}
// Create sector
builder.CreateSector(sector, null);
}
// Remove any sides that weren't part of a sector
for (int i = 0; i < edgeCount; i++)
{
LinedefSide ls = edges[i];
if (ls.Ignore || ls.Line == null) continue;
if (ls.Line.Start == null || ls.Line.End == null)
throw new Exception("ls line is null");
if(ls.Front)
{
if(ls.Line.Front != null)
{
ls.Line.Front.Dispose();
// Update doublesided flag
ls.Line.ApplySidedFlags();
}
}
else
{
if(ls.Line.Back != null)
{
ls.Line.Back.Dispose();
// Update doublesided flag
ls.Line.ApplySidedFlags();
}
}
}
// Check if any lines need to be flipped
FlipBackwardLinedefs(lines);
// Find an adjacent sector to copy properties from
Sector sector_copy = null;
foreach(Linedef l in lines)
{
// Check front sector
Sector sector = (l.Front != null ? l.Front.Sector : null);
if(sector != null && !sector.Marked)
{
// Copy this sector if it isn't newly created
sector_copy = sector;
break;
}
// Check back sector
sector = (l.Back != null ? l.Back.Sector : null);
if(sector != null && !sector.Marked)
{
// Copy this sector if it isn't newly created
sector_copy = sector;
break;
}
}
// Go through newly created sectors
List newsectors = General.Map.Map.GetMarkedSectors(true); //mxd
foreach(Sector s in newsectors)
{
// Skip if sector already has properties
if(s.CeilTexture != "-" || s.FloorTexture != "-"
|| s.FloorHeight != General.Settings.DefaultFloorHeight
|| s.CeilHeight != General.Settings.DefaultCeilingHeight)
continue;
// Copy from adjacent sector if any
if(sector_copy != null)
{
sector_copy.CopyPropertiesTo(s);
continue;
}
// Otherwise, use defaults from game configuration
s.SetFloorTexture(General.Map.Options.DefaultFloorTexture);
s.SetCeilTexture(General.Map.Options.DefaultCeilingTexture);
s.FloorHeight = General.Settings.DefaultFloorHeight;
s.CeilHeight = General.Settings.DefaultCeilingHeight;
s.Brightness = General.Settings.DefaultBrightness;
}
// Update line textures
List newsides = General.Map.Map.GetMarkedSidedefs(true);
foreach(Sidedef side in newsides)
{
// Clear any unneeded textures
side.RemoveUnneededTextures(side.Other != null, false, true);
// Set middle texture if needed
if(side.MiddleRequired() && side.MiddleTexture == "-")
{
// Find adjacent texture (any)
string tex = GetAdjacentMiddleTexture(side.Line.Start);
if(tex == "-") tex = GetAdjacentMiddleTexture(side.Line.End);
// If no adjacent texture, get default from game configuration
if(tex == "-") tex = General.Settings.DefaultTexture;
// Set texture
side.SetTextureMid(tex);
}
// Update sided flags
side.Line.ApplySidedFlags();
}
// Remove any extra sectors
General.Map.Map.RemoveUnusedSectors(false);
}
//mxd. Try to create outer sidedefs if needed
private static void CorrectOuterSides(HashSet changedlines)
{
HashSet linesmissingfront = new HashSet();
HashSet linesmissingback = new HashSet();
// Collect lines without front/back sides
foreach(Linedef line in changedlines)
{
if(line.Back == null) linesmissingback.Add(line);
if(line.Front == null) linesmissingfront.Add(line);
}
// Anything to do?
if(linesmissingfront.Count == 0 && linesmissingback.Count == 0) return;
// Let's use a blockmap...
RectangleF area = CreateArea(linesmissingfront);
area = IncreaseArea(area, linesmissingback);
BlockMap blockmap = new BlockMap(area);
blockmap.AddSectorsSet(General.Map.Map.Sectors);
// Find sectors to join singlesided lines
Dictionary linefrontsectorref = new Dictionary();
foreach(Linedef line in linesmissingfront)
{
// Line is now inside a sector?
Sector nearest = FindSectorContaining(blockmap, line);
// We can reattach our line!
if(nearest != null) linefrontsectorref[line] = nearest;
}
Dictionary linebacksectorref = new Dictionary();
foreach(Linedef line in linesmissingback)
{
// Line is now inside a sector?
Sector nearest = FindSectorContaining(blockmap, line);
// We can reattach our line!
if(nearest != null) linebacksectorref[line] = nearest;
}
// Check single-sided lines. Add new sidedefs if necessary
// Key is dragged single-sided line, value is a sector dragged line ended up in.
foreach(KeyValuePair group in linefrontsectorref)
{
Linedef line = group.Key;
// Create new sidedef
Sidedef newside = General.Map.Map.CreateSidedef(line, true, group.Value);
// Copy props from the other side
Sidedef propssource = (line.Front ?? line.Back);
propssource.CopyPropertiesTo(newside);
// Correct the linedef
if((line.Front == null) && (line.Back != null))
{
line.FlipVertices();
line.FlipSidedefs();
}
// Adjust textures
if(line.Front != null) line.Front.RemoveUnneededTextures(line.Back != null, false, true);
if(line.Back != null) line.Back.RemoveUnneededTextures(line.Front != null, false, true);
// Correct the sided flags
line.ApplySidedFlags();
}
foreach(KeyValuePair group in linebacksectorref)
{
Linedef line = group.Key;
// Create new sidedef
Sidedef newside = General.Map.Map.CreateSidedef(line, false, group.Value);
// Copy props from the other side
Sidedef propssource = (line.Front ?? line.Back);
propssource.CopyPropertiesTo(newside);
// Correct the linedef
if((line.Front == null) && (line.Back != null))
{
line.FlipVertices();
line.FlipSidedefs();
}
// Adjust textures
if(line.Front != null) line.Front.RemoveUnneededTextures(line.Back != null, false, true);
if(line.Back != null) line.Back.RemoveUnneededTextures(line.Front != null, false, true);
// Correct the sided flags
line.ApplySidedFlags();
}
}
//mxd
private static Sector FindSectorContaining(BlockMap sectorsmap, Linedef line)
{
HashSet blocks = new HashSet
{
sectorsmap.GetBlockAt(line.Start.Position),
sectorsmap.GetBlockAt(line.End.Position),
};
foreach(BlockEntry be in blocks)
{
foreach(Sector sector in be.Sectors)
{
// Check if target line is inside the found sector
if(sector.Intersect(line.Start.Position, false) && sector.Intersect(line.End.Position, false))
return sector;
}
}
return null;
}
//mxd
private static string GetAdjacentMiddleTexture(Vertex v)
{
// Go through adjacent lines
foreach(Linedef l in v.Linedefs)
{
if(l.Front != null && l.Front.MiddleTexture != "-") return l.Front.MiddleTexture;
if(l.Back != null && l.Back.MiddleTexture != "-") return l.Back.MiddleTexture;
}
return "-";
}
#endregion
#region ================== Geometry Tools
/// This removes any virtual sectors in the map and returns the number of sectors removed.
public int RemoveVirtualSectors()
{
int count = 0;
int index = 0;
// Go for all sectors
while(index < numsectors)
{
// Remove when virtual
if(sectors[index].Fields.ContainsKey(VIRTUAL_SECTOR_FIELD))
{
sectors[index].Dispose();
count++;
}
else
{
index++;
}
}
return count;
}
/// This removes unused sectors and returns the number of removed sectors.
public int RemoveUnusedSectors(bool reportwarnings)
{
int count = 0;
int index = numsectors - 1;
// Go for all sectors
while(index >= 0)
{
// Remove when unused
if(sectors[index].Sidedefs.Count == 0)
{
if(reportwarnings)
General.ErrorLogger.Add(ErrorType.Warning, "Sector " + index + " was unused and has been removed.");
sectors[index].Dispose();
count++;
}
index--;
}
return count;
}
/// This joins overlapping lines together. Returns false when the operation failed.
public static bool JoinOverlappingLines(ICollection lines)
{
bool joined;
do
{
// No joins yet
joined = false;
// Go for all the lines
foreach(Linedef l1 in lines)
{
// Check if these vertices have lines that overlap
foreach(Linedef l2 in l1.Start.Linedefs)
{
//mxd. The same line?
if(l1.Index == l2.Index) continue;
// Sharing vertices?
if(l1.End == l2.End || l1.End == l2.Start)
{
bool oppositedirection = (l1.End == l2.Start);
bool l2marked = l2.Marked;
// Merge these two linedefs
while(lines.Remove(l2));
if(!l2.Join(l1)) return false;
// If l2 was marked as new geometry, we have to make sure
// that l1's FrontInterior is correct for the drawing procedure
if(l2marked)
{
l1.FrontInterior = l2.FrontInterior ^ oppositedirection;
}
// If l1 is marked as new geometry, we may need to flip it to preserve
// orientation of the original geometry, and update its FrontInterior
else if(l1.Marked)
{
if(oppositedirection)
{
l1.FlipVertices(); // This also flips FrontInterior
l1.FlipSidedefs();
}
}
joined = true;
break;
}
}
// Will have to restart when joined
if(joined) break;
// Check if these vertices have lines that overlap
foreach(Linedef l2 in l1.End.Linedefs)
{
//mxd. The same line?
if(l1.Index == l2.Index) continue;
// Sharing vertices?
if(l1.Start == l2.End || l1.Start == l2.Start)
{
bool oppositedirection = (l1.Start == l2.End);
bool l2marked = l2.Marked;
// Merge these two linedefs
while(lines.Remove(l2));
if(!l2.Join(l1)) return false;
// If l2 was marked as new geometry, we have to make sure
// that l1's FrontInterior is correct for the drawing procedure
if(l2marked)
{
l1.FrontInterior = l2.FrontInterior ^ oppositedirection;
}
// If l1 is marked as new geometry, we may need to flip it to preserve
// orientation of the original geometry, and update its FrontInterior
else if(l1.Marked)
{
if(oppositedirection)
{
l1.FlipVertices(); // This also flips FrontInterior
l1.FlipSidedefs();
}
}
joined = true;
break;
}
}
// Will have to restart when joined
if(joined) break;
}
}
while(joined);
// Return result
return true;
}
/// This removes looped linedefs (linedefs which reference the same vertex for
/// start and end) and returns the number of linedefs removed.
public static int RemoveLoopedLinedefs(ICollection lines)
{
int linesremoved = 0;
bool removedline;
do
{
// Nothing removed yet
removedline = false;
// Go for all the lines
foreach(Linedef l in lines)
{
// Check if referencing the same vertex twice (mxd. Or if both verts are null)
if(l.Start == l.End || l.Start.Position == l.End.Position)
{
// Remove this line
while(lines.Remove(l));
l.Dispose();
linesremoved++;
removedline = true;
break;
}
}
}
while(removedline);
// Return result
return linesremoved;
}
/// This joins nearby vertices from two collections. This does NOT join vertices
/// within the same collection, only if they exist in both collections.
/// The vertex from the second collection is moved to match the first vertex.
/// When keepsecond is true, the vertex in the second collection is kept,
/// otherwise the vertex in the first collection is kept.
/// Returns the number of joins made.
public static int JoinVertices(ICollection set1, ICollection set2, bool keepsecond, float joindist)
{
float joindist2 = joindist * joindist;
int joinsdone = 0;
bool joined;
do
{
// No joins yet
joined = false;
// Go for all vertices in the first set
foreach (Vertex v1 in set1)
{
// Go for all vertices in the second set
foreach (Vertex v2 in set2)
{
// Check if vertices are close enough
if (v1.DistanceToSq(v2.Position) <= joindist2)
{
// Check if not the same vertex
if (v1 != v2)
{
// Move the second vertex to match the first
v2.Move(v1.Position);
// Check which one to keep
if (keepsecond)
{
// Join the first into the second
// Second is kept, first is removed
v1.Join(v2);
set1.Remove(v1);
set2.Remove(v1);
}
else
{
// Join the second into the first
// First is kept, second is removed
v2.Join(v1);
set1.Remove(v2);
set2.Remove(v2);
}
// Count the join
joinsdone++;
joined = true;
break;
}
}
}
// Will have to restart when joined
if (joined) break;
}
}
while (joined);
// Return result
return joinsdone;
}
/// This joins nearby vertices in the same collection
public static int JoinVertices(List set, float joindist)
{
float joindist2 = joindist * joindist;
int joinsdone = 0;
bool joined;
do
{
// No joins yet
joined = false;
// Go for all vertices in the first set
for(int i = 0; i < set.Count - 1; i++)
{
for(int c = i + 1; c < set.Count; c++)
{
Vertex v1 = set[i];
Vertex v2 = set[c];
// Check if vertices are close enough
if(v1.DistanceToSq(v2.Position) <= joindist2)
{
// Check if not the same vertex
if(v1.Index != v2.Index)
{
// Move the second vertex to match the first
v2.Move(v1.Position);
// Join the second into the first
v2.Join(v1);
set.Remove(v2);
// Count the join
joinsdone++;
joined = true;
break;
}
}
}
}
} while(joined);
// Return result
return joinsdone;
}
/// This corrects lines that have a back sidedef but no front sidedef by flipping them. Returns the number of flips made.
public static int FlipBackwardLinedefs(ICollection lines)
{
int flipsdone = 0;
// Examine all lines
foreach(Linedef l in lines)
{
// Back side but no front side?
if((l.Back != null) && (l.Front == null))
{
// Flip that linedef!
l.FlipVertices();
l.FlipSidedefs();
flipsdone++;
}
}
// Return result
return flipsdone;
}
/// This splits the given lines with the given vertices. All affected lines
/// will be added to changedlines. Returns false when the operation failed.
public static bool SplitLinesByVertices(ICollection lines, ICollection verts, float splitdist, ICollection changedlines) { return SplitLinesByVertices(lines, verts, splitdist, changedlines, MergeGeometryMode.CLASSIC); }
public static bool SplitLinesByVertices(ICollection lines, ICollection verts, float splitdist, ICollection changedlines, MergeGeometryMode mergemode)
{
if (verts.Count == 0 || lines.Count == 0) return true; //mxd
float splitdist2 = splitdist * splitdist;
//mxd. Create blockmap
RectangleF area = CreateArea(lines);
IncreaseArea(area, verts);
General.WriteLogLine("Area = " + area.Width + ", " + area.Height);
BlockMap blockmap = new BlockMap(area);
blockmap.AddVerticesSet(verts);
blockmap.AddLinedefsSet(lines);
int bmWidth = blockmap.Size.Width;
int bmHeight = blockmap.Size.Height;
BlockEntry[,] bmap = blockmap.Map;
HashSet splitverts = new HashSet();
HashSet changedsectors = (mergemode == MergeGeometryMode.REPLACE ? General.Map.Map.GetSectorsFromLinedefs(changedlines) : new HashSet());
HashSet lineverts = new HashSet();
foreach (Linedef l in lines)
{
lineverts.Add(l.Start);
lineverts.Add(l.End);
}
foreach (Vertex v in verts)
{
List blocks;
// If a vertex is in the very bottom left of it's block, and a linedef passes through the vertex it can
// happen (depending on the linedef's direction) that the vertex and the linedef are not in the same
// block. This will cause the linedef to not be split correctly. The prevent this we'll get all blocks
// surrounding the vertex, since the linedef will definitely be in at least one of them. Otherwise
// just take the block the vertex is in.
if ((blockmap.Range.Left - (int)v.Position.x) % blockmap.BlockSize == 0 && (blockmap.Range.Bottom - (int)v.Position.y) % blockmap.BlockSize == 0)
{
Rectangle r = new Rectangle((int)v.Position.x - 1, (int)v.Position.y - 1, 2, 2);
blocks = blockmap.GetSquareRange(r);
}
else
{
blocks = new List() { blockmap.GetBlockAt(v.Position) };
}
foreach (BlockEntry be in blocks)
{
if (be == null) continue;
for (int i = 0; i < be.Lines.Count; i++)
{
Linedef l = be.Lines[i];
// Check if v is close enough to l for splitting
if (l.DistanceToSq(v.Position, true) <= splitdist2)
{
// Line is not already referencing v?
Vector2D deltastart = l.Start.Position - v.Position;
Vector2D deltaend = l.End.Position - v.Position;
if (((Math.Abs(deltastart.x) > 0.001f) || (Math.Abs(deltastart.y) > 0.001f)) &&
((Math.Abs(deltaend.x) > 0.001f) || (Math.Abs(deltaend.y) > 0.001f)))
{
// Split line l with vertex v
Linedef nl = l.Split(v);
if (nl == null) return false;
v.Marked = true; //mxd
splitverts.Add(v); //mxd
// Add the new line to the list
lines.Add(nl);
blockmap.AddLinedef(nl);
// Both lines must be updated because their new length is relevant for next iterations!
l.UpdateCache();
nl.UpdateCache();
// Add both lines to changedlines
if (changedlines != null)
{
changedlines.Add(l);
changedlines.Add(nl);
}
}
}
}
}
}
//mxd. Remove lines, which are inside affected sectors
if(mergemode == MergeGeometryMode.REPLACE && changedsectors.Count > 0)
{
HashSet alllines = new HashSet(lines);
if(changedlines != null) alllines.UnionWith(changedlines);
foreach(Linedef l in alllines) l.UpdateCache();
foreach(Sector s in changedsectors) s.UpdateBBox();
foreach(Linedef l in alllines)
{
// Remove line when it's start, center and end are inside a changed sector and neither side references it
if(l.Start != null && l.End != null &&
(l.Front == null || !changedsectors.Contains(l.Front.Sector)) &&
(l.Back == null || !changedsectors.Contains(l.Back.Sector)))
{
foreach(Sector s in changedsectors)
{
if(s.Intersect(l.Start.Position) && s.Intersect(l.End.Position) && s.Intersect(l.GetCenterPoint()))
{
Vertex[] tocheck = { l.Start, l.End };
while(lines.Remove(l));
if(changedlines != null) while(changedlines.Remove(l));
l.Dispose();
foreach(Vertex v in tocheck)
{
// If the newly created vertex only has 2 linedefs attached, then merge the linedefs
if(!v.IsDisposed && v.Linedefs.Count == 2 && splitverts.Contains(v))
{
Linedef ld1 = General.GetByIndex(v.Linedefs, 0);
Linedef ld2 = General.GetByIndex(v.Linedefs, 1);
if(!ld1.Marked && !ld2.Marked)
{
Vertex v2 = (ld2.Start == v) ? ld2.End : ld2.Start;
if(ld1.Start == v) ld1.SetStartVertex(v2); else ld1.SetEndVertex(v2);
while(lines.Remove(ld2));
if(changedlines != null) while(changedlines.Remove(ld2));
ld2.Dispose();
// Trash vertex
v.Dispose();
}
}
}
break;
}
}
}
}
}
// [ZZ] note: disposing a vertex means also disposing all attached linedefs!
// we need to iterate through our lines collection and make sure no disposed linedefs exist there.
// also, just in case, do it for vertices as well, because vertices can be chain-disposed.
foreach (Linedef line in lines.Where(line => line.IsDisposed).ToList())
while (lines.Remove(line));
foreach (Vertex vert in verts.Where(vert => vert.IsDisposed).ToList())
while (verts.Remove(vert));
return true;
}
/// Splits lines by lines. Adds new lines to the second collection. Returns false when the operation failed.
public static bool SplitLinesByLines(ICollection lines, HashSet changedlines, MergeGeometryMode mergemode) //mxd
{
if(lines.Count == 0 || changedlines.Count == 0 || mergemode == MergeGeometryMode.CLASSIC) return true;
// Create blockmap
HashSet verts = new HashSet(); //mxd
foreach(Linedef l in lines)
{
verts.Add(l.Start);
verts.Add(l.End);
}
foreach(Linedef l in changedlines)
{
verts.Add(l.Start);
verts.Add(l.End);
}
RectangleF area = RectangleF.Union(CreateArea(lines), CreateArea(changedlines));
BlockMap blockmap = new BlockMap(area);
blockmap.AddLinedefsSet(lines);
blockmap.AddLinedefsSet(changedlines);
blockmap.AddVerticesSet(verts); //mxd
int bmWidth = blockmap.Size.Width;
int bmHeight = blockmap.Size.Height;
BlockEntry[,] bmap = blockmap.Map;
//mxd
HashSet splitverts = new HashSet();
HashSet changedsectors = (mergemode == MergeGeometryMode.REPLACE ? General.Map.Map.GetSectorsFromLinedefs(changedlines) : new HashSet());
// Check for intersections
for(int w = 0; w < bmWidth; w++)
{
for(int h = 0; h < bmHeight; h++)
{
BlockEntry block = bmap[w, h];
if(block.Lines.Count == 0) continue;
for(int i = 0; i < block.Lines.Count; i++)
{
Linedef l1 = block.Lines[i];
for(int c = 0; c < block.Lines.Count; c++)
{
if(i == c) continue;
Linedef l2 = block.Lines[c];
if(l1 == l2
|| l1.Start.Position == l2.Start.Position
|| l1.Start.Position == l2.End.Position
|| l1.End.Position == l2.Start.Position
|| l1.End.Position == l2.End.Position) continue;
// Check for intersection
Vector2D intersection = Line2D.GetIntersectionPoint(new Line2D(l1), new Line2D(l2), true);
if(!float.IsNaN(intersection.x))
{
//mxd. Round to map format precision
intersection.x = (float)Math.Round(intersection.x, General.Map.FormatInterface.VertexDecimals);
intersection.y = (float)Math.Round(intersection.y, General.Map.FormatInterface.VertexDecimals);
//mxd. Skip when intersection matches start/end position.
// Otherwise infinite ammount of 0-length lines will be created...
if( l1.Start.Position == intersection || l1.End.Position == intersection ||
l2.Start.Position == intersection || l2.End.Position == intersection) continue;
//mxd. Do we already have a vertex here?
bool existingvert = false;
Vertex splitvertex = null;
foreach(Vertex v in block.Vertices)
{
if(v.Position == intersection)
{
splitvertex = v;
existingvert = true;
break;
}
}
//mxd. Create split vertex?
if(splitvertex == null) splitvertex = General.Map.Map.CreateVertex(intersection);
if(splitvertex == null) return false;
// Split both lines
Linedef nl1 = l1.Split(splitvertex);
if(nl1 == null) return false;
Linedef nl2 = l2.Split(splitvertex);
if(nl2 == null) return false;
// Mark split vertex?
if(!existingvert)
{
splitvertex.Marked = true;
splitverts.Add(splitvertex); //mxd
}
// Add to the second collection
changedlines.Add(nl1);
changedlines.Add(nl2);
// And to the block entry
blockmap.AddLinedef(nl1);
blockmap.AddLinedef(nl2);
}
}
}
}
}
//mxd. Remove lines, which are inside affected sectors
if(mergemode == MergeGeometryMode.REPLACE)
{
HashSet alllines = new HashSet(lines);
alllines.UnionWith(changedlines);
foreach(Linedef l in alllines) l.UpdateCache();
foreach(Sector s in changedsectors) s.UpdateBBox();
foreach(Linedef l in alllines)
{
// Remove line when it's start, center and end are inside a changed sector and neither side references it
if(l.Start != null && l.End != null
&& (l.Front == null || !changedsectors.Contains(l.Front.Sector))
&& (l.Back == null || !changedsectors.Contains(l.Back.Sector)))
{
foreach(Sector s in changedsectors)
{
if(s.Intersect(l.Start.Position) && s.Intersect(l.End.Position) && s.Intersect(l.GetCenterPoint()))
{
Vertex[] tocheck = { l.Start, l.End };
l.Dispose();
foreach(Vertex v in tocheck)
{
// If the newly created vertex only has 2 linedefs attached, then merge the linedefs
if(!v.IsDisposed && v.Linedefs.Count == 2 && splitverts.Contains(v))
{
Linedef ld1 = General.GetByIndex(v.Linedefs, 0);
Linedef ld2 = General.GetByIndex(v.Linedefs, 1);
Vertex v2 = (ld2.Start == v) ? ld2.End : ld2.Start;
if(ld1.Start == v) ld1.SetStartVertex(v2); else ld1.SetEndVertex(v2);
ld2.Dispose();
// Trash vertex
v.Dispose();
}
}
break;
}
}
}
}
}
return true;
}
/// This finds the side closest to the specified position.
public static Sidedef NearestSidedef(ICollection selection, Vector2D pos)
{
Sidedef closest = null;
float distance = float.MaxValue;
// Go for all sidedefs in selection
foreach(Sidedef sd in selection)
{
// Calculate distance and check if closer than previous find
float d = sd.Line.SafeDistanceToSq(pos, true);
if(d == distance)
{
// Same distance, so only pick the one that is on the right side of the line
float side = sd.Line.SideOfLine(pos);
if(((side <= 0.0f) && sd.IsFront) || ((side > 0.0f) && !sd.IsFront))
{
closest = sd;
distance = d;
}
}
else if(d < distance)
{
// This one is closer
closest = sd;
distance = d;
}
}
// Return result
return closest;
}
/// This finds the line closest to the specified position.
public static Linedef NearestLinedef(BlockMap selectionmap, Vector2D pos) //mxd
{
Linedef closest = null;
float distance = float.MaxValue;
Point p = selectionmap.GetBlockCoordinates(pos);
int minx = p.X;
int maxx = p.X;
int miny = p.Y;
int maxy = p.Y;
int step = 0;
// Check square block ranges around pos...
while(true)
{
bool noblocksfound = true;
for(int x = minx; x < maxx + 1; x++)
{
for(int y = miny; y < maxy + 1; y++)
{
// Skip inner blocks...
if(x > minx && x < maxx && y > miny && y < maxy) continue;
if(!selectionmap.IsInRange(new Point(x, y))) continue;
// Go for all linedefs in block
BlockEntry be = selectionmap.Map[x, y];
foreach(Linedef l in be.Lines)
{
// Calculate distance and check if closer than previous find
float d = l.SafeDistanceToSq(pos, true);
if(d < distance)
{
// This one is closer
closest = l;
distance = d;
}
}
noblocksfound = false;
}
}
// Abort if line was found or when outside of blockmap range...
// Check at least 3x3 blocks, because there's a possibility that a line closer to pos exists in a nearby block than in the first block
if(noblocksfound || (closest != null && step > 0)) return closest;
// Increase search range...
minx--;
maxx++;
miny--;
maxy++;
step++;
}
}
/// This finds the line closest to the specified position.
public static Linedef NearestLinedef(ICollection selection, Vector2D pos)
{
Linedef closest = null;
float distance = float.MaxValue;
// Go for all linedefs in selection
foreach(Linedef l in selection)
{
// Calculate distance and check if closer than previous find
float d = l.SafeDistanceToSq(pos, true);
if(d < distance)
{
// This one is closer
closest = l;
distance = d;
}
}
// Return result
return closest;
}
/// This finds the line closest to the specified position.
public static Linedef NearestLinedefRange(ICollection selection, Vector2D pos, float maxrange)
{
Linedef closest = null;
float distance = float.MaxValue;
float maxrangesq = maxrange * maxrange;
// Go for all linedefs in selection
foreach(Linedef l in selection)
{
// Calculate distance and check if closer than previous find
float d = l.SafeDistanceToSq(pos, true);
if(d < distance && d <= maxrangesq)
{
// This one is closer
closest = l;
distance = d;
}
}
// Return result
return closest;
}
/// This finds the line closest to the specified position.
public static Linedef NearestLinedefRange(BlockMap selectionmap, Vector2D pos, float maxrange) //mxd
{
if (selectionmap == null)
return null;
Linedef closest = null;
float distance = float.MaxValue;
float maxrangesq = maxrange * maxrange;
HashSet processed = new HashSet();
List blocks;
// If the max range is lower or equal to the blockmap's block size we can take a shortcut got the the possible blocks.
// Otherwise get an rectangular range of blocks. This happens when maxrange is computed from low zoom levels
if (maxrange <= selectionmap.BlockSize)
{
blocks = new List
{
selectionmap.GetBlockAt(pos),
selectionmap.GetBlockAt(new Vector2D(pos.x + maxrange, pos.y + maxrange)),
selectionmap.GetBlockAt(new Vector2D(pos.x + maxrange, pos.y - maxrange)),
selectionmap.GetBlockAt(new Vector2D(pos.x - maxrange, pos.y + maxrange)),
selectionmap.GetBlockAt(new Vector2D(pos.x - maxrange, pos.y - maxrange))
};
}
else
{
blocks = selectionmap.GetSquareRange(pos.x - maxrange, pos.y - maxrange, maxrange * 2, maxrange * 2);
}
foreach(BlockEntry be in blocks)
{
if(be == null) continue;
foreach(Linedef l in be.Lines)
{
if(processed.Contains(l)) continue;
// Calculate distance and check if closer than previous find
float d = l.SafeDistanceToSq(pos, true);
if(d < distance && d <= maxrangesq)
{
// This one is closer
closest = l;
distance = d;
}
processed.Add(l);
}
}
// Return result
return closest;
}
/// mxd. This finds the line closest to the specified position excluding given list of linedefs.
public Linedef NearestLinedef(Vector2D pos, HashSet linesToExclude)
{
Linedef closest = null;
float distance = float.MaxValue;
// Go for all linedefs in selection
foreach(Linedef l in linedefs)
{
if(linesToExclude.Contains(l)) continue;
// Calculate distance and check if closer than previous find
float d = l.SafeDistanceToSq(pos, true);
if(d < distance)
{
// This one is closer
closest = l;
distance = d;
}
}
// Return result
return closest;
}
/// This finds the vertex closest to the specified position.
public static Vertex NearestVertex(ICollection selection, Vector2D pos)
{
Vertex closest = null;
float distance = float.MaxValue;
// Go for all vertices in selection
foreach(Vertex v in selection)
{
// Calculate distance and check if closer than previous find
float d = v.DistanceToSq(pos);
if(d < distance)
{
// This one is closer
closest = v;
distance = d;
}
}
// Return result
return closest;
}
/// This finds the thing closest to the specified position.
public static Thing NearestThing(ICollection selection, Vector2D pos)
{
Thing closest = null;
float distance = float.MaxValue;
// Go for all things in selection
foreach(Thing t in selection)
{
// Calculate distance and check if closer than previous find
float d = t.DistanceToSq(pos);
if(d < distance)
{
// This one is closer
closest = t;
distance = d;
}
}
// Return result
return closest;
}
/// mxd. This finds the thing closest to the specified thing.
public static Thing NearestThing(ICollection selection, Thing thing)
{
Thing closest = null;
float distance = float.MaxValue;
// Go for all things in selection
foreach(Thing t in selection)
{
if(t == thing) continue;
// Calculate distance and check if closer than previous find
float d = t.DistanceToSq(thing.Position);
if(d < distance)
{
// This one is closer
closest = t;
distance = d;
}
}
// Return result
return closest;
}
/// This finds the vertex closest to the specified position.
public static Vertex NearestVertexSquareRange(ICollection selection, Vector2D pos, float maxrange)
{
RectangleF range = RectangleF.FromLTRB(pos.x - maxrange, pos.y - maxrange, pos.x + maxrange, pos.y + maxrange);
Vertex closest = null;
float distance = float.MaxValue;
// Go for all vertices in selection
foreach(Vertex v in selection)
{
float px = v.Position.x;
float py = v.Position.y;
//mxd. Within range?
if((v.Position.x < range.Left) || (v.Position.x > range.Right)
|| (v.Position.y < range.Top) || (v.Position.y > range.Bottom))
continue;
// Close than previous find?
float d = Math.Abs(px - pos.x) + Math.Abs(py - pos.y);
if(d < distance)
{
// This one is closer
closest = v;
distance = d;
}
}
// Return result
return closest;
}
/// This finds the thing closest to the specified position.
public static Thing NearestThingSquareRange(ICollection selection, Vector2D pos, float maxrange)
{
RectangleF range = RectangleF.FromLTRB(pos.x - maxrange, pos.y - maxrange, pos.x + maxrange, pos.y + maxrange);
Thing closest = null;
float distance = float.MaxValue;
float size = float.MaxValue; //mxd
// Go for all things in selection
foreach(Thing t in selection)
{
float px = t.Position.x;
float py = t.Position.y;
//mxd. Determine displayed size
float ts;
if(t.FixedSize && General.Map.Renderer2D.Scale > 1.0f)
ts = t.Size / General.Map.Renderer2D.Scale;
else if(General.Settings.FixedThingsScale)
ts = General.Map.Renderer2D.Scale;
else
ts = t.Size;
//mxd. Within range?
if(px < range.Left - ts || px > range.Right + ts || py < range.Top - ts || py > range.Bottom + ts) continue;
// Closer than previous find? mxd. Or smaller when distance is the same?
float d = Math.Abs(px - pos.x) + Math.Abs(py - pos.y);
if(d < distance || (d == distance && ts < size))
{
// This one is closer
closest = t;
distance = d;
size = ts; //mxd
}
}
// Return result
return closest;
}
#endregion
#region ================== Tools
/// This snaps all vertices to the map format accuracy. Call this to ensure the vertices are at valid coordinates.
public void SnapAllToAccuracy()
{
SnapAllToAccuracy(true);
}
/// This snaps all vertices to the map format accuracy. Call this to ensure the vertices are at valid coordinates.
public void SnapAllToAccuracy(bool usepreciseposition)
{
foreach(Vertex v in vertices) v.SnapToAccuracy(usepreciseposition);
foreach(Thing t in things) t.SnapToAccuracy(usepreciseposition);
}
/// This returns the next unused tag number.
public int GetNewTag()
{
Dictionary usedtags = new Dictionary();
ForAllTags(NewTagHandler, false, usedtags);
ForAllTags(NewTagHandler, true, usedtags);
// Now find the first unused index
for(int i = 1; i <= General.Map.FormatInterface.MaxTag; i++)
if(!usedtags.ContainsKey(i)) return i;
// All tags used!
return 0;
}
//mxd
/// This returns the next unused tag number.
public int GetNewTag(List moreusedtags)
{
Dictionary usedtags = new Dictionary();
foreach(int t in moreusedtags) if(!usedtags.ContainsKey(t)) usedtags.Add(t, true);
ForAllTags(NewTagHandler, false, usedtags);
ForAllTags(NewTagHandler, true, usedtags);
// Now find the first unused index
for(int i = 1; i <= General.Map.FormatInterface.MaxTag; i++)
if(!usedtags.ContainsKey(i)) return i;
// All tags used!
return 0;
}
//mxd
/// This returns the tag number, which is not used by any map element of given type. This method doesn't check action arguments!
public int GetNewTag(UniversalType elementType)
{
Dictionary usedtags = new Dictionary();
switch(elementType)
{
case UniversalType.ThingTag:
for(int i = 0; i < things.Length; i++)
{
if(things[i].Tag > 0 && !usedtags.ContainsKey(things[i].Tag))
usedtags.Add(things[i].Tag, false);
}
break;
case UniversalType.LinedefTag:
for(int i = 0; i < linedefs.Length; i++)
{
foreach(int tag in linedefs[i].Tags)
{
if(tag == 0) continue;
if(!usedtags.ContainsKey(tag)) usedtags.Add(tag, false);
}
}
break;
case UniversalType.SectorTag:
for(int i = 0; i < sectors.Length; i++)
{
foreach(int tag in sectors[i].Tags)
{
if(tag == 0) continue;
if(!usedtags.ContainsKey(tag)) usedtags.Add(tag, false);
}
}
break;
}
// Now find the first unused index
for(int i = 1; i <= General.Map.FormatInterface.MaxTag; i++)
if(!usedtags.ContainsKey(i)) return i;
// All tags used!
return 0;
}
/// This returns the next unused tag number within the marked geometry.
public int GetNewTag(bool marked)
{
Dictionary usedtags = new Dictionary();
ForAllTags(NewTagHandler, marked, usedtags);
// Now find the first unused index
for(int i = 1; i <= General.Map.FormatInterface.MaxTag; i++)
if(!usedtags.ContainsKey(i)) return i;
// All tags used!
return 0;
}
/// This returns the next unused tag number.
public List GetMultipleNewTags(int count)
{
List newtags = new List(count);
if(count > 0)
{
Dictionary usedtags = new Dictionary();
ForAllTags(NewTagHandler, false, usedtags);
ForAllTags(NewTagHandler, true, usedtags);
// Find unused tags and add them
for(int i = 1; i <= General.Map.FormatInterface.MaxTag; i++)
{
if(!usedtags.ContainsKey(i))
{
newtags.Add(i);
if(newtags.Count == count) break;
}
}
}
return newtags;
}
/// This returns the next unused tag number within the marked geometry.
public List GetMultipleNewTags(int count, bool marked)
{
List newtags = new List(count);
if(count > 0)
{
Dictionary usedtags = new Dictionary();
ForAllTags(NewTagHandler, marked, usedtags);
// Find unused tags and add them
for(int i = 1; i <= General.Map.FormatInterface.MaxTag; i++)
{
if(!usedtags.ContainsKey(i))
{
newtags.Add(i);
if(newtags.Count == count) break;
}
}
}
return newtags;
}
// Handler for finding a new tag
private static void NewTagHandler(MapElement element, bool actionargument, UniversalType type, ref int value, Dictionary usedtags)
{
usedtags[value] = true;
}
/// This calls a function for all tag fields in the marked or unmarked geometry. The obj parameter can be anything you wish to pass on to your TagHandler function.
public void ForAllTags(TagHandler handler, bool marked, T obj)
{
// Call handler on sectors tags
foreach(Sector s in sectors)
{
if(s.Marked == marked)
{
//mxd. Multiple tags support...
bool changed = false;
// Make a copy of tags, otherwise BeforePropsChange will be triggered after tag changes
List tags = new List(s.Tags);
for(int i = 0; i < tags.Count; i++)
{
int tag = tags[i];
handler(s, false, UniversalType.SectorTag, ref tag, obj);
if(tag != tags[i])
{
tags[i] = tag;
changed = true;
}
}
if(changed) s.Tags = tags.Distinct().ToList();
}
}
// Call handler on things tags
if(General.Map.FormatInterface.HasThingTag)
{
foreach(Thing t in things)
{
if(t.Marked == marked)
{
int tag = t.Tag;
handler(t, false, UniversalType.ThingTag, ref tag, obj);
if(tag != t.Tag) t.Tag = tag;
}
}
}
// Call handler on things action
if(General.Map.FormatInterface.HasThingAction && General.Map.FormatInterface.HasActionArgs)
{
foreach(Thing t in things)
{
if(t.Marked == marked)
{
LinedefActionInfo info = General.Map.Config.GetLinedefActionInfo(t.Action);
for(int i = 0; i < Thing.NUM_ARGS; i++)
{
if(info.Args[i].Used && CheckIsTagType(info.Args[i].Type))
{
int tag = t.Args[i];
handler(t, true, (UniversalType)(info.Args[i].Type), ref tag, obj);
if(tag != t.Args[i]) t.Args[i] = tag;
}
}
}
}
}
// Call handler on linedefs tags
if(General.Map.FormatInterface.HasLinedefTag)
{
foreach(Linedef l in linedefs)
{
if(l.Marked == marked)
{
//mxd. Multiple tags support...
bool changed = false;
// Make a copy of tags, otherwise BeforePropsChange will be triggered after tag changes
List tags = new List(l.Tags);
for(int i = 0; i < tags.Count; i++)
{
int tag = tags[i];
handler(l, false, UniversalType.LinedefTag, ref tag, obj);
if(tag != tags[i])
{
tags[i] = tag;
changed = true;
}
}
if(changed) l.Tags = tags.Distinct().ToList();
}
}
}
// Call handler on linedefs action
if(General.Map.FormatInterface.HasActionArgs)
{
foreach(Linedef l in linedefs)
{
if(l.Marked == marked)
{
LinedefActionInfo info = General.Map.Config.GetLinedefActionInfo(l.Action);
for(int i = 0; i < Linedef.NUM_ARGS; i++)
{
if(info.Args[i].Used && CheckIsTagType(info.Args[i].Type))
{
int tag = l.Args[i];
handler(l, true, (UniversalType)(info.Args[i].Type), ref tag, obj);
if(tag != l.Args[i]) l.Args[i] = tag;
}
}
}
}
}
}
// This checks if the given action argument type is a tag type
private static bool CheckIsTagType(int argtype)
{
return (argtype == (int)UniversalType.LinedefTag) ||
(argtype == (int)UniversalType.SectorTag) ||
(argtype == (int)UniversalType.ThingTag);
}
/// This makes a list of lines related to marked vertices.
/// A line is unstable when one vertex is marked and the other isn't.
public List LinedefsFromMarkedVertices(bool includeunmarked, bool includestable, bool includeunstable)
{
List list = new List((numlinedefs / 2) + 1);
// Go for all lines
foreach(Linedef l in linedefs)
{
// Check if this is to be included
if((includestable && (l.Start.Marked && l.End.Marked)) ||
(includeunstable && (l.Start.Marked ^ l.End.Marked)) ||
(includeunmarked && (!l.Start.Marked && !l.End.Marked)))
{
// Add to list
list.Add(l);
}
}
// Return result
return list;
}
/// This makes a list of unstable lines from the given vertices.
/// A line is unstable when one vertex is selected and the other isn't.
public static ICollection UnstableLinedefsFromVertices(ICollection verts)
{
Dictionary lines = new Dictionary();
// Go for all vertices
foreach(Vertex v in verts)
{
// Go for all lines
foreach(Linedef l in v.Linedefs)
{
// If the line exists in the list
if(lines.ContainsKey(l))
{
// Remove it
lines.Remove(l);
}
// Otherwise add it
else
{
// Add the line
lines.Add(l, l);
}
}
}
// Return result
return new List(lines.Values);
}
//mxd
/// This returns a sector if given coordinates are inside one.
public Sector GetSectorByCoordinates(Vector2D pos)
{
foreach(Sector s in sectors)
{
if(s.Intersect(pos)) return s;
}
return null;
}
//mxd
/// This returns a sector if given coordinates are inside one.
public Sector GetSectorByCoordinates(Vector2D pos, VisualBlockMap blockmap)
{
return blockmap.GetSectorAt(pos);
}
//mxd
/// Gets unselected sectors, which have all their linedefs selected
public HashSet GetUnselectedSectorsFromLinedefs(IEnumerable lines)
{
HashSet result = new HashSet();
Dictionary> sectorsbysides = new Dictionary>();
HashSet selectedsectors = new HashSet(General.Map.Map.GetSelectedSectors(true));
// Collect unselected sectors, which sidedefs belong to selected lines
foreach(Linedef line in lines)
{
if(line.Front != null && line.Front.Sector != null && !selectedsectors.Contains(line.Front.Sector))
{
if(!sectorsbysides.ContainsKey(line.Front.Sector)) sectorsbysides.Add(line.Front.Sector, new HashSet());
sectorsbysides[line.Front.Sector].Add(line.Front);
}
if(line.Back != null && line.Back.Sector != null && !selectedsectors.Contains(line.Back.Sector))
{
if(!sectorsbysides.ContainsKey(line.Back.Sector)) sectorsbysides.Add(line.Back.Sector, new HashSet());
sectorsbysides[line.Back.Sector].Add(line.Back);
}
}
// Add sectors, which have all their lines selected
foreach(var group in sectorsbysides)
{
if(group.Key.Sidedefs.Count == group.Value.Count) result.Add(group.Key);
}
return result;
}
//mxd
///