Segue o caso-de-uso passado pelo professor Rafael Jefman:
------------------------------------------------------------------------------------------
Trabalho: Jogo de Labirinto
Objetivo:
Implementar um jogo de labirinto, com interface em modo texto,
utilizando a linguagem Java, obedecendo as regras e requisitos abaixo.
Regras e requisitos:
- A interface com o usuário será feita via console, com o usuário
digitando comandos.
- Os comandos serão compostos por verbos e substantivos, por exemplo
"Andar Sul", ou "Olhar armadilha".
- O objetivo do jogo é que o Jogador consiga "fugir" de um labirinto .
- O labirinto é formado por salas, onde cada sala pode ter até 6
saídas (Norte, Sul, Leste, Oeste, Acima, Abaixo).
- Cada sala pode estar vazia, conter um tesouro, um inimigo, uma
armadilha, ou não ter nada.
- O Labirinto será descrito por um arquivo texto, entregue pelo
professor, em aula.
Inimigos e Regras de Combate:
- O Jogador terá, no início do jogo, 10 unidades de vida
- Cada golpe do Jogador, em combate causará 2 unidades de dano, mais
as unidades somadas da arma que o Jogador está utilizando.
- As armas disponíveis para o Jogador são:
- Faca: 1 dano (o jogador inicia com a faca)
- Espada: 2 danos
- Cimitarra: 3 danos
- As armas são obtidas como os tesouros.
- O jogador só pode carregar uma arma de cada vez.
- Os inimigos causam danos variados e possuem pontos variados de vida,
de acordo com o tipo de inimigo:
Goblins: 1-2 ponto de dano, 2 a 3 pontos de vida
Orcs: 2-4 pontos de dano, 3 a 5 pontos de vida
Trolls: 4-6 pontos de dano, 4 a 7 pontos de vida
- O combate é resolvido em "turnos", sendo que o Jogador pode escolher
combater o inimigo ou não. Sempre que o Jogador atacar o inimigo, ele
irá revidar com um golpe. Golpes serão efetivos 80% das vezes para os
jogares e 50% das vezes para os inimigos.
- Se um inimigo está em uma sala, ele bloqueará a passagem do jogador
para uma das saídas, aleatoriamente.
- Os inimigos serão distribuídos aleatoriamente pelo labirinto.
Tesouros:
Além das armas, outros tesouros podem ser encontrados no labirinto:
- Poção da Vida: faz com que a quantidade de pontos de vida do
jogador retorne a 10
- Armadura: Aumenta a resistencia aos golpes dos inimigos
- Armadura de Couro: 1 ponto
- Armadura de Metal: 2 pontos
- Armadura de Mithrill: 3 pontos
- Fogo de Dragão: Quando utilizado, mata o inimigo instantaneamente.
- Chaves: Algumas portas estarão trancadas, e é preciso que o jogador
possua uma chave para abri-las. As chaves podem ser das cores Azul,
Verde, Vermelha e Amarela, cada uma abre uma porta da mesma cor.
Portas "marrom" não são trancadas. Uma porta tem 10% de chance de ser
Azul, 10% de chance de ser Verde, 10% de chance de ser Vermelha e 10%
de chance de ser Amarela. Se uma porta não tiver "cor", ela será
"marrom" e estará destrancada.
Os Tesouros estarão em salas aleatórias. O Jogador pode carregar
apenas uma arma, um tesouro e uma armadura ao mesmo tempo. Para
carregar outro equipamento, é necessário largar o que já está
utilizando.
As armadilhas são inimigos que:
- Não bloqueiam a porta onde estão localizadas.
- Causam dano aleatório de 1 até a morte instantânea (ao contrário dos
inimigos, cujo dano é fixo)
- Tem dois estados: armadas e desarmadas
- Se um jogador passar pela armadilha sem a desarmar, recebe o dano,
mas consegue passar.
- Uma porta pode ter uma armadilha e um inimigo.
- O jogador tem 90% de chance de desarmar a armadilha.
------------------------------------------------------------------------------------------
Daqui em diante, seguem as classes que implementei:
------------------------------------------------------------------------------------------
Classe Labirinto, método main, que chama as demais classes.
------------------------------------------------------------------------------------------
package Labirinto;
import java.io.*;
public class Labirinto {
public static void main(String[] args) {
String a="";
String aux="";
BufferedReader entra = new BufferedReader(new InputStreamReader(System.in));
mapa m = new mapa();
m.abrir();
m.LugarInicial();
while (!aux.equals("O")||!aux.equals("o")){
try{
System.out.println("Digite a ação desejada: \n");
aux = entra.readLine();
System.out.println(aux);
if(aux.equals("Ver Ajuda")){
a+="Andar Norte - Escolhe passar pela porta norte \n";
a+="Andar Sul - Escolhe passar pela porta sul \n";
a+="Andar Leste - Escolhe passar pela porta leste \n";
a+="Andar Oeste - Escolhe passar pela porta oeste \n";
a+="Subir Escada - Escolhe subir o andar \n";
a+="Descer Escada - Escolhe descer o andar \n";
a+="Ver Mochila - Escolhe ver os itens carregados \n";
a+="Ver Ajuda - Escolhe ver os comandos de ajuda \n";
a+="Descrever Sala - Descreve a sala onde você está \n";
a+="Desarmar Armadilha - Desarma a armadilha encontrada \n";
a+="Pegar Arma - Pega Arma do tesouro \n";
a+="Pegar Armadura - Pega Armadura do tesouro \n";
a+="Pegar Fogo - Pega Fogo do Dragão do tesouro \n";
a+="Pegar Cura - Pega Poção de Cura do tesouro \n";
a+="Pegar Chave - Pega Chave do tesouro \n";
a+="Fechar Jogo - Escolhe fechar o jogo \n";
}
if(aux.equals("Andar Norte")||aux.equals("Andar Sul")||aux.equals("Andar Leste")||aux.equals("Andar Oeste")||aux.equals("Subir Escada")||aux.equals("Descer escada")){
m.andar(aux);
}
if(aux.equals("Ver Mochila")){
m.listaMochila();
}
if(aux.equals("Descrever Sala")){
m.descrever();
}
if(aux.equals("Desarmar Armadilha")){
m.desarmarArmadilha();
}
if((aux.equals("Pegar Arma"))||(aux.equals("Pegar Armadura"))||(aux.equals("Pegar Chave"))||(aux.equals("Pegar Cura"))||(aux.equals("Pegar Fogo"))){
m.pegarTesouro(aux);
}
if(aux.equals("Fechar Jogo")){
aux="O";
}
System.out.println(a);
a="";
}catch (IOException exception) {
exception.printStackTrace();
}
}
}
}
------------------------------------------------------------------------------------------
Classe Mapa, principal classe, responsável pela leitura do arquivo, montagem do mapa, movimentação do personagem e descrição.
------------------------------------------------------------------------------------------
package Labirinto;
import java.io.*;
import java.util.Scanner;
class mapa {
/*Cria uma matriz que guardará as salas e conexões de qualquer labirinto com até 1000 salas:
Estrutura:
Linha 1: Conexão Norte; N - não tem | 0 a 1000 - número da sala que faz conexão;
Linha 2: Conexão Sul; N - não tem | 0 a 1000 - número da sala que faz conexão;
Linha 3: Conexão Leste; N - não tem | 0 a 1000 - número da sala que faz conexão;
Linha 4: Conexão Oeste; N - não tem | 0 a 1000 - número da sala que faz conexão;
Linha 5: Conexão Acima; N - não tem | 0 a 1000 - número da sala que faz conexão;
Linha 6: Conexão Abaixo; N - não tem | 0 a 1000 - número da sala que faz conexão;
Exemplo:
room 18 north 24 south 25 TRAP east 19 west 22 up 28 TRAP
sala[18][1] = 24;
sala[18][2] = 25;
sala[18][3] = 19;
sala[18][4] = 22;
sala[18][5] = 28;
sala[18][6] = N;
*/
private String [][] sala = new String[1000][7];
/*Cria uma matriz que guardará a cor das conexões de qualquer labirinto com até 1000 salas:
Estrutura:
Linha 1: Conexão Norte; N - não tem | Cor da Porta | D - destrancada
Linha 2: Conexão Sul; N - não tem | Cor da Porta | D - destrancada
Linha 3: Conexão Leste; N - não tem | Cor da Porta | D - destrancada
Linha 4: Conexão Oeste; N - não tem | Cor da Porta | D - destrancada
Linha 5: Conexão Acima; N - não tem | Cor da Porta | D - destrancada
Linha 6: Conexão Abaixo; N - não tem | Cor da Porta | D - destrancada
Exemplo:
room 18 north 24 (Marrom) south 25 TRAP (Azul) east 19 (Marrom) west 22 (Vermelha) up 28 TRAP (Verde)
cor[18][1] = Marrom;
cor[18][2] = Azul;
cor[18][3] = Marrom;
cor[18][4] = Vermelha;
cor[18][5] = Verde;
cor[18][6] = N;
*/
private String [][] cor = new String[1000][7];
/*Cria uma matriz que guardará as armadilhas de qualquer labirinto com até 1000 salas:
Estrutura:
Linha 1: Conexão Norte; N - não possui | TRAP - possui armada | D - possui desarmada ;
Linha 2: Conexão Sul; N - não possui | TRAP - possui armada | D - possui desarmada ;
Linha 3: Conexão Leste; N - não possui | TRAP - possui armada | D - possui desarmada ;
Linha 4: Conexão Oeste; N - não possui | TRAP - possui armada | D - possui desarmada ;
Linha 5: Conexão Acima; N - não possui | TRAP - possui armada | D - possui desarmada ;
Linha 6: Conexão Abaixo; N - não possui | TRAP - possui armada | D - possui desarmada ;
Exemplo:
room 18 north 24 south 25 TRAP east 19 west 22 up 28 TRAP
trap[18][1] = N;
trap[18][2] = TRAP;
trap[18][3] = N;
trap[18][4] = N;
trap[18][5] = TRAP;
trap[18][6] = N;
*/
private String [][] trap = new String[1000][7];
/*Cria uma matriz que guardará os inimigos de qualquer labirinto com até 1000 salas:
Estrutura:
Linha 1: Conexão Norte; N - não possui | G - Goblin | O - Orc | T - Troll;
Linha 2: Conexão Sul; N - não possui | G - Goblin | O - Orc | T - Troll;
Linha 3: Conexão Leste; N - não possui | G - Goblin | O - Orc | T - Troll;
Linha 4: Conexão Oeste; N - não possui | G - Goblin | O - Orc | T - Troll;
Linha 5: Conexão Acima; N - não possui | G - Goblin | O - Orc | T - Troll;
Linha 6: Conexão Abaixo; N - não possui | G - Goblin | O - Orc | T - Troll;
Exemplo:
room 18 north 24 south 25 TRAP(+ goblin) east 19 west 22(troll) up 28 TRAP
inimigo[18][1] = N;
inimigo[18][2] = G;
inimigo[18][3] = N;
inimigo[18][4] = T;
inimigo[18][5] = N;
inimigo[18][6] = N;
*/
private String [][] inimigo = new String[1000][7];
/*Cria uma matriz que guardará os tesouros de qualquer labirinto com até 1000 salas:
Estrutura:
Linha 1: Arma; N - não possui | Faca - Faca | Espada - Espada | Cimitarra - Cimitarra;
Linha 2: Armadura; N - não possui | Couro - Couro | Metal - Metal | Mitrhrill - Mitrhrill;
Linha 3: Chave; N - não possui | Cor da Chave
Linha 4: Poção de Cura; N - não possui | Cura - Possui
Linha 5: Fogo do Dragão; N - não possui | Fogo - Possui
Exemplo:
room 18 north 24 south 25 TRAP(+ goblin) east 19 west 22(troll) up 28 TRAP
tesouro[18][1] = N;
tesouro[18][2] = G;
tesouro[18][3] = N;
tesouro[18][4] = T;
tesouro[18][5] = N;
tesouro[18][6] = N;
*/
private String [][] tesouro = new String[1000][7];
private String [][] dadosInimigo = new String[1000][7];
// guarda a posição do personagem.
private int posicao = 0;
private int nDirecao= 0;
inventario i = new inventario();
tesouro tes = new tesouro();
inimigo ini = new inimigo();
personagem p = new personagem();
// Abre o arquivo e monta a matriz do labirinto
public void abrir(){
//zera o mapa (salas, armadilhas e inimigos)
for (int i=0; i<1000; i++){
for (int j=0; j<7; j++){
sala[i][j]="N";
trap[i][j]="N";
inimigo[i][j]="N";
cor[i][j]="N";
tesouro[i][j]="N";
dadosInimigo[i][j]="N";
}
}
// garanto a linha zero da matriz das salas para as saídas.
for (int j=0; j<7; j++){
sala[0][j]="SAIDA";
}
String caminhonome=""; // serve para pegar o 'caminhonome' do arquivo
int n=0; // serve para guardar o número da sala em String
String aux=""; // serve para auxiliar as conversões de int para String
String direcao=""; // serve para guardar a direção da conexão
Scanner entra = new Scanner(System.in);
while(caminhonome==""){
System.out.println("Digite o caminho, nome e extensão do arquivo do labirinto:");
caminhonome = entra.next();
}
try {
FileInputStream fis = new FileInputStream(caminhonome);
Scanner scanner = new Scanner(fis);
while (scanner.hasNext("room")) {
scanner.next();
// guarda o número da sala
n = scanner.nextInt();
tesouro[n][1]=tes.arma();
tesouro[n][2]=tes.armadura();
tesouro[n][3]=tes.Chave();
tesouro[n][4]=tes.cura();
tesouro[n][5]=tes.fogodragao();
while (scanner.hasNext("south")||scanner.hasNext("north")||scanner.hasNext("east")||scanner.hasNext("west")||scanner.hasNext("up")||scanner.hasNext("down")){
// pula e guarda a próxima direção
direcao = scanner.next();
if(direcao.equals("north")){
nDirecao=1;
}
if(direcao.equals("south")){
nDirecao=2;
}
if(direcao.equals("east")){
nDirecao=3;
}
if(direcao.equals("west")){
nDirecao=4;
}
if(direcao.equals("up")){
nDirecao=5;
}
if(direcao.equals("down")){
nDirecao=6;
}
// busco o número da sala de conexão e guardo na sala:
aux = scanner.next();
sala[n][nDirecao] = aux;
cor[n][nDirecao] = cor();
if(scanner.hasNext("TRAP")){
// se tiver TRAP, somo ao número da sala de conexão a String 'TRAP' e guardo na matriz trap:
aux = " "+scanner.next();
trap[n][nDirecao] = aux;
}
// crio inimigo para a conexão
inimigo[n][nDirecao]=ini.Tipo();
if(!inimigo[n][nDirecao].equals("N")){
geraInimigo(inimigo[n][nDirecao], n, nDirecao);
}
// limpo a aux para próximo uso
aux="";
}
// limpo a n para próximo uso
n=0;
}
}
catch (Exception e) {
e.printStackTrace();
}
for (int i=0; i<40; i++) {
System.out.println("Sala " + i + " Norte " +sala[i][1] + trap[i][1] + inimigo[i][1] + " Sul " +sala[i][2] + trap[i][2] + inimigo[i][2] + " Leste " +sala[i][3] + trap[i][3] + inimigo[i][3] + " Oeste " +sala[i][4] + trap[i][4] + inimigo[i][4] + " Acima " +sala[i][5] + trap[i][5] + inimigo[i][5] + " Abaixo " +sala[i][6] + trap[i][6] + inimigo[i][6]);
}
}
// cria a localização incial
public void LugarInicial(){
int w=0;
int k=1;
while(w==0){
k = (int) (1+(Math.random() * 1000));
if(!sala[k][1].equals("N") || !sala[k][2].equals("N") || !sala[k][3].equals("N") || !sala[k][4].equals("N") || !sala[k][5].equals("N") || !sala[k][6].equals("N")){
w=1;
}
}
posicao = k;
i.criaInventario();
salaPresa();
descrever();
}
public void salaPresa(){
int r=0, n=0;
String aux="";
// testo se todas as portas estão fechadas
aux = tesouro[posicao][3];
for(int j=0;j<7;j++){
// testo se há chave no chão para abrir uma das portas da sala
if(!cor[posicao][j].equals("N")){
if(!cor[posicao][j].equals(aux)){
r++;
}
n++;
}
}
for(int j=0;j<7;j++){
if(cor[posicao][j].equals("Marrom")){
r=0;
}
}
if(r==n){
descrever();
System.out.println("\n Você está preso nesta sala.");
System.exit(0);
}
}
// Descreve o lugar onde o personagem está
public void descrever(){
String a="";
if(posicao==0){
System.out.println("Parabéns! Você conseguiu escapar do Labirinto!");
System.exit(0);
}
a += "Você está na Sala " + posicao +"\n";
if(!sala[posicao][1].equals("N")){
a += "Porta "+cor[posicao][1]+" ao norte. ";
if(!inimigo[posicao][1].equals("N")){
a+="Há um "+inimigo[posicao][1]+" bloquando esta porta. ";
}
if(!trap[posicao][1].equals("N")){
a+="Há uma armadilha nesta porta. ";
}
a+="\n";
}
if(!sala[posicao][2].equals("N")){
a += "Porta "+cor[posicao][2]+" ao sul. ";
if(!inimigo[posicao][2].equals("N")){
a+="Há um "+inimigo[posicao][2]+" bloquando esta porta.";
}
if(!trap[posicao][2].equals("N")){
a+="Há uma armadilha nesta porta. ";
}
a+="\n";
}
if(!sala[posicao][3].equals("N")){
a += "Porta "+cor[posicao][3]+" ao leste; ";
if(!inimigo[posicao][3].equals("N")){
a+="Há um "+inimigo[posicao][3]+" bloquando esta porta.";
}
if(!trap[posicao][3].equals("N")){
a+="Há uma armadilha nesta porta. ";
}
a+="\n";
}
if(!sala[posicao][4].equals("N")){
a += "Porta "+cor[posicao][4]+" a oeste; ";
if(!inimigo[posicao][4].equals("N")){
a+="Há um "+inimigo[posicao][4]+" bloquando esta porta.";
}
if(!trap[posicao][4].equals("N")){
a+="Há uma armadilha nesta porta. ";
}
a+="\n";
}
if(!sala[posicao][5].equals("N")){
a += "Escada "+cor[posicao][5]+" para Subir; ";
if(!inimigo[posicao][5].equals("N")){
a+="Há um "+inimigo[posicao][5]+" bloquando esta Escada.";
}
if(!trap[posicao][5].equals("N")){
a+="Há uma armadilha nesta Escada. ";
}
a+="\n";
}
if(!sala[posicao][6].equals("N")){
a += "Escada "+cor[posicao][6]+" para descer; ";
if(!inimigo[posicao][6].equals("N")){
a+="Há um "+inimigo[posicao][6]+" bloquando esta Escada.";
}
if(!trap[posicao][6].equals("N")){
a+="Há uma armadilha nesta Escada. ";
}
a+="\n";
}
for(int i=0; i<7; i++){
if(!tesouro[posicao][i].equals("N")){
a +="Tesouro: "+tesouro[posicao][i]+"\n";
}
}
System.out.println(a);
}
//move o personagem pelo labirinto
public void andar(String comando){
String aux="";
if(comando.equals("Andar Norte")){
nDirecao=1;
}
if(comando.equals("Andar Sul")){
nDirecao=2;
}
if(comando.equals("Andar Leste")){
nDirecao=3;
}
if(comando.equals("Andar Oeste")){
nDirecao=4;
}
if(comando.equals("Subir Escada")){
nDirecao=5;
}
if(comando.equals("Descer Escada")){
nDirecao=6;
}
// Testa se há sala para onde o jogador quer se mover
if(sala[posicao][nDirecao].equals("N")){
System.out.println("Não há porta para esta direção. \n");
}
else{
// testa se há inimigo na porta e leva para o método de combate
if (!inimigo[posicao][nDirecao].equals("N")){
aux=combate(posicao, nDirecao);
if(!aux.equals(inimigo[posicao][nDirecao])){
inimigo[posicao][nDirecao]=aux;
}
}
else{
// testa se há armadilha na porta e leva para o método de dano da armadilha
if(trap[posicao][nDirecao].equals("TRAP")){
danoArmadilha();
}
}
if((!cor[posicao][nDirecao].equals("D"))||(!cor[posicao][nDirecao].equals("Marrom"))){
abrirPorta(nDirecao);
}
if(inimigo[posicao][nDirecao].equals("N")){
if(cor[posicao][nDirecao].equals("Marrom")){
// comando que move o personagem para a próxima sala
posicao = Integer.parseInt(sala[posicao][nDirecao]);
}
}
}
salaPresa();
descrever();
}
// Este método teste se há chave para abrir a porta correspondente.
public void abrirPorta(int nDirecao){
// recupera a chave que o personagem carrega
String aux = i.listatesouro();
// testa se a chave que o personagem carrega é igual à cor da porta
if(cor[posicao][nDirecao].equals(aux)){
cor[posicao][nDirecao]="Marrom";
System.out.println("Você abriu esta porta.");
}
else{
if(!cor[posicao][nDirecao].equals("Marrom")){
System.out.println("Você não possui a chave para abrir esta porta.");
}
}
}
public String cor(){
String cor="";
while (cor.equals("")){
int a = (int) (1+(Math.random() * 10));
switch(a){
case 1: cor = "Verde"; break;
case 3: cor = "Vermelha"; break;
case 5: cor = "Amarela"; break;
case 7: cor = "Azul"; break;
default: cor = "Marrom"; break;
}
}
return cor;
}
public void pegarTesouro(String opcao){
String aux = "";
if(opcao.equals("Pegar Arma")){
if(!tesouro[posicao][1].equals("N")){
aux=i.listaarma();
i.getarma(tesouro[posicao][1]);
tesouro[posicao][1]=aux;
}
else{
System.out.println("Não há arma no tesouro");
}
}
if(opcao.equals("Pegar Armadura")){
if(!tesouro[posicao][2].equals("N")){
aux=i.listaarmadura();
i.getarmadura(tesouro[posicao][2]);
tesouro[posicao][2]=aux;
}
else{
System.out.println("Não há armadura no tesouro");
}
}
if(opcao.equals("Pegar Chave")){
if(!tesouro[posicao][3].equals("N")){
aux=i.listatesouro();
i.gettesouro(tesouro[posicao][3]);
tesouro[posicao][3]=aux;
}
else{
System.out.println("Não há Chave no tesouro");
}
}
if(opcao.equals("Pegar Cura")){
if(!tesouro[posicao][4].equals("N")){
aux=i.listatesouro();
i.gettesouro(tesouro[posicao][4]);
tesouro[posicao][4]=aux;
}
else{
System.out.println("Não há Poção de Cura no tesouro");
}
}
if(opcao.equals("Pegar Fogo")){
if(!tesouro[posicao][5].equals("N")){
aux=i.listatesouro();
i.gettesouro(tesouro[posicao][5]);
tesouro[posicao][5]=aux;
}
else{
System.out.println("Não há Fogo do Dragão no tesouro");
}
}
}
// Desarma a armadilha.
public void desarmarArmadilha(){
int a = (int) (1+(Math.random() * 10));
switch(a){
case 5:
System.out.println("Você não conseguiu desarmar a armadilha. \n");break;
default:
System.out.println("Você conseguiu desarmar a armadilha. \n");
trap[posicao][nDirecao]="N";break;
}
}
//gera o combate entre o personagem e os inimigos
public String combate(int posicao, int nDirecao){
Scanner entra = new Scanner(System.in);
String sa=""+posicao;
String di=""+nDirecao;
for(int i=0;i<1000;i++){
if(dadosInimigo[i][2].equals(sa)){
if(dadosInimigo[i][3].equals(di)){
posicao=i;
break;
}
}
}
String aux="";
aux=i.listatesouro();
int a=0, vida=0;
if(!aux.equals(null)){
if(aux.equals("Fogo")){
System.out.println("Atacar com Arma ou com Fogo do Dragão?");
aux = entra.nextLine();
if(aux.equals("Usar Fogo")){
return "N";
}
}
}
a = p.dano(i.listaarma());
aux=dadosInimigo[posicao][4];
int b = Integer.parseInt(aux);
vida = b - a;
System.out.println("Você acertou o "+dadosInimigo[posicao][1]+" com "+a+" pontos de dano. \n");
dadosInimigo[posicao][4]=""+vida;
if(vida>0){
a = ini.ataque(dadosInimigo[posicao][1]);
System.out.println("O "+dadosInimigo[posicao][1]+" acertou você com "+a+" pontos de dano. \n");
a = p.vida(a, i.listaarmadura());
return dadosInimigo[posicao][1];
}
else{
System.out.println("Você matou o "+dadosInimigo[posicao][1]+"\n");
return "N";
}
}
public void geraInimigo(String Tipo, int posicao, int nDirecao){
int a=0;
for(int i=0; i<1000; i++){
if(dadosInimigo[i][1].equals("N")){
dadosInimigo[i][1] = Tipo;
dadosInimigo[i][2] = ""+posicao;
dadosInimigo[i][3] = ""+nDirecao;
a = ini.vida(Tipo);
dadosInimigo[i][4] = ""+a;
break;
}
}
}
public void listaMochila(){
String aux="";
String a="";
aux=i.listaarma();
a+="Arma: "+aux+"\n";
aux=i.listaarmadura();
a+="Armadura: "+aux+"\n";
aux=i.listatesouro();
a+="Tesouro: "+aux+"\n";
System.out.println(a);
}
// GERA O DANO POR PASSAR EM UM ARMADILHA NÃO DESARMADA
public void danoArmadilha(){
System.out.println("Você não desarmou a armadilha e foi vítima dela. \n");
// calcula o dano
int dano = (int) (1+(Math.random() * 10));
// cria o objeto da classe personagem para enviar o dano inflingido pela armadilha
personagem p = new personagem();
dano = p.vida(dano, i.listaarmadura());
}
}
------------------------------------------------------------------------------------------
Classe Inimigo. Gera e controla os inimigos no jogo.
------------------------------------------------------------------------------------------
package Labirinto;
public class inimigo {
public String Tipo(){
String inimigo="";
int a = (int) (1+(Math.random() * 8));
switch(a){
case 1: inimigo = "Goblin"; break;
case 2: inimigo = "Orc"; break;
case 3: inimigo = "Trol"; break;
case 4: inimigo = "N"; break;
case 5: inimigo = "N"; break;
case 6: inimigo = "N"; break;
case 7: inimigo = "N"; break;
case 8: inimigo = "N"; break;
}
return inimigo;
}
// gera atque do inimigo
public int vida(String inimigo){
int a=0;
if(inimigo.equals("Goblin")){
a = (int) (2 + (Math.random() * 2));
}
if(inimigo.equals("Orc")){
a = (int) (3 + (Math.random() * 3));
}
if(inimigo.equals("Trol")){
a = (int) (4 + (Math.random() * 4));
}
return a;
}
// Gera ataque do inimigo
public int ataque(String inimigo){
int a=0;
if(inimigo.equals("Goblin")){
a = (int) (1 + (Math.random() * 2));
}
if(inimigo.equals("Orc")){
a = (int) (2 + (Math.random() * 3));
}
if(inimigo.equals("Trol")){
a = (int) (4 + (Math.random() * 3));
}
return a;
}
}
------------------------------------------------------------------------------------------
Classe Inventário. Gera, controla e mostra o inventário do jogador.
------------------------------------------------------------------------------------------
package Labirinto;
import java.util.Scanner;
public class inventario {
public String inventario[][]=new String[2][4];
// 1 - arma;
// 2 - tesouro;
// 3 - armadura;
public void criaInventario(){
inventario[1][1]="Faca";
inventario[1][2]="Cura";
inventario[1][3]="";
}
public String listaarma(){
String aux =inventario[1][1];
return aux;
}
public String listatesouro(){
String aux =inventario[1][2];
return aux;
}
public String listaarmadura(){
String aux =inventario[1][3];
return aux;
}
public String getarma(String a){
Scanner entra = new Scanner(System.in);
String aux ="";
if (inventario[1][1].equals("")){
inventario[1][1] = a;
}
else{
aux +="Voce esta carregando "+inventario[1][1]+"\n";
aux +="Deseja trocar por "+a+"? \n";
aux +="Digite: S -> Sim; N-> Nao \n";
System.out.println(aux);
aux = entra.next();
if(aux.equals("S")){
inventario[1][1] = a;
}
}
return inventario[1][1];
}
public String gettesouro(String a){
Scanner entra = new Scanner(System.in);
String aux ="";
if (inventario[1][2].equals("")){
inventario[1][2] = a;
}
else{
aux +="Voce esta carregando "+inventario[1][2]+"\n";
aux +="Deseja trocar por "+a+"? \n";
aux +="Digite: S -> Sim; N-> Nao \n";
System.out.println(aux);
aux = entra.next();
if(aux.equals("S")){
inventario[1][2] = a;
}
}
return inventario[1][2];
}
public String getarmadura(String a){
Scanner entra = new Scanner(System.in);
String aux ="";
if (inventario[1][3].equals("")){
inventario[1][3] = a;
}
else{
aux +="Voce esta carregando "+inventario[1][3]+"\n";
aux +="Deseja trocar por "+a+"? \n";
aux +="Digite: S -> Sim; N-> Nao \n";
System.out.println(aux);
aux = entra.next();
if(aux.equals("S")){
inventario[1][3] = a;
}
}
return inventario[1][3];
}
}
------------------------------------------------------------------------------------------
Classe personagem: Cria e Controla os atributos do Personagem
------------------------------------------------------------------------------------------
package Labirinto;
class personagem {
public String inventario="";
public int vida=10, dano=3;
public int vida(int dano, String Armadura){
String a="";
if(dano>0){
a = Armadura;
if(a.equals("Couro")){
dano = dano - 1;
System.out.println("Sua armadura de Couro absorveu 1 de dano \n");
}
if(a.equals("Metal")){
dano = dano - 2;
System.out.println("Sua armadura de Metal absorveu 2 de dano \n");
}
if(a.equals("Mithrill")){
dano = dano - 3;
System.out.println("Sua armadura de Mithrill absorveu 3 de dano \n");
}
vida = vida - dano;
}
else{
vida = 10;
System.out.println("Voce tomou uma pocao de cura.");
}
System.out.println("Vida: "+vida);
if(vida <= 0){
System.out.println("Voce morreu");
System.exit(0);
}
return vida;
}
public int dano(String arma){
int dano=2;
if(arma.equals("Faca")){
dano=4;
}
if(arma.equals("Espada")){
dano=5;
}
if(arma.equals("Cimitarra")){
dano=6;
}
dano = (int) (Math.random() * dano );
return dano;
}
}
------------------------------------------------------------------------------------------
Classe Tesouro: Cria e controla os tesouros do labirinto.
------------------------------------------------------------------------------------------
package Labirinto;
class tesouro {
public String Chave(){
String chave="";
while (chave.equals("")){
int a = (int) (1+(Math.random() * 8));
switch(a){
case 1: chave = "Azul"; break;
case 3: chave = "Amarela"; break;
case 5: chave = "Verde"; break;
case 7: chave = "Vermelha"; break;
default: chave = "N";
}
}
return chave;
}
public String arma(){
String arma="";
while (arma.equals("")){
int a = (int) (1+(Math.random() * 14));
switch(a){
case 1: arma = "Faca"; break;
case 3: arma = "Cimitarra"; break;
case 5: arma = "Espada"; break;
case 7: arma = "Faca"; break;
case 9: arma = "Espada"; break;
case 11: arma = "Faca"; break;
default: arma = "N";
}
}
return arma;
}
public String armadura(){
String armadura="";
while (armadura.equals("")){
int a = (int) (1+(Math.random() * 14));
switch(a){
case 1: armadura = "Couro"; break;
case 3: armadura = "Mitrhrill"; break;
case 5: armadura = "Metal"; break;
case 7: armadura = "Couro"; break;
case 9: armadura = "Metal"; break;
case 11: armadura = "Couro"; break;
default: armadura = "N";
}
}
return armadura;
}
public String cura(){
String pocao="";
int a = (int) (1+(Math.random() * 10));
switch(a){
case 2: pocao="Cura"; break;
case 4: pocao="Cura"; break;
case 5: pocao="Cura"; break;
case 6: pocao="Cura"; break;
case 8: pocao="cura"; break;
default: pocao="N";
}
return pocao;
}
public String fogodragao(){
String pocao="";
int a = (int) (1+(Math.random() * 10));
switch(a){
case 3: pocao="Fogo"; break;
case 5: pocao="Fogo"; break;
case 7: pocao="Fogo"; break;
default: pocao="N";
}
return pocao;
}
}
------------------------------------------------------------------------------------------
