Unit Indexing : Hashtables or Integer[Arrays] ?

[chukky-jr]

as the title says, which is better? and what is the pros and cons for each method?

 

[Ryushi]

Hashtables are better, they are easier to work with and won't run into problems if there are a lot of units to be stored.

 

[keychup]

hashtables.

 

[GFreak45]

think of a varriable like this:

x - 1 2 3 4 5 6 7 8

Think of a hashtable like this:
...x -->
.y...1 2 3 4 5 6 7 8
.|.1
\/ 2____.(3,2)
...3
...4__________.(7,4)
...5__.(2,5)
...6
...7
...8


In conclusion, variables can access information easier but store less information before they get messy
Hashtables take a split second longer before they can load, nothing huge, but if you are checking something 1000 times/sec it can get dicy


PS. i was bored so i did that ^

 

[chukky-jr]

i did a quick search for Hashtables, but none seem give some ideas about HandleID, i don't really get how it works, how come (key(target unit of ability being cast)) corresponds to (key(picked unit))?? (i forgot the whole trigger)

can some1 give me a link for tutorial of HandleID ?

 

[KaerfNomekop]

That isn't always the case.

Every unit/destructible/point/special effect/lightning effect etc. except for Reals, Integers, Booleans and Strings will be assigned a Handle ID when first created. These things are called Handles.

Handle IDs are unique to every handle, and will never overlap. When using (Key (Handle)), it returns a value which you know refers to Handle. This makes it very useful alongside a hashtable as it gives pretty much everything a unique ID to identify it, allowing you to make huge arrays of arrays and still know which value belongs to what.

 

[GFreak45]

picked unit/triggering unit/target unit of ability being cast

all of these are ways of defining what unit it is and they are local to that trigger, it can be a different unit every time but every time u get that specific unit it will work with the same key

 

[Dirac]

Hashtables
Pros
-Bidimensional arrays (h[x][y])
-Can store more than 8191 indexes (which means it can use handles as indexes)
Cons
-Slower than integer array
-Ugly API
-Have to be initialized

Conclusion: use integer arrays every time until you need to use a hashtable.

When do i need to use a hashtable?

A) When you need a bidimensional array
h[0][0]=3
h[0][1]=5
h[1][0]=8
h[1][1]=4

B) When you need to use handles as indexes
h[unit handle][0]=value

Any other case should use common arrays

 

[Inflicted]

Well arrays are probably easier to use.
If its a simple usage, definately go for arrays. Especially if you are new to w3 editing.

However hashtables are definately more effective.

Think of hashtables as almost 2D arrays. kinda.

Everything that can be done in an array can be done in a hashtable.

Although I might be wrong but I think hastables take more memory and are often declared at map initialisation causing a slightly longer load time. (I could be wrong about that though.)

 

[GFreak45]

they dont take any more memory, they take longer to load, because it has 2 coordinates rather than 1 (also the variable/hashtable so its a 3:2 ratio) it takes roughly 1.5 times as long to find the information, eventhough its rare to call enough data to make a game lag, the exceptions are damage systems where aoe is included on multiple units at once, etc.