Java - Movimiento W,A,S,D en una matriz 1 y 0. AYUDAA PLEASE

 
Vista:

Movimiento W,A,S,D en una matriz 1 y 0. AYUDAA PLEASE

Publicado por Gerardo Serrano (3 intervenciones) el 08/01/2020 21:57:08
Hola tengo un problema con mi codigo, el ejercicio que estoy resolviendo se encuentra en el minuto 14:10 de este video: https://www.youtube.com/watch?v=6qgOFZnhYEA&t=611s

Bueno la cuestion es que no logro mover mi 1 hacia abajo y poner un 0 en el lugar anterior para ir desplazandome por mi tablero que seria una matriz de 3x3, intento mover el 1 con w,a,s,d y primero estaba probando con "case s:" pero sigo sin entender porque no lo mueve

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
package paquete1;
 
public class Movimiento {
 
    // atributos
 
    int x = 0;
    int y = 0;
 
 
    // metodos
 
    // Metodo constructor
 
    public Movimiento(char L){
 
    this.y = y;
    this.x = x;
 
    }
 
    public int Arriba(){
 
        x--;
 
        return y;
 
    }
 
    public int Abajo(){
 
        x++;
 
        return y;
 
    }
 
    public int Izq(){
 
        y--;
 
        return x;
 
    }
 
    public int Der(){
 
        y++;
 
        return x;
    }
 
 
}
 
// Esa es una clase
 
// Aca esta la siguiente clase en la que estoy trabajando:
 
 
package paquete1;
 
import paquete1.Movimiento; // importo la clase de movimiento
import javax.swing.JOptionPane;
 
public class Main {
 
    public static void main(String[] args){
 
        // variables
        int x = 0;
        int y = 0;
        int xa = 0;
        int ya = 0;
        boolean repetir = true;
        char L = 's';
 
 
        int tablero[][] = new int[3][3];
 
        // constantes
 
        // algoritmos
 
        Movimiento objac = new Movimiento(L);
 
        System.out.println("Bienvenido eres el numero uno \ny te podras mover entre los ceros.");
        System.out.println();
 
        tablero[x][y] = 1;
 
        for(int i = 0; i<x; i++){
 
            for(int j = 0; j<y; j++){
 
                System.out.print(tablero[i][j]);
 
            }
            System.out.println();
 
        }
 
        while(repetir == true){
 
        L = JOptionPane.showInputDialog(null, "").charAt(0);
 
        switch(L){
 
            case ('w' | 'W') :
 
 
 
 
                      break;
            case 'a' :
                      System.out.println("A");
                      break;
            case 's' :
 
                      xa = x; // guardo la posicion anterior
                      ya = y;
 
                      x = objac.Abajo();
 
                      tablero[xa][ya] = 0; // la pos anterior se vuelve 0
                      tablero[x][y] = 1; // la nueva posicion se vuelve 1
 
                       for(int i = 0; i<3; i++){
 
                         for(int j = 0; j<3; j++){
 
                          System.out.print(tablero[i][j]);
                          }
 
                         System.out.println();
                       }
 
                      break;
            case 'd' :
                      System.out.println("D");
                      break;
            default :
                      System.out.println("ERROR, Unicamente \"w,a,s,d\" en minuscula.");
                      break;
        }
 
 
    }
 
 
 
    }
}
 
// PD: Aclaro que mi codigo sigue incompleto porque no entiendo como resolver ni siquiera el caso para bajar hacia abajo XD.
Valora esta pregunta
Me gusta: Está pregunta es útil y esta claraNo me gusta: Está pregunta no esta clara o no es útil
0
Responder
Imágen de perfil de Kabuto
Val: 2.268
Oro
Ha mantenido su posición en Java (en relación al último mes)
Gráfica de Java

Movimiento W,A,S,D en una matriz 1 y 0. AYUDAA PLEASE

Publicado por Kabuto (568 intervenciones) el 13/01/2020 13:51:46
Hola.
Veo cosas que quizás no sean correctas. En los métodos de movimiento, si modificas la x, devuelves la y que no se ha modificado, o viceversa.

Por otra parte, creo que las cosas se simplifican más si a esto le metemos más POO.

Yo crearía una clase llamada Tablero. Su atributo sería una matriz de int con las dimensiones que queramos indicarle por el constructor de la clase.
Tendría otro atributo para guardar la posición donde está actualmente el valor 1. Para conocer esta posición necesitamos dos valores, X e Y, por lo tanto los guardamos en un array de dos dimensiones para tenerlos juntos en un único atributo.
Esta clase tendría los métodos necesarios para mostrar en pantalla la matriz y para reposicionar el valor 1 cada vez que el usuario decida moverlo.

Luego otra clase llamada Movimiento muy similar a la que has hecho tú.
Los cambios que le haría es que esta clase debe controlar que nos movemos dentro de los límites de la matriz sin salirnos de ella.

Es decir, si la matriz es de 3 x 3, las posiciones válidas solo van de 0 a 2 en ambas dimensiones.
Pues los valores X e Y nunca pueden tener valores menores de 0 (valores negativos) ni superiores a 2.

Para controlar esto, esta clase necesita conocer las dimensiones del Tablero, su ancho y su alto. Así que tendrá atributos para guardar estos valores que recibirá por su constructor, valores los cuáles la propia clase Tablero se encargará de comunicarle mediante un método.

Los métodos para mover Arriba, Abajo, etc.... comprobarán que estamos dentro de los límites antes de mover nada y además no devolverán ningún valor.
Existirá otro método que retornara juntos los valores X e Y para que el Tablero sepa donde tiene que reposicionar (mover) el valor 1.

Mira, esta podría ser la clase Movimiento:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
package moverMatriz;
 
public class Movimiento {
 
	private int x; //Para movernos a lo ANCHO (izquierda-derecha)
	private int y; //Para movernos a lo ALTO (arriba-abajo)
	//La matriz tendrá unos límites máximos donde movernos.
	private int limiteX;
	private int limiteY;
 
	public Movimiento(int anchoMatriz, int altoMatriz) {
		x = 0;
		y = 0;
		limiteX = anchoMatriz - 1; //Si por ejemplo el ancho es 10, solo podemos movernos de 0 a 9
		limiteY = altoMatriz - 1;
	}
 
	public void Arriba() {
		if (y > 0) //Solo decrementamos si el valor actual es mayor que 0
			y--;
	}
 
	public void Abajo() {
		if (y < limiteY) //Solo incrementos si estamos por debajo del límite
			y++;
	}
 
	public void Izquierda() {
		if (x > 0)
			x--;
	}
 
	public void Derecha() {
		if (x < limiteX)
			x++;
	}
 
	/*
	 * Este método devuelve los valores X e Y
	 * para indicar la posición actual a la que
	 * nos hemos movido.
	 * Para poder enviar estos dos valores juntos,
	 * los metemos en un pequeño array de 2 elementos.
	 */
	public int[] getPosicion() {
		int[] posicion = new int[2];
		posicion[0] = x;
		posicion[1] = y;
		return posicion;
	}
}

Y esta podría ser la clase Tablero

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
package moverMatriz;
 
public class Tablero {
 
	private int[][] tablero;
	private int[] posicion1; //Este array guarda la posicion actual del valor 1
 
	public Tablero(int ancho, int alto) {
		tablero = new int[ancho][alto];
		posicion1 = new int[2];
		//Posicionamos ya el valor 1
		tablero[posicion1[1]][posicion1[0]] = 1;
	}
 
	public int getAlto() {
		return tablero.length;
	}
 
	public int getAncho() {
		return tablero[0].length;
	}
 
	public void mostrarTablero() {
		System.out.println("\n------------------------\n");
		for (int i = 0; i < tablero.length; i++) {
			for (int j = 0; j < tablero[0].length; j++)
				System.out.print(tablero[i][j] + " ");
 
			System.out.println();
		}
	}
	/*
	 * Este método posiciona el 1 según los valores
	 * que luego recibirá de la la clase Movimiento.
	 * Esta clase nos dará un array con los valores X e Y.
	 * La posicion [0] tendrá la X, es decir, el eje izquierda-derecha.
	 * Este valor se lo damos al tablero como segundo apuntador porque
	 * recorre las COLUMNAS de la matriz.
	 * La Y es el eje arriba-abajo, es decir, las FILAS de la matriz y
	 * por eso sería el primer apuntador.
	 *
	 * Es decir, recibimos un array con valores: {x, y}
	 * Pero al tablero/matriz se lo damos en orden invertido: tablero[y][x]
	 */
	public void posicionar1(int[] posicion) {
		//Primero ponemos un 0 en la posicion actual del valor 1
		tablero[posicion1[1]][posicion1[0]] = 0;
		//Segundo, ponemos el 1 en la nueva posicion
		tablero[posicion[1]][posicion[0]] = 1;
		//Tercero, guardamos la nueva posicion como actual
		posicion1 = posicion;
	}
}

Luego viene una tercera clase con el método main(), donde instanciamos las dos clases anteriores y vamos pidiendo valores al usuario para que vaya moviendo el valor 1

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
package moverMatriz;
 
import javax.swing.JOptionPane;
 
public class Mover1 {
 
	public static void main(String[] args) {
		Tablero tablero = new Tablero(4, 4);
		Movimiento movimiento = new Movimiento(tablero.getAncho(), tablero.getAlto());
		boolean repetir = true;
		tablero.mostrarTablero();
 
		while (repetir) {
 
			String opcion = JOptionPane.showInputDialog(null,
					"Usa (W,A,S,D) para mover el 1.\nPulsa T para Terminar");
 
			if (opcion != null) { //Si el usuario cancela el JOptionPane, obtendríamos un null problemático
				switch (opcion.toLowerCase().charAt(0)) {
					case 'w':
						movimiento.Arriba();
						tablero.posicionar1(movimiento.getPosicion());
						tablero.mostrarTablero();
						break;
					case 'a':
						movimiento.Izquierda();
						tablero.posicionar1(movimiento.getPosicion());
						tablero.mostrarTablero();
						break;
					case 's':
						movimiento.Abajo();
						tablero.posicionar1(movimiento.getPosicion());
						tablero.mostrarTablero();
						break;
					case 'd':
						movimiento.Derecha();
						tablero.posicionar1(movimiento.getPosicion());
						tablero.mostrarTablero();
						break;
					case 't':
						repetir = false;
						break;
					default:
						JOptionPane.showMessageDialog(null, "Opcion Equivocada", "Mover",
								JOptionPane.WARNING_MESSAGE);
				}
			}
		}
 
		JOptionPane.showMessageDialog(null, "Fin del programa", "Mover",
				JOptionPane.INFORMATION_MESSAGE);
		System.out.println("\nPrograma Terminado");
 
	}
 
}

En mi caso, las tres clases están dentro del mismo package así que no hay que importarlas. Tú ya organiza las clases como tu prefieras.

Si ejecutamos este código, cada vez que el usuario introduce una opción válida en los JOptionPane que le mostramos, el Tablero se redibuja con el 1 desplazándose por la matriz.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
------------------------
 
1 0 0 0
0 0 0 0
0 0 0 0
0 0 0 0
 
------------------------
 
0 0 0 0
1 0 0 0
0 0 0 0
0 0 0 0
 
------------------------
 
0 0 0 0
0 1 0 0
0 0 0 0
0 0 0 0
 
------------------------
 
0 0 0 0
0 0 1 0
0 0 0 0
0 0 0 0
 
------------------------
 
0 0 0 0
0 0 0 0
0 0 1 0
0 0 0 0
 
------------------------
 
0 0 0 0
0 0 0 0
0 1 0 0
0 0 0 0
 
------------------------
 
0 0 0 0
0 0 0 0
1 0 0 0
0 0 0 0
 
------------------------
 
0 0 0 0
1 0 0 0
0 0 0 0
0 0 0 0
 
Programa Terminado

Fíjate como Orientando el Programa más a Objetos (POO), aunque haya que escribir un poquito más, todo queda más simplificado, más comprensible para la mente humana, más fácil de luego añadir nuevas funcionalidades....
Si por ejemplo quisiéramos que saliera un aviso al usuario cuando intenta moverse fuera de los límites de la matriz, basta con hacer pequeños cambios a la clase Movimiento.

Fíjate también que las clases Tablero y Movimiento sirven para matrices de CUALQUIER tamaño. En el main() podríamos preguntarle al usuario que dimensiones desea aplicar al tablero y ambas clases se adaptarían al tamaño elegido.

En fin, creo que con los comentarios que he puesto se entiende bien. Pero no dudes en preguntar cualquier cosa que no entiendas.
Un saludo.
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
3
Comentar