Uses of Class antichess.Board

Overview

Package

Class

Use

Deprecated

Index

Home >> All >> [ antichess overview ]

PREV NEXT

Uses of Class
antichess.Board

Uses of Board in antichess

Fields in antichess declared as Board

private Board XChessBoard.board


private Board Zobrist.board


private Board TestBoard.board0


private Board TestBoard.board1


private Board TestBoard.board2


private Board TestBoard.board3


private Board TestBoard.board4


private Board Piece.board


private Board MachinePlayer.board


private Board GameController.board


private Board BetterEngine.board

Methods in antichess that return Board

Board Piece.getBoard()
          Gets the board the Piece is on

Board MachinePlayer.getBoard()


Board GameController.getBoard()
          Gets the Board representing the state of the game

Board EmptyPiece.getBoard()
           DOES NOTHING **DONT USE**

Methods in antichess with parameters of type Board

long Zobrist.getKey(Board board, int nextTurn)
          Returns a zobrist key for the board

void Zobrist.deletePiece(Board board, int type, int color, int col, int row)
          MUST BE CALLED WHEN BOARD IS CHANGED THROUGH A MOVE OR UNDOMOVE Updates the key for the board update

void Zobrist.addPiece(Board board, int type, int color, int col, int row)
          MUST BE CALLED WHEN BOARD IS CHANGED THROUGH A MOVE OR UNDOMOVE Updates the key for the board update

Piece Rook.copyPiece(Board b)
          Creates a copy to a new board

private boolean TestBoard.hasInside(Board b, Piece[][] array, Piece p)
          Helper Function Checks whether given piece is in array

Piece Queen.copyPiece(Board b)
          Creates a copy to a new board

Piece Piece.copyPiece(Board b)
          Creates a copy to a new board To be overriden by each class

static void Piece.addEmpty(Board board)
          Adds empty pieces to the rest of the board

void Piece.setBoard(Board b)
          Sets the board for this piece

private static boolean Piece.onlyKingLeft(Board b, int nextTurn)
          Returns if the king is the only piece left for a side

static boolean Piece.isGameOver(Board b, int nextTurn)
          Returns if a game is over given a board, with nextTurn being the next player to move Note that this method will recompute all the valid moves in order to determine whether the game is over or not.

static boolean Piece.isGameOver(Board b, int nextTurn, java.util.List validMoves)
          Returns if a game is over given a board, the nextTurn being the next player to move and the list of valid moves.

static boolean Piece.isTie(Board b, int nextTurn)
          Returns if a game is draw given a board, with nextTurn being the next player to move Note that this method will recompute all the valid moves in order to determine whether the game is a tie or not.

static boolean Piece.isTie(Board b, int nextTurn, java.util.List validMoves)
          Returns if a game is draw given a board, the nextTurn being the next player to move and the list of valid moves.

static boolean Piece.isWin(Board b, int nextTurn)
          Returns if a particular side has won.

static boolean Piece.isWin(Board b, int nextTurn, java.util.List validMoves)
          Returns if a particular side has won, given a board, the nextTurn being the next player to move and the list of valid moves.

static boolean Piece.kingInCheck(Board b, int color)


static java.util.List Piece.getValidMoves(Board b, int color)
          Finds all legal moves given a board and a color to move.

static java.util.List Piece.getAllValidMoves(Board b, int color)
          Finds all legal moves, including switch moves in both directions eg: both a1-a2 and a2-a1 will be included.

static java.util.List Piece.getStandardValidMoves(Board b, int color)
          Finds all legal moves given a board and a color to move, EXCLUDING switch moves.

static boolean Piece.isValidMove(Board b, Move move, int color)
          Checks if a move is legal given a board and the color to move.

static java.util.List Piece.getSwitchMoves(Board b, int color)
          Returns a list of valid switch moves.

private static java.util.List Piece.getPossibleSwitchMoves(Board b, int color)
          Returns a list of possible switch (not necesarily legal) moves a piece can make The Moves are not necessarily legal.

private static void Piece.removeCheckMoves(Board b, java.util.List moves)
          Removes illegal and duplicate moves from a List

static boolean Piece.makeMove(Board b, Move m)
          Makes a given move on a board, modifying it, recomputing the validMoves.

static boolean Piece.makeMove(Board b, Move m, java.util.List validMoves)
          Makes a given move on a board, modifying it, without recomputing the validMoves.

static void Piece.makeGeneratedMove(Board b, Move move)
          Makes a computer generated move.

static void Piece.undoMove(Board b, Move move)
          Undos a move.

static java.util.List Piece.getValidMovesNormalChess(Board b, int color)
          Finds all Normal chess legal moves given a board and a color to move.

static boolean Piece.isGameOverNormalChess(Board b, int nextTurn)
          Returns if a game is over given a board, with nextTurn being the next player to move Note that this method will recompute all the valid moves in order to determine whether the game is over or not.

static boolean Piece.isTieNormalChess(Board b, int nextTurn)
          Returns if a game is draw given a board, with nextTurn being the next player to move Note that this method will recompute all the valid moves in order to determine whether the game is a tie or not.

static boolean Piece.isLoseNormalChess(Board b, int nextTurn)
          Returns if a particular side has lost.

Piece Pawn.copyPiece(Board b)
          Creates a copy to a new board

void Move.setLastPieces(Board b)
          Retrieves and stores the last pieces information from a board

void Move.restoreLastPieces(Board b)
          Restores the last pieces information to a board

private static int NewEngine.negaMaxRec(Board board, int depth, int nextTurn)
          Standard NegaMax algorithm, recursive method (for children nodes) It is necessary to make a distinction between the entrance method which runs on the root node and the recursive method which runs on children nodes.

static Move NewEngine.negaMax(Board board, int depth, int nextTurn)
          Standard NegaMax algorithm, entrance method (for the root node)
board Board to make a search on
depth Depth of seach
nextTurn next player to move

static Move NewEngine.randomMove(Board board, int player)
          Returns a random move from the valid moves of the player

private static int NewEngine.alphaBetaRec(Board board, int depth, int nextTurn, int alphaIN, int betaIN)
          Standard AlphaBeta algorithm, lower terms It is necessary to make a distinction between the entrance method which runs on the root node and the recursive method which runs on children nodes.

static Move NewEngine.alphaBeta(Board board, int depth, int nextTurn, int alphaIN, int betaIN)
          Standard Alpha-Beta algorithm, entrance method
board Board to make a search on
depth Depth of seach
nextTurnnext player to move
alphalower term of alpha-beta
beta higher term of alpha-beta

private static int NewEngine.alphaBetaHashRec(Board board, java.util.Map boardTable, int depth, int nextTurn, int alphaIN, int betaIN)
          Standard AlphaBeta algorithm, lower terms It is necessary to make a distinction between the entrance method which runs on the root node and the recursive method which runs on children nodes.

static Move NewEngine.alphaBetaHash(Board board, java.util.Map boardTable, int depth, int nextTurn, int alphaIN, int betaIN)
          Standard Alpha-Beta algorithm, entrance method
board Board to make a search on
depth Depth of seach
nextTurnnext player to move
alphalower term of alpha-beta
beta higher term of alpha-beta

Piece King.copyPiece(Board b)
          Creates a copy to a new board

Piece Knight.copyPiece(Board b)
          Creates a copy to a new board

private void GameController.setBoard(Board b)
          Sets the board to be the given board

static int Evaluator.evaluateBoard(Board board, int colorToMove, int evalQuality)


Piece EmptyPiece.copyPiece(Board b)
          Creates a copy to a new board

boolean Board.equals(Board other)
          Checks for equality.

static int CEvaluator.evaluateBoard(Board board, int colorToMove, int evalQuality)


Piece Bishop.copyPiece(Board b)
          Creates a copy to a new board

private int BetterEngine.makeQuies(Board board, int nextTurn, int alphaIN, int betaIN, int depth)
          Returns the quiescent seach value

private int BetterEngine.evaluate(Board board, int nextTurn)
          Our evaluate function

Constructors in antichess with parameters of type Board

Zobrist(Board board)
          Creates a Zobrist matrix for a specific board.

Rook(char letter, Board b, int col, int row, int color)
          Creates a new piece.

Queen(char letter, Board b, int col, int row, int color)
          Creates a new piece.

Piece(int type, char letter, Board b, int col, int row, int color)
          Takes in a piece type and board and assigns the current piece to it.

Pawn(char letter, Board b, int col, int row, int color)
          Creates a new piece.

MachinePlayer(int color, int level, Board bd)
          Constructs a machineplayer from a given board.

King(char letter, Board b, int col, int row, int color)
          Creates a new piece.

Knight(char letter, Board b, int col, int row, int color)
          Creates a new piece.

EmptyPiece(Board b, int col, int row)


EmptyPiece(char letter, Board b, int col, int row)


Board(Board b)
          Creates a copy of a given board, deep copying every piece

Bishop(char letter, Board b, int col, int row, int color)
          Creates a new piece.

BetterEngine(Board board, java.util.Map boardTable, int depth, int nextTurn)
          This starts a new BetterEngine with the corresponding values