Namespaces

Variants
Actions

Please note that as of October 24, 2014, the Nokia Developer Wiki will no longer be accepting user contributions, including new entries, edits and comments, as we begin transitioning to our new home, in the Windows Phone Development Wiki. We plan to move over the majority of the existing entries over the next few weeks. Thanks for all your past and future contributions.

Archived:Colisões de esferas em FlashLite

From Wiki
Jump to: navigation, search

Archived.pngAquivado: Este artigo foi arquivado, pois o conteúdo não é mais considerado relevante para se criar soluções comerciais atuais. Se você achar que este artigo ainda é importante, inclua o template {{ForArchiveReview|escreva a sua justificativa}}.

Não recomendamos o desenvolvimento em Flash Lite para aparelhos atuais da Nokia. Todos os artigos relacionados a Flash Lite foram arquivados. A plataforma Nokia Asha e os aparelhos recentes S40 não possuem mais o Flash Lite. O uso de Flash Lite em Symbian é limitado. Por exemplo, informações relativas à plataforma Nokia Belle podem ser encontradas neste link (em Inglês). Informações específicas de Flash Lite para aparelhos S40 ANTIGOS e Symbian podem ser encontradas na Flash Lite Developers Library (em Inglês).

Article Metadata

Artigo
Tradução:
Por ivocalado
Última alteração feita por hamishwillee em 14 May 2013

Este artigo descreve a física envolvendo o movimento de reação a colisões entre duas esferas. Primeiramente, será necessário um entendimento de trigonometria para calcular as novas direções e valocidades das esferas após as colisões.

Sabendo que Flash usa Radianos ao invés de graus, é necessário realizar a conversão, da seguinte forma:

degrees = radians * 180/Math.PI
radians = degrees * Math.PI/180

Fazendo uma analogia ao relógio, o ângulo 0º corresponde a três horas, 90º graus é doze horas e assim por diante.

Lembrepse que a função cosseno, definida como a razão entre o cateto adjacente pela hipotenusa, o seno como sendo a razão entre o cateto oposto pela hipotenusa e a tangente como sendo a razão entre o cateto oposto pelo cateto adjacente. Você pode ler mais sobre trigonometria aqui.

Isto é o bastante para entender o código abaixo.

/*
Project: Flash Lite Effort - Embedded Systems and Pervasive Computing Lab.
Author: Felipe Sampaio
Modified: 09/08/2009
*/

 
//Determina a distância entre o centro das bolas através do teorema de Pitágoras
dx = ball1._x - ball2._x;
dy = ball1._y - ball2._y;
distance = Math.sqrt(dx * dx + dy * dy);
 
//Se a distância é menos que ball1.radius + ball2.radius, as bolas colidiram.
if (distance <= (ball1.radius + ball2.radius)
collision(ball1, ball2);
 
function collision(ball1, ball2)
{
 
dx = ball1._x - ball2._x;
dy = ball1._y - ball2._y;
 
//Calcula o ângula da colisão dy/dx
colision_angle = Math.atan2(dy, dx);
 
//Calcula o vetor de velocidade de ambas as bolas.
speed1 = Math.sqrt(ball1.vx * ball1.vx + ball1.vy * ball1.vy);
speed2 = Math.sqrt(ball2.vx * ball2.vx + ball2.vy * ball2.vy);
 
//Calcula o ângulo formado pelo vetor velocidade de cada bola, sabendo sua direção.
direction1 = Math.atan2(ball1.vy, ball1.vx);
direction2 = Math.atan2(ball2.vy, ball2.vx);
 
//esta etapa é necessária porque nós temos boas que estão se movendo em um ambiente 2D (figura 1), então rotacionanto o componente x do vetor
//velocidade para ultrapassar a linha formada pelo centro das bolas. Com essa transformação dos eixos a colisão ocorre
//em um ambiente 1D (picture 2): em torno do eixo x.
vx_1 = speed1 * Math.cos(direction1 - colision_angle);
vy_1 = speed1 * Math.sin(direction1 - colision_angle);
vx_2 = speed2 * Math.cos(direction2 - colision_angle);
vy_2 = speed2 * Math.sin(direction2 - colision_angle);
 
//A unica coisa que precisamos resolver em uma colisão elática em torno do eixo x é a lei de conservação de momento.
//Sabendo que em uma colisão elástica a energia cinética permanece igual a antes do choque
// Deste modo temos um sistema isolado.
 
//speedAfterA = (speedBeforeA * (mA - mB) + 2 * mB * speedBeforeB)/(mA + mB)
//speedAfterB = (speedBeforeB * (mB - mA) + 2 * mA * speedBeforeA)/(mA + mB)
//if mA = mB, then:
//speedAfterA = speedBeforeB
//speedAfterB = speedBeforeA
 
final_vx_1 = ((ball1.mass - ball2.mass) * vx_1 + (ball2.mass + ball2.mass) * vx_2)/(ball1.mass + ball2.mass);
final_vx_2 = ((ball1.mass + ball1.mass) * vx_1 + (ball2.mass - ball1.mass) * vx_2)/(ball1.mass + ball2.mass);
 
//Nenhuma mudança ocorre porque este é um ambiente de colisão 1D.
final_vy_1 = vy_1;
final_vy_2 = vy_2
 
//É hora de converter de novo os valores de velocidades ao sistema padrão cartesiano.
//Math.PI/2 é usado por que o angulo entre vx e vy é sempre 90º.
ball1.vx = Math.cos(colision_angle) * final_vx_1 + Math.cos(colision_angle + Math.PI/2) * final_vy_1;
ball1.vy = Math.sin(colision_angle) * final_vx_1 + Math.sin(colision_angle + Math.PI/2) * final_vy_1;
ball2.vx = Math.cos(colision_angle) * final_vx_2 + Math.cos(colision_angle + Math.PI/2) * final_vy_2;
ball2.vy = Math.sin(colision_angle) * final_vx_2 + Math.sin(colision_angle + Math.PI/2) * final_vy_2;
 
}


Collision1.JPG

Figura 1

Collision2.JPG

Figura 2

This page was last modified on 14 May 2013, at 07:17.
257 page views in the last 30 days.

Was this page helpful?

Your feedback about this content is important. Let us know what you think.

 

Thank you!

We appreciate your feedback.

×