Trabalho em C++

[Wellington Tomaz]

Meu trabalho é gerar bolinhas aleatórias, só que o problema é que não consigo fazer elas quicarem na parede ao invés de atravessá-la, e também não pode atravessar uma na outra, alguem poderia me ajudar, pra ver aonde está o erro?

 

Esse é o código das bolinhas, acredito eu que o erro está ai:

#include "particula.h"#include <stdlib.h> /* srand, rand */#include <cmath>Particula::Particula(){}void Particula::init(){m_r = 10;m_x = 900.0*rand()/RAND_MAX + 50;  m_y = 900.0*rand()/RAND_MAX + 50;m_vx = 2.0 * rand()/RAND_MAX - 1;  m_vy = 2.0 * rand()/RAND_MAX - 1;double norma = sqrt(m_vx*m_vx + m_vy*m_vy);m_vx /= norma;m_vy /= norma;}double Particula::x() const {  return m_x; }double Particula::y() const {  return m_y; }double Particula::r() const {  return m_r; }void Particula::andar(){m_x += m_vx;  m_y += m_vy;if(m_x > 1000) m_x += 1000;if(m_y > 1000) m_y += 1000;if(m_x < 0) m_x += 1000;if(m_y < 0) m_y += 1000;}

Obs.: também adicionei o arquivo completo do programa...

tp0.rar

[Edmorte]

Eu não uso Qt e nem conheço, mas por acaso eu estava estudando programação de jogos 2D e o bounce da tela é feito da seguinte forma:

 

1 - Cheque se o objeto já ultrapassou o limite, ou se preferir se ele começou a ultrapassar.

2 - Inverta o sentido do movimento.

 

Ou seja, quando ele começa a passar do limite da tela, mude o sentido para que a engine normalmente faça ele ir na direção contrária.

 

No caso se você uma uma velocidade de 10 pixeis * frameTime, você não incrementa|decrementa, mas multiplica ela por -1, o loop da janela ira fazer o trabalho de redirecionar a particula na direção correta, mantendo velocidade e angulo.

 

Já a colisão entre partículas é bem mais complexo, melhor ler um artigo de collision detection. Se forem círculos ou caixas é bem fácil de implementar.

[Wellington Tomaz]

Obrigado pela ajuda, a colisão com a parede eu já consegui fazer, agora falta somente a colisão entre as bolas.

[Edmorte]

Então se forem 2 círculos, a cada ciclo você tem que verificar se houve colisão.
 
Veja bem a teoria por trás da mágica, cada círculo tem um centro e um raio.
 
Para sabermos se os círculos estão colidindo precisamos calcular a norma do vetor representado pelos raios, desenhe os círculos se encostando para ver melhor. Claro que existem situações em que eles não se encostam, mas isso é não muda o fato de que existe um vetor que passa entre um centro e outro e os raios fazem projeção nesse vetor, a questão é justamente calcular essa projeção.
 
No caso dos raios, nós não vamos tirar a norma propriamente dita, pois já temos o tamanho, o raio em si. Vamos apenas elevar ao quadrado a soma entre eles para economizar uma operação futura de raiz.
 
Precisamos agora da distancia entre os centros, que também é um vetor, essa distância é dada pela diferença entre um centro e o outro. Agora sim é a norma, ou o comprimento do vetor: soma dos X ao quadrado + soma dos Y ao quadrado. Tira-se a raiz tem se o comprimento, mas como elevamos a soma dos raios ao quadrado, não vamos tirar a raiz.
 
Agora é só verificar SE distancia <= somaRaios ENTÃO colidiram.
 
* Não se esqueça de aplicar a escala do objeto se cabível na fórmula.
* Norma do vetor é o comprimento dele, sempre será um número escalar.
 
Um trecho de código se achar mais fácil pra entender, ele usa Direct3D.

 

//=============================================================================// Circular collision detection method// Called by collision(), default collision detection method// Post: returns true if collision, false otherwise//       sets collisionVector if collision//=============================================================================bool Entity::collideCircle(Entity &ent, VECTOR2 &collisionVector){    // difference between centers    distSquared = *getCenter() - *ent.getCenter();    distSquared.x *= distSquared.x;      // difference squared    distSquared.y *= distSquared.y;    // Calculate the sum of the radii (adjusted for scale)    sumRadiiSquared = (radius*getScale()) + (ent.radius*ent.getScale());    sumRadiiSquared *= sumRadiiSquared;                 // square it    // if entities are colliding    if(distSquared.x + distSquared.y <= sumRadiiSquared)    {        // Seu código aqui        return true;    }    return false;   // not colliding}