Jogo feito na disciplina de POO
├── README.md <- apresentação do projeto
│
├── src <- projeto em Java
│ │
│ ├── src <- arquivos-fonte do projeto (.java)
│ │
│ ├── bin <- arquivos em bytecode (.class)
│ │
│ └── README.md <- instruções básicas de instalação/execução
│
└── assets <- mídias usadas no projeto
Projeto em Java, incluindo todos os arquivos de dados e bibliotecas necessários para a sua execução. Dentro dessa pasta há uma subpasta src
onde estão os fontes e outra subpasta bin
onde estão os bytecodes.
O arquivo README.md
contém as instruções básicas de instalação e execução.
Mídias usadas no seu projeto: vídeo da execução do jogo, imagens da interface, slides de proposta de jogo e apresentação de destaques do código.
O jogo Dino World
- O dino pode se movimentar 1 casa em qualquer direção: vertical, horizontal ou diagonal. Uma casa não pode ser ocupada por mais de um dino.
- O ovo deve ser capturado o mais rápido possível. Ele pode ser capturado em até 10 jogadas para receber alguma pontuação. A pontuação atribuída será 100 - (jogada-1)*10. Capturar o ovo é uma condição imprescindível para ganhar o jogo. Então, deve ser capturado mesmo se não for em menos de 10 jogadas.
- O dino chega só pode capturar o ovo do seu filhote na rodada depois de chegar nele e só pode sair na seguinte.
- A cada jogada, uma célula conectada a um vulcão por outras lavas é ocupada por lava e o dino morre se passar por ela.
- Se a lava atingir uma surpresa, a supresa deixa de existir.
- Se o dino passar pela lava, sem o power up da estrela ativado, ele morre
- A caixinha de surpresas só é aberta uma vez, depois que o dino passa por ela, ela deixa de existir
- O dino não pode se mover para onde há um meteoro
No jogo há células de surpresas, que interferem no jogo de cada dino.
Surpresas
item | detalhamento |
---|---|
Comida | +10 pontos |
Pedra | -10 pontos |
Estrela | permite que o dino passe sobre lava 1 vez +50 potnos |
Meteoro | o dino volta para a casa inicial -20 pontos |
Instruções de como baixar e executar o jogo podem ser encontradas aqui .
Primeiro, deve-se preencher os nomes desejados para os players. Depois, cada Dino deve clicar em uma seta na sua vez de jogar, lembrando nos objetivos e regras do jogo. A ordem da rodada dos dinos por cor é: Vermelho, Marrom, Amarelo e Verde.
Uma janela mostrará o vencedor no final do jogo.
Giovanna Gennari Jungklaus
-198010
Isabella Garcia Fagioli
-173174
Em um primeiro momento, as jogadas de cada usuário foram tratadas a partir de chars
lidos pelo terminal, pois não sabíamos como trabalhar com Event Listeners
em JButtons
distribuídos em um GridLayout
.
Aqui mostra como tratamos uma jogada de exemplo:
//receive move solicitation
String str = keyboard.nextLine();
char command = str.charAt(0);
int destinyX = 0, destinyY = 0;
//up
if (command == '8') {
destinyX = dinos[i].getI() + 1;
destinyY = dinos[i].getJ();
}
No entanto, estudamos como adicionar Event Listeners
aos JButtons
. Como no código:
graphicInterface.getMenuBar().buttonUp.addActionListener(actionEvent -> {
command = 8;
click++;
});
Isso feito dentro do Controle do Jogo
e não no construtor da JToolbar
, pois era preciso
contabilizar a quantidade de cliques e saber quando um botão era clicado para executar
o movimento do jogador da vez. O movimento foi executado como mostra o código:
//up
if (command == 8) {
destinyX = dinos[i].getI() - 1;
destinyY = dinos[i].getJ();
}
Imagem dos JButtons
como o jogador seguinte:
Notamos que quando um jogador morria no jogo, era necessário aumentar a variável de int que
contabiliza os Clicks
, mesmo sem haver um novo evento.
Ao executar o jogo algumas vezes, notamos percebemos detalhes que tornariam a experiência do usuário mais agradável e intuitiva no jogo. Assim, adicionamos os seguintes à interface gráfica:
Janelas PopUp
Informar ao usuário qual surpresa foi sorteada através de pop up windows ao invés de apenas incrementar a pontuação no painel.
if (s instanceof Meteor){
message1 = new JLabel("A meteor was about to strike you.");
message2 = new JLabel("Go back to the start. (-20)");
icon = new JLabel(new ImageIcon(filePath.toString() + "/meteor.png"));
}
Dino na mesma célula do Ovo
Mostrar quando o dino está na casa do seu ovo e deve chocá-lo, assim como mostrar nas suas infos se ele já o possui;
Mostrar player seguinte abaixo dos botões de movimentação
Mostrar na interface qual o próximo player a jogar.
Usamos hierarquia para reconhecer surpresa, atualizar pontuação e mostrar surpresa na popup window
Na interface ISurprise
há o seguinte método:
public int pointsToAdd();
O uso de hieraquia facilita a incremetação dos pontos de cada jogador, pois essa função é sobrescrita por aquelas que extendem a Surprise
, como Meteor
, Food
Rocke
StarPowerUp`, evitando uma verificação com ifs ou instâncias.
<Destaque de patterns adotados pela equipe. Sugestão de estrutura:>
<Diagrama do pattern dentro do contexto da aplicação.>
Este é o diagrama compondo componentes para análise:
Este é um diagrama inicial do projeto de jogos:
Este é outro diagrama de um projeto de vendas:
<Explicação de como o pattern foi adotado e quais suas vantagens, referenciando o diagrama.>
Concluímos que uma boa interface gráfica é de suma importância para um jogo e entender sobre GUI foi importante para contruí-la. Além disso, trabalhar com eventos também não é uma tarefa fácil, mas esta é uma ótima ferramenta para obter inputs do jogador. O trabalho em grupo foi a chave para conseguirmos entender esses conceitos e aplicá-los. Por fim, se tivessemos mais tempo implementariamos um Bot para que o jogo pudesse ser jogado em menos de 4 pessoas. Além disso, também aumentariamos o encapsulamento do jogo, evitando fazer verificações diretas sobre as células em classes fora do tabuleiro. De modo geral, ficamos muito contentes com o resultado, mas ainda faríamos essas melhorias.>
Este é um diagrama UML gerado pelo IntellJ. As caixas com um C em verde indicam as classes utilizadas e as com um I em azul indicam as interfaces para fazer a comunicação entre classes. Tentamos adotar um modelo Model-View-Control.
A classe AppDinoWorld
instancia um Control
, que por sua vez instancia
um Builder
, responsável pela criação do modelo de tabuleiro
adotado no jogo, e uma GraphicInterface
, que apresenta o tabuleiro e
suas atualizações a pedido do controle.
Para cada componente será apresentado um documento conforme o modelo a seguir:
O
ControlP
é onde ocorre toda a base do jogo. Nele, chamamos obuilder
para contruirmos nosso tabuleiro e atores, rodamos todo o príncipio de lógica do jogo e chamamos a interface gráfica a cada atualização
Ficha Técnica
item | detalhamento |
---|---|
Classe | ControlP.Control ControlP.TextFieldEvent |
Autores | Isabella Fagioli e Giovanna Gennari |
Interfaces | IControl |
Interfaces associadas a esse componente:
Interface agregadora do componente em Java:
public interface IDataSet extends ITableProducer, IDataSetProperties {
}
Board
é onde o jogo acontece. É o espaço celular onde ocorrem as movimentações.
Ficha Técnica
item | detalhamento |
---|---|
Classe | Board.Board |
Autores | Isabella Fagioli e Giovanna Gennari |
Interfaces | Board.IBoard |
Interfaces associadas a esse componente:
Interface agregadora do componente em Java:
public interface IDataSet extends ITableProducer, IDataSetProperties {
}
Cada célula do jogo possui indicações do que há dentro. Se há um dino, uma lava,
Cell
é quem controla isso
Ficha Técnica
item | detalhamento |
---|---|
Classe | Cell.Cell Cell.Surprise Cell.Volcano Cell.Food Cell.Meteor Cell.StarPowerUp Cell.Rock |
Autores | Isabella Fagioli e Giovanna Gennari |
Interfaces | ICell, ISurprise, IVolcano |
Interfaces associadas a esse componente:
Interface agregadora do componente em Java:
public interface IDataSet extends ITableProducer, IDataSetProperties {
}
Nossos atores são os dinos. Eles têm controle sobre as posições de chegada e de ovo, e são responsáveis por guardarem seus estados, se estão vivos, sua pontução, se possuem PowerUp, etc.
Ficha Técnica
item | detalhamento |
---|---|
Classe | Actor.Actor |
Autores | Isabella Fagioli e Giovanna Gennari |
Interfaces | Actor.IActor |
Interfaces associadas a esse componente:
Interface agregadora do componente em Java:
public interface IDataSet extends ITableProducer, IDataSetProperties {
}
Builder
é o que constrói o nosso jogo. Ele define as localizações iniciais de tudo no tabuleiro e os estados de jogo e dos dinos no começo
Ficha Técnica
item | detalhamento |
---|---|
Classe | Builder.Builder |
Autores | Isabella Fagioli e Giovanna Gennari |
Interfaces | Builder.IBuilder |
Interfaces associadas a esse componente:
Interface agregadora do componente em Java:
public interface IDataSet extends ITableProducer, IDataSetProperties {
}
<
BoardView é responsável pela nossa interface gráfica, por mostrar o tabuleiro com imagens e atualizar sua representação a cada modificação
>
Ficha Técnica
item | detalhamento |
---|---|
Classe | BoardView.BoardView BoardView.DinoInfo BoardView.GraphicInterface BoardView.MenuBar |
Autores | Isabella Fagioli e Giovanna Gennari |
Interfaces | IGraphicInterface |
Interfaces associadas a esse componente:
Interface agregadora do componente em Java:
public interface IDataSet extends ITableProducer, IDataSetProperties {
}
Getters e Setters foram omitidos nas tabelas descrevendo os métodos das interfaces, mas foram implementados para todos os atributos de suas respectivas classes quando necessário.
Interface com as funções do Control além de conectar as classe deste componente com os outros
public interface IControl {
public void executeGame(String[] names);
public void connect(IBoard board);
public void connect(int idx, IActor actor);
public void connect(int idx, IVolcano v);
public boolean atLeastOneAlive();
public IGraphicInterface getGraphicInterface( );
public IActor[] getDinos();
}
Método | Objetivo |
---|---|
public void executeGame(String[] names) |
Pega os nomes dos dinos e executa o jogo com os dinos |
public void connect(IBoard board) |
Conecta ao tabuleiro |
public void connect(int idx, IActor actor) |
Coloca ator pego no Board |
em um IActor[] |
|
public boolean atLeastOneAlive() |
Verifica se tem pelo menos um dino vivo |
Contém os métodos responsáveis pelas ações do tabuleiro e pelas suas cinexões com outros componentes
public interface IBoard {
public void move(IActor dino, int destinyX, int destinyY);
public boolean validatesMove(int destinyX, int destinyY);
public void insertLavas(IVolcano[] volcanoes);
public boolean captureEgg(IActor dino);
public void updateBoard(boolean capturedEgg, boolean surpriseUsed, int destinyX, int destinyY);
public void connect(char character, boolean value, int i, int j);
public void connect(IActor actor, int i, int j);
public void connect(ISurprise surprise, int i, int j);
public void connect(IVolcano volcano, int i, int j);
public ICell[][] getCellsSpace();
public boolean verifySurprise(int destinyX, int destinyY);
}
Método | Objetivo |
---|---|
public void move(IActor dino, int destinyX, int destinyY) |
Faz movimentação do ator, verificando se a posição de destino contém surpresa ou lava para executar suas implicações |
public boolean validatesMove(int destinyX, int destinyY) |
Garante que a movimentação está dentro dos limites tabuleiro e não avança para uma casa inválida, como Volcano ou Meteor |
public void insertLavas(IVolcano[] volcanoes) |
Insere uma lava, conforme a posição sugerida pelao método nextLava() do IVolcano , para cada vulcão no tabuleiro no final de cada rodada |
public boolean captureEgg(IActor dino) |
Verifica se o ator capturou o ovo e remove-o do tabuleiro |
public void updateBoard(boolean capturedEgg, boolean surpriseUsed, int destinyX, int destny) |
Atualiza tabuleiro removendo surpresas abertas e ovos capturados |
public void connect(char character, boolean value, int i, int j) |
Atualiza booleanos para conter ovo e forte em uma posição do tabuleiro |
public void connect(IActor actor, int i, int j) |
Conecta actor em sua respectiva posição do tableiro |
public void connect(ISurprise surprise, int i, int j) |
Conecta surpresa em sua respectiva posição do tableiro |
public void connect(IVolcano volcano, int i, int j) |
Conecta vulcão em sua respectiva posição do tableiro |
public ICell[][] getCellsSpace() |
Retorna a matriz de células do tabuleiro para verificações fora da classe |
public boolean verifySurprise(int destinyX, int destinyY) |
Verifica qual é o tipo da surpresa aberta pelo ator |
Contém todos os métodos relacionados a cada célula do tabuleiro
public interface ICell {
public boolean getHasEgg();
public boolean getHasLava();
public boolean getHasMeteor();
public boolean getHasFort();
public void setHasEgg(boolean value);
public void setHasLava(boolean value);
public void setHasMeteor(boolean value);
public void setHasFort(boolean value);
public ISurprise getSurprise();
public void setSurprise(ISurprise surprise);
public IActor getDino();
public void setDino(IActor dino);
public IVolcano getVolcano();
public void setVolcano(IVolcano v);
public void connectSurprise(ISurprise value);
public void connectVolcano(IVolcano value);
}
Método | Objetivo |
---|---|
public void connectSurprise(ISurprise value) |
Conecta surpresa em uma célula a pedido do tabuleiro |
public void connectVolcano(IVolcano value) |
Conecta vulcão em uma célula a pedido do tabuleiro |
Contém os métodos das surpresas
public interface ISurprise {
public int pointsToAdd();
public int getValue();
public void connect(ISurprise surprise);
}
Método | Objetivo |
---|---|
public int pointsToAdd() |
Adiciona os pontos da surpresa tirada |
public int getValue() |
Pega o valor da surpresa tirada |
public void connect(ISurprise surprise) |
Conecta a surpresa |
Contém os métodos relacionados às ações dos vulcões, como a adição de lavas a cada rodada
public interface IVolcano {
public int[] nextLava(Board b);
public void connect(IBoard board);
}
Método | Objetivo |
---|---|
public int[] nextLava(Board b) |
Sorteia a posição onde a próxima lava deve ser colocada |
public void connect(IBoard board) |
Conecta o tabuleiro |
Referente aos dinos, suas ações e conexões com os demais componentes
public interface IActor {
public void setI(int value);
public void setJ(int value);
public int getI();
public int getJ();
public void setEggPos();
public void setFortPos();
public int getEggX();
public int getEggY();
public int getFortX();
public int getFortY();
public int getScore();
public boolean getHasEgg();
public boolean getIsAlive(IBoard b);
public boolean getStarPowerUpOn();
public boolean getHasWon();
public String getName();
public void setHasEgg(boolean value);
public void setIsAlive(boolean value);
public void setStarPowerUpOn(boolean value);
public void setHasWon(boolean value);
public void updateScore(int value);
public void setName(String name);
public void setInitialI(int initialI);
public void setInitialJ(int initialJ);
public int getInitialI();
public int getInitialJ();
public boolean isSurrounded(int x, int y, IBoard board);
}
Método | Objetivo |
---|---|
public void updateScore(int value) |
Atualiza a pontuação do jogador |
public boolean isSurrounded(int x, int y, IBoard board) |
Verifica se a posição está cercada por lava |
Realiza as ações de construir o tabuleiro jogo com seus respectibos elementos
public interface IBuilder {
public void newBoard(IControl control);
}
Método | Objetivo |
---|---|
public void newBoard(IControl control) |
Cria o tabuleiro e tudo dentro dele, incluindo os dinos |
Referente à interface gráfica do jogo
public interface IGraphicInterface {
public void connect(IBoard b);
public void connect(IActor[] dinos);
public JFrame getF();
public void printGame();
public MenuBar getMenuBar();
public void setMenuBar(MenuBar menuBar);
public BoardView getBoardView();
public void updateBoardView( int next);
}
Método | Objetivo |
---|---|
public void connect(IBoard b) |
Conecta o tabuleiro |
public void connect(IActor[] dinos) |
Conecta os atores |
public void printGame() |
Mostra o jogo na tela com todas as imagens |
public void updateBoardView(int next) |
Mostra o estado atual do jogo |
As exceções foram tratadas dentro das verificações internas na lógica de execução do jogo.