05-03. Two dice pig

In this programme we're going to pull together most of the concepts we've learned so far into a bigger programme.

As always, we'll create the boilerplate and, because this programme will make use of random numbers, we'll declare a random generator, in the global section so that it's available to all our subprograms without the need to pass it between them.

The object of the game is to achieve a total score of over 100 on a turn.

A player rolls two dice and adds together the face value of the dice, adding that to their score for the turn.

If a player rolls a one on either die, their turn is over, and they lose their score for the turn.

Otherwise they can choose to bank their total and end their turn or take another roll to potentially add the roll again to their total.

To make the game easier to write, we'll use problem decomposition to break the problem down and start with writing a couple of handy functions.

Static int, which will be an array, hence open and close brackets.

Roll.

This function will roll two six sided dice and return the result in an array.

Let's enumerate the array.

Int Dice has the numbers 0 and 0.

Note, we're not using quotes here because we want the numbers, not a string.

Dice 0, that's the first dice, because things tend to start at zero in computing, will become the random generator's next random number between 1 and 7 exclusive, which means 1 and 6 dice 1, which is actually the second dice, will become a random number between 1 and 6, then return the dice.

So we didn't really need to use an array here.

It only has two values, so we could have just used two variables.

But doing it this way allows us to return a single structure and not two variables, which is not possible in some languages.

Also notice how we enumerated the array with two zeros to start.

This just gave us two indexes or elements that we could change.

There are other ways to do this, such as stating the number of indexes for the array, but this approach enables an easy comparison to Python.

If you're interested in doing that.

The next subprogram, will calculate the points from the static int points from the dice.

If dice 0 is 1 and dice 1 is a 1, then they're both 1 and the player loses their turn.

We'll return a minus 1 to indicate that else.

If dice 0 is a 1 or dice 1 is a 1, then only one of the two dice is a 1.

We score 0 and return that.

This is almost the same outcome, but we'll use minus 1 and 0 in an extension to the game later in all other cases.

Else we return the sum of the two die.

That's dice zero plus dice one.

That's the helper functions written.

We can now write the actual static voidplaygame.

We'll need some variables to manage the game.

Score will be an array holding the scores for both players.

These will start at 0 and 0.

Player will hold whose turn it currently is.

Our two players are numbered 0 and 1.

The starting player will be player 0.

So player is assigned to be 0.

Total will hold the running total of the dice so far before the player chooses to bank which they could lose before it is banked.

So we can't store that in score.

This is a new player's turn, which is helpful to know so that we can provide the players with an indication of when a new player's turn has started.

We use a variable called newplayer to store this and assign it to be true.

Turn end will allow us to know if the player's turn has ended.

This is currently false.

We also need to store the player's choice of whether to bank or gamble.

So we'll say choice is currently an empty string.

The game continues until either player has reached more than 100 points.

So while score for player 0 is less than or equal to 100 and score for player 1 is less than or equal to 100, do the following code.

If it's a new player, we'll give them a handy prompt.

A blank line makes the output look nicer.

and some hyphens too.

Then we tell the player whose turn it is.

Note that we're using player one in this line.

That's because humans will think it's a bit odd.

If the computer outputs player zero, it's your turn.

We normally number players from one upwards.

In human terms, it's only the computer that starts an index at 0.

So if we add 1 to the player number, that will make more sense to the players.

Player one is actually player zero and player two is actually player one.

In the code, we will then output the score for the current player.

This is where we have a real advantage of storing both the player scores with one array instead of two variables.

It allows us to use the index that's the variable player to specify which player we're referring to.

The alternative would require two variables, one for each score and an if statement to output the correct one.

There's no need.

We can simplify the code a lot by using arrays.

When we have more than One of something to store, in this case more than one player and also more than one dice.

Assign the total score to be zero.

It's no longer a new player's turn and their turn has not ended.

So let's set, both of these to false.

That's everything we want to do if it's the start of a new player's turn.

So we close the curly bracket for the if statement.

Tell the player to press enter to roll the dice.

Collect the input, but don't store it in a variable.

We just want to know they pressed enter the array.

Dice becomes the result of a roll that we've already written a subprogram for, and the result becomes the return value from the points subprogram we've already written.

To remember, minus 1 meant the player rolled a double 1, 0 meant a single 1 and any other roll is the sum of the two dice.

We see again how the use of subprograms has made the programme easier to read and write.

We can tell the player what they rolled by outputting the data in the elements zero and one of the dice array, concatenating the string to a single sentence for the console writeline command.

So now we can programme the logic of the game depending on the result of the dice roll.

If the result is greater than zero, output what the player scored.

That's the result.

Then running total then becomes whatever it is.

Now that's total plus the result of the dice output the new total.

The player now gets to choose if they want to gamble and roll the dice again.

If they roll a zero or a minus one, they'll lose their turn and the points for that round.

But they can also keep going until they bank or win.

So the user needs to say yes or no to continuing to roll the dice while choice is not Y and choice is not N.

Oops, I should have really put the curly bracket on the next line to make it easier to read.

But once you become good at C, you'll find programmers often put it on the same line.

Next, ask the user for their choice and, store this in a variable choice.

If the player's choice is N, which will mean no, then we will add their total from this round to their overall score.

Scores are stored in an array, so score for the player is equal to the score for the player.

That is what it is now, plus their total for the round.

We could also have written this as, score player plus equals total, which would have been neater.

They're turn ends, so we can assign turnend to Be true if they select Y, which will mean yes to gamble and have another roll.

The while loop will take care of that, so we don't need to write any more code to handle it.

We've already coded what happens when a player takes a roll.

However, they might have scored a zero or minus one, so.

So back to finish the if statement.

Else output.

Oh no, that's a pig out.

And end the turn.

If the turn has ended, we'll tell the player so that they can keep track of what's going on in the game.

With a handy prompt.

Press Enter to hand the dice to the next player.

Wait for the user to press enter by not doing anything with the input console readline.

That's a bit more abstraction there, as we're not really passing any dice, just changing the player variable.

Then player becomes whoever the player is now.

Plus one and modulo two.

This is a neat programming trick.

It means player zero will become player one or player one will become player zero because we took the remainder from dividing by two.

Now don't worry if you're thinking I wouldn't have come up with that because you could have achieved this with an if statement instead.

For example, if player equals 1, then player equals 0, else player equals 1.

That's fine too.

As you become more experienced, you become more aware of these little shortcuts, which actually increase processing speed too.

In the same way that we now understand arrays, we can use them instead of multiple variables.

You can use multiple variables, but it just makes the code longer to write.

Finally, we set new player to be true because it's the next player's turn.

In the main programme section, all that's left to do is called the Play gamesub programme.

That's the game written.

At the moment, we're treating a score of zero to be the same as a score of minus one.

But that's an extension for you to do.

Run the programme, play a few games.

Check.

It works.

Sam?