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);