1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
|
# A Party of Dice
A game simulation I wrote to help me better understand Go concurrency
concepts.
Based loosely on the `makeThumbnails6` example in Chapter 8 (page 238)
of *The Go Programming Language* (Addison-Wesley, 2016).
# Usage
The following invocation runs the simulation with two players, each of
which plays with a six-sided die:
`go run . -n 2 -sides 6`
Since 2 and 6 are the default values, in this case the following is
equivalent:
`go run .`
Of course, `go run . -help` will print a detailed listing of available
command-line arguments.
# The Scene
Several people agree to convene to play a game of dice. Beforehand,
they decided on the number of sides a given die should have. Once they
do that, each player brings with them a die of that many sides (for
example, 6, 12, etc.; even a coin can count as a die in this case.)
The die (it doesn't matter which) is first rolled once, which decides
what is to be the winning number. Each player is then tasked with
rolling their die until they hit that number.
For example, three players get together and decide to use an ordinary
six-sided die each. The die is rolled, resulting in a 4. The players
then each go off into their corners and roll their die until they hit
a 4, upon which they can declare victory.
The player to hit the number in the smallest number of turns, wins. In
the case of a tie, the first one to roll the winning number wins. For
example, if player 1 hits the number in three turns, then player 2
hits the number in two turns, then player 3 also in two turns, player
2 wins.
|
