Flocking

In the final part of the assignment you will implement and explore the flocking algorithm.

The skeleton code Flocker.java is again based on the Follower class. There are two important additions to the skeleton code file, which take the form of inner classes.

• The FlockerAttributes class handles input and output of the properties that determine flocker behavior. Each Flocker includes an instance flocking of the FlockerAttributes, which you should access when you consult the agent.
• The WeightedForce class provides infrastructure for manipulating and especially visualizing the factors that go into flocker decision making. In particular, you can add an instance member (e.g., force) to the Flocker to save the force that you are interested in, and then draw it in the Flocker.draw() method with a call like force.draw(lastStatus, myWorld, g);

Your job is to implement the different forces, then create scenarios that illustrate typical flocking behavior. Extensions allow you to experiment with the expressive capabilities of the simulation.

Programming

Your Flocker should potentially reflect a balance among five different priorities. They are:

• Avoiding obstacles (clearance)
• Avoiding other flockers (separation)
• Aligning with nearby flockers (alignment)
• Moving to the center of nearby flockers (centering)
• Approaching light sources (following)

The way a Flocker balances these priorities is using the WeightedForce object. In particular, the basic algorithm for Flocker decision making goes like this.

Start with a new force with weight 1 and heading 0 (straight ahead)
For of the five flocker priorities 
   If the agent is sensitive to that priority
      Calculate its force in the current situation
      Add that force into the overall force
Create the intention to move in the direction of the force, at full speed

This amounts to the pseudocode for the new deliberate method in your flocker.

Here is a brief explanation of how to calculate each force.

Clearance. Find all the obstacles that the flocker can see (and predators and whatever else you think this flocker will want to avoid, besides lights and other flockers). If the obstacle is closer than the distance flocker.clearance and lies within the angle bounded by flocking.cone on either side of the flocker's direct heading, add in a force to avoid that obstacle. That force should:

• Be weighted inversely proportional to the distance to the obstacle
• Assume a weight of flocking.obstacleWeight when the obstacle is flocking.clearance away
• Go in the direction of flocking.cone or -flocking.cone, whichever turns the flocker most quickly away from the obstacle.

See the picture:

Note: There are lots of different directions you could imagine steering to avoid an obstacle, as Braitenberg already points out. You could imagine steering backwards, or directly to one side or another. You might want to play with the different strategies. The strategy above, more or less, is the one Craig Reynolds recommends in his original paper. It balances better with the other flocking forces, which will tend to keep a group of agents flying more or less forward. A directly opposed clearance force would need to be very strong and would lead to unstable and, perhaps, unlikely behaviors.

Separation Find all the nearby boids that the flocker can see. If they are closer than the distance flocking.separation, then add in a force to avoid that boid. The force should:

• Be weighted inversely proportional to the distance to the other boid.
• Assume a weight of flocking.separationWeight when the obstacle is flocking.separation away
• Go in the opposite direction of the other boid.

See the picture:

Note: In this case, we do steer away from the other boid, because we imagine this force typically being applied in the middle of crowds, where the boids are ''jockeying for position'' with subtle movements to one side or another.

Alignment Find the nearby boids that the flocker can see that are closer than the distance flocking.detection but further than flocking.separation. Create a force with a weight of flocking.alignmentWeight that points in the average orientation of these boids. (To average, add all the forces together and then reweight by 1/n where n is the number of relevant boids.) See the picture:

Note: You want the force to depend on the average orientation because that way there is the same alignment force on each flocker regardless of the size of the flock around it. That means you only have to tune the balance among the different priorities once for flocks of many different sizes.

Centering Consider the same nearby boids as the alignment force. Create a force with a weight of flocking.centeringWeight that points to the average position of these boids. See the picture:

Following Find the closest light, and create a force towards it. The force should have a weight of followWeight.

Note: You could imagine having the force vary with the distance to the light. If the force increases with distance, it steers the flock as a whole towards lights; if it increases with the inverse of distance, it makes sure that individual agents near lights are sure to go out of their way to eat them.

Testing

The best way to test the flocker is to implement the forces one at a time, visualizing them as you go. These test cases showcase the effects of individual forces.

• worksite:/Homework/HW1/Examples/fo1.xml The obstacle force should make a boid steer away from obstacles. sample run
• worksite:/Homework/HW1/Examples/fs1.xml The separation force should make a boid steer away from nearby boids. sample run
• worksite:/Homework/HW1/Examples/fa1.xml The alignment force should make a boid steer in the same direction as nearby boids. sample run
• worksite:/Homework/HW1/Examples/fc1.xml The centering force should make a boid nestle in among nearby boids. sample run
• worksite:/Homework/HW1/Examples/ff1.xml The light following force should make a boid go after lights. sample run

Once you have the forces working individually, then you can start to look at how they interact with one another in simple cases. For example, worksite:/Homework/Examples/fl1.xml shows three boids going around an obstacle to reach a light. sample run

Finally you can work with fancier files that show more interesting behavior, like this one which shows a predator chasing a big flock. sample run

Analysis

Create three specific files, showing some of the strengths and weaknesses of flocking.

• split.xml shows a flock splitting and then merging back together as it goes around and obstacle.
• stuck.xml shows a flock unable to get around an obstacle to some food because the flock is not capable of doing long-term planning but instead just follows its immediate drives.
• story.xml a demonstration file showing some interesting, fun and perhaps surprisingly complex behavior from a flock, which we can use as a conversation piece in class.

Extensions

Make the behavior of your flockers more sophisticated, interesting or realistic. As always the extensions should get turned on only if the XML property with-extensions and therefore the internal variable form.withExtensions are set.

Possible examples include:

• Having flockers interact differently with other boids of different colors
• Having flockers explicitly react to predators, for example by scattering.

Another option is to create an auxiliary program that makes interesting random worlds for flockers to navigate through.

Hand in

• Flocker.java Your implmentation
• split.xml, stuck.xml and story.xml your examples
• Any additional code you create for extensions (for example to make random worlds).

Navigation

That is the end.

• Project 1 Back to project home.