Menerapkan program atau fungsi yang mensimulasikan dadu umum untuk permainan peran. Ini harus menangani setidaknya d6 dan d20, dua dadu yang paling umum.

Namun, itu harus bekerja sebagai gamer stereotip mengharapkan mereka untuk bekerja, dan bukan sebagai pekerjaan dadu nyata.

Ini adalah lelucon di antara gamer, bahwa seseorang dapat memiliki lucky lucky khusus untuk lemparan yang sangat penting, dengan sebelumnya melempar banyak dadu, memilih yang menghasilkan angka "1", lalu melemparkannya lagi, sampai Anda mendapatkan beberapa yang menggulung "1" beberapa kali. Anda kemudian dengan hati-hati melestarikannya, karena mereka menggulung 1 beberapa kali secara berurutan, sehingga kemungkinan untuk menggulung 1 kali harus sangat rendah.

Tentu saja, ini bukan cara dadu bekerja dalam kehidupan nyata , karena gulungan secara statistik independen.

Dadu yang disimulasikan harus memperhitungkan daftar sebelumnya, dan bekerja dengan cara yang sama dengan cara penjudi dalam kekeliruan penjudi mengharapkannya berfungsi. Sebagai contoh, jika banyak angka rendah digulung, kemungkinan menggulirkan angka yang lebih tinggi harus ditingkatkan.

Namun, karena ini curang, Anda harus menyembunyikannya dengan baik . Ini berarti, pandangan sekilas pada program seharusnya tidak mengungkapkan bahwa Anda curang. Ini berarti, secara eksplisit menyimpan hasil sebelumnya dan membacanya di setiap lemparan akan terlalu mencurigakan. Anda harus menyembunyikan "properti" ini dari dadu Anda, dan poin bonus jika Anda menjadikannya masuk akal dan menyamarkannya sebagai kesalahan jujur. (misalnya, Anda membuat RNG Anda sendiri dengan cacat "tidak disengaja")

Para pemilih, harap perhatikan seberapa baik "cacat" tersembunyi ini.

Program harus jelas, dan tidak dikaburkan. Terlalu mudah untuk menyembunyikan kode jahat dalam program yang dikaburkan.

Jawa

public class GamerDie {
    private final java.util.Random rnd;
    private final int sides;

    public GamerDie(int sides) {
        this.sides = sides;
        this.rnd = new java.util.Random();
    }

    public int throw() {
        return rnd.nextInt(sides) + 1;
    }
}

Ini sangat sederhana sehingga jelas tidak menyembunyikan apa pun: tetapi java.util.Randommerupakan generator kongruensi linear yang lugas, dan menggunakan teknik buang untuk memastikan keseragaman, sehingga menjamin bahwa dalam sembarang kelipatan terbesar dari yang sizelebih kecil dari 2 ^ 48 sampel, ia akan mendistribusikan angka merata, memenuhi persyaratan.

Rubi

Saat ini hanya mendukung d6, nanti akan menambahkan dukungan d20 ...

Lihat dan lihat - dadu-dadu itu jahat!

# first idea was to create 6 super cool dices just by copy&paste
# -> each dice holds its number at the beginning of the array
# -> we don't need all of them now, so we comment them out
dice0 = %w[[[[[[[[[ 0 . : :. :: ::. ::: ]]]]]]]]
#dice1 = %w[[[[[[[ 1 : . :. ::. :: ::: ]]]]]]]
#dice2 = %w[[[[[[ 2 . : :. :: ::. ::: ]]]]]]
#dice3 = %w[[[[[[ 3 : . :. ::. :: ::: ]]]]]]]
#dice4 = %w[[[[[[[ 4 . : :. :: ::: ::. ]]]]]]]
#dice5 = %w[[[[[[[[ 5 . : :. :: ::. ::: ]]]]]]]]]

# and hey, those dices are almost ascii art ;)

# well, let's just create a standard dice
# -> get rid of the number at the beginning
# -> then sort (maybe we need that later due to the
#    currently unused dices being unsorted)
dice = dice0.select!{|e| /[:.]+/ === e}.sort

def roll(d)
  # rolling is easy
  # -> use size instead of hardcoded number,
  #   maybe we'll have other dices later
  d.slice!(rand(d.size - 1))
end

# and here you have 8 very underhanded dices!
dices = [dice]*8

# roll like a champion
roll(dices[0])
...

Haskell

Gunakan satu hal acak untuk membuat hal acak lain: dalam kasus ini, kocok kartu untuk menghasilkan lemparan dadu.

import System.Environment
import System.Random
import Data.Array.IO
import Control.Monad
-- make random dice from random cards
suit c=map (\(a,b)->[a,b])$zip "A23456789TJQK" (repeat c)
deck=concatMap(\s->suit s) "♠♥♦♣"
-- just like casinos, use more decks for extra randomness
decks=concat$take 8$repeat deck
-- shuffle the cards
shuffle :: [a] -> IO [a]
shuffle xs = do
        ar <- newArray n xs
        forM [1..n] $ \i -> do
            j <- randomRIO (i,n)
            vi <- readArray ar i
            vj <- readArray ar j
            writeArray ar j vi
            return vj
  where
    n = length xs
    newArray :: Int -> [a] -> IO (IOArray Int a)
    newArray n xs =  newListArray (1,n) xs
-- convert a card to a die, by counting along the original deck
-- then taking mod (faces). If we don't have enough cards to make
-- a full set of faces, assign the 'extra' cards a value of 0
card2die faces card=
  let index=(head[i|(i,c)<-zip[0..]deck,c==card]) in
  if (index > (length deck-(length deck`mod`faces)))
  then 0
  else (index`mod`faces)+1
main=
  do
    args <- getArgs
    let faces = read (args!!0)
    -- throw away cards we can't map to die faces
    cards<-shuffle$filter (\card->card2die faces card/=0) decks
    mapM_ (\card->putStrLn (card++" -> "++(show (card2die faces card)))) cards

Mengambil satu argumen, jumlah wajah pada dadu. Outputnya seperti ini:

./cards 20|head
2♦ -> 8
7♥ -> 20
J♦ -> 17
6♥ -> 19
9♥ -> 2
8♥ -> 1
5♥ -> 18
4♠ -> 4
Q♥ -> 5
2♣ -> 1

... dan seterusnya untuk semua kartu (discard tidak dicetak). Terlalu jelas?