the problem with _MEM in UDT

[Cobalt]

So tried my hand, rather successfully I might add, at simulating an ARRAY in UDT with _MEM.

HOWEVER, it does create an issue when trying to save that UDT the quick and easy way.

Code: QB64: [Select]

1. TYPE Player
2.  Nam AS STRING * 24
3.  HP AS _UNSIGNED _BYTE
4.  Max_HP AS _UNSIGNED _BYTE
5.  Armor AS _BYTE
6.  Weapon AS _BYTE
7.  Pack AS _MEM
8.  Items AS _BYTE
9. END TYPE
10.  
11. DIM SHARED P(250000) AS Player
12. P(0).Pack = _MEMNEW(32)
13.  
14. Add_To_Inventory 0, 1, 1
15. Add_To_Inventory 0, 4, 5
16. Add_To_Inventory 0, 19, 3
17. Add_To_Inventory 0, 9, 1
18. Add_To_Inventory 0, 29, 45
19. Add_To_Inventory 0, 100, 103
20. Print_Inventory 0
21. SLEEP
22. CLS
23. Remove_Inventory 0, 29, 5
24. Print_Inventory 0
25. SLEEP
26. CLS
27. Remove_Inventory 0, 9, 1
28. Print_Inventory 0
29.  
30. OPEN "Debug.txt" FOR BINARY AS #1
31. PUT #1, , P()
32. CLOSE
33.  
34.  
35. _MEMFREE P(0).Pack
36.  
37. SUB Add_To_Inventory (Who%%, Item%%, Count%%)
38.  Match%% = false
39.  FOR i%% = 0 TO 15
40.   IF Item%% = _MEMGET(P(Who%%).Pack, P(Who%%).Pack.OFFSET + i%% * 2, _BYTE) THEN Match%% = i%%: i%% = 30
41.  NEXT i%%
42.  IF NOT Match%% THEN 'new item
43.   _MEMPUT P(Who%%).Pack, P(Who%%).Pack.OFFSET + P(Who%%).Items * 2, Item%% 'POKE
44.   _MEMPUT P(Who%%).Pack, P(Who%%).Pack.OFFSET + P(Who%%).Items * 2 + 1, Count%% 'POKE
45.   P(Who%%).Items = P(Who%%).Items + 1
46.  ELSE
47.   temp%% = _MEMGET(P(Who%%).Pack, P(Who%%).Pack.OFFSET + Match%% * 2 + 1, _BYTE)
48.   temp%% = temp%% + 1
49.   _MEMPUT P(Who%%).Pack, P(Who%%).Pack.OFFSET + Match%% * 2 + 1, Count%% 'POKE
50.  END IF
51. END SUB
52.  
53. SUB Remove_Inventory (who%%, Item%%, Count%%)
54.  Match%% = false
55.  FOR i%% = 0 TO 15 'find the item
56.   IF Item%% = _MEMGET(P(who%%).Pack, P(who%%).Pack.OFFSET + i%% * 2, _BYTE) THEN Match%% = i%%: i%% = 30
57.  NEXT i%%
58.  IF Match%% = false THEN
59.   'something went horribly wrong!
60.   PRINT "ERROR ITEM NOT FOUND!"; Item%%; Match%%
61.   CLOSE
62.   _MEMFREE P(who%%).Pack
63.   END
64.  ELSE
65.   temp%% = _MEMGET(P(who%%).Pack, P(who%%).Pack.OFFSET + Match%% * 2 + 1, _BYTE)
66.   temp%% = temp%% - Count%%
67.  
68.   IF temp%% = 0 THEN 'item is out so remove from inventory
69.    temp$ = _MEMGET(P(who%%).Pack, P(who%%).Pack.OFFSET, STRING * 32) 'get entire pack string
70.    temp$ = LEFT$(temp$, Match%% * 2 - 1) + MID$(temp$, 2 * Match%% + 2)
71.    P(who%%).Items = P(who%%).Items - 1
72.  
73.    l%% = LEN(temp$)
74.    FOR i%% = l%% TO 31 'pad temp$ to full 32 characters
75.     temp$ = temp$ + CHR$(0)
76.    NEXT i%%
77.  
78.    _MEMPUT P(who%%).Pack, P(who%%).Pack.OFFSET, temp$ 'put invetory back
79.   ELSE
80.    _MEMPUT P(who%%).Pack, P(who%%).Pack.OFFSET + Match%% * 2 + 1, temp%% 'put adjusted count back
81.   END IF
82.  END IF
83.  
84. END SUB
85.  
86.  
87. SUB Print_Inventory (who%%)
88.  'check that values in inventory are correct
89.  'DEBUGGING!_-------------------------------
90.  LOCATE 1, 1
91.  FOR i%% = 0 TO P(who%%).Items
92.   PRINT "Item ID#:"; _MEMGET(P(who%%).Pack, P(who%%).Pack.OFFSET + 2 * i%%, _BYTE)
93.   PRINT "Item Count:"; _MEMGET(P(who%%).Pack, P(who%%).Pack.OFFSET + 2 * i%% + 1, _BYTE)
94.  NEXT i%%
95. END SUB
96.  

now if you run this program you will see it creates an inventory and modifies it a time or two then saves it to a file,
but if you open the file you will not see any of the inventory data there. just the _MEM TYPE data in its place.

so everything now has to be saved one item at a time one record at a time. and while 250000 players may(WILL) never actually happen (though its only using ~23megs, or so, of memory total if we created all the _MEM areas too) but if we had to cycle a FOR\NEXT 250000 (or say even 2,500,000!) times to save each player is not good.

My yearly plea for arrays in types, not REDIMable arrays just standard arrays. surely easier than variable length strings(attempted valiantly by Luke, I believe), as this would be a fixed area in memory with the rest of the UDT memory.

[SMcNeill]

Question:  Why not just make P().Pack as string * 32?

TYPE Player
....
  Pack AS STRING * 32
....
END TYPE


Then, in SUB Add_To_Inventory, use _MEM to reference that string...

SUB Add...
   STATIC m as _MEM ‘no need to initialize/free it over and over
   STATIC String_Offset AS _OFFSET
   m = _MEM(P(WHO%%)) ‘Just change where you want to point it to.
   String_Offset = m.OFFSET + 28 ‘move to where P(Who%%).Pack starts at in memory


At this point, you memget/memput as you were, but from String_Offset instead of from P(Who%%).Pack.Offset and such, as before...

I haven’t tried it, but it should work for you, and still preserve the Type in such a manner so you can GET/PUT it to file like normal, with no issues.

Example — INSTEAD OF:
    _MEMGET(P(Who%%).Pack, P(Who%%).Pack.OFFSET + i%% * 2, _BYTE)
YOU WOULD:
    _MEMGET(m, String_Offset + i% * 2, _BYTE)

[SMcNeill]

Question2: If you DIM P(250000), doesn’t Who need to be larger than a %%?  Shouldn’t you make it a LONG(&), instead?

[Cobalt]

Question:  Why not just make P().Pack as string * 32?
SUB Add...
   STATIC m as _MEM ‘no need to initialize/free it over and over
   STATIC String_Offset AS _OFFSET
   m = _MEM(P(WHO%%)) ‘Just change where you want to point it to.
   String_Offset = m.OFFSET + 28 ‘move to where P(Who%%).Pack starts at in memory


At this point, you memget/memput as you were, but from String_Offset instead of from P(Who%%).Pack.Offset and such, as before...

I haven’t tried it, but it should work for you, and still preserve the Type in such a manner so you can GET/PUT it to file like normal, with no issues.

Example — INSTEAD OF:
    _MEMGET(P(Who%%).Pack, P(Who%%).Pack.OFFSET + i%% * 2, _BYTE)
YOU WOULD:
    _MEMGET(m, String_Offset + i% * 2, _BYTE)

Oh just lack of experience with _MEM, I was trying something new for me.
I won't have to keep _MEMFREEing each time too will I?

Question2: If you DIM P(250000), doesn’t Who need to be larger than a %%?  Shouldn’t you make it a LONG(&), instead?

I kind of embellished it a bit when I posted to make the issue a little more prominent, though some of the routines do indeed use ~& variables.

[SMcNeill]

Oh just lack of experience with _MEM, I was trying something new for me.
I won't have to keep _MEMFREEing each time too will I?

Nope.   That’s the whole idea behind writing it like this:

STATIC m as _MEM ‘no need to initialize/free it over and over
   m = _MEM(P(WHO%%)) ‘Just change where you want to point it to.

Keep the MEM variable for use all the time, and just change where it points to, when you call the sub.  No need to waste the time and effort to endlessly free and reset it over and over.

Just don’t exit a sub with a MEM variable DIMed, without freeing it, or you’ll make a memory leak in your program.  STATIC lets us just reuse the same MEM variable over and over, whereas DIM would create a new temp MEM variable with each call, and slowly raise the program’s memory usage.

[Cobalt]

  _MEMPUT m, Pack, _memget(m, pack, string * (34-(match%%*2))) 'put invetory back

"Invalid TYPE name" ???

Take it thats a 'no can do'?.

I was trying to clean up removing an item from inventory by padding the pack string with 2 extra unused 0s. and just _MEMGETing the pack string from just after the item to be dropped and copying it over the now gone item.

example pack:(as: item,count   item,count   item,count   ect..)
11 21 31 41 51 61 71 81 91 A1 B1 C1 D1 E1 F1 00

dropping item 6, so copy from item 7 to end and just paste back 2 bytes

11 21 31 41 51 71 81 91 A1 B1 C1 D1 E1 F1 00 00

take it I can't just use _MEMGET in place of the variable in _MEMPUT?