Trabalho do Labirinto Java
Autor: Arthur Tavares | Publicado: 2010-11-24T12:04:00-08:00

Segue o caso-de-uso passado pelo professor Rafael Jefman:------------------------------------------------------------------------------------------Trabalho: Jogo de LabirintoObjetivo: 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&quot;Andar Sul&quot;, ou &quot;Olhar armadilha&quot;.- O objetivo do jogo é que o Jogador consiga &quot;fugir&quot; de um labirinto . - O labirinto é formado por salas, onde cada sala pode ter até 6saídas (Norte, Sul, Leste, Oeste, Acima, Abaixo).- Cada sala pode estar vazia, conter um tesouro, um inimigo, umaarmadilha, ou não ter nada. - O Labirinto será descrito por um arquivo texto, entregue peloprofessor, 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 &quot;turnos&quot;, sendo que o Jogador pode escolher combater o inimigo ou não. Sempre que o Jogador atacar o inimigo, eleirá revidar com um golpe. Golpes serão efetivos 80% das vezes para osjogares 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 dojogador 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 &quot;marrom&quot; 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 &quot;cor&quot;, ela será&quot;marrom&quot; 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. Paracarregar 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 dosinimigos, 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=&quot;&quot;;          String aux=&quot;&quot;;                  BufferedReader entra = new BufferedReader(new InputStreamReader(System.in));           mapa m = new mapa();                  m.abrir();         m.LugarInicial();                  while (!aux.equals(&quot;O&quot;)||!aux.equals(&quot;o&quot;)){             try{                 System.out.println(&quot;Digite a ação desejada: \n&quot;);                 aux = entra.readLine();                                  System.out.println(aux);                                  if(aux.equals(&quot;Ver Ajuda&quot;)){                     a+=&quot;Andar Norte        - Escolhe passar pela porta norte \n&quot;;                     a+=&quot;Andar Sul          - Escolhe passar pela porta sul \n&quot;;                     a+=&quot;Andar Leste        - Escolhe passar pela porta leste \n&quot;;                     a+=&quot;Andar Oeste        - Escolhe passar pela porta oeste \n&quot;;                     a+=&quot;Subir Escada       - Escolhe subir o andar \n&quot;;                     a+=&quot;Descer Escada      - Escolhe descer o andar \n&quot;;                     a+=&quot;Ver Mochila        - Escolhe ver os itens carregados \n&quot;;                     a+=&quot;Ver Ajuda          - Escolhe ver os comandos de ajuda \n&quot;;                     a+=&quot;Descrever Sala     - Descreve a sala onde você está \n&quot;;                     a+=&quot;Desarmar Armadilha - Desarma a armadilha encontrada \n&quot;;                     a+=&quot;Pegar Arma         - Pega Arma do tesouro \n&quot;;                     a+=&quot;Pegar Armadura     - Pega Armadura do tesouro \n&quot;;                     a+=&quot;Pegar Fogo         - Pega Fogo do Dragão do tesouro \n&quot;;                     a+=&quot;Pegar Cura         - Pega Poção de Cura do tesouro \n&quot;;                     a+=&quot;Pegar Chave        - Pega Chave do tesouro \n&quot;;                     a+=&quot;Fechar Jogo        - Escolhe fechar o jogo \n&quot;;                 }                                  if(aux.equals(&quot;Andar Norte&quot;)||aux.equals(&quot;Andar  Sul&quot;)||aux.equals(&quot;Andar Leste&quot;)||aux.equals(&quot;Andar  Oeste&quot;)||aux.equals(&quot;Subir Escada&quot;)||aux.equals(&quot;Descer escada&quot;)){                     m.andar(aux);                                 }                                  if(aux.equals(&quot;Ver Mochila&quot;)){                     m.listaMochila();                 }                                 if(aux.equals(&quot;Descrever Sala&quot;)){                     m.descrever();                 }                 if(aux.equals(&quot;Desarmar Armadilha&quot;)){                     m.desarmarArmadilha();                 }                 if((aux.equals(&quot;Pegar Arma&quot;))||(aux.equals(&quot;Pegar  Armadura&quot;))||(aux.equals(&quot;Pegar Chave&quot;))||(aux.equals(&quot;Pegar  Cura&quot;))||(aux.equals(&quot;Pegar Fogo&quot;))){                     m.pegarTesouro(aux);                 }                 if(aux.equals(&quot;Fechar Jogo&quot;)){                     aux=&quot;O&quot;;                 }                                                                                  System.out.println(a);                 a=&quot;&quot;;             }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&lt;1000; i++){             for (int j=0; j&lt;7; j++){                 sala[i][j]=&quot;N&quot;;                 trap[i][j]=&quot;N&quot;;                 inimigo[i][j]=&quot;N&quot;;                 cor[i][j]=&quot;N&quot;;                 tesouro[i][j]=&quot;N&quot;;                 dadosInimigo[i][j]=&quot;N&quot;;             }         }                  // garanto a linha zero da matriz das salas para as saídas.                 for (int j=0; j&lt;7; j++){             sala[0][j]=&quot;SAIDA&quot;;         }                  String caminhonome=&quot;&quot;; // serve para pegar o &#39;caminhonome&#39; do arquivo         int n=0;                  // serve para guardar o número da sala em String         String aux=&quot;&quot;;           // serve para auxiliar as conversões de int para String         String direcao=&quot;&quot;;       // serve para guardar a direção da conexão                  Scanner entra = new Scanner(System.in);         while(caminhonome==&quot;&quot;){             System.out.println(&quot;Digite o caminho, nome e extensão do arquivo do labirinto:&quot;);             caminhonome = entra.next();                     }          try {             FileInputStream fis = new FileInputStream(caminhonome);               Scanner     scanner = new Scanner(fis);                   while (scanner.hasNext(&quot;room&quot;)) {                   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(&quot;south&quot;)||scanner.hasNext(&quot;north&quot;)||scanner.hasNext(&quot;east&quot;)||scanner.hasNext(&quot;west&quot;)||scanner.hasNext(&quot;up&quot;)||scanner.hasNext(&quot;down&quot;)){                     // pula e guarda a próxima direção                     direcao = scanner.next();                     if(direcao.equals(&quot;north&quot;)){                         nDirecao=1;                     }                     if(direcao.equals(&quot;south&quot;)){                         nDirecao=2;                     }                     if(direcao.equals(&quot;east&quot;)){                         nDirecao=3;                     }                     if(direcao.equals(&quot;west&quot;)){                         nDirecao=4;                     }                     if(direcao.equals(&quot;up&quot;)){                         nDirecao=5;                     }                     if(direcao.equals(&quot;down&quot;)){                         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(&quot;TRAP&quot;)){                         // se tiver TRAP, somo ao número da sala de conexão a String &#39;TRAP&#39; e guardo na matriz trap:                         aux = &quot; &quot;+scanner.next();                         trap[n][nDirecao] = aux;                     }                     // crio inimigo para a conexão                     inimigo[n][nDirecao]=ini.Tipo();                     if(!inimigo[n][nDirecao].equals(&quot;N&quot;)){                         geraInimigo(inimigo[n][nDirecao], n, nDirecao);                     }                     // limpo a aux para próximo uso                     aux=&quot;&quot;;                                     }                 // limpo a n para próximo uso                 n=0;             }           }          catch (Exception e) {               e.printStackTrace();           }         for (int i=0; i&lt;40; i++) {               System.out.println(&quot;Sala &quot; + i + &quot; Norte &quot; +sala[i][1] +  trap[i][1] + inimigo[i][1] + &quot; Sul &quot; +sala[i][2] + trap[i][2] +  inimigo[i][2] + &quot; Leste &quot; +sala[i][3] + trap[i][3] + inimigo[i][3] + &quot;  Oeste &quot; +sala[i][4] + trap[i][4] + inimigo[i][4] + &quot; Acima &quot; +sala[i][5]  + trap[i][5] + inimigo[i][5] + &quot; Abaixo &quot; +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(&quot;N&quot;) || !sala[k][2].equals(&quot;N&quot;) ||  !sala[k][3].equals(&quot;N&quot;) || !sala[k][4].equals(&quot;N&quot;) ||  !sala[k][5].equals(&quot;N&quot;) || !sala[k][6].equals(&quot;N&quot;)){                 w=1;             }         }                  posicao = k;         i.criaInventario();         salaPresa();                  descrever();     }          public void salaPresa(){         int r=0, n=0;         String aux=&quot;&quot;;         // testo se todas as portas estão fechadas         aux = tesouro[posicao][3];         for(int j=0;j&lt;7;j++){             // testo se há chave no chão para abrir uma das portas da sala             if(!cor[posicao][j].equals(&quot;N&quot;)){                 if(!cor[posicao][j].equals(aux)){                     r++;                 }                 n++;             }         }         for(int j=0;j&lt;7;j++){             if(cor[posicao][j].equals(&quot;Marrom&quot;)){                 r=0;             }         }         if(r==n){             descrever();             System.out.println(&quot;\n Você está preso nesta sala.&quot;);             System.exit(0);         }     }          // Descreve o lugar onde o personagem está     public void descrever(){         String a=&quot;&quot;;         if(posicao==0){             System.out.println(&quot;Parabéns! Você conseguiu escapar do Labirinto!&quot;);             System.exit(0);         }                  a += &quot;Você está na Sala &quot; + posicao +&quot;\n&quot;;                  if(!sala[posicao][1].equals(&quot;N&quot;)){             a += &quot;Porta &quot;+cor[posicao][1]+&quot; ao norte. &quot;;             if(!inimigo[posicao][1].equals(&quot;N&quot;)){                 a+=&quot;Há um &quot;+inimigo[posicao][1]+&quot; bloquando esta porta. &quot;;             }             if(!trap[posicao][1].equals(&quot;N&quot;)){                 a+=&quot;Há uma armadilha nesta porta. &quot;;             }             a+=&quot;\n&quot;;         }         if(!sala[posicao][2].equals(&quot;N&quot;)){             a += &quot;Porta &quot;+cor[posicao][2]+&quot; ao sul. &quot;;             if(!inimigo[posicao][2].equals(&quot;N&quot;)){                 a+=&quot;Há um &quot;+inimigo[posicao][2]+&quot; bloquando esta porta.&quot;;             }             if(!trap[posicao][2].equals(&quot;N&quot;)){                 a+=&quot;Há uma armadilha nesta porta. &quot;;             }             a+=&quot;\n&quot;;         }         if(!sala[posicao][3].equals(&quot;N&quot;)){             a += &quot;Porta &quot;+cor[posicao][3]+&quot; ao leste; &quot;;             if(!inimigo[posicao][3].equals(&quot;N&quot;)){                 a+=&quot;Há um &quot;+inimigo[posicao][3]+&quot; bloquando esta porta.&quot;;             }             if(!trap[posicao][3].equals(&quot;N&quot;)){                 a+=&quot;Há uma armadilha nesta porta. &quot;;             }             a+=&quot;\n&quot;;         }         if(!sala[posicao][4].equals(&quot;N&quot;)){             a += &quot;Porta &quot;+cor[posicao][4]+&quot; a oeste; &quot;;             if(!inimigo[posicao][4].equals(&quot;N&quot;)){                 a+=&quot;Há um &quot;+inimigo[posicao][4]+&quot; bloquando esta porta.&quot;;             }             if(!trap[posicao][4].equals(&quot;N&quot;)){                 a+=&quot;Há uma armadilha nesta porta. &quot;;             }             a+=&quot;\n&quot;;         }         if(!sala[posicao][5].equals(&quot;N&quot;)){             a += &quot;Escada &quot;+cor[posicao][5]+&quot; para Subir; &quot;;             if(!inimigo[posicao][5].equals(&quot;N&quot;)){                 a+=&quot;Há um &quot;+inimigo[posicao][5]+&quot; bloquando esta Escada.&quot;;             }             if(!trap[posicao][5].equals(&quot;N&quot;)){                 a+=&quot;Há uma armadilha nesta Escada. &quot;;             }             a+=&quot;\n&quot;;         }         if(!sala[posicao][6].equals(&quot;N&quot;)){             a += &quot;Escada &quot;+cor[posicao][6]+&quot; para descer; &quot;;             if(!inimigo[posicao][6].equals(&quot;N&quot;)){                 a+=&quot;Há um &quot;+inimigo[posicao][6]+&quot; bloquando esta Escada.&quot;;             }             if(!trap[posicao][6].equals(&quot;N&quot;)){                 a+=&quot;Há uma armadilha nesta Escada. &quot;;             }             a+=&quot;\n&quot;;         }                  for(int i=0; i&lt;7; i++){             if(!tesouro[posicao][i].equals(&quot;N&quot;)){                 a +=&quot;Tesouro: &quot;+tesouro[posicao][i]+&quot;\n&quot;;             }                      }          System.out.println(a);     }          //move o personagem pelo labirinto     public void andar(String comando){                  String aux=&quot;&quot;;                          if(comando.equals(&quot;Andar Norte&quot;)){             nDirecao=1;         }         if(comando.equals(&quot;Andar Sul&quot;)){             nDirecao=2;         }         if(comando.equals(&quot;Andar Leste&quot;)){             nDirecao=3;         }         if(comando.equals(&quot;Andar Oeste&quot;)){             nDirecao=4;         }         if(comando.equals(&quot;Subir Escada&quot;)){             nDirecao=5;         }         if(comando.equals(&quot;Descer Escada&quot;)){             nDirecao=6;         }                                  // Testa se há sala para onde o jogador quer se mover         if(sala[posicao][nDirecao].equals(&quot;N&quot;)){             System.out.println(&quot;Não há porta para esta direção. \n&quot;);         }         else{             // testa se há inimigo na porta e leva para o método de combate             if (!inimigo[posicao][nDirecao].equals(&quot;N&quot;)){                 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(&quot;TRAP&quot;)){                     danoArmadilha();                 }                             }                          if((!cor[posicao][nDirecao].equals(&quot;D&quot;))||(!cor[posicao][nDirecao].equals(&quot;Marrom&quot;))){                 abrirPorta(nDirecao);             }                          if(inimigo[posicao][nDirecao].equals(&quot;N&quot;)){                 if(cor[posicao][nDirecao].equals(&quot;Marrom&quot;)){                     // 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]=&quot;Marrom&quot;;             System.out.println(&quot;Você abriu esta porta.&quot;);         }         else{             if(!cor[posicao][nDirecao].equals(&quot;Marrom&quot;)){                 System.out.println(&quot;Você não possui a chave para abrir esta porta.&quot;);             }         }     }          public String cor(){         String cor=&quot;&quot;;         while (cor.equals(&quot;&quot;)){             int a = (int) (1+(Math.random() * 10));             switch(a){                 case 1:  cor = &quot;Verde&quot;; break;                 case 3:  cor = &quot;Vermelha&quot;; break;                 case 5:  cor = &quot;Amarela&quot;; break;                 case 7:  cor = &quot;Azul&quot;; break;                 default: cor = &quot;Marrom&quot;; break;             }         }         return cor;             }     public void pegarTesouro(String opcao){                  String aux = &quot;&quot;;                  if(opcao.equals(&quot;Pegar Arma&quot;)){             if(!tesouro[posicao][1].equals(&quot;N&quot;)){                 aux=i.listaarma();                 i.getarma(tesouro[posicao][1]);                 tesouro[posicao][1]=aux;             }             else{                 System.out.println(&quot;Não há arma no tesouro&quot;);             }         }         if(opcao.equals(&quot;Pegar Armadura&quot;)){             if(!tesouro[posicao][2].equals(&quot;N&quot;)){                 aux=i.listaarmadura();                 i.getarmadura(tesouro[posicao][2]);                 tesouro[posicao][2]=aux;             }             else{                 System.out.println(&quot;Não há armadura no tesouro&quot;);             }         }         if(opcao.equals(&quot;Pegar Chave&quot;)){             if(!tesouro[posicao][3].equals(&quot;N&quot;)){                 aux=i.listatesouro();                 i.gettesouro(tesouro[posicao][3]);                 tesouro[posicao][3]=aux;             }             else{                 System.out.println(&quot;Não há Chave no tesouro&quot;);             }         }                 if(opcao.equals(&quot;Pegar Cura&quot;)){             if(!tesouro[posicao][4].equals(&quot;N&quot;)){                 aux=i.listatesouro();                 i.gettesouro(tesouro[posicao][4]);                 tesouro[posicao][4]=aux;             }             else{                 System.out.println(&quot;Não há Poção de Cura no tesouro&quot;);             }         }         if(opcao.equals(&quot;Pegar Fogo&quot;)){             if(!tesouro[posicao][5].equals(&quot;N&quot;)){                 aux=i.listatesouro();                 i.gettesouro(tesouro[posicao][5]);                 tesouro[posicao][5]=aux;             }             else{                 System.out.println(&quot;Não há Fogo do Dragão no tesouro&quot;);             }         }             }     // Desarma a armadilha.     public void desarmarArmadilha(){                  int a = (int) (1+(Math.random() * 10));         switch(a){             case 5:                  System.out.println(&quot;Você não conseguiu desarmar a armadilha. \n&quot;);break;             default:                  System.out.println(&quot;Você conseguiu desarmar a armadilha. \n&quot;);                 trap[posicao][nDirecao]=&quot;N&quot;;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=&quot;&quot;+posicao;         String di=&quot;&quot;+nDirecao;         for(int i=0;i&lt;1000;i++){             if(dadosInimigo[i][2].equals(sa)){                 if(dadosInimigo[i][3].equals(di)){                     posicao=i;                     break;                 }             }         }                 String aux=&quot;&quot;;         aux=i.listatesouro();         int a=0, vida=0;                  if(!aux.equals(null)){                     if(aux.equals(&quot;Fogo&quot;)){                 System.out.println(&quot;Atacar com Arma ou com Fogo do Dragão?&quot;);                 aux = entra.nextLine();                 if(aux.equals(&quot;Usar Fogo&quot;)){                     return &quot;N&quot;;                 }             }         }                  a = p.dano(i.listaarma());         aux=dadosInimigo[posicao][4];         int b = Integer.parseInt(aux);         vida =  b - a;         System.out.println(&quot;Você acertou o &quot;+dadosInimigo[posicao][1]+&quot; com &quot;+a+&quot; pontos de dano. \n&quot;);         dadosInimigo[posicao][4]=&quot;&quot;+vida;                  if(vida&gt;0){             a = ini.ataque(dadosInimigo[posicao][1]);             System.out.println(&quot;O &quot;+dadosInimigo[posicao][1]+&quot; acertou você com &quot;+a+&quot; pontos de dano. \n&quot;);             a = p.vida(a, i.listaarmadura());             return dadosInimigo[posicao][1];         }         else{             System.out.println(&quot;Você matou o &quot;+dadosInimigo[posicao][1]+&quot;\n&quot;);             return &quot;N&quot;;         }              }          public void geraInimigo(String Tipo, int posicao, int nDirecao){                  int a=0;                  for(int i=0; i&lt;1000; i++){             if(dadosInimigo[i][1].equals(&quot;N&quot;)){                 dadosInimigo[i][1] = Tipo;                 dadosInimigo[i][2] = &quot;&quot;+posicao;                 dadosInimigo[i][3] = &quot;&quot;+nDirecao;                 a = ini.vida(Tipo);                 dadosInimigo[i][4] = &quot;&quot;+a;                 break;             }         }     }          public void listaMochila(){                  String aux=&quot;&quot;;         String a=&quot;&quot;;         aux=i.listaarma();         a+=&quot;Arma: &quot;+aux+&quot;\n&quot;;         aux=i.listaarmadura();         a+=&quot;Armadura: &quot;+aux+&quot;\n&quot;;         aux=i.listatesouro();         a+=&quot;Tesouro: &quot;+aux+&quot;\n&quot;;         System.out.println(a);     }          // GERA O DANO POR PASSAR EM UM ARMADILHA NÃO DESARMADA     public void danoArmadilha(){                  System.out.println(&quot;Você não desarmou a armadilha e foi vítima dela. \n&quot;);                  // 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=&quot;&quot;;         int a = (int) (1+(Math.random() * 8));         switch(a){             case 1: inimigo = &quot;Goblin&quot;; break;             case 2: inimigo = &quot;Orc&quot;; break;             case 3: inimigo = &quot;Trol&quot;; break;             case 4: inimigo = &quot;N&quot;; break;             case 5: inimigo = &quot;N&quot;; break;             case 6: inimigo = &quot;N&quot;; break;             case 7: inimigo = &quot;N&quot;; break;             case 8: inimigo = &quot;N&quot;; break;         }         return inimigo;     }      // gera atque do inimigo     public int vida(String inimigo){         int a=0;         if(inimigo.equals(&quot;Goblin&quot;)){             a = (int) (2 + (Math.random() * 2));         }         if(inimigo.equals(&quot;Orc&quot;)){             a = (int) (3 + (Math.random() * 3));         }         if(inimigo.equals(&quot;Trol&quot;)){             a = (int) (4 + (Math.random() * 4));         }         return a;     }          // Gera ataque do inimigo     public int ataque(String inimigo){         int a=0;         if(inimigo.equals(&quot;Goblin&quot;)){             a = (int) (1 + (Math.random() * 2));         }         if(inimigo.equals(&quot;Orc&quot;)){             a = (int) (2 + (Math.random() * 3));         }         if(inimigo.equals(&quot;Trol&quot;)){             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]=&quot;Faca&quot;;         inventario[1][2]=&quot;Cura&quot;;         inventario[1][3]=&quot;&quot;;     }      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 =&quot;&quot;;         if (inventario[1][1].equals(&quot;&quot;)){             inventario[1][1] = a;         }         else{             aux +=&quot;Voce esta carregando &quot;+inventario[1][1]+&quot;\n&quot;;             aux +=&quot;Deseja trocar por &quot;+a+&quot;? \n&quot;;             aux +=&quot;Digite: S -&gt; Sim; N-&gt; Nao \n&quot;;             System.out.println(aux);             aux = entra.next();             if(aux.equals(&quot;S&quot;)){                 inventario[1][1] = a;             }         }         return inventario[1][1];     }     public String gettesouro(String a){         Scanner entra = new Scanner(System.in);         String aux =&quot;&quot;;         if (inventario[1][2].equals(&quot;&quot;)){             inventario[1][2] = a;         }         else{             aux +=&quot;Voce esta carregando &quot;+inventario[1][2]+&quot;\n&quot;;             aux +=&quot;Deseja trocar por &quot;+a+&quot;? \n&quot;;             aux +=&quot;Digite: S -&gt; Sim; N-&gt; Nao \n&quot;;             System.out.println(aux);             aux = entra.next();             if(aux.equals(&quot;S&quot;)){                 inventario[1][2] = a;             }         }         return inventario[1][2];     }     public String getarmadura(String a){         Scanner entra = new Scanner(System.in);         String aux =&quot;&quot;;         if (inventario[1][3].equals(&quot;&quot;)){             inventario[1][3] = a;         }         else{             aux +=&quot;Voce esta carregando &quot;+inventario[1][3]+&quot;\n&quot;;             aux +=&quot;Deseja trocar por &quot;+a+&quot;? \n&quot;;             aux +=&quot;Digite: S -&gt; Sim; N-&gt; Nao \n&quot;;             System.out.println(aux);             aux = entra.next();             if(aux.equals(&quot;S&quot;)){                 inventario[1][3] = a;             }         }         return inventario[1][3];     } }  ------------------------------------------------------------------------------------------Classe personagem: Cria e Controla os atributos do Personagem ------------------------------------------------------------------------------------------ package Labirinto;  class personagem {          public String inventario=&quot;&quot;;     public int vida=10, dano=3;          public int vida(int dano, String Armadura){         String a=&quot;&quot;;                  if(dano&gt;0){                          a = Armadura;                          if(a.equals(&quot;Couro&quot;)){                 dano = dano - 1;                 System.out.println(&quot;Sua armadura de Couro absorveu 1 de dano \n&quot;);             }             if(a.equals(&quot;Metal&quot;)){                 dano = dano - 2;                 System.out.println(&quot;Sua armadura de Metal absorveu 2 de dano \n&quot;);             }             if(a.equals(&quot;Mithrill&quot;)){                 dano = dano - 3;                 System.out.println(&quot;Sua armadura de Mithrill absorveu 3 de dano \n&quot;);             }                                     vida = vida - dano;         }         else{             vida = 10;             System.out.println(&quot;Voce tomou uma pocao de cura.&quot;);         }                  System.out.println(&quot;Vida: &quot;+vida);                  if(vida &lt;= 0){             System.out.println(&quot;Voce morreu&quot;);             System.exit(0);         }                  return vida;     }      public int dano(String arma){                  int dano=2;         if(arma.equals(&quot;Faca&quot;)){             dano=4;         }         if(arma.equals(&quot;Espada&quot;)){             dano=5;         }         if(arma.equals(&quot;Cimitarra&quot;)){             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=&quot;&quot;;         while (chave.equals(&quot;&quot;)){             int a = (int) (1+(Math.random() * 8));             switch(a){                 case 1:  chave = &quot;Azul&quot;;     break;                 case 3:  chave = &quot;Amarela&quot;;  break;                 case 5:  chave = &quot;Verde&quot;;    break;                 case 7:  chave = &quot;Vermelha&quot;; break;                 default: chave = &quot;N&quot;;             }         }         return chave;     }     public String arma(){         String arma=&quot;&quot;;         while (arma.equals(&quot;&quot;)){             int a = (int) (1+(Math.random() * 14));             switch(a){                 case 1:  arma = &quot;Faca&quot;;      break;                 case 3:  arma = &quot;Cimitarra&quot;; break;                 case 5:  arma = &quot;Espada&quot;;    break;                 case 7:  arma = &quot;Faca&quot;;      break;                 case 9:  arma = &quot;Espada&quot;;    break;                 case 11: arma = &quot;Faca&quot;;      break;                 default: arma = &quot;N&quot;;             }         }                 return arma;     }              public String armadura(){         String armadura=&quot;&quot;;         while (armadura.equals(&quot;&quot;)){             int a = (int) (1+(Math.random() * 14));             switch(a){                 case 1:  armadura = &quot;Couro&quot;;     break;                 case 3:  armadura = &quot;Mitrhrill&quot;; break;                 case 5:  armadura = &quot;Metal&quot;;     break;                 case 7:  armadura = &quot;Couro&quot;;     break;                 case 9:  armadura = &quot;Metal&quot;;     break;                 case 11: armadura = &quot;Couro&quot;;     break;                 default: armadura = &quot;N&quot;;             }         }         return armadura;     }          public String cura(){         String pocao=&quot;&quot;;         int a = (int) (1+(Math.random() * 10));         switch(a){             case 2:  pocao=&quot;Cura&quot;; break;             case 4:  pocao=&quot;Cura&quot;; break;             case 5:  pocao=&quot;Cura&quot;; break;             case 6:  pocao=&quot;Cura&quot;; break;             case 8:  pocao=&quot;cura&quot;; break;             default: pocao=&quot;N&quot;;          }                 return pocao;     }     public String fogodragao(){         String pocao=&quot;&quot;;         int a = (int) (1+(Math.random() * 10));         switch(a){             case 3:  pocao=&quot;Fogo&quot;; break;             case 5:  pocao=&quot;Fogo&quot;; break;             case 7:  pocao=&quot;Fogo&quot;; break;             default: pocao=&quot;N&quot;;          }         return pocao;     } }------------------------------------------------------------------------------------------