SpellRegister - Useful?

[TriggerHappy]

Alright, I took another shot at this.

Basically it's a framework that runs all spells off of the same trigger and event reducing the handle count.

Is it efficient and useful?

library SpellRegister initializer onInit

    globals
        private constant trigger TRIGGER = CreateTrigger()
        private hashtable HASH = InitHashtable()
    endglobals
    
    struct spell
        
        conditionfunc action
        
        static method create takes integer spellid, code func returns spell
            local spell s = spell.allocate()
            if func != null then
                set s.action = Condition(func)
            endif
            call SaveInteger(HASH, spellid, 0, s)
            return s
        endmethod
        
    endstruct
    
    private function DoStuff takes nothing returns nothing
        local spell s
        local integer id = GetSpellAbilityId()
        if HaveSavedInteger(HASH, id, 0) then
            set s = LoadInteger(HASH, id, 0)
            if s.action != null then
                call TriggerAddCondition(TRIGGER, s.action)
                call TriggerEvaluate(TRIGGER)
                call TriggerClearConditions(TRIGGER)
            endif
        endif
    endfunction
    
    private function onInit takes nothing returns nothing
        call TriggerRegisterAnyUnitEventBJ(TRIGGER, EVENT_PLAYER_UNIT_SPELL_EFFECT)
        call TriggerAddAction(TRIGGER, function DoStuff)
    endfunction
    
endlibrary

Example;

scope Spell initializer onInit

    private function Actions takes nothing returns nothing
        call BJDebugMsg(GetObjectName(GetSpellAbilityId()))
    endfunction

    private function onInit takes nothing returns nothing
        call spell.create('AHds', function Actions)
        call spell.create('AHtc', function Actions)
    endfunction

endscope

 

[uberfoop]

Triggers don't divie themselves up into segments operating independantly.

If you try to use this is a traditional condition-action way, it will always fail. If all of the conditions are true, all of the actions fire; if so much as one condition is false, none of the actions fire.

 

[TriggerHappy]

Yea, I edited my post after I did some more tests.

 

[TriggerHappy]

Bump, this one actually works.

 

[Azlier]

Instead of looping, why not use a hashtable or something else sane?

And why not keep a single trigger for each registered spell? Efficiency increase that way.

After you do this correctly, you get something called GTrigger. Though I am suspicious that a hashtable would be better than GTrigger's hashing.

 

[Romek]

Jesus4Lyfs GTrigger basically does this, and was originally based on this concept.
Yes, it works.

Your implementation sucks though. O(n) search each time a spell is cast? Use a hashtable or hashing to attach to spell ids.

 

[TriggerHappy]

Updated.

I'd still like to know how useful this is, and if it's inefficient in some way.

EDIT: I skimmed through GTrigger, and I thought it created a new trigger per spell.

 

[Romek]

I already answered both of those questions.
The fact that GTrigger is a great resource which is approved may give you an idea of how useful it is.

I thought I'd mention that I use something similar to this for my map. With more of a JASS2 interface though, and more efficient, of course.
I found GTrigger to be overkill.

 

[Azlier]

Use a new trigger per spell. It's better that way.

You could possibly end up with something like this.

private function DoStuff takes nothing returns nothing
    call TriggerEvaluate(spell(LoadInteger(HASH, id, 0)).trig)
endfunction

 

[TriggerHappy]

Alright, all I needed to know was which was more efficient.

Thanks.

 

[Azlier]

Well, this would be the ideal for your snippet, BTW.

I think it should be more efficient than even GTrigger.

library QuickSpell initializer Init

globals
	private hashtable ht = InitHashtable()
endglobals

function QS_Register takes code c, integer spellID returns nothing
	local trigger t = CreateTrigger()
	call TriggerAddCondition(t, Condition(c))
	call SaveTriggerHandle(ht, 0, spellID, t))
endfunction

private function Fire takes nothing returns boolean
	call TriggerEvaluate(LoadTriggerHandle(ht, 0, GetSpellAbilityId()))
	return false
endfunction

private function Init takes nothing returns nothing
	local trigger t = CreateTrigger()
	local integer i = 15
	loop
		call TriggerRegisterPlayerUnitEvent(t, Player(i), EVENT_PLAYER_UNIT_SPELL_EFFECT, null)
		exitwhen i == 0
		set i = i - 1
	endloop
	call TriggerAddCondition(t, Condition(function Fire))
endfunction

endlibrary

 

[TriggerHappy]

You can submit it if you want, that snippet was made by you and the idea is nothing special.

Plus it differs from mine anyways, I was trying to avoid dynamic triggers which apparently is less efficient.

EDIT:
Inline

private function Fire takes nothing returns boolean
	return TriggerEvaluate(LoadTriggerHandle(ht, 0, GetSpellAbilityId()))
endfunction

 

[Azlier]

Those aren't dynamic triggers.

 

[Romek]

That wouldn't inline either.

 

[TriggerHappy]

That wouldn't inline either.

Not by jasshelper optimization.

I was saying that it is just one line...

 

[Azlier]

Yeah, I could do that if I restricted the user to returning false. Hey, that's a good idea. I'll do that.

Spoiler

library QuickSpell initializer Init

globals
	private hashtable ht = InitHashtable()
endglobals

function QS_Register takes code c, integer spellID returns nothing
	local trigger t = CreateTrigger()
	call TriggerAddCondition(t, Condition(c))
	call SaveTriggerHandle(ht, 0, spellID, t))
endfunction

private function Fire takes nothing returns boolean
	return TriggerEvaluate(LoadTriggerHandle(ht, 0, GetSpellAbilityId()))
endfunction

private function Init takes nothing returns nothing
	local trigger t = CreateTrigger()
	local integer i = 15
	loop
		call TriggerRegisterPlayerUnitEvent(t, Player(i), EVENT_PLAYER_UNIT_SPELL_EFFECT, null)
		exitwhen i == 0
		set i = i - 1
	endloop
	call TriggerAddCondition(t, Condition(function Fire))
endfunction

endlibrary

Curses. I forgot about the new spoiler rule.

 

[Romek]

I don't think that made any difference to performance whatsoever.

Also, I'd rather you tell Jesus4Lyf that he could improve his implementation rather than remaking his stuff and submitting it as your own. I'm sure you know that I hate it when people do that by now.

 

[Jesus4Lyf]

Eh. I think I talked to Azlier about this on PM. I told him that I intended to release a GT2 of some description that functions exactly like that (in the GT thread).

GT is better in the sense that it allows multiple triggers per spell id, supports conditions and actions, didn't break on patch (it was pre 1.23b), supported dynamic triggers and supported event removal. The efficiency gain is useless. Ever seen a spell lag on cast even with the O(n) complexity stuff people typically use? (That is, lag due to the trigger firing, not the complexity of what happens in that spell.) The answer is "no".

There is a more important thing which is that registering the event is apparently O(n) complexity which does not reset between maps, see the GT thread, and GT accomplishes a solution to this just fine.

>I'd rather you tell Jesus4Lyf
Yea, I actually told him. Much like how I talked to you 'bout T32.

 

[kingkingyyk3]

lol, I did it long time ago by using hash+array method.

 

[Viikuna]

This alone is not usefull.

I know theres many of these systems, but SpellEvent is still the only one that fixxes blizzards fucked up event responses and thus the only really useful one.