documentação do simple tetris(versão 1.8) - franciele ehrhardt hoffmann

SIMPLE TETRIS – Trabalho de Engenharia de Software III –

2011/2

Aluno: Franciele Ehrhardt Hoffmann

Professor: Paulo Betencourt

1

Documentação do SIMPLE TETRIS

Versão 1.8


2011/2



2

Histórico

Data Versão Descrição Autor

19/11/2010 1.0 Término da primeira versão da

documentação dos requisitos Franciele Hoffmann

20/11/2010 1.0

Últimas modificações e ajustes

na documentação dos

requisitos

Franciele Hoffmann

21/11/2010 1.0

Entrega da Documentação do

SIMPLE TETRIS contendo os

Requisitos do jogo

Franciele Hoffmann

03/06/2011 1.0 Revisão dos Requisitos do

jogo Franciele Hoffmann

04/06/2011 1.0

Entrega da primeira versão da

Documentação do SIMPLE

TETRIS contendo os

Requisitos e a Análise do jogo

Franciele Hoffmann

24/06/2011 1.1 Exclusão da classe Jogador do

Diagrama de Classes Franciele Hoffmann

24/06/2011 1.1 Inclusão da classe Tetris no

Diagrama de Classes Franciele Hoffmann

24/06/2011 1.1 Modificação dos métodos e

atributos das classes Franciele Hoffmann

25/06/2011 1.1

Inclusão das especializações

da classe Peça do Diagrama

de Classes

Franciele Hoffmann

25/06/2011 1.1 Inclusão de explicações sobre

os diagramas no capítulo 1.3 Franciele Hoffmann

25/06/2011 1.1 Modificações gramaticas e

estruturais no documento Franciele Hoffmann


2011/2



3

26/06/2011 1.1 Modificações nos diagramas

de sequência Franciele Hoffmann

26/06/2011 1.1

Inserção da classe

TetrisThread no diagrama de

classe

Franciele Hoffmann

26/06/2011 1.1 Criação de mais diagramas de

atividade Franciele Hoffmann

26/06/2011 1.2 Término da Revisão do

Documento Franciele Hoffmann

10/07/2011 1.3 Revisão e modificação nos

Diagramas de Sequência Franciele Hoffmann

10/07/2011 1.4 Término da Revisão do

Documento Franciele Hoffmann

12/07/2011 1.5

Modificações na parte de

projeto da documentação.

Incluindo diagramas e maiores

explicações

Franciele Hoffmann

13/07/2011 1.6

Término dos Ajustes para

entrega do documento de

projeto como Exame

Franciele Hoffmann

19/08/2011 1.7

Junção do documento versão

1.6 que continha apenas o

documento de projeto com a

versão 1.4 que continha as

demais partes da

documentação

Franciele Hoffmann

30/08/2011 1.7.1 Primeira versão EAP Franciele Hoffmann

28/11/2011 1.7.2 Montagem da documentação

do Plano de Projeto

04/12/2011 1.8 Finalização e entrega do Plano Franciele Hoffmann


2011/2



4

de Projeto


2011/2



5

Organização do Documento

Índice de Figuras .............................................................................................. 16

1. Introdução .................................................................................................. 20

1.1. Propósito ............................................................................................. 20

1.2. Âmbito ................................................................................................. 20

1.3. Definições, acrônimos e abreviaturas ................................................. 21

1.3.1. Requisito ....................................................................................... 21

1.3.1.1. Prioridade .................................................................................. 22

1.3.1.2. Frequência ................................................................................ 22

1.3.2. Jogador ......................................................................................... 22

1.3.3. Sistema ......................................................................................... 22

1.3.4. Direcionar ..................................................................................... 22

1.3.5. Ranking ........................................................................................ 23

1.3.6. Score ............................................................................................ 23

1.3.7. Limites da tela............................................................................... 23

1.3.7.1. Inferior ....................................................................................... 23

1.3.7.2. Superior ..................................................................................... 23

1.3.7.3. Direito ........................................................................................ 23

1.3.7.4. Esquerdo ................................................................................... 23

1.3.8. Ator primário ................................................................................. 24

1.3.9. Gatilho .......................................................................................... 24

1.3.10. Tarefa primária .......................................................................... 24

1.3.11. Tarefa específica ....................................................................... 24

1.4.1. Diagrama de Classes ....................................................................... 24

1.4.2. Classes ......................................................................................... 24

1.4.2.1. Atributos .................................................................................... 25

1.4.2.2. Métodos ..................................................................................... 25

1.5. Diagrama de Atividade ........................................................................ 25

1.6. Diagrama de Sequência ...................................................................... 25

1.7. Referências ......................................................................................... 25


2011/2



6

1.8. Organização ........................................................................................ 26

2. Descrição Geral do Jogo ........................................................................... 26

2.1. Perspectivas do produto ...................................................................... 26

2.1.1. Interfaces de sistema .................................................................... 26

2.1.2. Interfaces com o utilizador ............................................................ 26

2.1.2.1. Teclado ...................................................................................... 27

2.1.2.2. Mouse ........................................................................................ 27

2.1.2.3. Interface gráfica ......................................................................... 27

2.1.2.4. Interface de áudio ...................................................................... 27

2.1.3. Interfaces de hardware ................................................................. 27

2.1.3.1. Teclado ...................................................................................... 27

2.1.3.2. Mouse ........................................................................................ 28

2.1.3.3. Monitor ...................................................................................... 28

2.1.4. Interfaces de software .................................................................. 28

2.1.5. Interfaces de comunicação ........................................................... 28

2.1.6. Memória ........................................................................................ 28

2.1.7. Operações .................................................................................... 28

2.1.8. Adaptações ao local de instalação ............................................... 29

2.2. Funções do Produto ............................................................................ 29

2.3. Características do utilizador ................................................................ 29

2.4. Restrições ........................................................................................... 29

2.5. Assunções e dependências ................................................................ 30

2.6. Divisão e atribuição das exigências .................................................... 30

3. Exigências Específicas do Jogo ............................................................. 30

3.1. Interfaces externas .............................................................................. 30

3.1.1. Teclado ......................................................................................... 31

3.1.2. Mouse ........................................................................................... 31

3.1.3. Monitor .......................................................................................... 31

3.2. Funções .............................................................................................. 31

3.2.1. Pré-jogo ........................................................................................ 31


2011/2



7

3.2.1.1. Requisitos de usuário ................................................................ 31

Caso de Uso [01]: Escolher opção ............................................................ 32

Caso de Uso [02]: Escolher opção Iniciar jogo .......................................... 33

Caso de Uso [03]: Escolher opção Instruções ........................................... 34

Caso de Uso [04]: Escolher opção Desligar/Ligar som .............................. 36

Caso de Uso [05]: Escolher opção Sair ..................................................... 37

3.2.2. Jogo .............................................................................................. 38


Caso de Uso [06]: Pausar .......................................................................... 39

Caso de Uso [07]: Direcionar peça ............................................................ 40

Caso de Uso [08]: Girar peça .................................................................... 42

Caso de Uso [09]: Descer peça ................................................................. 43

3.2.2.2. Requisitos de sistema ............................................................... 44

Caso de Uso [10]: Sortear peça ................................................................. 44

Caso de Uso [11]: Peça caindo ................................................................. 46

Caso de Uso [12]: Fechar linha ................................................................. 47

Caso de Uso [13]: Aumentar nível ............................................................. 48

Caso de Uso [14]: Contar pontuação ......................................................... 50

Caso de Uso [15]: Chegar ao topo ............................................................ 51

3.2.3. Pós-jogo ....................................................................................... 52


Caso de Uso [16]: Informar nome .............................................................. 53

Caso de Uso [17]: Submeter ao ranking .................................................... 54

3.2.3.2. Requisitos de sistema ............................................................... 55

Caso de Uso [18]: Mostrar ranking ............................................................ 56

3.3. Exigências de desempenho ................................................................ 57

3.3.1. Número máximo de jogadores por partida ....................................... 57

3.3.2. Número de partidas simultâneas ..................................................... 57

3.4. Exigências lógicas de base de dados ................................................. 57

3.5. Restrições de desenho ........................................................................ 57


2011/2



8

3.5.1. Restrições de hardware ................................................................... 58

3.5.1.1. Processador.................................................................................. 58

3.5.1.2. Memória ........................................................................................ 58

3.6. Atributos do sistema de software ........................................................ 58

3.6.1. Fiabilidade ........................................................................................ 58

3.6.2. Disponibilidade ................................................................................. 59

3.6.3. Segurança ........................................................................................ 59

3.6.4. Capacidade de manutenção ............................................................ 59

3.6.5. Portabilidade .................................................................................... 59

3.7. Organização das exigências específicas ............................................ 60

3.7.1. Modo de sistema .............................................................................. 60

3.7.2. Classe do utilizador .......................................................................... 60

3.7.3. Objetos............................................................................................. 60

3.7.4. Características ................................................................................. 60

3.7.5. Estímulos ......................................................................................... 60

3.7.6. Resposta .......................................................................................... 60

3.7.7. Hierarquia funcional ......................................................................... 60

3.8. Comentários adicionais ....................................................................... 60

4. Plataforma para Desenvolvimento .......................................................... 61

5. Informações adicionais ........................................................................... 61

5.1. Apêndice ............................................................................................. 61

5.1.1. Instruções do jogo ............................................................................ 61

5.1.1.1. Teclas ........................................................................................... 61

5.1.1.2. Objetivo ........................................................................................ 62

5.1.2. Peças ............................................................................................... 62

6. Análise dos Requisitos do Jogo.............................................................. 63

6.1. Visão Completa das Classes .............................................................. 63

6.1.1. TetrisThread ..................................................................................... 64

6.1.1.1. run ................................................................................................ 64

6.1.2. Tetris ................................................................................................ 65


2011/2



9

6.1.2.1. escolherOpção() ........................................................................... 65

6.1.2.2. iniciarJogo() .................................................................................. 65

6.1.2.3. ajuda() .......................................................................................... 65

6.1.2.4. liga/desligaSom() .......................................................................... 66

6.1.2.5. sair() ............................................................................................. 66

6.1.2.6. pausar() ........................................................................................ 66

6.1.2.1. descerPeça() ................................................................................ 66

6.1.2.2. sortearPeça() ................................................................................ 66

6.1.2.3. inserirNovaPeça() ......................................................................... 67

6.1.2.4. pedeNomeJogador() ..................................................................... 67

6.1.2.5. retornaTodoRanking() ................................................................... 67

6.1.2.6. atualizaRanking() .......................................................................... 67

6.1.2.7. moveEsquerda() ........................................................................... 67

6.1.2.8. moveDireita() ................................................................................ 68

6.1.2.1. girarPeça() .................................................................................... 68

6.1.2.2. aumentaNível() ............................................................................. 68

6.1.2.3. aumentaPontuação() .................................................................... 68

6.1.3. Tabuleiro .......................................................................................... 68

6.1.3.1. esvaziarTabuleiro() ....................................................................... 69

6.1.3.2. preenchePosição(linha : int, coluna : int, quadrado : Quadrado) .. 69

6.1.3.3. esvaziarPosição(linha : int, coluna : int) ........................................ 69

6.1.3.4. ehPosiçãoVazia(linha : int, coluna : int) ........................................ 69

6.1.3.5. copiarLinha(linhaOrigem : int, linhaDestino : int) .......................... 69

6.1.3.6. verificaLinhaCompleta() ................................................................ 69

6.1.3.7. linhaEstaPreenchida(linha : int) .................................................... 69

6.1.4. Peça ................................................................................................. 70

6.1.4.1. inserirNoTabuleiro() ...................................................................... 70

6.1.4.2. retirarDoTabuleiro() ...................................................................... 70

6.1.4.3. descerPeça() ................................................................................ 70

6.1.4.4. moveParaEsquerda() .................................................................... 70


2011/2



10

6.1.4.5. moveParaDireita() ......................................................................... 71

6.1.4.6. girarPeça() .................................................................................... 71

6.1.4.7. verificaColisãoInferior() ................................................................. 71

6.1.4.8. verificaColisãoSuperior() .............................................................. 71

6.1.4.9. verificaColisãoEsquerda() ............................................................. 72

6.1.4.10. verificaColisãoDireita() .............................................................. 72

6.1.5. Quadrado ......................................................................................... 72

6.1.5.1. atualizaPosição(linha : int, coluna : int) ......................................... 72

6.1.6. Ranking ............................................................................................ 72

6.1.6.1. inserirNoRanking(nome : String, pontuação : int) ......................... 73

6.1.6.2. reordenaRanking() ........................................................................ 73

6.1.6.3. zerarRanking() .............................................................................. 73

6.1.6.4. retornaLinhaArquivo(linha : int) ..................................................... 73

6.2. Visão das Atividades ........................................................................... 73

6.3. Descrição das Funcionalidades .......................................................... 75

6.3.1. Opções Iniciais Disponíveis ............................................................. 75

6.3.2. Funções Durante o Jogo .................................................................. 80

6.3.3. Funções Finais Disponíveis ............................................................. 87

7. Visão Completa Dos Pacotes ................................................................. 89

7.1. Descrição dos Pacotes Java ............................................................... 90

7.1.1. Java.io.............................................................................................. 91

7.1.2. Java.awt ........................................................................................... 91

7.1.3. Javax.swing ..................................................................................... 91

7.1.4. Java.appelt ....................................................................................... 91

7.1.5. Java.lang.* ....................................................................................... 92

7.2. Descrição dos Pacotes do Jogo .......................................................... 92

7.2.1. Pacote modelPeças ......................................................................... 92

7.2.1.1. Construtor PeçaIdentificação (tabuleiro : tabuleiro) ...................... 94

7.2.1.2. Função getCopy(t : Tabuleiro) : Peça ........................................... 95

7.2.2. Pacote model ................................................................................... 95


2011/2



11

7.2.2.1. Classe Quadrado .......................................................................... 95

7.2.2.1.1. Construtor Quadrado(linha : int, coluna : int) .......................... 95

7.2.2.1.2. Função getLin() : int ............................................................... 96

7.2.2.1.3. Função getCol() : int ............................................................... 96

7.2.2.1.4. Função getCor() : Color.......................................................... 96

7.2.2.1.5. Função setCor(cor : Color) : void ........................................... 96

7.2.2.1.6. Função incrementaLinha() : void ............................................ 96

7.2.2.1.7. Função incrementaColuna() : void ......................................... 97

7.2.2.1.8. Função decrementaColuna() : void ........................................ 97

7.2.2.1.9. Função atualizaPosição(linha : int, coluna : int) : void ............ 97

7.2.2.2. Classe Peça.................................................................................. 97

7.2.2.2.1. Construtor Peça(tabuleiro : Tabuleiro) ................................... 97

7.2.2.2.2. Função inserirNoTabuleiro() : void ......................................... 98

7.2.2.2.3. Função retirarDoTabuleiro() : void ......................................... 99

7.2.2.2.4. Função descer() : void ........................................................... 99

7.2.2.2.5. Função moveParaEsquerda() : void ..................................... 100

7.2.2.2.6. Função moveParaDireita() : void .......................................... 101

7.2.2.2.7. Função girarPeça() : void ..................................................... 102

7.2.2.2.8. Função verificaColisãoInferior() : boolean ............................ 104

7.2.2.2.9. Função verificaColisãoSuperior() : boolean ......................... 105

7.2.2.2.10. Função verificaColisãoEsquerda() : boolean ....................... 106

7.2.2.2.11. Função verificaColisãoDireita() : boolean ............................ 107

7.2.2.2.12. Função getTabuleiro() : Tabuleiro........................................ 108

7.2.2.2.13. Função getCopy(): Peça ...................................................... 108

7.2.2.2.14. Função setTabuleiro(tab : Tabuleiro) : void ......................... 108

7.2.2.3. Classe Ranking ........................................................................... 108

7.2.2.3.1. Construtor Ranking() ............................................................ 109

7.2.2.3.2. Função existeRankingNoDisco() : boolean .......................... 109

7.2.2.3.3. Função leRankingNoDisco() : void ....................................... 110

7.2.2.3.4. Função gravaRankingNoDisco() : void ................................. 110


2011/2



12

7.2.2.3.5. Função criaRanking() : void ................................................. 111

7.2.2.3.6. Função inicializaRanking() : void .......................................... 111

7.2.2.3.7. Função atualizaRanking(nome : String, pontos : int) : void .. 111

7.2.2.3.8. Função reordenaRanking(ind : int, nome : String, pont : int) :

void 111

7.2.2.3.9. Função getNomePosição(i : int) : String ............................... 112

7.2.2.3.10. Função getPontosPosição(i : int) : int .................................. 112

7.2.2.3.11. Função setNomePosição(nome : String, i : int) : void .......... 112

7.2.2.3.12. Função setPontosPosição(pontos : int, i : int) : void ............ 112

7.2.2.3.13. Função getQtd() : int ............................................................ 112

7.2.2.3.14. Função zerarRanking() : void .............................................. 112

7.2.2.3.15. Função retornaLinhaArquivo(linha : int) : String .................. 112

7.2.2.4. Classe Tabuleiro ......................................................................... 113

7.2.2.4.1. Construtor Tabuleiro(linhas : int, colunas : int) ..................... 113

7.2.2.4.2. Função esvaziarTabuleiro() : void ........................................ 114

7.2.2.4.3. Função preenchePosição(linha : int, coluna : int, quadrado :

Quadrado) : void ...................................................................................... 114

7.2.2.4.4. Função esvaziarPosição(linha : int, coluna : int) : void ......... 114

7.2.2.4.5. Função ehPosiçãoVazia(linha : int, coluna : int) : boolean ... 115

7.2.2.4.6. Função copiarLinha(linhaOrigem : int, linhaDestino : int) : void

115

7.2.2.4.7. Função verificaLinhaCompleta() : int .................................... 115

7.2.2.4.8. Função linhaEstaPreenchida(linha : int) : boolean ............... 115

7.2.2.4.9. Função getLinhas() : int ....................................................... 116

7.2.2.4.10. Função getColunas() : int .................................................... 116

7.2.2.5. Classe Tetris ............................................................................... 116

7.2.2.5.1. Construtor Tetris(tetrisGui : TetrisGUI) ................................ 116

7.2.2.5.2. escolherOpção() ................................................................... 117

7.2.2.5.3. iniciarJogo() .......................................................................... 117

7.2.2.5.4. ajuda() .................................................................................. 119

7.2.2.5.5. liga/desligaSom() ................................................................. 119


2011/2



13

7.2.2.5.6. sair() ..................................................................................... 120

7.2.2.5.7. pausar() ................................................................................ 121

7.2.2.5.8. descerPeça() ........................................................................ 121

7.2.2.5.9. sortearPeça() ....................................................................... 123

7.2.2.5.10. inserirNovaPeça() ................................................................ 123

7.2.2.5.11. pedeNomeJogador() ............................................................ 123

7.2.2.5.12. retornaTodoRanking() .......................................................... 124

7.2.2.5.13. atualizaRanking() ................................................................. 124

7.2.2.5.14. moveEsquerda() .................................................................. 125

7.2.2.5.15. moveDireita() ....................................................................... 125

7.2.2.5.16. girarPeça() ........................................................................... 126

7.2.2.5.17. aumentaNível() .................................................................... 127

7.2.2.5.18. aumentaPontuação() ........................................................... 127

7.2.2.5.19. Função getPróximaPeça() : Peça ........................................ 127

7.2.2.5.20. Função sleepTime() : int ...................................................... 127

7.2.2.5.21. Função getRanking() : Ranking ........................................... 127

7.2.2.5.22. Função getTabuleiro() : Tabuleiro........................................ 128

7.2.2.5.23. Função ehFimJogo() : boolean ............................................ 128

7.2.2.5.24. Função ehPausado() : boolean ........................................... 128

7.2.2.5.25. Função setPausado(b : boolean) : void ............................... 128

7.2.2.5.26. Função getNivelAtual() : int ................................................. 128

7.2.2.5.27. Função setPontos(pontos : int) : void .................................. 128

7.2.2.5.28. Função setNivelAtual(nívelAtual : int) : void ........................ 128

7.2.2.5.29. Função setFimJogo(fimJogo : boolean) : void ..................... 128

7.2.2.5.30. Função getPontos() : int ...................................................... 128

7.2.3. Pacote control ................................................................................ 128

7.2.3.1. Classe TetrisThread ................................................................... 129

7.2.3.1.1. Construtor TetrisThread(tetris : Tetris, tetrisGui : TetrisGUI) 129

7.2.3.1.2. Função run() ......................................................................... 129

7.2.4. Pacote view .................................................................................... 130


2011/2



14

7.2.4.1. Classe MiniTabuleiroGUI ............................................................ 131

7.2.4.1.1. Construtor MiniTabuleiroGUI(tetris : Tetris, tabuleiro :

Tabuleiro) 131

7.2.4.1.2. Função paint(g : Graphics) ................................................... 132

7.2.4.2. Classe TabuleiroGUI .................................................................. 133

7.2.4.2.1. Construtor TabuleiroGUI(tabuleiro : Tabuleiro) .................... 133

7.2.4.2.2. Função paint(g : Graphics) ................................................... 134

7.2.4.3. Classe TetrisGUI ........................................................................ 134

7.2.4.3.1. Construtor TetrisGUI() .......................................................... 135

7.2.4.3.2. Função pausaJogo() : void ................................................... 135

7.2.4.3.3. Função tecla/BotãoPrecionado() : void ................................ 136

8. Interação entre os Objetos ................................................................... 138

9. Protótipos de Interfaces do Jogo .......................................................... 139

10. Processo de Planejamento do Projeto .............................................. 143

10.1. Objetivos ........................................................................................ 143

10.2. Público alvo .................................................................................... 143

10.3. Premissas ...................................................................................... 143

10.4. Restrições ...................................................................................... 144

10.5. Análise de Viabilidade .................................................................... 144

10.5.1. Viabilidade Tecnológica .............................................................. 144

10.5.2. Viabilidade Econômica ............................................................... 145

10.5.3. Viabilidade Legal ........................................................................ 145

10.6. Fatores Ambientais e Organizacionais .......................................... 145

10.6.1. Ambientais .................................................................................. 146

10.6.2. Organizacionais .......................................................................... 146

10.7. Termos ........................................................................................... 146

10.7.1. Termo de Abertura do Projeto .................................................... 146

10.7.2. Termo de Encerramento do Projeto ............................................ 147

10.8. Declaração do Escopo Preliminar do Projeto ................................. 147

10.9. Estrutura Analítica do Projeto (EAP) .............................................. 148


2011/2



15

10.9.1. Verificação do Escopo ................................................................ 149

10.10. Gerenciamento do Projeto .......................................................... 153

10.10.1. Funções do Software .................................................................. 153

10.10.1.1. Gerência da Partida................................................................. 153

10.10.1.2. Gerência de Periféricos ........................................................... 154

10.10.2. Estimativas ................................................................................. 154

10.10.3. Recursos .................................................................................... 160

10.10.3.1. Recursos Humanos ................................................................. 160

10.10.3.2. Recursos Tecnológicos ........................................................... 161

10.10.4. Cronograma ................................................................................ 161

10.10.5. Custos ........................................................................................ 163

10.10.5.1. Custos Fixos ............................................................................ 163

10.10.5.2. Custos Variáveis ..................................................................... 163

10.10.5.3. Custo Total .............................................................................. 164

10.10.6. Riscos ......................................................................................... 164

10.10.7. Qualidade ................................................................................... 165


2011/2



16

Índice de Figuras

Figura 1: Requisitos de Usuário no Pré-jogo .................................................... 32

Figura 2: Caso de Uso [01]: Escolher opção .................................................... 32

Figura 3: Caso de Uso [02]: Escolher opção Iniciar jogo .................................. 33

Figura 4: Caso de Uso [03]: Escolher opção Instruções .................................. 35

Figura 5: Caso de Uso [04]: Escolher opção Desligar/Ligar som ..................... 36

Figura 6: Caso de Uso [05]: Escolher opção Sair ............................................. 37

Figura 7: Requisitos de Usuário no Jogo ......................................................... 39

Figura 8: Caso de Uso [06]: Pausar ................................................................. 39

Figura 9: Caso de Uso [07]: Direcionar peça ................................................... 40

Figura 10: Caso de Uso [08]: Girar peça .......................................................... 42

Figura 11: Caso de Uso [09]: Descer peça ...................................................... 43

Figura 12: Requisitos do Sistema no Jogo ....................................................... 44

Figura 13: Caso de Uso [10]: Sortear peça ...................................................... 45

Figura 14: Caso de Uso [11]: Peça caindo ....................................................... 46

Figura 15: Caso de Uso [12]: Fechar linha ....................................................... 47

Figura 16: Caso de Uso [13]: Aumentar nível................................................... 49

Figura 17: Caso de Uso [14]: Contar pontuação .............................................. 50

Figura 18: Caso de Uso [15]: Chegar ao topo .................................................. 51

Figura 19: Requisitos de Usuário no Pós-jogo ................................................. 53

Figura 20: Caso de Uso [16]: Informar nome ................................................... 53

Figura 21: Caso de Uso [17]: Submeter ao ranking ......................................... 54

Figura 22: Requisitos de Sistema no Pós-jogo................................................. 56

Figura 23: Caso de Uso [18]: Mostrar ranking .................................................. 56

Figura 24: Diagrama de Classes ...................................................................... 64

Figura 25: Diagrama Geral de Atividades ........................................................ 74

Figura 26: Diagrama de Atividade Opções Iniciais Disponíveis ....................... 76

Figura 27: Diagrama de Sequência Escolher Opção ....................................... 77

Figura 28: Diagrama de Sequência Escolher Opção Ajuda ............................. 77

Figura 29: Diagrama de Sequência Escolher Opção Ligar/Desligar som ......... 78

Figura 30: Diagrama de Sequência Escolher Opção Sair ................................ 78

Figura 31: Diagrama de Sequência Inserir no Tabuleiro .................................. 79

Figura 32: Diagrama de Sequência Escolher Opção Iniciar Jogo .................... 80

Figura 33: Diagrama de Atividade Funções Durante o Jogo ............................ 81

Figura 34: Diagrama de Sequência Inserir no Tabuleiro .................................. 82

Figura 35: Diagrama de Sequência Inserir Nova Peça .................................... 82

Figura 36: Diagrama de Sequência Retirar do Tabuleiro ................................. 83

Figura 37: Diagrama de Sequência Descer Peça Com Fluxo Com Interação

Durante o Jogo ................................................................................................. 84


2011/2



17

Figura 38: Diagrama de Sequência Pausar Durante o Jogo ............................ 85

Figura 39: Diagrama de Sequência Mover Peça Para Direita Durante o Jogo 85

Figura 40: Diagrama de Sequência Mover Peça Para Esquerda Durante o Jogo

......................................................................................................................... 86

Figura 41: Diagrama de Sequência Girar Peça Durante o Jogo ...................... 86

Figura 42: Diagrama de Sequência Descer Peça Com Fluxo Sem Interação

Durante o Jogo ................................................................................................. 87

Figura 43: Diagrama de Atividade Opções Finais Disponíveis ......................... 88

Figura 44: Diagrama de Sequência Submeter-se Ao Ranking ......................... 89

Figura 45: Diagrama de Classe em Nível de Projeto ....................................... 90

Figura 46: Diagrama de Sequencia Construtor de Peça2D ............................. 94

Figura 47: Diagrama de Sequência Construtor de Quadrado .......................... 96

Figura 48: Diagrama de Sequência Construtor de Peça .................................. 98

Figura 49: Diagrama de Sequência Inserir No Tabuleiro de Peça ................... 98

Figura 50: Diagrama de Sequência Retirar do Tabuleiro de Peça ................... 99

Figura 51: Diagrama de Sequência Descer de Peça ..................................... 100

Figura 52: Diagrama de Sequência Mover Para Esquerda de Peça .............. 101

Figura 53: Diagrama de Sequência Mover Para Esquerda de Peça .............. 102

Figura 54: Diagrama de Sequência Girar de Peça ......................................... 104

Figura 55: Diagrama de Sequência Verifica Colisão Inferior de Peça ............ 105

Figura 56: Diagrama de Sequência Verifica Colisão Superior de Peça ......... 106

Figura 57: Diagrama de Sequência Verifica Colisão Esquerda de Peça ........ 107

Figura 58: Diagrama de Sequência Verifica Colisão Direita ........................... 108

Figura 59: Diagrama de Sequência Construtor de Ranking ........................... 109

Figura 60: Diagrama de Sequencia Construtor de Tabuleiro ......................... 114

Figura 61: Diagrama de Sequência Construtor de Tetris ............................... 117

Figura 62: Diagrama de Sequência Inserir No Tabuleiro Através de Tetris ... 118

Figura 63: Diagrama de Sequência Iniciar Jogo de Tetris .............................. 118

Figura 64: Diagrama de Sequência Ajuda de Tetris ....................................... 119

Figura 65: Diagrama de Sequência Ligar/Desligar Som de Tetris .................. 120

Figura 66: Diagrama de Sequência Sair de Tetris .......................................... 121

Figura 67: Diagrama de Sequência Descer Peça de Tetris ........................... 122

Figura 68: Diagrama de Sequência Inserir Nova Peça de Tetris .................... 123

Figura 69: Diagrama de Sequência Pede Nome Jogador de Tetris ............... 124

Figura 70: Diagrama de Sequência Move Esquerda de Tetris ....................... 125

Figura 71: Diagrama de Sequência Move Direita de Tetris ............................ 126

Figura 72: Diagrama de Sequência Girar de Tetris ........................................ 127

Figura 73: Diagrama de Sequência Construtor de TetrisThread .................... 129

Figura 74: Diagrama de Sequência Run de TetrisThread .............................. 130

Figura 75: Diagrama de Sequência Construtor de MiniTabuleiroGUI ............ 132


2011/2



18

Figura 76: Diagrama de Sequência Paint de MiniTabuleiroGUI ..................... 133

Figura 77: Diagrama de Sequência Construtor TetrisThread ......................... 135

Figura 78: Diagrama de Sequência Pausa Jogo de TetrisGUI ....................... 136

Figura 79: Diagrama de Sequência Tecla/BotãoPrecionado .......................... 137

Figura 80: Diagrama de Objetos do Jogo ....................................................... 138

Figura 81: Tela Inicial ..................................................................................... 139

Figura 82: Tela de Ajuda ................................................................................ 140

Figura 83: Interface Durante o Jogo ............................................................... 141

Figura 84: Solicitar Nome Antes de Inserir No Ranking ................................. 142

Figura 85: Mostrando o Ranking .................................................................... 142

Figura 86: Estrutura Analítica do Projeto ........................................................ 149

Figura 87: Estimativa de esforço pessoa/mês ................................................ 157

Figura 88: Relatório do Software Costar ........................................................ 158

Figura 89: Informações Estimadas por Etapa pelo Software Costar .............. 159

Figura 90: Cronograma Principais Atividades ................................................ 162

Figura 91: Cronograma das Subatividades .................................................... 162


2011/2



19

Índice de Tabelas

Tabela 1: Atalhos do Jogo ................................................................................ 61

Tabela 2: Descrição dos Nomes das Peças ..................................................... 62

Tabela 3: Identificação dos Modelos de Peças ................................................ 92

Tabela 4: Verificação do Escopo das Atividades da EAP .............................. 150

Tabela 5: Gerenciamento das Funcionalidades do Software ......................... 153

Tabela 6: Estimativa por LOC ........................................................................ 155

Tabela 7: Resultado Estimativa LOC e FP ..................................................... 155

Tabela 8: Dados Inseridos no Costar ............................................................. 156

Tabela 9: Recursos Humanos Previstos ........................................................ 160

Tabela 10: Demonstrativo de Custo dos Funcionários ................................... 160

Tabela 11: Recursos Tecnológicos Previstos................................................. 161

Tabela 12: Custos Fixos do Projeto .............................................................. 163

Tabela 13: Custos Variáveis do Projeto ........................................................ 163

Tabela 14: Custos Totais do Projeto ............................................................. 164

Tabela 15: Ricos Possíveis do Projeto ........................................................... 165


2011/2



20

1. Introdução

1.1. Propósito

O presente documento tem por objetivo fornecer todas as características

e funcionalidade que o jogo deverá apresentar no momento de sua

implementação e execução, descrevendo os requisitos, a análise, o projeto e o

plano de projeto deste software, para que assim o desenvolvedor de software

tenha o total domínio dos reais requisitos que o sistema deve atingir.

Dos capítulos 1 à 4 são apresentadas, além da introdução, descrição

geral do jogo, bem como as exigências específicas do jogo e informações

adicionais, sendo estas, informações necessárias para o bom funcionamento

do mesmo. No capítulo 5 tem-se a análise dos requisitos do jogo contendo a

descrição das classes e dos métodos que deverão ser implementados. O

capítulo 6 traz as informações referentes ao projeto de software, juntamente

com imagens que têm por objetivo auxiliar o desenvolvedor a “ver” como o jogo

deverá ser. Finalmente no capítulo 6 são apresentadas as informações

referentes ao plano de projeto do jogo.

1.2. Âmbito

O produto a ser desenvolvido trata-se de um jogo conhecido como

Tetris, originado da Rússia no ano de 1984 por engenheiros informáticos.

Acredita-se que este jogo é um sucesso até os dias atuais, graças basicamente

a sua simplicidade. O Tetris entrou para o Guinness, o livro dos recordes, por

se tornar o jogo mais portado e com o maior número de variantes oficiais e não

oficiais.

O jogo é caracterizado por peças de diferentes formatos que “caem” do

topo da tela aleatoriamente, e devem ser encaixadas, uma a uma pelo jogador,

com o objetivo de organizá-las de maneira a formar uma linha horizontal, que

desaparecerá assim que não houver mais espaços em branco na determinada


2011/2



21

linha, o que concede ao jogador pontos que serão acumulados. Conforme o

jogador consegue pontos, o nível de dificuldade do jogo aumenta.

O requisito para passar de nível pode ser diferente de uma plataforma

para a outra. Neste documento, o nível do jogo, como dito anteriormente,

aumentará de acordo com a pontuação do jogador, fazendo com que as peças

comecem a “descer” mais rápido. O final do jogo ocorre quando as linhas

incompletas empilham-se e fazem com que uma das peças “encoste” na parte

superior da tela, ocasionando a derrota do jogador.

Este jogo proporcionará ao usuário um entretenimento simples e

agradável, que diverte ao mesmo tempo em que desenvolve o raciocínio lógico.

O jogador deverá ter opções de “pausa”, “inicio” e “fim” do jogo durante sua

execução. Pretende-se que seja armazenada a pontuação de cada jogador,

juntamente com seu nome, a fim de manter um sistema de ranking, sendo que

este poderá optar por não submeter sua pontuação ao ranking.

Não serão abordadas neste trabalho questões referentes à

acessibilidade de pessoas com deficiência. O jogo só poderá ser portado para

web caso a opção de ranking seja desativada ou o suporte ao mesmo seja

projetado e implementado, observando-se que estas opções não fazem parte

do escopo deste trabalho.

1.3. Definições, acrônimos e abreviaturas

Para o correto compreendimento deste documento, exige-se o

conhecimento de algumas definições que são descritas a seguir.

1.3.1. Requisito

Requisito é o conjunto de características e funcionalidades que o

software poderá e/ou deverá atender. Cada requisito deverá participar de uma

escala de prioridade e de frequência, que diz o quão importante é, e qual a

frequência de uso, respectivamente, da funcionalidade em questão. Para isto


2011/2



22

utilizou-se palavras que representam pesos em relação à prioridade e à

frequência, os quais são descritos abaixo:

1.3.1.1. Prioridade

Essencial: São requisitos essenciais para o funcionamento do jogo e

não devem deixar de ser implementados.

Importante: São requisitos fundamentais para o funcionamento

satisfatório do jogo. Sem estes, o jogo pode não funcionar de forma correta ou

sofrer limitações em relação ao seu funcionamento.

Desejável: São requisitos que não chegam a comprometer as

funcionalidades básicos do jogo, podendo ser implementado em versões

futuras do jogo.

1.3.1.2. Frequência

Alta: São os requisitos com as funcionalidades que são utilizadas mais

repetidamente durante o jogo.

Média: São os requisitos com as funcionalidades utilizadas com

repetição intermediária durante o jogo.

Baixa: São os requisitos com as funcionalidades utilizadas com menor

repetição durante o jogo.

1.3.2. Jogador

O jogador, como assim foi por vezes tratado, é o usuário do software.

1.3.3. Sistema

O sistema representa um conjunto de funcionalidades, presentes no

computador do jogador, e que controlam o jogo.

1.3.4. Direcionar


2011/2



23

Direcionar refere-se a mover a peça para um lugar escolhido, utilizando-

se dos meios que o jogo oferece.

1.3.5. Ranking

Ranking é uma tabela que mostra o nome dos jogadores que mais

obtiveram pontos no jogo, bem como, suas pontuações.

1.3.6. Score

Score é a pontuação do usuário no jogo, seja ela total ou parcial.

1.3.7. Limites da tela

Abaixo são descritos os limites da tela e qual a importância da

compreensão de cada um para o sistema.

1.3.7.1. Inferior

Limite inferior da tela refere-se ao final da tela ou à encontrar(encostar)

em uma peça que esteja posicionada abaixo, este limite deve ser checado

enquanto a peça estiver caindo (Caso de Uso [11]).

1.3.7.2. Superior

Limite superior da tela refere-se ao inicio da tela, a parte de cima ou à

encontrar(encostar) uma peça neste limite. Este limite deve ser checado

quando a peça “parar” (Caso de Uso [15]).

1.3.7.3. Direito

Limite direito da tela refere-se ao lado direito da tela, este limite desse

ser checado quando a peça for movida para a direita ou quando a peça for

girada (Caso de Uso [07] e Caso de Uso [08]).

1.3.7.4. Esquerdo


2011/2



24

Limite esquerdo da tela refere-se ao lado esquerdo da tela, este limite

desse ser checado quando a peça for movida para a esquerda ou quando a

peça for girada (Caso de Uso [07] e Caso de Uso [08]).

1.3.8. Ator primário

O ator primário é a entidade responsável pela ação em questão. Neste

trabalho, representará sempre um ser humano.

1.3.9. Gatilho

Ação que leva a execução de alguma funcionalidade no software.

1.3.10. Tarefa primária

Uma tarefa que possui sub tarefas.

1.3.11. Tarefa específica

Uma tarefa que não possui sub tarefas.

1.4. Diagramas

Os diagramas são os gráficos que descrevem o conteúdo em uma visão.

Neste documento utiliza-se a linguagem UML e o software Astah Community

para gerar tais diagramas.

1.4.1. Diagrama de Classes

O diagrama de classes é o principal diagrama da UML, pois demonstra a

estrutura estática das classes de um sistema, além de ilustrar as interfaces e

relacionamentos entre elas.

1.4.2. Classes

Uma classe é a descrição das propriedades e comportamentos de um

objeto, ou seja, objetos são instâncias de uma classe.


2011/2



25

1.4.2.1. Atributos

Atributos representam propriedades comuns entre todos os objetos da

classe, podem ter valores iguais ou diferentes.

1.4.2.2. Métodos

Métodos representam as ações comuns entre todos os objetos da

classe, geralmente os métodos alteram os valores dos atributos.

1.5. Diagrama de Atividade

Um diagrama de atividade é uma maneira alternativa de se mostrar

interações, com a possibilidade de expressar como as ações são executadas, o

que elas fazem (mudanças nos estados dos objetos), quando elas são

executadas (sequência das ações), e onde elas acontecem (swimlanes).

O diagrama de atividade mostra o fluxo sequencial das atividades, é

normalmente utilizado para demonstrar as atividades executadas por uma

operação específica do sistema. Decisões e condições, como execução

paralela, também podem ser mostradas neste diagrama. O diagrama também

pode conter especificações de mensagens enviadas e recebidas como partes

de ações executadas.

1.6. Diagrama de Sequência

O diagrama de sequência mostra a colaboração dinâmica entre os vários

objetos de um sistema. É mostrado através dele as interações entre os objetos,

ou seja, as coisas que acontecem em um ponto específico da execução do

programa.

1.7. Referências

Norma IEEE Std 830-1998 (disponível em

http://www.urisan.tche.br/~pbetencourt/engsoftI/estrutura.pdf)

http://www.urisan.tche.br/~pbetencourt/engsoftI/estrutura.pdf


2011/2



26

Pressman, Roger – Engenharia de Software, 6ª edição – editora

Mc-Graw Hill

Free Tetris (disponível em http://www.freetetris.org/game.php)

1.8. Organização

Este documento segue o modelo padrão da IEEE, juntamente com seus

conceitos quanto à qualidade, estando organizado em seções e subseções.

As informações contidas nas primeiras seções tratam do software em

caráter geral, além da organização do documento. O documento possui as

informações necessárias quanto ao funcionamento do jogo, documento este,

essencial para o bom compreendimento do funcionamento do jogo, bem como

suas características, recursos e limitações.

2. Descrição Geral do Jogo

2.1. Perspectivas do produto

O jogo SIMPLE TETRIS é um software autônomo, ou seja, não é parte

de um sistema maior. Entretanto, para que seu funcionamento ocorra da

maneira esperada, são necessários alguns subsistemas específicos. A

comunicação correta com estes subsistemas serão descritas abaixo:

2.1.1. Interfaces de sistema

O presente trabalho não contempla interfaces de sistema por não ser

parte de um sistema maior.

2.1.2. Interfaces com o utilizador

O software utiliza-se de alguns periféricos de entrada e saída para que

ocorra a interação do usuário com o jogo, estes periféricos são descritos a

seguir.

http://www.freetetris.org/game.php


2011/2



27

2.1.2.1. Teclado

O teclado será o periférico de entrada mais utilizado no software, pois

através dele o jogador fará todas as movimentações no jogo, além de

conseguir iniciar, sair, pausar, acessar ajuda, submeter pontuação e

ligar/desligar o som através de atalhos, e ainda confirmar a submissão do seu

nome e pontuação para o ranking.

2.1.2.2. Mouse

O mouse não será utilizado frequentemente, pois as funções de iniciar,

sair, pausar, acessar ajuda, submeter pontuação e ligar/desligar o som, que

podem ser feitas através do mouse, possuem atalhos no teclado.

2.1.2.3. Interface gráfica

A interface gráfica que será apresentada ao usuário deverá ser de fácil

uso, além de dispor da tela do jogo e botões que permitam ao usuário iniciar,

sair, pausar, acessar ajuda, submeter pontuação e ligar/desligar o som quando

necessitar.

2.1.2.4. Interface de áudio

O áudio será utilizado apenas como forma de entretenimento, podendo

ser desligado sem que prejudique a jogabilidade.

2.1.3. Interfaces de hardware

Para que seja implementada a interface com o utilizador e assim ocorra

o correto funcionamento do software, são exigidas algumas especificidades de

hardware, citadas a seguir.

2.1.3.1. Teclado

É necessário que o teclado esteja no padrão ABNT2 e, em caso de

teclados multimídia esteja com os drives corretamente instalados.


2011/2



28

2.1.3.2. Mouse

O mouse deve utilizar a configuração padrão do Sistema Operacional

(selecionar com o botão esquerdo e abrir opções com o botão direito – o botão

direito não será utilizado).

2.1.3.3. Monitor

O monitor será utilizado para mostrar a interface gráfica ao usuário, é

aconselhável que utilize uma resolução entre “800x600” e “1280x800”. O

software não implementará qualquer funcionalidade que permita interação por

touchscreen, presente nos monitores mais modernos.

2.1.4. Interfaces de software

O único software necessário para a execução desde jogo é a Máquina

Virtual Java(Java Virtual Machine).

2.1.5. Interfaces de comunicação

Este software não contemplará opções de jogo on-line – mantendo

ranking de todos os jogadores, por exemplo – nem em rede – vários usuários

jogam, e vence quem tiver o maior score, por exemplo.

2.1.6. Memória

O software a ser implementado não terá restrições referentes à

memória, seja ela principal ou secundária, por ser um jogo leve, ou seja, não

necessita de grande poder de processamento. Sendo assim, se o computador

atender às interfaces de hardware e software deste documento, o jogo terá a

performance pretendida.

2.1.7. Operações


2011/2



29

Não são necessárias operações especiais para a inicialização deste

software, levando sempre em consideração as interfaces de hardware e

software.

2.1.8. Adaptações ao local de instalação

Para este software não são necessárias adaptações físicas e nem

virtuais, pois o software é portável, ou seja, pode ser executado em qualquer

Sistema Operacional que possua a Java Virtual Machine, não necessitando de

instalação.

2.2. Funções do Produto

O software SIMPLE TETRIS deverá implementar um jogo simples de

Tetris no qual

O usuário poderá a qualquer momento iniciar, sair, pausar,

acessar ajuda ou ligar/desligar o som;

O software deverá disponibilizar a opção de o usuário submeter-

se ao ranking no final do jogo, e também mostrar esse ranking ao usuário;

2.3. Características do utilizador

O utilizador do software não necessita de conhecimentos avançados em

computação para jogar, basta que tenha familiaridade com o mouse e

principalmente com o teclado.

O software não provê nenhum tipo de acessibilidade para usuários com

deficiência visual ou outro tipo de deficiência que não permita que o usuário

utilize o teclado e/ou o mouse.

O software espera que o utilizador seja alfabetizado, uma vez que todas

as suas instruções são em modo textual.

2.4. Restrições


2011/2



30

O jogo SIMPLE TETRIS será de utilização local single player – um

jogador por máquina –, sem suporte à web, não necessitando, assim, de banco

de dados para armazenar a pontuação e nome dos jogadores, esta

armazenagem será feita em arquivos simples, sendo que haverá um arquivo

por máquina à rodar o jogo.

O projeto do jogo foi realizado com base na linguagem de programação

Java, necessitando assim, que a máquina que irá rodar o jogo tenha uma Java

Virtual Machine, independendo, desta forma, do seu Sistema Operacional.

Como dispositivos de input/output necessários, tem-se o monitor, o teclado no

padrão ABNT2 e se possível o mouse, lembrando que o mouse não é

necessário para a interação com o jogo, podendo as ações do mouse serem

executadas através de atalhos do teclado.

Pode-se jogar também utilizando teclado virtual, porém o jogador talvez

possa ser prejudicado pelo tempo que leva para clicar em uma tecla.

2.5. Assunções e dependências

O jogo só pode ser jogado no modo singleplayer, mas pode ser rodado

em máquinas diferentes ao mesmo tempo, a fim de simular uma competição,

por exemplo, deste que as máquinas contemplem as interfaces de hardware e

software já citadas.

2.6. Divisão e atribuição das exigências

Poderia ser desenvolvido o modo multiplayer do jogo, utilizando tanto o

mesmo computador – teclas diferentes – quanto a rede ou a web, a fim de

estimular a confraternização de usuários, e para tanto seria necessário

implementar também um ranking on-line.

3. Exigências Específicas do Jogo

3.1. Interfaces externas


2011/2



31

Nesta seção serão expostas as principais exigências do software quanto

às interfaces externas citadas anteriormente.

3.1.1. Teclado

O teclado tem como entrada uma combinação de teclas que é

repassada na forma de um sinal de comando para o software. Quando o

usuário pressiona uma tecla, o teclado identifica a tecla e repassa para o

software qual a tecla pressionada, disparando um movimento no jogo ou uma

função.

3.1.2. Mouse

O mouse é utilizado como outra forma de interação do usuário com o

software. Quando o usuário clica sobre um botão, o mouse recebe a

identificação do botão selecionado e o repassa para o software, que disparará

alguma funcionalidade.

3.1.3. Monitor

O monitor recebe do software os dados da interface gráfica e os mostra

em forma de janelas para o usuário.

3.2. Funções

As funções que o software deverá possuir estão listadas abaixo,

divididas quanto à etapa (pré-jogo, jogo e pós-jogo) e quanto ao ator

responsável por ativar essa funcionalidade.

3.2.1. Pré-jogo

Neste tópico serão descritos todos os Casos de Uso referentes ao pré-

jogo, ou seja, tudo que o usuário poderá fazer no software antes de começar a

jogar.

3.2.1.1. Requisitos de usuário


2011/2



32

Funcionalidades que o usuário poderá usufruir no pré-jogo. São dividas

em 4 sub funções.

Figura 1: Requisitos de Usuário no Pré-jogo

Caso de Uso [01]: Escolher opção

Figura 2: Caso de Uso [01]: Escolher opção

Descrição: O jogador terá uma série de opções, onde poderá escolher

apenas uma delas por vez.

Escopo: Jogo

Nível: Tarefa primária

Pré-condições: O jogador deve estar com o software aberto.


2011/2



33

Condição em caso de sucesso: O usuário escolhe a opção desejada.

Condição em caso de falha: O software foi encerrado.

Ator primário: Jogador

Gatilho: Início do programa.

Cenário principal de sucesso:

1. O jogador seleciona a opção desejada;

2. A opção desejada é executada.

Objetivo de desempenho: Sem tempo pré-definido, o software se

mantém naquela condição até que o usuário escolha uma das opções do

menu.

Assuntos abertos: O jogo não prosseguirá, nem encerrará até que o

jogador escolha uma das opções do menu.

Prioridade: Essencial.

Frequência: Alta.

Calendário: release 1.0

Caso de Uso [02]: Escolher opção Iniciar jogo

Figura 3: Caso de Uso [02]: Escolher opção Iniciar jogo


2011/2



34

Descrição: Se escolhida a opção Iniciar jogo, o software iniciará uma

nova partida.

Escopo: Jogo

Nível: Tarefa primária

Pré-condições:

1. O Caso de Uso [01] deve ter sido executado, e;

2. A opção Iniciar jogo deve ter sido escolhida.

Condição em caso de sucesso: Uma partida foi iniciada.



Gatilho: Jogador escolhe Iniciar jogo no Caso de Uso [01].


1. O jogador seleciona a opção Iniciar jogo;

2. Uma nova partida é iniciada.

Objetivo de desempenho: Rápido.

Assuntos abertos: Uma nova partida é iniciada.


Frequência: Alta.


Caso de Uso [03]: Escolher opção Instruções


2011/2



35

Figura 4: Caso de Uso [03]: Escolher opção Instruções

Descrição: Se escolhida a opção Instruções, o software deverá mostrar

as instruções do jogo, descritas na subseção 4.2.1 deste documento. Esta

opção deverá estar disponível a qualquer instante da execução do software.

Escopo: Jogo.

Nível: Tarefa específica.

Pré-condições:


2. A opção Instruções deve ter sido escolhida.

Condição em caso de sucesso: As instruções foram mostradas.



Gatilho: Jogador escolhe Instruções no Caso de Uso [01].


1. O jogador seleciona a opção Instruções;

2. As instruções são mostradas na tela para o jogador.



2011/2



36

Assuntos abertos: As instruções são mostradas ao jogador.

Prioridade: Importante.

Frequência: Baixa.


Caso de Uso [04]: Escolher opção Desligar/Ligar som

Figura 5: Caso de Uso [04]: Escolher opção Desligar/Ligar som

Descrição: Se escolhida à opção Desligar/Ligar som, o som deverá ser

desligado se estiver ligado ou ligado se estiver desligado. Esta opção deverá

estar disponível a qualquer instante durante a execução do software.

Escopo: Jogo

Nível: Tarefa específica.

Pré-condições:


2. A opção Desligar/Ligar som deve ter sido escolhida.

Condição em caso de sucesso: O som foi desligado/ligado.




2011/2



37

Gatilho: Jogador escolhe Desligar/Ligar no Caso de Uso [01].


1. O jogador seleciona a opção Desligar/Ligar som;

2. O som é desligado/ligado.


Assuntos abertos: O som é desligado/ligado.

Prioridade: Desejável.

Frequência: Baixa.


Caso de Uso [05]: Escolher opção Sair

Figura 6: Caso de Uso [05]: Escolher opção Sair

Descrição: Se escolhida à opção Sair, o software deverá ser

corretamente encerrado.

Escopo: Jogo

Nível: Tarefa específica

Pré-condições:


2011/2



38


2. A opção Sair deve ter sido escolhida.

Condição em caso de sucesso: O software foi encerrado.

Condição em caso de falha: O software não foi encerrado.


Gatilho: Jogador escolhe Sair no Caso de Uso [01].


1. O jogador seleciona a opção Sair;

2. O software é encerrado.


Assuntos abertos: O software será encerrado e o jogo será perdido.


Frequência: Média.


3.2.2. Jogo

Neste tópico serão descritos todos os Casos de Uso referentes ao jogo,

ou seja, tudo que o usuário poderá fazer no decorrer da execução do software.


Funcionalidades que o usuário poderá usufruir durante o jogo – além

daquelas descritas no pré-jogo e que podem ser acessadas durante a

execução do jogo – e que são divididos em 4 sub-funções.


2011/2



39

Figura 7: Requisitos de Usuário no Jogo

Caso de Uso [06]: Pausar

Figura 8: Caso de Uso [06]: Pausar

Descrição: O usuário clica na opção Pausar ou utiliza um atalho de

teclado e então o jogo é pausado(parado) na situação em que estiver, até que

o usuário efetue esta operação novamente.

Escopo: Jogo


Pré-condições:



2011/2



40

2. A opção Pausar deve ter sido solicitada (através de clique do

mouse ou atalho de teclado).

Condição em caso de sucesso: O software foi pausado.



Gatilho: Clicar em Pausar ou atalho de teclado para Pausar.


1. O jogador seleciona a opção Pausar;

2. O jogo é pausado.


Assuntos abertos: O software é pausado.




Caso de Uso [07]: Direcionar peça

Figura 9: Caso de Uso [07]: Direcionar peça


2011/2



41

Descrição: Após iniciar o jogo, o usuário pressionará as teclas

direcionais que deverão direcionar a peça que estiver “caindo”. A peça não

será direcionada para o ‘lado’ que o usuário pressionar se ela já estiver no

limite da tela deste lado.

Escopo: Jogo

Nível: Tarefa Específica

Pré-condições:


2. As teclas direcionais devem ter sido pressionadas.

Condição em caso de sucesso: A peça que está “caindo” é

movimentada.

Condição em caso de falha: A peça já está no limite da tela e não é

movida para a direção escolhida.


Gatilho: Teclas direcionais pressionadas.


1. O jogador pressiona uma tecla direcional;

2. A peça é movimentada.


Assuntos abertos: A peça será direcionada.


Frequência: Alta.



2011/2



42

Caso de Uso [08]: Girar peça

Figura 10: Caso de Uso [08]: Girar peça

Descrição: A peça deve ser girada sempre que o usuário pressionar a

tecla direcional para cima, a menos que não haja espaço para que a peça seja

girada.

Escopo: Jogo


Pré-condições:


2. A tecla direcional para cima deve ter sido pressionada.

Condição em caso de sucesso: A peça é girada.

Condição em caso de falha: Não há espaço para a peça ser girada.


Gatilho: Jogador pressiona tecla direcional para cima.


1. O jogador pressiona a tecla direcional para cima;

2. A peça é girada.


2011/2



43


Assuntos abertos: A peça é girada.


Frequência: Alta.


Caso de Uso [09]: Descer peça

Figura 11: Caso de Uso [09]: Descer peça

Descrição: A peça deve descer em maior velocidade quando a tecla

direcional para baixo for pressionada, a menos que a peça já esteja no limite

inferior da tela.

Escopo: Jogo


Pré-condições:


2. A tecla direcional para baixo deve ter sido pressionada.

Condição em caso de sucesso: A peça desce em maior velocidade.

Condição em caso de falha: A peça já está no limite inferior da tela.


2011/2



44


Gatilho: Jogador pressiona tecla direcional para baixo.


1. O jogador pressiona a tecla direcional para baixo;

2. A peça desce em maior velocidade.


Assuntos abertos: A peça desce em maior velocidade.


Frequência: Alta.


3.2.2.2. Requisitos de sistema

Funcionalidades que o sistema executará durante o jogo.

Figura 12: Requisitos do Sistema no Jogo

Caso de Uso [10]: Sortear peça


2011/2



45

Figura 13: Caso de Uso [10]: Sortear peça

Descrição: Uma peça é sorteada assim que o jogo é executado, esta

peça começa a cair e outra peça é sorteada e exibida ao usuário como a

próxima peça. Quando a peça que está caindo chegar no limite inferior, a peça

que atava sendo exibida ao usuário como próxima começa a cair e uma nova

peça é sorteada e fica como a próxima peça.

Escopo: Jogo


Pré-condições:

O Caso de Uso [02] deve ter sido executado.

Condição em caso de sucesso: Uma peça deve ser sorteada.

Condição em caso de falha: O software é encerrado.

Ator primário: Sistema

Gatilho: Uma peça chega no limite inferior.


1. Uma peça é sorteada;

2. A peça sorteada é exibida para o usuário.



2011/2



46

Assuntos abertos: Uma peça é sorteada.


Frequência: Alta.


Caso de Uso [11]: Peça caindo

Figura 14: Caso de Uso [11]: Peça caindo

Descrição: A peça que foi sorteada começa a cair até que chegue no

limite inferior da tela.

Escopo: Jogo


Pré-condições:


Condição em caso de sucesso: A peça vai caindo.

Condição em caso de falha: A peça chega no limite inferior da tela..


Gatilho: Uma peça chega no limite inferior.


2011/2



47


A peça vai caindo;


Assuntos abertos: A peça começa a cair.


Frequência: Alta.


Caso de Uso [12]: Fechar linha

Figura 15: Caso de Uso [12]: Fechar linha

Descrição: Durante o jogo, cada vez que o usuário completar uma linha,

ou seja, não exista nesta linha nenhum espaço vazio, a mesma deve

“desaparecer”, dando pontos ao usuário e fazendo com que as teclas ou

“pedaços” de peças que estiverem na linha acima, ocupem o lugar desta que

desapareceu.

Escopo: Jogo


Pré-condições:


2011/2



48

1. O Caso de Uso [02] deve ter sido executado.

2. Uma linha deve ter sido fechada.

Condição em caso de sucesso: A linha fechada desaparece.



Gatilho: Uma linha é fechada.


1. Uma linha é fechada;

2. A linha fechada desaparece.

3. As peças ou “pedaços” de peças que estiverem acima desta linha

descem.


Assuntos abertos: Uma linha é fechada.


Frequência: Alta.


Caso de Uso [13]: Aumentar nível


2011/2



49

Figura 16: Caso de Uso [13]: Aumentar nível

Descrição: Enquanto o usuário joga, ganha pontos, e assim que atingir

uma quantidade ‘x’ de pontos o nível de dificuldade deverá aumentar e então a

velocidade do jogo deve aumentar.

Escopo: Jogo


Pré-condições:


2. Uma pontuação ‘x’ deve ser alcançada.

Condição em caso de sucesso: O nível é aumentado.



Gatilho: Uma pontuação ‘x’ é atingida.


1. O nível de dificuldade é aumentado;

2. O aumento de nível é informado ao usuário.



2011/2



50

Assuntos abertos: Aumenta o nível de dificuldade.




Caso de Uso [14]: Contar pontuação

Figura 17: Caso de Uso [14]: Contar pontuação

Descrição: Sempre que uma peça chegar ao limite inferior na tela,

deverá ser verificada a posição dessa peça (altura) e de acordo com a posição

é acrescida uma quantidade de pontos para o jogador.

Escopo: Jogo


Pré-condições:


2. Uma peça deve atingir o limite inferior da tela.

Condição em caso de sucesso: A pontuação do jogador é atualizada.




2011/2



51

Gatilho: Uma peça chega ao limite inferior da tela.


1. Uma peça chega no limite inferior da tela;

2. O jogador ganha pontos.


Assuntos abertos: A pontuação é atualizada.


Frequência: Alta.


Caso de Uso [15]: Chegar ao topo

Figura 18: Caso de Uso [15]: Chegar ao topo

Descrição: Sempre que uma peça chegar no limite superior da tela,

deverá ser informado ao jogador que ele perdeu. Em seguida, a possibilidade

de inserir nome e pontuação deve ser mostrada.

Escopo: Jogo


Pré-condições:


2011/2



52


2. Uma peça deve atingir o limite superior da tela.

Condição em caso de sucesso: Uma peça encostou no limite superior

da tela.



Gatilho: Uma peça chega no limite superior da tela.


1. Uma peça chega no limite superior da tela;

2. O jogo acaba, o jogador perde;

3. Entra nas funções de pós-jogo.


Assuntos abertos: Alguma peça chega ao topo, o que ocasiona o fim

do jogo.


Frequência: Alta.


3.2.3. Pós-jogo

Neste tópico serão descritos todos os Casos de Uso referentes ao pó-

jogo, ou seja, tudo que o usuário poderá fazer no software após o término do

jogo.


Funcionalidades que o usuário poderá usufruir no pós-jogo.


2011/2



53

Figura 19: Requisitos de Usuário no Pós-jogo

Caso de Uso [16]: Informar nome

Figura 20: Caso de Uso [16]: Informar nome

Descrição: Quando um jogo chega ao fim, deverá ser apresentada ao

usuário a possibilidade de incluir seu nome e pontuação ao ranking.

Escopo: Jogo


Pré-condições:


Condição em caso de sucesso: O usuário informa o nome.


2011/2



54

Condição em caso de falha: O usuário opta por não incluir-se no

ranking.


Gatilho: Uma peça chega no limite superior da tela, ou seja, o jogo

termina.


O usuário informa o nome.


Assuntos abertos: O nome é informado.




Caso de Uso [17]: Submeter ao ranking

Figura 21: Caso de Uso [17]: Submeter ao ranking

Descrição: Quando o jogo acabar, e o usuário inserir seu nome, e a

opção de submeter ao ranking for selecionada, esta opção deve ser executada,

inserindo o nome e a pontuação do jogador atual no ranking.


2011/2



55

Escopo: Jogo


Pré-condições:


2. Deve ter sido selecionada a opção de submeter ao ranking.

Condição em caso de sucesso: O nome e pontuação do jogador são

submetidos ao ranking.



Gatilho: A opção de submeter ao ranking foi escolhida.


O nome e a pontuação obtidos devem ser inseridos no ranking.


Assuntos abertos: O nome e pontuação são incluídos no ranking.




3.2.3.2. Requisitos de sistema

Funcionalidades que o sistema executará no pós-jogo.


2011/2



56

Figura 22: Requisitos de Sistema no Pós-jogo

Caso de Uso [18]: Mostrar ranking

Figura 23: Caso de Uso [18]: Mostrar ranking

Descrição: Quando o jogo acabar, e o usuário inserir seu nome, e a

opção de submeter ao ranking for selecionada, esta opção deve ser executada,

mostrando o ranking atualizado.

Escopo: Jogo


Pré-condições:


2. Deve ter sido selecionada a opção de submeter ao ranking.

Condição em caso de sucesso: Os nomes e pontuações contidas no

ranking são mostradas na tela.


2011/2



57



Gatilho: A opção de submeter ao ranking foi escolhida.


O ranking deve ser mostrado.


Assuntos abertos: Os nomes e as pontuações que estiverem contidas

no ranking devem ser mostradas na tela.




3.3. Exigências de desempenho

Nesta seção serão descritas as não suportabilidades do software.

3.3.1. Número máximo de jogadores por partida

O software será projetado para funcionar com apenas um jogador.

3.3.2. Número de partidas simultâneas

O software dará suporte para jogar apenas uma partida por vez.

3.4. Exigências lógicas de base de dados

O software utilizará um sistema de ranking local, não será utilizada,

portanto, nenhuma base de dados. O ranking será gravado em arquivo e

servirá apenas para o computador local onde estiver rodando.

3.5. Restrições de desenho


2011/2



58

Serão especificadas nesta seção as restrições de desenho.

3.5.1. Restrições de hardware

Neste tópico são descritas restrições referentes ao hardware.

3.5.1.1. Processador

O usuário deverá ser capaz de rodar o software com um processador

acima de 700MHz ou superior.

3.5.1.2. Memória

O software deverá rodar corretamente em um computador que possui no

mínimo 256MB de memória RAM.

3.6. Atributos do sistema de software

Nesta seção serão especificados os atributos de software requeridos e

que servem de exigência, de modo a que seu cumprimento possa ser

objetivamente verificado.

3.6.1. Fiabilidade

Para que o software apresente as fiabilidades para o qual será

projetado, algumas exigências devem ser respeitadas:

A máquina na qual o software será rodado deve possuir um

Sistema Operacional corretamente instalado (estável) além de ter uma

Máquina Virtual Java instalada(versão 6.0 em diante);

A máquina na qual o software será rodado não deve estar

infectada por vírus ou outras pragas digitais que atrapalham o correto

funcionamento do Sistema Operacional;

Todos os periféricos de entrada citados como interface externa

devem estar em correto funcionamento.


2011/2



59

3.6.2. Disponibilidade

Não há requisitos de disponibilidade neste software por ele não utilizar

rede local.

3.6.3. Segurança

Para que o software mantenha uma boa segurança, as seguintes

medidas devem ser tomadas:

O Sistema Operacional deve além de estar corretamente

instalado, estar atualizado;

O antivírus deve estar com sua base de dados atualizada

recentemente;

É altamente recomendado que o Sistema Operacional esteja com

seu firewall ativado;

O código fonte do software não deve ser alterado.

3.6.4. Capacidade de manutenção

Pelo fato de o software estar usando métodos da engenharia como

requisitos e análise do software, orientação a objetos, modelagem, o software

poderá ser facilmente alterado para manutenção. Além de o software ser

dividido em pacotes de acordo com a funcionalidade, como:

Pacote de controles do jogo;

Pacote da interface com o usuário.

3.6.5. Portabilidade

O software será projetado de modo a ficar totalmente portável, para isso,

deverá ser implementado utilizando a linguagem de programação Java.


2011/2



60

3.7. Organização das exigências específicas

As organizações das exigências específicas serão descritas nesta

seção.

3.7.1. Modo de sistema

O software apresentará somente um modo de utilização, que é descrito

através dos requisitos citados anteriormente.

3.7.2. Classe do utilizador

O software será projetado somente para um usuário “genérico”, não

havendo outros modos para tipos de usuários específicos.

3.7.3. Objetos

Os objetos identificam as entidades que se correspondem com o

sistema, ou seja, no jogo em questão, podemos citar as peças, dentre outros.

3.7.4. Características

Este software não é afetado por características externas.

3.7.5. Estímulos

Neste software, não são contemplados estímulos por possuir suas

tradicionais regras.

3.7.6. Resposta

As funcionalidades deste software não geram respostas.

3.7.7. Hierarquia funcional

Não há hierarquias neste software.

3.8. Comentários adicionais


2011/2



61

Os requisitos do software foram levantados seguindo a técnica de Casos

de Uso, onde, além de se obter os autores e as funcionalidades já se

estabelecem os principais estímulos recebidos pelo sistema e suas principais

respostas.

4. Plataforma para Desenvolvimento

A plataforma escolhida para o desenvolvimento do jogo SIMPLE TETRIS

é a linguagem de programação Java, por ser uma linguagem muito utilizada

nos dias de hoje e por ter uma grande portabilidade, além de conter ótimos

recursos para o desenvolvimento da interface gráfica.

O projeto do jogo foi baseado inteiramente na orientação a objetos e

para tanto, as representações utilizam-se das classes e interfaces

disponibilizadas na API Java.

5. Informações adicionais

5.1. Apêndice

Nesta seção são mostradas informações importantes para o

desenvolvimento e jogabilidade do jogo.

5.1.1. Instruções do jogo

Neste tópico são descritas todas instruções do jogo.

5.1.1.1. Teclas

Durante toda execução do software, os menus podem ser acessados

através do mouse – botões da interface –, ou através de atalhos do teclado que

são descritos na tabela a seguir, além das teclas necessárias para jogar:

Tabela 1: Atalhos do Jogo

Funcionalidade Atalho


2011/2



62

Iniciar Enter

Sair Esc

Instruções F1

Desligar/ligar som S

Pausar P

Descer peça Tecla direcional para baixo

Girar peça Tecla direcional para cima

Mover para direita Tecla direcional para direita

Mover para esquerda Tecla direcional para esquerda

Submeter ao ranking Enter

5.1.1.2. Objetivo

O objetivo do jogo é encaixar “tetraminós”, que são peças de diversos

formados que descem do topo de uma tela. O jogador deve rodas as diversas

peças a fim de completar uma linha. Quando uma linha é completada, a

mesma desaparece e dá pontos extras ao jogador. O jogo termina quando as

linhas incompletas se empilham até o topo da tela do jogo.

5.1.2. Peças

No jogo Tetris, há 7peças básicas, sendo umas o inverso horizontal de

outras. As peças podem ser giradas para que se consiga encaixá-las

corretamente. Cada peça é constituída de 4 quadros posicionados de maneira

a tornar cada peça diferente. O valor de cada peça, é calculado levando-se em

consideração a altura em que a peça parou, sendo que quando mais longe do

topo, mais vale a peça, e quando mais perto do topo, menos vale a peça. A cor

das peças só serve para diferenciá-las, não influenciando na pontuação. O

desenho das peças é mostrado abaixo:

Tabela 2: Descrição dos Nomes das Peças


2011/2



63

Peça Identificação*

Peça 2D – 2 quadrados acima do lado

direito e 2 abaixo do lado esquerdo

Peça 2E – 2 quadrados acima do lado

esquerdo e 2 abaixo do lado direito

Peça 3C - 3 quadrados acima e uma

abaixo no centro

Peça 3D - 3 quadrados acima e uma

abaixo na direita

Peça 3E – 3 quadrados acima e uma

abaixo na esquerda

Peça Quadrada

Peça Reta

* A identificação é utilizada para nomear cada especialização de peça no

diagrama de classes da seção 7.2.1 .

6. Análise dos Requisitos do Jogo

A análise do software foi baseada no paradigma de análise orientada a

objetos, sendo assim realizada a identificação das classes adequadas, com

seus métodos e atributos necessários para uma correta implementação e futuro

bom funcionamento do jogo.

Os diagramas de classes que são o paradigma fundamental da

orientação a objetos e os outros contidos no documento foram feitos com

auxílio do programa Astah Community 6.4 (Model Version: 34) e da linguagem

UML (Unified Modeling Language ou Linguagem de Modelagem Unificada).

6.1. Visão Completa das Classes


2011/2



64

Figura 24: Diagrama de Classes

O diagrama da Figura 24 representa as classes do jogo, bem como seus

atributos e métodos que realizam as interações entre as classes e assim entre

o jogo e o usuário. Estas classes, juntamente com seus atributos e métodos

são descritas abaixo.

6.1.1. TetrisThread

A classe TetrisThread possui ligação apenas com a classe Tetris,

possuindo assim apenas um atributo tetris desta classe.

6.1.1.1. run

O método run() tem por objetivo executar um fluxo de operação(Thread)

independente do fluxo original sendo assim independente da interação com o

usuário. Neste método deverá haver um loop que só “para” quando o jogo

finalizar, for pausado ou a opção ajuda for requerida. Sua função é a de


2011/2



65

chamar o método peçaDescendo() através do objeto da classe Tetris, que faz

com que a peça desça linha por linha no tabuleiro.

6.1.2. Tetris

A classe Tetris pode ser considerada como a classe mais importante,

pois é responsável por fazer o controle geral do jogo, tendo ligação com quase

todas as demais classes. É através desta classe que o usuário poderá interagir

com o jogo. Nesta classe tem-se atributos como tabuleiro que guarda as peças

do jogo, a peçaAtual e a próximaPeça que irão participar do jogo, além de

atributos como pontuação, para guardar quantos pontos o usuário já

conquistou, e seu nívelAtual. Encontram-se também nesta classe atributos que

servem para controlar o jogo como fim, pausado e som. O atributo ranking é

utilizado para referenciar-se ao ranking onde são mantidas as pontuações dos

jogadores.

6.1.2.1. escolherOpção()

Este método verifica qual a opção escolhida pelo usuário e então

chama-a. Esta função é executada internamente, ou seja, sem interferência do

usuário.

6.1.2.2. iniciarJogo()

Este método inicia o jogo, chamando as funções que disparam a thread.

Também neste método são dados valores a quase todos os atributos desta

classe, além de sortear a próxima peça e inseri-la no tabuleiro. Esta função só

pode ser acessada antes do jogo e necessita de intervenção do usuário.

6.1.2.3. ajuda()

Este método mostra as instruções do jogo, regras e teclas necessárias

para realizar a interação com o mesmo. Esta função pode ser acessada a

qualquer momento antes ou durante o jogo e necessita de intervenção do

usuário.


2011/2



66

6.1.2.4. liga/desligaSom()

Este método altera o valor do atributo som de true para false e vice-

versa, demonstrando que o som está ligado ou desligado. Esta função pode ser

acessada a qualquer momento antes ou durante o jogo e necessita de

intervenção do usuário.

6.1.2.5. sair()

Este método encerra o jogo por completo de maneira segura. Esta

função pode ser acessada a qualquer momento antes, durante ou após o jogo

e necessita de intervenção do usuário.

6.1.2.6. pausar()

Este método “para” a execução do jogo quando for requerida e só

continua após ser executada novamente. Esta função pode ser acessada a

qualquer momento durante o jogo e necessita de intervenção do usuário.

6.1.2.1. descerPeça()

Este método verifica colisões inferiores para que se possa descer a

peçaAtual. Após esta verificação, quando ocorre colisão, ele chama o método

descerPeça() da classe Peça. Quando ocorre colisão o método verifica se

alguma linha foi completada através do método verificaLinhaCompleta() da

classe Tabuleiro, caso haja, aumenta-se a pontuação e o nível do jogador,

caso contrário apenas aumenta-se a pontuação. Este método ainda chama o

método que verifica colisão superior da peçaAtual, caso haja, ocasiona o fim do

jogo. Esta função pode ser acessada a qualquer momento durante o jogo e

pode ser executada tanto pelo usuário para acelerar o movimento de descida

da peça quanto pelo próprio jogo, a fim de mostrar a peça descendo linha a

linha.

6.1.2.2. sortearPeça()


2011/2



67

Este método sorteia a próxima peça, e a retorna. Esta função é

requerida toda vez que o jogo for iniciado e toda vez que uma nova peça for

inserida no tabuleiro. Esta função é executada internamente, ou seja, sem

interferência do usuário.

6.1.2.3. inserirNovaPeça()

Este método sorteia qual será a próximaPeça e posteriormente insere

esta peça como peçaAtual do tabuleiro. Esta função é requerida ao iniciar novo

jogo e toda vez que uma peça “parar” no tabuleiro. Esta função é executada

internamente, ou seja, sem interferência do usuário.

6.1.2.4. pedeNomeJogador()

Este método solicita o nome do jogador para incluí-lo no ranking através

da função atualizaRanking(). Esta função é requerida apenas quando o jogo for

encerrado e somente se o jogador aceitar submeter-se ao ranking.

6.1.2.5. retornaTodoRanking()

Este método gera uma String com todo o ranking e a retorna. Para

conseguir o nome e a pontuação de cada jogador no Ranking é chamada a

função retornaLinhaArquivo() da classe Ranking. Esta função é executada


6.1.2.6. atualizaRanking()

Este método envia a classe Ranking o nome e a pontuação do jogador

através do método inserirNoRanking da classe Ranking. Esta função é

executada internamente, ou seja, sem interferência do usuário.

6.1.2.7. moveEsquerda()

Este método verifica colisão do lado esquerdo e se esta não ocorreu

então chama a função moverParaEsquerda() da classe Peça através do


2011/2



68

atributo peçaAtual. Esta função pode ser acessada a qualquer momento

durante o jogo através de intervenção do usuário.

6.1.2.8. moveDireita()

Este método verifica colisão do lado direito e se esta não ocorreu então

chama a função moverParaDireita() da classe Peça através do atributo

peçaAtual. Esta função pode ser acessada a qualquer momento durante o jogo

através de intervenção do usuário.

6.1.2.1. girarPeça()

Este método chama o método girarPeça() da classe Peça através do

atributo peçaAtual, o que faz com que a peça seja girada, quando possível, ou

seja, quando não houver possibilidade de colisão. Esta função pode ser

acessada a qualquer momento durante o jogo através de intervenção do

usuário.

6.1.2.2. aumentaNível()

Este método é utilizado quando uma linha é completada para aumentar

a dificuldade do jogo. Esta função é executada internamente, ou seja, sem


6.1.2.3. aumentaPontuação()

Este método é utilizado a cada peça que é encaixada, contando pontos

para o jogador. Quando uma linha é completada o jogador ganha mais pontos.

Esta função é executada internamente, ou seja, sem interferência do usuário.

6.1.3. Tabuleiro

A classe Tabuleiro é formada por uma matriz de Quadrados – a classe

Quadrado será descrita posteriormente – com linha e coluna especificadas pelo

programador.


2011/2



69

6.1.3.1. esvaziarTabuleiro()

Este método limpa todas as posições do tabuleiro, geralmente a fim de

iniciar um novo jogo. Esta função é executada internamente, ou seja, sem


6.1.3.2. preenchePosição(linha : int, coluna : int, quadrado :

Quadrado)

Este método coloca um quadrado, passado como parâmetro, em uma

posição do tabuleiro, também passada por parâmetro. Esta função é executada


6.1.3.3. esvaziarPosição(linha : int, coluna : int)

Este método limpa uma posição do tabuleiro passada por parâmetro.


6.1.3.4. ehPosiçãoVazia(linha : int, coluna : int)

Este método verifica se a posição passada por padrâmetro está vazia.


6.1.3.5. copiarLinha(linhaOrigem : int, linhaDestino : int)

Este método copia toda linhaDestino no lugar da linhaOrigem passadas

por parâmetro. Esta função é executada internamente, ou seja, sem


6.1.3.6. verificaLinhaCompleta()

Este método verifica quantas linhas do tabuleiro estão preenchidas. Esta

função é executada internamente, ou seja, sem interferência do usuário.

6.1.3.7. linhaEstaPreenchida(linha : int)


2011/2



70

Este método verifica se a linha passada por parâmetro está preenchida.


6.1.4. Peça

A classe Peça representa as peças do jogo, que diferenciam-se pelo

formato e cor. Cada modelo de peça é formado por quatro quadrados e

pertence a um tabuleiro. Esta classe possui especializações que correspondem

aos modelos de peças. Para melhor entendimento dos nomes dos modelos

verifique a seção 4.1.2 deste documento.

6.1.4.1. inserirNoTabuleiro()

Este método insere uma peça no tabuleiro e para isso chama o método

preencherPosição da classe Tabuleiro. Esta função é executada internamente,

ou seja, sem interferência do usuário.

6.1.4.2. retirarDoTabuleiro()

Este método retira uma peça do tabuleiro e para isso chama o método

esvaziarPosição da classe Tabuleiro. Esta função é executada internamente,

ou seja, sem interferência do usuário.

6.1.4.3. descerPeça()

Este método desce em uma linha uma peça do tabuleiro, para isso ele

retira a peça do tabuleiro, atualiza a posição de cada quadrado da peça através

da classe Quadrado e depois insere novamente a peça no tabuleiro. Esta

função é executada internamente, ou seja, sem interferência do usuário.

6.1.4.4. moveParaEsquerda()

Este método decrementa em uma coluna uma peça do tabuleiro, para

isso ele retira a peça do tabuleiro, atualiza a posição de cada quadrado da

peça através da classe Quadrado e depois insere novamente a peça no


2011/2



71

tabuleiro. Esta função é executada internamente, ou seja, sem interferência do

usuário.

6.1.4.5. moveParaDireita()

Este método incrementa em uma linha uma peça do tabuleiro, para isso

ele retira a peça do tabuleiro, atualiza a posição de cada quadrado da peça

através da classe Quadrado e depois insere novamente a peça no tabuleiro.


6.1.4.6. girarPeça()

Este método gira a peça, e para isso, retira-a do tabuleiro, verifica de

pode girá-la, caso sim, atualiza a posição de cada quadrado da peça através

da classe Quadrado e então insere novamente a peça no tabuleiro, caso não,

apenas insere novamente a peça no tabuleiro. Esta função é executada


6.1.4.7. verificaColisãoInferior()

Este método verifica se a peça está “encostando” no limite inferior da

tela, para isso, retira a peça do tabuleiro, verifica se já está na linha mais

abaixo do tabuleiro ou se a posição abaixo está vazia, caso sim, insere

novamente a peça no tabuleiro, caso não, apenas insere novamente a peça no


usuário.

6.1.4.8. verificaColisãoSuperior()

Este método verifica se a peça está “encostando” no limite superior da

tela, para isso, sempre é chamada quando se verifica a colisão inferior, pois no

final desta função é inserida uma nova peça, se esta peça imediatamente tiver

colisão inferior, é porque chegou ao limite superior da tela, por isso essa função

apenas chama a função de verificação de colisão inferior. Esta função é



2011/2



72

6.1.4.9. verificaColisãoEsquerda()

Este método verifica se a peça está “encostando” no limite direito da

tela, para isso, retira a peça do tabuleiro, verifica se não está na coluna 0 (zero)

do tabuleiro ou se a posição ao lado esquerdo está vazia, caso sim, insere



usuário.

6.1.4.10. verificaColisãoDireita()

Este método verifica se a peça está “encostando” no limite direito da

tela, para isso, retira a peça do tabuleiro, verifica se não está na coluna mais a

direita do tabuleiro ou se a posição ao lado direito está vazia, caso sim, insere



usuário.

6.1.5. Quadrado

A classe Quadrado é responsável por guardar as características de cada

quadrado que formará cada peça, ou que formará o tabuleiro. Nesta classe

tem-se informações como a cor do quadrado e sua localização, através da

linha e da coluna.

6.1.5.1. atualizaPosição(linha : int, coluna : int)

Este método atualiza a localização/posição de um quadrado através dos

parâmetros passados. Esta função é executada internamente, ou seja, sem


6.1.6. Ranking


2011/2



73

A classe Ranking é responsável por guardar a pontuação de cada

jogador, bem como seu nome. Esta classe é manipulada exclusivamente pela

classe Tetris.

6.1.6.1. inserirNoRanking(nome : String, pontuação : int)

Este método insere uma nova pontuação no ranking, juntamente com o

nome do jogador. Esta função é executada somente se o usuário aceitar

inserir-se no ranking.

6.1.6.2. reordenaRanking()

Este método reordena, em ordem decrescente de pontuação, os

jogadores. Geralmente é chamado pela função inserirNoRanking().Esta função

é executada internamente, ou seja, sem interferência do usuário.

6.1.6.3. zerarRanking()

Este método limpa o ranking. Esta função é executada internamente, ou

seja, sem interferência do usuário.

6.1.6.4. retornaLinhaArquivo(linha : int)

Este método retorna uma linha do arquivo que teve seu número passado

por parâmetro. Esta função é executada internamente, ou seja, sem


6.2. Visão das Atividades


2011/2



74

Figura 25: Diagrama Geral de Atividades


2011/2



75

O diagrama da Figura 25 pretende mostrar todas as interações,

demonstrando inclusive os dois fluxos (Threads) de execução do jogo. Os

comentários servem para melhor descrever o que acontece, principalmente,

nos nodos decisivos. Este diagrama serve para mostrar o comportamento do

jogo, informando inclusive quando é necessária a interação do jogador com o

jogo.

No início do diagrama percebe-se as opções pelas quais o usuário pode

optar, sendo elas: iniciar o jogo, ajuda, liga/desliga som ou sair. Lembrando que

as opções de ajuda, sair e liga/desliga som podem ser acessadas durante o

jogo, ou seja, após a opção iniciar jogo ter sido escolhida, juntamente com a

opção de pausar.

Pode-se verificar neste diagrama que há dois fluxos de execução após

iniciar-se o jogo, um fluxo é executado sem nenhuma interação, o que faz com

que o jogo possa chegar ao fim sem que o usuário interaja com o jogo, um

segundo fluxo é executado no jogo, porém, este fluxo necessita da interação do

usuário, seja por meio de atalhos do teclado ou através dos botões da

interface. É através das interações que o usuário aumenta o tempo de duração

do jogo.

Percebe-se ainda no diagrama que após o término do jogo o usuário

pode optar por submeter sua pontuação ao ranking ou não, e jogar novamente

ou não.

6.3. Descrição das Funcionalidades

Nesta seção, são apresentadas as funcionalidades do jogo e como elas

ocorrem, seguindo, como base, os requisitos do jogo.

6.3.1. Opções Iniciais Disponíveis

Esta funcionalidade engloba os Casos de Uso [01], [02], [03], [04] e [05],

descritos nos requisitos deste documento. Estas opções necessitam de


2011/2



76

interação do jogador para que aconteçam, ou seja, o jogo é iniciado e fica

aguardando a interação do usuário, mostrando estas opções disponíveis.

Figura 26: Diagrama de Atividade Opções Iniciais Disponíveis

A Figura 26 demonstra através de um diagrama de atividades as opções

iniciais disponíveis para o usuário. As opções Ajuda e Liga/Desliga Som

retornam o fluxo para a escolha, enquanto que a opção Sair encerra o sistema

e a opção Iniciar Jogo realiza todas as funções necessárias para que o jogo

seja iniciado – estas opções serão descritas posteriormente.

As figuras abaixo demonstram através de diagramas de sequência estas

funcionalidades.


2011/2



77

Figura 27: Diagrama de Sequência Escolher Opção

Figura 28: Diagrama de Sequência Escolher Opção Ajuda


2011/2



78

Figura 29: Diagrama de Sequência Escolher Opção Ligar/Desligar som

Figura 30: Diagrama de Sequência Escolher Opção Sair

A funcionalidade Sair (Figura 30) mostra que após escolher esta opção,

o jogo é encerrado e os objetos das classes por sua vez são eliminados.


2011/2



79

Figura 31: Diagrama de Sequência Inserir no Tabuleiro


2011/2



80

Figura 32: Diagrama de Sequência Escolher Opção Iniciar Jogo

A Figura 32 mostra todo o processo necessário para iniciar o jogo,

contendo referência à função Inserir No Tabuleiro da Figura 31.

6.3.2. Funções Durante o Jogo

Esta funcionalidade engloba os Casos de Uso [06], [07], [08], [09], [10],

[11], [12], [13], [14] e [15], sendo os quatro primeiros as funções que o usuário

pode realizar durante o Jogo e os demais as funções que o sistema realiza

independente da interação do usuário. São apresentadas ainda as funções

Sair, Ligar/Desligar som e Ajuda por estas funcionalidades poderem ser

acessadas também nesta etapa. Os diagramas que descrevem cada uma das

funcionalidades recém citadas encontra-se na seção 5.3.1.


2011/2



81

Figura 33: Diagrama de Atividade Funções Durante o Jogo

A Figura 33 representa as atividades do sistema que ocorrem após o

usuário selecionar a opção Iniciar Jogo (Figura 31). As setas em vermelho

representam os dois fluxos do sistema. A seta vermelha da esquerda mostra o

fluxo que não necessita de interações do usuário, enquanto que na seta

vermelha da direita é necessária a interação do usuário para realizar as

funções de mover, girar e descer peça, dentre outras, caso não ocorra

interação do usuário o jogo prosseguirá de forma normal até que uma interação

aconteça ou até que seja verificada uma colisão superior ocasionando, assim,

o fim do jogo.


2011/2



82

Figura 34: Diagrama de Sequência Inserir no Tabuleiro

Figura 35: Diagrama de Sequência Inserir Nova Peça


2011/2



83

Figura 36: Diagrama de Sequência Retirar do Tabuleiro


2011/2



84

Figura 37: Diagrama de Sequência Descer Peça Com Fluxo Com Interação Durante o

Jogo


2011/2



85

Figura 38: Diagrama de Sequência Pausar Durante o Jogo

A opção Pausar pode ser acessada a qualquer momento durante o jogo,

assim como as opções Sair, Ajuda e Ligar/desligar som.

Figura 39: Diagrama de Sequência Mover Peça Para Direita Durante o Jogo


2011/2



86

Figura 40: Diagrama de Sequência Mover Peça Para Esquerda Durante o Jogo

Figura 41: Diagrama de Sequência Girar Peça Durante o Jogo


2011/2



87

Após mover para direita, girar ou mover para a esquerda a peça, não

ocorre a verificação de colisão inferior e as demais verificações e funções –

que dão a impressão de ocorrer nos diagramas de atividade das Figuras 25 e

33 – pois estas verificações e funcionalidades ocorrem na função Descer Peça,

independente de ela ser executada com ou sem interação do usuário e não

necessitando-se assim de tamanha redundância de funcionalidades.

Figura 42: Diagrama de Sequência Descer Peça Com Fluxo Sem Interação Durante o

Jogo

As Figuras 37 e 42 representam a funcionalidade Descer Peça que pode

ser considerada a mais importante do jogo, pois é nesta função que verificam-

se colisões inferiores e superiores, além da verificação de linha completa, que

rende ao jogador mais pontos. Além das funções citadas, a funcionalidade

Descer Peça ainda aumenta o nível do jogo, aumenta a pontuação do jogador

e sorteia a próxima a peça. Pode-se verificar nas Figuras que independendo de

haver ou não a interação do usuário, as mesmas funcionalidade são

executadas.

6.3.3. Funções Finais Disponíveis

Esta funcionalidade engloba os Casos de Uso [16], [17] e [18], os quais

todos necessitam de interação do usuário para realizarem-se. Estas


2011/2



88

funcionalidades ocorrem somente após o término do jogo. Permite-se ao

usuário que opte por inserir-se no ranking ou não, e por jogar novamente ou

não.

Figura 43: Diagrama de Atividade Opções Finais Disponíveis


2011/2



89

Figura 44: Diagrama de Sequência Submeter-se Ao Ranking

A Figura 44 apresenta um diagrama de sequência que demonstra como

ocorre a funcionalidade de submeter-se ao ranking. Primeiramente solicita-se o

nome do jogador, para então atualizar-se o ranking, inserindo-o no ranking

juntamente com sua pontuação, a lista do ranking é reordenada e após isto

pode-se então mostra-la o ranking ao usuário, recuperando-se linha a linha da

lista do ranking.

No próximo capítulo são demonstradas todas as funções que deverão

ser implementadas no jogo detalhadamente.

7. Visão Completa Dos Pacotes


2011/2



90

Figura 45: Diagrama de Classe em Nível de Projeto

A Figura 45 apresenta um diagrama de classes do sistema e suas

ligações com as classes de interface. Neste diagrama as classes já encontram-

se divididas em pacotes, principalmente, para melhor organização. As classes

de cada pacote serão descritas nas seções abaixo.

7.1. Descrição dos Pacotes Java


2011/2



91

Nesta seção serão descritos os pacotes Java utilizados e quais as

classes utilizadas de cada pacote, bem como para quê são utilizadas estas

classes no jogo.

7.1.1. Java.io

Neste pacote encontram-se classes utilizadas para, no escopo do jogo,

manipulação de arquivo, além da classe IOException que captura e trata

exceções. A classe Tetris utiliza-se de objetos IOException para tratar

exceções que podem ser geradas pelo construtor da classe Ranking ao se

instanciar um objeto da mesma. Na classe Ranking, além de tratar exceções,

as classes do pacote Java.io servem para manipulação de arquivos.

7.1.2. Java.awt

Deste pacote utilizam-se as classes Color e Graphics, necessárias para

pintar o tabuleiro do jogo. Na classe Quadrado utiliza-se a classe Color para

definir a cor de um quadrado. Já nas classes MiniTabuleiroGUI e Tabuleiro GUI

os métodos das classes Color e Graphics são utilizados para definir a cor e

pintar o tabuleiro.

7.1.3. Javax.swing

Neste pacote encontram-se todas as classes de interface necessárias

para criar janelas, botões, ícones, dentre outros. As classes deste pacote são

utilizadas nas classes MiniTabuleiroGUI, TabuleiroGUI e TetrisGUI a fim de

montar a interface do jogo.

7.1.4. Java.appelt

Deste pacote utiliza-se a classe AudioClip, necessária para a utilização

do áudio no jogo. Esta classe disponibiliza métodos que param e iniciam os

sons. Esta classe é utilizada pela classe TetrisGUI que controla os sons do

jogo.


2011/2



92

7.1.5. Java.lang.*

Neste pacote encontram-se classes que representam tipos de variáveis,

como os utilizados boolean e String, além de disponibilizar classes que tratam

de threads, possibilitando iniciá-las, etc. A classe TetrisThread utiliza-se da

classe Thread deste pacote para poder criar e manter um novo fluxo de

execução. As classes boolean e String são utilizadas por várias classes do

pacote model.

7.2. Descrição dos Pacotes do Jogo

Nesta seção serão descritas as classes de cada pacote, bem como os

métodos destas classes em detalhes. As classes do jogo estão distribuídas em

pacotes no padrão MVC (Model-View-Controller).

Este padrão é bastante utilizado por minimizar a análise da aplicação,

retirando a dificuldade de pensar na lógica de aplicação. Assim sendo, o

objetivo deste padrão é proporcionar facilidade de integração dos requisitos de

software com as entidades externas do mesmo.

7.2.1. Pacote modelPeças

Este pacote contém classes que são especializações da classe Peça – a

classe Peça será explicada posteriormente no pacote model, Seção 5.1.2 do

presente documento – e que correspondem aos modelos de peças utilizados

no jogo. O nome das peças, bem como seu formato, podem ser compreendidos

na Tabela 1 abaixo.

Tabela 3: Identificação dos Modelos de Peças

Peça Identificação Linha, Coluna

Peça 2D – 2 quadrados acima do lado

direito e 2 abaixo do lado esquerdo

0, 4

0, 5

1, 3


2011/2



93

1, 4

Peça 2E – 2 quadrados acima do lado

esquerdo e 2 abaixo do lado direito

0, 3

0, 4

1, 4

1, 5

Peça 3C - 3 quadrados acima e uma

abaixo no centro

0, 3

0, 4

0, 5

1, 4

Peça 3D - 3 quadrados acima e uma

abaixo na direita

0, 3

0, 4

0, 5

1, 5

Peça 3E – 3 quadrados acima e uma

abaixo na esquerda

0, 3

0, 4

0, 5

1, 3

Peça Quadrada

0, 4

0, 5

1, 4

1, 5

Peça Reta

0, 3

0, 4

0, 5

0, 6

Devido às classes desde pacotes serem iguais, optou-se por não

descrevê-las separadamente. As classes deste pacote não possuem atributos,

por isso nenhuma delas é descrita, sendo descritos apenas seus métodos.


2011/2



94

7.2.1.1. Construtor PeçaIdentificação (tabuleiro : tabuleiro)

No construtor de cada uma das classes de model.Peças é chamado o

construtor da classe superior, passando-se o tabuleiro como parâmetro e

posteriormente instanciando-se os quatro quadrados que formam a peça,

passando como parâmetros os valores da terceira coluna (Linha, Coluna) da

Tabela 1 referente ao modelo da Peça desejada. Lembrando que ao

implementar o construtor de cada classe, a palavra Identificação no nome do

construtor deverá ser trocada pelo correspondente modelo descrito na segunda

coluna (Identificação) da Tabela 1, vide exemplo da imagem abaixo.

Figura 46: Diagrama de Sequencia Construtor de Peça2D


2011/2



95

A Figura 46 exemplifica a construção de uma peça no modelo Peça2D.

Ao implementar os construtores dos outros modelos de peça, os nome devem

ser alterados e os parâmetros passados ao criar os Quadrados também,

seguindo, como já dito, a Tabela 1.

7.2.1.2. Função getCopy(t : Tabuleiro) : Peça

Este método sobrescreve o método getCopy da Classe Peça. Sua

função é a de criar uma nova peça e retorná-la. O parâmetro t deve ser

passado como argumento ao se criar a nova peça.

7.2.2. Pacote model

Este pacote contém todas classes que formam os modelos do jogo e

que são de extrema importância para o bom funcionamento do mesmo. Estas

classes são responsáveis por especificar o comportamento dos objetos que

controlam boa parte do jogo.

7.2.2.1. Classe Quadrado

A classe Quadrado representa cada quadrado que forma cada peça, e

que forma o tabuleiro. Para isto, esta classe possui atributos que guardam o

valor da linha e da coluna de cada quadrado a fim de saber a localização de

cada quadrado no tabuleiro, além de um atributo que guarda a cor de cada

quadrado.

7.2.2.1.1. Construtor Quadrado(linha : int, coluna : int)

Ao se instanciar um quadrado devem-se passar a linha e a coluna do

mesmo como parâmetros. Os valores dos parâmetros são passados para as

respectivas variáveis do objeto.


2011/2



96

Figura 47: Diagrama de Sequência Construtor de Quadrado

A Figura 47 represente o diagrama de sequência da construção de um

objeto da classe Quadrado.

7.2.2.1.2. Função getLin() : int

Este método retorna o valor atual do atributo linha do quadrado. Não

recebe parâmetros.

7.2.2.1.3. Função getCol() : int

Este método retorna o valor atual do atributo coluna do quadrado. Não

recebe parâmetros.

7.2.2.1.4. Função getCor() : Color

Este método retorna o valor do atributo cor que representa a cor do

quadrado. Não recebe parâmetros.

7.2.2.1.5. Função setCor(cor : Color) : void

Este método atribui ao atributo cor o valor (cor) passado como

parâmetro. Não possui retorno.

7.2.2.1.6. Função incrementaLinha() : void


2011/2



97

Este método acrescenta 1 (um) ao valor atual do atributo linha do

quadrado. Não recebe parâmetros e não possui retorno.

7.2.2.1.7. Função incrementaColuna() : void

Este método acrescenta 1 (um) ao valor atual do atributo coluna do

quadrado. Não recebe parâmetros e não possui retorno.

7.2.2.1.8. Função decrementaColuna() : void

Este método diminui 1 (um) do valor atual do atributo linha do quadrado.

Não recebe parâmetros e não possui retorno.

7.2.2.1.9. Função atualizaPosição(linha : int, coluna : int) :

void

Este método atribui aos atributos linha e coluna os valores passados,

respectivamente como parâmetros. Não possui retorno.

7.2.2.2. Classe Peça

Esta classe é responsável por manter cada peça que participará do jogo,

para isto é formada por um vetor de Quadrados de tamanho 4 (quatro), devido

ao fato de que cada peça tem 4 Quadrados (partes). Possui ainda um atributo

tabuleiro da classe Tabuleiro – esta classe será explicada posteriormente – que

é onde será inserida ou de onde poderá ser retirada a peça durante o jogo.

Esta classe possui métodos que realizam as movimentações necessárias nas

peças durante o jogo e verificam se as peças podem ou não ser

movimentadas.

7.2.2.2.1. Construtor Peça(tabuleiro : Tabuleiro)

Ao se instanciar uma peça deve-se passar o tabuleiro ao qual a peça

pertence como parâmetro. O valor do parâmetro é passado para o respectivo

atributo do objeto.


2011/2



98

Figura 48: Diagrama de Sequência Construtor de Peça

Na Figura 48 é representado o diagrama que mostra a criação de um

objeto da classe Peça.

7.2.2.2.2. Função inserirNoTabuleiro() : void

Este método insere a peça no tabuleiro do jogo e para isto, insere cada

quadrado da peça na sua respectiva posição do tabuleiro. Para isto, é chamada

a função preenchePosição(linha : int, coluna : int, quadradro : Quadrado) da

classe Tabuleiro através de atributo desta classe.

Figura 49: Diagrama de Sequência Inserir No Tabuleiro de Peça

A Figura 49 representa a execução da função inserirNoTabuleiro de

peça.


2011/2



99

7.2.2.2.3. Função retirarDoTabuleiro() : void

Este método retira a peça do tabuleiro do jogo e para isto, retira cada um

dos 4 (quatro) quadrados do tabuleiro. Para isto é chamada a função

esvaziaPosição(linha : int, coluna : int) da classe Tabuleiro através de atributo

desta classe.

Figura 50: Diagrama de Sequência Retirar do Tabuleiro de Peça

A Figura 50 representa a execução da função retirarDoTabuleiro de

peça.

7.2.2.2.4. Função descer() : void

Este método tem por objetivo descer em uma linha a peça que está no

tabuleiro. Para isto, retira a peça do tabuleiro, decrementa a linha de cada

quadrado da peça e posteriormente insere a peça no tabuleiro novamente.


2011/2



100

Figura 51: Diagrama de Sequência Descer de Peça

Na Imagem 51 é representada a execução da função Descer da classe

Peça.

7.2.2.2.5. Função moveParaEsquerda() : void

Este método tem por objetivo mover a peça que está no tabuleiro um

quadrado à esquerda. Para isto, retira a peça do tabuleiro, decrementa a

coluna de cada um dos quadrados e então insere a peça novamente no

tabuleiro.


2011/2



101

Figura 52: Diagrama de Sequência Mover Para Esquerda de Peça

A Figura 52 demonstra a execução da função moveParaEsquerda() da

classe Peça.

7.2.2.2.6. Função moveParaDireita() : void

Este método tem por objetivo mover a peça que está no tabuleiro um

quadrado à direita. Para isto, retira a peça do tabuleiro, incrementa a coluna de

cada um dos quadrados e então insere a peça novamente no tabuleiro.


2011/2



102

Figura 53: Diagrama de Sequência Mover Para Esquerda de Peça

A Figura 53 demonstra a execução da função moveParaDireita() da

classe Peça.

7.2.2.2.7. Função girarPeça() : void

Este método tem por objetivo girar a peça que está no tabuleiro. Para

isto, retira-a do tabuleiro, e então pega os valores das linhas e colunas dos

quadrados que compõem as peças e coloca em variáveis auxiliares, sendo que

em um vetor auxiliar coloca os valores das linhas, e em outro os valores das

colunas. Posteriormente, cria-se uma variável que controlará se o giro foi

realizado com sucesso, que deverá ser uma variável boolean com valor inicial

em verdadeiro (true) e então um loop de 1 a 4 realiza as seguintes funções:


2011/2



103

- Soma os valores de linha e de coluna do primeiro quadrado (estes

valores estão salvos nos vetores auxiliares descritos anteriormente) e diminui-

se do valor da coluna do quadrado correspondente a variável que controla o

loop – inicialmente 1, depois 2, depois 3 – e salva este resultado em uma

variável auxiliar.

- Diminui-se o valor da linha do quadrado correspondente a variável que

controla o loop – inicialmente 1, depois 2, depois 3 – da soma dos valores de

linha e coluna do primeiro quadrado (estes valores estão salvos nos vetores

auxiliares descritos anteriormente) e salva este resultado em uma variável

auxiliar.

- Se o valor da soma for maior ou igual à 0 (zero) E se o valor da soma

for menor ou igual a 19 (dezenove) E se o valor da diminuição for maior ou

igual a 0 (zero) E se o valor da diminuição for menor ou igual a 9 (nove) E se a

verificação de ehPosiçãoVazia(soma, diminuição) da classe tabuleiro resultar

em verdadeiro (true) então deve-se atualizar a posição do quadrado que

corresponde a variável que controla o loop para a posição (soma, diminuição).

Caso contrário, a variável boolean criada recebe o valor false.

Se ao final do loop o valor da variável boolean for false, então atualiza-

se a posição de cada um dos quadrados que formam a peça, utilizando-se os

valores salvos nos vetores no início da função. Caso contrário nada é feito.

Após estas instruções serem executadas, a peça é inserida novamente

no tabuleiro.


2011/2



104

Figura 54: Diagrama de Sequência Girar de Peça

A Figura 54 demonstra a execução da função girar() da classe Peça.

7.2.2.2.8. Função verificaColisãoInferior() : boolean

Este método verifica se ocorreu colisão inferior da peça. Para isto, retira

a peça do tabuleiro, então entra num loop que verifica se alguma linha dos

quadrados que formam a peça é igual a 19 ou se a posição uma linha abaixo

de cada quadrado está vazia no tabuleiro, se sim, insere a peça no tabuleiro e

retorna true. Se o loop chega ao fim, insere a peça no tabuleiro e retorna false,

mostrando que não ocorreu colisão.


2011/2



105

Figura 55: Diagrama de Sequência Verifica Colisão Inferior de Peça

A Figura 55 demonstra a execução da função verificaColisãoInferior() da

classe Peça.

7.2.2.2.9. Função verificaColisãoSuperior() : boolean

Este método verifica se ocorreu colisão superior na peça. Para isto, após

inserir uma nova peça verifica imediatamente se ocorreu colisão inferior.


2011/2



106

Figura 56: Diagrama de Sequência Verifica Colisão Superior de Peça

A Figura 56 apresenta a execução da função verificaColisãoSuperior()

da classe Peça.

7.2.2.2.10. Função verificaColisãoEsquerda() : boolean

Este método verifica se está ocorrendo colisão no limite esquerdo do

tabuleiro. Para isto, retira a peça do tabuleiro, então entra num loop que verifica

se alguma coluna dos quadrados que formam a peça é igual a 0 ou se a

posição uma coluna acima de cada quadrado está vazia no tabuleiro, se sim,

insere a peça no tabuleiro e retorna true. Se o loop chega ao fim, insere a peça

no tabuleiro e retorna false, mostrando que não ocorreu colisão.


2011/2



107

Figura 57: Diagrama de Sequência Verifica Colisão Esquerda de Peça

A Figura 57 demonstra a execução da função verificaColisãoEsquerda

da classe Peça.

7.2.2.2.11. Função verificaColisãoDireita() : boolean

Este método verifica se está ocorrendo colisão no limite esquerdo do

tabuleiro. Para isto, retira a peça do tabuleiro, então entra num loop que verifica

se alguma coluna dos quadrados que formam a peça é igual a 9 ou se a

posição uma coluna abaixo de cada quadrado está vazia no tabuleiro, se sim,

insere a peça no tabuleiro e retorna true. Se o loop chega ao fim, insere a peça

no tabuleiro e retorna false, mostrando que não ocorreu colisão.


2011/2



108

Figura 58: Diagrama de Sequência Verifica Colisão Direita

7.2.2.2.12. Função getTabuleiro() : Tabuleiro

Este método retorna o valor do atributo tabuleiro de peça. Não possui

parâmetros.

7.2.2.2.13. Função getCopy(): Peça

Este método retorna uma nova Peça, sem modelo, mas que pertence ao

mesmo tabuleiro das demais. Não possui parâmetros.

7.2.2.2.14. Função setTabuleiro(tab : Tabuleiro) : void

Este método coloca o valor passado por parâmetro no respectivo

atributo da classe. Não possui retorno.

7.2.2.3. Classe Ranking

A classe Ranking é responsável por manter o ranking do jogo em um

arquivo. Esta classe possui atributos necessário para manipular arquivos, como

os atributos input, output e file. O atributo quantidade serve para verificar


2011/2



109

quantos jogadores estão no ranking, para este fim também serve os vetores de

nomes e pontos. Os métodos desta classe são responsáveis por manipular o

arquivo, além de atualizar e reordenar o ranking.

7.2.2.3.1. Construtor Ranking()

O construtor da classe Ranking cria uma instância de ranking. Nesta

função verifica-se se existe ranking no disco, se sim, lê este ranking, se não,

inicializa um novo ranking e grava o ranking no disco.

Figura 59: Diagrama de Sequência Construtor de Ranking

A Figura 59 demonstra a criação de um objeto ranking e as verificações

que são realizadas nesta função.

7.2.2.3.2. Função existeRankingNoDisco() : boolean


2011/2



110

Este método cria um novo arquivo chamado “ranking.txt” na pasta onde

estão localizadas as classes do jogo e atribui-o ao atributo file da classe.

Retorna-se um valor boolean que é o retorno da função exists() acessada pelo

atributo file.

7.2.2.3.3. Função leRankingNoDisco() : void

Este método é responsável por abrir e ler o arquivo no disco. Para isto,

cria-se um objeto do tipo StringBuffer, faz-se com que o atributo input da classe

receba o retorno da criação de um objeto FileReader(file). Após este processo,

um loop que lê uma linha do arquivo através da chamada file.read() coloca,

enquanto o valor lido não for -1, todo o conteúdo lido do arquivo no objeto

StringBuffer através da função append(), este loop termina quando o valor lido

for -1. Posteriomente fecha-se o arquivo através do objeto de FileReader com

a função close(). É criado um objeto da classe StringTokenizer que recebe

como parâmetro o retorno da função toString() do objeto da classe StringBuffer

e um valor vazio ( “ “ ), um loop é iniciado para atualizar os valores nas devidas

posições do ranking, para isto, verifica-se se o retorno da função

hasMoreTokens() chamada pelo objeto da classe StringTokenizer é verdadeiro

(true), e enquanto for, chamam-se as funções setNomePosição() passando-se

como parâmetros o retorno da chamada nextToken().toString do objeto da

classe StringTokenizer e um valor i que inicialmente valerá 0 (zero), depois 1,

depois 2 e assim sucessivamente, ainda é chamada a função

setPontosPosição() passando-se como parâmetros o retorno da chamada

Integer.parseInt(objetoStrinTokenizer.nextToken()) e o valor i, após estas

chamadas o valor i é incrementado e o loop continua.

7.2.2.3.4. Função gravaRankingNoDisco() : void

Este método tem como objetivo gravas o arquivo de ranking no disco.

Para isto, atribui ao atributo output da classe o retorno da criação de um objeto

da classe FileWriter(file) passando como parâmetro o atributo da classe que

representa o arquivo. Escreve-se em um loop, que vai de 0 ao valor do atributo


2011/2



111

quantidade da classe, os valores contidos nos vetores nomes e pontos. Após o

loop, o objeto da classe FileWriter utiliza a função close() para fechar o arquivo.

7.2.2.3.5. Função criaRanking() : void

Este método instancia o vetor de nomes e o vetor de pontos da classe.

Não possui retorno nem parâmetros.

7.2.2.3.6. Função inicializaRanking() : void

Este método atribui a todo vetor de nomes um valor default, por

exemplo, “NULL”, e atribui a todo vetor de pontos o valor 0 (zero), através de

um loop que vai de 0 até o valor do atributo quantidade da classe.

7.2.2.3.7. Função atualizaRanking(nome : String, pontos :

int) : void

Este método tem por objetivo inserir um novo jogador no ranking e

reordenar o ranking. Para isto, é feito um loop de 0 até o valor do atributo

quantidade da classe, neste loop é verificado se o valor pontos recebido como

parâmetro é maior que o valor pontos da posição i do vetor de pontos, se sim,

chama-se a função reordenaRanking, passando o valor de i, o nome e os

pontos como parâmetro da função e então sai-se do loop utilizando break. O

ranking é posteriormente gravado no disco utilizando-se a função

gravaRankingNoDisco.

7.2.2.3.8. Função reordenaRanking(ind : int, nome : String,

pont : int) : void

Este método tem por objetivo reordenar o ranking. Para isto, é realizado

um loop que vai do valor do atributo quantidade da classe – 1 até o valor ind

passado recebido como parâmetro. Dentro do loop a posição i do vetor de

nomes recebe o valor contido na posição i-1 deste mesmo vetor, o mesmo

acontece com pontos, a posição i do vetor de pontos recebe o valor contigo na

posição i-1 deste mesmo vetor. Após o loop a posição ind do vetor de nome


2011/2



112

recebe o valor nome recebido como parâmetro e a posição ind do vetor de

pontos recebe o valor pont recebido como parâmetro.

7.2.2.3.9. Função getNomePosição(i : int) : String

Este método retorna o valor contido na posição i do vetor de nomes.

7.2.2.3.10. Função getPontosPosição(i : int) : int

Este método retorna o valor contido na posição i do vetor de pontos.

7.2.2.3.11. Função setNomePosição(nome : String, i : int) :

void

Este método atribui à posição i do vetor de nomes o valor nome recebido

como parâmetro.

7.2.2.3.12. Função setPontosPosição(pontos : int, i : int) :

void

Este método atribui à posição i do vetor de pontos o valor pontos

recebido como parâmetro.

7.2.2.3.13. Função getQtd() : int

Este método retorna o valor do atributo quantidade desta classe.

7.2.2.3.14. Função zerarRanking() : void

Este método tem como objetivo zerar o ranking do jogo. Para isto, atribui

a todo vetor de nomes um valor default, por exemplo, “NULL”, e atribui a todo

vetor de pontos o valor 0 (zero), através de um loop que vai de 0 até o valor do

atributo quantidade da classe. Posteriormente grava-se o arquivo no disco

através da função gravaRankingNoDisco().

7.2.2.3.15. Função retornaLinhaArquivo(linha : int) : String


2011/2



113

Este método tem como objetivo retornar uma linha do arquivo. Para isto,

cria-se uma String e atribui-se a esta os valores retornados das funções

getNomePosição(linha) e getPontosPosição(linha). Após estes procedimentos

a String é retornada.

7.2.2.4. Classe Tabuleiro

A classe Tabuleiro é responsável por manter o tabuleiro e para isto

fornece método que permitem às outras classes que interajam com esta.

Possui como atributos valores que representam a quantidade de linhas e a

quantidade de colunas que formam o tabuleiro. O atributo tabuleiro

corresponde a uma matriz de quadrados com os tamanhos recém

especificados.

7.2.2.4.1. Construtor Tabuleiro(linhas : int, colunas : int)

No construtor os valores linhas e colunas recebidos como parâmetros

são atribuídos aos respectivos atributos da classe. Após isto é instanciada a

matriz de quadrados, passando-se como parâmetros para o construtor de

Quadrado os valores recebidos como parâmetros. O tabuleiro é esvaziado

posteriormente, como forma de “inicializa-lo”.


2011/2



114

Figura 60: Diagrama de Sequencia Construtor de Tabuleiro

A figura 60 demonstra a execução do construtor da classe Tabuleiro.

7.2.2.4.2. Função esvaziarTabuleiro() : void

Este método tem por objetivo atribuir NULL à todas as posições da

matriz tabuleiro. Para isto, possui um loop que vai de 0 ao valor do atributo

linhas da classe, e dentro desse um loop que vai se 0 ao valor do atributo

colunas desta classe.

7.2.2.4.3. Função preenchePosição(linha : int, coluna : int,

quadrado : Quadrado) : void

Este método atribui à posição linha, coluna de tabuleiro, o quadrado

passa como parâmetro. Não possui retorno.

7.2.2.4.4. Função esvaziarPosição(linha : int, coluna : int) :

void


2011/2



115

Este método atribui NULL à posição linha, coluna de tabuleiro. Não

possui retorno.

7.2.2.4.5. Função ehPosiçãoVazia(linha : int, coluna : int) :

boolean

Este método verifica se a posição linha, coluna de tabuleiro é igual à

NULL e retorna o resultado.

7.2.2.4.6. Função copiarLinha(linhaOrigem : int,

linhaDestino : int) : void

Este método tem por objetivo copiar a linhaOrigem na linhaDestino do

tabuleiro. Para isto, utiliza um loop que vai de 0 ao valor do atributo colunas da

classe, dentro do loop é atribuída à posição linhaDestino, col o valor de

linhaOrigem, col e posteriormente a posição linhaOrigem, col é esvaziada

através do método esvaziarPosição(linhaOrigem, col) desta classe.

7.2.2.4.7. Função verificaLinhaCompleta() : int

Este método tem por objetivo verificar quantas linhas estão

completamente preenchidas. Para isto, cria-se uma variável inteira para fazer a

contagem, faz-se um loop de vai do valor do atributo linhas – 1 até 0, de forma

decrescente, dentro do loop é verificado se linha está preenchida, se sim, um

novo loop é iniciado e vai de lin (valor a linha que esta sendo verificada) até 0,

de forma decrescente, e dentro do loop chama-se a função copiarLinha(lin-1,

lin), ao sair do loop, o atributo que controla o primeiro loop recebe o valor do

atributo linhas da classe e a variável que faz a contagem é incrementada. Após

o loop terminar o valor da variável que faz a contagem é retornado.

7.2.2.4.8. Função linhaEstaPreenchida(linha : int) : boolean

Este método tem como objetivo verificar se algum quadrado da linha

possui valor, ou seja, possui parte de uma peça. Para isto, tem-se um loop que

vai de 0 ao valor do atributo colunas da classe, dentro do loop é verificado se a


2011/2



116

posição linha, col é igual a NULL, se sim retorna false, encerrando o método,

se não, o loop continua e ao terminar retorna true.

7.2.2.4.9. Função getLinhas() : int

Este método retorna o valor do atributo linhas da classe. Não possui

parâmetros.

7.2.2.4.10. Função getColunas() : int

Este método retorna o valor do atributo colunas da classe. Não possui

parâmetros.

7.2.2.5. Classe Tetris

A classe Tetris pode ser considerada como a classe mais importante,

pois é responsável por fazer o controle geral do jogo, tendo ligação com quase

todas as demais classes. É através desta classe que o usuário poderá interagir

com o jogo. Nesta classe tem-se atributos como tabuleiro que guarda as peças

do jogo, a peçaAtual e a próximaPeça que irão participar do jogo, além de

atributos como pontuação, para guardar quantos pontos o usuário já

conquistou, e seu nívelAtual. Encontram-se também nesta classe atributos que

servem para controlar o jogo como fim, pausado e som. O atributo ranking é

utilizado para referenciar-se ao ranking onde são mantidas as pontuações dos

jogadores.

7.2.2.5.1. Construtor Tetris(tetrisGui : TetrisGUI)

No construtor o valor recebido como parâmetro é passado ao respectivo

atributo da classe. Posteriormente instancia-se o Ranking e chama-se a função

iniciarJogo().


2011/2



117

Figura 61: Diagrama de Sequência Construtor de Tetris

7.2.2.5.2. escolherOpção()

Este método verifica qual a opção escolhida pelo usuário e então

chama-a. Esta função é executada internamente, ou seja, sem interferência do

usuário.

7.2.2.5.3. iniciarJogo()

Este método inicia o jogo, atribuindo valores aos atributos da classe,

além de sortear a próxima peça e inseri-la no tabuleiro. Esta função só pode

ser acessada antes do jogo e necessita de intervenção do usuário.


2011/2



118

Figura 62: Diagrama de Sequência Inserir No Tabuleiro Através de Tetris

Figura 63: Diagrama de Sequência Iniciar Jogo de Tetris


2011/2



119

7.2.2.5.4. ajuda()

Este método mostra as instruções do jogo, regras e teclas necessárias

para realizar a interação com o mesmo. Esta função pode ser acessada a

qualquer momento antes ou durante o jogo e necessita de intervenção do

usuário.

Figura 64: Diagrama de Sequência Ajuda de Tetris

7.2.2.5.5. liga/desligaSom()

Este método altera o valor do atributo som de true para false e vice-

versa, demonstrando que o som está ligado ou desligado. Esta função pode ser

acessada a qualquer momento antes ou durante o jogo e necessita de

intervenção do usuário.


2011/2



120

Figura 65: Diagrama de Sequência Ligar/Desligar Som de Tetris

7.2.2.5.6. sair()

Este método encerra o jogo por completo de maneira segura. Esta

função pode ser acessada a qualquer momento antes, durante ou após o jogo

e necessita de intervenção do usuário.


2011/2



121

Figura 66: Diagrama de Sequência Sair de Tetris

7.2.2.5.7. pausar()

Este método “para” a execução do jogo quando for requerida e só

continua após ser executada novamente. Esta função pode ser acessada a

qualquer momento durante o jogo e necessita de intervenção do usuário.

7.2.2.5.8. descerPeça()

Este método verifica colisões inferiores para que se possa descer a

peçaAtual. Após esta verificação, quando ocorre colisão, ele chama o método

descerPeça() da classe Peça. Quando ocorre colisão o método verifica se

alguma linha foi completada através do método verificaLinhaCompleta() da

classe Tabuleiro, caso haja, aumenta-se a pontuação e o nível do jogador,

caso contrário apenas aumenta-se a pontuação. Este método ainda chama o

método que verifica colisão superior da peçaAtual, caso haja, ocasiona o fim do

jogo. Esta função pode ser acessada a qualquer momento durante o jogo e

pode ser executada tanto pelo usuário para acelerar o movimento de descida


2011/2



122

da peça quanto pelo próprio jogo, a fim de mostrar a peça descendo linha a

linha.

Figura 67: Diagrama de Sequência Descer Peça de Tetris


2011/2



123

7.2.2.5.9. sortearPeça()

Este método sorteia a próxima peça, e a retorna. Esta função é

requerida toda vez que o jogo for iniciado e toda vez que uma nova peça for

inserida no tabuleiro. Esta função é executada internamente, ou seja, sem


7.2.2.5.10. inserirNovaPeça()

Este método sorteia qual será a próximaPeça e posteriormente insere

esta peça como peçaAtual do tabuleiro. Esta função é requerida ao iniciar novo

jogo e toda vez que uma peça “parar” no tabuleiro. Esta função é executada


Figura 68: Diagrama de Sequência Inserir Nova Peça de Tetris

7.2.2.5.11. pedeNomeJogador()


2011/2



124

Este método solicita o nome do jogador para incluí-lo no ranking através

da função atualizaRanking(). Esta função é requerida apenas quando o jogo for

encerrado e somente se o jogador aceitar submeter-se ao ranking.

Figura 69: Diagrama de Sequência Pede Nome Jogador de Tetris

7.2.2.5.12. retornaTodoRanking()

Este método gera uma String com todo o ranking e a retorna. Para

conseguir o nome e a pontuação de cada jogador no Ranking é chamada a

função retornaLinhaArquivo() da classe Ranking. Esta função é executada


7.2.2.5.13. atualizaRanking()


2011/2



125

Este método envia a classe Ranking o nome e a pontuação do jogador

através do método inserirNoRanking da classe Ranking. Esta função é


7.2.2.5.14. moveEsquerda()

Este método verifica colisão do lado esquerdo e se esta não ocorreu

então chama a função moverParaEsquerda() da classe Peça através do

atributo peçaAtual. Esta função pode ser acessada a qualquer momento

durante o jogo através de intervenção do usuário.

Figura 70: Diagrama de Sequência Move Esquerda de Tetris

7.2.2.5.15. moveDireita()

Este método verifica colisão do lado direito e se esta não ocorreu então

chama a função moverParaDireita() da classe Peça através do atributo


2011/2



126

peçaAtual. Esta função pode ser acessada a qualquer momento durante o jogo

através de intervenção do usuário.

Figura 71: Diagrama de Sequência Move Direita de Tetris

7.2.2.5.16. girarPeça()

Este método chama o método girarPeça() da classe Peça através do

atributo peçaAtual, o que faz com que a peça seja girada, quando possível, ou

seja, quando não houver possibilidade de colisão. Esta função pode ser

acessada a qualquer momento durante o jogo através de intervenção do

usuário.


2011/2



127

Figura 72: Diagrama de Sequência Girar de Tetris

7.2.2.5.17. aumentaNível()

Este método é utilizado quando uma linha é completada para aumentar

a dificuldade do jogo. Esta função é executada internamente, ou seja, sem


7.2.2.5.18. aumentaPontuação()

Este método é utilizado a cada peça que é encaixada, contando pontos

para o jogador. Quando uma linha é completada o jogador ganha mais pontos.


7.2.2.5.19. Função getPróximaPeça() : Peça

Retorna a próxima Peça.

7.2.2.5.20. Função sleepTime() : int

Gera um valor de acordo com o nível, isso fará com que quanto maior o

nível, mais rápido a peça desça.

7.2.2.5.21. Função getRanking() : Ranking


2011/2



128

Retorna o ranking.

7.2.2.5.22. Função getTabuleiro() : Tabuleiro

Retorna o tabuleiro.

7.2.2.5.23. Função ehFimJogo() : boolean

Retorna valor da variável fimJogo.

7.2.2.5.24. Função ehPausado() : boolean

Retorna valor da variável pausado.

7.2.2.5.25. Função setPausado(b : boolean) : void

Altera o valor da variável pausado.

7.2.2.5.26. Função getNivelAtual() : int

Retorna o nível atual.

7.2.2.5.27. Função setPontos(pontos : int) : void

Altera o valor da variável pontos.

7.2.2.5.28. Função setNivelAtual(nívelAtual : int) : void

Altera o valor da variável nívelAtual.

7.2.2.5.29. Função setFimJogo(fimJogo : boolean) : void

Altera o valor da variável fimJogo.

7.2.2.5.30. Função getPontos() : int

Retorna valor da variável pontos.

7.2.3. Pacote control


2011/2



129

Este pacote é responsável por fazer o controle do fluxo de execução da

aplicação.

7.2.3.1. Classe TetrisThread

A classe TetrisThread é responsável por manter a execução de uma

thread que se caracteriza como um segundo fluxo de execução do jogo. Possui

como atributos Tetris e TetrisGUI. Pode-se dizer que é esta classe que controla

o jogo, por ser esta que possui como atributos a classe que controla o jogo e a

classe que controla a interface do jogo, respectivamente.

7.2.3.1.1. Construtor TetrisThread(tetris : Tetris, tetrisGui :

TetrisGUI)

O Construtor desta classe apenas atribui aos atributos da classe os

valores recebidos como parâmetro.

Figura 73: Diagrama de Sequência Construtor de TetrisThread

A Figura 73 demonstra a criação de um objeto da classe TetrisThread.

7.2.3.1.2. Função run()

O método run() tem por objetivo executar um fluxo de operação(Thread)

independente do fluxo original sendo assim independente da interação com o

usuário. Para isto, tem-se um loop que só “para” quando o jogador escolher a


2011/2



130

opção pausar ou sair do jogo. Dentro do loop são executadas as funções

descerPeça() de Tetris e repaint() de TetrisGUI. A função tem um sleep que

serve para demonstrar que a peça desde tempo a tempo. Ao findar-se o loop é

verificado se o jogo terminou através da função isFimJogo(), e se sim, é

preguntado ao usuário se deseja submeter-se ao ranking, caso sim, o chama-

se a função atualizaRanking(), caso contrário, a função é apenas encerrada.

Figura 74: Diagrama de Sequência Run de TetrisThread

Na Figura acima é apresentada a execução do método run() da classe

TetrisThread.

7.2.4. Pacote view

As classes do Pacote View, que não foram abordadas na documentação

do SIMPLE TETRIS que continha a análise do jogo, tem por objetivo, prover a

interface do sistema, gerando as telas com as quais o jogador irá interagir e

onde visualizará todo o jogo.


2011/2



131

Os atributos e funções relacionados à exibição de componentes da

interface não serão especificados, pois são gerados automaticamente pela IDE

NetBeans ao se “desenhar” um projeto e também por haver neste documento

protótipos de interface, permitindo ao desenvolvedor que “monte” a interface da

forma que desejar, desde que tenha os itens mostrados nos protótipos da

Seção 8.

Não é necessário que os componentes utilizados para montar os

protótipos de interface sejam utilizados na implementação de cada interface,

podendo ser utilizados outros, desde que a interface final possua a mesma

representatividade e interatividade daquelas, ou seja, devem-se ter exibidas

ainda as opções de pausar, ligar/desligar som, etc.

7.2.4.1. Classe MiniTabuleiroGUI

Esta classe tem por objetivo exibir na tela a próxima peça que foi

sorteada, para isto, possui ligações com as classes Tetris, Tabuleiro e Peça,

com as quais tem os atributos tetris, tabuleiro e pecaatual, respectivamente.

7.2.4.1.1. Construtor MiniTabuleiroGUI(tetris : Tetris,

tabuleiro : Tabuleiro)

Neste construtor são inicializados os componente que geram a interface

do jogo através do método initComponents() gerado pela própria IDE. Além da

interface, são passados os parâmetros tetris e tabuleiro para os atributos tetris

e tabuleiro da classe, além de inicializar o atributo pecaatual como NULL.


2011/2



132

Figura 75: Diagrama de Sequência Construtor de MiniTabuleiroGUI

A Figura acima demonstra a criação de um objeto da classe

MiniTabuleiroGUI.

7.2.4.1.2. Função paint(g : Graphics)

Esta função sobrescreve a função paint da classe JPanel que é invocada

para desenhar componentes. Dentro deste método são chamadas as funções

paint da classe superior, setColor(color.black) e fillRect(0,0,30*4,30*4) para

pintar o retângulo(tabuleiro) na interface, que são funções da Classe Graphics

e portanto devem ser acessadas com o atributo g passado por parâmetro.

Obtem-se da classe Tetris qual a próxima peça e então verifica-se se esta peça

é diferente da peçaAtual e se não é igual a NULL, se sim, torna esta peça a

nova peça atual, obtem-se uma cópia da peça nova peça através do método

getCopy. Esvazia-se o tabuleiro e logo após insere-se a nova peça no

tabuleiro, direcionando-a dois quadrados à esquerda e um abaixo. Utilizando as

mesmas funções descritas anteriormente pinta-se o tabuleiro, posteriormente

define-se o tamanho da linha e coluna dos quadrados, fazendo-se os seguintes

cálculos: (30*4)/tabuleiro.getLinhas e (30*4)/tabuleiro.getColunas,

respectivamente, onde atribui-se o resultado destes cálculos às variáveis que

definem o tamanho dos quadrados. Após isto, tem-se um loop de 0 até

tabuleiro.getLinhas() e dentro deste um loop que vai de 0 à

tabuleiro.getColunas(), então verifica-se se a posição no tabuleiro não está


2011/2



133

vazia, e se não estiver, pinta-se a linha através da função

g.fillRect((col+1)*ladoCol+1,(lin+2)*ladoLin+1,ladoCol-1,ladoLin-1) .

Figura 76: Diagrama de Sequência Paint de MiniTabuleiroGUI

A Figura acima demonstra as interações entre a classe

MiniTabuleiroGUI e as demais durante a execução do método paint.

7.2.4.2. Classe TabuleiroGUI

Esta classe faz a mesma coisa que a classe MiniTabuleiroGUI, a única

diferença é que nesta classe pretende-se mostrar todo o tabuleiro, com as

peças já posicionadas e as que ainda estão caindo.

7.2.4.2.1. Construtor TabuleiroGUI(tabuleiro : Tabuleiro)

Neste construtor são inicializados os componentes que geram a

interface do jogo através do método initComponents() que é gerado pela


2011/2



134

própria IDE. Além disso, é atribuído ao atributo tabuleiro da classe o valor

recebido como parâmetro.

7.2.4.2.2. Função paint(g : Graphics)

Esta função possui o mesmo princípio de funcionamento da função paint

da classe MiniTabuleiroGUI. Não será especificada em um diagrama de

sequência, pois este método realiza apenas funções que pintam o tabuleiro da

interface. Este método sobrescreve a função paint da classe JPanel que é

invocada para desenhar componentes. Dentro deste método são chamadas as

funções paint da classe superior, setColor(color.black) e fillRect(0,0,300,600)

para pintar o retângulo(tabuleiro) na interface, que são funções da Classe

Graphics e portanto devem ser acessadas com o atributo g passado por

parâmetro. Posteriormente define-se o tamanho da linha e coluna dos

quadrados, fazendo-se os seguintes cálculos: (600)/tabuleiro.getLinhas e

(300)/tabuleiro.getColunas, respectivamente, onde atribui-se o resultado destes

cálculos às variáveis que definem o tamanho dos quadrados.

Utiliza-se a função setColor(color.write) novamente a fim de desenhar as

linhas e as colunas do tabuleiro, para isto, tem-se um loop de 1 até

tabuleiro.getLinhas() onde executa-se a função

g.drawLine(0,lin*ladoLin,300,lin*ladoLin). Logo após tem-se outro loop de 1 até

tabuleiro.getColunas() onde executa-se a função

g.drawLine(col*ladoCol,0,col*ladoCol,600).

Após isto, tem-se um loop de 0 até tabuleiro.getLinhas() e dentro deste

um loop que vai de 0 à tabuleiro.getColunas(), então verifica-se se a posição no

tabuleiro não está vazia, e se não estiver, pinta-se a linha através da função

g.fillRect((col+1)*ladoCol+1,(lin+2)*ladoLin+1,ladoCol-1,ladoLin-1) .

7.2.4.3. Classe TetrisGUI

Esta classe possui ligação com as classes Tetris, TetrisThread,

MiniTabuleiroGUI e TabuleiroGUI, o que confere a ela grande importância. É


2011/2



135

esta classe que receberá as interações do usuário, pois é nesta que de

disponibilizará os botões para ajuda, iniciar jogo, sair, pausar, ligar/desligar

som. Além dos botões, está classe também deverá captar as interações via

teclado do usuário, navegando pelas opções disponíveis ou movimentando,

girando e descendo as peças.

7.2.4.3.1. Construtor TetrisGUI()

Neste construtor são inicializados os componentes que geram a

interface do jogo através do método initComponents() que é gerado pela

própria IDE. É instanciado o atributo pnMiniTabuleiro passando-se Tetris e new

Tabuleiro(8,8) como parâmetros. Posteriormente é criado um objeto da classe

TetrisThread e então iniciado a thread através da função start() que é uma

função fornecida pela classe Thread.

Figura 77: Diagrama de Sequência Construtor TetrisThread

A Figura 77 demonstra a criação de um objeto da classe TetrisGUI.

Pode-se dizer que este diagrama representa a criação de todo o jogo.

7.2.4.3.2. Função pausaJogo() : void


2011/2



136

Este método verifica inicialmente o retorno da função isPausado da

classe Tetris, quando o retorno for true, é executada a função

setPausado(false), logo após é criada uma nova instancia de TetrisThread que

enseguida é iniciada com a função start(), já quando o retorno for false, é

executada a função setPausado(true).

Figura 78: Diagrama de Sequência Pausa Jogo de TetrisGUI

A Figura 78 demonstra o processo realizado ao pausar o jogo.

7.2.4.3.3. Função tecla/BotãoPrecionado() : void

Este método verifica qual tecla o usuário pressionou, se for alguma tecla

de ação do jogo, este método chama os métodos responsáveis por executar a

ação desejada pelo usuário. Os atalhos que deverão estar disponíveis para

acesso via teclado pelo usuário podem ser verificados no documento de

requisitos deste software.


2011/2



137

Figura 79: Diagrama de Sequência Tecla/BotãoPrecionado


2011/2



138

A Figura 79 demonstra as opções que o jogador pode acessar e como

elas são chamadas.

8. Interação entre os Objetos

Figura 80: Diagrama de Objetos do Jogo

A Figura 80 apresenta um Diagrama de Objetos das classes do Jogo,

incluindo as classes de interface. O Objetivo deste diagrama é o de mostrar

que todo o jogo está interligado, ou seja, por exemplo, o atributo tetris, da

classe Tetris, encontrado em várias classes, referencia o mesmo objeto, sendo

assim, quando ocorre alteração desse objeto em uma das classes, ocorre nas

outras também. O mesmo ocorre com a classe tabuleiro, que é acessada de

varias outras classes.

Diferentemente acontece com a classe Peça, que possui dois objetos

neste diagrama, o objeto peçaAtual e o objeto próxima peça, diferentes entre


2011/2



139

si, pois um representa a peça que está em jogo no instante, e a outro

representa a peça que estará em jogo assim que for verificada uma colisão

inferior da peçaAtual.

Ainda diferente é a classe Quadrado, que possui os objetos tabuleiro e

quadrados, que possuem finalidades completamente diferentes; o tabuleiro de

Quadrado formará o tabuleiro da classe Tabuleiro, enquanto que o quadrados

de Quadrado formará uma peça. Lembrando que cada peça é formada por 4

quadrados, e que um tabuleiro é formado, neste jogo, por uma matriz 20x10.

9. Protótipos de Interfaces do Jogo

Nesta seção serão apresentadas algumas interfaces para que o

programador possa ter plena noção de como deverão ser as interfaces do jogo.

Lembrando que estas interfaces podem, e devem, ser melhoradas pelo

programador.

Figura 81: Tela Inicial

A Figura 81 apresenta uma possível interface inicial para o jogo, onde o

jogador tem opções de Iniciar Jogo, Ajuda, Sair ou Ligar/Desligar o Som. A

execução do jogo só ocorre após esta primeira interação do jogador.


2011/2



140

Figura 82: Tela de Ajuda

A Figura 82 apresenta uma possível tela de ajuda ao usuário, onde ele

consegue visualizar a descrição do jogo e também as teclas que ele deve

utilizar. Também nesta tela pode-se Ligar/Desligar o Som.


2011/2



141

Figura 83: Interface Durante o Jogo

A Figura 83 apresenta uma possível tela de execução do jogo. Deverão

constar nesta tela, como já mencionado neste documento, opções para pausar

o jogo, ligar/desligar som, sair e ajuda, todas acessíveis via teclado. Para o

programador, é interessante salientar que a os dois tabuleiro, o que mostra a


2011/2



142

próxima peça e o tabuleiro onde ocorre a movimentação das peças, são

repintados a cada movimentação, seja ela com ou sem interação do jogador.

Para trabalhos futuros, poder-se-ia aprimorar a interface com o jogador,

alterando de pintura de cada quadro para imagens de blocos, como as

demonstradas na Tabela 1 da Seção 6.2.1 deste documento.

Figura 84: Solicitar Nome Antes de Inserir No Ranking

A Figura 84 representa a tela em que solicita-se o nome do usuário para

inseri-lo no ranking.

Figura 85: Mostrando o Ranking

A Figura 85 representa a tela onde o usuário verifica o ranking. O

jogador só aparecerá no ranking se sua pontuação for maior que a pontuação

do último colocado.


2011/2



143

As telas decisivas como a “Deseja inserir-se no ranking?” e “Jogar

Novamente” não foram demonstradas através de figuras, pois não se percebeu

necessidade para tal, já que as imagens mostradas exemplificam bem uma

possível interface do jogo.

10. Processo de Planejamento do Projeto

A partir desta parte do documento, é pretendido que se possa estimar os

valores dos custos de um projeto de software, onde os mesmo devem ser

entregues dentro do prazo estipulado e com os requisitos solicitados pelo

cliente.

10.1. Objetivos

Definir detalhadamente todas as informações necessárias para a

aprovação efetiva do projeto, contemplando todas as etapas que serão, de

alguma forma, relevantes para o planejamento, execução e desenvolvimento,

envolvendo o escopo, comunicações, tempo, custo, recursos humanos, dentre

outros.

10.2. Público alvo

Pessoas de qualquer idade, que queiram divertir-se em um jogo simples

e que tenham um mínimo de instrução sobre as funcionalidades do jogo e

interação do usuário com o jogo.

10.3. Premissas

Nesta seção são descritas as premissas de funcionamento e

desenvolvimento do software.

O software deve proporcionar partidas com jogadores humanos,

ou seja, não há adversários;

O software deve possuir uma interface gráfica de fácil utilização;


2011/2



144

A entrada de dados poderá ser feita por meio do teclado ou do

mouse, sendo necessário apenas o primeiro para o correto

funcionamento do jogo;

A saída de dados deve ocorrer por meio do monitor do

computador;

Nenhum tipo de recurso de acessibilidade, para portadores de

deficiência, precisa ser implementado;

O jogo possui regras estáticas e imutáveis.

10.4. Restrições

O software deve seguir as informações estabelecidas nas restrições

deste documento, além da seção de Informações Adicionais, não devendo fugir

do padrão de funcionamento do conhecido jogo Tetris.

10.5. Análise de Viabilidade

Nesta seção é mostrada a viabilidade tecnológica, econômica e legal do

projeto.

10.5.1. Viabilidade Tecnológica

Analisando-se a descrição do software, percebe-se que:

Não é necessária a realização de cálculos complexos nem a

utilização de recursos avançados de computação gráfica, o que

diminui os requisitos de hardware exigidos durante o

desenvolvimento do jogo e durante sua utilização.

Os requisitos de hardware exibidos pelo jogo são supridos pelos

computadores atuais.


2011/2



145

Sendo assim, pode-se concluir que o projeto é viável do ponto de vista

tecnológico.

10.5.2. Viabilidade Econômica

Baseando-se na descrição do produto, pode-se estimar que:

São necessários poucos gastos com equipamentos e

ferramentas;

Grande parte dos gastos será para pagamento de pessoal;

É um projeto de curta duração.

Sendo assim, pode-se concluir que o projeto também é viável do ponto

de vista econômico.

10.5.3. Viabilidade Legal

Serão utilizadas ferramentas gratuitas para o desenvolvimento do

jogo;

O jogo não fornecerá qualquer tipo de funcionalidade que

possibilite, facilite ou mesmo incentive a aposta durante as

partidas;

A interface gráfica não utilizará qualquer tipo de linguagem

ofensiva ou racista, nem mesmo imagens que possam ser

consideradas ilegais.

Sendo assim, pode-se concluir que o projeto também é viável do ponto

de vista legal.

10.6. Fatores Ambientais e Organizacionais

Nesta seção são descritos os fatores ambientais e organizacionais do

projeto do software.


2011/2



146

10.6.1. Ambientais

O ambiente necessário para a execução correta do software detém-se a

um computador que possua a Maquina Virtual Java instalada. Quanto a

interface, esta deverá ser projetada de forma a tornar-se amigável ao usuário.

10.6.2. Organizacionais

O software será desenvolvido para qualquer usuário com interesse em

diversão, entretenimento, ou até mesmo, exercitar seu raciocínio lógico. Na

criação dos documento é necessário que o projetista tenha certo conhecimento

do projeto em questão, bem como experiência em desenvolvimento de

documentos de requisito, projeto, análise, plano de projeto, dentre outros.

Na criação do sistema necessita-se de um programador com

conhecimentos em linguagem de programação Java, não precisando ter

conhecimento sobre banco de dados, já que o software em questão não utiliza

tais recursos.

10.7. Termos

Nesta seção são descritos os termos de autorização do projeto e de

encerramento do mesmo.

10.7.1. Termo de Abertura do Projeto

Termo de Abertura do Projeto

SIMPLE TETRIS

Justificativa: Entreter o usuário com um jogo simples, intuitivo e

conhecido mundialmente.

Produtos e serviços: Software com interface amigável e que armazena

a pontuação obtida pelo jogador.


2011/2



147

Restrições: É limitado a um jogador por vez e funciona localmente, sem

qualquer tipo de conexão de rede para partidas multiplayer ou armazenamento

de pontuação de vários jogadores em computadores diversos em um mesmo

arquivo.

Pré-requisito: Os documentos de requisitos, análise e projeto devem

estar de acordo com as exigências do cliente.

Cronograma: Início: Agosto de 2011

Término: Dezembro de 2011

10.7.2. Termo de Encerramento do Projeto

Santo Ângelo, ___ de _____________ de 2011.

Termo de encerramento do projeto

Atesto que Srº (ª) _________________________________, representante da

empresa ______________________________________, CPF

_________________, recebeu e testou o _________________________, e de

que tem pleno conhecimento das condições do mesmo e que recebeu toda a

documentação pertinente da entrega do mesmo.

_______________________________

Responsável

10.8. Declaração do Escopo Preliminar do Projeto

Nesta seção são demonstradas a definição do projeto, as atividades a

serem realizadas, abordando e documentando as características e limites do

projeto e seus produtos e serviços.

Objetivos do Projeto: jogo simples de tetris com as regras básicas do

mesmo.


2011/2



148

Requisitos do Produto ou Serviço: o software deve aceitar os

comando do usuário e exibir graficamente o resultado de sua ação.

Critérios de Aceitação do Produto: o software deve efetuar todas as

funcionalidades exibidas pelo cliente e descritas nos documentos de requisitos,

análise e projeto.

Limites do Projeto: o sistema é limitado a um jogador por vez, não

contemplando partidas com mais de um jogador.

Entrega do Projeto: Dezembro de 2011.

Restrições do Projeto: restrito as regras básicas do conhecido jogo de

tetris.

Riscos iniciais definidos: não concluir o projeto no tempo previsto.

Requisitos de aprovação: o software deverá estar completamente de

acordo com as especificações definidas nos documentos de requisitos, análise

e projeto.

10.9. Estrutura Analítica do Projeto (EAP)

Nesta seção são demonstradas as atividade que compõem o projeto,

sendo estas representadas na forma de uma Estrutura Analítica de Projeto

(EAP).

A Figura abaixo demonstra as principais atividades do projeto,

juntamente com suas subatividades.


2011/2



149

Figura 86: Estrutura Analítica do Projeto

Nas próximas seções será apresentada uma descrição das atividades

presentes na EAP.

10.9.1. Verificação do Escopo

Esta seção contém a tabela com a descrição das atividades presentes

na EAP. Nesta descrição são encontradas informações referentes a:

Nome do Pacote / Sub Pacote: informa a qual pacote pertence

àquela atividade e ainda qual o sub pacote, se este existir.

Nome do Sub pacote e da Atividade: informa a qual o nome da

atividade.

Objetivos: informa uma breve descrição dos objetivos daquela

atividade.

Critério para Tomada de Decisão: informa porquê é necessária

àquela atividade.

SIMPLE TETRIS

Documentação

Levantamento de Requisitos

Pesquisa de Material

Obtenção de Requisitos

Estabelecimento dos Casos de Uso

Montagem/redação do Documento

Análise dos Requisitos

Identificação das Classes

Identificação dos Atributos e Métodos

Identificação dos Relacionamentos

Desenvolvimento dos Diagramas


Projeto de

Software

Escolha da Linguagem

Identificação dos Tipos

Desenvolvimento dos Diagramas

Projeto da Interface Gráfica


Codificação

Implementação das classes de

entidade/modelo

Implementação das classes de controle

Implementação dos relacionamentos

Interface Gráfica

Implementação das classes de interface

Implementação das funcionalidades da

interface gráfica

Testes

Testes individuais das classes

Testes do conjunto

Modificações

Alterações do código

Alterações na interface gráfica

Entrega

Entrega da Versão Final


2011/2



150

Artefatos Gerados: informa se a atividade gera algum

documento, código, etc...

Tabela 4: Verificação do Escopo das Atividades da EAP

Nome do Pacote /

Sub Pacote Nome da Atividade Objetivos Artefatos Gerados

Documentação /

Levantamento de

Requisitos

Pesquisa de

Material

Verificar material

existente relacionado

ao escopo do projeto

Material para

consulta e auxílio nas

decisões

Obtenção de

Requisitos

Verificar os requisitos

de usuário e de

sistema

Descrição dos

Requisitos de usuário

e de Sistema

Estabelecimento

dos Casos de Uso

Definir o

funcionamento

específico de cada

função do software

Descrição dos Casos

de Uso do software

Montagem / redação

do Documento

Gerar documento

contendo as

especificações dos

casos de uso e dos

requisitos do software

Documento de

Requisitos

Documentação /

Análise dos

Requisitos

Identificação das

Classes

Definir em classes as

diferentes áreas

deverão ser

implementadas

Descrição das

Classes do software

Identificação dos

Atributos e Métodos

Definir os atributos e

funções que serão

necessários para o

correto funcionamento

do software

Descrição dos

Atributos e métodos

das classes

anteriormente

definidas

Identificação dos

Relacionamentos

Definir os

relacionamentos entre

as classes do software

que farão com que as

classes comuniquem-

Descrição dos

Relacionamento

entre as classes


2011/2



151

se

Desenvolvimento

dos Diagramas

Gerar diagramas

explicativos do

funcionamento do

software, tais como

diagramas de

atividade, de

sequência, de

objetos...

Descrição dos

Diagramas que

demonstram o

funcionamento do

software


do Documento

Gerar documento

contendo informações

mais detalhadas do

funcionamento das

classes, atributos e

principalmente os

métodos do software

Documento de

Análise e Documento

de Projeto contendo

as informações

obtidas anteriormente

Documentação /

Projeto de Software

Escolha da

Linguagem

Verificar qual a

linguagem mais

adequada para a

implementação do

software

Definição da

linguagem a ser

utilizada

Identificação dos

Tipos

Definir os tipos dos

atributos, seus valores

default, o retorno dos

métodos, bem como

seus parâmetros, e

ainda definir quais

classes são de

interface ou de

controle

Descrição dos tipos

das variáveis, etc

Desenvolvimento

dos Diagramas

Desenvolver os

gráficos de estimativas

do projeto

Diagramas

explicativos das

estimativas do

software

Projeto da Interface

Gráfica

Definir como será a

interface, o quê

Definição da interface

gráfica do software


2011/2



152

conterá, etc


do Documento

Gerar documento

contendo as

estimativas do projeto

Plano de Projeto

contendo inclusive os

documentos

anteriores

Codificação

Implementação das

classes de

entidade/modelo

Realizar a

implementação

completa das classes

de definição (modelo)

Códigos fonte das

classes

Implementação das

classes de controle

Realizar a

implementação

completa das classes

de controle,

responsáveis por

controlar o software

Códigos fonte das

classes definidos em

pacotes

Implementação dos

relacionamentos

Realizar a

implementação dos

relacionamentos entre

as classes

Códigos fonte das

classes inter-

relacionadas

Interface Gráfica

Implementação das

classes de interface

Realizar a

implementação das


contendo os

componentes gráficos

necessários

Códigos fonte das

classes que definem

a interface gráfica do

software

Implementação das

funcionalidades da

interface gráfica

Realizar a

implementação das

funcionalidade de

cada componente

gráfico, como botões,

etc

Códigos fonte de


com componente

gráficos funcionais

Testes Testes individuais

das classes

Realizar testes

internos para verificar

se os métodos estão

realizando as funções

corretas

Descrição dos teste

aplicados e relação

dos erros

encontrados


2011/2



153

Testes do conjunto

Realizar teste de

funcionamento do

software completo

Relatório de testes e

relação dos erros

encontrados

Modificações

Alterações do

código

Realizar alterações no

código fonte, caso

necessário

Novos códigos fonte

com erros corrigidos

Alterações na

interface gráfica

Realizar ajustes na

interface gráfica, caso

necessário

Novos códigos fonte

com interface gráfica

readequada

Entrega Entrega da Versão

Final

Entregar o software

completo e funcional,

juntamente com a

documentação

Documentação

completo e software

funcional

10.10. Gerenciamento do Projeto

Nesta seção são mostradas as gerências do projeto.

10.10.1. Funções do Software

Abaixo estão descritas as principais funcionalidades do software,

divididas em duas áreas.

Tabela 5: Gerenciamento das Funcionalidades do Software

Área Funcionalidades

Gerência da Partida

Descer Peça

Direcionar Peça

Girar Peça

Gerência de Periféricos Gerenciamento de entrada (mouse e teclado)

Gerenciamento de saída (monitor)

10.10.1.1. Gerência da Partida


2011/2



154

O software deverá permitir ao usuário realizar as seguintes

funcionalidades, previamente definidas:

Descer Peça: o usuário poderá descer a peça quando desejar

durante o jogo.

Direcionar Peça: o usuário poderá direcionar a peça de acordo

com sua vontade.

Girar Peça: o usuário poderá girar a peça para encaixá-la com

maior facilidade.

10.10.1.2. Gerência de Periféricos

A comunicação do usuário com o software deverá ocorrer através dos

periféricos de entrada e saída, sendo assim, o software deverá gerenciar tal

comunicação de forma:

Gerenciamento de entrada (mouse e teclado): o usuário

poderá interagir com o software através do teclado,

essencialmente, ou opcionalmente através do mouse, porém as

funções que realizam efetivamente as jogadas do software devem

ser realizadas através do teclado.

Gerenciamento de saída (monitor): o usuário perceberá a

movimentação das peças do jogo através do monitor.

10.10.2. Estimativas

Existem várias técnicas de estimativas para projetos de software, as

utilizadas neste projeto são descritas abaixo:

Estimativa utilizando linhas de código (LOC), que usa base de

conhecimento histórico relacionada a projetos de

desenvolvimento que possuam o mesmo escopo;


2011/2



155

Estimativa utilizando Pontos por Função (FP);

Depois de uma análise profunda e avaliação de projetos similares,

seguindo o padrão de linhas de código é obtém-se as seguintes estimativas:

Tabela 6: Estimativa por LOC

Classe Otimista Provável Pessimista

TetrisThread 68 62 56

Peça 183 166 149

Quadrado 67 61 55

Ranking 227 206 185

Tabuleiro 109 99 89

Tetris 252 229 206

Peça2D 42 38 34

Peça2E 41 37 33

Peça3C 42 38 34

Peça3D 42 38 34

Peça3E 42 38 34

PeçaQuadrada 41 37 33

PeçaReta 41 37 33

MiniTabuleiroGUI 127 115 104

TabuleiroGUI 96 87 78

TetrisGUI 428 389 350

TOTAL 1.845 1.677 1.509

Realizando os cálculos de Pontos por Função, a tabela resultante é:

Tabela 7: Resultado Estimativa LOC e FP

Técnica Resultado

LOC 1.677

FP 31,64


2011/2



156

Após encontrar os valores acima, pode-se perceber que 31,64 pontos

por função equivalem a 1.677 linhas de código. Sendo assim, estima-se que 1

ponto por função equivalha a cerca de 53 linhas de código, respeitando-se a

regra das 100 linhas de código de diferença.

Utilizando-se a técnica COCOMO II, através do software Costar, foram

inseridos pelo projetista os seguintes valores:

Tabela 8: Dados Inseridos no Costar

Questão Resposta

Experiência dos Analistas Baixa

Maturidade do Projeto Normal

Experiência dos Programadores Baixa

Experiência na Plataforma Alta

Experiência com linguagem e ferramentas Alta

Coesão da Equipe Normal

Ferramentas CASE Alta

Locação da Equipe Alta

Flexibilidade dos Requisitos Normal

Arquitetura Definida Normal

Similaridade com Projetos Anteriores Normal

Complexidade do Software Alta

Reutilização de Trabalho Normal

Documentação Criada Baixa

Através destes valores, o software Costar calculou os valores com

estimativas próprias na forma de “esforço pessoa/mês”.


2011/2



157

Figura 87: Estimativa de esforço pessoa/mês

Na próxima imagem são apresentadas algumas informações geradas

pelo software Costar, tais como a necessidade de 152 horas por pessoa/mês,

além de outras informações.


2011/2



158

Figura 88: Relatório do Software Costar

E por fim, a imagem abaixo mostra as estimativas da divisão de etapas.

Inicialmente são mostradas as estimativas totais e abaixo as divisões de tarefa


2011/2



159

contendo informações como esforço, duração, média de pessoas, dentre

outras.

Figura 89: Informações Estimadas por Etapa pelo Software Costar


2011/2



160

Nota-se que o projeto deverá levar cerca de 7,1 meses para ser

desenvolvido, e que o esforço pessoa/mês é em média 5,5 para 302,9 linhas

de código/mês.

Através de todas estas estimativa pode-se ter uma boa ideia do tempo

necessário para desenvolver o projeto, tanto como a quantia de linhas de

código, o esforço necessário, e os módulos que necessitam de maior atenção.

10.10.3. Recursos

Nesta seção serão descritas as informações referentes aos recursos do

projeto.

10.10.3.1. Recursos Humanos

Devido a baixa complexidade do projeto, foram definidas as seguintes

atribuições e responsabilidade para cada funcionário e cargo.

Tabela 9: Recursos Humanos Previstos

Quantidade Disponibilidade Cargo Funções Funcionário

01 Imediata Programador Java

Realiza a

codificação, testes e

adequação do

software

Franciele

Ehrhardt

Hoffmann

01 Imediata Projetista de

Software

Projetar o software e

redigir toda a

documentação do

mesmo

Franciele

Ehrhardt

Hoffmann

O valor mensal do salário dos funcionários é descrito na tabela abaixo.

Tabela 10: Demonstrativo de Custo dos Funcionários

Funcionário Salário Mensal Custo Total Estimado

Franciele Ehrhardt Hoffmann R$ 3.000,00 R$ 24.000,00


2011/2



161

10.10.3.2. Recursos Tecnológicos

Para o desenvolvimento total do projeto, são utilizados os seguintes

recursos tecnológicos:

Tabela 11: Recursos Tecnológicos Previstos

Qtd. Recurso Dispon. Descrição Utilização Custo

01 Hardware Imediata Computador

Utilizado em todas as

etapas ao longo do

projeto

R$ 2.500,00

01 Software Imediata NetBeans

versão 7.0.1

Implementação do

software Gratuito

01 Software Imediata Microsoft Office

2010

Redação dos

documentos ao longo

do projeto

R$ 499,00

01 Software Imediata

Microsoft

Project

Professional

2010

Desenvolvimento de

cronogramas R$ 1.900,00

01 Software Imediata Costar 7.0 Desenvolvimento de

estimativas de custo Gratuito

01 Software Imediata Astah

Community 6.4

Desenvolvimento de

diagramas Gratuito

TOTAL R$ 4.899,00

10.10.4. Cronograma

Nesta seção são apresentados os gráficos de cronograma do projeto

gerados a partir do Software Microsoft Project 2010, baseado nas separações

de atividades definidas na EAP do projeto, demonstrando o tempo requerido

por cada etapa, levando em consideração os 7,1 meses calculados pelo

software Costar para execução do projeto.


2011/2



162

Abaixo é mostrada a imagem contendo o gráfico de duração das tarefas

principais do projeto.

Figura 90: Cronograma Principais Atividades

Pode-se observar que as atividades possuem certa ordem de

continuidade, ou seja, uma atividade começa somente após outra atividade

terminar. O cronograma foi definido desta forma levando em conta também, o

fato de haver apenas um funcionário no projeto. A imagem a seguir contém o

gráfico de duração de todas as tarefas do projeto.

Figura 91: Cronograma das Subatividades


2011/2



163

10.10.5. Custos

Nesta seção são apresentados os custos previstos para o

desenvolvimento do projeto. Todos os valores são estimativas, portanto, em

uma aplicação real haverá diferença nos valores. Para esta estimativa foram

levados em conta as atividades, os recursos e o cronograma do projeto.

10.10.5.1. Custos Fixos

Os custos fixos são custos relevantes para todo o projeto, sendo direta

ou indiretamente usados por todas ou pelo menos mais de uma etapa do

desenvolvimento do projeto. A tabela abaixo contém o recurso, seu custo

mensal e total.

Tabela 12: Custos Fixos do Projeto

Recurso Custo Mensal Custo Total

Funcionários R$ 3.000,00 R$ 24.000,00

Computador R$ 312,50 R$ 2.500,00

Microsoft Project 2010 R$ 237,50 R$ 1.900,00

Microsoft Office 2010 R$ 62,50 R$ 499,00

TOTAL R$ 3.612,50 R$ 28.899,00

Estes valores baseiam-se no tempo estimado de 7,1 meses para o

desenvolvimento do projeto, porém foram calculados com base em 8 meses.

10.10.5.2. Custos Variáveis

Os custos variáveis são aqueles que variam de acordo com o tempo ou

consumo. Aqui estão previstos gastos com água, luz, telefone e manutenção,

mas por serem variáveis de estimativa podem diferir bastante do caso real.

Tabela 13: Custos Variáveis do Projeto

Recurso Custo Mensal Custo Total

Água R$ 60,00 R$ 480,00


2011/2



164

Luz R$ 100,00 R$ 800,00

Telefone R$ 60,00 R$ 480,00

Manutenção R$ 70,00 R$ 560,00

Gerais R$ 90,00 R$ 720,00

TOTAL R$ 380,00 R$ 3.040,00

10.10.5.3. Custo Total

O custo total do projeto refere-se a soma dos custos fixos e variáveis, e

está representada na tabela abaixo.

Tabela 14: Custos Totais do Projeto

Tipo Custo Mensal Custo Total

Custo Fixo R$ 3.612,50 R$ 28,899,00

Custo Variável R$ 380,00 R$ 3.040,00

TOTAL R$ 3.992,50 R$ 31,939,00

Relembrando que os cálculos de custo foram baseados no

arredondamento dos 7,1 meses necessários ao projeto para 8 meses,

permitindo assim 0,9 mês de reserva.

10.10.6. Riscos

Um risco é qualquer coisa que pode dar errado e em consequência

atrapalhar ou mesmo inviabilizar o projeto.

Os termos utilizados na tabela indica, graus de acordo com a convenção

abaixo:

Custo: Baixo, Médio, Alto.

Impacto: 1 a 5 (muito baixo a muito alto)

Ocorrência: 1 a 5 (muito incomum a muito comum)


2011/2



165

N/A: Nenhuma alternativa é possível.

Tabela 15: Ricos Possíveis do Projeto

Descrição Ocor. Imp. Custo Contenção

Queda de energia 3 1 Alto Uso de nobreak ou gerador

Queima de hardware 1 5 Alto Aquisição de hardware novo

Incapacitação de funcionário 2 4 Médio Compensar trabalho perdido

Prorrogação dos prazos

Não cumprimento de prazo final 3 5 Alto Negociação de novo prazo

Não cumprimento de prazo de

atividade 3 2 Baixo Advertência para funcionário

Estouro do orçamento 1 3 Alto

Corte de gastos internos

Negociar com cliente

Replanejamento de atividades

Perda de dados 2 5 Alto Backups frequentes

10.10.7. Qualidade

Para atingir a qualidade do produto necessária no projeto, é necessário

que alguns padrões sejam seguidos, para que haja então uma consolidação do

projeto e a satisfação das necessidades de cada etapa. As orientações são

mostradas a seguir:

O documento de requisitos do sistema proposto deve ser

elaborado dentro do conjunto de normas do padrão IEEE 830,

garantindo a integridade dos requisitos levantados.

Os documentos de análise e projeto devem seguir o padrão de

modelagem UML.

A linguagem de programação escolhida deverá ser orientada a

objetos, garantindo a modularização das funções e opções do

software, para que assim, sejam criadas as classes, atributos e

métodos necessários.


2011/2



166

Ainda relevante é a necessidade de clareza do código, incluindo

identação e nomes relevantes para variáveis. Também

recomenda-se comentários para ajudar a identificação de

segmentos de código e permitir o suporte posterior.


2011/2



167

Tabela de conteúdos e índice remissivo

Adaptações ao local de instalação ................................................................... 26

ajuda() ...................................................................................................... 62, 116

Âmbito .............................................................................................................. 17

Análise dos Requisitos do Jogo ....................................................................... 60

Apêndice .......................................................................................................... 58

Assunções e dependências.............................................................................. 27

Ator primário ..................................................................................................... 21

Atributos ........................................................................................................... 22

Atributos do sistema de software ............................................................... 55, 56

atualizaPosição(linha : int, coluna : int) ............................................................ 69

atualizaRanking() ........................................................................................... 121

aumentaNível() ......................................................................................... 65, 124

aumentaPontuação() ................................................................................ 65, 124

Capacidade de manutenção............................................................................. 56

Características ................................................................................................. 57

Características do utilizador ............................................................................. 26

Caso de Uso [01]: Escolher opção ................................................................... 29

Caso de Uso [02]: Escolher opção Iniciar jogo ................................................. 30

Caso de Uso [03]: Escolher opção Instruções.................................................. 31

Caso de Uso [04]: Esolher opção Desligar/Ligar som ...................................... 33

Caso de Uso [05]: Escolher opção Sair ............................................................ 34

Caso de Uso [06]: Direcionar peça ................................................................... 38

Caso de Uso [06]: Pausar ................................................................................ 36

Caso de Uso [07]: Direcionar peça ................................................................... 37

Caso de Uso [08]: Girar peça ........................................................................... 39

Caso de Uso [09]: Descer peça ........................................................................ 40

Caso de Uso [10]: Sortear peça ....................................................................... 41

Caso de Uso [11]: Peça caindo ........................................................................ 43

Caso de Uso [12]: Aumentar nível(dificuldade) ................................................ 47

Caso de Uso [12]: Fechar linha ........................................................................ 44

Caso de Uso [13]: Aumentar nível .................................................................... 45

Caso de Uso [13]: Contar pontuação ............................................................... 48

Caso de Uso [14]: Contar pontuação ............................................................... 47

Caso de Uso [15]: Chegar ao topo ................................................................... 48

Caso de Uso [16]: Informar nome .................................................................... 50

Caso de Uso [16]: Submeter ao ranking .......................................................... 52

Caso de Uso [17]: Mostrar ranking ................................................................... 53

Caso de Uso [17]: Submeter ao ranking .......................................................... 51


2011/2



168

Classe do utilizador .......................................................................................... 57

Classe MiniTabuleiroGUI ............................................................................... 128

Classe Peça ..................................................................................................... 94

Classe Quadrado ............................................................................................. 92

Classe Ranking .............................................................................................. 105

Classe Tabuleiro ............................................................................................ 110

Classe TabuleiroGUI ...................................................................................... 130

Classe Tetris .................................................................................................. 113

Classe TetrisGUI ............................................................................................ 131

Classe TetrisThread ....................................................................................... 126

Classes ............................................................................................................ 21

Comentários adicionais .................................................................................... 57

Construtor MiniTabuleiroGUI(tetris : Tetris, tabuleiro : Tabuleiro) .................. 128

Construtor Peça(tabuleiro : Tabuleiro) ............................................................. 94

Construtor PeçaIdentificação (tabuleiro : tabuleiro) .......................................... 91

Construtor Quadrado(linha : int, coluna : int) .................................................... 92

Construtor Ranking() ...................................................................................... 106

Construtor Tabuleiro(linhas : int, colunas : int) ............................................... 110

Construtor TabuleiroGUI(tabuleiro : Tabuleiro) .............................................. 130

Construtor Tetris(tetrisGui : TetrisGUI) ........................................................... 113

Construtor TetrisGUI() .................................................................................... 132

Construtor TetrisThread(tetris : Tetris, tetrisGui : TetrisGUI) .......................... 126

copiarLinha(linhaOrigem : int, linhaDestino : int) .............................................. 66

Definições, acrônimos e abreviaturas .............................................................. 18

descerPeça() .................................................................................................... 67

Descrição das Funcionalidades ........................................................................ 72

Descrição dos Pacotes do Jogo ....................................................................... 89

Descrição dos Pacotes Java ............................................................................ 87

Descrição Geral ................................................................................................ 23

Diagrama de Atividade ..................................................................................... 22

Diagrama de Classes ....................................................................................... 21

Diagrama de Sequência ................................................................................... 22

Diagramas ........................................................................................................ 21

Direcionar ......................................................................................................... 19

Direito ............................................................................................................... 20

Disponibilidade ................................................................................................. 56

Divisão e atribuição das exigências ................................................................. 27

ehPosiçãoVazia(linha : int, coluna : int) ............................................................ 66

escolherOpção() ............................................................................................. 114

Esquerdo .......................................................................................................... 20


2011/2



169

Estímulos.......................................................................................................... 57

esvaziaPosição(linha : int, coluna : int) ............................................................ 66

esvaziarTabuleiro() ........................................................................................... 66

Exigências de desempenho ............................................................................. 54

Exigências Específicas ..................................................................................... 27

Exigências lógicas de base de dados .............................................................. 54

Fiabilidade ........................................................................................................ 55

Frequência ....................................................................................................... 19

Função atualizaPosição(linha : int, coluna : int) : void ...................................... 94

Função atualizaRanking(nome : String, pontos : int) : void ............................ 108

Função copiarLinha(linhaOrigem : int, linhaDestino : int) : void...................... 112

Função criaRanking() : void............................................................................ 108

Função decrementaColuna() : void .................................................................. 94

Função descer() : void ...................................................................................... 96

Função ehFimJogo() : boolean ....................................................................... 125

Função ehPausado() : boolean ...................................................................... 125

Função ehPosiçãoVazia(linha : int, coluna : int) : boolean ............................. 112

Função esvaziarPosição(linha : int, coluna : int) : void ................................... 111

Função esvaziarTabuleiro() : void .................................................................. 111

Função existeRankingNoDisco() : boolean .................................................... 106

Função getCol() : int ......................................................................................... 93

Função getColunas() : int ............................................................................... 113

Função getCopy(): Peça ................................................................................ 105

Função getCopy(t : Tabuleiro) : Peça ............................................................... 92

Função getCor() : Color .................................................................................... 93

Função getLin() : int ......................................................................................... 93

Função getLinhas() : int .................................................................................. 113

Função getNivelAtual() : int ............................................................................ 125

Função getNomePosição(i : int) : String ......................................................... 109

Função getPontos() : int ................................................................................. 125

Função getPontosPosição(i : int) : int ............................................................. 109

Função getPróximaPeça() : Peça ................................................................... 124

Função getQtd() : int ...................................................................................... 109

Função getRanking() : Ranking ...................................................................... 124

Função getTabuleiro() : Tabuleiro .......................................................... 105, 125

Função girarPeça() : void ................................................................................. 99

Função gravaRankingNoDisco() : void ........................................................... 107

Função incrementaColuna() : void ................................................................... 94

Função incrementaLinha() : void ...................................................................... 93

Função inicializaRanking() : void .................................................................... 108


2011/2



170

Função inserirNoTabuleiro() : void ................................................................... 95

Função leRankingNoDisco() : void ................................................................. 107

Função linhaEstaPreenchida(linha : int) : boolean ......................................... 112

Função moveParaDireita() : void ...................................................................... 98

Função moveParaEsquerda() : void ................................................................. 97

Função paint(g : Graphics) ..................................................................... 129, 131

Função pausaJogo() : void ............................................................................. 132

Função preenchePosição(linha : int, coluna : int, quadrado : Quadrado) : void

.................................................................................................................... 111

Função reordenaRanking(ind : int, nome : String, pont : int) : void ................. 108

Função retirarDoTabuleiro() : void .................................................................... 96

Função retornaLinhaArquivo(linha : int) : String ............................................. 109

Função run() ................................................................................................... 126

Função setCor(cor : Color) : void ..................................................................... 93

Função setFimJogo(fimJogo : boolean) : void ................................................ 125

Função setNivelAtual(nívelAtual : int) : void ................................................... 125

Função setNomePosição(nome : String, i : int) : void ..................................... 109

Função setPausado(b : boolean) : void .......................................................... 125

Função setPontos(pontos : int) : void ............................................................. 125

Função setPontosPosição(pontos : int, i : int) : void ....................................... 109

Função setTabuleiro(tab : Tabuleiro) : void .................................................... 105

Função sleepTime() : int ................................................................................. 124

Função tecla/BotãoPrecionado() .................................................................... 133

Função verificaColisãoDireita() : boolean ....................................................... 104

Função verificaColisãoEsquerda() : boolean .................................................. 103

Função verificaColisãoInferior() : boolean ...................................................... 101

Função verificaColisãoSuperior() : boolean ................................................... 102

Função verificaLinhaCompleta() : int .............................................................. 112

Função zerarRanking() : void ......................................................................... 109

Funções ........................................................................................................... 28

Funções do Produto ......................................................................................... 26

Funções Durante o Jogo .................................................................................. 77

Funções Finais Disponíveis.............................................................................. 84

Gatilho .............................................................................................................. 21

girarPeça().......................................................................................... 65, 68, 123

Hierarquia funcional ......................................................................................... 57

Histórico ............................................................................................................. 2

Inferior .............................................................................................................. 20

Informações de suporte .................................................................................... 58

iniciarJogo() .............................................................................................. 62, 114


2011/2



171

inserirNoRanking(nome : String, pontuação : int) ............................................. 70

inserirNoTabuleiro() .......................................................................................... 67

inserirNovaPeça() ..................................................................................... 64, 120

Instruções do jogo ............................................................................................ 58

Interação entre os Objetos ............................................................................. 135

Interface de áudio ............................................................................................. 24

Interface gráfica ................................................................................................ 24

Interfaces com o utilizador ............................................................................... 23

Interfaces de comunicação............................................................................... 25

Interfaces de hardware ..................................................................................... 24

Interfaces de sistema ....................................................................................... 23

Interfaces de software ...................................................................................... 25

Interfaces externas ........................................................................................... 27

Introdução ........................................................................................................ 17

Java.appelt ....................................................................................................... 88

Java.awt ........................................................................................................... 88

Java.io .............................................................................................................. 88

Java.lang.*........................................................................................................ 89

Javax.swing ...................................................................................................... 88

Jogador ............................................................................................................ 19

Jogo ................................................................................................................. 35

liga/desligaSom() ...................................................................................... 63, 116

Limites da tela .................................................................................................. 20

linhaEstaPreenchida(linha : int) ........................................................................ 66

Memória ..................................................................................................... 25, 55

Métodos ........................................................................................................... 22

Modo de sistema .............................................................................................. 57

Monitor ....................................................................................................... 25, 28

mostrarRanking() ...................................................................................... 64, 121

Mouse .................................................................................................. 24, 25, 28

moveDireita() ............................................................................................ 65, 122

moveEsquerda() ....................................................................................... 64, 121

moveParaDireita() ............................................................................................ 68

moveParaEsquerda() ....................................................................................... 67

Número de partidas simultâneas ...................................................................... 54

Número máximo de jogadores por partida ....................................................... 54

Objetivo ............................................................................................................ 59

Objetos ............................................................................................................. 57

Opções Iniciais Disponíveis.............................................................................. 72

Operações ........................................................................................................ 25


2011/2



172

Organização ..................................................................................................... 23

Organização das exigências específicas ......................................................... 57

Pacote control ................................................................................................ 125

Pacote model ................................................................................................... 92

Pacote model.Peças ........................................................................................ 89

Pacote view .................................................................................................... 127

pausar() .................................................................................................... 63, 118

Peça ................................................................................................................. 67

peçaDescendo() ....................................................................................... 63, 118

Peças ............................................................................................................... 59

Perspectivas do produto ................................................................................... 23

Portabilidade .................................................................................................... 56

Pós-jogo ........................................................................................................... 49

preenchePosição(linha : int, coluna : int, quadrado : Quadrado) ...................... 66

Pré-jogo ............................................................................................................ 28

Prioridade ......................................................................................................... 19

Processador ..................................................................................................... 55

Propósito .......................................................................................................... 17

Protótipos de Interfaces do jogo ..................................................................... 136

Quadrado ......................................................................................................... 69

Ranking ...................................................................................................... 20, 69

Referências ...................................................................................................... 22

reordenaRanking() ........................................................................................... 70

Requisito .......................................................................................................... 18

Requisitos de sistema ................................................................................ 41, 52

Requisitos de usuário ........................................................................... 28, 35, 49

Resposta .......................................................................................................... 57

Restrições ........................................................................................................ 26

Restrições de desenho ............................................................................... 54, 55

Restrições de hardware ................................................................................... 55

retirarDoTabuleiro() .......................................................................................... 67

retornaLinhaArquivo(linha : int) ........................................................................ 70

run .................................................................................................................... 61

sair() ......................................................................................................... 63, 117

Score ................................................................................................................ 20

Segurança ........................................................................................................ 56

Sistema ............................................................................................................ 19

solicitarNome() ......................................................................................... 64, 120

sortearPeça() ............................................................................................ 63, 120

Superior ............................................................................................................ 20


2011/2



173

Tabela de conteúdos e índice remissivo ........................................................ 141

Tabuleiro .......................................................................................................... 65

Tarefa específica .............................................................................................. 21

Teclado ...................................................................................................... 24, 28

Teclas ............................................................................................................... 58

Tetris ................................................................................................................ 62

TetrisThread ..................................................................................................... 61

verificaColisãoDireita() ..................................................................................... 69

verificaColisãoEsquerda() ................................................................................ 69

verificaColisãoInferior() .................................................................................... 68

verificaColisãoSuperior() .................................................................................. 68

verificaLinhaCompleta() ................................................................................... 66

Visão Completa das Classes ............................................................................ 60

Visão Completa Dos Pacotes ........................................................................... 86

Visão das Atividades ........................................................................................ 70

zerarRanking() .................................................................................................. 70

documentação do simple tetris(versão 1.8) - franciele ehrhardt hoffmann

Documents