public static double DistanceSqrt( IPoint2D from, IPoint2D to )
        {
            float xDelta = Math.Abs( from.X - to.X );
            float yDelta = Math.Abs( from.Y - to.Y );

            return Math.Sqrt( xDelta*xDelta + yDelta*yDelta );
        }

        public static int Distance( IPoint2D from, IPoint2D to )
        {
            int xDelta = Math.Abs( from.X - to.X );
            int yDelta = Math.Abs( from.Y - to.Y );

            return ( xDelta > yDelta ? xDelta : yDelta );
        }

 public static NestArea Find(IPoint2D p)
 {
     foreach (NestArea area in m_Areas)
     {
         if (area.Contains(p))
             return area;
     }
     return null;
 }

 public bool Contains(IPoint2D p)
 {
     foreach (Rectangle2D rect in this.m_Rects)
     {
         if (rect.Contains(p))
             return true;
     }
     return false;
 }

 public bool Contains(IPoint2D p)
 {
     foreach (var rect in m_Rects)
     {
         if (rect.Contains(p))
             return true;
     }
     return false;
 }

        /// <summary>
        /// Calculates the distance between two points
        /// </summary>
        /// <param name="origin">the starting point</param>
        /// <param name="target">the ending point</param>
        /// <returns>an integer of the distance between the origin and target</returns>
        public static int DistanceBetween( IPoint2D origin, IPoint2D target )
        {
            if( origin.X == target.X )
                return Math.Abs((origin.Y - target.Y));

            if( origin.Y == target.Y )
                return Math.Abs((origin.Y - target.Y));

            //pythagorean theorem... dist = sqrt of (x2-x1)^2 + (y2-y1)^2
            return (int)Math.Sqrt(Math.Pow(Math.Abs(target.X - origin.X), 2) + Math.Pow(Math.Abs(target.Y - origin.Y), 2));
        }

		public static BaseBoat FindBoatAt( IPoint2D loc, Map map )
		{
			Sector sector = map.GetSector( loc );

			for ( int i = 0; i < sector.Multis.Count; i++ )
			{
				BaseBoat boat = sector.Multis[i] as BaseBoat;

				if ( boat != null && boat.Contains( loc.X, loc.Y ) )
					return boat;
			}

			return null;
		}

        private static bool ConsumeJumpStamina( Player pm, IPoint2D start, IPoint2D end )
        {
            double weightRatio = (pm.TotalWeight / pm.MaxWeight);
            int weightInducedLoss = (int)(5 * weightRatio);

            int dist = Util.DistanceBetween(start, end);
            int toConsume = (int)(dist * 5);
            toConsume += weightInducedLoss;

            if( (pm.Stam - toConsume) <= 0 )
                return false;

            pm.Stam -= toConsume;

            return true;
        }

		public static BaseMulti FindMultiAt(IPoint2D loc, Map map)
		{
			Sector sector = map.GetSector(loc);

			for (int i = 0; i < sector.Multis.Count; i++)
			{
				BaseMulti multi = sector.Multis[i];

				if (multi != null && multi.Contains(loc.X, loc.Y))
				{
					return multi;
				}
			}

			return null;
		}

		public static bool Contains(IPoint2D p, IPoint2D a, IPoint2D b, IPoint2D c)
		{
			var x = p.X - a.X;
			var y = p.Y - a.Y;

			var delta = (b.X - a.X) * y - (b.Y - a.Y) * x > 0;

			if ((c.X - a.X) * y - (c.Y - a.Y) * x > 0 == delta)
			{
				return false;
			}

			if ((c.X - b.X) * (p.Y - b.Y) - (c.Y - b.Y) * (p.X - b.X) > 0 != delta)
			{
				return false;
			}

			return true;
		}

		/// <summary>
		///     Gets a Point2D collection representing all locations between 'start' and 'end', including 'start' and 'end', on the given 'map'.
		/// </summary>
		public static Point2D[] GetLine2D(this IPoint2D start, IPoint2D end, Map map)
		{
			var path = new List<Point2D>();

			Geometry.Line2D(ToPoint3D(start), ToPoint3D(end), map, (p, m) => path.Add(ToPoint2D(p)));

			var arr = path.OrderBy(p => GetDistance(start, p)).ToArray();

			path.Clear();
			path.TrimExcess();

			return arr;
		}

 public bool InSquareRange(IPoint2D p, int xyRange)
 {
     return ((((this.m_X >= (p.X - xyRange)) && (this.m_X <= (p.X + xyRange))) && (this.m_Y >= (p.Y - xyRange))) && (this.m_Y <= (p.Y + xyRange)));
 }

		public Rectangle2D(IPoint2D start, IPoint2D end)
			: this(start.X, start.Y, end.X, end.Y) {
		}

		public static StaticTile[] GetStaticTiles(this Map map, IPoint2D p)
		{
			return map.Tiles.GetStaticTiles(p.X, p.Y);
		}

		public static bool HasLand(this Map map, IPoint2D p)
		{
			return !GetLandTile(map, p).Ignored;
		}

		/// <summary>
		/// Returns the angle towards a target spot in degrees, clockwise
		/// </summary>
		/// <param name="tx">target x</param>
		/// <param name="ty">target y</param>
		/// <returns>the angle towards the spot</returns>
		public float GetAngle( IPoint2D point )
		{
			float headingDifference = ( GetHeading( point ) & 0xFFF ) - ( this.Heading & 0xFFF );

			if (headingDifference < 0)
				headingDifference += 4096.0f;

			return (headingDifference * 360.0f / 4096.0f);
		}

		public static Direction GetDirection(this IPoint2D from, IPoint2D to)
		{
			int dx = to.X - from.X, dy = to.Y - from.Y, adx = Math.Abs(dx), ady = Math.Abs(dy);

			if (adx >= ady * 3)
			{
				if (dx > 0)
				{
					return Direction.East;
				}

				return Direction.West;
			}

			if (ady >= adx * 3)
			{
				if (dy > 0)
				{
					return Direction.South;
				}

				return Direction.North;
			}

			if (dx > 0)
			{
				if (dy > 0)
				{
					return Direction.Down;
				}

				return Direction.Right;
			}

			if (dy > 0)
			{
				return Direction.Left;
			}

			return Direction.Up;
		}

 public static bool InRange(IPoint2D from, IPoint2D to, int range)
 {
     return (from.X >= (to.X - range)) && (from.X <= (to.X + range)) && (from.Y >= (to.Y - range)) && (from.Y <= (to.Y + range));
 }

		public static Point2D Rotate2D(this IPoint2D from, IPoint2D to, int count)
		{
			int rx = from.X - to.X, ry = from.Y - to.Y;

			for (int i = 0; i < count; ++i)
			{
				int temp = rx;
				rx = -ry;
				ry = temp;
			}

			return new Point2D(to.X + rx, to.Y + ry);
		}

		public static bool IsInHavenIsland( IPoint2D loc )
		{
			return ( loc.X >= 3314 && loc.X <= 3814 && loc.Y >= 2345 && loc.Y <= 3095 );
		}