Use structs instead of ds_maps for built-in features (such as async_load).

[BscotchSeth]

Is your feature request related to a problem?

There are a large number of built-in systems, such as asynchronous file operations, web events, spine events, etc... that all require the user to create and/or interact with ds_maps and ds_lists.

Given that ds_maps and ds_lists are hard to work with and are fragile due to their "manual cleanup" requirement, and because they have numeric IDs that can be accidentally interacted with, even Game Maker's own documentation suggests that we avoid using these data structures wherever possible. But then it forces us to use them all the time, because so many built-in functions require them!

A great example of this is skeleton_bone_state_get(). In the Game Maker manual, here is some example code for setting the information on a bone.

var map = ds_map_create();
skeleton_bone_state_get("head", map);
var xx = ds_map_find_value(map, "worldX");
var yy = ds_map_find_value(map, "worldY");
var deltax = mouse_x - (x + xx);
var deltay = mouse_y - (y + yy);
var angle = -radtodeg(arctan2(deltay, deltax));
ds_map_replace(map, "angle", angle);
skeleton_bone_state_set("head", map);
ds_map_destroy(map);

In this scenario, you have to create your own map first, pass the map into the function, and then destroy the map afterwards. If instead this function used structs, it would be cleaner and less prone to error, like this:

var _bone_state = skeleton_bone_state_get("head");
var xx = _bone_state[$ "worldX"];
var yy = _bone_state[$ "worldY"];
var deltax = mouse_x - (x + xx);
var deltay = mouse_y - (y + yy);
_bone_state[$ "angle"] = -radtodeg(arctan2(deltay, deltax));
skeleton_bone_state_set("head", _bone_state);

Here are just some of the features and functions that require us to use ds_maps and/or ds_lists, which would be much easier to work with if they used structs and arrays instead.

Spine functions:

• skeleton_bone_data_get
• skeleton_bone_data_set
• skeleton_bone_state_get
• skeleton_bone_state_set
• skeleton_bone_list
• skeleton_animation_list
• skeleton_slot_list
• skeleton_slot_data
• skeleton_slot_data_instance
• skeleton_find_slot
• skeleton_skin_list

Built-in Events:

• Animation Event
• Audio Playback
• Audio Playback Ended
• Audio Recording
• Cloud
• Dialog
• HTTP
• In App Purchase
• Image Loaded
• Networking
• Push Notifications
• Save / Load
• Social
• Steam
• System

Describe the solution you'd like

• Convert most or all of the functions to use structs and arrays instead of ds_maps and ds_lists.
• Alternatively, create new versions of the functions that operate on structs and arrays, allowing the user to choose which functions to use (and to maintain backwards compatibility).
• Add a checkbox to the project options to have async_load be a struct instead of a ds_map in all of the associated events. This would preserve backwards compatibility and give people time to make the switch as needed.

Describe alternatives you've considered

None, really. It's a pretty straightforward problem, though the implementation of the solution will definitely take some time.

Additional context

No response

[KormexGit]

The various collision list functions are another one that uses ds_lists, would be nice to have array versions

[Totobal5]

+1

[yoshikins]

Much appreciated feature I think. If compatability with older projects is an issue, I could see some toggleable option within the project settings that could enable/disable this behavior, like how we have a collision compatibilty mode and the old copy-on-write behavior for arrays. We could have a "prefer ds_maps over structs" toggle (Could probably have a better name tho) that could enable the old behavior for imported projects.

Gonna mention the collision_list_* functions too, as I think they should have been arrays from the start tbh

[zzhamzz]

Just want to mention structs are not maps; primarily difference being maps can use any type of key, while structs use only string keys.

While I 'think' all the above functions listed in feature request currently do use string keys this difference should be reviewed.

Personally I would prefer the DS_* types to be refactored/updated into garbage collected equivalents, instead of replacing maps with structs.