Make store_variable and get_variable meet expectations and just work

[shak2]

File/save operations are a reccuring problem for new users for something that should be common and trivial.

Inevitably they all try using store_var and get_var, which feels correct but does not do what they think (which is storing and loading a variable).

PROPOSAL - Make easy to understand just works gdscript functions for saving and loading a generic non typed variable to a given file save path. So beginners can simply use store_variable(savepath, variable_name) and get_variable(savepath, variable_name) and GDscript does the magic behind the scenes (make/load the dictionaries etc.).

Pro users can still use the existing properties like they already do and this will not affect them.

END OF PROPOSAL

Thank you.

[AThousandShips]

That's not what they do and not what the documentation says, so I'm unsure where the confusion comes from:

Stores any Variant value in the file.

Why would you need to store just one variable with no other data, and why is it not just as easy to use:

var fa := FileAccess.open(path, FileAccess.WRITE)
fa.store_var(my_data)

It's just one additional line and it can do so much more

There's even detailed tutorials on this

Adding a method just for people who are absolute beginners and can't read the documentation feels unnecessary

[shak2]

var fa := FileAccess.open(path, FileAccess.WRITE)
fa.store_var(my_data)

When you try to get your variablle this code will produce the standard error all beginners face:

"Invalid type in function 'get_var' in base '_File'. Cannot convert argument 1 from --- to bool."

What does this even mean? Well, turns out var means variant and it's a whole thing to read and absorb when all you want to do is simply save and load the variables you made.

It is currently one of those things where suddenly the exact technical definition and deep understanding of what var means (Variant) is needed. This is jarring for new users and unneccessarily deep for users just simply wanting to save and load a variable or variables between game loads without going down the Variant rabbit hole (which is an advanced level topic).

Pros can of course use this functionality too (and I think many will) or stick to their deeper functionality they already enjoy, it would not be for only beginners!

[AThousandShips]

I have no clue but that doesn't happen for me, are you using exactly this code?

For this you should open a report over here, but this isn't going to be different with your suggestion, either your data is broken or there's some bug in the core code, this won't change that

[shak2]

First comment here:

https://www.reddit.com/r/godot/comments/xdxy2s/cant_make_savingloading_variable_why/

[AThousandShips]

Please follow the documentation, you don't pass this arguement, that's documented, the argument is for reading objects, as someone responded with two years ago https://www.reddit.com/r/godot/comments/xdxy2s/comment/iodnssl/

Please read the documentation to learn how to use this correctly

[AThousandShips]

Also if you need this you can just add your own autoload or static method to do this, something like:

extends Object
class_name LoadSaveHelper

static func get_variable(path: String, allow_objects: bool = false) -> Variant:
    var fa := FileAccess.open(path, FileAccess.READ)
    if fa:
        return fa.get_var(allow_objects)
    
    return Variant()

static func store_variable(path: String, value: Variant, full_objects: bool = false) -> bool:
    var fa := FileAccess.open(path, FileAccess.WRITE)
    if fa:
        fa.store_var(value, full_objects)
        return true
    
    return false

Haven't tested but should work fine, you just call LoadSaveHelper.get_variable(...) and LoadSaveHelper.store_variable(...)

[AThousandShips]

But if you're speaking specifically about loading one of several values from a file, that's not something that's trivial to make, nor is it something that you just make universally, and I don't know why people assume that the FileAccess method would work like that. But what you can do is load and save a Dictionary, like so:

extends Object
class_name LoadSaveHelper

static func get_variable(path: String, var_name: String, allow_objects: bool = false) -> Variant:
    var fa := FileAccess.open(path, FileAccess.READ)
    if fa:
        var dict : Dictionary = fa.get_var(allow_objects)
        return dict.get(var_name, Variant())
    
    return Variant()

static func store_variable(path: String, var_name: String, value: Variant, full_objects: bool = false) -> bool:
    var fa := FileAccess.open(path, FileAccess.READ)
    var dict : Dictionary
    if fa:
        dict = fa.get_var(full_objects)
    
    dict[var_name] = value
    
    fa = FileAccess.open(path, FileAccess.WRITE)
    if fa:
        fa.store_var(dict, full_objects)
        return true
    
    return false

This should work, but haven't tested

But this isn't proper use of file storage, it's really wasteful and you should try to load a variable from a file like this, instead you should have the data entirely and store it as one, this comes, IMO, from a poor understanding how to use file storage for data in any context

Instead store your game state etc. in a variable, an autoload perhaps, and then save it when you need to save, and load it when you need to load, but access the data from the variable, not the file, that's not efficient or useful

But to address the original claim, that this is the expected behaviour that should "just work", that is simply false, most people don't make this assumption, and those who read the documentation won't

[AThousandShips]

Have you tried this? Does it work for you?

[shak2]

That should really be code hidden in-engine, behind the scenes stuff.

Users should have available:

save_variable(VARIABLENAME, VARIABLEVALUE)

load_variable(VARIABLENAME, VARIABLEVALUE)

For reference, this is how web cookies work.

[AThousandShips]

But that's not how files work

This isn't how you should store data in files generally

If you want this you should use ConfigFile or similar instead, or just use a script, but it isn't how most people do things IMO

IMO adding this would just teach users to use inefficient and inappropriate ways to store data instead of more appropriate ways