Embed Size (px)
Citation preview
INSTITUTO FEDERAL DE EDUCAÇÃO, CIÊNCIAS E TECNOLOGIA CATARINENSE –
CAMPUS AVANÇADO SOMBRIO
ÉRIK SCHEFFER BEHENCK
JOÃO PAULO MARQUES VOTRI
JOGO DE SINUCA COM OBSTÁCULOS
Sombrio (SC)
2015
ÉRIK SCHEFFER BEHENCK
JOÃO PAULO MARQUES VOTRI
JOGO DE SINUCA COM OBSTÁCULOS
Trabalho de Conclusão de Curso apresentado como requisito para a obtenção do título de Técnico em Informática Integrado ao Ensino Médio, no Curso de Técnico em Informática Integrado ao Ensino Médio, do Instituto Federal de Educação, Ciência e Tecnologia Catarinense – Campus Avançado Sombrio.
Orientador: Prof. Me. Iuri Sônego Cardoso
Sombrio (SC)
2015
ÉRIK SCHEFFER BEHENCK
JOÃO PAULO MARQUES VOTRI
TRABALHO DE CONCLUSÃO DE CURSO
Esta Produção Técnico Informática Integrado ao Ensino Médio foi julgada adequada para obtenção do título de Técnico em Informática e aprovada pelo Curso de Técnico em Informática do Instituto Federal de Educação, Ciência e Tecnologia Catarinense – Campus Avançado Sombrio
Área de Concentração: Desenvolvimento de software
Sombrio, 19 de janeiro de 2015.
Prof. Me. Iuri Sônego CardosoInstituto Federal Catarinense – Campus Avançado
Sombrio Orientador
Profª. Aline de Brittos ValdatiInstituto Federal Catarinense – Campus Avançado
Sombrio Membro
Profª. Esp. Alini dos Santos AntoneliInstituto Federal Catarinense – Campus Avançado
Sombrio Membro
DEDICATÓRIA
Dedicamos às nossas famílias, que souberam entender os nossos momentos de ausência dedicados ao estudo.
AGRADECIMENTOS
Agradecemos a Deus por ter nos dado saúde e força para superarmos todas as dificuldades.
A este Instituto, seu corpo docente, direção e administração que nos deram essa oportunidade de ensino.
Ao Prof. Me. Iuri Sônego Cardoso, pela orientação, confiança e apoio.
Agradecemos nossas famílias que sempre estiveram presentes nos momentos mais importantes, e aos amigos que nos ajudaram.
Aos nossos colegas, com quem formamos um laço fraterno e respeitoso. Impossível esquecer!
A todos que direta ou indiretamente fizeram parte da nossa formação, o nosso muito obrigado.
EPÍGRAFE
Tente uma, duas, três vezes e se possível tente a quarta, a quinta e quantas vezes for necessário.
Só não desista nas primeiras tentativas, a persistência é amiga da conquista. Se você quer chegar a onde a maioria não chega, faça o que a maioria não faz.
Bill Gates
RESUMO
O trabalho apresenta o desenvolvimento de um jogo simulador de sinuca, onde o
jogador deverá mirar em alguma das extremidades da mesa para tentar desviar de uma
barreira. Para o desenvolvimento, foram utilizados conceitos de matemática como ângulos
que fazem com que a bola mude a sua trajetória ao se chocar com um objeto ou com a
mesa, e conceitos da física como força e atrito. A força é utilizada quando o jogador tira a
bola da inércia e a coloca em movimento e o atrito está relacionado à força de contato
que atua quando dois corpos entram em choque. O atrito diminui a velocidade da bola a
cada movimento que ela faz. O jogo pode ser utilizado como uma forma divertida de
aprender sobre ângulos, que aparecem na tela durante o jogo.
Palavras-chave: Ângulos. Física. Jogo. Matemática.
ABSTRACT
The paper presents the development of a pool simulator game where the player must aim
at some end of the table to try to dodge a barrier. For development, math concepts were
used as angles that make the ball change its trajectory to collide with an object or the
table, and physics concepts as force and friction . The force is used when the player takes
the ball inertia and sets in motion and friction is related to the contact force acting when
two bodies collide . The friction slows the ball every move she makes . The game can be
used as a fun way to learn about angles on the screen during the game.
Keywords: Angles. Physics. Game. Mathematics.
LISTA DE QUADROS
Quadro 1: Código de Atualização da tela..........................................................................24
Quadro 2: Verificação de colisão…...................................................................................24
Quadro 3: Código de Reflexão..........................................................................................27
Quadro 4: Código de Atrito................................................................................................28
Quadro 5: Desenhar objetos na tela .................................................................................29
Quadro 6: Desenhar a linha da trajetória..........................................................................30
Quadro 7: Calcular o final da linha da trajetória................................................................30
Quadro 8: Comandos do jogo...........................................................................................31
Quadro 9: Código para o cálculo da pontuação................................................................32
Quadro 10: Códigos para a barra de força 1.....................................................................32
Quadro 11: Códigos para a barra de força 2.....................................................................33
Quadro 12: Códigos para a barra de força 3.....................................................................33
LISTA DE FIGURAS
Figura 1: Reflexão da luz.…..............................................................................................14
Figura 2: Atrito sobre superfície rugosa.............................................................................17
Figura 3: Mesa de sinuca …..............................................................................................18
Figura 4: Exemplo de ângulo.............................................................................................19
Figura 5: Comparação de imagem....................................................................................22
Figura 6: Trajetória da bola................................................................................................29
Figura 7: Tela do jogo........................................................................................................34
SUMÁRIO
1. INTRODUÇÃO.................................................................................................................122. OBJETIVOS.....................................................................................................................132.1 Objetivo geral.................................................................................................................132.2 Objetivos específicos.....................................................................................................133. REFERENCIAL TEÓRICO...............................................................................................143.1 Física..............................................................................................................................143.1.1 Reflexão......................................................................................................................143.1.2 Força...........................................................................................................................153.1.3 Atrito............................................................................................................................153.1.4 Colisão........................................................................................................................173.2 Matemática.....................................................................................................................183.2.1 Trigonometria..............................................................................................................183.2.2 Ângulos.......................................................................................................................193.3 Programação de computadores....................................................................................193.3.1 Algoritmos...................................................................................................................203.3.2 Linguagens de programação......................................................................................203.3.3 Java.............................................................................................................................213.3.4 Desenhos em java......................................................................................................213.4 Técnicas de simulação da física em jogos eletrônicos..................................................223.4.1 Animação....................................................................................................................233.4.2 Verificação de colisão.................................................................................................244. MATERIAL E MÉTODOS.................................................................................................264.1 MATERIAL......................................................................................................................264.2 MÉTODOS.....................................................................................................................264.2.1 Código para reflexão...................................................................................................274.2.2 Código para atrito.......................................................................................................284.2.3 Desenhar objetos na tela ...........................................................................................284.2.4 Desenhar a linha da trajetória da bola........................................................................294.2.5 Comandos do jogo......................................................................................................314.2.6 Código para pontuação ..............................................................................................323.2.7 Códigos para a barra de força....................................................................................325. RESULTADO E DISCUSSÃO .........................................................................................346. CONSIDERAÇÕES FINAIS.............................................................................................36REFERÊNCIAS....................................................................................................................37
12
1. INTRODUÇÃO
O mercado de jogos eletrônicos no Brasil está em constante expansão
fazendo com que as grandes empresas do mundo relacionadas a esta categoria
invistam em nosso país. Atualmente universidades públicas e privadas e também
empresas desenvolvedoras e distribuidoras de jogos oferecem cursos relacionados
à área. (MAFRA, 2012).
A presente pesquisa é um estudo elaborado sobre a construção de um jogo
eletrônico de sinuca utilizando ângulos, força e atrito, visto que seus empregos são
importantes nas áreas de Matemática e Física.
Percebe-se assim, a necessidade de estudar sobre trigonometria, ângulos,
força, atrito, reflexão, e elaboração de softwares. Uma vez que aplicados
corretamente, estes conceitos podem promover novas descobertas em suas áreas e
também em conjunto, fazendo com que cada vez mais estudantes se interessem
pela construção de jogos.
Esta pesquisa está organizada da seguinte forma: Capítulo 2 aborda os
objetivos do estudo; Capítulo 3 encontra-se o referencial teórico, apresentando
assuntos de Física, Matemática e Programação; Capítulo 4 explica os materiais e os
métodos utilizados na elaboração do software. No capítulo 5, explana-se o resultado
final do software e as considerações finais. No capítulo 6, são apresentados os
resultados obtidos ao final da pesquisa e da construção do jogo, também abordando
perspectivas para a continuidade do presente estudo.
13
2. OBJETIVOS
Neste capítulo serão apresentados o objetivo geral e os objetivos específicos
do trabalho.
2.1 Objetivo geral
Construir um jogo eletrônico de sinuca com ângulos, com o auxílio da
Matemática e da Física, onde seja possível acertar objetos, sendo que entre eles e a
bola existem obstáculos; estimulando a aprendizagem sobre ângulos.
2.2 Objetivos específicos
• Utilizar a trigonometria para cálculo de reflexão ao colidir com objetos,
fazendo com que o sistema apresente ângulos e o jogador possa
acertar o alvo;
• Empregar algoritmos de colisão de objetos para verificação da
existência de choque entre a bola e a mesa;
• Aplicar a força de atrito no deslocamento de objetos para que a
velocidade da bola diminua conforme sua movimentação;
• Demonstrar ângulos de reflexão aplicados após colisões.
14
3. REFERENCIAL TEÓRICO
Como aporte para este trabalho realizou-se uma pesquisa teórica sobre
alguns conceitos de Física, Matemática e Programação.
3.1 Física
Os conceitos de Física utilizados nesse trabalho são Reflexão, Força, Atrito e Colisão.
3.1.1 Reflexão
Fonseca (2011) diz que na Física o fenômeno da reflexão incide na alteração
de direção da propagação da energia, após entrar em contato com uma superfície
refletora. Como exemplo de reflexão, pode-se utilizar um jogo de sinuca, em que
uma bola rebatida nas laterais da mesa age como um raio de luz sendo refletido em
um espelho.
Figura 1: Reflexão da luz.
Fonte: Aulas de Física e Química.
15
A Figura 1 apresenta um exemplo onde uma luz choca-se com um espelho,
gerando assim uma reflexão no sentido contrário.
3.1.2 Força
Para Calvão (2007), força indica um agente capaz de alterar a circunstância
de repouso ou de movimento de um corpo. Uma força é formada pelos seguintes
elementos:
a) Ponto de aplicação – é a parte do corpo onde a força atua diretamente;
b) Sentido – é a orientação que tem a força na direção (esquerda, direita,
cima, baixo);
c) Direção – é a linha de atuação da força (horizontal, vertical, diagonal);
d) Intensidade – é o valor da força aplicada.
Segundo Marco Aurélio da Silva (2008):
Força designa um agente capaz de modificar o estado de repouso ou de
movimento de um determinado corpo. Porém, falar de força parece ser
muito abstrato, mas basta pensar em todas as tarefas diárias que
realizamos para que possamos perceber que força é algo que está presente
em nosso dia a dia. Por exemplo: quando empurramos ou puxamos um
objeto dizemos que estamos fazendo força sobre ele. Existem vários tipos
de força: força elétrica, força magnética, força gravitacional, força de atrito,
força peso, força normal e outras.
3.1.3 Atrito
Segundo Miranda (2012), o conceito de atrito está relacionado à força de
contato que atua quando dois corpos entram em choque. A força de atrito é
equivalente às superfícies e contrária ao movimento relativo. Quanto maior a força
16
nessa ocasião, maior será o atrito.
Ainda para Miranda (2012), existem dois tipos de atrito: atrito estático e atrito
cinético.
Atrito estático é o atrito que ocorre quando a força aplicada não é suficiente
para mexer o objeto, ou seja, a força aplicada é equiparada com a força de atrito. A
força de atrito estático tem intensidade variável. (MIRANDA, 2012).
O atrito cinético ocorre quando a força aplicada é maior que a força de atrito
em destaque. Nesses eventos, o corpo entra em movimento, deixando de ser
estático, e passando a ser cinético. Assim, o atrito cinético é o atrito que ocorre
quando os corpos se movimentam. (MIRANDA, 2012).
Para Machado (2013), pode-se qualificar também, as superfícies,
basicamente em dois tipos, rugosa e totalmente lisa. A classificação é definida
quanto à força de atrito.
A superfície rugosa dificulta o movimento de corpos, exemplo: a superfície de
madeira possui rugosidade, tornando-se mais complicado mover um objeto sobre
ela. (MACHADO, 2013).
Uma superfície totalmente lisa é uma superfície considerada ideal, em que o
nível de atrito é igual a zero. Estas superfícies não existem na realidade, somente na
teoria. (MACHADO, 2013).
Um exemplo prático no que se refere ao atrito, é que as mesas de sinuca de
bares geralmente são cobertas por um tecido sintético chamado acrílico. Já a lã é
mais utilizada em mesas oficiais. A vantagem deste tecido se dá pelos fios, que
aumentam o atrito entre a bola e a mesa, permitindo maior controle sobre a jogada e
diminuindo a velocidade da bola. (PORTILHO, 2013).
A Figura 2 apresenta um homem empurrando um objeto sobre uma superfície
rugosa. Como já explicado essa superfície dificulta a locomoção de objetos sobre a
mesma.
17
Figura 2: Atrito sobre superfície rugosa.
Fonte: Aulas de Física e Química.
3.1.4 Colisão
Para Kítor (2012), quando dois objetos se movem de modo a concorrer por
uma mesma posição em um dado instante de tempo, pode-se dizer que estão em
rota de colisão. Ou seja, se pelo menos um dos objetos está se movimentando de
forma que no referente instante de tempo ele atinja o segundo objeto, diz-se que
houve uma colisão entre os dois objetos.
De acordo com Domiciano Marques (2013).
Imagine uma partida de sinuca na qual uma bola é atirada contra outras
bolas gerando colisões. Nessas colisões podem ocorrer diversas situações,
como, por exemplo, uma bola para e outra segue em movimento, uma bola
segue atrás da outra, uma bola segue adiante e outra volta.
A Figura 3 ilustra a simulação de uma jogada qualquer em uma partida de
sinuca. A bola número 2 choca-se com a extremidade direita da mesa e volta; ocorre
também uma colisão entres as bolas número 3 e número 8, indo uma em direção
contrária a outra.
18
Figura 3: Mesa de sinuca.
Fonte: Os autores (2014).
3.2 Matemática
Os conceitos da matemática utilizados nesse trabalho foram Trigonometria e Ângulos.
3.2.1 Trigonometria
A trigonometria, segundo Noé (2013) é a parte da Matemática responsável
pela relação que existe entre os lados e os ângulos de um triângulo. Nos triângulos
retângulos que possuem um ângulo de 90º, as relações são formadas pelos
chamados ângulos notáveis, 30º, 45º e 60º, que possuem valores constantes
representados pelas relações seno, cosseno e tangente. Ressalta-se que a
trigonometria objetivou a criação dos estudos das funções trigonométricas,
relacionadas aos ângulos.
19
3.2.2 Ângulos
Noé (2013) diz que ângulo é a região do plano limitada por duas semirretas
de mesma origem. As semirretas ganham o nome de lados do ângulo e a origem
delas, de vértice do ângulo. A unidade habitual de medida de ângulo, conforme o
sistema internacional de medidas é o grau, representado pelo símbolo º.
Os ângulos podem ser classificados de acordo com suas medidas:
a) Agudo – ângulo com medida menor que 90º;
b) Reto – ângulo com medida igual a 90º;
c) Obtuso – ângulo com medida maior que 90º;
d) Raso – ângulo com medida igual a 0º ou 180º.
A Figura 4 apresenta as quatro classificações dos ângulos.
Figura 4: Exemplo de ângulos
Fonte: Brasil Escola.
3.3 Programação de computadores
Esta sessão apresenta conceitos relacionados a programação de
computadores.
20
3.3.1 Algoritmos
Segundo Pereira (2009), um algoritmo é uma sequência lógica, finita e
definida de comandos que devem ser seguidos para resolver um problema ou
executar uma tarefa. Nada mais é do que uma receita que mostra passo a passo os
procedimentos necessários para a resolução de uma tarefa.
Ainda para Pereira (2009), algoritmos são utilizados de forma intuitiva e
automática diariamente quando são executadas tarefas comuns. Por exemplo,
quando é necessário fazer a troca de uma lâmpada, é executa uma sequência de
passos, ou seja, considerado um algoritmo.
Os algoritmos são empregados na área de programação, apresentando as
etapas que precisam ser realizadas para que um programa execute as tarefas que
lhe são encarregadas. (PEREIRA, 2009).
3.3.2 Linguagens de programação
De acordo com Pacievitch (2012), a linguagem de programação é
simplesmente como se escreve o algoritmo. O problema para muitos é o que dizer
para o computador fazer, ou seja, o que é almejado. No momento de programar
alguns passos são necessários, como declarar variáveis. Essas variáveis podem ser
escritas por letras ou números, que simulam um valor que pode ser mudado a
qualquer instante.
Ainda para Pacievitch (2012), cada variável tem um espaço na memória para
guardar seus dados, contudo existem vários tipos de dados, sendo os mais comuns:
a) Numérico - todo e qualquer tipo de número, positivo ou negativo;
b) Reais - podem ser positivos, negativos ou decimais;
c) Caractere - são os textos, podendo conter números, entretanto estes não terão
função matemática. (PACIEVITCH, 2012).
Entender lógica de programação, para Pacievitch (2012) é saber o melhor
21
modo de escrever um código para o computador interpretar corretamente. É
conseguir se comunicar com a máquina a partir de uma linguagem de programação.
Segundo Gabriel Duarte (2013)
Podemos imaginar o computador como uma super calculadora, capaz de
fazer cálculos muito mais rápido que nós, mas para isso devemos dizer para
o computador o que deve ser calculado e como deve ser calculado. A
função das linguagens de programação é exatamente essa, ou seja, servir
de um meio de comunicação entre computadores e humanos.
3.3.3 Java
Java é uma linguagem de programação orientada a objetos, criada na década
de 1990. Os programas escritos nesta linguagem podem ser executados vários
sistemas operacionais, o que ajuda muito em sua expansão. Java possui várias
versões, sua atualização é constante, pois para a criação de novos programas é
preciso estar sempre avançando. (TEIXEIRA, 2009). Exemplos de códigos fonte
escritos nesta linguagem são demonstrados no decorrer do trabalho.
3.3.4 Desenhos em java
Para Silveira Neto (2008), a simples criação de desenhos em java se dá pela
utilização de classes, sendo possível fazer retângulos, círculos, arcos e etc. Também
é possível pintar o contorno e o preenchimento dos desenhos com cores. As cores
exibidas nas telas dos computadores são definidas pelos seus componentes
vermelho, verde e azul. Esses componentes, denominados valores RGB (em inglês
red, green e blue), contém valores inteiros entre 0 e 255. A combinação de valores
gera novas cores. Exemplo: misturado o verde e o vermelho se obtêm o amarelo.
Desenhos são formados por imagens. Conforme Soares (2010), “Uma
imagem digital é uma imagem bidimensional, que emprega um código binário de
22
modo a permitir o seu processamento, transferência, impressão ou reprodução”.
Nos desenhos em java pode-se perceber a aplicação de pixel em sua
constituição. De acordo com Fonseca (2008), o pixel é a menor parte de uma
imagem digital. Ao visualizar uma imagem com elevado índice de proximidade, é
possível identificar pequenos quadrados coloridos nela, que somados, formam o
desenho completo.
A Figura 5 apresenta uma comparação de imagem vista de longe (à
esquerda) e de perto (à direita).
Figura 5: Comparação de imagem.
Fonte: Os autores (2014).
3.4 Técnicas de simulação da física em jogos eletrônicos
Esta sessão apresenta conceitos referentes a técnicas de simulação da física
em jogos eletrônicos, tais como: animação e verificação de colisão.
23
3.4.1 Animação
Segundo Sanches (2010), animação em jogos funciona pelo mesmo princípio
que em filmes ou desenhos animados: a tela é desenhada uma certa quantidade de
vezes por segundo (geralmente em jogos o mínimo aceitável é de 30 vezes por
segundo) em cada novo desenho surge uma imagem um pouco diferente da
anterior. Cada vez que a tela é desenhada tem-se um novo quadro (ou frame) e
como o olho humano não consegue entender que as imagens estão sendo trocadas
a cada quadro, o cérebro é iludido e encara as alterações como movimento. As
animações em jogos eletrônicos estão cada vez mais desenvolvidas, fazendo com
que os personagens praticamente ganhem vida; servem para mostrar o estado do
personagem, se está correndo ou parado, trazendo grande realidade para os jogos.
O Quadro 1 apresenta parte do código Java responsável por desenhar os
frames.
Na linha 1, o laço de repetição while, faz com que o trecho entre as linhas 2 e
8 se repitam, dando o efeito de animação.
Na linha 2, a função atualizar() é utilizada para atualizar variáveis a cada
quadro por segundo, como por exemplo, as variáveis de colisão.
Na linha 3, a função desenharGraficos() é usada para desenhar toda a parte
gráfica do jogo, como os objetos que ficam na mesa.
Na linha 5, a função Thread.sleep() serve para fazer o programa pausar
durante um certo tempo, que deve ser expresso em milissegundos, no caso do jogo,
a quantia de quadros por segundo (FPS – Frames per second) divida por 1000 ms
ou 1 segundo.
A constante FPS guarda um valor inteiro que indica a quantia de quadros por
segundo que um jogo será executado, no caso do jogo, seu valor é 60, ou seja, a
cada 1 segundo, todo código que estiver inserido nas funções atualizar() e
desenharGraficos() será atualizado 60 vezes.
24
Quadro 1: Código de atualização da tela.
123456789
while (true){ atualizar(); desenharGraficos(); try{ Thread.sleep(1000/FPS); }catch (Exception e){ System.out.println("Thread interrompida!!!"); }}
Fonte: Os autores (2014).
3.4.2 Verificação de colisão
Detecção de colisão, em simulações físicas, jogos e geometria
computacional, envolvem algoritmos para verificação de colisões, que verificam
intersecções de dois corpos sólidos. A simulação do que acontece quando uma
colisão é detectada é chamada de resposta de colisão. Algoritmos de detecção de
colisão são componentes básicos de motores de jogos. (Brazil, 2008).
A verificação de uma colisão no jogo é simples. É preciso testar se o
retângulo correspondente à primeira textura intercepta o retângulo referente a uma
segunda textura. Caso intercepte significa que ocorreu uma colisão. (Brazil, 2008).
O código utilizado para a verificação de colisão é apresentado no Quadro 2.
Quadro 2: Verificação de colisão.
1234
public boolean colisao(int pontoX, int pontoY, int x, int y, int w, int h){ return (pontoX >= x && pontoX <= x + w) && (pontoY >= y && pontoY <= y + h); }
Fonte: Os autores (2014).
As variáveis x e y são coordenadas do objeto com que será identificado a
colisão. As variáveis w e h são, respectivamente, os valores de largura e altura do
25
objeto que está nas coordenadas x e y descritas anteriormente.
As variáveis pontoX e pontoY são coordenadas de um ponto que será idêntica
a colisão do objeto descrito acima. Este ponto irá definir se houve colisão entre as
variáveis x e y, w e h e uma das extremidades da bola: esquerda, direita, cima e
baixo.
A função return() retornará o que estiver dentro dos parênteses, que neste
caso será true (verdadeiro) caso a colisão estiver ocorrendo ou false (falso) caso ela
não esteja.
26
4. MATERIAL E MÉTODOS
Este capítulo apresenta os materiais e métodos utilizados no desenvolvimento
do software, explicando os códigos usados em funções do jogo.
4.1 MATERIAL
Na elaboração do projeto foram empregados o programa NetBeans IDE, que
pode ser utilizado para o desenvolvimento de programas em várias linguagens, e a
linguagem de programação Java, utilizada para a escrita dos códigos de
programação. A escolha destas ferramentas deu-se pela aprendizagem durante o
curso.
Foram pesquisadas linhas de código disponíveis na internet para a utilização
e criação do algoritmo de animação e para o algoritmo de colisão. Um dos fóruns
utilizados foi Seu Mestre na Web1.
Na construção do jogo foram aplicados alguns conceitos da Física, tais como
reflexão e atrito. Esses conceitos servem para controlar a movimentação da bola. E
conceitos da Matemática, como trigonometria e ângulos, que foram utilizados para
mudar a direção da bola no momento do contato com uma superfície sólida.
4.2 MÉTODOS
Para o desenvolvimento do software, além dos códigos encontrados na
internet, foram criados vários códigos de programação. A seguir serão demonstrados
trechos de códigos utilizados como métodos para a criação de funções no jogo.
1 http://seumestredaweb.blogspot.com.br
27
4.2.1 Código para reflexão
Esta sessão trata sobre o código utilizado no jogo para simular a reflexão. O
Quadro 3 apresenta o código responsável por esta simulação.
Quadro 3: Código de reflexão.
1234567891011121314151617181920
if (colidiuEsquerda){ bola.setX(bloco1.getX() + bloco1.getWidth() + 5); bola.setXspeed(bola.getXspeed() * -1); bola.setAngle(Math.toDegrees(Math.atan2(bola.getSin(), -bola.getCos())));}if (colidiuDireita){ bola.setX(bloco1.getX() - bola.getWidth() - 5); bola.setXspeed(bola.getXspeed() * -1); bola.setAngle(Math.toDegrees(Math.atan2(bola.getSin(), -bola.getCos())));}if (colidiuCima){ bola.setY(bloco1.getY() + bloco1.getHeight() + 5); bola.setYspeed(bola.getYspeed() * -1); bola.setAngle(Math.toDegrees(Math.atan2(-bola.getSin(), bola.getCos())));}if (colidiuBaixo){ bola.setY(bloco1.getY() - bola.getHeight() - 5); bola.setYspeed(bola.getYspeed() * -1); bola.setAngle(Math.toDegrees(Math.atan2(-bola.getSin(), bola.getCos())));}
Fonte: Os autores (2014).
A primeira linha de código dentro da função if (linha 1) modifica a posição da
bola para que ela não entre dentro do objeto e fique travada. A nova posição neste
caso será o lado esquerdo do bloco (posição do bloco mais a largura) e um
acréscimo de 5 pixeis. A segunda linha de código (linha 2) multiplica a velocidade
horizontal da bola por -1, fazendo com que ela inverta seu valor. A terceira linha de
código (linha 3) atualiza o valor do ângulo em que a bola está se movendo, serve
para evitar erros no movimento da bola. Estas ações são executadas quando é
detectado uma colisão à esquerda (linha 1).
28
4.2.2 Código para atrito
Esta sessão apresenta o código elaborado para simular o atrito, explicando
suas aplicabilidade. Este código é apresentado no Quadro 4.
Quadro 4: Código de atrito.
12345678910
if (bola.getSpeed() != 0){ tempFriction += 0.075; if (tempFriction >= 1){ friction = (int) tempFriction; tempFriction -= (int) tempFriction; }}else{ friction = 0; tempFriction = 0;}
Fonte: Os autores (2014).
Primeiramente o trecho de código verifica se a bola está se movendo (linha
1), caso esteja, o jogo retira 0.075 de velocidade da bola a cada passo do jogo (linha
2), mas como a velocidade só pode ser inteira, o jogo vai acumulando o valor em
uma variável temporária (tempFriction) (linha 2) e quando o valor dentro dessa
variável for maior que 1, uma condição if acrescenta o valor na variável friction que
por sua vez diminui a velocidade da bola (linha 3).
4.2.3 Desenhar objetos na tela
Elaborou-se um algoritmo para desenhar objetos na tela. Este é apresentado
parcialmente pelo Quadro 5.
29
Quadro 5: Desenhar objetos na tela.
12345
Graphics bbg = backBuffer.getGraphics();bbg.setColor(Color.white);bbg.fillOval(bola.getX(), bola.getY(), bola.getWidth(), bola.getHeight());bbg.fillRect(bloco1.getX(), bloco1.getY(), bloco1.getWidth(), bloco1.getHeight());bbg.fillRect(bloco2.getX(), bloco2.getY(), bloco2.getWidth(), bloco2.getHeight());
Fonte: Os autores (2014).
A primeira linha de código é responsável por carregar o local onde a bola e os
obstáculos serão desenhados (neste caso, o objeto que desenha a mesa na tela).
Na linha 2, o código setColor() muda a cor do desenho atual, no caso, para
branco.
Na linha 3, fillOval() desenha um objeto oval na tela, usando as variáveis de
posição e tamanho da bola.
Nas linhas 4 e 5, fillRect() desenha um objeto retangular, usando as variáveis
de posição e tamanho dos obstáculos.
4.2.4 Desenhar a linha da trajetória da bola
É necessário apresentar ao jogador a direção para onde a bola será
arremessada após a tacada. No jogo, isto é demonstrado por uma linha azul que
parte do centro da bola em direção à direção da tacada. A Figura 6 apresenta a bola
(apresentada como um círculo preto para diferenciar do fundo) e sua linha de
trajetória.
Figura 6: Trajetória da bola.
Fonte: Os autores (2015).
30
Apresenta-se a seguir o código para a linha da trajetória da bola, com
explicação de suas funções.
Após a nova cor ser aplicada (linha 1), o jogo desenha a linha que mostra
para onde a bola deve se direcionar (linha 2) usando as funções que indicam a
posição do centro da bola (bola.getXMid() e bola.getYMid()) para desenhar o início
da linha e as variáveis que indicam as coordenadas de encerramento da linha
(bola.getXLine2() e bola.getYLine2()) que são resultantes de cálculos dentro de suas
funções como pode-se ver no quadro 7.
No Quadro 6 apresenta-se o código que desenha a linha da trajetória da bola.
Quadro 6: Desenhar a linha da trajetória.
123
bbg.setColor(Color.blue);bbg.drawLine(bola.getXMid(), bola.getYMid(), bola.getXLine2(), bola.getYLine2());
Fonte: Os autores (2014).
Os comandos calculam a posição final da linha, que indica a trajetória da bola,
utilizando os conceitos de seno e cosseno do ângulo escolhido pelo jogador, após
serem multiplicados por 100 (linhas 2 e 5), eles resultam em tamanho adequado
para a linha, tornando-a mais visível ao jogador.
O Quadro 7 apresenta o código para calcular o final da linha da trajetória da
bola.
Quadro 7: Calcular o final da linha da trajetória.
123456
public int getXLine2() { return (int) (Math.cos(this.angleradians) * 100 + this.getXMid());}public int getYLine2() { return (int) (Math.sin(this.angleradians) * 100 + this.getYMid());}
Fonte: Os autores (2014).
31
4.2.5 Comandos do jogo
Explana-se nesta sessão sobre os códigos utilizados para os comandos do
jogo.
A primeira função if checa se a tecla seta para cima foi pressionada. Caso
seja, o código diminui uma unidade na variável responsável pelo ângulo para onde a
bola está direcionada, fazendo com que a direção para onde a bola irá partir no
momento que for lançada, mude.
A segunda função if é muito semelhante à primeira, porém esta verifica se a
tecla seta para baixo foi pressionada e, ao contrário dá primeira, aumenta em uma
unidade o valor da unidade responsável pelo ângulo da bola, também a direcionando
para uma posição diferente.
A terceira função if será responsável por identificar se a tecla espaço foi
pressionada. Se for, ela muda a velocidade da bola de acordo com o valor da força
da tacada no momento em que a tecla foi pressionada.
No Quadro 8 apresenta-se o código dos comandos do jogo.
Quadro 8: Comandos do jogo.
123456789
if(e.getKeyCode()==e.VK_UP){ bola.setAngle(bola.getAngle()-1);}if(e.getKeyCode()==e.VK_DOWN){ bola.setAngle(bola.getAngle()+1);}if(e.getKeyCode()==e.VK_SPACE){ bola.setSpeed((int)power);}
Fonte: Os autores (2014).
32
4.2.6 Código para pontuação
Quando o número de tacadas for diferente de 0, o jogo divide o valor de 1000
pelo número de tacadas. O resultado é adicionado à pontuação atual do jogador. O
código de pontuação é apresentado no Quadro 9.
Quadro 9: Código para o cálculo da pontuação.
123
if (tacadas != 0){ pontuacao+=(int) (1000/tacadas); }
Fonte: Os autores (2014).
3.2.7 Códigos para a barra de força
A barra de força serve para orientar o jogador sobre a força que será aplicada
a bola no momento da tacada. Esta barra alterna seu tamanho no decorrer do
tempo, aumento e diminuindo automaticamente. O jogador pode escolher a força
que deseja aplicar à bola, pressionando a tecla espaço no momento que a barra
estiver no tamanho desejado.
O Quadro 10 apresenta o código que o jogo utiliza para variar a força da bola.
Este código é executado em um laço de repetição que repete 60 vezes por
segundo2. Na primeira linha de código, a função if verifica se o jogo está ou não
adicionando força; caso esteja, adiciona um valor de 0,5 à variável power; caso não
esteja, o jogo retira 0,5 desta variável.
Quadro 10: Código para a barra de força 1.
1234
if (adding){ power += 0.5;}else{ power -= 0.5; }
Fonte: Os autores (2015).
2 Este código de variação de força é executado junto com a atualização da tela do jogo.
33
A força da tacada possui como valor máximo 15 e valor mínimo 0. Quando um
destes limites é atingido, se a força estava aumentando, ela começa a diminuir; se
estava diminuindo, começa a aumentar. O Quadro 11 apresenta o código que faz
esta mudança.
Quadro 11: Código para a barra de força 2.
123456
if (power>15){ adding = false;}if (power<=0){ adding = true;}
Fonte: Os autores (2015).
Na primeira linha, a função if verifica se a variável power contém um valor
maior que 15; caso contenha, é atribuído o valor false à variável adding, ou seja,
indica que a força deve diminuir no decorrer do tempo. Se a variável power conter
um valor menor ou igual a zero, o valor a ser atribuído a variável adding é true,
indicando que a força deve aumentar conforme o tempo passa.
O valor da força é utilizado para definir a largura da barra de força. A cada
atualização da tela, a barra é desenhada de acordo com o valor da força. O Quadro
12 apresenta o código para desenhar a barra de força na tela do jogo.
Quadro 12: Código para a barra de força 3
1 bbg.fillRect(25, janelaH - 30, (int) power*4, 20);
Fonte: Os autores (2015).
34
5. RESULTADO E DISCUSSÃO
Como resultado foi obtido um jogo de sinuca onde existem barreiras e o
jogador deve desviá-las utilizando a reflexão, com o objetivo de acertar o alvo. A
força com que a bola é arremessada, é definida pelo tamanho da barra de força no
momento da tacada. Esta barra aumenta e diminui de tamanho conforme o tempo
passa. No momento em que o jogador tecla espaço, ocorre o arremesso da bola.
No jogo existem 6 tipos de mesa, algumas com um obstáculo e outras com
dois obstáculos. A mesa muda após o jogador acertar o alvo. O tamanho do alvo
também muda conforme a mesa. A pontuação é definida por 1000/t, sendo que t é o
número de tacadas. Ao final das 6 mesas, aparece na tela a soma do total de pontos
conquistado pelo jogador durante a partida.
Cada vez que o jogador pressiona as teclas direcionais do teclado, o ângulo
diminui (tecla baixo) ou aumenta (tecla cima). Esta mudança de ângulos aparece na
tela, ao lado direito da mesa, pela indicação Ângulo: nº, em que n é o ângulo de
direção da bola; conforme apresentado pela Figura 7. Os ângulos mudam a direção
da bola após o choque com uma superfície sólida.
Figura 7: Tela do jogo
Fonte: Os autores (2014).
35
Além do ângulo de direção da bola, são apresentados os ângulos de pós-
colisão vertical e pós-colisão horizontal. O ângulo de pós-colisão vertical apresenta
o ângulo que a bola assumirá após uma colisão no eixo vertical (eixo x). Similar a
este, o ângulo de pós-colisão horizontal apresenta o ângulo obtido após uma colisão
no eixo horizontal (eixo y). A Figura 7 apresenta a tela do jogo:
36
6. CONSIDERAÇÕES FINAIS
Nesta pesquisa foram revisados alguns conceitos e classificações sobre
trigonometria, ângulo, força, atrito, reflexão, e elaboração de softwares, segundo os
autores estudados. Além disso, foi elaborado um jogo de sinuca que envolve os
conceitos citados acima de acordo com os objetivos propostos.
Os objetivos foram alcançados, a trigonometria foi empregada para o cálculo
de reflexão, algoritmos de colisão foram utilizados para a verificação de choques
entre a bola e alguma superfície sólida.
O jogo desenvolvido para a conclusão do curso poderá ser utilizado em aulas
de Física e Matemática com o intuito dos alunos compreenderem melhor o conceito
e aplicação de ângulos.
Com a realização do trabalho foram obtidos conhecimentos que auxiliarão no
transcorrer da vida, pois não foram adquiridas apenas habilidades técnicas do
estudo, mas também como agir em conjunto, algo importante para conviver em
sociedade; teve-se que aprender a conviver com os limites e dificuldades um do
outro, assim a amizade tornou-se mais forte e verdadeira.
A elaboração desta pesquisa foi considerada gratificante pelos pesquisadores,
pois o estudo revelou a importância da aplicação dos conceitos de física,
Matemática e Programação para a elaboração de softwares de qualidade.
O resultado obtido foi satisfatório, o programa pode ajudar o jogador a
aprender sobre ângulos, visto que, muitas pessoas não compreendem o conceito de
ângulo e sua aplicação, pode ser utilizado na hora do lazer ou de estudar o
conteúdo.
O trabalho pode ter continuidade em seu desenvolvimento, adicionando novas
funções, tais como; caçapa, acerto ao alvo valendo pontos e ranking. Possibilitando
assim, uma expansão do projeto em uma nova formação acadêmica.
37
REFERÊNCIAS
AULAS DE FISICA E QUIMICA. ATRITO. Disponível em: <http://www.aulas-fisica-quimica.com/9f_13.html>. Acessado em 19 de janeiro de 2015.
AULAS DE FISICA E QUIMICA. REFLEXÃO DA LUZ. Disponível em: <http://www.aulas-fisica-quimica.com/8f_15.html>. Acessado em 19 de janeiro de 2015.
BRASIL ESCOLA. Colisões. Disponível em: <http://www.brasilescola.com/fisica/colisoes.htm>. Acessado em 23 de abril de 2014.
BRASIL ESCOLA. Força. Disponível em: <http://www.brasilescola.com/fisica/forca.htm>. Acessado em 23 de abril de 2014.
BRAZIL, André Luiz . Colisões em jogos. Disponível em: <http://www.selectgame.com.br/wp-content/uploads/Aula9.pdf>. Acessado em 30 de abril de 2014.
CAELUM. Java. Disponível em: <http://www.caelum.com.br/apostila-java-orientacao-objetos/o-que-e-java/#2-3-maquina-virtual>. Acessado em 30 de abril de 2014.
CALVÃO, Alexandre Ortiz. Força. Disponível em: <http://www.ebah.com.br/content/ABAAAAkNEAL/resumao-fisica>. Acessado em 20 de novembro de 2014.
FONSECA, Diogo. Reflexão. Disponível em: <http://fisicaoquadrado.wordpress.com/fisicafix/actividades-de-fisica-com-o-crocodile-physics/optica_reflexao-e-refraccao/>. Acessado em 21 de novembro de 2014.
FONSECA, Willian. Pixel. Disponível em: <http://www.tecmundo.com.br/imagem/203-o-que-e-pixel-.htm>. Acessado em 21 de novembro de 2014.
GRUPO ESCOLAR. Atrito. Disponível em: <http://www.grupoescolar.com/pesquisa/atrito.html>. Acessado em 23 de abril de 2014.
GRUPO ESCOLAR. Força. Disponível em: <http://www.grupoescolar.com/pesquisa/forcas.html>. Acessado em 23 de abril de
38
2014.
INFOESCOLA. Java. Disponível em: <http://www.infoescola.com/informatica/historia-do-java/>. Acessado em 30 de abril de 2014.
INFOESCOLA. Linguagens de programação. Disponível em: <http://www.infoescola.com/informatica/o-que-sao-linguagens-de-programacao/>. Acessado em 30 de abril de 2014.
INFOESCOLA. Linguagens de programação. Disponível em: <http://www.infoescola.com/informatica/o-que-sao-linguagens-de-programacao/>. Acessado em 30 de abril de 2014.
INFOPÉDIA. Colisão. Disponível em: <http://www.infopedia.pt/$colisao-(fisica);jsessionid=emDQp86c7urI5JDW0Lm57g>. Acessado em 23 de abril de 2014.
JAVA GAMES 2D. Animação. Disponível em: <http://seumestredaweb.blogspot.com.br/2012/06/java-games-2d-tutor-3.html>. Acessado em 30 de abril de 2014.
JAVA GAMES 2D. Colisão. Disponível em: <http://seumestredaweb.blogspot.com.br/2012/06/java-games-2d-tutorial-parte-11.html>. Acessado em 30 de abril de 2014.
KITOR, Glauber Luciano. Colisão. Disponível em: <http://www.infoescola.com/fisica/colisao-inelastica/>. Acessado em 20 de novembro de 2014.
MACHADO, Nuno. Atrito. Disponível em: <http://www.aulas-fisica-quimica.com/9f_13.html>. Acessado em 22 de novembro de 2014.
MAFRA, Aldilene. O crescimento e as expectativas do mercado de games no Brasil. Disponível em: <http://www.uva.br/noticias/o-crescimento-e-expectativas-do-mercado-de-games-no-brasil >. Acessado em 21 de novembro de 2014.
MIRANDA, Juliana. Atrito. Disponível em: <http://www.grupoescolar.com/pesquisa/atrito.html>. Acessado em 22 de novembro de 2014.
NETO, Silveira. Desenhos em java. Disponível em: <http://silveiraneto.net/2008/01/15/desenhando-com-java-e-netbeans/>. Acessado em 22 de novembro de 2014.
NOÉ, Marcos. Ângulos. Disponível em: <http://www.brasilescola.com/matematica/angulos.htm>. Acessado em 22 de novembro de 2014.
39
NOÉ, Marcos. Trigonometria. Disponível em: <http://www.brasilescola.com/matematica/trigonometria.htm>. Acessado em 20 de novembro de 2014.
PACIEVITCH, Yuri. Linguagens de programação. Disponível em: <http://www.infoescola.com/informatica/logica-de-programacao/>. Acessado em 22 de novembro de 2014.
PEREIRA, Ana Paula. Algoritmos. Disponível em: <http://www.tecmundo.com.br/programacao/2082-o-que-e-algoritmo-.htm>. Acessado em 22 de novembro de 2014.
PORTILHO, Gabriela. Colisão. Disponível em: <http://mundoestranho.abril.com.br/materia/como-funciona-uma-mesa-de-bilhar>. Acessado em 21 de novembro de 2014.
SANCHES, Bruno Crivelari. Animação. Disponível em: <http://www.pontov.com.br/site/arquitetura/51-programacao/140-tecnicas-de-animacao-3d>. Acessado em 24 de novembro de 2014.
SOARES, Ana Catarina. Imagem. Disponível em: <https://anasoares1.wordpress.com/2010/11/22/introducao-a-imagem-digital-definicao-de-pixel-e-cores-digitais/>. Acessado em 23 de novembro de 2014.
TABELA DE CORES HTML. RGB. Disponível em: <http://erikasarti.net/html/tabela-cores/>. Acessado em 21 de novembro de 2014.
TEIXEIRA, Maria. Java. Disponível em: <http://www.ceunes.ufes.br/downloads/2/mariateixeira-EC.Programa%C3%A7%C3%A3o%20III.Cap%C3%ADtulo%203.Item%201-2.2009.2.pdf>. Acessado em 21 de novembro de 2014.
