Ir ao conteúdo
  • Cadastre-se
Abigail6969

Trabalho da Faculdade - Preciso De Ajuda [Java básico - BlueJ]

Recommended Posts

1. Objetivo do Trabalho
Desenvolver um programa em Java que permita que duas pessoas joguem o Pif Paf -SM. 
2. O Jogo
• Meta: O jogo de baralho Pif Paf, versão SM, exige 2 baralhos, sem corigas. O jogo é 
disputado entre dois jogadores. Inicialmente, cada jogador recebe uma mão com 12 
cartas. O objetivo do jogo, como no Pif Paf tradicional, é bater. Para bater o jogador 
pode combinar suas cartas para formar trincas, quadras e sequências:
• trincas: 3 cartas de números iguais, mas naipes diferentes. Exemplo: [3C, 3P, 3E]
• quadras: 4 cartas de números iguais, mas naipes diferentes. Exemplo: [5C, 5P, 
5E, 5O]
• sequências: podem em ser 4, 5, 6, 7 e 8 cartas cujos valores formam uma 
sequência. As sequências podem ser de mesmo naipe (Exemplo: [2C, 3C, 4C, 
5C]) ou de naipes diferentes. No caso de naipes diferentes, deve haver uma 
alternância entre entre naipes vermelhos (ouro e copa) com naipes pretos (espada 
e paus). Exemplo: [5E,6C,7P,8C,9E].
Em geral, para bater, o jogador deve usar todas as cartas da sua mão, ou seja, ele deve 
formar trincas ou quadras ou sequências usando as suas 12 cartas. No entanto, quando 
um jogador formar uma sequência de 8 cartas, poderá bater, ainda que as 4 cartas 
restantes não formem outras combinações.
• Inicio: O jogo exige o uso de 2 baralhos. Chamaremos esses dois baralhos de mesa. O 
jogo inicia com o embaralhamento das cartas da mesa. A seguir, o programa deve 
solicitar os nomes dos dois jogadores: jogador1 e jogador2. Em seguida, são 
distribuídas 12 cartas da mesa para cada jogador, de forma alternada (a primeira carta da 
mesa vai para o jogador1; a segunda vai para o jogador2; a terceira para o jogador1 e 
assim sucessivamente. 
• Funcionamento: Cada jogador pode comprar uma carta da mesa ou do lixo. No inicio 
do jogo ainda não há lixo, portanto só será possível comprar da mesa (a mesa sempre 
fornece a carta que está no topo). Se o jogador optar por ficar com a carta comprada, 
deverá colocá-la em sua mão e descartar outra de suas cartas. Caso não queira a carta 
comprada da mesa, basta descartá-la. As cartas descartadas formam o lixo. Os jogadores 
só conseguem ver a última carta posta no lixo. Na existência de lixo, o jogador pode 
optar por comprar do lixo e não da mesa (cada jogador só pode comprar uma vez em seu 
turno: ou da mesa ou do lixo). Se optar por comprar do lixo, só poderá buscar a carta que 
está visível (a última carta posta fora). Da mesma forma, deve colocar a carta na sua 
mão e descartar outra de suas cartas no lixo. Cabe mencionar, que um jogador não pode 
bater sem comprar uma carta, seja da mesa ou do lixo. Se as cartas das mesa acabarem e a carta do lixo não for útil ao jogador atual, não haverá vencedor.
• Turnos: O jogo se desenrola em turnos, ora do jogador1, ora do jogador2. O programa
sorteia de forma aleatória quem irá começar. No turno do jogador1, as cartas do 
jogador2 ficam fechadas . Da mesma forma, no turno do jogador2, as cartas do 
jogador1 ficam igualmente fechadas. No seu turno, o jogador pode comprar (da mesa ou 
do lixo) , organizar as suas cartas e bater. A operação de organizar permite que o jogador 
ordene suas cartas por número ou por naipe, ou ainda simplesmente troque duas cartas 
de posição (lugar) em sua mão. Um jogador só poderá bater, se o programa confirmar 
que ele de fato pode fazer isso, ou seja, o programa deve ser capaz de verificar se o 
jogador possui as combinações (trincas, quadras e sequências) válidas e que satisfazem a 
ação de “bater”. Se for confirmado que o jogador tem condições de bater, as cartas desse 
jogador serão abertas e ele será declarado como vencedor. 
Exemplo de cartas abertas: [3C, 3C, 3P, 3E, 2P, 3P, 4P, 5P, 2E, 4O, 9E, 1C]
Exemplo de cartas fechadas: [*, *,*, *, *, *, *, *, *, *, *, *]
3. Modelagem
Modele o conjunto necessário de classes para esse jogo. Abaixo, estão algumas classes que 
serão necessárias na sua implementação. Use ArrayList e repetição sempre que possível.
• Classe Carta: deve conter o valor e o naipe de cada carta. Use C para copas, E para 
espadas, O para ouro e P para paus. Será necessário implementar os métodos básicos: 
construtor, modificadores e de acesso. No caso do toString, substitua o 1 (ás) por A, o 11 
por J, o 12 por Q e o 13 por K ao gerar o estado do objeto carta. 
• Classe MãoDoJogar: mantêm até 13 cartas (foi considerado espaço também para a 
carta que será comprada) e o nome do jogador. Inicialmente, a mão de cada jogador 
inicia vazia. A classe deve possuir métodos para inserir uma carta na mão do jogador e 
para descartar uma de suas cartas. Deve possuir também métodos para ordenar suas 
cartas por número, por naipe e ainda um método que permite trocar suas cartas de 
posição. É necessário ainda métodos que verifiquem se na mão do jogador há trincas, 
quadras e sequências. O toString deve ser capaz de exibir as cartas da mão do jogador 
fechadas ou abertas.
• Classe Mesa: o construtor dessa classe deve gerar os dois baralhos e disparar o método 
que as embalhara. Esta classe deve possuir um método que busca a carta do topo.
• Classe Lixo: inicia vazio, mas vai mantendo as cartas descartadas (jogadas fora). Deve 
conter métodos que colocam e retiram uma carta do topo. 
• Classe Aplicação: deve conter a interface do jogo, permitindo que cada jogador jogue 
em seu turno da forma como foi descrito anteriormente. Deve conter um menu principal 
na qual o jogo inicia e que é reapresentado ao final de um jogo. Esse menu deve conter 
pelo menos duas opções (1-iniciar, 0-Sair). A opção Iniciar permite o (re)inicio do jogo 
(as 104 cartas da mesa são geradas e embaralhadas; as mãos dos jogadores e o lixo 
iniciam vazios e as cartas são distribuídas aos jogadores), passando a vez para o jogador 
que foi sorteado como o primeiro a jogar. Deve conter ainda um menu com as operações que os jogadores podem realizar em cada turno (comprar da mesa, comprar do lixo, 
descartar, organizar cartas por número, organizar cartas por naipe, trocar de posição duas 
cartas, bater, …). Em cada turno, exiba na tela o nome do jogador que começará a jogar.
Durante o jogo, o programa deve exibir o nome do jogador atual, as cartas do oponente 
fechadas, as cartas do jogador atual abertas, a carta do topo do lixo aberta e a mesa 
sempre fechada. A carta do tipo da mesa somente se tornará visivel quando o usuário 
decidir comprá-la.


Vou mandar junto uma parte que já fiz, porém estou com dificuldades em terminar.
Se puder explicar como o código foi feito, agradeço muito, pois precisarei explicar para a professora também.
http://www.upload.ee...ttempt.zip.html (o que consegui fazer até agora. obs: está como projeto do blueJ)

Compartilhar este post


Link para o post
Compartilhar em outros sites

Crie uma conta ou entre para comentar

Você precisar ser um membro para fazer um comentário

Criar uma conta

Crie uma nova conta em nossa comunidade. É fácil!

Crie uma nova conta

Entrar

Já tem uma conta? Faça o login.

Entrar agora





Sobre o Clube do Hardware

No ar desde 1996, o Clube do Hardware é uma das maiores, mais antigas e mais respeitadas publicações sobre tecnologia do Brasil. Leia mais

Direitos autorais

Não permitimos a cópia ou reprodução do conteúdo do nosso site, fórum, newsletters e redes sociais, mesmo citando-se a fonte. Leia mais

×