Merge branch 'master' of https://scm.team4change.de/vimo/vivi-exercises

chess/src/main/java/de/vivi/chess/Main.java

@@ -1,12 +1,18 @@
 package de.vivi.chess;
 
 import de.vivi.chess.board.Board;
+import de.vivi.chess.board.Field;
 import de.vivi.chess.game.Game;
+import de.vivi.chess.pieces.Piece;
+
+import java.util.Arrays;
 
 public class Main {
 
     public static void main(String[] args) {
         Game game = new Game();
+
         game.play();
+
     }
 }

chess/src/main/java/de/vivi/chess/board/Board.java

@@ -1,11 +1,11 @@
 package de.vivi.chess.board;
 
-import de.vivi.chess.pieces.Piece;
+import de.vivi.chess.pieces.*;
+import de.vivi.chess.game.Game;
 
 public class Board {
 
     private static final int SIZE = 8;
-
     private final Piece[/* column */][/* row */] grid;
 
     public Board() {
@@ -21,8 +21,52 @@ public class Board {
      * in the bottom two rows. "White queen, white field, black
      * queen, black field".
      */
-    private void setup() {
 
+    private void setup() {
+        grid[0][0] = new Rook(Color.BLACK, Type.ROOK, new Field(0, 0));
+        grid[1][0] = new Knight(Color.BLACK, Type.KNIGHT, new Field(1, 0));
+        grid[2][0] = new Bishop(Color.BLACK, Type.BISHOP, new Field(2, 0));
+        grid[3][0] = new Queen(Color.BLACK, Type.QUEEN, new Field(3, 0));
+        grid[4][0] = new King(Color.BLACK, Type.KING, new Field(4, 0));
+        grid[5][0] = new Bishop(Color.BLACK, Type.BISHOP, new Field(5, 0));
+        grid[6][0] = new Knight(Color.BLACK, Type.KNIGHT, new Field(6, 0));
+        grid[7][0] = new Rook(Color.BLACK, Type.ROOK, new Field(7, 0));
+        //grid[0][0] = new Rook(Color.BLACK, Type.ROOK);
+//        grid[1][0] = new Knight(Color.BLACK, Type.KNIGHT);
+//        grid[2][0] = new Bishop(Color.BLACK, Type.BISHOP);
+//        grid[3][0] = new Queen(Color.BLACK, Type.QUEEN);
+//        grid[4][0] = new King(Color.BLACK, Type.KING);
+//        grid[5][0] = new Bishop(Color.BLACK, Type.BISHOP);
+//        grid[6][0] = new Knight(Color.BLACK, Type.KNIGHT);
+//        grid[7][0] = new Rook(Color.BLACK, Type.ROOK);
+
+        for (int i = 0; i < SIZE; i++) {
+            //grid[i][1] = new Pawn(Color.BLACK, Type.PAWN);
+            grid[i][1] = new Pawn(Color.BLACK, Type.PAWN, new Field(i, 0));
+        }
+
+        grid[0][7] = new Rook(Color.WHITE, Type.ROOK, new Field(0, 7));
+        grid[1][7] = new Knight(Color.WHITE, Type.KNIGHT, new Field(1, 7));
+        grid[2][7] = new Bishop(Color.WHITE, Type.BISHOP, new Field(2, 7));
+        grid[3][7] = new Queen(Color.WHITE, Type.QUEEN, new Field(3, 7));
+        grid[4][7] = new King(Color.WHITE, Type.KING, new Field(4, 7));
+        grid[5][7] = new Bishop(Color.WHITE, Type.BISHOP, new Field(5, 7));
+        grid[6][7] = new Knight(Color.WHITE, Type.KNIGHT, new Field(6, 7));
+        grid[7][7] = new Rook(Color.WHITE, Type.ROOK, new Field(7, 7));
+
+//        grid[0][7] = new Rook(Color.WHITE, Type.ROOK);
+//        grid[1][7] = new Knight(Color.WHITE, Type.KNIGHT);
+//        grid[2][7] = new Bishop(Color.WHITE, Type.BISHOP);
+//        grid[3][7] = new Queen(Color.WHITE, Type.QUEEN);
+//        grid[4][7] = new King(Color.WHITE, Type.KING);
+//        grid[5][7] = new Bishop(Color.WHITE, Type.BISHOP);
+//        grid[6][7] = new Knight(Color.WHITE, Type.KNIGHT);
+//        grid[7][7] = new Rook(Color.WHITE, Type.ROOK);
+
+        for (int i = 0; i < SIZE; i++) {
+            //grid[i][6] = new Pawn(Color.WHITE, Type.PAWN);
+            grid[i][6] = new Pawn(Color.WHITE, Type.PAWN, new Field(i, 6));
+        }
     }
 
     /**
@@ -34,7 +78,11 @@ public class Board {
      * just getting replaced.
      */
     public void move(Field from, Field to) {
-
+        if (grid[from.getColumn()][from.getRow()] != null) {
+            grid[to.getColumn()][to.getRow()] = grid[from.getColumn()][from.getRow()];
+            grid[to.getColumn()][to.getRow()].setField(to);
+            grid[from.getColumn()][from.getRow()] = null;
+        }
     }
 
     /**
@@ -44,7 +92,22 @@ public class Board {
      * present it just returns null.
      */
     public Piece getPiece(Field field) {
-        return null;
+        return grid[field.getColumn()][field.getRow()];
+    }
+
+    public Piece[][] getBoard() {
+        return grid;
+    }
+
+    public Piece getPiece(int column, int row) {
+        return grid[column][row];
+    }
+
+    public void setPiece(int column, int row, Piece piece) {
+        grid[column][row] = piece;
+        if (piece != null) {
+            piece.setField(new Field(column, row));
+        }
     }
 
     @Override

chess/src/main/java/de/vivi/chess/board/Field.java

@@ -1,5 +1,7 @@
 package de.vivi.chess.board;
 
+import de.vivi.chess.pieces.Piece;
+
 /**
  * TODO: implement fields and constructor
  * <p>
@@ -8,6 +10,14 @@ package de.vivi.chess.board;
  */
 public class Field {
 
+    private int column;
+    private int row;
+
+    public Field(int column, int row) {
+        this.column = column;
+        this.row = row;
+    }
+
     /**
      * TODO: implement
      * <p>
@@ -15,7 +25,7 @@ public class Field {
      * column and row indices.
      */
     public static Field from(int column, int row) {
-        return null;
+        return new Field(column, row);
     }
 
     /**
@@ -28,16 +38,81 @@ public class Field {
      * it should throw an IllegalArgument exception.
      */
     public static Field fromString(String value) throws IllegalArgumentException {
-        return null;
+        try {
+            char[] array = value.toCharArray();
+            int column_ = 0;
+            int row_ = 0;
+
+            switch (array[0]) {
+                case 'A':
+                    column_ = 0;
+                    break;
+                case 'B':
+                    column_ = 1;
+                    break;
+                case 'C':
+                    column_ = 2;
+                    break;
+                case 'D':
+                    column_ = 3;
+                    break;
+                case 'E':
+                    column_ = 4;
+                    break;
+                case 'F':
+                    column_ = 5;
+                    break;
+                case 'G':
+                    column_ = 6;
+                    break;
+                case 'H':
+                    column_ = 7;
+                    break;
+                default:
+                    System.out.println("Wrong input");
+            }
+
+            switch (array[1]) {
+                case '1':
+                    row_ = 0;
+                    break;
+                case '2':
+                    row_ = 1;
+                    break;
+                case '3':
+                    row_ = 2;
+                    break;
+                case '4':
+                    row_ = 3;
+                    break;
+                case '5':
+                    row_ = 4;
+                    break;
+                case '6':
+                    row_ = 5;
+                    break;
+                case '7':
+                    row_ = 6;
+                    break;
+                case '8':
+                    row_ = 7;
+                    break;
+                default:
+                    System.out.println("Wrong input");
+            }
+            return from(column_, row_);
+        } catch (RuntimeException e) {
+            throw new RuntimeException(e);
+        }
     }
 
     public int getColumn() {
         // TODO: implement
-        return -1;
+        return column;
     }
 
     public int getRow() {
         // TODO: implement
-        return -1;
+        return row;
     }
 }

chess/src/main/java/de/vivi/chess/game/Game.java

@@ -1,19 +1,30 @@
 package de.vivi.chess.game;
 
 import de.vivi.chess.board.Board;
+import de.vivi.chess.board.Field;
 import de.vivi.chess.pieces.Color;
+import de.vivi.chess.pieces.King;
+import de.vivi.chess.pieces.Piece;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Scanner;
+
+import static de.vivi.chess.pieces.Color.BLACK;
+import static de.vivi.chess.pieces.Color.WHITE;
 
 public class Game {
 
-    private final Board board;
-
+    private Board board;
     private Color player;
+    private int count = 0;
+    private boolean whiteTurn = true;
 
     /**
      * TODO: implement
      */
     public Game() {
-        board = null;
+        this.board = new Board();
         player = null;
     }
 
@@ -24,6 +35,296 @@ public class Game {
      * specified inside example-output.txt.
      */
     public void play() {
+        System.out.println("Welcome to Vivi's Chess Game!");
+        System.out.println(board);
+        player = ((count % 2) == 0) ? WHITE : BLACK;
+        System.out.println("It is white's turn: [from:to]");
+
+        Scanner scanner = new Scanner(System.in);
+
+        while (scanner.hasNext()) {
+
+                scanner.useDelimiter(":\\s*");
+                String fromString = scanner.nextLine();
+
+                char[] arrayInRange = fromString.toCharArray();
+
+                if ((arrayInRange[0] == 'A' ||
+                        arrayInRange[0] == 'B' ||
+                        arrayInRange[0] == 'C' ||
+                        arrayInRange[0] == 'D' ||
+                        arrayInRange[0] == 'E' ||
+                        arrayInRange[0] == 'F' ||
+                        arrayInRange[0] == 'G' ||
+                        arrayInRange[0] == 'H' ) &&
+                    (arrayInRange[1] == '0' ||
+                            arrayInRange[1] == '1' ||
+                            arrayInRange[1] == '2' ||
+                            arrayInRange[1] == '3' ||
+                            arrayInRange[1] == '4' ||
+                            arrayInRange[1] == '5' ||
+                            arrayInRange[1] == '6' ||
+                            arrayInRange[1] == '7' ||
+                            arrayInRange[1] == '8' )) {
+
+                    StringBuilder sb=new StringBuilder(fromString);
+                    int l=sb.length();
+
+                    if (l == 2) {
+                        String toString = scanner.nextLine();
+                        Field from = Field.fromString(fromString);
+                        Field to = Field.fromString(toString);
+
+                        System.out.println("player == WHITE && board.getPiece(from).getColor() == WHITE " +
+                                (player == WHITE && board.getPiece(from).getColor() == WHITE));
+
+
+                        System.out.println("board.getPiece(from).isValidMove(board, from,to) " +
+                                (board.getPiece(from).isValidMove(board, from,to)));
+
+                        if (player == WHITE && board.getPiece(from).getColor() == WHITE) {
+                            if (board.getPiece(from).isValidMove(board, from,to)) {
+                                count++;
+                                board.move(from, to);
+                                System.out.println("Moving white " + board.getPiece(to).getType()
+                                        + " from " + fromString + " to " + toString);
+                            }
+                            System.out.println(board);
+                        } else if (player == BLACK && board.getPiece(from).getColor() == BLACK) {
+                            if (board.getPiece(from).isValidMove(board, from,to)) {
+                                count++;
+                                board.move(from, to);
+                                System.out.println("Moving black " + board.getPiece(to).getType()
+                                        + " from " + fromString + " to " + toString);
+                            }
+                            System.out.println(board);
+                        } else {
+                            System.err.println("Illegal move, try again: ");
+                        }
+
+                        player = ((count % 2) == 0) ? WHITE : BLACK;
+                        if (player == BLACK) {
+                            System.out.println("It is black's turn: [from:to]");
+                        } else {
+                            System.out.println("It is white's turn: [from:to]");
+                        }
+                    } else {
+                        System.err.println("Illegal move, try again: ");
+                    }
+                } else
+                    System.err.println("Illegal move, try again: ");
+                }
+    }
+
+    public Board getBoard() {
+        return this.board;
+    }
+
+    public void resetGame() {
+        this.board = new Board();
+        this.whiteTurn = true;
+    }
+
+    public Color getCurrentPlayerColor() {
+        return whiteTurn ? Color.WHITE : Color.BLACK;
+    }
+
+    private Field selectedField;
+
+    public boolean isPieceSelected() {
+        return selectedField != null;
+    }
+
+    public boolean handleSquareSelection(int row, int col) {
+        if (selectedField == null) {
+            Piece selectedPiece = board.getPiece(row, col);
+            if (selectedPiece != null
+                    && selectedPiece.getColor() == (whiteTurn ? Color.WHITE : Color.BLACK)) {
+                selectedField = new Field(row, col);
+                return false;
+            }
+        } else {
+            boolean moveMade = makeMove(selectedField, new Field(row, col));
+            selectedField = null;
+            return moveMade;
+        }
+        return false;
+    }
+
+    public boolean makeMove(Field from, Field to) {
+        Piece movingPiece = board.getPiece(Field.from(from.getRow(), from.getColumn()));
+        if (movingPiece == null || movingPiece.getColor() != (whiteTurn ? WHITE : BLACK)) {
+            return false;
+        }
+
+        if (movingPiece.isValidMove(board, movingPiece.getField(), to)) {
+            board.move(from, to);
+            whiteTurn = !whiteTurn;
+            return true;
+        }
+        return false;
+    }
+
+    public boolean isInCheck(Color kingColor) {
+        Field kingPosition = findKingPosition(kingColor);
+        for (int row = 0; row < 8; row++) {
+            for (int col = 0; col < 8; col++) {
+                Piece piece = board.getPiece(Field.from(row, col));
+                if (piece != null && piece.getColor() != kingColor) {
+                    if (piece.isValidMove(board, piece.getField(), kingPosition)) {
+                        return true;
+                    }
+                }
+            }
+        }
+        return false;
 
     }
+
+    private Field findKingPosition(Color color) {
+        for (int row = 0; row < 8; row++) {
+            for (int col = 0; col < 8; col++) {
+                Piece piece = board.getPiece(Field.from(row, col));
+                if (piece instanceof King && piece.getColor() == color) {
+                    return new Field(row, col);
+                }
+            }
+        }
+        throw new RuntimeException("King not found, which should never happen.");
+    }
+
+    public boolean isCheckmate(Color kingColor) {
+        if (!isInCheck(kingColor)) {
+            return false;
+        }
+
+        Field kingPosition = findKingPosition(kingColor);
+        King king = (King) board.getPiece(Field.from(kingPosition.getRow(), kingPosition.getColumn()));
+
+        for (int rowOffset = -1; rowOffset <= 1; rowOffset++) {
+            for (int colOffset = -1; colOffset <= 1; colOffset++) {
+                if (rowOffset == 0 && colOffset == 0) {
+                    continue;
+                }
+                Field newPosition = new Field(kingPosition.getRow() + rowOffset,
+                        kingPosition.getColumn() + colOffset);
+                if (
+                        isPositionOnBoard(newPosition) &&
+                                king.isValidMove(board, king.getField() , newPosition)
+                        && !wouldBeInCheckAfterMove(kingColor, kingPosition, newPosition)) {
+                    return false;
+                }
+            }
+        }
+
+        return true;
+
+    }
+
+    private boolean isPositionOnBoard(Field field) {
+        return field.getRow() >= 0 && field.getRow() < 8 &&
+                field.getColumn() >= 0 && field.getColumn() < 8;
+
+    }
+
+    private boolean wouldBeInCheckAfterMove(Color kingColor, Field from, Field to) {
+        Piece temp = board.getPiece(Field.from(to.getRow(), to.getColumn()));
+        board.setPiece(to.getRow(), to.getColumn(), board.getPiece(to));
+        board.setPiece(from.getRow(), from.getColumn(), null);
+
+        boolean inCheck = isInCheck(kingColor);
+
+        board.setPiece(from.getRow(), from.getColumn(), board.getPiece(to.getRow(), to.getColumn()));
+        board.setPiece(to.getRow(), to.getColumn(), temp);
+
+        return inCheck;
+    }
+
+    public List<Field> getLegalMovesForPieceAt(Field field) {
+        Piece selectedPiece = board.getPiece(field.getRow(), field.getColumn());
+        if (selectedPiece == null)
+            return new ArrayList<>();
+
+        List<Field> legalMoves = new ArrayList<>();
+        switch (selectedPiece.getClass().getSimpleName()) {
+            case "Pawn":
+                addPawnMoves(field, selectedPiece.getColor(), legalMoves);
+                break;
+            case "Rook":
+                addLineMoves(field, new int[][] { { 1, 0 }, { -1, 0 }, { 0, 1 }, { 0, -1 } }, legalMoves);
+                break;
+            case "Knight":
+                addSingleMoves(field, new int[][] { { 2, 1 }, { 2, -1 }, { -2, 1 }, { -2, -1 }, { 1, 2 }, { -1, 2 },
+                        { 1, -2 }, { -1, -2 } }, legalMoves);
+                break;
+            case "Bishop":
+                addLineMoves(field, new int[][] { { 1, 1 }, { -1, -1 }, { 1, -1 }, { -1, 1 } }, legalMoves);
+                break;
+            case "Queen":
+                addLineMoves(field, new int[][] { { 1, 0 }, { -1, 0 }, { 0, 1 }, { 0, -1 }, { 1, 1 }, { -1, -1 },
+                        { 1, -1 }, { -1, 1 } }, legalMoves);
+                break;
+            case "King":
+                addSingleMoves(field, new int[][] { { 1, 0 }, { -1, 0 }, { 0, 1 }, { 0, -1 }, { 1, 1 }, { -1, -1 },
+                        { 1, -1 }, { -1, 1 } }, legalMoves);
+                break;
+        }
+        return legalMoves;
+    }
+
+    private void addLineMoves(Field field, int[][] directions, List<Field> legalMoves) {
+        for (int[] d : directions) {
+            Field newPos = new Field(field.getRow() + d[0], field.getColumn() + d[1]);
+            while (isPositionOnBoard(newPos)) {
+                if (board.getPiece(newPos.getRow(), newPos.getColumn()) == null) {
+                    legalMoves.add(new Field(newPos.getRow(), newPos.getColumn()));
+                    newPos = new Field(newPos.getRow() + d[0], newPos.getColumn() + d[1]);
+                } else {
+                    if (board.getPiece(newPos.getRow(), newPos.getColumn()).getColor() != board
+                            .getPiece(field.getRow(), field.getColumn()).getColor()) {
+                        legalMoves.add(newPos);
+                    }
+                    break;
+                }
+            }
+        }
+    }
+
+    private void addSingleMoves(Field field, int[][] moves, List<Field> legalMoves) {
+        for (int[] move : moves) {
+            Field newPos = new Field(field.getRow() + move[0], field.getColumn() + move[1]);
+            if (isPositionOnBoard(newPos) && (board.getPiece(newPos.getRow(), newPos.getColumn()) == null ||
+                    board.getPiece(newPos.getRow(), newPos.getColumn()).getColor() != board
+                            .getPiece(field.getRow(), field.getColumn()).getColor())) {
+                legalMoves.add(newPos);
+            }
+        }
+    }
+
+    private void addPawnMoves(Field field, Color color, List<Field> legalMoves) {
+        int direction = color == WHITE ? -1 : 1;
+        Field newPos = new Field(field.getRow() + direction, field.getColumn());
+        if (isPositionOnBoard(newPos) && board.getPiece(newPos.getRow(), newPos.getColumn()) == null) {
+            legalMoves.add(newPos);
+        }
+
+        if ((color == Color.WHITE && field.getRow() == 6)
+                || (color == Color.BLACK && field.getRow() == 1)) {
+            newPos = new Field(field.getRow() + 2 * direction, field.getColumn());
+            Field intermediatePos = new Field(field.getRow() + direction, field.getColumn());
+            if (isPositionOnBoard(newPos) && board.getPiece(newPos.getRow(), newPos.getColumn()) == null
+                    && board.getPiece(intermediatePos.getRow(), intermediatePos.getColumn()) == null) {
+                legalMoves.add(newPos);
+            }
+        }
+
+        int[] captureCols = { field.getColumn() - 1, field.getColumn() + 1 };
+        for (int col : captureCols) {
+            newPos = new Field(field.getRow() + direction, col);
+            if (isPositionOnBoard(newPos) && board.getPiece(newPos.getRow(), newPos.getColumn()) != null &&
+                    board.getPiece(newPos.getRow(), newPos.getColumn()).getColor() != color) {
+                legalMoves.add(newPos);
+            }
+        }
+    }
 }

chess/src/main/java/de/vivi/chess/pieces/Bishop.java

@@ -0,0 +1,59 @@
+package de.vivi.chess.pieces;
+
+import de.vivi.chess.board.Board;
+import de.vivi.chess.board.Field;
+
+public class Bishop extends Piece {
+    public Bishop(Color color, Type type) {
+        super(color, type);
+    }
+
+    public Bishop(Color color, Type type, Field field) {
+        super(color, type, field);
+    }
+
+    @Override
+    public char getSymbol() {
+        if (getColor() == Color.WHITE) {
+            if (getType() == Type.BISHOP) {
+                symbol = '\u265D';
+            }
+
+        } else if (getColor() == Color.BLACK) {
+            if (getType() == Type.BISHOP) {
+                symbol = '\u2657';
+            }
+        }
+        return symbol;
+    }
+
+    @Override
+    public boolean isValidMove(Board board, Field from, Field to) {
+        int rowDiff = Math.abs(from.getRow() - to.getRow());
+        int colDiff = Math.abs(from.getColumn() - to.getColumn());
+
+        if (rowDiff != colDiff) {
+            return false;
+        }
+
+        int rowStep = to.getRow() > from.getRow() ? 1 : -1;
+        int colStep = to.getColumn() > from.getColumn() ? 1 : -1;
+        int steps = rowDiff - 1;
+
+        for (int i = 1; i <= steps; i++) {
+            if (board.getPiece(Field.from(from.getColumn() + i * rowStep,
+                    from.getRow() + i * colStep)) != null) {
+                return false;
+            }
+        }
+
+        Piece destinationPiece = board.getPiece(Field.from(to.getColumn(), to.getRow()));
+        if (destinationPiece == null) {
+            return true;
+        } else if (destinationPiece.getColor() != this.getColor()) {
+            return true;
+        }
+
+        return false;
+    }
+}

chess/src/main/java/de/vivi/chess/pieces/Color.java

@@ -4,4 +4,6 @@ package de.vivi.chess.pieces;
  * TODO: add colors (white and black)
  */
 public enum Color {
+    WHITE,
+    BLACK
 }

chess/src/main/java/de/vivi/chess/pieces/King.java

@@ -0,0 +1,44 @@
+package de.vivi.chess.pieces;
+
+import de.vivi.chess.board.Board;
+import de.vivi.chess.board.Field;
+
+public class King extends Piece {
+    public King(Color color, Type type) {
+        super(color, type);
+    }
+
+    public King(Color color, Type type, Field field) {
+        super(color, type, field);
+    }
+
+    @Override
+    public char getSymbol() {
+        if (getColor() == Color.WHITE) {
+            if (getType() == Type.KING) {
+                symbol = '\u265A';
+            }
+
+        } else if (getColor() == Color.BLACK) {
+            if (getType() == Type.KING) {
+                symbol = '\u2654';
+            }
+        }
+        return symbol;
+    }
+
+    @Override
+    public boolean isValidMove(Board board, Field from, Field to) {
+        int rowDiff = Math.abs(from.getRow() - to.getRow());
+        int colDiff = Math.abs(from.getColumn() - to.getColumn());
+
+        boolean isOneSquareMove = rowDiff <= 1 && colDiff <= 1 && !(rowDiff == 0 && colDiff == 0);
+
+        if (!isOneSquareMove) {
+            return false;
+        }
+
+        Piece destinationPiece = board.getPiece(Field.from(to.getColumn(), to.getRow()));
+        return destinationPiece == null || destinationPiece.getColor() != this.getColor();
+    }
+}

chess/src/main/java/de/vivi/chess/pieces/Knight.java

@@ -0,0 +1,53 @@
+package de.vivi.chess.pieces;
+
+import de.vivi.chess.board.Board;
+import de.vivi.chess.board.Field;
+
+public class Knight extends Piece {
+    public Knight(Color color, Type type) {
+        super(color, type);
+    }
+
+    public Knight(Color color, Type type, Field field) {
+        super(color, type, field);
+    }
+
+    @Override
+    public char getSymbol() {
+        if (getColor() == Color.WHITE) {
+            if (getType() == Type.KNIGHT) {
+                symbol = '\u265E';
+            }
+
+        } else if (getColor() == Color.BLACK) {
+            if (getType() == Type.KNIGHT) {
+                symbol = '\u2658';
+            }
+        }
+        return symbol;
+    }
+
+
+    @Override
+    public boolean isValidMove(Board board, Field from, Field to) {
+        if (to.equals(from)) {
+            return false;
+        }
+
+        int rowDiff = Math.abs(from.getRow() - to.getRow());
+        int colDiff = Math.abs(from.getColumn() - to.getColumn());
+
+        boolean isValidLMove = (rowDiff == 2 && colDiff == 1) || (rowDiff == 1 && colDiff == 2);
+
+        if (!isValidLMove) {
+            return false;
+        }
+
+        Piece targetPiece = board.getPiece(to);
+        if (targetPiece == null) {
+            return true;
+        } else {
+            return targetPiece.getColor() != this.getColor();
+        }
+    }
+}

chess/src/main/java/de/vivi/chess/pieces/Pawn.java

@@ -0,0 +1,73 @@
+package de.vivi.chess.pieces;
+
+import de.vivi.chess.board.Board;
+import de.vivi.chess.board.Field;
+
+public class Pawn extends Piece {
+
+    public Pawn(Color color, Type type) {
+        super(color, type);
+    }
+
+    public Pawn(Color color, Type type, Field field) {
+        super(color, type, field);
+    }
+
+    @Override
+    public char getSymbol() {
+        if (getColor() == Color.WHITE) {
+            if (getType() == Type.PAWN) {
+                symbol = '\u265F';
+            }
+
+        } else if (getColor() == Color.BLACK) {
+            if (getType() == Type.PAWN) {
+                symbol = '\u2659';
+            }
+        }
+        return symbol;
+    }
+
+    @Override
+    public boolean isValidMove(Board board, Field from, Field to) {
+       int forwardDirection = getColor() == Color.WHITE ? -1 : 1;
+        System.out.println("forwardDirection " + forwardDirection);
+        System.out.println("to.getRow() " + to.getRow());
+        System.out.println("from.getRow() " + from.getRow());
+       int rowDiff = (to.getRow() - from.getRow()) * forwardDirection;
+        System.out.println("rowDiff " + rowDiff);
+       int colDiff = to.getColumn() - from.getColumn();
+        System.out.println("colDiff " + colDiff);
+        System.out.println("black pawn links " + board.getPiece(0,1));
+
+       if (colDiff == 0 && rowDiff == 1 && board.getPiece(to) == null) {
+           return true;
+       }
+
+       boolean isStartingField = (getColor() == Color.WHITE && from.getRow() == 6) ||
+               (getColor() == Color.BLACK && from.getRow() == 1);
+        System.out.println("getColor() " + getColor());
+        System.out.println("from.getRow() " + from.getRow());
+        System.out.println("isStartingField " + isStartingField);
+        System.out.println("board.getPiece(to) " + board.getPiece(to));
+       if (colDiff == 0 && rowDiff == 2 && isStartingField &&
+               board.getPiece(to) == null) {
+           int middleRow = from.getRow() + forwardDirection;
+           System.out.println("from.getRow() " +from.getRow());
+           System.out.println("middleRow " + middleRow);
+           System.out.println("from.getColumn() " + from.getColumn());
+
+           if (board.getPiece(Field.from(from.getColumn(), middleRow)) == null) {
+               return true;
+           }
+       }
+
+       if (Math.abs(colDiff) == 1 && rowDiff == 1 &&
+               board.getPiece(to) != null &&
+               board.getPiece(to).getColor() != this.getColor()) {
+           return true;
+        }
+
+        return false;
+    }
+}

chess/src/main/java/de/vivi/chess/pieces/Piece.java

@@ -5,6 +5,28 @@ import de.vivi.chess.board.Field;
 
 public abstract class Piece {
 
+    Color color;
+    private Type type;
+    protected char symbol;
+    protected Field field;
+
+    protected Piece(Color color, Type type) {
+        this.color = color;
+        this.type = type;
+        symbol = '\u0000';
+    }
+
+    protected Piece(Color color, Field field) {
+        this.color = color;
+        this.field = field;
+    }
+
+    protected Piece(Color color, Type type, Field field) {
+        this.color = color;
+        this.type = type;
+        this.field = field;
+    }
+
     /**
      * TODO: implement
      * <p>
@@ -16,14 +38,15 @@ public abstract class Piece {
      */
     public abstract boolean isValidMove(Board board, Field from, Field to);
 
+
     public Color getColor() {
         // TODO: implement
-        return null;
+        return color;
     }
 
     public Type getType() {
         // TODO: implement
-        return null;
+        return type;
     }
 
     /**
@@ -34,6 +57,14 @@ public abstract class Piece {
      * <a href="https://en.wikipedia.org/wiki/Chess_symbols_in_Unicode">Unicode chess pieces</a>
      */
     public char getSymbol() {
-        return 0;
+        return symbol;
+    }
+
+    public Field getField() {
+        return field;
+    }
+
+    public void setField(Field field) {
+        this.field = field;
     }
 }

chess/src/main/java/de/vivi/chess/pieces/Queen.java

@@ -0,0 +1,64 @@
+package de.vivi.chess.pieces;
+
+import de.vivi.chess.board.Board;
+import de.vivi.chess.board.Field;
+
+public class Queen extends Piece {
+    public Queen(Color color, Type type) {
+        super(color, type);
+    }
+
+    public Queen(Color color, Type type, Field field) {
+        super(color, type, field);
+    }
+
+    @Override
+    public char getSymbol() {
+        if (getColor() == Color.WHITE) {
+            if (getType() == Type.QUEEN) {
+                symbol = '\u265B';
+            }
+
+        } else if (getColor() == Color.BLACK) {
+            if (getType() == Type.QUEEN) {
+                symbol = '\u2655';
+            }
+        }
+        return symbol;
+    }
+
+    @Override
+    public boolean isValidMove(Board board, Field from, Field to) {
+        if (to.equals(from)) {
+            return false;
+        }
+
+        int rowDiff = Math.abs(to.getRow() - from.getRow());
+        int colDiff = Math.abs(to.getColumn() - from.getColumn());
+
+        boolean straightLine = from.getRow() == to.getRow()
+                || from.getColumn() == to.getColumn();
+
+        boolean diagonal = rowDiff == colDiff;
+
+        if (!straightLine && !diagonal) {
+            return false;
+        }
+
+        int rowDirection = Integer.compare(to.getRow(), from.getRow());
+        int colDirection = Integer.compare(to.getColumn(), from.getColumn());
+
+        int currentRow = from.getRow() + rowDirection;
+        int currentCol = from.getColumn() + colDirection;
+        while (currentRow != to.getRow() || currentCol != to.getColumn()) {
+            if (board.getPiece(Field.from(currentCol, currentRow)) != null) {
+                return false;
+            }
+            currentRow += rowDirection;
+            currentCol += colDirection;
+        }
+
+        Piece destinationPiece = board.getPiece(Field.from(to.getColumn(), to.getRow()));
+        return destinationPiece == null || destinationPiece.getColor() != this.getColor();
+    }
+}

chess/src/main/java/de/vivi/chess/pieces/Rook.java

@@ -0,0 +1,68 @@
+package de.vivi.chess.pieces;
+
+import de.vivi.chess.board.Board;
+import de.vivi.chess.board.Field;
+
+public class Rook extends Piece {
+
+    private boolean isValid = false;
+
+    public Rook(Color color, Type type) {
+        super(color, type);
+    }
+
+    public Rook(Color color, Field field) {
+        super(color, field);
+    }
+
+    public Rook(Color color, Type type, Field field) {
+        super(color, type, field);
+    }
+
+    @Override
+    public char getSymbol() {
+        if (getColor() == Color.WHITE) {
+            if (getType() == Type.ROOK) {
+                symbol = '\u265C';
+            }
+
+        } else if (getColor() == Color.BLACK) {
+            if (getType() == Type.ROOK) {
+                symbol = '\u2656';
+            }
+        }
+        return symbol;
+    }
+
+    @Override
+    public boolean isValidMove(Board board, Field from, Field to) {
+        if (from.getRow() == to.getRow()) {
+            int columnStart = Math.min(from.getColumn(), to.getColumn()) + 1;
+            int columnEnd = Math.max(from.getColumn(), to.getColumn());
+            for (int column = columnStart; column < columnEnd; column++) {
+                if (board.getPiece(Field.from(column, from.getRow())) != null) {
+                    return false;
+                }
+            }
+        } else if (from.getColumn() == to.getColumn()) {
+            int rowStart = Math.min(from.getRow(), to.getRow()) + 1;
+            int rowEnd = Math.max(from.getRow(), to.getRow());
+            for (int row = rowStart; row < rowEnd; row++) {
+                if (board.getPiece(Field.from(from.getColumn(), row)) != null) {
+                    return false;
+                }
+            }
+        } else {
+            return false;
+        }
+
+        Piece destinationPiece = board.getPiece(to);
+        if (destinationPiece == null) {
+            return true;
+        } else if (destinationPiece.getColor() != this.getColor()) {
+            return true;
+        }
+
+        return false;
+    }
+}

chess/src/main/java/de/vivi/chess/pieces/Type.java

@@ -14,4 +14,10 @@ package de.vivi.chess.pieces;
  * - pawn (Bauer)
  */
 public enum Type {
+    KING,
+    QUEEN,
+    BISHOP,
+    KNIGHT,
+    ROOK,
+    PAWN
 }

list/src/main/java/de/vivi/list/ArrayByteList.java

@@ -0,0 +1,88 @@
+package de.vivi.list;
+
+import java.util.*;
+
+public class ArrayByteList implements ByteList {
+
+    private int size = 0;
+    private byte[] values;
+
+    public ArrayByteList() {
+        values = new byte[0];
+    }
+
+    @Override
+    public void add(byte value) {
+        add(size(), value);
+    }
+
+    @Override
+    public void add(int index, byte value) {
+        byte[] newValues = new byte[size() + 1];
+
+        System.arraycopy(values, 0, newValues, 0, index);
+        System.arraycopy(values, index, newValues, index + 1, size() - index);
+
+        newValues[index] = value;
+        values = newValues;
+    }
+
+    @Override
+    public void remove(int index) {
+        byte[] newValues = new byte[size() - 1];
+
+        System.arraycopy(values, 0, newValues, 0, index);
+        System.arraycopy(values, index + 1, newValues, index, size() - index - 1);
+
+        values = newValues;
+    }
+
+    @Override
+    public void set(int index, byte value) {
+        values[index] = value;
+    }
+
+    @Override
+    public byte get(int index) {
+        return values[index];
+    }
+
+    @Override
+    public int size() {
+        return values.length;
+    }
+
+    @Override
+    public boolean contains(int value) {
+        boolean isIndexInArray = false;
+        for (int i = 0; i < values.length; i++) {
+            if (values[i] == value) {
+                isIndexInArray = true;
+            }
+        }
+        return isIndexInArray;
+    }
+
+    @Override
+    public String toString() {
+        return "ArrayByteList " + Arrays.toString(values);
+    }
+
+    @Override
+    public ByteList copy() {
+        ArrayByteList newArrayList = new ArrayByteList();
+        newArrayList.values = Arrays.copyOf(values, values.length);
+        return newArrayList;
+    }
+
+    @Override
+    public void clear() {
+        values = new byte[0];
+    }
+
+    @Override
+    public ArrayByteListIterator iterator() {
+        ArrayByteListIterator it = new ArrayByteListIterator(this);
+        return it;
+    }
+}

list/src/main/java/de/vivi/list/ArrayByteListIterator.java

@@ -0,0 +1,24 @@
+package de.vivi.list;
+
+import java.util.Iterator;
+import java.util.function.Consumer;
+
+public class ArrayByteListIterator implements Iterator<Byte> {
+
+    private ArrayByteList array;
+    private int currentIndex = 0;
+
+    public ArrayByteListIterator(ArrayByteList array) {
+        this.array = array;
+    }
+    
+    @Override
+    public boolean hasNext() {
+        return currentIndex < array.size();
+    }
+
+    @Override
+    public Byte next() {
+        return array.get(currentIndex++);
+    }
+}

list/src/main/java/de/vivi/list/BogoSort.java

@@ -0,0 +1,35 @@
+package de.vivi.list;
+
+import java.util.Random;
+
+public class BogoSort implements ByteSort {
+
+    @Override
+    public ByteList sort(ByteList list) {
+        bogoSort(list);
+        return list;
+    }
+
+    private void bogoSort(ByteList list) {
+        while (isSorted(list) == false) {
+            shuffleList(list);
+        }
+    }
+
+    private void shuffleList(ByteList list) {
+        Random r = new Random();
+        for (int i = list.size() - 1; i > 0; i--) {
+            int j = r.nextInt(i);
+            byte temp = list.get(i);
+            list.set(i, list.get(j));
+            list.set(j, temp);
+        }
+    }
+
+    private boolean isSorted(ByteList list) {
+        for (int i = 1; i < list.size(); i++)
+            if (list.get(i) < list.get(i - 1))
+                return false;
+        return true;
+    }
+}

list/src/main/java/de/vivi/list/BubbleSort.java

@@ -0,0 +1,19 @@
+package de.vivi.list;
+
+public class BubbleSort implements ByteSort {
+
+    @Override
+    public ByteList sort(ByteList list) {
+        int n = list.size();
+
+        for (int i = 0; i < n - 1; i++)
+            for (int j = 0; j < n - i - 1; j++)
+                if (list.get(j) > list.get(j + 1)) {
+                    byte temp = list.get(j);
+                    list.set(j, list.get(j + 1));
+                    list.set(j + 1, temp);
+                }
+
+        return list;
+    }
+}

list/src/main/java/de/vivi/list/ByteList.java

@@ -0,0 +1,24 @@
+package de.vivi.list;
+
+public interface ByteList extends Iterable<Byte> {
+
+    void add(byte value);
+
+    void add(int index, byte value);
+
+    void remove(int index);
+
+    void set(int index, byte value);
+
+    byte get(int index);
+
+    int size();
+
+    boolean contains(int value);
+
+    String toString();
+
+    ByteList copy();
+
+    void clear();
+}

list/src/main/java/de/vivi/list/ByteSort.java

@@ -0,0 +1,6 @@
+package de.vivi.list;
+
+public interface ByteSort {
+
+    ByteList sort(ByteList list);
+}

list/src/main/java/de/vivi/list/CombinedByteList.java

@@ -0,0 +1,59 @@
+package de.vivi.list;
+
+import java.util.Iterator;
+
+public class CombinedByteList implements ByteList {
+    
+    public CombinedByteList(int i) {
+    }
+
+    @Override
+    public void add(byte value) {
+
+    }
+
+    @Override
+    public void add(int index, byte value) {
+        
+    }
+
+    @Override
+    public void remove(int index) {
+
+    }
+
+    @Override
+    public void set(int index, byte value) {
+
+    }
+
+    @Override
+    public byte get(int index) {
+        return 0;
+    }
+
+    @Override
+    public int size() {
+        return 0;
+    }
+
+    @Override
+    public boolean contains(int value) {
+        return false;
+    }
+
+    @Override
+    public ArrayByteList copy() {
+        return null;
+    }
+
+    @Override
+    public void clear() {
+
+    }
+
+    @Override
+    public Iterator<Byte> iterator() {
+        return null;
+    }
+}

list/src/main/java/de/vivi/list/LinkedByteList.java

@@ -0,0 +1,158 @@
+package de.vivi.list;
+
+public class LinkedByteList implements ByteList {
+
+    private NodeLinked currNode;
+    private int size;
+    private NodeLinked last;
+    private NodeLinked first;
+
+    @Override
+    public void add(byte value) {
+        NodeLinked newNode = new NodeLinked(value);
+        if (first == null) {
+            first = newNode;
+        } else {
+            NodeLinked last = first;
+            while (last.next != null) {
+                last = last.next;
+            }
+            last.next = newNode;
+        }
+        size++;
+    }
+
+    @Override
+    public void add(int index, byte value) {
+        if (index == 0) {
+            NodeLinked newNode = new NodeLinked(value);
+            if (size == 0) {
+                last = newNode;
+            } else {
+                newNode.next = first;
+            }
+            first = newNode;
+            size++;
+        } else if (index == size) {
+            NodeLinked newNode = new NodeLinked(value);
+            last.next = newNode;
+            last = newNode;
+            size++;
+        } else {
+            NodeLinked newNode = new NodeLinked(value);
+            NodeLinked prev = getCurrNode(index - 1);
+            newNode.next = prev.next;
+            prev.next = newNode;
+            size++;
+        }
+    }
+
+    @Override
+    public void remove(int index) {
+        NodeLinked current = first;
+        if (index == 0) {
+            size--;
+            first = current.next;
+        }
+
+        NodeLinked temp = null;
+        for (int i = 1; i <= index; i++) {
+            temp = current;
+            current = current.next;
+        }
+
+        temp.next = current.next;
+        size--;
+    }
+
+    @Override
+    public void set(int index, byte value) {
+        NodeLinked x = node(index);
+        x.item = value;
+    }
+
+    NodeLinked node(int index) {
+        NodeLinked current = first;
+        for (int i = 0; i < index; i++) {
+            current = current.next;
+        }
+        return current;
+    }
+
+    @Override
+    public byte get(int index) {
+        return node(index).item;
+    }
+
+    public NodeLinked getCurrNode(int index) {
+        if (index < 0 || index >= size) {
+            return null;
+        }
+        NodeLinked current = first;
+        for (int i = 0; i < index; i++) {
+            current = current.next;
+        }
+        return current;
+    }
+
+    @Override
+    public int size() {
+        return size;
+    }
+
+    @Override
+    public boolean contains(int value) {
+        byte byteValue = (byte) value;
+        boolean isEqual = false;
+        for (int i = 0; i < size; i++) {
+            if (get(i) == byteValue) {
+                isEqual = true;
+                break;
+            } else {
+                isEqual = false;
+            }
+        }
+        return isEqual;
+    }
+
+    @Override
+    public ByteList copy() {
+        LinkedByteList clone = new LinkedByteList();
+        clone.first = clone.last = null;
+        clone.size = 0;
+
+        for (NodeLinked x = first; x != null; x = x.next) {
+            clone.add(x.item);
+        }
+        return clone;
+    }
+
+    @Override
+    public void clear() {
+        for (NodeLinked x = first; x != null;) {
+            NodeLinked next = x.next;
+            x.next = null;
+            x = next;
+        }
+        first = null;
+        size = 0;
+    }
+
+    @Override
+    public LinkedByteListIterator iterator() {
+        LinkedByteListIterator it = new LinkedByteListIterator(this);
+        return it;
+    }
+
+    @Override
+    public String toString() {
+        System.out.println();
+        System.out.println("LinkedList: ");
+        currNode = first;
+        while (currNode != null) {
+            System.out.print(currNode.item + " ");
+            currNode = currNode.next;
+        }
+        return String.valueOf(currNode).replace("null", "");
+    }
+}

list/src/main/java/de/vivi/list/LinkedByteListIterator.java

@@ -0,0 +1,23 @@
+package de.vivi.list;
+
+import java.util.Iterator;
+import java.util.function.Consumer;
+
+public class LinkedByteListIterator implements Iterator<Byte> {
+    private LinkedByteList linkedList;
+    private int currentIndex;
+
+    public LinkedByteListIterator(LinkedByteList linkedList) {
+        this.linkedList = linkedList;
+    }
+
+    @Override
+    public boolean hasNext() {
+        return currentIndex < linkedList.size();
+    }
+
+    @Override
+    public Byte next() {
+        return linkedList.get(currentIndex++);
+    }
+}

list/src/main/java/de/vivi/list/Main.java

@@ -5,17 +5,62 @@ public class Main {
     public static void main(String[] args) {
         ByteList array = new ArrayByteList();
         ByteList linked = new LinkedByteList();
-        ByteList combined = new CombinedByteList(16);
-
+//        ByteList combined = new CombinedByteList(16); // Paul meinte das kann weg gelassen werden
+ //       testListVivi(array);
+//        testListVivi(linked);
+//        testSortVivi(array);
         testList(array);
         testList(linked);
-        testList(combined);
+
+ //       testSortVivi(array);
+ //       testSortVivi(linked);
+//        testList(combined);
 
         testSort(array);
         testSort(linked);
-        testSort(combined);
+//        testSort(combined);
     }
 
+    private static void testListVivi(ByteList list) {
+        list.add((byte) 10);
+        list.add((byte) 5);
+        list.add((byte) -86);
+        list.add((byte) 3);
+
+        list.add(3, (byte) 99);
+        list.add(2, (byte) -40);
+
+        list.remove(2);
+        list.remove(3);
+
+        list.set(1, (byte) 43);
+        list.set(0, (byte) 8);
+
+        list.get(2);
+        list.get(1);
+
+        list.size();
+
+        list.contains(43);
+        list.contains(4);
+
+        String s  = list.toString();
+        System.out.println(s);
+
+        list.copy();
+        System.out.println(list.copy());
+
+//        list.clear();
+ //       System.out.println(list);
+
+        for (byte value : list) {
+            System.out.print(value + " ");
+        }
+
+    }
+
+
+
     private static void testList(ByteList list) {
         // add the element at the end
         list.add((byte) 10);
@@ -62,14 +107,21 @@ public class Main {
 
 
         // remove all elements inside the list
-        list.clear();
+//        list.clear();
 
         // list: []
 
         // allow to use for each loop on list
+//        for (byte value : list) {
+//            // do some stuff with value...
+//        }
+
+        System.out.println();
+        System.out.println("List ");
         for (byte value : list) {
-            // do some stuff with value...
+            System.out.print(value + " ");
         }
+
     }
 
     private static void testSort(ByteList list) {
@@ -78,8 +130,35 @@ public class Main {
         ByteSort bogo = new BogoSort();
 
         // sort the lists with the sorting algorithm
+        System.out.println();
         bubble.sort(list.copy());
+        System.out.println("bubble ");
+        System.out.println(bubble.sort(list.copy()));
+        merge.sort(list.copy());
+        System.out.println("merge ");
+        System.out.println(merge.sort(list.copy()));
+        bogo.sort(list.copy());
+        System.out.println("bogo ");
+        System.out.println(bogo.sort(list.copy()));
+    }
+
+
+
+    private static void testSortVivi(ByteList list) {
+        ByteSort bubble = new BubbleSort();
+        ByteSort merge = new MergeSort();
+        ByteSort bogo = new BogoSort();
+
+        // sort the lists with the sorting algorithm
+        bubble.sort(list.copy());
+        System.out.println();
+        System.out.println();
+        System.out.println("bubblesort " + bubble.sort(list.copy()));
+        System.out.println(merge.sort(list.copy()));
         merge.sort(list.copy());
         bogo.sort(list.copy());
+        System.out.println(bogo.sort(list.copy()));
     }
+
+
 }

list/src/main/java/de/vivi/list/MergeSort.java

@@ -0,0 +1,53 @@
+package de.vivi.list;
+
+
+public class MergeSort implements ByteSort {
+    @Override
+    public ByteList sort(ByteList list) {
+        int mid = list.size() / 2;
+        ByteList leftList = createSubList(list, 0, mid);
+        ByteList rightList = createSubList(list, mid, list.size());
+
+        ByteList mergedList = mergeList(leftList, rightList, mid);
+        sortMergedList(mergedList);
+        return mergedList;
+    }
+
+    private void sortMergedList(ByteList mergedList) {
+        for (int i = 0; i < (mergedList.size() - 1); i++)
+            for (int j = 0; j < mergedList.size() - i - 1; j++)
+                if (mergedList.get(j) > mergedList.get(j + 1)) {
+                    byte temp = mergedList.get(j);
+                    mergedList.set(j, mergedList.get(j + 1));
+                    mergedList.set(j + 1, temp);
+                }
+    }
+
+    private ByteList mergeList(ByteList leftList, ByteList rightList, int mid) {
+        ByteList mergedList = new ArrayByteList();
+        for (int i = 0; i < mid; i++) {
+            mergedList.add(leftList.get(i));
+            mergedList.add(rightList.get(i));
+        }
+        return mergedList;
+    }
+
+    public ByteList createSubList(ByteList list, int start, int end) {
+        ByteList subList = new ArrayByteList();
+        for (int i = start; i < end; i++) {
+            subList.add(list.get(i));
+        }
+        return subList;
+    }
+
+    public ByteList sortSubList(ByteList list, int mid) {
+        for (int i = 0; i < mid - 1; i++)
+            for (int j = 0; j < mid - i - 1; j++)
+                if (list.get(j) > list.get(j + 1)) {
+                    byte temp = list.get(j);
+                    list.set(j, list.get(j + 1));
+                    list.set(j + 1, temp);
+                }
+        return list;
+    }
+}

list/src/main/java/de/vivi/list/NodeLinked.java

@@ -0,0 +1,23 @@
+package de.vivi.list;
+
+public class NodeLinked {
+
+    byte item;
+    NodeLinked next;
+    NodeLinked prev;
+
+    public NodeLinked(NodeLinked prev, byte element, NodeLinked next) {
+        this.item = element;
+        this.next = null;
+        this.prev = null;
+    }
+
+    public NodeLinked(byte element) {
+        this.item = element;
+    }
+
+    public NodeLinked(byte element, NodeLinked next) {
+        this.item = element;
+        this.next = null;
+    }
+}