[vJASS] 2-D Arrays in structs

[sethmachine]

Hi,

I did a basic implementation of a 2-D array, e.g. [i * j + offset], but I realized this doesn't work if the 2-D array is in a struct, because what is happening is newer structs are overwriting the values of the previously instantiated structs as they don't really have their own separate array unfortunately.

I need 2-d array because in the struct, there is an array of dialogs, and I have to keep track of each dialog's set of buttons, and each dialog's button's message like so

button array[dialogNumber][bttnNumber]

string array[dialogNumber][bttnNumberMessage]

What would be a quick fix for this ... ?

 

[Maker]

You could factor in the struct id in the array. So each dialog gets enough space from the array.

For example if each dialog has max 10 buttons, then for struct with id 1 you reserve indexes 0-9, for id 2, 10-19.

Or use Table by Bribe.

 

[sethmachine]

Here's my problem.

I have an abstract struct which several different structs extend. The abstract struct provides all the generalized code (dialogs, etc. are managed the same, regardless of the struct) and also many of the same fields (notably 2-D arrays)

I then have an array of these abstract structs, which stores instances of the child struct.

That way I basically was able to do this, regardless of the different functions of each child struct

abstractArray[i].mainFunction(...)

So I guess what would be better, keeping a counter each time a struct is made to keep the 2-D arrays in line (I increment it by the appropriate size each time) and keep this implementation, or just make them all separate structs and copy the code in each one?

The former preserves the OOPness of my code, but the latter would allow me 8000+ instances of each child struct, rather than 8190 / highest array member size struct instances.

Not sure which to do yet...

 

[edo494]

what is wrong with Table or TableArray btw? you can do just that without physical limit of size

 

[sethmachine]

Well I did the extra offset trick and everything's working now.

I reduced the size of the 2-D arrays to [5 x 7], with ten players this leaves roughly 23 structs per player. Of course I can probably reduce it to around [3 x 6], which gives 45 structs per player (a much better number). I'll just need to set up a decent dialog recycling mechanic.

How would Table alleviate this issue?

 

[Cokemonkey11]

You have more options:

Use a linked list of one-dimensional arrays for each struct instance - reducing the array size from [x*y] to [x] - which improves the struct count by a factor y.

Use a struct with more index space if necessary http://www.wc3c.net/vexorian/jasshelpermanual.html#storstruct

And FYI, jasshelper automatically inlines 2D arrays http://www.wc3c.net/vexorian/jasshelpermanual.html#twodarray

 

[edo494]

struct myStruct
    integer array arr[10]
endstruct

will limit the number of instances to 801

struct myStruct
    Table arr
    static method create takes nothing returns thistype
        local thistype this = .allocate()
        set this.arr = Table.create()
        return this
    endmethod
    method destroy takes nothing returns nothing
        call .deallocate()
        call arr.destroy()
    endmethod
endstruct

yes, Table requires a creation and deletion of some sort, but it will give you -2,147,483,648 to 2,147,483,647 indexes for EACH struct instance

Table uses 1 hashtable for all data attached to all instances of Table and/or TableArray

if you want 2D array, you just do:

struct myStruct
    TableArray table
    static method create takes nothing returns thistype
        local thistype this = .allocate()
        set table = TableArray[0x2000] //argument passed is the size of first dimension
        return this
    endmethod
    method destroy takes nothing returns nothing
        call .deallocate()
        call table.destroy()
    endmethod
endstruct

and it allows you to store much more than just integers, you can store in Table and TableArray almost anything

Example:

Table t = Table.create()
t[54] = 456
t.unit[52] = CreateUnit(...)
t.boolexpr[11] = Filter(function someFunction)

TableArray table = TableArray[0x2000]
table[20][30] = 567
table[20].unit[31] = CreateUnit(...)
//etc etc

 

[sethmachine]

@cokemonkey

I am aware of the 2-D arrays, but nobody bothered to implement them for structs (you can't have array[x][y] as a struct field, outside of a struct it's legal though).

I did not consider more complicated data structures like a linked list, though I'm trying to avoid as much overhead as possible. Usually more complex structures give better performance (space and time), but come at a cost of code readability.

Well besides doing struct[20000], I could just make a static array of a massive size that all the instances share, e.g. array[50000]. That way I won't run out of room. And seeing as now I am managing part of how the structs share space with the 2-D array, I might as well push it into being just a static or global array...Obviously it would cost me a lot of time and be inefficient, but would I really notice a slowdown with what I'm doing (manipulating dialogs/buttons?).

@edo

I will try to understand this "Table," but what on earth did you pass for the 2-D argument?

And how would you use the Table as a 2-D array?

 

[edo494]

well, for 2D you can use the TableArray, its simple, you do TableArrayInstance[indexA][indexB] = 145

and if you want to store more than integer, you can do:

TableArrayInstance[indexA].type[indexB] = something

 

[sethmachine]

well, for 2D you can use the TableArray, its simple, you do TableArrayInstance[indexA][indexB] = 145

and if you want to store more than integer, you can do:

TableArrayInstance[indexA].type[indexB] = something

How do I specify the size of it though?

You put "0x2000" as a size. That's gibberish to me.

 

[Cokemonkey11]

0xZZZZ is hexadecimal, 0x2000 is just a huge number (2*16^3 = 8192, the maximum array size in jass)

also, JASS_MAX_ARRAY_SIZE

Edit: Use the constant instead of an arbitrary hex value (edo should know better )

 

[edo494]

constant is slower, because its variable read, 0x2000 is literal

and the TableArray is not limited to 8192, you can do TableArray tab = TableArray[50000] and it will give you range [0, 49999]

 

[Cokemonkey11]

constant is slower, because its variable read, 0x2000 is literal

Facepalm

and the TableArray is not limited to 8192, you can do TableArray tab = TableArray[50000] and it will give you range [0, 49999]

I didn't say that, I just explained why 0x2000 was chosen.

 

[edo494]

using JASS_MAX_ARRAY_SIZE is like using TRUE or FALSE, sorry but I dont see use of that

and sorry, but since you know vJass I thought you knew hexadecimal values already, well maybe not

 

[TriggerHappy]

using JASS_MAX_ARRAY_SIZE is like using TRUE or FALSE, sorry but I dont see use of that

and sorry, but since you know vJass I thought you knew hexadecimal values already, well maybe not

JASS_MAX_ARRAY_SIZEis a descriptive constant, I don't see a problem with it.

 

[Cokemonkey11]

Maybe I should inline all 113 constant instances in my Orianna spell pack - after all, reading variables is slower than literals.

The "use" of using constants is that it improves readability.

8192 looks like a number produced by hexadecimal, 0x2000 is a big hexadecimal number, but only JASS_MAX_ARRAY_SIZE actually describes WHAT it is and WHY you'd choose it.

 

[muzzel]

Stuff like inlining should be done by the compiler/optimizer, not by the programmer.
The programmers job is to keep his stuff readable.

 

[sethmachine]

Question about the table--if I have two 2-D arrays, do I also need two Tables per struct?

One is the 2-d array of buttons and the other a 2-D array of strings.

 

[TriggerHappy]

Question about the table--if I have two 2-D arrays, do I also need two Tables per struct?

One is the 2-d array of buttons and the other a 2-D array of strings.

Just use a hasthable directly.

 

[sethmachine]

??? How could I use a hashtable..?

I am mapping 1 value to many with 2-D array

array[x][y]

array[x] --> {y0, y1, y2, y3, ..., yn}

 

[edo494]

yes inlining should be done by compiler, but unless you run the map throught map optimizer, nothing like that will happen

also dont forget how Jass interprets its stuff, it is descriptive but hella long name

 

[muzzel]

??? How could I use a hashtable..?

I am mapping 1 value to many with 2-D array

array[x][y]

array[x] --> {y0, y1, y2, y3, ..., yn}

No a 2d array is mapping 2 values to one. If you want to map 1 value to 2 you can just use 2 normal 1d arrays or an array of structs (which is internally the exact same).

A hashtable is basically a 2d array, you map the combination of parentkey and childkey to a single value.
array: index -> value
2d array: index1 x index2 -> value
hashtable : parent x child -> value

vJass array members are basically the same as static 2d arrays (which vjass knows too), index1 is the objects "this" pointer and index2 is the index of the arraymember.
If you want to create a 2d array member you will need a static 3d array, and so on...