Auxílio em trabalho de aula

jefers0n
(usa Suse)

Enviado em 16/06/2010 - 19:34h

Boa noite,

Estou quaqse na data da entrega e estou apanhando pra fazer isso:

Preciso fazer um método pra gerar os passos de um robô para ele sair de unm labirinto, a maioria ja esta implementado, pegamos pronto do profº, tem um método que lê e interpreta um labirinto em txt qualquer e desenha o labiritno na tela, tem o método que move o robô(onde se passa o ponto corrente do mesmo no labiritno e uma direção"um int de 0-3, 0:esquerda, 1:cima, 3:cima e 2:direita"), tenho que fazer o método que gera os passos válidos seguindo a seguinte lógica:

Ele tem que ir sempre com a mão esquerda na parede, quando chegar na primeira entrada para esquerda ele deve entrar, se for reto ele vai até o fim e voltadaí tentando entrar pra sua esquerda(que vsualmente na tela será nossa direita) assim até achar a saída(os labs sempre terão saída).

pra saber se é caminho válido usamos o método que move, pois o mesmo retorna null se a posição que tentamos ir não é valida e se for diferente de null podemos nos mover pra ela... tem tb um método auxiliar que retorna true se for saída...

O que fiz:

Gera lista dos passos a serem seguidos...

   1. public ListTAD<Point> geraPassos() {  

   2.         //--> direction {0 - Esquerda 1 - Cima 2 - Direita 3 - Baixo}  

   3.        int count = 0;  

   4.        int nroIteracoes = getMaxPassos(); // máx passos passamos qdo criamos um novo robô...  

   5.          

   6.        ListTAD<Point> lista = new ListArray<Point>();  

   7.   

   8.        while (!ehSaida(pCorrente) && count < nroIteracoes) {  

   9.            Point pAux = move(pCorrente, decisao());  

  10.            if (pAux !=  null) {  

  11.                pCorrente = pAux;  

  12.                lista.add(pCorrente);  

  13.                count++;  

  14.            }  

  15.            count++;  

  16.        }  

  17.        return (lista);  

  18.    }  

 

metodo auxiliar pra saber pra onde devo ir

   1. public int decisao() {  

   2.         if (direction == 1){ // direção atual do robô  

   3.             Point pAux = move(pontoCorrente, 0);  

   4.             if (pAux !=  null)  

   5.                 return 0;    //se ta subindo devo tentar ir pra esquerda  

   6.             else pAux = move(pontoCorrente, 1);  

   7.             if (pAux !=  null)  

   8.                 return 1;  

   9.             else pAux = move(pontoCorrente, 2);  

  10.             if (pAux !=  null)  

  11.                 return 2;  

  12.             else return 3;  

  13.         }  

  14.         else if (direction == 2) {  

  15.             Point pAux = move(pontoCorrente, 1);  

  16.             if (pAux !=  null)  

  17.                 return 1;  

  18.             else pAux = move(pontoCorrente, 2);  

  19.             if (pAux !=  null)  

  20.                 return 2;  

  21.             else pAux = move(pontoCorrente, 3);  

  22.             if (pAux !=  null)  

  23.                 return 3;  

  24.             else return 0;  

  25.         }  

  26.         else if (direction == 3){  

  27.             Point pAux = move(pontoCorrente, 2);  

  28.             if (pAux !=  null)  

  29.                 return 2;  

  30.             else pAux = move(pontoCorrente, 3);  

  31.             if (pAux !=  null)  

  32.                 return 3;  

  33.             else pAux = move(pontoCorrente, 0);  

  34.             if (pAux !=  null)  

  35.                 return 0;  

  36.             else return 1;  

  37.         }  

  38.         else {  

  39.             Point pAux = move(pontoCorrente, 3);  

  40.             if (pAux !=  null)  

  41.                 return 3;  

  42.             else pAux = move(pontoCorrente, 0);  

  43.             if (pAux !=  null)  

  44.                 return 0;  

  45.             else pAux = move(pontoCorrente, 1);  

  46.             if (pAux !=  null)  

  47.                 return 1;  

  48.             else return 2;  

  49.           

  50.         }  

  51.     }  

 

Mas não ta funcionando....

jefers0n
(usa Suse)

Enviado em 17/06/2010 - 14:13h

E como poderia fazer isso em java, não sei se terei tempo hábil pra aprender e fazer com isto, poderia me dar um help...

Grato,

jefers0n
(usa Suse)

Enviado em 18/06/2010 - 09:29h

Sem problemas, acho que não terei tempo pra terminar, mas o profº ja praticamente disse como fazer, temos que guardar a posição que o robô estava e em que direção ele vinha vindo, pois se bater numa parede ele sabe pra onde deve virar... Mas não to conseguindo implementar isso....

O mapa do labirinto não pe necessário, ele ja deu pronto, funciona pra qualquer labirinto txt, elçe interpreta os espassos em branco como caminho e quqalquer outro caracter como parede.... tu pode fazer um labirinto salvar e abrir pelo programa que funciona...

Só tenho que fazer métodos que gere os passos do robo e armazene numa lista, daí qdo achar a saída retorna a lista que o robô vai ir pelos passos gerados....

jefers0n
(usa Suse)

Enviado em 21/06/2010 - 09:33h

Grato Sam L., mas esta função que passaste eu ja tenho pronta, acho que seria esta....

private Point move(Point p, int umaDirecao){
Point pAux = p;
int direction = umaDirecao;
// a partir da direção inicial procura
// um movimento válido

switch (direction) {
case 0: // para esquerda
if (p.x > 0) pAux = new Point(p.x-1, p.y);
break;
case 1: // para baixo
if (p.y < getLabirinto().getWidth()-1) pAux = new Point(p.x, p.y+1);
break;
case 2: // para direita
if (p.x < getLabirinto().getHeight()-1) pAux = new Point(p.x+1, p.y);
break;
case 3: // para cima
if (p.y > 0) pAux = new Point(p.x, p.y-1);
break;
}
if (getLabirinto().isEmpty(pAux)) return pAux;
return null;
}

E para ver se é saída tem esse tb:

// Metodo auxiliar que verifica se o ponto p corresponde a saída do labirinto
private boolean ehSaida(Point p) {
return (getLabirinto().isEmpty(p) &&
(p.x==0 ||
p.y==0 ||
p.x == getLabirinto().getHeight()-1 ||
p.y == getLabirinto().getWidth()-1));
}

Meu problema é a lógica para gerar os passos do robô, por exemplo, inicio num ponto e tento mover pra direita, se for válido, movo e teria que tentar subir no próximo passo, (para que ele vire sempre a esquerda) e se não for válido o movimento pra cima ele vai novamente pra direita, se nessa tentativa não for válido tb pra direita ele deve tentar descer, se não der tem que voltar até poder descer....

Só falta isso...

Grato...

jefers0n
(usa Suse)

Enviado em 22/06/2010 - 11:54h

Muito obrigado pelo auxílio, mas ontem na aula pedi auxílio pro professor e ele deu uma olhada e me deu uma dica que resolveu... Que foi no método decisao(), eu não tinha parâmetro algum, ele disse pra pôr a direção atual do robô, pra saber onde ele tá e saber pra onde ele vai... E a lógica dos movimentos tava certa, daí funcionou...

Como eram 3 robôs com diferentes lógicas, 2 deles ta feito, falta o último, que se não for pedir demais :), gostaria de um auxílio...

Este tem que usar árvore, ele ja deu a dica de como fazer, to meio perdido no código. Temos que usar como base o código que ja temos de caminhamento em largura de arvores gerais(não pode ser binária pq podemos ter até 4 posições válidas que serão filhos...).

Temos que criar uma árvore de Pontos(Tree<Point> arv...)que armazenará todas as posições do labirinto, mais ou menos assim: pega a posição corrente e põe na árvore e vai inserindo seus filhos numa "fila", daí qdo inseriu todos os filhos desta posição, vai na fila e retira o primeiro inserido(caracteristica da fila...) e insere na árvore e vai adicionando na fila os filhos deste agora que é o atual...assim até achar a saída, qdo achar a saída é só ir pegando o pai(sucessivamente) da posição que é saída até chegar no início da árvore(que foi o primeiro ponto onde estava o robô) que teremos o caminho que ele deve percorrer(e armazenar numa lista para devolver a lista de passos)...

Não sei se ficou claro, tb não sei se soube explicar, mas é mais ou menos isso... mas ta meio difícil(pois o caminhamento em largura foi o mais difícil quie achei).

Grato,