[Spell] Dynamic indexing, why is it better?

[HammerFist132]

First of all I am pure gui coder, I avoid jass as much as possible, and use it only for some actions, not possible in gui.
So I was thinking that dynamic indexing is done with vJass and thats why I never used it, but now I see that it is also done in gui.

So can someone give me a bit detailed description why is better to use it for loop spells then classic indexing?
I want to learn this before I start my next map project.

 

[Nestharus]

It's the idea of having blueprints for an object like a spell and then building from those blueprints, like a spell, every time you need one.

So rather than 1 constant static spell, you now have blueprints to make a spell and you just make that spell whenever you need it.

Hero A casts Meteor Shower, create a meteor shower then. Hero B casts meteor shower at the same time, create another meteor shower.

A unit is created, make a space for that unit to store data.

That's all it is =). To me, it makes more sense to create and destroy these things rather than to... i can't even fathom how you'd otherwise do it. 1 constant premade spell that is just inacted upon doesn't make much sense to me.

 

[HammerFist132]

Okey, but is it faster in game, does it have lesser action count, that is really important to me.

 

[Nichilus]

It doesn't have lesser action count => it's not as quick as a non-MUI spell (going by action count only); but I doubt it has any significant difference in speed.

Imo the most important aspect in speed is how efficiently you code it to make it MUI, as making spells MUI is probably the hardest part of the spell

 

[deathismyfriend]

Making spells MUI is very easy. Although it may look a bit more difficult it is very easy. Assign a value to an array with the index of the maxIndex. That's how u store. To remove one remove and clean leaks. Then set the data of currentIndex or tempInt to the data of maxIndex. Then set the stuff at maxindex to null. Finally reduce tempInt and maxindex by one. It is rather an easy concept to grasp.

All spells are faster when they are instant spells because they use less processing. Less variables and don't need loops or a second trigger. But it's not a lot slower and if u want a cool spell it most likely wont be an instant spell.

 

[HammerFist132]

Okey people, thank you, will try to learn it, btw I guess you know I was talking about hanky dynamic indexer, btw until now I was making mui spells, in classic way like paladon. Now will try to learn this.

 

[deathismyfriend]

My tutorial things a GUIer should know has a chapter called how to index. It will show u how to create a spell using arrays and indexing.

 

[HammerFist132]

If I get you right, you mean I dont know mui spell coding for loop like spells, man I do, I just want to learn it in this way like hanky do it in his dc spell/system.

 

[deathismyfriend]

I'm not saying that I'm saying the index hanky uses is the same in my tutorial. I show u how to do it. I'm not sure how he shows how to do it. I make a spell in there with dynamic indexing. I believe it's the exact same hanky uses.

 

[Maker]

Here are examples of dynamic and non dynamic indexing. They have similarities, both work like this.

When a spell is cast, the created instance is assinged a new index, always the last of the instance queue.

Set MaxIndex = (MaxIndex + 1) Set Caster[MaxIndex] = (Triggering unit)

A spell is cast, no other instances are active:

Index	1
Instance	1

A spell is cast, while other instances are active:

Index	1	2	...	MaxIndex
Instance	1	2	...	MaxIndex

The indexes are looped through in the periodic trigger

For each (Integer CurrentIndex) from 1 to MaxIndex, do (Actions)

----

However, the deindexing differs.

Non dynamic indexing When deindexing, a boolean is set to false to mark that the instance in inactive. Set Boolean[CurrentIndex] = false The loop checks each boolean before executing further actions if Boolean[CurrentIndex] == true then damage target move unit ... endif Here is what happens, example of four instances running Index 1 2 3 4 Instance 1 2 3 4 Instance 2 expires for some reason, we mark it inactive, so basically it will not be run. Index 1 2 3 4 Instance 1 x 3 4 The max index is still 4, and the loop will go from 1 to 4, even though there are only three active instances.

Dynamic indexing When deindexing, the last instance is reassigned to the current index that we want to destroy Set Caster[CurrentIndex] = Caster[MaxIndex] The max index is decreased by one since one instance is now destroyed. We also decrease current index so the instance that was assigned for last to current is looped through next Set MaxIndex = (MaxIndex - 1) Set CurrentIndex = (CurrentIndex - 1) Here is what happens, example of four instances running Index 1 2 3 4 Instance 1 2 3 4 Instance 2 expires for some reason, we move instance from last index to the position of instance 2 and decrease the array size Index 1 2 3 Instance 1 4 3 Current index is 2 at this point. Then current index is set to current - 1, which is 1. When the loop finishes, the loop index is increased by one, that happens in the background in GUI and does not need an extra action. The instance 4 in index 2 is run during the next loop. There are some small issues with this, but nothing too major. The issue is that the order changes. The instances run in order, 1-2-3-4 - 1-2-3-4..., but when an instance expires, the order changes. 1-2-3-4 - 1-2-3-4 - 1-4-3... Instance 2 is destroyed, and at that point we see that instance 4 is run twice between two instance 3 runs.

So you see that even dynamic indexing isn't perfect. An even better way is to use a linked list.

 

[HammerFist132]

Thank you maker, now I get it, btw you say linked list is better, where I can find tutorial, or excample of spell (in gui).