501 lines
16 KiB
Java
501 lines
16 KiB
Java
//This file is part of SECONDO.
|
|
|
|
//Copyright (C) 2004, University in Hagen, Department of Computer Science,
|
|
//Database Systems for New Applications.
|
|
|
|
//SECONDO is free software; you can redistribute it and/or modify
|
|
//it under the terms of the GNU General Public License as published by
|
|
//the Free Software Foundation; either version 2 of the License, or
|
|
//(at your option) any later version.
|
|
|
|
//SECONDO is distributed in the hope that it will be useful,
|
|
//but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
//GNU General Public License for more details.
|
|
|
|
//You should have received a copy of the GNU General Public License
|
|
//along with SECONDO; if not, write to the Free Software
|
|
//Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
|
|
package viewer.chess;
|
|
/**
|
|
* This class provides constants and static methods which are used by all classes
|
|
* in the chess package.
|
|
*/
|
|
public class ChessToolKit
|
|
{
|
|
/** constant for the minimum row number on a chessboard**/
|
|
public static final int MIN_ROW = 1;
|
|
|
|
/** constant for the maximum row number on a chessboard**/
|
|
public static final int MAX_ROW = 8;
|
|
|
|
/** char constant for the a marked file on a chessboard **/
|
|
public static final char A = 'a';
|
|
|
|
/** char constant for the b marked file on a chessboard **/
|
|
public static final char B = 'b';
|
|
|
|
/** char constant for the c marked file on a chessboard **/
|
|
public static final char C = 'c';
|
|
|
|
/** char constant for the d marked file on a chessboard **/
|
|
public static final char D = 'd';
|
|
|
|
/** char constant for the e marked file on a chessboard **/
|
|
public static final char E = 'e';
|
|
|
|
/** char constant for the f marked file on a chessboard **/
|
|
public static final char F = 'f';
|
|
|
|
/** char constant for the g marked file on a chessboard **/
|
|
public static final char G = 'g';
|
|
|
|
/** char constant for the h marked file on a chessboard **/
|
|
public static final char H = 'h';
|
|
|
|
/** char constant to mark a agent which does not exist**/
|
|
public static final char FALSE_AGENT = 'e';
|
|
|
|
/** key for the event - tag*/
|
|
public static final String EVENT_KEY = "event";
|
|
|
|
/** key for the site - tag*/
|
|
public static final String SITE_KEY = "site";
|
|
|
|
/** key for the date - tag*/
|
|
public static final String DATE_KEY = "date";
|
|
|
|
/** key for the round - tag*/
|
|
public static final String ROUND_KEY = "round";
|
|
|
|
/** key for the white - tag*/
|
|
public static final String WHITE_KEY = "white";
|
|
|
|
/** key for the black - tag*/
|
|
public static final String BLACK_KEY = "black";
|
|
|
|
/** key for the result - tag*/
|
|
public static final String RESULT_KEY = "result";
|
|
|
|
/** string representation of a relation type in a ListExpr **/
|
|
public static final String RELATION_TYPE_STRING = "rel";
|
|
|
|
/** string representation of the tuple type in a ListExpr **/
|
|
public static final String TUPLE_TYPE_STRING = "tuple";
|
|
|
|
/** string representation of the chessgame type in a ListExpr **/
|
|
public static final String CHESSGAME_TYPE_STRING = "chessgame";
|
|
|
|
/** directory which contains the image files of the chess viewer **/
|
|
public static final String IMAGES_DIR = "images";
|
|
|
|
/** path to the image directory **/
|
|
public static final String PATH_TO_THIS_CLASS = "viewer"+System.getProperty("file.separator")+"chess";
|
|
|
|
/** absoulute path to the images needed by this viewer **/
|
|
public static final String IMAGES_PATH = System.getProperty("user.dir")+
|
|
System.getProperty("file.separator")+
|
|
PATH_TO_THIS_CLASS+System.getProperty("file.separator")+
|
|
IMAGES_DIR+System.getProperty("file.separator");
|
|
|
|
/** file name of the black bishop image**/
|
|
public static final String BBISHOP_FILENAME = "black.bishop.png";
|
|
|
|
/** file name of the black rook image**/
|
|
public static final String BROOK_FILENAME = "black.rook.png";
|
|
|
|
/** file name of the black knight image**/
|
|
public static final String BKNIGHT_FILENAME = "black.knight.png";
|
|
|
|
/** file name of the black queen image**/
|
|
public static final String BQUEEN_FILENAME = "black.queen.png";
|
|
|
|
/** file name of the black king image**/
|
|
public static final String BKING_FILENAME = "black.king.png";
|
|
|
|
/** file name of the black pawn image**/
|
|
public static final String BPAWN_FILENAME = "black.pawn.png";
|
|
|
|
/** file name of a white bishop image**/
|
|
public static final String WBISHOP_FILENAME = "white.bishop.png";
|
|
|
|
/** file name of a white rook image**/
|
|
public static final String WROOK_FILENAME = "white.rook.png";
|
|
|
|
/** file name of a white knight image**/
|
|
public static final String WKNIGHT_FILENAME = "white.knight.png";
|
|
|
|
/** file name of a white king image**/
|
|
public static final String WKING_FILENAME = "white.king.png";
|
|
|
|
/** file name of a white pawn image**/
|
|
public static final String WPAWN_FILENAME = "white.pawn.png";
|
|
|
|
/** file name of a white queen image**/
|
|
public static final String WQUEEN_FILENAME = "white.queen.png";
|
|
|
|
/** pgn string for kingside castling **/
|
|
public static final String KINGSIDE_CASTLING_PGN = "O-O";
|
|
|
|
/** pgn string for queenside castling **/
|
|
public static final String QUEENSIDE_CASTLING_PGN = "O-O-O";
|
|
|
|
/** char representation of a white king **/
|
|
public static final char WHITE_KING = 'K';
|
|
|
|
/** char representation of a black king **/
|
|
public static final char BLACK_KING = 'k';
|
|
|
|
/** char representation of a white queen**/
|
|
public static final char WHITE_QUEEN = 'Q';
|
|
|
|
/** char representation of a black queen**/
|
|
public static final char BLACK_QUEEN = 'q';
|
|
|
|
/** char representation of a white bishop**/
|
|
public static final char WHITE_BISHOP = 'B';
|
|
|
|
/** char representation of a black bishop **/
|
|
public static final char BLACK_BISHOP = 'b';
|
|
|
|
/** char representation of a white knight **/
|
|
public static final char WHITE_KNIGHT = 'N';
|
|
|
|
/** char representation of a black knight **/
|
|
public static final char BLACK_KNIGHT = 'n';
|
|
|
|
/** char representation of a white rook **/
|
|
public static final char WHITE_ROOK = 'R';
|
|
|
|
/** char representation of a black rook **/
|
|
public static final char BLACK_ROOK = 'r';
|
|
|
|
/** char representation of a white pawn **/
|
|
public static final char WHITE_PAWN = 'P';
|
|
|
|
/** char representation of a black pawn **/
|
|
public static final char BLACK_PAWN = 'p';
|
|
|
|
/** char representation for a square where no chessman is on **/
|
|
public static final char NONE = 'z';
|
|
|
|
/**
|
|
* String representation of a Black King
|
|
*/
|
|
public static final String BLACK_KING_STRING = "black king";
|
|
|
|
/**
|
|
* String representation of a Black Queen
|
|
*/
|
|
public static final String BLACK_QUEEN_STRING = "black queen";
|
|
|
|
/**
|
|
* String representation of a Black Bishop
|
|
*/
|
|
public static final String BLACK_BISHOP_STRING = "black bishop";
|
|
|
|
/**
|
|
* String representation of a Black Knight
|
|
*/
|
|
public static final String BLACK_KNIGHT_STRING = "black knight";
|
|
|
|
/**
|
|
* String representation of a Black Rook
|
|
*/
|
|
public static final String BLACK_ROOK_STRING = "black rook";
|
|
|
|
/**
|
|
* String representation of a Black Pawn
|
|
*/
|
|
public static final String BLACK_PAWN_STRING = "black pawn";
|
|
|
|
/**
|
|
* String representation of a White King
|
|
*/
|
|
public static final String WHITE_KING_STRING = "white king";
|
|
|
|
/**
|
|
* String representation of a White Queen
|
|
*/
|
|
public static final String WHITE_QUEEN_STRING = "white queen";
|
|
|
|
/**
|
|
* String representation of a White bishop
|
|
*/
|
|
public static final String WHITE_BISHOP_STRING = "white bishop";
|
|
|
|
/**
|
|
* String representation of a White Knight
|
|
*/
|
|
public static final String WHITE_KNIGHT_STRING = "white knight";
|
|
|
|
/**
|
|
* String representation of a White Rook
|
|
*/
|
|
public static final String WHITE_ROOK_STRING = "white rook";
|
|
|
|
/**
|
|
* String representation of a white pawn
|
|
*/
|
|
public static final String WHITE_PAWN_STRING = "white pawn";
|
|
|
|
/**
|
|
* String representation of a square where no chess is
|
|
*/
|
|
public static final String NONE_STRING = "none";
|
|
|
|
/** String representation of a white king in the list format of chessgame*/
|
|
public static final String PGN_WHITE_KING = "King";
|
|
|
|
/** String representation of a white queen in the list format of chessgame*/
|
|
public static final String PGN_WHITE_QUEEN = "Queen";
|
|
|
|
/** String representation of a white bishop in the list format of chessgame*/
|
|
public static final String PGN_WHITE_BISHOP = "Bishop";
|
|
|
|
/** String representation of a white knight in the list format of chessgame*/
|
|
public static final String PGN_WHITE_KNIGHT = "Knight";
|
|
|
|
/** String representation of a white rook in the list format of chessgame*/
|
|
public static final String PGN_WHITE_ROOK = "Rook";
|
|
|
|
/** String representation of a white pawn in the list format of chessgame*/
|
|
public static final String PGN_WHITE_PAWN = "Pawn";
|
|
|
|
/** String representation of a black king in the list format of chessgame*/
|
|
public static final String PGN_BLACK_KING = "king";
|
|
|
|
/** String representation of a black queen in the list format of chessgame*/
|
|
public static final String PGN_BLACK_QUEEN = "queen";
|
|
|
|
/** String representation of a black bsihop in the list format of chessgame*/
|
|
public static final String PGN_BLACK_BISHOP = "bishop";
|
|
|
|
/** String representation of a black knight in the list format of chessgame*/
|
|
public static final String PGN_BLACK_KNIGHT = "knight";
|
|
|
|
/** String representation of a black rook in the list format of chessgame*/
|
|
public static final String PGN_BLACK_ROOK = "rook";
|
|
|
|
/** String representation of a black pawn in the list format of chessgame*/
|
|
public static final String PGN_BLACK_PAWN = "pawn";
|
|
|
|
/** String representation of no chessman*/
|
|
public static final String PGN_NONE = "none";
|
|
|
|
|
|
/**
|
|
* this method returns the char representation for the chessman in the String parameter
|
|
*/
|
|
public static char getCharAgent(String agent)
|
|
{
|
|
if (agent.trim().equals(ChessToolKit.PGN_WHITE_KING))
|
|
return ChessToolKit.WHITE_KING;
|
|
if(agent.trim().equals(ChessToolKit.PGN_BLACK_KING))
|
|
return ChessToolKit.BLACK_KING;
|
|
if(agent.trim().equals(ChessToolKit.PGN_WHITE_QUEEN))
|
|
return ChessToolKit.WHITE_QUEEN;
|
|
if(agent.trim().equals(ChessToolKit.PGN_BLACK_QUEEN))
|
|
return ChessToolKit.BLACK_QUEEN;
|
|
if(agent.trim().equals(ChessToolKit.PGN_WHITE_BISHOP))
|
|
return ChessToolKit.WHITE_BISHOP;
|
|
if(agent.trim().equals(ChessToolKit.PGN_BLACK_BISHOP))
|
|
return ChessToolKit.BLACK_BISHOP;
|
|
if(agent.trim().equals(ChessToolKit.PGN_WHITE_KNIGHT))
|
|
return ChessToolKit.WHITE_KNIGHT;
|
|
if(agent.trim().equals(ChessToolKit.PGN_BLACK_KNIGHT))
|
|
return ChessToolKit.BLACK_KNIGHT;
|
|
if(agent.trim().equals(ChessToolKit.PGN_WHITE_ROOK))
|
|
return ChessToolKit.WHITE_ROOK;
|
|
if(agent.trim().equals(ChessToolKit.PGN_BLACK_ROOK))
|
|
return ChessToolKit.BLACK_ROOK;
|
|
if(agent.trim().equals(ChessToolKit.PGN_WHITE_PAWN))
|
|
return ChessToolKit.WHITE_PAWN;
|
|
if(agent.trim().equals(ChessToolKit.PGN_BLACK_PAWN))
|
|
return ChessToolKit.BLACK_PAWN;
|
|
if(agent.trim().toLowerCase().equals(PGN_NONE))
|
|
return ChessToolKit.NONE;
|
|
return ChessToolKit.FALSE_AGENT;
|
|
}
|
|
|
|
/** this method checks if file is really a correct file on a chessboard**/
|
|
public static boolean isFile(char file)
|
|
{
|
|
char c = Character.toLowerCase(file);
|
|
if(c == ChessToolKit.A||
|
|
c==ChessToolKit.B ||
|
|
c==ChessToolKit.C ||
|
|
c==ChessToolKit.D ||
|
|
c==ChessToolKit.E ||
|
|
c==ChessToolKit.F ||
|
|
c==ChessToolKit.G ||
|
|
c==ChessToolKit.H
|
|
)
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
/** checks if row is a correct row on a chessboard **/
|
|
public static boolean isRow(int row)
|
|
{
|
|
if(row >=ChessToolKit.MIN_ROW && row <= ChessToolKit.MAX_ROW)
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
/**checks if agent is a correct chess agent, noneAllowed means that the 'none' value for a agent is allowed*/
|
|
public static boolean isAgent(String agent, boolean noneAllowed)
|
|
{
|
|
char c = ChessToolKit.getCharAgent(agent);
|
|
if(c==ChessToolKit.FALSE_AGENT)
|
|
return false;
|
|
if(c==ChessToolKit.NONE && !noneAllowed)
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
/** toString method for a GameData object**/
|
|
public static String toString(GameData game)
|
|
{
|
|
StringBuffer out = new StringBuffer();
|
|
if (game.getNo() != -1)
|
|
{
|
|
out.append(game.getNo());
|
|
out.append('.');
|
|
out.append(' ');
|
|
}
|
|
out.append(game.getEvent());
|
|
out.append(": ");
|
|
out.append(game.getWhite());
|
|
out.append(" vs. ");
|
|
out.append(game.getBlack());
|
|
return out.toString();
|
|
}
|
|
|
|
/** returns the string representation of the chessman in the char parameter **/
|
|
public static String stringForChar(char c)
|
|
{
|
|
switch (c)
|
|
{
|
|
case ChessToolKit.WHITE_KING:return ChessToolKit.WHITE_KING_STRING;
|
|
case ChessToolKit.WHITE_QUEEN:return ChessToolKit.WHITE_QUEEN_STRING;
|
|
case ChessToolKit.WHITE_BISHOP:return ChessToolKit.WHITE_BISHOP_STRING;
|
|
case ChessToolKit.WHITE_KNIGHT:return ChessToolKit.WHITE_KNIGHT_STRING;
|
|
case ChessToolKit.WHITE_ROOK:return ChessToolKit.WHITE_ROOK_STRING;
|
|
case ChessToolKit.WHITE_PAWN:return ChessToolKit.WHITE_PAWN_STRING;
|
|
case ChessToolKit.BLACK_KING:return ChessToolKit.BLACK_KING_STRING;
|
|
case ChessToolKit.BLACK_QUEEN:return ChessToolKit.BLACK_QUEEN_STRING;
|
|
case ChessToolKit.BLACK_BISHOP:return ChessToolKit.BLACK_BISHOP_STRING;
|
|
case ChessToolKit.BLACK_KNIGHT:return ChessToolKit.BLACK_KNIGHT_STRING;
|
|
case ChessToolKit.BLACK_ROOK:return ChessToolKit.BLACK_ROOK_STRING;
|
|
case ChessToolKit.BLACK_PAWN:return ChessToolKit.BLACK_PAWN_STRING;
|
|
}
|
|
return ChessToolKit.NONE_STRING;
|
|
}
|
|
|
|
/** to String method for a MoveData object **/
|
|
public static String toString(MoveData move)
|
|
{
|
|
if(move.getNo() != -1)
|
|
{
|
|
StringBuffer out = new StringBuffer();
|
|
out.append(move.getNo());
|
|
out.append(". ");
|
|
out.append(ChessToolKit.stringForChar(move.getAgent()));
|
|
out.append(": ");
|
|
if(move.getCaptured()!=ChessToolKit.NONE)
|
|
{
|
|
out.append("captures ");
|
|
out.append(ChessToolKit.stringForChar(move.getCaptured()));
|
|
out.append(" on ");
|
|
out.append(move.getTargetFile());
|
|
out.append(move.getTargetRow());
|
|
}
|
|
else
|
|
{
|
|
if (move.isKingSideCastling())
|
|
{
|
|
out.append("Kingside Castling");
|
|
}
|
|
else
|
|
{
|
|
if(move.isQueenSideCastling())
|
|
out.append("Queenside Castling");
|
|
else
|
|
{
|
|
if(move.isPawnPromotion())
|
|
{
|
|
out.append("is promoted to ");
|
|
char piece = move.getPromotionPiecePgn();
|
|
if (move.isWhite())
|
|
out.append(ChessToolKit.stringForChar(Character.toUpperCase(piece)));
|
|
else
|
|
out.append(ChessToolKit.stringForChar(Character.toLowerCase(piece)));
|
|
}
|
|
else
|
|
{
|
|
out.append(move.getStartFile());
|
|
out.append(move.getStartRow());
|
|
out.append(" --> ");
|
|
out.append(move.getTargetFile());
|
|
out.append(move.getTargetRow());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if(move.isCheck())
|
|
{
|
|
out.append("(check)");
|
|
}
|
|
return out.toString();
|
|
}
|
|
return ("start of game");
|
|
}
|
|
|
|
/** returns the char represenation of the file denoted in the int parameter **/
|
|
public static char fileForNumber(int file)
|
|
{
|
|
switch(file)
|
|
{
|
|
case 1: return ChessToolKit.A;
|
|
case 2: return ChessToolKit.B;
|
|
case 3: return ChessToolKit.C;
|
|
case 4: return ChessToolKit.D;
|
|
case 5: return ChessToolKit.E;
|
|
case 6: return ChessToolKit.F;
|
|
case 7: return ChessToolKit.G;
|
|
case 8: return ChessToolKit.H;
|
|
}
|
|
return 'Z'; //does not happen!
|
|
}
|
|
|
|
/** returns the int value for the file denoted in the char parameter **/
|
|
public static int fileToNumber(char file)
|
|
{
|
|
switch(Character.toLowerCase(file))
|
|
{
|
|
case ChessToolKit.A:return 0;
|
|
case ChessToolKit.B:return 1;
|
|
case ChessToolKit.C:return 2;
|
|
case ChessToolKit.D:return 3;
|
|
case ChessToolKit.E:return 4;
|
|
case ChessToolKit.F:return 5;
|
|
case ChessToolKit.G:return 6;
|
|
case ChessToolKit.H:return 7;
|
|
}
|
|
return -1; //should not happen
|
|
}
|
|
|
|
/** converts the key string to the notation of the key string in the list expression of a chessgame. This is neccessary
|
|
* since the "getKey"-operation of a chessgame in secondo is case sensitive. In the Viewer all keys are lowercased but for queries we need a
|
|
* uppercased first letter at the moment. So this method converts "white" to "White"*/
|
|
public static String convertKeyStringToListFormat(String key)
|
|
{
|
|
StringBuffer newKey = new StringBuffer();
|
|
char[] chars = key.toCharArray();
|
|
chars[0] = Character.toUpperCase(chars[0]);
|
|
return new String(chars);
|
|
}
|
|
}
|