**Category 9 – Full house**

Once again, I am going to bubble sort (bubble sort at the bottom of this post) the dice values, so that I can check to see if there are 3 of the same values and 2 of other values that are the same. This is very similar to counting how many values are the same with three/four of a kind, but this time need to make sure that there are only 3 / 2 split of different values, and for the scoring value we only need to return true/false since the value if it is a full house it is 25 points or 0 for nothing.

So, the way that I have done it, is with checking to see if values are the same within the array (whilst scanning from the start to end) and if they are increment the count (counting of similar values), if the values changes then check to see if the count is equal to 3 or 2 (which is the full house requirements) and if so set a boolean value to true and keep on checking. To get to return true, need to see if both the 3 and 2 boolean values are true then we know that we have a full house.

```
// need to check for 3 of the same value and then 2 of the same value
private Boolean checkFullHouse(int[] dice)
{
int count =1;
Boolean found3 = false, found2 = false;
for (int i=1; i < YahtzeeConstants.N_DICE;i++)
{
if (dice[i] == dice[i-1])
count++;
else
{
if (count == 3)
found3 = true;
else if (count == 2)
found2 = true;
count=1;
}
}
if (count == 3)
found3 = true;
else if (count == 2)
found2 = true;
if (found3 && found2) return true;
return false;
}
```

**Categories 10,11 - Small/Large straight**

The last two are very similar and because once again I am using the bubble sort to organise the array into a order then we just need to check the array by going through it from start to finish checking to make sure that the value before is 1 minus the present value in the array ( e.g. array being 3,4,5, present value is the 4 and the previous value is 3 which is correct), then add up these correct placements within the array and if the consecutive values are either 4 (small straight) or 5 (large straight) return true or false accordingly.

```
// consecutiveValues = how many in a straight line
private Boolean checkStraight(int[] dice, int consecutiveValues)
{
int inLine =1;
for (int i =1; i < YahtzeeConstants.N_DICE; i++)
{
if ((dice[i-1]+1) == dice[i]) inLine++;
}
if (inLine >= consecutiveValues) return true;
return false;
}
```

The main thing within the program is to make sure that you are always accounting for the difference with the categories numbers (which start from 1) and the scoring values (which start from 0) or the dice numbers (which start from 0 again), of course could make the size of those arrays 1 bigger.

To create the score array and also so we know what is a score value of 0 or not, then the score array is setup with all values of -1.

```
/* setup the scores to a value of -1, default value */
private void setupScores(int[][] scoresSetup, int playersNum, int totalValues)
{
for (int i=0; i < playersNum; i++)
for (int j=0; j < totalValues;j++)
scoresSetup[i][j] = -1;
}
```

So that when you are selecting a category to place the score of your dice and you try to select a category already selected, then just need to check the score for -1 and if so we know it is a category not already used.

```
private Boolean updateScore(int[] scoresUpdate, int category, int score)
{
// default is -1, since cannot get this score value
if (scoresUpdate[category] == -1)
{
scoresUpdate[category] = score;
return false;
}
else
{
display.printMessage("Category already selected, please select another");
return true;
}
}
```

Also within the source code, I have included a cheat mode so that you can insert the values of the dice in runtime (when you are asked about the number of players type in -99 and the cheat mode is activated and there is only 1 player setup).

The next post is the extensions of this assignment.