java - 试图让游戏工作，循环条件

Question

我将尝试简单而清晰地解释我得到了什么以及我需要什么。

我有一个二维数组，制作了一个 char 元素板。我必须从底部拍摄一张用“·”显示的照片。镜头从底部 (a.length-1) 到顶部 (0)，在墙壁上反弹，具体取决于拍摄方向。

if (dirDisp == 3){
            for(int x = 3, y = 0; x < 5 & y < 2; x++, y++) {
                if(a[(a.length-1) - y][(a[x].length-1) / 2 + x] == EMPTY)
                    a[(a.length-1) - y][(a[x].length-1) / 2 + x] = '·';
            }
            for(int x = 0, y = 1; x < 9 & y < 11; x++, y++) {
                if(a[(a.length-1) - y][(a[x].length-1) - x] == EMPTY)
                    a[(a.length-1) - y][(a[x].length-1) - x] = '·';
            }
            for(int x = 0, y = 9; x < 5 & y < 14; x++, y++) {
                if(a[(a.length-1) - y][x] == EMPTY)
                    a[(a.length-1) - y][x] = '·';
            }
        }

我已将拍摄方向 = 3 的代码放在上面。EMPTY 常量是“”。问题是我在数组中也有其他字符，比如'a'、'b'等。

我想要的是在没有 EMPTY 的情况下停止循环。它的实际作用是：

 g  g  b  g  g  y  y  r  r 
 y  o  y  a  r  y  g  o  b 
 g  o  r  a  b  r  a  a  b 
 g  y  o  a  y  a  g  o  b 
 g  a  b  b  b  o  o  b  g 
    ·                      
       ·                   
 r  r  r  r  r  r  r  r  r 
             ·             
                ·          
                   ·       
                      ·    
                         · 
                      ·   

当镜头到达与 EMPTY 不同的第一个字符时，镜头必须停止。我尝试使用中断并继续。还有使用firstLoop:{}。我也尝试在循环的每个部分使用布尔值，但我还没有让它工作。我需要一点帮助。

如果有不清楚的地方问。

PD：这个镜头有3个“for”循环，第一个是从底部到第一面墙填充阵列，第二个是墙和墙之间的空间，第三个是顶部相对的墙。PD2： 'r' 行是为了让你看看实际发生了什么。

---

使用布尔值后：

 a  b  a  b  y  a  r  y  y 
 y  a  o  y  g  r  o  g  g 
 g  o  y  o  a  y  y  a  y 
 y  o  a  a  g  o  o  b  a 
 o  o  r  a  o  r  g  y  y 


 r  r  r  r  r  r  r  r  r 




                         · 
                      ·   

---

主班

import java.util.Scanner;
import java.util.ArrayList;
import java.util.Stack;

public class BobbleTexto {

        public static Scanner sc = new Scanner(System.in);

        public static char RED = 'r';
        public static char GREEN = 'g';
        public static char  BLUE = 'b';
        public static char ORANGE = 'o';
        public static char  YELLOW = 'y';
        public static char  GRAY = 'a';
        public static char PURPLE = 'p';
        public static char EMPTY = ' ';

        public static char IZQUIERDA = 'A';
        public static char DERECHA = 'D';
        public static char DISPARO = 'S';
        public static char SALIR = 'Q';

        public static char [][] generarTablero (){

            char [][] a = new char [14][9];

            for (int x = 0; x < a.length; x++){
                for (int y = 0; y < a[x].length;y++){
                    a [x][y] = EMPTY;
                }
            }
            for(int x = 0; x < 5; x++){
              for(int y = 0; y < a[y].length; y++){
                  a[x][y] = generarBurbuja();
                     a[7][y] = RED;
              }
            }
            return a;
        }
        public static char [][] limpiarTablero (char [][] a){
            for (int x = 0; x < a.length; x++){
                for (int y = 0; y < a[x].length;y++){
                    if (a [x][y] == '·')
                        a[x][y] = EMPTY;
                }
            }
            return a;
        }
        public static void imprimirDisparo (char [][] a,int dirDisp,char Burbuja){
            if (dirDisp == 1){
                for(int x = 1, y = 0; x < 5 & y < 4; x++, y++){
                    if(a[(a.length-1) - y][(a[x].length-1) / 2 + x] == EMPTY){
                    a[(a.length-1) - y][(a[x].length-1) / 2 + x] = '·';
                    }
                    else{
                        break;
                    }
                }
                for(int x = 0, y = 3; x < 9 & y < 11; x++, y++){
                    if(a[(a.length-1) - y][(a[x].length-1) - x] == EMPTY){
                        a[(a.length-1) - y][(a[x].length-1) - x] = '·'; 
                    }
                    else{
                    }
                }
                for(int x = 0, y = 11; x < 4 & y < 14; x++, y++){
                    if(a[(a.length-1) - y][x] == EMPTY){
                        a[(a.length-1) - y][x] = '·';
                    }
                    else{
                        break;
                    }
                }   
            }
            if (dirDisp == 2){
                    for(int x = 2, y = 0; x < 5 & y < 3; x++, y++){
                        if(a[(a.length-1) - y][(a[x].length-1) / 2 + x] == EMPTY){
                            a[(a.length-1) - y][(a[x].length-1) / 2 + x] = '·';
                        }
                        else {
                        }
                    }
                    for(int x = 0, y = 2; x < 9 & y < 11; x++, y++){
                        if(a[(a.length-1) - y][(a[x].length-1) - x] == EMPTY){
                            a[(a.length-1) - y][(a[x].length-1) - x] = '·';
                        }
                        else {
                        }
                    }
                    for(int x = 0, y = 10; x < 4 & y < 14; x++, y++){
                        if(a[(a.length-1) - y][x] == EMPTY){
                            a[(a.length-1) - y][x] = '·';
                        }
                        else {
                        }
                    }
            }

            if (dirDisp == 3){
                boolean foundObstacle = false;
                for(int x = 3, y = 0; x < 5 & y < 2 && !foundObstacle; x++, y++){
                    if(a[(a.length-1) - y][(a[x].length-1) / 2 + x] == EMPTY)
                       a[(a.length-1) - y][(a[x].length-1) / 2 + x] = '·';
                    else {
                        foundObstacle = true;
                        break;
                    }
                }
                if(!foundObstacle) {
                    for(int x = 0, y = 1; x < 9 & y < 11 && !foundObstacle; x++, y++){
                        if(a[(a.length-1) - y][(a[x].length-1) - x] == EMPTY)
                           a[(a.length-1) - y][(a[x].length-1) - x] = '·';
                        else {
                            foundObstacle = true;
                            break;
                        }
                    }
                }
                if(!foundObstacle) {
                    for(int x = 0, y = 9; x < 5 & y < 14 && !foundObstacle; x++, y++){
                        if(a[(a.length-1) - y][x] == EMPTY)
                            a[(a.length-1) - y][x] = '·';
                        else break;
                    }
                }
            }
            if (dirDisp == 4){
                    for(int x = 4, y = 0; x < 5 & y < 1; x++, y++){
                        if(a[(a.length-1) - y][(a[x].length-1) / 2 + x] == EMPTY)
                        a[(a.length-1) - y][(a[x].length-1) / 2 + x] = '·';
                    }
                    for(int x = 0, y = 0; x < 9 & y < 11; x++, y++){
                        if(a[(a.length-1) - y][(a[x].length-1) - x] == EMPTY)
                        a[(a.length-1) - y][(a[x].length-1) - x] = '·';
                    }
                    for(int x = 0, y = 8; x < 6 & y < 14; x++, y++){
                        if(a[(a.length-1) - y][x] == EMPTY)
                        a[(a.length-1) - y][x] = '·';
                    }
            }
            if (dirDisp == 0) {
                    for (int x = 0; x < a.length; x++)
                        if(a[x][(a[x].length - 1) / 2] == EMPTY)
                        a[x][(a[x].length - 1) / 2] = '·';
            }
            if (dirDisp == -1){
                    for(int x = 1, y = 0; x < 5 & y < 4; x++, y++){
                        if(a[(a.length-1) - y][(a[x].length-1) / 2 - x] == EMPTY)
                        a[(a.length-1) - y][(a[x].length-1) / 2 - x] = '·';
                    }
                    for(int x = 1, y = 3; x < 11 & y < 12; x++, y++){
                        if(a[(a.length-1) - y][x-1] == EMPTY)
                        a[(a.length-1) - y][x-1] = '·';
                    }
                    for(int x = 0, y = 11; x < 4 & y < 14; x++, y++){
                        if(a[(a.length-1) - y][(a[x].length-1) - x] == EMPTY)
                        a[(a.length-1) - y][(a[x].length-1) - x] = '·';
                    }
            }
            if (dirDisp == -2){
                    for(int x = 2, y = 0; x < 5 & y < 4; x++, y++){
                        if( a[(a.length-1) - y][(a[x].length-1) / 2 - x] == EMPTY)
                        a[(a.length-1) - y][(a[x].length-1) / 2 - x] = '·';
                    }
                    for(int x = 1, y = 2; x < 10 & y < 12; x++, y++){
                        if(a[(a.length-1) - y][x-1] == EMPTY)
                        a[(a.length-1) - y][x-1] = '·';
                    }
                    for(int x = 0, y = 10; x < 4 & y < 14; x++, y++){
                        if(a[(a.length-1) - y][(a[x].length-1) - x] == EMPTY)
                        a[(a.length-1) - y][(a[x].length-1) - x] = '·';
                    }
            }       
            if (dirDisp == -3){
                    for(int x = 3, y = 0; x < 5 & y < 4; x++, y++){
                        if(a[(a.length-1) - y][(a[x].length-1) / 2 - x] == EMPTY)
                        a[(a.length-1) - y][(a[x].length-1) / 2 - x] = '·';
                    }
                    for(int x = 1, y = 1; x < 10 & y < 12; x++, y++){
                        if(a[(a.length-1) - y][x-1] == EMPTY)
                        a[(a.length-1) - y][x-1] = '·';
                    }
                    for(int x = 0, y = 9; x < 5 & y < 14; x++, y++){
                        if(a[(a.length-1) - y][(a[x].length-1) - x] == EMPTY)
                        a[(a.length-1) - y][(a[x].length-1) - x] = '·';
                    }
            }
            if (dirDisp == -4){
                for(int x = 4, y = 0; x < 5 & y < 4; x++, y++){
                    if(a[(a.length-1) - y][(a[x].length-1) / 2 - x] == EMPTY)
                    a[(a.length-1) - y][(a[x].length-1) / 2 - x] = '·';
                }
                for(int x = 1, y = 0; x < 10 & y < 12; x++, y++){
                    if(a[(a.length-1) - y][x-1] == EMPTY)
                    a[(a.length-1) - y][x-1] = '·';
                }
                for(int x = 0, y = 8; x < 6 & y < 14; x++, y++){
                    if(a[(a.length-1) - y][(a[x].length-1) - x] == EMPTY)
                    a[(a.length-1) - y][(a[x].length-1) - x] = '·';
                }
            }

            for (int x = 0; x < a.length; x++){
                System.out.println();
                for (int y = 0; y < a[x].length; y++){
                    System.out.print(" "+a [x][y]+" ");
                }       
            }

            System.out.println("\nDirección de disparo ["+dirDisp+"]");
            System.out.println("Burbuja ["+Burbuja+"]");
        }
        public static int getDirDisp(){
            int dirDisp = sc.nextInt();
            while (dirDisp < -4 || dirDisp > 4){
                System.out.println("Introduzca una dirección de disparo válida(-1,-2,-3,0,1,2,3)");
                dirDisp = sc.nextInt();
            }

            return dirDisp;
        }
        public static char generarBurbuja(){
            char burbuja = EMPTY;
            int azar = (int) (Math.random() * 6);
            switch (azar){
            case 0 : burbuja = RED; break;
            case 1 : burbuja = GREEN; break;
            case 2 : burbuja = BLUE; break;
            case 3 : burbuja = ORANGE; break;
            case 4 : burbuja = YELLOW; break;
            case 5 : burbuja = GRAY; break;
            case 6 : burbuja = PURPLE; break;
            }
            return burbuja;
        }
        public static char obtenerAccionJugador (){ 
            System.out.println("Acción?");
            String aux = sc.next();
            char accion = aux.charAt(0);
            while (accion != IZQUIERDA && accion != DERECHA && accion != DISPARO && accion != SALIR){
                System.out.println("Introduzca una acción válida:");
                aux = sc.next();
                accion = aux.charAt(0); 
            }
            System.out.println("***************************");
            return accion;
        }

        public static void obtenerTrayectoria (char [][] a){
            System.out.println("Posiciones:");
            for (int x = 0; x < a.length; x++){
                for (int y = 0; y < a[x].length;y++){
                    if(a [x][y] == '·'){
                        Posicion pos = new Posicion(x,y);
                        ArrayList<Posicion> aListPos = new ArrayList<Posicion>();
                        aListPos.add(pos);
                        for(Posicion ii : aListPos){
                            System.out.println("(" + pos.getFila() + "," + pos.getColumna()+")");
                        }
                    }
                }
            }
        }
        public static char [][] realizarDisparo (char [][] a,char Burbuja){
            int c [] = new int [a.length];
            int w = 0;
            for (int x = 0; x < a.length; x++){
                for (int y = 0; y < a[x].length;y++){
                    if (a [x][y] == '·'){
                        w++;
                        c [w]= x;   
                    }
                    if(a[c[1]][y] == '·'){
                        a[c[1]][y] = Burbuja;
                    }
                }   
            }
            return a;
        }
        public static int moverDerecha (int dirDisp, char [][] a){

            if(dirDisp == -4)
                dirDisp = -3;
            else if (dirDisp == -3)
                dirDisp = -2;
            else if (dirDisp == -2)
                dirDisp = -1;
            else if (dirDisp == -1)
                dirDisp = 0;
            else if (dirDisp == 0)
                dirDisp = 1;
            else if (dirDisp == 1)
                dirDisp = 2;
            else if (dirDisp == 2)
                dirDisp = 3;
            else if(dirDisp == 3)
                dirDisp = 4;

            return dirDisp;
        }
        public static int moverIzquierda (int dirDisp, char [][] a){

            if(dirDisp == 4)
                dirDisp = 3;
            else if (dirDisp == 3)
                dirDisp = 2;
            else if (dirDisp == 2)
                dirDisp = 1;
            else if (dirDisp == 1)
                dirDisp = 0;
            else if (dirDisp == 0)
                dirDisp = -1;
            else if (dirDisp == -1)
                dirDisp = -2;
            else if (dirDisp == -2)
                dirDisp = -3;
            else if(dirDisp == -3)
                dirDisp = -4;
            else{}



            return dirDisp;
        }
        public static boolean existenBurbujas (char [][] a){
            boolean result = true;
            int contadorBurbujas = 0;
            for (int x = 0; x < a.length; x++){
                for (int y = 0; y < a[x].length;y++){
                    if(a [x][y] != EMPTY){
                        contadorBurbujas++;
                    }
                }
            }
            if(contadorBurbujas > 0){
                return true;
            }
            return result;
        }
        public static void borrarBurbujasAgrupadas(char [][] b, Posicion p) {
            if(b[p.fila][p.columna] != EMPTY)
                vecinos(b, p.fila, p.columna, b[p.fila][p.columna]);                    
        }
        private static void vecinos(char [][] b, int i_comienzo, int j_comienzo, char destino) {        
            Stack<Integer> ic = new Stack<Integer>();
            Stack<Integer> jc = new Stack<Integer>();

            ic.add(i_comienzo);
            jc.add(j_comienzo);

            int t = 0;
            boolean [][] visitados = new boolean[b.length][b[0].length];

            while( !ic.isEmpty() ) {
                int i = ic.pop();
                int j = jc.pop();
                visitados[i][j] = true;

                t++;                        

                if(j-1 >= 0) {
                    if(b[i][j-1] == destino && !visitados[i][j-1]) {
                        ic.push(i);
                        jc.push(j-1);
                    }
                }
                if(j+1 < b[0].length) {
                    if(b[i][j+1] == destino && !visitados[i][j+1]) {
                        ic.push(i);
                        jc.push(j+1);
                    }
                }
                if(i-1 >=0) {
                    if(b[i-1][j] == destino && !visitados[i-1][j]) {
                        ic.push(i-1);
                        jc.push(j);
                    }
                }
                if(i+1 < b.length) {
                    if(b[i+1][j] == destino && !visitados[i+1][j]) {
                        ic.push(i+1);
                        jc.push(j);
                    }
                }

                if(j-1 >=0 && i-1 >=0) {
                    if(b[i-1][j-1] == destino && !visitados[i-1][j-1]) {
                        ic.push(i-1);
                        jc.push(j-1);
                    }
                }
                if(j+1 < b[0].length && i-1 >= 0 ) {
                    if(b[i-1][j+1] == destino && !visitados[i-1][j+1]) {
                        ic.push(i-1);
                        jc.push(j+1);
                    }
                }
                if(j-1>=0 && i+1<b.length) {
                    if(b[i+1][j-1] == destino && !visitados[i+1][j-1]) {
                        ic.push(i+1);
                        jc.push(j-1);
                    }
                }
                if(j+1<b[0].length && i+1<b.length) {
                    if(b[i+1][j+1] == destino && !visitados[i+1][j+1]) {
                        ic.push(i+1);
                        jc.push(j+1);
                    }
                }
            }   

            if(t >= 3)
                for(int i=0; i<visitados.length; i++)
                    for(int j=0; j<visitados[i].length; j++)
                        if(visitados[i][j])
                            b[i][j] = EMPTY;
        }

        public static void jugar (){
            Posicion p = new Posicion();
            char [][] a = generarTablero();
            System.out.println("Introduzca la dirección de disparo(-1,-2,-3,-4,0,1,2,3,4)");
            int dirDisp = getDirDisp();
            char Burbuja = generarBurbuja();
            imprimirDisparo(a,dirDisp,Burbuja); 
            char accion = obtenerAccionJugador();
            while(true){
                if (accion == IZQUIERDA){
                    dirDisp = moverIzquierda(dirDisp,a); 
                    limpiarTablero(a);
                    imprimirDisparo(a,dirDisp,Burbuja);
                    accion = obtenerAccionJugador();
                }

                else if(accion == DERECHA) {
                    dirDisp = moverDerecha(dirDisp,a);
                    limpiarTablero(a);
                    imprimirDisparo(a,dirDisp,Burbuja);
                    accion = obtenerAccionJugador();
                }

                else if(accion == DISPARO){
                    realizarDisparo(a,Burbuja);
                    borrarBurbujasAgrupadas(a,p);
                    Burbuja = generarBurbuja();
                    imprimirDisparo(a,dirDisp,Burbuja);
                    obtenerTrayectoria(a);
                    accion = obtenerAccionJugador();
                }
                else if (accion == SALIR){
                    System.out.println("GAME OVER");
                }continue;
            }

        }



        public static void main (String[] args){

            jugar();

        }
}

---

另一个有对象的类

---

公共类位置{

    int fila;
    int columna;

    public Posicion(int fila,int columna) {
        this.fila = fila;
        this.columna = columna;
    }

    public int getFila(){
        return this.fila;
    }

    public int getColumna(){
        return this.columna;
    }
    public Posicion(){}

}

尝试新的拍摄方式

在您回答完所有问题后，我已经完成了一种新的拍摄方法，比第一种更容易，带有 while 循环和更多常量名称，使其易于理解。

Position 类仍然相同。

我将把带有正向拍摄方向的代码放在这里：

public static void getTrayectory (char [][] a,int shootDirection){  

                int x = 0, y = 0;   
                START = ((RIGHT_WALL)/2) + shootDirection;
                a [BOTTOM][START] = SHOT;

                if(shootDirection > 0){
                    while (!isOut(BOTTOM-x,START+y) && emptyCell(BOTTOM-x,START+y)){
                        b [BOTTOM - x][START + y] = SHOT;
                        x++; y++;   
                    }
                    y = 0; x=x-1;
                    while (!isOut(BOTTOM-x,RIGHT_WALL-y) && emptyCell(BOTTOM-x,RIGHT_WALL-y)){
                        b [BOTTOM-x][RIGHT_WALL-y] = SHOT;
                        x++; y++;
                    }
                    y = 0; x=x-1;
                    while (!isOut(BOTTOM-x,LEFT_WALL+y) && emptyCell(BOTTOM-x,LEFT_WALL+y)){
                        b [BOTTOM-x][LEFT_WALL+y] = SHOT;
                        x++; y++;
                    }
                    y = 0; 
                    while (!isOut(BOTTOM-x,RIGHT_WALL-y) && emptyCell(BOTTOM-x,RIGHT_WALL-y)){
                        b [BOTTOM-x][RIGHT_WALL-y] = SHOT;
                        x++; y++;
                    }           

                }
    }

---

您还需要它才能编译它；)

public static char [][] b = new char [25][9];

    public static char EMPTY = '-';
    public static char SHOT = 'x';

    public static Scanner sc = new Scanner(System.in);

    public static int shootDirection;
    public static int BOTTOM = b.length - 1;
    public static int RIGHT_WALL = b[0].length - 1;
    public static int LEFT_WALL = 0;
    public static int TOP = 0;
    public static int CENTER = ((RIGHT_WALL)/2);
    public static int START = ((RIGHT_WALL)/2) + shootDirection;



    public static void fill (char [][] b){
        for (int x = 0; x < b.length; x++){
            for (int y = 0; y < b[x].length;y++){
                b [x][y] = EMPTY;
                b [10][y] = 'A';
            }
        }
    }

    public static void show (char [][] b){
        for (int x = 0; x < b.length; x++){
            System.out.println();
            for (int y = 0; y < b[x].length; y++){
                System.out.print(" "+b [x][y]+" ");
            }       
        }
    }

    public static boolean isOut (int x,int y){
        if(x < TOP)return true;
        if(y > RIGHT_WALL)return true;
        if(y < LEFT_WALL)return true;
        return false;     
    }
    static boolean emptyCell(int x, int y){
          return b [x-1][y] == EMPTY;
        }

问题是，它可以工作，但是 emptyCell 方法有一个错误。它返回 b [x-1][y] == EMPTY，因为如果我使用 return b[x][y] 它会得到一个 OutOfBounds 错误。由于 x-1，循环在它应该停止之前停止了一行，我不知道如何修改它以使其正常工作。

另一件事是，我想做一个更简单的方法，但即使有下面的小例子，我也不知道如何用我的常量来做。我希望你能为我做，它一定很容易但我不知道：S 使用 isOut 方法和 emptyCell 方法，答案一定很接近。谢谢你，很抱歉这个长线程。

Answer 1

据我了解代码，最接近您所拥有的解决方案是else在EMPTY检查中放置一个，并在那里告诉它break从可能被中断的第一个循环开始。然后，设置一个告诉它停止的变量，然后使其余for循环对该变量有条件，这样它就不会从那里选择。

所以，它可能是这样的（但请记住，以下是一个不好的解决方法，应该立即改进此代码的整体结构）：

if (dirDisp == 3){
            boolean foundObstacle = false;
            for(int x = 3, y = 0; x < 5 & y < 2; x++, y++){
                if(a[(a.length-1) - y][(a[x].length-1) / 2 + x] == EMPTY)
                   a[(a.length-1) - y][(a[x].length-1) / 2 + x] = '·';
                else {
                    foundObstacle = true;
                    break;
                }
            }
            if(!foundObstacle) {
                for(int x = 0, y = 1; x < 9 & y < 11; x++, y++){
                    if(a[(a.length-1) - y][(a[x].length-1) - x] == EMPTY)
                       a[(a.length-1) - y][(a[x].length-1) - x] = '·';
                    else {
                        foundObstacle = true;
                        break;
                    }
                }
            }
            if(!foundObstacle) {
                for(int x = 0, y = 9; x < 5 & y < 14; x++, y++){
                    if(a[(a.length-1) - y][x] == EMPTY)
                        a[(a.length-1) - y][x] = '·';
                    else break;
                }
            }
        }

一旦解决了您的问题，请考虑对您的代码进行一些更改，因为首先，for如果您知道循环将过早结束，则使用循环被认为是不好的做法。在这些情况下，我们通常使用while循环。其次，硬编码这些东西不是一个好主意。一旦你掌握了这个窍门，你就可以想出一个算法来完成任何给定方向的工作。

希望这可以帮助。

编辑：

        if (dirDisp == 3){
            boolean foundObstacle = false;
            for(int x = 3, y = 0; x < 5 & y < 2 && !foundObstacle; x++, y++){
                if(a[(a.length-1) - y][(a[x].length-1) / 2 + x] == EMPTY)
                   a[(a.length-1) - y][(a[x].length-1) / 2 + x] = '·';
                else {
                    foundObstacle = true;
                    break;
                }
            }
            if(!foundObstacle) {
                // At its first iteration, this loop finds the '·' symbol placed by the previous one. 
                // So I've made it start from the second.
                for(int x = 1, y = 2; x < 9 & y < 11 && !foundObstacle; x++, y++){
                    if(a[(a.length-1) - y][(a[x].length-1) - x] == EMPTY)
                       a[(a.length-1) - y][(a[x].length-1) - x] = '·';
                    else {
                        foundObstacle = true;
                        break;
                    }
                }
            }
            if(!foundObstacle) {
                for(int x = 0, y = 9; x < 5 & y < 14 && !foundObstacle; x++, y++){
                    if(a[(a.length-1) - y][x] == EMPTY)
                        a[(a.length-1) - y][x] = '·';
                    else break;
                }
            }
        }

请记住，正如其他人所建议的那样，您无法调试的原因是代码非常晦涩难懂。无论多么有经验的人，这都是一件很难调试的事情。

这就是为什么每个人都建议我们应该编写干净的代码。记住，每个人都会犯错。一旦你了解了如何用一种语言编写程序（显然你个人也是这样做的），最重要的是你自己对代码的理解程度如何，这样你就可以更容易地看到你的错误。永远不要认为仅仅因为你自己编写了一段代码就理解了它。制作大量变量，给它们起有意义的名字，将你的程序分成几部分，制作许多与你的程序必须处理的实体相对应的类型，给它们起有意义的名字，找到重复的代码模式，把它们变成函数/方法（带或不带参数化部分）并给它们起有意义的名称。

即使你在那个时候找不到你的错误，至少其他人会更容易帮助你。;)

Answer 2

如果您的中断条件很复杂，我建议改用 while 循环。使用漂亮的方法名称也会使您的代码更具可读性。

while (!outOfBounds(x,y) && emptyCell(x,y) {
  a[x][y] = '.';
  moveCursor(direction);
}

...

boolean emptyCell(int x, int y){
  return a[x][y] == EMPTY;
}

boolean outOfBounds(int x, int y){
  if (x<0) return true;
  if (y<0) return true;
  if (x>LIMIT_X) return true;
  if (y>LIMIT_Y) return true;
  return false;
}

void moveCursor(direction){
  if (direction==DOWN_RIGHT){
    x++;
    y++;
    if (x > X_LIMIT){
      x-=2;
      direction = DOWN_LEFT;
    }
    ...
  }

Answer 3

我刚刚写了这个小方法，它正在做你想做的事。但它被填充了一个 rnd char 数组。查看我的休息条件

private void shot() {
    char charArray[][] = new char[100][20];
    Random r = new Random();
    for(int i = 0;i<charArray.length;++i) {
        for(int j = 0;j<charArray[0].length;++j) {
            if(r.nextInt(5) == 0) {
                charArray[i][j] = (char) (r.nextInt(26)+65);
            }
        }
    }
    boolean shotRight = false;
    for(int i = charArray.length-1,j = charArray[0].length-1;i>0;--i) {
        System.out.println(i + " " + j);
                    // break condition
        if(charArray[i][j] != '\u0000') break;
        if(shotRight) {
            charArray[i][j] = '.';
            ++j;
        }
        else {
            charArray[i][j] = '.';
            --j;
        }
        if(j <= 0) {
            shotRight = true;
        }
        if(j >= charArray[0].length-1) {
            shotRight = false;
        }

    }
    for(int i = 0;i<charArray.length;++i) {
        for(int j = 0;j<charArray[0].length;++j) {
            System.out.print(((charArray[i][j] == '\u0000') ? "  ":charArray[i][j] + " ") + "  ");
        }
        System.out.println();
    }

}

它确实中断了，因为 char = '\u0000' 的默认值