Java Battleship Game: Implementation Method of Efficiently Randomly Placing Ships without Duplicate Positions

This tutorial details how to place a specified number of ships randomly and without duplication in Java for the Battleships game. Uniqueness of ship positions is ensured by maintaining a pool of available positions and randomly drawing from them, while filling areas where no ships are placed with a default value of 0. The article provides clear implementation ideas, steps and complete Java code examples to help developers build a stable game board layout.

Problem analysis

When developing an application like a battleship game, a common requirement is to randomly place a number of ships in a fixed-size grid (or one-dimensional array) and ensure that each ship occupies a unique position. At the same time, the location of unplaced ships usually needs to be represented by a default value (such as 0). The method of directly generating random numbers and assigning them to array positions can easily lead to repeated ship positions, or make it difficult to accurately control the number of ships, resulting in a layout that does not comply with game rules.

Core idea

An effective strategy to solve the problem of "randomly selecting K non-duplicate positions from N positions" is the "drawing" method. Its core idea is:

1. Build a pool of all available positions: First create a collection containing all possible positions (i.e. array indexes), such as a List.
2. Randomly draw and remove: A location is randomly drawn from this location pool. Once a location is selected for a ship, it is immediately removed from the pool.
3. Repeat: Repeat step 2 until the required number of ships have been placed. Since selected positions are removed after each draw, it is ensured that all ship positions are unique.

Implementation steps

The following are the specific steps to implement this logic based on Java:

1. Initialize the game board array: Create an integer array of specified size, for example int[] gameBoard = new int[20];. In Java, the elements of an integer array are initialized to 0 by default when declared, which exactly meets the needs of unplaced ship positions.

2. Create a pool of available positions: Construct a List containing all indices from 0 to boardSize - 1. These indices represent all available positions on the game board.

    List<integer> availablePositions = new ArrayList();
   for (int i = 0; i </integer>

3. Randomly place ships: cycle a specified number of times (for example, 5 times, corresponding to 5 ships). Do the following in each loop:

   • Use a java.util.Random object to generate a random index whose range is the size of the current availablePositions list (because the list is constantly shrinking).
   • Get an actual game board position (i.e. array index) from the availablePositions list via this random index.
   • Place the current ship's ID (e.g. from 1 to 5) at this actual position in the gameBoard array.
   • Remove the occupied position from the availablePositions list. This step is crucial as it ensures the uniqueness of the ship's position.

Sample code

The following is a complete Java code example that demonstrates how to randomly place 5 unique ships in 20 positions, with numbers 1-5 representing ships and 0 representing empty spaces:

 import java.util.ArrayList;
import java.util.List;
import java.util.Random;

public class BattleshipPlacement {

    public static void main(String[] args) {
        int boardSize = 20; // The total number of positions on the game board int numberOfShips = 5; // The number of ships to be placed // 1. Initialize the game board, all positions default to 0 (indicating no ships)
        int[] gameBoard = new int[boardSize];

        // 2. Create a list containing all available position indices List<integer> availablePositions = new ArrayList();
        for (int i = 0; i <p> Running the above code, you will get a random output similar to the following (the results may be different each time you run it):</p>
<pre class="brush:php;toolbar:false"> Final game board layout:
0 0 5 0 0 0 0 2 0 0 1 0 4 0 0 0 0 3 0 0

Things to note

• Uniqueness guarantee: By removing selected positions from the availablePositions list, we ensure that each ship is placed in a unique position, avoiding duplication.
• Flexibility and scalability: This approach is very flexible. If you need to change the size of the game board or the number of ships, you only need to modify the boardSize and numberOfShips variables without changing the core logic.
• Ship ID: The ship ID in the example increases from 1 to numberOfShips. If you need to use other identifiers or more complex ship objects, you can adjust the gameBoard type and assignment logic according to your needs.
• Alternative method (Collections.shuffle): For some specific scenarios, if you need to randomize all positions and select the top N elements from them, you can use Collections.shuffle(availablePositions) to "shuffle" the list, and then directly take out the first N elements. However, for scenarios where only N non-repeating positions need to be randomly selected, the above "drawing" method is more direct and efficient, because it avoids unnecessary shuffling of the entire list.

Summarize

By maintaining a dynamic pool of available locations, from which selected locations are randomly drawn and removed, we are able to efficiently and accurately place a specified number of unique ships in a fixed-size array. This method is not only logically clear, easy to understand and implement, but also has good scalability, making it an ideal solution for battleship games or other scenarios that require random unique position allocation.

The above is the detailed content of Java Battleship Game: Implementation Method of Efficiently Randomly Placing Ships without Duplicate Positions. For more information, please follow other related articles on the PHP Chinese website!