Confusion Bug

//===========================================================================
//A spell that selects all units inside the target AOE and confuses them, 
//changing their owner by an amount of time.
//
//Requires TimerUtils
//
//@author Flame_Phoenix 
//
//@credits
//- Rafael Br, the original creator of the spell and idea
//- Anitarf, the guy with ideas about how to solve problems
//- Litany, the only guys that helped me unbugging this spell, when all others didn't care
//- My first teacher of vJASS: Blue_Jeans
//- All other people I forgot or ignored
//
//@version 1.4
//===========================================================================
scope Confusion initializer Init

    //This will be needed for spell's core, don't change
    private keyword tmpPlayer
    private keyword PlayerArray
    private keyword playerLevelChances
    
//===========================================================================
//=============================SETUP START===================================
//===========================================================================
    globals 
        private constant integer AID = 'A003'   //the rawcode of the ability
        private constant integer ARRAY_SIZE = 15 //the maximum number of players, Human player + computer players you use
        private constant integer MAX_LEVELS = 3 //the maximum amount of levels the ability will have
        private constant integer MAX_HUMAN_PLAYERS = 11 //the maximum number of human player you'll use
        private constant string EFFECT = "Objects\\Spawnmodels\\Undead\\UndeadDissipate\\UndeadDissipate.mdl"
    endglobals
    
    private constant function Duration takes integer level returns real
        return 20. + (level * 10)   //the duration of the spell on the units
    endfunction
    
    private constant function Radius takes integer level returns real
        return 125. + (level * 75)  //the radius the spell will have
    endfunction
    
    private function PlayersCallibration takes nothing returns nothing
        local integer i
        local integer j
        
        //here we set all human players with a nice loop
        set i = 0
        loop
            exitwhen(i == MAX_HUMAN_PLAYERS)
            set PlayerArray[i] = Player(i)
            set i = i + 1
        endloop
        
        //here we set computer controled creeps manually
        set PlayerArray[12] = Player(PLAYER_NEUTRAL_AGGRESSIVE)
        set PlayerArray[13] = Player(bj_PLAYER_NEUTRAL_VICTIM)
        set PlayerArray[14] = Player(PLAYER_NEUTRAL_PASSIVE)
        
        //here we set the chances all human players have of controlling the units
        //with a nice loop to fill our 2D array
        set i = 1
        loop
            exitwhen (i > MAX_LEVELS)
            set j = 0
            loop
                exitwhen(j == MAX_HUMAN_PLAYERS)
                set playerLevelChances[i][j] = .0666
                set j = j + 1
            endloop
            
            set i = i + 1
        endloop
        
        //if you prefer, you can avoid loops and set the levels and chances 
        //manually, like I do in this example
        //I this case, computer controled players have more chances of getting 
        //the units.
        set playerLevelChances[1][12] = .067
        set playerLevelChances[1][13] = .067
        set playerLevelChances[1][14] = .0668
        
        set playerLevelChances[2][12] = .067
        set playerLevelChances[2][13] = .067
        set playerLevelChances[2][14] = .0668
        
        set playerLevelChances[3][12] = .067
        set playerLevelChances[3][13] = .067
        set playerLevelChances[3][14] = .0668
        
        //PS: Note that this takes a lot more text however xD
    endfunction
    
    private function Targets takes nothing returns boolean
    //the units that will be affected by the spell
        return IsUnitEnemy(GetFilterUnit(), tmpPlayer) and (GetWidgetLife(GetFilterUnit()) > 0.405) and (IsUnitType(GetFilterUnit(), UNIT_TYPE_MECHANICAL) == false) and (IsUnitType(GetFilterUnit(), UNIT_TYPE_MAGIC_IMMUNE) == false) and (IsUnitType(GetFilterUnit(), UNIT_TYPE_STRUCTURE) == false)
    endfunction
//===========================================================================
//=============================SETUP END=====================================
//===========================================================================
    
    //small array
    type playerChances extends real array[ARRAY_SIZE]
    
    globals
        //BIG array
        private playerChances array playerLevelChances[MAX_LEVELS]
        
        private player array PlayerArray[ARRAY_SIZE]
        private group g
        private boolexpr b
        private player tmpPlayer
    endglobals
//===========================================================================
    private struct MyStruct 
        unit caster
        integer level
        timer dur
        group array allPlayers[ARRAY_SIZE]
        
            static method create takes unit caster returns MyStruct
                local MyStruct data = MyStruct.allocate()
                local integer i
                
                //setting variables
                set data.caster = caster
                set data.level = GetUnitAbilityLevel(caster, AID)
                set data.dur = NewTimer()
                
                set i = 0
                loop
                    exitwhen (i == ARRAY_SIZE)
                    set data.allPlayers[i] = CreateGroup()
                    set i = i + 1
                endloop
                
                return data
            endmethod
            
            method onDestroy takes nothing returns nothing
                local integer i = 0
                loop
                    exitwhen (i == ARRAY_SIZE)
                    call DestroyGroup(.allPlayers[i])
                    set i = i + 1
                endloop
                
                call ReleaseTimer(.dur)
            endmethod
    endstruct
//===========================================================================
    private function EndEffect takes nothing returns nothing
        //here we catch the timer
        local MyStruct data = MyStruct(GetTimerData(GetExpiredTimer()))
        local unit f
        local integer i
        
        //here we walk trhough the group array
        set i = 0
        loop
            exitwhen(i == ARRAY_SIZE)
            
            //here we walk through every single unit inside the group
            loop
                set f = FirstOfGroup(data.allPlayers[i])
                exitwhen(f == null)
                call GroupRemoveUnit(data.allPlayers[i], f)
                call SetUnitOwner(f, Player(i), true)
            endloop
            
            set i = i + 1
        endloop
        
        call data.destroy()
    endfunction
//===========================================================================
//RandomPlayer function made by Litany, adapted to spell by Flame_Phoenix
//===========================================================================
    private function RandomPlayer takes integer structure returns player
        local MyStruct data = structure
        local real chance = GetRandomReal(0, 1)
        local real playerChance = 0
        local integer i = 0
        
        loop
            exitwhen(i == ARRAY_SIZE )
            set playerChance = playerChance + playerLevelChances[data.level][i]
            if chance <= playerChance then 
                return Player(i)
            endif
            set i = i + 1
        endloop
        
        return Player(0)
    endfunction
//===========================================================================
    private function Conditions takes nothing returns boolean
        return GetSpellAbilityId() == AID
    endfunction
//===========================================================================
    private function Actions takes nothing returns nothing
        local MyStruct data = MyStruct.create(GetTriggerUnit())
        local location spellLoc = GetSpellTargetLoc()
        local real spellX = GetLocationX(spellLoc)
        local real spellY = GetLocationY(spellLoc)
        local unit f
        local integer i
        
        //here we select the units we will affect
        set tmpPlayer = GetOwningPlayer(data.caster)
        call GroupEnumUnitsInRange(g, spellX, spellY, Radius(data.level), b)
        
        //and now we change their owners
        loop
            set f = FirstOfGroup(g)
            exitwhen(f == null)
            call GroupRemoveUnit(g, f)
            
            //with this line we keep track of the original owner
            call GroupAddUnit(data.allPlayers[GetPlayerId(GetOwningPlayer(f))], f)
            
            //here we change its player
            call SetUnitOwner(f, RandomPlayer(data), true)
            
            call DestroyEffect(AddSpecialEffect(EFFECT, GetUnitX(f), GetUnitY(f)))
        endloop
        
        //start the timer
        call SetTimerData(data.dur, integer(data))
        call TimerStart(data.dur, Duration(data.level), true, function EndEffect)
        
        call RemoveLocation(spellLoc)
        set spellLoc = null
    endfunction
//===========================================================================
    private function Init takes nothing returns nothing
        local integer i 
        local trigger ConfusionTrg = CreateTrigger(  )
        call TriggerRegisterAnyUnitEventBJ(ConfusionTrg, EVENT_PLAYER_UNIT_SPELL_EFFECT )
        call TriggerAddCondition(ConfusionTrg, Condition( function Conditions)) 
        call TriggerAddAction(ConfusionTrg, function Actions )
        
        set ConfusionTrg = null
        
        //setting globals
        set g = CreateGroup()
        set b = Condition(function Targets)
        
        //We create our 2D array, so we can set if after
        set i = 0
        loop
            exitwhen(i == MAX_LEVELS)
            set playerLevelChances[i] = playerChances.create()
            set i = i + 1
        endloop
        
        //We set our 2D array xD
        call PlayersCallibration()
        
        //to prevent lag  the first time we use spell
        call Preload(EFFECT)
    endfunction
endscope

//here we walk trhough the group array
        set i = 0
        loop
            exitwhen(i == ARRAY_SIZE)
            
            //here we walk through every single unit inside the group
            loop
                set f = FirstOfGroup(data.allPlayers[i])
                exitwhen(f == null)
                call GroupRemoveUnit(data.allPlayers[i], f)
                call SetUnitOwner(f, Player(i), true)
            endloop
            
            set i = i + 1
        endloop

globals
    private MyStruct array instances
    private integer instanceCount=0
endglobals

private struct MyStruct
    static method create takes unit caster returns MyStruct
        ...
        set instances[instanceCount]=data
        set instanceCount=instanceCount+1
        ...
    endmethod
    method onDestroy takes nothing returns nothing
        ...
        local integer i=0
        local boolean b=false
        set instanceCount=instanceCount-1
        loop
            exitwhen i>=instanceCount
            if instances[i]==this then
                set b = true
            endif
            if b then
                set instances[i]=instances[i+1]
            endif
            set i=i+1
        endloop
        ...
    endmethod
endstruct

        static method create takes player caster returns MyStruct
            ...
            if data.allPlayers[i]==null then //only create new groups if this index hasn't been used before
                loop
                    exitwhen (i == ARRAY_SIZE)
                    set data.allPlayers[i] = CreateGroup()
                    set i = i + 1
                endloop
            endif
            ...
        endmethod
        method onDestroy takes nothing returns nothing
            ...
            loop
                exitwhen (i == ARRAY_SIZE)
                call GroupClear(.allPlayers[i]) //save the groups for the next time this index is used
                set i = i + 1
            endloop
            ...
        endmethod

globals
        private SortedList array instances
        private integer instanceCount = 0
    endglobals
    
    private struct SortedList
        static method create takes nothing returns SortedList
            local SortedList anInstance = SortedList.allocate()
            
            set instances[instanceCount] = anInstance
            set instanceCount = instanceCount + 1
            
            return anInstance
        endmethod
    endstruct

scope confusion initializer init

globals 
    private constant integer AID = 'A003'   //the rawcode of the ability
    private constant string EFFECT = "Objects\\Spawnmodels\\Undead\\UndeadDissipate\\UndeadDissipate.mdl"
endglobals

private constant function Duration takes integer level returns real
    return 20. + (level * 10)   //the duration of the spell on the units
endfunction

private constant function Radius takes integer level returns real
    return 125. + (level * 75)  //the radius the spell will have
endfunction

private function h2i takes handle h returns integer
    return h
    return 0
endfunction

private struct olddata // a struct to store the old data, uses gamecache to do O(1) searchs 
    static gamecache GC = InitGameCache("Confusion.w3v")
    player p
    unit u
    
    static method Add takes unit c returns nothing
        local olddata OD = olddata.allocate()
        set OD.p = GetOwningPlayer(c)
        set OD.u = c
        call StoreInteger(olddata.GC, "olddataindexes", I2S(h2i(c)), integer(OD)) 
    endmethod
    
    static method GetOldData takes unit u returns olddata
        return olddata( GetStoredInteger(olddata.GC, "olddataindexes", I2S(h2i(u))) )
    endmethod
    
    method onDestroy takes nothing returns nothing
        call FlushStoredInteger(olddata.GC, "olddataindexes", I2S(h2i(.u)))
    endmethod
endstruct

private struct data
    static group G = CreateGroup() // this group will store ALL the units which are affected by the spell
                                   // This group will ensure that units can't be affected twice by different spell casts
    group g // this one will store the ones that are affected per spell cast
    
    private static method Assign takes nothing returns nothing
        
    endstruct
    
    static method create takes unit c, location l returns data
        local data D = data.allocate()
        if D.g == null then
            set D.g = CreateGroup()
        endif
        call GroupEnumUnitsInRangeOfLoc(D.g, l, Radius(GetUnitAbilityLevel(c, AID)), Condition(function data.filter))
        call ForGroup(D.g, function data.Assign)
    endmethod
    
endstruct

private function Actions takes nothing returns nothing
    
endfunction

private function init takes nothing returns nothing
    local trigger ConfusionTrg = CreateTrigger(  )
    call TriggerRegisterAnyUnitEventBJ(ConfusionTrg, EVENT_PLAYER_UNIT_SPELL_EFFECT )
    call TriggerAddCondition(ConfusionTrg, Condition( function Conditions)) 
    call TriggerAddAction(ConfusionTrg, function Actions )
    set ConfusionTrg = null
endfunction

endscope

private struct data
    static group G = CreateGroup() // this group will store ALL the units which are affected by the spell
                                   // This group will ensure that units can't be affected twice by different spell casts
    group g // this one will store the ones that are affected per spell cast
    
    private static method Assign takes nothing returns nothing
        
    endstruct
    
    static method create takes unit c, location l returns data
        local data D = data.allocate()
        if D.g == null then
            set D.g = CreateGroup()
        endif
        call GroupEnumUnitsInRangeOfLoc(D.g, l, Radius(GetUnitAbilityLevel(c, AID)), Condition(function data.filter))
        call ForGroup(D.g, function data.Assign)
    endmethod
    
endstruct

private static method Assign takes nothing returns nothing
        
    endstruct

 static method create takes unit c, location l returns data
        local data D = data.allocate()
        if D.g == null then
            set D.g = CreateGroup()
        endif
        call GroupEnumUnitsInRangeOfLoc(D.g, l, Radius(GetUnitAbilityLevel(c, AID)), Condition(function data.filter))
        call ForGroup(D.g, function data.Assign)
    endmethod

private struct Spell // this struct will manage the spell process
   group g // this group component will store all the units affected by the spell
endstruct

private struct Spell // this struct will manage the spell process
   group g // this group component will store all the units affected by the spell

   static method Add takes location l returns Spell
      local Spell S = Spell.allocate()
      if S.g == null then
         set S.g = CreateGroup()
      endif
      call GroupEnumUnitsInRangeOfLoc( // to be continued...
   endmethod
endstruct