How to make a selective RNG for a game in Python?

Question

This is almost certainly a very novice question, but being as I am a complete novice, I'm fine with that.

To put it simply, I'd like to know how to make a loot drop system in a simple game, where when you achieve a certain objective, you have a chance of getting certain objects more than others. If there are any open-source python games that have this, please refer me to them.

Here is what I know how to do: given a sample [A,B,C,D,E,F], select 3 items.

This is really simple and easy, however, what do I do when I would like to have somethings from the sample be selected more often than others, ie: given sample [A,B,C,D,E,F] have 3 be selected, without repeats, but have A be selected 30% of the time, B 25%, C 20%, D 15%, E 5%, F 5%.

Or, perhaps even better, have no limit (or a ranged limit, eg. 3-5 items) on the amount selected, but have each item in the sample be selected at a different rate and without repeats, so that I could do A 20%, B 20%, C 15%, D 10%, E 2%, F 1%.

Hope this makes sense.

Answer 1

pseudocode:

if(random()<0.2)addloot(a);
if(random()<0.15)addloot(b);
if(random()<0.1)addloot(c);
if(random()<0.02)addloot(d);
if(random()<0.01)addloot(e);

where random is a random number from 0 to 1. This is how it works in all MMORPG.

Answer 2

Here's an easy, lazy way to do it.

Given a list of (item,weight) pairs.

loot = [ (A,20), (B,20), (C,15), (D,10), (E,2), (F,1) ]

Note, the weights don't have to add to anything in particular, they just have to be integers.

One-time preparation step.

choices = []
for item, weight in loot:
    choices.extend( [item]*weight )

Now it's just random.choice( choices ).

Answer 3

Here's a nice recipe if you want a smooth gradation of likelihoods without making an enormous list to sample from:

class WeightedRandom(random.Random):
    """All numbers are random, but some are more random than others.

    Initialise with a weighting curve gamma. gamma=1 is unweighted, >1 returns
    the lower numbers more often, <1 prefers the higher numbers. 
    """
    def __init__(self, gamma):
        self.gamma= gamma # 1 is unweighted, >1 pushes values downwards
        random.Random.__init__(self)
    def random(self):
        return random.Random.random(self)**self.gamma

    # Override the standard sample method, whose pool-based 'optimisation' cocks
    # up weighted sampling. We know result set is small, so no need for dict
    # lookup either.
    #
    def sample(self, population, k):
        if k>=len(population):
            return population
        indexes= []
        for _ in range(k):
            while True:
                index= int(self.random()*len(population))
                if index not in indexes:
                    break
            indexes.append(index)
        return [population[index] for index in indexes]

>>> r= WeightedRandom(0.5)
>>> r.sample(range(100), 3)
[86, 98, 81]

Answer 4

You threw me off a little when you characterized this question as a "very novice" one. It's not as simple as it looks, depending on what kind of behavior you want. BarsMonster's answer is a good one if you don't mind that a lucky player can win all the items and an unlucky player can come away with nothing.

If you want to always select a certain number of items, then I would go with S.Lott's method of picking one item, but use it repeatedly. If you don't want to allow the same item to be selected more than once, you have to remove the chosen item from loot and then rebuild choices between selections. For example (very rough pseudocode):

items_won = random.randint(3, 5)
for i in range(items_won):
    item_won = s_lott_weighted_selection()
    inventory.add(item_won)
    loot.remove(item_won)

Answer 5

An alternative to S.Lott's weighted selection.

Warning - untested code.

import random

def weighted_selection(weights):    
    """returns an index corresponding to the weight of the item chosen"""
    total_sum = sum(weights)
    rnd = random.uniform(0, total_sum)
    cumulative_sum = 0
    for (idx, weight) in enumerate(weights):
        if rnd <= cumulative_sum + weight:
            return idx
        cumulative_sum += weight
    assert(0) # should never get here

weights = [30, 25, 20, 15, 5, 5]
# example of choosing 1 - will return value from 0 to 5
choice = weighted_selection(weights)

# example of choosing 3 such values without repeats
choices = []
for n in range(3):
    new_choice = weighted_selection(weights)
    del weights[new_choice]
    choices.append(new_choice)

You may want to wrap the selection-without-replacement code at the end in some sort of wrapper that ensures the number of unique choices you make never exceeds the number of options available.