public void ContainsTest()
{
var set = new IndexedSet <string>();
Assert.False(set.Contains("A"));
Assert.True(set.Add("A"));
Assert.True(set.Contains("A"));
Assert.False(set.Contains("B"));
}
public static void RemoveRaycaster(Pointer3DRaycaster raycaster)
{
if (!raycasters.Remove(raycaster))
{
return;
}
if (!processingRaycasters.Contains(raycaster) && Active)
{
Instance.CleanUpRaycaster(raycaster);
}
}
static void Main(string[] args)
{
Console.WriteLine("Generating test set.");
var rand = new Random();
IndexedSet <Sha256_Long> set =
new IndexedSet <Sha256_Long>(
GenerateRandomHashes(rand, NTestItems),
Sha256_Long.KeyBits);
Console.WriteLine("Testing with random input.");
int nFound = 0;
int nItems = NTestItems;
int waypointDistance = 100000;
int waypoint = 0;
for (int i = 0; i < nItems; i++)
{
if (++waypoint == waypointDistance)
{
Console.WriteLine("Test lookups complete: " + (i + 1));
waypoint = 0;
}
var item = RandomHash(rand);
nFound += set.Contains(item) ? 1 : 0;
}
Console.WriteLine("Testing complete.");
Console.WriteLine(String.Format("Found: {0} / {0}", nFound, nItems));
Console.ReadKey();
}
public void ExceptWithTest()
{
var firstSet = new IndexedSet <string>();
var secondSet = new IndexedSet <string>();
firstSet.Add("A");
secondSet.Add("A");
secondSet.Add("B");
secondSet.ExceptWith(firstSet);
Assert.That(secondSet.Count, Is.EqualTo(1));
Assert.False(secondSet.Contains("A"));
Assert.True(secondSet.Contains("B"));
}
private bool InternalRegisterCanvasElementForLayoutRebuild(ICanvasElement element)
{
if (m_LayoutRebuildQueue.Contains(element))
{
return(false);
}
return(m_LayoutRebuildQueue.AddUnique(element));
}
private void IndexedSetContains()
{
bool c;
for (int i = 0; i < count; i++)
{
c = indexedSet.Contains(data[i]);
}
}
public void RemoveTest()
{
var set = new IndexedSet <string>();
Assert.False(set.Remove("A"));
set.Add("A");
Assert.True(set.Remove("A"));
Assert.Zero(set.Count);
Assert.False(set.Contains("A"));
}
public void SimpleIndexedSetTest()
{
const double FirstElement = 17;
const double SecondElement = Math.PI;
const double ThirdElement = 6.23123438874;
const double FourthElement = 43;
var indexedSet = new IndexedSet <double>(new[] { FirstElement, SecondElement });
Assert.Equal(2, indexedSet.Count);
Assert.True(indexedSet.Contains(FirstElement));
var elements = indexedSet.Elements.ToArray();
Assert.Equal(SecondElement, elements[1]);
Assert.Equal(SecondElement, indexedSet.GetElementByIndex(1));
int secondElementIndex;
Assert.True(indexedSet.TryGetIndex(Math.PI, out secondElementIndex));
Assert.Equal(1, secondElementIndex);
indexedSet.Add(ThirdElement);
Assert.Equal(3, indexedSet.Count);
Assert.True(indexedSet.Contains(ThirdElement));
int fourthElementIndex;
Assert.Throws <ArgumentException>(() => indexedSet.Add(ThirdElement));
Assert.Throws <ArgumentOutOfRangeException>(() => indexedSet.GetElementByIndex(3));
Assert.False(indexedSet.TryGetIndex(FourthElement, out fourthElementIndex));
indexedSet.Add(ThirdElement, false);
indexedSet.Add(FourthElement);
Assert.Equal(FourthElement, indexedSet.GetElementByIndex(3));
indexedSet.Clear();
Assert.Equal(0, indexedSet.Count);
Assert.Throws <ArgumentException>(() => new IndexedSet <double>(new[] { FirstElement, SecondElement, SecondElement }));
}
private bool InternalRegisterCanvasElementForGraphicRebuild(ICanvasElement element)
{
if (m_PerformingGraphicUpdate)
{
Debug.LogError($"Trying to add {element} for graphic rebuild while we are already inside a graphic rebuild loop. This is not supported.");
return(false);
}
if (m_GraphicRebuildQueue.Contains(element))
{
return(false);
}
m_GraphicRebuildQueue.Add(element);
return(true);
}
private bool InternalRegisterCanvasElementForLayoutRebuild(ICanvasElement element)
{
if (m_LayoutRebuildQueue.Contains(element))
{
return(false);
}
if (m_PerformingLayoutUpdate)
{
Debug.LogError(string.Format("Trying to add {0} for layout rebuild while we are already inside a layout rebuild loop. This is not supported.", element));
return(false);
}
return(m_LayoutRebuildQueue.AddUnique(element));
}
private bool InternalRegisterCanvasElementForLayoutRebuild(ICanvasElement element)
{
if (m_LayoutRebuildQueue.Contains(element))
{
return(false);
}
/* TODO: this likely should be here but causes the error to show just resizing the game view (case 739376)
* if (m_PerformingLayoutUpdate)
* {
* Debug.LogError(string.Format("Trying to add {0} for layout rebuild while we are already inside a layout rebuild loop. This is not supported.", element));
* return false;
* }*/
return(m_LayoutRebuildQueue.AddUnique(element));
}
public Region Retract(int distance)
{
working.ResetTo(this);
foreach (Coord point in working.Ordering)
{
for (int x = Math.Max(0, point.X - distance), xd = Math.Min(Width - 1, point.X + distance); x < xd; x++)
{
for (int y = Math.Max(0, point.Y - distance), yd = Math.Min(Height - 1, point.Y + distance); y < yd; y++)
{
if (Math.Abs(point.X - x) + Math.Abs(point.Y - y) <= distance && !working.Contains(Coord.Get(x, y)))
{
Remove(point);
goto NEXT;
}
}
}
NEXT:
continue;
}
return(this);
}
static void Main()
{
var n = int.Parse(Console.ReadLine());
var set = new IndexedSet <int>();
Console.SetOut(new System.IO.StreamWriter(Console.OpenStandardOutput())
{
AutoFlush = false
});
while (n-- > 0)
{
var q = Array.ConvertAll(Console.ReadLine().Split(), int.Parse);
if (q[0] == 0)
{
set.Add(q[1]);
Console.WriteLine(set.Count);
}
else if (q[0] == 1)
{
Console.WriteLine(set.Contains(q[1]) ? 1 : 0);
}
else if (q[0] == 2)
{
set.Remove(q[1]);
}
else
{
foreach (var x in set.GetItems(x => x >= q[1], x => x <= q[2]))
{
Console.WriteLine(x);
}
}
}
Console.Out.Flush();
}
protected virtual void ProcessRaycast()
{
// use another list to iterate raycasters
// incase that raycasters may changed during this process cycle
processingRaycasters.AddRange(raycasters);
for (var i = processingRaycasters.Count - 1; i >= 0; --i)
{
var raycaster = processingRaycasters[i];
if (raycaster == null || !raycasters.Contains(raycaster))
{
continue;
}
raycaster.Raycast();
var result = raycaster.FirstRaycastResult();
// prepare raycaster value
var scrollDelta = raycaster.GetScrollDelta();
var raycasterPos = raycaster.transform.position;
var raycasterRot = raycaster.transform.rotation;
// hover event
var hoverEventData = raycaster.HoverEventData;
hoverEventData.Reset();
hoverEventData.delta = Vector2.zero;
hoverEventData.scrollDelta = scrollDelta;
hoverEventData.position = ScreenCenterPoint;
hoverEventData.pointerCurrentRaycast = result;
hoverEventData.position3DDelta = raycasterPos - hoverEventData.position3D;
hoverEventData.position3D = raycasterPos;
hoverEventData.rotationDelta = Quaternion.Inverse(hoverEventData.rotation) * raycasterRot;
hoverEventData.rotation = raycasterRot;
if (hoverEventData.pointerEnter != result.gameObject)
{
HandlePointerExitAndEnter(hoverEventData, result.gameObject);
}
// buttons event
for (int j = 0, jmax = raycaster.ButtonEventDataList.Count; j < jmax; ++j)
{
var buttonEventData = raycaster.ButtonEventDataList[j];
if (buttonEventData == null)
{
continue;
}
buttonEventData.Reset();
buttonEventData.delta = Vector2.zero;
buttonEventData.scrollDelta = scrollDelta;
buttonEventData.position = ScreenCenterPoint;
buttonEventData.pointerCurrentRaycast = result;
buttonEventData.position3DDelta = hoverEventData.position3DDelta;
buttonEventData.position3D = hoverEventData.position3D;
buttonEventData.rotationDelta = hoverEventData.rotationDelta;
buttonEventData.rotation = hoverEventData.rotation;
ProcessPress(buttonEventData);
var hoverGO = buttonEventData.eligibleForClick ? result.gameObject : null;
if (buttonEventData.pointerEnter != hoverGO)
{
HandlePointerExitAndEnter(buttonEventData, hoverGO);
}
ProcessDrag(buttonEventData);
}
// scroll event
if (result.isValid && !Mathf.Approximately(scrollDelta.sqrMagnitude, 0.0f))
{
var scrollHandler = ExecuteEvents.GetEventHandler <IScrollHandler>(result.gameObject);
ExecuteEvents.ExecuteHierarchy(scrollHandler, hoverEventData, ExecuteEvents.scrollHandler);
}
}
processingRaycasters.Clear();
}
protected virtual void ProcessRaycast()
{
if (m_processedFrame == Time.frameCount)
{
return;
}
m_processedFrame = Time.frameCount;
// use another list to iterate raycasters
// incase that raycasters may changed during this process cycle
for (int i = 0, imax = raycasters.Count; i < imax; ++i)
{
var r = raycasters[i];
if (r != null)
{
processingRaycasters.Add(r);
}
}
for (var i = processingRaycasters.Count - 1; i >= 0; --i)
{
var raycaster = processingRaycasters[i];
if (raycaster == null)
{
continue;
}
raycaster.Raycast();
var result = raycaster.FirstRaycastResult();
// prepare raycaster value
var scrollDelta = raycaster.GetScrollDelta();
var raycasterPos = raycaster.transform.position;
var raycasterRot = raycaster.transform.rotation;
var hoverEventData = raycaster.HoverEventData;
if (hoverEventData == null)
{
continue;
}
// gen shared data and put in hover event
hoverEventData.Reset();
hoverEventData.delta = Vector2.zero;
hoverEventData.scrollDelta = scrollDelta;
hoverEventData.position = ScreenCenterPoint;
hoverEventData.pointerCurrentRaycast = result;
hoverEventData.position3DDelta = raycasterPos - hoverEventData.position3D;
hoverEventData.position3D = raycasterPos;
hoverEventData.rotationDelta = Quaternion.Inverse(hoverEventData.rotation) * raycasterRot;
hoverEventData.rotation = raycasterRot;
// copy data to other button event
for (int j = 0, jmax = raycaster.ButtonEventDataList.Count; j < jmax; ++j)
{
var buttonEventData = raycaster.ButtonEventDataList[j];
if (buttonEventData == null || buttonEventData == hoverEventData)
{
continue;
}
buttonEventData.Reset();
buttonEventData.delta = Vector2.zero;
buttonEventData.scrollDelta = scrollDelta;
buttonEventData.position = ScreenCenterPoint;
buttonEventData.pointerCurrentRaycast = result;
buttonEventData.position3DDelta = hoverEventData.position3DDelta;
buttonEventData.position3D = hoverEventData.position3D;
buttonEventData.rotationDelta = hoverEventData.rotationDelta;
buttonEventData.rotation = hoverEventData.rotation;
}
ProcessPress(hoverEventData);
ProcessMove(hoverEventData);
ProcessDrag(hoverEventData);
// other buttons event
for (int j = 1, jmax = raycaster.ButtonEventDataList.Count; j < jmax; ++j)
{
var buttonEventData = raycaster.ButtonEventDataList[j];
if (buttonEventData == null || buttonEventData == hoverEventData)
{
continue;
}
buttonEventData.pointerEnter = hoverEventData.pointerEnter;
ProcessPress(buttonEventData);
ProcessDrag(buttonEventData);
}
// scroll event
if (result.isValid && !Mathf.Approximately(scrollDelta.sqrMagnitude, 0.0f))
{
var scrollHandler = ExecuteEvents.GetEventHandler <IScrollHandler>(result.gameObject);
ExecuteEvents.ExecuteHierarchy(scrollHandler, hoverEventData, ExecuteEvents.scrollHandler);
}
}
if (isActiveAndEnabled)
{
for (var i = processingRaycasters.Count - 1; i >= 0; --i)
{
var r = processingRaycasters[i];
if (!raycasters.Contains(r))
{
CleanUpRaycaster(r);
}
}
}
else
{
for (var i = processingRaycasters.Count - 1; i >= 0; --i)
{
CleanUpRaycaster(processingRaycasters[i]);
}
}
processingRaycasters.Clear();
}
public void IndexerSetter()
{
set[0] = 40;
Assert.AreEqual(40, set[0]);
Assert.IsFalse(set.Contains(10));
AssertItemsOrder();
set[0] = 30;
Assert.AreEqual(30, set[0]);
Assert.AreEqual(40, set[2]);
AssertItemsOrder();
set[0] = 30;
Assert.AreEqual(30, set[0]);
Assert.AreEqual(40, set[2]);
AssertItemsOrder();
}
/// <summary>Builds the csharp code containing the row layout structure.</summary>
/// <param name="layout">The layout to use.</param>
/// <param name="databaseName">The database name (only used for the structure name).</param>
/// <param name="tableName">The table name (only used for the structure name).</param>
/// <param name="className">The name of the class to generate.</param>
/// <param name="nameSpace">The namespace to use for the class (defaults to "Database").</param>
/// <param name="namingStrategy">Naming strategy for classes, properties, structures and fields.</param>
/// <returns>Returns a string containing csharp code.</returns>
public static GenerateTableCodeResult GenerateStruct(this RowLayout layout, string databaseName, string tableName = null, string className = null,
string nameSpace = null, NamingStrategy namingStrategy = NamingStrategy.CamelCase)
{
if (layout == null)
{
throw new ArgumentNullException(nameof(layout));
}
#region GetName()
string[] GetNameParts(string text) => text.ReplaceInvalidChars(ASCII.Strings.Letters + ASCII.Strings.Digits, "_").Split('_').SelectMany(s => s.SplitCamelCase()).ToArray();
string GetName(string text) =>
namingStrategy switch
{
NamingStrategy.CamelCase => GetNameParts(text).JoinCamelCase(),
NamingStrategy.SnakeCase => GetNameParts(text).JoinSnakeCase(),
NamingStrategy.Exact => text,
_ => throw new NotImplementedException($"Unknown NamingStrategy {namingStrategy}.")
};
#endregion
if (nameSpace == null)
{
nameSpace = "Database";
}
if (databaseName == null)
{
throw new ArgumentNullException(nameof(databaseName));
}
if (tableName == null)
{
tableName = layout.Name;
}
var fieldNameLookup = new Dictionary <int, string>();
var idCount = layout.Identifier.Count();
var idFields = (idCount == 0 ? layout : layout.Identifier).ToList();
var code = new StringBuilder();
code.AppendLine("//-----------------------------------------------------------------------");
code.AppendLine("// <summary>");
code.AppendLine("// Autogenerated table class");
code.AppendLine($"// Using {typeof(ITableExtensions).Assembly.FullName}");
code.AppendLine("// </summary>");
code.AppendLine("// <auto-generated />");
code.AppendLine("//-----------------------------------------------------------------------");
code.AppendLine();
code.AppendLine("using System;");
code.AppendLine("using System.Globalization;");
code.AppendLine("using Cave.Data;");
#region Build lookup tables
void BuildLookupTables()
{
var uniqueFieldNames = new IndexedSet <string>();
foreach (var field in layout)
{
var sharpName = GetName(field.Name);
var i = 0;
while (uniqueFieldNames.Contains(sharpName))
{
sharpName = GetName(field.Name) + ++i;
}
uniqueFieldNames.Add(sharpName);
fieldNameLookup[field.Index] = sharpName;
}
}
BuildLookupTables();
#endregion
if (className == null)
{
className = GetName(databaseName) + GetName(tableName) + "Row";
}
code.AppendLine();
code.AppendLine($"namespace {nameSpace}");
code.AppendLine("{");
code.AppendLine($"\t/// <summary>Table structure for {layout.Name}.</summary>");
code.AppendLine($"\t[Table(\"{layout.Name}\")]");
code.AppendLine($"\tpublic partial struct {className} : IEquatable<{className}>");
code.AppendLine("\t{");
#region static Parse()
code.AppendLine($"\t\t/// <summary>Converts the string representation of a row to its {className} equivalent.</summary>");
code.AppendLine("\t\t/// <param name=\"data\">A string that contains a row to convert.</param>");
code.AppendLine($"\t\t/// <returns>A new {className} instance.</returns>");
code.AppendLine($"\t\tpublic static {className} Parse(string data) => Parse(data, CultureInfo.InvariantCulture);");
code.AppendLine();
code.AppendLine($"\t\t/// <summary>Converts the string representation of a row to its {className} equivalent.</summary>");
code.AppendLine("\t\t/// <param name=\"data\">A string that contains a row to convert.</param>");
code.AppendLine("\t\t/// <param name=\"provider\">The format provider (optional).</param>");
code.AppendLine($"\t\t/// <returns>A new {className} instance.</returns>");
code.AppendLine($"\t\tpublic static {className} Parse(string data, IFormatProvider provider) => CsvReader.ParseRow<{className}>(data, provider);");
#endregion
#region Add fields
foreach (var field in layout)
{
code.AppendLine();
code.AppendLine($"\t\t/// <summary>{field} {field.Description}.</summary>");
if (!string.IsNullOrEmpty(field.Description))
{
code.AppendLine($"\t\t[Description(\"{field} {field.Description}\")]");
}
code.Append("\t\t[Field(");
var i = 0;
void AddAttribute <T>(T value, Func <string> content)
{
if (Equals(value, default))
{
return;
}
if (i++ > 0)
{
code.Append(", ");
}
code.Append(content());
}
if (field.Flags != 0)
{
code.Append("Flags = ");
var flagCount = 0;
foreach (var flag in field.Flags.GetFlags())
{
if (flagCount++ > 0)
{
code.Append(" | ");
}
code.Append("FieldFlags.");
code.Append(flag);
}
code.Append(", ");
}
var sharpName = fieldNameLookup[field.Index];
if (sharpName != field.Name)
{
AddAttribute(field.Name, () => $"Name = \"{field.Name}\"");
}
if (field.MaximumLength < int.MaxValue)
{
AddAttribute(field.MaximumLength, () => $"Length = {(int)field.MaximumLength}");
}
AddAttribute(field.AlternativeNames, () => $"AlternativeNames = \"{field.AlternativeNames.Join(", ")}\"");
AddAttribute(field.DisplayFormat, () => $"DisplayFormat = \"{field.DisplayFormat.EscapeUtf8()}\"");
code.AppendLine(")]");
if ((field.DateTimeKind != DateTimeKind.Unspecified) || (field.DateTimeType != DateTimeType.Undefined))
{
code.AppendLine($"\t\t[DateTimeFormat({field.DateTimeKind}, {field.DateTimeType})]");
}
if (field.StringEncoding != 0)
{
code.AppendLine($"\t\t[Cave.IO.StringFormat(Cave.IO.StringEncoding.{field.StringEncoding})]");
}
code.AppendLine($"\t\tpublic {field.DotNetTypeName} {sharpName};");
}
#endregion
#region ToString()
{
code.AppendLine();
code.AppendLine("\t\t/// <summary>Gets a string representation of this row.</summary>");
code.AppendLine("\t\t/// <returns>Returns a string that can be parsed by <see cref=\"Parse(string)\"/>.</returns>");
code.AppendLine("\t\tpublic override string ToString() => ToString(CultureInfo.InvariantCulture);");
code.AppendLine();
code.AppendLine("\t\t/// <summary>Gets a string representation of this row.</summary>");
code.AppendLine("\t\t/// <returns>Returns a string that can be parsed by <see cref=\"Parse(string, IFormatProvider)\"/>.</returns>");
code.AppendLine("\t\tpublic string ToString(IFormatProvider provider) => CsvWriter.RowToString(this, provider);");
}
#endregion
#region GetHashCode()
{
code.AppendLine();
if (idCount == 1)
{
var idField = layout.Identifier.First();
var idFieldName = fieldNameLookup[idField.Index];
code.AppendLine($"\t\t/// <summary>Gets the hash code for the identifier of this row (field {idFieldName}).</summary>");
code.AppendLine("\t\t/// <returns>A hash code for the identifier of this row.</returns>");
code.Append("\t\tpublic override int GetHashCode() => ");
code.Append(idFieldName);
code.AppendLine(".GetHashCode();");
}
else
{
if (idCount == 0)
{
code.AppendLine("\t\t/// <summary>Gets the hash code based on all values of this row (no identififer defined).</summary>");
}
else
{
var names = idFields.Select(field => fieldNameLookup[field.Index]).Join(", ");
code.AppendLine($"\t\t/// <summary>Gets the hash code for the identifier of this row (fields {names}).</summary>");
}
code.AppendLine("\t\t/// <returns>A hash code for the identifier of this row.</returns>");
code.AppendLine("\t\tpublic override int GetHashCode() =>");
var first = true;
foreach (var idField in idFields)
{
if (first)
{
first = false;
}
else
{
code.AppendLine(" ^");
}
code.Append($"\t\t\t{fieldNameLookup[idField.Index]}.GetHashCode()");
}
code.AppendLine(";");
}
}
#endregion
#region Equals()
{
code.AppendLine();
code.AppendLine("\t\t/// <inheritdoc/>");
code.AppendLine($"\t\tpublic override bool Equals(object other) => other is {className} row && Equals(row);");
code.AppendLine();
code.AppendLine("\t\t/// <inheritdoc/>");
code.AppendLine($"\t\tpublic bool Equals({className} other)");
code.AppendLine("\t\t{");
code.AppendLine("\t\t\treturn");
{
var first = true;
foreach (var field in layout)
{
if (first)
{
first = false;
}
else
{
code.AppendLine(" &&");
}
var name = fieldNameLookup[field.Index];
code.Append($"\t\t\t\tEquals(other.{name}, {name})");
}
code.AppendLine(";");
}
code.AppendLine("\t\t}");
}
#endregion
code.AppendLine("\t}");
code.AppendLine("}");
code.Replace("\t", " ");
return(new()
{
ClassName = className,
TableName = tableName,
DatabaseName = databaseName,
Code = code.ToString()
});
}
public static IndexedSet <Coord> Perimeter(this Radius r, Coord center, int radiusLength, bool surpassEdges, int width, int height)
{
IndexedSet <Coord> rim = new IndexedSet <Coord>();
if (!surpassEdges && (center.X < 0 || center.X >= width || center.Y < 0 || center.Y > height))
{
return(rim);
}
if (radiusLength < 1)
{
rim.Add(center);
return(rim);
}
switch (r)
{
case SquidGrid.Radius.Square:
case SquidGrid.Radius.Cube: {
for (int i = center.X - radiusLength; i <= center.X + radiusLength; i++)
{
int x = i;
if (!surpassEdges)
{
x = Clamp(i, 0, width);
}
rim.Add(Coord.Get(x, Clamp(center.Y - radiusLength, 0, height)));
rim.Add(Coord.Get(x, Clamp(center.Y + radiusLength, 0, height)));
}
for (int j = center.Y - radiusLength; j <= center.Y + radiusLength; j++)
{
int y = j;
if (!surpassEdges)
{
y = Clamp(j, 0, height);
}
rim.Add(Coord.Get(Clamp(center.X - radiusLength, 0, height), y));
rim.Add(Coord.Get(Clamp(center.X + radiusLength, 0, height), y));
}
}
break;
case SquidGrid.Radius.Diamond:
case SquidGrid.Radius.Octahedron: {
int xUp = center.X + radiusLength, xDown = center.X - radiusLength,
yUp = center.Y + radiusLength, yDown = center.Y - radiusLength;
if (!surpassEdges)
{
xDown = Clamp(xDown, 0, width);
xUp = Clamp(xUp, 0, width);
yDown = Clamp(yDown, 0, height);
yUp = Clamp(yUp, 0, height);
}
rim.Add(Coord.Get(xDown, center.Y));
rim.Add(Coord.Get(xUp, center.Y));
rim.Add(Coord.Get(center.X, yDown));
rim.Add(Coord.Get(center.X, yUp));
for (int i = xDown + 1, c = 1; i < center.X; i++, c++)
{
int x = i;
if (!surpassEdges)
{
x = Clamp(i, 0, width);
}
rim.Add(Coord.Get(x, Clamp(center.Y - c, 0, height)));
rim.Add(Coord.Get(x, Clamp(center.Y + c, 0, height)));
}
for (int i = center.X + 1, c = 1; i < center.X + radiusLength; i++, c++)
{
int x = i;
if (!surpassEdges)
{
x = Clamp(i, 0, width);
}
rim.Add(Coord.Get(x, Clamp(center.Y + radiusLength - c, 0, height)));
rim.Add(Coord.Get(x, Clamp(center.Y - radiusLength + c, 0, height)));
}
}
break;
default: {
double theta;
int x, y, denom = 1;
bool anySuccesses;
while (denom <= 256)
{
anySuccesses = false;
for (int i = 1; i <= denom; i += 2)
{
theta = i * (pi2 / denom);
x = (int)(Math.Cos(theta) * (radiusLength + 0.25)) + center.X;
y = (int)(Math.Sin(theta) * (radiusLength + 0.25)) + center.Y;
if (!surpassEdges)
{
x = Clamp(x, 0, width);
y = Clamp(y, 0, height);
}
Coord p = Coord.Get(x, y);
bool test = !rim.Contains(p);
rim.Add(p);
anySuccesses = test || anySuccesses;
}
if (!anySuccesses)
{
break;
}
denom *= 2;
}
break;
}
}
return(rim);
}
public bool Contains(int indexID)
{
return(mIndexedSet.Contains(indexID));
}
