Saat ini saya sedang berurusan dengan sistem pertarungan multipemain di mana kerusakan yang ditangani oleh para pemain selalu dikalikan dengan faktor acak antara 0,8 dan 1,2.

Secara teori, RNG yang benar-benar acak akhirnya dapat menghasilkan jumlah yang sama beberapa kali (lihat dilema Tetris ). Ini bisa menghasilkan pertandingan di mana pemain selalu membuat kerusakan sangat tinggi sementara yang lain selalu membuat kerusakan sangat rendah.

Apa yang bisa saya lakukan untuk memastikan ini tidak terjadi? Apakah beberapa RNG lebih baik daripada yang lain untuk menghindari pengulangan?

Anda dapat menyelesaikannya dengan cara yang sama dengan Tetris, dengan membuat daftar hasil kerusakan dan pengacakan yang telah ditentukan sebelumnya.

Katakanlah Anda tahu pemain akan menangani kerusakan 0,8x hingga 1,2x dengan distribusi linier. Ambil daftar [0.8, 0.9, 1.0, 1.1, 1.2]. Acak secara acak , jadi Anda mendapatkan misal [1.2, 1.0, 0.8, 0.9, 1.1].

Pertama kali pemain memberikan Damage, mereka melakukan 1.2x. Lalu 1x. Lalu, dll, ke 1.1x. Hanya ketika array kosong Anda harus membuat dan mengocok array baru.

Dalam praktiknya, Anda mungkin ingin melakukan ini ke 4+ array sekaligus (mis. Mulai dengan [0.8.0.8.0.8.0.8.0.9.0.9.0.9.0.9, ...]). Kalau tidak, periode urutannya cukup rendah sehingga pemain dapat mengetahui apakah hit mereka berikutnya "baik" atau tidak. (Meskipun itu juga dapat menambahkan lebih banyak strategi untuk pertempuran, seperti dalam tabel Hoimi Dragon Quest IX , yang orang tahu cara menyelidiki dengan melihat angka penyembuhan dan men-tweak sampai Anda dijamin drop langka.)

Saya sebenarnya menulis beberapa kode untuk melakukan ini . Intinya adalah menggunakan statistik untuk memperbaiki coretan sial. Cara Anda dapat melakukan ini adalah untuk melacak berapa kali peristiwa telah terjadi dan menggunakannya untuk membiasakan nomor yang dihasilkan oleh PRNG.

Pertama, bagaimana kita melacak persentase acara? Cara naif melakukan ini adalah menjaga semua angka yang pernah dihasilkan dalam memori dan rata-rata keluar: yang akan bekerja tetapi sangat tidak efisien. Setelah sedikit berpikir saya datang dengan yang berikut (yang pada dasarnya adalah rata-rata bergerak kumulatif )

Ambil sampel PRNG berikut (tempat kami membeli jika sampel>> 0,5):

Values: 0.1, 0.5, 0.9, 0.4, 0.8
Events: 0  , 1  , 1  , 0  , 1
Percentage: 60%

Perhatikan bahwa setiap nilai berkontribusi hingga 1/5 dari hasil akhir. Mari kita lihat dengan cara lain:

Values: 0.1, 0.5
Events: 0  , 1

Perhatikan bahwa 0kontribusi berkontribusi 50% dari nilai dan 1kontribusi 50% nilai. Diambil sedikit lebih jauh:

Values: [0.1, 0.5], 0.9
Events: [0  , 1  ], 1

Sekarang nilai pertama berkontribusi 66% dari nilai dan 33% terakhir. Kami pada dasarnya dapat menyaring ini ke proses berikut:

result = // 0 or 1 depending on the result of the event that was just generated
new_samples = samples + 1

average = (average * samples / new_samples) + (result * 1 / new_samples)
// Essentially:
average = (average * samples / new_samples) + (result / new_samples)

// You might want to limit this to, say, 100.
// Leaving it to carry on increasing can lead to unfairness
// if the game draws on forever.
samples = new_samples

Sekarang kita perlu mem-bias hasil dari nilai sampel dari PRNG, karena kita akan mencari peluang persentase di sini segalanya jauh lebih mudah (dibandingkan, katakanlah, jumlah kerusakan acak dalam RTS). Ini akan sulit untuk dijelaskan karena 'baru saja terpikir olehku'. Jika rata-rata lebih rendah itu berarti bahwa kita perlu meningkatkan peluang acara terjadi dan sebaliknya. Demikian beberapa contoh

average = 0.1
desired = 0.5
corrected_chance = 83%

average = 0.2
desired = 0.5
corrected_chance = 71%

average = 0.5
desired = 0.5
corrected_change = 50%

Sekarang apa yang 'terpikir oleh saya' adalah bahwa dalam contoh pertama 83% hanya "0,5 dari 0,6" (dengan kata lain "0,5 dari 0,5 ditambah 0,1"). Dalam istilah peristiwa acak yang artinya:

procced = (sample * 0.6) > 0.1
// or
procced = (sample * 0.6) <= 0.5

Jadi untuk menghasilkan suatu acara pada dasarnya Anda akan menggunakan kode berikut:

total = average + desired
sample = rng_sample() * total // where the RNG provides a value between 0 and 1
procced = sample <= desired

Dan karena itu Anda mendapatkan kode yang saya masukkan di intinya. Saya cukup yakin ini semua dapat digunakan dalam skenario kasus kerusakan acak, tapi saya belum meluangkan waktu untuk mencari tahu.

Penafian: Ini semua statistik buatan sendiri, saya tidak punya pendidikan di lapangan. Tes unit saya lulus.

Apa yang Anda minta sebenarnya adalah kebalikan dari kebanyakan PRNG, distribusi non-linear. Cukup masukkan semacam logika pengembalian yang berkurang dalam aturan Anda, Dengan anggapan bahwa segala sesuatu di atas 1,0x adalah "pukulan kritis", katakan saja bahwa setiap putaran peluang Anda untuk mendapatkan kritik naik sebesar X, sampai Anda mendapatkannya di titik mana mereka reset ke Y. Anda kemudian melakukan dua gulungan setiap putaran, satu untuk menentukan crit atau tidak, dan kemudian satu lagi untuk besarnya sebenarnya.

Sid Meier memiliki pidato yang luar biasa di GDC 2010 tentang topik ini dan game Peradaban Saya akan mencoba mencari dan menempelkan tautan nanti. Pada dasarnya, keacakan yang dirasakan tidak sama dengan keacakan yang sebenarnya. Untuk membuat segalanya terasa adil, Anda perlu menganalisis hasil sebelumnya dan memperhatikan psikologi pemain.

Hindari goresan nasib buruk di semua biaya (jika dua belokan sebelumnya tidak beruntung, nasib berikutnya harus dijamin beruntung). Pemain harus selalu lebih beruntung dari lawan AI.

Gunakan bias pergeseran

Generator dasar menggunakan distribusi yang seragam antara dan untuk menghasilkan . Awalnya atur nilai bias, , menjadi .$0$$1$$r$$b$$0$

Distribusi keseluruhan akan menjadi bias dengan rumus berikut:

$r^{\exp (-b)}$

Efeknya di sini adalah bahwa ketika positif, jumlah yang dihasilkan akan menjadi bias terhadap . Ketika negatif, angka yang dihasilkan akan bias menuju .$b$$1$$b$$0$

Ambil nomor ini dan skala sesuai dengan kisaran yang diinginkan.

Setiap kali seorang pemain berguling dengan baik, kurangi dari bias. Setiap kali pemain berputar dengan tidak baik, tambahkan ke bias. Jumlah yang diubah dapat diskalakan dengan seberapa (tidak) menguntungkan gulungan itu atau bisa menjadi jumlah yang datar (atau kombinasi). Anda perlu menyesuaikan nilai-nilai spesifik agar sesuai dengan perasaan yang Anda inginkan.