Comment faire un RNG sélectif pour un jeu en Python?

Question

C'est presque certainement une question très novice, mais étant comme je suis un novice complet, je vais bien avec ça. Pour le dire simplement, j'aimerais savoir comment faire un système de butin dans un jeu simple, où lorsque vous atteignez un certain objectif, vous avez une chance d'obtenir certains objets plus que d'autres. S'il y a des jeux python open-source qui ont ceci, veuillez me les référer.

Voici ce que je sais comment faire: étant donné un échantillon [A, B, C, D, E, F], sélectionnez 3 articles.

Ceci est vraiment simple et facile, cependant, que dois-je faire lorsque je souhaite que certains éléments de l'échantillon soient sélectionnés plus souvent que d'autres, par exemple: échantillon donné [A, B, C, D, E, F ] 3 doivent être sélectionnés, sans répétition, mais A doit être sélectionné 30% du temps, B 25%, C 20%, D 15%, E 5%, F 5%. Ou peut-être même mieux, sans limite (ou une limite à distance, par exemple 3-5 articles) sur la quantité sélectionnée, mais chaque élément de l'échantillon peut être sélectionné à un taux différent et sans répétitions, de sorte que Je pourrais faire A 20%, B 20%, C 15%, D 10%, E 2%, F 1%.

Espérons que cela a du sens.

Answer 1

est ici un moyen facile, paresseux pour le faire.

donné une liste de (item,weight) paires.

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

Remarque, les poids n'ont rien à ajouter à quoi que ce soit, ils doivent simplement être des nombres entiers.

étape de préparation unique.

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

Maintenant c'est juste random.choice(choices).

Answer 2

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

où au hasard est un nombre aléatoire de 0 à 1. Voici comment cela fonctionne dans tous les MMORPG.

Answer 3

Voici une recette bien si vous voulez une gradation lisse de vraisemblances sans faire une liste énorme à l'échantillon de:

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

Vous me secouèrent un peu quand vous Caractérisé cette question comme un « très novice » . Ce n'est pas aussi simple que ça en a l'air, selon le type de comportement que vous voulez. La réponse de BarsMonster est une bonne chose si cela ne vous dérange pas qu'un joueur chanceux puisse gagner tous les objets et qu'un joueur malchanceux puisse repartir sans rien.

Si vous voulez toujours sélectionner un certain nombre d'éléments, alors j'aller avec la méthode de S. Lott de choisir un élément, mais l'utiliser à plusieurs reprises. Si vous ne souhaitez pas autoriser le même élément à être sélectionné plusieurs fois, vous devez supprimer l'élément sélectionné de loot, puis recréer choices entre les sélections. Par exemple (pseudocode très rugueux):

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

Une alternative à la sélection pondérée de S.Lott.

Attention - code non testé.

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) 

Vous pouvez envelopper la sélection, sans remplacement code à la fin dans une sorte d'emballage qui assure le nombre de choix uniques que vous faites ne dépasse jamais le nombre d'options disponibles.