I am looking to randomly generate 3 items using a loot table. The loot table currently works as expected, it will randomly generate an item based on the item's rarity. However, I don't want there to be duplicates of the same item. How can I set this up? This script is currently attached to 3 separate GameObject item pedestals.

using System.Collections.Generic;
using UnityEngine;

public class ShopItemSpawner : MonoBehaviour
{
    [System.Serializable]
    public class DropItem
    {
        public string name;
        public GameObject item;
        public int dropRarity;
    }

    public List<DropItem> ShopItemPool = new List<DropItem>();


    private void Start()
    {

        int itemWeight = 0;

        for (int i = 0; i < ShopItemPool.Count; i  )
        {
            itemWeight  = ShopItemPool[i].dropRarity;
        }

        int randomValue = Random.Range(0, itemWeight);

        for (int j = 0; j < ShopItemPool.Count; j  )
        {
            if (randomValue <= ShopItemPool[j].dropRarity)
            {
                Instantiate(ShopItemPool[j].item, transform.position, Quaternion.identity);
                return;
            }
            randomValue -= ShopItemPool[j].dropRarity;

        }
    }
}

CodePudding user response：

You could clone the ShopItemPool list and with each item rolled you remove that item from the list. You then need to go all over again by recalculating the total weight.

I find it useful to have a general purpose class for randomizing items with weights, it allows you do this this:

var randomizer = new WeightRandomizer<DropItem>();

foreach (var shopItem in ShopItemPool) {
    randomizer.Add(shopItem, shopItem.dropRarity);
}

randomizer.Roll(); // Get a random element based on weight.
randomizer.Take(); // Get a random element based on weight and remove it from the randomizer.

General Purpose Weight Randomizer:

public class WeightRandomizer<T> {
    
    [Serializable]
    public class WeightedElement<T> {
        public T value;
        public int weight;

        public WeightedElement (T value, int weight) {
            this.value = value;
            this.weight = weight;
        }
    }
    
    private readonly List<WeightedElement<T>> elements = new();
    
    public void Add (T value, int weight) => elements.Add(new WeightedElement<T>(value, weight));
    public void AddRange (IEnumerable<WeightedElement<T>> weightedElements) => elements.AddRange(weightedElements);
    public int TotalWeight() => elements.Sum(x => x.weight);
    public T Roll() => Pick(false);
    public T Take() => Pick(true);
    
    private T Pick (bool remove) {
        if (elements.Count == 0) {
            Debug.LogWarning($"{nameof(WeightRandomizer<T>)} is missing elements.");
            return default(T);
        }

        var roll = Random.Range(0, TotalWeight());

        var selectedIndex = elements.Count - 1;
        var selected = elements[selectedIndex].value;

        for (var i = 0; i < elements.Count; i  ) {
            var element = elements[i];

            // Found an element with a low enough value.
            if (roll < element.weight) {
                selected = element.value;
                selectedIndex = i;
                break;
            }

            // Keep searching for an element with a lower value.
            roll -= element.weight;
        }

        // Sometimes we want to take and remove the element from the pool.
        if (remove) elements.RemoveAt(selectedIndex);

        return selected;
    }
}