public Coords(CoordsType newType, Vector v)
        {
            this._type = newType;
            if (newType == CoordsType.Tile)
            {
                _X = (Int32)(v.X / Constants.TileSize);
                _Y = (Int32)(v.Y / Constants.TileSize);
                return;
            }

            _X = (Int32)Math.Floor(v.X);
            _Y = (Int32)Math.Floor(v.Y);
        }
 public double DistanceTo(Vector somewhere)
 {
     return Math.Sqrt(Math.Pow(this.X - somewhere.X, 2) + Math.Pow(this.Y - somewhere.Y, 2));
 }
        public bool RayTracerVisibilityCheckPixel(Vector c1, Vector c2)
        {
            double x0 = c1.X;
            double y0 = c1.Y;
            double x1 = c2.X;
            double y1 = c2.Y;

            double dx = Math.Abs(x1 - x0);
            double dy = Math.Abs(y1 - y0);

            int x = (int)(Math.Floor(x0));
            int y = (int)(Math.Floor(y0));

            int n = 1;
            int x_inc, y_inc;
            double error;

            if (dx == 0)
            {
                x_inc = 0;
                error = Double.PositiveInfinity;
            }
            else if (x1 > x0)
            {
                x_inc = 1;
                n += (int)(Math.Floor(x1)) - x;
                error = (Math.Floor(x0) + 1 - x0) * dy;
            }
            else
            {
                x_inc = -1;
                n += x - (int)(Math.Floor(x1));
                error = (x0 - Math.Floor(x0)) * dy;
            }

            if (dy == 0)
            {
                y_inc = 0;
                error -= Double.PositiveInfinity;
            }
            else if (y1 > y0)
            {
                y_inc = 1;
                n += (int)(Math.Floor(y1)) - y;
                error -= (Math.Floor(y0) + 1 - y0) * dx;
            }
            else
            {
                y_inc = -1;
                n += y - (int)(Math.Floor(y1));
                error -= (y0 - Math.Floor(y0)) * dx;
            }


            Coords c2Tile = new Coords(CoordsType.Tile, c2);

            for (; n > 0; --n)
            {
                Coords currentCoords = new Coords(CoordsType.Tile, x, y);

                // We ignore accrued visibility for now. Can add it later.
                if ((this._visibilityMap[currentCoords.X, currentCoords.Y] == 0) && (currentCoords != c2Tile))
                {
                    return false;
                }

                if (error > 0)
                {
                    y += y_inc;
                    error -= dx;
                }
                else
                {
                    x += x_inc;
                    error += dy;
                }
            }

            return true;
        }
        /// <summary>
        /// Performs a terrain passability check betwee two points by doing pixel validity checks at interval delta.
        /// </summary>
        public List<Creature> RayTracerPassabilityCheckRough(Creature client, Vector v1, Vector v2, double delta)
        {
            Vector difference = v2 - v1;
            Vector deltaV = difference;
            deltaV.ScaleToLength(delta);

            Vector currentPosition = v1;

            for (int i = 0; i < difference.Length() / deltaV.Length(); ++i)
            {
                Coords pixel = new Coords(CoordsType.Pixel, currentPosition);
                List<Creature> collision = _myCollider.CreatureClippingCheck(client, pixel, false);
                if (collision == null || collision.Count > 0)
                {
                    return collision;
                }
                currentPosition += deltaV;
            }

            return new List<Creature>();
        }
        /// <summary>
        /// Obtains step towards goal. Returns null if path is blocked.
        /// Returns (infinity, infinity) if goal is reached.
        /// </summary>
        /// <returns></returns>
        public Nullable<Vector> Navigate()
        {
            ++_timeTraveled;

            // Check to see if we've arrived. In that case the navigator has finished its job.
            if (_traveler.MyCollider.CollisionCheckPixelInEllipse(_goalPixel, _traveler.PositionPixel, _traveler.RadiusX, _traveler.RadiusY))
            {
                // goal attained.
                ++Constants._navigationSuccesses;
                return new Vector(Double.PositiveInfinity, Double.PositiveInfinity);
            }

            // Check to see if we have a visible goal or if we're taking too long to get to it
            if (_visiblePixelGoal == null || _timeTraveled >= _timeTraveledUpperBound)
            {
                // no goal set. check to see if a exists and whether we're on it:
                if (_routeCoarse == null || !this._putativeCurrentPosition.Equals(_traveler.PositionTile))
                {
                    // no route or we need a recalc
                    AcquireRoute();
                }
            }

            // Check to see if we've arrived to the current visible goal. If so, get new one.
            if (_traveler.MyCollider.CollisionCheckPixelInEllipse(_visiblePixelGoal.Value, _traveler.PositionPixel, _traveler.RadiusX, _traveler.RadiusY))
            {
                AcquireVisiblePixelGoal();
            }

            // We move towards current visible pixel goal.

            // Declare movement vector
            Vector principleMoveDir = new Vector(_visiblePixelGoal.Value) - _traveler.PositionDouble;
            principleMoveDir.ScaleToLength(_traveler.MoveSpeedCurrent);
            Vector startPoint = _traveler.PositionDouble;

            // Try to move in given direction. If the move fails, offset the direction angle and try again.
            // The offsets are under a full PI in either direction (so the agent doesn't get stuck in a loop).
            // Avoidance is first attempted in one direction. If it fails, the agent tries to other direction.
            // If both directions fail, the agent gives up.
            Int32 numberOfOffsetAttempts = (Int32)(Math.PI / Constants.CollisionAvoidanceRotation);

            // flags whether avoidance direction was flipped.
            bool directionFlipped = false;

            // list of creatures the agent has asked to step aside.
            List<Creature> askedToStepAside = new List<Creature>();

            while (true)
            {
                for (sbyte i = 0; i < numberOfOffsetAttempts; ++i)
                {
                    double offsetAngle = Math.Pow(-1, (sbyte)_avoidanceDirection) * i * Constants.CollisionAvoidanceRotation;
                    Vector moveDir = principleMoveDir.Rotate(offsetAngle);

                    List<Creature> checkForCollisions = _traveler.MyCollider.RayTracerPassabilityCheckPrecise(_traveler, startPoint, startPoint + moveDir);

                    if (checkForCollisions != null)
                    {
                        if (checkForCollisions.Count > 0)
                        {
                            // ask agents in the way to move
                            foreach (Creature impediment in checkForCollisions)
                            {
                                if (!askedToStepAside.Contains(impediment))
                                {
                                    Vector vectorToImpediment = impediment.PositionDouble - _traveler.PositionDouble;
                                    vectorToImpediment.ScaleToLength(1);

                                    Vector moveDirPerpendicular = directionFlipped ? moveDir.PerpendiculatRight() : moveDir.PerpendiculatLeft();
                                    moveDirPerpendicular.ScaleToLength(1);

                                    impediment.CreatureBrain.StepAsideRequest(vectorToImpediment + moveDirPerpendicular);
                                    askedToStepAside.Add(impediment);
                                }

                            }
                        }
                        else
                        {
                            // success. update creature position.
                            //_traveler.PositionDouble = startPoint + moveDir;
                            _timeWaited = 0;
                            return moveDir;
                        }
                    }
                }

                // we failed to move anywhere. the agent tries avoidance in the other direction.
                if (!directionFlipped)
                {
                    _avoidanceDirection = (AvoidanceDir)(((sbyte)_avoidanceDirection + 1) % 2);
                    directionFlipped = true;
                }
                else
                {
                    // avoidance in either direction failed. the agent gives up.
                    // NOTE: perhaps add a brief (1 second?) waiting time for the agent before giving up.
                    ++_timeWaited;

                    if (_timeWaited >= Constants.FailedCollisionAvoidanceWaitTime)
                    {
                        // give up
                        _timeWaited = 0;
                        break;
                    }
                    else
                    {
                        // pass back static moveVector
                        return new Vector(0, 0);
                    }
                }
            }

            ++Constants._navigationFailures;
            return null;

        }
        /*
        private UInt16 _sideStepTimer = 0;
        private Vector _sideStepDir;
        */

        /// <summary>
        /// Requests a move from the agent.
        /// </summary>
        /// <param name="direction">Move direction.</param>
        /// <param name="clipChecked">Whether the move has been clip-checked.</param>
        /// <param name="normalizedToSpeed">Whether the vector is normalized.</param>
        public void MoveRequest(Vector direction, bool clipChecked, bool normalizedToSpeed)
        {
            if (!normalizedToSpeed)
            {
                // Accelerate and normalize the move.
                this.Accelerate();
                direction.ScaleToLength(_owner.MoveSpeedCurrent);
            }

            _moveDir = direction;
            _moveClipChecked = clipChecked;
            _moveRequested = true;
        }
        /// <summary>
        /// Finds a route to the target.
        /// </summary>
        private void AcquireRoute()
        {
            // Line of sight check to avoid needless A* calls
            //Vector here = new Vector(_traveler.PositionPixel.X , _traveler.PositionPixel.Y);
            Vector there = new Vector(_goalPixel.X, _goalPixel.Y);

            List<Creature> clipCheck =
                _traveler.InhabitedMap.RayTracerPassabilityCheckRough(_traveler, _traveler.PositionDouble, there, _traveler.RadiusX);
            if (clipCheck != null && clipCheck.Count == 0)
            {
                _visiblePixelGoal = _goalPixel;
                _putativeCurrentPosition = _goalTile;
                EstimateTimeOfTravel();

                return;
            }

            //Coords hereCoords = _traveler.Position;
            this._routeCoarse = _traveler.MyPathfinder.PathfinderAStarCoarse(_traveler.PositionTile, _goalTile, StaticMathFunctions.DistanceBetweenTwoCoordsEucledean);

            this._putativeCurrentPosition = _traveler.PositionTile;
            AcquireVisiblePixelGoal();
        }
        // Acquires new visible pixel goal. Deletes the route entries up to that point.
        private void AcquireVisiblePixelGoal()
        {
            UInt16 i = 0;
            //Coords returnVal;
            Coords currentTile = _traveler.PositionTile;

            for (; i < _routeCoarse.Count; ++i)
            {
                Direction currentDir = _routeCoarse[_routeCoarse.Count - i - 1];
                Coords newTile = currentTile.NeighborInDirection(currentDir);

                //Vector here = new Vector(_traveler.PositionPixel.X , _traveler.PositionPixel.Y);

                Coords newTileMiddle = _traveler.InhabitedMap.GetTile(newTile).PixelMiddle();
                Vector there = new Vector(newTileMiddle.X, newTileMiddle.Y);

                List<Creature> clipCheck =
                    _traveler.InhabitedMap.RayTracerPassabilityCheckRough(_traveler, _traveler.PositionDouble, there, _traveler.RadiusX);
                if (clipCheck == null || clipCheck.Count > 0)
                {
                    // We've reached an tile, to which a direct line can't go. Set the target to the midpoint of previous tile.
                    _visiblePixelGoal = _traveler.InhabitedMap.GetTile(currentTile).PixelMiddle();
                    EstimateTimeOfTravel();

                    // remove directions from route
                    _routeCoarse.RemoveRange(_routeCoarse.Count - i, i);
                    _putativeCurrentPosition = currentTile;

                    return;
                }

                currentTile = newTile;
            }

            // we went through the loop without returning. that means the end-pixel is visible.
            _visiblePixelGoal = _goalPixel;
            EstimateTimeOfTravel();
            _putativeCurrentPosition = _goalTile;
            _routeCoarse = null;
        }
        /// <summary>
        /// Ask the agent to move aside if he can.
        /// </summary>
        public void StepAsideRequest(Vector direction)
        {
            if (_owner.MoveSpeedCurrent > 0)
            {
                //the agent is already in motion. ignore request.
                return;
            }

            // include other conditions for ignoring the request here.

            // try to step aside
            MoveRequest(direction, false, false);
        }
 /// <summary>
 /// Returns an exact pixel-by-pixel collision check.
 /// 'null' - terrain collision.
 /// empty - no collision.
 /// non-empty - creature collision.
 /// </summary>
 public List<Creature> RayTracerPassabilityCheckPrecise(Creature client, Vector v1, Vector v2)
 {
     return RayTracerPassabilityCheckPrecise(client, new Coords(CoordsType.Pixel, v1), new Coords(CoordsType.Pixel, v2));
 }
        /// <summary>
        /// Handles collisions for an agent.
        /// </summary>
        public void HandleCollisions(Creature someGuy, Vector oldPosition)
        {
            this.UpdateCreatureBoxes(someGuy, oldPosition);

            List<Creature> collisions = this.PotentialCreatureToCreatureCollision(someGuy, new Coords(CoordsType.Pixel, someGuy.PositionDouble));

            for (int i = 0; i < collisions.Count; ++i)
            {
                this.HandleCollisionBetweenTwoPlayers(someGuy, collisions[i]);
            }
        }
        /// <summary>
        /// Updates the tiles of the grid which an agent covers.
        /// </summary>
        public void UpdateCreatureBoxes(Creature someGuy, Vector oldPosition)
        {
            Coords oldCoords = new Coords((Int32)(oldPosition.X / _pixelsPerBoxX), (Int32)(oldPosition.Y / _pixelsPerBoxY));
            Coords newCoords = new Coords((Int32)(someGuy.PositionDouble.X / _pixelsPerBoxX), (Int32)(someGuy.PositionDouble.Y / _pixelsPerBoxY));

            if (oldCoords == newCoords)
            {
                // nothing to do
                return;
            }

            LinkedList<Coords> steppedOn = TilesCoveredByEllipse(new Coords(CoordsType.Pixel, someGuy.PositionDouble), someGuy.RadiusX, someGuy.RadiusY);
            foreach (Coords c in _occupiedBoxes[someGuy])
            {
                this.ClippingBoxesRemoveFrom(c, someGuy);
            }
            foreach (Coords c in steppedOn)
            {
                this.ClippingBoxesAddTo(c, someGuy);
            }

            _occupiedBoxes[someGuy] = steppedOn;
        }
        private void HandlerMouseRightClick()
        {
            Coords clicked = PixelUnderMousecursor();

            Vector averagePosition= new Vector();
            if (_selectedCreatures.Count > 0)
            {
                averagePosition = SelectedCreaturesAveragePosition();
            }
            Coords averagePositionCoords = new Coords(CoordsType.Pixel, averagePosition);

            foreach (Creature c in _selectedCreatures)
            {
                if (!c.Dead)
                {
                    Coords delta = c.PositionPixel - averagePositionCoords;
                    c.CreatureBrain.OrderMove(clicked + delta);
                }
            }
        }