Add a keyword to constant string type sharing it's name as string value. (as Syntax Sugar)

[JoanPotatoes2021]

Hello everyone, here's an idea, syntax sugar for gdscript, 🍺 📑

Currently I am coding a lot of pointers to an library of constants to create a point in the code where all depedencies are stablished once, later I use those constants to load information from json files, so it works like:

Gamedata.gd
const weapon_data:String = "weapon_data"
const weapon_fire_sound:String = "weapon_fire_sound"
const weapon_reload_sound:String = "weapon_reload_sound"
const weapon_mesh_path:String = "weapon_mesh_path"
const weapon_reload_speed:String = "weapon_reload_speed"

Then later whenever I need to retrieve from a data bank the weapon fire sound, in code:

Player.gd
weapon_fire_sound = load( Gamedata.json_data[ Gamedata.weapon_data ][ Gamedata.weapon_fire_sound ] )

What if we could write like this on the autoload Gamedata.gd:

const_str weapon_data
const_str weapon_fire_sound
const_str weapon_reload_sound
const_str weapon_mesh_path
const_str weapon_reload_speed

# Instead of :

const weapon_data:String = "weapon_data"
const weapon_fire_sound:String = "weapon_fire_sound"
const weapon_reload_sound:String = "weapon_reload_sound"
const weapon_mesh_path:String = "weapon_mesh_path"
const weapon_reload_speed:String = "weapon_reload_speed"

# Or super sugary unhealthy minimal code-style: 🍰 

const_str {weapon_data, weapon_fire_sound, weapon_reload_sound, weapon_mesh_path, weapon_reload_speed}

I know we can do var weapon_data := "weapon_data" as well, I just like to use the var type definition explicity,

The idea is const_str weapon_fire_sound = const weapon_fire_sound:String = "weapon_fire_sound"
Can this be done currently through other means? Or is my use-case too much specific and gross 💩 to implement in core?

This seems trivial, but it really bugs me having to type the same thing twice everytime.
For ref, using currently >> v4.0.alpha14.official [106b68050]

Relevant Github links:
godotengine/godot#20988
godotengine/godot#31896

[mieldepoche]

I don't have further input about this but for the time being you can automate this the following way:

# can't be `const` but let's pretend and use CONSTANT_CASE.
var WEAPON_DATA: String
var WEAPON_FIRE_SOUND: String
var WEAPON_RELOAD_SOUND: String
var WEAPON_MESH_PATH: String
var WEAPON_RELOAD_SPEED: String


func _init() -> void:
    for p in get_property_list():
        if p.name.begins_with("WEAPON_"): # or any other pattern
            assert(p.type == TYPE_STRING)
            set(p.name, p.name)

For reference see also the GDScript style guide on how to name constants.

[JoanPotatoes2021]

Hmmm, didn't thought about using get_property_list(), I would have to manage a proper unique preffix for the pattern though, can modify other unrelated variables by accident, if one is not careful enough, or maybe putting them inside a dictionary will do the trick.

[Mickeon]

Hmm... I suppose that if this was valid syntax for creating a Dictionary, you'd no longer have this problem, either?

# Notice the lack of assignment
const WEAPON = {
    "DATA",
    "FIRE_SOUND",
    "RELOAD_SOUND",
    "MESH_PATH",
    "RELOAD_SPEED",
}

[JoanPotatoes2021]

That would be ideal if possible! It is the way currently one uses to make enums atm, but you have to do some hacking to get them as strings later, the idea of using a dictionaries was mentioned in the issues:

hilfazer: -they're probably less efficient at lookups, and don't have IDE autocomplete support (one main advantage of enums for me, anyway)[...]

Originally posted by @nobuyukinyuu in godotengine/godot#20988 (comment)

I guess the most simplest way atm, is by creating a dictionary and assigning empty entries, then later filling each entry with it's key in a for loop:

var data_refs = {
    "WEAPON" : {
        "DATA" : "",
        "FIRE_SOUND" : "",
        "RELOAD_SOUND" : "",
        "MESH_PATH" : "",
        "RELOAD_SPEED" : ""
    }
}

Would be converted to:

var data_refs = {
    "WEAPON_DATA" : "WEAPON_DATA",
    "WEAPON_FIRE_SOUND" : "WEAPON_FIRE_SOUND",
    "WEAPON_RELOAD_SOUND" : "WEAPON_RELOAD_SOUND",
    "WEAPON_MESH_PATH" : "WEAPON_MESH_PATH",
    "WEAPON_RELOAD_SPEED" : "WEAPON_RELOAD_SPEED"
}

This of course will loose auto complete support, but it works in theory, we're basically simulating string enums using dictionaries at this point, I would love a solution out of the box though.

[Mickeon]

You don't need to assign them later. I don't exactly know what this is for, but you can just iterate through the keys of WEAPON:

for key in WEAPON:
    pass

or get an array containing all of its keys:

var keys = WEAPON.keys()

[JoanPotatoes2021]

Yea that's exactly what I meant, my 'later' 😄 means when the game is running, at ready() or init(), as it runs in a autoload everything should work fine afterwards.