AbstractChess3D

abstract class AbstractChess3D(rules: List<SpecialRules3D<AbstractChess3D>>, endConditions: List<EndCondition3D<AbstractChess3D>>, startPlayer: Int) : AbstractChess<Board3D, MoveGenerator3D, Piece3D, Coordinate3D> , GameType3D

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

Constructors

AbstractChess3D

fun AbstractChess3D(rules: List<SpecialRules3D<AbstractChess3D>> = listOf(), endConditions: List<EndCondition3D<AbstractChess3D>> = listOf(EndConditions3DChess()), startPlayer: Int = 0)

Functions

concede

abstract 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)

abstract 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<Board3D, MoveGenerator3D, Piece3D, Coordinate3D>>

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

abstract fun getValidMoves(player: Player): List<Move<Board3D, MoveGenerator3D, Piece3D, Coordinate3D>>

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

abstract fun initGame()

Initialises the game by clearing and initialising the board

isOver

abstract fun isOver(): Boolean

Returns if the game is over or not

makeMove

abstract fun makeMove(move: Move<Board3D, MoveGenerator3D, Piece3D, Coordinate3D>)

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<Board3D, MoveGenerator3D, Piece3D, Coordinate3D>)

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: Board3D

the board of the game

endConditions

abstract val endConditions: List<EndCondition<GameType<Board3D, MoveGenerator3D, Piece3D, Coordinate3D>, Board3D, MoveGenerator3D, Piece3D, Coordinate3D>>

moveLog

abstract val moveLog: MutableList<Move<Board3D, MoveGenerator3D, Piece3D, Coordinate3D>>

the list of all moves played

name

abstract val name: String

the name of the game

players

abstract val players: List<Player>

the list of all participants of the game

playerTurn

abstract var playerTurn: Int

the current turn of the game

rules

abstract val rules: List<SpecialRules<GameType<Board3D, MoveGenerator3D, Piece3D, Coordinate3D>, Board3D, MoveGenerator3D, Piece3D, Coordinate3D>>

seed

abstract var seed: Double?

the random seed

Inheritors

RaumschachChess