public static Facing ToFacing(this Angle heading,  Vector relativePosition)
        {
            var azimuth = Math.Atan2(relativePosition.Y, relativePosition.X);
            var relativeAzimuth = azimuth - heading.Value;
            relativeAzimuth = Angle.ReduceAngle(relativeAzimuth);

            Facing facing = Facing.None;

            // err on the side of gnerosity and consider all edge cases in both facings
            if (relativeAzimuth >= -PiOnFour && relativeAzimuth <= PiOnFour)
            {
                facing =  facing | Facing.Bow;
            }
            if (relativeAzimuth <= -PiOnFour && relativeAzimuth >= -3 * PiOnFour)
            {
                facing = facing | Facing.Starboard;
            }
            if (relativeAzimuth >= PiOnFour && relativeAzimuth <= 3 * PiOnFour)
            {
                facing = facing | Facing.Port;
            }
            if (relativeAzimuth >= 3* PiOnFour || relativeAzimuth <= -3 * PiOnFour)
            {
                facing = facing | Facing.Stern;
            }

            return facing;
        }
 /// <summary>
 /// Time based constant velocity linear motion
 /// </summary>
 /// <param name="startTime">The begining time of this motion</param>
 /// <param name="velocity">The velocity per second or 1000 time units</param>
 /// <param name="initialPosition">The starting point of the line</param>
 public LinearMotion(ulong startTime, Vector velocity, Vector initialPosition)
 {
     // the starting time for this set of motion
     m_StartTime = startTime;
     // the velocity per second or 1000 time units
     m_Velocity = velocity;
     m_InitialPosition = initialPosition;
 }
        public bool IntersectsPoint(Vector worldPosition, ulong time)
        {
            IMotion motion = m_Path.GetCurrentMotion(time);

            var objectPosition = motion.GetCurrentPosition(time);

            return m_Bounds.Contains(worldPosition, objectPosition);
        }
Esempio n. 4
0
        public bool Contains(Vector positionOne, Vector positionTwo)
        {
            var relativePosition = positionOne - positionTwo;

            return relativePosition.X >= TopLeft.X
                   && relativePosition.X <= BottomRight.X
                   && relativePosition.Y >= BottomRight.Y
                   && relativePosition.Y <= TopLeft.Y;
        }
        public void Test_Get_Motion_Initial_North()
        {
            var motion = new CircularMotion(0, 1, new Angle(0), new Angle(0), 1, Vector.Zero);
            Vector velocity = new Vector(0, 0);
            Vector motionVelocity = motion.GetMotion(0);

            Assert.AreEqual(velocity.X, motionVelocity.X, 0.000000000001);
            Assert.AreEqual(velocity.Y, motionVelocity.Y, 0.000000000001);
        }
        public void Test_Get_Motion_Initial_South_Clockwise()
        {
            var motion = new CircularMotion(0, 0, new Angle(0), new Angle(-Math.PI), 1, Vector.Zero);
            Vector velocity = new Vector(0, 0);
            Vector motionVelocity = motion.GetMotion(2000);

            Assert.AreEqual(velocity.X, motionVelocity.X, 0.000000000001);
            Assert.AreEqual(velocity.Y, motionVelocity.Y, 0.000000000001);
        }
        public void ConvertToAndFromVector3()
        {
            var vector = new Vector(5.7, 6.6);

            var vector3 = VectorConversions.ToOgreVector(vector);

            var returnedVector = VectorConversions.FromOgreVector(vector3);

            Assert.AreEqual(vector, returnedVector);
        }
Esempio n. 8
0
        public List<IMotion> CreatePathTo(Vector destination, Vector initialVelocity, Vector initialPosition, ulong startTime)
        {
            // get initial velocity
            //determine turning circles
            Vector circleOnePosition, circleTwoPosition;

            double circleRadius = CalcRadius(initialVelocity.Length, m_Acceleration);

            DetermineTurningCircles(initialVelocity, circleRadius, out circleOnePosition, out circleTwoPosition);

            //select a turning circle

            Vector destinationRelativeToInitialPosition = destination - initialPosition;

            Vector selectedTuringCicle = SelectTuriningCircle(circleOnePosition, circleTwoPosition, destinationRelativeToInitialPosition, circleRadius);

            //determine turn direction
            TurnDirection turnDirection = DetermineTurnDirection(initialVelocity, selectedTuringCicle);

            //determine turn end
            Angle turnStart = new Angle(-selectedTuringCicle);
            // zero the destination around the turning circle
            var destinationRelativeToTurningCircle = destination - (initialPosition + selectedTuringCicle);

            //use the relative destination to pick an end point for the turn
            Angle turnEnd = DetermineTurnEnd(destinationRelativeToTurningCircle, circleRadius, turnDirection);

            Angle turnRate = DetermineTurnRate(initialVelocity.Length, circleRadius, turnDirection);

            var turnDuration = DetermineDurationOfTurn(turnStart, turnEnd, turnRate, turnDirection);
            turnDuration += startTime;
            // create circular motion

            var circle = new CircularMotion(startTime, circleRadius, turnStart, turnRate, initialVelocity.Length, initialPosition);

            Vector startOfLine = initialPosition + selectedTuringCicle + CoordinateConversions.RadialToVector(turnEnd, circleRadius);
            //Vector startOfLine = circle.GetCurrentPosition(turnDuration);
            // create linear motion

            var velocity = (destination - startOfLine);
            ulong destinationTime = (ulong)((velocity.Length / initialVelocity.Length) * 1000.0);
            velocity = velocity.Normalise();
            velocity = velocity * initialVelocity.Length;
            var linear = new LinearMotion(turnDuration, velocity, startOfLine);
            var linear2 = new LinearMotion(turnDuration + destinationTime, velocity, destination);

            //Assert.AreEqual(circle.GetVelocity(turnDuration), linear.GetVelocity(turnDuration));
            List<IMotion> path = new List<IMotion>
            {
                circle,
                linear,
                linear2,
            };
            return path;
        }
        /// <summary>
        /// primary constructor for circular motion objects
        /// </summary>
        /// <param name="startTime">The begining time for the motion</param>
        /// <param name="radius">The radius of the turning circle</param>
        /// <param name="startAngle">The angle to the start point on the circle</param>
        /// <param name="turnRate">The turn rate in radians</param>
        /// <param name="initialSpeed">Speed used to determine the current velocity</param>
        /// <param name="initialPosition">The position when this motion started</param>
        public CircularMotion(ulong startTime, double radius, Angle startAngle, Angle turnRate, double initialSpeed, Vector initialPosition)
        {
            m_StartTime = startTime;
            m_Radius = radius;
            m_StartAngle = startAngle;
            m_TurnRate = turnRate;
            m_InitialSpeed = initialSpeed;

            m_CircleOffset = CoordinateConversions.RadialToVector(startAngle, m_Radius);
            m_InitialPosition = initialPosition;
        }
 public IList<SelectableObject> GetObjectAt(Vector worldPosition, ulong time)
 {
     var selected = new List<SelectableObject>();
     foreach (var selectableObject in m_Objects)
     {
         if (selectableObject.IntersectsPoint(worldPosition, time))
         {
             selected.Add(selectableObject);
         }
     }
     return selected;
 }
        public void ClearsOldSelectedObject()
        {
            var message = new SelectObjectAtMessage(m_Position, m_TestTime);

            var newPosition = new Vector(50, 5);

            var secondObject = CreateSelectableObjectAt(newPosition);
            m_Repository.AddObject(secondObject);
            m_Repository.OnSelectObject(message);

            m_Bus.DidNotReceive().Send(Arg.Any<DeselectedObjectMessage>());

            m_Repository.OnSelectObject(new SelectObjectAtMessage(newPosition, m_TestTime));

            m_Bus.Received().Send(Arg.Any<DeselectedObjectMessage>());
        }
        public void CreateTurningCirclesBasicPositiveY()
        {
            var path = new Path();
            Vector initialVelocity = new Vector(0, 1);
            double acceleration = 1;
            Vector circleOne;
            Vector circleTwo;
            path.DetermineTurningCircles(initialVelocity, acceleration, out circleOne, out circleTwo);

            var circleOneResultShouldBe = new Vector(-1, 0);
            var circleTwoResultShouldBe = new Vector(1, 0);

            Assert.AreEqual(circleOneResultShouldBe.X, circleOne.X, 0.000000001);
            Assert.AreEqual(circleOneResultShouldBe.Y, circleOne.Y, 0.000000001);
            Assert.AreEqual(circleTwoResultShouldBe.X, circleTwo.X, 0.000000001);
            Assert.AreEqual(circleTwoResultShouldBe.Y, circleTwo.Y, 0.000000001);
        }
        public OverlayScene(Vector screenSize)
        {
            m_ScreenSize = screenSize;

            //note we need to load a font if we want to use a font
            var font = FontManager.Singleton.Create("Arial", ResourceGroupManager.DEFAULT_RESOURCE_GROUP_NAME);
            font.SetParameter("type", "truetype");
            font.SetParameter("source", "Arial.ttf");
            font.SetParameter("size", "16");
            font.SetParameter("resolution", "96");
            font.Load();
            m_Container = (OverlayContainer)OverlayManager.Singleton.CreateOverlayElement("Panel", "PanelName");

            //note positions and sizes are in relative screen space
            m_Container.SetPosition(0.35, 0.3);
            m_Container.SetDimensions(0.3, 0.5);
            m_Container.MaterialName = "triangle/red";

            m_Overlay = OverlayManager.Singleton.Create("bob");

            m_Overlay.Add2D(m_Container);

            m_Overlay.Show();
        }
 public HighlightTargetMessage(Vector worldPosition, ulong time)
 {
     WorldPosition = worldPosition;
     Time = time;
 }
        public void SetUp()
        {
            m_Bus = Substitute.For<IBus>();
            m_Id = new PlayerId();
            m_VesselRepo = Substitute.For<IVesselRepository>();

            m_Repository = new SelectableObjectRepository(m_Bus, m_Id, m_VesselRepo);

            m_Position = new Vector(5, 7);
            m_TestTime = 500;

            m_SelectableObject = CreateSelectableObjectAt(m_Position);

            m_Repository.AddObject(m_SelectableObject);
        }
        private SelectableObject CreateSelectableObjectAt(Vector position)
        {
            var path = Get<IPath>();
            var motion = Get<IMotion>();

            motion.GetCurrentPosition(m_TestTime).Returns(position);
            path.GetCurrentMotion(m_TestTime).Returns(motion);
            return new SelectableObject("fred", path);
        }
Esempio n. 17
0
        /// <summary>
        /// Select the closest turning circle to the desitnation unless the closest circle is within the 
        /// radius of the turning circle.
        /// All positions need to be in the same reference frame
        /// </summary>
        /// <param name="circleCentreOne"></param>
        /// <param name="circleCentreTwo"></param>
        /// <param name="targetPosition">The destination</param>
        /// <param name="turningRadius">The radius of the circles</param>
        /// <returns></returns>
        public Vector SelectTuriningCircle(Vector circleCentreOne, Vector circleCentreTwo, Vector targetPosition, double turningRadius)
        {
            double displacementOne = (circleCentreOne - targetPosition).Length;
            double displacementTwo = (circleCentreTwo - targetPosition).Length;

            Vector selectedCircle;

            if (displacementOne < displacementTwo && displacementOne >= turningRadius)
            {
                selectedCircle = circleCentreOne;
            }
            else
            {
                selectedCircle = displacementTwo < turningRadius ? circleCentreOne : circleCentreTwo;
            }

            return selectedCircle;
        }
Esempio n. 18
0
        /// <summary>
        /// Determines the positions of the two possible turning circles 
        /// Relative to the initial position which is not passed into the function
        /// </summary>
        /// <param name="initialVelocity">The current velocity of the object</param>
        /// <param name="radius">The desired radius of the object</param>
        /// <param name="circleOne">The first of the two possible turning circles</param>
        /// <param name="circleTwo">The second of the two possible turning circles</param>
        public void DetermineTurningCircles(Vector initialVelocity, double radius, out Vector circleOne, out Vector circleTwo)
        {
            Angle velocityAngle;

            // calculate the angle of the current velocity
            velocityAngle = new Angle(initialVelocity);
            velocityAngle.ReduceAngle();

            //double vesselSpeed = initialVelocity.Length;
            // calculate the radius if the turning circle based on the acceleration and current speed
            //double radius = CalcRadius(vesselSpeed, acceleration);

            // calcualte both of the turning circles
            Angle angleOne = new Angle(velocityAngle.Value + (Math.PI / 2));
            circleOne = CoordinateConversions.RadialToVector(angleOne, radius);

            Angle angleTwo = new Angle(velocityAngle.Value - (Math.PI / 2));
            circleTwo = CoordinateConversions.RadialToVector(angleTwo, radius);
        }
 public static Vector3 ToOgreVector(Vector vector)
 {
     return new Vector3(vector.X, 0.0, vector.Y);
 }
        public void CreateTurningCirclesOnAngle()
        {
            var path = new Path();
            Vector initialVelocity = new Vector(3, 4);
            double acceleration = 5;
            Vector circleOne;
            Vector circleTwo;
            path.DetermineTurningCircles(initialVelocity, acceleration, out circleOne, out circleTwo);

            var circleOneResultShouldBe = new Vector(-4, 3);
            var circleTwoResultShouldBe = new Vector(4, -3);

            Assert.AreEqual(circleOneResultShouldBe.X, circleOne.X, 0.000000001);
            Assert.AreEqual(circleOneResultShouldBe.Y, circleOne.Y, 0.000000001);
            Assert.AreEqual(circleTwoResultShouldBe.X, circleTwo.X, 0.000000001);
            Assert.AreEqual(circleTwoResultShouldBe.Y, circleTwo.Y, 0.000000001);
        }
Esempio n. 21
0
 /// <summary>
 /// A box around 0,0 with X being the horizontal 
 /// And Y being the vertiacal
 /// </summary>
 /// <param name="x">the width of the box</param>
 /// <param name="y">the height of the box</param>
 public Box(double x, double y)
 {
     const double two = 2.0;
     m_TopLeftCorner = new Vector(-x / two, y / two);
     m_BottomRightCorner = new Vector(x / two, -y / two);
 }
 public SetPathToTargetMessage(Vector worldPosition, ulong time)
 {
     WorldPosition = worldPosition;
     Time = time;
 }
        private Vector FromWinScreenToWorldPosition(IntPtr hwnd, IntPtr param)
        {
            RECT rect;

            // unpack x and y from the param
            double x = unchecked((short)(long)param);
            double y = unchecked((short)((long)param >> 16));

            Vector worldPos = Vector.Zero;

            // get the size of the screen so we can tell how big we are.
            // this could be cahced in the future if we wanted to
            // should be done if we need the performance
            if(GetWindowRect( hwnd, out rect))
            {
                double width = rect.Right - rect.Left;
                double height = rect.Bottom - rect.Top;

                //convert the positions to relative to top left corner. top left 0,0 bottom right 1,1
                double relx = x/ width;
                double rely = y / height;

                double cameraWidth = m_Camera.OrthoWindowWidth;
                double cameraHeight = m_Camera.OrthoWindowHeight;

                //calc a corner for the camera.
                //should be top left corner
                Vector3 cornerPosition = m_Camera.Position - new Vector3(cameraWidth / 2.0, 0, cameraHeight / 2.0);

                //camera coordinates decrease as the go down so subtract the z value
                Vector3 inputPosition = new Vector3( relx * cameraWidth, 0 ,(1 -  rely) * cameraHeight);

                Vector3 worldVector = cornerPosition + inputPosition;

                worldPos = new Vector(worldVector.z, worldVector.x);
            }

            return worldPos;
        }
Esempio n. 24
0
        /// <summary>
        /// Determines if a turn is clockwise or anti clockwise
        /// </summary>
        /// <param name="velocity">The current velocity of the object</param>
        /// <param name="turiningCircleOffset">The position of the turning circle relative to the initial position</param>
        /// <returns>Clockwise or anti clockwise</returns>
        public TurnDirection DetermineTurnDirection(Vector velocity, Vector turiningCircleOffset)
        {
            int velocityFacing = Angle.FacingNumber(velocity);
            int offsetFacing = Angle.FacingNumber(turiningCircleOffset);

            TurnDirection turnDirection = TurnDirection.Unknown;

            if ((velocityFacing == (offsetFacing + 3)) || (velocityFacing == (offsetFacing - 1)))
            {
                turnDirection = TurnDirection.AntiClockwise;
            }
            else if ((velocityFacing == (offsetFacing - 3)) || (velocityFacing == (offsetFacing + 1)))
            {
                turnDirection = TurnDirection.Clockwise;
            }

            return turnDirection;
        }
Esempio n. 25
0
        /// <summary>
        /// 
        /// </summary>
        /// <param name="destination">The position of the destination relative to the turning point</param>
        /// <param name="radius">The radius of the turning circle</param>
        /// <param name="turnDirection">If the turn is clockwise or anti clockwise</param>
        /// <returns></returns>
        public Angle DetermineTurnEnd(Vector destination, double radius, TurnDirection turnDirection)
        {
            Angle angleTowardsDestination = new Angle(destination);

            Angle tangentAngles = new Angle(Math.Acos(radius / destination.Length));

            Angle desiredEndPoint;
            if (turnDirection == TurnDirection.Clockwise)
            {
                desiredEndPoint = angleTowardsDestination + tangentAngles;
            }
            else
            {
                desiredEndPoint = angleTowardsDestination - tangentAngles;
            }
            desiredEndPoint.ReduceAngle();
            return desiredEndPoint;
        }
Esempio n. 26
0
 public bool Equals(Vector other)
 {
     return other.X.Equals(X) && other.Y.Equals(Y);
 }
Esempio n. 27
0
        public void MoveToDestination(Vector destination, ulong currentTime)
        {
            var currentMotion = m_Motion.GetCurrentMotion(currentTime);
            var initialPosition = currentMotion.GetCurrentPosition(currentTime);
            var initialVelocity = currentMotion.GetVelocity(currentTime);

            var newPath = CreatePathTo(destination, initialVelocity, initialPosition, currentTime);

            if (newPath[0].GetCurrentPosition(currentTime) != initialPosition)
            {
                throw new InvalidOperationException("The positions do not match up");
            }

            m_Motion = new CombinedMotion( new List<IMotion>(newPath));
        }
        public void SelectTurningCircleCloserToSecondPointWithinRadius()
        {
            var path = new Path();
            Vector circleOne = new Vector(1, 0);
            Vector circleTwo = new Vector(-1, 0);
            Vector targetPosition = new Vector(-1, 1);
            double turningRadius = 1.5;

            Vector selectedCircle = path.SelectTuriningCircle(circleOne, circleTwo, targetPosition, turningRadius);

            Assert.AreEqual(selectedCircle.X, circleOne.X, 0.000000001);
            Assert.AreEqual(selectedCircle.Y, circleOne.Y, 0.000000001);
        }
 public Attack(ulong firingTime, string target, Vector firingPosition)
 {
     m_FiringTime = firingTime;
     m_Target = target;
     m_FiringPosition = firingPosition;
 }
 public void AddButton( string text, Vector positon, Vector dimensions )
 {
     var button = new Button();
     button.Size = new Size();
 }