Weighted random number generation with seed and modifiers - algorithm

Question

I try to implement a generation of a complex object based on a weighted elements list.
ListEnum.kt
enum class Elements(weighting:Int){
ELEM1(15),
ELEM2(20),
ELEM3(7),
ELEM4(18)
// function to get weighted random element
companion object{
fun getRandomElement(seed:Long): Elements{
var totalSum = 0
values().forEach {
totalSum += it.weighting
}
val index = Random(seed).nextInt(totalSum)
var sum = 0
var i = 0
while (sum < index) {
sum += values()[i++].weighting
}
return values()[max(0, i - 1)]
}
}
}
MyClass.kt
class MyClass{
fun getRandomElement():RandomElement{
val seed = Random.nextLong()
val element = Elements.getRandomElement(seed)
return RandomElement(element, seed)
}
}
I can persist the seed and recreate the same object with the same seed.
Now I want to modify the weighting in the Elements enum at runtime.
Elements.kt
enum class Elements(weighting:Int){
ELEM1(15),
ELEM2(20),
ELEM3(7),
ELEM4(18)
// function to get weighted random element
companion object{
fun getRandomElement(seed:Long, modifiers:Mods): Elements{
var totalSum = 0
values().forEach {
var modifiedWeighting =it.weighting
if(modifiers.modifier[it] != null){
modifiedWeighting= modifiers.modifier[it].times(modifiedWeighting).toInt()
}
totalSum += modifiedWeighting
}
val index = Random(seed).nextInt(totalSum)
var sum = 0
var i = 0
while (sum < index) {
var newSum = values()[i].weighting
if(modifiers.modifier[values()[i]] != null){
newSum = newSum.times(modifiers.modifier[values()[i]]).toInt()
}
sum += newSum
i++
}
return values()[max(0, i - 1)]
}
}
}
That works for generating random elements with modified weightings, but now I can't recreate the object because the seed does not consider the modifiers.
How can I generate such an object based on modified weightings that I can recreate just from the seed?
UPDATE:
To clarify by what I mean with modifiers. You can see them as a temporary modification of the weight of a specific element.
Modifiers are just float numbers like 1.0f -> keep weight as it is, 2.0f -> double the weight.
So after applying the modifiers, the element enum would look different. But like you can see, the modification is just temporary inside the calculation method.
One possible solution may be to create a static elements enum for every modification I need (they are limited, three or four), e.g.
ElementsModifiedByX, ElementsModifiedByY.
But that seems quiet a dirty solution to me.

Answer 1

I won't try to write Kotlin, but here is a simple strategy.
Instead of keeping your weights in the enum, move them into a structure like this:
{
start_weight: 0,
end_weight: 60,
choices: [(ELEM1, 15, 15), (ELEM2, 20, 35), (ELEM3, 7, 42), (ELEM4, 18, 60))],
}
And now to add weight, you just add onto the list and adjust the end_weight. To remove weight you move start_weight forward far enough then add in new entries for the weights that you accidentally erased. Your seeds are random numbers in the range from start_weight to end_weight. Making the choice can be done with a binary search. And, because you never erase entries, you can reliably reconstruct the same result every time from the same seed.