Pig the dice game/Player: Difference between revisions

{{task}}

 

 

 

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

<br><br>

 

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:

out of 100 000 tests.

</pre>

 

=={{header|Java}}==

 

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.

Player 3 had 102 points.

</pre>

 

=={{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|Perl}}==

 

package Player;

 

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

Distribution of wins after 10000 games:

{{out}}

<pre>929 3518 3462 1715 376</pre>

 

=={{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 2 wins!

2

</pre>

 

 

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

 

 

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>