java - ゲームを機能させようとして、条件をループする

Question

私が得たものと必要なものを簡単かつ明確に説明しようとします。

2 次元の配列があり、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」ループがあります。1 つ目は配列を下から最初の壁まで埋め、2 つ目は壁と壁の間のスペースを埋め、3 つ目は反対側の壁を上に向けます。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();

        }
}

---

オブジェクトを持つ他のクラス

---

public class 位置 {

    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 メソッドに誤りがあります。return b[x][y] を使用すると OutOfBounds エラーが発生するため、b [x-1][y] == EMPTY を返します。x-1 が原因で、ループは停止する前に 1 行停止します。適切に機能させるためにループを変更する方法がわかりません。

もう1つは、もっと簡単な方法をやりたいということですが、以下の小さな例でも、定数を使ってそれを行う方法がわかりません。簡単にできるはずですが、わかりません:S isOut メソッドと emptyCell メソッドを使用すると、答えは近くにあるはずです。この長いスレッドに感謝し、申し訳ありません。

Answer 1

ブレーク条件が複雑な場合は、代わりに 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 2

私がコードを理解している限り、あなたが持っているものに最も近い解決策は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 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' のデフォルト値であるため、壊れます