java - statement - Necesita Ayuda Programación Battleship Location Selector/Checker

if statement java

Question

Estoy intentando desarrollar un juego Battleship de 1 lado y tengo casi todo configurado. Solo necesito incorporar una matriz que contenga en este momento, 5, objetos Ships. La clase que creé para cada barco se llama Ships.java. Anteriormente tuve problemas para inicializar la matriz, pero eso ya se solucionó.

El problema surge cuando intento aumentar la longitud de un barco (2, 3, 4 o 5) desde un índice en el conjunto. No estoy seguro de cómo conceptualmente colocar naves.

Siento que he probado todas las combinaciones de do-whiles, para loops y declaraciones. Incluso probé una caja de conmutación.

El objetivo es que la computadora seleccione las posiciones para los cinco barcos y configure cada celda en una cuadrícula (ROWSxCOLS) para que sea igual a NC_SHIP (sin hacer clic, más enviar). El problema es hacer que verifique las posiciones de las celdas adyacentes a una ubicación aleatoria en la cuadrícula. También debe verificar si el barco en cuestión encajará (tirando de los barcos [i] .getShipLength ()).

Aquí está el código que tengo hasta ahora:

int shipsPlaced = 0;

    for (int i = 0; i < ships.length; i++)
    {
        boolean shipPlaced = false;

        do
        {
            int randomRow = (int)(Math.random()*ROWS);
            int randomCol = (int)(Math.random()*COLS);
            int p = 0;

            if (randomRow - ships[p].getShipLength() >= 0 && gameBoard[(randomRow - p)][randomCol] == NC_EMPTY)
            {
                for (int x = 0; x < ships[x].getShipLength(); x++)
                {
                    gameBoard[(randomRow - x)][randomCol] = NC_SHIP;
                    shipsPlaced = shipsPlaced + 1;
                    if (x == ships[x].getShipLength())
                    {
                        shipPlaced = true;
                        p = p + 1;
                    }
                }
            }
        }while (shipPlaced == false);

    }

Todo se ha inicializado y configurado si no está visible aquí. El problema es sobre la matemática / lógica utilizada para ubicar los barcos en ubicaciones ''aleatorias''.

Answer 1

Antes que nada: todos tus barcos se irán en horizontal, también deberías aleatorizar la dirección de colocación de la nave.

Hay dos formas en que podría enfrentar ese problema:

1. Primero coloque la posición inicial y luego mire si la nave encaja.
2. Primero enumera todas las posiciones disponibles, luego aleatoriza para un número igual a la longitud de la lista

1 - Realice una búsqueda recursiva de la posición inicial aleatoria (x, y) (que debería ser libre , si no volver a lanzar una posición). En el método recursivo " lookForPos ", crea una randomPlacementDirection , y de ahí, una bandera (por ejemplo, horizontal). Si no encaja (la longitud desde el inicio hasta la posición final desborda el tamaño de la matriz), vuelva a tirar . Cubre las posiciones (posición, posición + 1, posición + 2, ..., posición + n) donde ''n'' es la longitud de tu nave y la posición es el par x, y y el +1 afecta solo a uno de los cardenales (dependiendo si es horizontal o no) si alguno de ellos también está ocupado re-throw . Eventualmente tendrás lo que necesitas.

2 - Haga una lista de todas las posiciones donde cabe (una estructura ''para''), tanto horizontal como vertical, luego aleatorice para la longitud de la lista.

Answer 2

Entonces, tu problema es el de colocar acorazados aleatoriamente en un tablero. Interesante. Aquí es cómo lo haría.

Primero, supongamos que tenemos una clase Ship :

public class Ship {

    int size;

    public Ship(int size) {
        this.size = size;
    }

    public int getSize() {
        return size;
    }

}

Entonces, tendría una clase de BattleshipBoard la siguiente manera:

public class BattleshipBoard {

    private final int rows;
    private final int cols;

    private char[][] board;

    public BattleshipBoard(int rows, int cols) {
        this.rows = rows;
        this.cols = cols;
        board = new char[rows][cols];
    }

    public void place(Ship[] ships) {

        Arrays.sort(ships, new Comparator<Ship>() {

            @Override
            public int compare(Ship s1, Ship s2) {
                return Integer.valueOf(s1.size).compareTo(Integer.valueOf(s2.size));
            }
        });

        for (int j = 0; j < rows; j++)
            for (int k = 0; k < cols; k++)
                board[j][k] = ''-''; // Empty position

        char[][] checked = new char[rows][cols];
        Random random = new Random();
        for (int i = ships.length - 1; i >=0; i--) {
            for (int j = 0; j < rows; j++)
                for (int k = 0; k < cols; k++)
                    checked[j][k] = ''U''; // Unchecked position
            boolean placed = false;
            while (! placed) {
                int r = random.nextInt(rows);
                int c = random.nextInt(cols);
                if (checked[r][c] == ''U'') {
                    checked[r][c] = ''C''; // Checked position
                    if (board[r][c] == ''-'') {
                        int direction = random.nextInt(4);
                        // 0 = North; 1 = East; 2 = South; 3 = West;
                        if (canPlace(ships[i], r, c, direction)) {
                            place(ships[i], r, c, direction);
                            placed = true;
                        }
                    }               
                }
            }
        }
    }

    private void place(Ship ship, int row, int col, int direction) {
        int size = ship.getSize();
        switch (direction) {
        case 0: // North
            for (int  i = row; i >= row - (size - 1); i--)
                board[i][col] = ''S'';
            break;

        case 1: // East
            for (int i = col; i <= col + (size - 1); i++)
                board[row][i] = ''S'';
            break;

        case 2: // South
            for (int i = row; i <= row + (size - 1); i++)
                board[i][col] = ''S'';
            break;

        default: // West
            for (int i = col; i >= col - (size - 1); i--) 
                board[row][i] = ''S'';
            break;
        }       
    }

    private boolean canPlace(Ship ship, int row, int col, int direction) {
        int size = ship.getSize();
        boolean thereIsRoom = true;
        switch (direction) {
        case 0: // North
            if (row - (size - 1) < 0)
                thereIsRoom = false;
            else 
                for (int  i = row; i >= row - (size - 1) && thereIsRoom; i--)
                    thereIsRoom = thereIsRoom & (board[i][col] == ''-'');
            break;

        case 1: // East
            if (col + (size - 1) >= cols)
                thereIsRoom = false;
            else
                for (int i = col; i <= col + (size - 1) && thereIsRoom; i++)
                    thereIsRoom = thereIsRoom & (board[row][i] == ''-'');
            break;

        case 2: // South
            if (row + (size - 1) >= rows)
                thereIsRoom = false;
            else
                for (int i = row; i <= row + (size - 1) && thereIsRoom; i++)
                    thereIsRoom  = thereIsRoom & (board[i][col] == ''-'');
            break;

        default: // West
            if (col - (size - 1) < 0) 
                thereIsRoom = false;
            else
                for (int i = col; i >= col - (size - 1) && thereIsRoom; i--) 
                    thereIsRoom = thereIsRoom & (board[row][i] == ''-'');
            break;
        }
        return thereIsRoom;
    }

    public void printBoard() {
        for (int i = 0; i < rows; i++)
            System.out.println(Arrays.toString(board[i]));
    }

}

Entonces, si tienes algo como esto:

public static void main(String[] args) {
    Ship[] ships = new Ship[] {
            new Ship(1),
            new Ship(3),
            new Ship(2),
            new Ship(3)
    };
    BattleshipBoard battleshipBoard = new BattleshipBoard(7, 7);
    battleshipBoard.place(ships);
    battleshipBoard.printBoard();
}

puede obtener la siguiente salida (dependiendo de su generador Random ):

[-, -, -, -, -, -, -]
[-, -, -, -, -, -, -]
[-, -, S, -, -, -, -]
[-, -, -, -, -, -, -]
[-, S, -, S, S, -, -]
[-, S, -, -, -, -, -]
[-, S, -, -, S, S, S]

que es una ubicación aleatoria de cuatro barcos de tamaño 1, 2, 3 y 3.

Algunos comentarios:

• el método place() intenta colocar aleatoriamente las naves eligiendo la posición de partida aleatoria (r,c) y la direction aleatoria

• el conjunto de ships está ordenado, de modo que comenzamos con las naves más grandes primero (es más fácil ubicarlas cuando nuestra junta tiene menos puestos ocupados)

• la matriz checked se usa para evitar verificar la misma posición aleatoria (r,c) más de una vez cuando se intenta colocar un barco

• el método canPlace() devuelve verdadero si el ship pasado se puede colocar en el board comenzando en la posición (r,c) y yendo hacia la direction pasada

• el método place() coloca el ship pasado en el board comenzando en la posición (r,c) y yendo hacia la direction pasada

Answer 3

Que haría yo:

1. consigue un lugar aleatorio para intentar colocar tu nave allí. - Como lo hiciste tú

2. En un bucle, itere hasta este punto (pase por toda la matriz, parece que necesita 2 bucles, una hasta el final de la matriz y la siguiente desde el inicio hasta ese punto)

3. freeRowsInARow() métodos freeRowsInARow() y freeColsInARow() que devuelve el número del barco más grande que se puede insertar allí, comenzando desde ese punto dado (x, y)

4. Comprueba si tu nave tiene el size <= returnedValue (de los métodos mencionados anteriormente), si es así - invoca el método insertándolo allí (elige el modo - vertical u horizontal) y rompe el ciclo (con return ); si no - ofc continúe buscando.