×
Samples Blogs Make Payment About Us Reviews 4.9/5 Order Now

Program To Create a Battleship Game in Java Assignment Solution

July 06, 2024
Dr. Julia Wong
Dr. Julia
🇨🇦 Canada
Java
Dr. Julia Wong, a distinguished Ph.D. holder in Computer Science from the University of Bristol, brings over 7 years of invaluable experience to our team. With a track record of completing over 800 Java assignments, Dr. Wong combines academic rigor with practical expertise to deliver exceptional solutions tailored to your needs.
Key Topics
  • Instructions
  • Requirements and Specifications
Tip of the day
Use the REPL (Read-Eval-Print Loop) to test your code interactively, and practice writing concise, readable expressions to harness Scala’s powerful syntax effectively.
News
In 2024, universities abroad, like Dublin City University, have introduced cutting-edge programming courses, including Computer Engineering programs focusing on AI and machine learning.

Instructions

Objective

Write a java assignment program to create a battleship game in java language.

Requirements and Specifications

Program to create a battleship game in java
Program to create a battleship game in java 1

Source Code

BATTLESHIP GAME /** * A simple implementation of the game Battleship. There are two players, each with 5 ships as in * the real game. This version uses the extends relation to create 5 ship types: Carrier * Battleship * Destroyer * Submarine * PTBoat * * * The ships, one each of the above types, are placed on the board at random but do not overlap. * Boards are displayed in ASCII characters. One player wins win he/she sinks all of the other * player's ships. * * * * @author David Mathias * @version November 12, 2013 */ import java.util.Scanner; class BattleshipGame { // This is the method that begins and controls game play. public static void main(String[] args) { // Scanner for getting player moves Scanner scan = new Scanner(System.in); // There are two players, each with their own board. // Player 0 plays first. Board player0 = new Board(scan); Board player1 = new Board(scan); int current_player = 0; // Play until someone wins while(!player0.allSunk() && !player1.allSunk()) { if(current_player == 0) { System.out.printf("Player 0, it is your turn. Here is the board:%n%n"); player1.printBoard(); player1.makeGuess(); player1.printBoard(); current_player = 1; } else if(current_player == 1) { System.out.printf("Player 1, it is your turn. Here is the board:%n%n"); player0.printBoard(); player0.makeGuess(); player0.printBoard(); current_player = 0; } System.out.printf("%n%n"); } if(player0.allSunk()) { System.out.printf("Player 1, you win!%n%n"); } else { System.out.printf("Player 0, you win!%n%n"); } scan.close(); } } BOARD /** * Board class for the Battleship game. * * A board is an nxn array containing one each of: Carrier * Battleship * Destroyer * Submarine * PTBoat * * @author David Mathias * @version November 12, 2013 */ import java.util.Scanner; public class Board { // class variables // If the number of ships is changed, the constructor must be // updated as well // When debug is true, positions of ships will be shown when the // board is displayed. This is helpful when testing the game since // you won't have to guess the ships' locations. final static boolean debug = true; final static int board_size = 10; final static int num_ships = 5; // Characters printed when the board is displayed. Not all are used. final static char hit = 'H'; final static char miss = 'M'; final static char used = 'S'; final static char blank = ' '; final static char sunk = 'X'; // instance variables - replace the example below with your own private char[][] board = new char[board_size][board_size]; private int num_sunk; private Ship[] ships = new Ship[num_ships]; private Scanner scanIn; /** * Default constructor for objects of class Board * * @param s */ public Board(Scanner s) { // initialise instance variables scanIn = s; num_sunk = 0; initializeBoard(); // create the ships ships[0] = new PTBoat(); hideShip(0); ships[1] = new Submarine(); hideShip(1); ships[2] = new Destroyer(); hideShip(2); ships[3] = new Battleship(); hideShip(3); ships[4] = new Carrier(); hideShip(4); } /** * Set every board position to blank */ private void initializeBoard() { for(int i=0; i < board_size; i++) { for(int j=0; j < board_size; j++) { board[i][j] = blank; } } } /** * Place a ship on the board at a random but valid location. * In other words, a ship can't go beyond the bounds of the board * or intersect another ship. * * @param s - index into the array of ships */ private void hideShip(int s) { boolean valid = false; // keep looking until a randomly generated position is valid while(!valid) { // choose a direction and a starting row or column int start = (int)(Math.random() * (board_size - ships[s].getSize())); int dir = (int)(Math.random() * 2); if(dir == 0) // horizontal { ships[s].setDir(0); ships[s].setCol(start); int row = (int)(Math.random() * 32767) % board_size; ships[s].setRow(row); valid = true; for(int i=0; i < ships[s].getSize(); i++) { valid = (valid && (board[row][start + i] != used)); } if(valid) { for(int i=0; i < ships[s].getSize(); i++) { board[row][start + i] = used; } } } else // dir == 1, vertical { ships[s].setDir(1); ships[s].setRow(start); int col = (int)(Math.random() * 32767) % board_size; ships[s].setCol(col); valid = true; for(int i=0; i < ships[s].getSize(); i++) { valid = (valid && (board[start + i][col] != used)); } if(valid) { for(int i=0; i < ships[s].getSize(); i++) { board[start + i][col] = used; } } } } } // method allSunk /** * Return true if all of the ships on the board have been sunk * * @return boolean */ public boolean allSunk() { for (Ship ship : ships) { if (!ship.isSunk()) { return false; } } return true; } /** * Output a representation of the board */ public void printBoard() { System.out.printf(" "); for(int i=0; i < board_size; i++) { System.out.printf("%4d", i); } System.out.printf("%n%n"); // for each board position, print blank, hit or miss for(int i=0; i < board_size; i++) { System.out.printf("%d ", i); for(int j=0; j < board_size; j++) { // don't want to reveal position of ships when printing // the board so print a blank instead if(board[i][j] == used && !debug) { System.out.printf("%4c", blank); } else { System.out.printf("%4c", board[i][j]); } } System.out.printf("%n%n"); } } // makeGuess method /** * Get a guess from the user. Make sure it hasn't been guessed * previously. Call evaluateGuess to see if it is a hit or a miss. * Assume that the values entered are integers in the correct range. */ public void makeGuess() { System.out.print("Enter a row (0--9): "); int row = Integer.parseInt(scanIn.nextLine()); System.out.print("Enter a column (0--9): "); int column = Integer.parseInt(scanIn.nextLine()); if (board[row][column] == blank || board[row][column] == used) { evaluateGuess(row, column); } else { System.out.printf("%nThat's a miss.%n"); } } /** * Determine if a guess is a hit or a miss * * @param r - row of guess * @param c - column of guess */ private void evaluateGuess(int r, int c) { // assume the guess is a miss until we see otherwise int i = 0; boolean is_hit = false; // check each ship by calling the Ship isAHit method while((i < num_ships) && !is_hit) { // if it's a hit, update that board position to hit if(ships[i].isAHit(r, c)) { System.out.printf("That's a Hit! %n"); board[r][c] = hit; is_hit = true; if(ships[i].isSunk()) { num_sunk++; markSunk(ships[i]); System.out.printf("You sunk my %s!%n%n", ships[i].getName()); } } i++; } // if it's a miss, update board position to miss if(!is_hit) { board[r][c] = miss; System.out.printf("%nThat's a miss.%n"); } } // method markSunk /** * When a ship is sunk, change the board markers * for that ship to 'X'. Note that this is defined * as a final static char at the top of this file. * * @param s - the ship that has just been sunk */ public void markSunk(Ship s) { if (s.isSunk()) { for (int i = 0; i int row = s.getDirection() == 0 ? s.getStartRow() : s.getStartRow() + i; int col = s.getDirection() == 0 ? s.getStartCol() + i : s.getStartCol(); board[row][col] = sunk; } } } } CARRIER /** * Class for the Aircraft Carrier of the Battleship Game. * * Superclass: Ship * Subclasses: none * * Attributes: String name * int aircraft * * name = "Aircraft Carrier" * size = 5 * aircraft = number of aircraft on this aircraft carrier * * You must declare the attributes, complete the constructors and * write any necessary getters and setters * * @author * @version */ public class Carrier extends Ship { private static final int CARRIER_SIZE = 5; // instance variables /** * Constructors for objects of class Carrier */ public Carrier() { // initialize name, size and aircraft and // invoke the Ship constructor super(); setSize(CARRIER_SIZE); } public Carrier(int row, int col, int dir) { super(row, col, dir); setSize(CARRIER_SIZE); } /** * This method exists solely so that it can be overriden in * the subclasses of Ship */ @Override public String getName() { return "Aircraft Carrier"; } } DESTROYER /** * Class for the Destroyer of the Battleship Game. * * Superclass: Ship * Subclasses: none * * Attributes: String name * int guns * * name = "Destroyer" * size = 3 * guns = number of guns on this Destroyer * * You must declare the attributes, complete the constructors and * write any necessary getters and setters * * @author * @version */ public class Destroyer extends Ship { private static final int DESTROYER_SIZE = 3; // instance variables /** * Constructors for objects of class Carrier */ public Destroyer() { super(); setSize(DESTROYER_SIZE); } public Destroyer(int row, int col, int dir) { super(row, col, dir); setSize(DESTROYER_SIZE); } /** * This method exists solely so that it can be overriden in * the subclasses of Ship */ @Override public String getName() { return "Destroyer"; } } PT BOAT /** * Class for the PT Boat of the Battleship Game. * * Superclass: Ship * Subclasses: none * * Attributes: String name * int charges; * * name = "PT Boat" * size = 2 * charges - number of depth charges on this PT Boat * * You must declare the attributes, complete the constructors and * write any necessary getters and setters * * @author * @version */ public class PTBoat extends Ship { private static final int PTBOAT_SIZE = 2; // instance variables /** * Constructors for objects of class Carrier */ public PTBoat() { super(); setSize(PTBOAT_SIZE); } public PTBoat(int row, int col, int dir) { super(row, col, dir); setSize(PTBOAT_SIZE); } /** * This method exists solely so that it can be overriden in * the subclasses of Ship */ @Override public String getName() { return "PT Boat"; } } SHIP /** * Ship class for the Battleship game. * * Superclass: none (Object) * Subclasses: Carrier * Battleship * Destroyer * Submarine * PTBoat * * Attributes: int size - the number of board positions for this ship * note that size is intitalized in the subclasses * int start_row - the first row on which this ship appears * int start_col - the first columb on which this ship appears * int direction - is this ship horizontal or vertical on the board * int hits - number of times this ship has been hit * boolean sunk - if this ship has been sunk or not * * You must declare the attributes, complete the body of the isAHit method * as well as all of the getters and setters. isAHit is a complicated * operation -- reason it through before you start coding. * * @author * @version */ public abstract class Ship { // class variables // Constants used to encode direction // What does the static keyword mean in this context? protected static final int horizontal = 0; protected static final int vertical = 1; // instance variables (attributes) go here private int size; private int start_row; private int start_col; private int direction; private int hits; private boolean sunk; /* ********************************************************* *** Students to provide the attributes (described above) ********************************************************* */ // Are any objects of type Ship ever declared? // Think about what this means for when these // constructors are invoked. /** * Default constructor for objects of class Ship */ public Ship() { // initialise instance variables hits = 0; sunk = false; } /** * Constructor for objects of class Ship */ public Ship(int row, int col, int dir) { // initialise instance variables hits = 0; sunk = false; start_row = row; start_col = col; direction = dir; } /** * Given a guess (row, col) determine if it is a hit for this ship * Update hits and sunk attributes of ship as appropriate * * Parameters: int row -- row of the guess * int col -- column of the guess * * Return: true: if the guess hits this ship * false: otherwise * * Note: you do not have to determine if this position has been guessed * previously -- that has already been done in the Board class. * Also - in this method, you are evaluating one guess for one ship. * That is very important -- the guess you are provided as a parameter * is being evaluated by this method with respect to one ship, the * ship to which this method is being applied. In the Board class, * this method is called for each ship -- in that way we check all of * the ships. */ public boolean isAHit(int row, int col) { boolean result; if (direction == horizontal) { int diff = col - start_col; result = row == start_row && (diff >= 0) && (diff < size); } else { int diff = row - start_row; result = col == start_col && (diff >= 0) && (diff < size); } if (result) { hits++; if (hits == size) { sunk = true; } } return result; } // getters and setters /** * Indicate if the ship has been sunk */ public boolean isSunk() { return sunk; } /** * Set value of start_row */ public void setRow(int row) { start_row = row; } /** * Set value of start_col */ public void setCol(int col) { start_col = col; } /** * Set value of size */ public void setSize(int size) { this.size = size; } /** * Set value of direction */ public void setDir(int dir) { direction = dir; } /** * Return value of size */ public int getSize() { return size; } /** * Return value of start_row */ public int getStartRow() { return start_row; } /** * Return value of start_col */ public int getStartCol() { return start_col; } /** * Return value of direction */ public int getDirection() { return direction; } /** * This method exists solely so that it can be overriden in * the subclasses of Ship */ public abstract String getName(); } SUBMARINE /** * Class for the Submarine of the Battleship Game. * * Superclass: Ship * Subclasses: none * * Attributes: String name * int torpedos * * name = "Submarine" * size = 3 * torpedos = number of torpedos on this Submarine * * You must declare the attributes, complete the constructors and * write any necessary getters and setters * * @author * @version */ public class Submarine extends Ship { private static final int SUBMARINE_SIZE = 3; // instance variables /** * Constructors for objects of class Carrier */ public Submarine() { super(); setSize(SUBMARINE_SIZE); } public Submarine(int row, int col, int dir) { super(row, col, dir); setSize(SUBMARINE_SIZE); } /** * This method exists solely so that it can be overriden in * the subclasses of Ship */ @Override public String getName() { return "Submarine"; } }

Similar Samples

At ProgrammingHomeworkHelp.com, we offer expertly crafted programming assignments across various languages and topics. Our sample solutions showcase our commitment to quality, accuracy, and clarity, ensuring you receive the best possible assistance to excel in your programming courses.