Introdução à Ciência
da Computação com Jogos
Preencha a ficha de cadastro no final deste livro
e receba gratuitamente informações
sobre os lançamentos e as promoções da Elsevier.
Consulte também nosso catálogo completo,
últimos lançamentos e serviços exclusivos no site
www.elsevier.com.br
Introdução à Ciência
da Computação com Jogos
© 2010, Elsevier Editora Ltda.
Todos os direitos reservados e protegidos pela Lei no 9.610, de 19/02/1998.
Nenhuma parte deste livro, sem autorização prévia por escrito da editora, poderá ser reproduzida ou
transmitida sejam quais forem os meios empregados: eletrônicos, mecânicos, fotográficos, gravação ou
quaisquer outros.
Copidesque: Adriana Kraner
Revisão: Marília Pinto de Oliveira
Editoração Eletrônica: SBNIGRI Artes e Textos Ltda.
Elsevier Editora Ltda.
Conhecimento sem Fronteiras
Rua Sete de Setembro, 111 – 16o andar
20050-006 – Centro – Rio de Janeiro – RJ – Brasil
Rua Quintana, 753 – 8o andar
04569-011 – Brooklin – São Paulo – SP – Brasil
Serviço de Atendimento ao Cliente
0800-0265340
[email protected]
ISBN 978-85-352-3419-0
Nota: Muito zelo e técnica foram empregados na edição desta obra. No entanto, podem ocorrer erros
de digitação, impressão ou dúvida conceitual. Em qualquer das hipóteses, solicitamos a comunicação
ao nosso Serviço de Atendimento ao Cliente, para que possamos esclarecer ou encaminhar a questão.
Nem a editora nem o autor assumem qualquer responsabilidade por eventuais danos ou perdas a
pessoas ou bens, originados do uso desta publicação.
CIP-Brasil. Catalogação-na-fonte.
Sindicato Nacional dos Editores de Livros, RJ
_________________________________________________________________________
F328i Feijó, Bruno
Introdução à ciência da computação com jogos : aprendendo a
programar com entretenimento / Bruno Feijó, Esteban Clua e Flavio
S. Corrêa da Silva. – Rio de Janeiro: Elsevier, 2010.
Apêndice
ISBN 978-85-352-3419-0
1. Programação (Computadores). 2. Jogos por computador. 3. Animação por computador. 4. Computação. I. Clua, Esteban. II. Silva,
Flavio S. Corrêa da. III. Título.
09-4873.
CDD: 005.1
CDU: 004.42
_________________________________________________________________________
Agradecimentos
Muitas pessoas contribuíram para a realização desta obra. Em primeiro
lugar estão as nossas famílias, que se privaram do nosso convívio e da nossa
atenção durante a nossa contínua e exagerada jornada extra de trabalho. Para
eles vão os agradecimentos, literalmente infinitos, pelos apoio, compreensão
e paciência. Bruno agradece à sua esposa Carmem e aos seus filhos Marcelo e
Leonardo. Esteban agradece à sua esposa Luciana. Flávio agradece à sua esposa Renata e à sua filha Maria Clara.
Este livro não teria surgido sem o espírito inovador de Karin Breitman
(professora e pesquisadora do Departamento de Informática da PUC-Rio)
que, na qualidade de Diretora de Publicações da Sociedade Brasileira de Computação, deu toda a atenção e todo o estímulo aos autores.
Agradecimentos efusivos vão para a equipe da Editora Campus Elsevier
que com rigor, competência e muita paciência nos acompanharam passo a
passo. Em especial, gostaríamos de citar André Gerhard Wolff, Vanessa Vilas
Bôas Huguenin e Silvia Barbosa Lima.
Sem a ajuda de Lucas Machado e Rodrigo Martins, o motor javaPlay não
teria sido possível. Não temos como agradecer suficientemente a dedicação
desses dois pesquisadores do VisionLab/PUC-Rio. Raros profissionais no país
têm a competência desses dois pioneiros da área de jogos digitais.
A equipe por detrás deste livro é ainda maior e a muitos devemos palavras de agradecimento: Luciana Rocha Mariz Clua, por sua ajuda em design
gráfico; Fernando Ribeiro e Pablo Bioni, pela arte nos elementos visuais dos
jogos; Anselmo Antunes Montenegro e Dante Corbucci Filho, professores do
Instituto de Computação/UFF, como consultores em Java; e Marcelo Pana-
ro Zamith, pela ajuda no material de demonstração colocado no site. Com o
receio de não sermos suficientemente abrangentes e considerando o grande
número de pessoas, nos limitamos a agradecer, em bloco, a todos os nossos
alunos – nossa primeira fonte de inspiração e de colaboração na pesquisa e
no ensino – por seus permanentes questionamentos, suas incuráveis mentes
criativas e suas alegrias em aprender e ajudar.
Os Autores
Bruno Feijó possui graduação em Engenharia Aeronáutica pelo
ITA, mestrado em simulação dinâmica pela PUC-Rio e doutorado em CAD
(Computer-Aided Design) pela University of London. Atualmente é professor
associado do DI (Departamento de Informática) da PUC-Rio, no Grupo de
Computação Gráfica e Entretenimento Digital, e Coordenador do VisionLab/
PUC-Rio – Laboratório de Visualização, TV/Cinema Digital, Games e Produção de Conteúdo Digital. É pioneiro em 3 áreas de pesquisa em Informática
no país: CAD, Animação e Jogos. Foi um dos criadores da Comissão Especial
da SBC em Jogos e Entretenimento Digital e foi o seu primeiro Presidente. Ele
também é um dos fundadores do SBGames (Simpósio Brasileiro de Jogos e
Entretenimento Digital). Foi o idealizador da Rede Brasileira de Visualização
(RBV) ligada ao MCT. Também foi um dos principais colaboradores na idealização do curso profissionalizante do Núcleo de Pesquisa em Educação, criado
pelo Instituto Oi Futuro. Na pós-graduação do Departamento de Informática
da PUC-Rio, da qual já foi Coordenador, ministra cursos de jogos, animação
e efeitos especiais. Na graduação do DI/PUC-Rio, da qual já foi Coordenador,
tem ministrado os cursos de introdução à ciência da computação por cerca de
15 anos.
Esteban Clua possui graduação em Computação pela USP, mestrado
pela PUC-Rio e doutorado também pela PUC-Rio. Atualmente é professor
do Instituto de Computação da UFF e coordenador geral do UFF Media Lab,
além de atuar na pós-graduação dessa universidade. Atua especialmente na
área de Computação Gráfica em tempo real, Games, Realidade Virtual, GPUs,
visualização e simulação. É membro do conselho administrativo da ABRAGAMES, membro da Comissão Especial de Jogos e Entretenimento Digital
da SBC e um dos pioneiros na área de pesquisa científica em jogos e entretenimento digital. Também é um dos criadores do SBGames e um grande entusiasta da área de jogos digitais.
Flávio S. Correa da Silva possui graduação em Engenharia de Produção pela USP, mestrado pela Politécnica da USP e doutorado em Inteligência Artificial pela University of Edinburgh. Atualmente é professor associado
da USP, revisor do Journal of Information Technology Research e membro do
corpo editorial da Applied Intelligence (Boston).
Prefácio
Estamos vivendo a revolução do mundo digital, onde ter noções de
programação é tão essencial quanto saber o básico da matemática, da física,
da economia, e quem sabe até dos primeiros socorros médicos... Até mesmo
artistas e designers já perceberam que programar está na essência das novas
mídias. Se você abriu este livro, muito provavelmente você ou é um fissurado
por jogos, ou é um estudante, ou é um educador, ou pelo menos é um curioso
incorrigível (uma das maiores qualidades do novo profissional criativo). Em
qualquer desses casos, você deve estar buscando uma introdução à arte de programar que esteja mais próxima das novas demandas do mundo digital e que
seja menos maçante para acompanhar. Você também pode estar procurando
uma introdução à arte de desenvolver jogos digitais, quer porque você almeja
ser um profissional da área, quer porque lhe disseram que o jogo digital é uma
aplicação onde convergem os maiores desafios da computação (um jogo tem
que ser multimídia, visualmente elaborado, distribuído, artificialmente inteligente ... e tudo isso rodando em tempo real). Como educador, muito provavelmente você deve estar buscando um texto mais leve e estimulante para
a geração de jovens Y. Este livro pretende atender a todas essas expectativas.
Muita coisa mudou desde que a primeira linguagem de programação de
alto nível foi lançada há mais de 50 anos. Desde então, as linguagens e os paradigmas de programação têm evoluído constantemente. Linguagens caem em
desuso e novas surgem. E qual a melhor linguagem para aprender no momento? Essa é uma pergunta que vem sendo formulada desde o momento em que
surgiram duas linguagens diferentes e os primeiros cursos de computação; e
provavelmente continuará a ser feita até o dia em que não precisaremos mais
dos computadores... Muito dificilmente haverá um consenso na resposta a essa
pergunta, mesmo entre os mais conceituados cientistas de computação do país.
Não existe a situação ideal de que podemos aprender os conceitos da ciência da
computação sem nos incomodarmos com as idiossincrasias e as complexidades
de uma particular linguagem. Talvez o Lisp seja a que mais tenha se aproximado deste ideal (sua qualidade é atestada pelo fato de ser a segunda mais antiga
linguagem do planeta ainda viva). Mas o Lisp está longe de ser uma opção para
as novas demandas do mundo digital. A linguagem C já está distante dos novos
paradigmas de programação. C++ é muito eficiente, especialmente no mundo
dos jogos 3D, mas além de estar se tornando antiga, não é uma linguagem de
fácil aprendizado. Neste livro optamos pela linguagem Java por várias razões.
Primeiro, o Java possibilita aplicações em uma grande variedade de plataformas:
internet nos servidores, PCs, celulares e sistemas embarcados. Segundo, o Java
roda em mais de um sistema operacional (Windows, Linux, ...) e conta com um
bom ambiente de desenvolvimento gratuito (NetBeans). Terceiro, o Java é uma
linguagem orientada a objetos – um paradigma atual de programação. Quarto,
Java é o ponto de partida para a programação da internet – a invenção que determinará o futuro da computação. Quinto, a próxima geração de linguagens
orientadas a objetos será a evolução natural do Java (como já o é a linguagem
C#). Sexto, Java serve muito bem para desenvolver jogos 2D – o tipo de aplicação que estamos usando neste livro.
Independente da escolha do Java, este livro procura, antes de mais nada,
apresentar os conceitos e os bons hábitos da arte de programar. Dessa maneira, o livro está organizado em duas partes. A primeira parte se concentra na
programação procedimental estruturada (capítulos 2 a 6) e a segunda parte é
dedicada aos paradigmas de orientação orientada a objetos e de programação
guiada a eventos (capítulos 7 a 9). Introduzir o conceito de orientação a objetos não é uma tarefa fácil, mas é indispensável no cenário atual da ciência
da computação. Este livro procura ir trazendo esse novo conceito aos poucos,
sem pretender esgotar o assunto, nem aspirar ser usado como um livro de
referência. Este é um livro didático que funciona como ponto de partida para
os modernos conceitos em ciência da computação. O projeto deste livro inclui
uma terceira parte, disponível na internet, que pode sustentar um curso mais
avançado e/ou pode dar continuidade a uma especialização na área de desenvolvimento de jogos:
www.inf.puc-rio.br/livroicc
A melhor maneira de usar este livro é implementar cada exemplo citado
no texto e fazer os exercícios no final de cada capítulo. Um motor de jogo 2D,
chamado javaPlay, foi especialmente desenvolvido para este livro. O javaPlay
é conciso, didático, mas tem uma estrutura profissional, moderna e com possibilidade de ser usado com eficiência pela indústria. O javaPlay é apresentado em várias versões de graus crescentes de complexidade: Mini (a versão
minimalista, para começar), Versão 00 (a versão intermediária) e Versão 0 (a
versão-base mais completa). A Versão 1 deverá ser a que o leitor mais dedicado certamente criará.
Os apêndices complementam o estudo e servem de referência. Recomendamos, em especial, que sejam feitos os projetos de jogos do Apêndice B.
Os amantes de desenvolvimento de jogos acharão muito interessante o Apêndice A. Os Apêndices C e D servem de referência para o motor de jogo javaPlay.
Este é um livro texto para um primeiro curso de introdução à ciência da
computação, usando a criação de jogos digitais como instrumento de aprendizado e motivação. Esta obra é organizada em uma sequência de tópicos que
correspondem a um curso de 64 horas, em blocos de 4h/semana (16 semanas,
ao total). Sugestões de sequência de assuntos e material de suporte ao professor e ao aluno podem ser encontrados na página Web citada anteriormente.
Uma possível sequência para 16 semanas pode ser:
semana 1:
apresentação e cap.1
semana 2:
cap.2
semana 3:
cap.3
semanas 4 a 6:
cap.4
semana 7:
cap.5
semana 8:
cap.6
semanas 9 a 11:
cap.7
semanas 12 a 14: cap.8
semanas 15 e 16: cap.9
Uma outra sequência de aprendizado pode ser proposta através de dois
cursos, com mais tempo para elaborar os conceitos:
Curso I – Programação Procedimental Estruturada
Cap. 1 ao Cap. 5
Cap.6 como preparação ao Curso II
Curso II – Programação Orientada a Objetos e Guiada a Eventos
Cap. 7 ao Cap. 9
Material extra no site sobre estruturas de dados
A presente obra é resultado de anos de experiência dos autores no ensino de programação e de disciplinas de jogos, em três das melhores universidades do país. Este livro representa uma contribuição tanto para iniciar as
pessoas na arte da programação como para ajudar na formação básica da mão
de obra necessária para as oportunidades que surgem com a indústria do entretenimento (jogos e TV digital interativa) e com as aplicações de simulação
em tempo real.
Sumário
Capítulo 1 – Computadores ........................................................................ 1
1.1. A Long Long Time ago…............................................................................. 1
1.2. al-Khowarizm ................................................................................................ 3
1.3. Para que serve a computação? ..................................................................... 5
1.4. Qual é o idioma dos computadores? .......................................................... 6
1.5. Insetos ............................................................................................................. 9
1.6. Sintaxe e semântica ..................................................................................... 10
1.7. Arquitetura de computadores.................................................................... 11
CPU............................................................................................................... 12
Memória ....................................................................................................... 14
Barramento .................................................................................................. 14
1.8. Dispositivos de entrada e saída ................................................................. 15
Capítulo 2 – Variáveis, Tipos de Dados e Expressões ............................... 17
2.1. Primeiros passos, ou melhor, primeiras palavras em Java ..................... 18
2.2. Saída de dados ............................................................................................. 21
2.3. Comentários ................................................................................................ 22
2.4. Variáveis ....................................................................................................... 23
2.5. Entrada de dados......................................................................................... 29
2.6. Expressões .................................................................................................... 31
Exercícios................................................................................................................ 40
Capítulo 3 – Controle de Fluxo por Comandos de Seleção...................... 43
3.1. O comando if-else ....................................................................................... 44
3.2. O comando Switch ...................................................................................... 48
3.3. Um pouco mais sobre controle de fluxo .................................................. 52
Exercícios................................................................................................................ 52
Capítulo 4 – Métodos e Soluções .............................................................. 55
4.1. Métodos ........................................................................................................ 55
4.2. Criando um método estático ..................................................................... 57
4.3. Sobrecarga de métodos............................................................................... 60
4.4. Soluções Iterativas com laços .................................................................... 61
4.4.1. O Laço while ............................................................................... 62
4.4.2. Erros Numéricos em Soluções Iterativas .................................... 64
4.4.3. Os Laços for e do-while ........................................................ 68
4.5. Soluções recursivas ..................................................................................... 70
Exercícios................................................................................................................ 77
Capítulo 5 – Dados compostos como vetores ........................................... 79
5.1. Vetores unidimensionais ............................................................................ 80
5.2. Vetores bidimensionais .............................................................................. 85
Exercícios ................................................................................................... 87
Capítulo 6 – Usando Mais Objetos e Classes Simples .............................. 89
6.1. Um programa, muitas classes... ................................................................. 90
6.2. O tipo de dados String................................................................................ 93
6.3. Leitura e gravação de arquivos .................................................................. 96
6.4. Classes abstratas e interfaces ..................................................................... 98
Exercícios..............................................................................................................101
Capítulo 7 – Classes, Objetos e Herança..................................................103
7.1. Classes e objetos ........................................................................................104
7.2. O modificador Static .................................................................................107
7.3. Instância versus estático ...........................................................................108
7.4. Abstração de classe e encapsulamento ...................................................109
7.5. A referência this ....................................................................................113
7.6. Herança ......................................................................................................114
7.7. A palavra-chave super ...........................................................................118
7.8. Classes abstratas ........................................................................................119
7.9. As classes GameObject e Player ..............................................................123
Exercícios..............................................................................................................125
Capítulo 8 – Programação Gráfica ..........................................................127
8.1. As classes Graphics e Color.......................................................................128
8.2. Escrevendo texto no modo gráfico .........................................................138
8.3. O Game Loop ............................................................................................140
8.4. Incrementando o modo gráfico...............................................................144
8.5. Colisão ........................................................................................................153
8.6. Opsss... tratamento de exceção................................................................156
Exercícios..............................................................................................................160
Capítulo 9 – Programação Guiada a Eventos ..........................................163
9.1. Eventos e ações simples ............................................................................164
9.2. Eventos de teclado.....................................................................................167
9.3. Eventos definidos no contexto do jogo ..................................................170
Exercícios..............................................................................................................177
APÊNDICES
A – Desenvolvimento e Design de Jogos ..................................................181
A.1. Introdução..................................................................................................181
A.2. Design de um jogo ....................................................................................182
A.3. Desenvolvimento artístico .......................................................................188
Modelagem 3D ..........................................................................................188
Terrenos ......................................................................................................190
A.4. Programação / Motores de jogos ............................................................191
Módulo de Visualização ...........................................................................194
Módulo de Física .......................................................................................196
Módulo de Áudio ......................................................................................197
Módulo de Inteligência Artificial ............................................................197
A.5. Motores de jogos: Qual usar? ..................................................................198
Bibliografia ...........................................................................................................199
B – Sugestões de Projetos .........................................................................201
B.1. Frogger........................................................................................................201
B.2. SpaceWar!...................................................................................................202
B.3. Tetris ...........................................................................................................203
C – O Motor 2D javaPlay..........................................................................205
C.1. JavaPlay – Versão Mini .............................................................................206
C.1.1. Demo da Versão Mini .................................................................207
C.1.2. javaPlay reduzido para a Versão Mini.......................................209
C.2. Demo Versão 00 ........................................................................................213
C.3. Demo da Versão 0 .....................................................................................222
C.4. javaPlay para as Versões 00 e 0 ................................................................233
D – O Projeto do javaPlay ........................................................................250
D.1. Arquitetura geral .......................................................................................250
D.2. Sistema Motor............................................................................................251
D.3. Sistema de estado ......................................................................................252
D.4. Objetos de jogo ..........................................................................................253
D.5. Sistemas de entrada...................................................................................253
D.6. Sistema gráfico ...........................................................................................254
D.7. Sprites .........................................................................................................256
D.8. Exemplo de loop........................................................................................256
Índice Remissivo ......................................................................................259