Challenge+Project1+Project2

JavaGAD_ChessGame/src/GameBoard.java

@@ -0,0 +1,33 @@
+import java.awt.Color;
+import java.awt.Graphics;
+import javax.swing.JFrame;
+import javax.swing.JPanel;
+public class GameBoard extends JPanel {
+
+    public void paint(Graphics g) {
+
+        g.fillRect(100, 100, 400, 400);
+        for (int i = 100; i <= 400; i += 100) {
+            for (int j = 100; j <= 400; j += 100) {
+                g.clearRect(i, j, 50, 50);
+            }
+        }
+
+        for (int i = 150; i <= 450; i += 100) {
+            for (int j = 150; j <= 450; j += 100) {
+                g.clearRect(i, j, 50, 50);
+            }
+        }
+    }
+
+    public static void main(String[] args) {
+        JFrame frame = new JFrame();
+        frame.setTitle("Chess Game-Java GAD");
+        frame.setSize(600, 600);
+        frame.getContentPane().add(new GameBoard());
+        frame.setLocationRelativeTo(null);
+        frame.setBackground(Color.LIGHT_GRAY);
+        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+        frame.setVisible(true);
+    }
+}

JavaGAD_ChessGame/src/board/Board.java

@@ -0,0 +1,87 @@
+package board;
+import com.google.common.collect.ImmutableList;
+import pieces.Alliance;
+import pieces.Pawn;
+import pieces.Piece;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+
+public class Board {
+    private final List<Tile> game;
+    private final Collection<Piece> whiteP;
+    private final Collection<Piece> blackP;
+    private Board(Build builder)
+    {
+        this.game=createGame(builder);
+        this.whiteP=NrActivePieces(this.game,Alliance.White);
+        this.blackP=NrActivePieces(this.game,Alliance.Black);
+    }
+
+    private Collection<Piece> NrActivePieces(List<Tile> game, Alliance A) {
+        final List<Piece> active=new ArrayList<>();
+        for(final Tile tile:game) {
+            if (tile.isOccupied()) {
+                final Piece piece = tile.getPiece();
+                if (piece.getAlliance() == A) {
+                    active.add(piece);
+                }
+            }
+        }
+        return ImmutableList.copyOf(active);
+    }
+
+    private static List<Tile>createGame(final Build builder){
+        final Tile[] tiles=new Tile[BoardUtils.NrTiles];
+        for(int i=0;i<BoardUtils.NrTiles;i++) {
+            tiles[i] = Tile.createT(i, builder.boardConfig.get(i));
+        }
+        return ImmutableList.copyOf(tiles);
+    }
+    public static Board createNewBoard(){
+        final Build b=new Build();
+        b.setPiece(new Pawn(48, Alliance.White));
+        b.setPiece(new Pawn(49, Alliance.White));
+        b.setPiece(new Pawn(50, Alliance.White));
+        b.setPiece(new Pawn(51, Alliance.White));
+        b.setPiece(new Pawn(52, Alliance.White));
+        b.setPiece(new Pawn(53, Alliance.White));
+        b.setPiece(new Pawn(54, Alliance.White));
+        b.setPiece(new Pawn(55, Alliance.White));
+
+        b.setPiece(new Pawn(8, Alliance.Black));
+        b.setPiece(new Pawn(9, Alliance.Black));
+        b.setPiece(new Pawn(10, Alliance.Black));
+        b.setPiece(new Pawn(11, Alliance.Black));
+        b.setPiece(new Pawn(12, Alliance.Black));
+        b.setPiece(new Pawn(13, Alliance.Black));
+        b.setPiece(new Pawn(14, Alliance.Black));
+        b.setPiece(new Pawn(15, Alliance.Black));
+
+        b.setMove(Alliance.White);
+        //build the board
+        return b.build();
+    }
+    public Tile getTile(final int TileCoord){
+        return game.get(TileCoord);
+    }
+    public static class Build{
+        Map<Integer, Piece> boardConfig;
+        Alliance nextMove;
+        public Build(){
+        }
+        public Build setPiece(final Piece piece){
+            this.boardConfig.put(piece.getPosition(), piece);
+            return this;
+        }
+        public Build setMove(final Alliance nextMove){
+            this.nextMove=nextMove;
+            return this;
+        }
+        public Board build(){
+            return new Board(this);
+        }
+    }
+}

JavaGAD_ChessGame/src/board/BoardUtils.java

@@ -0,0 +1,33 @@
+package board;
+
+public class BoardUtils {
+    public static final boolean[] FIRST_COLUMN=initColumn(0);
+
+    private static boolean[] initColumn(int c) {
+        final boolean[] column=new boolean[64];
+        while(c<64)
+        {
+            column[c]=true;
+            c+=8;
+        }
+        return column;
+    }
+
+    public static final boolean[] SECOND_COLUMN=initColumn(1);
+    public static final boolean[] SEVENTH_COLUMN=initColumn(6);
+    public static final boolean[] EIGHTH_COLUMN=initColumn(7);
+    public static final boolean[] SECOND_ROW=null;
+    public static final boolean[] SEVENTH_ROW=null;
+
+    public static final int NrTiles=64;
+    public static final int NrTilesPerRow=8;
+
+    private BoardUtils()
+    {
+        throw new RuntimeException(" ");
+    }
+    public static boolean ValidTCoord(int coord)
+    {
+        return coord>=0 && coord<=63;
+    }
+}

JavaGAD_ChessGame/src/board/Move.java

@@ -0,0 +1,30 @@
+package board;
+
+import pieces.Piece;
+
+public abstract class Move {
+    final Board board;
+    final Piece MovedPiece;
+    final int DestCoord;
+
+    private Move(final Board board, final Piece MovedPiece, final int DestCoord)
+    {
+        this.board=board;
+        this.MovedPiece=MovedPiece;
+        this.DestCoord=DestCoord;
+    }
+
+    public static final class MMove extends Move{
+        public MMove(final Board board, final Piece MovedPiece, final int DestCoord) {
+            super(board, MovedPiece, DestCoord);
+        }
+    }
+
+    public static final class AttackMove extends Move{
+        final Piece AttackedPiece;
+        public AttackMove(final Board board, final Piece MovedPiece, final int DestCoord, final Piece AttackedPiece){
+            super(board, MovedPiece, DestCoord);
+            this.AttackedPiece=AttackedPiece;
+        }
+    }
+}

JavaGAD_ChessGame/src/board/Tile.java

@@ -0,0 +1,72 @@
+package board;
+import com.google.common.collect.ImmutableMap;
+import pieces.Piece;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+
+public abstract class Tile {
+    protected final int TileCoord;
+    private static final Map<Integer, Empty> EMPTY=createAllEmptyTiles();
+
+    private static Map<Integer, Empty> createAllEmptyTiles() {
+        final Map<Integer, Empty> emptyTM=new HashMap<>();
+        for(int i=0;i<=63;i++){
+            emptyTM.put(i, new Empty(i));
+        }
+
+        return ImmutableMap.copyOf(emptyTM);
+    }
+
+    public static Tile createT(final int TileCoord, final Piece piece)
+    {
+        return piece!=null ? new Occupied(TileCoord, piece) : EMPTY.get(TileCoord);
+    }
+
+    //constructor
+    private Tile(int TileCoord){
+        this.TileCoord=TileCoord;
+    }
+
+    //verifica daca spatiul/patratul este ocupat
+    public abstract boolean isOccupied();
+
+    public abstract Piece getPiece();
+
+    public static final class Empty extends Tile{
+        //constructor
+        Empty(final int coord)
+        {
+            super(coord);
+        }
+        @Override
+        public boolean isOccupied()
+        {
+            return false;
+        }
+        @Override
+        public Piece getPiece()
+        {
+            return null;
+        }
+    }
+
+    public static final class Occupied extends Tile{
+        private final Piece PieceOnTile;
+        Occupied(int TileCoord, Piece PieceOnTile){
+            super(TileCoord);
+            this.PieceOnTile=PieceOnTile;
+        }
+        @Override
+        public boolean isOccupied()
+        {
+            return true;
+        }
+        @Override
+        public Piece getPiece()
+        {
+            return this.PieceOnTile;
+        }
+
+    }
+}

JavaGAD_ChessGame/src/pieces/Alliance.java

@@ -0,0 +1,41 @@
+package pieces;
+
+public enum Alliance {
+    White{
+        @Override
+        public int getDirection(){
+            return -1;
+        }
+
+        @Override
+        public boolean isW() {
+            return true;
+        }
+
+        @Override
+        public boolean isB() {
+            return false;
+        }
+    },
+    Black{
+        @Override
+        public int getDirection(){
+            return 1;
+        }
+
+        @Override
+        public boolean isW() {
+            return false;
+        }
+
+        @Override
+        public boolean isB() {
+            return true;
+        }
+    };
+    public abstract int getDirection();
+    public abstract boolean isW();
+    public abstract boolean isB();
+
+}
+

JavaGAD_ChessGame/src/pieces/Pawn.java

@@ -0,0 +1,63 @@
+package pieces;
+
+import board.Board;
+import board.BoardUtils;
+import board.Move;
+import com.google.common.collect.ImmutableList;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+
+public class Pawn extends Piece{
+    private final static int[] move_coord={8};
+    public Pawn(final int Position, final Alliance A){
+        super(Position,A);
+    }
+    @Override
+    public Collection<Move> NrLegalMoves(Board board){
+        final List<Move> legalM=new ArrayList<>();
+        for(final int current:move_coord){
+            int candidateDestCoord=this.Position+(this.getAlliance().getDirection())+current;
+            if(!BoardUtils.ValidTCoord(current)){
+                continue;
+            }
+            if(current==8&&!board.getTile(candidateDestCoord).isOccupied()){
+                legalM.add(new Move.MMove(board,this,candidateDestCoord));
+            }
+            else
+                if(current==16&&this.FirstMove()&&
+                        (BoardUtils.SECOND_ROW[this.Position]&&this.getAlliance().isB())||
+                        (BoardUtils.SEVENTH_ROW[this.Position]&&this.getAlliance().isW())){
+                                final int behindDestCoord=this.Position+this.getAlliance().getDirection()+8;
+                                if(!board.getTile(behindDestCoord).isOccupied()&&!board.getTile(candidateDestCoord).isOccupied()){
+                                    legalM.add(new Move.MMove(board,this,candidateDestCoord));
+
+                                }
+                                else
+                                    if(current==7&&!(BoardUtils.EIGHTH_COLUMN[this.Position]&&this.getAlliance().isW())||
+                                            (BoardUtils.FIRST_COLUMN[this.Position]&&this.getAlliance().isB())){
+                                            if(board.getTile(candidateDestCoord).isOccupied() ){
+                                                final Piece pieceC=board.getTile(candidateDestCoord).getPiece();
+                                                if(this.getAlliance()!=pieceC.getAlliance())
+                                                {
+                                                    legalM.add(new Move.MMove(board,this,candidateDestCoord));
+                                                }
+                                            }
+                                    }
+                                    else
+                                        if(current==9&&!(BoardUtils.FIRST_COLUMN[this.Position]&&this.getAlliance().isW())||
+                                                (BoardUtils.EIGHTH_COLUMN[this.Position]&&this.getAlliance().isB())){
+                                            if(board.getTile(candidateDestCoord).isOccupied() ){
+                                                final Piece pieceC=board.getTile(candidateDestCoord).getPiece();
+                                                if(this.getAlliance()!=pieceC.getAlliance())
+                                                {
+                                                    legalM.add(new Move.MMove(board,this,candidateDestCoord));
+                                                }
+                                            }
+                                        }
+                }
+        }
+        return ImmutableList.copyOf(legalM);
+    }
+}

JavaGAD_ChessGame/src/pieces/Piece.java

@@ -0,0 +1,30 @@
+package pieces;
+import board.Board;
+import board.Move;
+import java.util.Collection;
+import java.util.List;
+
+public abstract class Piece {
+    protected final int Position;
+    protected final Alliance A;
+    protected final boolean FirstMove;
+
+    Piece(final int Position, final Alliance A)
+    {
+        this.A=A;
+        this.Position=Position;
+        this.FirstMove=false;
+    }
+
+    public int getPosition(){
+        return this.Position;
+    }
+    public Alliance getAlliance(){
+        return this.A;
+    }
+    public boolean FirstMove(){
+        return this.FirstMove;
+    }
+    public abstract Collection<Move> NrLegalMoves(final Board board);
+
+}