Complete Java Assignment: Building a Battleship Game Program

Instructions

Objective

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

Requirements and Specifications

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"; } }