garrettmills
/
eecs448-project-1
mirror of https://github.com/EECS-448-Battleship/project-1
1
0
Fork 0
Code Issues Releases Wiki Activity

add helper method to handle placing and validating a ship (#2)

Browse Source
issue-2
Garrett Mills 4 years ago
parent a803c6937d
commit 9a2afe523e
Signed by: garrettmills
GPG Key ID: D2BF5FBA8298F246
1 changed files with 218 additions and 36 deletions
Show Stats Download Patch File Download Diff File

254
src/services/GameState.service.js
Unescape View File

@ -1,4 +1,5 @@
import { Player, GridCellState, GameState, clone } from '../module/util.js'
import { Player, GridCellState, GameState, clone, ShipType, isShipType, isShipCell } from '../module/util.js'
import { InvalidShipPlacementError, InvalidAdvanceStateError } from '../module/errors.js'
/**
* Singleton service for managing the state of the game.
@ -11,6 +12,13 @@ export class GameStateService {
*/
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
@ -88,6 +96,7 @@ export class GameStateService {
// 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] = []
}
}
@ -152,21 +161,6 @@ export class GameStateService {
})
}
/**
* 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,
}
})
})
}
/**
* get the "score" (the number of hits) that the
* current player has (counting sunk ships)
@ -231,7 +225,7 @@ export class GameStateService {
* @return
* @private
*/
advance_game_state(){
advance_game_state() {
/** functions to be made that validate:
* 1) number of ships
* 2) player one placement
@ -241,36 +235,224 @@ export class GameStateService {
* 6) player 2 turn
* 7) advance to player one
* 8) player win
*
*
*/
//1
if(this.current_state === GameState.ChoosingNumberOfShips)
{
if(this.n_boats >= 1 && this.n_boats <= 5 )
{
this.current_state = GameState.PlayerSetup;
if (this.current_state === GameState.ChoosingNumberOfShips) {
if (this.n_boats >= 1 && this.n_boats <= 5) {
this.current_state = GameState.PlayerSetup;
this.current_player = Player.One;
this.current_opponent = Player.Two;
this.current_opponent = Player.Two;
} else {
throw new InvalidAdvanceStateError("Invalid Number of Boats");
}
else
{
throw new Error("Invalid Number of Boats");
}
}
if(this.current_state === GameState.PlayerSetup)
{
if(this.current_player === Player.One)
{
if (this.current_state === GameState.PlayerSetup) {
if (this.current_player === Player.One) {
//wait
// because the place_ship handles all the validation
// all you need to do is make sure they have placed all the appropriate ships
// e.g. if ( this.get_ship_entities(this.current_player).length === this.n_boats ) { ... }
}
if(this.current_player === Player.Two)
{
if (this.current_player === Player.Two) {
//wait for now
}
}
}
/**
* 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 {ShipType} ship_type
* @param {[number, number]} coords_one
* @param {[number, 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)
})
}
/**
* 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, number]} coords_one
* @param {[number, number]} coords_two
* @return {[number, 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 {ShipType} ship_type
* @param {[number, number]} coords_one
* @param {[number, 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 {ShipType} 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 {Player} player
* @return {[number, 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
}
/**
* Get an array of ship entities for the given player.
* @param {Player} 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 {Player} player
* @param {number} row_i
* @param {number} col_i
* @param {GridCellState} state
* @private
*/
_set_cell_state(player, row_i, col_i, state) {
this.player_x_game_board[player][row_i][col_i].render = state
}
}

Write Preview
Loading…
Cancel
Save