using System;

using System.Collections;

using System.Collections.Generic;

using System.Diagnostics;

using System.IO;

using System.Linq;

using weland.level;

namespace Weland;

public delegate bool PolygonFilter(Polygon p);

public delegate bool ObjectFilter(MapObject o);

public partial class Level

{

public static PolygonFilter Filter = p => true;

public static ObjectFilter ObjectFilter = o => true;

public static bool FilterPoints = false;

public static bool RememberDeletedSides = false;

public static LevelAttributes Attributes = new LevelAttributes();

public static int? VisibleLayer = null;

Dictionary<short, Side> ClockwiseOrphanedSides = [];

Dictionary<short, Side> CounterClockwiseOrphanedSides = [];

HashSet<short> LinesReflectingOrphanedSides = [];

public bool FilterLine(PolygonFilter f, Line line)

{

if (line.ClockwisePolygonOwner == -1)

{

if (line.CounterclockwisePolygonOwner == -1)

{

return true;

}

else

{

return f(Polygons[line.CounterclockwisePolygonOwner]);

}

}

else

{

if (line.CounterclockwisePolygonOwner == -1)

{

return f(Polygons[line.ClockwisePolygonOwner]);

}

else

{

return f(Polygons[line.ClockwisePolygonOwner]) || f(Polygons[line.CounterclockwisePolygonOwner]);

}

}

}

public bool FilterPoint(PolygonFilter f, short index)

{

if (!FilterPoints) return true;

var polygonSet = EndpointPolygons[index];

foreach (var polygon in polygonSet)

{

if (f(polygon))

{

return true;

}

}

var lineSet = EndpointLines[index];

foreach (var line in lineSet)

{

if (FilterLine(f, line))

{

return true;

}

}

return false;

}

public int Distance(Point p0, Point p1)

{

return (int)Math.Round(Math.Sqrt(Math.Pow(p0.X - p1.X, 2) + Math.Pow(p0.Y - p1.Y, 2)));

}

double U(Point p, Line line)

{

var e0 = Endpoints[line.EndpointIndexes[0]];

var e1 = Endpoints[line.EndpointIndexes[1]];

return ((((double)p.X - e0.X) * ((double)e1.X - e0.X)) + (((double)p.Y - e0.Y) * ((double)e1.Y - e0.Y))) / (Math.Pow(e1.X - e0.X, 2) + Math.Pow(e1.Y - e0.Y, 2));

}

public Point ClosestPointOnLine(Point p, Line line)

{

var e0 = Endpoints[line.EndpointIndexes[0]];

var e1 = Endpoints[line.EndpointIndexes[1]];

var u = U(p, line);

Point point;

point.X = (short)Math.Round(e0.X + (u * (e1.X - e0.X)));

point.Y = (short)Math.Round(e0.Y + (u * (e1.Y - e0.Y)));

return point;

}

public int Distance(Point p, Line line)

{

var e0 = Endpoints[line.EndpointIndexes[0]];

var e1 = Endpoints[line.EndpointIndexes[1]];

var u = U(p, line);

if (u > 1.0)

{

return Distance(p, e1);

}

else if (u < 0.0)

{

return Distance(p, e0);

}

else

{

var i = new Point

{

X = (short)Math.Round(e0.X + (u * (e1.X - e0.X))),

Y = (short)Math.Round(e0.Y + (u * (e1.Y - e0.Y)))

};

return Distance(p, i);

}

}

public double Dot(Point p0, Point p1)

{

return (p0.X * p1.X) + (p0.Y * p1.Y);

}

public double Cross(Point p0, Point p1)

{

return (p0.Y * p1.X) - (p0.X * p1.Y);

}

public short GetClosestAnnotation(Point p)

{

var min = int.MaxValue;

short closest_annotation = -1;

for (short i = 0; i < Annotations.Count; ++i)

{

var a = Annotations[i];

var distance = Distance(p, new Point(a.X, a.Y));

if (distance < min)

{

closest_annotation = i;

min = distance;

}

}

return closest_annotation;

}

public short GetClosestPoint(Point p)

{

var min = int.MaxValue;

short closest_point = -1;

for (short i = 0; i < Endpoints.Count; ++i)

{

if (FilterPoint(Filter, i))

{

var distance = Distance(p, Endpoints[i]);

if (distance < min)

{

closest_point = i;

min = distance;

}

}

}

return closest_point;

}

public short GetClosestObject(Point p)

{

var min = int.MaxValue;

short closest_object = -1;

for (short i = 0; i < Objects.Count; ++i)

{

if (Filter(Polygons[Objects[i].PolygonIndex]) && ObjectFilter(Objects[i]))

{

var distance = Distance(p, new Point(Objects[i].X, Objects[i].Y));

if (distance < min)

{

closest_object = i;

min = distance;

}

}

}

return closest_object;

}

public short GetClosestLine(Point p)

{

var min = int.MaxValue;

short closest_line = -1;

for (short i = 0; i < Lines.Count; ++i)

{

if (FilterLine(Filter, Lines[i]))

{

var distance = Distance(p, Lines[i]);

if (distance < min)

{

closest_line = i;

min = distance;

}

}

}

return closest_line;

}

public short GetEnclosingPolygon(Point p)

{

for (var i = 0; i < Polygons.Count; ++i)

{

if (Filter(Polygons[i]))

{

var points = GetPointRingFromLineRing(new List<short>(Polygons[i].LineIndexes).GetRange(0, Polygons[i].VertexCount));

if (PointLoopEnclosesPoint(p, points))

{

return (short)i;

}

}

}

return -1;

}

public List<short> GetEnclosingPolygons(Point p)

{

var polygons = new List<short>();

for (var i = 0; i < Polygons.Count; ++i)

{

if (Filter(Polygons[i]))

{

var points = GetPointRingFromLineRing(new List<short>(Polygons[i].LineIndexes).GetRange(0, Polygons[i].VertexCount));

if (PointLoopEnclosesPoint(p, points))

{

polygons.Add((short)i);

}

}

}

return polygons;

}

public short NewPoint(short X, short Y)

{

var p = new Point

{

X = X,

Y = Y

};

Endpoints.Add(p);

EndpointPolygons.Add([]);

EndpointLines.Add([]);

return (short)(Endpoints.Count - 1);

}

public short NewLine(short p1, short p2)

{

var line = new Line();

line.EndpointIndexes[0] = p1;

line.EndpointIndexes[1] = p2;

EndpointLines[p1].Add(line);

EndpointLines[p2].Add(line);

Lines.Add(line);

return (short)(Lines.Count - 1);

}

public short NewObject(Point p, short polygon_index)

{

var o = new MapObject

{

X = p.X,

Y = p.Y,

PolygonIndex = polygon_index

};

Objects.Add(o);

return (short)(Objects.Count - 1);

}

// split line, return a new point index at X, Y

public short SplitLine(short index, short X, short Y)

{

var line = Lines[index];

var e0 = line.EndpointIndexes[0];

var e1 = line.EndpointIndexes[1];

var p = NewPoint(X, Y);

var l1 = NewLine(e0, p);

var l2 = NewLine(p, e1);

if (line.ClockwisePolygonOwner != -1)

{

var polygon = Polygons[line.ClockwisePolygonOwner];

for (var i = 0; i < Polygon.MaxVertexCount; ++i)

{

if (polygon.LineIndexes[i] == index)

{

for (var j = Polygon.MaxVertexCount - 2; j >= i; --j)

{

polygon.LineIndexes[j + 1] = polygon.LineIndexes[j];

polygon.AdjacentPolygonIndexes[j + 1] = polygon.AdjacentPolygonIndexes[j];

polygon.EndpointIndexes[j + 1] = polygon.EndpointIndexes[j];

}

polygon.LineIndexes[i] = l1;

polygon.LineIndexes[i + 1] = l2;

if (polygon.EndpointIndexes[i] == e0)

{

polygon.EndpointIndexes[i + 1] = p;

}

else

{

polygon.EndpointIndexes[i] = p;

}

EndpointPolygons[p].Add(polygon);

polygon.VertexCount++;

UpdatePolygonConcavity(polygon);

if (line.ClockwisePolygonSideIndex != -1)

{

// clone it

var side = Sides[line.ClockwisePolygonSideIndex];

var stream = new MemoryStream();

var writer = new BinaryWriterBE(stream);

side.Save(writer);

stream.Seek(0, SeekOrigin.Begin);

var s1 = new Side();

var reader = new BinaryReaderBE(stream);

s1.Load(reader);

s1.LineIndex = l1;

Lines[l1].ClockwisePolygonSideIndex = (short)Sides.Count;

Sides.Add(s1);

stream.Seek(0, SeekOrigin.Begin);

var s2 = new Side();

s2.Load(reader);

s2.LineIndex = l2;

var l1_length = (short)Distance(Endpoints[e0], Endpoints[p]);

if (!s2.Primary.Texture.IsEmpty())

{

s2.Primary.X += l1_length;

}

if (!s2.Secondary.Texture.IsEmpty())

{

s2.Secondary.X += l1_length;

}

if (!s2.Transparent.Texture.IsEmpty())

{

s2.Transparent.X += l1_length;

}

Lines[l2].ClockwisePolygonSideIndex = (short)Sides.Count;

Sides.Add(s2);

}

break;

}

}

Lines[l1].ClockwisePolygonOwner = line.ClockwisePolygonOwner;

Lines[l2].ClockwisePolygonOwner = line.ClockwisePolygonOwner;

}

if (line.CounterclockwisePolygonOwner != -1)

{

var polygon = Polygons[line.CounterclockwisePolygonOwner];

for (var i = 0; i < Polygon.MaxVertexCount; ++i)

{

if (polygon.LineIndexes[i] == index)

{

for (var j = Polygon.MaxVertexCount - 2; j >= i; --j)

{

polygon.LineIndexes[j + 1] = polygon.LineIndexes[j];

polygon.AdjacentPolygonIndexes[j + 1] = polygon.AdjacentPolygonIndexes[j];

polygon.EndpointIndexes[j + 1] = polygon.EndpointIndexes[j];

}

polygon.LineIndexes[i] = l2;

polygon.LineIndexes[i + 1] = l1;

if (polygon.EndpointIndexes[i] == e0)

{

polygon.EndpointIndexes[i] = p;

}

else

{

polygon.EndpointIndexes[i + 1] = p;

}

polygon.VertexCount++;

UpdatePolygonConcavity(polygon);

if (line.CounterclockwisePolygonSideIndex != -1)

{

// clone it

var side = Sides[line.CounterclockwisePolygonSideIndex];

var stream = new MemoryStream();

var writer = new BinaryWriterBE(stream);

side.Save(writer);

stream.Seek(0, SeekOrigin.Begin);

var s1 = new Side();

var reader = new BinaryReaderBE(stream);

s1.Load(reader);

s1.LineIndex = l1;

Lines[l1].CounterclockwisePolygonSideIndex = (short)Sides.Count;

Sides.Add(s1);

stream.Seek(0, SeekOrigin.Begin);

var s2 = new Side();

s2.Load(reader);

s2.LineIndex = l2;

var l1_length = (short)Distance(Endpoints[e0], Endpoints[p]);

if (!s2.Primary.Texture.IsEmpty())

{

s2.Primary.X += l1_length;

}

if (!s2.Secondary.Texture.IsEmpty())

{

s2.Secondary.X += l1_length;

}

if (!s2.Transparent.Texture.IsEmpty())

{

s2.Transparent.X += l1_length;

}

Lines[l2].CounterclockwisePolygonSideIndex = (short)Sides.Count;

Sides.Add(s2);

}

break;

}

}

Lines[l1].CounterclockwisePolygonOwner = line.CounterclockwisePolygonOwner;

Lines[l2].CounterclockwisePolygonOwner = line.CounterclockwisePolygonOwner;

if (Lines[l1].ClockwisePolygonOwner != -1)

{

Lines[l1].Transparent = true;

}

if (Lines[l2].ClockwisePolygonOwner != -1)

{

Lines[l2].Transparent = true;

}

}

if (line.ClockwisePolygonSideIndex != -1)

{

DeleteSide(line.ClockwisePolygonSideIndex);

}

if (line.CounterclockwisePolygonSideIndex != -1)

{

DeleteSide(line.CounterclockwisePolygonSideIndex);

}

DeleteLineIndex(index);

return p;

}

// returns all line indices due east of X, Y sorted by x intersect

SortedDictionary<double, short> GetFillCandidateLines(short X, short Y)

{

SortedDictionary<double, short> candidates = [];

for (var i = 0; i < Lines.Count; ++i)

{

if (FilterLine(Filter, Lines[i]))

{

var p0 = Endpoints[Lines[i].EndpointIndexes[0]];

var p1 = Endpoints[Lines[i].EndpointIndexes[1]];

if (p1.Y == p0.Y)

{

continue;

}

var u = (double)(Y - p0.Y) / (p1.Y - p0.Y);

var x_intersect = p0.X + (u * (p1.X - p0.X));

if (u >= 0.0 && u <= 1.0 && x_intersect > X)

{

// note that if two lines miraculously share the

// same X intercept, one will be lost--oh well,

// click somewhere else

candidates[x_intersect] = (short)i;

}

}

}

return candidates;

}

// get all lines attached to endpoint

public List<short> FindEndpointLines(short index)

{

List<short> lines = [];

for (var i = 0; i < Lines.Count; ++i)

{

var line = Lines[i];

if (FilterLine(Filter, line) && (line.EndpointIndexes[0] == index ||

line.EndpointIndexes[1] == index))

{

lines.Add((short)i);

}

}

return lines;

}

// get all polygons that have this endpoint

public List<short> FindEndpointPolygons(short index)

{

List<short> polygons = [];

for (var i = 0; i < Polygons.Count; ++i)

{

for (var j = 0; j < Polygons[i].VertexCount; ++j)

{

var line = Lines[Polygons[i].LineIndexes[j]];

if (line.EndpointIndexes[0] == index ||

line.EndpointIndexes[1] == index)

{

polygons.Add((short)i);

break;

}

}

}

return polygons;

}

Point Diff(Point p0, Point p1)

{

return new Point((short)(p0.X - p1.X), (short)(p0.Y - p1.Y));

}

double Norm(Point p)

{

return Math.Sqrt(Math.Pow(p.X, 2) + Math.Pow(p.Y, 2));

}

bool BuildLoop(short target, short prev, short current, int depth, short starter, List<short> list)

{

if (depth >= 8)

{

return false;

}

else if (current == target)

{

int other_index = Lines[list[0]].EndpointIndexes[0];

if (other_index == current)

other_index = Lines[list[0]].EndpointIndexes[1];

var cross = Cross(Diff(Endpoints[prev], Endpoints[current]), Diff(Endpoints[other_index], Endpoints[current]));

if (cross >= 0.0)

{

return true;

}

else

{

return false;

}

}

var neighbors = FindEndpointLines(current);

neighbors.Remove(starter);

if (neighbors.Count == 0)

{

return false;

}

// C# needs a multimap :(

SortedDictionary<double, List<short>> dotProducts = [];

foreach (var i in neighbors)

{

if (Lines[i].EndpointIndexes[0] == prev ||

Lines[i].EndpointIndexes[1] == prev)

{

continue;

}

var p0 = Endpoints[Lines[i].EndpointIndexes[0]];

var p1 = Endpoints[Lines[i].EndpointIndexes[1]];

double dp;

if (Lines[i].EndpointIndexes[0] == current)

{

dp = Dot(Diff(Endpoints[prev], Endpoints[current]), Diff(p1, Endpoints[current])) / Norm(Diff(p1, Endpoints[current]));

}

else

{

dp = Dot(Diff(Endpoints[prev], Endpoints[current]), Diff(p0, Endpoints[current])) / Norm(Diff(p0, Endpoints[current]));

}

if (!dotProducts.ContainsKey(dp))

{

dotProducts[dp] = [];

}

dotProducts[dp].Add(i);

}

short firstNeighbor = -1;

foreach (var kvp in dotProducts)

{

foreach (var i in kvp.Value)

{

double cross;

var p0 = Endpoints[Lines[i].EndpointIndexes[0]];

var p1 = Endpoints[Lines[i].EndpointIndexes[1]];

if (Lines[i].EndpointIndexes[0] == current)

{

cross = Cross(Diff(Endpoints[prev], Endpoints[current]), Diff(p1, Endpoints[current]));

}

else

{

cross = Cross(Diff(Endpoints[prev], Endpoints[current]), Diff(p0, Endpoints[current]));

}

if (cross >= 0.0)

{

firstNeighbor = i;

}

}

}

if (firstNeighbor == -1)

{

return false;

}

short tightest;

if (Lines[firstNeighbor].EndpointIndexes[0] == current)

{

tightest = Lines[firstNeighbor].EndpointIndexes[1];

}

else

{

tightest = Lines[firstNeighbor].EndpointIndexes[0];

}

list.Add(firstNeighbor);

return BuildLoop(target, current, tightest, depth + 1, starter, list);

}

List<short> GetPointRingFromLineRing(List<short> lines)

{

List<short> points =

[

// find the first point

Lines[lines[0]].EndpointIndexes[0] == Lines[lines[1]].EndpointIndexes[0] ||

Lines[lines[0]].EndpointIndexes[0] == Lines[lines[1]].EndpointIndexes[1] ? Lines[lines[0]].EndpointIndexes[0] : Lines[lines[0]].EndpointIndexes[1],

];

for (var i = 1; i < lines.Count; ++i)

{

if (points[points.Count - 1] == Lines[lines[i]].EndpointIndexes[0])

{

points.Add(Lines[lines[i]].EndpointIndexes[1]);

}

else

{

points.Add(Lines[lines[i]].EndpointIndexes[0]);

}

}

return points;

}

double Angle(int X0, int Y0, int X1, int Y1)

{

// computes the angle from the line from the origin to p0,

// and the line from the origin to p1, and returns a value

// in the range [-pi,pi]

var dtheta = (Math.Atan2(Y0, X0) - Math.Atan2(Y1, X1)) % (Math.PI * 2);

if (dtheta > Math.PI)

return dtheta - (Math.PI * 2);

else if (dtheta < -Math.PI)

return dtheta + (Math.PI * 2);

else

return dtheta;

}

bool PointLoopEnclosesPoint(Point p, List<short> points)

{

double angle_sum = 0;

for (var i = 0; i < points.Count; ++i)

{

var p0 = Endpoints[points[i]];

var p1 = Endpoints[points[(i + 1) % points.Count]];

var angle = Angle(p0.X - p.X, p0.Y - p.Y, p1.X - p.X, p1.Y - p.Y);

angle_sum += angle;

}

return !(Math.Abs(angle_sum) < Math.PI);

}

List<short> SelectLineLoop(short X, short Y)

{

var candidates = GetFillCandidateLines(X, Y);

foreach (var kvp in candidates)

{

var line = Lines[kvp.Value];

var p0 = line.EndpointIndexes[0];

var p1 = line.EndpointIndexes[1];

if (Endpoints[p0].Y > Endpoints[p1].Y)

{

p0 = line.EndpointIndexes[1];

p1 = line.EndpointIndexes[0];

}

List<short> lines = [kvp.Value];

if (BuildLoop(p0, p0, p1, 0, kvp.Value, lines))

{

// make sure the points enclose X, Y!

var points = GetPointRingFromLineRing(lines);

if (PointLoopEnclosesPoint(new Point(X, Y), points))

{

return lines;

}

}

}

return [];

}

public bool FillPolygon(short X, short Y)

{

if (GetEnclosingPolygon(new Point(X, Y)) != -1)

{

return false;

}

var loop = SelectLineLoop(X, Y);

if (loop.Count == 0)

{

return false;

}

foreach (var i in loop)

{

if (Lines[i].ClockwisePolygonOwner != -1 &&

Lines[i].CounterclockwisePolygonOwner != -1)

{

return false;

}

}

var polygon = new Polygon

{

VertexCount = (ushort)loop.Count

};

loop.CopyTo(polygon.LineIndexes);

var points = GetPointRingFromLineRing(loop);

points.CopyTo(polygon.EndpointIndexes);

foreach (var i in points)

{

EndpointPolygons[i].Add(polygon);

}

var index = (short)Polygons.Count;

Polygons.Add(polygon);

Polygon adjacent = null;

for (var i = 0; i < loop.Count; ++i)

{

var line = Lines[loop[i]];

if (line.EndpointIndexes[1] == polygon.EndpointIndexes[i])

{

line.ClockwisePolygonOwner = index;

if (line.CounterclockwisePolygonOwner != -1 && adjacent == null)

{

adjacent = Polygons[line.CounterclockwisePolygonOwner];

}

if (RememberDeletedSides && ClockwiseOrphanedSides.ContainsKey(loop[i]))

{

var side = ClockwiseOrphanedSides[loop[i]];

line.ClockwisePolygonSideIndex = (short)Sides.Count;

side.LineIndex = loop[i];

side.PolygonIndex = index;

Sides.Add(side);

FixSideType(side);

ClockwiseOrphanedSides.Remove(loop[i]);

}

}

else

{

line.CounterclockwisePolygonOwner = index;

if (line.ClockwisePolygonOwner != -1 && adjacent == null)

{

adjacent = Polygons[line.ClockwisePolygonOwner];

}

if (RememberDeletedSides && CounterClockwiseOrphanedSides.ContainsKey(loop[i]))

{

var side = CounterClockwiseOrphanedSides[loop[i]];

line.CounterclockwisePolygonSideIndex = (short)Sides.Count;

side.LineIndex = loop[i];

side.PolygonIndex = index;

Sides.Add(side);

FixSideType(side);

CounterClockwiseOrphanedSides.Remove(loop[i]);

}

}

if (line.ClockwisePolygonOwner != -1 &&

line.CounterclockwisePolygonOwner != -1)

{

line.Flags = LineFlags.Transparent;

// empty the side opposite

if (line.ClockwisePolygonOwner == index)

{

if (line.CounterclockwisePolygonSideIndex != -1)

{

if (RememberDeletedSides && LinesReflectingOrphanedSides.Contains(loop[i]))

{

LinesReflectingOrphanedSides.Remove(loop[i]);

}

else

{

Sides[line.CounterclockwisePolygonSideIndex].Clear();

}

}

}

else

{

if (line.ClockwisePolygonSideIndex != -1)

{

if (RememberDeletedSides && LinesReflectingOrphanedSides.Contains(loop[i]))

{

LinesReflectingOrphanedSides.Remove(loop[i]);

}

else

{

Sides[line.ClockwisePolygonSideIndex].Clear();

}

}

}

}

}

if (adjacent != null)

{

// copy some settings from it

polygon.FloorHeight = adjacent.FloorHeight;

polygon.CeilingHeight = adjacent.CeilingHeight;

polygon.FloorTexture = adjacent.FloorTexture;

polygon.CeilingTexture = adjacent.CeilingTexture;

polygon.FloorTransferMode = adjacent.FloorTransferMode;

polygon.CeilingTransferMode = adjacent.CeilingTransferMode;

polygon.FloorLight = adjacent.FloorLight;

polygon.CeilingLight = adjacent.CeilingLight;

}

UpdatePolygonConcavity(polygon);

return true;

}

public void UpdatePolygonConcavity(Polygon polygon)

{

List<short> lines = [];

for (var i = 0; i < polygon.VertexCount; ++i)

{

lines.Add(polygon.LineIndexes[i]);

}

double positive = 0;

var points = GetPointRingFromLineRing(lines);

for (var i = 0; i < points.Count; ++i)

{

var p0 = Endpoints[points[i]];

var p1 = Endpoints[points[(i + 1) % points.Count]];

var p2 = Endpoints[points[(i + 2) % points.Count]];

var cross = Cross(Diff(p1, p0), Diff(p2, p1));

if (positive == 0)

{

positive = cross;

}

else if (cross != 0)

{

if ((positive > 0) != (cross > 0))

{

polygon.Concave = true;

return;

}

}

}

polygon.Concave = false;

}

public Point PolygonCenter(Polygon polygon)

{

double X = 0;

double Y = 0;

for (var i = 0; i < polygon.VertexCount; ++i)

{

X += Endpoints[polygon.EndpointIndexes[i]].X;

Y += Endpoints[polygon.EndpointIndexes[i]].Y;

}

return new Point((short)(X / polygon.VertexCount), (short)(Y / polygon.VertexCount));

}

public void DeleteObject(short index)

{

var obj = Objects[index];

if (obj.Type == ObjectType.Monster && MonsterPlacement[obj.Index].InitialCount > 0)

{

MonsterPlacement[obj.Index].InitialCount--;

}

else if (obj.Type == ObjectType.Item && ItemPlacement[obj.Index].InitialCount > 0)

{

ItemPlacement[obj.Index].InitialCount--;

}

Objects.RemoveAt(index);

}

public void DeletePlatform(short index)

{

Platforms.RemoveAt(index);

foreach (var polygon in Polygons)

{

if (polygon.Type == PolygonType.Platform)

{

if (polygon.Permutation > index)

{

--polygon.Permutation;

}

}

}

}

public void TogglePolygonLayer(short index, int layer)

{

if (Attributes.PolygonLayers.ContainsKey(index))

{

if (Attributes.PolygonLayers[index].Contains(layer))

{

Attributes.PolygonLayers[index].Remove(layer);

}

else

{

Attributes.PolygonLayers[index].Add(layer);

}

}

else

{

Attributes.PolygonLayers[index] = [layer];

}

}

public void ClearPolygonLayers(short index)

{

if (Attributes.PolygonLayers.ContainsKey(index))

{

Attributes.PolygonLayers.Remove(index);

}

}

public void DeletePolygon(short index)

{

var polygonRef = Polygons[index];

short platformIndex = -1;

if (Polygons[index].Type == PolygonType.Platform)

{

platformIndex = Polygons[index].Permutation;

}

Polygons.RemoveAt(index);

for (short line_index = 0; line_index < Lines.Count; ++line_index)

{

var line = Lines[line_index];

if (line.ClockwisePolygonOwner > index)

{

--line.ClockwisePolygonOwner;

}

else if (line.ClockwisePolygonOwner == index)

{

line.ClockwisePolygonOwner = -1;

if (RememberDeletedSides)

{

if (LinesReflectingOrphanedSides.Contains(line_index))

{

LinesReflectingOrphanedSides.Remove(line_index);

}

else

{

LinesReflectingOrphanedSides.Add(line_index);

}

}

line.Flags = LineFlags.Solid;

}

if (line.CounterclockwisePolygonOwner > index)

{

--line.CounterclockwisePolygonOwner;

}

else if (line.CounterclockwisePolygonOwner == index)