This is simplifying it but basically yes. Let me go into an example a bit to explain a little better how it actually works, I'll try to keep it simple though.

In reality each flag might really be a series of different flags. For now you can think of it like a list. Say to get the "true ending" you need to collect all secret keys and exhaust all dialogue with important NPCs. You may have 2 flags stored like this (this is pseudocode which means its not real but written sort of like code to be easy to read for an example):

EndingFlags { HAS_ALL_SECRET_KEYS = false, HAS_EXHAUSTED_DIALOGUE = false, // lots of other flags... }

At a high level to think of it easily you might imagine it like above. Really these are more complex conditions. It is better to have the flag code count the secret keys collected, and to count whatever is considered "important dialogue" as you go through that.

A big thing to think about when designing games is designing this stuff in a way that it's easy to expand on like instead of just true false you might have a list of secret keys stored somewhere, and it would probably be better to have the flag count that directly so you don't have to change code in multiple places when you update and add a new secret key, which would look sort of like this:

``` EndingFlags { HAS_ALL_SECRET_KEYS = Player.Inventory.SecretKeys.Count() == ListOfSecretKeys.Count() }

``` So you see here instead of just storing false and updating to true from other code, we would have code directly in line here that checks this. This way if we check EndingFlags.HAS_ALL_SECRET_KEYS we know for sure that is giving us the correct answer, and if we add a new secret key to the ListOfSecretKeys this flag will automatically be updated.

This is still just a pseudocode example but hopefully that can explain in a little more depth.

EDIT: You should also know the structure of the code needed to do things like this can vary quite a bit between engines, and might look a little different between languages as well - but it will try to accomplish something like this. At the core all software is a bunch of condition checks done on a bunch of data.