CODIGOS PALAVRAS CRUZADAS - JAVA

Ola pessoal esta eu inutilizado na minha casa, programando um joguinho de palavras

cruzadas em java, quado de repente, me deparei com a realidade e percebi que meu
codigo esta uma merda… funcionando quase tudo mais muito ruim mesmo. Alguem
aqui que tenha tempo para olhar e disposição para olhar este codigo me apontaria
uma solução melhor para isto??

[code]import java.awt.;
import java.awt.event.;
import javax.swing.*;

public class Jogo extends JFrame

implements KeyListener

{
//atributos
private final int someMuda = 25;
private final int tamanho = 23;
private int aondeX = 1;
private int aondeY = 1;
private int posX = 28;
private int posY = 28;
private char letra;
private boolean impriLetra = false;
private boolean reImpriLetra = false;
private char [][]gravaLetra = new char[10][10];

//construtor
public Jogo(){
super("Jogando");
showFrame();
}

//metodos
public void paint(Graphics g)
{
if(!impriLetra)
{
super.paint(g);

//desenha o jogo
g.setColor(Color.black);

for(int count = 0; count <= 275; count+=25)

{
g.fillRect(count, 25, 3, 250);
}
for(int count = 0; count <= 275; count += 25)
{
g.fillRect(25, count, 250, 3);
}

//pinta os quadrados
g.setColor(Color.blue);
g.fillRect(posX, posY, 22, 22);
}

//imprime novas letras

 g.setColor(Color.black);
g.setFont(new Font("SansSerif", Font.BOLD, 15));
g.drawString(letra+"", posX+5, posY+15);
impriLetra = false;
reImpriLetra = true;

//Reimpri as letras ja imprimidas

//quando da o super.paint(g) limpa tudo e eu preciso que as letra continuem
if(reImpriLetra)
{
for(int i=0; i<10; i++)
for(int j=0; j<10; j++){

g.setColor(Color.black);
g.setFont(new Font("SansSerif", Font.BOLD, 15));
g.drawString(gravaLetra[i][j]+"",((i+1)*25)+8, ((j+1)*25+18));
}

reImpriLetra = false;
}
}
//Mostra o Frame
public void showFrame()
{
addKeyListener(this);
setSize(315, 400);
setVisible(true);
gravaLetra = inicializa(gravaLetra);
}

//Implementação da interface KeyListener

public void keyTyped(KeyEvent e){}

public void keyPressed(KeyEvent e)

{
if(e.getKeyCode()>=37&&e.getKeyCode()<=40)
{

gravaLetra[aondeX-1][aondeY-1] = letra;
letra = ' ';
reImpriLetra = true;

if(e.getKeyCode()==39)
{

if(aondeX == 10)
{
posX = 28;
aondeX = 1;
}
else
{
posX+=25;
aondeX++;
}
}
if(e.getKeyCode()==37)
{
if(aondeX==1)
{
posX+=(25*9);
aondeX=10;
}
else
{
posX-=25;
aondeX--;
}
}

if(e.getKeyCode()==38)
{
if(aondeY==1)
{
aondeY = 10;
posY+=(25*9);
}
else
{
aondeY--;
posY-=25;
}
 }
if(e.getKeyCode()==40)
{
if(aondeY==10)
{
posY=28;
aondeY=1;
}
else
{
posY+=25;
aondeY++;
}
}

if(gravaLetra[aondeX-1][aondeY-1]!=' ')
{
letra = gravaLetra[aondeX-1][aondeY-1];
gravaLetra[aondeX-1][aondeY-1] = ' ';
//System.err.println(letra+"");
}

repaint();
}

else
{

if(letra!=' ')
 {
gravaLetra[aondeX-1][aondeY-1] = ' ';
impriLetra = true;
repaint();
}

impriLetra = true;
letra = Letra.retornaLetra(e.getKeyCode());
reImpriLetra = true;
repaint();
}
}

public void keyReleased(KeyEvent e){}

public char[][] inicializa(char a[][])

{

for(int i=0; i<10; i++)

for(int j=0; j<10; j++)
a[i][j] = ' ';

return a;
}
}[/code]

[code]Clase Letra -> um pessima classe, fazendo quem inventou a orientação ao

objecto remoer no cachão!!
public class Letra{
public static char retornaLetra(int a)
{
switch(a)
{
case 65:
return 'A';

case 66:
return 'B';

case 67:
return 'C';

case 68:
return 'D';

case 69:
return 'E';

case 70:
return 'F';

case 71:
return 'G';

case 72:
return 'H';

case 73:
return 'I';
case 74:
return 'J';

case 75:
return 'K';

case 76:
return 'L';

case 77:
return 'M';

case 78:
return 'N';

case 79:
return 'O';

case 80:
return 'P';

case 81:
return 'Q';

case 82:
return 'R';

case 83:
 return 'S';

case 84:
return 'T';

case 85:
return 'U';

case 86:
return 'V';

case 87:
return 'W';

case 88:
return 'X';

case 89:
return 'Y';

case 90:
return 'Z';

return ' ';

}
}[/code]
Seus problemas acabaram

http://fivedots.coe.psu.ac.th/~ad/jg/

Antes de baixar os capítulos, recomendo ter bastante comida estocada em volta de

você e colocar seu computador no banheiro, pois não vai conseguir parar

Caça palavras não encontra a palavra

Galera, tô tentando fazer um jogo de caça palavras em java, mas não estou
conseguindo encontrar a palavra, alguém pode ajudar?

Segue o código:

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.Scanner;

public class File {

public static void main(String[]args) throws Exception{
// File arquivo = new File ("C:\\teste01.txt");

FileReader arquivo = new FileReader ("C:\\teste01.txt");

BufferedReader br = new BufferedReader(arquivo);
Scanner sc = new Scanner(System.in);

char[][] matriz = null;

String entrada = null;
int coluna = 0;
boolean primeira = true;
while (br.ready()){
String linha = br.readLine();
 if(primeira) {
String []b = linha.split(" ");
int a = Integer.parseInt(b[0]);
int d = Integer.parseInt(b[1]);
matriz = new char[a][d];
primeira = false;
} else {
char[] auxLinha = linha.toCharArray();

for (int i = 0; i < auxLinha.length; i++) {

matriz[coluna][i] = auxLinha[i];
}

coluna++;
}
}

for (int i = 0; i < matriz.length; i++) {

for (int j = 0; j < matriz[i].length; j++) {
System.out.print(matriz[i][j]+" ");
}
System.out.println("\n");
}

br.close();

int i, j, k, n = 0, p = 0, t; //Contadores

int encontrada = 0; // SIM = 1. NÃO = 0.

char palavra[][] = null ;

for (i = 0; i < p; i++)
System.out.println("DIGITE A PALAVRA:\n");
String palavraNextLine = sc.nextLine(); //Armazena as palavras que serão buscadas
na matriz.

System.out.println("RESULTADO:\n");

for (k = 0; k < p; k++) //Para cada palavra

{
//Inicialmente a palavra é considerada Não-Encontrada.
encontrada = 0;

for (i = 0; i < n; i++) //Para cada linha da matriz

{
 for (j = 0; j < n; j++) //Para cada coluna da matriz
{
if (palavra[k][0] == matriz[i][j]) //Se a primeira letra for encontrada
{
if (palavra[k][1] == matriz[i - 1][j]) //Se a segunda letra for encontrada acima
(Norte)
{
encontrada = 1;

for (t = 0; t < (palavra[k]).length; t++)

if (palavra[k][t] != matriz[i - t][j])
encontrada = 0;

if (encontrada == 1){
break;
}else{
return;
}
}

if (palavra[k][1] == matriz[i + 1][j]) //Se a segunda letra for encontrada abaixo

(Sul)
{
encontrada = 1;

for (t = 0; t < (palavra[k].length); t++)

if (palavra[k][t] != matriz[i + t][j])
encontrada = 0;

if (encontrada == 1){
break;
}else{
return;
}
}

if (palavra[k][1] == matriz[i][j + 1]) //Se a segunda letra for encontrada a

direita (Leste)
{
encontrada = 1;

for (t = 0; t < (palavra[k].length); t++)

if (palavra[k][t] != matriz[i][j + t])
encontrada = 0;

if (encontrada == 1){
break;
 }else{
return;
}
}

if (palavra[k][1] == matriz[i][j - 1]) //Se a segunda letra for encontrada a

esquerda (Oeste)
{
encontrada = 1;

for (t = 0; t < (palavra[k].length); t++)

if (palavra[k][t] != matriz[i][j - t])
encontrada = 0;

if (encontrada == 1){
break;
}else{
return;
}
}

if (palavra[k][1] == matriz[i - 1][j + 1]) //Se a segunda letra for encontrada

acima-direita (Nordeste)
{
encontrada = 1;

for (t = 0; t < (palavra[k].length); t++)

if (palavra[k][t] != matriz[i - t][j + t])
encontrada = 0;

if (encontrada == 1){
break;
}else{
return;
}
}

if (palavra[k][1] == matriz[i - 1][j - 1]) //Se a segunda letra for encontrada

acima-esquerda (Noroeste)
{
encontrada = 1;

for (t = 0; t < (palavra[k].length); t++)

if (palavra[k][t] != matriz[i - t][j - t])
encontrada = 0;

if (encontrada == 1){
 break;
}else{
return;
}
}

if (palavra[k][1] == matriz[i + 1][j + 1]) //Se a segunda letra for encontrada

abaixo-direita (Sudeste)
{
encontrada = 1;

for (t = 0; t < (palavra[k].length); t++)

if (palavra[k][t] != matriz[i + t][j + t])
encontrada = 0;

if (encontrada == 1){
break;
}else{
return;
}
}

if (palavra[k][1] == matriz[i + 1][j - 1]) //Se a segunda letra for encontrada

abaixo-esquerda (Sudoeste)
{
encontrada = 1;

for (t = 0; t < (palavra[k].length); t++)

if (palavra[k][t] != matriz[i + t][j - t])
encontrada = 0;
if (encontrada == 1){
break;
}else{
return;
}
}
}
}

if (encontrada == 1){
break;
}else{
return;
}
}
}
 //Depois da verificação ele diz se a palavra foi encontrada ou não, então passa para
a verificação da próxima palavra.
if (encontrada == 1){
System.out.println(" PALAVRA ENCONTRADA\n");
}else{
System.out.println(" PALAVRA NAO ENCONTRADA\n");
}
}
}

11
1. Use o tipo boolean! Ele é seu amigo e serve para ajudar! Não
utilize int com 0 e 1 para representar valores verdadeiro/falso ou sim/não.
2. Aprenda a identar o código. Só de ver a forma como você posicionou os
blocos else, me dá a entender que você os colocou no lugar errado e com
isso, você acaba entendendo errado o seu próprio código.
3. Isso daqui, que aparece repetido nove vezes no seu código NÃO faz o que
você quer:
4. if (encontrada == 1) {
5. break;
6. } else {
7. return;
8. }
Em especial, o return dentro do método main faz o seu programa abortar
imediatamente, não importando se ele encontrou ou não a palavra. No
caso do seu programa, você não deveria usar return em lugar nenhum.
9. Você não verifica os limites da matriz antes de acessar os seus elementos,
e como resultado terá alguns IndexOutOfBoundsException. Por exemplo,
nesta linha:
10. if (palavra[k][1] == matriz[i - 1][j]) //Se a segunda letra for encontrada
acima (Norte)
Adivinha o que vai acontecer se i tiver o valor 0? O correto é verificar isso
antes de tentar acessar o índice:

if (i > 0 && palavra[k][1] == matriz[i - 1][j]) //Se a segunda letra for

encontrada acima (Norte)
11. Você pode dar nome para os seus laços for, while e do-while. Por exemplo:
12. a: for (int i = 0; i < n; i++) {
13. b: for (int j = 0; j < n; j++) {
14. // ... blablabla
15. break a; // Interrompe o laço a (e também o laço b).
16. // ... blablabla
17. }
18. }
Usando isso, a lógica do seu programa pode ser simplificada um bocado. O
mesmo vale para continue.
 19. Dar o nome da sua classe de File é uma péssima ideia, afinal isso vai te dar
dor-de-cabeça quando você for precisar da classe java.io.File. Use um
nome diferente, tal como CacaPalavras.
20. Utilize a sintaxe try-with-resources para ler dados de arquivos, tal como
você faz com o seu BufferedReader.
21. Prefira declarar as variáveis no ponto aonde serão usadas (dentro do for)
do que todas elas juntas do lado de fora. A regra de ouro é não deixar elas
terem um escopo maior que o necessário.
22. O algoritmo fica bem mais simples se você dividi-lo em vários métodos.
Uma abordagem orientada a objetos
Este problema pode ser resolvido também com um pouco da boa e velha orientação a
objetos, diminuindo a repetição de código e a quantidade de loops e ifs a fim de
facilitar o desenvolvimento e ter um resultado final mais simples:

public class CacaPalavras {

public static boolean palavraEncontrada(char[][] tabuleiro, String palavra) {

for (int posicaoY = 0; posicaoY < tabuleiro.length; posicaoY++) {

for (int posicaoX = 0; posicaoX < tabuleiro[posicaoY].length; posicaoX++) {

if (tabuleiro[posicaoY][posicaoX] == palavra.charAt(0)) {

for(Direcao direcao: Direcao.values()) {

if (TabuleiroNavegavel.existePalavra(palavra, tabuleiro, direcao,
posicaoY, posicaoX)) {
return true;
}
}
}
}
}
return false;
}
}
Eu utilizei a mesma lógica proposta por você: percorrer o tabuleiro da esquerda para a
direita e de cima para baixo e, ao encontrar uma letra que coincida com a primeira
letra da palavra procurada, passa a percorrer o tabuleiro nos mais diversos sentidos
para ver se encontra a palavra completa.

O restante do código que faz a mágica acontecer está abaixo:

class TabuleiroNavegavel {
public static boolean existePalavra(String palavra, char[][] tabuleiro,
Direcao direcao, int posicaoInicialY, int posicalInicialX) {
 StringBuilder palavraEncontrada = new StringBuilder();

NavegadorLetras letras = direcao.letras(tabuleiro,

posicaoInicialY, posicalInicialX);

int qtdLetrasLidas = 0;

while(letras.temProxima() && qtdLetrasLidas <= palavra.length()) {

palavraEncontrada.append(letras.proxima());
qtdLetrasLidas++;
}
return palavraEncontrada.toString().equals(palavra);
}
}

interface NavegadorLetras {
boolean temProxima();
char proxima();
}

interface LetrasNavegaveis {
NavegadorLetras navegador(final char[][] tabuleiro,
final int posicaoInicialY, final int posicalInicialX);
}

enum Direcao {
LESTE(new Leste()),
SUDESTE(new Sudeste()),
SUL(new Sul()),
NORDESTE(new Nordeste());

private LetrasNavegaveis letrasNavegaveis;

Direcao(LetrasNavegaveis letrasNavegaveis) {
this.letrasNavegaveis = letrasNavegaveis;
}
public NavegadorLetras letras(char[][] tabuleiro,
int posicaoInicialY, int posicalInicialX){
return letrasNavegaveis.navegador(tabuleiro, posicaoInicialY, posicalInicialX);
}
}

class Leste implements LetrasNavegaveis {

public NavegadorLetras navegador(final char[][] tabuleiro,

final int posicaoInicialY, final int posicalInicialX) {

return new NavegadorLetras() {

 int posicaoX = posicalInicialX;
int posicaoY = posicaoInicialY;

public boolean temProxima() {

return posicaoX < tabuleiro[posicaoY].length;
}
public char proxima() {
char letra = tabuleiro[posicaoY][posicaoX];
posicaoX++;
return letra;
}
};
}
}

class Sudeste implements LetrasNavegaveis {

public NavegadorLetras navegador(final char[][] tabuleiro,

final int posicaoInicialY, final int posicalInicialX) {

return new NavegadorLetras() {

int posicaoY = posicaoInicialY;

int posicaoX = posicalInicialX;

public boolean temProxima() {

return posicaoY >= 0 && posicaoY < tabuleiro.length
&& posicaoX >= 0 && posicaoX < tabuleiro[posicaoY].length;
}
public char proxima() {
char letra = tabuleiro[posicaoY][posicaoX];
posicaoY++;
posicaoX++;
return letra;
}
};
}
}

class Sul implements LetrasNavegaveis {

public NavegadorLetras navegador(final char[][] tabuleiro, final int posicaoInicialY,

final int posicalInicialX) {

return new NavegadorLetras() {

int posicaoY = posicaoInicialY;
int posicaoX = posicalInicialX;
 public boolean temProxima() {
return posicaoY >= 0 && posicaoY < tabuleiro.length;
}
public char proxima() {
char letra = tabuleiro[posicaoY][posicaoX];
posicaoY++;
return letra;
}
};
}
}

class Nordeste implements LetrasNavegaveis {

public NavegadorLetras navegador(final char[][] tabuleiro,

final int posicaoInicialY, final int posicalInicialX) {

return new NavegadorLetras() {

int posicaoY = posicaoInicialY;
int posicaoX = posicalInicialX;

public boolean temProxima() {

return posicaoY >= 0 && posicaoY < tabuleiro.length
&& posicaoX < tabuleiro[posicaoY].length;
}
public char proxima() {
char letra = tabuleiro[posicaoY][posicaoX];
posicaoY--;
posicaoX++;
return letra;
}
};
}
}
Um exemplo de código consumidor:

@Test
public void cacaPalavras() {

char[][] tabuleiro = new char[][] {

{'R','X','L','X','A'},
{'X','A','U','X','X'},
{'R','U','I','V','A'},
{'X','A','Z','V','X'},
{'C','X','A','X','A'}};

assertTrue(CacaPalavras.palavraEncontrada(tabuleiro, "RUIVA"));
assertTrue(CacaPalavras.palavraEncontrada(tabuleiro, "RAIVA"));
 assertTrue(CacaPalavras.palavraEncontrada(tabuleiro, "LUIZA"));
assertTrue(CacaPalavras.palavraEncontrada(tabuleiro, "CAIXA"));
assertFalse(CacaPalavras.palavraEncontrada(tabuleiro, "INEXISTENTE"));
}
Você pode envolver este código com a sua lógica de ler o tabuleiro de um arquivo e
solicitar uma lista de palavras do usuário :-)

Como estender a solução

Veja que eu só implementei o padrão mais ocidental de leitura, por assim dizer: leste,
sul, sudeste, nordeste.

Mas para implementar mais padrões é muito simples. Você não precisa inserir código
no meio de um grande e complexo método nem reprogramar o fluxo do programa. Ao
invés, você define um nova direção de leitura na enumeração e declara uma classe
especializada em ler nesta direção.

Se você quiser por exemplo implementar agora a direção sudoeste de leitura, basta
declarar a seguinte classe:

class Sudoeste implements LetrasNavegaveis {

public NavegadorLetras navegador(final char[][] tabuleiro, final int posicaoInicialY,

final int posicalInicialX) {

return new NavegadorLetras() {

int posicaoY = posicaoInicialY;
int posicaoX = posicalInicialX;

public boolean temProxima() {

return posicaoY < tabuleiro.length
&& posicaoX >= 0;
}
public char proxima() {
char letra = tabuleiro[posicaoY][posicaoX];
posicaoY++;
posicaoX--;
return letra;
}
};
}
}
E adicionar esta nova direção de leitura na enumeração:

SUDOESTE(new Sudoeste());
Agora, no teste abaixo, a palavra "Ruiva" será encontrada:

@Test
public void sudoeste() {
char[][] tabuleiro = new char[][] {
{' ',' ',' ',' ','R'},
{' ',' ',' ','U',' '},
{' ',' ','I',' ',' '},
{' ','V',' ',' ',' '},
{'A',' ',' ',' ',' '}};

assertTrue(CacaPalavras.palavraEncontrada(tabuleiro, "RUIVA"));
}
E pronto :-)

Conclusão
Eu e muitos dos nossos colegas consideram este código bastante simples mas eu
entendo que talvez você não o compreenda completamente ainda.

Minha sugestão, é claro, é que você tente compreender.

Alguns recursos do Java que foram utilizados aí:

 Interface
 Enumeração.
 Extensão de enumeração: eu adicionei um atributo a cada item da
enumeração, que é o objeto especializado em percorrer o tabuleiro
naquela direção.
E apesar de eu não considerar quantidade total de linhas muito importante, eu
observo que embora meu código funcione ele tem ainda menos linhas que o código
original da pergunta.