Ir ao conteúdo
  • Cadastre-se
Wellington Tomaz

Trabalho em C++

Recommended Posts

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

Compartilhar este post


Link para o post
Compartilhar em outros sites

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.

Compartilhar este post


Link para o post
Compartilhar em outros sites

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}

Compartilhar este post


Link para o post
Compartilhar em outros sites

Crie uma conta ou entre para comentar

Você precisar ser um membro para fazer um comentário

Criar uma conta

Crie uma nova conta em nossa comunidade. É fácil!

Crie uma nova conta

Entrar

Já tem uma conta? Faça o login.

Entrar agora





Sobre o Clube do Hardware

No ar desde 1996, o Clube do Hardware é uma das maiores, mais antigas e mais respeitadas publicações sobre tecnologia do Brasil. Leia mais

Direitos autorais

Não permitimos a cópia ou reprodução do conteúdo do nosso site, fórum, newsletters e redes sociais, mesmo citando-se a fonte. Leia mais

×