You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
761 lines
26 KiB
761 lines
26 KiB
<!DOCTYPE html>
|
|
<html lang="en">
|
|
<head>
|
|
<meta charset="utf-8">
|
|
<title>JSDoc: Source: services/GameState.service.js</title>
|
|
|
|
<script src="scripts/prettify/prettify.js"> </script>
|
|
<script src="scripts/prettify/lang-css.js"> </script>
|
|
<!--[if lt IE 9]>
|
|
<script src="//html5shiv.googlecode.com/svn/trunk/html5.js"></script>
|
|
<![endif]-->
|
|
<link type="text/css" rel="stylesheet" href="styles/prettify-tomorrow.css">
|
|
<link type="text/css" rel="stylesheet" href="styles/jsdoc-default.css">
|
|
</head>
|
|
|
|
<body>
|
|
|
|
<div id="main">
|
|
|
|
<h1 class="page-title">Source: services/GameState.service.js</h1>
|
|
|
|
|
|
|
|
|
|
|
|
|
|
<section>
|
|
<article>
|
|
<pre class="prettyprint source linenums"><code>import { Player, GridCellState, GameState, clone, ShipType, isShipType, isShipCell, isValidTargetCell } from '../module/util.js'
|
|
import { InvalidShipPlacementError, InvalidAdvanceStateError, InvalidMissileFireAttemptError } from '../module/errors.js'
|
|
|
|
/**
|
|
* Singleton service for managing the state of the game.
|
|
*/
|
|
export class GameStateService {
|
|
/**
|
|
* A mapping of player => game board state.
|
|
* @private
|
|
* @type {object}
|
|
*/
|
|
player_x_game_board = {}
|
|
|
|
/**
|
|
* A mapping of player => ship definitions.
|
|
* @private
|
|
* @type {object}
|
|
*/
|
|
player_x_ships = {}
|
|
|
|
/**
|
|
* An array of all players. This is mostly for internal purposes.
|
|
* @private
|
|
* @type {string[]}
|
|
*/
|
|
players = [Player.One, Player.Two]
|
|
|
|
/**
|
|
* Number of rows in the grid.
|
|
* @private
|
|
* @type {number}
|
|
*/
|
|
n_rows = 9
|
|
|
|
/**
|
|
* Number of cols in the grid.
|
|
* @private
|
|
* @type {number}
|
|
*/
|
|
n_cols = 9
|
|
|
|
/**
|
|
* Number boats placed on the board.
|
|
* @private
|
|
* @type {number}
|
|
*/
|
|
n_boats = 1
|
|
|
|
/**
|
|
* gets the number of boats placed on the board
|
|
* @private
|
|
* @return {number}
|
|
*/
|
|
get_n_boats(){
|
|
return (this.n_boats);
|
|
}
|
|
|
|
/**
|
|
* sets the number of boats to a valid number
|
|
* @private
|
|
* @return none
|
|
*/
|
|
set_n_boats(number){
|
|
if(number >= 1 && number <= 5 )
|
|
{
|
|
this.n_boats = number;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Given the number of boats set by the player (n_boats), return an array
|
|
* of possible ShipTypes.
|
|
* @return {string[]}
|
|
*/
|
|
get_possible_boats(){
|
|
if (this.get_n_boats() === 1) {
|
|
return [ShipType.x1]
|
|
}
|
|
else if (this.get_n_boats() === 2) {
|
|
return [ShipType.x1, ShipType.x2]
|
|
}
|
|
else if (this.get_n_boats() === 3) {
|
|
return [ShipType.x1, ShipType.x2, ShipType.x3]
|
|
}
|
|
else if (this.get_n_boats() === 4) {
|
|
return [ShipType.x1, ShipType.x2, ShipType.x3, ShipType.x4]
|
|
}
|
|
else if (this.get_n_boats() === 5) {
|
|
return [ShipType.x1, ShipType.x2, ShipType.x3, ShipType.x4, ShipType.x5]
|
|
}
|
|
}
|
|
|
|
/**
|
|
* The current state of the game.
|
|
* @private
|
|
* @type {string}
|
|
*/
|
|
current_state = GameState.ChoosingNumberOfShips
|
|
|
|
/**
|
|
* The current player.
|
|
* @private
|
|
* @type {string}
|
|
*/
|
|
current_player = Player.One
|
|
|
|
/**
|
|
* The current opponent.
|
|
* @private
|
|
* @type {string}
|
|
*/
|
|
current_opponent = Player.Two
|
|
|
|
/**
|
|
* If the current state is the PromptPlayerChange, then this is
|
|
* the state that we should move to next.
|
|
* @type {undefined|string}
|
|
*/
|
|
post_player_change_state = undefined
|
|
|
|
/**
|
|
* True if, during the current turn, the user has tried to fire a missile.
|
|
* @type {boolean}
|
|
*/
|
|
current_turn_had_missile_attempt = false
|
|
|
|
/**
|
|
* Array of functions that are called when the game state changes.
|
|
* @type {function[]}
|
|
*/
|
|
game_state_change_listeners = []
|
|
|
|
/**
|
|
* Construct a new game service. Initialize any internal states.
|
|
*/
|
|
constructor() {
|
|
// Generate empty boards for each player
|
|
for ( const player of this.players ) {
|
|
this.player_x_game_board[player] = this._build_empty_board()
|
|
this.player_x_ships[player] = []
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get the dimensions of the board as [rows, cols].
|
|
* @example const [n_rows, n_cols] = game_service.get_dimensions()
|
|
* @return {number[]}
|
|
*/
|
|
get_dimensions() {
|
|
return [this.n_rows, this.n_cols]
|
|
}
|
|
|
|
/**
|
|
* Get the player who is the focus of the current game state.
|
|
* @return {string}
|
|
*/
|
|
get_current_player() {
|
|
return this.current_player
|
|
}
|
|
|
|
/**
|
|
* Get the player who is NOT the focus of the current game state.
|
|
* @return {string}
|
|
*/
|
|
get_current_opponent() {
|
|
return this.current_opponent
|
|
}
|
|
|
|
/**
|
|
* Get the state of the current player's board, as it should appear to them.
|
|
* @return {object[][]}
|
|
*/
|
|
get_current_player_state() {
|
|
// The player can see everything about their own board, so just return it.
|
|
// Return a deep-copy, so internal state can't be modified.
|
|
return clone(this.player_x_game_board[this.current_player])
|
|
}
|
|
|
|
/**
|
|
* Get the state of the current opponent's board, as it should appear to the
|
|
* current player. Note that the current player cannot see "ship" spaces, only
|
|
* available, damaged, missed, or sunk.
|
|
* @return {object[][]}
|
|
*/
|
|
get_current_opponent_state() {
|
|
// Return a deep-copy, so internal state can't be modified.
|
|
const state = clone(this.player_x_game_board[this.current_opponent])
|
|
const hidden_states = [
|
|
GridCellState.Disabled,
|
|
GridCellState.Ship,
|
|
]
|
|
|
|
return state.map(row => {
|
|
return row.map(cell => {
|
|
if ( hidden_states.includes(cell.render) ) {
|
|
// This is a hidden state, so hide it
|
|
cell.render = GridCellState.Available
|
|
}
|
|
|
|
return cell
|
|
})
|
|
})
|
|
}
|
|
|
|
/**
|
|
* Get the states that should be shown on the victory screen.
|
|
* First element is the winner's state, second element is the loser's state.
|
|
* @return {object[][][]}
|
|
*/
|
|
get_player_victory_state(){
|
|
return [clone(this.player_x_game_board[this.current_player]), clone(this.player_x_game_board[this.current_opponent])]
|
|
}
|
|
|
|
/**
|
|
* get the "score" (the number of hits) that the
|
|
* current player has (counting sunk ships)
|
|
* @return {number}
|
|
* @private
|
|
*/
|
|
get_player_score(player) {
|
|
let score = 0
|
|
this.player_x_game_board[player].some(row => {
|
|
row.some(cell => {
|
|
if ( cell.render === GridCellState.Damaged || cell.render === GridCellState.Sunk ) {
|
|
score += 1
|
|
}
|
|
})
|
|
})
|
|
|
|
return score
|
|
}
|
|
|
|
/**
|
|
* gets the number of the boats (sunken, damaged or not) that the opponent has
|
|
* used to help keep get progress method looking clean
|
|
* @return {number}
|
|
* @private
|
|
*/
|
|
get_boat_count(player){
|
|
let boat_count = 0
|
|
this.player_x_game_board[player].some(row => {
|
|
row.some(cell => {
|
|
if ( isShipCell(cell.render) ) {
|
|
boat_count += 1
|
|
}
|
|
})
|
|
})
|
|
|
|
return boat_count
|
|
}
|
|
|
|
/**
|
|
* gets the progress (hits/total boats) that the player has
|
|
* @return {number}
|
|
* @private
|
|
*/
|
|
get_progress(player){
|
|
const boat_count = this.get_boat_count(player)
|
|
if ( boat_count !== 0 ) {
|
|
return (this.get_player_score(player) / boat_count).toFixed(2)
|
|
} else {
|
|
return 0
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get the current game state.
|
|
* @return {string}
|
|
*/
|
|
get_game_state() {
|
|
return clone(this.current_state)
|
|
}
|
|
|
|
/**
|
|
* responsible for advancing the game state
|
|
* will be consisting of
|
|
*/
|
|
advance_game_state() {
|
|
/** functions to be made that validate:
|
|
* 1) number of ships
|
|
* 2) player one placement
|
|
* 3) player two placement
|
|
* 4) player one turn
|
|
* 5) advance to player 2
|
|
* 6) player 2 turn
|
|
* 7) advance to player one
|
|
* 8) player win
|
|
*/
|
|
if (this.current_state === GameState.ChoosingNumberOfShips) {
|
|
if (this.n_boats >= 1 && this.n_boats <= 5) {
|
|
this.current_state = GameState.PromptPlayerChange;
|
|
this.post_player_change_state = GameState.PlayerSetup;
|
|
this.current_player = Player.One;
|
|
this.current_opponent = Player.Two;
|
|
} else {
|
|
throw new InvalidAdvanceStateError("Invalid Number of Boats");
|
|
}
|
|
}
|
|
else if (this.current_state === GameState.PlayerSetup) {
|
|
if (this.current_player === Player.One) {
|
|
// because the place_ship handles all the validation
|
|
// all you need to do is make sure they have placed all the appropriate ships
|
|
if ( this.get_ship_entities(this.current_player).length === this.n_boats ) {
|
|
this.current_state = GameState.PromptPlayerChange;
|
|
this.post_player_change_state = GameState.PlayerSetup;
|
|
this.current_player = Player.Two;
|
|
this.current_opponent = Player.One;
|
|
}
|
|
else{
|
|
throw new InvalidAdvanceStateError("Player One has a problem with the number of boats selected");
|
|
}
|
|
}
|
|
else if (this.current_player === Player.Two) {
|
|
if ( this.get_ship_entities(this.current_player).length === this.n_boats ) {
|
|
this.current_state = GameState.PromptPlayerChange;
|
|
this.post_player_change_state = GameState.PlayerTurn;
|
|
this.current_player = Player.One;
|
|
this.current_opponent = Player.Two;
|
|
}
|
|
else{
|
|
throw new InvalidAdvanceStateError("Player Two has a problem with the number of boats selected");
|
|
}
|
|
}
|
|
}
|
|
else if (this.current_state === GameState.PlayerTurn && this.current_player === Player.One) {
|
|
if (this.current_turn_had_missile_attempt === true) {
|
|
this.current_state = GameState.PromptPlayerChange;
|
|
this.post_player_change_state = GameState.PlayerTurn;
|
|
this.current_player = Player.Two;
|
|
this.current_opponent = Player.One;
|
|
}
|
|
else {
|
|
throw new InvalidAdvanceStateError("the player has not fired a missle");
|
|
}
|
|
}
|
|
else if (this.current_state === GameState.PlayerTurn && this.current_player === Player.Two) {
|
|
if (this.current_turn_had_missile_attempt === true) {
|
|
this.current_state = GameState.PromptPlayerChange;
|
|
this.post_player_change_state = GameState.PlayerTurn;
|
|
this.current_player = Player.One;
|
|
this.current_opponent = Player.Two;
|
|
}
|
|
else {
|
|
throw new InvalidAdvanceStateError("the player has not fired a missle");
|
|
}
|
|
}
|
|
else if ( this.current_state === GameState.PromptPlayerChange ) {
|
|
if ( !this.post_player_change_state ) {
|
|
throw new InvalidAdvanceStateError('No state to advance to after player change!')
|
|
}
|
|
|
|
this.current_state = this.post_player_change_state
|
|
this.post_player_change_state = undefined
|
|
}
|
|
|
|
let winner = this.get_winner();
|
|
if(winner) {
|
|
this.current_state = GameState.PlayerVictory;
|
|
this.current_player = winner;
|
|
this.current_opponent = this.get_other_player(winner);
|
|
}
|
|
|
|
this.current_turn_had_missile_attempt = false
|
|
this.game_state_change_listeners.forEach(fn => fn(this.current_state, false))
|
|
}
|
|
|
|
/**
|
|
* Register a handler to be called when the game state changes.
|
|
* @param {function} handler
|
|
*/
|
|
on_state_change(handler) {
|
|
this.game_state_change_listeners.push(handler)
|
|
}
|
|
|
|
/**
|
|
* Attempt to fire a missile at the current opponent at the given coordinates.
|
|
* The coordinates should be an array of [row_index, column_index] where the missile should fire.
|
|
* Returns true if the missile hit an undamaged cell of a ship.
|
|
*
|
|
* @example
|
|
* If I want to fire a missile at row 5 column 7, then:
|
|
* game_service.attempt_missile_fire([5, 7])
|
|
*
|
|
* @param {number[]} coords
|
|
* @return {boolean}
|
|
*/
|
|
attempt_missile_fire([target_row_i, target_col_i]) {
|
|
if ( this.current_turn_had_missile_attempt ) {
|
|
throw new InvalidMissileFireAttemptError('Cannot fire more than once per turn.')
|
|
} else {
|
|
this.current_turn_had_missile_attempt = true
|
|
}
|
|
|
|
const target_cell = this._get_cell_state(this.current_opponent, target_row_i, target_col_i)
|
|
if ( !isValidTargetCell(target_cell.render) ) {
|
|
this.current_turn_had_missile_attempt = false
|
|
throw new InvalidMissileFireAttemptError('Cannot fire on cell with state: ' + target_cell.render)
|
|
}
|
|
|
|
if ( target_cell.render === GridCellState.Ship ) {
|
|
// We hit an un-hit ship cell!
|
|
this._set_cell_state(this.current_opponent, target_row_i, target_col_i, GridCellState.Damaged)
|
|
|
|
// set ships to sunk where appropriate
|
|
this._sink_damaged_ships(this.current_opponent)
|
|
this._trigger_view_update()
|
|
return true
|
|
} else if ( target_cell.render === GridCellState.Available ) {
|
|
// We missed...
|
|
this._set_cell_state(this.current_opponent, target_row_i, target_col_i, GridCellState.Missed)
|
|
}
|
|
|
|
this._trigger_view_update()
|
|
return false
|
|
}
|
|
|
|
/**
|
|
* Checks the player's ships. If any are fully damaged, it flags that ship's cells
|
|
* as "sunk" rather than damaged.
|
|
* @param {string} player
|
|
* @private
|
|
*/
|
|
_sink_damaged_ships(player) {
|
|
this.get_ship_entities(player).some(ship => {
|
|
const covered_cells = this.get_covered_cells(ship.coords_one, ship.coords_two)
|
|
const all_damaged = covered_cells.every(([cell_row, cell_col]) => {
|
|
return this._get_cell_state(player, cell_row, cell_col).render === GridCellState.Damaged
|
|
})
|
|
|
|
if ( all_damaged ) {
|
|
// The entire boat was damaged, so sink it
|
|
covered_cells.some(([cell_row, cell_col]) => {
|
|
this._set_cell_state(player, cell_row, cell_col, GridCellState.Sunk)
|
|
})
|
|
}
|
|
})
|
|
}
|
|
|
|
/**
|
|
* Attempt to place a ship of the given type at the given coordinates.
|
|
* Throws an InvalidShipPlacementError if the coordinates are invalid.
|
|
* Coordinates should be [row_index, column_index] of either end of the ship.
|
|
*
|
|
* @example
|
|
* If I am placing a 1x3 ship and I want it to be in row 3 column 2 horizontal
|
|
* to row 3 column 4, then I would call:
|
|
* game_service.place_ship(ShipType.x3, [3,2], [3,4])
|
|
*
|
|
* @param {string} ship_type
|
|
* @param {number[]} coords_one
|
|
* @param {number[]} coords_two
|
|
*/
|
|
place_ship(ship_type, coords_one, coords_two) {
|
|
// make sure the coordinates are valid for the given ship type
|
|
this.validate_coordinates(ship_type, coords_one, coords_two)
|
|
|
|
// get the ships for the current player
|
|
const player_ships = this.get_ship_entities(this.current_player)
|
|
|
|
// make sure they don't already have this ship type
|
|
const have_ship_type = player_ships.some(ship => ship.ship_type === ship_type)
|
|
if ( have_ship_type )
|
|
throw new InvalidShipPlacementError('A ship with this type has already been placed.')
|
|
|
|
// make sure they don't already have too many
|
|
if ( player_ships.length >= this.n_boats )
|
|
throw new InvalidShipPlacementError('This player cannot place any more ships.')
|
|
|
|
// place the ship
|
|
this.player_x_ships[this.current_player].push({ ship_type, coords_one, coords_two })
|
|
|
|
// mark the cells as having a ship in them
|
|
this.get_covered_cells(coords_one, coords_two).some(([row_i, col_i]) => {
|
|
this._set_cell_state(this.current_player, row_i, col_i, GridCellState.Ship)
|
|
})
|
|
|
|
// refresh the view
|
|
this._trigger_view_update()
|
|
}
|
|
|
|
/**
|
|
* Get an array of cell coordinates that are covered by a ship that spans
|
|
* the given coordinates.
|
|
*
|
|
* @example
|
|
* If a ship goes from row 1 column 1 to row 4 column 1, then I can get
|
|
* the coordinates of all cells covered by that ship using:
|
|
* game_service.get_covered_cells([1,1], [4,1])
|
|
* Which would return [[1,1], [2,1], [3,1], [4,1]].
|
|
*
|
|
* @param {number[]} coords_one
|
|
* @param {number[]} coords_two
|
|
* @return {number[][]}
|
|
*/
|
|
get_covered_cells(coords_one, coords_two) {
|
|
const [row_one, col_one] = coords_one
|
|
const [row_two, col_two] = coords_two
|
|
const [left_col, right_col] = [Math.min(col_one, col_two), Math.max(col_one, col_two)]
|
|
const [top_row, bottom_row] = [Math.min(row_one, row_two), Math.max(row_one, row_two)]
|
|
const is_horizontal = top_row === bottom_row
|
|
|
|
if ( is_horizontal ) {
|
|
return Array((right_col - left_col) + 1).fill('').map((_, i) => {
|
|
return [top_row, i + left_col]
|
|
})
|
|
} else {
|
|
return Array((bottom_row - top_row) + 1).fill('').map((_, i) => {
|
|
return [i + top_row, left_col]
|
|
})
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Validate the given coordinates for the given ship type.
|
|
* Throws an InvalidShipPlacementError if the coordinates are invalid.
|
|
* Coordinates should be [row_index, column_index] of either end of the ship.
|
|
*
|
|
* @example
|
|
* If I am placing a 1x3 ship and I want it to be in row 3 column 2 horizontal
|
|
* to row 3 column 4, then I would call:
|
|
* game_service.validate_coordinates(ShipType.x3, [3,2], [3,4])
|
|
*
|
|
* @param {string} ship_type
|
|
* @param {number[]} coords_one
|
|
* @param {number[]} coords_two
|
|
*/
|
|
validate_coordinates(ship_type, coords_one, coords_two) {
|
|
if ( !isShipType(ship_type) ) throw new InvalidShipPlacementError('Invalid ship type: '+ship_type)
|
|
|
|
const ship_length = this.get_ship_length(ship_type)
|
|
const [row_one, col_one] = coords_one
|
|
const [row_two, col_two] = coords_two
|
|
const [left_col, right_col] = [Math.min(col_one, col_two), Math.max(col_one, col_two)]
|
|
const [top_row, bottom_row] = [Math.min(row_one, row_two), Math.max(row_one, row_two)]
|
|
|
|
const is_horizontal = top_row === bottom_row
|
|
const ship_cells = this.get_ship_cells(this.current_player)
|
|
const placement_cells = []
|
|
|
|
if ( is_horizontal ) {
|
|
// Make sure the input length matches the given ship type
|
|
if ( (right_col - left_col) !== (ship_length - 1) )
|
|
throw new InvalidShipPlacementError('Invalid coordinates: ship length is invalid')
|
|
|
|
Array(ship_length).fill('').map((_, i) => {
|
|
placement_cells.push([top_row, i + left_col])
|
|
})
|
|
} else {
|
|
// Make sure the input length matches the given ship type
|
|
if ( (bottom_row - top_row) !== (ship_length - 1) )
|
|
throw new InvalidShipPlacementError('Invalid coordinates: ship length is invalid')
|
|
|
|
Array(ship_length).fill('').map((_, i) => {
|
|
placement_cells.push([i + top_row, left_col])
|
|
})
|
|
}
|
|
|
|
// Make sure none of the placement cells overlap with existing ships
|
|
const has_overlap = ship_cells.some(([ship_row, ship_col]) => {
|
|
return placement_cells.some(([placement_row, placement_col]) => {
|
|
return ship_row === placement_row && ship_col === placement_col
|
|
})
|
|
})
|
|
|
|
if ( has_overlap )
|
|
throw new InvalidShipPlacementError('Invalid coordinates: ship overlaps with others')
|
|
}
|
|
|
|
/**
|
|
* Get the number of cells the given ship type should occupy.
|
|
* @param {string} ship_type
|
|
* @return {number}
|
|
*/
|
|
get_ship_length(ship_type) {
|
|
if ( ship_type === ShipType.x1 ) return 1
|
|
if ( ship_type === ShipType.x2 ) return 2
|
|
if ( ship_type === ShipType.x3 ) return 3
|
|
if ( ship_type === ShipType.x4 ) return 4
|
|
if ( ship_type === ShipType.x5 ) return 5
|
|
}
|
|
|
|
/**
|
|
* Get the coordinates of all cells that have ships in them, for the given player.
|
|
* @param {string} player
|
|
* @return {number[]}
|
|
*/
|
|
get_ship_cells(player) {
|
|
const cells = []
|
|
this.player_x_game_board[player].some((row, row_i) => {
|
|
row.some((col, col_i) => {
|
|
if ( isShipCell(col.render) ) {
|
|
cells.push([row_i, col_i])
|
|
}
|
|
})
|
|
})
|
|
return cells
|
|
}
|
|
|
|
/**
|
|
* If there is a winner, this will return the Player that won.
|
|
* If no winner has been decided yet, will return undefined.
|
|
* @return {string|undefined}
|
|
*/
|
|
get_winner() {
|
|
const [player_1, player_2] = this.players
|
|
|
|
// Make sure to sink any fully-damaged ships
|
|
this._sink_damaged_ships(player_1)
|
|
const player_1_ship_cells = this.get_ship_cells(player_1)
|
|
const player_1_loses = (
|
|
(player_1_ship_cells.length > 0)
|
|
&& player_1_ship_cells.every(cell => this._get_cell_state(player_1, cell[0], cell[1]).render === GridCellState.Sunk)
|
|
)
|
|
if ( player_1_loses ) return player_2
|
|
|
|
// Make sure to sink any fully-damaged ships
|
|
this._sink_damaged_ships(player_2)
|
|
const player_2_ship_cells = this.get_ship_cells(player_2)
|
|
const player_2_loses = (
|
|
(player_2_ship_cells.length > 0)
|
|
&& player_2_ship_cells.every(cell => this._get_cell_state(player_2, cell[0], cell[1]).render === GridCellState.Sunk)
|
|
)
|
|
if ( player_2_loses ) return player_2
|
|
}
|
|
|
|
/**
|
|
* Returns the other player.
|
|
* @param {string} player
|
|
* @return {string}
|
|
*/
|
|
get_other_player(player) {
|
|
if ( player === Player.One ) return Player.Two
|
|
else if ( player === Player.Two ) return Player.One
|
|
}
|
|
|
|
/**
|
|
* Given a Player type, return the display value of that player.
|
|
* @param {string} player
|
|
* @return {string}
|
|
*/
|
|
get_player_display(player) {
|
|
if ( player === Player.One ) return 'Player 1'
|
|
else if ( player === Player.Two ) return 'Player 2'
|
|
}
|
|
|
|
/**
|
|
* Get an array of ship entities for the given player.
|
|
* @param {string} player
|
|
* @return {object[]}
|
|
*/
|
|
get_ship_entities(player) {
|
|
return clone(this.player_x_ships[player])
|
|
}
|
|
|
|
/**
|
|
* Build an empty structure of grid cells.
|
|
* @return {object[][]}
|
|
* @private
|
|
*/
|
|
_build_empty_board() {
|
|
return Array(this.n_rows).fill('').map(_ => {
|
|
return Array(this.n_cols).fill('').map(_ => {
|
|
return {
|
|
render: GridCellState.Available,
|
|
}
|
|
})
|
|
})
|
|
}
|
|
|
|
/**
|
|
* Set the state of the cell at the given coordinates on the player's board
|
|
* to the specified state.
|
|
* @param {string} player
|
|
* @param {number} row_i
|
|
* @param {number} col_i
|
|
* @param {string} state
|
|
* @private
|
|
*/
|
|
_set_cell_state(player, row_i, col_i, state) {
|
|
this.player_x_game_board[player][row_i][col_i].render = state
|
|
}
|
|
|
|
/**
|
|
* Get the state of the cell at the given coordinates on the player's board.
|
|
* @param {string} player
|
|
* @param {number} row_i
|
|
* @param {number} col_i
|
|
* @return {object}
|
|
* @private
|
|
*/
|
|
_get_cell_state(player, row_i, col_i) {
|
|
return this.player_x_game_board[player][row_i][col_i]
|
|
}
|
|
|
|
/**
|
|
* Force a view update without changing the current state.
|
|
* @private
|
|
*/
|
|
_trigger_view_update() {
|
|
this.game_state_change_listeners.forEach(fn => fn(this.current_state, true))
|
|
}
|
|
}
|
|
|
|
// Export a single instance, so it can be shared by all files
|
|
// To use the game state service, you should do:
|
|
// import game_service from './services/GameState.service.js'
|
|
const game_service = new GameStateService()
|
|
export default game_service
|
|
</code></pre>
|
|
</article>
|
|
</section>
|
|
|
|
|
|
|
|
|
|
</div>
|
|
|
|
<nav>
|
|
<h2><a href="index.html">Home</a></h2><h3>Modules</h3><ul><li><a href="module-errors.html">errors</a></li><li><a href="module-lang.html">lang</a></li><li><a href="module-sounds.html">sounds</a></li><li><a href="module-util.html">util</a></li></ul><h3>Classes</h3><ul><li><a href="GameBoardComponent.html">GameBoardComponent</a></li><li><a href="GameStateService.html">GameStateService</a></li><li><a href="GridCellComponent.html">GridCellComponent</a></li><li><a href="module-errors.InvalidAdvanceStateError.html">InvalidAdvanceStateError</a></li><li><a href="module-errors.InvalidMissileFireAttemptError.html">InvalidMissileFireAttemptError</a></li><li><a href="module-errors.InvalidShipPlacementError.html">InvalidShipPlacementError</a></li><li><a href="module-sounds-Sound.html">Sound</a></li><li><a href="ScoreBoardComponent.html">ScoreBoardComponent</a></li><li><a href="TopLevelComponent.html">TopLevelComponent</a></li></ul>
|
|
</nav>
|
|
|
|
<br class="clear">
|
|
|
|
<footer>
|
|
Documentation generated by <a href="https://github.com/jsdoc/jsdoc">JSDoc 3.6.5</a> on Sat Sep 12 2020 16:40:09 GMT-0500 (Central Daylight Time)
|
|
</footer>
|
|
|
|
<script> prettyPrint(); </script>
|
|
<script src="scripts/linenumber.js"> </script>
|
|
</body>
|
|
</html>
|