Andropov_Vsevolod

README.md

@@ -1,9 +1,25 @@
 # Java Core June 2021
 
-## *Nikolaev Artem*
+### Andropov Vsevolod
 
 | 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 |
+HW1   | [Console printer](./src/main/java/homework_1/Main.java) <br/> [Tests](./src/test/java/homework_1/MainTest.java) | The app that reads input arguments and prints them, until "error" argument |
+HW2.1 | [Traffic Light](./src/main/java/homework_2/traffic_light/) <br/> [Tests](./src/test/java/homework_2/traffic_light/TrafficLightTest.java) | The app that switching colors on different number value (input from keyboard) |
+HW2.2 | [Pyramid Printer](./src/main/java/homework_2/pyramid_printer/) <br/> [Tests](./src/test/java/homework_2/pyramid_printer/PyramidPrinterTest.java) | Printing 'x' Pyramid with the input parameter as Pyramid height |
+HW2.3 | [Random Chars Table](./src/main/java/homework_2/random_chars_table/) <br/> [Tests](./src/test/java/homework_2/random_chars_table/RandomCharsTableTest.java) | The app that creates 2-dimensional array/matrix made of random Character values (from A=65 to Z=90), dimensions set by input from keyboard. Then generating resulting string with even/odd parameter depends on input |
+HW3   | [Immutable Class](./src/main/java/homework_3/ImmutableClass.java) | Create Immutable class: several fields, including reference type; several constructors; method returning a new object. | 
+HW4.1 | [Custom File Reader](./src/main/java/homework_4/custom_file_reader/) <br/> [Tests](./src/test/java/homework_4/custom_file_reader/CustomFileReaderTest.java) | App reading data from file and prints to console. Text file path: main/resources/custom_file_reader/. Reading file in 4 different ways (one of them using NIO) executable with methods: run1(), run2(), run3(), run4() |
+HW4.2 | [Singleton](./src/main/java/homework_4/singleton/) <br/> [Tests](./src/test/java/homework_4/singleton/SingletonMenuTest.java) | Singleton App: private constructor and public method getInstance() |
+HW4.3 | [Custom Annotation](./src/main/java/homework_4/custom_annotation/) <br/> [Tests](./src/test/java/homework_4/custom_annotation/ResourcesPathTest.java) | Custom annotation class. |
+HW5.1 | [Power Of Number](./src/main/java/homework_5/power_of_number/) <br/> [Tests](./src/test/java/homework_5/power_of_number/PowerOfNumberTest.java) | Power of number recursion using App. Reads 2 non-negative integer numbers from console and prints out the result of exponentiation. Only for positive integer numbers. On any problem output message will be gotten: "Only 2 non-negative integers are allowed"  |
+HW5.2 | [Custom Regex Matcher](./src/main/java/homework_5/custom_regex_matcher/) <br/> [Tests](./src/test/java/homework_5/custom_regex_matcher/CustomRegexMatcherTest.java) | App reads input from keyboard and print true or false for the input matching to the hardcoded regex format. |
+HW6 | [MapProblemsGenerator](./src/main/java/homework_6/map_problems_collision_generator/) | App which has: <br/> 1) Class creating 100% HashMap collisions <br/> 2) Mutable class with overridden HashCode/Equals. When put MutableClass object into HashMap as key - can't retrieve it (equals works correctly) |
+HW7 | [Kitten to Cat](./src/main/java/homework_7/kitten_to_cat/) <br/> [Tests](./src/test/java/homework_7/kitten_to_cat/KittenToCatTest.java) | App using Functional Interface KittenToCatFunction with abstract method grow(). Realization in Main class through lambda function |
+Course project | [Sea Battle](./src/main/java/course_project/) | Sea Battle console game |
 
-[Link to markdown giude](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet)
+<br>
+
+___
+
+[codingbat profile](https://codingbat.com/done?user=devngrow@gmail.com&tag=1205090974) `done`

build.gradle

@@ -10,8 +10,16 @@ repositories {
 }
 
 dependencies {
-    testImplementation 'org.junit.jupiter:junit-jupiter-api:5.7.0'
-    testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.7.0'
+    implementation 'org.junit.jupiter:junit-jupiter:5.7.2'
+    implementation 'org.jetbrains:annotations:22.0.0'
+    testImplementation 'org.junit.jupiter:junit-jupiter-api:5.7.2'
+    testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.7.2'
+
+    // lombok
+    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,11 @@
+package course_project;
+
+import course_project.services.SeaBattle;
+
+public class Main {
+
+    public static void main(String[] args) {
+        SeaBattle.getInstance().run();
+    }
+
+}

src/main/java/course_project/gamestuff/field/Battlefield.java

@@ -0,0 +1,112 @@
+package course_project.gamestuff.field;
+
+import course_project.gamestuff.player.Player;
+import course_project.gamestuff.ships.*;
+
+import java.util.Collection;
+import java.util.LinkedList;
+
+import static course_project.services.conversation.DialogueMenu.*;
+import static course_project.utils.AroundDestroyedShipMarker.*;
+import static course_project.utils.RandomCellPositionGenerator.generateRandomForCell;
+import static course_project.utils.RandomShipDirectionGenerator.generateRandomDirection;
+import static course_project.utils.ShipOnBattlefieldPlacer.*;
+
+/**
+ * Battlefield is Field for the Player(owner) of this object.
+ */
+public class Battlefield extends Field {
+
+    private final Collection<Ship> availableShips;
+
+    public Battlefield() {
+        super();
+        this.availableShips = new LinkedList<>();
+        initAvailableShips();
+    }
+
+    private void initAvailableShips() {
+        availableShips.add(new ExtraLargeShip());
+        availableShips.add(new LargeShip());
+        availableShips.add(new LargeShip());
+        availableShips.add(new MiddleShip());
+        availableShips.add(new MiddleShip());
+        availableShips.add(new MiddleShip());
+        availableShips.add(new SmallShip());
+        availableShips.add(new SmallShip());
+        availableShips.add(new SmallShip());
+        availableShips.add(new SmallShip());
+    }
+
+    public Collection<Ship> getAvailableShips() {
+        return this.availableShips;
+    }
+
+    public boolean addShipOnBattlefield(Ship ship, Cell toCell, boolean isHorizontal) {
+        if (isEnoughSpaceToPlaceShip(toCell, ship.getSize(), isHorizontal)) {
+            return isHorizontal ?
+                    addRowOfCells(this, toCell, ship) :
+                    addColumnOfCells(this, toCell, ship);
+        }
+        return false;
+    }
+
+    // onDestroy
+    public void availableShipsDecrease(Ship ship) {
+        this.availableShips.remove(ship);
+    }
+
+    public boolean hasAvailableShips() {
+        return countOfAvailableShips() > 0;
+    }
+
+    public int countOfAvailableShips() {
+        return this.availableShips.size();
+    }
+
+    public static void addShipsManually(Player currentPlayer) {
+        printPlayerShipPlacingHelp();
+        currentPlayer.getField().getAvailableShips().forEach(ship -> {
+                    currentPlayer.getField().printField();
+                    Cell toPos;
+                    boolean isHorizontal = true;
+                    do {
+                        printSetPositionMessage(ship.getName(), ship.getSize());
+                        String[] pos = getShipPlacingInput().split(" ");
+                        int x = Integer.parseInt(pos[0].substring(1)) - 1;
+                        int y = Integer.parseInt(String.valueOf(pos[0].charAt(0) - LOWERCASE_A));
+                        toPos = currentPlayer.getField().getCellByPosition(x, y);
+                        if (pos.length == 2) {
+                            isHorizontal = "h".equals(pos[1]);
+                        }
+                    } while (!currentPlayer.getField().addShipOnBattlefield(ship, toPos, isHorizontal));
+                }
+        );
+    }
+
+    public static void addShipsAuto(Player currentPlayer) {
+        currentPlayer.getField().getAvailableShips().forEach(ship -> {
+                    Cell toPos;
+                    boolean isHorizontal;
+                    do {
+                        toPos = currentPlayer.getField().getCellByPosition(generateRandomForCell(),
+                                generateRandomForCell());
+                        isHorizontal = generateRandomDirection();
+                    } while (!currentPlayer.getField().addShipOnBattlefield(ship, toPos, isHorizontal));
+                }
+        );
+    }
+
+    public void setAroundShipCellsAsHit(Player currentPlayer, Ship ship) {
+        if (ship.getSize() == 1) {
+            fillAroundSmallShip(currentPlayer, ship);
+        } else {
+            if (ship.isHorizontal()) {
+                fillAroundHorizontalShip(currentPlayer, ship);
+            } else {
+                fillAroundVerticalShip(currentPlayer, ship);
+            }
+        }
+    }
+
+}

src/main/java/course_project/gamestuff/field/Cell.java

@@ -0,0 +1,47 @@
+package course_project.gamestuff.field;
+
+import course_project.gamestuff.ships.Ship;
+
+public class Cell {
+
+    private final int x;
+    private final int y;
+    private Ship ref;
+    private boolean hit; // stores state of cell: if motion to this cell was made
+
+    public Cell(int x, int y) {
+        this.x = x;
+        this.y = y;
+        this.ref = null;
+        this.hit = false;
+    }
+
+    public boolean isHit() {
+        return this.hit;
+    }
+
+    public void setHit(boolean hit) {
+        this.hit = hit;
+    }
+
+    public Ship isShipPlacedAtCell() {
+        return this.ref == null ? null : ref;
+    }
+
+    public void placeShipOnCell(Ship ship) {
+        this.ref = ship;
+    }
+
+    public int getX() {
+        return this.x;
+    }
+
+    public int getY() {
+        return this.y;
+    }
+
+    public Ship getRef() {
+        return this.ref;
+    }
+
+}

src/main/java/course_project/gamestuff/field/Field.java

@@ -0,0 +1,140 @@
+package course_project.gamestuff.field;
+
+import course_project.gamestuff.player.Player;
+
+import static homework_2.Colors.*;
+
+public abstract class Field {
+
+    public static final int FIELD_SIZE = 10;
+    public static final int LOWERCASE_A = 'a';
+    private static final String WATER = BLUE_BG + " " + ANSI_RESET;
+    private static final String DESTROYED = ANSI_RED + "†" + ANSI_RESET;
+    private static final String HIT = ANSI_RED + "X" + ANSI_RESET;
+    private static final String MISS = ANSI_YELLOW + "O" + ANSI_RESET;
+    private static final String SHIP = ANSI_GREEN + "¤" + ANSI_RESET;
+    private static final char FIRST_SYMBOL_TOP_LINE = 'A';
+    private static final String TOP_LINE;
+    private static final String CELL_FORMAT = "%s   ";
+    private static final String ROW_NUMBER_FORMAT = "[%-2d]";
+
+    private final Cell[][] cells;
+
+    protected Field() {
+        this.cells = new Cell[FIELD_SIZE][FIELD_SIZE];
+        fillCellsWithIndexes();
+    }
+
+    static {
+        StringBuilder stringBuilder = new StringBuilder();
+        for (int i = FIRST_SYMBOL_TOP_LINE; i < FIRST_SYMBOL_TOP_LINE + FIELD_SIZE; i++) {
+            stringBuilder
+                    .append((char) i)
+                    .append("   ");
+        }
+        TOP_LINE = stringBuilder.toString().trim();
+    }
+
+    private void fillCellsWithIndexes() {
+        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 oneField = new StringBuilder();
+        oneField
+                .append("\t")
+                .append(TOP_LINE)
+                .append("\n");
+        for (int i = 0; i < FIELD_SIZE; i++) {
+            oneField.append(String.format(ROW_NUMBER_FORMAT, i + 1));
+            for (int j = 0; j < FIELD_SIZE; j++) {
+                Cell currentCell = getCellByPosition(i, j);
+                String toPrint = WATER;
+                if (!isCellEmpty(currentCell)) {
+                    toPrint = SHIP;
+                }
+                oneField.append(String.format(CELL_FORMAT, toPrint));
+            }
+            oneField.append("\n");
+        }
+        System.out.println(oneField);
+    }
+
+    public void printBothFields(Player currentPlayer, Player enemy) {
+        StringBuilder bothFields = new StringBuilder();
+        bothFields
+                .append("\t")
+                .append(TOP_LINE)
+                .append("\t\t\t\t")
+                .append(TOP_LINE)
+                .append("\n");
+        for (int i = 0; i < FIELD_SIZE; i++) {
+            bothFields.append(String.format(ROW_NUMBER_FORMAT, i + 1));
+            for (int j = 0; j < FIELD_SIZE; j++) {
+                Cell currentPlayerCell = currentPlayer.getField().getCellByPosition(i, j);
+                if (currentPlayerCell.isHit()) {
+                        bothFields
+                                .append(getCellStateAsString(currentPlayer, currentPlayerCell));
+                } else {
+                    if (currentPlayer.getField().isCellEmpty(currentPlayerCell)) {
+                        bothFields
+                                .append(String.format(CELL_FORMAT, WATER));
+                    } else {
+                        bothFields
+                                .append(String.format(CELL_FORMAT, SHIP));
+                    }
+                }
+            }
+            bothFields
+                    .append("\t\t")
+                    .append(String.format(ROW_NUMBER_FORMAT, i + 1));
+            for (int j = 0; j < FIELD_SIZE; j++) {
+                Cell currentEnemyCell = enemy.getField().getCellByPosition(i, j);
+                if (currentEnemyCell.isHit()) {
+                    bothFields
+                            .append(getCellStateAsString(enemy, currentEnemyCell));
+                } else {
+                    bothFields
+                            .append(String.format(CELL_FORMAT, WATER));
+                }
+            }
+            bothFields.append("\n");
+        }
+        System.out.println(bothFields);
+    }
+
+    private String getCellStateAsString(Player currentPlayer, Cell playersCell) {
+        if (currentPlayer.getField().getHit(playersCell)) {
+            if (playersCell.getRef().isShipDestroyed()) {
+                return String.format(CELL_FORMAT, DESTROYED);
+            } else {
+                return String.format(CELL_FORMAT, HIT);
+            }
+        }
+        return String.format(CELL_FORMAT, MISS);
+    }
+
+    public Cell getCellByPosition(int x, int y) {
+        for (Cell[] cellRow : this.cells) {
+            for (Cell cellCol : cellRow) {
+                if (cellCol.getX() == x && cellCol.getY() == y) {
+                    return cellCol;
+                }
+            }
+        }
+        return null;
+    }
+
+    public boolean isCellEmpty(Cell currentCell) {
+        return currentCell.isShipPlacedAtCell() == null;
+    }
+
+    public boolean getHit(Cell toCell) {
+        return !isCellEmpty(cells[toCell.getX()][toCell.getY()]);
+    }
+
+}

src/main/java/course_project/gamestuff/player/Player.java

@@ -0,0 +1,29 @@
+package course_project.gamestuff.player;
+
+import course_project.gamestuff.field.Battlefield;
+
+public class Player {
+
+    private final boolean computer;
+    private final String name;
+    private final Battlefield battlefield;
+
+    public Player(String name, boolean isComputer) {
+        this.computer = isComputer;
+        this.name = name;
+        this.battlefield = new Battlefield();
+    }
+
+    public boolean isComputer() {
+        return this.computer;
+    }
+
+    public String getName() {
+        return this.name;
+    }
+
+    public Battlefield getField() {
+        return this.battlefield;
+    }
+
+}