public static void correctOverlap(Agent agent, List<Flockable> neighbors)
        {
            double distSq;
                double overlap;
                double newX, newY;

                foreach (Flockable other in neighbors)
                {
                    if (other is Agent == true)
                    {
                        Vector2 toOther = new Vector2((float)(other.getLocation().X - agent.getLocation().X), (float)(other.getLocation().Y - agent.getLocation().Y));
                        distSq = toOther.LengthSquared();
                        //distSq = (Math.Pow((agent.getLocation().X - other.getLocation().X), 2) + Math.Pow((agent.getLocation().Y - other.getLocation().Y), 2));
                        overlap = agent.getAgentRadiusSq() + other.getAgentRadiusSq() - distSq;
                        if (agent.Equals(other) == false && overlap >= 0)
                        {
                            double scale = overlap / Math.Sqrt(distSq);
                            Vector2 move = new Vector2((float)(toOther.X * scale), (float)(toOther.Y * scale));
                            //newX = agent.getLocation().X + (((other.getLocation().X - agent.getLocation().X) / Math.Sqrt(distSq)) * overlap);
                            //newY = agent.getLocation().Y + (((other.getLocation().Y - agent.getLocation().Y) / Math.Sqrt(distSq)) * overlap);
                            newX = agent.getLocation().X + move.X;
                            newY = agent.getLocation().Y + move.Y;
                            agent.setLocation(new DotNET.Point(newX, newY));
                        }
                    }
                } // end foreach
        }
 ///<summary>
 ///Add an agent to the flock
 ///</summary>
 ///<param name="newAgent">The agent to add</param>
 public void AddAgent(Agent newAgent)
 {
     if (boids.Count <= MAX_BOIDS)
     {
         boids.Add(newAgent);
     }
 }
        /* Seperation
         * Steer away from our neighbors to distance given agent from peers.
         *
         * We assume that neighbors represents all of the visible neighbors of the
         * provided agent.
         */
        private static Vector2 ComputeSeperation(Agent agent, List<Flockable> neighbors)
        {
            Vector2 steeringForce = new Vector2();
            int numNeighbors = 0;

            foreach (Flockable otherAgent in neighbors)
            {
                if (otherAgent.Equals(agent) == false)
                {
                    Vector stupidTemp = DotNET.Point.Subtract(agent.getLocation(), otherAgent.getLocation());
                    Vector2 diffBetweenAgents = new Vector2((float) stupidTemp.X, (float) stupidTemp.Y);

                    diffBetweenAgents.Normalize();
                    diffBetweenAgents = Vector2.Divide(diffBetweenAgents, diffBetweenAgents.Length());

                    steeringForce = Vector2.Add(steeringForce, diffBetweenAgents);

                    numNeighbors += 1;
                }
            }

            return steeringForce;
        }
        /* Cohesion
         * Calculate center of mass of neighbors.
         */
        private static Vector2 ComputeCohesion(Agent agent, List<Flockable> neighbors)
        {
            Vector2 centerMassSum = new Vector2();
            float numNeighbors = 0;

            foreach (Flockable otherAgent in neighbors)
            {
                if (agent.Equals(otherAgent) == false)
                {
                    Vector2 stupidTemp = new Vector2((float) otherAgent.getLocation().X, (float) otherAgent.getLocation().Y);
                    if (otherAgent.getFlockingWeight() > 1)
                    {
                        stupidTemp = Vector2.Multiply(stupidTemp, otherAgent.getFlockingWeight());
                        numNeighbors += otherAgent.getFlockingWeight();
                    }
                    else
                    {
                        numNeighbors += 1;
                    }
                    centerMassSum = Vector2.Add(centerMassSum, stupidTemp);
                }
            }

            if (numNeighbors > 0)
            {
                centerMassSum = Vector2.Divide(centerMassSum, numNeighbors);

                return Seek(agent, centerMassSum);
            }

            return new Vector2();
        }
        /* Alignment
         * Align the heading of an agent based on those of its neighbors. The
         * force is calculated by generating an average heading vector. We then
         * subtract the agent's heading to get the steering force for the agent.
         *
         * We assume that neighbors represents all of the visible neighbors of the
         * provided agent.
         */
        private static Vector2 ComputeAlignment(Agent agent, List<Flockable> neighbors)
        {
            // A running sum of the given agent's neighbors headings.
            Vector2 headingSum = new Vector2();
            int divisor = 0;

            Vector2 weightedHeading;
            // For each of the given agents neighbors...
            foreach (Flockable otherAgent in neighbors)
            {
                // Ensure that our agent was not counted among its neighbors.
                if (agent.Equals(otherAgent) == false)
                {
                    // Add our neighbors heading to our running sum
                    weightedHeading = Vector2.Multiply(otherAgent.getHeading(), otherAgent.getFlockingWeight());
                    headingSum = Vector2.Add(headingSum, weightedHeading);

                    // Necessary as we allow our given boid to be included in the neighbors.
                    divisor += otherAgent.getFlockingWeight();
                }
            }

            // The average of the neighbor headings.
            // Zero vector in the event that provided agent has no neighbors.
            Vector2 averageHeading = new Vector2();

            if (divisor > 0) // Avoid divide by zero erros.
            {
                // Basic math.
                averageHeading = Vector2.Divide(headingSum, (float) divisor);

                // Subtract the provided agent's heading to produce the steering force.
                // If this is puzzling the most effective way to think about this is to draw a
                // picture of the current heading and the average heading.
                averageHeading = Vector2.Subtract(averageHeading, agent.getHeading());
            }

            // Return steering force necessary to achieve alignment with peers.
            return averageHeading;
        }
        public static Vector2 Seek(Agent agent, Vector2 goal)
        {
            Vector2 agentLocation = new Vector2((float) agent.getLocation().X, (float) agent.getLocation().Y);
            Vector2 desired = Vector2.Subtract(goal, agentLocation);

            desired.Normalize();

            return desired;
        }
        public static List<Flockable> getNeigbors(Agent agent, List<Flockable> candidates)
        {
            List<Flockable> neighbors = new List<Flockable>();
            double distSq;

            foreach (Flockable other in candidates)
            {

                distSq = (Math.Pow((agent.getLocation().X - other.getLocation().X), 2) + Math.Pow((agent.getLocation().Y - other.getLocation().Y), 2));
                if (other is Hand)
                {
                    if (distSq < other.getNeighborhoodRadiusSq())
                    {
                        neighbors.Add(other);
                    }
                }
                else if (distSq < other.getNeighborhoodRadiusSq() && agent.Equals(other) == false)
                {
                    neighbors.Add(other);
                }
            }

            return neighbors;
        }