846 lines
26 KiB
Java
846 lines
26 KiB
Java
package backend;
|
|
|
|
import java.util.ArrayList;
|
|
import java.lang.Math;
|
|
|
|
public class Board {
|
|
private int colNum;
|
|
private int lineNum;
|
|
private ArrayList<Piece> pieces;
|
|
// coordinates of the square used
|
|
private int x;
|
|
private int y;
|
|
private int turnNumber;
|
|
|
|
private boolean lastTurnPawnTwo;//for en passant
|
|
private int xTwo;
|
|
private int yTwo;
|
|
private boolean enPassant;
|
|
private boolean kingWMoved;
|
|
private boolean kingBMoved;
|
|
private boolean rookLWMoved;
|
|
private boolean rookRWMoved;
|
|
private boolean rookLBMoved;
|
|
private boolean rookRBMoved;
|
|
private boolean castling;
|
|
private boolean castlingDone;
|
|
private ArrayList<String> previousBoard;
|
|
private ArrayList<Piece> altPieces;
|
|
|
|
private boolean isChecked;
|
|
|
|
public Board(int colNum, int lineNum) {
|
|
this.kingWMoved = false;
|
|
this.kingBMoved = false;
|
|
this.rookLWMoved = false;
|
|
this.rookRWMoved = false;
|
|
this.rookLBMoved = false;
|
|
this.rookRBMoved = false;
|
|
this.castling = false;
|
|
this.castlingDone = false;
|
|
this.colNum = colNum;
|
|
this.lineNum = lineNum;
|
|
pieces = new ArrayList<>();
|
|
x = -1;
|
|
y = -1;
|
|
turnNumber= 0;
|
|
enPassant = false;
|
|
lastTurnPawnTwo = false;
|
|
previousBoard = new ArrayList<>();
|
|
}
|
|
//test
|
|
public int getWidth() {
|
|
return colNum; //The width is represented by the columns
|
|
}
|
|
|
|
public int getHeight() {
|
|
return lineNum;//The height is represented by the lines
|
|
}
|
|
|
|
public int getTurnNumber() {
|
|
return turnNumber;//returns the turn number
|
|
}
|
|
|
|
public boolean isTurnWhite() { //check if it is the white player's turn
|
|
boolean turnWhite = false;
|
|
if (this.turnNumber % 2 == 0) {
|
|
turnWhite = true;
|
|
}
|
|
return turnWhite;
|
|
}
|
|
|
|
public void setPiece(boolean isWhite, PieceType type, int x, int y) {
|
|
Piece newPiece = new Piece(isWhite,type,x,y);
|
|
pieces.add(newPiece);
|
|
}
|
|
|
|
public void populateBoard() {
|
|
ArrayList<Piece> basePieces = new ArrayList<>();
|
|
for(int i = 0; i<colNum; i++) {
|
|
Piece blackPawn = new Piece(false,PieceType.Pawn,i,1);
|
|
basePieces.add(blackPawn);
|
|
Piece pawn = new Piece(true,PieceType.Pawn,i,lineNum-2);
|
|
basePieces.add(pawn);
|
|
if((i==0) || (i==colNum-1)){
|
|
Piece blackRook = new Piece(false,PieceType.Rook,i,0);
|
|
basePieces.add(blackRook);
|
|
Piece rook = new Piece(true,PieceType.Rook,i,lineNum-1);
|
|
basePieces.add(rook);
|
|
}
|
|
if((i==1) || (i==colNum-2)){
|
|
Piece blackKnight = new Piece(false,PieceType.Knight,i,0);
|
|
basePieces.add(blackKnight);
|
|
Piece knight = new Piece(true,PieceType.Knight,i,lineNum-1);
|
|
basePieces.add(knight);
|
|
}
|
|
if((i==2) || (i==colNum-3)){
|
|
Piece blackBishop = new Piece(false,PieceType.Bishop,i,0);
|
|
basePieces.add(blackBishop);
|
|
Piece bishop = new Piece(true,PieceType.Bishop,i,lineNum-1);
|
|
basePieces.add(bishop);
|
|
}
|
|
if (i==3){
|
|
Piece blackQueen = new Piece(false,PieceType.Queen,i,0);
|
|
basePieces.add(blackQueen);
|
|
Piece queen = new Piece(true,PieceType.Queen,i,lineNum-1);
|
|
basePieces.add(queen);
|
|
}
|
|
if(i==4){
|
|
Piece blackKing = new Piece(false,PieceType.King,i,0);
|
|
basePieces.add(blackKing);
|
|
Piece king = new Piece(true,PieceType.King,i,lineNum-1);
|
|
basePieces.add(king);
|
|
}
|
|
}
|
|
pieces = basePieces;
|
|
previousBoard.add(this.toString());
|
|
}
|
|
|
|
public void cleanBoard() {
|
|
turnNumber = 0;
|
|
pieces.clear();
|
|
enPassant = false;
|
|
kingWMoved = false;
|
|
kingBMoved = false;
|
|
rookLWMoved = false;
|
|
rookRWMoved = false;
|
|
rookLBMoved = false;
|
|
rookRBMoved = false;
|
|
castling = false;
|
|
castlingDone = false;
|
|
}
|
|
|
|
public String toString() {
|
|
String outputString = "";
|
|
for(int i=0; i<8; i++ ) {
|
|
for(int j=0; j<8; j++) {
|
|
if (this.positionOccupied(j,i)==true){
|
|
outputString += this.pieces.get(this.whatPiece(j, i)).getSummaryColor() + this.pieces.get(this.whatPiece(j, i)).getType().getSummary() +",";
|
|
}
|
|
else {
|
|
outputString += " ,";
|
|
}
|
|
|
|
}
|
|
outputString += "\n";
|
|
}
|
|
outputString+= turnNumber;
|
|
outputString+= "\n";
|
|
if (this.lastTurnPawnTwo == false) {
|
|
outputString+= "0";
|
|
}
|
|
else {
|
|
outputString+= "1";
|
|
}
|
|
outputString += xTwo;
|
|
outputString += yTwo;
|
|
if (this.enPassant == false) {
|
|
outputString+="0";
|
|
}
|
|
else {
|
|
outputString+= "1";
|
|
}
|
|
outputString += "\n";
|
|
return outputString;
|
|
}
|
|
|
|
public boolean positionOccupied(int x, int y) { // method which verifies if there is a piece at a given location
|
|
int sizePieces = pieces.size();
|
|
boolean positionOccupied = false;
|
|
for(int j = 0;j < sizePieces; j++) {
|
|
if ((x == pieces.get(j).getX()) && (y == pieces.get(j).getY())){
|
|
positionOccupied = true;
|
|
}
|
|
}
|
|
return positionOccupied;
|
|
}
|
|
|
|
public int whatPiece(int x, int y) { // method which gives the index (in the pieces array) of the piece at a position x,y
|
|
boolean pieceHere = false;
|
|
int index = 0;
|
|
while (pieceHere == false && index != pieces.size()) {
|
|
if((x == pieces.get(index).getX()) && (y == pieces.get(index).getY())){
|
|
pieceHere =true;
|
|
}
|
|
else {
|
|
index += 1;
|
|
}
|
|
}
|
|
if(index == pieces.size()) {
|
|
index=-1;
|
|
}
|
|
return index;
|
|
}
|
|
|
|
public ArrayList<Piece> getPieces() {
|
|
return pieces;
|
|
}
|
|
|
|
public void userTouch(int x, int y) {
|
|
boolean positionOccupied = this.positionOccupied(x, y) ; // verify if the square is occupied
|
|
//
|
|
if ((this.x == -1 ) && (positionOccupied == true)){ // set coordinates of the piece to play
|
|
this.x = x;
|
|
this.y = y;
|
|
}
|
|
else {
|
|
if((this.x == x) && (this.y == y)) { // reset since square is already selected
|
|
this.x = -1;
|
|
this.y = -1;
|
|
}
|
|
else { // we know we already have a piece so we move it to another position
|
|
boolean highlights = isHighlighted(x,y);
|
|
if( this.positionOccupied(x, y) == true && highlights) {
|
|
if (pieces.get(whatPiece(x,y)).isWhite() != pieces.get(whatPiece(this.x,this.y)).isWhite()) {//check if we do not move to a position occupied by a piece of the same color
|
|
this.pieces.remove(whatPiece(x,y)); //if there is a piece at the position we want to move we remove it from the array list
|
|
}
|
|
else {//castling
|
|
if (castling == true) {
|
|
if (pieces.get(whatPiece(x,y)).getX()==7 || pieces.get(whatPiece(this.x,this.y)).getX()==7) {//that means we are dealing with the right rooks for castling
|
|
if (pieces.get(whatPiece(this.x,this.y)).isWhite()==true){
|
|
kingWMoved = true;
|
|
}
|
|
else {
|
|
kingBMoved = true;
|
|
}
|
|
pieces.get(whatPiece(7,y)).setX(5);
|
|
pieces.get(whatPiece(4,y)).setX(6);
|
|
this.x=-1;
|
|
this.y=-1;
|
|
this.turnNumber +=1;
|
|
castlingDone=true;
|
|
}//TEST
|
|
|
|
else {//that means we are dealing with the right rooks for castling
|
|
if (pieces.get(whatPiece(x,y)).isWhite()==true){
|
|
kingWMoved = true;
|
|
}
|
|
else {
|
|
kingBMoved = true;
|
|
}
|
|
pieces.get(whatPiece(0,y)).setX(3);
|
|
pieces.get(whatPiece(4,y)).setX(2);
|
|
this.x=-1;
|
|
this.y=-1;
|
|
this.turnNumber +=1;
|
|
castlingDone=true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if(((this.positionOccupied(x, y) == false || pieces.get(whatPiece(x,y)).isWhite() != pieces.get(whatPiece(this.x,this.y)).isWhite())) && (highlights) && castlingDone==false) {//moves the piece only if the position selected is not occupied by a piece of the same color
|
|
if (enPassant) {
|
|
this.pieces.remove(whatPiece(xTwo,yTwo));
|
|
enPassant = false;
|
|
}
|
|
if (pieces.get(whatPiece(this.x, this.y)).getX() == 0 && pieces.get(whatPiece(this.x, this.y)).getY() == 7) {
|
|
rookLWMoved = true;
|
|
}
|
|
if (pieces.get(whatPiece(this.x, this.y)).getX() == 7 && pieces.get(whatPiece(this.x, this.y)).getY() == 7) {
|
|
rookRWMoved = true;
|
|
}
|
|
if (pieces.get(whatPiece(this.x, this.y)).getX() == 0 && pieces.get(whatPiece(this.x, this.y)).getY() == 0) {
|
|
rookLBMoved = true;
|
|
}
|
|
if (pieces.get(whatPiece(this.x, this.y)).getX() == 7 && pieces.get(whatPiece(this.x, this.y)).getY() == 0) {
|
|
rookRBMoved = true;
|
|
}
|
|
if (pieces.get(whatPiece(this.x, this.y)).getX() == 4 && pieces.get(whatPiece(this.x, this.y)).getY() == 7) {
|
|
kingWMoved = true;
|
|
}
|
|
if (pieces.get(whatPiece(this.x, this.y)).getX() == 4 && pieces.get(whatPiece(this.x, this.y)).getY() == 0) {
|
|
kingBMoved = true;
|
|
}
|
|
|
|
int indexPiece = this.whatPiece(this.x, this.y);
|
|
|
|
if (pieces.get(indexPiece).getType() == PieceType.Pawn && Math.abs(this.y-y)==2) {//save the number of the turn at which a pawn moved by two
|
|
lastTurnPawnTwo = true;
|
|
xTwo = x;
|
|
yTwo = y;
|
|
}
|
|
else {
|
|
lastTurnPawnTwo = false;
|
|
}
|
|
|
|
pieces.get(indexPiece).setX(x);
|
|
pieces.get(indexPiece).setY(y);
|
|
|
|
this.turnNumber +=1;
|
|
}
|
|
|
|
// we now reset our parameters
|
|
this.x=-1;
|
|
this.y=-1;
|
|
castlingDone=false;
|
|
previousBoard.add(this.toString());
|
|
// we add 1 to the number of turned played
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
public boolean isSelected(int x, int y) {
|
|
boolean selection = false;
|
|
if ((this.x == x) && (this.y == y)){
|
|
selection = true;
|
|
}
|
|
return selection;
|
|
}
|
|
|
|
/* saving-loading feature :*/
|
|
|
|
public String[] toFileRep() {
|
|
String[] saveFile = new String[10]; // creation of the string array which will be the one returned
|
|
String actualBoard = this.toString();
|
|
int nbLine = 0;
|
|
saveFile[0] = "";
|
|
for(int i = 0; i<200 ;i++) { // there are in total 200 strings in the
|
|
if (actualBoard.charAt(i) == '\n') {
|
|
nbLine+=1;
|
|
saveFile[nbLine]= "";
|
|
}
|
|
else {
|
|
saveFile[nbLine] += actualBoard.charAt(i);
|
|
}
|
|
}
|
|
saveFile[8]="";
|
|
saveFile[8] += this.turnNumber;
|
|
saveFile[9]="";
|
|
if (this.lastTurnPawnTwo == false) {
|
|
saveFile[9]+= "0";
|
|
}
|
|
else {
|
|
saveFile[9]+= "1";
|
|
}
|
|
saveFile[9] += xTwo;
|
|
saveFile[9] += yTwo;
|
|
if (this.enPassant == false) {
|
|
saveFile[9]+="0";
|
|
}
|
|
else {
|
|
saveFile[9]+= "1";
|
|
}
|
|
return saveFile;
|
|
}
|
|
|
|
public Board(String[] array) {
|
|
this.colNum = 8;
|
|
this.lineNum = 8;
|
|
x = -1;
|
|
y = -1;
|
|
pieces = new ArrayList<>();
|
|
for(int i=0; i<8;i++) { // this will be the Y coordinate
|
|
for(int j=0; j<8;j++) { // this will be the X coordinate
|
|
if(array[i].charAt(j*3) != ' ') {
|
|
Piece newPiece = new Piece(true,PieceType.Pawn,0,0);
|
|
if(array[i].charAt(j*3)=='B') {
|
|
newPiece.setIsWhite(false);
|
|
}
|
|
else {
|
|
newPiece.setIsWhite(true);
|
|
}
|
|
newPiece.setType(PieceType.fromSummary(array[i].charAt((j*3)+1)));
|
|
newPiece.setX(j);
|
|
newPiece.setY(i);
|
|
pieces.add(newPiece);
|
|
}
|
|
}
|
|
}
|
|
turnNumber = Integer.parseInt(array[8]);
|
|
System.out.println(turnNumber);
|
|
int turn = this.getTurnNumber();
|
|
System.out.println(turn);
|
|
if(array[9].charAt(0)==0) {
|
|
lastTurnPawnTwo = false;
|
|
}
|
|
else {
|
|
lastTurnPawnTwo = true;
|
|
}
|
|
xTwo = Character.getNumericValue(array[9].charAt(1));
|
|
yTwo = Character.getNumericValue(array[9].charAt(2));
|
|
if(array[9].charAt(3)==0) {
|
|
enPassant = false;
|
|
}
|
|
else {
|
|
enPassant = true;
|
|
}
|
|
enPassant = false;
|
|
kingWMoved = false;
|
|
kingBMoved = false;
|
|
rookLWMoved = false;
|
|
rookRWMoved = false;
|
|
rookLBMoved = false;
|
|
rookRBMoved = false;
|
|
castling = false;
|
|
castlingDone = false;
|
|
}
|
|
|
|
/* The following methods require more work ! */
|
|
|
|
// COUCOU LES COPAINS SI VOUS ARRIVEZ A OPTIMISER LA SUITE CA SERAIT COOL
|
|
public ArrayList<ArrayList<Integer>> highlightBishop(){ //creates a table of the x and y coordinates to highlight for the bishop
|
|
boolean spotOccupied = false;
|
|
ArrayList<ArrayList<Integer>> toHighlight = new ArrayList<> ();
|
|
toHighlight.add(new ArrayList<>()); // ArrayList that will contain the x coordinates
|
|
toHighlight.add(new ArrayList<>()); // ArrayList that will contain the y coordinates
|
|
int i = 0;
|
|
while (spotOccupied == false) { //left top diagonal
|
|
if ((x-i-1 >= 0) && (y-i-1 >= 0)) { //check if we are still in the board
|
|
toHighlight.get(0).add(this.x-i-1);
|
|
toHighlight.get(1).add(this.y-i-1);
|
|
if (positionOccupied(this.x-i-1,this.y-i-1)) { //if we reach a position already occupied, stops highlighting the diagonal
|
|
spotOccupied = true;
|
|
}
|
|
}
|
|
else {
|
|
spotOccupied = true;
|
|
}
|
|
i += 1;
|
|
}
|
|
|
|
spotOccupied = false;
|
|
i = 0;
|
|
while (spotOccupied == false) { //left bottom diagonal
|
|
if ((x-i-1 >= 0) && (y+1+i <= 7)) {
|
|
toHighlight.get(0).add(this.x-i-1);
|
|
toHighlight.get(1).add(this.y+i+1);
|
|
if (positionOccupied(this.x-i-1,this.y+i+1)) {
|
|
spotOccupied = true;
|
|
}
|
|
}
|
|
else {
|
|
spotOccupied = true;
|
|
}
|
|
i += 1;
|
|
}
|
|
|
|
spotOccupied = false;
|
|
i = 0;
|
|
while (spotOccupied == false) { //right bottom diagonal
|
|
if ((x+1+i <= 7) && (y+1+i <= 7)) {
|
|
toHighlight.get(0).add(this.x+i+1);
|
|
toHighlight.get(1).add(this.y+i+1);
|
|
if (positionOccupied(this.x+i+1,this.y+i+1)) {
|
|
spotOccupied = true;
|
|
}
|
|
}
|
|
else {
|
|
spotOccupied = true;
|
|
}
|
|
i += 1;
|
|
}
|
|
|
|
spotOccupied = false;
|
|
i = 0;
|
|
while (spotOccupied == false) { //right top diagonal
|
|
if ((y-i-1 >= 0) && (x+1+i <= 7)) {
|
|
toHighlight.get(0).add(this.x+i+1);
|
|
toHighlight.get(1).add(this.y-i-1);
|
|
if (positionOccupied(this.x+i+1,this.y-i-1)) {
|
|
spotOccupied = true;
|
|
}
|
|
}
|
|
else {
|
|
spotOccupied = true;
|
|
}
|
|
i += 1;
|
|
}
|
|
return toHighlight;
|
|
}
|
|
|
|
public ArrayList<ArrayList<Integer>> highlightQueen(){ //list of positions to highlight for the queens
|
|
ArrayList<ArrayList<Integer>> toHighlight = highlightBishop();
|
|
ArrayList<ArrayList<Integer>> toHighlight2 = highlightRook();
|
|
toHighlight.get(0).addAll(toHighlight2.get(0)); //combine the x coordinates
|
|
toHighlight.get(1).addAll(toHighlight2.get(1)); //combine the y coordinates
|
|
return toHighlight;
|
|
}
|
|
|
|
public ArrayList<ArrayList<Integer>> highlightRook(){ //list of positions to highlight for the rooks
|
|
boolean spotOccupied = false;
|
|
ArrayList<ArrayList<Integer>> toHighlight = new ArrayList<> ();
|
|
toHighlight.add(new ArrayList<>());
|
|
toHighlight.add(new ArrayList<>());
|
|
int i = 0;
|
|
while (spotOccupied == false) { //horizontal top line
|
|
if (y-i-1 >= 0) { // check if we are still in the board (works the same as the bishop)
|
|
toHighlight.get(0).add(this.x);
|
|
toHighlight.get(1).add(this.y-i-1);
|
|
if (positionOccupied(this.x,this.y-i-1)) {
|
|
spotOccupied = true;
|
|
}
|
|
}
|
|
else {
|
|
spotOccupied = true;
|
|
}
|
|
i += 1;
|
|
}
|
|
|
|
spotOccupied = false;
|
|
i = 0;
|
|
while (spotOccupied == false) { //horizontal bottom line
|
|
if (y+i+1 <= 7) {
|
|
toHighlight.get(0).add(this.x);
|
|
toHighlight.get(1).add(this.y+i+1);
|
|
if (positionOccupied(this.x,this.y+i+1)) {
|
|
spotOccupied = true;
|
|
}
|
|
}
|
|
else {
|
|
spotOccupied = true;
|
|
}
|
|
i += 1;
|
|
}
|
|
|
|
spotOccupied = false;
|
|
i = 0;
|
|
while (spotOccupied == false) { //vertical left line
|
|
if (x-i-1 >= 0) {
|
|
toHighlight.get(0).add(this.x-i-1);
|
|
toHighlight.get(1).add(this.y);
|
|
if (positionOccupied(this.x-i-1,this.y)) {
|
|
spotOccupied = true;
|
|
}
|
|
}
|
|
else {
|
|
spotOccupied = true;
|
|
}
|
|
i += 1;
|
|
}
|
|
|
|
spotOccupied = false;
|
|
i = 0;
|
|
while (spotOccupied == false) { //vertical right line
|
|
if (x+i+1 <= 7) {
|
|
toHighlight.get(0).add(this.x+i+1);
|
|
toHighlight.get(1).add(this.y);
|
|
if (positionOccupied(this.x+i+1,this.y)) {
|
|
spotOccupied = true;
|
|
}
|
|
}
|
|
else {
|
|
spotOccupied = true;
|
|
}
|
|
i += 1;
|
|
}
|
|
return toHighlight;
|
|
}
|
|
|
|
|
|
public boolean isHighlighted(int x, int y) { //not at all optimized, if you have ideas go ahead
|
|
boolean highlight = false;
|
|
if (positionOccupied(this.x,this.y)) { //check if we have selected a position with a piece
|
|
int indexPieceSelect = whatPiece(this.x,this.y);
|
|
|
|
if (pieces.get(indexPieceSelect).getType() == PieceType.Pawn) {//highlight for pawns
|
|
|
|
if (pieces.get(indexPieceSelect).isWhite()) {//white pawns
|
|
|
|
if (lastTurnPawnTwo) {//en passant
|
|
if(yTwo == this.y && Math.abs(xTwo - this.x) == 1 && x == xTwo && y == this.y - 1) {
|
|
highlight = true;
|
|
enPassant = true;
|
|
}
|
|
}
|
|
|
|
if(y == this.y-1) {
|
|
if((x == this.x) && (positionOccupied(x,y)==false)) {//advance one case
|
|
highlight = true;
|
|
}
|
|
|
|
|
|
if((Math.abs(x-this.x) == 1) && (positionOccupied(x,y)) && pieces.get(whatPiece(x,y)).isWhite() != pieces.get(indexPieceSelect).isWhite()) {//highlight the piece in diagonal, if existing and of another color
|
|
highlight = true;
|
|
}
|
|
}
|
|
if((y == this.y-2) && (this.y == 6) && (x == this.x) && (positionOccupied(this.x,this.y-1))==false) {//move by two if not moved and if no piece in front
|
|
highlight = true;
|
|
}
|
|
}
|
|
|
|
if (pieces.get(indexPieceSelect).isWhite() == false) {//black pawns
|
|
if(y == this.y+1) {
|
|
|
|
if (lastTurnPawnTwo) {//en passant
|
|
if(yTwo == this.y && Math.abs(xTwo - this.x) == 1 && x == xTwo && y == this.y+1) {
|
|
highlight = true;
|
|
enPassant = true;
|
|
}
|
|
}
|
|
|
|
if((x == this.x) && (positionOccupied(x,y)==false)) {
|
|
highlight = true;
|
|
}
|
|
|
|
if((Math.abs(x-this.x) == 1) && (positionOccupied(x,y)) && pieces.get(whatPiece(x,y)).isWhite() != pieces.get(indexPieceSelect).isWhite()) {
|
|
highlight = true;
|
|
}
|
|
}
|
|
if((y == this.y+2) && (this.y == 1) && (x == this.x) && (positionOccupied(this.x,this.y+1) == false)) {
|
|
highlight = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (pieces.get(indexPieceSelect).getType() == PieceType.King) { //highlight for Kings THIS IS NOT OPTIMISED BC OF WHATPIECE (SAME FOR ALL FOLLOWING PIECES)
|
|
if(positionOccupied(x,y) == false) {
|
|
if((Math.abs(x-this.x) <= 1) && (Math.abs(y-this.y) <= 1)) { //consider all cases at distance one from the king
|
|
if ((Math.abs(x-this.x) != 0) || (Math.abs(y-this.y) != 0)) { //check if we are not considering the place where the king is
|
|
highlight = true;
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
if(pieces.get(whatPiece(x,y)).isWhite() != pieces.get(indexPieceSelect).isWhite()){
|
|
if((Math.abs(x-this.x) <= 1) && (Math.abs(y-this.y) <= 1)) { //consider all cases at distance one from the king
|
|
if ((Math.abs(x-this.x) != 0) || (Math.abs(y-this.y) != 0)) { //check if we are not considering the place where the king is
|
|
highlight = true;
|
|
}
|
|
}
|
|
}
|
|
//check if the castling is possible, if yes highlight the rook(s)
|
|
int nbOccupied = 0;
|
|
boolean occupiedLeftLine = true;
|
|
boolean occupiedRightLine = true;
|
|
|
|
for(int i = 3; i > 0; i--) {
|
|
if (positionOccupied(i,pieces.get(indexPieceSelect).getY()) == true) {
|
|
nbOccupied = nbOccupied + 1;
|
|
}
|
|
if (nbOccupied == 0) {
|
|
occupiedLeftLine=false;
|
|
}
|
|
}
|
|
if (occupiedLeftLine == false) {//check if the castling is possible with the rooks on the left
|
|
if (kingWMoved == false && rookLWMoved == false && x==0 && y==7 && pieces.get(whatPiece(0,7)).isWhite() == pieces.get(indexPieceSelect).isWhite()) {
|
|
highlight = true;
|
|
castling = true;
|
|
}
|
|
if (kingBMoved == false && rookLBMoved == false && x==0 && y==0 && pieces.get(whatPiece(0,0)).isWhite() == pieces.get(indexPieceSelect).isWhite()) {
|
|
highlight = true;
|
|
castling = true;
|
|
// }
|
|
//else {
|
|
//castling = false;
|
|
}
|
|
}
|
|
nbOccupied = 0;
|
|
for(int i = 5; i < 7; i++) {
|
|
if (positionOccupied(i,pieces.get(indexPieceSelect).getY()) == true) {
|
|
nbOccupied = nbOccupied + 1;
|
|
}
|
|
if (nbOccupied == 0) {
|
|
occupiedRightLine=false;
|
|
}
|
|
}
|
|
if (occupiedRightLine == false) {//check if the castling is possible with the rooks on the right
|
|
if (kingWMoved == false && rookRWMoved == false && x==7 && y==7 && pieces.get(whatPiece(7,7)).isWhite() == pieces.get(indexPieceSelect).isWhite()) {
|
|
highlight = true;
|
|
castling = true;
|
|
}
|
|
if (kingBMoved == false && rookRBMoved == false && x==7 && y==0 && pieces.get(whatPiece(7,0)).isWhite() == pieces.get(indexPieceSelect).isWhite()) {
|
|
highlight = true;
|
|
castling = true;
|
|
}
|
|
// else {
|
|
// castling = false;
|
|
//}
|
|
}
|
|
nbOccupied = 0;
|
|
}
|
|
|
|
/*altPieces = pieces; //create a copy of pieces that we will modify to check if the movement leaves the king in check
|
|
if (highlight) {
|
|
altPieces.get(whatPiece(this.x,this.y)).setX(x);
|
|
altPieces.get(whatPiece(this.x,this.y)).setY(y);
|
|
}*/
|
|
}
|
|
|
|
if (pieces.get(indexPieceSelect).getType() == PieceType.Knight) { //highlight for knights
|
|
if(positionOccupied(x,y) == false) {
|
|
if (((Math.abs(x-this.x) == 1) && (Math.abs(y-this.y) == 2)) || ((Math.abs(x-this.x) == 2) && (Math.abs(y-this.y) == 1))) {//consider all positions at 2 by 1 from the knight
|
|
highlight = true;
|
|
}
|
|
}
|
|
else {
|
|
if(pieces.get(whatPiece(x,y)).isWhite() != pieces.get(indexPieceSelect).isWhite()){
|
|
if (((Math.abs(x-this.x) == 1) && (Math.abs(y-this.y) == 2)) || ((Math.abs(x-this.x) == 2) && (Math.abs(y-this.y) == 1))) {//consider all positions at 2 by 1 from the knight
|
|
highlight = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (pieces.get(indexPieceSelect).getType() == PieceType.Bishop) { //highlight for bishops
|
|
int numHighlight = highlightBishop().get(0).size();
|
|
for(int i = 0; i < numHighlight; i++) {
|
|
if ((x == highlightBishop().get(0).get(i)) && (y == highlightBishop().get(1).get(i))) {//check if the considered x and y are in the list of positions that should be highlighted
|
|
if(positionOccupied(x,y) == false) {
|
|
highlight = true;
|
|
}
|
|
else {
|
|
if(pieces.get(whatPiece(x,y)).isWhite() != pieces.get(indexPieceSelect).isWhite()) {
|
|
highlight = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (pieces.get(indexPieceSelect).getType() == PieceType.Queen) { //highlight for Queens
|
|
int numHighlight = highlightQueen().get(0).size();
|
|
for(int i = 0; i < numHighlight; i++) {
|
|
if ((x == highlightQueen().get(0).get(i)) && (y == highlightQueen().get(1).get(i))) {//check if the considered x and y are in the list of positions that should be highlighted
|
|
if(positionOccupied(x,y) == false) {
|
|
highlight = true;
|
|
}
|
|
else {
|
|
if(pieces.get(whatPiece(x,y)).isWhite() != pieces.get(indexPieceSelect).isWhite()) {
|
|
highlight = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (pieces.get(indexPieceSelect).getType() == PieceType.Rook) { //highlight for rooks
|
|
int numHighlight = highlightRook().get(0).size();
|
|
for(int i = 0; i < numHighlight; i++) {
|
|
if ((x == highlightRook().get(0).get(i)) && (y == highlightRook().get(1).get(i))) {//check if the considered x and y are in the list of positions that should be highlighted
|
|
if(positionOccupied(x,y) == false) {
|
|
highlight = true;
|
|
}
|
|
else {
|
|
if(pieces.get(whatPiece(x,y)).isWhite() != pieces.get(indexPieceSelect).isWhite()) {
|
|
highlight = true;
|
|
}
|
|
//check if the castling is possible, if yes highlight the king
|
|
if (pieces.get(indexPieceSelect).isWhite() == true) {//check if castling is possible for the white
|
|
if (kingWMoved == false && rookLWMoved == false && x==4 && y==7 && pieces.get(indexPieceSelect).getX()==0 && pieces.get(indexPieceSelect).getY()==7) {
|
|
highlight = true;
|
|
castling = true;
|
|
}
|
|
if (kingWMoved == false && rookRWMoved == false && x==4 && y==7 && pieces.get(indexPieceSelect).getX()==7 && pieces.get(indexPieceSelect).getY()==7) {
|
|
highlight = true;
|
|
castling = true;
|
|
}
|
|
else {
|
|
castling = false;
|
|
}
|
|
}
|
|
if (pieces.get(indexPieceSelect).isWhite() == false) {//check if castling is possible for the black
|
|
if (kingBMoved == false && rookLBMoved == false && x==4 && y==0 && pieces.get(indexPieceSelect).getX()==0 && pieces.get(indexPieceSelect).getY()==0) {
|
|
highlight = true;
|
|
castling = true;
|
|
}
|
|
if (kingBMoved == false && rookRBMoved == false && x==4 && y==0 && pieces.get(indexPieceSelect).getX()==7 && pieces.get(indexPieceSelect).getY()==0) {
|
|
highlight = true;
|
|
castling = true;
|
|
}
|
|
else {
|
|
castling = false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return highlight;
|
|
}
|
|
|
|
public void undoLastMove() {
|
|
if(turnNumber == 0) {
|
|
String lastBoard = previousBoard.get(turnNumber); // we have a String but we need a String[] in order to use the constructer
|
|
String[] oldBoard = new String[10];
|
|
boolean complete = false;
|
|
int indexLine=0;
|
|
int indexColumn=0;
|
|
for(int i=0; i<10; i++) {
|
|
oldBoard[i] = "";
|
|
}
|
|
while (complete == false) {
|
|
if (lastBoard.charAt(indexColumn) == '\n') {
|
|
indexLine+=1;
|
|
if (indexLine == 10) {
|
|
complete= true;
|
|
}
|
|
}
|
|
else {
|
|
oldBoard[indexLine] += lastBoard.charAt(indexColumn);
|
|
}
|
|
indexColumn+=1;
|
|
}
|
|
Board undo = new Board(oldBoard);
|
|
this.pieces = undo.pieces;
|
|
this.xTwo=undo.xTwo;
|
|
this.yTwo=undo.yTwo;
|
|
this.enPassant=undo.enPassant;
|
|
this.lastTurnPawnTwo=undo.lastTurnPawnTwo;
|
|
}
|
|
if (turnNumber != 0 ) {
|
|
turnNumber -= 1;
|
|
String lastBoard = previousBoard.get(turnNumber); // we have a String but we need a String[] in order to use the constructer
|
|
String[] oldBoard = new String[10];
|
|
boolean complete = false;
|
|
int indexLine=0;
|
|
int indexColumn=0;
|
|
for(int i=0; i<10; i++) {
|
|
oldBoard[i] = "";
|
|
}
|
|
while (complete == false) {
|
|
if (lastBoard.charAt(indexColumn) == '\n') {
|
|
indexLine+=1;
|
|
if (indexLine == 10) {
|
|
complete= true;
|
|
}
|
|
}
|
|
else {
|
|
oldBoard[indexLine] += lastBoard.charAt(indexColumn);
|
|
}
|
|
indexColumn+=1;
|
|
}
|
|
Board undo = new Board(oldBoard);
|
|
this.pieces = undo.pieces;
|
|
this.xTwo=undo.xTwo;
|
|
this.yTwo=undo.yTwo;
|
|
this.enPassant=undo.enPassant;
|
|
this.lastTurnPawnTwo=undo.lastTurnPawnTwo;
|
|
previousBoard.remove(turnNumber+1);
|
|
}
|
|
|
|
}
|
|
|
|
public Board(Board board) {
|
|
//TODO
|
|
|
|
}
|
|
|
|
public void playMove(Move move) {
|
|
//TODO
|
|
|
|
}
|
|
|
|
}
|