boids | Boids simulation using PyGame | Game Engine library

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.

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:

The reason why you are not seeing obvious performance gains from the Quadtree is because of the nature of your simulation. Currently, the default separation causes a large number of boids to "converge" to the same position.

Lots of objects in the same position is going to negate possible speedups due to spatial partitioning. If all the objects are in the same or near position, boids in the area a forced to check against all other boids in the area.

You can demonstrate to yourself that your Quadtree is working by watching or profiling your application with its default settings. Now turn separation up to maximum. You will see visually, or through profiling, that as the boids spread out more evenly, the FPS increases significantly. This is because the Quadtree can now prevent computations thanks to its spatial partitioning.

With default low separation:

With maximum separation:

You can see how performance is increased in the second image. Also note, that the conjecture by another commentor that it is the construction of the Quadtree (insert) that is taking up all the time is wrong.

While in some applications you may be able to update a Quadtree as things move around, since in this simulation every constituent moves every frame, reconstructing the Quadtree from scratch is less work, then taking every object out and reinserting it into its new position.

The advice to skip square-rooting and just use the distance-squared is good though as this will get you a bit more performance.