How to check for collision between particles?

So it seems the problem is more to check for collisions. A simple way is to check that the distance between the particles is less than the sum of their rays:

Somethinglike:

dist<(p1.r()+p2.r())

Ifthisistrue,theparticlep1collidedwithp2.

Fromthereyoucalculatethecollisionbetweentheparticles.Ifyou'regoingtodosomethingrealistic,youshouldtakealookat Linear Moment . If you consider that they have the same mass, it becomes simpler.

Based on the code you posted you can check the collision like this:

float temp_x, temp_y, dist;

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

    for(int j = 0; j < n; ++j)
    {
        if(i == j)
        {
            // Não verifica colisão entre a mesma partícula.
            continue;
        }
        else
        {
            // Verifica se a distância entre duas partículas é menor que 2.diametro,
            // se for é porque colidiu.
            Particula& p2 = m_particulas[j];

            temp_x = p2.x() - p1.x();
            temp_y = p2.y() - p1.y();

            dist = std::sqrt(temp_x * temp_x + temp_y * temp_y);

            if(dist < (p1.r() + p2.r()))
            {
                // Colidiram.
                // Nesse caso, elas devem mudar de direção.

                // Inverta a velocidade ou faça um metodo para colisão mais realístico.

                if(temp_x > temp_y)
                {
                    p1.invVx();
                    p2.invVx();
                }
                else
                {
                    p1.invVy();
                    p2.invVy();
                }                    

                break;
            }
        }
    }

    m_particulas[i].andar();
}

There are more efficient ways to check for collision between particles, but this is a simple and should help solve your problem.

If you want to delve deeper, this link has a similar but more realistic implementation, considering the mass of the particles and everything.

In C ++, the version presented by the link looks like this:

void Particula::colidir(Particula& p1, Particula& p2)
{
    // diferença entre as distâncias em x e y
    double dx = p1.x() - p2.x();
    double dy = p1.y() - p2.y();

    // angulo de colisão
    double col_angle = std::atan2(dy, dx);

    // módulo da velocidade
    double V1 = p1.velocity();
    double V2 = p2.velocity();

    // ângulo da direção
    double direction1 = std::atan2(p1.vy(), p1.vx());
    double direction2 = std::atan2(p2.vy(), p2.vx());

    // joga os cálculos para uma única dimesão para realizar
    // os cálculos.
    double vx_1 = V1 * std::cos(direction1 - col_angle);
    double vy_1 = V1 * std::sin(direction1 - col_angle);
    double vx_2 = V2 * std::cos(direction2 - col_angle);
    double vy_2 = V2 * std::sin(direction2 - col_angle);

    // calcula a velocidade final, considerando a massa das partículas.
    double final_vx_1 = ((p1.mass() - p2.mass()) * vx_1 + (p2.mass() + p2.mass()) * vx_2)/(p1.mass() + p2.mass());
    double final_vx_2 = ((p1.mass() + p1.mass()) * vx_1 + (p2.mass() - p1.mass()) * vx_2)/(p1.mass() + p2.mass());
    double final_vy_1 = vy_1;
    double final_vy_2 = vy_2;

    // retorna os cálculos para o 2d
    const double PI2 = 1.57079632679489661923132169163;
    p1.m_vx = std::cos(col_angle) * final_vx_1 + std::cos(col_angle + PI2) * final_vy_1;
    p1.m_vy = std::sin(col_angle) * final_vx_1 + std::sin(col_angle + PI2) * final_vy_1;
    p2.m_vx = std::cos(col_angle) * final_vx_2 + std::cos(col_angle + PI2) * final_vy_2;
    p2.m_vy = std::sin(col_angle) * final_vx_2 + std::sin(col_angle + PI2) * final_vy_2;
}

However, it should be noted that for this algorithm it still does not cover two situations:

Another detail: In your program, when you draw the particle, you use a 5-pixel border. Remove this border or add it to the radius because it influences the collision visualization.

You can investigate the following Qt classes to accomplish this task for you:

• QGraphicsScene
• QGraphicsItem

The two classes together offer collision detection capabilities, as demonstrated in the Colliding Mice :

The example uses QGraphicsScene::collidingItems() to check for collisions between the mice.