Post on 16-Dec-2018
Universidade Tecnológica Federal do Paraná Disciplina: IF62C - Fundamentos de Programação 2 Professores: Robinson Vida Noronha
WAR Equipe de desenvolvimento
Everton Plotchkacz Herica Batista
Sumário Introdução ..................................................................................................................................... 2
Dados técnicos do jogo ................................................................................................................. 2
Dinâmica do Jogo .......................................................................................................................... 3
As cartas .................................................................................................................................... 3
O jogo ........................................................................................................................................ 3
Adaptação do jogo para o ambiente computacional .................................................................... 7
Disposição dos jogadores e sua representação no ambiente computacional .............................. 7
Modelo computacional ................................................................................................................. 7
Pacotes ...................................................................................................................................... 7
Classes ....................................................................................................................................... 8
Pacote Baralho comum ......................................................................................................... 9
Pacote War ............................................................................................................................ 9
Pacote Controle ................................................................................................................... 11
Pacote Gráfico ..................................................................................................................... 11
Pacote javax.swing .............................................................................................................. 11
Pacote java.awt.event ......................................................................................................... 12
Análise orientada a objetos do diagrama de classes .................................................................. 12
Diagrama de classes .................................................................................................................... 14
Introdução
War é a versão de cartas do famoso jogo de tabuleiro de mesmo nome. Através
de uma estratégia, cada jogador tenta cumprir seu objetivo conquistando territórios
que pertencem a outros jogadores, utilizando suas cartas de dados e cartas especiais.
A figura a seguir mostra os vários conjuntos de cartas disponíveis:
Dados técnicos do jogo
Propriedade Valor
Quantidade de participantes 3 a 4
Objetivo Conquistar os territórios definidos nas cartas objetivo antes dos demais jogadores
Quantidade de cartas 8 cartas objetivo 16 cartas especiais 36 cartas território 49 cartas de dados 1 carta general
Vencedor Vence quem cumprir o objetivo primeiro
Dinâmica do Jogo
As cartas
Cada jogador recebe uma carta-objetivo, por sorteio. Esse objetivo deverá ser
mantido em segredo até o final do jogo. Em cada carta há dois objetivos, de acordo
com o número de jogadores (3 ou 4). As cartas território devem ser embaralhadas e
distribuídas igualmente entre os jogadores. Elas devem ficar abertas e com as faces
viradas para cima, na frente de cada jogador.
As cartas especiais devem ser embaralhadas e colocadas de lado, formando um
monte, com a face virada para baixo. Elas serão conquistadas no decorrer do jogo.
Cada carta tem uma função diferente, descrita na própria carta.
As cartas de dados são usadas para ataque e defesa. Essas cartas são recebidas
conforme a quantidade de cartas território que cada jogador possui. Os dados
vermelhos de cada carta são usados para ataque, e os dados amarelos para defesa.
A carta general serve para indicar qual jogador dará início à rodada. Ela passará
de um jogador para outro a cada rodada, seguindo sempre no sentido horário. Uma
rodada termina depois que todos os jogadores tiveram sua vez de jogar. Assim, quem
iniciou uma rodada será o último a jogar na rodada seguinte.
O jogo
Por sorteio, escolhe-se o jogador que iniciará a primeira rodada. Ele ficará com
a carta general. No início de cada rodada os jogadores somam o número de cartas
território que possuem e dividem por 2. O resultado será o número de cartas de dados
que cada jogador deverá receber. Isto é feito no início de cada rodada - a quantidade
mínima de cartas de dados recebida é 3.
O ataque poderá ser feito a qualquer território, desde que você possua outro
território no mesmo continente ou possua uma carta território que faça fronteira com
o território a ser atacado.
O atacante deve anunciar de que território vai partir o ataque e qual território será
atacado. O jogador escolhe uma carta (de dados ou especial) e a deixa com a face
virada para baixo. O jogador que possui o território atacado deve defendê-lo, usando
para tal uma das cartas em sua mão ou virar uma carta do monte de compras. A carta
de defesa deve ser colocada sobre a carta de ataque, de cabeça pra baixo, de forma
que a coluna com os dados de ataque fique ao lado da coluna com os dados de defesa.
Na sua vez de jogar, o jogador pode atacar quantas vezes quiser para
conquistar um território adversário, desde que tenha cartas para isso. A cada ataque
deve haver uma confrontação de cartas.
A comparação de dados é feita do maior número para o menor. Compara-se o
dado com mais pontos do atacante com o de mais pontos do defensor. A vitória será
de quem tiver mais pontos. No caso de empate, a vitória será da defesa. Em seguida
compara-se o segundo e o terceiro dado com mais pontos. A comparação é feita da
seguinte forma:
Comparação Ataque Defesa Vitória
Maior 6 4 Ataque
Segundo maior 6 3 Ataque
Menor 3 3 Defesa
Neste caso o ataque vence a batalha, por ter 2 vitórias contra 1 da defesa. Ao
final de cada batalha, todas as cartas utilizadas são descartadas.
Quando o ataque vence, o jogador fica com a carta território do defensor. Se
perder, nada acontece e poderão ser feitos outros ataques.
Após efetuar os ataques, o jogador passa a vez para quem está à sua esquerda,
que decide se deseja ou não atacar, e passa a vez. Quando o último jogador da rodada
terminar seus ataques, a rodada é finalizada, e a carta general passa para o próximo
jogador.
Para iniciar uma próxima rodada, são necessários alguns procedimentos: os
jogadores que conquistaram pelo menos uma carta território recebem uma carta
especial (independente do número de territórios conquistados). Quem possuir um
continente inteiro recebe cartas especiais extras conforme a tabela:
Continente Cartas especiais
América do Norte 2
América do Sul 1
Europa 2
África 2
Ásia 3
Oceania 1
Se acaso acontecer de um jogador tomar a última carta território de outro,
aquele ficará também com as cartas especiais e de dados que este possuir, se não
ultrapassar o limite de cartas.
O jogo termina quando um jogador atinge seu objetivo, virando a carta objetivo
para comprovar sua vitória.
O jogo segue a dinâmica do seguinte diagrama:
Adaptação do jogo para o ambiente computacional
A adaptação a ser realizada será a escolha de um mecanismo que gere várias
combinações de dados ao invés de copiar as combinações de dados existentes nas cartas do
jogo.
Disposição dos jogadores e sua representação no ambiente
computacional
Os jogadores devem ser dispostos de maneira que um não veja as cartas de
dados do outro.
Exemplo para 3 jogadores:
O General é indicado pela carta General, de onde partiu o primeiro jogador da
rodada. O jogo segue quando o general passa a sua vez ao jogador à sua esquerda
(sempre no sentido horário).
Modelo computacional
Pacotes
Para obter uma melhor clareza e identificação das funções e objetivos de cada
integrante do projeto, dividimos o mesmo até o momento em 6 pacotes, sendo eles:
a) BaralhoComum: Conjunto de classes genéricas para um modelo de baralho,
possui informações das propriedades de uma carta, diferenciar uma carta de
outra, distribuir e agrupar cartas, podendo então ser aplicado a qualquer tipo
de jogo.
b) War: Conjunto de classes específicas que definem o formato do jogo, onde
cada classe é responsável por executar uma das regras que regem o jogo.
c) Controle: as classes contidas nesse pacote são responsáveis pelo
gerenciamento do jogo, ou seja, ela define quem são os jogadores, controla a
pontuação, controla o inicio e o fim de uma rodada e de uma partida.
d) Gráficos: Responsável por gerenciar as interfaces gráficas contidas na tela,
como por exemplo, mensagens em caixas de texto, movimentação de figuras
na tela.
e) Javax.swing: pacote onde encontram-se todas as classes, interfaces para o
controle de animações e ações do jogador com a interface gráfica.
f) Java.awt.event: pacote onde encontram-se todas as classes e interfaces
utilizadas no controle de hardware (mouse, teclado etc) e gerenciamento de
tarefas de software, como iniciar e encerras aplicações.
Classes
As seguintes classes foram criadas para representar o jogo War, essas estão
agrupadas em pacotes para melhor organização e separação de funções, vamos
demonstrar cada uma delas de acordo com seu pacote.
Pacote Baralho comum
Propriedades: responsável por armazenar as informações que uma carta pode conter,
como por exemplo, a cor, valor, imagem entre outras. O nome de cada propriedade é
armazenado em um Array do tipo string, cada propriedade deve possuir um valor que
será armazenado na mesma posição, porém em um Array do tipo int e por último
podemos ter ou não uma imagem associada a esse parâmetro e valor, sua a localização
será armazenada em um Array do tipo string. As funções dessa classe são responsáveis
por retornar, criar, alterar e apagar qualquer uma dessas informações.
Carta: a classe carta possui uma variável chamada id, esta por sua vez é única e tem a
função de selecionar as propriedades corretas da carta em questão. Tendo as
propriedades selecionadas corretamente de acordo com seu id a classe é capaz de
realizar comparações com qualquer outra carta, dessa forma ela nos informa se a
propriedade da carta é maior, menor ou igual à outra da outra carta, cada função
retorna um valor verdadeiro ou falso.
Baralho: sua função é agrupar todas as cartas de mesmo tipo para formar um monte e
então gerencia-las, ou seja, a classe pode informar a quantidade de cartas no monte,
embaralhar as mesmas e distribuir para os jogadores conforme as regras do jogo. As
funções dessa classe podem retirar inserir ou verificar o valor de uma carta que está
no topo, no meio, no fundo ou em qualquer outra posição especifica.
Pacote War
Objetivo: informa ao jogador qual deve ser o continente a ser conquistado para que o
mesmo seja o vencedor da partida, também é capaz de informar ao jogador se seu
objetivo foi ou não completado com sucesso.
Território: é uma carta que representa um país a ser ou não conquistado por um de
seus adversários de acordo com o seu objetivo. Ele pode indicar ao jogador se pode ser
atacado e se foi escolhido para uma batalha, também pode informar seu nome, o
nome de seus países localizados no mesmo continente e se faz ou não fronteira com
países de outros continentes para que estes possam ser atacados caso o jogador não
possua um território pertencente a aquele continente.
Continente: representa um conjunto de cartas territórios que fazem parte dele. Pode
nos informar quanto países e quais fazem parte dele e assim descobrir se o continente
está ou não completo de acordo com seus objetivos de jogo.
Dado: é uma carta utilizada durante as batalhas para efetuar ataques e defesas. Cada
carta contém 3 valores aleatórios de um dado para o modo de ataque e da mesma
forma a carta possui valores aleatórios utilizados para defesas. Pode indicar se foi
escolhido e para o que foi escolhida se para ataque ou defesa, também indica o
número de vitorias de ataque, defesa e empates, em caso de empate é computado
como vitória da defesa.
Especial: é uma carta que possui várias funções específicas, totalizando 16 métodos
que podem anular ataques, vencer batalhas independentemente da defesa, recuperar
cartas especiais descartadas entre outras, esses métodos são criados através de uma
enumeração.
Deck: conjunto de cartas territórios, dados, especiais e objetivo. Assemelha-se ao
baralho, porém fica em posse do jogador, podendo indicar a quantidade exata de
territórios, dados e especiais que estão com o jogador, estas informações são
necessárias para verificações de quantidade de cartas na mão do jogador, se o jogador
possuir um total de 15 cartas entre dados e especiais o mesmo não pode mais receber
cartas em uma nova rodada, caso possua um valor inferior ele poderá receber mais
cartas, sendo que a soma não poderá exceder esse valor.
General: utilizado para indicar o jogador que irá iniciar a rodada, após todos os
jogadores efetuarem ou não ataques e o próximo jogador for novamente o que está
em posse da carta general a presente rodada é finalizada, então a carta general é
passada para o jogador à sua esquerda, indicando o início de uma nova rodada.
Atacante: essa classe é utilizada para indicar se o jogador vai ou não atacar outro
jogador, caso resolva atacar ela é capaz de selecionar o território de onde parte o
ataque e qual será seu alvo, também seleciona o dado para ataque ou uma carta
especial caso possua em seu deck. Caso o jogador resolva não atacar um de seus
adversários os métodos não serão executados, então a vez de atacar ou não passa
para o jogador à sua esquerda.
Defensor: é utilizada apenas pelo jogador que está sendo atacado no momento e suas
funções são as mesmas do atacante. Ela somente irá existir se o jogador opinar por
atacar algum território, caso contrário os métodos não serão executados.
Batalha: responsável por processar as informações do atacante e defensor, é nela que
as comparações serão executadas e pontuações computadas, ela somente irá existir se
o jogador opinar por atacar algum território, caso contrário os métodos não serão
executados.
Pacote Controle
Estatística: calcula o desempenho de cada jogador levando em consideração a
pontuação por rodadas e número de partidas que o jogador participou, podendo
armazenar um vetor com o nome das propriedades e seus devidos valores.
Jogador: armazena o código e nome de cada jogador da partida, também indica
quantas partidas e rodadas foram disputadas bem como a sua pontuação atual para
serem utilizadas nas estatísticas do mesmo.
Rodada: controla o inicio e fim de cada rodada, nesse caso, uma rodada é finalizada
quando o jogador da vez possui a carta general em mãos, cada jogador pode efetuar
várias batalhas na mesma rodada desde que seja sua vez de jogar e possua cartas de
dados ou especiais em seu deck.
Partida: controla o inicio e o fim de uma partida, que por sua vez pode conter várias
rodadas até que um dos jogadores possa completar seu objetivo. Ao inicio de cada
rodada a classe partida é responsável por fazer a redistribuição de cartas conforme as
regras do jogo. Quando um jogador completar seu objetivo a partida então é finalizada
e definido o campeão.
Mouse: executa o gerenciamento do mouse, ou seja, identifica a posição do cursor na
tela, verifica se um botão do mouse foi pressionado, verifica se o scroll foi acionado
entre outros.
Teclado: executa o gerenciamento do teclado, ou seja, identifica e retorna o valor de
uma tecla quando pressionada.
Pacote Gráfico
Imagem: contém funções para o controle das imagens exibidas na tela.
Janela: gerencia a criação e o espaço onde as imagens e textos serão exibidos para os
jogadores.
Mensagem: utilizado para enviar e receber mensagens de ajuda ou mensagens de
chats entre jogadores.
Coordenada: controla e armazena o posicionamento das imagens, ícones entre outros
itens que serão exibidos na tela para o jogador.
Pacote javax.swing
ImageIcon: gerencia a localização, abertura e fechamento dos arquivos de imagens
que serão exibidos na tela.
jFrame: configura espaço para que as imagens sejam exibidas.
jPanel: cria o espaço para exibição das imagens.
JTextArea: cria uma caixa de texto para exibição na janela.
Pacote java.awt.event
MouseEvent: lista de eventos e funções que devem ser implementadas na classe
mouse para que seja possível identificar as ações feitas por ele.
KeyListener: lista de eventos e funções que devem ser implementadas na classe
teclado para que seja possível identificar quais teclas foram pressionadas.
KeyEvent: lista de eventos e funções que devem ser implementadas para definir
quando uma janela ou aplicação deve ser encerrada, inicializada, minimizada etc.
Análise orientada a objetos do diagrama de classes
1) Existe Herança entre as classes? Se sim, apresente-as. Sim, as classes: Dado, Especial, Território e Objetivo herdam as funções da classe Carta. Da mesma forma as classes: Atacante e Defensor herdam as funções da classe Jogador.
2) Vislumbra-se a possibilidade do uso de polimorfismo? Explique. Sim, na classe Carta, os métodos de comparações ehMaior(), ehMenor(), ehIgual(), recebem como argumentos uma referencia à classe carta, porém a classe Dado é um tipo de Carta, logo podemos passar para a comparação qualquer objeto que seja instanciado pelas classes: Especial, Dado, Território e Objetivo. Da mesma forma há polimorfismo na classe Jogador pois a classe Atacante é um tipo de Jogador assim como o Defensor.
3) Quais os tipos de relacionamentos foram empregados? Foram empregados: Associação entre classes (Classe Continente); Associação com multiplicidade (Classe Território); Associação de dependência (Classe Propriedade); Agregação (Classe Deck); Composição (Classe Baralho); Generalização (Classe Atacante, Defensor etc.);
4) Existe alguma classe Associativa? Se sim, quais e quais são os detalhes da associação que ela representa? A classe Continente é associada à Território, isso se faz necessário para sabermos quais países fazem parte de um continente, dessa forma, podemos verificar se o continente está ou não completo no deck do jogador e se seus objetivos foram completados com sucesso.
5) Existe, no diagrama de classes, alguma definição que conduza o programador a escolher alguma linguagem de programação específica? Não, da forma com que foi construído, o programador pode implementar o jogo em qualquer linguagem, a dificuldade da implementação é definida pela particularidade de cada linguagem.
6) Existe a definição de Enumerações? Sim, a classe Especial utiliza uma enumeração chamada TipoDeEspecial. Optou-
se por utilizar a enumeração, pois cada especial executa uma função
totalmente diferente dos outros especiais, dessa forma os métodos referente a
cada especial são executados de acordo com seu tipo.
7) Foi definido algum atributo estático? Se sim, justifique.
A classe Carta e Jogador possuem atributos do tipo int estáticos, isso nos dá a possibilidade de incrementar sequencialmente um código que irá diferenciar uma carta da outra e um jogador do outro sem que o mesmo possa ser reescrito acidentalmente, ou seja, atribuir o mesmo código a dois jogadores diferentes. Além disso no pacote War a maioria das classes utiliza um atributo do tipo string static final que tem a função de diferenciar as classes quando forem comparadas, esses atributos não podem ser modificados, o que nos permite interromper uma execução se o jogador escolher uma carta de Dado e outra Objetivo para uma batalha, nesse caso a comparação dos tipos de carta irá nos retornar um valor informando que a batalha não poderá ser executada.
8) Existe alguma classe abstrata ou que contenha pelo menos um método abstrato? Se sim, justifique o uso da abstração. Não foram utilizadas classes abstratas.