国际象棋棋盘的ASCII码表示
我正在用Java编写一个国际象棋引擎，我想用ASCII字符打印棋盘（例如：＃代表空格，K代表国王，Q代表女王等）。 代表应区分黑色和白色的部分。
我正在寻找将输入一个列表（或地图或数组）的方法，并将输出一个字符串表示董事会。
我已经有一个Board对象，包含一个Pieces列表。 件是一个抽象类，有一个位置（x，y）和一个颜色（黑色或白色）。 然后，国王，女王，骑士是执行Piece类的课程。
谢谢
我想你用一个Object代表每个单独的棋盘位置。 因此，您可以使用映射器将您的对象布局（即电路板）转换为字符矩阵。
Map<Object, Character> mapper = new HashMap<Object, Character>();
mapper.put(new Queen(), 'Q');
...
在印刷电路板时，您应该简单地遍历电路板正方形，并从上面填充的映射器中打印出相应的字符。
我认为你可以使用抽象类（或接口）：
public abstract class ChessObject {
private ChessColor color;
public abstract String getCharRepresentation();
public ChessObject(ChessColor color){
this.color = color;
}
public ChessColor getColor() {
return color;
}
public void setColor(ChessColor color) {
this.color = color;
}
}
执行：
public class King extends ChessObject{
public King(ChessColor color){
super(color);
}
@Override
public String getCharRepresentation() {
return "K";
}
}
枚举：
public enum ChessColor {
WHITE, BLACK;
}
主要例子：
public static void main(String[] args) {
List<ChessObject> objects = new ArrayList<ChessObject>();
objects.add(new King());
for(ChessObject obj : objects){
System.out.println(obj.getCharRepresentation());
}
}
首先：如果你的意图是编写一个国际象棋引擎，那么你应该全面阅读国际象棋编程维基。
如果您仍想尝试一下，您应该意识到面向对象编程的通常最佳实践可能不一定适用于国际象棋编程。 面向对象的许多方面都针对国际象棋根本不存在的目标。 例如，可扩展性。 除了那些从一开始就存在的东西，你永远不会有其他的东西。 对于一个高效的国际象棋引擎，你可能根本不会以类的形式明确表示棋子。 而对于董事会，你不应该使用List<Piece> ，而应该使用一个特殊的数组（请参见董事会代表了解大量细节）。
然而，根据你目前的描述，除了通过instanceof检查来检查他们的类之外，似乎没有办法区分这些部分。 当然，这不是很好，但除非你用类似getType()方法的方法扩展Piece类（使整个继承无用），否则几乎没有其他选择。
我在下面勾画了这个方法。 该符号大致基于代数移动符号：字母
K = Knight
Q = Queen
B = Bishop
N = Knight
R = Rook
P = Pawn
通常用来表示件的类型。 为了区分黑色和白色作品，您可以简单地使用白色大写字母和黑色小写字母。
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class ChessBoardString
{
public static void main(String[] args)
{
Board board = new Board();
String s = createString(board);
System.out.println(s);
}
private static String createString(Board board)
{
char empty = '.';
char chars[] = new char[8*8+8];
Arrays.fill(chars, empty);
for (int y=0; y<8; y++)
{
chars[y*9+8] = 'n';
}
List<Piece> pieces = board.getPieces();
for (Piece piece : pieces)
{
int x = piece.getX();
int y = piece.getY();
char c = charFor(piece);
chars[x+y*9] = c;
}
String s = new String(chars);
return s;
}
private static char charFor(Piece p)
{
char c = ' ';
if (p instanceof King)
{
c = 'k';
}
else if (p instanceof Queen)
{
c = 'q';
}
else if (p instanceof Bishop)
{
c = 'b';
}
else if (p instanceof Knight)
{
c = 'n';
}
else if (p instanceof Rook)
{
c = 'r';
}
else if (p instanceof Pawn)
{
c = 'p';
}
if (p.getColor() == Color.WHITE)
{
c = Character.toUpperCase(c);
}
return c;
}
}
class Board
{
List<Piece> getPieces()
{
List<Piece> pieces = new ArrayList<Piece>();
pieces.add(new King(Color.WHITE,3,4));
pieces.add(new King(Color.BLACK,5,6));
pieces.add(new Queen(Color.WHITE,7,2));
pieces.add(new Queen(Color.BLACK,2,0));
pieces.add(new Bishop(Color.WHITE,1,2));
pieces.add(new Bishop(Color.BLACK,5,4));
pieces.add(new Knight(Color.WHITE,5,1));
pieces.add(new Knight(Color.BLACK,0,7));
pieces.add(new Rook(Color.WHITE,2,2));
pieces.add(new Rook(Color.BLACK,1,4));
pieces.add(new Pawn(Color.WHITE,6,1));
pieces.add(new Pawn(Color.BLACK,2,3));
return pieces;
}
}
enum Color
{
BLACK,
WHITE
}
abstract class Piece
{
private Color color;
private int x;
private int y;
Piece(Color color, int x, int y)
{
this.color = color;
this.x = x;
this.y = y;
}
Color getColor()
{
return color;
}
int getX()
{
return x;
}
int getY()
{
return y;
}
}
class King extends Piece
{
King(Color color, int x, int y)
{
super(color, x, y);
}
}
class Queen extends Piece
{
Queen(Color color, int x, int y)
{
super(color, x, y);
}
}
class Bishop extends Piece
{
Bishop(Color color, int x, int y)
{
super(color, x, y);
}
}
class Knight extends Piece
{
Knight(Color color, int x, int y)
{
super(color, x, y);
}
}
class Rook extends Piece
{
Rook(Color color, int x, int y)
{
super(color, x, y);
}
}
class Pawn extends Piece
{
Pawn(Color color, int x, int y)
{
super(color, x, y);
}
}
上一篇: ASCII representation of chess board
下一篇: (Chess game)Function that returns possible moves of pawn