Campo Minado - Erro na expansão de vazios

27 de maio de 2011 9 respostas

lordbeowulf 27 de maio de 2011

Boa tarde Senhores,

Estou desenvolvendo um jogo de campo minado 100% texto (System.out.printf)
Estou usando uma martriz de tamanho variavel.

Consegui desenvolver o jogo quase completamente, mas estou com dificuldades em fazer a expansão do campos quando for vazio, sem bombas em volta até que feche uma linha, como na imagem do campo minado abaixo do windows…

no meu caso, o retorno -1 é bomba, > 0 é a quantidade de bombas em volta daquele vazio -2 é coordenada inválida ou campo já jogado.
matriz é a matriz do jogo.
matrizadj é a matriz que armazena a fila, sendo matrizadj[0][x] = linha e matrizadj[1][x] = coluna

o meu código de validação é este:

private int bombasValida(int x, int y){ //retorna: -2 caso x,y seja coord inválida / -1 caso x,y seja bomba / qtde de bombas ao redor de x,y caso seja válido e não bomba
        if (coordValida(x,y) == false)
            return -2;
        if (matriz[x][y] >= 0)
            return -2;
        else if(matriz[x][y] == -1){
                bomba = 1;
                return -1;
        }
        else{
            int cont = 0, cancela = 0;
            for (int a = -1; a < 2; a++){
                for (int b = -1; b < 2; b++){
                    if (x == 0){
                        if (y == 0){
                            if((a != -1) && (b != -1)){
                                if (matriz[x+a][y+b] == -1){
                                    cont++;
                                }
                                else{
                                    for (int f = 0; f <= fim; f++){
                                        if ((matrizadj[0][f] == x+a) && (matrizadj[1][f] == y+b)){
                                            cancela = 1;
                                        }
                                    }
                                    if (cancela == 0){
                                        fim++;
                                        matrizadj[0][fim] = x+a;
                                        matrizadj[1][fim] = y+b;
                                    }
                                }
                            }
                        }
                        else if (y == cols-1){
                            if((a != -1) && (b != 1)){
                                if (matriz[x+a][y+b] == -1){
                                    cont++;
                                }
                                else{
                                    for (int f = 0; f <= fim; f++){
                                        if ((matrizadj[0][f] == x+a) && (matrizadj[1][f] == y+b)){
                                            cancela = 1;
                                        }
                                    }
                                    if (cancela == 0){
                                        fim++;
                                        matrizadj[0][fim] = x+a;
                                        matrizadj[1][fim] = y+b;
                                    }
                                }
                            }
                        }
                        else{
                            if(a != -1){
                                if (matriz[x+a][y+b] == -1){
                                    cont++;
                                }
                                else{
                                    for (int f = 0; f <= fim; f++){
                                        if ((matrizadj[0][f] == x+a) && (matrizadj[1][f] == y+b)){
                                            cancela = 1;
                                        }
                                    }
                                    if (cancela == 0){
                                        fim++;
                                        matrizadj[0][fim] = x+a;
                                        matrizadj[1][fim] = y+b;
                                    }
                                }
                            }
                        }
                    }
                    else if(x == lins - 1){
                        if (y == 0){
                            if((a != 1) && (b != -1)){
                                if (matriz[x+a][y+b] == -1){
                                    cont++;
                                }
                                else{
                                    for (int f = 0; f <= fim; f++){
                                        if ((matrizadj[0][f] == x+a) && (matrizadj[1][f] == y+b)){
                                            cancela = 1;
                                        }
                                    }
                                    if (cancela == 0){
                                        fim++;
                                        matrizadj[0][fim] = x+a;
                                        matrizadj[1][fim] = y+b;
                                    }
                                }
                            }
                        }
                        else if (y == cols-1){
                            if((a != 1) && (b != 1)){
                                if (matriz[x+a][y+b] == -1){
                                    cont++;
                                }
                                else{
                                    for (int f = 0; f <= fim; f++){
                                        if ((matrizadj[0][f] == x+a) && (matrizadj[1][f] == y+b)){
                                            cancela = 1;
                                        }
                                    }
                                    if (cancela == 0){
                                        fim++;
                                        matrizadj[0][fim] = x+a;
                                        matrizadj[1][fim] = y+b;
                                    }
                                }
                            }
                        }
                        else{
                            if(a != 1){
                                if (matriz[x+a][y+b] == -1){
                                    cont++;
                                }
                                else{
                                    for (int f = 0; f <= fim; f++){
                                        if ((matrizadj[0][f] == x+a) && (matrizadj[1][f] == y+b)){
                                            cancela = 1;
                                        }
                                    }
                                    if (cancela == 0){
                                        fim++;
                                        matrizadj[0][fim] = x+a;
                                        matrizadj[1][fim] = y+b;
                                    }
                                }
                            }
                        }
                    }
                    else if(y == 0){
                        if (x == 0){
                            if((a != -1) && (b != -1)){
                                if (matriz[x+a][y+b] == -1){
                                    cont++;
                                }
                                else{
                                    for (int f = 0; f <= fim; f++){
                                        if ((matrizadj[0][f] == x+a) && (matrizadj[1][f] == y+b)){
                                            cancela = 1;
                                        }
                                    }
                                    if (cancela == 0){
                                        fim++;
                                        matrizadj[0][fim] = x+a;
                                        matrizadj[1][fim] = y+b;
                                    }
                                }
                            }
                        }
                        else if (x == lins-1){
                            if((a != 1) && (b != -1)){
                                if (matriz[x+a][y+b] == -1){
                                    cont++;
                                }
                                else{
                                    for (int f = 0; f <= fim; f++){
                                        if ((matrizadj[0][f] == x+a) && (matrizadj[1][f] == y+b)){
                                            cancela = 1;
                                        }
                                    }
                                    if (cancela == 0){
                                        fim++;
                                        matrizadj[0][fim] = x+a;
                                        matrizadj[1][fim] = y+b;
                                    }
                                }
                            }
                        }
                        else{
                            if(b != -1){
                                if (matriz[x+a][y+b] == -1){
                                    cont++;
                                }
                                else{
                                    for (int f = 0; f <= fim; f++){
                                        if ((matrizadj[0][f] == x+a) && (matrizadj[1][f] == y+b)){
                                            cancela = 1;
                                        }
                                    }
                                    if (cancela == 0){
                                        fim++;
                                        matrizadj[0][fim] = x+a;
                                        matrizadj[1][fim] = y+b;
                                    }
                                }
                            }
                        }
                    }
                    else if(y == cols - 1){
                        if (x == 0){
                            if((a != -1) && (b != 1)){
                                if (matriz[x+a][y+b] == -1){
                                    cont++;
                                }
                                else{
                                    for (int f = 0; f <= fim; f++){
                                        if ((matrizadj[0][f] == x+a) && (matrizadj[1][f] == y+b)){
                                            cancela = 1;
                                        }
                                    }
                                    if (cancela == 0){
                                        fim++;
                                        matrizadj[0][fim] = x+a;
                                        matrizadj[1][fim] = y+b;
                                    }
                                }
                            }
                        }
                        else if (x == lins-1){
                            if((a != 1) && (b != 1)){
                                if (matriz[x+a][y+b] == -1){
                                    cont++;
                                }
                                else{
                                    for (int f = 0; f <= fim; f++){
                                        if ((matrizadj[0][f] == x+a) && (matrizadj[1][f] == y+b)){
                                            cancela = 1;
                                        }
                                    }
                                    if (cancela == 0){
                                        fim++;
                                        matrizadj[0][fim] = x+a;
                                        matrizadj[1][fim] = y+b;
                                    }
                                }
                            }
                        }
                        else{
                            if(b != 1){
                                if (matriz[x+a][y+b] == -1){
                                    cont++;
                                }
                                else{
                                    for (int f = 0; f <= fim; f++){
                                        if ((matrizadj[0][f] == x+a) && (matrizadj[1][f] == y+b)){
                                            cancela = 1;
                                        }
                                    }
                                    if (cancela == 0){
                                        fim++;
                                        matrizadj[0][fim] = x+a;
                                        matrizadj[1][fim] = y+b;
                                    }
                                }
                            }
                        }
                    }
                    else{
                        if (matriz[x+a][y+b] == -1){
                            cont++;
                        }
                        else{
                            for (int f = 0; f <= fim; f++){
                                if ((matrizadj[0][f] == x+a) && (matrizadj[1][f] == y+b)){
                                    cancela = 1;
                                }
                            }
                            if (cancela == 0){
                                fim++;
                                matrizadj[0][fim] = x+a;
                                matrizadj[1][fim] = y+b;
                            }
                        }
                    }
                }
            }
            matriz[x][y] = cont;
            return cont;
        }
}

e a chamada dentro do programa esta assim:

ret recebe o retorno da função acima:

if (ret == 0){
                for (int f = 0; f <= fim; f++){
                    bombasValida(matrizadj[0][f],matrizadj[1][f]);
                }
            }
                ini = 0;
                fim = 0;

9 Respostas

drsmachado 27 de mai. de 2011

O que você está tentando fazer é “limpar” os campos que estão em volta de um campo “sem bomba” quando este é clicado, certo?
Eu verificaria primeiro a linha (esquerda e direita) e depois coluna (cima e baixo), por último, verificaria os pontos em que foi criado um “quadrado” das casas mais extremas…
É uma sugestão

lordbeowulf 27 de mai. de 2011

Na verdade vai ser digitado, já que o jogo é modo texto.

Bom, eu não estou conseguindo criar uma fila de verificação correta. Pode ser que o adjacente do adjacente do adjacente tenha que ser mudado, mas apenas se for 0 bombas ao redor. se existir bombas ao redor, ele nao verifica mais adjacentes deste.

Nao estou conseguindo fazer o codigo executar os adjacentes para fazer a contagem pra ver se deve ser buscado os adjacentes e entao refazer a verificação para adicionar na fila de adjacentes a mudar.

Não estou conseguindo montar esta logica, estou um pouco perdido.

Sem expandir, ele verifica normalmente os adjacentes e retorna a contagem, inclusive com controle de bordas para nao abortar.

drsmachado 27 de mai. de 2011

Creio que seja necessário isolar cada caso.
Primeiro, identifica-se que é um campo vazio.
Segundo, verifica-se se o item à esquerda é vazio (até achar uma bomba).
Terceiro, verifica-se se o item à diteira é vazio (até achar uma bomba).
Segue-se a mesma lógica para cima e baixo.
Em um determinado ponto à esquerda ele acha uma bomba (o mesmo à direita, acima e abaixo), neste quadrado ele vai limpando…
Tenta “desenhar isto”

lordbeowulf 27 de mai. de 2011

Entendi! Eu estava tentando pensar no sentido dos oito ponto, incluindo as diagonais, usando for.

Vou tentar fazer nesse sentido ai, depois retorno.

Obrigado.

pmlm 27 de mai. de 2011

Pesquisa por recursividade…

raghy 28 de mai. de 2011

bacana o post, eu gosto de jogos. se puder, posta o jogo pronto aí depois. tenho dois jogos no meu site, em www.raghyjose.net/programacaoatual.php
:lol: :roll:

lordbeowulf 30 de mai. de 2011

drsmachado:
Creio que seja necessário isolar cada caso.
Primeiro, identifica-se que é um campo vazio.
Segundo, verifica-se se o item à esquerda é vazio (até achar uma bomba).
Terceiro, verifica-se se o item à diteira é vazio (até achar uma bomba).
Segue-se a mesma lógica para cima e baixo.
Em um determinado ponto à esquerda ele acha uma bomba (o mesmo à direita, acima e abaixo), neste quadrado ele vai limpando…
Tenta “desenhar isto”

Tentei fazer desta forma mas não consegui prosseguir, pois tenho que verificar quadrado a quadrado. Checar a coluna e depois as linhas da coluna não resolve.
Eu teria que ver quadrado a quadrado pra poder fechar as linhas de forma correta.
Ainda está muito complexo.
Estou tentando algumas ideias com recursividade e outras sem, mas até agora sem sucesso.
Se alguém tiver alguma idéia…

Quando eu tiver o jogo pronto, posto aqui.

drsmachado 30 de mai. de 2011

Supondo que o jogador clique num ponto vazio (sem bomba ou número). Este ponto está localizado em uma linha X e numa coluna Y.
Se ele for o elemento mais à direita ou mais à esquerda (ou seja, última ou primeira coluna) basta ir comparando os elementos do outro lado (os pontos X, Y - coluna ou + coluna) até encontrar uma bomba ou número. Da mesma forma, se este ponto é na primeira ou última linha, basta comparar a coluna, ponto a ponto, para encontrar uma bomba.
Quando o ponto não está em uma extremidade, você precisará verificar em todos os lados. Feito isso, você vai checar todos os itens no “quadrado” que se forma da coluna mais à esquerda, à coluna mais à direita e, da linha mais acima, à linha mais abaixo.

1 2 3 4 5 6 7 8 9
1X X X X X X X X X 1
2X X X X X X X  1B 2
3X X X X X X         3
4X X X X X X X X X 4
 1 2 3 4 5 6 7 8 9

Pense que o o B é a bomba e que o 1 o número. O clique, sendo dado no ponto (8, 3) irá analisaro ponto acima (8, 2), ao lado, (7, 3) e assim por diante…

pmlm 30 de mai. de 2011

O teu método terá de ser mais ou menos assim:

valida (int x, int y){

  if (posicao[x][y] == numero) {
     //mostra numero e espera proxima jogada 
  } else if (posicao[x][y] == bomba) {
     //perdeu
  } else {
      //está vazio e chama o metodo valida para cada uma das 8 posições 
      if (x>0){
           valida(x-1, y);
           if (y>0){
                valida(x-1, y-1);
           }
           if (y<tamanho maximo-1){
                valida(x-1, y+1);
           }
     }    
     if (x<tamanho maximo-1){
           valida(x+1, y);
           if (y>0){
                valida(x+1, y-1);
           }
           if (y<tamanho maximo-1){
                valida(x+1, y+1);
           }
     }    
     if(y>0){
       valida(x, y-1);
     }

      if(y<tamanho maximo-1){
         valida(x, y+1);
       }

  }
}

Criado 27 de maio de 2011

Ultima resposta 30 de mai. de 2011

Respostas 9

Participantes 4

9 Respostas

Topicos relacionados