Help with boids

hi, I'm trying to recreate Sebastian Lague's video on boids in Construct.

I have the first 2 rules (Separation and Alignment) working okay. Although the turning could use some work.

Any suggestions on making the turning not so jittery? or at least the concept I should approach? right now I'm just rotating 3 degrees in valid direction where no other boid is. I need it fast to make sure they avoid each other, but it seems like there needs to be some sort of ramp tied into how close the other boid is.

Also I sometimes get pairs swirling around each other endlessly... :/

drive.google.com/file/d/1e70farNbRKXZNyez9A2KMA9j870fUq_x/view

(see video I am trying to follow)

youtu.be/bqtqltqcQhw

Maybe switching the rotate towards angle with an angleLerp?

anglelerp(a, b, x) Linearly interpolate the angle a to b by x. Unlike the standard lerp, this takes in to account the cyclical nature of angles.

As a quick test I replaced your rotate toward angle with this:

-> boid: Set angle to anglelerp(Self.Angle,boids.Angle+3,0.01) degrees

and it looks to me a bit smoother - you can fiddle with the 0.01 value to change the rotation speed. Also I'm not sure the "boids.Angle+3" part of the lerp is the correct conversion for move "3 degrees towards".

mekonbekon

Thanks, it's a fun project to try to emulate..

I'm not sure anglelerp works because the angle+3 is not constant. It is updating a new angle every tick, also I think it has to be some calculation since it has to turn faster than 3 if the collision is very close.

So I think the anglelerp just makes it turn slower, which does make it looks less jittery.

Ideally I'm looking for less collisions.

dop2000 wow, that does look a lot smoother...looks like fish! I like how you tie in the new vector into the loop and I think you are looking for what is closer? cw or ccw? also great way to fix the 2 spinning off endlessly by randomizing the direction.

I'm no good at RegEx? (whatever its called) can you explain with this is doing?

(loopindex%2=0 ? dir : -dir)*loopindex

I just realized that the video I was following has the c# code included!

github.com/SebLague/Boids/blob/master/Assets/Scripts/Boid.cs

one thing I realize is that to find a new angle he uses SphereCast, which checks for a possible collision of the size of the boid rather than just a ray intersection. (its probably more important for him since he's in 3D). C3 doesn't have anything like that except Overlapping at Offset, but I'm not sure how efficient that is..I'm wondering if that would prevent more collisions?

also I am using bullet behavior whereas he manually calculates the speed/accel/dir. So maybe Bullet is no good here?

 velocity += acceleration * Time.deltaTime;
 float speed = velocity.magnitude;
 Vector3 dir = velocity / speed;
 speed = Mathf.Clamp (speed, settings.minSpeed, settings.maxSpeed);
 velocity = dir * speed;

 cachedTransform.position += velocity * Time.deltaTime;
 cachedTransform.forward = dir;
 position = cachedTransform.position;
 forward = dir;

(loopindex%2=0 ? dir : -dir)*loopindex

the % means modulo, or the remainder after dividing, so loopindex % 2 will be either 1 (if loopindex is odd) or 0 (if even)

the rest is an "if then else" statement

if the statement "loopindex%2=0" is true, then return what is in "dir"

if it is not true, it will return -dir

then the result is multiplied by loopindex

I haven't looked at Dop's sample yet, but was just starting to have fun with yours! :)

Hi all,

Inspired by your efforts I've been playing around with this over the last few days:

dropbox.com/s/kz9k3aqa9a723q4/flock.c3p

The group and align events seem to work pretty well, but I've got a problem with the avoid routine; at any avoidStrength above zero the birbs all head to the left of the screen and hug the wall.

Try with just the avoidStrength and avoidRange on.

The issue lies somewhere within events 24-29.

Rather than try and calculate a group-based avoidance angle, I've gone for a simpler approach by just reacting to the nearest neighbour. My thinking is: for each birb, pick the next nearest birb; if the neighbour is within avoidRange and in front then try to turn turn 0-45 degrees in the opposite direction from the neighbour.

Given that they all fall into a pattern it suggests there is some constant biasing their movement, but I can't pin it down. Any ideas?