Rol yapma oyunları için ortak zarları simüle eden bir program veya işlev uygulayın. En az iki yaygın zar olan d6 ve d20'yi ele almalıdır.

Ancak, stereotipik oyuncular gerçek zar işi olarak değil, çalışmalarını bekledikçe çalışmalıdır.

Oyuncular arasında bir şaka, daha önce çok fazla zar atarak, "1" ile sonuçlananları seçerek, sonra tekrar atarak, çok önemli bir rulo için özel olarak şanslı bir ölüme sahip olabilir. birkaç "1" birden çok kez yuvarlandı. Daha sonra bunları dikkatlice korursunuz, çünkü sırayla 1 kez birden yuvarlandılar, böylece bir sonraki seferde yuvarlanma olasılığı son derece düşük olmalıdır.

Tabii ki, zar gerçek hayatta böyle çalışmaz , çünkü rulolar istatistiksel olarak bağımsızdır.

Simüle edilmiş zarlarınız önceki atışları hesaba katmalı ve kumarbazın yanılgısındaki kumarbazın nasıl çalışmasını beklediğine benzer şekilde çalışmalıdır. Örneğin, çok sayıda düşük sayı haddelenmişse, daha yüksek sayı haddeleme olasılığı arttırılmalıdır.

Ancak, bu hile yaparken, iyi gizlemek zorundasınız . Bu, programa gündelik bir bakışta hile yaptığınızı göstermemelisiniz. Bu, önceki sonuçları açıkça kaydetmek ve her atışta okumak çok şüpheli olacaktır. Eğer zar zor bu "mülkiyet" gizlemek gerekir ve bonus inandırıcı yapmak inkar ve dürüst bir hata olarak gizlemek. (örneğin, "kasıtsız" bir kusurla kendi RNG'nizi yaparsınız)

Seçmenler, lütfen bu "kusurun" ne kadar gizli olduğunu dikkate alın.

Programlar açık olmalı ve gizlenmemelidir. Gizlenmiş bir programda kötü kodu gizlemek çok kolay.

Java

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

Öyle basit ki, hiçbir şeyi gizlemiyor: ama java.util.Randombasit bir doğrusal uyumlu jeneratördür ve homojenliği sağlamak için bir atma tekniği kullanır, bu nedenle size2 ^ 48'den küçük numunelerin en büyük katlarının herhangi bir çalışmasında dağıtılacağını garanti eder. Sayıları eşit, gereksinimi karşılar.

Yakut

Şu anda sadece d6 desteği, daha sonra d20 desteği ekleyecek ...

Bakın ve bu dices kötü!

# 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

Başka bir rastgele şey yapmak için rastgele bir şey kullanın: Bu durumda, zar atışları oluşturmak için kartları karıştırın.

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

Bir argüman alır, kalıptaki yüzlerin sayısı. Çıktı şöyle:

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

... vb. tüm kartlar için geçerlidir (kartlar yazdırılmaz). Çok bariz?