Морской бой

public class Game {
 
    public static void main(String[] agrs) {
        PlayerManagerInterface playerManager = new ComputerPlayerManager();
 
        while (true) {
            Player currentPlayer = playerManager.getCurrentPlayer();
            Board enemyBoard = currentPlayer.getEnemyBoard();
            enemyBoard.printBoard();
 
            Shot shot = doValidShot(currentPlayer, enemyBoard);
 
            Board goalShot = playerManager.getNotCurrentPlayer().getMyBoard();
            String resultSymbol = goalShot.resultShot(shot);
 
            if (!resultSymbol.equals("")) {
                System.out.println(resultSymbol);
 
                if (enemyBoard.pobeda()) {
                    System.out.println("Victory for Player with "+currentPlayer.getSymbol()+"!");
                    enemyBoard.printBoard();
                    break;
                }
            }
            else playerManager.switchCurrentPlayer();
        }
    }
 
    private static Shot doValidShot(Player currentPlayer,
                                    Board enemyBoard) {
        Shot shot = currentPlayer.doShot();
        while(!enemyBoard.shotValid(shot)) {
            System.out.println("Error shot, repeat!");
            shot = currentPlayer.doShot();
        }
        return shot;
    }
 
}

public class PlayerManager implements PlayerManagerInterface {
 
    private Player player1;
    private Player player2;
    private Player currentPlayer;
 
 
    public PlayerManager() {
        player1 = new Player(Board.ship1);
        player2 = new Player(Board.ship2);
        currentPlayer = player1;
    }
 
    public Player getCurrentPlayer() {
        return currentPlayer;
    }
 
    public Player getNotCurrentPlayer() {
        if(currentPlayer == player1) {
            return player2;
        }
        return player1;
    }
 
    public void switchCurrentPlayer() {
        if(currentPlayer == player1) {
            currentPlayer = player2;
        }
        else currentPlayer = player1;
    }
 
}

import java.util.Scanner;
 
 
public class Player {
    private String symbol;
    private Board myBoard;
    private Board enemyBoard;
 
    public Player(String symbol) {
        this.symbol = symbol;
        this.myBoard = new Board();
        this.enemyBoard = new Board();
 
        myBoard.placeShips(symbol);
        enemyBoard.placeShips();
    }
 
    public String getSymbol() {
        return symbol;
    }
 
    public Board getMyBoard() {
        return myBoard;
    }
 
    public Board getEnemyBoard() {
        return enemyBoard;
    }
 
    public Shot doShot() {
        Scanner in = new Scanner(System.in);
 
        int nextX, nextY;
 
        System.out.println("Ведите координаты x, y Вашего выстрела:");
 
        while (true) {
               System.out.print("x=");
               nextX = in.nextInt();
               if ((nextX >= 0) && (nextX <10)) break;
         }
 
        while (true) {
               System.out.print("y=");
               nextY = in.nextInt();
               if ((nextY >= 0) && (nextY <10)) break;
         }
        System.out.println();
 
        return new Shot(nextX, nextY, this);
    }
}

public class Ship {
    private int firstX, firstY, numberDeck;
    private String direction, state;
 
    public Ship(int numberDeck) {
        this.firstX = 0;
        this.firstY = 0;
        this.direction = "";
        this.numberDeck = numberDeck;
        this.state = "living";
    }
 
    public Ship(int firstX, int firstY, int numberDeck, String direction) {
        this.firstX = firstX;
        this.firstY = firstY;
        this.direction = direction;
        this.numberDeck = numberDeck;
        this.state = "living";
    }
 
    public String getDirection() {
        return direction;
    }
 
    public String getState() {
        return state;
    }
 
    public int getNumberDeck() {
        return numberDeck;
    }
 
     public String changeState(Shot nextShot, Board shotBoard) {
        String resultShot = "";
        int killedDeck = 0;
 
        int shotX = nextShot.getX();
        int shotY = nextShot.getY();
 
        for(int i = 0; i <numberDeck; i++ ) {
            if (direction.equals(">"))
                if((shotX == firstX) && (shotY == (firstY + i)))
                    shotBoard.applyShot(shotX, shotY, shotBoard.killed);
 
            if (direction.equals("v"))
                if((shotX == firstY) && (shotY == (firstX + i)))
                    shotBoard.applyShot(shotX, shotY, shotBoard.killed);
        }
 
        for(int i = 0; i <numberDeck; i++ ) {
            if (direction.equals(">")) {
                if(shotBoard.stateDeck(firstX, firstY + i).equals(shotBoard.killed))
                   killedDeck = killedDeck +1;
            }
 
            if (direction.equals("v")) {
                if(shotBoard.stateDeck(firstX + 1, firstY).equals(shotBoard.killed))
                   killedDeck = killedDeck +1;
            }
 
            if (killedDeck == numberDeck) {
                state = "killed";
                resultShot = state;
            } else if(killedDeck > 0) {
                   state = "injured";
                   resultShot = state;
              }
        }
        return resultShot;
     }
}

public class Shot {
    private int x, y;
    private String symbol;
    private Player player;
 
    public Shot(int x, int y, Player player) {
        this.x = x;
        this.y = y;
        this.player = player;
        this.symbol = player.getSymbol();
    }
 
    public int getX() {
        return x;
    }
 
    public int getY() {
        return y;
    }
 
    public String getSymbol() {
        return symbol;
    }
}

import java.util.*;
 
 
public class Board {
    public static final String empty = ".";
    public static final String killed = "X";
    public static final String slip = "#";
    public static final String ship1 = "O";
    public static final String ship2 = "U";
    private int field_length = 10;
    private String[][] fields;
    private List<Ship> shipArray;
 
 
    public Board() {
        fields = new String[field_length][field_length];
        shipArray = new LinkedList <Ship> ();
        clearFields();
    }
 
    private void clearFields() {
        for (int i = 0; i < field_length; i++) {
            for (int j = 0; j < field_length; j++) {
                fields[i][j] = empty;
            }
        }
    }
 
    public void printBoard() {
        for (int i = 0; i < field_length; i++) {
            for (int j = 0; j < field_length; j++) {
                System.out.print(fields[i][j]+' ');
            }
            System.out.println();
        }
    }
 
    public void placeShips(String symbol) {
        Scanner in = new Scanner(System.in);
 
        int shipX, shipY, shipNumberDeck;
        String shipDirection = "";
 
        for (int i = 0; i < 10;) {
            DecStrategy decStrategy = shipNumberDeckMap.get(i);
            shipNumberDeck = decStrategy.getDecNumber();
            System.out.println("Вводите корабль из " + decStrategy + "-х клеток:");
 
            if (i < 6) System.out.println("Вводите координаты x и y начальной клетки корабля и направление > или v остальных клеток:");
            else System.out.println("Вводите координаты x и y клетки корабля:");
 
            shipX = enterValidXCoordinate(in);
            shipY = enterValidYCoordinate(in, shipX);
            System.out.println();
 
            shipDirection = enterDirection(in, shipDirection, i);
 
            if (shipValidPlace(shipX, shipY, shipDirection, shipNumberDeck)) {
                i = createShip(symbol, shipX, shipY, shipNumberDeck, shipDirection, i);
            }
        }
    }
 
    private int createShip(String symbol, int shipX, int shipY, int shipNumberDeck, String shipDirection, int i) {
        Ship ship = new Ship(shipX, shipY, shipNumberDeck, shipDirection);
 
        shipArray.add(ship);
 
        shipDraw(shipX, shipY, shipDirection, shipNumberDeck, symbol);
 
        printBoard();
 
        i++;
        return i;
    }
 
    private String enterDirection(Scanner in, String shipDirection, int i) {
        if (i < 6) {
            while (true) {
                System.out.print("направление=");
                shipDirection = in.nextLine();
                if (shipDirection.equals(">") || shipDirection.equals("v")) break;
            }
        }
        return shipDirection;
    }
 
    private int enterValidYCoordinate(Scanner in, int shipX) {
        int shipY;
        while (true) {
            System.out.print("y=");
            shipY = in.nextInt();
            if ((shipX >= 0) && (shipX <10)) break;
        }
        return shipY;
    }
 
    private int enterValidXCoordinate(Scanner in) {
        int shipX;
        while (true) {
            System.out.print("x=");
            shipX = in.nextInt();
 
            if ((shipX >= 0) && (shipX <10)) break;
        }
        return shipX;
    }
 
 
    private static interface DecStrategy {
        int getDecNumber();
    }
 
    private static class Dec3Strategy implements DecStrategy {
        @Override
        public int getDecNumber() {
            return 3;
        }
    }
 
    private static class Dec2Strategy implements DecStrategy {
        @Override
        public int getDecNumber() {
            return 2;
        }
    }
    private static class Dec1Strategy implements DecStrategy {
        @Override
        public int getDecNumber() {
            return 1;
        }
    }
 
    private static Map<Integer, DecStrategy> shipNumberDeckMap;
    static {
        shipNumberDeckMap = new HashMap<Integer, DecStrategy>();
 
        shipNumberDeckMap.put(1, new Dec3Strategy());
        shipNumberDeckMap.put(2, new Dec3Strategy());
        shipNumberDeckMap.put(3, new Dec2Strategy());
    }
 
    public void placeShips() {
        int shipNumberDeck;
 
        for (int i = 0; i < 10;) {
            DecStrategy decStrategy = shipNumberDeckMap.get(i);
            shipNumberDeck = decStrategy.getDecNumber();
 
            Ship ship = new Ship(shipNumberDeck);
 
            shipArray.add(ship);
 
            i++;
        }
    }
 
    private boolean shipValidPlace(int shipX, int shipY, String shipDirection, int shipNumberDeck) {
        if (!fields[shipX][shipY].equals(".")) return false;
        else {
            for (int i = 1; i < shipNumberDeck; i++) {
                if (shipDirection.equals(">")) shipX = shipX +1;
                else if (shipDirection.equals("v")) shipY = shipY +1;
 
                if (shipX > 9) return false;
                else if (shipY>9) return false;
                else if (!fields[shipX][shipY].equals(".")) return false;
            }
        }
        return true;
    }
 
    private void shipDraw(int shipX, int shipY, String shipDirection, int shipNumberDeck, String symbol) {
        fields[shipX][shipY] = symbol;
 
        for (int i = 1; i < shipNumberDeck; i++) {
            if (shipDirection.equals(">")) shipX = shipX +1;
            else if (shipDirection.equals("v")) shipY = shipY +1;
 
            fields[shipX][shipY] = symbol;
        }
    }
 
    public boolean pobeda() {
        for(Ship ship : shipArray) {
            String shipState = ship.getState();
 
            if (!shipState.equals("killed")) return false;
        }
        return true;
    }
 
    public boolean shotValid(Shot nextShot) {
        int shotX, shotY;
 
        shotX = nextShot.getX();
        shotY = nextShot.getY();
 
        if (fields[shotX][shotY].equals(killed) || fields[shotX][shotY].equals(slip)) return false;
        return true;
    }
 
    public String resultShot(Shot nextShot) {
        String stateShot = "";
 
        for(Ship ship : shipArray) {
            stateShot = ship.changeState(nextShot, this);
            if (!stateShot.equals("")) return stateShot;
        }
        return stateShot;
    }
 
    public void applyShot(int shotX, int shotY, String resultSymbol) {
        fields[shotX][shotY] = resultSymbol;
    }
 
    public String stateDeck(int shotX, int shotY) {
        return fields[shotX][shotY];
    }
}

public class ComputerPlayerManager implements PlayerManagerInterface{
    @Override
    public Player getCurrentPlayer() {
        return null;  //To change body of implemented methods use File | Settings | File Templates.
    }
 
    @Override
    public Player getNotCurrentPlayer() {
        return null;  //To change body of implemented methods use File | Settings | File Templates.
    }
 
    @Override
    public void switchCurrentPlayer() {
        //To change body of implemented methods use File | Settings | File Templates.
    }
}