# A Dicey Game

Build a small dice game according to the rules stated below. The intermediate tasks will guide you along to help build the program step-by-step.

The Rules

This is a game for 2 players, called `Player 1` and `Player 2`, which each start with a score of 0 points. It is played with a six-sided die with the numbers 1, …, 6 on it. The goal is to collect as many points as possible over 5 rounds (or until one player looses) without exceeding a limit in each turn. This limit usually is set to 21.

In each round, the players take turns. At the beginning of each turn, the die is rolled three times and the shown numbers are added up to get the turn sum. Then the current player can decide to either

• Stop, in which case the turn sum is added to the players score and the next players turn starts.
• Roll again, which rolls the die again and adds the number shown to the turn sum.
• Should the turn sum exceed the limit the player was too greedy and looses the game.

If all rounds have passed and no player has lost yet, the players scores are compared and the player with the higher score wins. In case the scores are equal, it is considered a draw.

## Preparation¶

If you haven’t done so yet, create a new Python file `dice-game.py` in which to put the code for this task.

Create constants and variables as follows:

Name Value Comment / Explanation
`PLAYER_1` `"Player 1"` The text used to represent the first player
`PLAYER_2` `"Player 2"` The text used to represent the second player
`DRAW` `"Draw"` The text used to represent if a draw occurred
`INPUT_ROLL` `"roll"` The word which the user has to input to roll again
`INPUT_STOP` `"stop"` The word which the user has to input to end their turn

## Roll the Dice¶

To simulate dice rolling, we can use functions from Pythons built-in module `random`.

Read up on the `randrange(…)` and `randint(…)` functions from the module in the Python Documentation. Decide which one you want to use to generate a number between 1 and 6 to simulate a dice roll.

Before you write any actual code, test in the REPL if you can import the function of your choice from the `random` module. Also try calling the function a few time to try out generating random numbers.

Write a function called `roll_dice()` that uses the random functions to simulate a dice roll, prints the rolled number, and also returns the number that was rolled. (Don’t forget the import!)

## Take a Turn¶

We will wrap the inner workings of a turn into a function, so it can be re-used.

Define a function `take_turn(current_player)`.

It will start by printing which players turn it is. Next it will prepare a variable `turn_sum` which starts at `0`. Afterwards it calls the `roll_dice()`-function three times and adds the results to the `turn_sum`. The `turn_sum` is printed to inform the player about their current amount of points.

Prepare a variable `current_input`, that starts out with no data (yet). Now, the function enters a loop. As long as the player did not input the stop-word according to `INPUT_STOP` or the `turn_sum` exceeded the `limit`, the following is done:

• Request an input from the player.
• If the input was anything else then `INPUT_ROLL` or `INPUT_STOP`, print which words the player is allowed to use
• If the input was `INPUT_ROLL`, call the `roll_dice()`-function and add the result to the `turn_sum`

After the loop, the function returns the achieved `turn_sum`.

## The complete Game¶

Define a function `play_dice_game(…)`.

The `limit` a player may achieve in each turn (default: `21`) and the `maximum_rounds` to be played (default: `5`) should be made available as parameters so users may choose their own rules if they want to do so.

You will need a variables to count how many rounds you have already played and what the total score of each player is. Also introduce a variable `looser` to keep track if any of the players has lost early. Of course this initially is `None`.

Create a loop that runs as long as there is no looser or the maximum amount of rounds have not been played yet. Inside, print the current round and print the scores so far. To play the round, first, `PLAYER_1` takes a turn, then `PLAYER_2` (use the `take_turn(…)`-function accordingly). If their turn sum did exceed the ```limit, announce that they lost and stop the function immediately. Otherwise update their```player_…_score`-variables by adding the turn scores onto them.

If the loop completes and no player has lost yet, compare the scores and print the name of the winner or the `DRAW`-text as appropriate.

``````if __name__ == "__main__":
Inside the `if __name__ == "__main__":`-block, ask the user if they want to play with custom rules. If that is the case, allow them to set a different `limit` and `maximum_rounds`. Call the `play_dice_game(limit=…, maximum_rounds=…)` with the according values.