予測可能なランダムジェネレーターの必要性

私はウェブゲームの開発者で、乱数に問題がありました。プレーヤーが剣でクリティカルヒットを得る確率が20％であるとしましょう。つまり、5ヒットのうち1ヒットが重要です。問題は、実際の結果が非常に悪いことです。5ヒットで3クリティカル、15ヒットでまったくクリティカルにならない場合があります。戦いはかなり短い（3-10ヒット）ので、良いランダム分布を得ることが重要です。

現在はPHPを使用していますがmt_rand()、コードをC ++に移動しているだけなので、ゲームの新しいエンジンでこの問題を解決したいと考えています。

解が均一な乱数発生器であるかどうか、または適切な分布を強制するために以前のランダムな状態を覚えているかもしれません。

一部のゲームの小規模な実行における真のランダム性は望ましくないという以前の回答に同意します-一部のユースケースでは不公平に思えます。

Rubyでの実装のような単純なシャッフルバッグを作成し、いくつかのテストを行いました。実装はこれを行いました：

• それでもフェアであると思われる場合、または最小ロールのしきい値に達していない場合は、通常の確率に基づいてフェアヒットを返します。
• 過去のロールから観測された確率が不公平に見える場合、「公正な」ヒットを返します。

境界確率に基づいて不公平と見なされます。たとえば、20％の確率で、10％を下限、40％を上限として設定できます。

これらの範囲を使用して、10ヒットの実行で、実際の疑似ランダム実装が14.2％の時間でこれらの範囲外の結果を生成したことがわかりました。時間の約11％で、10回の試行で0のクリティカルヒットが記録されました。3.3％の確率で、5回以上のクリティカルヒットが10から発生しました。当然、このアルゴリズムを使用して（最小ロールカウントは5）、「フェアリー」ランのはるかに少ない量（0.03％）が範囲外でした。 。以下の実装が不適切な場合でも（確かにもっと賢いことが可能です）、実際の疑似ランダムソリューションでは不公平であるとユーザーが感じることは注目に値します。

FairishBagRubyで書かれた私の肉は次のとおりです。実装全体とクイックモンテカルロシミュレーションは、こちらから入手できます（要旨）。

def fire!
  hit = if @rolls >= @min_rolls && observed_probability > @unfair_high
    false
  elsif @rolls >= @min_rolls && observed_probability < @unfair_low
    true
  else
    rand <= @probability
  end
  @hits += 1 if hit
  @rolls += 1
  return hit
end

def observed_probability
  @hits.to_f / @rolls
end

更新：この方法を使用すると、クリティカルヒットが発生する可能性が全体的に増加し、上記の範囲を使用すると約22％になります。「実際の」確率を少し低く設定することで、これを相殺できます。フェアリッシュな修正を加えた17.5％の確率は、約20％の観測された長期確率をもたらし、短期の実行を公平に保ちます。

つまり、5ヒットのうち1ヒットが重要です。問題は、実際の結果が非常に悪いことです。5ヒットで3クリティカル、15ヒットでまったくクリティカルにならない場合があります。

必要なのはシャッフルバッグです。真のランダムがゲームにとってランダムすぎるという問題を解決します。

アルゴリズムは次のようなものです。1つのクリティカルヒットと4つの非クリティカルヒットをバッグに入れます。次に、バッグの順序をランダムにして、一度に1つずつ取り出します。バッグが空の場合は、同じ値を再度入力してランダム化します。このようにして、5ヒットあたり平均1クリティカルヒット、最大で2クリティカルヒットと8ノンクリティカルヒットを続けて取得できます。バッグ内のアイテムの数を増やしてランダム性を高めます。

これは、（Javaでの）実装の例と、前に書いたテストケースです。

ランダムの意味が誤解されています。

これらのうちどれがよりランダムですか？

2番目のプロットはより均等に分布しているように見えますが、実際にはよりランダムなものが最初のプロットです。人間の心はパターンをランダムに見ることが多いので、最初のプロットの塊はパターンとして見えますが、そうではなく、ランダムに選択されたサンプルの一部にすぎません。

あなたが求めている振る舞いを考えると、あなたは間違った変数をランダム化していると思います。

このヒットがクリティカルになるかどうかをランダム化するのではなく、次のクリティカルヒットが発生するまでターン数をランダム化してみてください。たとえば、プレーヤーがクリティカルを取得するたびに2から9までの数を選択し、そのラウンド数が経過した後に次のクリティカルを与えるだけです。サイコロの方法を使用して正規分布に近づけることもできます。たとえば、2D4ターンで次のクリティカルを取得します。

このテクニックは、地上でもランダムに遭遇するRPGで使用されると思います。ステップカウンターをランダム化し、その数のステップの後で、再びヒットします。2回続けて遭遇することはほとんどないので、より公平に感じられます。それが一度でも発生すると、プレイヤーはイライラします。

まず、「適切な」分布を定義します。乱数はまあ、ランダムです-あなたが見ている結果は（疑似）ランダム性と完全に一致しています。

これをさらに拡大すると、「フェアネス」の感覚が欲しいと思うので、ユーザーは100ターン成功することができません。もしそうなら、私は最後の成功以降の失敗の数を追跡し、生成された結果に重みを付けます。5分の1のロールで「成功」したいとしましょう。したがって、1から5までの数をランダムに生成し、5の場合は素晴らしいです。

そうでない場合は、失敗を記録し、次に1から5までの数を生成しますが、たとえば、floor（numFailures / 2）を追加します。したがって、今回も、5分の1のチャンスがあります。それらが失敗した場合、次回の勝ちの間隔は4 と 5です。成功の5分の2の確率。これらの選択により、8つの失敗の後、それらは確実に成功します。

mt_rand（）をこのようなものに置き換えてみませんか？

（RFC 1149.5は、標準のIEEE検査済み乱数として4を指定しています。）

XKCDから。

この記事がお役に立てば幸いです：http : //web.archive.org/web/20090103063439/http : //www.gamedev.net :80/reference/design/features/randomness /

「乱数」を生成するこの方法は、rpg / mmorpgゲームでは一般的です。

それが解決する問題はこれです（抜粋）：

ブレードスパイダーが喉に近づいています。ヒットしてミス。それは再びヒットし、あなたは再びミスします。そして、何度も何度も、あなたに当たるものがなくなるまで。あなたは死んでいて、死体の上に2トンのクモが浮かんでいます。不可能な？いいえ、ありそうですか？はい。しかし、十分なプレーヤーと十分な時間が与えられれば、ありえないことはほぼ確実になります。ブレードスパイダーが硬かったのではなく、不運だった。いらいらする。プレイヤーをやめたければ十分です。

必要なのは乱数ではなく、人間にはランダムに見える数字です。他の人は、Shuffle Badのように、あなたを助けることができる個々のアルゴリズムをすでに提案しています。

このドメインの詳細で広範な分析については、AI Game Programming Wisdom 2を参照してください。本全体はどのゲーム開発者にとっても読む価値があります。「一見すると乱数」という考えは章で処理されます。

AIの決定とゲームロジックのフィルタリングされたランダム性：

要約：従来の知識では、乱数発生器が優れているほど、ゲームの予測が難しくなることが示唆されています。ただし、心理学の研究によると、短期間の真のランダム性は、多くの場合、人間には明らかにランダムであるように見えます。この記事では、強力な統計的ランダム性を維持しながら、ランダムなAIの決定とゲームロジックをプレイヤーにとってよりランダムに見えるようにする方法を示します。

別の章も興味深いかもしれません：

乱数の統計

要約：乱数は、人工知能およびゲーム一般で最も頻繁に使用されます。彼らの可能性を無視することは、ゲームを予測可能で退屈なものにすることです。それらを誤って使用することは、完全にそれらを無視するのと同じくらい悪いことです。乱数がどのように生成されるか、それらの制限と機能を理解することで、乱数をゲームで使用する際の多くの困難を取り除くことができます。この記事では、乱数、その生成、および良いものと悪いものを区別する方法についての洞察を提供します。

確かに任意の乱数生成がそのような実行を生成する可能性がありますか？適切なパーセンテージを表示するのに十分な大きさのサンプルセットを3〜10個のロールで取得することはありません。

たぶん、あなたが望むのは慈悲のしきい値でしょう...最後の10のロールを思い出してください。クリティカルヒットがなかった場合は、景品をあげてください。ランダムのスリングと矢印を滑らかにします。

最善の解決策は、複数の異なる非ランダムスキームを使用してプレイテストを行い、プレイヤーを最も幸せにするものを選択することです。

たとえば、プレーヤーが1最初のターンにを出してそれを受け入れた場合など、特定のエンカウンターで同じ番号に対してバックオフポリシーを試すこともできます。別のものを手に入れるために、1彼らは2 1秒続けて振る必要があります。3分の1を取得するに1は、連続して3 が必要です。

残念ながら、あなたが求めているのは事実上、非乱数ジェネレータです-次の数を決定するときに以前の結果を考慮に入れたいからです。これは、乱数発生器がどのように機能するかではありません。

5ヒットごとに1クリティカルにする場合は、1から5までの数値を選択して、そのヒットがクリティカルになると言います。

mt_rand（）はMersenne Twisterの実装に基づいています。これは、取得できる最良のランダム分布の1つを生成することを意味します。

どうやら必要なのはランダム性ではないので、必要なものを正確に指定することから始める必要があります。期待が矛盾していることに気づくでしょう-結果は真にランダムで予測不可能であると同時に、指定された確率からの局所的な変動を示さないはずですが、その後予測可能になります。連続して最大10の非クリティカルを設定した場合は、「連続して9の非クリティカルがあった場合、次のクリティカルは100％の確率でクリティカルになる」とプレイヤーに伝えたことになります。まあ、ランダム性はまったく気になりません。

このような少数のテストでは、次のような結果が期待できます。

真のランダム性は巨大なセットサイズでのみ予測可能です。つまり、コインを裏返して最初に3回続けて表を出すことは十分に可能ですが、数百万回以上の裏返しでは、結果として約50〜50になります。

以前に生成された数値を追跡すること、またはすべての可能な値をシャッフルすることを提案する多くの回答が表示されます。

個人的に、私は同意しません、連続して3つのクリティカルが悪いことです。また、連続して15の非クリティカルが悪いことにも同意しません。

私は、各数値の後に、クリティカルチャンスを修正することで、問題を解決します。例（アイデアを示すため）：

int base_chance = 20;
int current_chance = base_chance;

int hit = generate_random_number(0, 100) + 1; // anything from 1 to 100
if(hit < current_chance)//Or whatever method you use to check
{
    //crit!
    if(current_chance > base_chance)
        current_chance = base_chance; // reset the chance.
    else
        current_chance *= 0.8; // decrease the crit chance for the NEXT hit.
}
else
{
    //no crit.
    if(current_chance < base_chance)
        current_chance = base_chance; // reset the chance.
    else
        current_chance *= 1.1; // increase the crit chance for the NEXT hit.
    //raise the current_chance
}

クリティカルが長くならないほど、次のアクションがクリティカルになる可能性が高くなります。私が含めたリセットは完全にオプションであり、それが必要かどうかを判断するにはテストが必要です。クリティカルではない長いアクションチェーンの後で、連続する複数のアクションに対してクリティカルの確率が高くなることが望ましい場合と望ましくない場合があります。

私の2セントを投入するだけ...

上位のいくつかの回答は優れた説明であるため、「不良ストリーク」の確率を制御しながら、決定論的になることのないアルゴリズムに焦点を当てます。これはあなたがすべきだと私が思うことです：

代わりに、指定のP、クリティカルヒットのあなたの確率であるベルヌーイ分布のパラメータを指定し、Bをベルヌーイ分布の「共役前」、ベータ分布のパラメータを設定します。これまでのクリティカルヒットと非クリティカルヒットの数であるAとBを追跡する必要があります。

ここで、aおよびbを指定するために、クリティカルヒットの可能性であるa /（a + b）= pであることを確認します。（a + b）は、A /（A + B）を一般にpにどの程度近づけたいかを数値化したものです。

次のようにサンプリングを行います。

をp(x)ベータ分布の確率密度関数とします。多くの場所で入手できますが、GSLでgsl_ran_beta_pdfとして見つけることができます。

S = A+B+1
p_1 = p((A+1)/S)
p_2 = p(A/S)

確率p_1 /（p_1 + p_2）でベルヌーイ分布からサンプリングしてクリティカルヒットを選択します

あなたは、ランダムな数字があまりにも多くの「悪いすじ」を持っていることが判明した場合、スケールアップおよびbは、しかし限界で、ようやbは無限大に行く、あなたはシャッフルバッグアプローチは、先に説明しています。

これを実装する場合は、どうなるか教えてください！

繰り返し値を落とす分布が必要な場合は、単純な繰り返し拒否アルゴリズムを使用できます。

例えば

int GetRand(int nSize)
{
    return 1 + (::rand() % nSize);
}
int GetDice()
{
    static int nPrevious=-1;
    while (1) {
        int nValue = GetRand(6);
        // only allow repeat 5% of the time
        if (nValue==nPrevious && GetRand(100)<95)
            continue;
        nPrevious = nValue;
        return nValue;
    }
}

このコードは、95％の確率で繰り返し値を拒否するため、繰り返しはほとんどありませんが不可能ではありません。統計的には少し見苦しいですが、おそらくあなたが望む結果を生み出すでしょう。もちろん、「5 4 5 4 5」のような配布を妨げることはありません。あなたはより巧妙になって、最後の（たとえば）60％の時間を拒否し、3番目の（たとえば）30％を拒否することができます。

これは良いゲームデザインとしてはお勧めしません。単にあなたが望むものを達成する方法を提案しています。

あなたが何を望んでいるかは本当にはっきりしていません。最初に5回呼び出すと、ランダムな順序で1〜5の数値が返されるように関数を作成できます。

しかし、それは本当にランダムではありません。プレーヤーは、次の5つの攻撃でちょうど1つの5を獲得することを知っています。それはあなたが望むものかもしれません、そしてその場合、あなたは単にあなた自身でそれをコーディングしなければなりません。（数値を含む配列を作成し、それらをシャッフルします）

あるいは、現在のアプローチを使い続け、現在の結果がランダムジェネレーターの不良によるものであると想定することもできます。現在の数字に問題はないことに注意してください。ランダムな値はランダムです。時には、同じ値の2、3、または8が連続して表示されることがあります。ランダムだからです。優れたランダムジェネレーターは、平均してすべての数値が均等に返されることを保証します。

もちろん、悪い乱数発生器を使用している場合は、結果が歪んでいる可能性があります。その場合は、より良い乱数発生器に切り替えるだけで問題が解決するはずです。（より良いジェネレーターについては、Boost.Randomライブラリーをチェックしてください）

あるいは、ランダム関数によって返された最後のN個の値を覚えて、それらの結果を比較することもできます。（簡単な例は、「新しい結果が発生するたびに、値を破棄して新しい値を取得する必要がある確率は50％です。」

推測しなければならないのであれば、「実際の」ランダム性を守ることが最善の策だと思います。優れたランダムジェネレーターを使用していることを確認してから、今のやり方を続けてください。

1から5までの数値を含むリストを作成し、ランダムに並べ替えることができます。次に、作成したリストを確認します。少なくとも1回はすべての数字に出会うことが保証されています...最初の5個が終わったら、さらに5個の数字を作成してください...

私はブリザードが使用するような漸進的な割合システムをお勧めします： http //www.shacknews.com/onearticle.x/57886

通常、RNGをロールしてから、それを値と比較して、成功したかどうかを判断します。次のようになります。

if ( randNumber <= .2 ) {
   //Critical
} else {
   //Normal
}

あなたがする必要があるのは、ベースチャンスの漸進的な増加を追加することです...

if (randNumber <= .2 + progressiveChance ) {
   progressiveChance = 0;
   //Critical
} else {
   progressiveChance += CHANCE_MODIFIER;
   //Normal hit
}

もっと豪華にしたい場合は、追加するのは簡単です。あなたは、progressiveChanceが100％のクリティカルチャンスを回避したり、特定のイベントでリセットしたりできる量に上限を設けることができます。また、プログレッシブチャンス+ =（1-プログレッシブチャンス）* SCALE（SCALE <1）のように、ブーストごとに少しずつプログレッシブチャンスを増やすこともできます。

まあ、あなたが数学に少し興味があるなら、おそらく指数分布を試すことができます

たとえば、ラムダ= 0.5の場合、期待値は2です（その記事を読んでください！）。これは、2ターンごとにヒット/クリティカル/何でも（50％など）ヒットすることを意味します。ただし、このような確率分布では、0ターン（イベントが既に発生しており、turn_counterがリセットされているターン）で、かなりミスする（または何と反対になる）と、次のターンにヒットする確率は40％、約65％になります。 2回目（次の次のターン）にそれを行うチャンス、約80％で3回目をヒット、など。

その分布の全体的な目的は、50％のヒットチャンスがあり、連続して3回ミスした場合、彼は確実に（まあ、80％を超える確率でヒットし、次のターンごとに増加します）ヒットです。これにより、より公平な結果が得られ、50％を超える確率が変更されません。

クリティカルの20％の確率で、

• 17％で第1ターンをクリティカル
• 以前のすべてでクリティカルが発生しなかった場合、2ターン目にクリティカルする32％。
• 以前のすべてでクリティカルが発生しなかった場合、45％で3ターン目をクリティカルします。
• 以前のすべてでクリティカルが発生しなかった場合、4ターンをクリティカルする54％。
• ...
• 以前のすべてでクリティカルが発生しなかった場合、8ターン目のクリティカルの80％。

それでも、約0.2％（対5％）の確率で、3クリティカル+ 2ノンクリティカルの確率が5ターン発生します。そして、4つの結果としての非クリティカルの可能性は14％、5のうちの5％、6では1.5％、7では0.3％、8つの結果としての非クリティカルでは0.07％です。41％、32％、26％、21％、16％よりも「公平」だと思います。

あなたがまだ死ぬほど退屈していないことを願っています。

クリティカルの可能性を作ることについては、最後のN攻撃に依存します。単純なスキームの1つは、マルコフチェーンの一種です。http：//en.wikipedia.org/wiki/Markov_chainですが、コードは非常に単純です。

IF turns_since_last_critical < M THEN 
   critial = false
   turns_since_last_critical++;
ELSE
   critial = IsCritical(chance);
   IF Critial THEN
       turns_since_last_critica = 0;
   ELSE
       turns_since_last_critica++;
   END IF;
END IF;

もちろん、最後のターンから十分なターンであることがわかったら、クリティカルの可能性はクリティカルの可能性よりも低いため、計算を行う必要があります。

OP、

ほとんどの場合、それを公平にしたい場合は、ランダムではありません。

あなたのゲームの問題は、実際の試合の長さです。一致が長ければ長いほど、ランダムさが少なくなり（クリティカルは20％になる傾向があります）、意図した値に近づきます。

前のロールに基づいて攻撃を事前に計算する2つのオプションがあります。5回の攻撃（20％に基づく）ごとに1つのクリティカルを取得しますが、ランダムに発生する順序を作成できます。

listOfFollowingAttacks = {ヒット、ヒット、ヒット、ミス、クリティカル};

それがあなたが望むパターンです。そのリストからランダムに選択させ、空になるまで再作成します。

それは私が自分のゲーム用に作成したパターンであり、私がやりたいことに対して、それはかなりうまくいきます。

2番目のオプションは、批判の可能性を高めることです。おそらく、すべての攻撃の最後に偶数がより多く表示されます（一致がかなり早く終了すると想定）。確率が低いほど、RNGが多くなります。

正規分布が必要な場合に、線形分布を調べています。

若者がD＆Dをプレイしていたことを思い出すと、複数のn面サイコロを振って結果を合計するように求められました。

たとえば、4 x 6面のサイコロを振るのは、1 x 24面のサイコロを振るのとは異なります。

City of Heroesには、この問題を正確に解決する「ストリークブレーカー」と呼ばれるメカニズムがあります。それが機能する方法は、文字列内の最も低いヒット確率に関連する長さの一連のミスの後で、次の攻撃がヒットであることが保証されることです。たとえば、ヒット率が90％を超える攻撃を逃した場合、次の攻撃は自動的にヒットしますが、ヒット率が60％のように低い場合、「ストリークブレーカー」をトリガーするために連続して数回ミスする必要があります（正確な数がわからない）

これは本当に予測可能です...しかし、あなたは確信が持てません。

値の重み付けはどうですか？

たとえば、クリティカルヒットの可能性が20％の場合、1から5までの数値を生成し、1つの数値がクリティカルヒットを表すか、1から100までの数値を生成し、20の数値がクリティカルヒットであることを示します。

ただし、乱数または疑似乱数を使用している限り、現在表示されている結果を潜在的に回避する方法はありません。それはランダム性の性質です。

反応：「問題は、実際の結果が非常に悪いことです。5ヒットで3クリティカル、15ヒットでまったくクリティカルにならない場合があります。」

15ヒットで何も得られない確率は3〜4％です...

次の「ランダムに遅延されたプットバックダイ」を提案します。

• 2つの配列を維持します。1つは（in-array）最初は0からn-1までの値で埋められ、もう1つは（out-array）空です
• 結果が要求された場合：
  • すべてからランダムな値を返す定義された値でin-array
  • この値をからin-arrayに移動しますout-array
  • 1つのランダムな要素（未定義を含むすべての要素上）をout-array後ろからin-array

これには、nが大きいほど「反応」が遅くなるという性質があります。たとえば、20％の確率が必要な場合、nを5 に設定して0を打つことは、nを10に設定して0または1を打つよりも「ランダム性が低く」、1000のうち0から199にすることはほぼ小さなサンプルの真のランダム性と区別がつかない。nをサンプルサイズに調整する必要があります。

各プレイヤーのランダムクリティカルヒットを事前に計算します。

// OBJECT
//...
// OnAttack()
//...
c_h = c_h -1;
if ( c_h == 0 ) {
 // Yes, critical hit!
 c_h = random(5) + 1 // for the next time
 // ...
}

おそらく、あなたは間違ったランダム分布関数を使用していると思います。おそらく、数値を均等に分散したくないでしょう。代わりに正規分布を試して、クリティカルヒットが「通常の」ヒットよりも一般的でないようにします。

私はJavaを使用しているので、正規分布で乱数を提供するC ++のどこを見つけることができるかわかりませんが、そこに何かがあるはずです。