У мене є вікно грабування, яке я хочу заповнити випадковим елементом. Але я хочу, щоб кожен предмет мав різні шанси на вибір. Наприклад:

• 5% шанс на 10 золотих
• 20% шансів меча
• 45% шансів на щит
• 20% шанс броні
• 10% шанс зілля

Як я можу зробити так, щоб я обрав саме один із пунктів вище, де ці відсотки - це відповідні шанси на отримання видобутку?

Рішення ймовірностей з м'яким кодом

Рішення ймовірності з твердим кодом має той недолік, що вам потрібно встановити ймовірності у своєму коді. Ви не можете визначити їх під час виконання. Це також важко підтримувати.

Ось динамічна версія того ж алгоритму.

1. Створіть масив пар фактичних елементів та ваги кожного елемента
2. Коли ви додаєте елемент, вага предмета повинна бути його власною вагою плюс сума ваг усіх елементів, які вже є в масиві. Тож слід відстежувати суму окремо. Тим більше, що вам це знадобиться для наступного кроку.
3. Щоб отримати об'єкт, генеруйте випадкове число від 0 до суми ваг усіх елементів
4. ітератуйте масив від початку до кінця, поки ви не знайдете запис із вагою, більшою або рівною випадковому числу

Ось приклад реалізації на Java у вигляді шаблонного класу, який ви можете створити для будь-якого об'єкта, який використовує ваша гра. Потім ви можете додати об'єкти методом .addEntry(object, relativeWeight)і вибрати одну із записів, яку ви додали раніше.get()

import java.util.ArrayList;
import java.util.List;
import java.util.Random;

public class WeightedRandomBag<T extends Object> {

    private class Entry {
        double accumulatedWeight;
        T object;
    }

    private List<Entry> entries = new ArrayList<>();
    private double accumulatedWeight;
    private Random rand = new Random();

    public void addEntry(T object, double weight) {
        accumulatedWeight += weight;
        Entry e = new Entry();
        e.object = object;
        e.accumulatedWeight = accumulatedWeight;
        entries.add(e);
    }

    public T getRandom() {
        double r = rand.nextDouble() * accumulatedWeight;

        for (Entry entry: entries) {
            if (entry.accumulatedWeight >= r) {
                return entry.object;
            }
        }
        return null; //should only happen when there are no entries
    }
}

Використання:

WeightedRandomBag<String> itemDrops = new WeightedRandomBag<>();

// Setup - a real game would read this information from a configuration file or database
itemDrops.addEntry("10 Gold",  5.0);
itemDrops.addEntry("Sword",   20.0);
itemDrops.addEntry("Shield",  45.0);
itemDrops.addEntry("Armor",   20.0);
itemDrops.addEntry("Potion",  10.0);

// drawing random entries from it
for (int i = 0; i < 20; i++) {
    System.out.println(itemDrops.getRandom());
}

Ось той самий клас, реалізований у C # для вашого проекту Unity, XNA або MonoGame:

using System;
using System.Collections.Generic;

class WeightedRandomBag<T>  {

    private struct Entry {
        public double accumulatedWeight;
        public T item;
    }

    private List<Entry> entries = new List<Entry>();
    private double accumulatedWeight;
    private Random rand = new Random();

    public void AddEntry(T item, double weight) {
        accumulatedWeight += weight;
        entries.Add(new Entry { item = item, accumulatedWeight = accumulatedWeight });
    }

    public T GetRandom() {
        double r = rand.NextDouble() * accumulatedWeight;

        foreach (Entry entry in entries) {
            if (entry.accumulatedWeight >= r) {
                return entry.item;
            }
        }
        return default(T); //should only happen when there are no entries
    }
}

І ось один у JavaScript :

var WeightedRandomBag = function() {

    var entries = [];
    var accumulatedWeight = 0.0;

    this.addEntry = function(object, weight) {
        accumulatedWeight += weight;
        entries.push( { object: object, accumulatedWeight: accumulatedWeight });
    }

    this.getRandom = function() {
        var r = Math.random() * accumulatedWeight;
        return entries.find(function(entry) {
            return entry.accumulatedWeight >= r;
        }).object;
    }   
}

Про:

• Може працювати з будь-якими співвідношеннями ваги. Ви можете мати в наборі предмети з астрономічно малою ймовірністю. Ваги також не потрібно складати до 100.
• Ви можете читати предмети та ваги під час виконання
• Використання пам'яті пропорційно кількості елементів у масиві

Контраст:

• Щоб отримати право, потрібно трохи більше програмування
• У гіршому випадку, можливо, вам доведеться повторити весь масив ( O(n)складність виконання). Тому коли у вас дуже великий набір предметів і малюєте дуже часто, це може стати повільним. Проста оптимізація полягає в тому, щоб спочатку ставити найімовірніші елементи, щоб алгоритм припинявся на ранніх етапах у більшості випадків. Складнішою оптимізацією, яку ви можете зробити, є використання факту сортування масиву та пошуку бісекції. На це потрібен лише O(log n)час.
• Потрібно створити список у пам'яті перед тим, як використовувати його (хоча ви можете легко додавати елементи під час виконання. Також можна буде додавати елементи для видалення, але це потребує оновлення накопиченої ваги всіх елементів, що надходять після видаленого запису, який знову є O(n)найгірший час виконання)

Примітка. Я створив бібліотеку C # для цієї точної проблеми

Інші рішення чудові, якщо у вас є лише невелика кількість предметів і ваші ймовірності ніколи не змінюються. Однак з великою кількістю предметів або зміною ймовірностей (наприклад, вилучення елементів після їх вибору) вам потрібно щось більш потужне.

Ось два найпоширеніших рішення (обидва вони включені до вищезгаданої бібліотеки)

Метод псевдоніма Уокера

Розумне рішення, яке надзвичайно швидко ( O(1)!), Якщо ваші ймовірності постійні. По суті, алгоритм створює 2D дартсборд ("таблицю псевдонімів") з ваших імовірностей і кидає на нього дротик.

В Інтернеті є чимало статей про те, як це працює, якщо ви хочете дізнатися більше.

Єдине питання полягає в тому, що якщо ваші ймовірності змінюються, вам потрібно відновити таблицю псевдонімів, що відбувається повільно. Таким чином, якщо вам потрібно видалити предмети після їх вибору, це не для вас рішення.

Рішення на основі дерева

Іншим поширеним рішенням є створення масиву, де кожен елемент зберігає суму його ймовірності та всіх елементів перед ним. Тоді просто генеруйте випадкове число з [0,1) та виконайте двійковий пошук місця, де ця кількість знаходиться у списку.

Це рішення дуже легко кодувати / зрозуміти, але вибір виходить повільніше, ніж метод псевдоніму Уокера, і зміна ймовірностей все ж є O(n). Ми можемо вдосконалити його, перетворивши масив у дерево бінарного пошуку, де кожен вузол відстежує суму ймовірностей у всіх елементах свого піддерева. Тоді, коли ми формуємо число з [0,1), ми можемо просто спуститися по дереву, щоб знайти предмет, який він представляє.

Це дає нам O(log n)можливість вибрати предмет і змінити ймовірності! Це робить NextWithRemoval()надзвичайно швидко!

Результати

Ось декілька швидких орієнтирів з вищевказаної бібліотеки, порівнюючи ці два підходи

         Показники зваженого рандомізера | Дерево | Таблиця
-------------------------------------------------- ---------------------------------
Додати () x10000 + NextWithReplacement () x10: | 4 мс | 2 мс
Додати () x10000 + NextWithReplacement () x10000: | 7 мс | 4 мс
Додати () x10000 + NextWithReplacement () x100000: | 35 мс | 28 мс
(Додати () + NextWithReplacement ()) x10000 (перемежовано) | 8 мс | 5403 мс
Додати () x10000 + NextWithRemoval () x10000: | 10 мс | 5948 мс

Отже, як ви бачите, для особливого випадку статичних (незмінних) ймовірностей метод Alias ​​Уокера на 50-100% швидший. Але в більш динамічних випадках дерево на кілька порядків швидше !

Рішення «Колесо фортуни»

Ви можете використовувати цей метод, коли ймовірності у вашому пулі елементів мають досить великий спільний знаменник, і вам потрібно витягувати з нього дуже часто.

Створіть масив параметрів. Але введіть у нього кожен елемент кілька разів, при цьому кількість дублікатів кожного елемента пропорційна його шансу з’явитися. У наведеному вище прикладі всі елементи мають ймовірності, що є множниками 5%, тому ви можете створити масив з 20 елементів на зразок цього:

10 gold
sword
sword
sword
sword
shield
shield
shield
shield
shield
shield
shield
armor
armor
armor
armor
potion
potion

Потім просто виберіть випадковий елемент цього списку, генеруючи одне випадкове ціле число між 0 і довжиною масиву - 1.

Недоліки:

• Вам потрібно створити масив у перший раз, коли ви хочете створити елемент.
• Коли один з ваших елементів повинен мати дуже низьку ймовірність, у вас виходить дійсно великий масив, який може зажадати багато пам'яті.

Переваги:

• Коли ви вже маєте масив і хочете отримати з нього кілька разів, то це дуже швидко. Лише одне випадкове ціле число та один доступ до масиву.

Рішення твердо закодованих ймовірностей

Найпростіший спосіб знайти випадковий предмет із зваженої колекції - пройти по ланцюжку тверджень if-else, де кожен if-else напевно збільшується, оскільки попередній не потрапляє.

int rand = random(100); //Random number between 1 and 100 (inclusive)
if(rand <= 5) //5% chance
{
    print("You found 10 gold!");
}
else if(rand <= 25) //20% chance
{
    print("You found a sword!");
}
else if(rand <= 70) //45% chance
{
    print("You found a shield!");
}
else if(rand <= 90) //20% chance
{
    print("You found armor!");
}
else //10% chance
{
    print("You found a potion!");
}

Причина, що умовні умови дорівнюють її шансу плюс усі попередні умовні умови, полягає в тому, що попередні умови вже виключили можливість того, що вони є тими предметами. Отже, для умовного щита else if(rand <= 70)70 дорівнює шансу 45% щита плюс 5% шансу на золото та 20% шансу меча.

Переваги:

• Легко програмувати, оскільки не потребує структур даних.

Недоліки:

• Важко в обслуговуванні, тому що вам потрібно підтримувати свої показники падіння в коді. Ви не можете визначити їх під час виконання. Тож якщо ви хочете чогось більшого підтвердження у майбутньому, слід перевірити інші відповіді.

У C # ви можете використати сканування Linq, щоб запустити свій акумулятор, щоб перевірити випадкове число в діапазоні від 0 до 100,0f та. Перший () для отримання. Так, як один рядок коду.

Тож щось на кшталт:

var item = a.Select(x =>
{
    sum += x.prob;
    if (rand < sum)
        return x.item;
    else
        return null;
 }).FirstOrDefault());

sumє нульовим ініціалізованим цілим числом і aє списком проблем / елементів структур / кортежів / екземплярів. randявляє собою попередньо сформоване випадкове число в діапазоні.

Це просто накопичує суму над списком діапазонів, поки воно не перевищить раніше вибране випадкове число, і повертає або пункт, або нуль, де null буде повернуто, якщо діапазон випадкових чисел (наприклад, 100) менший за загальний діапазон зважування помилково , а вибране випадкове число знаходиться поза загальним діапазоном зважування.

Однак ви помітите, що ваги в ОП тісно відповідають нормальному розподілу (Крива Белла). Я думаю, що в цілому ви не хочете конкретних діапазонів, ви прагнете бажати розподілу, яке звужується або навколо кривої дзвону, або просто на зменшувальній експоненціальній кривій (наприклад). У цьому випадку ви можете просто використовувати математичну формулу для генерування індексу в масиві елементів, відсортованих у порядку бажаної ймовірності. Хороший приклад - CDF при нормальному поширенні

Також приклад тут .

Іншим прикладом є те, що ви можете взяти випадкове значення від 90 градусів до 180 градусів, щоб отримати нижній правий квадрант кола, взяти компонент x за допомогою cos (r) і використовувати його для індексації у пріоритетний список.

За допомогою різних формул у вас може бути загальний підхід, коли ви просто вводите пріоритетний список будь-якої довжини (наприклад, N) і відображаєте результат формули (наприклад: cos (x) - 0 до 1) шляхом множення (наприклад: Ncos (x) ) = 0 до N), щоб отримати індекс.

Ймовірності не потрібно чітко кодувати. Елементи та пороги можуть бути разом у масиві.

for X in items’range loop
  If items (X).threshold < random() then
     Announce (items(X).name)
     Exit loop
  End if
End loop

Вам доведеться все-таки накопичувати пороги, але ви можете це робити, створюючи файл параметрів, а не кодувати його.

Я виконав цю функцію: https://github.com/thewheelmaker/GDscript_Weighted_Random Now! у вашому випадку ви можете використовувати його так:

on_normal_case([5,20,45,20,10],0)

Він дає лише число від 0 до 4, але ви можете помістити його в масив, де ви отримали предмети.

item_array[on_normal_case([5,20,45,20,10],0)]

Або у функції:

item_function(on_normal_case([5,20,45,20,10],0))

Ось код. Я зробив це на GDscript, ви можете, але це може змінити іншу мову, також перевірити логічні помилки:

func on_normal_case(arrayy,transformm):
    var random_num=0
    var sum=0
    var summatut=0
    #func sumarrays_inarray(array):
    for i in range(arrayy.size()):
        sum=sum+arrayy[i]
#func no_fixu_random_num(here_range,start_from):
    random_num=randi()%sum+1
#Randomies be pressed down
#first start from zero
    if 0<=random_num and random_num<=arrayy[0]:
        #print(random_num)
        #print(array[0])
        return 0+ transformm
    summatut=summatut+arrayy[0]
    for i in range(arrayy.size()-1):
        #they must pluss together
        #if array[i]<=random_num and random_num<array[i+1]:
        if summatut<random_num and random_num<=summatut+arrayy[i+1]:
            #return i+1+transform
            #print(random_num)
            #print(summatut)
            return i+1+ transformm

        summatut=summatut+arrayy[i+1]
    pass

Це працює так: on_normal_case ([50,50], 0) Це дає 0 або 1, він має однакову імовірність.

on_normal_case ([50,50], 1) Це дає 1 або 2, це однакова ймовірність і для обох.

on_normal_case ([20,80], 1) Це дає 1 або 2, він має більші зміни, щоб отримати два.

on_normal_case ([20,80,20,20,30], 1) Це дає діапазон випадкових чисел 1-5, і більші числа швидше, ніж менші числа.

on_normal_case ([20,80,0,0,20,20,30,0,0,0,0,33], 45) Цей кидок кісток між числами 45,46,49,50,51,56 ви бачите, коли є це нуль, воно ніколи не виникає.

Таким чином, функція повертає лише одне випадкове число, яке залежить від довжини цього масиву та номера трансформації, а входи в масиві - це ймовірнісні ваги, які може виникнути число, де це число є в масиві, плюс число трансформації.