Optimize collision between particles

You are testing all particles against all other particles twice (i.e.% with% of% with% with% with% with% with%). Try them only once:

for(int i = 0 ; i<n ; ++i)
{
    m_particulas[i].andar();
    Particula &pi = m_particulas[i];

    for(int j = i+1 ; j < n ; ++j)
    {
        //if (i == j) continue;

        Particula &pj = m_particulas[j];

For this to be possible, do not make the particle walk after testing the collision. Instead, move the particles first, then start the tests (Q. Why are you moving each particle twice?):

// Primeiro move
for (int i = 0 ; i < n ; i++ )
    m_particulas[i].andar();

// Depois testa
for(int i = 0 ; i<n ; ++i)
{
    Particula &pi = m_particulas[i];

    for(int j = i+1 ; j < n ; ++j) ...

Calculating the square root is much slower than multiplication. Raise the equation of the entire distance squared so as to avoid this calculation:

bool Particula::testa_colisao (Particula &p)
{
    double dx = x() - p.x();
    double dy = y() - p.y();
    double dist2 = dx*dx + dy*dy;
    double somaRaios = r() + p.r()
    return dist2 <= somaRaios * somaRaios;
}

In% with%, make the particle walk at least once before testing again for collisions (since the first time it runs, it will always return i ):

...
normaliza(m_vx, m_vy);

do
{
    andar();
    p.andar();
} while (testa_colisao(p));

Divide your space into smaller areas, and do the calculation separately for each of these areas. For example, if your scenario is a square of [0,n] , create 9 squares of j (with some intersection between squares, so that a particle very close to the boundary is sure to be tested against the adjacent square) and place each particle in one or more squares. Update this with every move (it should be quick, as it is just a matter of comparing [0,n] and calcula_colisao positions - and if the number of sub-areas is large, you can do a binary search). When testing for collisions, consider only particles that are in the same square.

• Bonus: This is a good candidate for parallelization - create a separate process / thread to deal with each square. Just be careful that the overhead of managing competition does not nullify the benefit, this technique is only worth it if the number of particles is quite large.

Instead of searching for collisions with each simulation frame, store in another data structure the distances between each pair of particles divided by the sum of their velocities. This value corresponds to the minimum number of frames needed for a chance of these particles to collide. If at the time of collision testing this value is greater than or equal to true , decrease it and do not take the test - because it will surely return false. If it is smaller, test it and update the collision prediction (which may have increased, decreased, or stayed the same depending on the direction of the movement).

• Note: If your frames do not have fixed duration, adaptations may be necessary.

Whenever a particle collides with any other, its velocity may increase. You could that whole prediction matrix [for this particle] whenever that happened, but I imagine it would be too costly. A reasonable approximation might be to simply reduce all values proportionally (eg, speed increased from% to% with% of%, divide all predictions from collision to% with%).