THALISSON CHRISTIANO DE ALMEIDA
IMPLEMENTAÇÃO DE JOGO PARA DISPOSITIVO DE TELEFONIA
MÓVEL SIMULANDO PRINCÍPIOS DA FÍSICA
JOINVILLE - SC
2010
ii
UNIVERSIDADE DO ESTADO DE SANTA CATARINA UDESC
CENTRO DE CIÊNCIAS TECNOLÓGICAS CCT
DEPARTAMENTO DE CIÊNCIA DA COMPUTAÇÃO
THALISSON CHRISTIANO DE ALMEIDA
IMPLEMENTAÇÃO DE JOGO PARA DISPOSITIVO DE TELEFONIA
MÓVEL SIMULANDO PRINCÍPIOS DA FÍSICA
Trabalho de conclusão de curso submetido à Universidade do Estado de Santa Catarina como parte dos requisitos para a obtenção do grau de Bacharel em Ciência da Computação. Orientador: Gilmário Barbosa dos Santos Co-Orientador: Santiago Viertel
JOINVILLE - SC
2010
iii
THALISSON CHRISTIANO DE ALMEIDA
IMPLEMENTAÇÃO DE JOGO PARA DISPOSITIVO DE TELEFONIA
MÓVEL SIMULANDO PRINCÍPIOS DA FÍSICA
Trabalho aprovado como requisito parcial para obtenção do grau de bacharel, no curso de graduação em Ciência da Computação da Universidade do Estado de Santa Catarina.
Banca Examinadora:
Orientador: _________________________________________________
Mestre Gilmário Barbosa dos Santos
Co-Orientador: _________________________________________________
Bacharel Santiago Viertel
Membro: _________________________________________________
Mestre Carlos Norberto Vetorazzi Jr.
Membro: _________________________________________________
Doutor Roberto Silvio Ubertino Rosso Jr.
iv
AGRADECIMENTOS
Agradeço a Deus pela paciência dada.
Agradeçõ a minha família pelo apoio e carinho, dos quais foram necessários para
seguir em frente.
Agradeço os meus amigos Santiago Viertel e Fabiano Naspolini de Oliveira, que
nunca deixaram eu desistir do trabalho e nem do curso. Agradeço a eles também
pela ajuda que deram no desenvolvimento deste TCC.
Agradeço ao meu orientador Gilmário Barbosa dos Santos, que independente das
minhas falhas e dos meus erros, sempre me ajudou com bom humor.
v
RESUMO
Este trabalho tem como objetivo aplicar uma técnica de simulação de física e aplicá-la em um jogo de celular. O principal desafio consiste em aliar recursos da física proporcionando um realismo adequado no tratamento de colisões com as limitações de processamentos das plataformas de dispositivos móveis. No intuito de validar a solução proposta, criar um protótipo de jogo 3D e realizar testes funcionais e de desempenho em celulares.
Palavras-Chave: Simulação Física. Jogo. Dispositivo móvel. Ambiente 3D.
vi
LISTA DE ILUSTRAÇÕES
Figura 1. Os vários tipos de contato entre a bola e o terreno são modelados através de impulsos (MIRTICH, 1996). .............................................................................................. 3 Figura 2. Resposta de Colisão usando Projeção (ATENCIO, 2005)............................... 9 Figura 3. Tratamento de Colisão com atrito usando projeção e modificação da velocidade tangencial (JAKOBSEN, 2001) ....................................................................... 10 Figura 4. Fluxo do Sistema (HAHN, 1988) ........................................................................ 11 Figura 5. Normais nos pontos de contato (Hahn, 1988) ................................................. 12 Figura 6. Impulso normal e impulso tangente na colisão (KAWACHI, 1997) .............. 15 Figura 7: Movimento Indesejado e Desejado causado pelo atrito (KAWACHI, 1997)17 Figura 8. Procura por um plano de separação, onde apenas um plano satisfaz a condição (BARAFF; WITKIN, 1997). .................................................................................. 21 Figura 9. Definição das faces (BARAFF; WITKIN, 1997). .............................................. 21 Figura 10. Campo de Golfe modelado no Blender ........................................................... 27 Figura 11. Cenários do Campo de Golfe sendo executado no emulador Java Wireless ToolkitTM para J2ME .............................................................................................. 28 Figura 12. Um ciclo no Método de Euler (BOURG, 2002). ............................................. 33 Figura 13. Objeto com detecção de colisão errônea ....................................................... 36 Figura 14. Fluxo da Simulação Física da dinâmica do Movimento .............................. 40 Figura 15. Ciclo de Vida de uma MIDlet (SUN, 2010) .................................................... 42 Figura 16. Modelagem da classe Principal ....................................................................... 43 Figura 17. Fluxograma do startApp() ................................................................................. 44 Figura 18. Modelagem da classe Jogo ............................................................................. 44 Figura 19. Diagrama de estados da classe Jogo ............................................................ 45 Figura 20. Fluxograma do construtor da classe Jogo ..................................................... 46 Figura 21. Fluxograma do processo principal do jogo, este executado no método run() .......................................................................................................................................... 47 Figura 22. Modelagem da Classe Bola ............................................................................. 48 Figura 23. Fluxograma do construtor Bola() ..................................................................... 50 Figura 24. Fluxograma do método calculaVento() .......................................................... 50 Figura 25. Algoritmo de detecção de colisão. .................................................................. 51 Figura 26. Fluxograma do método detactarColisao() ..................................................... 52 Figura 27. Verificação de uma bola rasteira. ..................................................................... 53 Figura 28. Fluxograma do método verificaRasteiro() ....................................................... 54 Figura 29. Realocação da bola após detectada colisão .................................................. 55 Figura 30. Fluxograma do método integrar() ..................................................................... 56 Figura 31. Modelo original (A) e o Modelo final (B) .......................................................... 57 Figura 32. Ação e Reação .................................................................................................... 68 Figura 33. Esquema do Atrito, onde uma força F é aplicada. ........................................ 72
vii
LISTA DE ABREVIATURAS
3D Tridimensional
API Aplication Programming Interface
FPS Frames per Seconds (Frames por Segundos)
J2ME JavaTM 2 Micro Edition
M3G Mobile 3D Graphics
MRU Movimento Retilíneo Uniforme
MRUV Movimento Retilíneo Uniformemente Variável
viii
SUMÁRIO
1 INTRODUÇÃO ..................................................................................................................... 1 1.1 OBJETIVOS ..................................................................................................................... 4
1.1.1 Objetivo Geral ........................................................................................................... 4
1.1.2 Objetivos Específicos ................................................................................................ 4
1.2 ESTRUTURA DO TRABALHO ..................................................................................... 4
2 TRABALHOS RELACIONADOS ...................................................................................... 6 2.1 MÉTODOS DE INTEGRAÇÃO...................................................................................... 6
2.1.1 Integração de Euler .................................................................................................... 6
2.1.2 Integração de Verlet................................................................................................... 6
2.2 TRATAMENTO DE COLISÃO ...................................................................................... 8
2.2.1 Tratamento de Atrito ................................................................................................. 9
2.3 ANIMAÇÃO REALISTICA DE CORPOS RÍGIDOS .................................................. 10
2.3.1 Dinâmica de Impacto ............................................................................................... 12
2.4 SIMULAÇÃO DE MOVIMENTO DE CORPOS RÍGIDOS COM FORÇA DE
ATRITO IMPULSIVO ......................................................................................................... 13
2.4.1 Impulso do Atrito .................................................................................................... 15
2.5 SIMULAÇÃO DE CORPOS RÍGIDOS BASEADO EM IMPULSOS ......................... 17
2.6 DETECÇÃO DE COLISÃO DE CORPOS RÍGIDOS .................................................. 20
3 PROJETO DA FÍSICA DO JOGO .................................................................................... 25 3.1 FERRAMENTAS E LINGUAGEM UTILIZADAS ..................................................... 26
3.2 MODELAGEM DO CENÁRIO ..................................................................................... 26
3.2.1 Terreno..................................................................................................................... 26
3.2.2 Elementos ................................................................................................................ 28
3.3 COMPORTAMENTO FÍSICO ...................................................................................... 28
3.3.1 Bola de Golfe ........................................................................................................... 29
3.3.2 Forças ...................................................................................................................... 29
3.4 ALGORITMOS DE COLISÃO ..................................................................................... 29
3.4.1 Detecção de Colisão ................................................................................................ 30
3.4.2 Resposta de Colisão ................................................................................................. 31
3.5 INTEGRAÇÃO .............................................................................................................. 32
3.6 PARÂMETROS ............................................................................................................. 36
3.6.1 Coeficientes de Restituição ..................................................................................... 37
3.6.2 Coeficientes de Atrito .............................................................................................. 37
3.7 CONSIDERAÇÕES FINAIS DO CAPÍTULO .............................................................. 38
4 DESENVOLVIMENTO ...................................................................................................... 42 4.1 IMPLEMENTAÇÃO ..................................................................................................... 42
4.1.1 Classes Desenvolvidas ............................................................................................. 42
4.1.2 Dificuldades e Mudança no Projeto......................................................................... 56
4.2 TESTES .......................................................................................................................... 58
5 CONCLUSÃO ...................................................................................................................... 62
ix
5.1 CONSIDERAÇÕES FINAIS ......................................................................................... 62
5.2 TRABALHOS FUTUROS ............................................................................................. 64
REFERÊNCIAS BIBLIOGRÁFICAS ................................................................................. 65
ANEXOS ................................................................................................................................. 67
ANEXO A: CONCEITOS FÍSICOS .................................................................................... 67 A.1 CORPOS RÍGIDOS ...................................................................................................... 67
A.2 AS TRÊS LEIS DE NEWTON ..................................................................................... 67
A.3 MOVIMENTO RETILÍNEO......................................................................................... 68
A.4 MOMENTO ................................................................................................................... 69
A.5 IMPULSO ...................................................................................................................... 70
A.6 COLISÃO ...................................................................................................................... 70
A.7 ATRITO ......................................................................................................................... 71
1
1 INTRODUÇÃO
As simulações físicas não são triviais para serem implementadas,
principalmente na área de jogos eletrônicos onde é primordial o bom desempenho
durante o processamento do jogo. Segundo Crawford (1982), jogo é um sistema
formal fechado que subjetivamente representa uma parte de uma realidade.
Fechado porque tudo que é preciso para que o jogo exista é encontrado dentro dele.
Formal porque eles têm regras explícitas. É um sistema porque seus elementos
interagem entre si. Finalmente, a afirmação “subjetivamente representa uma parte
de uma realidade” significa que os jogadores necessitam ter uma imersão numa
realidade subjetiva, ou seja, uma realidade criada pelas próprias mentes dos
jogadores. No caso dos jogos eletrônicos, um computador age como um juiz,
garantindo que as regras do jogo sejam respeitadas, assim como pode agir como
um oponente. O computador também é responsável por exibir uma representação
do jogo ao jogador, sendo na maioria das vezes animações gráficas que ajudarão o
jogador a imergir na realidade do jogo.
Devido ao aumento de processamento dos computadores, os gráficos e
animações computadorizadas estão cada vez mais próximos da realidade, logo,
permite criar imagens mais realistas. Segundo o dicionário Aurélio (2001), realismo é
o atributo do que é real, ou seja, é uma métrica subjetiva que demonstra o grau de
semelhança entre o objeto modelado e o real. Porém, para se fazer algum tipo de
animação realista é necessário que os elementos obedeçam às leis da física, como,
por exemplo, dois corpos não podem ocupar o mesmo lugar no espaço ao mesmo
tempo (ATENCIO, 2005).
A cinemática e a dinâmica são partes da física que estudam os movimentos
dos corpos e as forças que os regem. Para isso, é essencial conhecer as três leis
que regem a dinâmica, também conhecidas como as leis de Newton (ATENCIO,
2005):
Lei da Inércia: um corpo em repouso em relação à uma referência
inercial permanecerá em repouso, assim como um corpo em movimento
permanecerá em movimento e com velocidade constante na ausência de forças
externas. Conceitua-se força como qualquer influência que altera o movimento de
um corpo e velocidade é a razão segundo a qual sua posição varia com o tempo
(HALLIDAY,1981). A propriedade da Inércia de um corpo é caracterizada pela
2
massa e quanto maior a massa, mais força será necessário para movê-lo
(MCKELVEY, 1978);
Lei da Força: a mudança do movimento é proporcional à força aplicada
que a causou;
Lei da Ação e Reação: para toda força exercida em um corpo, este
exerce uma força de mesmo módulo e direção, todavia em sentido oposto
(HALLIDAY,1981).
BOURG (2002) descreve que existem cinco passos para a modelagem da
física em jogos:
1. Definir o que exatamente será modelado possibilitando uma melhor
imersão no jogo, pois uma simulação desnecessária gera um
desperdício no tempo de processamento do software;
2. Definir o comportamento dos elementos que serão modelados, ou
seja, deve-se ter em mente qual será o comportamento do objeto a
ser modelado. Por exemplo, se o objeto possui um comportamento
de um corpo rígido (que não se deforma), ou corpo deformável;
3. Identificar a distinção entre detecção e resposta de colisão.
Detecção de colisão é um problema geométrico computacional,
cujo propósito é saber se dois ou mais objetos colidiram. Já a
resposta de colisão é um problema físico que envolve o movimento
de dois ou mais objetos após a colisão;
4. Resolver equações diferenciais para a simulação de movimento de
corpos rígidos. Isso pode ser feito através de métodos analíticos ou
utilizando integração numérica como por exemplo, o Método de
Euler;
5. Definir corretamente os parâmetros envolvidos na simulação física.
Por exemplo, a massa do corpo, coeficiente de restituição (indica a
dissipação de energia durante a colisão), entre outras
características.
Muitos autores propuseram técnicas que garantem uma precisão considerável
nos cálculos da simulação física. Entretanto na área de jogos por computador,
precisão pode não ser o objetivo principal, mas sim o realismo para manter o jogador
imerso e aumentar a velocidade de execução do algoritmo para liberar o
processador para dedicar-se às outras tarefas do jogo (JAKOBSEN, 2001).
3
Uma das técnicas de simulação física que possui destaque devido ao seu
rápido processamento é o método baseado em impulso (MIRTICH, 1996), que
modela todas as forças através de séries de impulsos. Impulso é o produto de uma
força aplicada por um período de tempo (YOUNG, 2003). Usando o exemplo
ilustrado na Figura 1, a bola recebe uma série de impulsos enquanto colide com o
terreno e fica saltando após a rampa.
Figura 1. Os vários tipos de contato entre a bola e o terreno são modelados através de
impulsos (MIRTICH, 1996).
Este trabalho está focado na simulação física que inclui tratamento de colisão,
com ênfase na resposta de colisão de corpos rígidos, estes sofrendo ações das
forças de gravidade e atrito em um ambiente 3D. Entenda-se simulação física como
a reprodução dos efeitos físicos num ambiente virtual. Gravidade é a força de
atração mútua entre as massas. Um exemplo seriam os efeitos das marés que
ocorrem devido a Lua exercer uma força de atração sobre as águas. Atrito é uma
força que age em sentido contrário ao do movimento e ocorre quando dois corpos
estão em contato. Neste caso, um exemplo são as pessoas poderem ficar paradas
numa superfície íngreme sem escorregar. Isto ocorre devido à força de atrito que
age de forma contrária ao movimento (MCKELVEY, 1977).
A técnica aplicada deve resultar em um algoritmo eficiente num protótipo de
jogo para um aparelho celular. Considerando a plataforma em questão, ressalta-se a
limitação de processamento das diversas plataformas de hardware para dispositivos
móveis. Tal motivação justifica-se pelo fato de que entidades como o Governo do
Estado de Santa Catarina, FINEP (Financiador de Estudos e Projetos), FAPESC
(Fundação de Apoio à Pesquisa Científica e Tecnológica de Santa Catarina) estão
financiando a área de desenvolvimento de jogos, abrindo o projeto SC Games. Além
disso, segundo a reportagem de Dalmasco publicada na revista Exame edição 937
(Fev 2009) existe uma tendência de aumento de 20% no mercado de jogos casuais
4
(jogos simples com pouca duração) para celulares e a área atualmente movimenta
2,7 bilhões de dólares por ano (DALMASCO, 2009).
1.1 OBJETIVOS
1.1.1 Objetivo Geral
Aplicar uma técnica que simule de forma eficiente e realista a física envolvida
na colisão de objetos 3D rígidos em um protótipo de jogo para celular.
1.1.2 Objetivos Específicos
1. Fazer um levantamento bibliográfico sobre o uso de simulação física em
jogos de celulares;
2. Estudar a física da dinâmica de colisão bem como as variáveis físicas
(gravidade, atrito e impulso) envolvidas;
3. Projetar a técnica de simulação física;
4. Implementar a técnica de simulação física;
5. Avaliar a técnica de simulação física em celulares.
1.2 ESTRUTURA DO TRABALHO
Este trabalho de conclusão de curso está disposto em 5 capítulos.
O capítulo 1 apresenta a introdução, os objetivos, motivações e a estrutura
deste trabalho.
O capítulo 2 apresenta os trabalhos relacionados com conceitos e estratégias
que foram utilizados no desenvolvimento este trabalho de conclusão de curso.
O capítulo 3 apresenta o projeto da solução adotada para este trabalho de
conclusão de curso, utilizando a metodologia descrita por Bourg (2002), que inclui as
definições dos elementos, os algoritmos que serão utilizados, o método de
integração e os parâmetros escolhidos.
O capítulo 4 apresenta o desenvolvimento, cujo enfoque é a descrição de
como foi implementado o jogo, bem como suas classes e algoritmos. Também são
demonstrados os testes realizados quanto ao desempenho da aplicação proposta,
além das dificuldades encontradas durante a realização da pesquisa.
O capítulo 5 apresenta a conclusão deste trabalho, assim como os possíveis
trabalhos futuros.
5
A título de breve revisão, no Anexo 1 encontra-se um rol de conceitos básicos
de física (tais como: momento, impulso, colisão e atrito) pertinentes ao
desenvolvimento deste trabalho.
6
2 TRABALHOS RELACIONADOS
Este capítulo relata alguns trabalhos relacionados ao tema explorado nesta
monografia de conclusão de curso.
2.1 MÉTODOS DE INTEGRAÇÃO
Para simular a movimentação dos corpos é necessário utilizar métodos
numéricos. O objetivo dos métodos de integração é obter os valores dos parâmetros
dos objetos, como velocidade e posição através das próprias derivadas (ATENCIO,
2005).
Os métodos numéricos calculam os parâmetros de forma iterativa. Um
exemplo é utilizar a equação do Movimento Retilíneo Uniforme (Equação 20) para
calcular a posição de um objeto: tendo o mesmo na posição x, com uma velocidade
y e um período de tempo, é possível encontrar a nova posição em x’. Na próxima
iteração, usando a posição x’ é calculada a próxima posição x’’ e assim por diante.
2.1.1 Integração de Euler
O método de Euler é baseado no Teorema de Taylor que permite aproximar
uma função utilizando-se de informações já encontradas e utilizá-las para derivar as
novas informações (BOURG, 2002).
Normalmente cada partícula possui duas variáveis principais: sua posição
x
e sua velocidade
v . Então, em cada ciclo, uma nova posição '
x e velocidade
'v são
computadas aplicando os conceitos de Movimento Retilíneo Unifome (Equação 20) e
Movimento Retilíneo Uniformemente Variável (Equação 22), sendo Δt o tempo do
ciclo e
a a aceleração que será aplicada no sistema. Esse processo é conhecido
como Integração de Euler (JAKOBSEN, 2001).
2.1.2 Integração de Verlet
Diferente do método de Euler, o método de Verlet em vez de armazenar a
posição e velocidade, armazena-se a posição atual
x e a posição anterior '
x .
Mantendo o tempo de ciclo fixo, o passo de integração é o seguinte:
7
xx
taxxx
:*
.*2' 2
(1)
Onde:
'
x é a nova posição do objeto após o cálculo;
x é a posição atual do objeto;
*x é a posição anterior do objeto;
a é a aceleração;
t é o tempo de duração de um ciclo.
O método de integração de Verlet é muito usado em simulações moleculares.
É estável, uma vez que a velocidade é implicitamente dada e, consequentemente,
torna-se difícil perder a sincronia entre a velocidade e a posição. Isso se deve que
na Equação 1, a expressão
*2 xx pode ser substituída pela expressão )*(
xxx .
Sendo que a expressão
*xx é a distância que o objeto percorreu durante o último
intervalo de tempo, conclui-se que a velocidade está inclusa de forma implícita na
Equação 1. O método de Verlet não é sempre preciso, todavia é rápido e estável
(JAKOBSEN, 2001).
Jakobsen (2001), explica as diferenças entre o método de Euler e de Verlet.
Também neste mesmo trabalho foi utilizado o método de integração de Verlet.
O quadro 1 mostra o código de implementação da Integração de Verlet em
C++:
8
Quadro 1. Implementação do Método de Verlet (JAKOBSEN, 2001)
2.2 TRATAMENTO DE COLISÃO
No ponto de vista computacional, uma colisão ocorre quando existe uma
interpenetração entre objetos (ATENCIO, 2005). Assim, quando se deseja que um
corpo possua a característica da impenetrabilidade, é necessário que seja realizado
o processo de tratamento de colisão.
// Código de exemplo para simulação física
class ParticleSystem {
Vector3 m_x[NUM_PARTICLES]; // Posições Atuais
Vector3 m_oldx[NUM_PARTICLES]; // Posições Anteriores
Vector3 m_a[NUM_PARTICLES]; // Acumuladores de Forças (ou aceleração)
Vector3 m_vGravity; // Gravidade
float m_fTimeStep;
public:
void TimeStep();
private:
void Verlet();
void SatisfyConstraints();
void AccumulateForces();
// (Construtores, inicializações etc. omitidos)
};
// Verlet integration step
void ParticleSystem::Verlet() {
for(int i=0; i
9
Esse tipo de tratamento possui dois passos: a detecção e a resposta de
colisão. O primeiro é um problema de geometria computacional que envolve
identificar se dois objetos ou mais estão colidindo e onde isto ocorre. O último,
resposta de colisão, é um problema físico que envolve o movimento de dois ou mais
objetos após a colisão (BOURG, 2002). Neste trabalho, será necessária a escolha
de um algoritmo de detecção de colisão, mas o foco estará no tratamento da
resposta de colisão.
Em Thomas Jakobsen (2001), a estratégia de tratamento de colisão neste
trabalho relacionado faz uso da projeção. Ao ser detectada a colisão, o objeto é
deslocado para fora do obstáculo. Isto é ilustrado na Figura 2, onde possui uma
esfera caindo na superfície. Quando ela penetra a plataforma, será iniciado o
processo de tratamento de colisão.
Figura 2. Resposta de Colisão usando Projeção (ATENCIO, 2005)
No conceito computacional, ocorre uma colisão quando um corpo está
penetrado em um outro, no caso do exemplo da Figura 2, os corpos são a esfera e a
superfície. Então, o primeiro passo é separar os dois corpos que estão colidindo.
Para isso, projeta-se a esfera na direção normal da superfície (perpendicular a
superfície), até que não haja mais contato. Após os objetos serem separados,
aplicam-se os efeitos físicos desejados, como o impulso gerado pela colisão e o
atrito.
2.2.1 Tratamento de Atrito
Segundo o modelo de atrito de Coulomb (Equação 28), a força de atrito
depende da intensidade da força normal entre os objetos em contato. Para
implementar o tratamento de atrito, mede-se a profundidade de penetração dp
quando ocorrer tal evento (antes de projetar o objeto para fora do obstáculo). A
profundidade de penetração é a distância entre o ponto de colisão e a posição do
objeto penetrante, ou seja, a distância que o objeto será deslocado ao ser projetado.
10
Após projetá-lo, a velocidade tangencial vt é reduzida proporcionalmente ao dp. A Lei
do atrito de Coulomb (Equação 28) foi adaptada por Jakobsen, obtendo-se a
Equação 2:
pt dv .' (2)
Onde v’t é o módulo da velocidade tangencial à superfície. Assim como na Lei
do atrito de Coulomb (Equação 28), deve-se ter cautela para que a velocidade
tangencial não inverta o sentido do movimento. Caso ocorra este evento, significa
que a força de atrito é grande o suficiente para parar o objeto. Logo, a velocidade
tangencial resultante é zero.
A Figura 3 demonstra a idéia básica, onde (a) mede-se a profundidade de
penetração, (b) o objeto é projetado para fora da superfície e (c) a velocidade
tangencial é reduzida de acordo com a Equação 2.
(a) (b) (c)
Figura 3. Tratamento de Colisão com atrito usando projeção e modificação da velocidade
tangencial (JAKOBSEN, 2001)
2.3 ANIMAÇÃO REALISTICA DE CORPOS RÍGIDOS
James K. Hahn (1988) teve como objetivo apresentar um sistema de
simulação capaz de modelar de forma realística a dinâmica de movimentos de
corpos rígidos.
Para cada objeto na cena a ser simulada são atribuídas características físicas
como forma, coeficientes de restituição, coeficientes de atrito, entre outros.
Utilizando as variáveis atuais da dinâmica do objeto, determinam-se as
variáveis da dinâmica em um tempo infinitesimal depois. Essa atualização é feita em
dois passos. Primeiramente, os objetos são movidos utilizando os valores das
11
variáveis atuais. Isso envolve resolver a nova posição do objeto utilizando alguma
solução numérica, como o método de Euler explicado na seção 2.1.1, por exemplo.
Em seguida, é verificado se existem intersecções entre os objetos. Caso ocorram, as
variáveis dos objetos envolvidos são calculadas utilizando a dinâmica de impacto,
esta descrita na seção 2.2.1.
A Figura 4 ilustra o fluxo do sistema desenvolvido por Hahn (1988).
Primeiramente são definidos os atributos físicos, como a forma do objeto, massa,
coeficiente de atrito e coeficiente de restituição. Em seguida, inicia-se o ciclo com a
saída dos dados, onde ocorrem as transformações de objetos e as alterações dos
atributos da câmera. Após este processo, é realizada a atualização da velocidade e
posição, cujo método necessita de informações como a velocidade atual e a posição
atual, assim como a posição de outros objetos e forças externas. Então se utiliza a
detecção de colisão e os tratamentos necessários são realizados. Depois, inicia-se
novamente o ciclo, atualizando o tempo.
Figura 4. Fluxo do Sistema (HAHN, 1988)
12
2.3.1 Dinâmica de Impacto
Uma análise do processo de impacto entre dois corpos rígidos foi proposta
por Routh no final do século XIX, que inclui o efeito de atrito usando o modelo de
Coulomb (Equação 28) e materiais parcialmente elásticos.
Quando dois corpos colidem e a área de contato é localmente plana, pode-se
definir a normal
N da superfície utilizando a superfície tangente de contato entre os
dois corpos. Se a superfície de contato não pode ser definida para o impacto, o
resultado é teoricamente indeterminado. A proposta de Hahn(1988) foi localizar um
vetor médio utilizando os vetores normais dos polígonos vizinhos para ser utilizado
como o vetor normal da colisão. A Figura 5 demonstra algumas normais em relação
aos planos.
Figura 5. Normais nos pontos de contato (Hahn, 1988)
No processo de impacto, os corpos interagem, conforme a terceira lei de
Newton disponível no Anexo A.2, com um impulso
I , cuja definição é descrita na
Equação 24. Como o intervalo de tempo Δt é muito curto, qualquer força externa,
como a gravidade, não influencia no impulso
I . Logo, significa que o tempo de
colisão é curto suficiente para que forças externas influenciem significativamente .
Ambos os corpos recebem o impulso
I , todavia em sentidos opostos, como
demonstram a Equação 3 e Equação 4, estas obtidas a partir do Princípio da
Conservação do Momento.
13
1111 )'.( Ivvm (3)
2222 )'.( Ivvm (4)
onde:
12 II
Então, ao utilizar a equação do Coeficiente de Restituição (Equação 27),
obtém-se o sistema de equação necessário para calcular as novas velocidades.
Para adicionar o efeito de atrito entre os dois corpos no momento do impacto,
utiliza-se a lei do atrito de Coulomb (Equação 28).
2.4 SIMULAÇÃO DE MOVIMENTO DE CORPOS RÍGIDOS COM FORÇA DE
ATRITO IMPULSIVO
No trabalho realizado por Kawachi et al (1997) foi desenvolvido um algoritmo
para simulação dos impulsos de colisão com atrito entre os corpos rígidos.
Em sistemas sem atrito, um impulso de colisão pN
n age entre os corpos em
colisão, onde
n é o vetor unitário perpendicular ao plano de colisão e pN é o valor
escalar do impulso. A mudança da velocidade causada pelo impulso é dada pela
Equação 5:
m
npvv N
' (5)
O autor utiliza a velocidade normal relativa do objeto como condição para
colisões sem penetração. Se a velocidade normal relativa
NV for menor que zero,
significa que os objetos estão colidindo. Caso 0
NV , indica que eles estão em
contato e 0
NV equivale que estão se afastando.
NV é definido utilizando a
velocidade escalar do corpo a AV , juntamente com a velocidade do corpo b BV :
14
).( BAN vvnv
(6)
Já a velocidade normal relativa NV
' , depois da colisão é definida pela
Equação 7 (Kawachi,1997):
NNN
NNBAN
BAN
vpcv
vpccnv
vvnv
.'
)..('
)''.('
(7)
Onde
c é uma constante da velocidade normal relativa utilizada para facilitar
a dedução para a próxima fórmula.
Se houver n pontos de colisões simultaneamente, a Equação 7 pode ser
expandida para Equação 8 (Kawachi,1997):
n
j
NNijN ijivpAv
1
' (8)
Onde Niv
é a velocidade normal relativa antes da colisão no iésimo ponto de
colisão, Niv
' é a velocidade normal relativa após a colisão, pN é o módulo do
impulso de colisão e a matriz Aij é a constante
c calculada a partir dos pontos de
colisões. Assim, a Equação 8 pode ser simplificada para uma forma geral (Equação
9):
vApv ' (9)
Onde:
15
nxn
ij
nT
nNN
nTnNN
nT
nNN
RAA
Rppp
Rvvv
Rvvv
)(
),...,(
),...,(
)',...,'('
1
1
1
Ou seja, v’, v e p serão matrizes unidimensionais contendo respectivamente
as velocidades finais, as velocidades iniciais e os módulos do impulso da colisão,
enquanto A é a matriz Aij vista na Equação 8.
2.4.1 Impulso do Atrito
Se dois objetos estão em contato e deslizando, a força de atrito será aplicada
no ponto de colisão dos objetos. Similarmente, se os dois objetos estão colidindo e
deslizando, tanto o impulso da colisão quanto o impulso da força de atrito pT
t , onde
t é o vetor unitário tangente serão aplicados (Figura 6).
Figura 6. Impulso normal e impulso tangente na colisão (KAWACHI, 1997)
A relação entre a velocidade normal e tangente e as variáveis de impulso
pode ser escrita de maneira semelhante à Equação 9, onde as velocidades
tangentes
Tv' ,
Tv e o impulso tangente pT são adicionados aos vetores v’, v e p,
como mostra a Equação 10:
16
vApv ' (10)
Onde:
nnx
ij
nT
TnNN
nTTnNN
nT
TnNN
RAA
Rpppp
Rvvvv
Rvvvv
n
n
n
22
2
1
21
2
1
)(
),,...,(
),,...,(
)',',...,'('
Se a velocidade tangencial relativa entre os dois objetos não for igual a zero,
utiliza-se o coeficiente de atrito dinâmico. Caso contrário, utiliza-se o coeficiente de
atrito estático. Para o cálculo, é utilizada a lei de Coulomb (Equação 28).
Os dois casos citados assumem que o sinal da velocidade relativa tangencial
mantém-se inalterado no período de colisão. Entretanto, caso o sinal mude, significa
que o tipo de atrito mudou entre estático e dinâmico. Esse caso é de resolução
complexa quando se tratam de colisões simultâneas. Buscando simplificar os
cálculos, Kawachi et al(1997) assume que a velocidade dos objetos não muda
durante o período de colisão, mas sim de forma descontínua no fim do mesmo.
No atrito estático, a força de atrito é somente o suficiente para manter a
velocidade tangencial relativa do objeto igual a zero. A força de atrito máximo é
definido pela lei de Coulomb. Caso o valor máximo não seja mais suficiente para
manter a velocidade relativa tangencial igual a zero, então o atrito passará a ser
dinâmico.
No atrito dinâmico, caso a velocidade relativa tangencial seja pequena, a
força de atrito calculada poderá criar um efeito indesejado, como se o objeto
estivesse colidido numa parede invisível (Figura 7). Isso ocorre porque o valor
calculado para a força de atrito supera a tendencidade do objeto. Para evitar esse
efeito, quando a velocidade relativa tangencial atingir zero, deixa-se de utilizar o
atrito dinâmico e usa-se o estático.
17
Figura 7: Movimento Indesejado e Desejado causado pelo atrito (KAWACHI, 1997)
2.5 SIMULAÇÃO DE CORPOS RÍGIDOS BASEADO EM IMPULSOS
No trabalho realizado por Mirtich (1996) é abordada uma simulação física
baseada em impulso, onde todos os tipos de contatos (colisão, deslizamento,
repouso) são modelados através de séries de impulsos aplicados nos corpos rígidos
envolvidos.
Em uma simulação baseada em impulso, um bloco em repouso em cima de
uma mesa está sofrendo várias colisões com a mesma, cada uma sendo tratada
usando apenas a informação local no ponto de colisão. O objetivo é calcular o
impulso que deve ser aplicado ao objeto para evitar que ocorram colisões.
Quando dois corpos colidem, um impulso
p deve ser aplicado em um dos
corpos para evitar a penetração. Um impulso equivalente
p é aplicado no outro
corpo. Uma vez que
p e seu ponto de aplicação são conhecidos, basta calcular a
nova velocidade linear de cada corpo. Depois de atualizar todas as velocidades, a
simulação pode continuar assumindo uma trajetória balística para todos os objetos
em movimento. O ponto de aplicação é computado pelo sistema de detecção de
colisão, logo, o problema central é determinar o impulso de colisão
p .
Existem três pressupostos em relação à colisão. O primeiro é que o tempo de
colisão é infinitesimal, o que implica em que as posições dos objetos podem ser
tratadas como constantes durante o período de colisão. O segundo pressuposto é a
utilização da hipótese de Poisson para o cálculo de perda de energia e deformações
que ocorrem durante uma colisão com corpos reais. A hipótese de Poisson é a
seguinte (Mirtich, 1996):
18
mctotal pep ).1( (11)
Onde:
ptotal é a magnitude do componente normal do impulso, este
aplicado por um objeto em outro durante a colisão;
pmc é o componente normal do impulso antes no início da colisão;
e é o coeficiente de restituição, dependente do material do objeto.
O terceiro pressuposto é a utilização da Lei de Atrito de Coloumb (Anexo A.7).
Uma colisão é detectada quando a distância de dois corpos está abaixo de
uma tolerância εc. Entretanto é só uma possibilidade, visto que os objetos podem
estar se afastando. Se o componente normal da velocidade relativa dos pontos mais
próximos possui um sinal apropriado, não se deve aplicar um impulso de colisão.
Um exemplo é imaginar uma situação de colisão com o eixo z alinhado com a
normal da colisão, direcionado para o corpo 1. Sendo u=u1-u2 a velocidade relativa
entre os corpos 1 e 2. Quando u
19
Onde M é uma matriz 3x3 dependente apenas das massas dos corpos
envolvidos e da localização dos pontos de contato relativo aos centros de massa de
cada corpo.
Quando a velocidade tangencial não for zero, os corpos estão deslizando
entre si e p
está totalmente restrito. Sendo θ(γ) a direção do deslize durante a
colisão, isto é, θ é o argumento do número complexo ux+uy.i. Se o parâmetro γ é
escolhido para ser pz, então enquanto os corpos estiverem deslizando entre si,
aplica-se a Equação 13:
1
sin.
cos.
p
(13)
Aplicando o resultado da Equação 13 na Equação 12 será obtida a Equação
14:
1'
'
'
22
22
yx
y
yx
x
z
y
x
uu
u
uu
u
M
u
u
u
(14)
O algoritmo básico do cálculo do impulso procede da seguinte forma: após
computar a velocidade inicial u
e verificar que uz é negativo, utiliza-se de
integração numérica usando a equação 24. Durante a integração, uz aumentará.
Quando uz chegar a zero, o ponto máximo de compressão foi atingido. Multiplicando
esse valor por (i+e), resulta no valor para o parâmetro de colisão γf. Então, é
possível obter )( fu
.
20
2.6 DETECÇÃO DE COLISÃO DE CORPOS RÍGIDOS
Neste trabalho Baraff e Witkin (1997) descrevem procedimentos que podem
ser utilizados para detecções de colisão.
O algoritmo de detecção de colisão inicia com a determinação dos bounding
box para cada corpo rígido presente. Bounding Box é uma caixa com lados paralelos
aos eixos do sistema de referência que não é renderizada no ambiente, mas que
envolve um elemento do mesmo. Dado n elementos com bounding box, o objetivo
será determinar todos os pares de elementos cujos bounding boxes se
interseccionam. Os corpos rígidos que não ocorrem intersecção são descartados da
possibilidade de haver colisão. Já aqueles que o evento acontece são analisados.
Neste último caso, para detectar a colisão de dois poliedros convexos, basta verificar
se existe um plano que os separa de forma que os dois poliedros fiquem em lados
opostos desse plano. A verificação se o plano separa dois poliedros procede
testando os vértices dos dois objetos, de forma que todos os vértices do primeiro
objeto fiquem do lado oposto ao dos vértices do segundo objeto. Se não for possível
encontrar um plano que os separem, então os dois corpos devem estar em colisão.
Uma forma simples de encontrar o plano de separação é o seguinte: se um
par de poliedros convexos está separado ou em contato (porém não estão se
penetrando), então existe um plano de separação com a seguinte propriedade: o
plano contém a face de um dos poliedros ou ele contém uma aresta de um poliedro,
sendo paralelo com uma aresta do outro poliedro. Ou seja, a normal do plano de
separação é o produto vetorial das direções das duas arestas e o plano contém uma
delas.
Inicialmente, são verificadas as possíveis combinações de faces e vértices
para verificar se uma das combinações forma um plano de separação (Figura 8).
Para futuros ciclos, basta informar a face ou a aresta encontrada no ciclo anterior e
verificar se a mesma ainda é válida (Figura 9).
21
Figura 8. Procura por um plano de separação, onde apenas um plano satisfaz a condição (BARAFF; WITKIN, 1997).
Figura 9. Definição das faces (a) a face que forma o plano de separação é definida. (b) No próximo ciclo, os objetos são movidos, mas a mesma face continua formando o plano de
separação (BARAFF; WITKIN, 1997).
Caso o plano de separação deixar de ser válido, faces e arestas adjacentes
podem ser examinadas para verificar a existência de um novo plano de separação.
Entretanto, este é um acontecimento que não é muito freqüente e pode ser mais
simples procurar um novo plano de separação partindo do princípio.
Uma vez encontrado o plano de separação e assumindo que os poliedros
estão em contato, a região de contato pode ser facilmente encontrada, pois os
pontos em contato só podem ocorrer no plano de separação. Para isso, basta
verificar se as faces, arestas e vértices do poliedro estão no plano de separação.
Se não foi possível encontrar um plano de separação, então os dois poliedros
devem estar se penetrando. Na maioria dos casos, pode ser um vértice de um
poliedro que está dentro do outro ou é uma aresta de um poliedro, esta possuindo
22
uma intersecção com uma das faces do outro. Estes casos indicam que houve uma
colisão entre o ciclo anterior e o ciclo atual. O vértice (ou a aresta) e a face que
estão colidindo são armazenados na memória. Com isto, o simulador reiniciará o
ciclo na tentativa de computar o tempo em que ocorreu a colisão. Em cada tentativa,
o elemento armazenado é verificado se ainda está em colisão. Para cada falha, o
simulador tenta um período menor do ciclo até que encontre o momento da colisão.
2.7 CONSIDERAÇÕES FINAIS DO CAPÍTULO
Neste capítulo foram citados cinco trabalhos relacionados. O primeiro de
JAKOBSEN (2002) está diretamente relacionado na área de física aplicada em
jogos. Já as pesquisas de HAHN (1988), KAWACHI et al (1997) e MIRTICH (1996)
abordam o processamento dos cálculos físicos. Por fim, BARAFF; WITKIN (1997)
tem como foco o processo de detecção de colisão. Cabe ressaltar que não foram
encontrados trabalhos relacionados para simulações físicas em celulares. Portanto,
esta pesquisa pode contribuir para o desenvolvimento desta área em aplicativos
móveis.
Jakobsen (2002) buscou descrever no artigo a modelagem da física utilizada
no jogo Hitman: Codename 47. O trabalho mostra os métodos para o passo de
integração, onde descreve brevemente o método de Euler e se aprofunda naquele
utilizado no jogo: o método de Verlet. Ele também descreve o tratamento de colisão,
mais especificamente o passo de separação de corpos. Neste processo, ele projeta
o objeto perpendicularmente à superfície do obstáculo e, após eliminar a
penetração, aplica o algoritmo de resposta adequado. Por último, é demonstrado
como é feito o tratamento de atrito. Baseando-se através do valor da profundidade
de penetração, é calculado o quanto o atrito afetou a velocidade. O jogo Hitman:
Codename 47TM possui requisito mínimo de processador de 300 MHz e 64 MB de
memória RAM.
Hahn (1988) descreve o fluxo do sistema de animação, assim como a
dinâmica de impacto. O fluxo do sistema de animação (Figura 4) começa com a
inicialização dos parâmetros já definidos, como a massa e velocidade inicial, por
exemplo. Em seguida, ocorrem as atualizações dos elementos de saída, como os
parâmetros da câmera e renderização. Após, atualizam-se as velocidades e as
posições, verificando se ocorreram colisões. Caso sejam detectadas, é necessário
tratá-las e logo então, atualizar os elementos de saída, fechando o ciclo.
23
Na dinâmica de colisão é visto que os impulsos ocorridos durante a colisão
agem na direção da normal, além de como encontrar a normal em situações que não
são possíveis como, por exemplo, um canto de um objeto. Após definida a normal,
calcula-se o valor do impulso e aplica-se o impulso em ambos os corpos, mas em
sentidos opostos. O artigo não menciona a configuração de hardware onde foram
realizados os testes.
Kawachi et al (1997) descrevem um sistema de colisão com atrito com
múltiplos corpos. Primeiramente, é descrito o modelo sem atrito, então o mesmo foi
modificado para adicionar o atrito, considerando os tipos de atrito estático e
dinâmico. Também é alertado sobre a possibilidade da inversão de movimento,
quando a força de atrito calculado torna-se maior do que o movimento, fazendo com
que o objeto inverta sua direção. O hardware em que o sistema foi utilizado foi uma
máquina SGI R4000, com processador 100 MHz com 96 MB de memória RAM.
Baraff e Witkin(1997) descrevem um método de detecção de colisão para
políedros convexos. Primeiramente, é aplicada a técnica Bounding box nos
elementos. Então é verificado se existe um par de elementos cujo Bounding box está
em intersecção entre eles. Caso estejam, procura-se por um plano de separação, ou
seja, um plano em que os vértices de um poliedro A e os vértices de um poliedro B
fiquem em lados opostos em relação ao plano de separação. Se não for possível
encontrar um plano de separação, significa que os objetos devem estar em colisão,
sendo necessário encontrar o tempo em que ocorreu tal evento. Para encontrar esse
tempo, a simulação é retrocedida e executada em intervalos menores até encontrar
o momento de colisão.
Mirtich (1996) descreve um método baseado em impulso, onde todo os
contatos que ocorrem em uma simulação física, aplica-se um impulso para que os
objetos evitem a colisão. Levando ao fato de que todo corpo deforma-se e
reconstitui-se, mesmos os rígidos, é calculada a penetração do corpo e, a partir da
mesma, o impulso aplicado para evitar a colisão.
Os trabalhos relacionados forneceram informações sobre como executar a
integração através de métodos numéricos, tratamentos de colisão, atrito e impulso,
fontes importantes para se basear e montar a proposta desta pesquisa. Além disso,
as configurações das máquinas em que foram desenvolvidas e testadas são
relevantes para se medir desempenho, conforme demonstra a tabela 1. O motivo é
devido aos aparelhos celulares possuírem hardware limitado, como processamento
24
e memória. Um aparelho celular atual possui uma velocidade de processamento
variando entre 30 MHz e 70 Mhz, enquanto a memória RAM varia entre 1 e 2 MB
(TASTEPHONE, 2010).
Tabela 1. Comparativo entre os trabalhos relacionados
(Jakobsen,
1997)
(Hahn,
1988)
(Kawachi et
al, 1997)
(Baraff;
Witkin, 1997)
(Mirtich,
1996)
Velocidade 300 MHz Não
Fornecido
100 MHz Não
Fornecido
Não
Fornecido
RAM 64 MB Não
Fornecido
96 MB Não
Fornecido
Não
Fornecido
Plataforma PC Não
Fornecido
SGI 4000 Não
Fornecido
Não
Fornecido
Integração Verlet Euler Não
Fornecido
Não
Fornecido
Não
Fornecido
Colisão Apenas
Separação
Simples Múltiplas
Colisões
Apenas
Detecção
Simples
Atrito SIM SIM SIM NÃO SIM
Impulso SIM SIM SIM NÃO SIM
25
3 PROJETO DA FÍSICA DO JOGO
A proposta deste trabalho consiste em aplicar uma solução de modelagem da
física da dinâmica e tratamento de colisão em um protótipo de jogo para celular. É
importante ressaltar que o tipo de hardware para qual este projeto destina-se são
aparelhos celulares que possuem suporte a gráficos 3D da tecnologia J2ME.
Geralmente esses dispositivos possuem limitações de processamento e memória.
Isto torna evidente a necessidade de que o algoritmo a ser desenvolvido seja
eficiente e trate tais limitações. O primeiro passo consiste em definir qual será o caso
de estudo, ou seja, a aplicação que utilizará a física de dinâmica e colisão proposta
no projeto.
Neste caso, será um jogo de golfe em um ambiente 3D, pois este tipo de
aplicativo explora com completude as três dimensões espaciais. O objetivo do jogo é
levar uma bola até um buraco, conduzindo a mesma através de tacadas. Após
ocorrer a tacada, a bola estará sujeita aos efeitos do vento e do terreno, assim como
poderá vir a colidir com eventuais obstáculos.
Antes de entrar em detalhes no algoritmo de processamento da física do jogo,
é necessário definir os passos para o seu desenvolvimento. Bourg (2002) descreve
uma metodologia para auxiliar na modelagem da física, certificando-se que será
implementado somente o necessário. Isto evita cálculos desnecessários que
prejudiquem o desempenho, fator muito importante considerando a plataforma de
execução do algoritmo . Os passos a serem seguidos são os seguintes:
1. Definir os elementos do ambiente, tipos de terrenos e suas
características físicas;
2. Analisar o comportamento físico dos elementos para definir
exatamente o que será simulado e como será simulado;
3. Definir os algoritmos utilizados nos casos de colisões, como os
algoritmos de detecção e resposta de colisão;
4. Definição do processo de integração. É nessa fase que será definido o
cálculo dos atributos dos objetos, como por exemplo, a nova posição
resultante de um deslocamento, levando em consideração a influência
do vento;
26
5. Definição dos parâmetros para os elementos do ambiente, por
exemplo, a massa dos objetos, coeficientes de atrito, coeficientes de
restituição, entre outros que possam ser necessários.
Todas essas etapas serão detalhadas neste capítulo, cujo enfoque é
especificar o estudo de caso a ser modelado: o jogo de golfe.
3.1 FERRAMENTAS E LINGUAGEM UTILIZADAS
A linguagem de programação utilizada será o JAVA TM, usando o pacote J2ME
(Java TM 2 Micro Edition). Ele é uma APIs desenvolvida para sistemas de pequeno
porte, como celulares, PDAs, impressoras e eletrodomésticos.
As ferramentas utilizadas para execução do trabalho serão:
Blender TM 2.48a utilizando o plugin de exportação para M3G para a
criação dos modelos 3D;1
Eclipse TM Ganymede 3.4.2 com plugin Eclipse ME para programação
do protótipo do jogo de celular;2
Sun Java Wireless Toolkit TM 2.5.2 , emulador de celular utilizado nos
testes básicos de funcionalidades.3
3.2 MODELAGEM DO CENÁRIO
O ambiente criado para esse trabalho consiste em um campo de golfe em três
dimensões. Os elementos do ambiente podem ser divididos em duas categorias:
Terrenos e Elementos. O primeiro é a base do ambiente, ou seja, é o que forma o
campo propício para um jogo de golfe. Já o último são os componentes que
complementam os terrenos como a própria bola de golfe. Todas estas unidades
serão apresentadas com detalhes nas seções que compõem este tópico.
3.2.1 Terreno
O ambiente criado possui as seguintes áreas, todas elas utilizando a
nomenclatura oficial do golfe, onde os números são referências utilizadas para
localizar os respectivos terrenos na Figura 10:
1 Site Oficial da Ferramenta Blender TM: http://www.blender.org
2 Site Oficial da Ferramenta Eclipse TM: http://www.eclipse.org
3 Site Oficial da Ferramenta Java Wireless Toolkit TM: http://java.sun.com/products/sjwtoolkit
27
Figura 10. Campo de Golfe modelado no Blender
Fairway: área que forma o caminho entre o ponto de partida e o
Green, servindo de guia para o jogador. O ambiente de teste possui
uma área com grama devidamente aparada (1) e outra de um lago
congelado (2);
Green (3): área do campo que contém o buraco, onde a grama é fina,
compacta e rente ao solo. Quando a bola está nesta região, deve-se
utilizar o taco Putter, este especial para fazer a bola deslizar rente ao
chão;
Rough (4): área do campo com grama alta que dificulta a tacada.
Geralmente possui obstáculos como árvores, por exemplo;
Bunker (5): zona de terreno arenoso. Geralmente é colocada em
locais estratégicas para dificultar as tacadas;
Out of Bounds: é qualquer área onde a bola não deve parar. Quando
a bola cai e para numa área indevida, a bola é reposicionada no local
da tacada.
A Figura 11 mostra os terrenos sendo executados no emulador Java Wireless
ToolkitTM:
28
Figura 11. Cenários do Campo de Golfe sendo executado no emulador Java Wireless ToolkitTM
para J2ME
No terreno desenvolvido, existem paredes que preenchem o desnível dos
terrenos. A colisão nas paredes também deve ser considerada, entretanto, como as
paredes são totalmente verticais, não é possível a bola percorrê-las.
3.2.2 Elementos
O único elemento, todavia o mais importante do trabalho é a bola de golfe,
pois o foco do jogo baseia-se nela. Normalmente é feita com um material
termoplástico com o seu núcleo revestido por um material de alta elasticidade
chamado Surlyn. Entretanto, pelas regras oficiais, as bolas devem seguir os
seguintes padrões: o diâmetro deve ser maior que 42,67 milímetros e sua massa
deve ser menor que 15,93 gramas. (FEDERAÇÃO NORTE DE GOLFE, 2009). Para
este trabalho, a bola terá 43 milímetros de diâmetro e 15 gramas de massa,
obedecendo ao padrão estabelecido pelas regras do golfe.
3.3 COMPORTAMENTO FÍSICO
Nesse tópico será definido o comportamento dos elementos em relação ao
terreno, bem como outros itens relevantes à simulação. A importância da definição
29
do comportamento é filtrar as simulações desnecessárias que poderão prejudicar o
desempenho do algoritmo.
3.3.1 Bola de Golfe
A bola de golfe, no início de cada tacada, estará em repouso em relação ao
cenário. Ela entrará em movimento a partir do evento da tacada, onde receberá um
impacto do taco. A intensidade do impacto, responsável pelo impulso inicial da bola,
também será controlada pelo jogador.
Enquanto estiver no ar, a bola sofrerá influência da força exercida pelo vento,
responsável por alterar a sua trajetória. A bola também será influenciada pela
gravidade e resistência do ar. Enquanto ela estiver rente ao terreno, sofrerá os
efeitos do atrito de acordo com o tipo de terreno, até a bola retornar ao estado de
repouso.
Para casos de colisão entre outros elementos, a bola de golfe terá os efeitos
da dinâmica de colisão como visto no trabalho de Kawachi (1997), com a diferença
que será somente entre dois corpos.
3.3.2 Forças
Neste trabalho existem basicamente três forças que agem sobre os
elementos do ambiente: a força do vento, da gravidade e de atrito (tanto entre as
superfícies quanto à resistência do ar).
A primeira é causada pelo deslocamento do ar, que arrasta os elementos no
sentido do movimento do ar. A força do vento, tanto sua direção quanto a
intensidade, é determinada aleatoriamente e pode mudar a qualquer momento.
A força de gravidade é a força de atração entre duas massas, sendo causada
principalmente pela massa do planeta, fazendo com que a bola caia. Assim é
definida que esta força sempre agirá no sentido para baixo, em direção à superfície.
A última é a força de atrito que ocorre quando dois objetos em contato
deslizam entre si. Esta força age no sentido oposto do deslocamento, criando uma
desaceleração que cessa quando os corpos estão em repouso entre si.
3.4 ALGORITMOS DE COLISÃO
Nesta fase são abordados os algoritmos responsáveis pela colisão e resposta
de colisão entre os elementos. Esses dois procedimentos são necessários para que
30
o comportamento físico do objeto condiga com a realidade. A ausência da detecção
de colisão impossibilita a interação entre os elementos quando os mesmos entram
em contato, fazendo que os mesmos ignorem o fato de estarem em contato. A
resposta de colisão é a própria reação que os elementos devem possuir quando
houver contato.
3.4.1 Detecção de Colisão
O algoritmo de detecção de colisão consiste em determinar se existe
intersecção entre dois elementos, assim como o ponto de contato entre os corpos.
Baraf e Witkin (1997) desenvolveram uma técnica de detecção de colisão entre
poliedros, entretanto, o mesmo é um processo em que consome processamento e
memória. A detecção de colisão para este trabalho utiliza um método semelhante ao
Bounding Box utilizado por Baraf e Witkin (1997), denominada Bounding Sphere. A
principal diferença entre os dois métodos de detecção é que o primeiro utiliza uma
caixa que envolve os objetos, enquanto o segundo envolve os objetos com uma
esfera. Como o principal objeto da simulação é uma bola de golfe, utilizar Bounding
Sphere torna-se mais confiável que o Bounding Box.
O algoritmo desenvolvido utiliza da classe RayIntersection em conjunto com
o método pick() da classe World, ambos classes inclusos no J2ME no pacote m3g.
Para poder entender o funcionamento da detecção de colisão, primeiro será
explicada a função de cada classe.
A classe World serve como um nó raiz da árvore que contém is elementos do
ambiente 3D. O ambiente 3D tem seus elementos (câmeras, luzes, imagens 2D,
objetos 3D) distribuídos em uma árvore hierárquica, ou seja, os elementos são os
nós da mesma. Esse tipo de árvore denomina-se Árvore de Cenário (NOKIA
LIBRARY, 2009).
A classe RayIntersection é uma classe que armazena as informações
retornados pelo método pick() de qualquer grupo de elementos existentes em um
objeto da classe World. O método pick() é utilizado para detecção de colisão da
seguinte forma: utilizando os parâmetros que são passados, ou seja, as
coordenadas do objeto, a direção e o escopo (objetos que não serão analisados),
uma linha é projetada de um ponto específico para uma determinada direção até
uma distância pré-determinada. Caso a linha atinja algum objeto do ambiente, o
método pick() armazenará os dados em um objeto RayIntersection, que conterá qual
31
foi o objeto encontrado, o vetor normal da superfície atingida e a distância até a
superfície (NOKIA LIBRARY, 2009). A idéia utilizada pelo algoritmo é utilizar
bounding sphere, que neste caso é a própria bola de golfe. Então é verificado se
existem outros objetos dentro da esfera e analisar se existem intersecções dentro da
mesma. Se o método pick() encontrar algum outro objeto que não seja a bola, esse
corpo está colidindo com a bola, necessitando do tratamento de resposta de colisão.
3.4.2 Resposta de Colisão
O primeiro passo após a detecção de colisão ter sido confirmada é a
separação dos objetos. Para isto, será utilizado o método do Jakobsen (2001), cuja
proposta é projetar o corpo perpendicularmente em relação ao plano em que ocorreu
a colisão.
Segundo Hecker (1997), uma colisão ocorre quando dois corpos entram em
contato com a velocidade relativa normal negativa. Para modificar o movimento e
evitar que uma colisão ocorra, bastaria aplicar uma força em cada um dos corpos
que o problema já estaria resolvido. Porém este processo exigiria um tempo que não
existe, pois os objetos em questão já estão interpenetrados. Entretanto, o impulso é
capaz de modificar o movimento instantaneamente, com o mesmo efeito que
ocorreria ao aplicar uma força, mas sem o uso da variável tempo.
Uma vez que os objetos foram separados, aplica-se a dinâmica de colisão
que segundo Hecker (1997), pode utilizar-se da Equação 15:
nm
jvv
nm
jvv
b
bb
a
aa
'
'
(15)
Onde:
av '
e bv '
são respectivamente a velocidade do corpo a e do corpo b
após a colisão;
av
e bv
são respectivamente a velocidade do corpo a e do corpo b
antes da colisão;
32
ma e mb são a massa do corpo a e do corpo b
n é o vetor normal da colisão, que por definição, sempre estará
apontando para o objeto a;
j é um escalar da intensidade do impulso que cada corpo irá sofrer e é
definido pela Equação 16:
ba
ab
mmnn
nvj
11.
.)1(
(16)
Sendo ε o coeficiente de restituição e abv
a velocidade relativa entre o corpo
a e o corpo b antes da colisão. O símbolo “.” refere-se ao produto escalar entre dois
vetores, o que torna j um valor escalar.
Para o efeito de atrito na colisão será feito a mesma abordagem de Jakobsen
(2001). Utilizando a profundidade dp da penetração dos corpos, calcula-se a força do
atrito utilizando a Equação 2. Então, após o cálculo da colisão e com as velocidades
finais calculadas, diminui-se a velocidade tangencial de acordo com o valor
encontrado pela Equação 2. É importante verificar, após a redução da velocidade
tangencial, se a mesma não inverteu o sentido, pois quando a velocidade tangencial
atinge o zero, o atrito deixa de agir.
3.5 INTEGRAÇÃO
A etapa de integração consiste em calcular os novos valores das variáveis
utilizando como base os valores atuais. No trabalho de Jakobsen (2001), ele
menciona dois métodos de integração utilizados em jogos eletrônicos: o método de
Euler e Verlet.
No primeiro, em cada iteração de atualização verifica-se o tempo percorrido
desde a última iteração. Com esse período de tempo, calcula-se o deslocamento
dos elementos, assim como sua nova velocidade e outros atributos que se
modificam em função do tempo.
33
Já no método de Verlet, utiliza-se o deslocamento anterior para deduzir a
nova posição dos objetos em um período de tempo fixo, ou seja, o tempo de ciclo
das atualização é controlado.
É importante para ambos os método, que o período de tempo entre os ciclos
seja significativamente pequeno, visto que quanto maior é o tempo entre as
atualizações, maior é o erro entre os valores calculados, usando a Integração
numérica e os valores exatos, como mostra a Figura 12.
Figura 12. Um ciclo no Método de Euler (BOURG, 2002).
Para diminuir a complexidade dos cálculos a serem realizados, será utilizado
o seguinte pressuposto: as variáveis que podem alterar o comportamento atual, mas
não dependem do fator de tempo, serão atualizadas antes do passo de
integralização. Por exemplo, o vento, que pode mudar a sua direção e intensidade
aleatoriamente, irá alterar a aceleração da bola.
Em seguida é calculada a aceleração atual da bola. Para isso, calcula-se a
resultante da aceleração das forças envolvidas (gravidade, influência do vento e
atrito). A força da gravidade depende da distância entre os corpos envolvidos. Logo,
quanto mais longe, menor será a força exercida entre eles. Entretanto, devido ao
planeta ser um corpo com uma enorme massa, o problema pode ser reduzido para
um de aceleração constante (BOURG, 2002). A aceleração da gravidade em objetos
ao nível do mar é de 9,80665 m/s2 e será esse o valor da aceleração da gravidade
existente no jogo.
Segundo Bourg (2002) para a resistência do ar, utiliza-se a Equação 17:
34
2.vka (17)
Onde:
a é a aceleração causada pela resistência do ar;
k é uma constante que depende da aerodinâmica do corpo. Uma bola
de golfe tem esse valor aproximado de 0,009570313 m-1;
v é a velocidade escalar do objeto.
O sinal de menos da Equação 17 significa que a aceleração ocorrerá sempre
no sentido contrário da velocidade. Antes de explicar como foi encontrado o valor de
k é necessário entender o conceito de velocidade terminal. Quando um objeto está
em queda, significa que a força gravitacional do planeta está movendo esse objeto
em sentido ao solo. Como esse objeto está se movendo com uma força,
consequentemente está havendo uma aceleração no mesmo sentido. Esse é o
primeiro elemento necessário para entender a velocidade terminal.
O segundo elemento é a resistência do ar: quanto maior a velocidade do
corpo, maior será a resistência, ou seja, maior vai ser a desaceleração, sendo esta
uma aceleração em sentido contrário ao da velocidade.
Em uma queda, o objeto ganhará velocidade devido à aceleração da
gravidade. Entretanto, uma velocidade maior aumentará a resistência do ar que irá
causar uma desaceleração, chegando um momento em que essa desaceleração
será o suficiente para anular a aceleração da gravidade. A partir desse momento, a
aceleração do objeto será zero e ele passará a se mover com uma velocidade
constante, denominada velocidade terminal.
O valor de k pode ser encontrado sabendo a velocidade terminal da bola de
golfe, o equivalente a 32m/s, segundo Bourg (2002), além da aceleração da
gravidade, esta igual a 9,80665 m/s2. Como o objetivo é anular esta última, portanto
deverá ter o valor de -9,80665 m/s2 , sendo v a velocidade terminal da bola (32 m/s).
Substituindo os valores na Equação 17, será obtido o valor de k=0,009570313.
A aceleração linear da bola causada pelo vento pode ser um valor aleatório
entre 0 m/s2 e 6 m/s2 em direção e sentido aleatório e perpendicular ao vetor normal
da superfície do terreno. Esses valores são obtidos tendo em mente que a
velocidade escalar do vento varia entre 0 m/s e 25 m/s. Baseando-se na Equação 17
35
pode-se calcular os valores da aceleração para a velocidade, conforme é
apresentado na Equação 18:
2.vka (18)
Onde:
a é a aceleração linear do objeto causado pelo vento;
k é a mesma constante definida na Equação 17;
v é a velocidade linear do vento.
A semelhança entre a Equação 17 e a Equação 18 deve-se ao fato de que
ambas são próprias para um fenômeno da mesma natureza, tendo como diferença
que a primeira mede a desaceleração causada pela resistência do ar, enquanto a
última mede a aceleração causada pelo deslocamento do ar.
Para calcular a nova posição será utilizado o conceito de Movimento
Uniformente Variável, obtido pela Equação 21. Com a nova posição estimada, deve-
se atualizar a velocidade atual, utilizando a Equação 22.
Uma vez calculada a nova posição e velocidade, é necessário verificar se
houve colisão entre os objetos e, se houver, aplica-se o tratamento de colisão.
Existe um problema em potencial que é quando o espaço de tempo entre as
atualizações for longo demais, podendo o objeto vir a “atravessar” um outro sem que
o algoritmo de detecção de colisão consiga detectar (Figura 13a e Figura 13b). Para
resolver esse problema, Jakobsen (2001) sugere utilizar uma linha ou cilindro
imaginário, este na posição inicial da trajetória do objeto e terminando no final da
mesma. Assim, verifica-se se existe colisão entre algum objeto com o cilindro (Figura
13c). Caso haja colisão, aplica-se o tratamento (Figura 13d).
36
Figura 13. Objeto com detecção de colisão errônea (a) Um objeto na posição inicial. (b) Objeto moveu-se e atravessou a parede. (c) A linha entre a posição inicial e final é traçada e é
detectada colisão. (d) O corpo é movido ao local correto
Foi detectado através de observações que a falta de um tratamento adequado
na fase de integração faz com que o jogo não seja executado com coerência com o
mundo real em qualquer tipo de aparelho. Esse problema ocorre quando é utilizada
a quantidade de ciclo realizados como parâmetro de controle de sincronização.
Entretanto, processadores com maior poder de processamento, realizam mais ciclos
por segundo. Portanto, a velocidade dos elementos durante a animação será maior
do que aquela em aparelhos com processadores mais limitados. Para garantir a
compatibilidade de forma independente da velocidade do processador, deve ser
utilizado um parâmetro que não dependa do mesmo, como o tempo.
Com base neste fato, este trabalho utiliza o método de Euler pela sua
simplicidade, além da vantagem de não precisar definir um período entre o ciclo de
atualização de forma que o deixe constante. Devido a limitação de processamento
dos aparelhos celulares, haveria problemas na sincronização do tempo, caso o
aparelho não tenha poder de processamento necessário para um determinado
período. No caso do método de Euler, o aparelho completará o ciclo baseando-se no
tempo, evitando assim o problema da sincronização, além de minimizar as chances
da detecção de colisão falhar.
3.6 PARÂMETROS
Nessa seção serão definidos os parâmetros mais específicos da simulação
como coeficiente de restituição e coeficiente de atrito. Esses parâmetros são
específicos para cada tipo de caso e devem ser configurados de forma que torne as
interações mais realísticas em relação ao outro caso. Por exemplo, um terreno de
gelo possui um coeficiente de atrito menor comparado ao terreno com grama. O
37
comportamento físico é o mesmo, entretanto como o coeficiente de atrito do campo
de gelo é menor, a bola irá mais longe do que se estivesse num campo de grama.
3.6.1 Coeficientes de Restituição
O coeficiente de restituição é a proporção da energia dispersada durante a
colisão. Ele resulta numa perda de energia cinética e de velocidade como demostra
a Equação 27 no Anexo A.6. O coeficiente de restituição é uma característica que
depende de ambos os corpos, sendo necessário analisar cada possibilidade de
colisão. Como os coeficientes de restituição são obtidos experimentalmente, os
valores demonstrados são uma estimativa, podendo ser alterados conforme a
necessidade. Para determinar o coeficiente de restituição, foram observados outros
jogos de golfe como WiiSportsTM da NintendoTM (2009), analisando a altura máxima
que a bola atingiu antes da colisão com o terreno e a altura máxima atingida depois
da mesma. Nas colisões entre a bola e outros elementos e terrenos, têm-se os
seguintes valores:
Fairway: estima-se 0,5 como coeficiente de restituição para fairway de
grama, visto que apesar da grama ser aparada, é suficiente para
diminuir pela metade a energia da bola. Para o terreno de gelo,
estima-se um valor alto, como 0,855;
Green: a grama fina e prensada, a bola que cai nesta área, não perde
muita energia. Então é estimado um valor de 0,6 para Green;
Rough: devido à grama alta, existe uma perda muito grande de
energia, estimando um coeficiente de restituição de 0,2;
Bunker: caso a bola caia em um bunker, a areia absorverá o impacto
da queda, evitando que ela volte a ficar no ar. Isso significa que o
coeficiente de restituição é extremamente baixo, podendo-se
considerar 0;
Parede: absorverá pouco impacto da bola. Portanto, o coeficiente de
restituição estimado será de 0,98.
3.6.2 Coeficientes de Atrito
Sua função é expressar a oposição ao movimento quando dois corpos
deslizam entre si. Assim como o coeficiente de restituição, é obtido
experimentalmente porque depende muito da interface entre dois objetos. Por
38
exemplo, uma superfície mais áspera tende a possuir maiores coeficientes, mas
depende de outros fatores como o tipo de material, lubrificação, entre outros. Dadas
as razões, os valores definidos nesta seção são estimativas pesquisadas em livros
de física como Bourg (2002), Halliday (1981), Mckelvey (1978) e Young (2003),
cujos valores poderão ser modificados de acordo com a necessidade. Não foram
encontrados os coeficientes de atrito entre os materiais envolvidos (Surlyn e os
terrenos). Entretanto, baseando-se em materiais semelhantes, foram estimados os
coeficientes de atrito.
Como definido na seção 3.2.1, o atrito surtirá efeito quando a bola de golfe
estiver deslizando sobre um terreno, assim como haverá o atrito do ar. Dados os
tipos de terrenos, os coeficientes de atrito são:
Fairway: estima-se um coeficiente de atrito de 6,0 para fairway de
grama. Para o terreno de gelo, estima-se um valor baixo, como 1,0;
Green: como a grama é fina e prensada, o atrito é menor do que o
Fairway de grama. Então, é estimado um valor de 5,0 para Green;
Rough: devido à grama alta, torna-se mais difícil a bola deslizar nesse
tipo de terreno, estimando um coeficiente de restituição de 8,0;
Bunker: numa bancada de areia, a bola não se movimenta facilmente,
o que leva a ser coeficiente de atrito mais alto dos terrenos de 98,0.
3.7 CONSIDERAÇÕES FINAIS DO CAPÍTULO
Neste capítulo foi modelada a simulação física que será utilizada no
desenvolvimento do protótipo do jogo de golfe.
Foram definidos os elementos e como será o comportamento físico dos
mesmos, visto que este planejamento facilita na programação do aplicativo móvel
objeto deste estudo.
Também foram definidos os algoritmos que serão utilizados no tratamento de
colisão: detecção e resposta de colisão. O primeiro utilizará a classe RayIntersection
da biblioteca m3g do J2ME, enquanto a resposta de colisão será implementada com
base na física da dinâmica.
Em seguida, foi definido como será o método de integração e os cálculos
envolvidos no mesmo, utilizando os conceitos de Movimento Uniformemente
Variável. O método escolhido foi o de Euler, pela sua simplicidade de
implementação e facilidade de sincronização.
39
Por último foram estimados os parâmetros que serão utilizados durante a
simulação física. Os valores dos coeficientes de restituição e coeficientes de atrito
entre a bola de golfe e os outros elementos podem ser encontrados na tabela 2.
Tabela 2. Coeficientes de Restituição e de Atrito baseados nas seções 3.6.1 e 3.6.2
Parede
Fairway (Grama)
Fairway (Gelo)
Green Rough Bunker
Coeficiente de
Restituição
0,98 0,5 0,85 0,6 0,2 0
Coeficiente de Atrito 6 1 5 8 98
Para um melhor entendimento do algoritmo para a realização da simulação
física, a Figura 14 demonstra um fluxograma dos passos necessários:
40
Figura 14. Fluxo da Simulação Física da dinâmica do Movimento
41
O fluxo começa com a inicialização das variáveis como velocidade,
aceleração e posição. Os parâmetros constantes não precisam ser inicializados com
valores, pois como seu valor não será alterado, podem ser facilmente acoplados
diretamente no código. Após inicializado, ocorre a primeira renderização,
responsável por inicialmente ajustar os parâmetros da câmera e renderizar o
ambiente. Em seguida, ocorre o processo de integração, onde as variáveis
envolvidas na simulação são atualizadas. Então ocorre a detecção de colisão e,
caso seja detectada, acontece o processo de resposta de colisão entre os corpos
colididos e o tempo é atualizado. Caso contrário, somente este último é modificado.
Após, o fluxo retorna à renderização, onde o ciclo é retomado até que a simulação
seja encerrada pelo usuário.
42
4 DESENVOLVIMENTO
Este capítulo apresenta as mudanças ocorridas durante o desenvolvimento do
jogo, e como ele foi desenvolvido, explicando as classes criadas e suas
funcionalidades. Também será abordado o resultado dos testes do aplicativo
implementado, explicando os procedimentos de realização dos mesmos.
4.1 IMPLEMENTAÇÃO
4.1.1 Classes Desenvolvidas
Três classes foram desenvolvidas para a criação do jogo: a primeira classe
Principal responsável pela inicialização do jogo. A segunda classe Jogo que controla
as entradas e saída de dados. Por último, a classe Bola que contém as
características tanto de atributos quanto de comportamentos da bola de golfe.
Principal:
A classe Principal inicia uma MIDlet, ou seja, aplicações desenvolvidas com a
tecnologia J2ME nos telefones celulares. Elas são controladas pelo sistema
operacional do dispositivo móvel de acordo com a necessidade da situação, gerando
um ciclo de vida para a MIDlet com três estados como mostra a Figura 15:
Figura 15. Ciclo de Vida de uma MIDlet (SUN, 2010)
43
Ativo – uma MIDlet está ativa quando está apta para execução, tendo
permissão para alocar os recursos necessários para o seu processamento. Também
entra no estado ativo quando o método startApp() é chamado.
Suspenso – estado inicial da MIDlet e somente retorna para ele quando
ocorre um evento externo de maior prioridade, como uma chamada de telefone.
Neste estado, os recursos devem ser liberados, mantendo somente o necessário
para que o aplicativo retome à execução quando voltar ao estado Ativo. O método
pauseApp() é executado quando o aplicativo entra no estado Suspenso.
Destruído – é o estado que dá inicio „a finalização do aplicativo e seus
recursos são liberados. O método destroyApp() é executado quando é notificado o
encerramento do programa.
A classe Principal possui os três métodos herdados da MIDlet
(pauseApp(),startApp(),destroyApp()) e um atributo booleano iniciado (Figura 16).
Entretanto, somente o método startApp() é relevante para a implementação do jogo,
pois é ele que iniciará o aplicativo.
Figura 16. Modelagem da classe Principal
Esta classe também possui um atributo chamado iniciado, cujo valor inicial é
falso e indica se o jogo já foi iniciado. Esse atributo é necessário para o caso de a
MIDlet entrar no estado suspenso, após o jogo já ter sido iniciado. Ao retornar ao
estado ativo, o método startApp() é invocado novamente e este atributo evita uma
realocação do jogo, e assim, evitando que o mesmo seja reiniciado. A Figura 17
mostra o fluxograma desse algoritmo:
44
Figura 17. Fluxograma do startApp()
Jogo:
A classe Jogo é responsável por gerenciar o processamento do mesmo e
seus even