Ilia_Prokofev

README.md

@@ -1,9 +1,21 @@
 # Java Core June 2021
 
-## *Nikolaev Artem*
+## *Prokofev Ilia*
 
-| Number | Solution  | Short description
-| --- | --- | --- |
-| HW1 | [Console printer](https://github.com/NikolaevArtem/Java_Core_June_2021/tree/master/src/main/java/homework_1) | The app that reads input arguments and prints them, until "error" argument |
+| Index | Solution  | Short description|
+| :---: | --- | --- |
+|**Course Project**|[Sea Battle](https://github.com/NikolaevArtem/Java_Core_June_2021/tree/feature/IliaProkofev/src/main/java/course_project)|Console version of the classic Sea Battle game with graphical representation|
+| HW1 | [Console printer](https://github.com/NikolaevArtem/Java_Core_June_2021/tree/feature/IliaProkofev/src/main/java/homework_1) <br> [Test](https://github.com/NikolaevArtem/Java_Core_June_2021/tree/feature/IliaProkofev/src/test/java/homework_1/char_count) | The app that reads input arguments and prints them, until "error" argument |
+|-----| [Traffic Light](https://github.com/NikolaevArtem/Java_Core_June_2021/tree/feature/IliaProkofev/src/main/java/homework_2/traffic_light) <br> [Test](https://github.com/NikolaevArtem/Java_Core_June_2021/tree/feature/IliaProkofev/src/test/java/homework_2/traffic_light) | The app that reads console and calculate current traffic light's color |
+| HW2 | [Pyramid Printer](https://github.com/NikolaevArtem/Java_Core_June_2021/tree/feature/IliaProkofev/src/main/java/homework_2/pyramid_printer) <br> [Test](https://github.com/NikolaevArtem/Java_Core_June_2021/tree/feature/IliaProkofev/src/test/java/homework_2/pyramid_printer) | The app that reads console and prints a pyramid based on this  |
+|-----| [Random Chars Table](https://github.com/NikolaevArtem/Java_Core_June_2021/tree/feature/IliaProkofev/src/main/java/homework_2/random_chars_table) <br> [Test](https://github.com/NikolaevArtem/Java_Core_June_2021/tree/feature/IliaProkofev/src/test/java/homework_2/random_chars_table) | The app that reads console for length, width and strategy and prints table based on this|
+| HW3 | [Immutable Class](https://github.com/NikolaevArtem/Java_Core_June_2021/tree/feature/IliaProkofev/src/main/java/homework_3) | The class that give opportunity for create Immutable object|
+|-----| [Custom Annotation](https://github.com/NikolaevArtem/Java_Core_June_2021/tree/feature/IliaProkofev/src/main/java/homework_4/custom_annotation) <br> [Test](https://github.com/NikolaevArtem/Java_Core_June_2021/tree/feature/IliaProkofev/src/test/java/homework_4/custom_annotation) | A form of syntactic metadata that can be added to Java source code|
+| HW4 | [Custom File Reader](https://github.com/NikolaevArtem/Java_Core_June_2021/tree/feature/IliaProkofev/src/main/java/homework_4/custom_file_reader) <br> [Test](https://github.com/NikolaevArtem/Java_Core_June_2021/tree/feature/IliaProkofev/src/test/java/homework_4/custom_file_reader) | The app that provides 3 ways to read and edit a file|
+|-----| [Singleton](https://github.com/NikolaevArtem/Java_Core_June_2021/tree/feature/IliaProkofev/src/main/java/homework_4/singleton) <br> [Test](https://github.com/NikolaevArtem/Java_Core_June_2021/tree/feature/IliaProkofev/src/test/java/homework_4/singleton) | Creational design pattern, which ensures that only one object of its kind exists |
+| HW5 | [PowerOfNumber](https://github.com/NikolaevArtem/Java_Core_June_2021/tree/feature/IliaProkofev/src/main/java/homework_5/power_of_number) <br> [Test](https://github.com/NikolaevArtem/Java_Core_June_2021/tree/feature/IliaProkofev/src/test/java/homework_5/power_of_number) | The app that raises a number to a power  |
+|-----| [CustomRegexMatcher](https://github.com/NikolaevArtem/Java_Core_June_2021/tree/feature/IliaProkofev/src/main/java/homework_5/custom_regex_matcher) <br> [Test](https://github.com/NikolaevArtem/Java_Core_June_2021/tree/feature/IliaProkofev/src/test/java/homework_5/custom_regex_matcher) | The app that check input string by hardcoded regex and return boolean answer |
+| HW6 | [MapProblemsGenerator](https://github.com/NikolaevArtem/Java_Core_June_2021/tree/feature/IliaProkofev/src/main/java/homework_6/map_problems_generator)|Two classes that allow you to check the work of the collision and create a situation where it is impossible to get the object just put|
+| HW7 | [KittenToCatFunction](https://github.com/NikolaevArtem/Java_Core_June_2021/tree/feature/IliaProkofev/src/main/java/homework_7)|Functional interface that allows you to transform a Kitten into a Cat|
 
-[Link to markdown giude](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet)
+[CodingBat link](https://codingbat.com/done?user=slowly@live.ru&tag=8165639202)

build.gradle

@@ -12,6 +12,12 @@ repositories {
 dependencies {
     testImplementation 'org.junit.jupiter:junit-jupiter-api:5.7.0'
     testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.7.0'
+
+    compileOnly 'org.projectlombok:lombok:1.18.20'
+    annotationProcessor 'org.projectlombok:lombok:1.18.20'
+
+    testCompileOnly 'org.projectlombok:lombok:1.18.20'
+    testAnnotationProcessor 'org.projectlombok:lombok:1.18.20'
 }
 
 test {

src/main/java/course_project/Main.java

@@ -0,0 +1,8 @@
+package course_project;
+
+public class Main {
+
+    public static void main(String[] args)  {
+       SeaBattle.initializeGame();
+    }
+}

src/main/java/course_project/SeaBattle.java

@@ -0,0 +1,12 @@
+package course_project;
+
+import course_project.dialogue.Menu;
+
+final class SeaBattle {
+
+    public static void initializeGame() {
+        Menu.showLogo();
+        Menu.showGreetings();
+        Menu.showMainMenu();
+    }
+}

src/main/java/course_project/board/Battlefield.java

@@ -0,0 +1,207 @@
+package course_project.board;
+
+import course_project.player.Player;
+import course_project.ships.*;
+
+import java.util.*;
+
+import static course_project.dialogue.Menu.*;
+import static course_project.utils.RandomPositionGenerator.generateRandomForCell;
+import static course_project.utils.RandomDirectionGenerator.generateRandomDirection;
+
+public class Battlefield extends Board {
+
+    private final List<Ship> availableShips = new ArrayList<>();
+
+    public Battlefield() {
+        super.cells = new Cell[FIELD_SIZE][FIELD_SIZE];
+        fillCells();
+        addShipsToList();
+    }
+
+    public List<Ship> getAvailableShips() {
+        return this.availableShips;
+    }
+
+    public void addShipsToList() {
+        availableShips.add(new Battleship());
+        availableShips.add(new Destroyer());
+        availableShips.add(new Destroyer());
+        availableShips.add(new Cruiser());
+        availableShips.add(new Cruiser());
+        availableShips.add(new Cruiser());
+        availableShips.add(new PatrolBoat());
+        availableShips.add(new PatrolBoat());
+        availableShips.add(new PatrolBoat());
+        availableShips.add(new PatrolBoat());
+    }
+
+    public boolean addShipOnBattlefield(Ship ship, Cell cell, boolean isHorizontal) {
+        if (checkSpaceForPlaceShip(cell, ship.getSize(), isHorizontal)) {
+            if (isHorizontal) {
+                return !addRowOfCells(cell, ship);
+            } else {
+                return !addColumnOfCells(cell, ship);
+            }
+        }
+        return true;
+    }
+
+    public void availableShipsDecrease(Ship ship) {
+        this.availableShips.remove(ship);
+    }
+
+    private boolean addColumnOfCells(Cell entryCell, Ship ship) {
+        if (checkPossibilityForAddColumn(entryCell, ship.getSize())) {
+            int y = entryCell.getY();
+            for (int i = entryCell.getX(); i < entryCell.getX() + ship.getSize(); i++) {
+                getCellByPosition(i, y).setShipAtCell(ship);
+            }
+            return true;
+        }
+        return false;
+    }
+
+    private boolean addRowOfCells(Cell entryCell, Ship ship) {
+        if (checkPossibilityForAddRow(entryCell, ship.getSize())) {
+            int x = entryCell.getX();
+            for (int j = entryCell.getY(); j < entryCell.getY() + ship.getSize(); j++) {
+                getCellByPosition(x, j).setShipAtCell(ship);
+            }
+            return true;
+        }
+        return false;
+    }
+
+    private boolean checkPossibilityForAddColumn(Cell entryCell, int shipSize) {
+        if (!(checkCellAbove(entryCell) &&
+                checkCellAboveLeftDiagonal(entryCell) &&
+                checkCellAboveRightDiagonal(entryCell))) {
+            return false;
+        }
+        int y = entryCell.getY();
+        for (int i = entryCell.getX(); i < entryCell.getX() + shipSize; i++) {
+            Cell currentCell = cells[i][y];
+            if (!(isCellEmpty(currentCell) &&
+                    checkCellBelow(currentCell) &&
+                    checkCellOnTheLeft(currentCell) &&
+                    checkCellOnTheRight(currentCell))) {
+                return false;
+            }
+            if (i == entryCell.getX() + shipSize - 1 &&
+                    !(checkCellBelowLeftDiagonal(currentCell) &&
+                            checkCellBelowRightDiagonal(currentCell))
+            ) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    private boolean checkPossibilityForAddRow(Cell entryCell, int shipSize) {
+        if (!(checkCellOnTheLeft(entryCell) &&
+                checkCellAboveLeftDiagonal(entryCell) &&
+                checkCellBelowLeftDiagonal(entryCell) &&
+                checkCellAboveRightDiagonal(entryCell))
+        ) {
+            return false;
+        }
+        int x = entryCell.getX();
+        for (int j = entryCell.getY(); j < entryCell.getY() + shipSize; j++) {
+            Cell currentCell = cells[x][j];
+            if (!(isCellEmpty(currentCell) &&
+                    checkCellOnTheRight(currentCell) &&
+                    checkCellAbove(currentCell) &&
+                    checkCellBelow(currentCell))
+            ) {
+                System.out.println("Cannot set the ship to coordinates " + Character.toUpperCase((char) (entryCell.getY() + 97)) + "" + (entryCell.getX() + 1) + ", check if the ship is in contact with another.\n");
+                return false;
+            }
+            if (j == entryCell.getY() + shipSize - 1 &&
+                    !(checkCellAboveRightDiagonal(currentCell) &&
+                            checkCellBelowRightDiagonal(currentCell))
+            ) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    private boolean checkSpaceForPlaceShip(Cell fromCell, int shipSize, boolean isHorizontal) {
+        return isHorizontal ?
+                fromCell.getY() >= 0 && fromCell.getY() + shipSize <= FIELD_SIZE :
+                fromCell.getX() >= 0 && fromCell.getX() + shipSize <= FIELD_SIZE;
+    }
+
+    private boolean checkCellAbove(Cell currentCell) {
+        return currentCell.getX() == 0 || isCellEmpty(cells[currentCell.getX() - 1][currentCell.getY()]);
+    }
+
+    private boolean checkCellBelow(Cell currentCell) {
+        return currentCell.getX() == 9 || isCellEmpty(cells[currentCell.getX() + 1][currentCell.getY()]);
+    }
+
+    private boolean checkCellOnTheRight(Cell currentCell) {
+        return currentCell.getY() == 9 || isCellEmpty(cells[currentCell.getX()][currentCell.getY() + 1]);
+    }
+
+    private boolean checkCellOnTheLeft(Cell currentCell) {
+        return currentCell.getY() == 0 || isCellEmpty(cells[currentCell.getX()][currentCell.getY() - 1]);
+    }
+
+    private boolean checkCellAboveLeftDiagonal(Cell currentCell) {
+        return currentCell.getX() == 0 || currentCell.getY() == 0 ||
+                isCellEmpty(cells[currentCell.getX() - 1][currentCell.getY() - 1]);
+    }
+
+    private boolean checkCellBelowLeftDiagonal(Cell currentCell) {
+        return currentCell.getX() == 9 || currentCell.getY() == 0 ||
+                isCellEmpty(cells[currentCell.getX() + 1][currentCell.getY() - 1]);
+    }
+
+    private boolean checkCellAboveRightDiagonal(Cell currentCell) {
+        return currentCell.getX() == 0 || currentCell.getY() == 9 ||
+                isCellEmpty(cells[currentCell.getX() - 1][currentCell.getY() + 1]);
+    }
+
+    private boolean checkCellBelowRightDiagonal(Cell currentCell) {
+        return currentCell.getX() == 9 || currentCell.getY() == 9 ||
+                isCellEmpty(cells[currentCell.getX() + 1][currentCell.getY() + 1]);
+    }
+
+
+    public boolean hasAvailableShips() {
+        return !this.availableShips.isEmpty();
+    }
+
+    public static void addShipsOneByOne(Player currentPlayer) {
+        showHelp();
+        for (Ship ship : currentPlayer.getField().getAvailableShips()) {
+            currentPlayer.getField().printField();
+            Cell position;
+            boolean isHorizontal = true;
+            do {
+                System.out.print("Ship's type: " + ship.getName() + ". Size: " + ship.getSize() + ". Specify coordinates: ");
+                String[] cellPossition = getInputPosition().split(" ");
+                int x = Integer.parseInt(cellPossition[0].substring(1)) - 1;
+                int y = Integer.parseInt(String.valueOf(cellPossition[0].charAt(0) - 97));
+                position = currentPlayer.getField().getCellByPosition(x, y);
+                if (cellPossition.length == 2) {
+                    isHorizontal = !"v".equals(cellPossition[1]);
+                }
+            } while (currentPlayer.getField().addShipOnBattlefield(ship, position, isHorizontal));
+        }
+    }
+
+    public static void generateRandomPlacesForShips(Player currentPlayer) {
+        for (Ship ship : currentPlayer.getField().getAvailableShips()) {
+            Cell toPos;
+            boolean isHorizontal;
+            do {
+                toPos = currentPlayer.getField().getCellByPosition(generateRandomForCell(),
+                        generateRandomForCell());
+                isHorizontal = generateRandomDirection();
+            } while (currentPlayer.getField().addShipOnBattlefield(ship, toPos, isHorizontal));
+        }
+    }
+}

src/main/java/course_project/board/Board.java

@@ -0,0 +1,113 @@
+package course_project.board;
+
+import course_project.player.Player;
+
+import static course_project.utils.Colors.*;
+
+public class Board {
+
+    public static final int FIELD_SIZE = 10;
+    private static final String SHIP = ANSI_GREEN + "■" + ANSI_RESET;
+    private static final String WATER = "~";
+    private static final String MISS = ANSI_MAGENTA + "▓" + ANSI_RESET;
+    private static final String HIT = ANSI_YELLOW + "×" + ANSI_RESET;
+    private static final String DESTROY = ANSI_RED + "*" + ANSI_RESET;
+
+    Cell[][] cells;
+
+    protected Board() {
+        this.cells = new Cell[FIELD_SIZE][FIELD_SIZE];
+        fillCells();
+    }
+
+    public void fillCells() {
+        for (int i = 0; i < FIELD_SIZE; i++) {
+            for (int j = 0; j < FIELD_SIZE; j++) {
+                cells[i][j] = new Cell(i, j);
+            }
+        }
+    }
+
+    public void printField() {
+        StringBuilder field = new StringBuilder();
+        field.append("\t" + "A   B   C   D   E   F   G   H   I   J").append("\n");
+
+        for (int i = 0; i < FIELD_SIZE; i++) {
+            field.append(String.format("|%-2d|", i + 1));
+            for (int j = 0; j < FIELD_SIZE; j++) {
+                Cell currentCell = getCellByPosition(i, j);
+                String symbol = WATER;
+                if (!isCellEmpty(currentCell)) {
+                    symbol = SHIP;
+                }
+                field.append(String.format("%s   ", symbol));
+            }
+            field.append("\n");
+        }
+        System.out.println(field);
+    }
+
+    public void showTwoFields(Player currentPlayer, Player enemy) {
+
+        StringBuilder twoFields = new StringBuilder();
+
+        twoFields.append("\t" + "A   B   C   D   E   F   G   H   I   J").append("\t\t\t    " + "A   B   C   D   E   F   G   H   I   J").append("\n");
+
+        for (int i = 0; i < FIELD_SIZE; i++) {
+            twoFields.append(String.format("|%-2d|", i + 1));
+            for (int j = 0; j < FIELD_SIZE; j++) {
+                if (currentPlayer.getField().getCellByPosition(i, j).isHit()) {
+                    checkCellStateAndMarkIt(currentPlayer, twoFields, i, j);
+                } else {
+                    if (currentPlayer.getField().isCellEmpty(currentPlayer.getField().getCellByPosition(i, j))) {
+                        twoFields.append(String.format("%s   ", WATER));
+                    } else {
+                        twoFields.append(String.format("%s   ", SHIP));
+                    }
+                }
+            }
+            twoFields.append("\t\t").append(String.format("|%-2d|", i + 1));
+            for (int j = 0; j < FIELD_SIZE; j++) {
+                if (enemy.getField().getCellByPosition(i, j).isHit()) {
+                    checkCellStateAndMarkIt(enemy, twoFields, i, j);
+                } else {
+                    twoFields.append(String.format("%s   ", WATER));
+                }
+            }
+            twoFields.append("\n");
+        }
+        System.out.println(twoFields);
+    }
+
+    private void checkCellStateAndMarkIt(Player currentPlayer, StringBuilder bothFields, int i, int j) {
+        if (currentPlayer.getField().isHit(currentPlayer.getField().getCellByPosition(i, j))) {
+            if (currentPlayer.getField().getCellByPosition(i, j).getReference().isDestroyed()) {
+                bothFields.append(String.format("%s   ", DESTROY));
+            } else {
+                bothFields.append(String.format("%s   ", HIT));
+            }
+        } else {
+            bothFields.append(String.format("%s   ", MISS));
+        }
+    }
+
+    public Cell getCellByPosition(int x, int y) {
+        for (Cell[] cellRow : this.cells) {
+            for (Cell cellColumn : cellRow) {
+                if (cellColumn.getX() == x && cellColumn.getY() == y) {
+                    return cellColumn;
+                }
+            }
+        }
+        return null;
+    }
+
+    public boolean isCellEmpty(Cell currentCell) {
+        return currentCell.getShipReference() == null;
+    }
+
+    public boolean isHit(Cell toCell) {
+        return !isCellEmpty(cells[toCell.getX()][toCell.getY()]);
+    }
+
+}