public int CompareTo(IPosition other)
		{
			NaryPosition otherNary = other as NaryPosition;
			if (otherNary != null)
				return CompareTo(otherNary);
			return 0;
		}

 /// <summary>
 /// Checks if the figure is on the way that the figures want to move
 /// </summary>
 /// <param name="position">Position on which the figure moves</param>
 /// <param name="board">The game board</param>
 /// <exception cref="InvalidPositionException"></exception>
 public static void CheckIfFigureOnTheWay(IPosition position, IBoard board)
 {
     if (board.GetFigureAtPosition(position) != null)
     {
         throw new InvalidPositionException(GlobalErrorMessages.FigureOnTheWayErrorMessage);
     }
 }

		public static SpatialCriteria WithinRadiusOf(this SpatialCriteriaFactory @this,
													double radius,
													IPosition position)
		{
			var coordinate = position.GetCoordinate();
			return @this.WithinRadiusOf(radius, coordinate.Longitude, coordinate.Latitude);
		}

 public override void MouseUp(IPosition p, MouseButtons b)
 {
     if (b == MouseButtons.Left)
     {
         RectFinish();
     }
 }

 private void RobotReportedPosition(int robotId, IPosition position, IHeading heading)
 {
     if (ReportedPosition != null)
     {
         ReportedPosition(robotId, position, heading);
     }
 }

 /// <summary>
 /// Creates a new <c>PositionGeometry</c> from the supplied position (or casts
 /// the supplied position if it's already an instance of <c>PositionGeometry</c>).
 /// </summary>
 /// <param name="p">The position the geometry should correspond to</param>
 /// <returns>A newly created <c>PositionGeometry</c> instance, or the supplied
 /// position if it's already an instance of <c>PositionGeometry</c></returns>
 public static PositionGeometry Create(IPosition p)
 {
     if (p is PositionGeometry)
         return (p as PositionGeometry);
     else
         return new PositionGeometry(p.X, p.Y);
 }

 /// <summary>
 /// Add the specific figure at the specific position on the board
 /// </summary>
 /// <param name="figure">Figure to be added</param>
 /// <param name="position">The position on which the figure should be added</param>
 public void AddFigure(IFigure figure, IPosition position)
 {
     Validator.CheckIfObjectIsNull(figure);
     Validator.CheckIfPositionValid(position);
     this.board[position.Row, position.Col] = figure;
     this.figurePositionsOnBoard[figure.DisplaySign] = position;
 }

        /// <summary>
        /// Creates a new <c>FindOverlapsQuery</c> (and executes it). The result of the query
        /// can then be obtained through the <c>Result</c> property.
        /// </summary>
        /// <param name="index">The spatial index to search</param>
        /// <param name="closedShape">The closed shape defining the search area.</param>
        /// <param name="spatialType">The type of objects to look for.</param>
        internal FindOverlapsQuery(ISpatialIndex index, IPosition[] closedShape, SpatialType spatialType)
        {
            m_ClosedShape = new ClosedShape(closedShape);
            m_Points = new List<PointFeature>(100);
            m_Result = new List<ISpatialObject>(100);

            // If we are looking for points or lines, locate points that overlap. Note that
            // if the user does not actually want points in the result, we still do a point
            // search, since it helps with the selection of lines.
            if ((spatialType & SpatialType.Point)!=0 || (spatialType & SpatialType.Line)!=0)
            {
                index.QueryWindow(m_ClosedShape.Extent, SpatialType.Point, OnPointFound);

                // Remember the points in the result if the caller wants them
                if ((spatialType & SpatialType.Point)!=0)
                    m_Result.AddRange(m_Points.ToArray());
            }

            // Find lines (this automatically includes lines connected to the points we just found)
            if ((spatialType & SpatialType.Line)!=0)
                index.QueryWindow(m_ClosedShape.Extent, SpatialType.Line, OnLineFound);

            // Find any overlapping text
            if ((spatialType & SpatialType.Text)!=0)
                index.QueryWindow(m_ClosedShape.Extent, SpatialType.Text, OnTextFound);

            m_Result.TrimExcess();
            m_Points = null;
        }

 public CircularArcGeometry(ICircleGeometry circle, IPosition bc, IPosition ec, bool isClockwise)
 {
     m_Circle = circle;
     m_BC = PositionGeometry.Create(bc);
     m_EC = PositionGeometry.Create(ec);
     m_IsClockwise = isClockwise;
 }

 /// <summary>
 /// Constructor with 3 parameters
 /// </summary>
 /// <param name="playerPosition">Parameter of type IPosition</param>
 /// <param name="rows">Parameter of type int</param>
 /// <param name="cols">Parameter of type int</param>
 public StandardPlayFieldGenerator(IPosition playerPosition, int rows = Constants.StandardGameLabyrinthRows, int cols = Constants.StandardGameLabyrinthCols)
 {
     this.playField = new ICell[rows, cols];
     this.playerPosition = playerPosition;
     this.rows = rows;
     this.cols = cols;
 }

 public void AddFigure(IFigure figure, IPosition position)
 {
     Validator.CheckIfObjectIsNull(figure, GlobalErrorMessages.NullFigureErrorMessage);
     Validator.CheckIfPositionValid(position, GlobalErrorMessages.PositionNotValidMessage);
     this.board[position.Row, position.Col] = figure;
     this.figurePositionsOnBoard[figure.DisplayName] = position;
 }

        public static MediaQuery Parse(string value, IPosition forPosition)
        {
            if (value.Contains(','))
            {
                var parts = value.Split(',');

                var ret = new List<MediaQuery>();

                foreach (var part in parts)
                {
                    ret.Add(Parse(part.Trim(), forPosition));
                }

                if (ret.Count == 1) return ret[0];

                return new CommaDelimitedMedia(ret, forPosition);
            }

            if (value.StartsWith("only ", StringComparison.InvariantCultureIgnoreCase))
            {
                return new OnlyMedia(ParseQuery(value.Substring("only ".Length).Trim(), forPosition), forPosition);
            }

            if (value.StartsWith("not ", StringComparison.InvariantCultureIgnoreCase))
            {
                return new NotMedia(ParseQuery(value.Substring("not ".Length).Trim(), forPosition), forPosition);
            }

            return ParseQuery(value, forPosition);
        }

 public static void CheckIfFigureOnTheWay(IPosition position, IBoard board, string message)
 {
     if (board.GetFigureAtPosition(position) != null)
     {
         throw new ArgumentException(message);
     }
 }

        public static double CalculateDistance(IPosition position1, IPosition position2)
        {
            var xPortion = (position2.XCoord - position1.XCoord) * (position2.XCoord - position1.XCoord);
            var yPortion = (position2.YCoord - position1.YCoord) * (position2.YCoord - position1.YCoord);

            return Math.Sqrt(xPortion + yPortion);
        }

            public void Goto(IPosition position, bool KeepRunning)
            {
                var distance = DistanceTo(position);

                if (DistanceTo(position) > DistanceTolerance)
                {
                    DateTime duration = DateTime.Now.AddSeconds(5);
                    var player = api.Entity.GetLocalPlayer();
                    api.ThirdParty.KeyDown(Keys.NUMPAD8);

                    while (DistanceTo(position) > DistanceTolerance && DateTime.Now < duration)
                    {
                        if ((ViewMode)api.Player.ViewMode != ViewMode.FirstPerson)
                        {
                            api.Player.ViewMode = (int)ViewMode.FirstPerson;
                        }

                        FaceHeading(position);

                        System.Threading.Thread.Sleep(30);
                    }

                    api.ThirdParty.KeyUp(Keys.NUMPAD8);
                }
            }

 public override void MouseMove(IPosition p, MouseButtons b)
 {
     if (b == MouseButtons.Left)
     {
         RectUpdate(p);
     }
 }

 public virtual IGrid Fill(IPosition position, Mark mark)
 {
     var grid = new Mark[3, 3];
     Array.Copy(_grid, grid, _grid.Length);
     grid[position.Row, position.Col] = mark;
     return new Grid3X3(grid);
 }

 public void WhenMarkPosition_TheGridShouldGetUpdatedForTheSamePosition(IPosition position)
 {
     var mock = new Mock<IGrid>();
     mock.Setup(x => x.Fill(position, Mark.Cross));
     Mark.Cross.On(mock.Object, position);
     mock.Verify(x => x.Fill(position, Mark.Cross), Times.Once());
 }

 private StandardPlayer(string name, int id, IGame game, ICharacter character, IPosition position)
 {
     this._name = name;
     this._id = id;
     this._game = game;
     this._character = character;
     this._position = position;
 }

 /// <summary>
 /// Field constructor that takes an IPosition object as argument
 /// </summary>
 /// <param name="position">The position for the current IField object</param>
 /// <param name="color">The color for the current IField object</param>
 /// <param name="chessBoard">The chess board for the current IField object</param>
 protected Field(IPosition position, ColorType color, IChessBoard chessBoard)
 {
     this.ChessBoard = chessBoard;
     this.Position = position;
     this.Color = color;
     this.HasChessPiece = false;
     this.IsDrawable = true;
 }