Untitled

import java.util.Random;
import java.util.Scanner;

public class Main {
    Player[] players;
    Field[] fields;

    public static void main(String[] args) {
        Main newRound = new Main();
        newRound.start();
    }

    public void initializeBoard() {
        char[][] board = new char[13][13];
        // Inicjalizacja planszy całkowicie
        for (int i = 0; i < board.length; i++) {
            for (int j = 0; j < board[i].length; j++) {
                board[i][j] = '-';
            }
        }

        // Inicjalizacja pól do ruchu pionków
        int[][] movePositions = {
                {1,7}, {2,7},{3,7},{4,7},{5,7},
                {5,8}, {5,9},{5,10}, {5,11},
                {6,11}, {7,11},
                {7,10}, {7,9}, {7,8},{7,7},
                {8,7}, {9,7}, {10,7}, {11,7},
                {11,6}, {11,5}, {10,5}, {9,5},
                {8,5}, {7,5}, {7,4}, {7,3},
                {7,2}, {7,1}, {6,1}, {5,1},
                {5,2}, {5,3}, {5,4}, {5,5}, {4,5},
                {3,5}, {2,5}, {1,5}, {1,6}

        };

        fields = new Field[movePositions.length];

        for (int i = 0; i < movePositions.length; i++) {
            int x = movePositions[i][0];
            int y = movePositions[i][1];
            fields[i] = new Field(x, y, i + 1);
            board[x][y] = 'X';
        }

        // Dodawanie pionków do schowka dla każdego gracza
        for (Player player : players) {
            Pawn[] pawns = player.getPawns();
            int[][] hidingPositions = getHidingPositions(player.getSymbol());

            for (int[] position : hidingPositions) {
                int row = position[0];
                int col = position[1];
                board[row][col] = player.getSymbol();
            }
        }

        // Wyświetlanie planszy
        for (int i = 0; i < 13; i++) {
            for (int j = 0; j < 13; j++) {
                System.out.print(board[i][j] + " ");
            }
            System.out.println();
        }
    }

    private int[][] getHidingPositions(char playerSymbol) {
        switch (playerSymbol) {
            case 'a':
                return new int[][]{{1, 10}, {1, 11}, {2, 10}, {2, 11}};
            case 'b':
                return new int[][]{{10, 10}, {10, 11}, {11, 10}, {11, 11}};
            case 'c':
                return new int[][]{{10, 1}, {10, 2}, {11, 1}, {11, 2}};
            case 'd':
                return new int[][]{{1, 1}, {1, 2}, {2, 1}, {2, 2}};
            default:
                return new int[0][0];
        }
    }

    public Field getFieldByNumber(int fieldNumber) {
        for (Field field : fields) {
            if (field.getFieldNumber() == fieldNumber) {
                return field;
            }
        }
        return null;  // zwracamy null jeżeli nie znajdziemy pola o danym numerze
    }

    public void start() {
        Scanner scanner = new Scanner(System.in);

        System.out.println("Wprowadź liczbę graczy: ");
        int numberOfPlayers = scanner.nextInt();

        players = new Player[numberOfPlayers];

        for (int i = 0; i < numberOfPlayers; i++) {
            char playerSymbol = (char) ('a' + i);
            int startPoint = i * 10;

            players[i] = new Player(playerSymbol, startPoint);
        }

        initializeBoard();
        playGame();
    }

    public void playGame() {
        Random random = new Random();
        Scanner scanner = new Scanner(System.in);
        //losowanie gracza ktory rozpocznie jako pierwszy
        System.out.println("Trwa losowanie kto zaczyna ...");

        int firstPlayerIndex = random.nextInt(players.length);
        System.out.println("Rozpoczyna gracz " + players[firstPlayerIndex].getSymbol());

        int currentPlayerIndex = firstPlayerIndex;

        boolean isGameFinished = false; // zmienna logiczna ktora wykorzystam w petli rozgrywki

        while (!isGameFinished) {
            Player currentPlayer = players[currentPlayerIndex];

            int diceRoll = random.nextInt(6)+1;
            int moves = 0;

            // Jezeli obecny gracz ma wszystkie pionki w domku rzuca kostka do 3 rzutow
            while(currentPlayer.allPawnsAtHome() && diceRoll !=6 && moves < 3 ) {
                diceRoll = diceRoll(currentPlayer);
                moves++;
            }

            if (diceRoll == 6 && currentPlayer.allPawnsAtHome()) {
                currentPlayer.getOutFromHome();
            } else {
                if (!(currentPlayer.allPawnsAtHome())) {
                    System.out.println("Wybierz pole pionka, ktorym chcesz wykonac ruch: ");
                    int pawnField = scanner.nextInt();

                    Pawn[] pawns = currentPlayer.getPawns();
                    Pawn selectedPawn = pawns[pawnField-1];
                    int newPosition = (selectedPawn.getPosition() + diceRoll) % 40;
                    selectedPawn.incrementSteps(diceRoll);

                    for (Player player : players) {
                        for (Pawn pawn : player.getPawns()) {
                            if (pawn.getPosition() == newPosition && pawn != selectedPawn) {
                                pawn.setAtHome(true);
                                pawn.setPosition(-1);
                                break;
                            }
                        }
                    }
                    selectedPawn.setPosition(newPosition);
                }
            }

            if (currentPlayer.allPawnsFinished()) {
                isGameFinished = true;
                System.out.println("Gracz " + currentPlayer.getSymbol() + " wygrywa.");
            }

            currentPlayerIndex = (currentPlayerIndex + 1) % players.length; // Przełącz do następnego gracza
        }

    }

    public int diceRoll(Player player) {
        int roll = 0;
        Random random = new Random();
        roll = random.nextInt(6)+1;
        System.out.println("Gracz " + player.getSymbol() + " rzucił " + roll);

        return roll;
    }
}


class Player {
    private char symbol;
    private int startPoint;
    private Pawn[] pawns;

    public Player(char playerSymbol, int playerStartPoint) {
        this.symbol = playerSymbol;
        this.startPoint = playerStartPoint;
        this.pawns = new Pawn[4];
        createPawns();
    }

    private void createPawns() {
        for (int i = 0; i < pawns.length; i++) {
            pawns[i] = new Pawn(symbol);
        }
    }

    public char getSymbol() {
        return symbol;
    }

    public int getStartPoint() {
        return startPoint;
    }

    public Pawn[] getPawns() {
        return pawns;
    }

    public boolean allPawnsAtHome() {
        for (Pawn pawn : pawns) {
            if (!pawn.isAtHome())
                return false;
        }
        return true;
    }

    public void getOutFromHome() {
        for (Pawn pawn : pawns) {
            if (!pawn.isAtHome()) {
                pawn.setAtHome(false);
                pawn.setPosition(startPoint);
                break;
            }
        }
    }
    public boolean allPawnsFinished() {
        for (Pawn pawn : pawns) {
            if (!pawn.isInSafeZone())  // sprawdzamy, czy pionek jest w "domku"
                return false;
        }
        return true;
    }
}


class Pawn {
    private char symbol;
    private int position;
    private boolean isAtHome;
    private int stepsTaken;
    private boolean isFinished;
    private boolean isInSafeZone;

    public Pawn(char symbol) {
        this.symbol = symbol;
        this.position = -1; // pionek jest poza planszą na początku gry
        this.isAtHome = true; // pionek jest w domku na początku gry
        this.isInSafeZone = false;
        this.stepsTaken = 0;
    }

    public char getSymbol() {
        return symbol;
    }

    public int getPosition() {
        return position;
    }

    public void setPosition(int position) {
        this.position = position;
    }

    public boolean isAtHome() {
        return isAtHome;
    }

    public void setAtHome(boolean isAtHome) {
        this.isAtHome = isAtHome;
    }
    public int getStepsTaken() {
        return stepsTaken;
    }
    public void incrementSteps(int steps) {
        stepsTaken += steps;
        if(stepsTaken == 40) {  // jeśli pionek ma wejść do "domku"
            isInSafeZone = true;
        }
    }

    public boolean isInSafeZone() {
        return isInSafeZone;
    }
}


class Field {
    private int x;
    private int y;
    private int fieldNumber;

    public Field(int x, int y, int fieldNumber) {
        this.x = x;
        this.y = y;
        this.fieldNumber = fieldNumber;
    }

    public int getX() {
        return x;
    }

    public void setX(int x) {
        this.x = x;
    }

    public int getY() {
        return y;
    }

    public void setY(int y) {
        this.y = y;
    }

    public int getFieldNumber() {
        return fieldNumber;
    }

    public void setFieldNumber(int fieldNumber) {
        this.fieldNumber = fieldNumber;
    }
}