Exemple #1
0
        public void IPoint()
        {
            //Do various IPoint method calls to cover the point class with sufficient testing
            IPoint2D p0 = _geoFactory.CreatePoint() as IPoint2D;
            IPoint2D p1 = _geoFactory.CreatePoint2D(0, 0);
            IPoint2D p2 = _geoFactory.CreatePoint2D(450, 120);

            Assert.IsTrue(p0.IsEmpty);
            Assert.IsFalse(p1.IsEmpty);
            Assert.AreNotEqual(p0, p1);
            Assert.AreEqual(450, p2.X);
            Assert.AreEqual(120, p2.Y);
            Assert.AreNotSame(p2.Clone(), p2);
            p0 = _geoFactory.CreatePoint2D(p2.X + 100, 150);
            p0 = _geoFactory.CreatePoint2D(p0.X + p0.Y, p0.Y);
            Assert.AreEqual(_geoFactory.CreatePoint2D(700, 150), p0);
            Assert.AreEqual(p2.Coordinate, p2.Extents.Min);
            Assert.AreEqual(p2.Coordinate, p2.Extents.Max);
            Assert.IsTrue(p2.IsSimple);
            Assert.IsFalse(p2.IsEmpty);
            Assert.AreEqual(2, p2.OrdinateCount);
            Assert.AreEqual(_geoFactory.CreatePoint2D(400, 100), p2.Add(_geoFactory.CreatePoint2D(-50, -20)));
            Assert.AreEqual(_geoFactory.CreatePoint2D(500, 100), p2.Subtract(_geoFactory.CreatePoint2D(-50, 20)));
            Assert.AreEqual(_geoFactory.CreatePoint2D(900, 240), p2.Multiply(2));
            Assert.AreEqual(0, p2.Dimension);
            Assert.AreEqual(450, p2[Ordinates.X]);
            Assert.AreEqual(120, p2[Ordinates.Y]);
            Assert.IsNull(p2.Boundary);
            Assert.AreEqual(p2.X.GetHashCode() ^ p2.Y.GetHashCode() ^ p2.IsEmpty.GetHashCode(), p2.GetHashCode());
            Assert.Greater(p2.CompareTo(p1), 0);
            Assert.Less(p1.CompareTo(p2), 0);
            Assert.AreEqual(p2.CompareTo(_geoFactory.CreatePoint2D(450, 120)), 0);
        }
Exemple #2
0
 /// <remark>
 ///     Partial collision detection.
 /// </remark>
 protected override void ExecuteMovement(IPoint2D direction)
 {
     if (IsAlive())
     {
         IPoint2D newPosition = Position.Add(direction.Multiply(Speed));
         if (!HasCollided(newPosition, _obstaclesOnMap))
         {
             Position = newPosition;
             Status   = ActorStatus.Moving;
         }
     }
 }
        public ICollection <ICommand> Interpret(Tuple <ISet <Enum>, IPoint2D> inputs, IPoint2D spritePosition,
                                                double deltaTime)
        {
            var outList = new List <ICommand>();

            (ISet <Enum> keysAndButtons, IPoint2D mouseCoords) = Objects.RequireNonNull(inputs);
            ISet <string> actionNames = ConvertBindings(keysAndButtons);

            // Compute new movement direction
            IPoint2D moveDir = ProcessMovementDirection(actionNames);

            if (!Equals(moveDir, Direction.None.Get))
            {
                outList.Add(new MoveCommand(moveDir.Multiply(deltaTime)));
            }

            // Compute new angle
            IPoint2D newMouseCoords = ProcessMouseCoordinates(mouseCoords, spritePosition);

            if (!_currentMouseCoords.Equals(newMouseCoords))
            {
                outList.Add(new RotateCommand(MathUtils.MouseToDegrees(newMouseCoords)));
                _currentMouseCoords = newMouseCoords;
            }

            /*
             * Compute actions that need to be executed only once if
             * the user keeps holding the assigned key
             */
            outList.AddRange(ProcessOneTimeActions(actionNames));

            /*
             * Compute actions that can be executed continuously
             */
            outList.AddRange(ProcessContinuousActions(actionNames));

            return(outList);
        }