Boid | numerical model for bird 's flock ) simulation code

After some searching, I found out that scipy.spatial.distance is the correct spelling of the Module. Did you try import that?

The problems are a lot of draw calls. That is slow part of this program. In order to fix this, we can put all triangles into single vertex array and call draw upon only that array. That way we will speed up program. Problem with it is that you must implement your own rotate method. I implemented the method below and edited so the function returns triangles in single vertex array.

Copy the vector, then multiply it with the normal mult method

You are updating each boid one at a time. Some of the boids see the others move before they have a chance to. This means they never saw the other as close as the other saw them. This is the source of the asymmetry.

The problem lies in when the result of the separation call is applied to the boid's position.

You need to update all of the positions simultaneously. That is you need all of the separation calls to be done before you update the positions in reaction to the repulsive force.

Think of it like this I have two variables

I see nothing in this code that can cause an out of bounds access. However, you should not increment i on any loop iteration that removes an organism, otherwise you will skip the next organism in the list.

Imagine on the 1st loop iteration, the organism at index 0 needs to be removed. Subsequent organisms move down the list. On the next loop iteration, i gets incremented to 1, and the organism that had moved into index 0 is skipped.

Try this instead:

After a few days of struggle I finally got it working. I got the idea from this paper. Particularly this sentence:

Each boid considers its distance to other flock mates in its neighborhood and applies a repulsive force in the opposite direction, scaled by the inverse of the distance.

The code bellow does exactly what the above sentence says.

You really should not include those folders because they are dependent on your system and will most likely not work for other people (e.g., Mac vs Windows). Yes, a .gitignore (Note the spelling) is the way to go. There are many examples out there. Often when you create a Git Repo you can select to include one. However, it sounds like you already have a full git configured so it's best to push to an empty GitHub repo. Here's one that I often start with for Python projects: https://github.com/github/gitignore/blob/master/Python.gitignore

std::unique_ptr can't be copied, it doesn't have copy-constructor but has move constructor. You can use std::move to convert boid to rvalue then the move constructor could be used.

You can use std::find to check if an item already exists in a container. Or you could use a container that contains unique keys e.g. std::unordered_set.

You need to be very careful when storing addresses. If the object moves or goes out of scope the address becomes invalid. This is in fact what can happen in your example because std::vector will move objects around on resize.

Solutions:

• associate and store some unique identifier instead
• use std::unique_ptr (std::vector> boids;), this will ensure the object doesn't move (it's the smart pointer that moves)
• make boids vector or set const (initialize it on construction) and make sure the containing object (if any) doesn't move throughout your access via pointers.
• use a container that doesn't invalidate iterators on resize e.g. std::list

I tried doing it the std::unique_ptr way. It does not work when I try to push back the memory address

withinSensoryRange should be a vector of raw pointers: