Skip to main content
Game Development

Return to Answer

Correcting errors, adding image.
Source Link
DMGregory ♦
DMGregory ♦
  • 140.8k
  • 23
  • 257
  • 401
[System.Serializable]
public struct PrefabEntry {
    #if UNITY_EDITOR
    // This helps it look neater in the inspector.
    [HideInInspector]
    public string name;
    #endif
    public GameObject prefab;
    public float weight;
}

#if UNITY_EDITOR
[SerializeField]
PrefabEntry[] _weightedPrefabs;_weightedPrefabs = new PrefabEntry[0];

void OnValidate() {
    // When the array is modified,
    // update all the entries' names,
    // and total up the weight accounted for.
    float totalWeight = 0f;

    for(int i = 0,0; i < _weightedPrefabs.Length; i++) {
        var entry = _weightedPrefabs[i];
        if(entry.prefab == null)
            continue;

        entry.name = entry.prefab.name;
        _weightedPrefabs[i] = entry;
        totalWeight += entry.weight;
    }

    if (totalWeight == 0f)
        return;

    float reweight = 100f / totalWeight;

    // Create/resize the normalized version.
    if(_normalizedPrefabs == null || _normalizedPrefabs.Length != _weightedPrefabs.Length)
        _normalizedPrefabs = new PrefabEntry [_weightedPrefabs.Length];

    // Fill this array with copies of the original,
    // reweighted to add up to 100
    for(int i = 0,0; i < _weightedPrefabs.Length; i++) {
        var entry = _weightedPrefabs[i];
        if(entry.prefab == null)
            entry.weight = 0f;

        entry.weight *= reweight;
        _normalizedPrefabs[i] = entry;
    }
}
#endif

You'll just need to be careful that all your scripts that consume this data use the _normalized version. If you want to enforce that, you could encapsulate this in a type with a public getter for only the _normalized array.

Here's what it looks like in the Inspector:

Inspector showing a list of named pairs of prefabs & numeric weights

public struct PrefabEntry {
    #if UNITY_EDITOR
    // This helps it look neater in the inspector.
    [HideInInspector]
    public string name;
    #endif
    public GameObject prefab;
    public float weight;
}

#if UNITY_EDITOR
[SerializeField]
PrefabEntry[] _weightedPrefabs;

void OnValidate() {
    // When the array is modified,
    // update all the entries' names,
    // and total up the weight accounted for.
    float totalWeight = 0f;

    for(int i = 0, i < _weightedPrefabs.Length; i++) {
        var entry = _weightedPrefabs[i];
        if(entry.prefab == null)
            continue;

        entry.name = prefab.name;
        _weightedPrefabs[i] = entry;
        totalWeight += entry.weight;
    }

    if (totalWeight == 0f)
        return;

    float reweight = 100f / totalWeight;

    // Create/resize the normalized version.
    if(_normalizedPrefabs == null || _normalizedPrefabs.Length != _weightedPrefabs.Length)
        _normalizedPrefabs = new PrefabEntry [_weightedPrefabs.Length];

    // Fill this array with copies of the original,
    // reweighted to add up to 100
    for(int i = 0, i < _weightedPrefabs.Length; i++) {
        var entry = _weightedPrefabs[i];
        if(entry.prefab == null)
            entry.weight = 0f;

        entry.weight *= reweight;
        _normalizedPrefabs[i] = entry;
    }
}
#endif

You'll just need to be careful that all your scripts that consume this data use the _normalized version. If you want to enforce that, you could encapsulate this in a type with a public getter for only the _normalized array.

[System.Serializable]
public struct PrefabEntry {
    #if UNITY_EDITOR
    // This helps it look neater in the inspector.
    [HideInInspector]
    public string name;
    #endif
    public GameObject prefab;
    public float weight;
}

#if UNITY_EDITOR
[SerializeField]
PrefabEntry[] _weightedPrefabs = new PrefabEntry[0];

void OnValidate() {
    // When the array is modified,
    // update all the entries' names,
    // and total up the weight accounted for.
    float totalWeight = 0f;

    for(int i = 0; i < _weightedPrefabs.Length; i++) {
        var entry = _weightedPrefabs[i];
        if(entry.prefab == null)
            continue;

        entry.name = entry.prefab.name;
        _weightedPrefabs[i] = entry;
        totalWeight += entry.weight;
    }

    if (totalWeight == 0f)
        return;

    float reweight = 100f / totalWeight;

    // Create/resize the normalized version.
    if(_normalizedPrefabs == null || _normalizedPrefabs.Length != _weightedPrefabs.Length)
        _normalizedPrefabs = new PrefabEntry [_weightedPrefabs.Length];

    // Fill this array with copies of the original,
    // reweighted to add up to 100
    for(int i = 0; i < _weightedPrefabs.Length; i++) {
        var entry = _weightedPrefabs[i];
        if(entry.prefab == null)
            entry.weight = 0f;

        entry.weight *= reweight;
        _normalizedPrefabs[i] = entry;
    }
}
#endif

You'll just need to be careful that all your scripts that consume this data use the _normalized version. If you want to enforce that, you could encapsulate this in a type with a public getter for only the _normalized array.

Here's what it looks like in the Inspector:

Inspector showing a list of named pairs of prefabs & numeric weights

Source Link
DMGregory ♦
DMGregory ♦
  • 140.8k
  • 23
  • 257
  • 401

First, I'd make a struct to package together your prefabs and weights, so you can store them in an array without having to juggle so many named variables to figure out which number goes with which prefab.

public struct PrefabEntry {
    #if UNITY_EDITOR
    // This helps it look neater in the inspector.
    [HideInInspector]
    public string name;
    #endif
    public GameObject prefab;
    public float weight;
}

Next we set aside an array of these to use in-game. We'll maintain the invariant that these weights always add to 100.

[SerializeField]
[HideInInspector]
PrefabEntry[] _normalizedPrefabs;

But we hide that version, and instead show an Inspector-only version to the user:

#if UNITY_EDITOR
[SerializeField]
PrefabEntry[] _weightedPrefabs;

void OnValidate() {
    // When the array is modified,
    // update all the entries' names,
    // and total up the weight accounted for.
    float totalWeight = 0f;

    for(int i = 0, i < _weightedPrefabs.Length; i++) {
        var entry = _weightedPrefabs[i];
        if(entry.prefab == null)
            continue;

        entry.name = prefab.name;
        _weightedPrefabs[i] = entry;
        totalWeight += entry.weight;
    }

    if (totalWeight == 0f)
        return;

    float reweight = 100f / totalWeight;

    // Create/resize the normalized version.
    if(_normalizedPrefabs == null || _normalizedPrefabs.Length != _weightedPrefabs.Length)
        _normalizedPrefabs = new PrefabEntry [_weightedPrefabs.Length];

    // Fill this array with copies of the original,
    // reweighted to add up to 100
    for(int i = 0, i < _weightedPrefabs.Length; i++) {
        var entry = _weightedPrefabs[i];
        if(entry.prefab == null)
            entry.weight = 0f;

        entry.weight *= reweight;
        _normalizedPrefabs[i] = entry;
    }
}
#endif

Now every time you make a change, we ensure the version used in-game is adjusted to add up to 100 without changing the original values shown in the inspector.

So if you want to make a coordinated change like setting four prefabs to 25% each and the rest to 0, you can do that in one fell swoop without fighting the renormalizing logic that keeps trying to change your zeroes to1/remainingTotal ;)

You'll just need to be careful that all your scripts that consume this data use the _normalized version. If you want to enforce that, you could encapsulate this in a type with a public getter for only the _normalized array.

One last note: usually for probability math, we'll normalize so the total is 1 instead of 100, but I've left it as 100 above to fit with what you're doing so far.