Pig the dice game/Player: Difference between revisions

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)));

 

 

 

Requires additional file from [[Pig the dice game/Player/AutoHotkey]]

SetBatchLines, -1

#SingleInstance, Force

Roll := Optimal[SumMe,TurnSum,SumOpp+1]

Return Roll = "" ? 1 : Roll

{{out}}

<table border=1 cellpadding=1 cellspacing=0 width=500 style='table-layout:fixed;width:375pt'>

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>

}

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

{{out}}

<pre>

=={{header|Common Lisp}}==

Just implemented two strategies. One is actually a variable strategy which holds until a specific value is reached and then turns the dice over. The default value is 25. The other is from "Practical Play of the Dice Game Pig" by ToddW. Neller and Clifton G.M. Presser. Their suggested strategy is "If either player’s score is 71 or higher, roll for the goal. Otherwise, hold at 21 + (j - i) / 8" where j is the other player's score and i is the strategizing player's score. The scoring is handled by generic functions on the player type.

((score :initform 0 :accessor score)

(name :initarg :name :accessor name)))

 

(defun play-pig-player (player1 player2)

Output:

Darrell: Rolled a 3 - Turn: 7 Current Score: 7 Keep rolling (Y, N or Q)?Y

Darrell: Rolled a 3 - Turn: 10 Current Score: 10 Keep rolling (Y, N or Q)?Y

Darrell rolls a 3 and WINS!

Hooray! Darrell won the game!

 

=={{header|D}}==

{{trans|C++}}

 

enum nPlayers = 4, maxPoints = 100;

writeln("Player III (AL20): ", players[2].getCurrScore);

writeln("Player IV (AL20T): ", players[3].getCurrScore, "\n\n");

 

The output is similar to the C++ entry.

=={{header|Erlang}}==

Four players take turns starting. Their strategy is how long to wait before holding. They aim for 5, 10, 15 and 20 rolls. Player20 managed better than I thought it would.

-module( pig_dice_player ).

 

Result

end.

{{out}}

<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>

- player4 rolls 3/4 of the time, 1/4 he holds, but if he gets a score more than 75 he goes for the win

 

{-# LANGUAGE ViewPatterns #-}

 

p4 = pInfo { name = "Stephen" }

strat1 [p1, p2, p3, p4]

 

Example output:

To test the distribution by yourself (in parallel):

 

 

-- add this to the top

-- ghc FILENAME.hs -O2 -threaded -with-rtsopts="-N4" -o dice

 

 

Distribution:

 

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.

 

 

This is the main file, Pigdice.java

 

public class Pigdice {

}

 

This is the Player.java class file.

 

private int points = 0;

}

 

 

This is the Move.java class file.

 

This is the Strategy.java class file.

 

public interface Strategy {

};

 

 

And finally, this is the Dice.java class file. It's pretty self-explanatory.

 

public class Dice {

return rand.nextInt(sides) + 1;

}

 

Here's a small sample output using only bots (even though it fully supports human players too). A full game simulation can obviously be MUCH longer.

 

=={{header|Julia}}==

score::Int

ante::Int

 

rungames(1000000)

<pre>

Player 3 rolls a 5.

Even for 20+20 games strategy 12, 20 wins 8, 10

 

Module GamePig (games, strategy1, strategy2) {

Print "Game of Pig"

 

 

 

=={{header|Nim}}==

Except for some small differences in the formatting, the output is similar to that of D (or C++) implementation.

 

 

const MaxPoints = 100

for player in playerList:

let stratStr = &"({player.strategy}):"

 

{{out}}

=={{header|Perl}}==

{{trans|Raku}}

 

package Player;

 

print ' ----' x @players, "\n";

Distribution of wins after 10000 games:

{{out}}

 

=={{header|Phix}}==

{{out}}

<pre>

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.

Same as [[Pig_the_dice_game#Racket]], with three strategy makers, and

simulation code for trying out strategies.

 

(define (pig-the-dice #:print? [print? #t] . players)

;; (n-runs 1000 (n-random 2) (n-random 3) (n-random 4))

;; (n-runs 1000 (n-rounds 5) (n-points 24))

The following example run demonstrates the output from

Where <code>n-points</code> is a strategy where the user continues to roll until the specified number of points is gained and <code>n-rounds</code> is a strategy where the users rolls the specified number of times each round.

<pre>

player 4 randomly chooses to roll again but gets more consrvative as its score get closer to the goal.

 

 

constant DIE = 1 .. 6;

 

say "\nSCORES: for $games games";

 

'''Sample output for 10000 games'''

 

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).

sw= linesize() - 1 /*get the width of the terminal screen,*/

parse arg hp cp win die _ . '(' names ")" /*obtain optional arguments from the CL*/

/*──────────────────────────────────────────────────────────────────────────────────────*/

err: say; say; say center(' error! ', max(40, linesize() % 2), "*"); say

This REXX program makes use of &nbsp; '''LINESIZE''' &nbsp; BIF &nbsp; which returns the terminals width (linesize).

<br>Some REXXes don't have a &nbsp; '''LINESIZE''' &nbsp; BIF, so one is included here &nbsp; ──► &nbsp; [[LINESIZE.REX]].

 

=={{header|Ruby}}==

def player1(sum,sm)

for i in 1..100

sm=0

player1(sum,sm)

 

=={{header|Sidef}}==

{{trans|Raku}}

 

 

class Player(score=0, ante=0, rolls=0, strategy={false}) {

method turn {

loop {

when (1) {

}

case (roll > 1) {

}

}

}

}

}

 

 

# default, go-for-broke, always roll again

 

# try to roll 5 times but no more per turn

 

# try to accumulate at least 20 points per turn

 

# random but 90% chance of rolling again

 

# random but more conservative as approaches goal

 

 

games.times {

loop {

}

}

 

{{out}}

<pre>

<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>