Pig the dice game: Difference between revisions

{{trans|Python}}

 

V maxscore = 100

V safescore = [0] * playercount

(score, player) = (0, (player + 1) % playercount)

 

 

{{out}}

 

=={{header|ActionScript}}==

package {

}

 

=={{header|Ada}}==

Also, there is a procedure Play to play the game, following whatever the actors do.

 

type Dice_Score is range 1 .. 6;

end record;

 

 

The implementation of Pig is as follows:

 

package body Pig is

begin

RND.Reset(Gen);

 

===Solving the Task===

class Hand from the class Actor to implement manually playing the game.

 

 

procedure Play_Pig is

Play(A1, A2, Alice);

Ada.Text_IO.Put_Line("Winner = " & (if Alice then "Alice!" else "Bob!"));

 

{{out}}

 

=={{header|AutoHotkey}}==

Gui, Add, Text, vPlayer0, Player 0

Gui, Add, Text, vSum0, 000

 

ButtonReload:

=={{header|AWK}}==

# syntax: GAWK -f PIG_THE_DICE_GAME.AWK

# converted from LUA

exit(0)

}

 

=={{header|BASIC256}}==

{{trans|FreeBASIC}}

numjugadores = 2

maxpuntos = 100

Next jugador

Until false

 

=={{header|C}}==

#include <stdio.h>

#include <stdlib.h>

}

 

 

Output:

 

=={{header|C sharp}}==

using System;

using System.IO;

}

}

 

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

#include <windows.h>

#include <iostream>

}

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

Output:

<pre>

 

=={{header|Clojure}}==

 

(defn roll-dice []

(defn -main [& args]

(println "Pig the Dice Game.")

 

=={{header|CLU}}==

 

pig = cluster is play

start_up = proc()

pig$play()

{{out}}

<pre style='height:50ex'>Game of Pig

 

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

(defconstant +n-of-players+ 2)

 

(setf current-player (mod (1+ current-player) +n-of-players+)))))

(format t "~%Player ~d wins with a score of ~d~%" current-player

{{out}}

<pre>Player 0: (0, 0). Rolling? (Y)

=={{header|D}}==

{{trans|Python}}

import std.stdio, std.string, std.algorithm, std.random;

enum maxScore = 100;

writefln("\n\nPlayer %d wins with a score of %d",

player, safeScore[player]);

{{out}}

<pre> Player 0: (0, 0). Rolling? (y/n)

{{Trans|Go}}

Thanks JensBorrisholt for library [https://github.com/JensBorrisholt/DelphiConsole System.Console].

 

{$APPTYPE CONSOLE}

writeln(format('Player %d wins!!!', [(turn - 1) mod Length(playerScores)]));

Readln;

{{out}}

<pre>Player 0 has: 96 points

=={{header|Eiffel}}==

 

class

PLAYER

points: INTEGER

end

class

PIG_THE_DICE

winner: PLAYER

end

Test:

class

APPLICATION

pig: PIG_THE_DICE

end

{{out}}

<pre>

=={{header|Erlang}}==

Some of the code (ex: quit/2) is only there to make play during development easier. Some (ex: player_name/1) is only there to make [[Pig_the_dice_game/Player]] easier.

-module( pig_dice ).

 

[io:fwrite("~p with ~p~n", [N, T]) || {N, T} <- Rest];

task_display( Result ) -> io:fwrite( "Result: ~p~n", [Result] ).

{{out}}

Start of game:

 

=={{header|FOCAL}}==

01.20 S S(1)=0;S S(2)=0;S P=1

01.30 T !"PLAYER",%1,P," TURN BEGINS"!

03.55 T "- TOO BAD!"!;S T=0

03.60 S S(P)=S(P)+T

 

=={{header|Forth}}==

{{works with|4tH|3.62.1}}

include lib/yesorno.4th

 

; \ show the results

 

 

=={{header|FreeBASIC}}==

Const numjugadores = 2

Const maxpuntos = 100

Next jugador

Loop

 

=={{header|Go}}==

 

import (

}

fmt.Printf("Player %v wins!!!\n", (turn-1)%len(playerScores))

 

=={{header|Groovy}}==

Currently hard coded for 2 players, but will work for multiple players

class PigDice {

 

}

}

 

=={{header|Haskell}}==

import System.Random (randomRIO)

 

putStrLn "\nInvalid input - please try again."

askPlayer $ Score stack score

 

Example output:

 

=={{header|IS-BASIC}}==

110 RANDOMIZE

120 STRING PLAYER$(1 TO 2)*28

610 LOOP UNTIL K$="y" OR K$="n"

620 LET ANSWER$=K$

 

=={{header|J}}==

 

 

status=:3 :0

smoutput 'player scores now: ',":scores end. end.

smoutput 'player ',(":1+I.scores>:100),' wins'

 

Example game:

 

2 player game of pig

begining of turn for player 1

..Roll the dice or Hold or Quit? [R or H or Q]: H

player scores now: 84 102

 

=={{header|Java}}==

{{trans|D}}

 

public class PigDice {

player, safeScore[player]);

}

 

{{works with|Java|8+}}

import java.util.Random;

import java.util.Scanner;

;

}

 

<pre> Player 0: (0, 0) Rolling? (y/n) y

 

=={{header|JavaScript}}==

{ name: '', score: 0 },

{ name: '', score: 0 }

`);

}

 

=={{header|Julia}}==

The game is built around the <tt>PigPlayer</tt> type, which contains the player information, including a reference to the strategy function, <tt>strat</tt>, that is to be used to determined whether a player is going to continue to roll. In this incarnation of the game, there is only one strategy function available, <tt>pig_manual</tt>, which gets this decision from user input.

type PigPlayer

name::String

 

pig_game([PigPlayer("Alice"), PigPlayer("Bob")])

 

{{out}}

 

=={{header|Kotlin}}==

 

fun main(Args: Array<String>) {

}

}

 

{{out}}

{{works with|lua|5.1}}

Supports any number of players

local maxScore = 100

local scores = { }

end

end

 

=={{header|M2000 Interpreter}}==

Module GamePig {

Print "Game of Pig"

}

GamePig

 

=={{header|Maple}}==

local Points, pointsThisTurn, answer, rollNum, i, win;

randomize();

end proc;

 

{{out}}

<pre>

 

=={{header|Mathematica}}/{{header|Wolfram Language}}==

roll}, (score@# = 0) & /@ players;

Panel@Dynamic@

players = RotateLeft@players]]},

Button["Play again.",

 

=={{header|MiniScript}}==

Player = {}

Player.score = 0

if player.score >= goal then break

end for

 

{{out}}

=={{header|Nim}}==

{{trans|Kotlin}}

 

randomize()

 

else:

 

{{out}}

 

=={{header|Objeck}}==

class Pig {

function : Main(args : String[]) ~ Nil {

}

}

<pre>

Player 0: (0, 0) Rolling? (y/n)

=={{header|OCaml}}==

 

object

val name = name_init

let p1 = new player "Steven"

and p2 = new player "John" in

 

=={{header|Pascal}}==

{{works with|Free Pascal|2.6.4}}

 

 

const

else

Congratulate(Player2)

 

=={{header|Perl}}==

You can have as many players as you want, simply provide their names on the command line.

use strict;

use warnings;

}

__END__

 

=={{header|Phix}}==

Initially a translation of [[Pig_the_dice_game#Lua|Lua]], but now quite different.

maxScore = 100

sequence scores = repeat(0,numPlayers)

end if

end while

{{out}}

<pre>

=={{header|PHP}}==

{{trans|D}}

 

define('MAXSCORE', 100);

printf('\n\nPlayer %d wins with a score of %d ',

$player, $safeScore[$player]);

<pre>C:\UniServer\usr\local\php\php pig.php

Player 0: (0, 0) Rolling? (Yn)

 

=={{header|Python}}==

 

'''

score, player = 0, (player + 1) % playercount

 

;Samples from a game:

 

=={{header|Racket}}==

#lang racket

 

 

(pig-the-dice #:print? #t human human)

 

=={{header|Raku}}==

(formerly Perl 6)

{{works with|rakudo|2015-09-30}}

sub MAIN (Int :$players = 2, Int :$goal = 100) {

say " Sticking with $safe." if $ante;

}

The game defaults to the specified task, but we'll play a shorter game with three players for our example:

{{out}}

:::* names are used for the die faces (in addition to the pip value)

:::* a simple (but aggressive) strategy is used (that favors a human player)

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; REXX program (or BIF) which is used to determine the screen width (or linesize) of the terminal (console).

<br>The &nbsp; '''LINESIZE.REX''' &nbsp; REXX program is included here &nbsp; ──► &nbsp; [[LINESIZE.REX]].

 

=={{header|Ring}}==

# Project : Pig the dice game

 

end

see "Player " + player + " wins with a score of " + safeScore[player]

Output:

<pre>

* transparent game logic

 

Player = Struct.new(:name, :safescore, :score) do

def bust!() self.score = safescore end

end

 

 

;Samples from a game:

 

=={{header|Run BASIC}}==

maxScore = 100

dim safeScore(numPlayers)

goto [loop]

[winner]

 

=={{header|Rust}}==

{{works with|Rust|2018}}

 

fn main() {

self.score <= 100 || self.status == TurnStatus::Continue

}

 

=={{header|Scala}}==

{{libheader|Scala 100% Immutable variables}}

{{libheader|Scala Concise}}

private val (maxScore, nPlayers) = (100, 2)

private val rnd = util.Random

 

loop(Game(gameOver = false, 0, 0, Array.ofDim[Int](nPlayers).toVector))

 

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

 

oo::class create Player {

rotateList scores

}

Demonstrating with human players:

variable me

superclass Player

}

 

{{out|Sample output}}

<pre>

=={{header|VBA}}==

 

Option Explicit

 

MsgBox Replace(WIN, "¤¤¤¤", Cp)

End Sub

 

=={{header|Vlang}}==

{{trans|go}}

import rand.seed

import os

}

println("Player ${(turn-1)%player_scores.len} wins!!!", )

 

=={{header|Wren}}==

{{libheader|Wren-ioutil}}

{{libheader|Wren-str}}

import "/str" for Str

import "random" for Random

System.print(" Your score for the round is now %(score)")

}

 

{{out}}

 

=={{header|XPL0}}==

integer Player, Die, Points, Score(2);

[Score(0):= 0; Score(1):= 0; \starting scores for each player

until Score(Player) >= 100;

Text(0, "Player "); IntOut(0, Player+1); Text(0, " WINS!!!");

 

Output:

=={{header|zkl}}==

{{trans|D}}

players,safeScores:=Walker.cycle([0..PLAYERS-1]), PLAYERS.pump(List(),0);

rollDie:=(1).random.fp(7);

player,score,S=players.next(),0,safeScores[player];

}

{{out}}

<pre>