public override double DistanceTo(IRelevantObject relevantObject)
{
if (!(relevantObject is RelevantPoint relevantPoint))
{
return(double.PositiveInfinity);
}
return(Vector2.Distance(Child, relevantPoint.Child));
}
public override double DistanceTo(IRelevantObject relevantObject)
{
if (!(relevantObject is RelevantCircle relevantCircle))
{
return(double.PositiveInfinity);
}
return(Vector2.Distance(Child.Centre, relevantCircle.Child.Centre) +
Math.Abs(Child.Radius - relevantCircle.Child.Radius));
}
public void Add(IRelevantObject relevantObject, bool propagate = true)
{
// Don't add if this layer is over the max
if (Objects.GetCount() > ParentCollection.MaxObjects)
{
relevantObject.Dispose();
return;
}
var previousCollection = GetAllPreviousLayersCollection();
if (Objects.FindSimilar(relevantObject, ParentCollection.AcceptableDifference, out var similarObject))
{
// Consume object
similarObject.Consume(relevantObject);
// Dispose this relevant object
relevantObject.Dispose();
// Set DoNotDispose for the GenerateNewObjects method
if (!similarObject.DoNotDispose && !similarObject.DefinitelyDispose && previousCollection.FindSimilar(similarObject, ParentCollection.AcceptableDifference, out _))
{
similarObject.DefinitelyDispose = true;
}
else
{
similarObject.DoNotDispose = true;
}
return; // return so the relevant object doesn't get added
}
if (previousCollection != null && previousCollection.FindSimilar(relevantObject, ParentCollection.AcceptableDifference, out _))
{
// Don't consume because that causes inheritance issues
// Dispose this relevant object
relevantObject.Dispose();
return; // return so the relevant object doesn't get added
}
// Set DoNotDispose for the GenerateNewObjects method
relevantObject.DoNotDispose = true;
// Insert the new object
Objects.SortedInsert(relevantObject);
// Set layer variable in object
relevantObject.Layer = this;
// Propagate changes
if (!propagate || NextLayer == null)
{
return;
}
NextLayer.GenerateNewObjects();
}
public override double DistanceTo(IRelevantObject relevantObject)
{
if (!(relevantObject is RelevantLine relevantLine))
{
return(double.PositiveInfinity);
}
var cosAlpha = Vector2.Dot(Child.DirectionVector, relevantLine.Child.DirectionVector) /
(Child.DirectionVector.Length * relevantLine.Child.DirectionVector.Length);
// This is the length of the opposite side in a right triangle with an adjacent side length of 100
var angleDiff = Math.Sqrt(10000 / (cosAlpha * cosAlpha) - 10000);
return(Line2.Distance(Child, relevantLine.Child.PositionVector) + angleDiff);
}
public override bool Intersection(IRelevantObject other, out Vector2[] intersections)
{
intersections = new[] { Child };
switch (other)
{
case RelevantPoint point:
return(Precision.AlmostEquals(point.Child.X, Child.X) & Precision.AlmostEquals(point.Child.Y, Child.Y));
case RelevantLine line:
return(Precision.AlmostEquals(Line2.Distance(line.Child, Child), 0));
case RelevantCircle circle:
return(Precision.AlmostEquals(Vector2.Distance(circle.Child.Centre, Child), circle.Child.Radius));
default:
return(false);
}
}
public override bool Intersection(IRelevantObject other, out Vector2[] intersections)
{
switch (other)
{
case RelevantPoint point:
intersections = new[] { point.Child };
return(Precision.AlmostEquals(Vector2.Distance(Child.Centre, point.Child), Child.Radius));
case RelevantLine line:
return(Circle.Intersection(Child, line.Child, out intersections));
case RelevantCircle circle:
return(Circle.Intersection(Child, circle.Child, out intersections));
default:
intersections = new Vector2[0];
return(false);
}
}
public void Remove(IRelevantObject relevantObject, bool propagate = true)
{
// Remove relevant object from this layer
Objects.RemoveRelevantObject(relevantObject);
if (!propagate)
{
return;
}
// Return if there are no children
if (relevantObject.ChildObjects == null)
{
return;
}
// Kill all children
foreach (var relevantObjectChildObject in relevantObject.ChildObjects)
{
relevantObjectChildObject.Layer?.Remove(relevantObjectChildObject);
}
}
public override bool Intersection(IRelevantObject other, out Vector2[] intersections)
{
switch (other)
{
case RelevantPoint point:
intersections = new[] { point.Child };
return(Precision.AlmostEquals(Line2.Distance(Child, point.Child), 0));
case RelevantLine line: {
bool isIntersecting = Line2.Intersection(Child, line.Child, out var intersection);
intersections = new[] { intersection };
return(isIntersecting);
}
case RelevantCircle circle:
return(Circle.Intersection(circle.Child, Child, out intersections));
default:
intersections = new Vector2[0];
return(false);
}
}
public static IEnumerable <IRelevantObject[]> GeneratePairsSequential(Type[] dependencies,
RelevantObjectCollection.RelevantObjectCollection collection)
{
// Handle special case
if (collection == null || dependencies.Length == 0)
{
return(new[] { new IRelevantObject[0] });
}
var sortedObjects = collection.GetSortedSubset(new HashSet <Type>(dependencies));
var combinations = new List <IRelevantObject[]>();
var i = 0;
var firstIndex = 0;
var indicesFound = new List <int>();
var combination = new IRelevantObject[dependencies.Length];
while (i < sortedObjects.Count)
{
var obj = sortedObjects[i];
// Ignore the uninheritable objects
if (!obj.IsInheritable)
{
i++;
continue;
}
var type = obj.GetType();
var indexOfType = -1;
for (var j = 0; j < dependencies.Length; j++)
{
if (indicesFound.Contains(j) || type != dependencies[j])
{
continue;
}
indexOfType = j;
indicesFound.Add(j);
break;
}
if (indexOfType != -1)
{
if (indicesFound.Count == 1)
{
firstIndex = i;
combination = new IRelevantObject[dependencies.Length];
}
combination[indexOfType] = obj;
if (indicesFound.Count == dependencies.Length)
{
combinations.Add(combination);
indicesFound.Clear();
i = firstIndex;
}
}
i++;
}
return(combinations);
}
public bool Check(IRelevantObject relevantObject, RelevantObjectsGenerator generator)
{
return(Predicates.Count == 0 || Predicates.Any(o => o.Check(relevantObject, generator)));
}
public abstract bool Intersection(IRelevantObject other, out Vector2[] intersections);
