Is it possible to use a string somehow converted to match name of a bool?

Question

I have a Json file holding data for my LineData type i created.

[Serializable]
public class LineData
{
public string lineID;
public string lineDialog;
public float lineDuration;
public string condition;
}

Note the last one, 'condition', that is what I hope to use to hold a name of a specific bool in my code, so that the line can only be spoken when that bool is true.

Is this a decent way to achieve this? Or is it even possible? I've read about making 'custom markup' on my Json things like (!!) and (->) built in the text to mean stuff in my code, but I don't know where to start with it and cannot find any tutorials (I've only seen it on some Youtube GDC lecture style videos from professional game developers working for companies)

But failing the custom markup thing, if I can somehow use the string of the name of the bool, and use that to check the state of it's corresponding bool in the code, that would be enough for me so far.

Any ideas or help is fantastic and very welcome. Many thanks!!!

(PS. The json looks like this (Im sure you don't need it, but just in case)):

{ "lineDatas":
[
{
    "lineID": "BEDROOM_DAVE_0001",
    "lineDialog": "Yaawwn, up i get for another fun packed day.",
    "lineDuration": 3,
    "condition": ""
},
{
    "lineID": "BEDROOM_DAVE_0002",
    "lineDialog": "Well I think I need a cigarette before I get to work!",
    "lineDuration": 3,
    "condition1": "notSmokedCig"
}
]
}

Answer 1

Storing your boolean condition variables in a dictionary keyed by strings as Patrick Hughes recommends will work just fine, but it can lead to your code being "stringly typed"

If we don't know the full set of condition variables until runtime (eg. if we're running mods/scripts that added more content beyond what's in the compiled game), then this might be the best we can do.

But for stuff that's known at compile time, using strings means relying unnecessarily on every bit of code that reads or writes a particular condition flag to spell & capitalize it identically (or responsibly use the right constant instead of bodging in a literal). A single typo in a string literal somewhere can introduce insidious bugs that the compiler won't be able to detect for you. Also, strings are needlessly heavy to store/compare/hash if a simpler type will do.

We can improve on this method by using an enum to define our variable "slots":

public enum Condition : int {
    HasNotSmokedCigarette,
    HasPetParakeet,
    KnowsTheMacarena,
    SpeaksEsperanto, 
    /* ... add more conditions here */
    ConditionsCount
}

By making the enum backed by an integer type like this, we can cheat a little and use the enum directly as an index into an array of values, and skip the hashing / redundancy of a Dictionary entirely. Putting a "count" entry at the end lets us easily keep the array the right size:

bool[] conditionValues = new bool[(int)Condition.ConditionsCount];

Now we can get & set bools in one of these slots using:

void SetCondition(Condition condition, bool value) {
    conditionValues[(int)condition] = value;
}

bool GetCondition(Condition condition) {
    return conditionValues[(int)condition];
}

We can call these using the enum values like so, keeping compile-time checking & error reporting throughout:

SetCondition(Condition.HasPetParakeet, true);

And finally, the part we've all been waiting for: we can still look them up from strings when necessary:

bool GetCondition(string conditionName) {
    if(string.isNullOrEmpty(conditionName))
        return true;

    Condition condition;
    if(System.Enum.TryParse(conditionName, out condition))
        return GetCondition(condition);

    Debug.LogErrorFormat("Tried to check non-existent condition named {0}", conditionName);
}

Answer 2

It's not uncommon to store the variables used by the scripting system in a Dictionary with a string key. In my opinion, the "stringly typed" argument does not apply in this case, because you already got stringly typing in your JSON data and you won't be able to verify those at compile-time. If you want to confirm that there are no mistyped variable names in your script files, add a way to declare variables to them and do a validation at load-time (Btw: I made the experience that building a sophisticated validation system into your JSON loaders is usually well worth the time investment).

But if you really want the variables in your script files to map to "real" variables on the C# side, then you can use reflection to get the value of a member-variable by its name stored in a string at runtime.

For example, assume you have an object GameState state with a field public bool notSmokedCig and you have a string condition with the value of "notSmokedCig" at runtime, you can do this:

bool conditionIsTrue = (bool) typeof(GameState).GetField(condition).GetValue(state);

I am looking forward to playing your game.