1 / 16

Flocking

Flocking. References: http://www.red3d.com/cwr/boids/ xxx. What is it?. A way to simulate "herds": Flock of birds Flock of fish Herd of wildebeest A group of enemies. First image: http://www.hanskellner.com/2007/03/02/dusk-flock-of-birds-video/

glynn
Download Presentation

Flocking

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Flocking References: http://www.red3d.com/cwr/boids/ xxx

  2. What is it? • A way to simulate "herds": • Flock of birds • Flock of fish • Herd of wildebeest • A group of enemies First image: http://www.hanskellner.com/2007/03/02/dusk-flock-of-birds-video/ Second image: http://www.environment.ucla.edu/podcasts/article.asp?parentid=4002 Third image: http://virtualiansanity.blogspot.com/2010/09/lion-king-favorite-scenes.html Fourth image: http://en.wikipedia.org/wiki/Resident_Evil_4

  3. Boid Representation • A generic term for a flocking character • Position () • 2D: a 2-vector (x, y) • 3D: a 3-vector (x, y, z) • Orientation • 2D: an angle (0=right, 90=up, etc) • 3D: • an angle (if your character is always generally upright) • quaternion • rotation matrix • Euler angles • … • Linear Velocity: the speed the object is moving () • 2D: a 2-vector (Δx, Δy); Usually in units/s • 3D: a 3-vector (Δx, Δy, Δz); Usually in units/s • Rotational Velocity: the speed the object is rotating • Only needed if you have independent steering. • A rotation amount per second. • Rotation matrices are hard to use here. • Quaternions are especially nice for this.

  4. Boid Representation, cont. • Independent Steering? • For most characters, the orientation should match the direction of the linear velocity • Need a refresher on the math? • Sometimes, you do want a separate facing direction… • [optional] Max Speed (a scalar) • Useful to keep speed under control • Refresher (with vectors)? Image: http://www.atariage.com/screenshot_page.html?SoftwareLabelID=906

  5. Steering • Adjustments to current position / orientation • Two parts: • Linear (a force, ) • Update the position / velocity like this: • (this is Newton-Euler-1 Integration; Other approaches include Runga-Kutta-4 integration, Verlet integration, …) • Note: Unless Δt is infinitely small (which it isn't), the new position won't be exactly where it would be in real life.

  6. Steering, cont. • Rotational (a torque, T) • Only needed if you have independent steering • In 2D • Recall: • θ = orientation (an angle) • δ = rotational velocity (angles / s) • T = rotational acceleration (angles / s2)

  7. Steering, cont. • Rotational (a torque, T) • In 3D (I'm using quaternions for orientation, etc) • Recall: • Q = orientation (a quaternion) = [w, ] • δ = rotational velocity (a quaternion, rotation is in angles/s) • T = rotational acceleration (a quaternion, rotation is in angles / s2) • Note, to "combine" two quaternions you multiply (like you do with matrices), not add.

  8. Flocking overview • Every frame: • Generate 0 or more steerings (force vectors) • From a set of low-level behaviors • Seek • Flee • Wander • Avoid-another-boid • Align • Obstacle-avoid • Each force vector is created considering only that behavior • Combine these steerings into a single force vector • Apply it using the position-/velocity-update formula.

  9. Low-level behavior: Seek max_accel

  10. Low-level behavior: Flee max_accel

  11. Low-level Behavior: Wander • Approach #1: • Add random.uniform(-m, m) to heading. • Generate a force vector in this direction • Problem: tends to be "jittery" • Approach #2: • Every few seconds generate a new seek target. • Problem: can be abrupt. • Approach #3: • Place a target n units in the heading direction • Add random.uniform(-m,m) to it's rotation • This is relative to the heading direction • Seek towards this target • Usually a little less "jittery" • Even though the target itself is "jittery"

  12. Low-level behavior: Avoid-another-boid • Simple: • If within n units, flee • More advanced: • Predict if we'll collide, and if so steer to avoid • "Problem" cases: • Moving parallel to each other -- no collision! • Intersecting paths, but no hit. • Calculating the correction force vector. • Can also consider a "cone of vision"

  13. Low-level behavior: Align • Given: a direction vector. • Simple -- just accelerate in this direction!

  14. Low-level Behavior: Obstacle Avoid • One approach: Usually you want to modulate the force based on distance.

  15. Blending • Often, you have more than 1 steering force: • E.g. We want to take a meandering path towards a target: • Wander ~ 50% • Seek ~50% • Linear Blending • w1 + w2 + … + wn should equal 1.0 • Why?

  16. Blending, cont. • Problems: • Contradictory forces (Equlibria) • Oscillating: • If you gradually adjust weights, this shouldn't happen. • Near-sightedness • E.g. taking the wrong route in a maze. • Combine this with A* to get around this. • Behaviors that should take precedence: • E.g. Wall-avoid if we're close; otherwise, 0.5 wander, 0.5 seek. • Use a decision tree.

More Related