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

 

 

 

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.

</pre>

 

 

 

 

 

 

 

 

 

 

 

}

}

 

 

# 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

 

my $player = -1;

$player++;

 

 

}

 

 

<pre>

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

 

=={{header|Racket}}==

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

 

=={{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: ' _

 

 

 

 

 

say it @jra ! || @ati "total is: " in.j

end /*until stopped*/

 

end /*game*/

 

<br><br>

 

═══════════════════════════HAL 2 the computer won! ════════════════════════════

</pre>

 

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