/**
* Do the Jump, removing the piece from x1, y1 and setting the piece in x2, y2. Remove the piece
* from captureX, captureY as well. If the piece is now on their "King's Row", then promote the
* piece should be promoted to a King
*/
public void execute(final Jump jump) {
// CHECK IF ALL OF THEM ON BOARD
if (isOnBoard(jump.getX1(), jump.getX2())
&& isOnBoard(jump.getY1(), jump.getY2())
&& isOnBoard(jump.getCaptureX(), jump.getCaptureY())) {
// check if landing square is empty
if (isEmptySquare(jump.getY1(), jump.getY2())) {
Piece piece = getPiece(jump.getY1(), jump.getX1());
// check if capture piece is enemy color
if (getPiece(jump.getCaptureY(), jump.getCaptureX()).isEnemyColor(piece.getColor())) {
if (Piece.WHITE_MAN.equals(piece)) {
if (jump.getY2() == 7) {
piece = Piece.WHITE_KING;
}
} else if (Piece.RED_MAN.equals(piece)) {
if (jump.getY2() == 0) {
piece = Piece.RED_KING;
}
}
setPiece(jump.getY2(), jump.getX2(), piece);
removePiece(jump.getCaptureY(), jump.getCaptureX());
removePiece(jump.getY1(), jump.getX1());
}
}
}
}
public MITrisBoard addPiece(Piece piece, int rot, int x, int y) {
if (piece == null) return this;
MITrisBoard ret = new MITrisBoard(this);
rot %= piece.getMaxRotation();
for (int i = 0; i < piece.getNumComponents(); i++) {
int px = x, py = y;
switch (rot) {
case 0:
px += piece.getX(i);
py += piece.getY(i);
break;
case 1:
px += piece.getY(i);
py -= piece.getX(i);
break;
case 2:
px -= piece.getX(i);
py -= piece.getY(i);
break;
case 3:
px -= piece.getY(i);
py += piece.getX(i);
break;
default:
throw new RuntimeException("invalid rotation");
}
if (py < 0 || px < 0 || px >= width) // out of bounds
return null;
else if (py < height && ret.data[px][py] != null) // overlap
return null;
else if (py < height) ret.data[px][py] = piece;
}
return ret;
}
public List<ListQuadRowItem> generateDisplayList() {
List<Plan> lplans = Plan.getAllPlans();
Collections.sort(
lplans,
new Comparator<Plan>() {
public int compare(Plan s1, Plan s2) {
return (s1.getPriority() - s2.getPriority());
}
});
updateTotals(lplans);
ArrayList<ListQuadRowItem> result = new ArrayList<ListQuadRowItem>();
for (Plan plan : lplans) {
Piece piece = new Piece(plan.getPieceId());
Composer composer = new Composer(piece.getComposerId());
ListQuadRowItem item = new ListQuadRowItem();
item.setReference(plan.getMyid());
item.setTopLeft(plan.getPriority() + "." + piece.getName());
item.setBottomLeft(composer.getName());
item.setTopRight(plan.getDays());
item.setBottomRight(MyTime.minutesToString(plan.getMinutes()));
result.add(item);
}
ListQuadRowItem item = new ListQuadRowItem();
item.setReference(-1);
result.add(item);
return result;
}
public ArrayList<Move> generatePossibleMoves() {
ArrayList<Move> ans = new ArrayList<>();
for (Piece pc : pieces) {
if (pc.isFinalized()) continue;
for (int x = 0; x < 20; x++) {
for (int y = 0; y < 20; y++) {
Point place = new Point(x, y);
Piece p = pc.getCopy();
p.place(x, y);
for (int i = 0; i < p.data.rotations; i++) {
if (game.getBoard().canPlace(p)) {
ans.add(new Move(p, place, this));
}
p.rotateCW();
}
p.resetRotation();
if (p.data.flip) {
p.flipHorizontal();
for (int i = 0; i < p.data.rotations; i++) {
if (game.getBoard().canPlace(p)) {
ans.add(new Move(p, place, this));
}
p.rotateCW();
}
p.resetRotation();
}
}
}
}
possibleMoves = ans;
return ans;
}
/**
* Realise le roque (deplace les pieces)
*
* @param myCoup (le coup joue)
*/
public void realiserRoque(Coup myCoup) {
Piece roi = null;
Piece tour = null;
if (myCoup.estPetitRoque) {
if (myCoup.getCouleur().getColor() == 1) // blanc
{
roi = this.getPiecePosition(4, 0);
tour = this.getPiecePosition(7, 0);
roi.setPos(6, 0);
tour.setPos(5, 0);
} else {
roi = this.getPiecePosition(4, 7);
tour = this.getPiecePosition(7, 7);
roi.setPos(6, 7);
tour.setPos(5, 7);
}
} else {
if (myCoup.getCouleur().getColor() == 1) // blanc
{
roi = this.getPiecePosition(4, 0);
tour = this.getPiecePosition(0, 0);
roi.setPos(2, 0);
tour.setPos(3, 0);
} else {
roi = this.getPiecePosition(4, 7);
tour = this.getPiecePosition(0, 7);
roi.setPos(2, 7);
tour.setPos(3, 7);
}
}
}
public int score() {
int score = 0;
for (Piece p : pieces) {
if (p.isFinalized()) score += p.data.basePoints.size();
}
return score;
}
private List<Square> validMovesForPawn(Square square) {
List<Square> validMoves = new ArrayList<Square>();
// Regular moves, 1 or 2 up or down depending on color
Piece piece = square.getPiece();
if (piece.isWhite()) {
int movesUp = piece.movesUp();
if (square.containsPawnOnStartingRow()) movesUp += 1;
validMoves.addAll(validMovesForSquareInDirection(square, movesUp, 1, 0, 0, 0));
} else {
int movesDown = piece.movesDown();
if (square.containsPawnOnStartingRow()) movesDown += 1;
validMoves.addAll(validMovesForSquareInDirection(square, movesDown, 0, 0, 1, 0));
}
// Attacking move
int rowColPairs[][] = {{-1, -1}, {-1, 1}};
for (int i = 0; i < rowColPairs.length; i++) {
int row = square.Row + rowColPairs[i][0];
int col = square.Col + rowColPairs[i][1];
if (rowAndColAreWithinBounds(row, col)) {
Square s = Board[row][col];
if (s.isOccupiedByPieceOfColor(square.getPiece().oppositeColor())) validMoves.add(s);
}
}
return validMoves;
}
private static void showTheCasesForTheFirstTimeAuxi(
Position current, Piece p) { // les cases où la piece a le droit de se deplacer
if (p.getType().equals("Pion") && p.getCouleur().equals("noir")) {
System.out.println(current.getColonne());
System.out.println(current.getLigne());
Position a1 = createFinishPosition(current.getColonne(), current.getLigne() - 1);
Position a2 = createFinishPosition(current.getColonne(), current.getLigne() - 2);
if (getCasesToModify()[a1.getLigne()][a1.getColonne()].contains("img")) {
System.out.println("Case Inocuuppe");
modifyContent(current, a1);
}
if (getCasesToModify()[a2.getLigne()][a2.getColonne()].contains("img")) {
System.out.println("Case Inocuuppe");
modifyContent(current, a2);
}
}
if (p.getType().equals("Pion") && p.getCouleur().equals("blanc")) {
Position a1 = createFinishPosition(current.getColonne(), current.getLigne() + 1);
Position a2 = createFinishPosition(current.getColonne(), current.getLigne() + 2);
if (getCasesToModify()[a1.getLigne()][a1.getColonne()].contains("img")) {
System.out.println("Case Inocuuppe");
modifyContent(current, a1);
}
if (getCasesToModify()[a2.getLigne()][a2.getColonne()].contains("img")) {
System.out.println("Case Inocuuppe");
modifyContent(current, a2);
}
}
}
/**
* This specifically gets the jumps, and recursive jumps.
*
* @param move is the piece to move
* @return the final jump states
* @throws Exception
*/
private ArrayList<Board> childrenHelper(Board b, Piece move) {
ArrayList<Board> result = new ArrayList<Board>();
ArrayList<Piece> move_list = b.validJumps(move);
for (Piece move_to : move_list) {
Board temp = new Board(b);
boolean remain;
try {
remain = temp.makeMove(move, move_to);
if (remain == true) {
ArrayList<Board> future_list =
childrenHelper(
temp, temp.getPiece(move_to.getPosition()[0], move_to.getPosition()[1]));
for (Board future : future_list) {
result.add(future);
}
if (future_list.size() == 0) result.add(temp);
} else {
result.add(temp);
}
} catch (Exception e) {
System.out.println("Error: " + e.getMessage());
}
}
return result;
}
@Override
protected void onDraw(Canvas canvas) {
super.onDraw(canvas);
if (this.service == null) {
return;
}
Piece[][] pieces = service.getPieces();
if (pieces != null) {
for (int i = 0; i < pieces.length; i++) {
for (int j = 0; j < pieces[i].length; j++) {
if (pieces[i][j] != null) {
Piece piece = pieces[i][j];
canvas.drawBitmap(
piece.getImage().getImage(), piece.getBeginX(), piece.getBeginY(), null);
}
}
}
}
if (this.linkInfo != null) {
drawLine(this.linkInfo, canvas);
this.linkInfo = null;
}
// 画选中标识的图片
if (this.selectImage != null) {
canvas.drawBitmap(
this.selectPic, this.selectImage.getBeginX(), this.selectImage.getBeginY(), null);
}
}
/** Determines whether the king can be captured by the player with the move. */
public boolean isKingLeftInCheck() {
MoveLogic attacksKingLogic = new MoveAttacksKingLogic();
HashSet<Move> attackingMoves;
PieceColor colorToMove = this.getColorToMove();
int kx = -1; // If search succeeds, these should be set to "real" values
int ky = -1;
squareloop:
for (int j = 0; j < Chess.BOARD_SIZE; j++) {
for (int i = 0; i < Chess.BOARD_SIZE; i++) {
Piece pieceHere = this.getPieceAt(new Square(i, j));
if (pieceHere.getType() == PieceType.KING && pieceHere.getColor() == colorToMove.invert()) {
kx = i;
ky = j;
break squareloop;
}
}
}
assert ((kx != -1) || (ky != -1))
: "Unexpected search failure, inconsistent state. King not found.";
Square kingSquare = new Square(kx, ky);
attackingMoves = possibleMovesWhichEndAt(kingSquare);
for (Move move : attackingMoves) {
if (attacksKingLogic.isLegal(this, move)) {
return true;
}
}
return false;
}
/**
* method that will be called when mouse releases
* @param point , the point mouse release at
*/
public void onMouseRelease(Location point) {
isGrabbed = false;
if(!success){
for(Piece p: bp){
//if correctly matched
if(p.contains(grabbedPiece.getCenter()) &&
p.equals(grabbedPiece)){
grabbedPiece.hide();
p.show();
p.showHighlight(Color.GREEN);
lockedBP[p.getId()] = true;
//check if all pieces are matched
boolean check = true;
for(boolean b: lockedBP){
check = check && b;
}
if(check){
success = true;
for(Piece piece: bp){
piece.hideHighlight();
}
text.show();
}
}
}
}
}
private void rotate() {
final Coordinate c = randomNormal();
final Piece piece = pieces[c.getY()][c.getX()];
if (piece.getType() == PieceType.NORMAL) {
piece.rotate((int) GaUtil.random(1, 3));
}
}
@Test
public void testKing() {
Board b = new Board(true);
Piece water = new Piece(false, b, 2, 2, "bomb");
Piece fire = new Piece(true, b, 1, 1, "pawn");
Piece fire2 = new Piece(true, b, 2, 6, "shield");
b.place(water, 2, 2);
b.place(fire, 1, 1);
b.place(fire2, 2, 6);
assertEquals(false, water.isKing());
assertEquals(false, fire2.isKing());
assertEquals(fire, b.pieceAt(1, 1));
fire2.move(3, 7);
assertEquals(true, fire2.isKing());
assertEquals(true, fire2.isFire());
assertEquals(fire2, b.pieceAt(3, 7));
water.move(0, 0);
assertEquals(true, water.isKing());
assertEquals(true, fire2.isKing());
assertEquals(null, b.pieceAt(1, 1));
assertEquals(null, b.pieceAt(0, 0));
b.select(3, 7);
assertEquals(true, b.canSelect(4, 6)); // fire can now move down
assertEquals(false, b.canSelect(4, 8)); // out of bounds
}
@Test
public void testBombandShield() {
Board b = new Board(true);
Piece fire = new Piece(true, b, 5, 5, "bomb");
Piece water = new Piece(false, b, 4, 6, "shield");
Piece water2 = new Piece(false, b, 2, 6, "pawn");
b.place(fire, 5, 5);
b.place(water, 4, 6);
b.place(water2, 2, 6);
fire.move(3, 7);
assertEquals(null, b.pieceAt(4, 7));
assertEquals(null, b.pieceAt(3, 6));
assertEquals(null, b.pieceAt(5, 6));
fire = new Piece(true, b, 4, 4, "bomb");
water = new Piece(false, b, 3, 5, "shield");
water2 = new Piece(false, b, 3, 7, "pawn");
Piece water3 = new Piece(false, b, 1, 7, "pawn");
Piece water4 = new Piece(false, b, 1, 5, "bomb");
b.place(fire, 4, 4);
b.place(water, 3, 5);
b.place(water2, 3, 7);
b.place(water3, 1, 7);
b.place(water4, 1, 5);
fire.move(2, 6);
assertEquals(null, b.pieceAt(3, 5));
assertEquals(null, b.pieceAt(3, 7));
assertEquals(null, b.pieceAt(1, 7));
assertEquals(null, b.pieceAt(1, 5));
}
/**
* Rates a board by the position advantage
*
* @param b
* @param color
* @return
*/
private int h2(Board b, char color) {
int kingVal = 2;
int result = 0;
int[][] posVals = {
{2, 1, 1, 1, 1, 1, 1, 2},
{2, 1, 1, 1, 1, 1, 1, 2},
{2, 1, 1, 1, 1, 1, 1, 2},
{2, 1, 1, 1, 1, 1, 1, 2},
{2, 1, 1, 1, 1, 1, 1, 2},
{2, 1, 1, 1, 1, 1, 1, 2},
{2, 1, 1, 1, 1, 1, 1, 2},
{2, 1, 1, 1, 1, 1, 1, 2}
};
for (int i = 0; i < 8; i++) {
for (int j = 0; j < 8; j++) {
Piece p = b.getPiece(i, j);
int pVal = 0;
if (p.getColor() == color) pVal = posVals[i][j];
else if (p.getColor() != '-') pVal = -posVals[i][j];
if (p.isKing()) pVal = pVal * kingVal;
result += pVal;
}
}
return result;
}
/**
* Retourne la piece positionné a telle coordonnée x & y
*
* @param x
* @param y
* @return la piece a la position donnee , null si la position est vide
*/
public Piece getPiecePosition(int x, int y) {
for (Piece onePiece : this.pieceList) {
if (onePiece.getPos().equals(getPosition(x, y))) {
return onePiece;
}
}
return null;
}
/**
* returns the first piece at the specified location that is not marked as 'captured'.
*
* @param row one of Piece.ROW_..
* @param column one of Piece.COLUMN_..
* @return the first not captured piece at the specified location
*/
public Piece getNonCapturedPieceAtLocation(int row, int column) {
for (Piece piece : this.pieces) {
if (piece.getRow() == row && piece.getColumn() == column && piece.isCaptured() == false) {
return piece;
}
}
return null;
}
public void drawPieces(Graphics g) {
g.setColor(Color.red);
for (int i = 0; i < 8; i++)
for (int j = 0; j < 8; j++) {
Piece piece = chessBoard.getPiece(i, j);
if (piece != null) g.drawString(piece.toString(), i * 50, j * 50 + 10);
}
}
// possibly null result
public Piece getPiece(Cell c) {
for (Piece p : pieces) {
if (p.getLoc() != null && p.getLoc().equals(c)) {
return p;
}
}
return null;
}
public Piece getLostPiece(Class pieceClass) {
for (Piece piece : lostPieces) {
if (piece.matches(pieceClass)) {
return piece;
}
}
return null;
}
@Override
public final boolean equals(Object other) {
if (!(other instanceof Piece)) {
return false;
}
Piece p = (Piece) other;
return p.getKey() == this.key;
}
/**
* @param pos
* @return la piece a la position donnee , null si la position est vide
*/
public Piece getPiecePosition(Position pos) {
for (Piece onePiece : this.pieceList) {
if (onePiece.getPos().equals(pos)) {
return onePiece;
}
}
return null;
}
/** Test of isWhite method, of class Piece. */
@Test
public void testIsWhite() {
System.out.println("isWhite");
assertEquals(false, Piece.isWhite(Piece.BBISHOP));
assertEquals(true, Piece.isWhite(Piece.WBISHOP));
assertEquals(true, Piece.isWhite(Piece.WKING));
assertEquals(false, Piece.isWhite(Piece.BKING));
}
/** Set player PLAYER ("white" or "black") to be an automated player. */
private void autoCommand(String player) {
try {
Piece s = Piece.playerValueOf(player);
_playing = false;
_players[s.ordinal()] = new MachinePlayer(s, this);
} catch (IllegalArgumentException excp) {
error("unknown player: %s", player);
}
}
public ArrayList<Piece> getPiecesOfType(PieceTypes.Color color) {
ArrayList<Piece> ret = new ArrayList<Piece>();
for (Piece p : pieces) {
if (p.getColor() == color) {
ret.add(p);
}
}
return ret;
}
public synchronized void add_block(int pieceIndex, int offset, int size, byte[] b) {
Piece p = this.pieces.get(pieceIndex);
p.writeBlock(b, offset);
if (p.haveAllBlocks() == 1) {
this.finished_pieces[pieceIndex] = true;
// System.out.println("verified");
}
return;
}
public void Down() {
if (current.canMove(grid, 0)) {
grid = current.down(grid);
} else {
System.out.println("cannot move");
current = new TPiece();
}
repaint();
}
public PlayerMoves getValidMovesOn(Board board) {
PlayerMoves playerMoves = new PlayerMoves();
for (Piece piece : currentPieces) {
PieceMoves pieceMoves = piece.getValidMovesOn(board);
// if (!pieceMoves.isEmpty())
playerMoves.add(piece, pieceMoves);
}
return playerMoves;
}
/**
* Return information about given square.
*
* @param loc Square location as a SAN string.
* @return The type of the piece or null.
*/
public Type typeAt(String loc) {
try {
Piece piece = board.pieceAt(new Coord(loc));
return (piece == null) ? null : piece.getType();
} catch (Exception pass) {
}
return null;
}
