Mui

[Moderator]

15th Dec 2013
Maker: Auseful system that can makes creating spells
easier.
The system has a bit of overhead since it checks for every
type even if they are not used

 

[Rheiko]

what the hell is this
is this a tutorial or something ;_;

 

[Ruke]

what the hell is this
is this a tutorial or something ;_;

Ne, just suggar to gui-users who want to make MUI spells c:.

By the way, updated example-map (removed garbage <.<).

 

[Manasurge]

What is this and what's the point of it?

 

[Rheiko]

 

[zv27]

What is this and what's the point of it?

Read the description and everything will be clear

This has the potential for GUI users

+rep for originality

 

[Rheiko]

okay, so i read the whole description and trigger
and because you didn't answer that question properly, i ask it again
is this efficient?

 

[Daffa]

This fits more as a tutorial to me.
You can attach the map at the tut section as well.

 

[chobibo]

8190, index 8191 doesn't work as expected.
EDIT:

    call ConditionalTriggerExecute(triggerToExecute)
    -->
    if TriggerEvaluate(triggerToExecute) then
        call TriggerExecute(triggerToExecute)
    endif

This looks like the old CS_cache with a custom periodic event.

 

[Ruke]

Where's the loop? You should make two spells instead of one for the example because I see nothing interesting about this. How does giving stuff an array number of one/1 make stuff MUI?

there is no loop my friend .
well the mui crap is handled by the utility, the variables get their value depending on the order in which were saved (read read c.

so, when the timer gets executed, the utility sets value to the variables, so the user can use them .

is this efficient?

yes "it is". could be more efficient?, yes it can, but it will be kinda pointless (i didn't see high fps-drops). the goal of this, is to make gui-users' life easier.

Making triggering easier like this is an example of bad habits of code or something like that someone has said before.

it is not. you can keep repeating your self with the other methods, but why?, it is a waste of time. and remember, we are in gui.

the same goes for the leak-cleaner. users still have to make use of destroy-effect, group, etc., but they don't have to make x = null, that is old-school.

This fits more as a tutorial to me.

uhmm, it is not a tutorial, i'm presenting an utility. but it should have its own tutorial.

One question... how large is the limit? 8191 normally for normal MUI stuff due to array limit. If this is hashtables then it would be 255 right? I am not sure which area this falls in, but it looks like arrays. Just curious to how large the arrays go if not to the max.

i think it would be 8190 (also check MUI_GetLimit()).

 

[chobibo]

Translate the error messages and comments to English.

More: 1st Edit

is this efficient?

No. It also limits the user to some predefined storage structure (think vjass structs).

function MUI_GetHashtable takes nothing returns hashtable
   if ( udg_hashtable == null ) then
       set udg_hashtable = InitHashtable()
   endif
   
   return udg_hashtable
endfunction

function MUI_GetHashtable takes nothing returns hashtable
	return udg_hashtable
endfunction

function MUI_InitHashtable takes nothing returns nothing // hashtable // I overlooked this sorry.
	set udg_hashtable = InitHashtable()
endfunction

 

[Ruke]

No. It also limits the user to some predefined storage structure (think vjass structs).

it isn't efficient?, what kinda of maps/abilities do you have in mind that requires this to be more efficient?, limits?, how is that?
again, this is not intended to be efficient, but to easy things up.

hashtable: it's the same

 

[chobibo]

it isn't efficient?, what kinda of maps/abilities do you have in mind that requires this to be more efficient?

Please don't assume people won't need* that kind of efficiency.

function MUI_GetHashtable takes nothing returns hashtable
   if ( udg_hashtable == null ) then
       set udg_hashtable = InitHashtable()
   endif
   
   return udg_hashtable
endfunction

function MUI_GetHashtable takes nothing returns hashtable
    return udg_hashtable
endfunction

function MUI_InitHashtable takes nothing returns nothing
    set udg_hashtable = InitHashtable()
endfunction

limits?, how is that?

Ok, I apologize, I failed to look at that part.

 

[Tal'Rarity]

Aha I was doing something wrong as usual, I finally made a beam with your index system. I must say it was pretty easy and fast once I got the hang of it. Thank you making such a system yet I do want to see it handle something more complex to see how much it can handle lag-wise.

Fyi I was trying to create them at a certain spot every so tick of the timer yet it moved all of them in the timer trigger so instead I created them all at once in the execute trigger.

 

[Ruke]

Aha I was doing something wrong as usual, I finally made a beam with your index system. I must say it was pretty easy and fast once I got the hang of it. Thank you making such a system yet I do want to see it handle something more complex to see how much it can handle lag-wise.

Fyi I was trying to create them at a certain spot every so tick of the timer yet it moved all of them in the timer trigger so instead I created them all at once in the execute trigger.

glad to read .
i'm making more spell-examples, hopefully it will clear questions

 

[Ruke]

Updated
+ Points (locations)
+ more examples

 

[Rheiko]

use [hidden=Value][/hidden] please

 

[Ruke]

use [hidden=Value][/hidden] please

?

i'm thinking on making the process even easier for the final user.

what about

• Custom script: MUI_End(true)

if true, the utility will handle the destruction of some data (like special effects, groups, etc.), false, the user does.

so, if true, no need of use RemoveLocation, DestroyGroup, etc.

 

[chobibo]

Good idea, that.

 

[Tal'Rarity]

You asked for the edit/example I made so here it is.

A beam is similar to a projectile.

 

[Ruke]

You asked for the edit/example I made so here it is.

A beam is similar to a projectile.

Spoiler

updated
added automatically leak clear feature.

 

[deathismyfriend]

English only .....

BJDebugMsg("MUI - No podes guardar mas de " + I2S(MUI_GetLimit()) + ". Si necesitas mas, incrementa el limite en MUI_GetLimit")

The counting key functions are pointless.

I don't see how this is better than learning indexed arrays. Since indexed arrays are much faster. OR learning MUI hashtables. It is not hard at all.

It is better if you put more notes in your work.
It seems like you create multiple hashtables for each different spell.
A true MUI system would take advantage of one spell.

I would suggest a complete rework or scrapping it.

You should really explain your work better. Also anything submitted should be as efficient as possible.

Since this handles spells. It should use coordinates not locations. Creating and destroying locations is very inefficient compared to using coordinates.

 

[Ruke]

The counting key functions are pointless.

why?

I don't see how this is better than learning indexed arrays. Since indexed arrays are much faster. OR learning MUI hashtables. It is not hard at all.

if you like to repeat yourself, you're welcome to do it.

It is better if you put more notes in your work.
It seems like you create multiple hashtables for each different spell.
A true MUI system would take advantage of one spell.

1 hashtable

at the begining i didn't know if this were to work, so it's kinda improvised (that is why the lack of comments, although names are quite self-explanatory).

You should really explain your work better. Also anything submitted should be as efficient as possible.

oh, but it is efficient... on real/most-scenarios c:

i dont know if i can explain it better :\, i mean, i put 3 examples (i have to upload one more that was donated by Dat-C3, thanks by the way).

Since this handles spells. It should use coordinates not locations. Creating and destroying locations is very inefficient compared to using coordinates.

are you serius?, are you concern about creating/destroying locations?, omg.

this is mented to make gui-life' easier. is it efficient?, on what scenarios?, crazy ones?, of course not.

 

[deathismyfriend]

1) They are pointless because they return the same number so just simply use that number in the functions rather than create unnecessary function calls.

2) That was pointless and ignorant. What i said is valid.

3) Then put in comments after.

4) If it is not efficient in all scenarios then it is not efficient.

5) Yes as creating and destroying locations is very inefficient.
You can simply take a location using a function and change it to coordinates. That way every time those coordinates are used it is more efficient.
If it's not efficient it most likely will not be approved.

 

[Ruke]

1) They are pointless because they return the same number so just simply use that number in the functions rather than create unnecessary function calls.

oh, you're refering to the periodic function, yes they're useless. their value can be saved in variables.

2) That was pointless and ignorant. What i said is valid.

nu, take a look for example at spells who make use of the array technique. what do you see?, i can see repeating stuff.

3) Then put in comments after.

dude, calm down

4) If it is not efficient in all scenarios then it is not efficient.

breath, and read what you're saying.

5) Yes as creating and destroying locations is very inefficient.
You can simply take a location using a function and change it to coordinates. That way every time those coordinates are used it is more efficient.

yes, i could do that. but first, is it really necessary?, i think it is not.

If it's not efficient it most likely will not be approved.

efficiency is not everything. have faith.

 

[deathismyfriend]

1) they dont need to be saved as variables. Simply use them in the functions.

2) I make spells using indexed arrays. They are a lot more efficient than this. Im not sure what you mean by repeated stuff ?

3) I was just saying lol.

4) I know what im saying.

5) Yes it is as you are coding in jass not in GUI.

6) Efficiency plays a big role in all systems. All systems should be as efficient as possible.

 

[Ruke]

2) I make spells using indexed arrays. They are a lot more efficient than this. Im not sure what you mean by repeated stuff ?

efficient is not the point, but the ease (less time doing something, gives you more time to do other), increse productivity of the user (it is easy!) and increase scalability maintainability (easy to read, easy to maintain). but (there is always a but) with this, you have to sacrifice something, and that is efficiency. you lose a little bit of that but you're gaining other stuff (which i think they are more important, dont you think so?).

3) I was just saying lol.

okey, we're cool. now give me a hug c:

4) I know what im saying.

being not efficient in x scenarios doesn't make the hole utility un-efficient. but if you're so concern about that i will take a closer look at it.

5) Yes it is as you are coding in jass not in GUI.

i read your idea again... i think i don't follow it.

i mean, took a location from gui -> pass it to real -> what to do with the location? -> save the real -> when the user requires his location -> pass a real? -> user gets mad

i think locations are more easy to use in gui than coordinates.

6) Efficiency plays a big role in all systems. All systems should be as efficient as possible.

an example: your system works awesome in every scenario where it will be used. you know that you can improve it to make it work more efficient, but why?, users will no see any diference and it is not required! (cuz it does his job, and it does pretty well ).

Though he should be using coordinates. Check out my beam example using his indexer, it starts to lag at 12+ instances casted at the same time

it does?, uhmm i will check it later.

edit: i check the spell... think is the spell not this utility, i mean you're creating 50 units everytime you cast it and it have group leaks :\

 

[Ruke]

How else would you beam a beam if not with dummy unit creation?
Yea... the group leaks are horrible on my part.

if you can/want, try making the same spell but with array or hashtable as usual to check if it is the spell or this utility.

 

[chobibo]

These should be constant functions:

script

function MUI_GetLimit takes nothing returns integer
    return 200
endfunction

// private
function MUI_GetPointCountingKey takes nothing returns integer
    return -8
endfunction

// private
function MUI_GetEffectCountingKey takes nothing returns integer
    return -7
endfunction

// private
function MUI_GetRealCountingKey takes nothing returns integer
    return -6
endfunction

// private
function MUI_GetPlayerCountingKey takes nothing returns integer
    return -5
endfunction

// private
function MUI_GetIntegerCountingKey takes nothing returns integer
    return -4
endfunction

// private
function MUI_GetUnitGroupCountingKey takes nothing returns integer
    return -3
endfunction

// private
function MUI_GetBooleanCountingKey takes nothing returns integer
    return -2
endfunction

// private
function MUI_GetUnitCountingKey takes nothing returns integer
    return -1
endfunction

// private
function MUI_GetPointStartNumber takes nothing returns integer
    return MUI_GetLimit() * 7
endfunction

// private
function MUI_GetEffectStartNumber takes nothing returns integer
    return MUI_GetLimit() * 6
endfunction

// private
function MUI_GetRealStartNumber takes nothing returns integer
    return MUI_GetLimit() * 5
endfunction

// private
function MUI_GetPlayerStartNumber takes nothing returns integer
    return MUI_GetLimit() * 4
endfunction

// private
function MUI_GetIntegerStartNumber takes nothing returns integer
    return MUI_GetLimit() * 3
endfunction

// private
function MUI_GetUnitGroupStartNumber takes nothing returns integer
    return MUI_GetLimit() * 2
endfunction

// private
function MUI_GetBooleanStartNumber takes nothing returns integer
    return MUI_GetLimit() * 1
endfunction

// private
function MUI_GetUnitStartNumber takes nothing returns integer
    return 0
endfunction

Oh, and the debug message should be in English.

 

[T. D. W.]

I'm going to spare my review table for this one, when i first saw the trigger script .... it was awful, the really really long trigger is like 4x larger than normal MUI, we, coders do! And, for instance, i was completely Lost in it
I'll stand with the first comments and say: make a Tutorial, attach a demo map to the thread, it would be extremely better

 

[Ruke]

These should be constant functions:

yep, i will add it later, thanks.
also i will translate the messages too.

when i first saw the trigger script .... it was awful, the really really long trigger is like 4x larger than normal MUI, we, coders do! And, for instance, i was completely Lost in it

because of the comments. remove them, and you will get a nice/clean code.

I'll stand with the first comments and say: make a Tutorial, attach a demo map to the thread, it would be extremely better

demo map is already attached.
tutorial... uhmm... i will wait to see this approved.

You think its the group leaks? I think it is the costly use of the GUI move unit instantly. It might of handled around 20 beams otherwise.

is for the massive unit creation.

 

[T. D. W.]

because of the comments. remove them, and you will get a nice/clean code.

i did say it was very long, not that it wasn't clean

 

[deathismyfriend]

I dont see this getting approved. Also my spells took me about 15 minutes with indexed arrays. So this won't save any time. Hashtables are up to 8 times slower than indexed arrays.
Also how do you follow which unit belongs to what spell ?

 

[deathismyfriend]

Like said earlier something like this is bad coding practice. It is also inefficient and the TO doesn't seem to want to change anything to make it better.

I made something like this a while back but with some major differences. The spells were saved by the triggers handle id. Then each instance was increased for that certain spell. I then used a timer event loop to keep track of when the instance should end so there is no unecessary looping. It was still slow because it used hashtables and I never submitted it because it is simply bad practice.

 

[Ruke]

i did say it was very long, not that it wasn't clean

oh you're right, sorry about that.

Also my spells took me about 15 minutes with indexed arrays. So this won't save any time.

that's fine, but i can't agree that this doesn't save any time, have you try it?.

Hashtables are up to 8 times slower than indexed arrays.

benchmark please.

even if that is true, players won't notice that (at least you were doing some crazy stuffs).

edit:
if they do, then i will work in efficiency.

-------------------------------------

took a random spell to compare, these are the results

http://image.gxzone.com/images/6/a/6a4a8ca827c.jpg

(with = with this utility)
(without = array technique)

credits for the spell goes to: Napo from http://worldofeditors.forosweb.net/t355-waveform-por-napo-spell

edit:

Also how do you follow which unit belongs to what spell ?

you save it.

Like said earlier something like this is bad coding practice. It is also inefficient and the TO doesn't seem to want to change anything to make it better.

i will improve it, but not in areas where it does not need to.

I made something like this a while back but with some major differences. The spells were saved by the triggers handle id. Then each instance was increased for that certain spell. I then used a timer event loop to keep track of when the instance should end so there is no unecessary looping. It was still slow because it used hashtables and I never submitted it because it is simply bad practice.

it is not bad practice, it's just sugar. it simplifies the process to the final user, how could be that a bad practice?.

edit: just for the record, why are you saying that this is bad practice?

 

[deathismyfriend]

This type of thing is bad practice because it is doesn't show the right way on how spells should be made.

Ask bribe for his benchmark. He is the one that found this out.

Quote:
Also how do you follow which unit belongs to what spell ?
you save it.

When someone asks something like that normally you show them where in the code it does that not just say you save it.

I don't code in GUI anymore. This won't save time. Also my spells are complex you should look before saying they are simple.

The spell you showed is also inefficient and very bad to.
That spell uses an old style of indexing and de-indexing. The old style runs through indexes that are already used. It also has more lines of code than the new style.

In your periodic function you also leak handles.

 

[Ruke]

This type of thing is bad practice because it is doesn't show the right way on how spells should be made.

simply, no.

Ask bribe for his benchmark. He is the one that found this out.

. . .

When someone asks something like that normally you show them where in the code it does that not just say you save it.

the utility is like structs from vjass but to gui.

you init the "process" with MUI_Start(timeout).

MUI_Start it's like struct.create(), it gives you an instance where you can save your data (unit, real, etc.). also, it starts a timer with the timeout that has been passed.

that timer, holds the instance (the one that we just created with MUI_Start), so when it expires, we're able to retrieve the data.

when the data is retrieved, it is assigned to the variables so that the user can use them.

MUI_End it is like struct.destroy, it recycles the instance and clear things up.

the saving process is:

instance, amount_of_this_type_of_data_saved, data

where amount_of_this_type_of_data_saved is a counting which increases every time the user saves something of that same type.

example:

call MUI_Unit(unit)

instance, 1, unit

call MUI_Unit(unit)

instance, 2 (here, the counter has been increased), unit

if a say:

call MUI_Real(real)

instance, 1, real

why 1?, because it's the first of this type

but, why it doesn't collide?

because of MUI_GetStartXNumber, where X it's the type.

so, if unit begins at 0, the counter will start at that number.
if reals begins at 1000, counter will start at that number.

call MUI_Real(real)

instance, MUI_GetRealStartNumber + counter, real

 

[Ruke]

I don't code in GUI anymore. This won't save time.

i was talking about if you did try this utility. if you didn't, you can't say if this does or not saves time.

The spell you showed is also inefficient and very bad to.
That spell uses an old style of indexing and de-indexing. The old style runs through indexes that are already used. It also has more lines of code than the new style.

took a random spell to compare

if you have other, please share.

In your periodic function you also leak handles.

where?

you mean for the points?, the utility handles it.

 

[chobibo]

the utility is like structs from vjass but to gui

That's actually a stack plus an instance allocator.

 

[deathismyfriend]

I know how structs work i only code in jass and vJass. Try one of my spells with this system.

All local handles must be nulled when assigned a value. You barely null half of them.

Also as previously stated get rid of all the function calls that aren't needed. If you are only using one hashtable. Why would you create extra handles (that you are leaking btw) to store the hashtable if you already know the hashtables name...
Same with a ton of the other function calls.

 

[Ruke]

Try one of my spells with this system.

you try, you're the one who is against this : \

All local handles must be nulled when assigned a value. You barely null half of them.

seriusly man, you need to make a deep look before saying this things.

the utility uses globals, which means that the value can be replaced from anywhere.

 

[Ruke]

Also as previously stated get rid of all the function calls that aren't needed.

they're needed to avoid the user of making an initializator.

Why would you create extra handles (that you are leaking btw) to store the hashtable if you already know the hashtables name...

i'm not creating extra handles, i'm working with only 1 hashtable. if the hashtable has been created, return it, if not, create it, and then return it.

it doesn't leak, because the hashtable is never destroyed.

 

[deathismyfriend]

See this...

local hashtable hashTable = MUI_GetHashtable()

that line that has local in front of it creates a local handle. It is then used and it now points to the global variable.

Every local created will be stuck in memory unless it is released. It is only released if it is null by the end of the function.

Please read more on how to code in jass / vJass

Also creating locals as i have already said is pointless in this case. Simply use the global variables for it.

EVERY local handle must be nulled.

 

[chobibo]

There's actually no leak dude, the handle is never destroyed, it will never be recycled so the local handles will always point to a single handle instance. But the amount of function calls should be reduced if possible.

 

[deathismyfriend]

There's actually no leak dude, the handle is never destroyed, it will never be recycled so the local handles will always point to a single handle instance. But the amount of function calls should be reduced if possible.

local variables are handled wrong in wc3. No1 knows why but local variables that are handled have to be nulled or it leaks.

 

[Ruke]

making a new version (god, i should be working what am i doing here xD)

features
more easy
array instead of hashtable -> cuz of the god sir deathismyfriend

 

[axleion]

I suggest you to remove the remaining BJ in your script, as you can see:

function ConditionalTriggerExecute takes trigger trig returns nothing
    if TriggerEvaluate(trig) then
        call TriggerExecute(trig)
    endif
endfunction

and I suggest you to inline those MUI_GetHashtable() directly to the hashtable itself rather than using senseless wrapper, why senseless?
consider that MUI_GetHashtable() will:
1. always return the same hashtable
2. always out of user reach as it is system use
3. always initiated first time and never be initiated again
4. never be destroyed
so why always check if its exist everytime it is called?

rather than chobibo's method to change this:

function MUI_GetHashtable takes nothing returns hashtable
   if ( udg_hashtable == null ) then
       set udg_hashtable = InitHashtable()
   endif
   
   return udg_hashtable
endfunction

into

function MUI_GetHashtable takes nothing returns hashtable
    return udg_hashtable
endfunction

function MUI_InitHashtable takes nothing returns nothing
    set udg_hashtable = InitHashtable()
endfunction

I suggest you to do this:

function MUI_InitHashtable takes nothing returns nothing
    set udg_hashtable = InitHashtable()
endfunction

• MapInit
  • Events
    • Map initialization
  • Conditions
  • Actions
    • Custom script: call MUI_InitHashtable()

and use the hashtable directly like this:

function MUI_SetRecycleInstance takes integer instance returns nothing
    call SaveInteger(udg_hashtable, 0, 2, instance)
endfunction

it saves one function call and one if check almost everywhere in your script as any function in your script have MUI_GetHashtable() in it.

and yes, local handle will have pointer leak if not nulled.
and why use local on this?
local hashtable hashTable = MUI_GetHashtable()
use the udg_hashtable directly.

add support for destructable, although its rarely used.

why give the option to remove leak or not in MUI_End? the only case where it will be false is only when the user passes a global variable which is used in the map which is a bad practice anyway.

 

[deathismyfriend]

I suggest you to remove the remaining BJ in your script, as you can see:

function ConditionalTriggerExecute takes trigger trig returns nothing
    if TriggerEvaluate(trig) then
        call TriggerExecute(trig)
    endif
endfunction

and I suggest you to inline those MUI_GetHashtable() directly to the hashtable itself rather than using senseless wrapper, why senseless?
consider that MUI_GetHashtable() will:
1. always return the same hashtable
2. always out of user reach as it is system use
3. always initiated first time and never be initiated again
4. never be destroyed
so why always check if its exist everytime it is called?

rather than chobibo's method to change this:

function MUI_GetHashtable takes nothing returns hashtable
   if ( udg_hashtable == null ) then
       set udg_hashtable = InitHashtable()
   endif
   
   return udg_hashtable
endfunction

into

function MUI_GetHashtable takes nothing returns hashtable
    return udg_hashtable
endfunction

function MUI_InitHashtable takes nothing returns nothing
    set udg_hashtable = InitHashtable()
endfunction

I suggest you to do this:

function MUI_InitHashtable takes nothing returns nothing
    set udg_hashtable = InitHashtable()
endfunction

• MapInit
  • Events
    • Map initialization
  • Conditions
  • Actions
    • Custom script: call MUI_InitHashtable()

and use the hashtable directly like this:

function MUI_SetRecycleInstance takes integer instance returns nothing
    call SaveInteger(udg_hashtable, 0, 2, instance)
endfunction

it saves one function call and one if check almost everywhere in your script as any function in your script have MUI_GetHashtable() in it.

and yes, local handle will have pointer leak if not nulled.
and why use local on this?
local hashtable hashTable = MUI_GetHashtable()
use the udg_hashtable directly.

add support for destructable, although its rarely used.

why give the option to remove leak or not in MUI_End? the only case where it will be false is only when the user passes a global variable which is used in the map which is a bad practice anyway.

That is what i've been saying for a lot of posts lol. Thanks

The last thing i believe is necessary as some spells may have several steps. If it destroys something before all steps are completed it will cause crash.

 

[chobibo]

local variables are handled wrong in wc3.

Ah, yes, I overlooked the use, since it is being used periodically it does indeed leak references.

No1 knows why but local variables that are handled have to be nulled or it leaks.

Actually, Pipedream explained why, hava a look here.