The battleship game uses a 10x10 playing board with node Js There are 5 ship Migrate the local array of the game board to any array in NodeJS on the server and make a request to create the random board - start a new game
var Settings = require('./settings.js');
var GameStatus = require('./gameStatus.js');
/**
* BattleshipGame constructor
* @param {type} id Game ID
* @param {type} idPlayer1 Socket ID of player 1
* @param {type} idPlayer2 Socket ID of player 2
*/
function BattleshipGame(id, idPlayer1, idPlayer2) {
this.id = id;
this.currentPlayer = Math.floor(Math.random() * 2);
this.winningPlayer = null;
this.gameStatus = GameStatus.inProgress;
this.players = [new Player(idPlayer1), new Player(idPlayer2)];
}
/**
* Get socket ID of player
* @param {type} player
* @returns {undefined}
*/
BattleshipGame.prototype.getPlayerId = function(player) {
return this.players[player].id;
};
/**
* Get socket ID of winning player
* @returns {BattleshipGame.prototype@arr;players@pro;id}
*/
BattleshipGame.prototype.getWinnerId = function() {
if(this.winningPlayer === null) {
return null;
}
return this.players[this.winningPlayer].id;
};
/**
* Get socket ID of losing player
* @returns {BattleshipGame.prototype@arr;players@pro;id}
*/
BattleshipGame.prototype.getLoserId = function() {
if(this.winningPlayer === null) {
return null;
}
var loser = this.winningPlayer === 0 ? 1 : 0;
return this.players[loser].id;
};
/**
* Switch turns
*/
BattleshipGame.prototype.switchPlayer = function() {
this.currentPlayer = this.currentPlayer === 0 ? 1 : 0;
};
/**
* Abort game
* @param {Number} player Player who made the request
*/
BattleshipGame.prototype.abortGame = function(player) {
// give win to opponent
this.gameStatus = GameStatus.gameOver;
this.winningPlayer = player === 0 ? 1 : 0;
}
/**
* Fire shot for current player
* @param {Object} position with x and y
* @returns {boolean} True if shot was valid
*/
BattleshipGame.prototype.shoot = function(position) {
var opponent = this.currentPlayer === 0 ? 1 : 0,
gridIndex = position.y * Settings.gridCols + position.x;
if(this.players[opponent].shots[gridIndex] === 0 && this.gameStatus === GameStatus.inProgress) {
// Square has not been shot at yet.
if(!this.players[opponent].shoot(gridIndex)) {
// Miss
this.switchPlayer();
}
// Check if game over
if(this.players[opponent].getShipsLeft() <= 0) {
this.gameStatus = GameStatus.gameOver;
this.winningPlayer = opponent === 0 ? 1 : 0;
}
return true;
}
return false;
};
/**
* Get game state update (for one grid).
* @param {Number} player Player who is getting this update
* @param {Number} gridOwner Player whose grid state to update
* @returns {BattleshipGame.prototype.getGameState.battleshipGameAnonym$0}
*/
BattleshipGame.prototype.getGameState = function(player, gridOwner) {
return {
turn: this.currentPlayer === player, // is it this player's turn?
gridIndex: player === gridOwner ? 0 : 1, // which client grid to update (0 = own, 1 = opponent)
grid: this.getGrid(gridOwner, player !== gridOwner) // hide unsunk ships if this is not own grid
};
};
/**
* Get grid with ships for a player.
* @param {type} player Which player's grid to get
* @param {type} hideShips Hide unsunk ships
* @returns {BattleshipGame.prototype.getGridState.battleshipGameAnonym$0}
*/
BattleshipGame.prototype.getGrid = function(player, hideShips) {
return {
shots: this.players[player].shots,
ships: hideShips ? this.players[player].getSunkShips() : this.players[player].ships
};
};
module.exports = BattleshipGame;
module.exports = {
inProgress: 1,
gameOver: 2
};
var Ship = require('./ship.js');
var Settings = require('./settings.js');
/**
* Player constructor
* @param {type} id Socket ID
*/
function Player(id) {
var i;
this.id = id;
this.shots = Array(Settings.gridRows * Settings.gridCols);
this.shipGrid = Array(Settings.gridRows * Settings.gridCols);
this.ships = [];
for(i = 0; i < Settings.gridRows * Settings.gridCols; i++) {
this.shots[i] = 0;
this.shipGrid[i] = -1;
}
if(!this.createRandomShips()) {
// Random placement of ships failed. Use fallback layout (should rarely happen).
this.ships = [];
this.createShips();
}
};
/**
* Fire shot on grid
* @param {type} gridIndex
* @returns {Boolean} True if hit
*/
Player.prototype.shoot = function(gridIndex) {
if(this.shipGrid[gridIndex] >= 0) {
// Hit!
this.ships[this.shipGrid[gridIndex]].hits++;
this.shots[gridIndex] = 2;
return true;
} else {
// Miss
this.shots[gridIndex] = 1;
return false;
}
};
/**
* Get an array of sunk ships
* @returns {undefined}
*/
Player.prototype.getSunkShips = function() {
var i, sunkShips = [];
for(i = 0; i < this.ships.length; i++) {
if(this.ships[i].isSunk()) {
sunkShips.push(this.ships[i]);
}
}
return sunkShips;
};
/**
* Get the number of ships left
* @returns {Number} Number of ships left
*/
Player.prototype.getShipsLeft = function() {
var i, shipCount = 0;
for(i = 0; i < this.ships.length; i++) {
if(!this.ships[i].isSunk()) {
shipCount++;
}
}
return shipCount;
}
/**
* Create ships and place them randomly in grid
* @returns {Boolean}
*/
Player.prototype.createRandomShips = function() {
var shipIndex;
for(shipIndex = 0; shipIndex < Settings.ships.length; shipIndex++) {
ship = new Ship(Settings.ships[shipIndex]);
if(!this.placeShipRandom(ship, shipIndex)) {
return false;
}
this.ships.push(ship);
}
return true;
};
/**
* Try to place a ship randomly in grid without overlapping another ship.
* @param {Ship} ship
* @param {Number} shipIndex
* @returns {Boolean}
*/
Player.prototype.placeShipRandom = function(ship, shipIndex) {
var i, j, gridIndex, xMax, yMax, tryMax = 25;
for(i = 0; i < tryMax; i++) {
ship.horizontal = Math.random() < 0.5;
xMax = ship.horizontal ? Settings.gridCols - ship.size + 1 : Settings.gridCols;
yMax = ship.horizontal ? Settings.gridRows : Settings.gridRows - ship.size + 1;
ship.x = Math.floor(Math.random() * xMax);
ship.y = Math.floor(Math.random() * yMax);
if(!this.checkShipOverlap(ship) && !this.checkShipAdjacent(ship)) {
// success - ship does not overlap or is adjacent to other ships
// place ship array-index in shipGrid
gridIndex = ship.y * Settings.gridCols + ship.x;
for(j = 0; j < ship.size; j++) {
this.shipGrid[gridIndex] = shipIndex;
gridIndex += ship.horizontal ? 1 : Settings.gridCols;
}
return true;
}
}
return false;
}
/**
* Check if a ship overlaps another ship in the grid.
* @param {Ship} ship
* @returns {Boolean} True if ship overlaps
*/
Player.prototype.checkShipOverlap = function(ship) {
var i, gridIndex = ship.y * Settings.gridCols + ship.x;
for(i = 0; i < ship.size; i++) {
if(this.shipGrid[gridIndex] >= 0) {
return true;
}
gridIndex += ship.horizontal ? 1 : Settings.gridCols;
}
return false;
}
/**
* Check if there are ships adjacent to this ship placement
* @param {Ship} ship
* @returns {Boolean} True if adjacent ship found
*/
Player.prototype.checkShipAdjacent = function(ship) {
var i, j,
x1 = ship.x - 1,
y1 = ship.y - 1,
x2 = ship.horizontal ? ship.x + ship.size : ship.x + 1,
y2 = ship.horizontal ? ship.y + 1 : ship.y + ship.size;
for(i = x1; i <= x2; i++) {
if(i < 0 || i > Settings.gridCols - 1) continue;
for(j = y1; j <= y2; j++) {
if(j < 0 || j > Settings.gridRows - 1) continue;
if(this.shipGrid[j * Settings.gridCols + i] >= 0) {
return true;
}
}
}
return false;
}
/**
* Create ships and place them in grid in a prearranged layout
*/
Player.prototype.createShips = function() {
var shipIndex, i, gridIndex, ship,
x = [1, 3, 5, 8, 8], y = [1, 2, 5, 2, 8],
horizontal = [false, true, false, false, true];
for(shipIndex = 0; shipIndex < Settings.ships.length; shipIndex++) {
ship = new Ship(Settings.ships[shipIndex]);
ship.horizontal = horizontal[shipIndex];
ship.x = x[shipIndex];
ship.y = y[shipIndex];
// place ship array-index in shipGrid
gridIndex = ship.y * Settings.gridCols + ship.x;
for(i = 0; i < ship.size; i++) {
this.shipGrid[gridIndex] = shipIndex;
gridIndex += ship.horizontal ? 1 : Settings.gridCols;
}
this.ships.push(ship);
}
};
module.exports = Player;
module.exports = {
gridRows: 10,
gridCols: 10,
ships: [ 5, 4, 3, 3, 2 ]
};
/**
* Ship constructor
* @param {Number} size
*/
function Ship(size) {
this.x = 0;
this.y = 0;
this.size = size;
this.hits = 0;
this.horizontal = false;
}
/**
* Check if ship is sunk
* @returns {Boolean}
*/
Ship.prototype.isSunk = function() {
return this.hits >= this.size;
};
module.exports = Ship;
The battleship game uses a 10x10 playing board with node Js There are 5 ship Migrate...
Assignment - Battleship In 1967, Hasbro toys introduced a childrens game named “Battleship”. In the next two assignments you will be creating a one-player version of the game. The game is extremely simple. Each player arranges a fleet of ships in a grid. The grid is hidden from the opponent. Here is an ASCII representation of a 10x10 grid. The ‘X’s represent ships, the ‘~’s represent empty water. There are three ships in the picture: A vertical ship with a...
For your Project, you will develop a simple battleship game. Battleship is a guessing game for two players. It is played on four grids. Two grids (one for each player) are used to mark each players' fleets of ships (including battleships). The locations of the fleet (these first two grids) are concealed from the other player so that they do not know the locations of the opponent’s ships. Players alternate turns by ‘firing torpedoes’ at the other player's ships. The...
The game Battleship is played on a grid board. Each opponent has multiple ships that are placed on the grid where the other opponent cannot see them. In order to attack, each player takes turns calling out coordinates on a grid. If the attacker calls out a coordinate that hits their opponent's ship, they must call out, "Hit." You are going to be developing a computer program to mimic this game. Use the Gridlayout that is six columns by six...
The game Battleship is played on a grid board. Each opponent has multiple ships that are placed on the grid where the other opponent cannot see them. In order to attack, each player takes turns calling out coordinates on a grid. If the attacker calls out a coordinate that hits their opponent's ship, they must call out, "Hit." You are going to be developing a computer program to mimic this game. Use the Gridlayout that is six columns by six...
In C++ program use the new style od C++ not the old one. Simple Battleship You will make a game similar to the classic board game Battleship. You will set up a 5 x 5, 2 dimensional array. In that array, you will use a random number generator to select 5 elements that will act as the placeholders for your "battleships". Your user will get 10 guesses to "seek and destroy" the battleships. After their 10 guesses, you will tell...
Assignment overview In this assignment, you will implement a simple game of Battleship. If you are unfamiliar with the game Battleship, there are tutorials online describing the game. In short, there are two players that each have a 10 by 10 grid where ships are placed. The players take turns taking shots at each other’s ships. A player wins when they have shot at all spaces on their opponent’s grid that are occupied by ship. To sink a ship, you...
Program in C computer language In this program you will be mimicking a game of Battleship. Your game board is a line of 10 slots. You have to implement 3 methods. The following methods must be implemented: void setBoard(int *) This method sets up the human’s game board. The method prompts the user for 2 slots to place the “ship”. The program should ensure that the slots are consecutive. In other words, your ship cannot be placed at slot 2...
C#: Implement a multiplayer Battleship game with AI The rules are the same as before. The game is played on an NxN grid. Each player will place a specified collection of ships: The ships will vary in length (size) from 2 to 5; There can be any number or any size ship. There may be no ships of a particular size; EXCEPT the battleship – which there will always be 1 and only 1. Player order will be random but...
Write a Java program to play the game Tic-Tac-Toe. Start off with a human playing a human, so each player makes their own moves. Follow the design below, creating the methods indicated and invoking them in the main program. Use a char array of size 9 as the board; initialize with the characters 0 to 8 so that it starts out looking something like the board on the left. 0|1|2 3|4|5 6|7|8 and then as moves are entered the board...
Write a Java program to play the game Tic-Tac-Toe. Start off with a human playing a human, so each player makes their own moves. Follow the design below, creating the methods indicated and invoking them in the main program. Use a char array of size 9 as the board; initialize with the characters 0 to 8 so that it starts out looking something like the board on the left. 0|1|2 3|4|5 6|7|8 and then as moves are entered the board...