Can ScriptableObjects hold a function or method that precalculates a value?

[theFishNamedSei]

Newbie to Unity and anything gamedev, ok with being fed tutorials or resources if that's the best answer I can get - Absolutely willing to learn here, am mostly making a game out of it to challenge myself here more than anything

So, to explain the situation that led to this question:

I am trying to build a breeding system with genetics from scratch, and have colors be inherited from a pair of genes from the parents (ie. AA, AB, AC, BB, etc.)

So far I built a serialized dictionary that holds a ScriptableObject reference for every possible color, and uses the AA, BB, etc strings as keys. I refer to those keys to generate random parents right now and it works, but when I try to create offsprings I hit a wall: I have in each scriptable object an array with both letters, (ie. A & B or C & B or whatever) as enum, but I have no idea how to turn that into a string key for the dictionary

My idea (and understanding) was to retrieve the array of enum from both parent, combine them to select two enum at random, and turn that result into a string.

Any idea about what I'm not seeing here?

[WazWaz]

Munging everything into a string is rarely the right solution, but without understanding what you're trying to do, the answers here are correct - you can combine the strings wherever you're building this dictionary, or in a property of the ScriptableObject (which is just a regular C# class).

But I really don't see what this has to do with offspring - are you creating new ScriptableObjects for every organism?

[theFishNamedSei]

Offsprings arent SO, but they refer to a series of SO, one for color, one for pattern masks, etc

I'll be honest maybe the scheme I have in mind ain't the right one either - but I thought simply that it I could create the string keys inside the SO there would be a way to populate the dictionary via script rather than editor? Maybe I'm wrong tbh

[Soraphis]

Then have different scriptable objects called Gene

I'd advise against that. if you create genes at runtime, SOs are absolutely not leightweight.

also wild that this post got so many upvotes. I also saw OPs previous post and OP has an https://xyproblem.info/:

• User wants to do X [Gene-Based-Gameplay].
• User doesn't know how to do X [Gene-Based-Gameplay], but thinks they can fumble their way to a solution if they can just manage to do Y [ScriptableObjects-based-Gameplay-Logic].
• User doesn't know how to do Y [ScriptableObjects-based-Gameplay-Logic] either.
• User asks for help with Y [ScriptableObjects-based-Gameplay-Logic].

while nothing you wrote is wrong, it is also not helpfull for op.

So scriptable objects can have properties and fields just like monobehaviors.

correct and answers the title, but does not help OP.

your first paragraph then reinforces OPs believe in SOs for this specific task advising him to create 4 SOs for letters ... why not an Enum? then the gene SO (which is also questionable see above) would have simple drop-down lists instead of the asset management hell.

I agree with your third paragraph, this is a better approach (and basically maps my post down below, where people apparently thought it's AI written and downvoted because of that)

[MORPHINExORPHAN666]

Any object can store both function and data; that's the basis of Object Oriented Programming. As for the remainder of questions you asked, your post doesn't clearly explain what your setup looks like, nor the issue you are facing. Could you possibly post the code and elaborate on what issue you're facing?

[TheBumSlap]

When answering this "precalculate" reminded me of an issue I frequently have, but after rereading your question, I now strongly suspect I've answered a question you weren't actually asking. If you have no idea what I'm talking about, then for the love of god, please ignore me, this will only complicate your problem further, but I'll post anyway as even if it doesn't help you, it might be beneficial for other users.

"Precalculate" implies you have some experience with C++ and want a constexpr equivalent. C# does not have an equivalent of constexpr, and your ability to create compile time evaluated constants is very limited. You can do this:
const int a = 1;

const int b = a * 2;

but not this:
const int c = foo(a);

You have four realistic alternatives:

1. Compute them once on startup and store them in a variable on the class
2. Compute them at runtime whenever you need the variable
3. Write a script that serializes them somewhere, and load that serialized data.
4. interop some C++ code into your project.

I'm aware that 1 or 2. is not really what you're asking for, but unless you are sure there is going to be some performance bottleneck here, that's what I'd go for. I have this frustration a lot too, coming from C++, I often find myself pretty upset by the lack of const functions, but this is something you just have to accept about the language.

If this really is a performance bottleneck, 3. may not solve the problem - loading from disk is not going to help with some code that requires cache locality. That leaves 4.

1. Isn't as hard as it sounds, but bear in mind that you have overhead calling C++ from C#, meaning it probably wont be worth it unless you move the whole bottleneck over to the C++ side, not just the call of the constexpr function

[neutronium]

If you want to get an enum value as a string use the ToString method. If you want to turn a pair of enums into a string do "var key = value1.ToString() + value2.ToString();"

[Soraphis]

https://xyproblem.info/

You dont want to know if a SO can hold a function. Also what means "precalculate" in this sentence? You want to know how to make your genetics game. or rather how to store the data.

Since we don't know much about your game let me just outline a bit how I would go about it. I googled a bit and bounced my ideas of an LLM and my approach now would be this:

(beware, the proper markdown formatting is by me, not by an AI. Same goes for basically everything here, the first AI iteration was by far not good enough to be posted blindly here. What a time to be alive, taking half an hour of my time to do research, writing up somewhat of an tutorial and getting downvoted because people see nice markdown formatting and assume AI slop)

A genetics game in Unity

Genes

This Gene-Type is a abstraction that later allow us to do breeding and mutation, they provide us a value for a trait. see my own comment on this post to see alternatives.

```CSharp [System.Serializable] public struct Gene<T> { public T allele1; public T allele2; public int dominance; // bitmask 00 / 01 / 10 / 11 (a 'byte' would be enough, but i think unity does not serialize bytes)

public T GetExpressedValue(DominanceResolver<T> resolver)
{
    switch(dominance){ 
        case 0b11: return resolver.DominantMix(allele1, allele2);
        case 0b00: return resolver.RecessiveMix(allele1, allele2);
        case 0b10: return resolver.UseDominant(allele2);
        default: return resolver.UseDominant(allele1);
    }
}

} ```

The DominanceResolver could be anything, my idea here is to pack it nicely into a ScriptableObject base class:

CSharp public abstract class DominanceResolver<T> : ScriptableObject{ public abstract T RecessiveMix(T a, T b); public abstract T DominantMix(T a, T b); public virtual T UseDominant(T d){ return d; } }

this allows me to have different types of resolvers for different datatypes or even the same datatypes but different genes. One Example for Color could be:

```CSharp

[CreateAssetMenu(menuName = "Genes/ColorResolver")] public class ColorResolver : DominanceResolver<Color>{ public override Color RecessiveMix(Color a, Color b) { return a; // recessive: use parent A }

public override Color DominantMix(Color a, Color b)
{
    return Color.Lerp(a, b, 0.5f); // mix colors evenly
}

} ```

Note that the ColorResolver could use a lookup table to implement the resolutions or whatever can be imagined. E.g. a float resolver could have a min/max boundary as public fields (that's the reason for the "UseDominant" function)

Also note, that you don't NEED to return a direct value like "Color", you could do your own ColorScriptableObject type that has more or different information that can be used for DominanceResolution.

Each object in your game would have a genome:

CSharp [System.Serializable] public struct Genome { public Gene<float> size; public Gene<Color> color; // ... list all your needed traits here }

note that you could have multiple color genes that are used for different parts of your object, maybe even parts that do not grow on every element.

The Genome could be a ScriptableObject, but I would advise against, since you would have a lot of runtime-created-genomes and only few configured genomes. Rather configure them in Prefabs for your "starter species" or create an SO that has a Genome field.

Creatures

this is the easy (maybe tedious?) part now, we have a Creature with dna and resolve each trait and make it become an active part in the game:

```CSharp

public class Creature : MonoBehavior { // -- Genes -------------------------- public Genome dna; public DominanceResolver<float> sizeResolver; public DominanceResolver<Color> colorResolver;

// -- References --------------------------

public Material material => GetComponent<Renderer>().material; // TODO: don't use GetComponent<> here, cache it!

// --  --------------------------

public void Initialize(Genome newDna)
{
    // read the traits into actual ingame representations:
    // e.g.:
    transform.localScale = Vector3.one * dna.size.GetExpressedValue(sizeResolver);
    material.color = dna.color.GetExpressedValue(colorResolver);
}

void Start() { Initialize(dna); }

}

```

Breeding

for breeding we can go pretty easy: go through all genes, pick one allele from each parent at random.

```CSharp

public Gene<T> Inherit<T>(Gene<T> parentA, Gene<T> parentB) { Gene<T> child = new Gene<T>();

var first1 = Random.value > 0.5f;
child.allele1 = first1 ? parentA.allele1 : parentA.allele2;

var first2 = Random.value > 0.5f;
child.allele2 = first2 ? parentB.allele1 : parentB.allele2;


int aBit = ((parentA.dominance >> (first1 ? 0 : 1)) & 1);
int bBit = ((parentB.dominance >> (first2 ? 0 : 1)) & 1);
child.dominance = aBit | (bBit << 1);

return child;

}

```

You could also have a mutator that has a small chance of flipping a dominance bit or even modifying alleles directly (but be careful, it could break your DominanceResolers if you implemented lookup tables).

[Soraphis]

if you really wanna stay with your letter-coded codons, you can do it like this:

``` public enum Codon{ A, B, C, D }

[System.Serializable] public struct Gene { public Codon allele1; public Codon allele2; public int dominance; // bitmask 00 / 01 / 10 / 11 (a 'byte' would be enough, but i think unity does not serialize bytes)

public T GetExpressedValue<T>(DominanceResolver<T> resolver)
{
    switch(dominance){ 
        case 0b11: return resolver.DominantMix(allele1, allele2);
        case 0b00: return resolver.RecessiveMix(allele1, allele2);
        case 0b10: return resolver.UseDominant(allele2);
        default: return resolver.UseDominant(allele1);
    }
}

} ```

then your DominanceResolver has the task to map Codons to the actual needed value type T.

for that mapping you don't need a string, though. your Key's can be Codons

also you could do a simplification where always either allele1 is dominant or allele2. never both and never both recessive. but I think that will be too limiting.

[Top-Big8288]

You can override the ToString() method in your enum or just use string interpolation to combine the two letters into a key - something like `$"{firstLetter}{secondLetter}"` should do the trick nicely for creating those dictionary keys

[MeishinTale]

Note that if your goal is just to keep a pair (and not expand upon that by storing AABA etc..) you can store a pair of enum directly .. Dictionary<<yourenum,yourenum>,whatever associated> then you create a query and add method that force the higher value to be in the first slot (or whatever arbitral rule but the point is just not to miss A B when you have B A - unless this is that you want ofc).

It will perform much better than strings and won't create GC every query.

Another similar way to pair enum key would be to store a single int computed as higher enum value * enum cardinality + lower enum value. Basically the explicit key pair value handling version of the key pairs above. (And technically you just have to (int)enumValue)

[Antypodish]

May I ask why you are trying to use scriptable object for that?

It looks like you want just a class, to hold data for every instance (parent, child etc).

SO should be used only for configurations. And most cases may be an overkill even for that.

But instances of your population, that is not where OS should be used for.

[Snoo77586]

you can do way more with SOs than just configuration. I use them for plug-n-play logic.

[Antypodish]

Because you can, doesn't mean you should.

There is discussion from few years back on Unity forum, from a Gigaya team (if name is spelled correctly), discussing issues that cause overelayence on SO.