예제 #1
0
        public void CalculateIntersections4RectangleNoIntersectionTest()
        {
            var rectangles = new List <Rectangle>()
            {
                new Rectangle()
                {
                    X = 10, Y = 10, Width = 10, Height = 10
                },
                new Rectangle()
                {
                    X = 100, Y = 100, Width = 10, Height = 10
                },
                new Rectangle()
                {
                    X = 1000, Y = 1000, Width = 10, Height = 10
                },
                new Rectangle()
                {
                    X = 10000, Y = 10000, Width = 10, Height = 10
                },
            };

            var expectedResult = new List <RectangleIntersection>();
            var result         = IntersectionCalculator.CalculateIntersections(rectangles);

            Assert.AreEqual(expectedResult, result);
        }
예제 #2
0
        public void CalculateIntersections10EqualRectanglesTest()
        {
            var rectangles = new List <Rectangle>()
            {
                new Rectangle()
                {
                    X = 100, Y = 101, Width = 250, Height = 80
                },
                new Rectangle()
                {
                    X = 100, Y = 101, Width = 250, Height = 80
                },
                new Rectangle()
                {
                    X = 100, Y = 101, Width = 250, Height = 80
                },
                new Rectangle()
                {
                    X = 100, Y = 101, Width = 250, Height = 80
                },
                new Rectangle()
                {
                    X = 100, Y = 101, Width = 250, Height = 80
                },
                new Rectangle()
                {
                    X = 100, Y = 101, Width = 250, Height = 80
                },
                new Rectangle()
                {
                    X = 100, Y = 101, Width = 250, Height = 80
                },
                new Rectangle()
                {
                    X = 100, Y = 101, Width = 250, Height = 80
                },
                new Rectangle()
                {
                    X = 100, Y = 101, Width = 250, Height = 80
                },
                new Rectangle()
                {
                    X = 100, Y = 101, Width = 250, Height = 80
                }
            };

            var expectedCount = 1013;

            var result = IntersectionCalculator.CalculateIntersections(rectangles);

            Assert.AreEqual(result.Count, expectedCount);

            for (int i = 0; i < expectedCount; i++)
            {
                Assert.AreEqual(result[i].Intersection.X, 100);
                Assert.AreEqual(result[i].Intersection.Y, 101);
                Assert.AreEqual(result[i].Intersection.Width, 250);
                Assert.AreEqual(result[i].Intersection.Height, 80);
            }
        }
예제 #3
0
        public void CalculateIntersections0RectangleTest()
        {
            var rectangles = new List <Rectangle>();

            var expectedResult = new List <RectangleIntersection>();
            var result         = IntersectionCalculator.CalculateIntersections(rectangles);

            Assert.AreEqual(expectedResult, result);
        }
예제 #4
0
    private void UpdateOrbit()
    {
        if (DeltaVelocity.magnitude < minimumDeltaVelocity)
        {
            return;
        }

        if (trajectoryObjectPrefab == null)
        {
            Debug.Log("No trajectory object prefab selected!");
            return;
        }

        if (trajectoryObject == null)
        {
            // Instantiate prefab if null
            trajectoryObject  = Instantiate(trajectoryObjectPrefab);
            trajectoryPlotter = trajectoryObject.GetComponent <TrajectoryPlotter>();

            // Pass ship to intersection calculator
            intersectionCalculator = trajectoryObject.GetComponent <IntersectionCalculator>();
            //intersectionCalculator.SetOrbitalBody(ship);
        }
        trajectoryObject.transform.parent   = ship.CurrentGravitySource.transform;
        trajectoryObject.transform.position = trajectoryObject.transform.parent.position;

        // Specifically velocity in world coordinates!
        Vector2 newOrbitalVelocity = orbitalSpeed * orbitalDirection + DeltaVelocity;
        Vector2 relVel             = newOrbitalVelocity.RotateVector(ship.Trajectory.ArgumentOfPeriapsis);
        Vector2 relPos             = (Vector2)transform.position - ship.CurrentGravitySource.Position; // world pos - newSource.pos

        trajectory.CalculateOrbitalParametersFromStateVectors(relPos, relVel, ship.CurrentGravitySource);
        if (trajectory.TrajectoryType == Mechanics.Globals.TrajectoryType.Ellipse)
        {
            trajectoryPlotter.BuildEllipticalTrajectory(trajectory.SemimajorAxis, trajectory.SemiminorAxis, trajectory.Eccentricity, trajectory.ArgumentOfPeriapsis);
        }
        else
        {
            trajectoryPlotter.BuildHyperbolicTrajectory(trajectory.SemimajorAxis, trajectory.SemiminorAxis, trajectory.Eccentricity, trajectory.ArgumentOfPeriapsis);
        }
        float timeToNode = OrbitalMechanics.UniversalVariableMethod.CalculateTimeOfFlight(ship.OrbitalPosition, ship.OrbitalVelocity, orbitalPosition, ship.Trajectory.EccentricityVector, ship.Trajectory.ParentGravitySource.Mass);

        UpdateIntersections(timeToNode, relPos, relVel);
    }
예제 #5
0
        public void CalculateIntersections4EqualRectanglesTest()
        {
            var rectangles = new List <Rectangle>()
            {
                new Rectangle()
                {
                    X = 100, Y = 100, Width = 250, Height = 80
                },
                new Rectangle()
                {
                    X = 100, Y = 100, Width = 250, Height = 80
                },
                new Rectangle()
                {
                    X = 100, Y = 100, Width = 250, Height = 80
                },
                new Rectangle()
                {
                    X = 100, Y = 100, Width = 250, Height = 80
                }
            };

            var expectedResult = new List <RectangleIntersection>()
            {
                new RectangleIntersection()
                {
                    RectangleIndexes = new List <int>()
                    {
                        1, 2
                    },
                    Intersection = new Rectangle()
                    {
                        X = 100, Y = 100, Width = 250, Height = 80
                    }
                },
                new RectangleIntersection()
                {
                    RectangleIndexes = new List <int>()
                    {
                        1, 3
                    },
                    Intersection = new Rectangle()
                    {
                        X = 100, Y = 100, Width = 250, Height = 80
                    }
                },
                new RectangleIntersection()
                {
                    RectangleIndexes = new List <int>()
                    {
                        1, 4
                    },
                    Intersection = new Rectangle()
                    {
                        X = 100, Y = 100, Width = 250, Height = 80
                    }
                },
                new RectangleIntersection()
                {
                    RectangleIndexes = new List <int>()
                    {
                        2, 3
                    },
                    Intersection = new Rectangle()
                    {
                        X = 100, Y = 100, Width = 250, Height = 80
                    }
                },
                new RectangleIntersection()
                {
                    RectangleIndexes = new List <int>()
                    {
                        2, 4
                    },
                    Intersection = new Rectangle()
                    {
                        X = 100, Y = 100, Width = 250, Height = 80
                    }
                },
                new RectangleIntersection()
                {
                    RectangleIndexes = new List <int>()
                    {
                        1, 2, 3
                    },
                    Intersection = new Rectangle()
                    {
                        X = 100, Y = 100, Width = 250, Height = 80
                    }
                },
                new RectangleIntersection()
                {
                    RectangleIndexes = new List <int>()
                    {
                        1, 2, 4
                    },
                    Intersection = new Rectangle()
                    {
                        X = 100, Y = 100, Width = 250, Height = 80
                    }
                },
                new RectangleIntersection()
                {
                    RectangleIndexes = new List <int>()
                    {
                        3, 4
                    },
                    Intersection = new Rectangle()
                    {
                        X = 100, Y = 100, Width = 250, Height = 80
                    }
                },
                new RectangleIntersection()
                {
                    RectangleIndexes = new List <int>()
                    {
                        1, 3, 4
                    },
                    Intersection = new Rectangle()
                    {
                        X = 100, Y = 100, Width = 250, Height = 80
                    }
                },
                new RectangleIntersection()
                {
                    RectangleIndexes = new List <int>()
                    {
                        2, 3, 4
                    },
                    Intersection = new Rectangle()
                    {
                        X = 100, Y = 100, Width = 250, Height = 80
                    }
                },
                new RectangleIntersection()
                {
                    RectangleIndexes = new List <int>()
                    {
                        1, 2, 3, 4
                    },
                    Intersection = new Rectangle()
                    {
                        X = 100, Y = 100, Width = 250, Height = 80
                    }
                },
            };

            var result = IntersectionCalculator.CalculateIntersections(rectangles);

            Assert.AreEqual(expectedResult.Count, result.Count);

            for (int i = 0; i < expectedResult.Count; i++)
            {
                Assert.AreEqual(IsEqual(expectedResult[i], result[i]), true);
            }
        }