Pig the dice game/Player: Difference between revisions

{{task}}

* State here the play strategies involved.

* Show play during a game here.

 

As a stretch goal:

* Simulate playing the game a number of times with two players of given strategies and report here summary statistics such as, but not restricted to, the influence of going first or which strategy seems stronger.

 

;Game Rules:

# '''Holding''': The player's score for that round is added to their total and becomes safe from the effects of throwing a one. The player's turn finishes with play passing to the next player.

 

* [[wp:Pig (dice)|Pig (dice)]]

 

=={{header|Ada}}==

The implementation reads five parameters from the command line, in that order: (1) N the number of games to play, (2) the Bound for the first player, (3) the Final_Run for the first player, (4) the Bound for the second player and (5) the Final_Run for the second player. After reading these from the command line (or accepting reasonable defaults), it plays the game N times and counts how often either player wins.

 

 

procedure automatic_Pig is

Ada.Text_IO.Put_Line(Natural'Image(Win_Count(True)) &

Natural'Image(Win_Count(False)));

 

 

$ ./automatic_pig 1000000 25 0 25 25

527935 472065</pre>

 

=={{header|C++}}==

Player 3 always tries to score at least 20 points in a round.<br />

Player 4, just like player 3, always tries to score at least 20 points in a round. But as his round score increases, he gets a little "nervous", what increases the chances that he'll hold.

#include <windows.h>

#include <iostream>

}

//--------------------------------------------------------------------------------------------------

<pre>

Player 1 rolled 1 - current score: 0

Player III (AL20): 101

Player IV (AL20T): 46

</pre>

 

=={{header|Go}}==

 

import (

}

pg.PrintStatus(gameOverSummary)

Sample run, player one just tries to keep ahead, while player two always tries to take three rolls, no more.

<pre>

player 1 104

player 2 98

</pre>

 

 

If the expected value is positive, it's probably in the best interest of the player to take the roll. That said, a more sophisticated strategy might play cautiously when a player is sufficiently ahead of the other player(s).

(+/%#)(-x),}.(1+i.6)<.100-y+x

Examples:

If we have 10 points from our current rolls and have 90 permanent points, rolling again is a bad idea.

3.33333 3.33333 3.33333 3.33333 3.33333 3.33333 3.33333 3.16667 0

2.5 2.5 2.5 2.5 2.5 2.5 2.33333 _0.833333 _5

1.66667 1.66667 1.66667 1.66667 1.66667 1.5 _1.66667 _5.83333 _10

0.833333 0.833333 0.833333 0.833333 0.666667 _2.5 _6.66667 _10.8333 _15

If we have 70 permanent points (or less) we should probably re-roll when our uncommitted rolls total to less than 20.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

This is a table of decision points. First row represents sum of our current uncommitted rolls. Second row represents the maximum permanent score where you should roll again with that number of uncommitted points, if we are using this estimation mechanism to choose our actions. Note that the first four columns here should have some obvious validity -- for example, if we have 96 permanent points and we have rolled 4 uncommitted points, we have won the game and we gain nothing from rerolling... Note also that this decision mechanism says we should never reroll if we have at least 20 uncommitted points.

 

=={{header|Python}}==

Notice how Pythons Counter class from the standard library is used to collate the winning statistics near the end of the program without much additional code.

 

 

'''

for i in range(maxgames))

print(' Players(position) winning on left; occurrences on right:\n %s'

{{out}}

First is shown the game data for a single game with reduced maxscore then statistics on multiple games.

 

Note: ''('(RollTo20(1), RandPlay(0))', 25063)'' means that the algorithm RollTo20 playing as the second player, (1) wins against algorithm RandPlay of the first player, (0) and wins 25063 times. (Zero based indexing so the first player is player(0)).

 

=={{header|REXX}}==

 

The (somewhat aggressive) "quarter" strategy was chosen to give the advantage to a human (it was presumed that this dice game would be played with a CBLF).

if _\=='' then call err 'too many arguments were specified: ' _

 

 

 

 

 

end /*until stopped*/

 

end /*game*/

 

 

To play this game with two computer players (simulate), use the following arguments:

<pre>

</pre>

to specify names for the (two) computer players.

 

=={{header|Tcl}}==

<table><tr><td>{{works with|Tcl|8.6}}</td><td>or alternatively with Tcl 8.5 and</td><td>{{libheader|TclOO}}</td></tr></table><!-- dirty trick! -->

First the structure of the game (from [[Pig the dice game#Tcl|the parent page]]):

 

oo::class create Player {

rotateList scores

}

Then the classes that create the various implemented strategies:

superclass Player

variable me

dict set scores $who $score

}

Demonstration, pitting the three of them against each other:

{{out}}

<pre>

Desperate® has (66,31)... roll

Desperate® has won! (Score: 101)

</pre>