GameType2P

abstract class GameType2P<B : Board<B, MG, P, C>, MG : MoveGenerator<B, MG, P, C>, P : Piece<B, MG, P, C>, C : Coordinate> : GameType<B, MG, P, C>

Represents a standard n-player game, which contains no special rules and standard end conditions.

Constructors

GameType2P

fun GameType2P()

Functions

concede

open override fun concede(player: Player)

Sets the concedeWinner to opponent (a player that is not current player)

equals

open operator fun equals(other: Any?): Boolean

getCurrentPlayer

open fun getCurrentPlayer(): Player

Returns the current player

getNextPlayer

open fun getNextPlayer(): Player

Returns the next player without incrementing the turn.

getOpponentPlayer

fun getOpponentPlayer(player: Player): Player

getOpponentPlayers

open fun getOpponentPlayers(player: Player): List<Player>

Returns a list of opponent players for a given player.

getOutcome

open fun getOutcome(): Outcome?

Returns the outcome of the game for the current player, which can be either Win or Draw (null if the game is not over)

open override fun getOutcome(player: Player): Outcome?

Returns the outcome of the game for the given player, which can be either Win or Draw (null if the game is not over)

getValidMoves

open fun getValidMoves(): List<Move<B, MG, P, C>>

Returns a list of all possible valid moves of the current player

abstract fun getValidMoves(player: Player): List<Move<B, MG, P, C>>

Returns a list of all possible valid moves of the given player

hashCode

open fun hashCode(): Int

inCheck

abstract fun inCheck(player: Player): Boolean

Returns if the given player's Royal piece is is check or not, assuming that the Royal piece is present on the board.

initBoard

abstract fun initBoard()

Initialises the board Places pieces on the initial position of the board

initGame

open override fun initGame()

Initialises the game by clearing and initialising the board

isOver

open override fun isOver(): Boolean

Returns if the game is over or not

makeMove

abstract fun makeMove(move: Move<B, MG, P, C>)

Makes the given move on the current board and add the move to the move log.

nextPlayer

open fun nextPlayer()

Increments the turn

playerMakeMove

open fun playerMakeMove(move: Move<B, MG, P, C>)

Makes a given move and increments the turn

prevPlayer

open fun prevPlayer()

Decrements the turn

toString

open fun toString(): String

undoMove

abstract fun undoMove()

Reverts the last move and removes it from the move log.

Properties

board

abstract val board: B

the board of the game

endConditions

abstract val endConditions: List<EndCondition<GameType<B, MG, P, C>, B, MG, P, C>>

moveLog

open override val moveLog: MutableList<Move<B, MG, P, C>>

the list of all moves played

name

abstract val name: String

the name of the game

players

open override val players: List<Player>

the list of all participants of the game

playerTurn

open override var playerTurn: Int = 0

the current turn of the game

rules

abstract val rules: List<SpecialRules<GameType<B, MG, P, C>, B, MG, P, C>>

seed

open override var seed: Double? = null

the random seed

Inheritors

AbstractChess