Ich habe eine Beutebox, die ich mit einem zufälligen Gegenstand füllen möchte. Aber ich möchte, dass jeder Gegenstand eine andere Chance hat, ausgewählt zu werden. Beispielsweise:

• 5% Chance auf 10 Gold
• 20% Chance auf Schwert
• 45% Schildchance
• 20% Rüstungschance
• 10% Chance auf Trank

Wie kann ich es schaffen, dass ich genau einen der oben genannten Gegenstände auswähle, bei denen diese Prozentsätze die jeweiligen Chancen auf die Beute darstellen?

Die Lösung für softcodierte Wahrscheinlichkeiten

Die hartcodierte Wahrscheinlichkeitslösung hat den Nachteil, dass Sie die Wahrscheinlichkeiten in Ihrem Code festlegen müssen. Sie können zur Laufzeit nicht ermittelt werden. Es ist auch schwer zu pflegen.

Hier ist eine dynamische Version desselben Algorithmus.

1. Erstellen Sie eine Reihe von Paaren von tatsächlichen Artikeln und dem Gewicht jedes Artikels
2. Wenn Sie einen Artikel hinzufügen, muss das Gewicht des Artikels sein eigenes Gewicht plus die Summe der Gewichte aller Artikel sein, die sich bereits im Array befinden. Sie sollten die Summe also separat verfolgen. Vor allem, weil Sie es für den nächsten Schritt benötigen.
3. Um ein Objekt abzurufen, generieren Sie eine Zufallszahl zwischen 0 und der Summe der Gewichte aller Elemente
4. Durchlaufen Sie das Array von Anfang bis Ende, bis Sie einen Eintrag mit einer Gewichtung gefunden haben, die größer oder gleich der Zufallszahl ist

Hier ist eine Beispielimplementierung in Java in Form einer Vorlagenklasse, die Sie für jedes Objekt, das Ihr Spiel verwendet, instanziieren können. Anschließend können Sie mit der Methode Objekte hinzufügen .addEntry(object, relativeWeight)und einen der zuvor hinzugefügten Einträge auswählen.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
    }
}

Verwendung:

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

Hier ist dieselbe Klasse, die in C # für Ihr Unity-, XNA- oder MonoGame-Projekt implementiert ist:

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

Und hier ist einer in 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;
    }   
}

Profi:

• Kann mit jedem Gewichtsverhältnis umgehen. Sie können Elemente mit astronomisch geringer Wahrscheinlichkeit im Set haben, wenn Sie möchten. Die Gewichte müssen auch nicht zu 100 addieren.
• Sie können die Artikel und Gewichte zur Laufzeit ablesen
• Die Speichernutzung ist proportional zur Anzahl der Elemente im Array

Contra:

• Benötigt etwas mehr Programmierung, um richtig zu werden
• Im schlimmsten Fall müssen Sie möglicherweise das gesamte Array iterieren ( O(n)Laufzeitkomplexität). Wenn Sie also sehr viele Gegenstände haben und sehr oft zeichnen, kann es langsam werden. Eine einfache Optimierung besteht darin, die wahrscheinlichsten Elemente an die erste Stelle zu setzen, sodass der Algorithmus in den meisten Fällen vorzeitig beendet wird. Eine komplexere Optimierung, die Sie durchführen können, besteht darin, die Tatsache auszunutzen, dass das Array sortiert ist, und eine Halbierungssuche durchzuführen. Das braucht nur O(log n)Zeit.
• Sie müssen die Liste im Arbeitsspeicher erstellen, bevor Sie sie verwenden können (obwohl Sie zur Laufzeit problemlos Elemente hinzufügen können. Das Entfernen von Elementen kann ebenfalls hinzugefügt werden. Dazu müssen jedoch die akkumulierten Gewichte aller Elemente aktualisiert werden, die nach dem entfernten Eintrag kommen hat wieder O(n)Worst-Case-Laufzeit

Hinweis: Für genau dieses Problem habe ich eine C # -Bibliothek erstellt

Die anderen Lösungen sind in Ordnung, wenn Sie nur eine kleine Anzahl von Elementen haben und sich Ihre Wahrscheinlichkeiten nie ändern. Bei vielen Elementen oder sich ändernden Wahrscheinlichkeiten (z. B. Entfernen von Elementen nach ihrer Auswahl) möchten Sie jedoch etwas Stärkeres.

Hier sind die beiden häufigsten Lösungen (beide sind in der obigen Bibliothek enthalten)

Walkers Alias-Methode

Eine clevere Lösung, die extrem schnell ( O(1)!) Ist, wenn Ihre Wahrscheinlichkeiten konstant sind. Im Wesentlichen erstellt der Algorithmus eine 2D-Dartscheibe ("Alias-Tabelle") aus Ihren Wahrscheinlichkeiten und wirft einen Pfeil darauf.

Es gibt viele Artikel online darüber, wie es funktioniert, wenn Sie mehr erfahren möchten.

Das einzige Problem ist, dass Sie die Alias-Tabelle, die langsam ist, neu generieren müssen, wenn sich Ihre Wahrscheinlichkeiten ändern. Wenn Sie also Artikel entfernen müssen, nachdem sie kommissioniert wurden, ist dies nicht die richtige Lösung für Sie.

Baumbasierte Lösung

Die andere übliche Lösung besteht darin, ein Array zu erstellen, in dem jedes Element die Summe seiner Wahrscheinlichkeit und aller Elemente davor speichert. Dann generiere einfach eine Zufallszahl aus [0,1] und suche binär, wo diese Zahl in der Liste landet.

Diese Lösung ist sehr einfach zu codieren / zu verstehen, aber das Treffen einer Auswahl ist langsamer als Walkers Alias-Methode, und das Ändern der Wahrscheinlichkeiten ist noch nicht abgeschlossen O(n). Wir können es verbessern, indem wir das Array in einen Binärsuchbaum verwandeln, in dem jeder Knoten die Summe der Wahrscheinlichkeiten in allen Elementen in seinem Unterbaum verfolgt. Wenn wir dann die Zahl aus [0,1] generieren, können wir einfach den Baum hinuntergehen, um das Objekt zu finden, das es darstellt.

Dies gibt uns O(log n)die Möglichkeit, einen Artikel auszuwählen und die Wahrscheinlichkeiten zu ändern! Das macht NextWithRemoval()extrem schnell!

Die Ergebnisse

Im Folgenden finden Sie einige schnelle Benchmarks aus der obigen Bibliothek, in denen diese beiden Ansätze verglichen werden

         WeightedRandomizer Benchmarks | Baum | Tabelle
-------------------------------------------------- ---------------------------------
Add () x10000 + NextWithReplacement () x10: | 4 ms | 2 ms
Add () x10000 + NextWithReplacement () x10000: | 7 ms | 4 ms
Add () x10000 + NextWithReplacement () x100000: | 35 ms | 28 ms
(Add () + NextWithReplacement ()) x10000 (verschachtelt) | 8 ms | 5403 ms
Add () x10000 + NextWithRemoval () x10000: | 10 ms | 5948 ms

Wie Sie sehen, ist die Walker-Alias-Methode für den Sonderfall statischer (sich nicht ändernder) Wahrscheinlichkeiten etwa 50-100% schneller. In den dynamischeren Fällen ist der Baum jedoch um mehrere Größenordnungen schneller !

Die Glücksrad-Lösung

Sie können diese Methode verwenden, wenn die Wahrscheinlichkeiten in Ihrem Artikelpool einen ziemlich großen gemeinsamen Nenner haben und Sie sehr oft daraus zeichnen müssen.

Erstellen Sie eine Reihe von Optionen. Setzen Sie jedoch jedes Element mehrmals ein, wobei die Anzahl der Duplikate jedes Elements proportional zur Wahrscheinlichkeit des Auftretens ist. Im obigen Beispiel haben alle Elemente Wahrscheinlichkeiten, die Multiplikatoren von 5% sind, sodass Sie ein Array mit 20 Elementen wie folgt erstellen können:

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

Wählen Sie dann einfach ein zufälliges Element dieser Liste aus, indem Sie eine zufällige Ganzzahl zwischen 0 und der Länge des Arrays - 1 generieren.

Nachteile:

• Sie müssen das Array erstellen, wenn Sie zum ersten Mal ein Element generieren möchten.
• Wenn eines Ihrer Elemente eine sehr geringe Wahrscheinlichkeit haben soll, haben Sie ein wirklich großes Array, das viel Speicherplatz beanspruchen kann.

Vorteile:

• Wenn Sie das Array bereits haben und mehrmals daraus zeichnen möchten, ist es sehr schnell. Nur eine zufällige Ganzzahl und ein Array-Zugriff.

Die Lösung für hartcodierte Wahrscheinlichkeiten

Der einfachste Weg, ein zufälliges Element aus einer gewichteten Sammlung zu finden, besteht darin, eine Kette von if-else-Anweisungen zu durchlaufen, wobei jedes if-else wahrscheinlich zunimmt, da das vorherige nicht trifft.

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!");
}

Der Grund, warum die Bedingungen gleich der Chance sind, zuzüglich aller vorherigen Bedingungen, ist, dass die vorherigen Bedingungen bereits die Möglichkeit beseitigt haben, dass es sich um diese Elemente handelt. Für die Bedingung des Schildes entsprechen else if(rand <= 70)70 der 45% igen Chance des Schildes plus der 5% igen Chance des Goldes und der 20% igen Chance des Schwertes.

Vorteile:

• Einfach zu programmieren, da keine Datenstrukturen erforderlich sind.

Nachteile:

• Schwer zu pflegen, da Sie Ihre Drop-Raten in Ihrem Code pflegen müssen. Sie können zur Laufzeit nicht ermittelt werden. Wenn Sie also mehr Zukunftssicherheit wünschen, sollten Sie die anderen Antworten überprüfen.

In C # könnten Sie einen Linq-Scan verwenden, um Ihren Akku mit einer Zufallszahl im Bereich von 0 bis 100.0f zu vergleichen und .First () zu erhalten. Also wie eine Codezeile.

Also so etwas wie:

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

sum ist eine null initialisierte ganze Zahl und a eine Liste von prob / item-Strukturen / Tupeln / Instanzen. randist eine zuvor generierte Zufallszahl im Bereich.

Dies summiert einfach die Summe über die Liste der Bereiche, bis sie die zuvor ausgewählte Zufallszahl überschreitet, und gibt entweder das Element oder null zurück, wobei null zurückgegeben würde, wenn der Zufallszahlenbereich (z. B. 100) versehentlich kleiner als der Gesamtgewichtungsbereich ist , und die ausgewählte Zufallszahl liegt außerhalb des gesamten Gewichtungsbereichs.

Sie werden jedoch feststellen, dass die Gewichte in OP einer Normalverteilung (Bell-Kurve) sehr nahe kommen. Ich denke, im Allgemeinen werden Sie keine bestimmten Bereiche wollen, Sie werden eher eine Verteilung wollen, die sich entweder um eine Glockenkurve oder nur auf einer abnehmenden Exponentialkurve (zum Beispiel) verjüngt. In diesem Fall können Sie einfach eine mathematische Formel verwenden, um einen Index für ein Array von Elementen zu generieren, die in der Reihenfolge der bevorzugten Wahrscheinlichkeit sortiert sind. Ein gutes Beispiel ist CDF in normaler Verteilung

Auch ein Beispiel hier .

Ein anderes Beispiel ist, dass Sie einen zufälligen Wert von 90 Grad bis 180 Grad verwenden könnten, um den unteren rechten Quadranten eines Kreises zu erhalten, die x-Komponente mit cos (r) zu nehmen und damit in eine priorisierte Liste zu indexieren.

Mit verschiedenen Formeln könnten Sie einen allgemeinen Ansatz verfolgen, bei dem Sie einfach eine priorisierte Liste beliebiger Länge (z. B. N) eingeben und das Ergebnis der Formel (z. B. cos (x) ist 0 zu 1) durch Multiplikation (z. B. Ncos (x) abbilden ) = 0 bis N), um den Index zu erhalten.

Wahrscheinlichkeiten müssen nicht fest codiert sein. Die Elemente und die Schwellenwerte können zusammen in einem Array sein.

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

Sie müssen die Schwellenwerte noch akkumulieren, können dies jedoch beim Erstellen einer Parameterdatei tun, anstatt sie zu codieren.

Ich habe diese Funktion ausgeführt: https://github.com/thewheelmaker/GDscript_Weighted_Random Now! in deinem Fall kannst du es so benutzen:

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

Es gibt nur eine Zahl zwischen 0 und 4, aber Sie können sie in ein Array einfügen, in dem Sie die Gegenstände erhalten haben.

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

Oder in Funktion:

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

Hier ist der Code. Ich habe es auf GDscript gemacht, das können Sie, aber es kann eine andere Sprache ändern, auch nach logischen Fehlern suchen:

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

Es funktioniert so: on_normal_case ([50,50], 0) Dies ergibt 0 oder 1, es hat beide die gleiche Wahrscheinlichkeit.

on_normal_case ([50,50], 1) Dies ergibt 1 oder 2, beide haben die gleiche Wahrscheinlichkeit.

on_normal_case ([20,80], 1) Dies ergibt 1 oder 2, es gibt eine größere Änderung, um zwei zu erhalten.

on_normal_case ([20,80,20,20,30], 1) Dies ergibt einen Zufallszahlenbereich von 1-5 und größere Zahlen sind wahrscheinlicher als kleinere Zahlen.

on_normal_case ([20,80,0,0,20,20,30,0,0,0,33], 45) Dieser Wurf würfelt zwischen den Zahlen 45,46,49,50,51,56, die Sie sehen, wenn Sie dort sind Null ist, kommt es nie vor.

Die Funktion gibt also nur eine Zufallszahl zurück, die von der Länge des Arrays und der Transformationsnummer abhängt, und die Angaben im Array sind Wahrscheinlichkeitsgewichte, mit denen eine Zahl auftreten kann, bei der sich diese Zahl auf dem Array befindet.