Can you give an example of something pointers are needed for that we can't do already?
Proper struct usage. For functons that take a dynamic struct (a struct per player or a struct per instance etc) you are forced to map all structs into a single array and then pass the integer index of the array as a form of pointer. If this struct needs instances allocated to a new system you need to eithor overallocate the struct array (resulting in wasted virtual machine memory which is already very limtied) or you need to sum all the required instances and manually increase the array size to fit requirements exactly (as there are no macros to keep count of where instances are needed and no way to dynamically allocate memory) which is very time consumming and error prone. Let us not mention the inefficincies this introduces as you need to resolve an array index instead of having a direct address to the struct in question. Most importantly this makes local structs completly usless as it is impossible to modify local structs via functions.
You don't find Data Tables sufficient for your dynamic needs?
Data tables are a global or local map of a string to a value. They are very useful for certain tasks but a lot of their usefullness is lost due to their limited scope settings (what if I want a system to have its own private map to avoid collisions?). String sufix/prefix are not a valid solution to scope as they add extra processing overhead. For non-map dynamic storage they are horriable as they require giving each reference a unique string which is extreemly demanding to generate compared to using an integer index.
If you want to create a list of references for dialog items (controls I think) and you do not know how many there will possible be you currently need to use the datatable to perform some sort of list. You can not store a struct using them so you are forced to map each component separatly. This means a 2 component string of <instance number> + <component name>. <instance number> is a converted int which also takes time and concatination requires allocation of new space to hold the string so also takes considerable time. To add an item to a linked list would need atleast 2 such strings with one for the previous node's link and one for the current node's value (assuming the lsit terminates at a lack of next entry existance). Removing would require the generation of atleast 3 such strings. This is a lot of strings for a task where no strings at all are needed.
A native implimentation could provide the same functionality and need no string generation at all. Adding would need arguments for the list instance and the balue to add. Removing the same. A dynamic array list implemention could allow for O(1) lookup times where that would need a 3 component string using the current mapping method.
I would really like to see...
1. Map (like current Data Tables system but takes an instance reference instead of a local/global boolean).
2. Dynamic array (also instanced).
Some others would be nice for convenience and efficiency but emulation via the above is satisfactory.
3. Llinked list (more meory efficient and more reliable add times).
4. Queue
5. Stack
6. AVL Binary tree
7. Piority queue
Combined with pointers, a greater efficiency would be obtainable.
