boolean gelukt=false;

        int category;

        while(gelukt == false){
            System.out.println("Kies een categorie d.m.v. het bijhorende nummer.\n" +
                        "0. Ones\n" +
                        "1. Twos\n" +
                        "2. Threes\n" +
                        "3. Fours\n" +
                        "4. Fives\n" +
                        "5. Sixes\n" +
                        "6. Three of a Kind\n" +
                        "7. Four of a Kind\n" +
                        "8. Full House\n" +
                        "9. Small Straight\n" +
                        "10. Large Straight\n" +
                        "11. Yahtzee!\n" +
                        "12. Chance");
                Scanner scan = new Scanner(System.in);
                category = scan.nextInt();

                gelukt = assignThrow(roll, posCategories[category]);
                }
        }
    }

    private void showDiceRoll() {
        System.out.println("Je gooide de volgende waarden: ");
        for(int i=0; i < roll.length; i++){
            System.out.print(roll[i]+" ");
        }
    }

    private void getPlayers() {

        String name="";
        System.out.println("Geef de namen van de spelers in. Kies -1 om door te gaan.");
        Scanner s = new Scanner(System.in);

        while(!name.equals("-1")) {
             name = s.nextLine();
             if(!name.equals("-1")) addPlayer(name);
        }
    }

    public boolean assignThrow(int[] dicethrow, int category){

        if(scoreCard[category][currentPlayer] != UNASSIGNED){ // we hoeven niet meer te vragen naar een andere categorie indien de gekozen categorie
            // ongeldig is. Indien dit zo is, sturen we nl. een false terug naar 'gelukt' in playRound en zal de lus daar worden uitgevoerd. De code
            // beschreven in die lus is net diegene die aan de gebruiker opnieuw vraagt voor een categorie. Dit wordt gedaan tot er een geldige waarde
            // is ingegeven.
            return false;
        }

        if(scoreCard[category][currentPlayer] == UNASSIGNED){

            // Berekening van de score voor de eerste 6 categoriën (bovenste vakjes).
            int scoreCategory=0;
            if(category >= 0 && category <= 5){
                for(int i=0; i < N_DICE; i++){
                    if(roll[i]==category+1){
                        scoreCategory = scoreCategory + category + 1;
                    }
                }
                scoreCard[category][currentPlayer] = scoreCategory;

                scoreCard[UPPER_SCORE][currentPlayer] = Math.max(scoreCard[ONES][currentPlayer],0)+Math.max(scoreCard[TWOS][currentPlayer],0)+
                Math.max(scoreCard[THREES][currentPlayer],0)+Math.max(scoreCard[FOURS][currentPlayer],0)+Math.max(scoreCard[FIVES][currentPlayer],0)+
                Math.max(scoreCard[SIXES][currentPlayer],0); //Math.max neemt het max van de twee waarden, dus als category op UNASSIGNED (-1) staat, verschijnt er 0.
                if(scoreCard[UPPER_SCORE][currentPlayer] >= UPPERVALUE){
                    scoreCard[UPPER_BONUS][currentPlayer] = 35;
                }
            }

            // Berekening voor de onderste vakjes.
            else if(category > 5){
                categoryCheck(category);

                scoreCard[LOWER_SCORE][currentPlayer] = Math.max(scoreCard[THREE_OF_A_KIND][currentPlayer],0)+Math.max(scoreCard[FOUR_OF_A_KIND][currentPlayer],0)+
                Math.max(scoreCard[FULL_HOUSE][currentPlayer],0)+Math.max(scoreCard[SMALL_STRAIGHT][currentPlayer],0)+Math.max(scoreCard[LARGE_STRAIGHT][currentPlayer],0)+
                Math.max(scoreCard[YAHTZEE][currentPlayer],0)+Math.max(scoreCard[CHANCE][currentPlayer],0);
            }

            if(category == CHANCE){
                int scoreChance = roll[0]+roll[1]+roll[2]+roll[3]+roll[4];
                scoreCard[CHANCE][currentPlayer] = scoreChance;
            }

            scoreCard[TOTAL][currentPlayer]= Math.max(scoreCard[UPPER_SCORE][currentPlayer],0)+Math.max(scoreCard[LOWER_SCORE][currentPlayer],0)+
            Math.max(scoreCard[UPPER_BONUS][currentPlayer],0);
        }
        return true;
    }

    private void categoryCheck(int category) {

        Arrays.sort(roll);

        if(category == THREE_OF_A_KIND){

            if((roll[0]==roll[1] && roll[1]==roll[2]) || (roll[2]==roll[3] && roll[3]==roll[4])){
                int scoreThreeOfaKind = roll[0]+roll[1]+roll[2]+roll[3]+roll[4];
                scoreCard[THREE_OF_A_KIND][currentPlayer] = scoreThreeOfaKind;
            }
            else{
                scoreCard[THREE_OF_A_KIND][currentPlayer] = 0;
            }
        }

        if(category == FOUR_OF_A_KIND){
            if((roll[0]==roll[1] && roll[1]==roll[2] && roll[2]==roll[3]) || (roll[1]==roll[2] && roll[2]==roll[3] && roll[3]==roll[4])){
                int scoreFourOfaKind = roll[0]+roll[1]+roll[2]+roll[3]+roll[4];
                scoreCard[FOUR_OF_A_KIND][currentPlayer] = scoreFourOfaKind;
            }
            else{
                scoreCard[FOUR_OF_A_KIND][currentPlayer] = 0;
            }
        }

        if(category == FULL_HOUSE){
            if((roll[0]==roll[1] && roll[1]==roll[2] && roll[3]==roll[4]) || (roll[0]==roll[1] &&roll[2]==roll[3] && roll[3]==roll[4])){
                int scoreFullHouse = 25;
                scoreCard[FULL_HOUSE][currentPlayer] = scoreFullHouse;
            }
            else{
                scoreCard[FULL_HOUSE][currentPlayer] = 0;
            }
        }

        if(category == SMALL_STRAIGHT){
            if((roll[1]==roll[0]+1 && roll[2]==roll[1]+1 && roll[3]==roll[2]+1) || (roll[4]==roll[3]+1 && roll[3]==roll[2]+1 && roll[2]==roll[1]+1)){
                int scoreSmallStraight = 30;
                scoreCard[SMALL_STRAIGHT][currentPlayer] = scoreSmallStraight;
            }
            else{
                scoreCard[SMALL_STRAIGHT][currentPlayer] = 0;
            }
        }

        if(category == LARGE_STRAIGHT){
            if(roll[0]==1 && roll[1]==2 && roll[2]==3 && roll[3]==4 && roll[4]==5){
                int scoreLargeStraight = 40;
                scoreCard[LARGE_STRAIGHT][currentPlayer] = scoreLargeStraight;
            }
            else{
                scoreCard[LARGE_STRAIGHT][currentPlayer] = 0;
            }
        }

        if(category == YAHTZEE){
            if(roll[0]==roll[1] && roll[1]==roll[2] && roll[2]==roll[3] && roll[3]==roll[4]){
                    int scoreYahtzee = 50;
                    scoreCard[YAHTZEE][currentPlayer] = scoreYahtzee;
                }
                else{
                    scoreCard[YAHTZEE][currentPlayer] = 0;
                }
            }
    }

    /* Java main method to ensure that this program starts correctly */
    public static void main(String[] args) {
        new Yahtzee().playGame();
    }





}